git.roojs.org Git - Pman.Builder/blob - Pman.Tab.BuilderTree.js

   1 //<script type="text/javascript">
   2
   3 // Auto generated file - created by app.Builder.js- do not edit directly (at present!)
   4
   5 Pman.Tab.BuilderTree = new Roo.XComponent({
   6     part     :  ["Builder","Tree"],
   7     order    : '001-Pman.Tab.BuilderTree',
   8     region   : 'center',
   9     parent   : 'Pman.Tab.BuilderTab',
  10     name     : "Pman.Tab.BuilderTree",
  11     disabled : false,
  12     permname : '',
  13     _tree : function()
  14     {
  15         var _this = this;
  16         var MODULE = this;
  17         return {
  18             xtype: 'NestedLayoutPanel',
  19             xns: Roo,
  20             region : 'west',
  21             layout : {
  22                 xtype: 'BorderLayout',
  23                 xns: Roo,
  24                 items : [
  25                     {
  26                         xtype: 'TreePanel',
  27                         xns: Roo,
  28                         listeners : {
  29                             activate : function (_self)
  30                             {
  31
  32                                 _this.tree = _self.tree;
  33                                 _this.menu = _self.menu;
  34
  35                                 if (_this.hasMouseEvent) {
  36                                     return;
  37                                 }
  38
  39                                 _this.hasMouseEvent = true;
  40                               //   this.el.on('mouseover', function() { _this.isMouseOver= true; });
  41                                  // this.el.on('mouseout', function() { _this.isMouseOver = false; });
  42
  43                             }
  44                         },
  45                         region : 'center',
  46                         tree : {
  47                             xtype: 'TreePanel',
  48                             xns: Roo.tree,
  49                             listeners : {
  50                                 beforenodedrop : function (e)
  51                                 {
  52
  53                                     return Pman.Builder.Tree.handleDropNode(e);
  54
  55                                 },
  56                                 click : function (node, e)
  57                                 {
  58                                       e.preventDefault();
  59                                                        // console.log(e.button);
  60                                         Pman.Builder.Tree.setCurrentNode(node);
  61
  62
  63
  64
  65                                 },
  66                                 contextmenu : function (node, e)
  67                                 {
  68                                     e.stopEvent();
  69
  70                                     this.getSelectionModel().select(node);
  71                                      Pman.Builder.Tree.setCurrentNode(node);
  72
  73                                           _this.menu = Roo.factory(_this.menu);
  74
  75                                         _this.menu.show(node.ui.textNode, 'tr');
  76                                      return;
  77
  78                                      /*
  79                                     var xt = node.elConfig.xtype;
  80                                     var altx= false;
  81                                     if (typeof(node.elConfig['*prop']) != 'undefined') {
  82                                         altx = node.parentNode.elConfig.xtype +'.' + node.elConfig['*prop'];
  83                                     }
  84                                     var mn = Pman.Tab.BuilderPalete.getMenu(xt,altx);
  85
  86
  87                                     if (mn) {
  88                                         mn.show(e.getTarget());
  89                                     }
  90
  91                                  */
  92
  93                                 },
  94                                 nodedragover : function (e)
  95                                 {
  96
  97                                         return Pman.Builder.Tree.handleDragOver(e);
  98
  99
 100
 101                                 }
 102                             },
 103                             animate : false,
 104                             containerScroll : true,
 105                             ddGroup : 'component',
 106                             enableDD : true,
 107                             rootVisible : true,
 108                             renderer : function(n) { return n.text; },
 109                             sm : {
 110                                 xtype: 'DefaultSelectionModel',
 111                                 xns: Roo.tree
 112                             },
 113                             root : {
 114                                 xtype: 'TreeNode',
 115                                 xns: Roo.tree,
 116                                 text : "Part",
 117                                 elConfig : function() {
 118                                     return  {
 119                                          xtype : '*top',
 120
 121                                             app : 'TestApp',
 122                                             // perm
 123                                             // permtype
 124                                             modkey : 0,
 125                                             '|module' :  '',
 126                                             region : 'center',
 127                                             '|parent' : 'Pman',
 128                                             name : "Module Name",
 129                                             items: []
 130
 131
 132                                     }
 133                                 }
 134                             }
 135                         },
 136                         menu : {
 137                             xtype: 'Menu',
 138                             xns: Roo.menu,
 139                             items : [
 140                                 {
 141                                     xtype: 'Item',
 142                                     xns: Roo.menu,
 143                                     listeners : {
 144                                         click : function (_self)
 145                                         {
 146
 147                                             var str = Pman.Builder.Tree.currentNodeType();
 148                                             if (typeof(Pman.Builder.Wizard[str]) == 'undefined') {
 149                                                 Roo.MessageBox.alert("Sorry", "No wizard exists for " + str);
 150                                                 return;
 151                                             }
 152                                             var cn = Pman.Builder.Tree.currentNode;
 153                                             if (typeof(cn.elConfig['.builderCfg']) == 'undefined') {
 154                                                 Roo.MessageBox.alert("Sorry", "No configuration exists for " + str);
 155                                                 return;
 156                                             }
 157
 158
 159                                             var cfg = Roo.decode(cn.elConfig['.builderCfg']);
 160
 161                                             Roo.log(cfg);
 162                                             Pman.Dialog.BuilderAddTable.show(
 163                                                 cfg,
 164                                                 function(data) {
 165
 166
 167                                                     var res = Pman.Builder.Wizard[str](data); // with old..
 168                                                      Pman.Builder.Tree.replaceCurrentNode( res );
 169                                                      Pman.Tab.BuilderView.panel.redraw();
 170
 171                                                }
 172                                             );
 173
 174
 175                                             // otherwise, call back with template??
 176
 177
 178
 179
 180                                         }
 181                                     },
 182                                     text : "Edit Using Wizard"
 183                                 },
 184                                 {
 185                                     xtype: 'Separator',
 186                                     xns: Roo.menu
 187                                 },
 188                                 {
 189                                     xtype: 'Item',
 190                                     xns: Roo.menu,
 191                                     listeners : {
 192                                         click : function (_self)
 193                                         {
 194
 195
 196                                             Pman.Builder.Tree.collapseToggle();
 197
 198                                         }
 199                                     },
 200                                     text : "Toggle Collapse"
 201                                 },
 202                                 {
 203                                     xtype: 'Item',
 204                                     xns: Roo.menu,
 205                                     listeners : {
 206                                         click : function (_self)
 207                                         {
 208
 209
 210                                             Pman.Builder.Tree.createSharedPart();
 211
 212                                         }
 213                                     },
 214                                     text : "Create shared part from this node"
 215                                 },
 216                                 {
 217                                     xtype: 'Separator',
 218                                     xns: Roo.menu
 219                                 },
 220                                 {
 221                                     xtype: 'Item',
 222                                     xns: Roo.menu,
 223                                     listeners : {
 224                                         click : function (_self)
 225                                         {
 226                                             Roo.MessageBox.confirm("Confirm", "Are you sure you want to delete that node?",
 227                                                 function(r) {
 228                                                     if (r!='yes') {
 229                                                         return;
 230                                                     }
 231                                                    Pman.Builder.Tree.deleteCurrent();
 232                                                 }
 233                                             );
 234
 235                                         }
 236                                     },
 237                                     text : "Delete Node"
 238                                 },
 239                                 {
 240                                     xtype: 'Item',
 241                                     xns: Roo.menu,
 242                                     text : "Save as template"
 243                                 }
 244                             ]
 245                         }
 246                     }
 247                 ],
 248                 center : {
 249                     xtype: 'LayoutRegion',
 250                     xns: Roo
 251                 },
 252                 south : {
 253                     xtype: 'LayoutRegion',
 254                     xns: Roo,
 255                     height : 300,
 256                     split : true
 257                 }
 258             }
 259         };
 260     }
 261 });