/**
                                 * Plugin for dd-drag for creating a proxy drag node, instead of dragging the original node.
                                 * @module dd
                                 * @submodule dd-proxy
                                 */
                                /**
                                 * Plugin for dd-drag for creating a proxy drag node, instead of dragging the original node.
                                 * @class DDProxy
                                 * @extends Base
                                 * @constructor
                                 * @namespace Plugin
                                 */
                                var DDM = Y.DD.DDM,
                                    NODE = 'node',
                                    DRAG_NODE = 'dragNode',
                                    HOST = 'host',
                                    TRUE = true, proto,
                                    P = function() {
                                        P.superclass.constructor.apply(this, arguments);
                                    };
                            
                                P.NAME = 'DDProxy';
                                /**
                                * The Proxy instance will be placed on the Drag instance under the proxy namespace.
                                * @property NS
                                * @default con
                                * @readonly
                                * @protected
                                * @static
                                * @type {String}
                                */
                                P.NS = 'proxy';
                            
                                P.ATTRS = {
                                    host: {
                                    },
                                    /**
                                    * Move the original node at the end of the drag. Default: true
                                    * @attribute moveOnEnd
                                    * @type Boolean
                                    */
                                    moveOnEnd: {
                                        value: TRUE
                                    },
                                    /**
                                    * Hide the drag node at the end of the drag. Default: true
                                    * @attribute hideOnEnd
                                    * @type Boolean
                                    */
                                    hideOnEnd: {
                                        value: TRUE
                                    },
                                    /**
                                    * Make the Proxy node assume the size of the original node. Default: true
                                    * @attribute resizeFrame
                                    * @type Boolean
                                    */
                                    resizeFrame: {
                                        value: TRUE
                                    },
                                    /**
                                    * Make the Proxy node appear in the same place as the original node. Default: true
                                    * @attribute positionProxy
                                    * @type Boolean
                                    */
                                    positionProxy: {
                                        value: TRUE
                                    },
                                    /**
                                    * The default border style for the border of the proxy. Default: 1px solid #808080
                                    * @attribute borderStyle
                                    * @type Boolean
                                    */
                                    borderStyle: {
                                        value: '1px solid #808080'
                                    },
                                    /**
                                    * Should the node be cloned into the proxy for you. Default: false
                                    * @attribute cloneNode
                                    * @type Boolean
                                    */
                                    cloneNode: {
                                        value: false
                                    }
                                };
                            
                                proto = {
                                    /**
                                    * Holds the event handles for setting the proxy
                                    * @private
                                    * @property _hands
                                    */
                                    _hands: null,
                                    /**
                                    * Handler for the proxy config attribute
                                    * @private
                                    * @method _init
                                    */
                                    _init: function() {
                                        if (!DDM._proxy) {
                                            DDM._createFrame();
                                            Y.on('domready', Y.bind(this._init, this));
                                            return;
                                        }
                                        if (!this._hands) {
                                            this._hands = [];
                                        }
                                        var h, h1, host = this.get(HOST), dnode = host.get(DRAG_NODE);
                                        if (dnode.compareTo(host.get(NODE))) {
                                            if (DDM._proxy) {
                                                host.set(DRAG_NODE, DDM._proxy);
                                            }
                                        }
                                        Y.Array.each(this._hands, function(v) {
                                            v.detach();
                                        });
                                        h = DDM.on('ddm:start', Y.bind(function() {
                                            if (DDM.activeDrag === host) {
                                                DDM._setFrame(host);
                                            }
                                        }, this));
                                        h1 = DDM.on('ddm:end', Y.bind(function() {
                                            if (host.get('dragging')) {
                                                if (this.get('moveOnEnd')) {
                                                    host.get(NODE).setXY(host.lastXY);
                                                }
                                                if (this.get('hideOnEnd')) {
                                                    host.get(DRAG_NODE).setStyle('display', 'none');
                                                }
                                                if (this.get('cloneNode')) {
                                                    host.get(DRAG_NODE).remove();
                                                    host.set(DRAG_NODE, DDM._proxy);
                                                }
                                            }
                                        }, this));
                                        this._hands = [h, h1];
                                    },
                                    initializer: function() {
                                        this._init();
                                    },
                                    destructor: function() {
                                        var host = this.get(HOST);
                                        Y.Array.each(this._hands, function(v) {
                                            v.detach();
                                        });
                                        host.set(DRAG_NODE, host.get(NODE));
                                    },
                                    clone: function() {
                                        var host = this.get(HOST),
                                            n = host.get(NODE),
                                            c = n.cloneNode(true);
                            
                                        c.all('input[type="radio"]').removeAttribute('name');
                            
                                        delete c._yuid;
                                        c.setAttribute('id', Y.guid());
                                        c.setStyle('position', 'absolute');
                                        n.get('parentNode').appendChild(c);
                                        host.set(DRAG_NODE, c);
                                        return c;
                                    }
                                };
                            
                                Y.namespace('Plugin');
                                Y.extend(P, Y.Base, proto);
                                Y.Plugin.DDProxy = P;
                            
                                //Add a couple of methods to the DDM
                                Y.mix(DDM, {
                                    /**
                                    * Create the proxy element if it doesn't already exist and set the DD.DDM._proxy value
                                    * @private
                                    * @for DDM
                                    * @namespace DD
                                    * @method _createFrame
                                    */
                                    _createFrame: function() {
                                        if (!DDM._proxy) {
                                            DDM._proxy = TRUE;
                            
                                            var p = Y.Node.create('<div></div>'),
                                            b = Y.one('body');
                            
                                            p.setStyles({
                                                position: 'absolute',
                                                display: 'none',
                                                zIndex: '999',
                                                top: '-999px',
                                                left: '-999px'
                                            });
                            
                                            b.prepend(p);
                                            p.set('id', Y.guid());
                                            p.addClass(DDM.CSS_PREFIX + '-proxy');
                                            DDM._proxy = p;
                                        }
                                    },
                                    /**
                                    * If resizeProxy is set to true (default) it will resize the proxy element to match the size of the Drag Element.
                                    * If positionProxy is set to true (default) it will position the proxy element in the same location as the Drag Element.
                                    * @private
                                    * @for DDM
                                    * @namespace DD
                                    * @method _setFrame
                                    */
                                    _setFrame: function(drag) {
                                        var n = drag.get(NODE), d = drag.get(DRAG_NODE), ah, cur = 'auto';
                            
                                        ah = DDM.activeDrag.get('activeHandle');
                                        if (ah) {
                                            cur = ah.getStyle('cursor');
                                        }
                                        if (cur === 'auto') {
                                            cur = DDM.get('dragCursor');
                                        }
                            
                                        d.setStyles({
                                            visibility: 'hidden',
                                            display: 'block',
                                            cursor: cur,
                                            border: drag.proxy.get('borderStyle')
                                        });
                            
                                        if (drag.proxy.get('cloneNode')) {
                                            d = drag.proxy.clone();
                                        }
                            
                                        if (drag.proxy.get('resizeFrame')) {
                                            d.setStyles({
                                                height: n.get('offsetHeight') + 'px',
                                                width: n.get('offsetWidth') + 'px'
                                            });
                                        }
                            
                                        if (drag.proxy.get('positionProxy')) {
                                            d.setXY(drag.nodeXY);
                                        }
                                        d.setStyle('visibility', 'visible');
                                    }
                                });
                            
                                //Create the frame when DOM is ready
                                //Y.on('domready', Y.bind(DDM._createFrame, DDM));