fix

src/views/courseware-list/component/book/index.tsx

@@ -53,8 +53,8 @@ export default defineComponent({
       });
     };
     const init = async () => {
-      await handleCreate('jquery', '/book/jquery.min.1.7.js');
-      await handleCreate('turn', '/book/turn.js');
+    //   await handleCreate('jquery', '/book/jquery.min.1.7.js');
+    //   await handleCreate('turn', '/book/turn.js');
       console.log('初始化完成');
     };
     let book: any = null;

src/views/courseware-list/index.tsx

@@ -23,6 +23,9 @@ import { useRouter } from 'vue-router';
 import TheBook from './component/book';
 import { postMessage } from '@/helpers/native-message';
 
+import './jquery.min.1.7.js';
+import './turn.js'
+
 export const BOOK_DATA = {
   grades: [
     { text: '全部年级', value: '' },

src/views/courseware-list/turn.js

@@ -0,0 +1,3352 @@
+/**
+ * turn.js 4th release
+ * turnjs.com
+ * turnjs.com/license.txt
+ *
+ * Copyright (C) 2012 Emmanuel Garcia
+ * All rights reserved
+ **/
+
+(function($) {
+
+'use strict';
+
+var has3d,
+  
+  hasRot,
+
+  vendor = '',
+  
+  version = '4.1.0',
+
+  PI = Math.PI,
+
+  A90 = PI/2,
+
+  isTouch = 'ontouchstart' in window,
+
+  mouseEvents = (isTouch) ?
+    {
+      down: 'touchstart',
+      move: 'touchmove',
+      up: 'touchend',
+      over: 'touchstart',
+      out: 'touchend'
+    }
+    :
+    {
+      down: 'mousedown',
+      move: 'mousemove',
+      up: 'mouseup',
+      over: 'mouseover',
+      out: 'mouseout'
+    },
+
+  // Contansts used for each corner
+  //   | tl * tr |
+  // l | *     * | r
+  //   | bl * br |
+
+  corners = {
+    backward: ['bl', 'tl'],
+    forward: ['br', 'tr'],
+    all: ['tl', 'bl', 'tr', 'br', 'l', 'r']
+  },
+
+  // Display values
+
+  displays = ['single', 'double'],
+
+  // Direction values
+
+  directions = ['ltr', 'rtl'],
+
+  // Default options
+
+  turnOptions = {
+
+    // Enables hardware acceleration
+
+    acceleration: true,
+
+    // Display
+
+    display: 'double',
+
+    // Duration of transition in milliseconds
+
+    duration: 600,
+
+    // First page
+
+    page: 1,
+    
+    // Enables gradients
+
+    gradients: true,
+
+    // Corners used when turning the page
+
+    turnCorners: 'bl,br',
+
+    // Events
+
+    when: null
+  },
+
+  flipOptions = {
+
+    // Size of the active zone of each corner
+
+    cornerSize: 100
+
+  },
+
+  // Number of pages in the DOM, minimum value: 6
+
+  pagesInDOM = 6,
+  
+
+turnMethods = {
+
+  // Singleton constructor
+  // $('#selector').turn([options]);
+
+  init: function(options) {
+
+    // Define constants
+    
+    has3d = 'WebKitCSSMatrix' in window || 'MozPerspective' in document.body.style;
+    hasRot = rotationAvailable();
+    vendor = getPrefix();
+
+    var i, that = this, pageNum = 0, data = this.data(), ch = this.children();
+
+    // Set initial configuration
+
+    options = $.extend({
+      width: this.width(),
+      height: this.height(),
+      direction: this.attr('dir') || this.css('direction') || 'ltr'
+    }, turnOptions, options);
+
+    data.opts = options;
+    data.pageObjs = {};
+    data.pages = {};
+    data.pageWrap = {};
+    data.pageZoom = {};
+    data.pagePlace = {};
+    data.pageMv = [];
+    data.zoom = 1;
+    data.totalPages = options.pages || 0;
+    data.eventHandlers = {
+      touchStart: $.proxy(turnMethods._touchStart, this),
+      touchMove: $.proxy(turnMethods._touchMove, this),
+      touchEnd: $.proxy(turnMethods._touchEnd, this),
+      start: $.proxy(turnMethods._eventStart, this)
+    };
+
+
+
+    // Add event listeners
+
+    if (options.when)
+      for (i in options.when)
+        if (has(i, options.when))
+          this.bind(i, options.when[i]);
+
+    // Set the css
+
+    this.css({position: 'relative', width: options.width, height: options.height});
+
+    // Set the initial display
+
+    this.turn('display', options.display);
+
+    // Set the direction
+
+    if (options.direction!=='')
+      this.turn('direction', options.direction);
+    
+    // Prevent blue screen problems of switching to hardware acceleration mode
+    // By forcing hardware acceleration for ever
+
+    if (has3d && !isTouch && options.acceleration)
+      this.transform(translate(0, 0, true));
+
+    // Add pages from the DOM
+
+    for (i = 0; i<ch.length; i++) {
+      if ($(ch[i]).attr('ignore')!='1') {
+        this.turn('addPage', ch[i], ++pageNum);
+      }
+    }
+
+    // Event listeners
+
+    $(this).bind(mouseEvents.down, data.eventHandlers.touchStart).
+      bind('end', turnMethods._eventEnd).
+      bind('pressed', turnMethods._eventPressed).
+      bind('released', turnMethods._eventReleased).
+      bind('flip', turnMethods._flip);
+
+    $(this).parent().bind('start', data.eventHandlers.start);
+
+    $(document).bind(mouseEvents.move, data.eventHandlers.touchMove).
+      bind(mouseEvents.up, data.eventHandlers.touchEnd);
+
+    // Set the initial page
+
+    this.turn('page', options.page);
+
+    // This flipbook is ready
+
+    data.done = true;
+
+    return this;
+  },
+
+  // Adds a page from external data
+
+  addPage: function(element, page) {
+
+    var currentPage,
+      className,
+      incPages = false,
+      data = this.data(),
+      lastPage = data.totalPages+1;
+
+    if (data.destroying)
+      return false;
+
+    // Read the page number from the className of `element` - format: p[0-9]+
+
+    if ((currentPage = /\bp([0-9]+)\b/.exec($(element).attr('class'))))
+      page = parseInt(currentPage[1], 10);
+
+    if (page) {
+      
+      if (page==lastPage)
+        incPages = true;
+      else if (page>lastPage)
+        throw turnError('Page "'+page+'" cannot be inserted');
+
+    } else {
+      
+      page = lastPage;
+      incPages = true;
+
+    }
+
+    if (page>=1 && page<=lastPage) {
+
+      if (data.display=='double')
+        className = (page%2) ? ' odd' : ' even';
+      else
+        className = '';
+
+      // Stop animations
+      if (data.done)
+        this.turn('stop');
+
+      // Move pages if it's necessary
+      if (page in data.pageObjs)
+        turnMethods._movePages.call(this, page, 1);
+
+      // Increase the number of pages
+      if (incPages)
+        data.totalPages = lastPage;
+
+      // Add element
+      data.pageObjs[page] = $(element).
+        css({'float': 'left'}).
+        addClass('page p' + page + className);
+
+      if (!hasHardPage() &&  data.pageObjs[page].hasClass('hard')) {
+        data.pageObjs[page].removeClass('hard');
+      }
+
+      // Add page
+      turnMethods._addPage.call(this, page);
+
+      // Remove pages out of range
+      turnMethods._removeFromDOM.call(this);
+    }
+
+    return this;
+  },
+
+  // Adds a page
+
+  _addPage: function(page) {
+    
+    var data = this.data(),
+      element = data.pageObjs[page];
+
+    if (element)
+      if (turnMethods._necessPage.call(this, page)) {
+
+        if (!data.pageWrap[page]) {
+
+          // Wrapper
+          data.pageWrap[page] = $('<div/>',
+            {'class': 'page-wrapper',
+              page: page,
+              css: {position: 'absolute',
+              overflow: 'hidden'}});
+
+          // Append to this flipbook
+          this.append(data.pageWrap[page]);
+
+          if (!data.pagePlace[page]) {
+            
+            data.pagePlace[page] = page;
+            // Move `pageObjs[page]` to wrapper
+            data.pageObjs[page].appendTo(data.pageWrap[page]);
+          
+         }
+
+          // Set the size of the page
+          var prop = turnMethods._pageSize.call(this, page, true);
+          element.css({width: prop.width, height: prop.height});
+          data.pageWrap[page].css(prop);
+
+        }
+
+        if (data.pagePlace[page] == page) {
+
+         // If the page isn't in another place, create the flip effect
+          turnMethods._makeFlip.call(this, page);
+
+      }
+        
+      } else {
+
+        // Place
+        data.pagePlace[page] = 0;
+
+        // Remove element from the DOM
+        if (data.pageObjs[page])
+          data.pageObjs[page].remove();
+
+      }
+
+  },
+
+  // Checks if a page is in memory
+  
+  hasPage: function(page) {
+
+    return has(page, this.data().pageObjs);
+  
+  },
+
+  // Centers the flipbook
+
+  center: function(page) {
+    
+    var data = this.data(),
+      size = $(this).turn('size'),
+      left = 0;
+
+    if (!data.noCenter) {
+      if (data.display=='double') {
+        var view = this.turn('view', page || data.tpage || data.page);
+
+        if (data.direction=='ltr') {
+          if (!view[0])
+            left -= size.width/4;
+          else if (!view[1])
+            left += size.width/4;
+        } else {
+          if (!view[0])
+            left += size.width/4;
+          else if (!view[1])
+            left -= size.width/4;
+        }
+      
+      }
+
+      $(this).css({marginLeft: left});
+    }
+
+    return this;
+
+  },
+
+  // Destroys the flipbook
+
+  destroy: function () {
+
+    var page,
+      flipbook = this,
+      data = this.data(),
+      events = [
+        'end', 'first', 'flip', 'last', 'pressed',
+        'released', 'start', 'turning', 'turned',
+        'zooming', 'missing'];
+
+    if (trigger('destroying', this)=='prevented')
+      return;
+
+    data.destroying = true;
+
+    $.each(events, function(index, eventName) {
+      flipbook.unbind(eventName);
+    });
+
+    this.parent().unbind('start', data.eventHandlers.start);
+
+    $(document).unbind(mouseEvents.move, data.eventHandlers.touchMove).
+      unbind(mouseEvents.up, data.eventHandlers.touchEnd);
+    
+    while (data.totalPages!==0) {
+      this.turn('removePage', data.totalPages);
+    }
+
+    if (data.fparent)
+      data.fparent.remove();
+
+    if (data.shadow)
+      data.shadow.remove();
+
+    this.removeData();
+    data = null;
+
+    return this;
+
+  },
+
+  // Checks if this element is a flipbook
+
+  is: function() {
+
+    return typeof(this.data().pages)=='object';
+
+  },
+
+  // Sets and gets the zoom value
+
+  zoom: function(newZoom) {
+    
+    var data = this.data();
+
+    if (typeof(newZoom)=='number') {
+
+      if (newZoom<0.001 || newZoom>100)
+        throw turnError(newZoom+ ' is not a value for zoom');
+      
+      if (trigger('zooming', this, [newZoom, data.zoom])=='prevented')
+        return this;
+      
+      var size = this.turn('size'),
+        currentView = this.turn('view'),
+        iz = 1/data.zoom,
+        newWidth = Math.round(size.width * iz * newZoom),
+        newHeight = Math.round(size.height * iz * newZoom);
+    
+      data.zoom = newZoom;
+
+      $(this).turn('stop').
+        turn('size', newWidth, newHeight);
+        /*.
+        css({marginTop: size.height * iz / 2 - newHeight / 2});*/
+
+      if (data.opts.autoCenter)
+        this.turn('center');
+      /*else
+        $(this).css({marginLeft: size.width * iz / 2 - newWidth / 2});*/
+
+      turnMethods._updateShadow.call(this);
+
+      for (var i = 0; i<currentView.length; i++) {
+        if (currentView[i] && data.pageZoom[currentView[i]]!=data.zoom) {
+  
+          this.trigger('zoomed',[
+            currentView[i],
+            currentView,
+            data.pageZoom[currentView[i]],
+            data.zoom]);
+
+          data.pageZoom[currentView[i]] = data.zoom;
+      }
+    }
+
+      return this;
+
+    } else
+      return data.zoom;
+
+  },
+
+  // Gets the size of a page
+
+  _pageSize: function(page, position) {
+
+    var data = this.data(),
+      prop = {};
+
+    if (data.display=='single') {
+
+      prop.width = this.width();
+      prop.height = this.height();
+
+      if (position) {
+        prop.top = 0;
+        prop.left = 0;
+        prop.right = 'auto';
+      }
+
+    } else {
+
+      var pageWidth = this.width()/2,
+        pageHeight = this.height();
+
+      if (data.pageObjs[page].hasClass('own-size')) {
+        prop.width = data.pageObjs[page].width();
+        prop.height = data.pageObjs[page].height();
+      } else {
+        prop.width = pageWidth;
+        prop.height = pageHeight;
+      }
+      
+      if (position) {
+        var odd = page%2;
+        prop.top = (pageHeight-prop.height)/2;
+
+        if (data.direction=='ltr') {
+          
+          prop[(odd) ? 'right' : 'left'] = pageWidth-prop.width;
+          prop[(odd) ? 'left' : 'right'] = 'auto';
+
+        } else {
+          
+          prop[(odd) ? 'left' : 'right'] = pageWidth-prop.width;
+          prop[(odd) ? 'right' : 'left'] = 'auto';
+
+        }
+      
+      }
+    }
+
+    return prop;
+
+  },
+
+  // Prepares the flip effect for a page
+
+  _makeFlip: function(page) {
+
+    var data = this.data();
+
+    if (!data.pages[page] && data.pagePlace[page]==page) {
+      
+      var single = data.display=='single',
+        odd = page%2;
+
+      data.pages[page] = data.pageObjs[page].
+        css(turnMethods._pageSize.call(this, page)).
+        flip({
+          page: page,
+          next: (odd || single) ? page+1 : page-1,
+          turn: this
+        }).
+        flip('disable', data.disabled);
+
+        // Issue about z-index
+        turnMethods._setPageLoc.call(this, page);
+
+        data.pageZoom[page] = data.zoom;
+        
+    }
+
+    return data.pages[page];
+  },
+
+  // Makes pages within a range
+
+  _makeRange: function() {
+
+    var page, range,
+      data = this.data();
+
+    if (data.totalPages<1)
+      return;
+
+    range = this.turn('range');
+
+    for (page = range[0]; page<=range[1]; page++)
+      turnMethods._addPage.call(this, page);
+
+  },
+
+  // Returns a range of pages that should be in the DOM
+  // Example:
+  // - page in the current view, return true
+  // * page is in the range, return true
+  // Otherwise, return false
+  //
+  // 1 2-3 4-5 6-7 8-9 10-11 12-13
+  //   **  **  --   **  **
+
+  range: function(page) {
+
+    var remainingPages, left, right, view,
+      data = this.data();
+
+      page = page || data.tpage || data.page || 1;
+      view = turnMethods._view.call(this, page);
+
+      if (page<1 || page>data.totalPages)
+        throw turnError('"'+page+'" is not a valid page');
+
+    
+      view[1] = view[1] || view[0];
+      
+      if (view[0]>=1 && view[1]<=data.totalPages) {
+
+        remainingPages = Math.floor((pagesInDOM-2)/2);
+
+        if (data.totalPages-view[1] > view[0]) {
+          left = Math.min(view[0]-1, remainingPages);
+          right = 2*remainingPages-left;
+        } else {
+          right = Math.min(data.totalPages-view[1], remainingPages);
+          left = 2*remainingPages-right;
+        }
+
+      } else {
+        left = pagesInDOM-1;
+        right = pagesInDOM-1;
+      }
+
+      return [Math.max(1, view[0]-left),
+          Math.min(data.totalPages, view[1]+right)];
+
+  },
+
+  // Detects if a page is within the range of `pagesInDOM` from the current view
+
+  _necessPage: function(page) {
+    
+    if (page===0)
+      return true;
+
+    var range = this.turn('range');
+
+    return this.data().pageObjs[page].hasClass('fixed') ||
+      (page>=range[0] && page<=range[1]);
+    
+  },
+
+  // Releases memory by removing pages from the DOM
+
+  _removeFromDOM: function() {
+
+    var page, data = this.data();
+
+    for (page in data.pageWrap)
+      if (has(page, data.pageWrap) &&
+        !turnMethods._necessPage.call(this, page))
+      turnMethods._removePageFromDOM.call(this, page);
+    
+  },
+
+  // Removes a page from DOM and its internal references
+
+  _removePageFromDOM: function(page) {
+
+    var data = this.data();
+
+    if (data.pages[page]) {
+      var dd = data.pages[page].data();
+
+      flipMethods._moveFoldingPage.call(data.pages[page], false);
+
+      if (dd.f && dd.f.fwrapper)
+        dd.f.fwrapper.remove();
+
+      data.pages[page].removeData();
+      data.pages[page].remove();
+      delete data.pages[page];
+    }
+
+    if (data.pageObjs[page])
+      data.pageObjs[page].remove();
+
+    if (data.pageWrap[page]) {
+      data.pageWrap[page].remove();
+      delete data.pageWrap[page];
+    }
+
+    turnMethods._removeMv.call(this, page);
+
+    delete data.pagePlace[page];
+    delete data.pageZoom[page];
+
+  },
+
+  // Removes a page
+
+  removePage: function(page) {
+
+    var data = this.data();
+
+    // Delete all the pages
+    if (page=='*') {
+      
+      while (data.totalPages!==0) {
+        this.turn('removePage', data.totalPages);
+      }
+
+    } else {
+
+      if (page<1 || page>data.totalPages)
+        throw turnError('The page '+ page + ' doesn\'t exist');
+        
+      if (data.pageObjs[page]) {
+
+        // Stop animations
+        this.turn('stop');
+
+        // Remove `page`
+        turnMethods._removePageFromDOM.call(this, page);
+
+        delete data.pageObjs[page];
+
+      }
+
+      // Move the pages
+      turnMethods._movePages.call(this, page, -1);
+
+      // Resize the size of this flipbook
+      data.totalPages = data.totalPages-1;
+
+      // Check the current view
+
+      if (data.page>data.totalPages) {
+
+       data.page = null;
+       turnMethods._fitPage.call(this, data.totalPages);
+
+      } else {
+
+        turnMethods._makeRange.call(this);
+        this.turn('update');
+
+      }
+    }
+
+    return this;
+  
+  },
+
+  // Moves pages
+
+  _movePages: function(from, change) {
+
+    var page,
+      that = this,
+      data = this.data(),
+      single = data.display=='single',
+      move = function(page) {
+
+        var next = page + change,
+          odd = next%2,
+          className = (odd) ? ' odd ' : ' even ';
+
+        if (data.pageObjs[page])
+          data.pageObjs[next] = data.pageObjs[page].
+            removeClass('p' + page + ' odd even').
+            addClass('p' + next + className);
+
+        if (data.pagePlace[page] && data.pageWrap[page]) {
+
+          data.pagePlace[next] = next;
+        
+          if (data.pageObjs[next].hasClass('fixed'))
+            data.pageWrap[next] = data.pageWrap[page].
+              attr('page', next);
+          else
+            data.pageWrap[next] = data.pageWrap[page].
+              css(turnMethods._pageSize.call(that, next, true)).
+              attr('page', next);
+      
+            if (data.pages[page])
+              data.pages[next] = data.pages[page].
+                flip('options', {
+                  page: next,
+                  next: (single || odd) ? next+1 : next-1
+                });
+
+            if (change) {
+              delete data.pages[page];
+              delete data.pagePlace[page];
+              delete data.pageZoom[page];
+              delete data.pageObjs[page];
+              delete data.pageWrap[page];
+            }
+
+        }
+
+    };
+
+    if (change>0)
+      for (page=data.totalPages; page>=from; page--)
+        move(page);
+    else
+      for (page=from; page<=data.totalPages; page++)
+        move(page);
+
+  },
+
+  // Sets or Gets the display mode
+
+  display: function(display) {
+
+    var data = this.data(),
+      currentDisplay = data.display;
+
+    if (display===undefined) {
+      
+      return currentDisplay;
+
+    } else {
+
+      if ($.inArray(display, displays)==-1)
+        throw turnError('"'+display + '" is not a value for display');
+      
+      switch(display) {
+        case 'single':
+
+          // Create a temporal page to use as folded page
+
+          if (!data.pageObjs[0]) {
+            this.turn('stop').
+              css({'overflow': 'hidden'});
+
+            data.pageObjs[0] = $('<div />',
+                {'class': 'page p-temporal'}).
+              css({width: this.width(), height: this.height()}).
+              appendTo(this);
+          }
+
+          this.addClass('shadow');
+
+        break;
+        case 'double':
+
+          // Remove the temporal page
+
+          if (data.pageObjs[0]) {
+            this.turn('stop').css({'overflow': ''});
+            data.pageObjs[0].remove();
+            delete data.pageObjs[0];
+          }
+
+          this.removeClass('shadow');
+
+        break;
+      }
+      
+
+      data.display = display;
+
+      if (currentDisplay) {
+        var size = this.turn('size');
+        turnMethods._movePages.call(this, 1, 0);
+        this.turn('size', size.width, size.height).
+          turn('update');
+      }
+
+      return this;
+
+    }
+  
+  },
+  
+  // Gets and sets the direction of the flipbook
+
+  direction: function(dir) {
+
+    var data = this.data();
+
+    if (dir===undefined) {
+
+      return data.direction;
+
+    } else {
+
+      dir = dir.toLowerCase();
+
+      if ($.inArray(dir, directions)==-1)
+        throw turnError('"' + dir + '" is not a value for direction');
+
+      if (dir=='rtl') {
+        $(this).attr('dir', 'ltr').
+          css({direction: 'ltr'});
+      }
+
+      data.direction = dir;
+
+      if (data.done)
+        this.turn('size', $(this).width(), $(this).height());
+
+      return this;
+    }
+
+  },
+
+  // Detects animation
+
+  animating: function() {
+
+    return this.data().pageMv.length>0;
+
+  },
+
+  // Gets the current activated corner
+
+  corner: function() {
+    
+    var corner,
+      page,
+      data = this.data();
+
+    for (page in data.pages) {
+      if (has(page, data.pages))
+        if ((corner = data.pages[page].flip('corner'))) {
+          return corner;
+        }
+    }
+
+    return false;
+  },
+
+  // Gets the data stored in the flipbook
+
+  data: function() {
+    
+    return this.data();
+
+  },
+
+  // Disables and enables the effect
+
+  disable: function(disable) {
+
+    var page,
+      data = this.data(),
+      view = this.turn('view');
+
+    data.disabled = disable===undefined || disable===true;
+
+    for (page in data.pages) {
+      if (has(page, data.pages))
+        data.pages[page].flip('disable',
+          (data.disabled) ? true : $.inArray(parseInt(page, 10), view)==-1);
+    }
+
+    return this;
+
+  },
+
+  // Disables and enables the effect
+
+  disabled: function(disable) {
+
+    if (disable===undefined) {
+      return this.data().disabled===true;
+    } else {
+      return this.turn('disable', disable);
+    }
+
+  },
+
+  // Gets and sets the size
+
+  size: function(width, height) {
+
+    if (width===undefined || height===undefined) {
+      
+      return {width: this.width(), height: this.height()};
+
+    } else {
+
+      this.turn('stop');
+
+      var page, prop,
+        data = this.data(),
+        pageWidth = (data.display=='double') ? width/2 : width;
+
+      this.css({width: width, height: height});
+
+      if (data.pageObjs[0])
+        data.pageObjs[0].css({width: pageWidth, height: height});
+      
+      for (page in data.pageWrap) {
+        if (!has(page, data.pageWrap)) continue;
+
+        prop = turnMethods._pageSize.call(this, page, true);
+
+        data.pageObjs[page].css({width: prop.width, height: prop.height});
+        data.pageWrap[page].css(prop);
+        
+        if (data.pages[page])
+          data.pages[page].css({width: prop.width, height: prop.height});
+      }
+
+      this.turn('resize');
+
+      return this;
+
+    }
+  },
+
+  // Resizes each page
+
+  resize: function() {
+
+    var page, data = this.data();
+
+    if (data.pages[0]) {
+      data.pageWrap[0].css({left: -this.width()});
+      data.pages[0].flip('resize', true);
+    }
+
+    for (page = 1; page <= data.totalPages; page++)
+      if (data.pages[page])
+        data.pages[page].flip('resize', true);
+
+    turnMethods._updateShadow.call(this);
+
+    if (data.opts.autoCenter)
+      this.turn('center');
+
+  },
+
+  // Removes an animation from the cache
+
+  _removeMv: function(page) {
+
+    var i, data = this.data();
+      
+    for (i=0; i<data.pageMv.length; i++)
+      if (data.pageMv[i]==page) {
+        data.pageMv.splice(i, 1);
+        return true;
+      }
+
+    return false;
+
+  },
+
+  // Adds an animation to the cache
+  
+  _addMv: function(page) {
+
+    var data = this.data();
+
+    turnMethods._removeMv.call(this, page);
+    data.pageMv.push(page);
+
+  },
+
+  // Gets indexes for a view
+
+  _view: function(page) {
+  
+    var data = this.data();
+    
+    page = page || data.page;
+
+    if (data.display=='double')
+      return (page%2) ? [page-1, page] : [page, page+1];
+    else
+      return [page];
+
+  },
+
+  // Gets a view
+
+  view: function(page) {
+
+    var data = this.data(),
+      view = turnMethods._view.call(this, page);
+
+    if (data.display=='double')
+      return [(view[0]>0) ? view[0] : 0,
+        (view[1]<=data.totalPages) ? view[1] : 0];
+    else
+      return [(view[0]>0 && view[0]<=data.totalPages) ? view[0] : 0];
+
+  },
+
+  // Stops animations
+
+  stop: function(ignore, animate) {
+
+    if (this.turn('animating')) {
+  
+      var i, opts, page,
+        data = this.data();
+
+      if (data.tpage) {
+        data.page = data.tpage;
+        delete data['tpage'];
+      }
+
+      for (i = 0; i<data.pageMv.length; i++) {
+
+        if (!data.pageMv[i] || data.pageMv[i]===ignore)
+          continue;
+
+        page = data.pages[data.pageMv[i]];
+        opts = page.data().f.opts;
+
+        page.flip('hideFoldedPage', animate);
+
+        if (!animate)
+          flipMethods._moveFoldingPage.call(page, false);
+
+        if (opts.force) {
+          opts.next = (opts.page%2===0) ? opts.page-1 : opts.page+1;
+          delete opts['force'];
+        }
+
+      }
+    }
+    
+    this.turn('update');
+
+    return this;
+  },
+
+  // Gets and sets the number of pages
+
+  pages: function(pages) {
+
+    var data = this.data();
+
+    if (pages) {
+
+      if (pages<data.totalPages) {
+
+        for (var page = data.totalPages; page>pages; page--)
+          this.turn('removePage', page);
+
+      }
+
+        data.totalPages = pages;
+        turnMethods._fitPage.call(this, data.page);
+
+      return this;
+
+    } else
+      return data.totalPages;
+
+  },
+
+  // Checks missing pages
+
+  _missing : function(page) {
+    
+    var data = this.data();
+
+    if (data.totalPages<1)
+      return;
+
+    var p,
+        range = this.turn('range', page),
+        missing = [];
+
+    for (p = range[0]; p<=range[1]; p++) {
+      if (!data.pageObjs[p])
+        missing.push(p);
+    }
+
+    if (missing.length>0)
+      this.trigger('missing', [missing]);
+
+  },
+
+  // Sets a page without effect
+
+  _fitPage: function(page) {
+
+    var data = this.data(),
+      newView = this.turn('view', page);
+
+    turnMethods._missing.call(this, page);
+    
+    if (!data.pageObjs[page])
+      return;
+
+    data.page = page;
+  
+    this.turn('stop');
+
+    for (var i = 0; i<newView.length; i++) {
+
+      if (newView[i] && data.pageZoom[newView[i]]!=data.zoom) {
+  
+        this.trigger('zoomed',[
+          newView[i],
+          newView,
+          data.pageZoom[newView[i]],
+          data.zoom]);
+
+        data.pageZoom[newView[i]] = data.zoom;
+
+      }
+    }
+
+    turnMethods._removeFromDOM.call(this);
+    turnMethods._makeRange.call(this);
+    turnMethods._updateShadow.call(this);
+    this.trigger('turned', [page, newView]);
+    this.turn('update');
+
+    if (data.opts.autoCenter)
+      this.turn('center');
+
+  },
+  
+  // Turns the page
+
+  _turnPage: function(page) {
+
+    var current,
+      next,
+      data = this.data(),
+      place = data.pagePlace[page],
+      view = this.turn('view'),
+      newView = this.turn('view', page);
+
+
+    if (data.page!=page) {
+
+      var currentPage = data.page;
+
+      if (trigger('turning', this, [page, newView])=='prevented') {
+
+        if (currentPage==data.page && $.inArray(place, data.pageMv)!=-1)
+          data.pages[place].flip('hideFoldedPage', true);
+        
+        return;
+
+      }
+
+      if ($.inArray(1, newView)!=-1)
+        this.trigger('first');
+      if ($.inArray(data.totalPages, newView)!=-1)
+        this.trigger('last');
+
+    }
+
+    if (data.display=='single') {
+      current = view[0];
+      next = newView[0];
+    } else if (view[1] && page>view[1]) {
+      current = view[1];
+      next = newView[0];
+    } else if (view[0] && page<view[0]) {
+      current = view[0];
+      next = newView[1];
+    }
+
+    var optsCorners = data.opts.turnCorners.split(','),
+      flipData = data.pages[current].data().f,
+      opts = flipData.opts,
+      actualPoint = flipData.point;
+
+    turnMethods._missing.call(this, page);
+    
+    if (!data.pageObjs[page])
+      return;
+
+    this.turn('stop');
+
+    data.page = page;
+
+    turnMethods._makeRange.call(this);
+
+    data.tpage = next;
+
+    if (opts.next!=next) {
+      opts.next = next;
+      opts.force = true;
+    }
+
+    this.turn('update');
+
+    flipData.point = actualPoint;
+    
+    if (flipData.effect=='hard')
+      if (data.direction=='ltr')
+        data.pages[current].flip('turnPage',
+          (page>current) ? 'r' : 'l');
+      else
+        data.pages[current].flip('turnPage',
+          (page>current) ? 'l' : 'r');
+    else {
+      if (data.direction=='ltr')
+        data.pages[current].flip('turnPage',
+          optsCorners[(page>current) ? 1 : 0]);
+      else
+        data.pages[current].flip('turnPage',
+          optsCorners[(page>current) ? 0 : 1]);
+    }
+
+  },
+
+  // Gets and sets a page
+
+  page: function(page) {
+
+    var data = this.data();
+
+    if (page===undefined) {
+      
+      return data.page;
+
+    } else {
+
+      if (!data.disabled && !data.destroying) {
+
+        page = parseInt(page, 10);
+
+        if (page>0 && page<=data.totalPages) {
+
+          if (page!=data.page) {
+            if (!data.done || $.inArray(page, this.turn('view'))!=-1)
+              turnMethods._fitPage.call(this, page);
+            else
+              turnMethods._turnPage.call(this, page);
+          }
+      
+          return this;
+
+        } else {
+        
+          throw turnError('The page ' + page + ' does not exist');
+
+        }
+
+      }
+
+    }
+
+  },
+
+  // Turns to the next view
+
+  next: function() {
+
+    return this.turn('page', Math.min(this.data().totalPages,
+      turnMethods._view.call(this, this.data().page).pop() + 1));
+  
+  },
+
+  // Turns to the previous view
+
+  previous: function() {
+
+    return this.turn('page', Math.max(1,
+      turnMethods._view.call(this, this.data().page).shift() - 1));
+
+  },
+
+  // Shows a peeling corner
+
+  peel: function(corner, animate) {
+    
+    var data = this.data(),
+      view = this.turn('view');
+
+    animate = (animate===undefined) ? true : animate===true;
+
+    if (corner===false) {
+      
+      this.turn('stop', null, animate);
+
+    } else {
+    
+      if (data.display=='single') {
+
+        data.pages[data.page].flip('peel', corner, animate);
+
+      } else {
+
+        var page;
+
+        if (data.direction=='ltr') {
+          
+          page = (corner.indexOf('l')!=-1) ? view[0] : view[1];
+
+        } else {
+          
+          page = (corner.indexOf('l')!=-1) ? view[1] : view[0];
+
+        }
+        
+        if (data.pages[page])
+          data.pages[page].flip('peel', corner, animate);
+
+      }
+    }
+
+    return this;
+
+  },
+
+  // Adds a motion to the internal list
+  // This event is called in context of flip
+
+  _addMotionPage: function() {
+
+    var opts = $(this).data().f.opts,
+      turn = opts.turn,
+      dd = turn.data();
+
+    turnMethods._addMv.call(turn, opts.page);
+
+  },
+
+  // This event is called in context of flip
+
+  _eventStart: function(e, opts, corner) {
+
+    var data = opts.turn.data(),
+      actualZoom = data.pageZoom[opts.page];
+
+    if (e.isDefaultPrevented()) {
+      turnMethods._updateShadow.call(opts.turn);
+      return;
+    }
+
+    if (actualZoom && actualZoom!=data.zoom) {
+      
+      opts.turn.trigger('zoomed',[
+        opts.page,
+        opts.turn.turn('view', opts.page),
+        actualZoom,
+        data.zoom]);
+
+      data.pageZoom[opts.page] = data.zoom;
+
+    }
+
+    if (data.display=='single' && corner) {
+
+      if ((corner.charAt(1)=='l' && data.direction=='ltr') ||
+        (corner.charAt(1)=='r' && data.direction=='rtl'))
+      {
+        
+        opts.next = (opts.next<opts.page) ? opts.next : opts.page-1;
+        opts.force = true;
+
+      } else {
+        
+        opts.next = (opts.next>opts.page) ? opts.next : opts.page+1;
+
+      }
+
+    }
+
+    turnMethods._addMotionPage.call(e.target);
+    turnMethods._updateShadow.call(opts.turn);
+  },
+
+  // This event is called in context of flip
+
+  _eventEnd: function(e, opts, turned) {
+  
+    var that = $(e.target),
+      data = that.data().f,
+      turn = opts.turn,
+      dd = turn.data();
+
+    if (turned) {
+
+      var tpage = dd.tpage || dd.page;
+    
+      if (tpage==opts.next || tpage==opts.page) {
+        delete dd.tpage;
+
+        turnMethods._fitPage.call(turn, tpage || opts.next, true);
+      }
+
+    } else {
+      
+      turnMethods._removeMv.call(turn, opts.page);
+      turnMethods._updateShadow.call(turn);
+      turn.turn('update');
+
+    }
+    
+  },
+  
+  // This event is called in context of flip
+
+  _eventPressed: function(e) {
+
+    var page,
+      data = $(e.target).data().f,
+      turn = data.opts.turn,
+      turnData = turn.data(),
+      pages = turnData.pages;
+    
+    turnData.mouseAction = true;
+
+    turn.turn('update');
+
+    return data.time = new Date().getTime();
+
+  },
+
+  // This event is called in context of flip
+
+  _eventReleased: function(e, point) {
+
+    var outArea,
+      page = $(e.target),
+      data = page.data().f,
+      turn = data.opts.turn,
+      turnData = turn.data();
+    
+    if (turnData.display=='single') {
+      outArea = (point.corner=='br' || point.corner=='tr') ?
+        point.x<page.width()/2:
+        point.x>page.width()/2;
+    } else {
+      outArea = point.x<0 || point.x>page.width();
+    }
+
+    if ((new Date()).getTime()-data.time<200 || outArea) {
+
+      e.preventDefault();
+      turnMethods._turnPage.call(turn, data.opts.next);
+
+    }
+
+    turnData.mouseAction = false;
+
+  },
+
+  // This event is called in context of flip
+  
+  _flip: function(e) {
+
+    e.stopPropagation();
+
+    var opts = $(e.target).data().f.opts;
+
+    opts.turn.trigger('turn', [opts.next]);
+
+    if (opts.turn.data().opts.autoCenter) {
+      opts.turn.turn('center', opts.next);
+    }
+
+  },
+
+ //
+  _touchStart: function() {
+    var data = this.data();
+    for (var page in data.pages) {
+      if (has(page, data.pages) &&
+        flipMethods._eventStart.apply(data.pages[page], arguments)===false) {
+          return false;
+      }
+    }
+  },
+  
+  //
+  _touchMove: function() {
+    var data = this.data();
+    for (var page in data.pages) {
+      if (has(page, data.pages)) {
+        flipMethods._eventMove.apply(data.pages[page], arguments);
+      }
+    }
+  },
+
+  //
+  _touchEnd: function() {
+    var data = this.data();
+    for (var page in data.pages) {
+      if (has(page, data.pages)) {
+        flipMethods._eventEnd.apply(data.pages[page], arguments);
+      }
+    }
+  },
+
+  // Calculate the z-index value for pages during the animation
+
+  calculateZ: function(mv) {
+
+    var i, page, nextPage, placePage, dpage,
+      that = this,
+      data = this.data(),
+      view = this.turn('view'),
+      currentPage = view[0] || view[1],
+      total = mv.length-1,
+      r = {pageZ: {}, partZ: {}, pageV: {}},
+
+      addView = function(page) {
+        var view = that.turn('view', page);
+        if (view[0]) r.pageV[view[0]] = true;
+        if (view[1]) r.pageV[view[1]] = true;
+      };
+    
+    for (i = 0; i<=total; i++) {
+      page = mv[i];
+      nextPage = data.pages[page].data().f.opts.next;
+      placePage = data.pagePlace[page];
+      addView(page);
+      addView(nextPage);
+      dpage = (data.pagePlace[nextPage]==nextPage) ? nextPage : page;
+      r.pageZ[dpage] = data.totalPages - Math.abs(currentPage-dpage);
+      r.partZ[placePage] = data.totalPages*2 -  total + i;
+    }
+
+    return r;
+  },
+
+  // Updates the z-index and display property of every page
+
+  update: function() {
+
+    var page,
+      data = this.data();
+
+    if (this.turn('animating') && data.pageMv[0]!==0) {
+
+      // Update motion
+
+      var p, apage, fixed,
+        pos = this.turn('calculateZ', data.pageMv),
+        corner = this.turn('corner'),
+        actualView = this.turn('view'),
+        newView = this.turn('view', data.tpage);
+  
+      for (page in data.pageWrap) {
+
+        if (!has(page, data.pageWrap))
+          continue;
+
+        fixed = data.pageObjs[page].hasClass('fixed');
+
+        data.pageWrap[page].css({
+          display: (pos.pageV[page] || fixed) ? '' : 'none',
+          zIndex:
+            (data.pageObjs[page].hasClass('hard') ?
+              pos.partZ[page]
+              :
+              pos.pageZ[page]
+            ) || (fixed ? -1 : 0)
+        });
+
+        if ((p = data.pages[page])) {
+
+          p.flip('z', pos.partZ[page] || null);
+
+          if (pos.pageV[page])
+            p.flip('resize');
+          
+          if (data.tpage) { // Is it turning the page to `tpage`?
+
+            p.flip('hover', false).
+              flip('disable',
+                $.inArray(parseInt(page, 10), data.pageMv)==-1 &&
+                page!=newView[0] &&
+                page!=newView[1]);
+
+          } else {
+
+            p.flip('hover', corner===false).
+              flip('disable', page!=actualView[0] && page!=actualView[1]);
+
+          }
+
+        }
+
+      }
+
+    } else {
+
+      // Update static pages
+
+      for (page in data.pageWrap) {
+
+        if (!has(page, data.pageWrap))
+          continue;
+
+        var pageLocation = turnMethods._setPageLoc.call(this, page);
+
+        if (data.pages[page]) {
+          data.pages[page].
+            flip('disable', data.disabled || pageLocation!=1).
+            flip('hover', true).
+            flip('z', null);
+        }
+      }
+    }
+
+    return this;
+  },
+
+  // Updates the position and size of the flipbook's shadow
+
+  _updateShadow: function() {
+    
+    var view, view2, shadow,
+      data = this.data(),
+      width = this.width(),
+      height = this.height(),
+      pageWidth = (data.display=='single') ? width : width/2;
+
+    view = this.turn('view');
+
+    if (!data.shadow) {
+      data.shadow = $('<div />', {
+          'class': 'shadow',
+          'css': divAtt(0, 0, 0).css
+        }).
+        appendTo(this);
+    }
+
+    for (var i = 0; i<data.pageMv.length; i++) {
+      if (!view[0] || !view[1])
+        break;
+    
+      view = this.turn('view', data.pages[data.pageMv[i]].data().f.opts.next);
+      view2 = this.turn('view', data.pageMv[i]);
+
+      view[0] = view[0] && view2[0];
+      view[1] = view[1] && view2[1];
+    }
+
+    if (!view[0]) shadow = (data.direction=='ltr') ? 1 : 2;
+    else if (!view[1]) shadow = (data.direction=='ltr') ? 2 : 1;
+    else shadow = 3;
+
+    switch (shadow) {
+      case 1:
+        data.shadow.css({
+          width: pageWidth,
+          height: height,
+          top: 0,
+          left: pageWidth
+        });
+        break;
+      case 2:
+        data.shadow.css({
+          width: pageWidth,
+          height: height,
+          top: 0,
+          left: 0
+        });
+        break;
+      case 3:
+        data.shadow.css({
+          width: width,
+          height: height,
+          top: 0,
+          left: 0
+        });
+        break;
+    }
+
+  },
+
+  // Sets the z-index and display property of a page
+  // It depends on the current view
+
+  _setPageLoc: function(page) {
+
+    var data = this.data(),
+      view = this.turn('view'),
+      loc = 0;
+
+    
+    if (page==view[0] || page==view[1])
+      loc = 1;
+    else if (
+      (data.display=='single' && page==view[0]+1) ||
+      (data.display=='double' && page==view[0]-2 || page==view[1]+2)
+    )
+      loc = 2;
+
+    if (!this.turn('animating'))
+      switch (loc) {
+        case 1:
+          data.pageWrap[page].css(
+          {
+            zIndex: data.totalPages,
+            display: ''
+          });
+        break;
+        case 2:
+          data.pageWrap[page].css(
+          {
+            zIndex: data.totalPages-1,
+            display: ''
+          });
+        break;
+        case 0:
+          data.pageWrap[page].css(
+          {
+            zIndex: 0,
+            display: (data.pageObjs[page].hasClass('fixed')) ? '' : 'none'}
+          );
+        break;
+      }
+    
+    return loc;
+  },
+
+  // Gets and sets the options
+
+  options: function(options) {
+    
+    if (options===undefined) {
+      
+      return this.data().opts;
+
+    } else {
+
+      var data = this.data();
+
+      // Set new values
+
+      $.extend(data.opts, options);
+      
+      // Set pages
+
+      if (options.pages)
+        this.turn('pages', options.pages);
+
+      // Set page
+
+      if (options.page)
+        this.turn('page', options.page);
+
+      // Set display
+
+      if (options.display)
+        this.turn('display', options.display);
+      
+      // Set direction
+
+      if (options.direction)
+        this.turn('direction', options.direction);
+
+      // Set size
+
+      if (options.width && options.height)
+        this.turn('size', options.width, options.height);
+      
+      // Add event listeners
+
+      if (options.when)
+        for (var eventName in options.when)
+          if (has(eventName, options.when)) {
+            this.unbind(eventName).
+              bind(eventName, options.when[eventName]);
+          }
+
+      return this;
+    }
+
+  },
+
+  // Gets the current version
+
+  version: function() {
+
+    return version;
+
+  }
+},
+
+// Methods and properties for the flip page effect
+
+flipMethods = {
+
+  // Constructor
+
+  init: function(opts) {
+
+    this.data({f: {
+      disabled: false,
+      hover: false,
+      effect: (this.hasClass('hard')) ? 'hard' : 'sheet'
+    }});
+  
+    this.flip('options', opts);
+
+    flipMethods._addPageWrapper.call(this);
+
+    return this;
+  },
+
+  setData: function(d) {
+    
+    var data = this.data();
+
+    data.f = $.extend(data.f, d);
+
+    return this;
+  },
+
+  options: function(opts) {
+    
+    var data = this.data().f;
+
+    if (opts) {
+      flipMethods.setData.call(this,
+        {opts: $.extend({}, data.opts || flipOptions, opts)});
+      return this;
+    } else
+      return data.opts;
+
+  },
+
+  z: function(z) {
+    
+    var data = this.data().f;
+
+    data.opts['z-index'] = z;
+
+    if (data.fwrapper)
+      data.fwrapper.css({
+        zIndex: z || parseInt(data.parent.css('z-index'), 10) || 0
+      });
+
+    return this;
+  },
+
+  _cAllowed: function() {
+    
+    var data = this.data().f,
+      page = data.opts.page,
+      turnData = data.opts.turn.data(),
+      odd = page%2;
+    
+    if (data.effect=='hard') {
+    
+      return (turnData.direction=='ltr') ?
+        [(odd) ? 'r' : 'l'] :
+        [(odd) ? 'l' : 'r'];
+
+    } else {
+
+      if (turnData.display=='single') {
+
+        if (page==1)
+          return (turnData.direction=='ltr') ?
+            corners['forward'] : corners['backward'];
+        else if (page==turnData.totalPages)
+          return (turnData.direction=='ltr') ?
+            corners['backward'] : corners['forward'];
+        else
+          return corners['all'];
+
+      } else {
+
+        return (turnData.direction=='ltr') ?
+          corners[(odd) ? 'forward' : 'backward']
+          :
+          corners[(odd) ? 'backward' : 'forward'];
+
+      }
+
+    }
+
+  },
+
+  _cornerActivated: function(p) {
+
+    var data = this.data().f,
+      width = this.width(),
+      height = this.height(),
+      point = {x: p.x, y: p.y, corner: ''},
+      csz = data.opts.cornerSize;
+
+    if (point.x<=0 || point.y<=0 || point.x>=width || point.y>=height)
+      return false;
+
+    var allowedCorners = flipMethods._cAllowed.call(this);
+
+    switch (data.effect) {
+      case 'hard':
+        
+        if (point.x>width-csz)
+          point.corner = 'r';
+        else if (point.x<csz)
+          point.corner = 'l';
+        else
+          return false;
+            
+        break;
+
+      case 'sheet':
+        
+        if (point.y<csz)
+          point.corner+= 't';
+        else if (point.y>=height-csz)
+          point.corner+= 'b';
+        else
+          return false;
+    
+        if (point.x<=csz)
+          point.corner+= 'l';
+        else if (point.x>=width-csz)
+          point.corner+= 'r';
+        else
+          return false;
+     
+        break;
+      }
+
+    return (!point.corner || $.inArray(point.corner, allowedCorners)==-1) ?
+      false : point;
+
+  },
+
+  _isIArea: function(e) {
+
+    var pos = this.data().f.parent.offset();
+
+    e = (isTouch && e.originalEvent) ? e.originalEvent.touches[0] : e;
+
+    return flipMethods._cornerActivated.call(this,
+      {
+        x: e.pageX-pos.left,
+        y: e.pageY-pos.top
+      });
+
+  },
+
+  _c: function(corner, opts) {
+
+    opts = opts || 0;
+
+    switch (corner) {
+      case 'tl':
+        return point2D(opts, opts);
+      case 'tr':
+        return point2D(this.width()-opts, opts);
+      case 'bl':
+        return point2D(opts, this.height()-opts);
+      case 'br':
+        return point2D(this.width()-opts, this.height()-opts);
+      case 'l':
+        return point2D(opts, 0);
+      case 'r':
+        return point2D(this.width()-opts, 0);
+    }
+
+  },
+
+  _c2: function(corner) {
+
+    switch (corner) {
+      case 'tl':
+        return point2D(this.width()*2, 0);
+      case 'tr':
+        return point2D(-this.width(), 0);
+      case 'bl':
+        return point2D(this.width()*2, this.height());
+      case 'br':
+        return point2D(-this.width(), this.height());
+      case 'l':
+        return point2D(this.width()*2, 0);
+      case 'r':
+        return point2D(-this.width(), 0);
+    }
+
+  },
+
+  _foldingPage: function() {
+
+    var data = this.data().f;
+
+    if (!data)
+      return;
+
+    var opts = data.opts;
+
+    if (opts.turn) {
+      data = opts.turn.data();
+      if (data.display == 'single')
+        return (opts.next>1 || opts.page>1) ? data.pageObjs[0] : null;
+      else
+        return data.pageObjs[opts.next];
+    }
+
+  },
+
+  _backGradient: function() {
+
+    var data = this.data().f,
+      turnData = data.opts.turn.data(),
+      gradient =  turnData.opts.gradients && (turnData.display=='single' ||
+         (data.opts.page!=2 && data.opts.page!=turnData.totalPages-1));
+
+    if (gradient && !data.bshadow)
+      data.bshadow = $('<div/>', divAtt(0, 0, 1)).
+        css({'position': '', width: this.width(), height: this.height()}).
+        appendTo(data.parent);
+
+    return gradient;
+
+  },
+
+  type: function () {
+    
+    return this.data().f.effect;
+
+  },
+
+  resize: function(full) {
+    
+    var data = this.data().f,
+      turnData = data.opts.turn.data(),
+      width = this.width(),
+      height = this.height();
+
+    switch (data.effect) {
+      case 'hard':
+        
+      if (full) {
+        data.wrapper.css({width: width, height: height});
+        data.fpage.css({width: width, height: height});
+        if (turnData.opts.gradients) {
+          data.ashadow.css({width: width, height: height});
+          data.bshadow.css({width: width, height: height});
+        }
+      }
+
+      break;
+      case 'sheet':
+
+      if (full) {
+        var size = Math.round(Math.sqrt(Math.pow(width, 2)+Math.pow(height, 2)));
+
+        data.wrapper.css({width: size, height: size});
+        data.fwrapper.css({width: size, height: size}).
+          children(':first-child').
+          css({width: width, height: height});
+
+        data.fpage.css({width: width, height: height});
+
+        if (turnData.opts.gradients)
+          data.ashadow.css({width: width, height: height});
+
+        if (flipMethods._backGradient.call(this))
+          data.bshadow.css({width: width, height: height});
+      }
+
+      if (data.parent.is(':visible')) {
+        var offset = findPos(data.parent[0]);
+
+        data.fwrapper.css({top: offset.top,
+          left: offset.left});
+
+        //if (data.opts.turn) {
+         offset = findPos(data.opts.turn[0]);
+         data.fparent.css({top: -offset.top, left: -offset.left});
+        //}
+      }
+
+      this.flip('z', data.opts['z-index']);
+
+      break;
+    }
+
+  },
+
+  // Prepares the page by adding a general wrapper and another objects
+
+  _addPageWrapper: function() {
+
+    var att,
+      data = this.data().f,
+      turnData = data.opts.turn.data(),
+      parent = this.parent();
+
+    data.parent = parent;
+
+  if (!data.wrapper)
+    switch (data.effect) {
+      case 'hard':
+        
+        var cssProperties = {};
+        cssProperties[vendor + 'transform-style'] = 'preserve-3d';
+        cssProperties[vendor + 'backface-visibility'] = 'hidden';
+
+        data.wrapper = $('<div/>', divAtt(0, 0, 2)).
+          css(cssProperties).
+          appendTo(parent).
+          prepend(this);
+
+        data.fpage = $('<div/>', divAtt(0, 0, 1)).
+          css(cssProperties).
+          appendTo(parent);
+        
+        if (turnData.opts.gradients) {
+          data.ashadow = $('<div/>', divAtt(0, 0,  0)).
+            hide().
+            appendTo(parent);
+
+          data.bshadow = $('<div/>', divAtt(0, 0,  0));
+        }
+
+      break;
+      case 'sheet':
+        
+        var width = this.width(),
+          height = this.height(),
+          size = Math.round(Math.sqrt(Math.pow(width, 2)+Math.pow(height, 2)));
+        
+        data.fparent = data.opts.turn.data().fparent;
+
+        if (!data.fparent) {
+          var fparent = $('<div/>', {css: {'pointer-events': 'none'}}).hide();
+            fparent.data().flips = 0;
+            fparent.css(divAtt(0, 0, 'auto', 'visible').css).
+            appendTo(data.opts.turn);
+            
+            data.opts.turn.data().fparent = fparent;
+            data.fparent = fparent;
+        }
+
+        this.css({position: 'absolute', top: 0, left: 0, bottom: 'auto', right: 'auto'});
+
+        data.wrapper = $('<div/>', divAtt(0, 0, this.css('z-index'))).
+          appendTo(parent).
+          prepend(this);
+
+        data.fwrapper = $('<div/>', divAtt(parent.offset().top, parent.offset().left)).
+          hide().
+          appendTo(data.fparent);
+
+        data.fpage = $('<div/>', divAtt(0, 0, 0, 'visible')).
+          css({cursor: 'default'}).
+          appendTo(data.fwrapper);
+
+        if (turnData.opts.gradients)
+          data.ashadow = $('<div/>', divAtt(0, 0,  1)).
+          appendTo(data.fpage);
+
+        flipMethods.setData.call(this, data);
+
+      break;
+    }
+
+    // Set size
+    flipMethods.resize.call(this, true);
+
+  },
+
+  // Takes a 2P point from the screen and applies the transformation
+
+  _fold: function(point) {
+
+    var data = this.data().f,
+      turnData = data.opts.turn.data(),
+      o = flipMethods._c.call(this, point.corner),
+      width = this.width(),
+      height = this.height();
+
+    switch (data.effect) {
+
+      case 'hard':
+
+        if (point.corner=='l')
+          point.x = Math.min(Math.max(point.x, 0), width*2);
+        else
+          point.x = Math.max(Math.min(point.x, width), -width);
+
+        var leftPos,
+          shadow,
+          gradientX,
+          fpageOrigin,
+          parentOrigin,
+          totalPages = turnData.totalPages,
+          zIndex = data.opts['z-index'] || totalPages,
+          parentCss = {'overflow': 'visible'},
+          relX = (o.x) ? (o.x - point.x)/width : point.x/width,
+          angle = relX * 90,
+          half = angle<90;
+
+        switch (point.corner) {
+          case 'l':
+
+            fpageOrigin =  '0% 50%';
+            parentOrigin =  '100% 50%';
+
+            if (half) {
+              leftPos = 0;
+              shadow = data.opts.next-1>0;
+              gradientX = 1;
+            } else {
+              leftPos = '100%';
+              shadow = data.opts.page+1<totalPages;
+              gradientX = 0;
+            }
+
+          break;
+          case 'r':
+
+            fpageOrigin =  '100% 50%';
+            parentOrigin =  '0% 50%';
+            angle = -angle;
+            width = -width;
+
+            if (half) {
+              leftPos = 0;
+              shadow = data.opts.next+1<totalPages;
+              gradientX = 0;
+            } else {
+              leftPos = '-100%';
+              shadow = data.opts.page!=1;
+              gradientX = 1;
+            }
+
+          break;
+        }
+
+        parentCss[vendor+'perspective-origin'] = parentOrigin;
+
+        data.wrapper.transform('rotateY('+angle+'deg)' +
+          'translate3d(0px, 0px, '+(this.attr('depth')||0)+'px)', parentOrigin);
+
+        data.fpage.transform('translateX('+width+'px) rotateY('+(180+angle)+'deg)', fpageOrigin);
+
+        data.parent.css(parentCss);
+
+        if (half) {
+          relX = -relX+1;
+          data.wrapper.css({zIndex: zIndex+1});
+          data.fpage.css({zIndex: zIndex});
+        } else {
+          relX = relX-1;
+          data.wrapper.css({zIndex: zIndex});
+          data.fpage.css({zIndex: zIndex+1});
+        }
+
+        if (turnData.opts.gradients) {
+          if (shadow)
+            data.ashadow.css({
+              display: '',
+              left: leftPos,
+              backgroundColor: 'rgba(0,0,0,'+(0.5*relX)+')'
+            }).
+            transform('rotateY(0deg)');
+          else
+            data.ashadow.hide();
+
+          data.bshadow.css({opacity:-relX + 1});
+
+          if (half) {
+            if (data.bshadow.parent()[0]!=data.wrapper[0]) {
+              data.bshadow.appendTo(data.wrapper);
+            }
+          } else {
+            if (data.bshadow.parent()[0]!=data.fpage[0]) {
+              data.bshadow.appendTo(data.fpage);
+            }
+          }
+          /*data.bshadow.css({
+            backgroundColor: 'rgba(0,0,0,'+(0.1)+')'
+          })*/
+          gradient(data.bshadow, point2D(gradientX * 100, 0), point2D((-gradientX + 1)*100, 0),
+            [[0, 'rgba(0,0,0,0.3)'],[1, 'rgba(0,0,0,0)']],2);
+          
+        }
+
+        break;
+      case 'sheet':
+
+        var that = this,
+          a = 0,
+          alpha = 0,
+          beta,
+          px,
+          gradientEndPointA,
+          gradientEndPointB,
+          gradientStartVal,
+          gradientSize,
+          gradientOpacity,
+          shadowVal,
+          mv = point2D(0, 0),
+          df = point2D(0, 0),
+          tr = point2D(0, 0),
+          folding = flipMethods._foldingPage.call(this),
+          tan = Math.tan(alpha),
+          ac = turnData.opts.acceleration,
+          h = data.wrapper.height(),
+          top = point.corner.substr(0, 1) == 't',
+          left = point.corner.substr(1, 1) == 'l',
+
+      compute = function() {
+
+        var rel = point2D(0, 0);
+        var middle = point2D(0, 0);
+
+        rel.x = (o.x) ? o.x - point.x : point.x;
+
+        if (!hasRot) {
+          rel.y = 0;
+        } else {
+          rel.y = (o.y) ? o.y - point.y : point.y;
+        }
+
+        middle.x = (left)? width - rel.x/2 : point.x + rel.x/2;
+        middle.y = rel.y/2;
+        
+        var alpha =  A90-Math.atan2(rel.y, rel.x),
+          gamma = alpha - Math.atan2(middle.y, middle.x),
+          distance =  Math.max(0, Math.sin(gamma) * Math.sqrt(Math.pow(middle.x, 2) + Math.pow(middle.y, 2)));
+          
+          a = deg(alpha);
+
+          tr = point2D(distance * Math.sin(alpha), distance * Math.cos(alpha));
+
+          if (alpha > A90) {
+            tr.x = tr.x + Math.abs(tr.y * rel.y/rel.x);
+            tr.y = 0;
+            if (Math.round(tr.x*Math.tan(PI-alpha)) < height) {
+              point.y = Math.sqrt(Math.pow(height, 2)+2 * middle.x * rel.x);
+              if (top) point.y =  height - point.y;
+              return compute();
+            }
+          }
+      
+          if (alpha>A90) {
+            var beta = PI-alpha, dd = h - height/Math.sin(beta);
+            mv = point2D(Math.round(dd*Math.cos(beta)), Math.round(dd*Math.sin(beta)));
+            if (left) mv.x = - mv.x;
+            if (top) mv.y = - mv.y;
+          }
+
+          px = Math.round(tr.y/Math.tan(alpha) + tr.x);
+      
+          var side = width - px,
+            sideX = side*Math.cos(alpha*2),
+            sideY = side*Math.sin(alpha*2);
+            df = point2D(
+              Math.round((left ? side -sideX : px+sideX)),
+              Math.round((top) ? sideY : height - sideY));
+          
+        // Gradients
+          if (turnData.opts.gradients) {
+
+            gradientSize = side*Math.sin(alpha);
+
+            var endingPoint = flipMethods._c2.call(that, point.corner),
+             far = Math.sqrt(Math.pow(endingPoint.x-point.x, 2)+Math.pow(endingPoint.y-point.y, 2))/width;
+
+            shadowVal = Math.sin(A90*((far>1) ? 2 - far : far));
+
+            gradientOpacity = Math.min(far, 1);
+
+           
+              gradientStartVal = gradientSize>100 ? (gradientSize-100)/gradientSize : 0;
+
+              gradientEndPointA = point2D(
+                gradientSize*Math.sin(alpha)/width*100,
+                gradientSize*Math.cos(alpha)/height*100);
+           
+
+              if (flipMethods._backGradient.call(that)) {
+
+                gradientEndPointB = point2D(
+                  gradientSize*1.2*Math.sin(alpha)/width*100,
+                  gradientSize*1.2*Math.cos(alpha)/height*100);
+
+                if (!left) gradientEndPointB.x = 100-gradientEndPointB.x;
+                if (!top) gradientEndPointB.y = 100-gradientEndPointB.y;
+
+              }
+
+          }
+
+          tr.x = Math.round(tr.x);
+          tr.y = Math.round(tr.y);
+
+        return true;
+      },
+
+      transform = function(tr, c, x, a) {
+      
+        var f = ['0', 'auto'], mvW = (width-h)*x[0]/100, mvH = (height-h)*x[1]/100,
+          cssA = {left: f[c[0]], top: f[c[1]], right: f[c[2]], bottom: f[c[3]]},
+          cssB = {},
+          aliasingFk = (a!=90 && a!=-90) ? (left ? -1 : 1) : 0,
+          origin = x[0] + '% ' + x[1] + '%';
+
+        that.css(cssA).
+          transform(rotate(a) + translate(tr.x + aliasingFk, tr.y, ac), origin);
+
+        data.fpage.css(cssA).transform(
+          rotate(a) +
+          translate(tr.x + df.x - mv.x - width*x[0]/100, tr.y + df.y - mv.y - height*x[1]/100, ac) +
+          rotate((180/a - 2)*a),
+          origin);
+
+        data.wrapper.transform(translate(-tr.x + mvW-aliasingFk, -tr.y + mvH, ac) + rotate(-a), origin);
+
+        data.fwrapper.transform(translate(-tr.x + mv.x + mvW, -tr.y + mv.y + mvH, ac) + rotate(-a), origin);
+      
+        if (turnData.opts.gradients) {
+
+          if (x[0])
+            gradientEndPointA.x = 100-gradientEndPointA.x;
+
+          if (x[1])
+            gradientEndPointA.y = (100-gradientEndPointA.y);
+
+          cssB['box-shadow'] = '0 0 20px rgba(0,0,0,'+(0.5*shadowVal)+')';
+          folding.css(cssB);
+
+          gradient(data.ashadow,
+              point2D(left?100:0, top?0:100),
+              point2D(gradientEndPointA.x, gradientEndPointA.y),
+              [[gradientStartVal, 'rgba(0,0,0,0)'],
+              [((1-gradientStartVal)*0.8)+gradientStartVal, 'rgba(0,0,0,'+(0.2*gradientOpacity)+')'],
+              [1, 'rgba(255,255,255,'+(0.2*gradientOpacity)+')']],
+              3,
+              alpha);
+
+          if (flipMethods._backGradient.call(that))
+            gradient(data.bshadow,
+                point2D(left?0:100, top?0:100),
+                point2D(gradientEndPointB.x, gradientEndPointB.y),
+                [[0.6, 'rgba(0,0,0,0)'],
+                [0.8, 'rgba(0,0,0,'+(0.3*gradientOpacity)+')'],
+                [1, 'rgba(0,0,0,0)']
+                ],
+                3);
+        }
+
+      };
+
+      switch (point.corner) {
+        case 'l' :
+
+
+        break;
+        case 'r' :
+
+
+        break;
+        case 'tl' :
+          point.x = Math.max(point.x, 1);
+          compute();
+          transform(tr, [1,0,0,1], [100, 0], a);
+        break;
+        case 'tr' :
+          point.x = Math.min(point.x, width-1);
+          compute();
+          transform(point2D(-tr.x, tr.y), [0,0,0,1], [0, 0], -a);
+        break;
+        case 'bl' :
+          point.x = Math.max(point.x, 1);
+          compute();
+          transform(point2D(tr.x, -tr.y), [1,1,0,0], [100, 100], -a);
+        break;
+        case 'br' :
+          point.x = Math.min(point.x, width-1);
+          compute();
+          transform(point2D(-tr.x, -tr.y), [0,1,1,0], [0, 100], a);
+        break;
+      }
+
+    break;
+  }
+
+    data.point = point;
+  
+  },
+
+  _moveFoldingPage: function(move) {
+
+    var data = this.data().f;
+
+    if (!data)
+      return;
+
+    var turn = data.opts.turn,
+      turnData = turn.data(),
+      place = turnData.pagePlace;
+      
+    if (move) {
+
+      var nextPage = data.opts.next;
+  
+      if (place[nextPage]!=data.opts.page) {
+
+        if (data.folding)
+          flipMethods._moveFoldingPage.call(this, false);
+
+        var folding = flipMethods._foldingPage.call(this);
+        
+        folding.appendTo(data.fpage);
+        place[nextPage] = data.opts.page;
+        data.folding = nextPage;
+      }
+
+      turn.turn('update');
+
+    } else {
+
+      if (data.folding) {
+
+        if (turnData.pages[data.folding]) {
+         
+          // If we have flip available
+
+          var flipData = turnData.pages[data.folding].data().f;
+          
+          turnData.pageObjs[data.folding].
+            appendTo(flipData.wrapper);
+
+        } else if (turnData.pageWrap[data.folding]) {
+          
+          // If we have the pageWrapper
+
+          turnData.pageObjs[data.folding].
+            appendTo(turnData.pageWrap[data.folding]);
+
+        }
+
+        if (data.folding in place) {
+          place[data.folding] = data.folding;
+        }
+
+        delete data.folding;
+
+      }
+    }
+  },
+
+  _showFoldedPage: function(c, animate) {
+
+    var folding = flipMethods._foldingPage.call(this),
+      dd = this.data(),
+      data = dd.f,
+      visible = data.visible;
+
+    if (folding) {
+
+      if (!visible || !data.point || data.point.corner!=c.corner) {
+
+        var corner = (
+          data.status=='hover' ||
+          data.status=='peel' ||
+          data.opts.turn.data().mouseAction) ?
+        c.corner : null;
+
+        visible = false;
+
+        if (trigger('start', this, [data.opts, corner])=='prevented')
+          return false;
+
+      }
+
+      if (animate) {
+        
+        var that = this,
+          point = (data.point && data.point.corner==c.corner) ?
+          data.point : flipMethods._c.call(this, c.corner, 1);
+      
+        this.animatef({
+          from: [point.x, point.y],
+          to: [c.x, c.y],
+          duration: 500,
+          frame: function(v) {
+            c.x = Math.round(v[0]);
+            c.y = Math.round(v[1]);
+            flipMethods._fold.call(that, c);
+          }
+        });
+
+      } else  {
+
+        flipMethods._fold.call(this, c);
+
+        if (dd.effect && !dd.effect.turning)
+          this.animatef(false);
+
+      }
+
+      if (!visible) {
+
+        switch(data.effect) {
+          case 'hard':
+
+            data.visible = true;
+            flipMethods._moveFoldingPage.call(this, true);
+            data.fpage.show();
+            if (data.opts.shadows)
+              data.bshadow.show();
+
+          break;
+          case 'sheet':
+
+            data.visible = true;
+            data.fparent.show().data().flips++;
+            flipMethods._moveFoldingPage.call(this, true);
+            data.fwrapper.show();
+            if (data.bshadow)
+              data.bshadow.show();
+
+          break;
+        }
+
+      }
+
+      return true;
+
+    }
+
+    return false;
+  },
+
+  hide: function() {
+
+    var data = this.data().f,
+      turnData = data.opts.turn.data(),
+      folding = flipMethods._foldingPage.call(this);
+
+    switch (data.effect) {
+      case 'hard':
+        
+        if (turnData.opts.gradients) {
+          data.bshadowLoc = 0;
+          data.bshadow.remove();
+          data.ashadow.hide();
+        }
+
+        data.wrapper.transform('');
+        data.fpage.hide();
+
+      break;
+      case 'sheet':
+
+        if ((--data.fparent.data().flips)===0)
+          data.fparent.hide();
+
+        this.css({left: 0, top: 0, right: 'auto', bottom: 'auto'}).
+          transform('');
+
+        data.wrapper.transform('');
+
+        data.fwrapper.hide();
+
+        if (data.bshadow)
+          data.bshadow.hide();
+
+        folding.transform('');
+
+      break;
+    }
+
+      data.visible = false;
+
+    return this;
+  },
+
+  hideFoldedPage: function(animate) {
+
+    var data = this.data().f;
+
+    if (!data.point) return;
+
+    var that = this,
+      p1 = data.point,
+      hide = function() {
+        data.point = null;
+        data.status = '';
+        that.flip('hide');
+        that.trigger('end', [data.opts, false]);
+      };
+
+    if (animate) {
+
+      var p4 = flipMethods._c.call(this, p1.corner),
+        top = (p1.corner.substr(0,1)=='t'),
+        delta = (top) ? Math.min(0, p1.y-p4.y)/2 : Math.max(0, p1.y-p4.y)/2,
+        p2 = point2D(p1.x, p1.y+delta),
+        p3 = point2D(p4.x, p4.y-delta);
+    
+      this.animatef({
+        from: 0,
+        to: 1,
+        frame: function(v) {
+          var np = bezier(p1, p2, p3, p4, v);
+          p1.x = np.x;
+          p1.y = np.y;
+          flipMethods._fold.call(that, p1);
+        },
+        complete: hide,
+        duration: 800,
+        hiding: true
+      });
+
+    } else {
+
+      this.animatef(false);
+      hide();
+
+    }
+  },
+
+  turnPage: function(corner) {
+
+    var that = this,
+      data = this.data().f,
+      turnData = data.opts.turn.data();
+
+    corner = {corner: (data.corner) ?
+      data.corner.corner :
+      corner || flipMethods._cAllowed.call(this)[0]};
+
+    var p1 = data.point ||
+      flipMethods._c.call(this,
+        corner.corner,
+        (data.opts.turn) ? turnData.opts.elevation : 0),
+      p4 = flipMethods._c2.call(this, corner.corner);
+
+      this.trigger('flip').
+        animatef({
+          from: 0,
+          to: 1,
+          frame: function(v) {
+
+            var np = bezier(p1, p1, p4, p4, v);
+            corner.x = np.x;
+            corner.y = np.y;
+            flipMethods._showFoldedPage.call(that, corner);
+
+          },
+          complete: function() {
+            
+            that.trigger('end', [data.opts, true]);
+
+          },
+          duration: turnData.opts.duration,
+          turning: true
+        });
+
+      data.corner = null;
+  },
+
+  moving: function() {
+
+    return 'effect' in this.data();
+  
+  },
+
+  isTurning: function() {
+
+    return this.flip('moving') && this.data().effect.turning;
+  
+  },
+
+  corner: function() {
+    
+    return this.data().f.corner;
+      
+  },
+
+  _eventStart: function(e) {
+
+    var data = this.data().f,
+      turn = data.opts.turn;
+
+    if (!data.corner && !data.disabled && !this.flip('isTurning') &&
+      data.opts.page==turn.data().pagePlace[data.opts.page])
+    {
+
+      data.corner = flipMethods._isIArea.call(this, e);
+
+      if (data.corner && flipMethods._foldingPage.call(this)) {
+
+        this.trigger('pressed', [data.point]);
+        flipMethods._showFoldedPage.call(this, data.corner);
+
+        return false;
+
+      } else
+        data.corner = null;
+
+    }
+
+  },
+
+  _eventMove: function(e) {
+
+    var data = this.data().f;
+
+    if (!data.disabled) {
+
+      e = (isTouch) ? e.originalEvent.touches : [e];
+
+      if (data.corner) {
+
+        var pos = data.parent.offset();
+        data.corner.x = e[0].pageX-pos.left;
+        data.corner.y = e[0].pageY-pos.top;
+        flipMethods._showFoldedPage.call(this, data.corner);
+
+      } else if (data.hover && !this.data().effect && this.is(':visible')) {
+
+        var point = flipMethods._isIArea.call(this, e[0]);
+
+        if (point) {
+
+          if ((data.effect=='sheet' && point.corner.length==2)  || data.effect=='hard') {
+            data.status = 'hover';
+            var origin = flipMethods._c.call(this, point.corner, data.opts.cornerSize/2);
+            point.x = origin.x;
+            point.y = origin.y;
+            flipMethods._showFoldedPage.call(this, point, true);
+          }
+        
+        } else {
+          
+          if (data.status=='hover') {
+            data.status = '';
+            flipMethods.hideFoldedPage.call(this, true);
+          }
+
+        }
+
+      }
+
+    }
+
+  },
+
+  _eventEnd: function() {
+
+    var data = this.data().f,
+      corner = data.corner;
+
+    if (!data.disabled && corner) {
+      if (trigger('released', this, [data.point || corner])!='prevented') {
+        flipMethods.hideFoldedPage.call(this, true);
+      }
+    }
+
+    data.corner = null;
+
+  },
+
+  disable: function(disable) {
+
+    flipMethods.setData.call(this, {'disabled': disable});
+    return this;
+
+  },
+
+  hover: function(hover) {
+    
+    flipMethods.setData.call(this, {'hover': hover});
+    return this;
+
+  },
+
+  peel: function (corner, animate) {
+
+    var data = this.data().f;
+
+    if (corner) {
+
+      if ($.inArray(corner, corners.all)==-1)
+        throw turnError('Corner '+corner+' is not permitted');
+
+      if ($.inArray(corner, flipMethods._cAllowed.call(this))!=-1) {
+
+        var point = flipMethods._c.call(this, corner, data.opts.cornerSize/2);
+        
+        data.status = 'peel';
+
+        flipMethods._showFoldedPage.call(this,
+        {
+          corner: corner,
+          x: point.x,
+          y: point.y
+        }, animate);
+
+      }
+
+
+    } else {
+
+      data.status = '';
+
+      flipMethods.hideFoldedPage.call(this, animate);
+      
+    }
+
+    return this;
+  }
+};
+
+
+// Processes classes
+
+function dec(that, methods, args) {
+
+  if (!args[0] || typeof(args[0])=='object')
+    return methods.init.apply(that, args);
+
+  else if (methods[args[0]])
+    return methods[args[0]].apply(that, Array.prototype.slice.call(args, 1));
+
+  else
+    throw turnError(args[0] + ' is not a method or property');
+
+}
+
+
+// Attributes for a layer
+
+function divAtt(top, left, zIndex, overf) {
+    
+  return {'css': {
+    position: 'absolute',
+    top: top,
+    left: left,
+    'overflow': overf || 'hidden',
+    zIndex: zIndex || 'auto'
+  }
+};
+      
+}
+
+// Gets a 2D point from a bezier curve of four points
+
+function bezier(p1, p2, p3, p4, t) {
+
+  var a = 1 - t,
+    b = a * a * a,
+    c = t * t * t;
+    
+  return point2D(Math.round(b*p1.x + 3*t*a*a*p2.x + 3*t*t*a*p3.x + c*p4.x),
+    Math.round(b*p1.y + 3*t*a*a*p2.y + 3*t*t*a*p3.y + c*p4.y));
+
+}
+  
+// Converts an angle from degrees to radians
+
+function rad(degrees) {
+  
+  return degrees/180*PI;
+
+}
+
+// Converts an angle from radians to degrees
+
+function deg(radians) {
+  
+  return radians/PI*180;
+
+}
+
+// Gets a 2D point
+
+function point2D(x, y) {
+  
+  return {x: x, y: y};
+
+}
+
+// Webkit 534.3 on Android wrongly repaints elements that use overflow:hidden + rotation
+
+function rotationAvailable() {
+  var parts;
+
+  if ((parts = /AppleWebkit\/([0-9\.]+)/i.exec(navigator.userAgent))) {
+    var webkitVersion = parseFloat(parts[1]);
+    return (webkitVersion>534.3);
+  } else {
+    return true;
+  }
+}
+
+// Returns the traslate value
+
+function translate(x, y, use3d) {
+  
+  return (has3d && use3d) ? ' translate3d(' + x + 'px,' + y + 'px, 0px) '
+  : ' translate(' + x + 'px, ' + y + 'px) ';
+
+}
+
+// Returns the rotation value
+
+function rotate(degrees) {
+  
+  return ' rotate(' + degrees + 'deg) ';
+
+}
+
+// Checks if a property belongs to an object
+
+function has(property, object) {
+  
+  return Object.prototype.hasOwnProperty.call(object, property);
+
+}
+
+// Gets the CSS3 vendor prefix
+
+function getPrefix() {
+
+  var vendorPrefixes = ['Moz','Webkit','Khtml','O','ms'],
+  len = vendorPrefixes.length,
+  vendor = '';
+
+  while (len--)
+    if ((vendorPrefixes[len] + 'Transform') in document.body.style)
+      vendor='-'+vendorPrefixes[len].toLowerCase()+'-';
+
+  return vendor;
+
+}
+
+// Detects the transitionEnd Event
+
+function getTransitionEnd() {
+
+  var t,
+    el = document.createElement('fakeelement'),
+    transitions = {
+      'transition':'transitionend',
+      'OTransition':'oTransitionEnd',
+      'MSTransition':'transitionend',
+      'MozTransition':'transitionend',
+      'WebkitTransition':'webkitTransitionEnd'
+    };
+
+  for (t in transitions) {
+    if (el.style[t] !== undefined) {
+      return transitions[t];
+    }
+  }
+}
+
+// Gradients
+
+function gradient(obj, p0, p1, colors, numColors) {
+
+  var j, cols = [];
+
+  if (vendor=='-webkit-') {
+
+    for (j = 0; j<numColors; j++)
+      cols.push('color-stop('+colors[j][0]+', '+colors[j][1]+')');
+    
+    obj.css({'background-image':
+        '-webkit-gradient(linear, '+
+        p0.x+'% '+
+        p0.y+'%,'+
+        p1.x+'% '+
+        p1.y+'%, '+
+        cols.join(',') + ' )'});
+  } else {
+    
+    p0 = {x:p0.x/100 * obj.width(), y:p0.y/100 * obj.height()};
+    p1 = {x:p1.x/100 * obj.width(), y:p1.y/100 * obj.height()};
+
+    var dx = p1.x-p0.x,
+      dy = p1.y-p0.y,
+      angle = Math.atan2(dy, dx),
+      angle2 = angle - Math.PI/2,
+      diagonal = Math.abs(obj.width()*Math.sin(angle2))+Math.abs(obj.height()*Math.cos(angle2)),
+      gradientDiagonal = Math.sqrt(dy*dy + dx*dx),
+      corner = point2D((p1.x<p0.x) ? obj.width() : 0, (p1.y<p0.y) ? obj.height() : 0),
+      slope = Math.tan(angle),
+      inverse = -1/slope,
+      x = (inverse*corner.x - corner.y - slope*p0.x + p0.y)/(inverse-slope),
+      c = {x: x, y: inverse*x - inverse*corner.x + corner.y},
+      segA = (Math.sqrt( Math.pow(c.x-p0.x,2) + Math.pow(c.y-p0.y,2)));
+
+      for (j = 0; j<numColors; j++)
+        cols.push(' '+colors[j][1]+' '+((segA + gradientDiagonal*colors[j][0])*100/diagonal)+'%');
+
+      obj.css({'background-image': vendor+'linear-gradient(' + (-angle) + 'rad,' + cols.join(',') + ')'});
+  }
+}
+
+
+// Triggers an event
+
+function trigger(eventName, context, args) {
+
+  var event = $.Event(eventName);
+  context.trigger(event, args);
+  if (event.isDefaultPrevented())
+    return 'prevented';
+  else if (event.isPropagationStopped())
+    return 'stopped';
+  else
+    return '';
+}
+
+// JS Errors
+
+function turnError(message) {
+
+  function TurnJsError(message) {
+    this.name = "TurnJsError";
+    this.message = message;
+  }
+
+  TurnJsError.prototype = new Error();
+  TurnJsError.prototype.constructor = TurnJsError;
+  return new TurnJsError(message);
+
+}
+
+// Find the offset of an element ignoring its transformation
+
+function findPos(obj) {
+
+  var offset = {top: 0, left: 0};
+
+  do{
+    offset.left += obj.offsetLeft;
+    offset.top += obj.offsetTop;
+  } while ((obj = obj.offsetParent));
+
+  return offset;
+
+}
+
+// Checks if there's hard page compatibility
+// IE9 is the only browser that does not support hard pages
+
+function hasHardPage() {
+  return (navigator.userAgent.indexOf('MSIE 9.0')==-1);
+}
+
+// Request an animation
+
+window.requestAnim = (function() {
+  return window.requestAnimationFrame ||
+    window.webkitRequestAnimationFrame ||
+    window.mozRequestAnimationFrame ||
+    window.oRequestAnimationFrame ||
+    window.msRequestAnimationFrame ||
+    function(callback) {
+      window.setTimeout(callback, 1000 / 60);
+    };
+
+})();
+
+// Extend $.fn
+
+$.extend($.fn, {
+
+  flip: function() {
+    return dec($(this[0]), flipMethods, arguments);
+  },
+
+  turn: function() {
+    return dec($(this[0]), turnMethods, arguments);
+  },
+
+  transform: function(transform, origin) {
+
+    var properties = {};
+    
+    if (origin)
+      properties[vendor+'transform-origin'] = origin;
+    
+    properties[vendor+'transform'] = transform;
+  
+    return this.css(properties);
+
+  },
+
+  animatef: function(point) {
+
+    var data = this.data();
+
+    if (data.effect)
+      data.effect.stop();
+
+    if (point) {
+
+      if (!point.to.length) point.to = [point.to];
+      if (!point.from.length) point.from = [point.from];
+
+      var diff = [],
+        len = point.to.length,
+        animating = true,
+        that = this,
+        time = (new Date()).getTime(),
+        frame = function() {
+
+          if (!data.effect || !animating)
+            return;
+
+          var v = [],
+            timeDiff = Math.min(point.duration, (new Date()).getTime() - time);
+
+          for (var i = 0; i < len; i++)
+            v.push(data.effect.easing(1, timeDiff, point.from[i], diff[i], point.duration));
+
+          point.frame((len==1) ? v[0] : v);
+
+          if (timeDiff==point.duration) {
+            delete data['effect'];
+            that.data(data);
+            if (point.complete)
+              point.complete();
+          } else {
+            window.requestAnim(frame);
+          }
+        };
+
+      for (var i = 0; i < len; i++)
+        diff.push(point.to[i] - point.from[i]);
+
+      data.effect = $.extend({
+        stop: function() {
+          animating = false;
+        },
+        easing: function (x, t, b, c, data) {
+          return c * Math.sqrt(1 - (t=t/data-1)*t) + b;
+        }
+      }, point);
+
+      this.data(data);
+
+      frame();
+
+    } else {
+      
+      delete data['effect'];
+
+    }
+  }
+});
+
+// Export some globals
+
+$.isTouch = isTouch;
+$.mouseEvents = mouseEvents;
+$.cssPrefix = getPrefix;
+$.cssTransitionEnd = getTransitionEnd;
+$.findPos = findPos;
+
+})(jQuery);