/*
This file is part of Ext JS 4.2
Copyright (c) 2011-2013 Sencha Inc
Contact: http://www.sencha.com/contact
GNU General Public License Usage
This file may be used under the terms of the GNU General Public License version 3.0 as
published by the Free Software Foundation and appearing in the file LICENSE included in the
packaging of this file.
Please review the following information to ensure the GNU General Public License version 3.0
requirements will be met: http://www.gnu.org/copyleft/gpl.html.
If you are unsure which license is appropriate for your use, please contact the sales department
at http://www.sencha.com/contact.
Build date: 2013-05-16 14:36:50 (f9be68accb407158ba2b1be2c226a6ce1f649314)
*/
/**
* The class is the default component layout for {@link Ext.Component} when no explicit
* `{@link Ext.Component#componentLayout componentLayout}` is configured.
*
* This class uses template methods to perform the individual aspects of measurement,
* calculation and publication of results. The methods called depend on the component's
* {@link Ext.AbstractComponent#getSizeModel size model}.
*
* ## configured / calculated
*
* In either of these size models, the dimension of the outer element is of a known size.
* The size is found in the `ownerContext` (the {@link Ext.layout.ContextItem} for the owner
* component) as either "width" or "height". This value, if available, is passed to the
* `publishInnerWidth` or `publishInnerHeight` method, respectively.
*
* ## shrinkWrap
*
* When a dimension uses the `shrinkWrap` size model, that means the content is measured,
* then the outer (owner) size is calculated and published.
*
* For example, for a shrinkWrap width, the following sequence of calls are made:
*
* - `Ext.layout.component.Component#measureContentWidth`
* - `publishOwnerWidth`
* - `calculateOwnerWidthFromContentWidth`
* - `publishInnerWidth` (in the event of hitting a min/maxWidth constraint)
*
* ## natural
*
* When a dimension uses the `natural` size model, the measurement is made on the outer
* (owner) element. This size is then used to determine the content area in much the same
* way as if the outer element had a `configured` or `calculated` size model.
*
* - `Ext.layout.component.Component#measureOwnerWidth`
* - `publishInnerWidth`
*
* @protected
*/
Ext.define('Ext.layout.component.Auto', {
/* Begin Definitions */
alias: 'layout.autocomponent',
extend: 'Ext.layout.component.Component',
/* End Definitions */
type: 'autocomponent',
/**
* @cfg {Boolean} [setHeightInDom=false]
* @protected
* When publishing height of an auto Component, it is usually not written to the DOM.
* Setting this to `true` overrides this behaviour.
*/
setHeightInDom: false,
/**
* @cfg {Boolean} [setWidthInDom=false]
* @protected
* When publishing width of an auto Component, it is usually not written to the DOM.
* Setting this to `true` overrides this behaviour.
*/
setWidthInDom: false,
waitForOuterHeightInDom: false,
waitForOuterWidthInDom: false,
beginLayoutCycle: function(ownerContext, firstCycle){
var me = this,
lastWidthModel = me.lastWidthModel,
lastHeightModel = me.lastHeightModel,
el = me.owner.el;
me.callParent(arguments);
if (lastWidthModel && lastWidthModel.fixed && ownerContext.widthModel.shrinkWrap) {
el.setWidth(null);
}
if (lastHeightModel && lastHeightModel.fixed && ownerContext.heightModel.shrinkWrap) {
el.setHeight(null);
}
},
calculate: function(ownerContext) {
var me = this,
measurement = me.measureAutoDimensions(ownerContext),
heightModel = ownerContext.heightModel,
widthModel = ownerContext.widthModel,
width, height;
// It is generally important to process widths before heights, since widths can
// often effect heights...
if (measurement.gotWidth) {
if (widthModel.shrinkWrap) {
me.publishOwnerWidth(ownerContext, measurement.contentWidth);
} else if (me.publishInnerWidth) {
me.publishInnerWidth(ownerContext, measurement.width);
}
} else if (!widthModel.auto && me.publishInnerWidth) {
width = me.waitForOuterWidthInDom ? ownerContext.getDomProp('width')
: ownerContext.getProp('width');
if (width === undefined) {
me.done = false;
} else {
me.publishInnerWidth(ownerContext, width);
}
}
if (measurement.gotHeight) {
if (heightModel.shrinkWrap) {
me.publishOwnerHeight(ownerContext, measurement.contentHeight);
} else if (me.publishInnerHeight) {
me.publishInnerHeight(ownerContext, measurement.height);
}
} else if (!heightModel.auto && me.publishInnerHeight) {
height = me.waitForOuterHeightInDom ? ownerContext.getDomProp('height')
: ownerContext.getProp('height');
if (height === undefined) {
me.done = false;
} else {
me.publishInnerHeight(ownerContext, height);
}
}
if (!measurement.gotAll) {
me.done = false;
}
},
calculateOwnerHeightFromContentHeight: function (ownerContext, contentHeight) {
return contentHeight + ownerContext.getFrameInfo().height;
},
calculateOwnerWidthFromContentWidth: function (ownerContext, contentWidth) {
return contentWidth + ownerContext.getFrameInfo().width;
},
publishOwnerHeight: function (ownerContext, contentHeight) {
var me = this,
owner = me.owner,
height = me.calculateOwnerHeightFromContentHeight(ownerContext, contentHeight),
constrainedHeight, dirty, heightModel;
if (isNaN(height)) {
me.done = false;
} else {
constrainedHeight = Ext.Number.constrain(height, owner.minHeight, owner.maxHeight);
if (constrainedHeight == height) {
dirty = me.setHeightInDom;
} else {
heightModel = me.sizeModels[
(constrainedHeight < height) ? 'constrainedMax' : 'constrainedMin'];
height = constrainedHeight;
if (ownerContext.heightModel.calculatedFromShrinkWrap) {
// Don't bother to invalidate since that will come soon... but we need
// to signal our ownerLayout that we need an invalidate to actually
// make good on the determined (constrained) size!
ownerContext.heightModel = heightModel;
} else {
ownerContext.invalidate({ heightModel: heightModel });
}
}
ownerContext.setHeight(height, dirty);
}
},
publishOwnerWidth: function (ownerContext, contentWidth) {
var me = this,
owner = me.owner,
width = me.calculateOwnerWidthFromContentWidth(ownerContext, contentWidth),
constrainedWidth, dirty, widthModel;
if (isNaN(width)) {
me.done = false;
} else {
constrainedWidth = Ext.Number.constrain(width, owner.minWidth, owner.maxWidth);
if (constrainedWidth == width) {
dirty = me.setWidthInDom;
} else {
widthModel = me.sizeModels[
(constrainedWidth < width) ? 'constrainedMax' : 'constrainedMin'];
width = constrainedWidth;
if (ownerContext.widthModel.calculatedFromShrinkWrap) {
// Don't bother to invalidate since that will come soon... but we need
// to signal our ownerLayout that we need an invalidate to actually
// make good on the determined (constrained) size!
ownerContext.widthModel = widthModel;
} else {
ownerContext.invalidate({ widthModel: widthModel });
}
}
ownerContext.setWidth(width, dirty);
}
}
});
|
Download
