docs/source/Toolbar.html

   1 <html>
   2 <head>
   3   <title>The source code</title>
   4     <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
   5     <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
   6 </head>
   7 <body  onload="prettyPrint();">
   8     <pre class="prettyprint lang-js">/*!
   9  * Ext JS Library 3.0.3
  10  * Copyright(c) 2006-2009 Ext JS, LLC
  11  * licensing@extjs.com
  12  * http://www.extjs.com/license
  13  */
  14 <div id="cls-Ext.layout.ToolbarLayout"></div>/**\r
  15  * @class Ext.layout.ToolbarLayout\r
  16  * @extends Ext.layout.ContainerLayout\r
  17  * Layout manager implicitly used by Ext.Toolbar.\r
  18  */\r
  19 Ext.layout.ToolbarLayout = Ext.extend(Ext.layout.ContainerLayout, {\r
  20     monitorResize : true,\r
  21     triggerWidth : 18,\r
  22     lastOverflow : false,\r
  23 \r
  24     noItemsMenuText : '<div class="x-toolbar-no-items">(None)</div>',\r
  25     // private\r
  26     onLayout : function(ct, target){\r
  27         if(!this.leftTr){\r
  28             target.addClass('x-toolbar-layout-ct');\r
  29             target.insertHtml('beforeEnd',\r
  30                  '<table cellspacing="0" class="x-toolbar-ct"><tbody><tr><td class="x-toolbar-left" align="left"><table cellspacing="0"><tbody><tr class="x-toolbar-left-row"></tr></tbody></table></td><td class="x-toolbar-right" align="right"><table cellspacing="0" class="x-toolbar-right-ct"><tbody><tr><td><table cellspacing="0"><tbody><tr class="x-toolbar-right-row"></tr></tbody></table></td><td><table cellspacing="0"><tbody><tr class="x-toolbar-extras-row"></tr></tbody></table></td></tr></tbody></table></td></tr></tbody></table>');\r
  31             this.leftTr = target.child('tr.x-toolbar-left-row', true);\r
  32             this.rightTr = target.child('tr.x-toolbar-right-row', true);\r
  33             this.extrasTr = target.child('tr.x-toolbar-extras-row', true);\r
  34         }\r
  35         var side = this.leftTr;\r
  36         var pos = 0;\r
  37 \r
  38         var items = ct.items.items;\r
  39         for(var i = 0, len = items.length, c; i < len; i++, pos++) {\r
  40             c = items[i];\r
  41             if(c.isFill){\r
  42                 side = this.rightTr;\r
  43                 pos = -1;\r
  44             }else if(!c.rendered){\r
  45                 c.render(this.insertCell(c, side, pos));\r
  46             }else{\r
  47                 if(!c.xtbHidden && !this.isValidParent(c, side.childNodes[pos])){\r
  48                     var td = this.insertCell(c, side, pos);\r
  49                     td.appendChild(c.getDomPositionEl().dom);\r
  50                     c.container = Ext.get(td);\r
  51                 }\r
  52             }\r
  53         }\r
  54         //strip extra empty cells\r
  55         this.cleanup(this.leftTr);\r
  56         this.cleanup(this.rightTr);\r
  57         this.cleanup(this.extrasTr);\r
  58         this.fitToSize(target);\r
  59     },\r
  60 \r
  61     cleanup : function(row){\r
  62         var cn = row.childNodes;\r
  63         for(var i = cn.length-1, c; i >= 0 && (c = cn[i]); i--){\r
  64             if(!c.firstChild){\r
  65                 row.removeChild(c);\r
  66             }\r
  67         }\r
  68     },\r
  69 \r
  70     insertCell : function(c, side, pos){\r
  71         var td = document.createElement('td');\r
  72         td.className='x-toolbar-cell';\r
  73         side.insertBefore(td, side.childNodes[pos]||null);\r
  74         return td;\r
  75     },\r
  76 \r
  77     hideItem : function(item){\r
  78         var h = (this.hiddens = this.hiddens || []);\r
  79         h.push(item);\r
  80         item.xtbHidden = true;\r
  81         item.xtbWidth = item.getDomPositionEl().dom.parentNode.offsetWidth;\r
  82         item.hide();\r
  83     },\r
  84 \r
  85     unhideItem : function(item){\r
  86         item.show();\r
  87         item.xtbHidden = false;\r
  88         this.hiddens.remove(item);\r
  89         if(this.hiddens.length < 1){\r
  90             delete this.hiddens;\r
  91         }\r
  92     },\r
  93 \r
  94     getItemWidth : function(c){\r
  95         return c.hidden ? (c.xtbWidth || 0) : c.getDomPositionEl().dom.parentNode.offsetWidth;\r
  96     },\r
  97 \r
  98     fitToSize : function(t){\r
  99         if(this.container.enableOverflow === false){\r
 100             return;\r
 101         }\r
 102         var w = t.dom.clientWidth;\r
 103         var lw = this.lastWidth || 0;\r
 104         this.lastWidth = w;\r
 105         var iw = t.dom.firstChild.offsetWidth;\r
 106 \r
 107         var clipWidth = w - this.triggerWidth;\r
 108         var hideIndex = -1;\r
 109 \r
 110         if(iw > w || (this.hiddens && w >= lw)){\r
 111             var i, items = this.container.items.items, len = items.length, c;\r
 112             var loopWidth = 0;\r
 113             for(i = 0; i < len; i++) {\r
 114                 c = items[i];\r
 115                 if(!c.isFill){\r
 116                     loopWidth += this.getItemWidth(c);\r
 117                     if(loopWidth > clipWidth){\r
 118                         if(!c.xtbHidden){\r
 119                             this.hideItem(c);\r
 120                         }\r
 121                     }else{\r
 122                         if(c.xtbHidden){\r
 123                             this.unhideItem(c);\r
 124                         }\r
 125                     }\r
 126                 }\r
 127             }\r
 128         }\r
 129         if(this.hiddens){\r
 130             this.initMore();\r
 131             if(!this.lastOverflow){\r
 132                 this.container.fireEvent('overflowchange', this.container, true);\r
 133                 this.lastOverflow = true;\r
 134             }\r
 135         }else if(this.more){\r
 136             this.clearMenu();\r
 137             this.more.destroy();\r
 138             delete this.more;\r
 139             if(this.lastOverflow){\r
 140                 this.container.fireEvent('overflowchange', this.container, false);\r
 141                 this.lastOverflow = false;\r
 142             }\r
 143         }\r
 144     },\r
 145 \r
 146     createMenuConfig : function(c, hideOnClick){\r
 147         var cfg = Ext.apply({}, c.initialConfig),\r
 148             group = c.toggleGroup;\r
 149 \r
 150         Ext.apply(cfg, {\r
 151             text: c.overflowText || c.text,\r
 152             iconCls: c.iconCls,\r
 153             icon: c.icon,\r
 154             itemId: c.itemId,\r
 155             disabled: c.disabled,\r
 156             handler: c.handler,\r
 157             scope: c.scope,\r
 158             menu: c.menu,\r
 159             hideOnClick: hideOnClick\r
 160         });\r
 161         if(group || c.enableToggle){\r
 162             Ext.apply(cfg, {\r
 163                 group: group,\r
 164                 checked: c.pressed,\r
 165                 listeners: {\r
 166                     checkchange: function(item, checked){\r
 167                         c.toggle(checked);\r
 168                     }\r
 169                 }\r
 170             });\r
 171         }\r
 172         delete cfg.xtype;\r
 173         delete cfg.id;\r
 174         return cfg;\r
 175     },\r
 176 \r
 177     // private\r
 178     addComponentToMenu : function(m, c){\r
 179         if(c instanceof Ext.Toolbar.Separator){\r
 180             m.add('-');\r
 181         }else if(Ext.isFunction(c.isXType)){\r
 182             if(c.isXType('splitbutton')){\r
 183                 m.add(this.createMenuConfig(c, true));\r
 184             }else if(c.isXType('button')){\r
 185                 m.add(this.createMenuConfig(c, !c.menu));\r
 186             }else if(c.isXType('buttongroup')){\r
 187                 c.items.each(function(item){\r
 188                      this.addComponentToMenu(m, item);\r
 189                 }, this);\r
 190             }\r
 191         }\r
 192     },\r
 193 \r
 194     clearMenu : function(){\r
 195         var m = this.moreMenu;\r
 196         if(m && m.items){\r
 197             m.items.each(function(item){\r
 198                 delete item.menu;\r
 199             });\r
 200         }\r
 201     },\r
 202 \r
 203     // private\r
 204     beforeMoreShow : function(m){\r
 205         var h = this.container.items.items,\r
 206             len = h.length,\r
 207             c,\r
 208             prev,\r
 209             needsSep = function(group, item){\r
 210                 return group.isXType('buttongroup') && !(item instanceof Ext.Toolbar.Separator);\r
 211             };\r
 212 \r
 213         this.clearMenu();\r
 214         m.removeAll();\r
 215         for(var i = 0; i < len; i++){\r
 216             c = h[i];\r
 217             if(c.xtbHidden){\r
 218                 if(prev && (needsSep(c, prev) || needsSep(prev, c))){\r
 219                     m.add('-');\r
 220                 }\r
 221                 this.addComponentToMenu(m, c);\r
 222                 prev = c;\r
 223             }\r
 224         }\r
 225         // put something so the menu isn't empty\r
 226         // if no compatible items found\r
 227         if(m.items.length < 1){\r
 228             m.add(this.noItemsMenuText);\r
 229         }\r
 230     },\r
 231 \r
 232     initMore : function(){\r
 233         if(!this.more){\r
 234             this.moreMenu = new Ext.menu.Menu({\r
 235                 listeners: {\r
 236                     beforeshow: this.beforeMoreShow,\r
 237                     scope: this\r
 238                 }\r
 239             });\r
 240             this.moreMenu.ownerCt = this.container;\r
 241             this.more = new Ext.Button({\r
 242                 iconCls: 'x-toolbar-more-icon',\r
 243                 cls: 'x-toolbar-more',\r
 244                 menu: this.moreMenu\r
 245             });\r
 246             var td = this.insertCell(this.more, this.extrasTr, 100);\r
 247             this.more.render(td);\r
 248         }\r
 249     },\r
 250 \r
 251     destroy : function(){\r
 252         Ext.destroy(this.more, this.moreMenu);\r
 253         Ext.layout.ToolbarLayout.superclass.destroy.call(this);\r
 254     }\r
 255     <div id="prop-Ext.layout.ToolbarLayout-activeItem"></div>/**\r
 256      * @property activeItem\r
 257      * @hide\r
 258      */\r
 259 });\r
 260 \r
 261 Ext.Container.LAYOUTS.toolbar = Ext.layout.ToolbarLayout;\r
 262 \r
 263 <div id="cls-Ext.Toolbar"></div>/**\r
 264  * @class Ext.Toolbar\r
 265  * @extends Ext.Container\r
 266  * <p>Basic Toolbar class. Although the <tt>{@link Ext.Container#defaultType defaultType}</tt> for Toolbar\r
 267  * is <tt>{@link Ext.Button button}</tt>, Toolbar elements (child items for the Toolbar container) may\r
 268  * be virtually any type of Component. Toolbar elements can be created explicitly via their constructors,\r
 269  * or implicitly via their xtypes, and can be <tt>{@link #add}</tt>ed dynamically.</p>\r
 270  * <p>Some items have shortcut strings for creation:</p>\r
 271  * <pre>\r
 272 <u>Shortcut</u>  <u>xtype</u>          <u>Class</u>                  <u>Description</u>\r
 273 '->'      'tbfill'       {@link Ext.Toolbar.Fill}       begin using the right-justified button container\r
 274 '-'       'tbseparator'  {@link Ext.Toolbar.Separator}  add a vertical separator bar between toolbar items\r
 275 ' '       'tbspacer'     {@link Ext.Toolbar.Spacer}     add horiztonal space between elements\r
 276  * </pre>\r
 277  *\r
 278  * Example usage of various elements:\r
 279  * <pre><code>\r
 280 var tb = new Ext.Toolbar({\r
 281     renderTo: document.body,\r
 282     width: 600,\r
 283     height: 100,\r
 284     items: [\r
 285         {\r
 286             // xtype: 'button', // default for Toolbars, same as 'tbbutton'\r
 287             text: 'Button'\r
 288         },\r
 289         {\r
 290             xtype: 'splitbutton', // same as 'tbsplitbutton'\r
 291             text: 'Split Button'\r
 292         },\r
 293         // begin using the right-justified button container\r
 294         '->', // same as {xtype: 'tbfill'}, // Ext.Toolbar.Fill\r
 295         {\r
 296             xtype: 'textfield',\r
 297             name: 'field1',\r
 298             emptyText: 'enter search term'\r
 299         },\r
 300         // add a vertical separator bar between toolbar items\r
 301         '-', // same as {xtype: 'tbseparator'} to create Ext.Toolbar.Separator\r
 302         'text 1', // same as {xtype: 'tbtext', text: 'text1'} to create Ext.Toolbar.TextItem\r
 303         {xtype: 'tbspacer'},// same as ' ' to create Ext.Toolbar.Spacer\r
 304         'text 2',\r
 305         {xtype: 'tbspacer', width: 50}, // add a 50px space\r
 306         'text 3'\r
 307     ]\r
 308 });\r
 309  * </code></pre>\r
 310  * Example adding a ComboBox within a menu of a button:\r
 311  * <pre><code>\r
 312 // ComboBox creation\r
 313 var combo = new Ext.form.ComboBox({\r
 314     store: new Ext.data.ArrayStore({\r
 315         autoDestroy: true,\r
 316         fields: ['initials', 'fullname'],\r
 317         data : [\r
 318             ['FF', 'Fred Flintstone'],\r
 319             ['BR', 'Barney Rubble']\r
 320         ]\r
 321     }),\r
 322     displayField: 'fullname',\r
 323     typeAhead: true,\r
 324     mode: 'local',\r
 325     forceSelection: true,\r
 326     triggerAction: 'all',\r
 327     emptyText: 'Select a name...',\r
 328     selectOnFocus: true,\r
 329     width: 135,\r
 330     getListParent: function() {\r
 331         return this.el.up('.x-menu');\r
 332     },\r
 333     iconCls: 'no-icon' //use iconCls if placing within menu to shift to right side of menu\r
 334 });\r
 335 \r
 336 // put ComboBox in a Menu\r
 337 var menu = new Ext.menu.Menu({\r
 338     id: 'mainMenu',\r
 339     items: [\r
 340         combo // A Field in a Menu\r
 341     ]\r
 342 });\r
 343 \r
 344 // add a Button with the menu\r
 345 tb.add({\r
 346         text:'Button w/ Menu',\r
 347         menu: menu  // assign menu by instance\r
 348     });\r
 349 tb.doLayout();\r
 350  * </code></pre>\r
 351  * @constructor\r
 352  * Creates a new Toolbar\r
 353  * @param {Object/Array} config A config object or an array of buttons to <tt>{@link #add}</tt>\r
 354  * @xtype toolbar\r
 355  */\r
 356 Ext.Toolbar = function(config){\r
 357     if(Ext.isArray(config)){\r
 358         config = {items: config, layout: 'toolbar'};\r
 359     } else {\r
 360         config = Ext.apply({\r
 361             layout: 'toolbar'\r
 362         }, config);\r
 363         if(config.buttons) {\r
 364             config.items = config.buttons;\r
 365         }\r
 366     }\r
 367     Ext.Toolbar.superclass.constructor.call(this, config);\r
 368 };\r
 369 \r
 370 (function(){\r
 371 \r
 372 var T = Ext.Toolbar;\r
 373 \r
 374 Ext.extend(T, Ext.Container, {\r
 375 \r
 376     defaultType: 'button',\r
 377 \r
 378     <div id="cfg-Ext.Toolbar-layout"></div>/**\r
 379      * @cfg {String/Object} layout\r
 380      * This class assigns a default layout (<code>layout:'<b>toolbar</b>'</code>).\r
 381      * Developers <i>may</i> override this configuration option if another layout\r
 382      * is required (the constructor must be passed a configuration object in this\r
 383      * case instead of an array).\r
 384      * See {@link Ext.Container#layout} for additional information.\r
 385      */\r
 386 \r
 387     trackMenus : true,\r
 388     internalDefaults: {removeMode: 'container', hideParent: true},\r
 389     toolbarCls: 'x-toolbar',\r
 390 \r
 391     initComponent : function(){\r
 392         T.superclass.initComponent.call(this);\r
 393 \r
 394         <div id="event-Ext.Toolbar-overflowchange"></div>/**\r
 395          * @event overflowchange\r
 396          * Fires after the overflow state has changed.\r
 397          * @param {Object} c The Container\r
 398          * @param {Boolean} lastOverflow overflow state\r
 399          */\r
 400         this.addEvents('overflowchange');\r
 401     },\r
 402 \r
 403     // private\r
 404     onRender : function(ct, position){\r
 405         if(!this.el){\r
 406             if(!this.autoCreate){\r
 407                 this.autoCreate = {\r
 408                     cls: this.toolbarCls + ' x-small-editor'\r
 409                 };\r
 410             }\r
 411             this.el = ct.createChild(Ext.apply({ id: this.id },this.autoCreate), position);\r
 412             Ext.Toolbar.superclass.onRender.apply(this, arguments);\r
 413         }\r
 414     },\r
 415 \r
 416     <div id="method-Ext.Toolbar-add"></div>/**\r
 417      * <p>Adds element(s) to the toolbar -- this function takes a variable number of\r
 418      * arguments of mixed type and adds them to the toolbar.</p>\r
 419      * <br><p><b>Note</b>: See the notes within {@link Ext.Container#add}.</p>\r
 420      * @param {Mixed} arg1 The following types of arguments are all valid:<br />\r
 421      * <ul>\r
 422      * <li>{@link Ext.Button} config: A valid button config object (equivalent to {@link #addButton})</li>\r
 423      * <li>HtmlElement: Any standard HTML element (equivalent to {@link #addElement})</li>\r
 424      * <li>Field: Any form field (equivalent to {@link #addField})</li>\r
 425      * <li>Item: Any subclass of {@link Ext.Toolbar.Item} (equivalent to {@link #addItem})</li>\r
 426      * <li>String: Any generic string (gets wrapped in a {@link Ext.Toolbar.TextItem}, equivalent to {@link #addText}).\r
 427      * Note that there are a few special strings that are treated differently as explained next.</li>\r
 428      * <li>'-': Creates a separator element (equivalent to {@link #addSeparator})</li>\r
 429      * <li>' ': Creates a spacer element (equivalent to {@link #addSpacer})</li>\r
 430      * <li>'->': Creates a fill element (equivalent to {@link #addFill})</li>\r
 431      * </ul>\r
 432      * @param {Mixed} arg2\r
 433      * @param {Mixed} etc.\r
 434      * @method add\r
 435      */\r
 436 \r
 437     // private\r
 438     lookupComponent : function(c){\r
 439         if(Ext.isString(c)){\r
 440             if(c == '-'){\r
 441                 c = new T.Separator();\r
 442             }else if(c == ' '){\r
 443                 c = new T.Spacer();\r
 444             }else if(c == '->'){\r
 445                 c = new T.Fill();\r
 446             }else{\r
 447                 c = new T.TextItem(c);\r
 448             }\r
 449             this.applyDefaults(c);\r
 450         }else{\r
 451             if(c.isFormField || c.render){ // some kind of form field, some kind of Toolbar.Item\r
 452                 c = this.constructItem(c);\r
 453             }else if(c.tag){ // DomHelper spec\r
 454                 c = new T.Item({autoEl: c});\r
 455             }else if(c.tagName){ // element\r
 456                 c = new T.Item({el:c});\r
 457             }else if(Ext.isObject(c)){ // must be button config?\r
 458                 c = c.xtype ? this.constructItem(c) : this.constructButton(c);\r
 459             }\r
 460         }\r
 461         return c;\r
 462     },\r
 463 \r
 464     // private\r
 465     applyDefaults : function(c){\r
 466         if(!Ext.isString(c)){\r
 467             c = Ext.Toolbar.superclass.applyDefaults.call(this, c);\r
 468             var d = this.internalDefaults;\r
 469             if(c.events){\r
 470                 Ext.applyIf(c.initialConfig, d);\r
 471                 Ext.apply(c, d);\r
 472             }else{\r
 473                 Ext.applyIf(c, d);\r
 474             }\r
 475         }\r
 476         return c;\r
 477     },\r
 478 \r
 479     // private\r
 480     constructItem : function(item, type){\r
 481         return Ext.create(item, type || this.defaultType);\r
 482     },\r
 483 \r
 484     <div id="method-Ext.Toolbar-addSeparator"></div>/**\r
 485      * Adds a separator\r
 486      * <br><p><b>Note</b>: See the notes within {@link Ext.Container#add}.</p>\r
 487      * @return {Ext.Toolbar.Item} The separator {@link Ext.Toolbar.Item item}\r
 488      */\r
 489     addSeparator : function(){\r
 490         return this.add(new T.Separator());\r
 491     },\r
 492 \r
 493     <div id="method-Ext.Toolbar-addSpacer"></div>/**\r
 494      * Adds a spacer element\r
 495      * <br><p><b>Note</b>: See the notes within {@link Ext.Container#add}.</p>\r
 496      * @return {Ext.Toolbar.Spacer} The spacer item\r
 497      */\r
 498     addSpacer : function(){\r
 499         return this.add(new T.Spacer());\r
 500     },\r
 501 \r
 502     <div id="method-Ext.Toolbar-addFill"></div>/**\r
 503      * Forces subsequent additions into the float:right toolbar\r
 504      * <br><p><b>Note</b>: See the notes within {@link Ext.Container#add}.</p>\r
 505      */\r
 506     addFill : function(){\r
 507         this.add(new T.Fill());\r
 508     },\r
 509 \r
 510     <div id="method-Ext.Toolbar-addElement"></div>/**\r
 511      * Adds any standard HTML element to the toolbar\r
 512      * <br><p><b>Note</b>: See the notes within {@link Ext.Container#add}.</p>\r
 513      * @param {Mixed} el The element or id of the element to add\r
 514      * @return {Ext.Toolbar.Item} The element's item\r
 515      */\r
 516     addElement : function(el){\r
 517         return this.addItem(new T.Item({el:el}));\r
 518     },\r
 519 \r
 520     <div id="method-Ext.Toolbar-addItem"></div>/**\r
 521      * Adds any Toolbar.Item or subclass\r
 522      * <br><p><b>Note</b>: See the notes within {@link Ext.Container#add}.</p>\r
 523      * @param {Ext.Toolbar.Item} item\r
 524      * @return {Ext.Toolbar.Item} The item\r
 525      */\r
 526     addItem : function(item){\r
 527         return this.add.apply(this, arguments);\r
 528     },\r
 529 \r
 530     <div id="method-Ext.Toolbar-addButton"></div>/**\r
 531      * Adds a button (or buttons). See {@link Ext.Button} for more info on the config.\r
 532      * <br><p><b>Note</b>: See the notes within {@link Ext.Container#add}.</p>\r
 533      * @param {Object/Array} config A button config or array of configs\r
 534      * @return {Ext.Button/Array}\r
 535      */\r
 536     addButton : function(config){\r
 537         if(Ext.isArray(config)){\r
 538             var buttons = [];\r
 539             for(var i = 0, len = config.length; i < len; i++) {\r
 540                 buttons.push(this.addButton(config[i]));\r
 541             }\r
 542             return buttons;\r
 543         }\r
 544         return this.add(this.constructButton(config));\r
 545     },\r
 546 \r
 547     <div id="method-Ext.Toolbar-addText"></div>/**\r
 548      * Adds text to the toolbar\r
 549      * <br><p><b>Note</b>: See the notes within {@link Ext.Container#add}.</p>\r
 550      * @param {String} text The text to add\r
 551      * @return {Ext.Toolbar.Item} The element's item\r
 552      */\r
 553     addText : function(text){\r
 554         return this.addItem(new T.TextItem(text));\r
 555     },\r
 556 \r
 557     <div id="method-Ext.Toolbar-addDom"></div>/**\r
 558      * Adds a new element to the toolbar from the passed {@link Ext.DomHelper} config\r
 559      * <br><p><b>Note</b>: See the notes within {@link Ext.Container#add}.</p>\r
 560      * @param {Object} config\r
 561      * @return {Ext.Toolbar.Item} The element's item\r
 562      */\r
 563     addDom : function(config){\r
 564         return this.add(new T.Item({autoEl: config}));\r
 565     },\r
 566 \r
 567     <div id="method-Ext.Toolbar-addField"></div>/**\r
 568      * Adds a dynamically rendered Ext.form field (TextField, ComboBox, etc). Note: the field should not have\r
 569      * been rendered yet. For a field that has already been rendered, use {@link #addElement}.\r
 570      * <br><p><b>Note</b>: See the notes within {@link Ext.Container#add}.</p>\r
 571      * @param {Ext.form.Field} field\r
 572      * @return {Ext.Toolbar.Item}\r
 573      */\r
 574     addField : function(field){\r
 575         return this.add(field);\r
 576     },\r
 577 \r
 578     <div id="method-Ext.Toolbar-insertButton"></div>/**\r
 579      * Inserts any {@link Ext.Toolbar.Item}/{@link Ext.Button} at the specified index.\r
 580      * <br><p><b>Note</b>: See the notes within {@link Ext.Container#add}.</p>\r
 581      * @param {Number} index The index where the item is to be inserted\r
 582      * @param {Object/Ext.Toolbar.Item/Ext.Button/Array} item The button, or button config object to be\r
 583      * inserted, or an array of buttons/configs.\r
 584      * @return {Ext.Button/Item}\r
 585      */\r
 586     insertButton : function(index, item){\r
 587         if(Ext.isArray(item)){\r
 588             var buttons = [];\r
 589             for(var i = 0, len = item.length; i < len; i++) {\r
 590                buttons.push(this.insertButton(index + i, item[i]));\r
 591             }\r
 592             return buttons;\r
 593         }\r
 594         return Ext.Toolbar.superclass.insert.call(this, index, item);\r
 595     },\r
 596 \r
 597     // private\r
 598     initMenuTracking : function(item){\r
 599         if(this.trackMenus && item.menu){\r
 600             this.mon(item, {\r
 601                 'menutriggerover' : this.onButtonTriggerOver,\r
 602                 'menushow' : this.onButtonMenuShow,\r
 603                 'menuhide' : this.onButtonMenuHide,\r
 604                 scope: this\r
 605             });\r
 606         }\r
 607     },\r
 608 \r
 609     // private\r
 610     constructButton : function(item){\r
 611         var b = item.events ? item : this.constructItem(item, item.split ? 'splitbutton' : this.defaultType);\r
 612         this.initMenuTracking(b);\r
 613         return b;\r
 614     },\r
 615 \r
 616     // private\r
 617     onDisable : function(){\r
 618         this.items.each(function(item){\r
 619              if(item.disable){\r
 620                  item.disable();\r
 621              }\r
 622         });\r
 623     },\r
 624 \r
 625     // private\r
 626     onEnable : function(){\r
 627         this.items.each(function(item){\r
 628              if(item.enable){\r
 629                  item.enable();\r
 630              }\r
 631         });\r
 632     },\r
 633 \r
 634     // private\r
 635     onButtonTriggerOver : function(btn){\r
 636         if(this.activeMenuBtn && this.activeMenuBtn != btn){\r
 637             this.activeMenuBtn.hideMenu();\r
 638             btn.showMenu();\r
 639             this.activeMenuBtn = btn;\r
 640         }\r
 641     },\r
 642 \r
 643     // private\r
 644     onButtonMenuShow : function(btn){\r
 645         this.activeMenuBtn = btn;\r
 646     },\r
 647 \r
 648     // private\r
 649     onButtonMenuHide : function(btn){\r
 650         delete this.activeMenuBtn;\r
 651     }\r
 652 });\r
 653 Ext.reg('toolbar', Ext.Toolbar);\r
 654 \r
 655 <div id="cls-Ext.Toolbar.Item"></div>/**\r
 656  * @class Ext.Toolbar.Item\r
 657  * @extends Ext.BoxComponent\r
 658  * The base class that other non-interacting Toolbar Item classes should extend in order to\r
 659  * get some basic common toolbar item functionality.\r
 660  * @constructor\r
 661  * Creates a new Item\r
 662  * @param {HTMLElement} el\r
 663  * @xtype tbitem\r
 664  */\r
 665 T.Item = Ext.extend(Ext.BoxComponent, {\r
 666     hideParent: true, //  Hiding a Toolbar.Item hides its containing TD\r
 667     enable:Ext.emptyFn,\r
 668     disable:Ext.emptyFn,\r
 669     focus:Ext.emptyFn\r
 670     <div id="cfg-Ext.Toolbar.Item-overflowText"></div>/**\r
 671      * @cfg {String} overflowText Text to be used for the menu if the item is overflowed.\r
 672      */\r
 673 });\r
 674 Ext.reg('tbitem', T.Item);\r
 675 \r
 676 <div id="cls-Ext.Toolbar.Separator"></div>/**\r
 677  * @class Ext.Toolbar.Separator\r
 678  * @extends Ext.Toolbar.Item\r
 679  * A simple class that adds a vertical separator bar between toolbar items\r
 680  * (css class:<tt>'xtb-sep'</tt>). Example usage:\r
 681  * <pre><code>\r
 682 new Ext.Panel({\r
 683     tbar : [\r
 684         'Item 1',\r
 685         {xtype: 'tbseparator'}, // or '-'\r
 686         'Item 2'\r
 687     ]\r
 688 });\r
 689 </code></pre>\r
 690  * @constructor\r
 691  * Creates a new Separator\r
 692  * @xtype tbseparator\r
 693  */\r
 694 T.Separator = Ext.extend(T.Item, {\r
 695     onRender : function(ct, position){\r
 696         this.el = ct.createChild({tag:'span', cls:'xtb-sep'}, position);\r
 697     }\r
 698 });\r
 699 Ext.reg('tbseparator', T.Separator);\r
 700 \r
 701 <div id="cls-Ext.Toolbar.Spacer"></div>/**\r
 702  * @class Ext.Toolbar.Spacer\r
 703  * @extends Ext.Toolbar.Item\r
 704  * A simple element that adds extra horizontal space between items in a toolbar.\r
 705  * By default a 2px wide space is added via css specification:<pre><code>\r
 706 .x-toolbar .xtb-spacer {\r
 707     width:2px;\r
 708 }\r
 709  * </code></pre>\r
 710  * <p>Example usage:</p>\r
 711  * <pre><code>\r
 712 new Ext.Panel({\r
 713     tbar : [\r
 714         'Item 1',\r
 715         {xtype: 'tbspacer'}, // or ' '\r
 716         'Item 2',\r
 717         // space width is also configurable via javascript\r
 718         {xtype: 'tbspacer', width: 50}, // add a 50px space\r
 719         'Item 3'\r
 720     ]\r
 721 });\r
 722 </code></pre>\r
 723  * @constructor\r
 724  * Creates a new Spacer\r
 725  * @xtype tbspacer\r
 726  */\r
 727 T.Spacer = Ext.extend(T.Item, {\r
 728     <div id="cfg-Ext.Toolbar.Spacer-width"></div>/**\r
 729      * @cfg {Number} width\r
 730      * The width of the spacer in pixels (defaults to 2px via css style <tt>.x-toolbar .xtb-spacer</tt>).\r
 731      */\r
 732 \r
 733     onRender : function(ct, position){\r
 734         this.el = ct.createChild({tag:'div', cls:'xtb-spacer', style: this.width?'width:'+this.width+'px':''}, position);\r
 735     }\r
 736 });\r
 737 Ext.reg('tbspacer', T.Spacer);\r
 738 \r
 739 <div id="cls-Ext.Toolbar.Fill"></div>/**\r
 740  * @class Ext.Toolbar.Fill\r
 741  * @extends Ext.Toolbar.Spacer\r
 742  * A non-rendering placeholder item which instructs the Toolbar's Layout to begin using\r
 743  * the right-justified button container.\r
 744  * <pre><code>\r
 745 new Ext.Panel({\r
 746     tbar : [\r
 747         'Item 1',\r
 748         {xtype: 'tbfill'}, // or '->'\r
 749         'Item 2'\r
 750     ]\r
 751 });\r
 752 </code></pre>\r
 753  * @constructor\r
 754  * Creates a new Fill\r
 755  * @xtype tbfill\r
 756  */\r
 757 T.Fill = Ext.extend(T.Item, {\r
 758     // private\r
 759     render : Ext.emptyFn,\r
 760     isFill : true\r
 761 });\r
 762 Ext.reg('tbfill', T.Fill);\r
 763 \r
 764 <div id="cls-Ext.Toolbar.TextItem"></div>/**\r
 765  * @class Ext.Toolbar.TextItem\r
 766  * @extends Ext.Toolbar.Item\r
 767  * A simple class that renders text directly into a toolbar\r
 768  * (with css class:<tt>'xtb-text'</tt>). Example usage:\r
 769  * <pre><code>\r
 770 new Ext.Panel({\r
 771     tbar : [\r
 772         {xtype: 'tbtext', text: 'Item 1'} // or simply 'Item 1'\r
 773     ]\r
 774 });\r
 775 </code></pre>\r
 776  * @constructor\r
 777  * Creates a new TextItem\r
 778  * @param {String/Object} text A text string, or a config object containing a <tt>text</tt> property\r
 779  * @xtype tbtext\r
 780  */\r
 781 T.TextItem = Ext.extend(T.Item, {\r
 782     <div id="cfg-Ext.Toolbar.TextItem-text"></div>/**\r
 783      * @cfg {String} text The text to be used as innerHTML (html tags are accepted)\r
 784      */ \r
 785 \r
 786     constructor: function(config){\r
 787         T.TextItem.superclass.constructor.call(this, Ext.isString(config) ? {text: config} : config);\r
 788     },\r
 789     \r
 790     // private\r
 791     onRender : function(ct, position) {\r
 792         this.autoEl = {cls: 'xtb-text', html: this.text || ''};\r
 793         T.TextItem.superclass.onRender.call(this, ct, position);\r
 794     },\r
 795     \r
 796     <div id="method-Ext.Toolbar.TextItem-setText"></div>/**\r
 797      * Updates this item's text, setting the text to be used as innerHTML.\r
 798      * @param {String} t The text to display (html accepted).\r
 799      */\r
 800     setText : function(t) {\r
 801         if(this.rendered){\r
 802             this.el.update(t);\r
 803         }else{\r
 804             this.text = t;\r
 805         }\r
 806     }\r
 807 });\r
 808 Ext.reg('tbtext', T.TextItem);\r
 809 \r
 810 // backwards compat\r
 811 T.Button = Ext.extend(Ext.Button, {});\r
 812 T.SplitButton = Ext.extend(Ext.SplitButton, {});\r
 813 Ext.reg('tbbutton', T.Button);\r
 814 Ext.reg('tbsplit', T.SplitButton);\r
 815 \r
 816 })();\r
 817 </pre>
 818 </body>
 819 </html>