From 644891059e1f37d0748bc34b9ca78c05fa748214 Mon Sep 17 00:00:00 2001 From: Clipperz Date: Wed, 09 Jan 2013 09:03:53 +0000 Subject: Added JQTouch and Zepto libraries JQTouch and Zepto are tentatively used for the mobile version of Clipperz. No final commitment has been made, though. --- (limited to 'frontend') diff --git a/frontend/gamma/js/JQTouch/extensions/jqt.actionsheet.js b/frontend/gamma/js/JQTouch/extensions/jqt.actionsheet.js new file mode 100644 index 0000000..2a5f8d1 --- a/dev/null +++ b/frontend/gamma/js/JQTouch/extensions/jqt.actionsheet.js @@ -0,0 +1,159 @@ +/* + + _/ _/_/ _/_/_/_/_/ _/ + _/ _/ _/ _/_/ _/ _/ _/_/_/ _/_/_/ + _/ _/ _/_/ _/ _/ _/ _/ _/ _/ _/ _/ + _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ + _/ _/_/ _/ _/ _/_/ _/_/_/ _/_/_/ _/ _/ + _/ + _/ + + Documentation and issue tracking on Google Code + + (c) 2012 by jQTouch project members. + See LICENSE.txt for license. + + Author: Thomas Yip +*/ + +/* + + _/ _/_/ _/_/_/_/_/ _/ + _/ _/ _/ _/_/ _/ _/ _/_/_/ _/_/_/ + _/ _/ _/_/ _/ _/ _/ _/ _/ _/ _/ _/ + _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ + _/ _/_/ _/ _/ _/_/ _/_/_/ _/_/_/ _/ _/ + _/ + _/ + + Documentation and issue tracking on Google Code + + (c) 2012 by jQTouch project members. + See LICENSE.txt for license. + + Author: Thomas Yip +*/ + +(function($) { + var src = $("head script").last().attr("src") || ''; + var scriptpath = src.split('?')[0].split('/').slice(0, -1).join('/')+'/'; + var csspath = scriptpath + 'jqt.actionsheet.css'; + var link = $(''); + $('head').append($(link)); + + function hide(callback) { + var $target = $(this); + var data = $(this).data('actionsheet'); + var $source = data.source; + + var timeout; + + function cleanup() { + clearTimeout(timeout); + + $source.removeClass('transition'); + $target.removeClass('inmotion transition'); + !callback || callback.apply(this, arguments); + }; + timeout = setTimeout(cleanup, 500); + + if (data.shown) { + $(this).data('actionsheet', {}); + $target.one('webkitTransitionEnd', cleanup); + + $source.addClass('transition'); + $target.removeClass('current').addClass('inmotion transition'); + $('#jqt').removeClass('actionopened'); + } + return $target; + } + + function show(callback) { + var $target = $(this); + var data = $(this).data('actionsheet') || {}; + if (!data.shown) { + var $source = $('#jqt .current:not(.actionsheet)'); + + $target.one('webkitTransitionEnd', function() { + $source.removeClass('transition'); + $target.removeClass('inmotion transition'); + !callback || callback.apply(this, arguments); + }); + + data.shown = true; + data.source = $source; + $(this).data('actionsheet', data); + + $source.addClass('transition'); + $target.addClass('inmotion transition'); + $('#jqt').addClass('actionopened'); + setTimeout(function() { + $target.addClass('current'); + }, 50); + } + return $target; + } + + var methods = { + init: function(options) { + $(this).addClass('actionsheet'); + $(this).data({shown: false}); + }, + show: show, + hide: hide + }; + + $.fn.actionsheet = function(method) { + if (methods[method]) { + if ($(this).is('.actionsheet')) { + return methods[method].apply(this, Array.prototype.slice.call(arguments, 1)); + } else { + var msg = 'Target is not a `actionsheet`. Action `' + method + '` is ignored.'; + console.warn(msg); + } + } else if ( typeof method === 'object' || ! method ) { + return methods.init.apply(this, arguments); + } else { + $.error( 'Method ' + method + ' does not exist on jQuery.tooltip' ); + } + }; + + if ($.jQTouch) { + $.jQTouch.addTapHandler({ + name: 'open-actionsheet', + isSupported: function(e, params) { + return params.$el.is('.action'); + }, + fn: function(e, params) { + params.$el.removeClass('active'); + + var $target = $(params.hash); + $target.actionsheet('show'); + + return false; + } + }); + $.jQTouch.addTapHandler({ + name: 'follow-actionlink', + isSupported: function(e, params) { + if ($('#jqt').hasClass('actionopened')) { + return params.$el.is('.actionsheet a'); + } + return false; + }, + fn: function(e, params) { + params.$el.removeClass('active'); + + var $target = params.$el.closest('.actionsheet'); + $target.actionsheet('hide', function() { + if (!params.$el.is('.dismiss')) { + params.$el.trigger('tap'); + } + }); + return false; + } + }); + } else { + console.error('Extension `jqt.actionsheet` failed to load. jQT not found'); + } +})($); diff --git a/frontend/gamma/js/JQTouch/extensions/jqt.autotitles.js b/frontend/gamma/js/JQTouch/extensions/jqt.autotitles.js new file mode 100644 index 0000000..94f3d9b --- a/dev/null +++ b/frontend/gamma/js/JQTouch/extensions/jqt.autotitles.js @@ -0,0 +1,52 @@ +/* + + _/ _/_/ _/_/_/_/_/ _/ + _/ _/ _/ _/_/ _/ _/ _/_/_/ _/_/_/ + _/ _/ _/_/ _/ _/ _/ _/ _/ _/ _/ _/ + _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ + _/ _/_/ _/ _/ _/_/ _/_/_/ _/_/_/ _/ _/ + _/ + _/ + + Created by David Kaneda + Maintained by Thomas Yip + Sponsored by Sencha Labs + Special thanks to Jonathan Stark + + Documentation and issue tracking on GitHub + + (c) 2009-2011 Sencha Labs + jQTouch may be freely distributed under the MIT license. + +*/ + +(function($) { + if ($.jQTouch) + { + $.jQTouch.addExtension(function AutoTitles(jQT){ + + var titleSelector='.toolbar h1'; + + $(function(){ + $('#jqt').bind('pageAnimationStart', function(e, data){ + if (data.direction === 'in'){ + var $title = $(titleSelector, $(e.target)); + var $ref = $(e.target).data('referrer'); + if ($title.length && $ref && $title.text() === ''){ + $title.html($ref.text()); + } + } + }); + }); + + function setTitleSelector(ts){ + titleSelector=ts; + } + + return { + setTitleSelector: setTitleSelector + }; + + }); + } +})($); diff --git a/frontend/gamma/js/JQTouch/extensions/jqt.floaty.js b/frontend/gamma/js/JQTouch/extensions/jqt.floaty.js new file mode 100644 index 0000000..c7e4485 --- a/dev/null +++ b/frontend/gamma/js/JQTouch/extensions/jqt.floaty.js @@ -0,0 +1,96 @@ +/* + + _/ _/_/ _/_/_/_/_/ _/ + _/ _/ _/ _/_/ _/ _/ _/_/_/ _/_/_/ + _/ _/ _/_/ _/ _/ _/ _/ _/ _/ _/ _/ + _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ + _/ _/_/ _/ _/ _/_/ _/_/_/ _/_/_/ _/ _/ + _/ + _/ + + Created by David Kaneda + Documentation and issue tracking on Google Code + + Special thanks to Jonathan Stark + and pinch/zoom + + (c) 2009 by jQTouch project members. + See LICENSE.txt for license. + +*/ + +(function($) { + if ($.jQTouch) + { + $.jQTouch.addExtension(function Floaty(jQT){ + + $.fn.makeFloaty = function(options){ + var defaults = { + align: 'top', + spacing: 20, + time: '.3s' + }; + + var settings = $.extend({}, defaults, options); + + settings.align = (settings.align == 'top') ? 'top' : 'bottom'; + + return this.each(function(){ + var $el = $(this); + + $el.css({ + '-webkit-transition': 'top ' + settings.time + ' ease-in-out', + 'display': 'block', + 'min-height': '0 !important' + }).data('settings', settings); + + $(document).scroll(function(){ + if ($el.data('floatyVisible') === 'true') + { + $el.scrollFloaty(); + } + }); + $el.scrollFloaty(); + }); + }; + + $.fn.scrollFloaty = function(){ + + + return this.each(function(){ + var $el = $(this); + var settings = $el.data('settings'); // Settings not being set as object w/Zepto + var wHeight = $('html').attr('clientHeight'); // WRONG + + var newY = window.pageYOffset + + ((settings.align == 'top') ? + settings.spacing : wHeight - settings.spacing - $el.get(0).offsetHeight); + + $el.css('top', newY).data('floatyVisible', true); + }); + }; + + $.fn.hideFloaty = function(){ + return this.each(function(){ + var $el = $(this); + var oh = $el.get(0).offsetHeight; + + $el.css('top', -oh-10).data('floatyVisible', false); + }); + }; + + $.fn.toggleFloaty = function(){ + return this.each(function(){ + var $el = $(this); + if ($el.data('floatyVisible') === 'true'){ + $el.hideFloaty(); + } + else + { + $el.scrollFloaty(); + } + }); + }; + }); + } +})($); \ No newline at end of file diff --git a/frontend/gamma/js/JQTouch/extensions/jqt.location.js b/frontend/gamma/js/JQTouch/extensions/jqt.location.js new file mode 100644 index 0000000..9d53a1a --- a/dev/null +++ b/frontend/gamma/js/JQTouch/extensions/jqt.location.js @@ -0,0 +1,51 @@ +(function($) { + if ($.jQTouch) + { + $.jQTouch.addExtension(function Location(){ + + var latitude, longitude, callback, callback2; + + function updateLocation(fn, fn2) { + if (navigator.geolocation) + { + callback = fn; + callback2 = fn2; + navigator.geolocation.getCurrentPosition(savePosition, failResponse); + return true; + } else { + console.log('Device not capable of geo-location.'); + fn(false); + return false; + } + } + function failResponse(error){ + if (callback2) { + callback2(error); + } + } + function savePosition(position) { + latitude = position.coords.latitude; + longitude = position.coords.longitude; + if (callback) { + callback(getLocation()); + } + } + function getLocation() { + if (latitude && longitude) { + return { + latitude: latitude, + longitude: longitude + }; + + } else { + console.log('No location available. Try calling updateLocation() first.'); + return false; + } + } + return { + updateLocation: updateLocation, + getLocation: getLocation + }; + }); + } +})($); \ No newline at end of file diff --git a/frontend/gamma/js/JQTouch/extensions/jqt.menusheet.js b/frontend/gamma/js/JQTouch/extensions/jqt.menusheet.js new file mode 100644 index 0000000..8d21aca --- a/dev/null +++ b/frontend/gamma/js/JQTouch/extensions/jqt.menusheet.js @@ -0,0 +1,137 @@ +/* + + _/ _/_/ _/_/_/_/_/ _/ + _/ _/ _/ _/_/ _/ _/ _/_/_/ _/_/_/ + _/ _/ _/_/ _/ _/ _/ _/ _/ _/ _/ _/ + _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ + _/ _/_/ _/ _/ _/_/ _/_/_/ _/_/_/ _/ _/ + _/ + _/ + + Documentation and issue tracking on Google Code + + (c) 2012 by jQTouch project members. + See LICENSE.txt for license. + + Author: Thomas Yip +*/ + +(function($) { + var src = $("head script").last().attr("src") || ''; + var scriptpath = src.split('?')[0].split('/').slice(0, -1).join('/')+'/'; + var csspath = scriptpath + 'jqt.menusheet.css'; + var link = $(''); + $('head').append($(link)); + + function hide(callback) { + var $target = $(this); + var data = $(this).data('menusheet'); + if (data.shown) { + $(this).data('menusheet', {}); + var $source = data.source; + $source.unbind('touchstart mousedown', data.closehandler); + $source.one('webkitTransitionEnd', function() { + $source.removeClass('inmotion transition in'); + $target.removeClass('inmotion out'); + !callback || callback.apply(this, arguments); + }); + + $source.addClass('inmotion transition in'); + $target.addClass('inmotion out').removeClass('current'); + $('#jqt').removeClass('menuopened'); + } + return $target; + } + + function show(callback) { + var $target = $(this); + var data = $(this).data('menusheet') || {}; + if (!data.shown) { + var $source = $('#jqt .current:not(.menusheet)'); + var closehandler = function() { + $target.menusheet('hide'); + return false; + }; + + $source.one('webkitTransitionEnd', function() { + $source.one('touchstart mousedown', closehandler); + $source.removeClass('inmotion transition out'); + $target.removeClass('inmotion in'); + !callback || callback.apply(this, arguments); + }); + + data.shown = true; + data.closehandler = closehandler; + data.source = $source; + $(this).data('menusheet', data); + + $source.addClass('inmotion transition out'); + $target.addClass('current in'); + $('#jqt').addClass('menuopened'); + } + return $target; + } + + var methods = { + init: function(options) { + $(this).addClass('menusheet'); + $(this).data({shown: false}); + }, + show: show, + hide: hide + }; + + $.fn.menusheet = function(method) { + if (methods[method]) { + if ($(this).is('.menusheet')) { + return methods[method].apply(this, Array.prototype.slice.call(arguments, 1)); + } else { + var msg = 'Target is not a `menusheet`. Action `' + method + '` is ignored.'; + console.warn(msg); + } + } else if ( typeof method === 'object' || ! method ) { + return methods.init.apply(this, arguments); + } else { + $.error( 'Method ' + method + ' does not exist on jQuery.tooltip' ); + } + }; + + if ($.jQTouch) { + $.jQTouch.addTapHandler({ + name: 'open-menusheet', + isSupported: function(e, params) { + return params.$el.is('.menu'); + }, + fn: function(e, params) { + params.$el.removeClass('active'); + + var $target = $(params.hash); + $target.menusheet('show'); + + return false; + } + }); + $.jQTouch.addTapHandler({ + name: 'follow-menulink', + isSupported: function(e, params) { + if ($('#jqt').hasClass('menuopened')) { + return params.$el.is('.menusheet a'); + } + return false; + }, + fn: function(e, params) { + params.$el.removeClass('active'); + + var $target = params.$el.closest('.menusheet'); + $target.menusheet('hide', function() { + if (!params.$el.is('.dismiss')) { + params.$el.trigger('tap'); + } + }); + return false; + } + }); + } else { + console.error('Extension `jqt.menusheet` failed to load. jQT not found'); + } +})($); diff --git a/frontend/gamma/js/JQTouch/extensions/jqt.offline.js b/frontend/gamma/js/JQTouch/extensions/jqt.offline.js new file mode 100644 index 0000000..b333a16 --- a/dev/null +++ b/frontend/gamma/js/JQTouch/extensions/jqt.offline.js @@ -0,0 +1,97 @@ +/* + + _/ _/_/ _/_/_/_/_/ _/ + _/ _/ _/ _/_/ _/ _/ _/_/_/ _/_/_/ + _/ _/ _/_/ _/ _/ _/ _/ _/ _/ _/ _/ + _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ + _/ _/_/ _/ _/ _/_/ _/_/_/ _/_/_/ _/ _/ + _/ + _/ + + Created by David Kaneda + Documentation and issue tracking on Google Code + + Special thanks to Jonathan Stark + + Lots of this code is specifically derived from Jonathan's book, + "Building iPhone Apps with HTML, CSS, and JavaScript" + + (c) 2009 by jQTouch project members. + See LICENSE.txt for license. + +*/ + +(function($) { + if ($.jQTouch) + { + $.jQTouch.addExtension(function Offline(){ + + // Convenience array of status values + var cacheStatusValues = []; + cacheStatusValues[0] = 'uncached'; + cacheStatusValues[1] = 'idle'; + cacheStatusValues[2] = 'checking'; + cacheStatusValues[3] = 'downloading'; + cacheStatusValues[4] = 'updateready'; + cacheStatusValues[5] = 'obsolete'; + + // Listeners for all possible events + var cache = window.applicationCache; + cache.addEventListener('cached', logEvent, false); + cache.addEventListener('checking', logEvent, false); + cache.addEventListener('downloading', logEvent, false); + cache.addEventListener('error', logEvent, false); + cache.addEventListener('noupdate', logEvent, false); + cache.addEventListener('obsolete', logEvent, false); + cache.addEventListener('progress', logEvent, false); + cache.addEventListener('updateready', logEvent, false); + + // Log every event to the console + function logEvent(e) { + var online, status, type, message; + online = (isOnline()) ? 'yes' : 'no'; + status = cacheStatusValues[cache.status]; + type = e.type; + message = 'online: ' + online; + message+= ', event: ' + type; + message+= ', status: ' + status; + if (type == 'error' && navigator.onLine) { + message+= ' There was an unknown error, check your Cache Manifest.'; + } + console.log(message); + } + + function isOnline() { + return navigator.onLine; + } + + if (!$('html').attr('manifest')) { + console.log('No Cache Manifest listed on the tag.') + } + + // Swap in newly download files when update is ready + cache.addEventListener('updateready', function(e){ + // Don't perform "swap" if this is the first cache + if (cacheStatusValues[cache.status] != 'idle') { + cache.swapCache(); + console.log('Swapped/updated the Cache Manifest.'); + } + } + , false); + + // These two functions check for updates to the manifest file + function checkForUpdates(){ + cache.update(); + } + function autoCheckForUpdates(){ + setInterval(function(){cache.update()}, 10000); + } + + return { + isOnline: isOnline, + checkForUpdates: checkForUpdates, + autoCheckForUpdates: autoCheckForUpdates + } + }); + } +})(jQuery); \ No newline at end of file diff --git a/frontend/gamma/js/JQTouch/extensions/jqt.themeswitcher.js b/frontend/gamma/js/JQTouch/extensions/jqt.themeswitcher.js new file mode 100755 index 0000000..ef3a75d --- a/dev/null +++ b/frontend/gamma/js/JQTouch/extensions/jqt.themeswitcher.js @@ -0,0 +1,123 @@ +/* + + _/ _/_/ _/_/_/_/_/ _/ + _/ _/ _/ _/_/ _/ _/ _/_/_/ _/_/_/ + _/ _/ _/_/ _/ _/ _/ _/ _/ _/ _/ _/ + _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ + _/ _/_/ _/ _/ _/_/ _/_/_/ _/_/_/ _/ _/ + _/ + _/ + + Documentation and issue tracking on Google Code + + (c) 2011 by jQTouch project members. + See LICENSE.txt for license. + +*/ + +(function($) { + if ($.jQTouch) { + + var scriptpath = $("script").last().attr("src").split('?')[0].split('/').slice(0, -1).join('/')+'/'; + + $.jQTouch.addExtension(function ThemeSwitcher(jQT) { + + var current, + link, + titles = {}, + defaults = { + themeStyleSelector: 'link[rel="stylesheet"][title]', + themeIncluded: [ + {title: 'jQTouch', href: scriptpath + '../themes/css/jqtouch.css'}, + {title: 'Apple', href: scriptpath + '../themes/css/apple.css'}, + {title: 'Vanilla', href: scriptpath + '../themes/css/vanilla.css'} + + ] + }, + options = $.extend({}, defaults, jQT.settings); + + function setStyleState(item, title) { + var $item = $(item); + + if ($item.attr('title') === title) { + item.disabled = false; // workaround for Firefox on Zepto + $item.removeAttr('disabled'); + } else { + item.disabled = true; // workaround for Firefox on Zepto + $item.attr('disabled', true); + } + } + + function initializeStyleState(item, title) { + // and, workaround for WebKit by initializing the 'disabled' attribute + if (!current) { + current = title; + } + setStyleState(item, current); + } + + // public + function switchStyle(title) { + current = title; + $(options.themeStyleSelector).each(function(i, item) { + setStyleState(item, title); + }); + } + + // collect title names, from + $(options.themeStyleSelector).each(function(i, item) { + var $item = $(item); + var title = $item.attr('title'); + + titles[title] = true; + + initializeStyleState(item, title); + }); + + // add included theme + for (var i=0; i < options.themeIncluded.length; i++) { + var hash = options.themeIncluded[i]; + if (!(hash.title in titles)) { + link = $(''); + $('head').append($(link)); + + titles[hash.title] = true; + + initializeStyleState(link, hash.title); + } + } + + if (options.themeSelectionSelector) { + // create UI items + for (var title in titles) { + var $item = $('
  • ' + title + '
    • '); + $(options.themeSelectionSelector).append($item); + } + + // bind to UI items + $(options.themeSelectionSelector).delegate('* > a', 'tap', function(e) { + e.preventDefault(); + e.stopPropagation(); + + var $a = $(this).closest('a'); + $a.removeClass('active'); + switchStyle($a.attr('data-title')); + + // poor-man simulation of radio button behaviour + $(options.themeSelectionSelector).find('a').removeClass('selected'); + $a.addClass('selected'); + }); + + // poor-man simulation of radio button behaviour + $(options.themeSelectionSelector).closest('#jqt > *').bind('pageAnimationEnd', function(e, data){ + if (data.direction === 'in') { + $(options.themeSelectionSelector).find('a[data-title="' + current + '"]').addClass('selected'); + } + }); + } + + return {switchStyle: switchStyle}; + + }); + } +})($); diff --git a/frontend/gamma/js/JQTouch/jqtouch.js b/frontend/gamma/js/JQTouch/jqtouch.js new file mode 100644 index 0000000..bdc6d2e --- a/dev/null +++ b/frontend/gamma/js/JQTouch/jqtouch.js @@ -0,0 +1,889 @@ +/* + + _/ _/_/ _/_/_/_/_/ _/ + _/ _/ _/ _/_/ _/ _/ _/_/_/ _/_/_/ + _/ _/ _/_/ _/ _/ _/ _/ _/ _/ _/ _/ + _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ + _/ _/_/ _/ _/ _/_/ _/_/_/ _/_/_/ _/ _/ + _/ + _/ + + Created by David Kaneda + Maintained by Thomas Yip + Sponsored by Sencha Labs + Special thanks to Jonathan Stark + + Documentation and issue tracking on GitHub + + (c) 2009-2011 Sencha Labs + jQTouch may be freely distributed under the MIT license. + +*/ +(function() { + + var fx; + if ('Zepto' in window) { + fx = window.Zepto; + fx.fn.prop = fx.fn.attr; + + Event.prototype.isDefaultPrevented = function() { + return this.defaultPrevented; + }; + } else if ('jQuery' in window) { + fx = window.jQuery; + + // trick to get Zepto/touch.js to work for jQuery + window.Zepto = $; + } else { + throw('Either Zepto or jQuery is required but neither can be found.'); + } + + $.jQTouch = function(options) { + // Initialize internal jQT variables + var $ = fx, + $body, + $head=$('head'), + history=[], + newPageCount=0, + jQTSettings={}, + $currentPage='', + orientation='portrait', + touchSelectors=[], + publicObj={}, + tapBuffer=100, // High click delay = ~350, quickest animation (slide) = 250 + extensions=$.jQTouch.prototype.extensions, + extTapHandlers=$.jQTouch.prototype.tapHandlers, + tapHandlers=[], + animations=[], + hairExtensions='', + defaults = { + addGlossToIcon: true, + backSelector: '.back, .cancel, .goback', + cacheGetRequests: true, + debug: true, + defaultAnimation: 'slideleft', + fixedViewport: true, + formSelector: 'form', + fullScreen: true, + fullScreenClass: 'fullscreen', + icon: null, + icon4: null, // available in iOS 4.2 and later. + preloadImages: false, + startupScreen: null, + statusBar: 'default', // other options: black-translucent, black + submitSelector: '.submit', + touchSelector: 'a, .touch', + trackScrollPositions: true, + useAnimations: true, + useFastTouch: true, + useTouchScroll: true, + animations: [ // highest to lowest priority + {name:'cubeleft', selector:'.cubeleft, .cube', is3d: true}, + {name:'cuberight', selector:'.cuberight', is3d: true}, + {name:'dissolve', selector:'.dissolve'}, + {name:'fade', selector:'.fade'}, + {name:'flipleft', selector:'.flipleft, .flip', is3d: true}, + {name:'flipright', selector:'.flipright', is3d: true}, + {name:'pop', selector:'.pop', is3d: true}, + {name:'swapleft', selector:'.swap', is3d: true}, + {name:'slidedown', selector:'.slidedown'}, + {name:'slideright', selector:'.slideright'}, + {name:'slideup', selector:'.slideup'}, + {name:'slideleft', selector:'.slideleft, .slide, #jqt > * > ul li a'} + ] + }; // end defaults + + function warn(message) { + if (window.console !== undefined && jQTSettings.debug === true) { + console.warn(message); + } + } + function addAnimation(animation) { + if (typeof(animation.selector) === 'string' && typeof(animation.name) === 'string') { + animations.push(animation); + } + } + function addTapHandler(tapHandler) { + if (typeof(tapHandler.name) === 'string' + && typeof(tapHandler.isSupported) === 'function' + && typeof(tapHandler.fn) === 'function') { + + tapHandlers.push(tapHandler); + } + } + function addPageToHistory(page, animation) { + history.unshift({ + page: page, + animation: animation, + hash: '#' + page.attr('id'), + id: page.attr('id') + }); + } + + // Unfortunately, we can not assume the "tap" event + // is being used for links, forms, etc. + function clickHandler(e) { + // Figure out whether to prevent default + var $el = $(e.target); + + // Find the nearest tappable ancestor + if (!$el.is(touchSelectors.join(', '))) { + $el = $(e.target).closest(touchSelectors.join(', ')); + } + + // Prevent default if we found an internal link (relative or absolute) + if ($el && $el.attr('href') && !$el.isExternalLink()) { + warn('Need to prevent default click behavior'); + e.preventDefault(); + } else { + warn('No need to prevent default click behavior'); + } + + // Trigger a tap event if touchstart is not on the job + if ($.support.touch) { + warn('Not converting click to a tap event because touch handler is on the job'); + } else { + warn('Converting click event to a tap event because touch handlers are not present or off'); + $(e.target).trigger('tap', e); + } + + } + function doNavigation(fromPage, toPage, animation, goingBack) { + + goingBack = goingBack ? goingBack : false; + + // Error check for target page + if (toPage === undefined || toPage.length === 0) { + $.fn.unselect(); + warn('Target element is missing.'); + return false; + } + + // Error check for fromPage===toPage + if (toPage.hasClass('current')) { + $.fn.unselect(); + warn('You are already on the page you are trying to navigate to.'); + return false; + } + + // Collapse the keyboard + $(':focus').trigger('blur'); + + fromPage.trigger('pageAnimationStart', { direction: 'out', back: goingBack }); + toPage.trigger('pageAnimationStart', { direction: 'in', back: goingBack }); + + if ($.support.animationEvents && animation && jQTSettings.useAnimations) { + // Fail over to 2d animation if need be + if (!$.support.transform3d && animation.is3d) { + warn('Did not detect support for 3d animations, falling back to ' + jQTSettings.defaultAnimation); + animation.name = jQTSettings.defaultAnimation; + } + + // Reverse animation if need be + var finalAnimationName = animation.name, + is3d = animation.is3d ? 'animating3d' : ''; + + if (goingBack) { + finalAnimationName = finalAnimationName.replace(/left|right|up|down|in|out/, reverseAnimation ); + } + + warn('finalAnimationName is ' + finalAnimationName); + + // Bind internal "cleanup" callback + fromPage.bind('webkitAnimationEnd', navigationEndHandler); + + // Trigger animations + $body.addClass('animating ' + is3d); + + var lastScroll = window.pageYOffset; + + // Position the incoming page so toolbar is at top of viewport regardless of scroll position on from page + if (jQTSettings.trackScrollPositions === true) { + toPage.css('top', window.pageYOffset - (toPage.data('lastScroll') || 0)); + } + + toPage.addClass(finalAnimationName + ' in current'); + fromPage.removeClass('current').addClass(finalAnimationName + ' out inmotion'); + + if (jQTSettings.trackScrollPositions === true) { + fromPage.data('lastScroll', lastScroll); + $('.scroll', fromPage).each(function(){ + $(this).data('lastScroll', this.scrollTop); + }); + } + } else { + toPage.addClass('current in'); + fromPage.removeClass('current'); + navigationEndHandler(); + } + + // Housekeeping + $currentPage = toPage; + if (goingBack) { + history.shift(); + } else { + addPageToHistory($currentPage, animation); + } + setHash($currentPage.attr('id')); + + // Private navigationEnd callback + function navigationEndHandler(event) { + var bufferTime = tapBuffer; + + if ($.support.animationEvents && animation && jQTSettings.useAnimations) { + fromPage.unbind('webkitAnimationEnd', navigationEndHandler); + fromPage.removeClass(finalAnimationName + ' out inmotion'); + if (finalAnimationName) { + toPage.removeClass(finalAnimationName); + } + $body.removeClass('animating animating3d'); + if (jQTSettings.trackScrollPositions === true) { + toPage.css('top', -toPage.data('lastScroll')); + + // Have to make sure the scroll/style resets + // are outside the flow of this function. + setTimeout(function(){ + toPage.css('top', 0); + window.scroll(0, toPage.data('lastScroll')); + $('.scroll', toPage).each(function(){ + this.scrollTop = - $(this).data('lastScroll'); + }); + }, 0); + } + } else { + fromPage.removeClass(finalAnimationName + ' out inmotion'); + if (finalAnimationName) { + toPage.removeClass(finalAnimationName); + } + bufferTime += 260; + } + + // In class is intentionally delayed, as it is our ghost click hack + setTimeout(function(){ + toPage.removeClass('in'); + window.scroll(0,0); + }, bufferTime); + + fromPage.unselect(); + + // Trigger custom events + toPage.trigger('pageAnimationEnd', { + direction:'in', animation: animation, back: goingBack + }); + fromPage.trigger('pageAnimationEnd', { + direction:'out', animation: animation, back: goingBack + }); + } + + return true; + } + function reverseAnimation(animation) { + var opposites={ + 'up' : 'down', + 'down' : 'up', + 'left' : 'right', + 'right' : 'left', + 'in' : 'out', + 'out' : 'in' + }; + + return opposites[animation] || animation; + } + function getOrientation() { + return orientation; + } + function goBack() { + + // Error checking + if (history.length < 1 ) { + warn('History is empty.'); + } + + if (history.length === 1 ) { + warn('You are on the first panel.'); + window.history.go(-1); + } + + var from = history[0], + to = history[1]; + + if (doNavigation(from.page, to.page, from.animation, true)) { + return publicObj; + } else { + warn('Could not go back.'); + return false; + } + + } + function goTo(toPage, animation) { + + var fromPage = history[0].page; + + if (typeof animation === 'string') { + for (var i=0, max=animations.length; i < max; i++) { + if (animations[i].name === animation) { + animation = animations[i]; + break; + } + } + } + + if (typeof toPage === 'string') { + var nextPage = $(toPage); + + if (nextPage.length < 1) { + showPageByHref(toPage, { + animation: animation + }); + return; + } else { + toPage = nextPage; + } + } + if (doNavigation(fromPage, toPage, animation)) { + return publicObj; + } else { + warn('Could not animate pages.'); + return false; + } + } + function hashChangeHandler(e) { + if (location.hash === history[0].hash) { + warn('We are on the right panel'); + return true; + } else if (location.hash === '') { + goBack(); + return true; + } else { + if( (history[1] && location.hash === history[1].hash) ) { + goBack(); + return true; + } else { + // Lastly, just try going to the ID... + warn('Could not find ID in history, just forwarding to DOM element.'); + goTo($(location.hash), jQTSettings.defaultAnimation); + } + } + } + function init(options) { + jQTSettings = $.extend({}, defaults, options); + + // Preload images + if (jQTSettings.preloadImages) { + for (var i = jQTSettings.preloadImages.length - 1; i >= 0; i--) { + (new Image()).src = jQTSettings.preloadImages[i]; + } + } + + // Set appropriate icon (retina display available in iOS 4.2 and later.) + var precomposed = (jQTSettings.addGlossToIcon) ? '' : '-precomposed'; + if (jQTSettings.icon) { + hairExtensions += ''; + } + if (jQTSettings.icon4) { + hairExtensions += ''; + } + // Set startup screen + if (jQTSettings.startupScreen) { + hairExtensions += ''; + } + + // Set viewport + if (jQTSettings.fixedViewport) { + hairExtensions += ''; + } + + // Set full-screen + if (jQTSettings.fullScreen) { + hairExtensions += ''; + if (jQTSettings.statusBar) { + hairExtensions += ''; + } + } + + // Attach hair extensions + if (hairExtensions) { + $head.prepend(hairExtensions); + } + } + + function getAnimation(el) { + var animation; + + for (var i=0, max=animations.length; i < max; i++) { + if (el.is(animations[i].selector)) { + animation = animations[i]; + break; + } + } + + if (!animation) { + warn('Animation could not be found. Using ' + jQTSettings.defaultAnimation + '.'); + animation = jQTSettings.defaultAnimation; + } + return animation; + } + + function insertPages(nodes, animation) { + + var targetPage = null; + + // Call dom.createElement element directly instead of relying on $(nodes), + // to work around: https://github.com/madrobby/zepto/issues/312 + var div = document.createElement('div'); + div.innerHTML = nodes; + + $(div).children().each(function(index, node) { + var $node = $(this); + if (!$node.attr('id')) { + $node.attr('id', 'page-' + (++newPageCount)); + } + + // Remove any existing instance + $('#' + $node.attr('id')).remove(); + + $body.append($node); + $body.trigger('pageInserted', {page: $node}); + + if ($node.hasClass('current') || !targetPage) { + targetPage = $node; + } + }); + if (targetPage !== null) { + goTo(targetPage, animation); + return targetPage; + } else { + return false; + } + } + + function orientationChangeHandler() { + $body.css('minHeight', 1000); + scrollTo(0,0); + var bodyHeight = window.innerHeight; + $body.css('minHeight', bodyHeight); + + orientation = Math.abs(window.orientation) == 90 ? 'landscape' : 'portrait'; + $body.removeClass('portrait landscape').addClass(orientation).trigger('turn', {orientation: orientation}); + } + function setHash(hash) { + // Sanitize + location.hash = '#' + hash.replace(/^#/, ''); + } + function showPageByHref(href, options) { + + var defaults = { + data: null, + method: 'GET', + animation: null, + callback: null, + $referrer: null + }; + + var settings = $.extend({}, defaults, options); + + if (href != '#') { + $.ajax({ + url: href, + data: settings.data, + type: settings.method, + success: function (data) { + var firstPage = insertPages(data, settings.animation); + if (firstPage) { + if (settings.method == 'GET' && jQTSettings.cacheGetRequests === true && settings.$referrer) { + settings.$referrer.attr('href', '#' + firstPage.attr('id')); + } + if (settings.callback) { + settings.callback(true); + } + } + }, + error: function (data) { + if (settings.$referrer) { + settings.$referrer.unselect(); + } + if (settings.callback) { + settings.callback(false); + } + } + }); + } else if (settings.$referrer) { + settings.$referrer.unselect(); + } + } + function submitHandler(e, callback) { + + $(':focus').trigger('blur'); + + e.preventDefault(); + + var $form = (typeof(e)==='string') ? $(e).eq(0) : (e.target ? $(e.target) : $(e)); + + if ($form.length && $form.is(jQTSettings.formSelector) && $form.attr('action')) { + showPageByHref($form.attr('action'), { + data: $form.serialize(), + method: $form.attr('method') || "POST", + animation: getAnimation($form), + callback: callback + }); + return false; + } + return true; + } + function submitParentForm($el) { + + var $form = $el.closest('form'); + if ($form.length === 0) { + warn('No parent form found'); + } else { + warn('About to submit parent form'); + $form.trigger('submit'); + return false; + } + return true; + } + function supportForTransform3d() { + + var head, body, style, div, result; + + head = document.getElementsByTagName('head')[0]; + body = document.body; + + style = document.createElement('style'); + style.textContent = '@media (transform-3d),(-o-transform-3d),(-moz-transform-3d),(-webkit-transform-3d){#jqt-3dtest{height:3px}}'; + + div = document.createElement('div'); + div.id = 'jqt-3dtest'; + + // Add to the page + head.appendChild(style); + body.appendChild(div); + + // Check the result + result = div.offsetHeight === 3; + + // Clean up + style.parentNode.removeChild(style); + div.parentNode.removeChild(div); + + // Pass back result + warn('Support for 3d transforms: ' + result); + return result; + } + function supportIOS5() { + var support = false; + var REGEX_IOS_VERSION = /OS (\d+)(_\d+)* like Mac OS X/i; + + var agentString = window.navigator.userAgent; + if (REGEX_IOS_VERSION.test(agentString)) { + support = (REGEX_IOS_VERSION.exec(agentString)[1] >= 5); + } + return support; + } + function touchStartHandler(e){ + + var $el = $(e.target), + selectors = touchSelectors.join(', '); + + // Find the nearest tappable ancestor + if (!$el.is(selectors)) { + $el = $el.closest(selectors); + } + + // Make sure we have a tappable element + if ($el.length && $el.attr('href')) { + $el.addClass('active'); + } + + // Remove our active class if we move + $el.on($.support.touch ? 'touchmove' : 'mousemove', function(){ + $el.removeClass('active'); + }); + + $el.on('touchend', function(){ + $el.unbind('touchmove mousemove'); + }); + + } + function tapHandler(e){ + + if (e.isDefaultPrevented()) { + return true; + } + + // Grab the target element + var $el = $(e.target); + + // Find the nearest tappable ancestor + if (!$el.is(touchSelectors.join(', '))) { + $el = $el.closest(touchSelectors.join(', ')); + } + + // Make sure we have a tappable element + if (!$el.length || !$el.attr('href')) { + warn('Could not find a link related to tapped element'); + return true; + } + + // Init some vars + var target = $el.attr('target'), + hash = $el.prop('hash'), + href = $el.attr('href'); + + var params = { + e: e, + $el: $el, + target: target, + hash: hash, + href: href, + jQTSettings: jQTSettings + }; + + // Loop thru all handlers + for (var i=0, len=tapHandlers.length; i -1) && jQTSettings.useFastTouch; + $.support.transform3d = supportForTransform3d(); + $.support.ios5 = supportIOS5(); + + if (!$.support.touch) { + warn('This device does not support touch interaction, or it has been deactivated by the developer. Some features might be unavailable.'); + } + if (!$.support.transform3d) { + warn('This device does not support 3d animation. 2d animations will be used instead.'); + } + + // Define public jQuery functions + $.fn.isExternalLink = function() { + var $el = $(this); + return ($el.attr('target') == '_blank' || $el.attr('rel') == 'external' || $el.is('a[href^="http://maps.google.com"], a[href^="mailto:"], a[href^="tel:"], a[href^="javascript:"], a[href*="youtube.com/v"], a[href*="youtube.com/watch"]')); + }; + $.fn.makeActive = function() { + return $(this).addClass('active'); + }; + $.fn.unselect = function(obj) { + if (obj) { + obj.removeClass('active'); + } else { + $('.active').removeClass('active'); + } + }; + + // Add extensions + for (var i=0, max=extensions.length; i < max; i++) { + var fn = extensions[i]; + if ($.isFunction(fn)) { + $.extend(publicObj, fn(publicObj)); + } + } + + // Add extensions tapHandlers + for (var i=0, max=extTapHandlers.length; i < max; i++) { + addTapHandler(extTapHandlers[i]); + } + // Add default tapHandlers + addDefaultTapHandlers(); + + // Add animations + for (var j=0, max_anims=defaults.animations.length; j < max_anims; j++) { + var animation = defaults.animations[j]; + if(jQTSettings[animation.name + 'Selector'] !== undefined){ + animation.selector = jQTSettings[animation.name + 'Selector']; + } + addAnimation(animation); + } + + // Create an array of stuff that needs touch event handling + touchSelectors.push(jQTSettings.touchSelector); + touchSelectors.push(jQTSettings.backSelector); + touchSelectors.push(jQTSettings.submitSelector); + $(touchSelectors.join(', ')).css('-webkit-touch-callout', 'none'); + + // Make sure we have a jqt element + $body = $('#jqt'); + var anatomy_lessons = []; + + if ($body.length === 0) { + warn('Could not find an element with the id "jqt", so the body id has been set to "jqt". If you are having any problems, wrapping your panels in a div with the id "jqt" might help.'); + $body = $(document.body).attr('id', 'jqt'); + } + + // Add some specific css if need be + if ($.support.transform3d) { + anatomy_lessons.push('supports3d'); + } + if ($.support.ios5 && jQTSettings.useTouchScroll) { + anatomy_lessons.push('touchscroll'); + } + + if (jQTSettings.fullScreenClass && window.navigator.standalone === true) { + anatomy_lessons.push(jQTSettings.fullScreenClass, jQTSettings.statusBar); + } + + // Bind events + + $body + .addClass(anatomy_lessons.join(' ')) + .bind('click', clickHandler) + .bind('orientationchange', orientationChangeHandler) + .bind('submit', submitHandler) + .bind('tap', tapHandler) + .bind( $.support.touch ? 'touchstart' : 'mousedown', touchStartHandler) + .trigger('orientationchange'); + + $(window).bind('hashchange', hashChangeHandler); + + var startHash = location.hash; + + // Determine what the initial view should be + if ($('#jqt > .current').length === 0) { + $currentPage = $('#jqt > *:first-child').addClass('current'); + } else { + $currentPage = $('#jqt > .current'); + } + + setHash($currentPage.attr('id')); + addPageToHistory($currentPage); + + if ($(startHash).length === 1) { + goTo(startHash); + } + }); + + // Expose public methods and properties + publicObj = { + addAnimation: addAnimation, + animations: animations, + getOrientation: getOrientation, + goBack: goBack, + insertPages: insertPages, + goTo: goTo, + history: history, + settings: jQTSettings, + submitForm: submitHandler + }; + return publicObj; + }; + + $.jQTouch.prototype.extensions = []; + $.jQTouch.prototype.tapHandlers = []; + + // Extensions directly manipulate the jQTouch object, before it's initialized. + $.jQTouch.addExtension = function(extension) { + $.jQTouch.prototype.extensions.push(extension); + }; + + // Experimental tap hanlders that can bypass default jQTouch tap handling + $.jQTouch.addTapHandler = function(extension) { + $.jQTouch.prototype.tapHandlers.push(extension); + }; + +})(); // Double closure, ALL THE WAY ACROSS THE SKY diff --git a/frontend/gamma/js/Zepto/ajax.js b/frontend/gamma/js/Zepto/ajax.js new file mode 100644 index 0000000..f4da150 --- a/dev/null +++ b/frontend/gamma/js/Zepto/ajax.js @@ -0,0 +1,285 @@ +// Zepto.js +// (c) 2010-2012 Thomas Fuchs +// Zepto.js may be freely distributed under the MIT license. + +;(function($){ + var jsonpID = 0, + isObject = $.isObject, + document = window.document, + key, + name, + rscript = /)<[^<]*)*<\/script>/gi, + scriptTypeRE = /^(?:text|application)\/javascript/i, + xmlTypeRE = /^(?:text|application)\/xml/i, + jsonType = 'application/json', + htmlType = 'text/html', + blankRE = /^\s*$/ + + // trigger a custom event and return false if it was cancelled + function triggerAndReturn(context, eventName, data) { + var event = $.Event(eventName) + $(context).trigger(event, data) + return !event.defaultPrevented + } + + // trigger an Ajax "global" event + function triggerGlobal(settings, context, eventName, data) { + if (settings.global) return triggerAndReturn(context || document, eventName, data) + } + + // Number of active Ajax requests + $.active = 0 + + function ajaxStart(settings) { + if (settings.global && $.active++ === 0) triggerGlobal(settings, null, 'ajaxStart') + } + function ajaxStop(settings) { + if (settings.global && !(--$.active)) triggerGlobal(settings, null, 'ajaxStop') + } + + // triggers an extra global event "ajaxBeforeSend" that's like "ajaxSend" but cancelable + function ajaxBeforeSend(xhr, settings) { + var context = settings.context + if (settings.beforeSend.call(context, xhr, settings) === false || + triggerGlobal(settings, context, 'ajaxBeforeSend', [xhr, settings]) === false) + return false + + triggerGlobal(settings, context, 'ajaxSend', [xhr, settings]) + } + function ajaxSuccess(data, xhr, settings) { + var context = settings.context, status = 'success' + settings.success.call(context, data, status, xhr) + triggerGlobal(settings, context, 'ajaxSuccess', [xhr, settings, data]) + ajaxComplete(status, xhr, settings) + } + // type: "timeout", "error", "abort", "parsererror" + function ajaxError(error, type, xhr, settings) { + var context = settings.context + settings.error.call(context, xhr, type, error) + triggerGlobal(settings, context, 'ajaxError', [xhr, settings, error]) + ajaxComplete(type, xhr, settings) + } + // status: "success", "notmodified", "error", "timeout", "abort", "parsererror" + function ajaxComplete(status, xhr, settings) { + var context = settings.context + settings.complete.call(context, xhr, status) + triggerGlobal(settings, context, 'ajaxComplete', [xhr, settings]) + ajaxStop(settings) + } + + // Empty function, used as default callback + function empty() {} + + $.ajaxJSONP = function(options){ + if (!('type' in options)) return $.ajax(options) + + var callbackName = 'jsonp' + (++jsonpID), + script = document.createElement('script'), + abort = function(){ + $(script).remove() + if (callbackName in window) window[callbackName] = empty + ajaxComplete('abort', xhr, options) + }, + xhr = { abort: abort }, abortTimeout + + if (options.error) script.onerror = function() { + xhr.abort() + options.error() + } + + window[callbackName] = function(data){ + clearTimeout(abortTimeout) + $(script).remove() + delete window[callbackName] + ajaxSuccess(data, xhr, options) + } + + serializeData(options) + script.src = options.url.replace(/=\?/, '=' + callbackName) + $('head').append(script) + + if (options.timeout > 0) abortTimeout = setTimeout(function(){ + xhr.abort() + ajaxComplete('timeout', xhr, options) + }, options.timeout) + + return xhr + } + + $.ajaxSettings = { + // Default type of request + type: 'GET', + // Callback that is executed before request + beforeSend: empty, + // Callback that is executed if the request succeeds + success: empty, + // Callback that is executed the the server drops error + error: empty, + // Callback that is executed on request complete (both: error and success) + complete: empty, + // The context for the callbacks + context: null, + // Whether to trigger "global" Ajax events + global: true, + // Transport + xhr: function () { + return new window.XMLHttpRequest() + }, + // MIME types mapping + accepts: { + script: 'text/javascript, application/javascript', + json: jsonType, + xml: 'application/xml, text/xml', + html: htmlType, + text: 'text/plain' + }, + // Whether the request is to another domain + crossDomain: false, + // Default timeout + timeout: 0, + // Whether data should be serialized to string + processData: true + } + + function mimeToDataType(mime) { + return mime && ( mime == htmlType ? 'html' : + mime == jsonType ? 'json' : + scriptTypeRE.test(mime) ? 'script' : + xmlTypeRE.test(mime) && 'xml' ) || 'text' + } + + function appendQuery(url, query) { + return (url + '&' + query).replace(/[&?]{1,2}/, '?') + } + + // serialize payload and append it to the URL for GET requests + function serializeData(options) { + if (options.processData && isObject(options.data)) + options.data = $.param(options.data, options.traditional) + if (options.data && (!options.type || options.type.toUpperCase() == 'GET')) + options.url = appendQuery(options.url, options.data) + } + + $.ajax = function(options){ + var settings = $.extend({}, options || {}) + for (key in $.ajaxSettings) if (settings[key] === undefined) settings[key] = $.ajaxSettings[key] + + ajaxStart(settings) + + if (!settings.crossDomain) settings.crossDomain = /^([\w-]+:)?\/\/([^\/]+)/.test(settings.url) && + RegExp.$2 != window.location.host + + var dataType = settings.dataType, hasPlaceholder = /=\?/.test(settings.url) + if (dataType == 'jsonp' || hasPlaceholder) { + if (!hasPlaceholder) settings.url = appendQuery(settings.url, 'callback=?') + return $.ajaxJSONP(settings) + } + + if (!settings.url) settings.url = window.location.toString() + serializeData(settings) + + var mime = settings.accepts[dataType], + baseHeaders = { }, + protocol = /^([\w-]+:)\/\//.test(settings.url) ? RegExp.$1 : window.location.protocol, + xhr = $.ajaxSettings.xhr(), abortTimeout + + if (!settings.crossDomain) baseHeaders['X-Requested-With'] = 'XMLHttpRequest' + if (mime) { + baseHeaders['Accept'] = mime + if (mime.indexOf(',') > -1) mime = mime.split(',', 2)[0] + xhr.overrideMimeType && xhr.overrideMimeType(mime) + } + if (settings.contentType || (settings.contentType !== false && settings.data && settings.type.toUpperCase() != 'GET')) + baseHeaders['Content-Type'] = (settings.contentType || 'application/x-www-form-urlencoded') + settings.headers = $.extend(baseHeaders, settings.headers || {}) + + xhr.onreadystatechange = function(){ + if (xhr.readyState == 4) { + xhr.onreadystatechange = empty; + clearTimeout(abortTimeout) + var result, error = false + if ((xhr.status >= 200 && xhr.status < 300) || xhr.status == 304 || (xhr.status == 0 && protocol == 'file:')) { + dataType = dataType || mimeToDataType(xhr.getResponseHeader('content-type')) + result = xhr.responseText + + try { + if (dataType == 'script') (1,eval)(result) + else if (dataType == 'xml') result = xhr.responseXML + else if (dataType == 'json') result = blankRE.test(result) ? null : $.parseJSON(result) + } catch (e) { error = e } + + if (error) ajaxError(error, 'parsererror', xhr, settings) + else ajaxSuccess(result, xhr, settings) + } else { + ajaxError(null, xhr.status ? 'error' : 'abort', xhr, settings) + } + } + } + + var async = 'async' in settings ? settings.async : true + xhr.open(settings.type, settings.url, async) + + for (name in settings.headers) xhr.setRequestHeader(name, settings.headers[name]) + + if (ajaxBeforeSend(xhr, settings) === false) { + xhr.abort() + return false + } + + if (settings.timeout > 0) abortTimeout = setTimeout(function(){ + xhr.onreadystatechange = empty + xhr.abort() + ajaxError(null, 'timeout', xhr, settings) + }, settings.timeout) + + // avoid sending empty string (#319) + xhr.send(settings.data ? settings.data : null) + return xhr + } + + $.get = function(url, success){ return $.ajax({ url: url, success: success }) } + + $.post = function(url, data, success, dataType){ + if ($.isFunction(data)) dataType = dataType || success, success = data, data = null + return $.ajax({ type: 'POST', url: url, data: data, success: success, dataType: dataType }) + } + + $.getJSON = function(url, success){ + return $.ajax({ url: url, success: success, dataType: 'json' }) + } + + $.fn.load = function(url, success){ + if (!this.length) return this + var self = this, parts = url.split(/\s/), selector + if (parts.length > 1) url = parts[0], selector = parts[1] + $.get(url, function(response){ + self.html(selector ? + $('
    ').html(response.replace(rscript, "")).find(selector) + : response) + success && success.apply(self, arguments) + }) + return this + } + + var escape = encodeURIComponent + + function serialize(params, obj, traditional, scope){ + var array = $.isArray(obj) + $.each(obj, function(key, value) { + if (scope) key = traditional ? scope : scope + '[' + (array ? '' : key) + ']' + // handle data in serializeArray() format + if (!scope && array) params.add(value.name, value.value) + // recurse into nested objects + else if (traditional ? $.isArray(value) : isObject(value)) + serialize(params, value, traditional, key) + else params.add(key, value) + }) + } + + $.param = function(obj, traditional){ + var params = [] + params.add = function(k, v){ this.push(escape(k) + '=' + escape(v)) } + serialize(params, obj, traditional) + return params.join('&').replace(/%20/g, '+') + } +})(Zepto) diff --git a/frontend/gamma/js/Zepto/assets.js b/frontend/gamma/js/Zepto/assets.js new file mode 100644 index 0000000..b5a5712 --- a/dev/null +++ b/frontend/gamma/js/Zepto/assets.js @@ -0,0 +1,21 @@ +// Zepto.js +// (c) 2010-2012 Thomas Fuchs +// Zepto.js may be freely distributed under the MIT license. + +;(function($){ + var cache = [], timeout + + $.fn.remove = function(){ + return this.each(function(){ + if(this.parentNode){ + if(this.tagName === 'IMG'){ + cache.push(this) + this.src = 'data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs=' + if (timeout) clearTimeout(timeout) + timeout = setTimeout(function(){ cache = [] }, 60000) + } + this.parentNode.removeChild(this) + } + }) + } +})(Zepto) diff --git a/frontend/gamma/js/Zepto/data.js b/frontend/gamma/js/Zepto/data.js new file mode 100644 index 0000000..b4c289f --- a/dev/null +++ b/frontend/gamma/js/Zepto/data.js @@ -0,0 +1,67 @@ +// Zepto.js +// (c) 2010-2012 Thomas Fuchs +// Zepto.js may be freely distributed under the MIT license. + +// The following code is heavily inspired by jQuery's $.fn.data() + +;(function($) { + var data = {}, dataAttr = $.fn.data, camelize = $.camelCase, + exp = $.expando = 'Zepto' + (+new Date()) + + // Get value from node: + // 1. first try key as given, + // 2. then try camelized key, + // 3. fall back to reading "data-*" attribute. + function getData(node, name) { + var id = node[exp], store = id && data[id] + if (name === undefined) return store || setData(node) + else { + if (store) { + if (name in store) return store[name] + var camelName = camelize(name) + if (camelName in store) return store[camelName] + } + return dataAttr.call($(node), name) + } + } + + // Store value under camelized key on node + function setData(node, name, value) { + var id = node[exp] || (node[exp] = ++$.uuid), + store = data[id] || (data[id] = attributeData(node)) + if (name !== undefined) store[camelize(name)] = value + return store + } + + // Read all "data-*" attributes from a node + function attributeData(node) { + var store = {} + $.each(node.attributes, function(i, attr){ + if (attr.name.indexOf('data-') == 0) + store[camelize(attr.name.replace('data-', ''))] = + $.zepto.deserializeValue(attr.value) + }) + return store + } + + $.fn.data = function(name, value) { + return value === undefined ? + // set multiple values via object + $.isPlainObject(name) ? + this.each(function(i, node){ + $.each(name, function(key, value){ setData(node, key, value) }) + }) : + // get value from first element + this.length == 0 ? undefined : getData(this[0], name) : + // set value on all elements + this.each(function(){ setData(this, name, value) }) + } + + $.fn.removeData = function(names) { + if (typeof names == 'string') names = names.split(/\s+/) + return this.each(function(){ + var id = this[exp], store = id && data[id] + if (store) $.each(names, function(){ delete store[camelize(this)] }) + }) + } +})(Zepto) diff --git a/frontend/gamma/js/Zepto/detect.js b/frontend/gamma/js/Zepto/detect.js new file mode 100644 index 0000000..22c0386 --- a/dev/null +++ b/frontend/gamma/js/Zepto/detect.js @@ -0,0 +1,42 @@ +// Zepto.js +// (c) 2010-2012 Thomas Fuchs +// Zepto.js may be freely distributed under the MIT license. + +;(function($){ + function detect(ua){ + var os = this.os = {}, browser = this.browser = {}, + webkit = ua.match(/WebKit\/([\d.]+)/), + android = ua.match(/(Android)\s+([\d.]+)/), + ipad = ua.match(/(iPad).*OS\s([\d_]+)/), + iphone = !ipad && ua.match(/(iPhone\sOS)\s([\d_]+)/), + webos = ua.match(/(webOS|hpwOS)[\s\/]([\d.]+)/), + touchpad = webos && ua.match(/TouchPad/), + kindle = ua.match(/Kindle\/([\d.]+)/), + silk = ua.match(/Silk\/([\d._]+)/), + blackberry = ua.match(/(BlackBerry).*Version\/([\d.]+)/), + chrome = ua.match(/Chrome\/([\d.]+)/) || ua.match(/CriOS\/([\d.]+)/) + + // todo clean this up with a better OS/browser + // separation. we need to discern between multiple + // browsers on android, and decide if kindle fire in + // silk mode is android or not + + if (browser.webkit = !!webkit) browser.version = webkit[1] + + if (android) os.android = true, os.version = android[2] + if (iphone) os.ios = os.iphone = true, os.version = iphone[2].replace(/_/g, '.') + if (ipad) os.ios = os.ipad = true, os.version = ipad[2].replace(/_/g, '.') + if (webos) os.webos = true, os.version = webos[2] + if (touchpad) os.touchpad = true + if (blackberry) os.blackberry = true, os.version = blackberry[2] + if (kindle) os.kindle = true, os.version = kindle[1] + if (silk) browser.silk = true, browser.version = silk[1] + if (!silk && os.android && ua.match(/Kindle Fire/)) browser.silk = true + if (chrome) browser.chrome = true, browser.version = chrome[1] + } + + detect.call($, navigator.userAgent) + // make available to unit tests + $.__detect = detect + +})(Zepto) diff --git a/frontend/gamma/js/Zepto/event.js b/frontend/gamma/js/Zepto/event.js new file mode 100644 index 0000000..b40af22 --- a/dev/null +++ b/frontend/gamma/js/Zepto/event.js @@ -0,0 +1,248 @@ +// Zepto.js +// (c) 2010-2012 Thomas Fuchs +// Zepto.js may be freely distributed under the MIT license. + +;(function($){ + var $$ = $.zepto.qsa, handlers = {}, _zid = 1, specialEvents={}, + hover = { mouseenter: 'mouseover', mouseleave: 'mouseout' } + + specialEvents.click = specialEvents.mousedown = specialEvents.mouseup = specialEvents.mousemove = 'MouseEvents' + + function zid(element) { + return element._zid || (element._zid = _zid++) + } + function findHandlers(element, event, fn, selector) { + event = parse(event) + if (event.ns) var matcher = matcherFor(event.ns) + return (handlers[zid(element)] || []).filter(function(handler) { + return handler + && (!event.e || handler.e == event.e) + && (!event.ns || matcher.test(handler.ns)) + && (!fn || zid(handler.fn) === zid(fn)) + && (!selector || handler.sel == selector) + }) + } + function parse(event) { + var parts = ('' + event).split('.') + return {e: parts[0], ns: parts.slice(1).sort().join(' ')} + } + function matcherFor(ns) { + return new RegExp('(?:^| )' + ns.replace(' ', ' .* ?') + '(?: |$)') + } + + function eachEvent(events, fn, iterator){ + if ($.isObject(events)) $.each(events, iterator) + else events.split(/\s/).forEach(function(type){ iterator(type, fn) }) + } + + function eventCapture(handler, captureSetting) { + return handler.del && + (handler.e == 'focus' || handler.e == 'blur') || + !!captureSetting + } + + function realEvent(type) { + return hover[type] || type + } + + function add(element, events, fn, selector, getDelegate, capture){ + var id = zid(element), set = (handlers[id] || (handlers[id] = [])) + eachEvent(events, fn, function(event, fn){ + var handler = parse(event) + handler.fn = fn + handler.sel = selector + // emulate mouseenter, mouseleave + if (handler.e in hover) fn = function(e){ + var related = e.relatedTarget + if (!related || (related !== this && !$.contains(this, related))) + return handler.fn.apply(this, arguments) + } + handler.del = getDelegate && getDelegate(fn, event) + var callback = handler.del || fn + handler.proxy = function (e) { + var result = callback.apply(element, [e].concat(e.data)) + if (result === false) e.preventDefault(), e.stopPropagation() + return result + } + handler.i = set.length + set.push(handler) + element.addEventListener(realEvent(handler.e), handler.proxy, eventCapture(handler, capture)) + }) + } + function remove(element, events, fn, selector, capture){ + var id = zid(element) + eachEvent(events || '', fn, function(event, fn){ + findHandlers(element, event, fn, selector).forEach(function(handler){ + delete handlers[id][handler.i] + element.removeEventListener(realEvent(handler.e), handler.proxy, eventCapture(handler, capture)) + }) + }) + } + + $.event = { add: add, remove: remove } + + $.proxy = function(fn, context) { + if ($.isFunction(fn)) { + var proxyFn = function(){ return fn.apply(context, arguments) } + proxyFn._zid = zid(fn) + return proxyFn + } else if (typeof context == 'string') { + return $.proxy(fn[context], fn) + } else { + throw new TypeError("expected function") + } + } + + $.fn.bind = function(event, callback){ + return this.each(function(){ + add(this, event, callback) + }) + } + $.fn.unbind = function(event, callback){ + return this.each(function(){ + remove(this, event, callback) + }) + } + $.fn.one = function(event, callback){ + return this.each(function(i, element){ + add(this, event, callback, null, function(fn, type){ + return function(){ + var result = fn.apply(element, arguments) + remove(element, type, fn) + return result + } + }) + }) + } + + var returnTrue = function(){return true}, + returnFalse = function(){return false}, + ignoreProperties = /^([A-Z]|layer[XY]$)/, + eventMethods = { + preventDefault: 'isDefaultPrevented', + stopImmediatePropagation: 'isImmediatePropagationStopped', + stopPropagation: 'isPropagationStopped' + } + function createProxy(event) { + var key, proxy = { originalEvent: event } + for (key in event) + if (!ignoreProperties.test(key) && event[key] !== undefined) proxy[key] = event[key] + + $.each(eventMethods, function(name, predicate) { + proxy[name] = function(){ + this[predicate] = returnTrue + return event[name].apply(event, arguments) + } + proxy[predicate] = returnFalse + }) + return proxy + } + + // emulates the 'defaultPrevented' property for browsers that have none + function fix(event) { + if (!('defaultPrevented' in event)) { + event.defaultPrevented = false + var prevent = event.preventDefault + event.preventDefault = function() { + this.defaultPrevented = true + prevent.call(this) + } + } + } + + $.fn.delegate = function(selector, event, callback){ + return this.each(function(i, element){ + add(element, event, callback, selector, function(fn){ + return function(e){ + var evt, match = $(e.target).closest(selector, element).get(0) + if (match) { + evt = $.extend(createProxy(e), {currentTarget: match, liveFired: element}) + return fn.apply(match, [evt].concat([].slice.call(arguments, 1))) + } + } + }) + }) + } + $.fn.undelegate = function(selector, event, callback){ + return this.each(function(){ + remove(this, event, callback, selector) + }) + } + + $.fn.live = function(event, callback){ + $(document.body).delegate(this.selector, event, callback) + return this + } + $.fn.die = function(event, callback){ + $(document.body).undelegate(this.selector, event, callback) + return this + } + + $.fn.on = function(event, selector, callback){ + return !selector || $.isFunction(selector) ? + this.bind(event, selector || callback) : this.delegate(selector, event, callback) + } + $.fn.off = function(event, selector, callback){ + return !selector || $.isFunction(selector) ? + this.unbind(event, selector || callback) : this.undelegate(selector, event, callback) + } + + $.fn.trigger = function(event, data){ + if (typeof event == 'string' || $.isPlainObject(event)) event = $.Event(event) + fix(event) + event.data = data + return this.each(function(){ + // items in the collection might not be DOM elements + // (todo: possibly support events on plain old objects) + if('dispatchEvent' in this) this.dispatchEvent(event) + }) + } + + // triggers event handlers on current element just as if an event occurred, + // doesn't trigger an actual event, doesn't bubble + $.fn.triggerHandler = function(event, data){ + var e, result + this.each(function(i, element){ + e = createProxy(typeof event == 'string' ? $.Event(event) : event) + e.data = data + e.target = element + $.each(findHandlers(element, event.type || event), function(i, handler){ + result = handler.proxy(e) + if (e.isImmediatePropagationStopped()) return false + }) + }) + return result + } + + // shortcut methods for `.bind(event, fn)` for each event type + ;('focusin focusout load resize scroll unload click dblclick '+ + 'mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave '+ + 'change select keydown keypress keyup error').split(' ').forEach(function(event) { + $.fn[event] = function(callback) { + return callback ? + this.bind(event, callback) : + this.trigger(event) + } + }) + + ;['focus', 'blur'].forEach(function(name) { + $.fn[name] = function(callback) { + if (callback) this.bind(name, callback) + else this.each(function(){ + try { this[name]() } + catch(e) {} + }) + return this + } + }) + + $.Event = function(type, props) { + if (typeof type != 'string') props = type, type = props.type + var event = document.createEvent(specialEvents[type] || 'Events'), bubbles = true + if (props) for (var name in props) (name == 'bubbles') ? (bubbles = !!props[name]) : (event[name] = props[name]) + event.initEvent(type, bubbles, true, null, null, null, null, null, null, null, null, null, null, null, null) + event.isDefaultPrevented = function(){ return this.defaultPrevented } + return event + } + +})(Zepto) diff --git a/frontend/gamma/js/Zepto/form.js b/frontend/gamma/js/Zepto/form.js new file mode 100644 index 0000000..4d562a6 --- a/dev/null +++ b/frontend/gamma/js/Zepto/form.js @@ -0,0 +1,40 @@ +// Zepto.js +// (c) 2010-2012 Thomas Fuchs +// Zepto.js may be freely distributed under the MIT license. + +;(function ($) { + $.fn.serializeArray = function () { + var result = [], el + $( Array.prototype.slice.call(this.get(0).elements) ).each(function () { + el = $(this) + var type = el.attr('type') + if (this.nodeName.toLowerCase() != 'fieldset' && + !this.disabled && type != 'submit' && type != 'reset' && type != 'button' && + ((type != 'radio' && type != 'checkbox') || this.checked)) + result.push({ + name: el.attr('name'), + value: el.val() + }) + }) + return result + } + + $.fn.serialize = function () { + var result = [] + this.serializeArray().forEach(function (elm) { + result.push( encodeURIComponent(elm.name) + '=' + encodeURIComponent(elm.value) ) + }) + return result.join('&') + } + + $.fn.submit = function (callback) { + if (callback) this.bind('submit', callback) + else if (this.length) { + var event = $.Event('submit') + this.eq(0).trigger(event) + if (!event.defaultPrevented) this.get(0).submit() + } + return this + } + +})(Zepto) diff --git a/frontend/gamma/js/Zepto/fx.js b/frontend/gamma/js/Zepto/fx.js new file mode 100644 index 0000000..575449a --- a/dev/null +++ b/frontend/gamma/js/Zepto/fx.js @@ -0,0 +1,102 @@ +// Zepto.js +// (c) 2010-2012 Thomas Fuchs +// Zepto.js may be freely distributed under the MIT license. + +;(function($, undefined){ + var prefix = '', eventPrefix, endEventName, endAnimationName, + vendors = { Webkit: 'webkit', Moz: '', O: 'o', ms: 'MS' }, + document = window.document, testEl = document.createElement('div'), + supportedTransforms = /^((translate|rotate|scale)(X|Y|Z|3d)?|matrix(3d)?|perspective|skew(X|Y)?)$/i, + transform, + transitionProperty, transitionDuration, transitionTiming, + animationName, animationDuration, animationTiming, + cssReset = {} + + function dasherize(str) { return downcase(str.replace(/([a-z])([A-Z])/, '$1-$2')) } + function downcase(str) { return str.toLowerCase() } + function normalizeEvent(name) { return eventPrefix ? eventPrefix + name : downcase(name) } + + $.each(vendors, function(vendor, event){ + if (testEl.style[vendor + 'TransitionProperty'] !== undefined) { + prefix = '-' + downcase(vendor) + '-' + eventPrefix = event + return false + } + }) + + transform = prefix + 'transform' + cssReset[transitionProperty = prefix + 'transition-property'] = + cssReset[transitionDuration = prefix + 'transition-duration'] = + cssReset[transitionTiming = prefix + 'transition-timing-function'] = + cssReset[animationName = prefix + 'animation-name'] = + cssReset[animationDuration = prefix + 'animation-duration'] = + cssReset[animationTiming = prefix + 'animation-timing-function'] = '' + + $.fx = { + off: (eventPrefix === undefined && testEl.style.transitionProperty === undefined), + speeds: { _default: 400, fast: 200, slow: 600 }, + cssPrefix: prefix, + transitionEnd: normalizeEvent('TransitionEnd'), + animationEnd: normalizeEvent('AnimationEnd') + } + + $.fn.animate = function(properties, duration, ease, callback){ + if ($.isObject(duration)) + ease = duration.easing, callback = duration.complete, duration = duration.duration + if (duration) duration = (typeof duration == 'number' ? duration : + ($.fx.speeds[duration] || $.fx.speeds._default)) / 1000 + return this.anim(properties, duration, ease, callback) + } + + $.fn.anim = function(properties, duration, ease, callback){ + var key, cssValues = {}, cssProperties, transforms = '', + that = this, wrappedCallback, endEvent = $.fx.transitionEnd + + if (duration === undefined) duration = 0.4 + if ($.fx.off) duration = 0 + + if (typeof properties == 'string') { + // keyframe animation + cssValues[animationName] = properties + cssValues[animationDuration] = duration + 's' + cssValues[animationTiming] = (ease || 'linear') + endEvent = $.fx.animationEnd + } else { + cssProperties = [] + // CSS transitions + for (key in properties) + if (supportedTransforms.test(key)) transforms += key + '(' + properties[key] + ') ' + else cssValues[key] = properties[key], cssProperties.push(dasherize(key)) + + if (transforms) cssValues[transform] = transforms, cssProperties.push(transform) + if (duration > 0 && typeof properties === 'object') { + cssValues[transitionProperty] = cssProperties.join(', ') + cssValues[transitionDuration] = duration + 's' + cssValues[transitionTiming] = (ease || 'linear') + } + } + + wrappedCallback = function(event){ + if (typeof event !== 'undefined') { + if (event.target !== event.currentTarget) return // makes sure the event didn't bubble from "below" + $(event.target).unbind(endEvent, arguments.callee) + } + $(this).css(cssReset) + callback && callback.call(this) + } + if (duration > 0) this.bind(endEvent, wrappedCallback) + + // trigger page reflow so new elements can animate + this.size() && this.get(0).clientLeft + + this.css(cssValues) + + if (duration <= 0) setTimeout(function() { + that.each(function(){ wrappedCallback.call(this) }) + }, 0) + + return this + } + + testEl = null +})(Zepto) diff --git a/frontend/gamma/js/Zepto/fx_methods.js b/frontend/gamma/js/Zepto/fx_methods.js new file mode 100644 index 0000000..23daf6e --- a/dev/null +++ b/frontend/gamma/js/Zepto/fx_methods.js @@ -0,0 +1,71 @@ +// Zepto.js +// (c) 2010-2012 Thomas Fuchs +// Zepto.js may be freely distributed under the MIT license. + +;(function($, undefined){ + var document = window.document, docElem = document.documentElement, + origShow = $.fn.show, origHide = $.fn.hide, origToggle = $.fn.toggle + + function anim(el, speed, opacity, scale, callback) { + if (typeof speed == 'function' && !callback) callback = speed, speed = undefined + var props = { opacity: opacity } + if (scale) { + props.scale = scale + el.css($.fx.cssPrefix + 'transform-origin', '0 0') + } + return el.animate(props, speed, null, callback) + } + + function hide(el, speed, scale, callback) { + return anim(el, speed, 0, scale, function(){ + origHide.call($(this)) + callback && callback.call(this) + }) + } + + $.fn.show = function(speed, callback) { + origShow.call(this) + if (speed === undefined) speed = 0 + else this.css('opacity', 0) + return anim(this, speed, 1, '1,1', callback) + } + + $.fn.hide = function(speed, callback) { + if (speed === undefined) return origHide.call(this) + else return hide(this, speed, '0,0', callback) + } + + $.fn.toggle = function(speed, callback) { + if (speed === undefined || typeof speed == 'boolean') + return origToggle.call(this, speed) + else return this.each(function(){ + var el = $(this) + el[el.css('display') == 'none' ? 'show' : 'hide'](speed, callback) + }) + } + + $.fn.fadeTo = function(speed, opacity, callback) { + return anim(this, speed, opacity, null, callback) + } + + $.fn.fadeIn = function(speed, callback) { + var target = this.css('opacity') + if (target > 0) this.css('opacity', 0) + else target = 1 + return origShow.call(this).fadeTo(speed, target, callback) + } + + $.fn.fadeOut = function(speed, callback) { + return hide(this, speed, null, callback) + } + + $.fn.fadeToggle = function(speed, callback) { + return this.each(function(){ + var el = $(this) + el[ + (el.css('opacity') == 0 || el.css('display') == 'none') ? 'fadeIn' : 'fadeOut' + ](speed, callback) + }) + } + +})(Zepto) diff --git a/frontend/gamma/js/Zepto/gesture.js b/frontend/gamma/js/Zepto/gesture.js new file mode 100644 index 0000000..035455b --- a/dev/null +++ b/frontend/gamma/js/Zepto/gesture.js @@ -0,0 +1,35 @@ +// Zepto.js +// (c) 2010-2012 Thomas Fuchs +// Zepto.js may be freely distributed under the MIT license. + +;(function($){ + if ($.os.ios) { + var gesture = {}, gestureTimeout + + function parentIfText(node){ + return 'tagName' in node ? node : node.parentNode + } + + $(document).bind('gesturestart', function(e){ + var now = Date.now(), delta = now - (gesture.last || now) + gesture.target = parentIfText(e.target) + gestureTimeout && clearTimeout(gestureTimeout) + gesture.e1 = e.scale + gesture.last = now + }).bind('gesturechange', function(e){ + gesture.e2 = e.scale + }).bind('gestureend', function(e){ + if (gesture.e2 > 0) { + Math.abs(gesture.e1 - gesture.e2) != 0 && $(gesture.target).trigger('pinch') && + $(gesture.target).trigger('pinch' + (gesture.e1 - gesture.e2 > 0 ? 'In' : 'Out')) + gesture.e1 = gesture.e2 = gesture.last = 0 + } else if ('last' in gesture) { + gesture = {} + } + }) + + ;['pinch', 'pinchIn', 'pinchOut'].forEach(function(m){ + $.fn[m] = function(callback){ return this.bind(m, callback) } + }) + } +})(Zepto) diff --git a/frontend/gamma/js/Zepto/polyfill.js b/frontend/gamma/js/Zepto/polyfill.js new file mode 100644 index 0000000..933d1f8 --- a/dev/null +++ b/frontend/gamma/js/Zepto/polyfill.js @@ -0,0 +1,36 @@ +// Zepto.js +// (c) 2010-2012 Thomas Fuchs +// Zepto.js may be freely distributed under the MIT license. + +;(function(undefined){ + if (String.prototype.trim === undefined) // fix for iOS 3.2 + String.prototype.trim = function(){ return this.replace(/^\s+/, '').replace(/\s+$/, '') } + + // For iOS 3.x + // from https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/reduce + if (Array.prototype.reduce === undefined) + Array.prototype.reduce = function(fun){ + if(this === void 0 || this === null) throw new TypeError() + var t = Object(this), len = t.length >>> 0, k = 0, accumulator + if(typeof fun != 'function') throw new TypeError() + if(len == 0 && arguments.length == 1) throw new TypeError() + + if(arguments.length >= 2) + accumulator = arguments[1] + else + do{ + if(k in t){ + accumulator = t[k++] + break + } + if(++k >= len) throw new TypeError() + } while (true) + + while (k < len){ + if(k in t) accumulator = fun.call(undefined, accumulator, t[k], k, t) + k++ + } + return accumulator + } + +})() diff --git a/frontend/gamma/js/Zepto/selector.js b/frontend/gamma/js/Zepto/selector.js new file mode 100644 index 0000000..c0b035a --- a/dev/null +++ b/frontend/gamma/js/Zepto/selector.js @@ -0,0 +1,81 @@ +;(function($){ + var zepto = $.zepto, oldQsa = zepto.qsa, oldMatches = zepto.matches + + function visible(elem){ + elem = $(elem) + return !!(elem.width() || elem.height()) && elem.css("display") !== "none" + } + + // Implements a subset from: + // http://api.jquery.com/category/selectors/jquery-selector-extensions/ + // + // Each filter function receives the current index, all nodes in the + // considered set, and a value if there were parentheses. The value + // of `this` is the node currently being considered. The function returns the + // resulting node(s), null, or undefined. + // + // Complex selectors are not supported: + // li:has(label:contains("foo")) + li:has(label:contains("bar")) + // ul.inner:first > li + var filters = $.expr[':'] = { + visible: function(){ if (visible(this)) return this }, + hidden: function(){ if (!visible(this)) return this }, + selected: function(){ if (this.selected) return this }, + checked: function(){ if (this.checked) return this }, + parent: function(){ return this.parentNode }, + first: function(idx){ if (idx === 0) return this }, + last: function(idx, nodes){ if (idx === nodes.length - 1) return this }, + eq: function(idx, _, value){ if (idx === value) return this }, + contains: function(idx, _, text){ if ($(this).text().indexOf(text) > -1) return this }, + has: function(idx, _, sel){ if (zepto.qsa(this, sel).length) return this } + } + + var filterRe = new RegExp('(.*):(\\w+)(?:\\(([^)]+)\\))?$\\s*'), + childRe = /^\s*>/, + classTag = 'Zepto' + (+new Date()) + + function process(sel, fn) { + // quote the hash in `a[href^=#]` expression + sel = sel.replace(/=#\]/g, '="#"]') + var filter, arg, match = filterRe.exec(sel) + if (match && match[2] in filters) { + var filter = filters[match[2]], arg = match[3] + sel = match[1] + if (arg) { + var num = Number(arg) + if (isNaN(num)) arg = arg.replace(/^["']|["']$/g, '') + else arg = num + } + } + return fn(sel, filter, arg) + } + + zepto.qsa = function(node, selector) { + return process(selector, function(sel, filter, arg){ + try { + var taggedParent + if (!sel && filter) sel = '*' + else if (childRe.test(sel)) + // support "> *" child queries by tagging the parent node with a + // unique class and prepending that classname onto the selector + taggedParent = $(node).addClass(classTag), sel = '.'+classTag+' '+sel + + var nodes = oldQsa(node, sel) + } catch(e) { + console.error('error performing selector: %o', selector) + throw e + } finally { + if (taggedParent) taggedParent.removeClass(classTag) + } + return !filter ? nodes : + zepto.uniq($.map(nodes, function(n, i){ return filter.call(n, i, nodes, arg) })) + }) + } + + zepto.matches = function(node, selector){ + return process(selector, function(sel, filter, arg){ + return (!sel || oldMatches(node, sel)) && + (!filter || filter.call(node, null, arg) === node) + }) + } +})(Zepto) diff --git a/frontend/gamma/js/Zepto/stack.js b/frontend/gamma/js/Zepto/stack.js new file mode 100644 index 0000000..c995285 --- a/dev/null +++ b/frontend/gamma/js/Zepto/stack.js @@ -0,0 +1,22 @@ +// Zepto.js +// (c) 2010-2012 Thomas Fuchs +// Zepto.js may be freely distributed under the MIT license. + +;(function($){ + $.fn.end = function(){ + return this.prevObject || $() + } + + $.fn.andSelf = function(){ + return this.add(this.prevObject || $()) + } + + 'filter,add,not,eq,first,last,find,closest,parents,parent,children,siblings'.split(',').forEach(function(property){ + var fn = $.fn[property] + $.fn[property] = function(){ + var ret = fn.apply(this, arguments) + ret.prevObject = this + return ret + } + }) +})(Zepto) diff --git a/frontend/gamma/js/Zepto/touch.js b/frontend/gamma/js/Zepto/touch.js new file mode 100644 index 0000000..af109b9 --- a/dev/null +++ b/frontend/gamma/js/Zepto/touch.js @@ -0,0 +1,113 @@ +// Zepto.js +// (c) 2010-2012 Thomas Fuchs +// Zepto.js may be freely distributed under the MIT license. + +;(function($){ + var touch = {}, + touchTimeout, tapTimeout, swipeTimeout, + longTapDelay = 750, longTapTimeout + + function parentIfText(node) { + return 'tagName' in node ? node : node.parentNode + } + + function swipeDirection(x1, x2, y1, y2) { + var xDelta = Math.abs(x1 - x2), yDelta = Math.abs(y1 - y2) + return xDelta >= yDelta ? (x1 - x2 > 0 ? 'Left' : 'Right') : (y1 - y2 > 0 ? 'Up' : 'Down') + } + + function longTap() { + longTapTimeout = null + if (touch.last) { + touch.el.trigger('longTap') + touch = {} + } + } + + function cancelLongTap() { + if (longTapTimeout) clearTimeout(longTapTimeout) + longTapTimeout = null + } + + function cancelAll() { + if (touchTimeout) clearTimeout(touchTimeout) + if (tapTimeout) clearTimeout(tapTimeout) + if (swipeTimeout) clearTimeout(swipeTimeout) + if (longTapTimeout) clearTimeout(longTapTimeout) + touchTimeout = tapTimeout = swipeTimeout = longTapTimeout = null + touch = {} + } + + $(document).ready(function(){ + var now, delta + + $(document.body) + .bind('touchstart', function(e){ + now = Date.now() + delta = now - (touch.last || now) + touch.el = $(parentIfText(e.touches[0].target)) + touchTimeout && clearTimeout(touchTimeout) + touch.x1 = e.touches[0].pageX + touch.y1 = e.touches[0].pageY + if (delta > 0 && delta <= 250) touch.isDoubleTap = true + touch.last = now + longTapTimeout = setTimeout(longTap, longTapDelay) + }) + .bind('touchmove', function(e){ + cancelLongTap() + touch.x2 = e.touches[0].pageX + touch.y2 = e.touches[0].pageY + }) + .bind('touchend', function(e){ + cancelLongTap() + + // swipe + if ((touch.x2 && Math.abs(touch.x1 - touch.x2) > 30) || + (touch.y2 && Math.abs(touch.y1 - touch.y2) > 30)) + + swipeTimeout = setTimeout(function() { + touch.el.trigger('swipe') + touch.el.trigger('swipe' + (swipeDirection(touch.x1, touch.x2, touch.y1, touch.y2))) + touch = {} + }, 0) + + // normal tap + else if ('last' in touch) + + // delay by one tick so we can cancel the 'tap' event if 'scroll' fires + // ('tap' fires before 'scroll') + tapTimeout = setTimeout(function() { + + // trigger universal 'tap' with the option to cancelTouch() + // (cancelTouch cancels processing of single vs double taps for faster 'tap' response) + var event = $.Event('tap') + event.cancelTouch = cancelAll + touch.el.trigger(event) + + // trigger double tap immediately + if (touch.isDoubleTap) { + touch.el.trigger('doubleTap') + touch = {} + } + + // trigger single tap after 250ms of inactivity + else { + touchTimeout = setTimeout(function(){ + touchTimeout = null + touch.el.trigger('singleTap') + touch = {} + }, 250) + } + + }, 0) + + }) + .bind('touchcancel', cancelAll) + + $(window).bind('scroll', cancelAll) + }) + + ;['swipe', 'swipeLeft', 'swipeRight', 'swipeUp', 'swipeDown', 'doubleTap', 'tap', 'singleTap', 'longTap'].forEach(function(m){ + $.fn[m] = function(callback){ return this.bind(m, callback) } + }) +})(Zepto) diff --git a/frontend/gamma/js/Zepto/zepto.js b/frontend/gamma/js/Zepto/zepto.js new file mode 100644 index 0000000..e67b3a2 --- a/dev/null +++ b/frontend/gamma/js/Zepto/zepto.js @@ -0,0 +1,751 @@ +// Zepto.js +// (c) 2010-2012 Thomas Fuchs +// Zepto.js may be freely distributed under the MIT license. + +var Zepto = (function() { + var undefined, key, $, classList, emptyArray = [], slice = emptyArray.slice, filter = emptyArray.filter, + document = window.document, + elementDisplay = {}, classCache = {}, + getComputedStyle = document.defaultView.getComputedStyle, + cssNumber = { 'column-count': 1, 'columns': 1, 'font-weight': 1, 'line-height': 1,'opacity': 1, 'z-index': 1, 'zoom': 1 }, + fragmentRE = /^\s*<(\w+|!)[^>]*>/, + tagExpanderRE = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig, + rootNodeRE = /^(?:body|html)$/i, + + // special attributes that should be get/set via method calls + methodAttributes = ['val', 'css', 'html', 'text', 'data', 'width', 'height', 'offset'], + + adjacencyOperators = [ 'after', 'prepend', 'before', 'append' ], + table = document.createElement('table'), + tableRow = document.createElement('tr'), + containers = { + 'tr': document.createElement('tbody'), + 'tbody': table, 'thead': table, 'tfoot': table, + 'td': tableRow, 'th': tableRow, + '*': document.createElement('div') + }, + readyRE = /complete|loaded|interactive/, + classSelectorRE = /^\.([\w-]+)$/, + idSelectorRE = /^#([\w-]*)$/, + tagSelectorRE = /^[\w-]+$/, + toString = {}.toString, + zepto = {}, + camelize, uniq, + tempParent = document.createElement('div') + + zepto.matches = function(element, selector) { + if (!element || element.nodeType !== 1) return false + var matchesSelector = element.webkitMatchesSelector || element.mozMatchesSelector || + element.oMatchesSelector || element.matchesSelector + if (matchesSelector) return matchesSelector.call(element, selector) + // fall back to performing a selector: + var match, parent = element.parentNode, temp = !parent + if (temp) (parent = tempParent).appendChild(element) + match = ~zepto.qsa(parent, selector).indexOf(element) + temp && tempParent.removeChild(element) + return match + } + + function isFunction(value) { return toString.call(value) == "[object Function]" } + function isObject(value) { return value instanceof Object } + function isPlainObject(value) { + return isObject(value) && value != window && value.__proto__ == Object.prototype + } + function isArray(value) { return value instanceof Array } + function likeArray(obj) { return typeof obj.length == 'number' } + + function compact(array) { return filter.call(array, function(item){ return item != null }) } + function flatten(array) { return array.length > 0 ? $.fn.concat.apply([], array) : array } + camelize = function(str){ return str.replace(/-+(.)?/g, function(match, chr){ return chr ? chr.toUpperCase() : '' }) } + function dasherize(str) { + return str.replace(/::/g, '/') + .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2') + .replace(/([a-z\d])([A-Z])/g, '$1_$2') + .replace(/_/g, '-') + .toLowerCase() + } + uniq = function(array){ return filter.call(array, function(item, idx){ return array.indexOf(item) == idx }) } + + function classRE(name) { + return name in classCache ? + classCache[name] : (classCache[name] = new RegExp('(^|\\s)' + name + '(\\s|$)')) + } + + function maybeAddPx(name, value) { + return (typeof value == "number" && !cssNumber[dasherize(name)]) ? value + "px" : value + } + + function defaultDisplay(nodeName) { + var element, display + if (!elementDisplay[nodeName]) { + element = document.createElement(nodeName) + document.body.appendChild(element) + display = getComputedStyle(element, '').getPropertyValue("display") + element.parentNode.removeChild(element) + display == "none" && (display = "block") + elementDisplay[nodeName] = display + } + return elementDisplay[nodeName] + } + + function children(element) { + return 'children' in element ? + slice.call(element.children) : + $.map(element.childNodes, function(node){ if (node.nodeType == 1) return node }) + } + + // `$.zepto.fragment` takes a html string and an optional tag name + // to generate DOM nodes nodes from the given html string. + // The generated DOM nodes are returned as an array. + // This function can be overriden in plugins for example to make + // it compatible with browsers that don't support the DOM fully. + zepto.fragment = function(html, name, properties) { + if (html.replace) html = html.replace(tagExpanderRE, "<$1>") + if (name === undefined) name = fragmentRE.test(html) && RegExp.$1 + if (!(name in containers)) name = '*' + + var nodes, dom, container = containers[name] + container.innerHTML = '' + html + dom = $.each(slice.call(container.childNodes), function(){ + container.removeChild(this) + }) + if (isPlainObject(properties)) { + nodes = $(dom) + $.each(properties, function(key, value) { + if (methodAttributes.indexOf(key) > -1) nodes[key](value) + else nodes.attr(key, value) + }) + } + return dom + } + + // `$.zepto.Z` swaps out the prototype of the given `dom` array + // of nodes with `$.fn` and thus supplying all the Zepto functions + // to the array. Note that `__proto__` is not supported on Internet + // Explorer. This method can be overriden in plugins. + zepto.Z = function(dom, selector) { + dom = dom || [] + dom.__proto__ = arguments.callee.prototype + dom.selector = selector || '' + return dom + } + + // `$.zepto.isZ` should return `true` if the given object is a Zepto + // collection. This method can be overriden in plugins. + zepto.isZ = function(object) { + return object instanceof zepto.Z + } + + // `$.zepto.init` is Zepto's counterpart to jQuery's `$.fn.init` and + // takes a CSS selector and an optional context (and handles various + // special cases). + // This method can be overriden in plugins. + zepto.init = function(selector, context) { + // If nothing given, return an empty Zepto collection + if (!selector) return zepto.Z() + // If a function is given, call it when the DOM is ready + else if (isFunction(selector)) return $(document).ready(selector) + // If a Zepto collection is given, juts return it + else if (zepto.isZ(selector)) return selector + else { + var dom + // normalize array if an array of nodes is given + if (isArray(selector)) dom = compact(selector) + // Wrap DOM nodes. If a plain object is given, duplicate it. + else if (isObject(selector)) + dom = [isPlainObject(selector) ? $.extend({}, selector) : selector], selector = null + // If it's a html fragment, create nodes from it + else if (fragmentRE.test(selector)) + dom = zepto.fragment(selector.trim(), RegExp.$1, context), selector = null + // If there's a context, create a collection on that context first, and select + // nodes from there + else if (context !== undefined) return $(context).find(selector) + // And last but no least, if it's a CSS selector, use it to select nodes. + else dom = zepto.qsa(document, selector) + // create a new Zepto collection from the nodes found + return zepto.Z(dom, selector) + } + } + + // `$` will be the base `Zepto` object. When calling this + // function just call `$.zepto.init, which makes the implementation + // details of selecting nodes and creating Zepto collections + // patchable in plugins. + $ = function(selector, context){ + return zepto.init(selector, context) + } + + function extend(target, source, deep) { + for (key in source) + if (deep && isPlainObject(source[key])) { + if (!isPlainObject(target[key])) target[key] = {} + extend(target[key], source[key], deep) + } + else if (source[key] !== undefined) target[key] = source[key] + } + + // Copy all but undefined properties from one or more + // objects to the `target` object. + $.extend = function(target){ + var deep, args = slice.call(arguments, 1) + if (typeof target == 'boolean') { + deep = target + target = args.shift() + } + args.forEach(function(arg){ extend(target, arg, deep) }) + return target + } + + // `$.zepto.qsa` is Zepto's CSS selector implementation which + // uses `document.querySelectorAll` and optimizes for some special cases, like `#id`. + // This method can be overriden in plugins. + zepto.qsa = function(element, selector){ + var found + return (element === document && idSelectorRE.test(selector)) ? + ( (found = element.getElementById(RegExp.$1)) ? [found] : [] ) : + (element.nodeType !== 1 && element.nodeType !== 9) ? [] : + slice.call( + classSelectorRE.test(selector) ? element.getElementsByClassName(RegExp.$1) : + tagSelectorRE.test(selector) ? element.getElementsByTagName(selector) : + element.querySelectorAll(selector) + ) + } + + function filtered(nodes, selector) { + return selector === undefined ? $(nodes) : $(nodes).filter(selector) + } + + $.contains = function(parent, node) { + return parent !== node && parent.contains(node) + } + + function funcArg(context, arg, idx, payload) { + return isFunction(arg) ? arg.call(context, idx, payload) : arg + } + + function setAttribute(node, name, value) { + value == null ? node.removeAttribute(name) : node.setAttribute(name, value) + } + + // access className property while respecting SVGAnimatedString + function className(node, value){ + var klass = node.className, + svg = klass && klass.baseVal !== undefined + + if (value === undefined) return svg ? klass.baseVal : klass + svg ? (klass.baseVal = value) : (node.className = value) + } + + // "true" => true + // "false" => false + // "null" => null + // "42" => 42 + // "42.5" => 42.5 + // JSON => parse if valid + // String => self + function deserializeValue(value) { + var num + try { + return value ? + value == "true" || + ( value == "false" ? false : + value == "null" ? null : + !isNaN(num = Number(value)) ? num : + /^[\[\{]/.test(value) ? $.parseJSON(value) : + value ) + : value + } catch(e) { + return value + } + } + + $.isFunction = isFunction + $.isObject = isObject + $.isArray = isArray + $.isPlainObject = isPlainObject + + $.inArray = function(elem, array, i){ + return emptyArray.indexOf.call(array, elem, i) + } + + $.camelCase = camelize + $.trim = function(str) { return str.trim() } + + // plugin compatibility + $.uuid = 0 + $.support = { } + $.expr = { } + + $.map = function(elements, callback){ + var value, values = [], i, key + if (likeArray(elements)) + for (i = 0; i < elements.length; i++) { + value = callback(elements[i], i) + if (value != null) values.push(value) + } + else + for (key in elements) { + value = callback(elements[key], key) + if (value != null) values.push(value) + } + return flatten(values) + } + + $.each = function(elements, callback){ + var i, key + if (likeArray(elements)) { + for (i = 0; i < elements.length; i++) + if (callback.call(elements[i], i, elements[i]) === false) return elements + } else { + for (key in elements) + if (callback.call(elements[key], key, elements[key]) === false) return elements + } + + return elements + } + + $.grep = function(elements, callback){ + return filter.call(elements, callback) + } + + if (window.JSON) $.parseJSON = JSON.parse + + // Define methods that will be available on all + // Zepto collections + $.fn = { + // Because a collection acts like an array + // copy over these useful array functions. + forEach: emptyArray.forEach, + reduce: emptyArray.reduce, + push: emptyArray.push, + sort: emptyArray.sort, + indexOf: emptyArray.indexOf, + concat: emptyArray.concat, + + // `map` and `slice` in the jQuery API work differently + // from their array counterparts + map: function(fn){ + return $($.map(this, function(el, i){ return fn.call(el, i, el) })) + }, + slice: function(){ + return $(slice.apply(this, arguments)) + }, + + ready: function(callback){ + if (readyRE.test(document.readyState)) callback($) + else document.addEventListener('DOMContentLoaded', function(){ callback($) }, false) + return this + }, + get: function(idx){ + return idx === undefined ? slice.call(this) : this[idx] + }, + toArray: function(){ return this.get() }, + size: function(){ + return this.length + }, + remove: function(){ + return this.each(function(){ + if (this.parentNode != null) + this.parentNode.removeChild(this) + }) + }, + each: function(callback){ + emptyArray.every.call(this, function(el, idx){ + return callback.call(el, idx, el) !== false + }) + return this + }, + filter: function(selector){ + if (isFunction(selector)) return this.not(this.not(selector)) + return $(filter.call(this, function(element){ + return zepto.matches(element, selector) + })) + }, + add: function(selector,context){ + return $(uniq(this.concat($(selector,context)))) + }, + is: function(selector){ + return this.length > 0 && zepto.matches(this[0], selector) + }, + not: function(selector){ + var nodes=[] + if (isFunction(selector) && selector.call !== undefined) + this.each(function(idx){ + if (!selector.call(this,idx)) nodes.push(this) + }) + else { + var excludes = typeof selector == 'string' ? this.filter(selector) : + (likeArray(selector) && isFunction(selector.item)) ? slice.call(selector) : $(selector) + this.forEach(function(el){ + if (excludes.indexOf(el) < 0) nodes.push(el) + }) + } + return $(nodes) + }, + has: function(selector){ + return this.filter(function(){ + return isObject(selector) ? + $.contains(this, selector) : + $(this).find(selector).size() + }) + }, + eq: function(idx){ + return idx === -1 ? this.slice(idx) : this.slice(idx, + idx + 1) + }, + first: function(){ + var el = this[0] + return el && !isObject(el) ? el : $(el) + }, + last: function(){ + var el = this[this.length - 1] + return el && !isObject(el) ? el : $(el) + }, + find: function(selector){ + var result + if (this.length == 1) result = $(zepto.qsa(this[0], selector)) + else result = this.map(function(){ return zepto.qsa(this, selector) }) + return result + }, + closest: function(selector, context){ + var node = this[0] + while (node && !zepto.matches(node, selector)) + node = node !== context && node !== document && node.parentNode + return $(node) + }, + parents: function(selector){ + var ancestors = [], nodes = this + while (nodes.length > 0) + nodes = $.map(nodes, function(node){ + if ((node = node.parentNode) && node !== document && ancestors.indexOf(node) < 0) { + ancestors.push(node) + return node + } + }) + return filtered(ancestors, selector) + }, + parent: function(selector){ + return filtered(uniq(this.pluck('parentNode')), selector) + }, + children: function(selector){ + return filtered(this.map(function(){ return children(this) }), selector) + }, + contents: function() { + return this.map(function() { return slice.call(this.childNodes) }) + }, + siblings: function(selector){ + return filtered(this.map(function(i, el){ + return filter.call(children(el.parentNode), function(child){ return child!==el }) + }), selector) + }, + empty: function(){ + return this.each(function(){ this.innerHTML = '' }) + }, + // `pluck` is borrowed from Prototype.js + pluck: function(property){ + return $.map(this, function(el){ return el[property] }) + }, + show: function(){ + return this.each(function(){ + this.style.display == "none" && (this.style.display = null) + if (getComputedStyle(this, '').getPropertyValue("display") == "none") + this.style.display = defaultDisplay(this.nodeName) + }) + }, + replaceWith: function(newContent){ + return this.before(newContent).remove() + }, + wrap: function(structure){ + var func = isFunction(structure) + if (this[0] && !func) + var dom = $(structure).get(0), + clone = dom.parentNode || this.length > 1 + + return this.each(function(index){ + $(this).wrapAll( + func ? structure.call(this, index) : + clone ? dom.cloneNode(true) : dom + ) + }) + }, + wrapAll: function(structure){ + if (this[0]) { + $(this[0]).before(structure = $(structure)) + var children + // drill down to the inmost element + while ((children = structure.children()).length) structure = children.first() + $(structure).append(this) + } + return this + }, + wrapInner: function(structure){ + var func = isFunction(structure) + return this.each(function(index){ + var self = $(this), contents = self.contents(), + dom = func ? structure.call(this, index) : structure + contents.length ? contents.wrapAll(dom) : self.append(dom) + }) + }, + unwrap: function(){ + this.parent().each(function(){ + $(this).replaceWith($(this).children()) + }) + return this + }, + clone: function(){ + return this.map(function(){ return this.cloneNode(true) }) + }, + hide: function(){ + return this.css("display", "none") + }, + toggle: function(setting){ + return this.each(function(){ + var el = $(this) + ;(setting === undefined ? el.css("display") == "none" : setting) ? el.show() : el.hide() + }) + }, + prev: function(selector){ return $(this.pluck('previousElementSibling')).filter(selector || '*') }, + next: function(selector){ return $(this.pluck('nextElementSibling')).filter(selector || '*') }, + html: function(html){ + return html === undefined ? + (this.length > 0 ? this[0].innerHTML : null) : + this.each(function(idx){ + var originHtml = this.innerHTML + $(this).empty().append( funcArg(this, html, idx, originHtml) ) + }) + }, + text: function(text){ + return text === undefined ? + (this.length > 0 ? this[0].textContent : null) : + this.each(function(){ this.textContent = text }) + }, + attr: function(name, value){ + var result + return (typeof name == 'string' && value === undefined) ? + (this.length == 0 || this[0].nodeType !== 1 ? undefined : + (name == 'value' && this[0].nodeName == 'INPUT') ? this.val() : + (!(result = this[0].getAttribute(name)) && name in this[0]) ? this[0][name] : result + ) : + this.each(function(idx){ + if (this.nodeType !== 1) return + if (isObject(name)) for (key in name) setAttribute(this, key, name[key]) + else setAttribute(this, name, funcArg(this, value, idx, this.getAttribute(name))) + }) + }, + removeAttr: function(name){ + return this.each(function(){ this.nodeType === 1 && setAttribute(this, name) }) + }, + prop: function(name, value){ + return (value === undefined) ? + (this[0] && this[0][name]) : + this.each(function(idx){ + this[name] = funcArg(this, value, idx, this[name]) + }) + }, + data: function(name, value){ + var data = this.attr('data-' + dasherize(name), value) + return data !== null ? deserializeValue(data) : undefined + }, + val: function(value){ + return (value === undefined) ? + (this[0] && (this[0].multiple ? + $(this[0]).find('option').filter(function(o){ return this.selected }).pluck('value') : + this[0].value) + ) : + this.each(function(idx){ + this.value = funcArg(this, value, idx, this.value) + }) + }, + offset: function(coordinates){ + if (coordinates) return this.each(function(index){ + var $this = $(this), + coords = funcArg(this, coordinates, index, $this.offset()), + parentOffset = $this.offsetParent().offset(), + props = { + top: coords.top - parentOffset.top, + left: coords.left - parentOffset.left + } + + if ($this.css('position') == 'static') props['position'] = 'relative' + $this.css(props) + }) + if (this.length==0) return null + var obj = this[0].getBoundingClientRect() + return { + left: obj.left + window.pageXOffset, + top: obj.top + window.pageYOffset, + width: obj.width, + height: obj.height + } + }, + css: function(property, value){ + if (arguments.length < 2 && typeof property == 'string') + return this[0] && (this[0].style[camelize(property)] || getComputedStyle(this[0], '').getPropertyValue(property)) + + var css = '' + for (key in property) + if (!property[key] && property[key] !== 0) + this.each(function(){ this.style.removeProperty(dasherize(key)) }) + else + css += dasherize(key) + ':' + maybeAddPx(key, property[key]) + ';' + + if (typeof property == 'string') + if (!value && value !== 0) + this.each(function(){ this.style.removeProperty(dasherize(property)) }) + else + css = dasherize(property) + ":" + maybeAddPx(property, value) + + return this.each(function(){ this.style.cssText += ';' + css }) + }, + index: function(element){ + return element ? this.indexOf($(element)[0]) : this.parent().children().indexOf(this[0]) + }, + hasClass: function(name){ + return emptyArray.some.call(this, function(el){ + return this.test(className(el)) + }, classRE(name)) + }, + addClass: function(name){ + return this.each(function(idx){ + classList = [] + var cls = className(this), newName = funcArg(this, name, idx, cls) + newName.split(/\s+/g).forEach(function(klass){ + if (!$(this).hasClass(klass)) classList.push(klass) + }, this) + classList.length && className(this, cls + (cls ? " " : "") + classList.join(" ")) + }) + }, + removeClass: function(name){ + return this.each(function(idx){ + if (name === undefined) return className(this, '') + classList = className(this) + funcArg(this, name, idx, classList).split(/\s+/g).forEach(function(klass){ + classList = classList.replace(classRE(klass), " ") + }) + className(this, classList.trim()) + }) + }, + toggleClass: function(name, when){ + return this.each(function(idx){ + var newName = funcArg(this, name, idx, className(this)) + ;(when === undefined ? !$(this).hasClass(newName) : when) ? + $(this).addClass(newName) : $(this).removeClass(newName) + }) + }, + scrollTop: function(){ + if (!this.length) return + return ('scrollTop' in this[0]) ? this[0].scrollTop : this[0].scrollY + }, + position: function() { + if (!this.length) return + + var elem = this[0], + // Get *real* offsetParent + offsetParent = this.offsetParent(), + // Get correct offsets + offset = this.offset(), + parentOffset = rootNodeRE.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset() + + // Subtract element margins + // note: when an element has margin: auto the offsetLeft and marginLeft + // are the same in Safari causing offset.left to incorrectly be 0 + offset.top -= parseFloat( $(elem).css('margin-top') ) || 0 + offset.left -= parseFloat( $(elem).css('margin-left') ) || 0 + + // Add offsetParent borders + parentOffset.top += parseFloat( $(offsetParent[0]).css('border-top-width') ) || 0 + parentOffset.left += parseFloat( $(offsetParent[0]).css('border-left-width') ) || 0 + + // Subtract the two offsets + return { + top: offset.top - parentOffset.top, + left: offset.left - parentOffset.left + } + }, + offsetParent: function() { + return this.map(function(){ + var parent = this.offsetParent || document.body + while (parent && !rootNodeRE.test(parent.nodeName) && $(parent).css("position") == "static") + parent = parent.offsetParent + return parent + }) + } + } + + // for now + $.fn.detach = $.fn.remove + + // Generate the `width` and `height` functions + ;['width', 'height'].forEach(function(dimension){ + $.fn[dimension] = function(value){ + var offset, Dimension = dimension.replace(/./, function(m){ return m[0].toUpperCase() }) + if (value === undefined) return this[0] == window ? window['inner' + Dimension] : + this[0] == document ? document.documentElement['offset' + Dimension] : + (offset = this.offset()) && offset[dimension] + else return this.each(function(idx){ + var el = $(this) + el.css(dimension, funcArg(this, value, idx, el[dimension]())) + }) + } + }) + + function traverseNode(node, fun) { + fun(node) + for (var key in node.childNodes) traverseNode(node.childNodes[key], fun) + } + + // Generate the `after`, `prepend`, `before`, `append`, + // `insertAfter`, `insertBefore`, `appendTo`, and `prependTo` methods. + adjacencyOperators.forEach(function(operator, operatorIndex) { + var inside = operatorIndex % 2 //=> prepend, append + + $.fn[operator] = function(){ + // arguments can be nodes, arrays of nodes, Zepto objects and HTML strings + var nodes = $.map(arguments, function(n){ return isObject(n) ? n : zepto.fragment(n) }), + parent, copyByClone = this.length > 1 + if (nodes.length < 1) return this + + return this.each(function(_, target){ + parent = inside ? target : target.parentNode + + // convert all methods to a "before" operation + target = operatorIndex == 0 ? target.nextSibling : + operatorIndex == 1 ? target.firstChild : + operatorIndex == 2 ? target : + null + + nodes.forEach(function(node){ + if (copyByClone) node = node.cloneNode(true) + else if (!parent) return $(node).remove() + + traverseNode(parent.insertBefore(node, target), function(el){ + if (el.nodeName != null && el.nodeName.toUpperCase() === 'SCRIPT' && + (!el.type || el.type === 'text/javascript') && !el.src) + window['eval'].call(window, el.innerHTML) + }) + }) + }) + } + + // after => insertAfter + // prepend => prependTo + // before => insertBefore + // append => appendTo + $.fn[inside ? operator+'To' : 'insert'+(operatorIndex ? 'Before' : 'After')] = function(html){ + $(html)[operator](this) + return this + } + }) + + zepto.Z.prototype = $.fn + + // Export internal API functions in the `$.zepto` namespace + zepto.uniq = uniq + zepto.deserializeValue = deserializeValue + $.zepto = zepto + + return $ +})() + +// If `$` is not yet defined, point it to `Zepto` +window.Zepto = Zepto +'$' in window || (window.$ = Zepto) -- cgit v0.9.0.2