lc_alchemy_cms 3.2.0

data/vendor/assets/javascripts/jquery_plugins/jquery.ui.tabspaging.js

@@ -0,0 +1,296 @@
+/*
+ * UI Tabs Paging extension - v1.2.2 (for jQuery 1.9.0 and jQuery UI 1.9.0)
+ *
+ * Copyright (c) 2013, http://seyfertdesign.com/jquery/ui-tabs-paging.html
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * Depends:
+ *   jquery.ui.core.js
+ *   jquery.ui.widget.js
+ *   jquery.ui.tabs.js
+ */
+
+(function($) {
+
+//  overridden ui.tabs functions
+var uiTabsFuncs = {
+  refresh: $.ui.tabs.prototype.refresh,
+  option: $.ui.tabs.prototype.option
+};
+
+$.extend($.ui.tabs.prototype, {
+  paging: function(options) {
+    var opts = {
+      tabsPerPage: 0,       // Max number of tabs to display at one time.  0 automatically sizing.
+      nextButton: '»', // Text displayed for next button.
+      prevButton: '«', // Text displayed for previous button.
+      follow: false,        // When clicking next button, automatically make first tab active.  When clicking previous button automatically make last tab active.
+      cycle: false,         // When at end of list, next button returns to first page.  When at beginning of list previous button goes to end of list.
+      activeOnAdd: false,   // When new tab is added, make tab active automatically
+      followOnActive: false // When tab is changed to active, automatically go move to that tab group.
+    };
+
+    opts = $.extend(opts, options);
+
+    var self = this, initialized = false, currentPage,
+      buttonWidth, containerWidth, allTabsWidth, tabWidths,
+      maxPageWidth, pages, resizeTimer = null,
+      windowHeight, windowWidth;
+
+    // initialize paging
+    function init() {
+      destroy();
+
+      windowHeight = $(window).height();
+      windowWidth = $(window).width();
+
+      allTabsWidth = 0, currentPage = 0, maxPageWidth = 0, buttonWidth = 0,
+        pages = new Array(), tabWidths = new Array(), selectedTabWidths = new Array();
+
+      containerWidth = self.element.width();
+
+      // loops through LIs, get width of each tab when selected and unselected.
+      var maxDiff = 0;  // the max difference between a selected and unselected tab
+      self.tabs.each(function(i) {
+        if (i == self.options.active) {
+          selectedTabWidths[i] = $(this).outerWidth(true);
+          tabWidths[i] = self.tabs.eq(i).removeClass('ui-tabs-active').outerWidth(true);
+          self.tabs.eq(i).addClass('ui-tabs-active');
+          maxDiff = Math.min(maxDiff, Math.abs(selectedTabWidths[i] - tabWidths[i]));
+          allTabsWidth += tabWidths[i];
+        } else {
+          tabWidths[i] = $(this).outerWidth(true);
+          selectedTabWidths[i] = self.tabs.eq(i).addClass('ui-tabs-active').outerWidth(true);
+          self.tabs.eq(i).removeClass('ui-tabs-active');
+          maxDiff = Math.max(maxDiff, Math.abs(selectedTabWidths[i] - tabWidths[i]));
+          allTabsWidth += tabWidths[i];
+        }
+      });
+
+      // fix padding issues with buttons
+      // TODO determine a better way to handle this
+      allTabsWidth += maxDiff + 9;
+
+      // if the width of all tables is greater than the container's width, calculate the pages
+      if (allTabsWidth > containerWidth) {
+        // create next button
+        li = $('<li></li>')
+          .addClass('ui-state-default ui-tabs-paging-next')
+          .append($('<a href="#"></a>')
+              .click(function() { page('next'); return false; })
+              .html(opts.nextButton));
+
+        self.tablist.append(li);
+        buttonWidth = li.outerWidth(true);
+
+        // create prev button
+        li = $('<li></li>')
+          .addClass('ui-state-default ui-tabs-paging-prev')
+          .append($('<a href="#"></a>')
+              .click(function() { page('prev'); return false; })
+              .html(opts.prevButton));
+        self.tablist.prepend(li);
+        buttonWidth += li.outerWidth(true);
+
+        // TODO determine fix for padding issues to next button
+        buttonWidth += 19;
+
+        var pageIndex = 0, pageWidth = 0, maxTabPadding = 0;
+
+        // start calculating pageWidths
+        for (var i = 0; i < tabWidths.length; i++) {
+          // if first tab of page or selected tab's padding larger than the current max, set the maxTabPadding
+          if (pageWidth == 0 || selectedTabWidths[i] - tabWidths[i] > maxTabPadding)
+            maxTabPadding = (selectedTabWidths[i] - tabWidths[i]);
+
+          // if first tab of page, initialize pages variable for page
+          if (pages[pageIndex] == null) {
+            pages[pageIndex] = { start: i };
+
+          } else if ((i > 0 && (i % opts.tabsPerPage) == 0) || (tabWidths[i] + pageWidth + buttonWidth + 12) > containerWidth) {
+            if ((pageWidth + maxTabPadding) > maxPageWidth)
+              maxPageWidth = (pageWidth + maxTabPadding);
+            pageIndex++;
+            pages[pageIndex] = { start: i };
+            pageWidth = 0;
+          }
+          pages[pageIndex].end = i+1;
+          pageWidth += tabWidths[i];
+          if (i == self.options.active) currentPage = pageIndex;
+        }
+        if ((pageWidth + maxTabPadding) > maxPageWidth)
+          maxPageWidth = (pageWidth + maxTabPadding);
+
+          // hide all tabs then show tabs for current page
+        self.tabs.hide().slice(pages[currentPage].start, pages[currentPage].end).show();
+        if (currentPage == (pages.length - 1) && !opts.cycle)
+          disableButton('next');
+        if (currentPage == 0 && !opts.cycle)
+          disableButton('prev');
+
+        // calculate the right padding for the next button
+        buttonPadding = containerWidth - maxPageWidth - buttonWidth;
+        if (buttonPadding > 0)
+          $('.ui-tabs-paging-next', self.element).css({ paddingRight: buttonPadding + 'px' });
+      } else {
+        destroy();
+      }
+
+      $(window).bind('resize', handleResize);
+
+      initialized = true;
+    }
+
+    // handles paging forward and backward
+    function page(direction) {
+      currentPage = currentPage + (direction == 'prev'?-1:1);
+
+      if ((direction == 'prev' && currentPage < 0 && opts.cycle) ||
+        (direction == 'next' && currentPage >= pages.length && !opts.cycle))
+        currentPage = pages.length - 1;
+      else if ((direction == 'prev' && currentPage < 0) ||
+           (direction == 'next' && currentPage >= pages.length && opts.cycle))
+        currentPage = 0;
+
+      var start = pages[currentPage].start;
+      var end = pages[currentPage].end;
+      self.tabs.hide().slice(start, end).show();
+
+      if (direction == 'prev') {
+        enableButton('next');
+        if (opts.follow && (self.options.active < start || self.options.active > (end-1))) self.option('active', end-1);
+        if (!opts.cycle && start <= 0) disableButton('prev');
+      } else {
+        enableButton('prev');
+        if (opts.follow && (self.options.active < start || self.options.active > (end-1))) self.option('active', start);
+        if (!opts.cycle && end >= self.tabs.length) disableButton('next');
+      }
+    }
+
+    // change styling of next/prev buttons when disabled
+    function disableButton(direction) {
+      $('.ui-tabs-paging-'+direction, self.element).addClass('ui-tabs-paging-disabled');
+    }
+
+    function enableButton(direction) {
+      $('.ui-tabs-paging-'+direction, self.element).removeClass('ui-tabs-paging-disabled');
+    }
+
+    // special function defined to handle IE resize issues
+    function handleResize() {
+      if (resizeTimer) clearTimeout(resizeTimer);
+
+      if (windowHeight != $(window).height() || windowWidth != $(window).width())
+      {
+        resizeTimer = setTimeout(init, 100);
+      }
+    }
+
+    // remove all paging related changes and events
+    function destroy() {
+      // remove buttons
+      $('.ui-tabs-paging-next', self.element).remove();
+      $('.ui-tabs-paging-prev', self.element).remove();
+
+      // show all tabs
+      self.tabs.show();
+
+      initialized = false;
+
+      $(window).unbind('resize', handleResize);
+    }
+
+
+
+    // ------------- OVERRIDDEN PUBLIC FUNCTIONS -------------
+    self.option = function(optionName, value) {
+      var retVal = uiTabsFuncs.option.apply(this, [optionName, value]);
+
+      // if "followOnActive" is true, then move page when selection changes
+      if (optionName == "active")
+      {
+        // if paging is not initialized or it is not configured to
+        // change pages when a new tab is active, then do nothing
+        if (!initialized || !opts.followOnActive)
+          return retVal;
+
+        // find the new page based on index of the active tab
+        for (var i in pages) {
+          var start = pages[i].start;
+          var end = pages[i].end;
+          if (value >= start && value < end) {
+            // if the the active tab is not within the currentPage of tabs, then change pages
+            if (i != currentPage) {
+              this.tabs.hide().slice(start, end).show();
+
+              currentPage = parseInt(i);
+              if (currentPage == 0) {
+                enableButton('next');
+                if (!opts.cycle && start <= 0) disableButton('prev');
+              } else {
+                enableButton('prev');
+                if (!opts.cycle && end >= this.tabs.length) disableButton('next');
+              }
+            }
+            break;
+          }
+        }
+      }
+
+      return retVal;
+    }
+
+    self.refresh = function() {
+      if (initialized)
+      {
+        destroy();
+
+        uiTabsFuncs.refresh.apply(this);
+
+        // re-initialize paging buttons
+        init();
+      }
+
+      uiTabsFuncs.refresh.apply(this);
+    }
+
+
+    // ------------- PUBLIC FUNCTIONS -------------
+    $.extend($.ui.tabs.prototype, {
+      // public function for removing paging
+      pagingDestroy: function() {
+        destroy();
+        return this;
+      },
+
+      // public function to handle resizes that are not on the window
+      pagingResize: function() {
+        init();
+        return this;
+      }
+    });
+
+    // initialize on startup!
+    init();
+  }
+});
+
+
+})(jQuery);

data/vendor/assets/javascripts/keymaster.js

@@ -0,0 +1,296 @@
+//     keymaster.js
+//     (c) 2011-2013 Thomas Fuchs
+//     keymaster.js may be freely distributed under the MIT license.
+
+;(function(global){
+  var k,
+    _handlers = {},
+    _mods = { 16: false, 18: false, 17: false, 91: false },
+    _scope = 'all',
+    // modifier keys
+    _MODIFIERS = {
+      '⇧': 16, shift: 16,
+      '⌥': 18, alt: 18, option: 18,
+      '⌃': 17, ctrl: 17, control: 17,
+      '⌘': 91, command: 91
+    },
+    // special keys
+    _MAP = {
+      backspace: 8, tab: 9, clear: 12,
+      enter: 13, 'return': 13,
+      esc: 27, escape: 27, space: 32,
+      left: 37, up: 38,
+      right: 39, down: 40,
+      del: 46, 'delete': 46,
+      home: 36, end: 35,
+      pageup: 33, pagedown: 34,
+      ',': 188, '.': 190, '/': 191,
+      '`': 192, '-': 189, '=': 187,
+      ';': 186, '\'': 222,
+      '[': 219, ']': 221, '\\': 220
+    },
+    code = function(x){
+      return _MAP[x] || x.toUpperCase().charCodeAt(0);
+    },
+    _downKeys = [];
+
+  for(k=1;k<20;k++) _MAP['f'+k] = 111+k;
+
+  // IE doesn't support Array#indexOf, so have a simple replacement
+  function index(array, item){
+    var i = array.length;
+    while(i--) if(array[i]===item) return i;
+    return -1;
+  }
+
+  // for comparing mods before unassignment
+  function compareArray(a1, a2) {
+    if (a1.length != a2.length) return false;
+    for (var i = 0; i < a1.length; i++) {
+        if (a1[i] !== a2[i]) return false;
+    }
+    return true;
+  }
+
+  var modifierMap = {
+      16:'shiftKey',
+      18:'altKey',
+      17:'ctrlKey',
+      91:'metaKey'
+  };
+  function updateModifierKey(event) {
+      for(k in _mods) _mods[k] = event[modifierMap[k]];
+  };
+
+  // handle keydown event
+  function dispatch(event) {
+    var key, handler, k, i, modifiersMatch, scope;
+    key = event.keyCode;
+
+    if (index(_downKeys, key) == -1) {
+        _downKeys.push(key);
+    }
+
+    // if a modifier key, set the key.<modifierkeyname> property to true and return
+    if(key == 93 || key == 224) key = 91; // right command on webkit, command on Gecko
+    if(key in _mods) {
+      _mods[key] = true;
+      // 'assignKey' from inside this closure is exported to window.key
+      for(k in _MODIFIERS) if(_MODIFIERS[k] == key) assignKey[k] = true;
+      return;
+    }
+    updateModifierKey(event);
+
+    // see if we need to ignore the keypress (filter() can can be overridden)
+    // by default ignore key presses if a select, textarea, or input is focused
+    if(!assignKey.filter.call(this, event)) return;
+
+    // abort if no potentially matching shortcuts found
+    if (!(key in _handlers)) return;
+
+    scope = getScope();
+
+    // for each potential shortcut
+    for (i = 0; i < _handlers[key].length; i++) {
+      handler = _handlers[key][i];
+
+      // see if it's in the current scope
+      if(handler.scope == scope || handler.scope == 'all'){
+        // check if modifiers match if any
+        modifiersMatch = handler.mods.length > 0;
+        for(k in _mods)
+          if((!_mods[k] && index(handler.mods, +k) > -1) ||
+            (_mods[k] && index(handler.mods, +k) == -1)) modifiersMatch = false;
+        // call the handler and stop the event if neccessary
+        if((handler.mods.length == 0 && !_mods[16] && !_mods[18] && !_mods[17] && !_mods[91]) || modifiersMatch){
+          if(handler.method(event, handler)===false){
+            if(event.preventDefault) event.preventDefault();
+              else event.returnValue = false;
+            if(event.stopPropagation) event.stopPropagation();
+            if(event.cancelBubble) event.cancelBubble = true;
+          }
+        }
+      }
+    }
+  };
+
+  // unset modifier keys on keyup
+  function clearModifier(event){
+    var key = event.keyCode, k,
+        i = index(_downKeys, key);
+
+    // remove key from _downKeys
+    if (i >= 0) {
+        _downKeys.splice(i, 1);
+    }
+
+    if(key == 93 || key == 224) key = 91;
+    if(key in _mods) {
+      _mods[key] = false;
+      for(k in _MODIFIERS) if(_MODIFIERS[k] == key) assignKey[k] = false;
+    }
+  };
+
+  function resetModifiers() {
+    for(k in _mods) _mods[k] = false;
+    for(k in _MODIFIERS) assignKey[k] = false;
+  };
+
+  // parse and assign shortcut
+  function assignKey(key, scope, method){
+    var keys, mods;
+    keys = getKeys(key);
+    if (method === undefined) {
+      method = scope;
+      scope = 'all';
+    }
+
+    // for each shortcut
+    for (var i = 0; i < keys.length; i++) {
+      // set modifier keys if any
+      mods = [];
+      key = keys[i].split('+');
+      if (key.length > 1){
+        mods = getMods(key);
+        key = [key[key.length-1]];
+      }
+      // convert to keycode and...
+      key = key[0]
+      key = code(key);
+      // ...store handler
+      if (!(key in _handlers)) _handlers[key] = [];
+      _handlers[key].push({ shortcut: keys[i], scope: scope, method: method, key: keys[i], mods: mods });
+    }
+  };
+
+  // unbind all handlers for given key in current scope
+  function unbindKey(key, scope) {
+    var multipleKeys, keys,
+      mods = [],
+      i, j, obj;
+
+    multipleKeys = getKeys(key);
+
+    for (j = 0; j < multipleKeys.length; j++) {
+      keys = multipleKeys[j].split('+');
+
+      if (keys.length > 1) {
+        mods = getMods(keys);
+        key = keys[keys.length - 1];
+      }
+
+      key = code(key);
+
+      if (scope === undefined) {
+        scope = getScope();
+      }
+      if (!_handlers[key]) {
+        return;
+      }
+      for (i in _handlers[key]) {
+        obj = _handlers[key][i];
+        // only clear handlers if correct scope and mods match
+        if (obj.scope === scope && compareArray(obj.mods, mods)) {
+          _handlers[key][i] = {};
+        }
+      }
+    }
+  };
+
+  // Returns true if the key with code 'keyCode' is currently down
+  // Converts strings into key codes.
+  function isPressed(keyCode) {
+      if (typeof(keyCode)=='string') {
+        keyCode = code(keyCode);
+      }
+      return index(_downKeys, keyCode) != -1;
+  }
+
+  function getPressedKeyCodes() {
+      return _downKeys.slice(0);
+  }
+
+  function filter(event){
+    var tagName = (event.target || event.srcElement).tagName;
+    // ignore keypressed in any elements that support keyboard data input
+    return !(tagName == 'INPUT' || tagName == 'SELECT' || tagName == 'TEXTAREA');
+  }
+
+  // initialize key.<modifier> to false
+  for(k in _MODIFIERS) assignKey[k] = false;
+
+  // set current scope (default 'all')
+  function setScope(scope){ _scope = scope || 'all' };
+  function getScope(){ return _scope || 'all' };
+
+  // delete all handlers for a given scope
+  function deleteScope(scope){
+    var key, handlers, i;
+
+    for (key in _handlers) {
+      handlers = _handlers[key];
+      for (i = 0; i < handlers.length; ) {
+        if (handlers[i].scope === scope) handlers.splice(i, 1);
+        else i++;
+      }
+    }
+  };
+
+  // abstract key logic for assign and unassign
+  function getKeys(key) {
+    var keys;
+    key = key.replace(/\s/g, '');
+    keys = key.split(',');
+    if ((keys[keys.length - 1]) == '') {
+      keys[keys.length - 2] += ',';
+    }
+    return keys;
+  }
+
+  // abstract mods logic for assign and unassign
+  function getMods(key) {
+    var mods = key.slice(0, key.length - 1);
+    for (var mi = 0; mi < mods.length; mi++)
+    mods[mi] = _MODIFIERS[mods[mi]];
+    return mods;
+  }
+
+  // cross-browser events
+  function addEvent(object, event, method) {
+    if (object.addEventListener)
+      object.addEventListener(event, method, false);
+    else if(object.attachEvent)
+      object.attachEvent('on'+event, function(){ method(window.event) });
+  };
+
+  // set the handlers globally on document
+  addEvent(document, 'keydown', function(event) { dispatch(event) }); // Passing _scope to a callback to ensure it remains the same by execution. Fixes #48
+  addEvent(document, 'keyup', clearModifier);
+
+  // reset modifiers to false whenever the window is (re)focused.
+  addEvent(window, 'focus', resetModifiers);
+
+  // store previously defined key
+  var previousKey = global.key;
+
+  // restore previously defined key and return reference to our key object
+  function noConflict() {
+    var k = global.key;
+    global.key = previousKey;
+    return k;
+  }
+
+  // set window.key and window.key.set/get/deleteScope, and the default filter
+  global.key = assignKey;
+  global.key.setScope = setScope;
+  global.key.getScope = getScope;
+  global.key.deleteScope = deleteScope;
+  global.key.filter = filter;
+  global.key.isPressed = isPressed;
+  global.key.getPressedKeyCodes = getPressedKeyCodes;
+  global.key.noConflict = noConflict;
+  global.key.unbind = unbindKey;
+
+  if(typeof module !== 'undefined') module.exports = key;
+
+})(this);