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

javascriptmvc 3.0.0.pre15

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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);