/** * Private utility class for Ext.resizer.Resizer. * @private */Ext.define('Ext.resizer.ResizeTracker', { extend: 'Ext.dd.DragTracker', dynamic: true, preserveRatio: false, // Resizer mousedown must blur active element preventDefault: false, // Default to no constraint constrainTo: null, proxyCls: Ext.baseCSSPrefix + 'resizable-proxy', constructor: function(config) { var me = this, widthRatio, heightRatio, throttledResizeFn; if (!config.el) { if (config.target.isComponent) { me.el = config.target.getEl(); } else { me.el = config.target; } } this.callParent(arguments); // Ensure that if we are preserving aspect ratio, the largest minimum is honoured if (me.preserveRatio && me.minWidth && me.minHeight) { widthRatio = me.minWidth / me.el.getWidth(); heightRatio = me.minHeight / me.el.getHeight(); // largest ratio of minimum:size must be preserved. // So if a 400x200 pixel image has // minWidth: 50, maxWidth: 50, the maxWidth will be 400 * (50/200)... that is 100 if (heightRatio > widthRatio) { me.minWidth = me.el.getWidth() * heightRatio; } else { me.minHeight = me.el.getHeight() * widthRatio; } } // If configured as throttled, create an instance version of resize which calls // a throttled function to perform the resize operation. if (me.throttle) { throttledResizeFn = Ext.Function.createThrottled(function() { Ext.resizer.ResizeTracker.prototype.resize.apply(me, arguments); }, me.throttle); me.resize = function(box, direction, atEnd) { if (atEnd) { Ext.resizer.ResizeTracker.prototype.resize.apply(me, arguments); } else { throttledResizeFn.apply(null, arguments); } }; } }, onBeforeStart: function(e) { // record the startBox this.startBox = this.target.getBox(); }, /** * @private * Returns the object that will be resized instead of the true target on every mousemove event. * If dynamic is false, this will be a proxy, otherwise it will be null target. */ getProxy: function() { var me = this; if (!me.dynamic && !me.proxy) { me.proxy = me.createProxy(me.target || me.el); // Only hide proxy at end if we create one dynamically // When a wrapped resizer is used it passes the wrapping el in as the proxy. me.hideProxy = true; } if (me.proxy) { me.proxy.show(); return me.proxy; } }, /** * Create a proxy for this resizer * @param {Ext.Component/Ext.dom.Element} target The target * @return {Ext.dom.Element} A proxy element */ createProxy: function(target) { var proxy, cls = this.proxyCls; if (target.isComponent) { proxy = target.getProxy().addCls(cls); } else { proxy = target.createProxy({ tag: 'div', role: 'presentation', cls: cls, id: target.id + '-rzproxy' }, Ext.getBody()); } proxy.removeCls(Ext.baseCSSPrefix + 'proxy-el'); return proxy; }, onStart: function(e) { // returns the Ext.ResizeHandle that the user started dragging this.activeResizeHandle = Ext.get(this.getDragTarget().id); // If we are using a proxy, ensure it is sized. if (!this.dynamic) { this.resize(this.startBox); } }, onMouseDown: function(e, target) { // Logic to resize components on top of iframes or handle resizers bound to iframes. // To properly handle iframes "below" the resizable component, we cannot wait for // triggerStart or onStart because if the cursor moves out of the component and over the // iframe we won't detect that the drag has started. We cannot do this in // general because other draggable things cannot assume that mouseDown is safe // for this purpose. In particular ComponentDragger on a maximizable window will // get tricked by the maximize button onMouseDown and mask everything but will // never get the onMouseUp to unmask. this.callParent([e, target]); Ext.dom.Element.maskIframes(); }, onMouseUp: function(e) { this.callParent([e]); Ext.dom.Element.unmaskIframes(); }, onDrag: function(e) { // dynamic resizing, update dimensions during resize if (this.dynamic || this.proxy) { this.updateDimensions(e); } }, updateDimensions: function(e, atEnd) { var me = this, region = me.activeResizeHandle.region, offset = me.getOffset(me.constrainTo ? 'dragTarget' : null), box = me.startBox, ratio, widthAdjust = 0, heightAdjust = 0, snappedWidth, snappedHeight, adjustX = 0, adjustY = 0, dragRatio, oppositeCorner, axis, // 1 = x, 2 = y, 3 = x and y. newBox, newHeight, newWidth; region = me.convertRegionName(region); switch (region) { case 'south': heightAdjust = offset[1]; axis = 2; break; case 'north': heightAdjust = -offset[1]; adjustY = -heightAdjust; axis = 2; break; case 'east': widthAdjust = offset[0]; axis = 1; break; case 'west': widthAdjust = -offset[0]; adjustX = -widthAdjust; axis = 1; break; case 'northeast': heightAdjust = -offset[1]; adjustY = -heightAdjust; widthAdjust = offset[0]; oppositeCorner = [box.x, box.y + box.height]; axis = 3; break; case 'southeast': heightAdjust = offset[1]; widthAdjust = offset[0]; oppositeCorner = [box.x, box.y]; axis = 3; break; case 'southwest': widthAdjust = -offset[0]; adjustX = -widthAdjust; heightAdjust = offset[1]; oppositeCorner = [box.x + box.width, box.y]; axis = 3; break; case 'northwest': heightAdjust = -offset[1]; adjustY = -heightAdjust; widthAdjust = -offset[0]; adjustX = -widthAdjust; oppositeCorner = [box.x + box.width, box.y + box.height]; axis = 3; break; } newBox = { width: box.width + widthAdjust, height: box.height + heightAdjust, x: box.x + adjustX, y: box.y + adjustY }; // Snap value between stops according to configured increments snappedWidth = Ext.Number.snap(newBox.width, me.widthIncrement); snappedHeight = Ext.Number.snap(newBox.height, me.heightIncrement); if (snappedWidth !== newBox.width || snappedHeight !== newBox.height) { switch (region) { case 'northeast': newBox.y -= snappedHeight - newBox.height; break; case 'north': newBox.y -= snappedHeight - newBox.height; break; case 'southwest': newBox.x -= snappedWidth - newBox.width; break; case 'west': newBox.x -= snappedWidth - newBox.width; break; case 'northwest': newBox.x -= snappedWidth - newBox.width; newBox.y -= snappedHeight - newBox.height; } newBox.width = snappedWidth; newBox.height = snappedHeight; } // out of bounds if (newBox.width < me.minWidth || newBox.width > me.maxWidth) { newBox.width = Ext.Number.constrain(newBox.width, me.minWidth, me.maxWidth); // Re-adjust the X position if we were dragging the west side if (adjustX) { newBox.x = box.x + (box.width - newBox.width); } } else { me.lastX = newBox.x; } if (newBox.height < me.minHeight || newBox.height > me.maxHeight) { newBox.height = Ext.Number.constrain(newBox.height, me.minHeight, me.maxHeight); // Re-adjust the Y position if we were dragging the north side if (adjustY) { newBox.y = box.y + (box.height - newBox.height); } } else { me.lastY = newBox.y; } // If this is configured to preserve the aspect ratio, // or they are dragging using the shift key if (me.preserveRatio || e.shiftKey) { ratio = me.startBox.width / me.startBox.height; // Calculate aspect ratio constrained values. newHeight = Math.min(Math.max(me.minHeight, newBox.width / ratio), me.maxHeight); newWidth = Math.min(Math.max(me.minWidth, newBox.height * ratio), me.maxWidth); // X axis: width-only change, height must obey if (axis === 1) { newBox.height = newHeight; } // Y axis: height-only change, width must obey else if (axis === 2) { newBox.width = newWidth; } // Corner drag. else { // Drag ratio is the ratio of the mouse point from the opposite corner. // Basically what edge we are dragging, a horizontal edge or a vertical edge. dragRatio = Math.abs(oppositeCorner[0] - this.lastXY[0]) / Math.abs(oppositeCorner[1] - this.lastXY[1]); // If drag ratio > aspect ratio then width is dominant and height must obey if (dragRatio > ratio) { newBox.height = newHeight; } else { newBox.width = newWidth; } // Handle dragging start coordinates if (region === 'northeast') { newBox.y = box.y - (newBox.height - box.height); } else if (region === 'northwest') { newBox.y = box.y - (newBox.height - box.height); newBox.x = box.x - (newBox.width - box.width); } else if (region === 'southwest') { newBox.x = box.x - (newBox.width - box.width); } } } // Keep track of whether position needs changing me.setPosition = newBox.x !== me.startBox.x || newBox.y !== me.startBox.y; me.resize(newBox, atEnd); }, resize: function(box, atEnd) { var me = this, target, setPosition = me.setPosition; // We are live resizing the target, or at the end: Size the target if (me.dynamic || (!me.dynamic && atEnd)) { // Resize the target if (setPosition) { me.target.setBox(box); } else { me.target.setSize(box.width, box.height); } } // In the middle of a resize - just resize the proxy if (!atEnd) { target = me.getProxy(); if (target && target !== me.target) { if (setPosition || me.hideProxy) { target.setBox(box); } else { target.setSize(box.width, box.height); } } } }, onEnd: function(e) { this.updateDimensions(e, true); if (this.proxy && this.hideProxy) { this.proxy.hide(); } }, convertRegionName: function(name) { return name; }});