wrapper attribute.
*
* @attribute wrap
* @default false
* @type boolean
*/
wrap: {
setter: '_setWrap',
value: false,
validator: isBoolean
},
/**
* Elements that requires a wrapper by default. Normally are elements
* which cannot have children elements.
*
* @attribute wrapTypes
* @default /canvas|textarea|input|select|button|img/i
* @readOnly
* @type Regex
*/
wrapTypes: {
readOnly: true,
value: /^canvas|textarea|input|select|button|img|iframe|table|embed$/i
},
/**
* Element to wrap the wrapTypes. This element will house
* the handles elements.
*
* @attribute wrapper
* @default div
* @type String | Node
* @writeOnce
*/
wrapper: {
readOnly: true,
valueFn: '_valueWrapper',
writeOnce: true
}
},
RULES: {
b: function(instance, dx, dy) {
var info = instance.info,
originalInfo = instance.originalInfo;
info.offsetHeight = originalInfo.offsetHeight + dy;
},
l: function(instance, dx) {
var info = instance.info,
originalInfo = instance.originalInfo;
info.left = originalInfo.left + dx;
info.offsetWidth = originalInfo.offsetWidth - dx;
},
r: function(instance, dx) {
var info = instance.info,
originalInfo = instance.originalInfo;
info.offsetWidth = originalInfo.offsetWidth + dx;
},
t: function(instance, dx, dy) {
var info = instance.info,
originalInfo = instance.originalInfo;
info.top = originalInfo.top + dy;
info.offsetHeight = originalInfo.offsetHeight - dy;
},
tr: function() {
this.t.apply(this, arguments);
this.r.apply(this, arguments);
},
bl: function() {
this.b.apply(this, arguments);
this.l.apply(this, arguments);
},
br: function() {
this.b.apply(this, arguments);
this.r.apply(this, arguments);
},
tl: function() {
this.t.apply(this, arguments);
this.l.apply(this, arguments);
}
},
capitalize: capitalize
});
Y.Resize = Y.extend(
Resize,
Y.Base,
{
/**
* Array containing all possible resizable handles.
*
* @property ALL_HANDLES
* @type {String}
*/
ALL_HANDLES: [ T, TR, R, BR, B, BL, L, TL ],
/**
* Regex which matches with the handles that could change the height of
* the resizable element.
*
* @property REGEX_CHANGE_HEIGHT
* @type {String}
*/
REGEX_CHANGE_HEIGHT: /^(t|tr|b|bl|br|tl)$/i,
/**
* Regex which matches with the handles that could change the left of
* the resizable element.
*
* @property REGEX_CHANGE_LEFT
* @type {String}
*/
REGEX_CHANGE_LEFT: /^(tl|l|bl)$/i,
/**
* Regex which matches with the handles that could change the top of
* the resizable element.
*
* @property REGEX_CHANGE_TOP
* @type {String}
*/
REGEX_CHANGE_TOP: /^(tl|t|tr)$/i,
/**
* Regex which matches with the handles that could change the width of
* the resizable element.
*
* @property REGEX_CHANGE_WIDTH
* @type {String}
*/
REGEX_CHANGE_WIDTH: /^(bl|br|l|r|tl|tr)$/i,
/**
* Template used to create the resize wrapper for the handles.
*
* @property HANDLES_WRAP_TEMPLATE
* @type {String}
*/
HANDLES_WRAP_TEMPLATE: '',
/**
* Template used to create the resize wrapper node when needed.
*
* @property WRAP_TEMPLATE
* @type {String}
*/
WRAP_TEMPLATE: '',
/**
* Template used to create each resize handle.
*
* @property HANDLE_TEMPLATE
* @type {String}
*/
HANDLE_TEMPLATE: 'Loop through each handle which is being used and executes a callback.
*Example:
*instance.eachHandle(
* function(handleName, index) { ... }
* );Generates metadata to the info * and originalInfo
*bottom, actXY, left, top, offsetHeight, offsetWidth, rightinstance.changeHeightHandles,
* instance.changeLeftHandles, instance.changeTopHandles,
* instance.changeWidthHandles information.
*
* @method _updateChangeHandleInfo
* @private
*/
_updateChangeHandleInfo: function(handle) {
var instance = this;
instance.changeHeightHandles = instance.REGEX_CHANGE_HEIGHT.test(handle);
instance.changeLeftHandles = instance.REGEX_CHANGE_LEFT.test(handle);
instance.changeTopHandles = instance.REGEX_CHANGE_TOP.test(handle);
instance.changeWidthHandles = instance.REGEX_CHANGE_WIDTH.test(handle);
},
/**
* Update info values (bottom, actXY, left, top, offsetHeight, offsetWidth, right).
*
* @method _updateInfo
* @private
*/
_updateInfo: function(event) {
var instance = this;
instance.info = instance._getInfo(instance.get(WRAPPER), event);
},
/**
* Update properties
* nodeSurrounding,
* wrapperSurrounding,
* totalVSurrounding,
* totalHSurrounding.
*
* @method _updateSurroundingInfo
* @private
*/
_updateSurroundingInfo: function() {
var instance = this,
node = instance.get(NODE),
wrapper = instance.get(WRAPPER),
nodeSurrounding = instance._getBoxSurroundingInfo(node),
wrapperSurrounding = instance._getBoxSurroundingInfo(wrapper);
instance.nodeSurrounding = nodeSurrounding;
instance.wrapperSurrounding = wrapperSurrounding;
instance.totalVSurrounding = (nodeSurrounding.totalVPadding + wrapperSurrounding.totalVBorder);
instance.totalHSurrounding = (nodeSurrounding.totalHPadding + wrapperSurrounding.totalHBorder);
},
/**
* Set the active state of the handles.
*
* @method _setActiveHandlesUI
* @param {boolean} val True to activate the handles, false to deactivate.
* @protected
*/
_setActiveHandlesUI: function(val) {
var instance = this,
activeHandleNode = instance.get(ACTIVE_HANDLE_NODE);
if (activeHandleNode) {
if (val) {
// remove CSS_RESIZE_HANDLE_ACTIVE from all handles before addClass on the active
instance.eachHandle(
function(handleEl) {
handleEl.removeClass(CSS_RESIZE_HANDLE_ACTIVE);
}
);
activeHandleNode.addClass(CSS_RESIZE_HANDLE_ACTIVE);
}
else {
activeHandleNode.removeClass(CSS_RESIZE_HANDLE_ACTIVE);
}
}
},
/**
* Setter for the handles attribute
*
* @method _setHandles
* @protected
* @param {String} val
*/
_setHandles: function(val) {
var instance = this,
handles = [];
// handles attr accepts both array or string
if (isArray(val)) {
handles = val;
}
else if (isString(val)) {
// if the handles attr passed in is an ALL string...
if (val.toLowerCase() === ALL) {
handles = instance.ALL_HANDLES;
}
// otherwise, split the string to extract the handles
else {
Y.each(
val.split(COMMA),
function(node) {
var handle = trim(node);
// if its a valid handle, add it to the handles output
if (indexOf(instance.ALL_HANDLES, handle) > -1) {
handles.push(handle);
}
}
);
}
}
return handles;
},
/**
* Set the visibility of the handles.
*
* @method _setHideHandlesUI
* @param {boolean} val True to hide the handles, false to show.
* @protected
*/
_setHideHandlesUI: function(val) {
var instance = this,
wrapper = instance.get(WRAPPER);
if (!instance.get(RESIZING)) {
if (val) {
wrapper.addClass(CSS_RESIZE_HIDDEN_HANDLES);
}
else {
wrapper.removeClass(CSS_RESIZE_HIDDEN_HANDLES);
}
}
},
/**
* Setter for the wrap attribute
*
* @method _setWrap
* @protected
* @param {boolean} val
*/
_setWrap: function(val) {
var instance = this,
node = instance.get(NODE),
nodeName = node.get(NODE_NAME),
typeRegex = instance.get(WRAP_TYPES);
// if nodeName is listed on WRAP_TYPES force use the wrapper
if (typeRegex.test(nodeName)) {
val = true;
}
return val;
},
/**
* Default resize:mouseUp handler
*
* @method _defMouseUpFn
* @param {EventFacade} event The Event object
* @protected
*/
_defMouseUpFn: function() {
var instance = this;
instance.set(RESIZING, false);
},
/**
* Default resize:resize handler
*
* @method _defResizeFn
* @param {EventFacade} event The Event object
* @protected
*/
_defResizeFn: function(event) {
var instance = this;
instance._resize(event);
},
/**
* Logic method for _defResizeFn. Allow AOP.
*
* @method _resize
* @param {EventFacade} event The Event object
* @protected
*/
_resize: function(event) {
var instance = this;
instance._handleResizeAlignEvent(event.dragEvent);
// _syncUI of the wrapper, not using proxy
instance._syncUI();
},
/**
* Default resize:align handler
*
* @method _defResizeAlignFn
* @param {EventFacade} event The Event object
* @protected
*/
_defResizeAlignFn: function(event) {
var instance = this;
instance._resizeAlign(event);
},
/**
* Logic method for _defResizeAlignFn. Allow AOP.
*
* @method _resizeAlign
* @param {EventFacade} event The Event object
* @protected
*/
_resizeAlign: function(event) {
var instance = this,
info,
defMinHeight,
defMinWidth;
instance.lastInfo = instance.info;
// update the instance.info values
instance._updateInfo(event);
info = instance.info;
// basic resize calculations
instance._calcResize();
// if Y.Plugin.ResizeConstrained is not plugged, check for min dimension
if (!instance.con) {
defMinHeight = (instance.get(DEF_MIN_HEIGHT) + instance.totalVSurrounding);
defMinWidth = (instance.get(DEF_MIN_WIDTH) + instance.totalHSurrounding);
if (info.offsetHeight <= defMinHeight) {
instance._checkSize(OFFSET_HEIGHT, defMinHeight);
}
if (info.offsetWidth <= defMinWidth) {
instance._checkSize(OFFSET_WIDTH, defMinWidth);
}
}
},
/**
* Default resize:end handler
*
* @method _defResizeEndFn
* @param {EventFacade} event The Event object
* @protected
*/
_defResizeEndFn: function(event) {
var instance = this;
instance._resizeEnd(event);
},
/**
* Logic method for _defResizeEndFn. Allow AOP.
*
* @method _resizeEnd
* @param {EventFacade} event The Event object
* @protected
*/
_resizeEnd: function(event) {
var instance = this,
drag = event.dragEvent.target;
// reseting actXY from drag when drag end
drag.actXY = [];
// syncUI when resize end
instance._syncUI();
instance._setActiveHandlesUI(false);
instance.set(ACTIVE_HANDLE, null);
instance.set(ACTIVE_HANDLE_NODE, null);
instance.handle = null;
},
/**
* Default resize:start handler
*
* @method _defResizeStartFn
* @param {EventFacade} event The Event object
* @protected
*/
_defResizeStartFn: function(event) {
var instance = this;
instance._resizeStart(event);
},
/**
* Logic method for _defResizeStartFn. Allow AOP.
*
* @method _resizeStart
* @param {EventFacade} event The Event object
* @protected
*/
_resizeStart: function(event) {
var instance = this,
wrapper = instance.get(WRAPPER);
instance.handle = instance.get(ACTIVE_HANDLE);
instance.set(RESIZING, true);
instance._updateSurroundingInfo();
// create an originalInfo information for reference
instance.originalInfo = instance._getInfo(wrapper, event);
instance._updateInfo(event);
},
/**
* Fires the resize:mouseUp event.
*
* @method _handleMouseUpEvent
* @param {EventFacade} event resize:mouseUp event facade
* @protected
*/
_handleMouseUpEvent: function(event) {
this.fire(EV_MOUSE_UP, { dragEvent: event, info: this.info });
},
/**
* Fires the resize:resize event.
*
* @method _handleResizeEvent
* @param {EventFacade} event resize:resize event facade
* @protected
*/
_handleResizeEvent: function(event) {
this.fire(EV_RESIZE, { dragEvent: event, info: this.info });
},
/**
* Fires the resize:align event.
*
* @method _handleResizeAlignEvent
* @param {EventFacade} event resize:resize event facade
* @protected
*/
_handleResizeAlignEvent: function(event) {
this.fire(EV_RESIZE_ALIGN, { dragEvent: event, info: this.info });
},
/**
* Fires the resize:end event.
*
* @method _handleResizeEndEvent
* @param {EventFacade} event resize:end event facade
* @protected
*/
_handleResizeEndEvent: function(event) {
this.fire(EV_RESIZE_END, { dragEvent: event, info: this.info });
},
/**
* Fires the resize:start event.
*
* @method _handleResizeStartEvent
* @param {EventFacade} event resize:start event facade
* @protected
*/
_handleResizeStartEvent: function(event) {
if (!this.get(ACTIVE_HANDLE)) {
//This handles the "touch" case
this._setHandleFromNode(event.target.get('node'));
}
this.fire(EV_RESIZE_START, { dragEvent: event, info: this.info });
},
/**
* Mouseenter event handler for the wrapper.
*
* @method _onWrapperMouseEnter
* @param {EventFacade} event
* @protected
*/
_onWrapperMouseEnter: function() {
var instance = this;
if (instance.get(AUTO_HIDE)) {
instance._setHideHandlesUI(false);
}
},
/**
* Mouseleave event handler for the wrapper.
*
* @method _onWrapperMouseLeave
* @param {EventFacade} event
* @protected
*/
_onWrapperMouseLeave: function() {
var instance = this;
if (instance.get(AUTO_HIDE)) {
instance._setHideHandlesUI(true);
}
},
/**
* Handles setting the activeHandle from a node, used from startDrag (for touch) and mouseenter (for mouse).
*
* @method _setHandleFromNode
* @param {Node} node
* @protected
*/
_setHandleFromNode: function(node) {
var instance = this,
handle = instance._extractHandleName(node);
if (!instance.get(RESIZING)) {
instance.set(ACTIVE_HANDLE, handle);
instance.set(ACTIVE_HANDLE_NODE, node);
instance._setActiveHandlesUI(true);
instance._updateChangeHandleInfo(handle);
}
},
/**
* Mouseenter event handler for the handles.
*
* @method _onHandleMouseEnter
* @param {EventFacade} event
* @protected
*/
_onHandleMouseEnter: function(event) {
this._setHandleFromNode(event.currentTarget);
},
/**
* Mouseout event handler for the handles.
*
* @method _onHandleMouseLeave
* @param {EventFacade} event
* @protected
*/
_onHandleMouseLeave: function() {
var instance = this;
if (!instance.get(RESIZING)) {
instance._setActiveHandlesUI(false);
}
},
/**
* Default value for the wrapper handles node attribute
*
* @method _valueHandlesWrapper
* @protected
* @readOnly
*/
_valueHandlesWrapper: function() {
return Y.Node.create(this.HANDLES_WRAP_TEMPLATE);
},
/**
* Default value for the wrapper attribute
*
* @method _valueWrapper
* @protected
* @readOnly
*/
_valueWrapper: function() {
var instance = this,
node = instance.get(NODE),
pNode = node.get(PARENT_NODE),
// by deafult the wrapper is always the node
wrapper = node;
// if the node is listed on the wrapTypes or wrap is set to true, create another wrapper
if (instance.get(WRAP)) {
wrapper = Y.Node.create(instance.WRAP_TEMPLATE);
if (pNode) {
pNode.insertBefore(wrapper, node);
}
wrapper.append(node);
instance._copyStyles(node, wrapper);
// remove positioning of wrapped node, the WRAPPER take care about positioning
node.setStyles({
position: STATIC,
left: 0,
top: 0
});
}
return wrapper;
}
}
);
Y.each(Y.Resize.prototype.ALL_HANDLES, function(handle) {
// creating ATTRS with the handles elements
Y.Resize.ATTRS[handleAttrName(handle)] = {
setter: function() {
return this._buildHandle(handle);
},
value: null,
writeOnce: true
};
});
}, '3.17.2', {"requires": ["base", "widget", "event", "oop", "dd-drag", "dd-delegate", "dd-drop"], "skinnable": true});