topical media & game development

topical media & game development

[] readme course(s) preface I 1 2 II 3 4 III 5 6 7 IV 8 9 10 V 11 12 afterthought(s) appendix reference(s) example(s) resource(s) _

lib-present-jquery-desktop-basic-steps-lib-jquery-ui-core-drag-drop-select-1.5.3.js / js


  /*
   * jQuery UI 1.5.3
   *
   * Copyright (c) 2008 Paul Bakaus (ui.jquery.com)
   * Dual licensed under the MIT (MIT-LICENSE.txt)
   * and GPL (GPL-LICENSE.txt) licenses.
   *
   * http://docs.jquery.com/UI
   */
  ;(function( $) {$ .ui = {
          plugin: {
                  add: function(module, option, set) {
                          var proto =  $.ui[module].prototype;
                          for(var i in set) {
                                  proto.plugins[i] = proto.plugins[i] || [];
                                  proto.plugins[i].push([option, set[i]]);
                          }
                  },
                  call: function(instance, name, args) {
                          var set = instance.plugins[name];
                          if(!set) { return; }
                          
                          for (var i = 0; i < set.length; i++) {
                                  if (instance.options[set[i][0]]) {
                                          set[i][1].apply(instance.element, args);
                                  }
                          }
                  }        
          },
          cssCache: {},
          css: function(name) {
                  if ($ .ui.cssCache[name]) { return  $.ui.cssCache[name]; }
                  var tmp = $('$ <div class="ui-gen">').addClass(name).css({position:'absolute', top:'-5000px', left:'-5000px', display:'block'}).appendTo('body');
                  
                  //if (!.browser.safari)
                          //tmp.appendTo('body'); 
                  
                  //Opera and Safari set width and height to 0px instead of auto
                  //Safari returns rgba(0,0,0,0) when bgcolor is not set
                   $.ui.cssCache[name] = !!(
                          (!(/auto|default/).test(tmp.css('cursor')) || (/^[1-9]/).test(tmp.css('height')) || (/^[1-9]/).test(tmp.css('width')) || 
                          !(/none/).test(tmp.css('backgroundImage')) || !(/transparent|rgba\(0, 0, 0, 0\)/).test(tmp.css('backgroundColor')))
                  );
                  try { $('body').get(0).removeChild(tmp.get(0));        } catch(e){}
                  return$ .ui.cssCache[name];
          },
          disableSelection: function(el) {
                  el.attr('unselectable', 'on').css('MozUserSelect', 'none');
          },
          enableSelection: function(el) {
                  el.attr('unselectable', 'off').css('MozUserSelect', '');
          },
          hasScroll: function(e, a) {
                  var scroll = /top/.test(a||"top") ? 'scrollTop' : 'scrollLeft', has = false;
                  if (e[scroll] > 0) return true; e[scroll] = 1;
                  has = e[scroll] > 0 ? true : false; e[scroll] = 0;
                  return has;
          }
  };

jQuery core modifications and additions *


  
  
  var _remove =  $.fn.remove;$ .fn.remove = function() {
          $("*", this).add(this).triggerHandler("remove");
          return _remove.apply(this, arguments );
  };
  
  //  $.widget is a factory to create jQuery plugins
  // taking some boilerplate code out of the plugin code
  // created by Scott González and Jörn Zaefferer
  function getter(namespace, plugin, method) {
          var methods =$ [namespace][plugin].getter || [];
          methods = (typeof methods == "string" ? methods.split(/,?\s+/) : methods);
          return ( $.inArray(method, methods) != -1);
  }$ .widget = function(name, prototype) {
          var namespace = name.split(".")[0];
          name = name.split(".")[1];
          
          // create plugin method
           $.fn[name] = function(options) {
                  var isMethodCall = (typeof options == 'string'),
                          args = Array.prototype.slice.call(arguments, 1);
                  
                  if (isMethodCall && getter(namespace, name, options)) {
                          var instance =$ .data(this[0], name);
                          return (instance ? instance[options].apply(instance, args)
                                  : undefined);
                  }
                  
                  return this.each(function() {
                          var instance =  $.data(this, name);
                          if (isMethodCall && instance &&$ .isFunction(instance[options])) {
                                  instance[options].apply(instance, args);
                          } else if (!isMethodCall) {
                                   $.data(this, name, new$ [namespace][name](this, options));
                          }
                  });
          };
          
          // create widget constructor
           $[namespace][name] = function(element, options) {
                  var self = this;
                  
                  this.widgetName = name;
                  this.widgetBaseClass = namespace + '-' + name;
                  
                  this.options =$ .extend({},  $.widget.defaults,$ [namespace][name].defaults, options);
                  this.element = element
                          .bind('setData.' + name, function(e, key, value) {
                                  return self.setData(key, value);
                          })
                          .bind('getData.' + name, function(e, key) {
                                  return self.getData(key);
                          })
                          .bind('remove', function() {
                                  return self.destroy();
                          });
                  this.init();
          };
          
          // add widget prototype
           $[namespace][name].prototype =$ .extend({},  $.widget.prototype, prototype);$ };
  
  .widget.prototype = {
          init: function() {},
          destroy: function() {
                  this.element.removeData(this.widgetName);
          },
          
          getData: function(key) {
                  return this.options[key];
          },
          setData: function(key, value) {
                  this.options[key] = value;
                  
                  if (key == 'disabled') {
                          this.element[value ? 'addClass' : 'removeClass'](
                                  this.widgetBaseClass + '-disabled');
                  }
          },
          
          enable: function() {
                  this.setData('disabled', false);
          },
          disable: function() {
                  this.setData('disabled', true);
          }
  };
  
   $.widget.defaults = {
          disabled: false$ };

Mouse Interaction Plugin *


  
  
  .ui.mouse = {
          mouseInit: function() {
                  var self = this;
          
                  this.element.bind('mousedown.'+this.widgetName, function(e) {
                          return self.mouseDown(e);
                  });
                  
                  // Prevent text selection in IE
                  if ( $.browser.msie) {
                          this._mouseUnselectable = this.element.attr('unselectable');
                          this.element.attr('unselectable', 'on');
                  }
                  
                  this.started = false;
          },
          
          // TODO: make sure destroying one instance of mouse doesn't mess with
          // other instances of mouse
          mouseDestroy: function() {
                  this.element.unbind('.'+this.widgetName);
                  
                  // Restore text selection in IE
                  ($ .browser.msie
                          && this.element.attr('unselectable', this._mouseUnselectable));
          },
          
          mouseDown: function(e) {
                  // we may have missed mouseup (out of window)
                  (this._mouseStarted && this.mouseUp(e));
                  
                  this._mouseDownEvent = e;
                  
                  var self = this,
                          btnIsLeft = (e.which == 1),
                          elIsCancel = (typeof this.options.cancel == "string" ? $(e.target).parents().add(e.target).filter(this.options.cancel).length : false);
                  if (!btnIsLeft || elIsCancel || !this.mouseCapture(e)) {
                          return true;
                  }
                  
                  this._mouseDelayMet = !this.options.delay;
                  if (!this._mouseDelayMet) {
                          this._mouseDelayTimer = setTimeout(function() {
                                  self._mouseDelayMet = true;
                          }, this.options.delay);
                  }
                  
                  if (this.mouseDistanceMet(e) && this.mouseDelayMet(e)) {
                          this._mouseStarted = (this.mouseStart(e) !== false);
                          if (!this._mouseStarted) {
                                  e.preventDefault();
                                  return true;
                          }
                  }
                  
                  // these delegates are required to keep context
                  this._mouseMoveDelegate = function(e) {
                          return self.mouseMove(e);
                  };
                  this._mouseUpDelegate = function(e) {
                          return self.mouseUp(e);
                  };
                  document
                          .bind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
                          .bind('mouseup.'+this.widgetName, this._mouseUpDelegate);
                  
                  return false;
          },
          
          mouseMove: function(e) {
                  // IE mouseup check - mouseup happened when mouse was out of window
                  if ( $.browser.msie && !e.button) {
                          return this.mouseUp(e);
                  }
                  
                  if (this._mouseStarted) {
                          this.mouseDrag(e);
                          return false;
                  }
                  
                  if (this.mouseDistanceMet(e) && this.mouseDelayMet(e)) {
                          this._mouseStarted =
                                  (this.mouseStart(this._mouseDownEvent, e) !== false);
                          (this._mouseStarted ? this.mouseDrag(e) : this.mouseUp(e));
                  }
                  
                  return !this._mouseStarted;
          },
          
          mouseUp: function(e) {
                  document
                          .unbind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
                          .unbind('mouseup.'+this.widgetName, this._mouseUpDelegate);
                  
                  if (this._mouseStarted) {
                          this._mouseStarted = false;
                          this.mouseStop(e);
                  }
                  
                  return false;
          },
          
          mouseDistanceMet: function(e) {
                  return (Math.max(
                                  Math.abs(this._mouseDownEvent.pageX - e.pageX),
                                  Math.abs(this._mouseDownEvent.pageY - e.pageY)
                          ) >= this.options.distance
                  );
          },
          
          mouseDelayMet: function(e) {
                  return this._mouseDelayMet;
          },
          
          // These are placeholder methods, to be overriden by extending plugin
          mouseStart: function(e) {},
          mouseDrag: function(e) {},
          mouseStop: function(e) {},
          mouseCapture: function(e) { return true; }$ };
  
  .ui.mouse.defaults = {
          cancel: null,
          distance: 1,
          delay: 0
  };
  
  })(jQuery);
  /*
   * jQuery UI Draggable
   *
   * Copyright (c) 2008 Paul Bakaus
   * Dual licensed under the MIT (MIT-LICENSE.txt)
   * and GPL (GPL-LICENSE.txt) licenses.
   * 
   * http://docs.jquery.com/UI/Draggables
   *
   * Depends:
   *        ui.core.js
   */
  (function( $) {$ .widget("ui.draggable",  $.extend({},$ .ui.mouse, {
          init: function() {
                  
                  //Initialize needed constants
                  var o = this.options;
  
                  //Position the node
                  if (o.helper == 'original' && !(/(relative|absolute|fixed)/).test(this.element.css('position')))
                          this.element.css('position', 'relative');
  
                  this.element.addClass('ui-draggable');
                  (o.disabled && this.element.addClass('ui-draggable-disabled'));
                  
                  this.mouseInit();
                  
          },
          mouseStart: function(e) {
                  var o = this.options;
                  
                  if (this.helper || o.disabled || $(e.target).is('.ui-resizable-handle')) return false;
                  
                  var handle = !this.options.handle || !$(this.options.handle, this.element).length ? true : false;
                  
          
                  $(this.options.handle, this.element).find("*").andSelf().each(function() {
                          if(this == e.target) handle = true;
                  });
                  if (!handle) return false;
                  
                  if( $.ui.ddmanager)$ .ui.ddmanager.current = this;
                  
                  //Create and append the visible helper
                  this.helper =  $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [e])) : (o.helper == 'clone' ? this.element.clone() : this.element);
                  if(!this.helper.parents('body').length) this.helper.appendTo((o.appendTo == 'parent' ? this.element[0].parentNode : o.appendTo));
                  if(this.helper[0] != this.element[0] && !(/(fixed|absolute)/).test(this.helper.css("position"))) this.helper.css("position", "absolute");$ /*
  		 * - Position generation -
  		 * This block generates everything position related - it's the core of draggables.
  		 */
                  
                  this.margins = {                                                                                                                                                                //Cache the margins
                          left: (parseInt(this.element.css("marginLeft"),10) || 0),
                          top: (parseInt(this.element.css("marginTop"),10) || 0)
                  };                
                  
                  this.cssPosition = this.helper.css("position");                                                                                                        //Store the helper's css position
                  this.offset = this.element.offset();                                                                                                                        //The element's absolute position on the page
                  this.offset = {                                                                                                                                                                        //Substract the margins from the element's absolute offset
                          top: this.offset.top - this.margins.top,
                          left: this.offset.left - this.margins.left
                  };
                  
                  this.offset.click = {                                                                                                                                                        //Where the click happened, relative to the element
                          left: e.pageX - this.offset.left,
                          top: e.pageY - this.offset.top
                  };
                  
                  this.offsetParent = this.helper.offsetParent(); var po = this.offsetParent.offset();                        //Get the offsetParent and cache its position
                  if(this.offsetParent[0] == document.body && .browser.mozilla) po = { top: 0, left: 0 };                //Ugly FF3 fix
                  this.offset.parent = {                                                                                                                                                        //Store its position plus border
                          top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
                          left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
                  };
                  
                  var p = this.element.position();                                                                                                                                //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helpers
                  this.offset.relative = this.cssPosition == "relative" ? {
                          top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.offsetParent[0].scrollTop,
                          left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.offsetParent[0].scrollLeft
                  } : { top: 0, left: 0 };
                  
                  this.originalPosition = this.generatePosition(e);                                                                                                //Generate the original position
                  this.helperProportions = { width: this.helper.outerWidth(), height: this.helper.outerHeight() };//Cache the helper size
                  
                  if(o.cursorAt) {
                          if(o.cursorAt.left != undefined) this.offset.click.left = o.cursorAt.left + this.margins.left;
                          if(o.cursorAt.right != undefined) this.offset.click.left = this.helperProportions.width - o.cursorAt.right + this.margins.left;
                          if(o.cursorAt.top != undefined) this.offset.click.top = o.cursorAt.top + this.margins.top;
                          if(o.cursorAt.bottom != undefined) this.offset.click.top = this.helperProportions.height - o.cursorAt.bottom + this.margins.top;
                  }
                  
                  
                  /*
  		 * - Position constraining -
  		 * Here we prepare position constraining like grid and containment.
  		 */        
                  
                  if(o.containment) {
                          if(o.containment == 'parent') o.containment = this.helper[0].parentNode;
                          if(o.containment == 'document' || o.containment == 'window') this.containment = [
                                  0 - this.offset.relative.left - this.offset.parent.left,
                                  0 - this.offset.relative.top - this.offset.parent.top,
                                  $(o.containment == 'document' ? document : window).width() - this.offset.relative.left - this.offset.parent.left - this.helperProportions.width - this.margins.left - (parseInt(this.element.css("marginRight"),10) || 0),
                                  ($(o.containment == 'document' ? document : window).height() || document.body.parentNode.scrollHeight) - this.offset.relative.top - this.offset.parent.top - this.helperProportions.height - this.margins.top - (parseInt(this.element.css("marginBottom"),10) || 0)
                          ];
                          
                          if(!(/^(document|window|parent) $/).test(o.containment)) {
                                  var ce = $(o.containment)[0];
                                  var co = $(o.containment).offset();
                                  
                                  this.containment = [
                                          co.left + (parseInt(ce.css("borderLeftWidth"),10) || 0) - this.offset.relative.left - this.offset.parent.left,
                                          co.top + (parseInt(ce.css("borderTopWidth"),10) || 0) - this.offset.relative.top - this.offset.parent.top,
                                          co.left+Math.max(ce.scrollWidth,ce.offsetWidth) - (parseInt(ce.css("borderLeftWidth"),10) || 0) - this.offset.relative.left - this.offset.parent.left - this.helperProportions.width - this.margins.left - (parseInt(this.element.css("marginRight"),10) || 0),
                                          co.top+Math.max(ce.scrollHeight,ce.offsetHeight) - (parseInt(ce.css("borderTopWidth"),10) || 0) - this.offset.relative.top - this.offset.parent.top - this.helperProportions.height - this.margins.top - (parseInt(this.element.css("marginBottom"),10) || 0)
                                  ];
                          }
                  }$ //Call plugins and callbacks
                  this.propagate("start", e);
                  
                  this.helperProportions = { width: this.helper.outerWidth(), height: this.helper.outerHeight() };//Recache the helper size
                  if (.ui.ddmanager && !o.dropBehaviour)  $.ui.ddmanager.prepareOffsets(this, e);
                  
                  this.helper.addClass("ui-draggable-dragging");
                  this.mouseDrag(e); //Execute the drag once - this causes the helper not to be visible before getting its correct position
                  return true;
          },
          convertPositionTo: function(d, pos) {
                  if(!pos) pos = this.position;
                  var mod = d == "absolute" ? 1 : -1;
                  return {
                          top: (
                                  pos.top                                                                                                                                        // the calculated relative position
                                  + this.offset.relative.top        * mod                                                                                // Only for relative positioned nodes: Relative offset from element to offset parent
                                  + this.offset.parent.top * mod                                                                                        // The offsetParent's offset without borders (offset + border)
                                  - (this.cssPosition == "fixed" || (this.cssPosition == "absolute" && this.offsetParent[0] == document.body) ? 0 : this.offsetParent[0].scrollTop) * mod        // The offsetParent's scroll position, not if the element is fixed
                                  + (this.cssPosition == "fixed" ? document.scrollTop() : 0) * mod
                                  + this.margins.top * mod                                                                                                //Add the margin (you don't want the margin counting in intersection methods)
                          ),
                          left: (
                                  pos.left                                                                                                                                // the calculated relative position
                                  + this.offset.relative.left        * mod                                                                                // Only for relative positioned nodes: Relative offset from element to offset parent
                                  + this.offset.parent.left * mod                                                                                        // The offsetParent's offset without borders (offset + border)
                                  - (this.cssPosition == "fixed" || (this.cssPosition == "absolute" && this.offsetParent[0] == document.body) ? 0 : this.offsetParent[0].scrollLeft) * mod        // The offsetParent's scroll position, not if the element is fixed
                                  + (this.cssPosition == "fixed" ? document.scrollLeft() : 0) * mod
                                  + this.margins.left * mod                                                                                                //Add the margin (you don't want the margin counting in intersection methods)
                          )$ };
          },
          generatePosition: function(e) {
                  
                  var o = this.options;
                  var position = {
                          top: (
                                  e.pageY                                                                                                                                        // The absolute mouse position
                                  - this.offset.click.top                                                                                                        // Click offset (relative to the element)
                                  - this.offset.relative.top                                                                                                // Only for relative positioned nodes: Relative offset from element to offset parent
                                  - this.offset.parent.top                                                                                                // The offsetParent's offset without borders (offset + border)
                                  + (this.cssPosition == "fixed" || (this.cssPosition == "absolute" && this.offsetParent[0] == document.body) ? 0 : this.offsetParent[0].scrollTop)        // The offsetParent's scroll position, not if the element is fixed
                                  - (this.cssPosition == "fixed" ? document.scrollTop() : 0)
                          ),
                          left: (
                                  e.pageX                                                                                                                                        // The absolute mouse position
                                  - this.offset.click.left                                                                                                // Click offset (relative to the element)
                                  - this.offset.relative.left                                                                                                // Only for relative positioned nodes: Relative offset from element to offset parent
                                  - this.offset.parent.left                                                                                                // The offsetParent's offset without borders (offset + border)
                                  + (this.cssPosition == "fixed" || (this.cssPosition == "absolute" && this.offsetParent[0] == document.body) ? 0 : this.offsetParent[0].scrollLeft)        // The offsetParent's scroll position, not if the element is fixed
                                  - (this.cssPosition == "fixed" ? document.scrollLeft() : 0)
                          )
                  };
                  
                  if(!this.originalPosition) return position;                                                                                //If we are not dragging yet, we won't check for options
                  
                  /*
  		 * - Position constraining -
  		 * Constrain the position to a mix of grid, containment.
  		 */
                  if(this.containment) {
                          if(position.left < this.containment[0]) position.left = this.containment[0];
                          if(position.top < this.containment[1]) position.top = this.containment[1];
                          if(position.left > this.containment[2]) position.left = this.containment[2];
                          if(position.top > this.containment[3]) position.top = this.containment[3];
                  }
                  
                  if(o.grid) {
                          var top = this.originalPosition.top + Math.round((position.top - this.originalPosition.top) / o.grid[1]) * o.grid[1];
                          position.top = this.containment ? (!(top < this.containment[1] || top > this.containment[3]) ? top : (!(top < this.containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
                          
                          var left = this.originalPosition.left + Math.round((position.left - this.originalPosition.left) / o.grid[0]) * o.grid[0];
                          position.left = this.containment ? (!(left < this.containment[0] || left > this.containment[2]) ? left : (!(left < this.containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
                  }
                  
                  return position;
          },
          mouseDrag: function(e) {
                  
                  //Compute the helpers position
                  this.position = this.generatePosition(e);
                  this.positionAbs = this.convertPositionTo("absolute");
                  
                  //Call plugins and callbacks and use the resulting position if something is returned                
                  this.position = this.propagate("drag", e) || this.position;
                  
                  if(!this.options.axis || this.options.axis != "y") this.helper[0].style.left = this.position.left+'px';
                  if(!this.options.axis || this.options.axis != "x") this.helper[0].style.top = this.position.top+'px';
                  if(.ui.ddmanager)  $.ui.ddmanager.drag(this, e);
                  
                  return false;
          },
          mouseStop: function(e) {
                  
                  //If we are using droppables, inform the manager about the drop
                  var dropped = false;
                  if ($ .ui.ddmanager && !this.options.dropBehaviour)
                          var dropped =  $.ui.ddmanager.drop(this, e);                
                  
                  if((this.options.revert == "invalid" && !dropped) || (this.options.revert == "valid" && dropped) || this.options.revert === true) {
                          var self = this;
                          $(this.helper).animate(this.originalPosition, parseInt(this.options.revert, 10) || 500, function() {
                                  self.propagate("stop", e);
                                  self.clear();
                          });
                  } else {
                          this.propagate("stop", e);
                          this.clear();
                  }
                  
                  return false;
          },
          clear: function() {
                  this.helper.removeClass("ui-draggable-dragging");
                  if(this.options.helper != 'original' && !this.cancelHelperRemoval) this.helper.remove();
                  //if($ .ui.ddmanager)  $.ui.ddmanager.current = null;
                  this.helper = null;
                  this.cancelHelperRemoval = false;
          },
          
          // From now on bulk stuff - mainly helpers
          plugins: {},
          uiHash: function(e) {
                  return {
                          helper: this.helper,
                          position: this.position,
                          absolutePosition: this.positionAbs,
                          options: this.options$ };
          },
          propagate: function(n,e) {
                  .ui.plugin.call(this, n, [e, this.uiHash()]);
                  if(n == "drag") this.positionAbs = this.convertPositionTo("absolute"); //The absolute position has to be recalculated after plugins
                  return this.element.triggerHandler(n == "drag" ? n : "drag"+n, [e, this.uiHash()], this.options[n]);
          },
          destroy: function() {
                  if(!this.element.data('draggable')) return;
                  this.element.removeData("draggable").unbind(".draggable").removeClass('ui-draggable');
                  this.mouseDestroy();
          }
  }));
  
   $.extend($ .ui.draggable, {
          defaults: {
                  appendTo: "parent",
                  axis: false,
                  cancel: ":input",
                  delay: 0,
                  distance: 1,
                  helper: "original"
          }
  });
  
   $.ui.plugin.add("draggable", "cursor", {
          start: function(e, ui) {
                  var t = $('body');
                  if (t.css("cursor")) ui.options._cursor = t.css("cursor");
                  t.css("cursor", ui.options.cursor);
          },
          stop: function(e, ui) {
                  if (ui.options._cursor) $('body').css("cursor", ui.options._cursor);
          }
  });$ .ui.plugin.add("draggable", "zIndex", {
          start: function(e, ui) {
                  var t = $(ui.helper);
                  if(t.css("zIndex")) ui.options._zIndex = t.css("zIndex");
                  t.css('zIndex', ui.options.zIndex);
          },
          stop: function(e, ui) {
                  if(ui.options._zIndex) $(ui.helper).css('zIndex', ui.options._zIndex);
          }
  });
  
   $.ui.plugin.add("draggable", "opacity", {
          start: function(e, ui) {
                  var t = $(ui.helper);
                  if(t.css("opacity")) ui.options._opacity = t.css("opacity");
                  t.css('opacity', ui.options.opacity);
          },
          stop: function(e, ui) {
                  if(ui.options._opacity) $(ui.helper).css('opacity', ui.options._opacity);
          }
  });$ .ui.plugin.add("draggable", "iframeFix", {
          start: function(e, ui) {
                  $(ui.options.iframeFix === true ? "iframe" : ui.options.iframeFix).each(function() {                                        
                          $('<div class="ui-draggable-iframeFix" style="background: #fff;"></div>')
                          .css({
                                  width: this.offsetWidth+"px", height: this.offsetHeight+"px",
                                  position: "absolute", opacity: "0.001", zIndex: 1000
                          })
                          .css(this.offset())
                          .appendTo("body");
                  });
          },
          stop: function(e, ui) {
                  $("div.DragDropIframeFix").each(function() { this.parentNode.removeChild(this); }); //Remove frame helpers        
          }
  });
  
   $.ui.plugin.add("draggable", "scroll", {
          start: function(e, ui) {
                  var o = ui.options;
                  var i = this.data("draggable");
                  o.scrollSensitivity        = o.scrollSensitivity || 20;
                  o.scrollSpeed                = o.scrollSpeed || 20;
                  
                  i.overflowY = function(el) {
                          do { if(/auto|scroll/.test(el.css('overflow')) || (/auto|scroll/).test(el.css('overflow-y'))) return el; el = el.parent(); } while (el[0].parentNode);
                          return document;
                  }(this);
                  i.overflowX = function(el) {
                          do { if(/auto|scroll/.test(el.css('overflow')) || (/auto|scroll/).test(el.css('overflow-x'))) return el; el = el.parent(); } while (el[0].parentNode);
                          return document;
                  }(this);
                  
                  if(i.overflowY[0] != document && i.overflowY[0].tagName != 'HTML') i.overflowYOffset = i.overflowY.offset();
                  if(i.overflowX[0] != document && i.overflowX[0].tagName != 'HTML') i.overflowXOffset = i.overflowX.offset();
                  
          },
          drag: function(e, ui) {
                  
                  var o = ui.options;
                  var i = this.data("draggable");
                  
                  if(i.overflowY[0] != document && i.overflowY[0].tagName != 'HTML') {
                          if((i.overflowYOffset.top + i.overflowY[0].offsetHeight) - e.pageY < o.scrollSensitivity)
                                  i.overflowY[0].scrollTop = i.overflowY[0].scrollTop + o.scrollSpeed;
                          if(e.pageY - i.overflowYOffset.top < o.scrollSensitivity)
                                  i.overflowY[0].scrollTop = i.overflowY[0].scrollTop - o.scrollSpeed;
                                                          
                  } else {
                          if(e.pageY - document.scrollTop() < o.scrollSensitivity)
                                  document.scrollTop(document.scrollTop() - o.scrollSpeed);
                          if(window.height() - (e.pageY - document.scrollTop()) < o.scrollSensitivity)
                                  document.scrollTop(document.scrollTop() + o.scrollSpeed);
                  }
                  
                  if(i.overflowX[0] != document && i.overflowX[0].tagName != 'HTML') {
                          if((i.overflowXOffset.left + i.overflowX[0].offsetWidth) - e.pageX < o.scrollSensitivity)
                                  i.overflowX[0].scrollLeft = i.overflowX[0].scrollLeft + o.scrollSpeed;
                          if(e.pageX - i.overflowXOffset.left < o.scrollSensitivity)
                                  i.overflowX[0].scrollLeft = i.overflowX[0].scrollLeft - o.scrollSpeed;
                  } else {
                          if(e.pageX - document.scrollLeft() < o.scrollSensitivity)
                                  document.scrollLeft(document.scrollLeft() - o.scrollSpeed);
                          if(window.width() - (e.pageX - document.scrollLeft()) < o.scrollSensitivity)
                                  document.scrollLeft(document.scrollLeft() + o.scrollSpeed);
                  }
                  
          }
  });$ .ui.plugin.add("draggable", "snap", {
          start: function(e, ui) {
                  
                  var inst = this.data("draggable");
                  inst.snapElements = [];
                  $(ui.options.snap === true ? '.ui-draggable' : ui.options.snap).each(function() {
                          var  $t = this; var$ o =  $t.offset();
                          if(this != inst.element[0]) inst.snapElements.push({
                                  item: this,
                                  width:$ t.outerWidth(), height:  $t.outerHeight(),
                                  top:$ o.top, left:  $o.left
                          });
                  });
                  
          },
          drag: function(e, ui) {
                  
                  var inst = this.data("draggable");
                  var d = ui.options.snapTolerance || 20;
                  var x1 = ui.absolutePosition.left, x2 = x1 + inst.helperProportions.width,
                          y1 = ui.absolutePosition.top, y2 = y1 + inst.helperProportions.height;
                  
                  for (var i = inst.snapElements.length - 1; i >= 0; i--){
                          
                          var l = inst.snapElements[i].left, r = l + inst.snapElements[i].width, 
                                  t = inst.snapElements[i].top, b = t + inst.snapElements[i].height;
                          
                          //Yes, I know, this is insane ;)
                          if(!((l-d < x1 && x1 < r+d && t-d < y1 && y1 < b+d) || (l-d < x1 && x1 < r+d && t-d < y2 && y2 < b+d) || (l-d < x2 && x2 < r+d && t-d < y1 && y1 < b+d) || (l-d < x2 && x2 < r+d && t-d < y2 && y2 < b+d))) continue;
                          
                          if(ui.options.snapMode != 'inner') {
                                  var ts = Math.abs(t - y2) <= 20;
                                  var bs = Math.abs(b - y1) <= 20;
                                  var ls = Math.abs(l - x2) <= 20;
                                  var rs = Math.abs(r - x1) <= 20;
                                  if(ts) ui.position.top = inst.convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top;
                                  if(bs) ui.position.top = inst.convertPositionTo("relative", { top: b, left: 0 }).top;
                                  if(ls) ui.position.left = inst.convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left;
                                  if(rs) ui.position.left = inst.convertPositionTo("relative", { top: 0, left: r }).left;
                          }
                          
                          if(ui.options.snapMode != 'outer') {
                                  var ts = Math.abs(t - y1) <= 20;
                                  var bs = Math.abs(b - y2) <= 20;
                                  var ls = Math.abs(l - x1) <= 20;
                                  var rs = Math.abs(r - x2) <= 20;
                                  if(ts) ui.position.top = inst.convertPositionTo("relative", { top: t, left: 0 }).top;
                                  if(bs) ui.position.top = inst.convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top;
                                  if(ls) ui.position.left = inst.convertPositionTo("relative", { top: 0, left: l }).left;
                                  if(rs) ui.position.left = inst.convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left;
                          }$ };
          }
  });
  
  .ui.plugin.add("draggable", "connectToSortable", {
          start: function(e,ui) {
          
                  var inst = this.data("draggable");
                  inst.sortables = [];
                  $(ui.options.connectToSortable).each(function() {
                          if( $.data(this, 'sortable')) {
                                  var sortable =$ .data(this, 'sortable');
                                  inst.sortables.push({
                                          instance: sortable,
                                          shouldRevert: sortable.options.revert
                                  });
                                  sortable.refreshItems();        //Do a one-time refresh at start to refresh the containerCache        
                                  sortable.propagate("activate", e, inst);
                          }
                  });
  
          },
          stop: function(e,ui) {
                  
                  //If we are still over the sortable, we fake the stop event of the sortable, but also remove helper
                  var inst = this.data("draggable");
                  
                   $.each(inst.sortables, function() {
                          if(this.instance.isOver) {
                                  this.instance.isOver = 0;
                                  inst.cancelHelperRemoval = true; //Don't remove the helper in the draggable instance
                                  this.instance.cancelHelperRemoval = false; //Remove it in the sortable instance (so sortable plugins like revert still work)
                                  if(this.shouldRevert) this.instance.options.revert = true; //revert here
                                  this.instance.mouseStop(e);
                                  
                                  //Also propagate receive event, since the sortable is actually receiving a element
                                  this.instance.element.triggerHandler("sortreceive", [e,$ .extend(this.instance.ui(), { sender: inst.element })], this.instance.options["receive"]);
  
                                  this.instance.options.helper = this.instance.options._helper;
                          } else {
                                  this.instance.propagate("deactivate", e, inst);
                          }
  
                  });
                  
          },
          drag: function(e,ui) {
  
                  var inst = this.data("draggable"), self = this;
                  
                  var checkPos = function(o) {
                                  
                          var l = o.left, r = l + o.width,
                                  t = o.top, b = t + o.height;
  
                          return (l < (this.positionAbs.left + this.offset.click.left) && (this.positionAbs.left + this.offset.click.left) < r
                                          && t < (this.positionAbs.top + this.offset.click.top) && (this.positionAbs.top + this.offset.click.top) < b);                                
                  };
                  
                   $.each(inst.sortables, function(i) {
  
                          if(checkPos.call(inst, this.instance.containerCache)) {
  
                                  //If it intersects, we use a little isOver variable and set it once, so our move-in stuff gets fired only once
                                  if(!this.instance.isOver) {
                                          this.instance.isOver = 1;
  
                                          //Now we fake the start of dragging for the sortable instance,
                                          //by cloning the list group item, appending it to the sortable and using it as inst.currentItem
                                          //We can then fire the start event of the sortable with our passed browser event, and our own helper (so it doesn't create a new one)
                                          this.instance.currentItem = self.clone().appendTo(this.instance.element).data("sortable-item", true);
                                          this.instance.options._helper = this.instance.options.helper; //Store helper option to later restore it
                                          this.instance.options.helper = function() { return ui.helper[0];$ };
                                  
                                          e.target = this.instance.currentItem[0];
                                          this.instance.mouseCapture(e, true);
                                          this.instance.mouseStart(e, true, true);
  
                                          //Because the browser event is way off the new appended portlet, we modify a couple of variables to reflect the changes
                                          this.instance.offset.click.top = inst.offset.click.top;
                                          this.instance.offset.click.left = inst.offset.click.left;
                                          this.instance.offset.parent.left -= inst.offset.parent.left - this.instance.offset.parent.left;
                                          this.instance.offset.parent.top -= inst.offset.parent.top - this.instance.offset.parent.top;
                                          
                                          inst.propagate("toSortable", e);
                                  
                                  }
                                  
                                  //Provided we did all the previous steps, we can fire the drag event of the sortable on every draggable drag, when it intersects with the sortable
                                  if(this.instance.currentItem) this.instance.mouseDrag(e);
                                  
                          } else {
                                  
                                  //If it doesn't intersect with the sortable, and it intersected before,
                                  //we fake the drag stop of the sortable, but make sure it doesn't remove the helper by using cancelHelperRemoval
                                  if(this.instance.isOver) {
                                          this.instance.isOver = 0;
                                          this.instance.cancelHelperRemoval = true;
                                          this.instance.options.revert = false; //No revert here
                                          this.instance.mouseStop(e, true);
                                          this.instance.options.helper = this.instance.options._helper;
                                          
                                          //Now we remove our currentItem, the list group clone again, and the placeholder, and animate the helper back to it's original size
                                          this.instance.currentItem.remove();
                                          if(this.instance.placeholder) this.instance.placeholder.remove();
                                          
                                          inst.propagate("fromSortable", e);
                                  }
                                  
                          };
  
                  });
  
          }
  });
  
  .ui.plugin.add("draggable", "stack", {
          start: function(e,ui) {
                  var group =  $.makeArray($(ui.options.stack.group)).sort(function(a,b) {
                          return (parseInt(a.css("zIndex"),10) || ui.options.stack.min) - (parseInt(b.css("zIndex"),10) || ui.options.stack.min);
                  });
                  
                  group.each(function(i) {
                          this.style.zIndex = ui.options.stack.min + i;
                  });
                  
                  this[0].style.zIndex = ui.options.stack.min + group.length;
          }
  });
  
  })(jQuery);$ /*
   * jQuery UI Droppable
   *
   * Copyright (c) 2008 Paul Bakaus
   * Dual licensed under the MIT (MIT-LICENSE.txt)
   * and GPL (GPL-LICENSE.txt) licenses.
   * 
   * http://docs.jquery.com/UI/Droppables
   *
   * Depends:
   *        ui.core.js
   *        ui.draggable.js
   */
  (function() {
  
   $.widget("ui.droppable", {
          init: function() {
  
                  this.element.addClass("ui-droppable");
                  this.isover = 0; this.isout = 1;$ //Prepare the passed options
                  var o = this.options, accept = o.accept;
                  o = .extend(o, {
                          accept: o.accept && o.accept.constructor == Function ? o.accept : function(d) {
                                  return d.is(accept);
                          }
                  });
                  
                  //Store the droppable's proportions
                  this.proportions = { width: this.element[0].offsetWidth, height: this.element[0].offsetHeight };
                  
                  // Add the reference and positions to the manager
                   $.ui.ddmanager.droppables.push(this);
                  
          },
          plugins: {},
          ui: function(c) {
                  return {
                          draggable: (c.currentItem || c.element),
                          helper: c.helper,
                          position: c.position,
                          absolutePosition: c.positionAbs,
                          options: this.options,
                          element: this.element$ };
          },
          destroy: function() {
                  var drop = .ui.ddmanager.droppables;
                  for ( var i = 0; i < drop.length; i++ )
                          if ( drop[i] == this )
                                  drop.splice(i, 1);
                  
                  this.element
                          .removeClass("ui-droppable ui-droppable-disabled")
                          .removeData("droppable")
                          .unbind(".droppable");
          },
          over: function(e) {
                  
                  var draggable =  $.ui.ddmanager.current;
                  if (!draggable || (draggable.currentItem || draggable.element)[0] == this.element[0]) return; // Bail if draggable and droppable are same element
                  
                  if (this.options.accept.call(this.element,(draggable.currentItem || draggable.element))) {$ .ui.plugin.call(this, 'over', [e, this.ui(draggable)]);
                          this.element.triggerHandler("dropover", [e, this.ui(draggable)], this.options.over);
                  }
                  
          },
          out: function(e) {
                  
                  var draggable =  $.ui.ddmanager.current;
                  if (!draggable || (draggable.currentItem || draggable.element)[0] == this.element[0]) return; // Bail if draggable and droppable are same element
                  
                  if (this.options.accept.call(this.element,(draggable.currentItem || draggable.element))) {$ .ui.plugin.call(this, 'out', [e, this.ui(draggable)]);
                          this.element.triggerHandler("dropout", [e, this.ui(draggable)], this.options.out);
                  }
                  
          },
          drop: function(e,custom) {
                  
                  var draggable = custom ||  $.ui.ddmanager.current;
                  if (!draggable || (draggable.currentItem || draggable.element)[0] == this.element[0]) return false; // Bail if draggable and droppable are same element
                  
                  var childrenIntersection = false;
                  this.element.find(".ui-droppable").not(".ui-draggable-dragging").each(function() {
                          var inst =$ .data(this, 'droppable');
                          if(inst.options.greedy &&  $.ui.intersect(draggable,$ .extend(inst, { offset: inst.element.offset() }), inst.options.tolerance)) {
                                  childrenIntersection = true; return false;
                          }
                  });
                  if(childrenIntersection) return false;
                  
                  if(this.options.accept.call(this.element,(draggable.currentItem || draggable.element))) {
                           $.ui.plugin.call(this, 'drop', [e, this.ui(draggable)]);
                          this.element.triggerHandler("drop", [e, this.ui(draggable)], this.options.drop);
                          return true;
                  }
                  
                  return false;
                  
          },
          activate: function(e) {
                  
                  var draggable =$ .ui.ddmanager.current;
                   $.ui.plugin.call(this, 'activate', [e, this.ui(draggable)]);
                  if(draggable) this.element.triggerHandler("dropactivate", [e, this.ui(draggable)], this.options.activate);
                  
          },
          deactivate: function(e) {
                  
                  var draggable =$ .ui.ddmanager.current;
                   $.ui.plugin.call(this, 'deactivate', [e, this.ui(draggable)]);
                  if(draggable) this.element.triggerHandler("dropdeactivate", [e, this.ui(draggable)], this.options.deactivate);
                  
          }
  });$ .extend( $.ui.droppable, {
          defaults: {
                  disabled: false,
                  tolerance: 'intersect'
          }
  });$ .ui.intersect = function(draggable, droppable, toleranceMode) {
          
          if (!droppable.offset) return false;
          
          var x1 = (draggable.positionAbs || draggable.position.absolute).left, x2 = x1 + draggable.helperProportions.width,
                  y1 = (draggable.positionAbs || draggable.position.absolute).top, y2 = y1 + draggable.helperProportions.height;
          var l = droppable.offset.left, r = l + droppable.proportions.width,
                  t = droppable.offset.top, b = t + droppable.proportions.height;
          
          switch (toleranceMode) {
                  case 'fit':
                          return (l < x1 && x2 < r
                                  && t < y1 && y2 < b);
                          break;
                  case 'intersect':
                          return (l < x1 + (draggable.helperProportions.width / 2) // Right Half
                                  && x2 - (draggable.helperProportions.width / 2) < r // Left Half
                                  && t < y1 + (draggable.helperProportions.height / 2) // Bottom Half
                                  && y2 - (draggable.helperProportions.height / 2) < b ); // Top Half
                          break;
                  case 'pointer':
                          return (l < ((draggable.positionAbs || draggable.position.absolute).left + (draggable.clickOffset || draggable.offset.click).left) && ((draggable.positionAbs || draggable.position.absolute).left + (draggable.clickOffset || draggable.offset.click).left) < r
                                  && t < ((draggable.positionAbs || draggable.position.absolute).top + (draggable.clickOffset || draggable.offset.click).top) && ((draggable.positionAbs || draggable.position.absolute).top + (draggable.clickOffset || draggable.offset.click).top) < b);
                          break;
                  case 'touch':
                          return (
                                          (y1 >= t && y1 <= b) ||        // Top edge touching
                                          (y2 >= t && y2 <= b) ||        // Bottom edge touching
                                          (y1 < t && y2 > b)                // Surrounded vertically
                                  ) && (
                                          (x1 >= l && x1 <= r) ||        // Left edge touching
                                          (x2 >= l && x2 <= r) ||        // Right edge touching
                                          (x1 < l && x2 > r)                // Surrounded horizontally
                                  );
                          break;
                  default:
                          return false;
                          break;
                  }
          
  };
  
  /*
          This manager tracks offsets of draggables and droppables
  */
   $.ui.ddmanager = {
          current: null,
          droppables: [],
          prepareOffsets: function(t, e) {
                  
                  var m =$ .ui.ddmanager.droppables;
                  var type = e ? e.type : null; // workaround for #2317
  
                  for (var i = 0; i < m.length; i++) {
                          if(m[i].options.disabled || (t && !m[i].options.accept.call(m[i].element,(t.currentItem || t.element)))) continue;
                          m[i].visible = m[i].element.css("display") != "none"; if(!m[i].visible) continue; //If the element is not visible, continue
                          m[i].offset = m[i].element.offset();
                          m[i].proportions = { width: m[i].element[0].offsetWidth, height: m[i].element[0].offsetHeight };
                          
                          if(type == "dragstart" || type == "sortactivate") m[i].activate.call(m[i], e); //Activate the droppable if used directly from draggables
                  }
                  
          },
          drop: function(draggable, e) {
                  
                  var dropped = false;
                   $.each($ .ui.ddmanager.droppables, function() {
                          
                          if(!this.options) return;
                          if (!this.options.disabled && this.visible &&  $.ui.intersect(draggable, this, this.options.tolerance))
                                  dropped = this.drop.call(this, e);
                          
                          if (!this.options.disabled && this.visible && this.options.accept.call(this.element,(draggable.currentItem || draggable.element))) {
                                  this.isout = 1; this.isover = 0;
                                  this.deactivate.call(this, e);
                          }
                          
                  });
                  return dropped;
                  
          },
          drag: function(draggable, e) {
                  
                  //If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
                  if(draggable.options.refreshPositions)$ .ui.ddmanager.prepareOffsets(draggable, e);
                  
                  //Run through all droppables and check their positions based on specific tolerance options
  
                   $.each($ .ui.ddmanager.droppables, function() {
                          
                          if(this.options.disabled || this.greedyChild || !this.visible) return;
                          var intersects =  $.ui.intersect(draggable, this, this.options.tolerance);
                          
                          var c = !intersects && this.isover == 1 ? 'isout' : (intersects && this.isover == 0 ? 'isover' : null);
                          if(!c) return;
                          
                          var parentInstance;
                          if (this.options.greedy) {
                                  var parent = this.element.parents('.ui-droppable:eq(0)');
                                  if (parent.length) {
                                          parentInstance =$ .data(parent[0], 'droppable');
                                          parentInstance.greedyChild = (c == 'isover' ? 1 : 0);
                                  }
                          }
                          
                          // we just moved into a greedy child
                          if (parentInstance && c == 'isover') {
                                  parentInstance['isover'] = 0;
                                  parentInstance['isout'] = 1;
                                  parentInstance.out.call(parentInstance, e);
                          }
                          
                          this[c] = 1; this[c == 'isout' ? 'isover' : 'isout'] = 0;
                          this[c == "isover" ? "over" : "out"].call(this, e);
                          
                          // we just moved out of a greedy child
                          if (parentInstance && c == 'isout') {
                                  parentInstance['isout'] = 0;
                                  parentInstance['isover'] = 1;
                                  parentInstance.over.call(parentInstance, e);
                          }
                  });
                  
          }
  };
  
  /*
   * Droppable Extensions
   */
  
   $.ui.plugin.add("droppable", "activeClass", {
          activate: function(e, ui) {
                  this.addClass(ui.options.activeClass);
          },
          deactivate: function(e, ui) {
                  this.removeClass(ui.options.activeClass);
          },
          drop: function(e, ui) {
                  this.removeClass(ui.options.activeClass);
          }
  });$ .ui.plugin.add("droppable", "hoverClass", {
          over: function(e, ui) {
                  this.addClass(ui.options.hoverClass);
          },
          out: function(e, ui) {
                  this.removeClass(ui.options.hoverClass);
          },
          drop: function(e, ui) {
                  this.removeClass(ui.options.hoverClass);
          }
  });
  
  })(jQuery);
  /*
   * jQuery UI Selectable
   *
   * Copyright (c) 2008 Richard D. Worth (rdworth.org)
   * Dual licensed under the MIT (MIT-LICENSE.txt)
   * and GPL (GPL-LICENSE.txt) licenses.
   * 
   * http://docs.jquery.com/UI/Selectables
   *
   * Depends:
   *        ui.core.js
   */
  (function( $) {$ .widget("ui.selectable",  $.extend({},$ .ui.mouse, {
          init: function() {
                  var self = this;
                  
                  this.element.addClass("ui-selectable");
                  
                  this.dragged = false;
  
                  // cache selectee children based on filter
                  var selectees;
                  this.refresh = function() {
                          selectees = $(self.options.filter, self.element[0]);
                          selectees.each(function() {
                                  var  $this = this;
                                  var pos =$ this.offset();
                                   $.data(this, "selectable-item", {
                                          element: this,$ element:  $this,
                                          left: pos.left,
                                          top: pos.top,
                                          right: pos.left +$ this.width(),
                                          bottom: pos.top +  $this.height(),
                                          startselected: false,
                                          selected:$ this.hasClass('ui-selected'),
                                          selecting:  $this.hasClass('ui-selecting'),
                                          unselecting:$ this.hasClass('ui-unselecting')
                                  });
                          });
                  };
                  this.refresh();
  
                  this.selectees = selectees.addClass("ui-selectee");
                  
                  this.mouseInit();
                  
                  this.helper = $(document.createElement('div')).css({border:'1px dotted black'});
          },
          toggle: function() {
                  if(this.options.disabled){
                          this.enable();
                  } else {
                          this.disable();
                  }
          },
          destroy: function() {
                  this.element
                          .removeClass("ui-selectable ui-selectable-disabled")
                          .removeData("selectable")
                          .unbind(".selectable");
                  this.mouseDestroy();
          },
          mouseStart: function(e) {
                  var self = this;
                  
                  this.opos = [e.pageX, e.pageY];
                  
                  if (this.options.disabled)
                          return;
  
                  var options = this.options;
  
                  this.selectees = $(options.filter, this.element[0]);
  
                  // selectable START callback
                  this.element.triggerHandler("selectablestart", [e, {
                          "selectable": this.element[0],
                          "options": options
                  }], options.start);
  
                  $('body').append(this.helper);
                  // position helper (lasso)
                  this.helper.css({
                          "z-index": 100,
                          "position": "absolute",
                          "left": e.clientX,
                          "top": e.clientY,
                          "width": 0,
                          "height": 0
                  });
  
                  if (options.autoRefresh) {
                          this.refresh();
                  }
  
                  this.selectees.filter('.ui-selected').each(function() {
                          var selectee =  $.data(this, "selectable-item");
                          selectee.startselected = true;
                          if (!e.ctrlKey) {
                                  selectee.$ element.removeClass('ui-selected');
                                  selectee.selected = false;
                                  selectee. $element.addClass('ui-unselecting');
                                  selectee.unselecting = true;
                                  // selectable UNSELECTING callback
                                  self.element.triggerHandler("selectableunselecting", [e, {
                                          selectable: self.element[0],
                                          unselecting: selectee.element,
                                          options: options
                                  }], options.unselecting);
                          }
                  });
                  
                  var isSelectee = false;
                  $(e.target).parents().andSelf().each(function() {
                          if($ .data(this, "selectable-item")) isSelectee = true;
                  });
                  return this.options.keyboard ? !isSelectee : true;
          },
          mouseDrag: function(e) {
                  var self = this;
                  this.dragged = true;
                  
                  if (this.options.disabled)
                          return;
  
                  var options = this.options;
  
                  var x1 = this.opos[0], y1 = this.opos[1], x2 = e.pageX, y2 = e.pageY;
                  if (x1 > x2) { var tmp = x2; x2 = x1; x1 = tmp; }
                  if (y1 > y2) { var tmp = y2; y2 = y1; y1 = tmp; }
                  this.helper.css({left: x1, top: y1, width: x2-x1, height: y2-y1});
  
                  this.selectees.each(function() {
                          var selectee =  $.data(this, "selectable-item");
                          //prevent helper from being selected if appendTo: selectable
                          if (!selectee || selectee.element == self.element[0])
                                  return;
                          var hit = false;
                          if (options.tolerance == 'touch') {
                                  hit = ( !(selectee.left > x2 || selectee.right < x1 || selectee.top > y2 || selectee.bottom < y1) );
                          } else if (options.tolerance == 'fit') {
                                  hit = (selectee.left > x1 && selectee.right < x2 && selectee.top > y1 && selectee.bottom < y2);
                          }
  
                          if (hit) {
                                  // SELECT
                                  if (selectee.selected) {
                                          selectee.$ element.removeClass('ui-selected');
                                          selectee.selected = false;
                                  }
                                  if (selectee.unselecting) {
                                          selectee. $element.removeClass('ui-unselecting');
                                          selectee.unselecting = false;
                                  }
                                  if (!selectee.selecting) {
                                          selectee.$ element.addClass('ui-selecting');
                                          selectee.selecting = true;
                                          // selectable SELECTING callback
                                          self.element.triggerHandler("selectableselecting", [e, {
                                                  selectable: self.element[0],
                                                  selecting: selectee.element,
                                                  options: options
                                          }], options.selecting);
                                  }
                          } else {
                                  // UNSELECT
                                  if (selectee.selecting) {
                                          if (e.ctrlKey && selectee.startselected) {
                                                  selectee. $element.removeClass('ui-selecting');
                                                  selectee.selecting = false;
                                                  selectee.$ element.addClass('ui-selected');
                                                  selectee.selected = true;
                                          } else {
                                                  selectee. $element.removeClass('ui-selecting');
                                                  selectee.selecting = false;
                                                  if (selectee.startselected) {
                                                          selectee.$ element.addClass('ui-unselecting');
                                                          selectee.unselecting = true;
                                                  }
                                                  // selectable UNSELECTING callback
                                                  self.element.triggerHandler("selectableunselecting", [e, {
                                                          selectable: self.element[0],
                                                          unselecting: selectee.element,
                                                          options: options
                                                  }], options.unselecting);
                                          }
                                  }
                                  if (selectee.selected) {
                                          if (!e.ctrlKey && !selectee.startselected) {
                                                  selectee. $element.removeClass('ui-selected');
                                                  selectee.selected = false;
  
                                                  selectee.$ element.addClass('ui-unselecting');
                                                  selectee.unselecting = true;
                                                  // selectable UNSELECTING callback
                                                  self.element.triggerHandler("selectableunselecting", [e, {
                                                          selectable: self.element[0],
                                                          unselecting: selectee.element,
                                                          options: options
                                                  }], options.unselecting);
                                          }
                                  }
                          }
                  });
                  
                  return false;
          },
          mouseStop: function(e) {
                  var self = this;
                  
                  this.dragged = false;
                  
                  var options = this.options;
  
                  $('.ui-unselecting', this.element[0]).each(function() {
                          var selectee =  $.data(this, "selectable-item");
                          selectee.$ element.removeClass('ui-unselecting');
                          selectee.unselecting = false;
                          selectee.startselected = false;
                          self.element.triggerHandler("selectableunselected", [e, {
                                  selectable: self.element[0],
                                  unselected: selectee.element,
                                  options: options
                          }], options.unselected);
                  });
                  $('.ui-selecting', this.element[0]).each(function() {
                          var selectee =  $.data(this, "selectable-item");
                          selectee.$ element.removeClass('ui-selecting').addClass('ui-selected');
                          selectee.selecting = false;
                          selectee.selected = true;
                          selectee.startselected = true;
                          self.element.triggerHandler("selectableselected", [e, {
                                  selectable: self.element[0],
                                  selected: selectee.element,
                                  options: options
                          }], options.selected);
                  });
                  this.element.triggerHandler("selectablestop", [e, {
                          selectable: self.element[0],
                          options: this.options
                  }], this.options.stop);
                  
                  this.helper.remove();
                  
                  return false;
          }
  }));
  
   $.extend($ .ui.selectable, {
          defaults: {
                  distance: 1,
                  delay: 0,
                  cancel: ":input",
                  appendTo: 'body',
                  autoRefresh: true,
                  filter: '*',
                  tolerance: 'touch'
          }
  });
  
  })(jQuery);

[] readme course(s) preface I 1 2 II 3 4 III 5 6 7 IV 8 9 10 V 11 12 afterthought(s) appendix reference(s) example(s) resource(s) _

You may not copy or print any of this material without explicit permission of the author or the publisher. In case of other copyright issues, contact the author.