docs/source/Labelable.html

   1 <!DOCTYPE html>
   2 <html>
   3 <head>
   4   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
   5   <title>The source code</title>
   6   <link href="../prettify/prettify.css" type="text/css" rel="stylesheet" />
   7   <script type="text/javascript" src="../prettify/prettify.js"></script>
   8   <style type="text/css">
   9     .highlight { display: block; background-color: #ddd; }
  10   </style>
  11   <script type="text/javascript">
  12     function highlight() {
  13       document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
  14     }
  15   </script>
  16 </head>
  17 <body onload="prettyPrint(); highlight();">
  18   <pre class="prettyprint lang-js"><span id='Ext-form-Labelable'>/**
  19 </span> * @class Ext.form.Labelable
  20
  21 A mixin which allows a component to be configured and decorated with a label and/or error message as is
  22 common for form fields. This is used by e.g. {@link Ext.form.field.Base} and {@link Ext.form.FieldContainer}
  23 to let them be managed by the Field layout.
  24
  25 **NOTE**: This mixin is mainly for internal library use and most users should not need to use it directly. It
  26 is more likely you will want to use one of the component classes that import this mixin, such as
  27 {@link Ext.form.field.Base} or {@link Ext.form.FieldContainer}.
  28
  29 Use of this mixin does not make a component a field in the logical sense, meaning it does not provide any
  30 logic or state related to values or validation; that is handled by the related {@link Ext.form.field.Field}
  31 mixin. These two mixins may be used separately (for example {@link Ext.form.FieldContainer} is Labelable but not a
  32 Field), or in combination (for example {@link Ext.form.field.Base} implements both and has logic for connecting the
  33 two.)
  34
  35 Component classes which use this mixin should use the Field layout
  36 or a derivation thereof to properly size and position the label and message according to the component config.
  37 They must also call the {@link #initLabelable} method during component initialization to ensure the mixin gets
  38 set up correctly.
  39
  40  * @markdown
  41  * @docauthor Jason Johnston &lt;jason@sencha.com&gt;
  42  */
  43 Ext.define(&quot;Ext.form.Labelable&quot;, {
  44     requires: ['Ext.XTemplate'],
  45
  46 <span id='Ext-form-Labelable-cfg-labelableRenderTpl'>    /**
  47 </span>     * @cfg {Array/String/Ext.XTemplate} labelableRenderTpl
  48      * The rendering template for the field decorations. Component classes using this mixin should include
  49      * logic to use this as their {@link Ext.AbstractComponent#renderTpl renderTpl}, and implement the
  50      * {@link #getSubTplMarkup} method to generate the field body content.
  51      */
  52     labelableRenderTpl: [
  53         '&lt;tpl if=&quot;!hideLabel &amp;&amp; !(!fieldLabel &amp;&amp; hideEmptyLabel)&quot;&gt;',
  54             '&lt;label&lt;tpl if=&quot;inputId&quot;&gt; for=&quot;{inputId}&quot;&lt;/tpl&gt; class=&quot;{labelCls}&quot;&lt;tpl if=&quot;labelStyle&quot;&gt; style=&quot;{labelStyle}&quot;&lt;/tpl&gt;&gt;',
  55                 '&lt;tpl if=&quot;fieldLabel&quot;&gt;{fieldLabel}{labelSeparator}&lt;/tpl&gt;',
  56             '&lt;/label&gt;',
  57         '&lt;/tpl&gt;',
  58         '&lt;div class=&quot;{baseBodyCls} {fieldBodyCls}&quot;&lt;tpl if=&quot;inputId&quot;&gt; id=&quot;{baseBodyCls}-{inputId}&quot;&lt;/tpl&gt; role=&quot;presentation&quot;&gt;{subTplMarkup}&lt;/div&gt;',
  59         '&lt;div class=&quot;{errorMsgCls}&quot; style=&quot;display:none&quot;&gt;&lt;/div&gt;',
  60         '&lt;div class=&quot;{clearCls}&quot; role=&quot;presentation&quot;&gt;&lt;!-- --&gt;&lt;/div&gt;',
  61         {
  62             compiled: true,
  63             disableFormats: true
  64         }
  65     ],
  66
  67 <span id='Ext-form-Labelable-cfg-activeErrorsTpl'>    /**
  68 </span>     * @cfg {Ext.XTemplate} activeErrorsTpl
  69      * The template used to format the Array of error messages passed to {@link #setActiveErrors}
  70      * into a single HTML string. By default this renders each message as an item in an unordered list.
  71      */
  72     activeErrorsTpl: [
  73         '&lt;tpl if=&quot;errors &amp;&amp; errors.length&quot;&gt;',
  74             '&lt;ul&gt;&lt;tpl for=&quot;errors&quot;&gt;&lt;li&lt;tpl if=&quot;xindex == xcount&quot;&gt; class=&quot;last&quot;&lt;/tpl&gt;&gt;{.}&lt;/li&gt;&lt;/tpl&gt;&lt;/ul&gt;',
  75         '&lt;/tpl&gt;'
  76     ],
  77
  78 <span id='Ext-form-Labelable-property-isFieldLabelable'>    /**
  79 </span>     * @property isFieldLabelable
  80      * @type Boolean
  81      * Flag denoting that this object is labelable as a field. Always true.
  82      */
  83     isFieldLabelable: true,
  84
  85 <span id='Ext-form-Labelable-cfg-formItemCls'>    /**
  86 </span>     * @cfg {String} formItemCls
  87      * A CSS class to be applied to the outermost element to denote that it is participating in the form
  88      * field layout. Defaults to 'x-form-item'.
  89      */
  90     formItemCls: Ext.baseCSSPrefix + 'form-item',
  91
  92 <span id='Ext-form-Labelable-cfg-labelCls'>    /**
  93 </span>     * @cfg {String} labelCls
  94      * The CSS class to be applied to the label element. Defaults to 'x-form-item-label'.
  95      */
  96     labelCls: Ext.baseCSSPrefix + 'form-item-label',
  97
  98 <span id='Ext-form-Labelable-cfg-errorMsgCls'>    /**
  99 </span>     * @cfg {String} errorMsgCls
 100      * The CSS class to be applied to the error message element. Defaults to 'x-form-error-msg'.
 101      */
 102     errorMsgCls: Ext.baseCSSPrefix + 'form-error-msg',
 103
 104 <span id='Ext-form-Labelable-cfg-baseBodyCls'>    /**
 105 </span>     * @cfg {String} baseBodyCls
 106      * The CSS class to be applied to the body content element. Defaults to 'x-form-item-body'.
 107      */
 108     baseBodyCls: Ext.baseCSSPrefix + 'form-item-body',
 109
 110 <span id='Ext-form-Labelable-cfg-fieldBodyCls'>    /**
 111 </span>     * @cfg {String} fieldBodyCls
 112      * An extra CSS class to be applied to the body content element in addition to {@link #fieldBodyCls}.
 113      * Defaults to empty.
 114      */
 115     fieldBodyCls: '',
 116
 117 <span id='Ext-form-Labelable-cfg-clearCls'>    /**
 118 </span>     * @cfg {String} clearCls
 119      * The CSS class to be applied to the special clearing div rendered directly after the field
 120      * contents wrapper to provide field clearing (defaults to &lt;tt&gt;'x-clear'&lt;/tt&gt;).
 121      */
 122     clearCls: Ext.baseCSSPrefix + 'clear',
 123
 124 <span id='Ext-form-Labelable-cfg-invalidCls'>    /**
 125 </span>     * @cfg {String} invalidCls
 126      * The CSS class to use when marking the component invalid (defaults to 'x-form-invalid')
 127      */
 128     invalidCls : Ext.baseCSSPrefix + 'form-invalid',
 129
 130 <span id='Ext-form-Labelable-cfg-fieldLabel'>    /**
 131 </span>     * @cfg {String} fieldLabel
 132      * The label for the field. It gets appended with the {@link #labelSeparator}, and its position
 133      * and sizing is determined by the {@link #labelAlign}, {@link #labelWidth}, and {@link #labelPad}
 134      * configs. Defaults to undefined.
 135      */
 136     fieldLabel: undefined,
 137
 138 <span id='Ext-form-Labelable-cfg-labelAlign'>    /**
 139 </span>     * @cfg {String} labelAlign
 140      * &lt;p&gt;Controls the position and alignment of the {@link #fieldLabel}. Valid values are:&lt;/p&gt;
 141      * &lt;ul&gt;
 142      * &lt;li&gt;&lt;tt&gt;&quot;left&quot;&lt;/tt&gt; (the default) - The label is positioned to the left of the field, with its text
 143      * aligned to the left. Its width is determined by the {@link #labelWidth} config.&lt;/li&gt;
 144      * &lt;li&gt;&lt;tt&gt;&quot;top&quot;&lt;/tt&gt; - The label is positioned above the field.&lt;/li&gt;
 145      * &lt;li&gt;&lt;tt&gt;&quot;right&quot;&lt;/tt&gt; - The label is positioned to the left of the field, with its text aligned
 146      * to the right. Its width is determined by the {@link #labelWidth} config.&lt;/li&gt;
 147      * &lt;/ul&gt;
 148      */
 149     labelAlign : 'left',
 150
 151 <span id='Ext-form-Labelable-cfg-labelWidth'>    /**
 152 </span>     * @cfg {Number} labelWidth
 153      * The width of the {@link #fieldLabel} in pixels. Only applicable if the {@link #labelAlign} is set
 154      * to &quot;left&quot; or &quot;right&quot;. Defaults to &lt;tt&gt;100&lt;/tt&gt;.
 155      */
 156     labelWidth: 100,
 157
 158 <span id='Ext-form-Labelable-cfg-labelPad'>    /**
 159 </span>     * @cfg {Number} labelPad
 160      * The amount of space in pixels between the {@link #fieldLabel} and the input field. Defaults to &lt;tt&gt;5&lt;/tt&gt;.
 161      */
 162     labelPad : 5,
 163
 164 <span id='Ext-form-Labelable-cfg-labelSeparator'>    /**
 165 </span>     * @cfg {String} labelSeparator
 166      * Character(s) to be inserted at the end of the {@link #fieldLabel label text}.
 167      */
 168     labelSeparator : ':',
 169
 170 <span id='Ext-form-Labelable-cfg-labelStyle'>    /**
 171 </span>     * @cfg {String} labelStyle
 172      * &lt;p&gt;A CSS style specification string to apply directly to this field's label. Defaults to undefined.&lt;/p&gt;
 173      */
 174
 175 <span id='Ext-form-Labelable-cfg-hideLabel'>    /**
 176 </span>     * @cfg {Boolean} hideLabel
 177      * &lt;p&gt;Set to &lt;tt&gt;true&lt;/tt&gt; to completely hide the label element ({@link #fieldLabel} and {@link #labelSeparator}).
 178      * Defaults to &lt;tt&gt;false&lt;/tt&gt;.&lt;/p&gt;
 179      * &lt;p&gt;Also see {@link #hideEmptyLabel}, which controls whether space will be reserved for an empty fieldLabel.&lt;/p&gt;
 180      */
 181     hideLabel: false,
 182
 183 <span id='Ext-form-Labelable-cfg-hideEmptyLabel'>    /**
 184 </span>     * @cfg {Boolean} hideEmptyLabel
 185      * &lt;p&gt;When set to &lt;tt&gt;true&lt;/tt&gt;, the label element ({@link #fieldLabel} and {@link #labelSeparator}) will be
 186      * automatically hidden if the {@link #fieldLabel} is empty. Setting this to &lt;tt&gt;false&lt;/tt&gt; will cause the empty
 187      * label element to be rendered and space to be reserved for it; this is useful if you want a field without a label
 188      * to line up with other labeled fields in the same form. Defaults to &lt;tt&gt;true&lt;/tt&gt;.&lt;/p&gt;
 189      * &lt;p&gt;If you wish to unconditionall hide the label even if a non-empty fieldLabel is configured, then set
 190      * the {@link #hideLabel} config to &lt;tt&gt;true&lt;/tt&gt;.&lt;/p&gt;
 191      */
 192     hideEmptyLabel: true,
 193
 194 <span id='Ext-form-Labelable-cfg-preventMark'>    /**
 195 </span>     * @cfg {Boolean} preventMark
 196      * &lt;tt&gt;true&lt;/tt&gt; to disable displaying any {@link #setActiveError error message} set on this object.
 197      * Defaults to &lt;tt&gt;false&lt;/tt&gt;.
 198      */
 199     preventMark: false,
 200
 201 <span id='Ext-form-Labelable-cfg-autoFitErrors'>    /**
 202 </span>     * @cfg {Boolean} autoFitErrors
 203      * Whether to adjust the component's body area to make room for 'side' or 'under'
 204      * {@link #msgTarget error messages}. Defaults to &lt;tt&gt;true&lt;/tt&gt;.
 205      */
 206     autoFitErrors: true,
 207
 208 <span id='Ext-form-Labelable-cfg-msgTarget'>    /**
 209 </span>     * @cfg {String} msgTarget &lt;p&gt;The location where the error message text should display.
 210      * Must be one of the following values:&lt;/p&gt;
 211      * &lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
 212      * &lt;li&gt;&lt;code&gt;qtip&lt;/code&gt; Display a quick tip containing the message when the user hovers over the field. This is the default.
 213      * &lt;div class=&quot;subdesc&quot;&gt;&lt;b&gt;{@link Ext.tip.QuickTipManager#init Ext.tip.QuickTipManager.init} must have been called for this setting to work.&lt;/b&gt;&lt;/div&gt;&lt;/li&gt;
 214      * &lt;li&gt;&lt;code&gt;title&lt;/code&gt; Display the message in a default browser title attribute popup.&lt;/li&gt;
 215      * &lt;li&gt;&lt;code&gt;under&lt;/code&gt; Add a block div beneath the field containing the error message.&lt;/li&gt;
 216      * &lt;li&gt;&lt;code&gt;side&lt;/code&gt; Add an error icon to the right of the field, displaying the message in a popup on hover.&lt;/li&gt;
 217      * &lt;li&gt;&lt;code&gt;none&lt;/code&gt; Don't display any error message. This might be useful if you are implementing custom error display.&lt;/li&gt;
 218      * &lt;li&gt;&lt;code&gt;[element id]&lt;/code&gt; Add the error message directly to the innerHTML of the specified element.&lt;/li&gt;
 219      * &lt;/ul&gt;&lt;/div&gt;
 220      */
 221     msgTarget: 'qtip',
 222
 223 <span id='Ext-form-Labelable-cfg-activeError'>    /**
 224 </span>     * @cfg {String} activeError
 225      * If specified, then the component will be displayed with this value as its active error when
 226      * first rendered. Defaults to undefined. Use {@link #setActiveError} or {@link #unsetActiveError} to
 227      * change it after component creation.
 228      */
 229
 230
 231 <span id='Ext-form-Labelable-method-initLabelable'>    /**
 232 </span>     * Performs initialization of this mixin. Component classes using this mixin should call this method
 233      * during their own initialization.
 234      */
 235     initLabelable: function() {
 236         this.addCls(this.formItemCls);
 237
 238         this.addEvents(
 239 <span id='Ext-form-Labelable-event-errorchange'>            /**
 240 </span>             * @event errorchange
 241              * Fires when the active error message is changed via {@link #setActiveError}.
 242              * @param {Ext.form.Labelable} this
 243              * @param {String} error The active error message
 244              */
 245             'errorchange'
 246         );
 247     },
 248
 249 <span id='Ext-form-Labelable-method-getFieldLabel'>    /**
 250 </span>     * Returns the label for the field. Defaults to simply returning the {@link #fieldLabel} config. Can be
 251      * overridden to provide
 252      * @return {String} The configured field label, or empty string if not defined
 253      */
 254     getFieldLabel: function() {
 255         return this.fieldLabel || '';
 256     },
 257
 258 <span id='Ext-form-Labelable-method-getLabelableRenderData'>    /**
 259 </span>     * @protected
 260      * Generates the arguments for the field decorations {@link #labelableRenderTpl rendering template}.
 261      * @return {Object} The template arguments
 262      */
 263     getLabelableRenderData: function() {
 264         var me = this,
 265             labelAlign = me.labelAlign,
 266             labelPad = me.labelPad,
 267             labelStyle;
 268
 269         // Calculate label styles up front rather than in the Field layout for speed; this
 270         // is safe because label alignment/width/pad are not expected to change.
 271         if (labelAlign === 'top') {
 272             labelStyle = 'margin-bottom:' + labelPad + 'px;';
 273         } else {
 274             labelStyle = 'margin-right:' + labelPad + 'px;';
 275             // Add the width for border-box browsers; will be set by the Field layout for content-box
 276             if (Ext.isBorderBox) {
 277                 labelStyle += 'width:' + me.labelWidth + 'px;';
 278             }
 279         }
 280
 281         return Ext.copyTo(
 282             {
 283                 inputId: me.getInputId(),
 284                 fieldLabel: me.getFieldLabel(),
 285                 labelStyle: labelStyle + (me.labelStyle || ''),
 286                 subTplMarkup: me.getSubTplMarkup()
 287             },
 288             me,
 289             'hideLabel,hideEmptyLabel,labelCls,fieldBodyCls,baseBodyCls,errorMsgCls,clearCls,labelSeparator',
 290             true
 291         );
 292     },
 293
 294 <span id='Ext-form-Labelable-method-getLabelableSelectors'>    /**
 295 </span>     * @protected
 296      * Returns the additional {@link Ext.AbstractComponent#renderSelectors} for selecting the field
 297      * decoration elements from the rendered {@link #labelableRenderTpl}. Component classes using this mixin should
 298      * be sure and merge this method's result into the component's {@link Ext.AbstractComponent#renderSelectors}
 299      * before rendering.
 300      */
 301     getLabelableSelectors: function() {
 302         return {
 303 <span id='Ext-form-Labelable-property-labelEl'>            /**
 304 </span>             * @property labelEl
 305              * @type Ext.core.Element
 306              * The label Element for this component. Only available after the component has been rendered.
 307              */
 308             labelEl: 'label.' + this.labelCls,
 309
 310 <span id='Ext-form-Labelable-property-bodyEl'>            /**
 311 </span>             * @property bodyEl
 312              * @type Ext.core.Element
 313              * The div Element wrapping the component's contents. Only available after the component has been rendered.
 314              */
 315             bodyEl: '.' + this.baseBodyCls,
 316
 317 <span id='Ext-form-Labelable-property-errorEl'>            /**
 318 </span>             * @property errorEl
 319              * @type Ext.core.Element
 320              * The div Element that will contain the component's error message(s). Note that depending on the
 321              * configured {@link #msgTarget}, this element may be hidden in favor of some other form of
 322              * presentation, but will always be present in the DOM for use by assistive technologies.
 323              */
 324             errorEl: '.' + this.errorMsgCls
 325         };
 326     },
 327
 328 <span id='Ext-form-Labelable-method-getSubTplMarkup'>    /**
 329 </span>     * @protected
 330      * Gets the markup to be inserted into the outer template's bodyEl. Defaults to empty string, should
 331      * be implemented by classes including this mixin as needed.
 332      * @return {String} The markup to be inserted
 333      */
 334     getSubTplMarkup: function() {
 335         return '';
 336     },
 337
 338 <span id='Ext-form-Labelable-method-getInputId'>    /**
 339 </span>     * Get the input id, if any, for this component. This is used as the &quot;for&quot; attribute on the label element.
 340      * Implementing subclasses may also use this as e.g. the id for their own &lt;tt&gt;input&lt;/tt&gt; element.
 341      * @return {String} The input id
 342      */
 343     getInputId: function() {
 344         return '';
 345     },
 346
 347 <span id='Ext-form-Labelable-method-getActiveError'>    /**
 348 </span>     * Gets the active error message for this component, if any. This does not trigger
 349      * validation on its own, it merely returns any message that the component may already hold.
 350      * @return {String} The active error message on the component; if there is no error, an empty string is returned.
 351      */
 352     getActiveError : function() {
 353         return this.activeError || '';
 354     },
 355
 356 <span id='Ext-form-Labelable-method-hasActiveError'>    /**
 357 </span>     * Tells whether the field currently has an active error message. This does not trigger
 358      * validation on its own, it merely looks for any message that the component may already hold.
 359      * @return {Boolean}
 360      */
 361     hasActiveError: function() {
 362         return !!this.getActiveError();
 363     },
 364
 365 <span id='Ext-form-Labelable-method-setActiveError'>    /**
 366 </span>     * Sets the active error message to the given string. This replaces the entire error message
 367      * contents with the given string. Also see {@link #setActiveErrors} which accepts an Array of
 368      * messages and formats them according to the {@link #activeErrorsTpl}.
 369      *
 370      * Note that this only updates the error message element's text and attributes, you'll have
 371      * to call doComponentLayout to actually update the field's layout to match. If the field extends
 372      * {@link Ext.form.field.Base} you should call {@link Ext.form.field.Base#markInvalid markInvalid} instead.
 373      *
 374      * @param {String} msg The error message
 375      */
 376     setActiveError: function(msg) {
 377         this.activeError = msg;
 378         this.activeErrors = [msg];
 379         this.renderActiveError();
 380     },
 381
 382 <span id='Ext-form-Labelable-method-getActiveErrors'>    /**
 383 </span>     * Gets an Array of any active error messages currently applied to the field. This does not trigger
 384      * validation on its own, it merely returns any messages that the component may already hold.
 385      * @return {Array} The active error messages on the component; if there are no errors, an empty Array is returned.
 386      */
 387     getActiveErrors: function() {
 388         return this.activeErrors || [];
 389     },
 390
 391 <span id='Ext-form-Labelable-method-setActiveErrors'>    /**
 392 </span>     * Set the active error message to an Array of error messages. The messages are formatted into
 393      * a single message string using the {@link #activeErrorsTpl}. Also see {@link #setActiveError}
 394      * which allows setting the entire error contents with a single string.
 395      *
 396      * Note that this only updates the error message element's text and attributes, you'll have
 397      * to call doComponentLayout to actually update the field's layout to match. If the field extends
 398      * {@link Ext.form.field.Base} you should call {@link Ext.form.field.Base#markInvalid markInvalid} instead.
 399      *
 400      * @param {Array} errors The error messages
 401      */
 402     setActiveErrors: function(errors) {
 403         this.activeErrors = errors;
 404         this.activeError = this.getTpl('activeErrorsTpl').apply({errors: errors});
 405         this.renderActiveError();
 406     },
 407
 408 <span id='Ext-form-Labelable-method-unsetActiveError'>    /**
 409 </span>     * Clears the active error message(s).
 410      *
 411      * Note that this only clears the error message element's text and attributes, you'll have
 412      * to call doComponentLayout to actually update the field's layout to match. If the field extends
 413      * {@link Ext.form.field.Base} you should call {@link Ext.form.field.Base#clearInvalid clearInvalid} instead.
 414      */
 415     unsetActiveError: function() {
 416         delete this.activeError;
 417         delete this.activeErrors;
 418         this.renderActiveError();
 419     },
 420
 421 <span id='Ext-form-Labelable-method-renderActiveError'>    /**
 422 </span>     * @private
 423      * Updates the rendered DOM to match the current activeError. This only updates the content and
 424      * attributes, you'll have to call doComponentLayout to actually update the display.
 425      */
 426     renderActiveError: function() {
 427         var me = this,
 428             activeError = me.getActiveError(),
 429             hasError = !!activeError;
 430
 431         if (activeError !== me.lastActiveError) {
 432             me.fireEvent('errorchange', me, activeError);
 433             me.lastActiveError = activeError;
 434         }
 435
 436         if (me.rendered &amp;&amp; !me.isDestroyed &amp;&amp; !me.preventMark) {
 437             // Add/remove invalid class
 438             me.el[hasError ? 'addCls' : 'removeCls'](me.invalidCls);
 439
 440             // Update the aria-invalid attribute
 441             me.getActionEl().dom.setAttribute('aria-invalid', hasError);
 442
 443             // Update the errorEl with the error message text
 444             me.errorEl.dom.innerHTML = activeError;
 445         }
 446     },
 447
 448 <span id='Ext-form-Labelable-method-setFieldDefaults'>    /**
 449 </span>     * Applies a set of default configuration values to this Labelable instance. For each of the
 450      * properties in the given object, check if this component hasOwnProperty that config; if not
 451      * then it's inheriting a default value from its prototype and we should apply the default value.
 452      * @param {Object} defaults The defaults to apply to the object.
 453      */
 454     setFieldDefaults: function(defaults) {
 455         var me = this;
 456         Ext.iterate(defaults, function(key, val) {
 457             if (!me.hasOwnProperty(key)) {
 458                 me[key] = val;
 459             }
 460         });
 461     },
 462
 463 <span id='Ext-form-Labelable-method-getBodyNaturalWidth'>    /**
 464 </span>     * @protected Calculate and return the natural width of the bodyEl. Override to provide custom logic.
 465      * Note for implementors: if at all possible this method should be overridden with a custom implementation
 466      * that can avoid anything that would cause the browser to reflow, e.g. querying offsetWidth.
 467      */
 468     getBodyNaturalWidth: function() {
 469         return this.bodyEl.getWidth();
 470     }
 471
 472 });
 473 </pre>
 474 </body>
 475 </html>