cv 0.0.1

data/lib/cv/public/javascripts/scroll-follow.js

@@ -0,0 +1,251 @@
+/**
+ * jquery.scrollFollow.js
+ * Copyright (c) 2008 Net Perspective (http://kitchen.net-perspective.com/)
+ * Licensed under the MIT License (http://www.opensource.org/licenses/mit-license.php)
+ * 
+ * @author R.A. Ray
+ *
+ * @projectDescription  jQuery plugin for allowing an element to animate down as the user scrolls the page.
+ * 
+ * @version 0.4.0
+ * 
+ * @requires jquery.js (tested with 1.2.6)
+ * @requires ui.core.js (tested with 1.5.2)
+ * 
+ * @optional jquery.cookie.js (http://www.stilbuero.de/2006/09/17/cookie-plugin-for-jquery/)
+ * @optional jquery.easing.js (http://gsgd.co.uk/sandbox/jquery/easing/ - tested with 1.3)
+ * 
+ * @param speed     int - Duration of animation (in milliseconds)
+ *                              default: 500
+ * @param offset            int - Number of pixels box should remain from top of viewport
+ *                              default: 0
+ * @param easing        string - Any one of the easing options from the easing plugin - Requires jQuery Easing Plugin < http://gsgd.co.uk/sandbox/jquery/easing/ >
+ *                              default: 'linear'
+ * @param container string - ID of the containing div
+ *                              default: box's immediate parent
+ * @param killSwitch    string - ID of the On/Off toggle element
+ *                              default: 'killSwitch'
+ * @param onText        string - killSwitch text to be displayed if sliding is enabled
+ *                              default: 'Turn Slide Off'
+ * @param offText       string - killSwitch text to be displayed if sliding is disabled
+ *                              default: 'Turn Slide On'
+ * @param relativeTo    string - Scroll animation can be relative to either the 'top' or 'bottom' of the viewport
+ *                              default: 'top'
+ * @param delay         int - Time between the end of the scroll and the beginning of the animation in milliseconds
+ *                              default: 0
+ */
+
+( function( $ ) {
+    
+    $.scrollFollow = function ( box, options )
+    { 
+        // Convert box into a jQuery object
+        box = $( box );
+        
+        // 'box' is the object to be animated
+        var position = box.css( 'position' );
+        
+        function ani()
+        {       
+            // The script runs on every scroll which really means many times during a scroll.
+            // We don't want multiple slides to queue up.
+            box.queue( [ ] );
+        
+            // A bunch of values we need to determine where to animate to
+            var viewportHeight = parseInt( $( window ).height() );  
+            var pageScroll =  parseInt( $( document ).scrollTop() );
+            var parentTop =  parseInt( box.cont.offset().top );
+            var parentHeight = parseInt( box.cont.attr( 'offsetHeight' ) );
+            var boxHeight = parseInt( box.attr( 'offsetHeight' ) + ( parseInt( box.css( 'marginTop' ) ) || 0 ) + ( parseInt( box.css( 'marginBottom' ) ) || 0 ) );
+            var aniTop;
+            
+            // Make sure the user wants the animation to happen
+            if ( isActive )
+            {
+                // If the box should animate relative to the top of the window
+                if ( options.relativeTo == 'top' )
+                {
+                    // Don't animate until the top of the window is close enough to the top of the box
+                    if ( box.initialOffsetTop >= ( pageScroll + options.offset ) )
+                    {
+                        aniTop = box.initialTop;
+                    }
+                    else
+                    {
+                        aniTop = Math.min( ( Math.max( ( -parentTop ), ( pageScroll - box.initialOffsetTop + box.initialTop ) ) + options.offset ), ( parentHeight - boxHeight - box.paddingAdjustment ) );
+                    }
+                }
+                // If the box should animate relative to the bottom of the window
+                else if ( options.relativeTo == 'bottom' )
+                {
+                    // Don't animate until the bottom of the window is close enough to the bottom of the box
+                    if ( ( box.initialOffsetTop + boxHeight ) >= ( pageScroll + options.offset + viewportHeight ) )
+                    {
+                        aniTop = box.initialTop;
+                    }
+                    else
+                    {
+                        aniTop = Math.min( ( pageScroll + viewportHeight - boxHeight - options.offset ), ( parentHeight - boxHeight ) );
+                    }
+                }
+                
+                // Checks to see if the relevant scroll was the last one
+                // "-20" is to account for inaccuracy in the timeout
+                if ( ( new Date().getTime() - box.lastScroll ) >= ( options.delay - 20 ) )
+                {
+                    box.animate(
+                        {
+                            top: aniTop
+                        }, options.speed, options.easing
+                    );
+                }
+            }
+        };
+        
+        // For user-initiated stopping of the slide
+        var isActive = true;
+        
+        if ( $.cookie != undefined )
+        {
+            if( $.cookie( 'scrollFollowSetting' + box.attr( 'id' ) ) == 'false' )
+            {
+                var isActive = false;
+                
+                $( '#' + options.killSwitch ).text( options.offText )
+                    .toggle( 
+                        function ()
+                        {
+                            isActive = true;
+                            
+                            $( this ).text( options.onText );
+                            
+                            $.cookie( 'scrollFollowSetting' + box.attr( 'id' ), true, { expires: 365, path: '/'} );
+                            
+                            ani();
+                        },
+                        function ()
+                        {
+                            isActive = false;
+                            
+                            $( this ).text( options.offText );
+                            
+                            box.animate(
+                                {
+                                    top: box.initialTop
+                                }, options.speed, options.easing
+                            );  
+                            
+                            $.cookie( 'scrollFollowSetting' + box.attr( 'id' ), false, { expires: 365, path: '/'} );
+                        }
+                    );
+            }
+            else
+            {
+                $( '#' + options.killSwitch ).text( options.onText )
+                    .toggle( 
+                        function ()
+                        {
+                            isActive = false;
+                            
+                            $( this ).text( options.offText );
+                            
+                            box.animate(
+                                {
+                                    top: box.initialTop
+                                }, 0
+                            );  
+                            
+                            $.cookie( 'scrollFollowSetting' + box.attr( 'id' ), false, { expires: 365, path: '/'} );
+                        },
+                        function ()
+                        {
+                            isActive = true;
+                            
+                            $( this ).text( options.onText );
+                            
+                            $.cookie( 'scrollFollowSetting' + box.attr( 'id' ), true, { expires: 365, path: '/'} );
+                            
+                            ani();
+                        }
+                    );
+            }
+        }
+        
+        // If no parent ID was specified, and the immediate parent does not have an ID
+        // options.container will be undefined. So we need to figure out the parent element.
+        if ( options.container == '')
+        {
+            box.cont = box.parent();
+        }
+        else
+        {
+            box.cont = $( '#' + options.container );
+        }
+        
+        // Finds the default positioning of the box.
+        box.initialOffsetTop =  parseInt( box.offset().top );
+        box.initialTop = parseInt( box.css( 'top' ) ) || 0;
+        
+        // Hack to fix different treatment of boxes positioned 'absolute' and 'relative'
+        if ( box.css( 'position' ) == 'relative' )
+        {
+            box.paddingAdjustment = parseInt( box.cont.css( 'paddingTop' ) ) + parseInt( box.cont.css( 'paddingBottom' ) );
+        }
+        else
+        {
+            box.paddingAdjustment = 0;
+        }
+        
+        // Animate the box when the page is scrolled
+        $( window ).scroll( function ()
+            {
+                // Sets up the delay of the animation
+                $.fn.scrollFollow.interval = setTimeout( function(){ ani();} , options.delay );
+                
+                // To check against right before setting the animation
+                box.lastScroll = new Date().getTime();
+            }
+        );
+        
+        // Animate the box when the page is resized
+        $( window ).resize( function ()
+            {
+                // Sets up the delay of the animation
+                $.fn.scrollFollow.interval = setTimeout( function(){ ani();} , options.delay );
+                
+                // To check against right before setting the animation
+                box.lastScroll = new Date().getTime();
+            }
+        );
+
+        // Run an initial animation on page load
+        box.lastScroll = 0;
+        
+        ani();
+    };
+    
+    $.fn.scrollFollow = function ( options )
+    {
+        options = options || {};
+        options.relativeTo = options.relativeTo || 'top';
+        options.speed = options.speed || 500;
+        options.offset = options.offset || 0;
+        options.easing = options.easing || 'swing';
+        options.container = options.container || this.parent().attr( 'id' );
+        options.killSwitch = options.killSwitch || 'killSwitch';
+        options.onText = options.onText || 'Turn Slide Off';
+        options.offText = options.offText || 'Turn Slide On';
+        options.delay = options.delay || 0;
+        
+        this.each( function() 
+            {
+                new $.scrollFollow( this, options );
+            }
+        );
+        
+        return this;
+    };
+})( jQuery );
+
+
+

data/lib/cv/public/javascripts/scroll.js

@@ -0,0 +1,69 @@
+(function(){
+    
+    var special = jQuery.event.special,
+        uid1 = 'D' + (+new Date()),
+        uid2 = 'D' + (+new Date() + 1);
+        
+    special.scrollstart = {
+        setup: function() {
+            
+            var timer,
+                handler =  function(evt) {
+                    
+                    var _self = this,
+                        _args = arguments;
+                    
+                    if (timer) {
+                        clearTimeout(timer);
+                    } else {
+                        evt.type = 'scrollstart';
+                        jQuery.event.handle.apply(_self, _args);
+                    }
+                    
+                    timer = setTimeout( function(){
+                        timer = null;
+                    }, special.scrollstop.latency);
+                    
+                };
+            
+            jQuery(this).bind('scroll', handler).data(uid1, handler);
+            
+        },
+        teardown: function(){
+            jQuery(this).unbind( 'scroll', jQuery(this).data(uid1) );
+        }
+    };
+    
+    special.scrollstop = {
+        latency: 300,
+        setup: function() {
+            
+            var timer,
+                    handler = function(evt) {
+                    
+                    var _self = this,
+                        _args = arguments;
+                    
+                    if (timer) {
+                        clearTimeout(timer);
+                    }
+                    
+                    timer = setTimeout( function(){
+                        
+                        timer = null;
+                        evt.type = 'scrollstop';
+                        jQuery.event.handle.apply(_self, _args);
+                        
+                    }, special.scrollstop.latency);
+                    
+                };
+            
+            jQuery(this).bind('scroll', handler).data(uid2, handler);
+            
+        },
+        teardown: function() {
+            jQuery(this).unbind( 'scroll', jQuery(this).data(uid2) );
+        }
+    };
+    
+})();

data/lib/cv/public/javascripts/ui.core.js

@@ -0,0 +1,291 @@
+/*
+ * jQuery UI 1.5.2
+ *
+ * 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);