RubyGems - javascriptmvc - Versions diffs - 3.0.0.pre15 - Mend

javascriptmvc 3.0.0.pre15

Files changed (550) hide show

data/lib/javascriptmvc/jquery/event/drag/test/qunit/qunit.js ADDED

@@ -0,0 +1,4 @@
+steal
+ .plugins("jquery/event/drop",'funcunit/synthetic')  //load your app
+ .plugins('funcunit/qunit' )  //load qunit
+ .then("drag_test")

data/lib/javascriptmvc/jquery/event/drop/drop.html ADDED

@@ -0,0 +1,74 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+            "http://www.w3.org/TR/html4/strict.dtd">
+<html lang="en">
+	<head>
+		<title>drop</title>
+        <style type='text/css'>
+            .handle {
+				width: 100px;
+				height: 25px;
+				border: dashed 1px red;
+				cursor : pointer;
+			}
+            .dropout, .dropmove, .cancel {
+                width: 200px;
+				height: 50px;
+				border: dashed 1px green;
+				cursor : pointer;
+                background-color: white;
+            }
+            #dropout {
+                padding: 20px;
+                border: solid 1px blue;
+            }
+            .over {
+                background-color: yellow;
+            }
+        </style>
+	</head>
+	<body>
+<div  id='demo-html'>
+<h2>Drop Demo</h2>
+<div class='handle'>Drag Me</div>
+<h2>Dropout/Dropover</h2>
+<div id='dropout'>
+  <div class='dropout'></div>
+  <div class='dropout'></div>
+</div>
+<a href="javascript://" id='undelegate'>undelegate</a>
+<h2>Dropmove/Dropon</h2>
+<div class='dropmove'></div>
+<span>Drop Count <span class='count'>0</span></span>
+</div>
+		<script type='text/javascript'
+                src='../../../steal/steal.js?steal[app]=jquery/event/drop'>
+        </script>
+		<script type='text/javascript' id='demo-source'>
+//make drags
+$('.handle').live("draginit", function(){})
+//add dropout/dropover
+$('#dropout')
+  .delegate(".dropout","dropover", function(){ $(this).addClass('over') })
+  .delegate(".dropout","dropout", function(){ $(this).removeClass('over') })
+  .bind("dropover", function(){ $(this).addClass('over') })
+  .bind("dropout", function(){ $(this).removeClass('over') });
+//turn off dropout/dropover
+$("#undelegate").click(function(){
+    $('#dropout').undelegate(".dropout","dropover");
+    $('#dropout').undelegate(".dropout","dropout");
+})
+//add dropmove/dropon
+var count = 0
+$('.dropmove')
+  .bind('dropmove', function(){
+    $('.count').text(count++)
+  })
+  .bind('dropon', function(){
+    $(this).text("Dropped on!")
+  })
+        </script>
+	</body>
+</html>

data/lib/javascriptmvc/jquery/event/drop/drop.js ADDED

@@ -0,0 +1,301 @@
+steal.plugins('jquery/event/drag','jquery/dom/within','jquery/dom/compare').then(function($){
+	var event = $.event,
+		callHanders = function(){
+		};
+	//somehow need to keep track of elements with selectors on them.  When element is removed, somehow we need to know that
+	//
+	/**
+	 * @add jQuery.event.special static
+	 */
+	var eventNames = [
+	/**
+	 * @attribute dropover
+	 * Called when a drag is first moved over this drop element.
+	 * <p>Drop events are covered in more detail in [jQuery.Drop].</p>
+	 */
+	"dropover",
+	/**
+	 * @attribute dropon
+	 * Called when a drag is dropped on a drop element.
+	 * <p>Drop events are covered in more detail in [jQuery.Drop].</p>
+	 */
+	"dropon",
+	/**
+	 * @attribute dropout
+	 * Called when a drag is moved out of this drop.
+	 * <p>Drop events are covered in more detail in [jQuery.Drop].</p>
+	 */
+	"dropout",
+	/**
+	 * @attribute dropinit
+	 * Called when a drag motion starts and the drop elements are initialized.
+	 * <p>Drop events are covered in more detail in [jQuery.Drop].</p>
+	 */
+	"dropinit",
+	/**
+	 * @attribute dropmove
+	 * Called repeatedly when a drag is moved over a drop.
+	 * <p>Drop events are covered in more detail in [jQuery.Drop].</p>
+	 */
+	"dropmove",
+	/**
+	 * @attribute dropend
+	 * Called when the drag is done for this drop.
+	 * <p>Drop events are covered in more detail in [jQuery.Drop].</p>
+	 */
+	"dropend"];
+	/**
+	 * @constructor jQuery.Drop
+	 * @parent specialevents
+	 * @plugin jquery/event/drop
+	 * @download jquery/dist/jquery.event.drop.js
+	 * @test jquery/event/drag/qunit.html
+	 *
+	 * Provides drop events as a special event to jQuery.
+	 * By binding to a drop event, the your callback functions will be
+	 * called during the corresponding phase of drag.
+	 * <h2>Drop Events</h2>
+	 * All drop events are called with the native event, an instance of drop, and the drag.  Here are the available drop
+	 * events:
+	 * <ul>
+	 * 	<li><code>dropinit</code> - the drag motion is started, drop positions are calculated.</li>
+	 *  <li><code>dropover</code> - a drag moves over a drop element, called once as the drop is dragged over the element.</li>
+	 *  <li><code>dropout</code> - a drag moves out of the drop element.</li>
+	 *  <li><code>dropmove</code> - a drag is moved over a drop element, called repeatedly as the element is moved.</li>
+	 *  <li><code>dropon</code> - a drag is released over a drop element.</li>
+	 *  <li><code>dropend</code> - the drag motion has completed.</li>
+	 * </ul>
+	 * <h2>Examples</h2>
+	 * Here's how to listen for when a drag moves over a drop:
+	 * @codestart
+	 * $('.drop').live("dropover", function(ev, drop, drag){
+	 *   $(this).addClass("drop-over")
+	 * })
+	 * @codeend
+	 * A bit more complex example:
+	 * @demo jquery/event/drop/drop.html 1000
+	 * @init
+	 * The constructor is never called directly.
+	 */
+	$.Drop = function(callbacks, element){
+		jQuery.extend(this,callbacks);
+		this.element = element;
+	}
+	$.each(eventNames, function(){
+			event.special[this] = {
+				add: function( handleObj ) {
+					//add this element to the compiles list
+					var el = $(this), current = (el.data("dropEventCount") || 0);
+					el.data("dropEventCount",  current+1   )
+					if(current==0){
+						$.Drop.addElement(this);
+					}
+				},
+				remove: function() {
+					var el = $(this), current = (el.data("dropEventCount") || 0);
+					el.data("dropEventCount",  current-1   )
+					if(current<=1){
+						$.Drop.removeElement(this);
+					}
+				}
+			}
+	})
+	$.extend($.Drop,{
+		lowerName: "drop",
+		_elements: [], //elements that are listening for drops
+		_responders: [], //potential drop points
+		last_active: [],
+		endName: "dropon",
+		addElement: function( el ) {
+			//check other elements
+			for(var i =0; i < this._elements.length ; i++  ){
+				if(el ==this._elements[i]) return;
+			}
+			this._elements.push(el);
+		},
+		removeElement: function( el ) {
+			 for(var i =0; i < this._elements.length ; i++  ){
+				if(el == this._elements[i]){
+					this._elements.splice(i,1)
+					return;
+				}
+			}
+		},
+		/**
+		* @hide
+		* For a list of affected drops, sorts them by which is deepest in the DOM first.
+		*/
+		sortByDeepestChild: function( a, b ) {
+			var compare = a.element.compare(b.element);
+			if(compare & 16 || compare & 4) return 1;
+			if(compare & 8 || compare & 2) return -1;
+			return 0;
+		},
+		/**
+		 * @hide
+		 * Tests if a drop is within the point.
+		 */
+		isAffected: function( point, moveable, responder ) {
+			return ((responder.element != moveable.element) && (responder.element.within(point[0], point[1], responder).length == 1));
+		},
+		/**
+		 * @hide
+		 * Calls dropout and sets last active to null
+		 * @param {Object} drop
+		 * @param {Object} drag
+		 * @param {Object} event
+		 */
+		deactivate: function( responder, mover, event ) {
+			mover.out(event, responder)
+			responder.callHandlers(this.lowerName+'out',responder.element[0], event, mover)
+		},
+		/**
+		 * @hide
+		 * Calls dropover
+		 * @param {Object} drop
+		 * @param {Object} drag
+		 * @param {Object} event
+		 */
+		activate: function( responder, mover, event ) { //this is where we should call over
+			mover.over(event, responder)
+			//this.last_active = responder;
+			responder.callHandlers(this.lowerName+'over',responder.element[0], event, mover);
+		},
+		move: function( responder, mover, event ) {
+			responder.callHandlers(this.lowerName+'move',responder.element[0], event, mover)
+		},
+		/**
+		 * Gets all elements that are droppable, adds them
+		 */
+		compile: function( event, drag ) {
+			var el, drops, selector, sels;
+			this.last_active = [];
+			for(var i=0; i < this._elements.length; i++){ //for each element
+				el = this._elements[i]
+				var drops = $.event.findBySelector(el, eventNames)
+				for(selector in drops){ //find the selectors
+					sels = selector ? jQuery(selector, el) : [el];
+					for(var e= 0; e < sels.length; e++){ //for each found element, create a drop point
+						jQuery.removeData(sels[e],"offset");
+						this.add(sels[e], new this(drops[selector]), event, drag);
+					}
+				}
+			}
+		},
+		add: function( element, callbacks, event, drag ) {
+			element = jQuery(element);
+			var responder = new $.Drop(callbacks, element);
+			responder.callHandlers(this.lowerName+'init', element[0], event, drag)
+			if(!responder._canceled){
+				this._responders.push(responder);
+			}
+		},
+		show: function( point, moveable, event ) {
+			var element = moveable.element;
+			if(!this._responders.length) return;
+			var respondable,
+				affected = [],
+				propagate = true,
+				i,j, la, toBeActivated, aff,
+				oldLastActive = this.last_active;
+			for(var d =0 ; d < this._responders.length; d++ ){
+				if(this.isAffected(point, moveable, this._responders[d])){
+					affected.push(this._responders[d]);
+				}
+			}
+			affected.sort(this.sortByDeepestChild); //we should only trigger on lowest children
+			event.stopRespondPropagate = function(){
+				propagate = false;
+			}
+			//deactivate everything in last_active that isn't active
+			toBeActivated = affected.slice();
+			this.last_active = affected;
+			for (j = 0; j < oldLastActive.length; j++) {
+				la = oldLastActive[j]
+				i = 0;
+				while((aff = toBeActivated[i])){
+					if(la == aff){
+						toBeActivated.splice(i,1);break;
+					}else{
+						i++;
+					}
+				}
+				if(!aff){
+					this.deactivate(la, moveable, event);
+				}
+				if(!propagate) return;
+			}
+			for(var i =0; i < toBeActivated.length; i++){
+				this.activate(toBeActivated[i], moveable, event);
+				if(!propagate) return;
+			}
+			//activate everything in affected that isn't in last_active
+			for (i = 0; i < affected.length; i++) {
+				this.move(affected[i], moveable, event);
+				if(!propagate) return;
+			}
+		},
+		end: function( event, moveable ) {
+			var responder, la;
+			for(var r =0; r<this._responders.length; r++){
+				this._responders[r].callHandlers(this.lowerName+'end', null, event, moveable);
+			}
+			//go through the actives ... if you are over one, call dropped on it
+			for(var i = 0; i < this.last_active.length; i++){
+				la = this.last_active[i]
+				if( this.isAffected(event.vector(), moveable, la)  && la[this.endName]){
+					la.callHandlers(this.endName, null, event, moveable);
+				}
+			}
+			this.clear();
+		},
+		/**
+		 * Called after dragging has stopped.
+		 * @hide
+		 */
+		clear: function() {
+		  this._responders = [];
+		}
+	})
+	$.Drag.responder = $.Drop;
+	$.extend($.Drop.prototype,{
+		callHandlers: function( method, el, ev, drag ) {
+			var length = this[method] ? this[method].length : 0
+			for(var i =0; i < length; i++){
+				this[method][i].call(el || this.element[0], ev, this, drag)
+			}
+		},
+		/**
+		 * Caches positions of draggable elements.  This should be called in dropinit.  For example:
+		 * @codestart
+		 * dropinit: function( el, ev, drop ) { drop.cache_position() }
+		 * @codeend
+		 */
+		cache: function( value ) {
+			this._cache = value != null ? value : true;
+		},
+		/**
+		 * Prevents this drop from being dropped on.
+		 */
+		cancel: function() {
+			this._canceled = true;
+		}
+	} )
+});

data/lib/javascriptmvc/jquery/event/event.js ADDED

@@ -0,0 +1,6 @@
+/**
+ * @page specialevents Special Events
+ * @tag core
+ * JavaScriptMVC adds a bunch of useful jQuery extensions for the dom.  Check them out on the left.
+ */
+steal.plugins('jquery');

data/lib/javascriptmvc/jquery/event/hashchange/hashchange.js ADDED

@@ -0,0 +1,245 @@
+/*!
+ * jQuery hashchange event - v1.2 - 2/11/2010
+ * http://benalman.com/projects/jquery-hashchange-plugin/
+ *
+ * Copyright (c) 2010 "Cowboy" Ben Alman
+ * Dual licensed under the MIT and GPL licenses.
+ * http://benalman.com/about/license/
+ */
+// Script: jQuery hashchange event
+//
+// *Version: 1.2, Last updated: 2/11/2010*
+//
+// Project Home - http://benalman.com/projects/jquery-hashchange-plugin/
+// GitHub       - http://github.com/cowboy/jquery-hashchange/
+// Source       - http://github.com/cowboy/jquery-hashchange/raw/master/jquery.ba-hashchange.js
+// (Minified)   - http://github.com/cowboy/jquery-hashchange/raw/master/jquery.ba-hashchange.min.js (1.1kb)
+//
+// About: License
+//
+// Copyright (c) 2010 "Cowboy" Ben Alman,
+// Dual licensed under the MIT and GPL licenses.
+// http://benalman.com/about/license/
+//
+// About: Examples
+//
+// This working example, complete with fully commented code, illustrate one way
+// in which this plugin can be used.
+//
+// hashchange event - http://benalman.com/code/projects/jquery-hashchange/examples/hashchange/
+//
+// About: Support and Testing
+//
+// Information about what version or versions of jQuery this plugin has been
+// tested with, what browsers it has been tested in, and where the unit tests
+// reside (so you can test it yourself).
+//
+// jQuery Versions - 1.2.6, 1.3.2, 1.4.1, 1.4.2
+// Browsers Tested - Internet Explorer 6-8, Firefox 2-3.7, Safari 3-4, Chrome, Opera 9.6-10.1.
+// Unit Tests      - http://benalman.com/code/projects/jquery-hashchange/unit/
+//
+// About: Known issues
+//
+// While this jQuery hashchange event implementation is quite stable and robust,
+// there are a few unfortunate browser bugs surrounding expected hashchange
+// event-based behaviors, independent of any JavaScript window.onhashchange
+// abstraction. See the following examples for more information:
+//
+// Chrome: Back Button - http://benalman.com/code/projects/jquery-hashchange/examples/bug-chrome-back-button/
+// Firefox: Remote XMLHttpRequest - http://benalman.com/code/projects/jquery-hashchange/examples/bug-firefox-remote-xhr/
+// WebKit: Back Button in an Iframe - http://benalman.com/code/projects/jquery-hashchange/examples/bug-webkit-hash-iframe/
+// Safari: Back Button from a different domain - http://benalman.com/code/projects/jquery-hashchange/examples/bug-safari-back-from-diff-domain/
+//
+// About: Release History
+//
+// 1.2   - (2/11/2010) Fixed a bug where coming back to a page using this plugin
+//         from a page on another domain would cause an error in Safari 4. Also,
+//         IE6/7 Iframe is now inserted after the body (this actually works),
+//         which prevents the page from scrolling when the event is first bound.
+//         Event can also now be bound before DOM ready, but it won't be usable
+//         before then in IE6/7.
+// 1.1   - (1/21/2010) Incorporated document.documentMode test to fix IE8 bug
+//         where browser version is incorrectly reported as 8.0, despite
+//         inclusion of the X-UA-Compatible IE=EmulateIE7 meta tag.
+// 1.0   - (1/9/2010) Initial Release. Broke out the jQuery BBQ event.special
+//         window.onhashchange functionality into a separate plugin for users
+//         who want just the basic event & back button support, without all the
+//         extra awesomeness that BBQ provides. This plugin will be included as
+//         part of jQuery BBQ, but also be available separately.
+(function($,window,undefined){
+  '$:nomunge'; // Used by YUI compressor.
+  // Method / object references.
+  var fake_onhashchange,
+    jq_event_special = $.event.special,
+    // Reused strings.
+    str_location = 'location',
+    str_hashchange = 'hashchange',
+    str_href = 'href',
+    // IE6/7 specifically need some special love when it comes to back-button
+    // support, so let's do a little browser sniffing..
+    browser = $.browser,
+    mode = document.documentMode,
+    is_old_ie = browser.msie && ( mode === undefined || mode < 8 ),
+    // Does the browser support window.onhashchange? Test for IE version, since
+    // IE8 incorrectly reports this when in "IE7" or "IE8 Compatibility View"!
+    supports_onhashchange = 'on' + str_hashchange in window && !is_old_ie;
+  // Get location.hash (or what you'd expect location.hash to be) sans any
+  // leading #. Thanks for making this necessary, Firefox!
+  function get_fragment( url ) {
+    url = url || window[ str_location ][ str_href ];
+    return url.replace( /^[^#]*#?(.*)$/, '$1' );
+  };
+  // Property: jQuery.hashchangeDelay
+  //
+  // The numeric interval (in milliseconds) at which the <hashchange event>
+  // polling loop executes. Defaults to 100.
+  $[ str_hashchange + 'Delay' ] = 100;
+  // Event: hashchange event
+  //
+  // Fired when location.hash changes. In browsers that support it, the native
+  // window.onhashchange event is used (IE8, FF3.6), otherwise a polling loop is
+  // initialized, running every <jQuery.hashchangeDelay> milliseconds to see if
+  // the hash has changed. In IE 6 and 7, a hidden Iframe is created to allow
+  // the back button and hash-based history to work.
+  //
+  // Usage:
+  //
+  // > $(window).bind( 'hashchange', function(e) {
+  // >   var hash = location.hash;
+  // >   ...
+  // > });
+  //
+  // Additional Notes:
+  //
+  // * The polling loop and Iframe are not created until at least one callback
+  //   is actually bound to 'hashchange'.
+  // * If you need the bound callback(s) to execute immediately, in cases where
+  //   the page 'state' exists on page load (via bookmark or page refresh, for
+  //   example) use $(window).trigger( 'hashchange' );
+  // * The event can be bound before DOM ready, but since it won't be usable
+  //   before then in IE6/7 (due to the necessary Iframe), recommended usage is
+  //   to bind it inside a $(document).ready() callback.
+  jq_event_special[ str_hashchange ] = $.extend( jq_event_special[ str_hashchange ], {
+    // Called only when the first 'hashchange' event is bound to window.
+    setup: function() {
+      // If window.onhashchange is supported natively, there's nothing to do..
+      if ( supports_onhashchange ) { return false; }
+      // Otherwise, we need to create our own. And we don't want to call this
+      // until the user binds to the event, just in case they never do, since it
+      // will create a polling loop and possibly even a hidden Iframe.
+      $( fake_onhashchange.start );
+    },
+    // Called only when the last 'hashchange' event is unbound from window.
+    teardown: function() {
+      // If window.onhashchange is supported natively, there's nothing to do..
+      if ( supports_onhashchange ) { return false; }
+      // Otherwise, we need to stop ours (if possible).
+      $( fake_onhashchange.stop );
+    }
+  });
+  // fake_onhashchange does all the work of triggering the window.onhashchange
+  // event for browsers that don't natively support it, including creating a
+  // polling loop to watch for hash changes and in IE 6/7 creating a hidden
+  // Iframe to enable back and forward.
+  fake_onhashchange = (function(){
+    var self = {},
+      timeout_id,
+      iframe,
+      set_history,
+      get_history;
+    // Initialize. In IE 6/7, creates a hidden Iframe for history handling.
+    function init(){
+      // Most browsers don't need special methods here..
+      set_history = get_history = function(val){ return val; };
+      // But IE6/7 do!
+      if ( is_old_ie ) {
+        // Create hidden Iframe after the end of the body to prevent initial
+        // page load from scrolling unnecessarily.
+        iframe = $('<iframe src="javascript:0"/>').hide().insertAfter( 'body' )[0].contentWindow;
+        // Get history by looking at the hidden Iframe's location.hash.
+        get_history = function() {
+          return get_fragment( iframe.document[ str_location ][ str_href ] );
+        };
+        // Set a new history item by opening and then closing the Iframe
+        // document, *then* setting its location.hash.
+        set_history = function( hash, history_hash ) {
+          if ( hash !== history_hash ) {
+            var doc = iframe.document;
+            doc.open().close();
+            doc[ str_location ].hash = '#' + hash;
+          }
+        };
+        // Set initial history.
+        set_history( get_fragment() );
+      }
+    };
+    // Start the polling loop.
+    self.start = function() {
+      // Polling loop is already running!
+      if ( timeout_id ) { return; }
+      // Remember the initial hash so it doesn't get triggered immediately.
+      var last_hash = get_fragment();
+      // Initialize if not yet initialized.
+      set_history || init();
+      // This polling loop checks every $.hashchangeDelay milliseconds to see if
+      // location.hash has changed, and triggers the 'hashchange' event on
+      // window when necessary.
+      if(!navigator.userAgent.match(/Rhino/))
+	      (function loopy(){
+	        var hash = get_fragment(),
+	          history_hash = get_history( last_hash );
+	        if ( hash !== last_hash ) {
+	          set_history( last_hash = hash, history_hash );
+	          $(window).trigger( str_hashchange );
+	        } else if ( history_hash !== last_hash ) {
+	          window[ str_location ][ str_href ] = window[ str_location ][ str_href ].replace( /#.*/, '' ) + '#' + history_hash;
+	        }
+	        timeout_id = setTimeout( loopy, $[ str_hashchange + 'Delay' ] );
+	      })();
+    };
+    // Stop the polling loop, but only if an IE6/7 Iframe wasn't created. In
+    // that case, even if there are no longer any bound event handlers, the
+    // polling loop is still necessary for back/next to work at all!
+    self.stop = function() {
+      if ( !iframe ) {
+        timeout_id && clearTimeout( timeout_id );
+        timeout_id = 0;
+      }
+    };
+    return self;
+  })();
+})(jQuery,this);