add extjs 6.0.1 sources

[extjs.git] / extjs / classic / classic / src / grid / ColumnLayout.js

/**\r
 * @private\r
 *\r
 * This class is used only by the grid's HeaderContainer docked child.\r
 *\r
 * It adds the ability to shrink the vertical size of the inner container element back if a grouped\r
 * column header has all its child columns dragged out, and the whole HeaderContainer needs to shrink back down.\r
 *\r
 * Also, after every layout, after all headers have attained their 'stretchmax' height, it goes through and calls\r
 * `setPadding` on the columns so that they lay out correctly.\r
 */\r
Ext.define('Ext.grid.ColumnLayout', {\r
    extend: 'Ext.layout.container.HBox',\r
    alias: 'layout.gridcolumn',\r
    type : 'gridcolumn',\r
\r
    requires: [\r
        'Ext.panel.Table'  \r
    ],\r
\r
    firstHeaderCls: Ext.baseCSSPrefix + 'column-header-first',\r
    lastHeaderCls: Ext.baseCSSPrefix + 'column-header-last',\r
\r
    initLayout: function() {\r
        this.callParent();\r
\r
        if (this.scrollbarWidth === undefined) {\r
            this.self.prototype.scrollbarWidth = Ext.getScrollbarSize().width;\r
        }\r
    },\r
\r
    beginLayout: function (ownerContext) {\r
        var me = this,\r
            owner = me.owner,\r
            firstCls = me.firstHeaderCls,\r
            lastCls = me.lastHeaderCls,\r
            bothCls = [firstCls, lastCls],\r
            items = me.getVisibleItems(),\r
            len = items.length,\r
            i, item;\r
\r
        me.callParent([ ownerContext ]);\r
\r
        // Sync the first/lastCls states for all the headers.\r
        for (i = 0; i < len; i++) {\r
            item = items[i];\r
\r
            if (len === 1) {\r
                // item is the only item so it is both first and last\r
                item.addCls(bothCls);\r
            }\r
            else if (i === 0) {\r
                // item is the first of 2+ items\r
                item.addCls(firstCls);\r
                item.removeCls(lastCls);\r
            }\r
            else if (i === len - 1) {\r
                // item is the last of 2+ items\r
                item.removeCls(firstCls);\r
                item.addCls(lastCls);\r
            }\r
            else {\r
                item.removeCls(bothCls);\r
            }\r
        }\r
\r
        // Start this at 0 and for the root headerCt call determineScrollbarWidth to get\r
        // it set properly. Typically that amounts to a "delete" to expose the system's\r
        // scrollbar width stored on our prototype.\r
\r
        me.scrollbarWidth = 0;\r
\r
        if (owner.isRootHeader) {\r
            me.determineScrollbarWidth(ownerContext);\r
        }\r
        if (!me.scrollbarWidth) {\r
            // By default Mac OS X has overlay scrollbars that do not take space, but also\r
            // the RTL override may have set this to 0... so make sure we don't try to\r
            // compensate for a scrollbar when there isn't one.\r
            ownerContext.manageScrollbar = false;\r
        }\r
    },\r
\r
    moveItemBefore: function (item, before) {\r
        var prevOwner = item.ownerCt;\r
\r
        // Due to the nature of grid headers, index calculation for\r
        // moving items is complicated, especially since removals can trigger\r
        // groups to be removed (and thus alter indexes). As such, the logic\r
        // is simplified by removing the item first, then calculating the index\r
        // and inserting it\r
        if (item !== before && prevOwner) {\r
            prevOwner.remove(item, false);\r
        }\r
        return this.callParent([item, before]);\r
    },\r
\r
    determineScrollbarWidth: function (ownerContext) {\r
        var me = this,\r
            owner = me.owner,\r
            grid = owner.grid,\r
            // locking headerCt can refuse to reserveScrollbar, even if the locking grid\r
            // view does reserveScrollbar (special technique for hiding the vertical\r
            // scrollbar on the locked side)\r
            vetoReserveScrollbar = owner.reserveScrollbar === false,\r
            // We read this value off of the immediate grid since the locked side of a\r
            // locking grid will not have this set. The ownerGrid in that case would have\r
            // it set but will pass along true only to the normal side.\r
            reserveScrollbar = grid.reserveScrollbar && !vetoReserveScrollbar,\r
            manageScrollbar = !reserveScrollbar && !vetoReserveScrollbar &&\r
                    grid.view.scrollFlags.y;\r
\r
        // If we have reserveScrollbar then we will always have a vertical scrollbar so\r
        // manageScrollbar should be false. Otherwise it is based on overflow-y:\r
        ownerContext.manageScrollbar = manageScrollbar;\r
\r
        // Determine if there is any need to deal with the width of the vertical scrollbar\r
        // and set "scrollbarWidth" to 0 if not or the system determined value (stored on\r
        // our prototype).\r
        //\r
        if (!grid.ownerGrid.collapsed && (reserveScrollbar || manageScrollbar)) {\r
            // Ensure the real scrollbarWidth value is exposed from the prototype. This\r
            // may be needed if the scrollFlags have changed since we may have a 0 set on\r
            // this instance from a previous layout run.\r
            delete me.scrollbarWidth;\r
        }\r
\r
        // On return, the RTL override (Ext.rtl.grid.ColumnLayout) will deal with various\r
        // browser bugs and may set me.scrollbarWidth to 0 or a negative value.\r
    },\r
\r
    calculate: function (ownerContext) {\r
        var me = this,\r
            grid = me.owner.grid,\r
            // Our TableLayout buddy sets this in its beginLayout so we can work this\r
            // out together:\r
            viewContext = ownerContext.viewContext,\r
            state = ownerContext.state,\r
            context = ownerContext.context,\r
            lockingPartnerContext, ownerGrid,\r
            columnsChanged, columns, len, i, column, scrollbarAdjustment, viewOverflowY;\r
\r
        me.callParent([ ownerContext ]);\r
\r
        if (grid && state.parallelDone) {\r
            lockingPartnerContext = viewContext.lockingPartnerContext;\r
            ownerGrid = grid.ownerGrid;\r
\r
            // A force-fit needs to be "reflexed" so check that now. If we have to reflex\r
            // the items, we need to re-cacheFlexes and invalidate ourselves.\r
            if (ownerGrid.forceFit && !state.reflexed) {\r
                if (me.convertWidthsToFlexes(ownerContext)) {\r
                    me.cacheFlexes(ownerContext);\r
                    me.done = false;\r
                    ownerContext.invalidate({\r
                        state: {\r
                            reflexed: true,\r
                            scrollbarAdjustment: me.getScrollbarAdjustment(ownerContext)\r
                        }\r
                    });\r
                    return;\r
                }\r
            }\r
\r
            // Once the parallelDone flag goes up, we need to pack up the changed column\r
            // widths for our TableLayout partner.\r
            if ((columnsChanged = state.columnsChanged) === undefined) {\r
                columns = ownerContext.target.getVisibleGridColumns();\r
                columnsChanged = false;\r
\r
                for (i = 0, len = columns.length; i < len; i++) {\r
                    column = context.getCmp(columns[i]);\r
                    // Since we are parallelDone, all of the children should have width,\r
                    // so we can\r
\r
                    if (!column.lastBox || column.props.width !== column.lastBox.width) {\r
                        (columnsChanged || (columnsChanged = []))[i] = column;\r
                    }\r
                }\r
\r
                state.columnsChanged = columnsChanged;\r
                // This will trigger our TableLayout partner and allow it to proceed.\r
                ownerContext.setProp('columnsChanged', columnsChanged);\r
            }\r
\r
            if (ownerContext.manageScrollbar) {\r
                // If we changed the column widths, we need to wait for the TableLayout to\r
                // return whether or not we have overflowY... well, that is, if we are\r
                // needing to tweak the scrollbarAdjustment...\r
                scrollbarAdjustment = me.getScrollbarAdjustment(ownerContext);\r
\r
                if (scrollbarAdjustment) {\r
                    // Since we start with the assumption that we will need the scrollbar,\r
                    // we now need to wait to see if our guess was correct.\r
                    viewOverflowY = viewContext.getProp('viewOverflowY');\r
                    if (viewOverflowY === undefined) {\r
                        // The TableLayout has not determined this yet, so park it.\r
                        me.done = false;\r
                        return;\r
                    }\r
\r
                    if (!viewOverflowY) {\r
                        // We have our answer, and it turns out the view did not overflow\r
                        // (even with the reduced width we gave it), so we need to remove\r
                        // the scrollbarAdjustment and go again.\r
                        if (lockingPartnerContext) {\r
                            // In a locking grid, only the normal side plays this game,\r
                            // so now that we know the resolution, we need to invalidate\r
                            // the locking view and its headerCt.\r
                            lockingPartnerContext.invalidate();\r
                            lockingPartnerContext.headerContext.invalidate();\r
                        }\r
                        viewContext.invalidate();\r
                        ownerContext.invalidate({\r
                            state: {\r
                                // Pass a 0 adjustment on into our next life. If this is\r
                                // the invalidate that resets ownerContext then this is\r
                                // put onto the new state. If not, it will reset back to\r
                                // undefined and we'll have to begin again (which is the\r
                                // correct thing to do in that case).\r
                                scrollbarAdjustment: 0\r
                            }\r
                        });\r
                    }\r
                }\r
                // else {\r
                    // We originally assumed we would need the scrollbar and since we do\r
                    // not now, we must be on the second pass, so we can move on...\r
                // }\r
            }\r
        }\r
    },\r
\r
    finishedLayout: function(ownerContext) {\r
        this.callParent([ ownerContext ]);\r
        if (this.owner.ariaRole === 'rowgroup') {\r
            this.innerCt.dom.setAttribute('role', 'row');\r
        }\r
\r
        // Wipe this array because it holds component references and gets cached on the object\r
        // Can cause a circular reference\r
        ownerContext.props.columnsChanged = null;\r
    },\r
\r
    convertWidthsToFlexes: function(ownerContext) {\r
        var me = this,\r
            totalWidth = 0,\r
            calculated = me.sizeModels.calculated,\r
            childItems, len, i, childContext, item;\r
\r
        childItems = ownerContext.childItems;\r
        len = childItems.length;\r
\r
        for (i = 0; i < len; i++) {\r
            childContext = childItems[i];\r
            item = childContext.target;\r
\r
            totalWidth += childContext.props.width;\r
\r
            // Only allow to be flexed if it's a resizable column\r
            if (!(item.fixed || item.resizable === false)) {\r
                // For forceFit, just use allocated width as the flex value, and the proportions\r
                // will end up the same whatever HeaderContainer width they are being forced into.\r
                item.flex = ownerContext.childItems[i].flex = childContext.props.width;\r
                item.width = null;\r
                childContext.widthModel = calculated;\r
            }\r
        }\r
\r
        // Only need to loop back if the total column width is not already an exact fit\r
        return totalWidth !== ownerContext.props.width;\r
    },\r
\r
    getScrollbarAdjustment: function (ownerContext) {\r
        var me = this,\r
            state = ownerContext.state,\r
            grid = me.owner.grid,\r
            scrollbarAdjustment = state.scrollbarAdjustment;\r
\r
        // If there is potential for a vertical scrollbar, then we start by assuming\r
        // we will need to reserve space for it. Unless, of course, there are no\r
        // records!\r
        if (scrollbarAdjustment === undefined) {\r
            scrollbarAdjustment = 0;\r
\r
            if (grid.reserveScrollbar || (ownerContext.manageScrollbar &&\r
                    !grid.ownerGrid.layout.ownerContext.heightModel.shrinkWrap)) {\r
                scrollbarAdjustment = me.scrollbarWidth;\r
            }\r
\r
            state.scrollbarAdjustment = scrollbarAdjustment;\r
        }\r
\r
        return scrollbarAdjustment;\r
    },\r
\r
    /**\r
     * @private\r
     * Local getContainerSize implementation accounts for vertical scrollbar in the view.\r
     */\r
    getContainerSize: function (ownerContext) {\r
        var me = this,\r
            got, needed, padding, gotWidth, gotHeight, width, height, result;\r
\r
        if (me.owner.isRootHeader) {\r
            result = me.callParent([ ownerContext ]);\r
\r
            if (result.gotWidth) {\r
                result.width -= me.getScrollbarAdjustment(ownerContext);\r
            }\r
        } else {\r
            padding = ownerContext.paddingContext.getPaddingInfo();\r
            got = needed = 0;\r
\r
            // The container size here has to be provided by the ColumnComponentLayout to\r
            // account for borders in its odd way.\r
            if (!ownerContext.widthModel.shrinkWrap) {\r
                ++needed;\r
                width = ownerContext.getProp('innerWidth');\r
                gotWidth = (typeof width === 'number');\r
                if (gotWidth) {\r
                    ++got;\r
                    width -= padding.width;\r
                    if (width < 0) {\r
                        width = 0;\r
                    }\r
                }\r
            }\r
\r
            if (!ownerContext.heightModel.shrinkWrap) {\r
                ++needed;\r
                height = ownerContext.getProp('innerHeight');\r
                gotHeight = (typeof height === 'number');\r
                if (gotHeight) {\r
                    ++got;\r
                    height -= padding.height;\r
                    if (height < 0) {\r
                        height = 0;\r
                    }\r
                }\r
            }\r
\r
            return {\r
                width: width,\r
                height: height,\r
                needed: needed,\r
                got: got,\r
                gotAll: got === needed,\r
                gotWidth: gotWidth,\r
                gotHeight: gotHeight\r
            };\r
        }\r
\r
        return result;\r
    },\r
\r
    publishInnerCtSize: function(ownerContext) {\r
        var me = this,\r
            owner = me.owner,\r
            cw = ownerContext.peek('contentWidth'),\r
            adjustment = 0;\r
\r
        // Pass negative "reservedSpace", so that the innerCt gets *extra* size to accommodate the view's vertical scrollbar\r
        if (cw != null && owner.isRootHeader) {\r
            adjustment = -ownerContext.state.scrollbarAdjustment;\r
        }\r
\r
        return me.callParent([ownerContext, adjustment]);\r
    }\r
});\r