oridomi.coffee

# # OriDomi
# ### Fold up the DOM like paper.
# 1.0.4

# [oridomi.com](http://oridomi.com)
# #### by [Dan Motzenbecker](http://oxism.com)

# Copyright 2013, MIT License

'use strict'

# This variable is set to true and negated later if the browser does
# not support OriDomi.
isSupported = true

# Utility Functions
# ================

# Used for informing the developer which required feature the browser lacks.
supportWarning = (prop) ->
  console?.warn "OriDomi: Missing support for `#{ prop }`."
  isSupported = false


# Checks for the presence of CSS properties on a test element.
testProp = (prop) ->
  # Loop through the vendor prefix list and return a match is found.
  for prefix in prefixList
    return full if testEl.style[(full = prefix + capitalize prop)]?

  # If the unprefixed property is present, return it.
  return prop if testEl.style[prop]?
  # If no matches are found, return false to denote that the browser is
  # missing this property.
  false


# Generates CSS text based on a selector string and a map of styling rules.
addStyle = (selector, rules) ->
  style = ".#{ selector }{"
  for prop, val of rules
    # If the CSS property is among special properties defined later, prefix it.
    if prop of css
      prop = css[prop]
      prop = '-' + prop if prop.match /^(webkit|moz|ms)/i

    # Convert camelcase to hypenated.
    style += "#{ prop.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase() }:#{ val };"

  styleBuffer += style + '}'


# Defines gradient directions based on a given anchor.
getGradient = (anchor) ->
  "#{ css.gradientProp }(#{ anchor }, rgba(0, 0, 0, .5) 0%, rgba(255, 255, 255, .35) 100%)"


# Used mainly when creating camelcased strings.
capitalize = (s) ->
  s[0].toUpperCase() + s[1...]


# Create an element and look up the canonical class name.
createEl = (className) ->
  el = document.createElement 'div'
  el.className = elClasses[className]
  el


# Clone an element, add an additional class, and return it.
cloneEl = (parent, deep, className) ->
  el = parent.cloneNode deep
  el.classList.add elClasses[className]
  el


# GPU efficient ways of hiding and showing elements:
hideEl = (el) ->
  el.style[css.transform] = 'translate3d(-99999px, 0, 0)'


showEl = (el) ->
  el.style[css.transform] = 'translate3d(0, 0, 0)'


# This decorator is used on public effect methods to invoke preliminary tasks
# before the effect is applied.
prep = (fn) ->
  ->
    # If the method has been initiated by a touch handler, skip this process.
    if @_touchStarted
      fn.apply @, arguments
    else
      [a0, a1, a2] = arguments
      opt          = {}
      angle        = anchor = null

      # This switch is used to derive the intended order of arguments.
      # This keeps argument requirements flexible, allowing most to be left out.
      # By putting this logic in a decorator, it doesn't have to exist in any
      # of the individual methods.

      # Methods are inferred by their arity.
      switch fn.length
        when 1
          opt.callback = a0
          # If the composition is already folded up, skip the queueing process
          # and invoke the supplied callback immediately.
          return opt.callback?() unless @isFoldedUp
        when 2
          if typeof a0 is 'function'
            opt.callback = a0
          else
            anchor       = a0
            opt.callback = a1
        when 3
          angle = a0
          if arguments.length is 2
            if typeof a1 is 'object'
              opt = a1
            else if typeof a1 is 'function'
              opt.callback = a1
            else
              anchor = a1
          else if arguments.length is 3
            anchor = a1
            if typeof a2 is 'object'
              opt = a2
            else if typeof a2 is 'function'
              opt.callback = a2

      angle   ?= @_lastOp.angle or 0
      anchor or= @_lastOp.anchor
      # Here we add the called function and its normalized arguments to the
      # instance's queue.
      @_queue.push [fn, @_normalizeAngle(angle), @_getLonghandAnchor(anchor), opt]
      # `_step()` manages the queue and decides whether the action will occur now
      # or be deferred.
      @_step()
      # This decorator also returns the instance so effect methods are chainable.
      @


# It's necessary to defer many DOM manipulations to a subsequent event loop tick.
defer = (fn) ->
  setTimeout fn, 0


# Empty function to be used as placeholder for callback defaults
# (instead of creating separate empty functions).
noOp = ->


# Setup
# =====

# Set a reference to jQuery (or another `$`-aliased DOM library).
# If it doesn't exist, set to null so OriDomi knows we are working without jQuery.
# OriDomi doesn't require it to work, but offers a useful plugin bridge if present.
$ = if (window.jQuery or window.$)?.data then window.$ else null

# List of anchors and their corresponding axis pairs.
anchorList  = ['left', 'right', 'top', 'bottom']
anchorListV = anchorList[..1]
anchorListH = anchorList[2..]

# Create a div for testing CSS3 properties.
testEl = document.createElement 'div'

# The style buffer is later populated with CSS rules and appended to the document.
styleBuffer = ''

# List of browser prefixes for testing CSS3 properties.
prefixList = ['Webkit', 'Moz', 'ms']
baseName   = 'oridomi'
# CSS classes used by style rules.
elClasses  =
  active:       'active'
  clone:        'clone'
  holder:       'holder'
  stage:        'stage'
  stageLeft:    'stage-left'
  stageRight:   'stage-right'
  stageTop:     'stage-top'
  stageBottom:  'stage-bottom'
  content:      'content'
  mask:         'mask'
  maskH:        'mask-h'
  maskV:        'mask-v'
  panel:        'panel'
  panelH:       'panel-h'
  panelV:       'panel-v'
  shader:       'shader'
  shaderLeft:   'shader-left'
  shaderRight:  'shader-right'
  shaderTop:    'shader-top'
  shaderBottom: 'shader-bottom'

# Each class is namespaced to prevent styling collisions.
elClasses[k] = "#{ baseName }-#{ v }" for k, v of elClasses

# Map of the CSS3 properties needed to support OriDomi, with shorthand names as keys.
# The keys and values are initialized as identical pairs to start with and prefixed
# subsequently when necessary.
css = new ->
  @[key] = key for key in [
    'transform'
    'transformOrigin'
    'transformStyle'
    'transitionProperty'
    'transitionDuration'
    'transitionDelay'
    'transitionTimingFunction'
    'perspective'
    'perspectiveOrigin'
    'backfaceVisibility'
    'boxSizing'
    'mask'
  ]
  @

# This section is wrapped in an immediately invoked function so that it can exit
# early when discovering a lack of browser support to prevent unnecessary work.
do ->
  # Loop through the CSS map and replace each value with the result of `testProp()`.
  for key, value of css
    css[key] = testProp value
    # If the returned value is false, warn the user that the browser doesn't support
    # OriDomi, set `isSupported` to false, and break out of the loop.
    return supportWarning value unless css[key]

  # Test for `preserve-3d` as a transform style. This is particularly important
  # since it's necessary for nested 3D transforms and recent versions of IE that
  # support 3D transforms lack it.
  p3d = 'preserve-3d'
  testEl.style[css.transformStyle] = p3d
  # Failure is indicated when querying the style lacks the correct string.
  unless testEl.style[css.transformStyle] is p3d
    return supportWarning p3d

  # CSS3 linear gradients are used for shading.
  # Testing for them is different because they are prefixed values, not properties.
  # This invokes an anonymous function to loop through vendor-prefixed linear gradients.
  css.gradientProp = do ->
    for prefix in prefixList
      hyphenated = "-#{ prefix.toLowerCase() }-linear-gradient"
      testEl.style.backgroundImage = "#{ hyphenated }(left, #000, #fff)"
      # After setting a gradient background on the test div, attempt to retrieve it.
      return hyphenated unless testEl.style.backgroundImage.indexOf('gradient') is -1
    # If none of the hyphenated values worked, return the un-prefixed version.
    'linear-gradient'

  # The default cursor style is set to `grab` to prompt the user to interact with the element.
  # `grab` as a value isn't supported in all browsers so it has to be detected.
  [css.grab, css.grabbing] = do ->
    for prefix in prefixList
      plainGrab = 'grab'
      testEl.style.cursor = (grabValue = "-#{ prefix.toLowerCase() }-#{ plainGrab }")
      # If the cursor was set correctly, return the prefixed pair.
      return [grabValue, "-#{ prefix.toLowerCase() }-grabbing"] if testEl.style.cursor is grabValue
    # Otherwise try the unprefixed version.
    testEl.style.cursor = plainGrab
    if testEl.style.cursor is plainGrab
      [plainGrab, 'grabbing']
    else
      # Fallback to `move`.
      ['move', 'move']

  # Like gradients, transform (as a transition value) needs to be detected and prefixed.
  css.transformProp = do ->
    # Use a regular expression to pluck the prefix `testProp` found.
    if prefix = css.transform.match /(\w+)Transform/i
      "-#{ prefix[1].toLowerCase() }-transform"
    else
      'transform'

  # Set a `transitionEnd` property based on the browser's prefix for `transitionProperty`.
  css.transitionEnd = do ->
    switch css.transitionProperty.toLowerCase()
      when 'transitionproperty'       then 'transitionEnd'
      when 'webkittransitionproperty' then 'webkitTransitionEnd'
      when 'moztransitionproperty'    then 'transitionend'
      when 'mstransitionproperty'     then 'msTransitionEnd'


  # These calls generate OriDomi's stylesheet.
  addStyle elClasses.active,
    backgroundColor: 'transparent !important'
    backgroundImage: 'none !important'
    boxSizing:       'border-box !important'
    border:          'none !important'
    outline:         'none !important'
    padding:         '0 !important'
    position:        'relative'
    transformStyle:  p3d + ' !important'
    mask:            'none !important'

  addStyle elClasses.clone,
    margin:    '0 !important'
    boxSizing: 'border-box !important'
    overflow:  'hidden !important'
    display:   'block !important'

  addStyle elClasses.holder,
    width:          '100%'
    position:       'absolute'
    top:            '0'
    bottom:         '0'
    transformStyle: p3d

  addStyle elClasses.stage,
    width:          '100%'
    height:         '100%'
    position:       'absolute'
    transform:      'translate3d(-9999px, 0, 0)'
    margin:         '0'
    padding:        '0'
    transformStyle: p3d

  # Each anchor needs a particular perspective origin.
  for k, v of {Left: '0% 50%', Right: '100% 50%', Top: '50% 0%', Bottom: '50% 100%'}
    addStyle elClasses['stage' + k], perspectiveOrigin: v

  addStyle elClasses.shader,
    width:              '100%'
    height:             '100%'
    position:           'absolute'
    opacity:            '0'
    top:                '0'
    left:               '0'
    pointerEvents:      'none'
    transitionProperty: 'opacity'

  # Linear gradient directions depend on their anchor.
  for anchor in anchorList
    addStyle elClasses['shader' + capitalize anchor], background: getGradient anchor

  addStyle elClasses.content,
    margin:    '0 !important'
    position:  'relative !important'
    float:     'none !important'
    boxSizing: 'border-box !important'
    overflow:  'hidden !important'

  addStyle elClasses.mask,
    width:              '100%'
    height:             '100%'
    position:           'absolute'
    overflow:           'hidden'
    transform:          'translate3d(0, 0, 0)'
    outline:            '1px solid transparent'

  addStyle elClasses.panel,
    width:              '100%'
    height:             '100%'
    padding:            '0'
    position:           'relative'
    transitionProperty: css.transformProp
    transformOrigin:    'left'
    transformStyle:     p3d

  addStyle elClasses.panelH, transformOrigin: 'top'
  addStyle "#{ elClasses.stageRight } .#{ elClasses.panel }", transformOrigin: 'right'
  addStyle "#{ elClasses.stageBottom } .#{ elClasses.panel }", transformOrigin: 'bottom'

  styleEl      = document.createElement 'style'
  styleEl.type = 'text/css'

  # Once the style buffer is ready, it's appended to the document as a stylesheet.
  if styleEl.styleSheet
    styleEl.styleSheet.cssText = styleBuffer
  else
    styleEl.appendChild document.createTextNode styleBuffer

  document.head.appendChild styleEl


# Defaults
# ========

# These defaults are used by all OriDomi instances unless overridden.
defaults =
  # The number of vertical panels (for folding left or right).
  vPanels: 3
  # The number of horizontal panels (for folding top or bottom).
  hPanels: 3
  # The determines the distance in pixels (z axis) of the camera/viewer to the paper.
  # The smaller the value, the more distorted and exaggerated the effects will appear.
  perspective: 1000
  # The default shading style is hard, which shows distinct creases in the paper.
  # Other options include `'soft'` -- for a smoother, more rounded look -- or `false`
  # to disable shading altogether for a flat look.
  shading: 'hard'
  # Determines the duration of all animations in milliseconds.
  speed: 700
  # Configurable maximum angle for effects. With most effects, exceeding 90/-90 usually
  # makes the element wrap around and pass through itself leading to some glitchy visuals.
  maxAngle: 90
  # Ripple mode causes effects to fold in a staggered, cascading manner.
  # `1` indicates a forward cascade, `2` is backwards. It is disabled by default.
  ripple: 0
  # This CSS class is applied to OriDomi elements so they can be easily targeted later.
  oriDomiClass: 'oridomi'
  # This is a multiplier that determines the darkness of shading.
  # If you need subtler shading, set this to a value below 1.
  shadingIntensity: 1
  # This option allows you to supply the name of a CSS easing method or a
  # cubic bezier formula for customized animation easing.
  easingMethod: ''
  # Allows the user to fold the element via touch or mouse.
  touchEnabled: true
  # Coefficient of touch/drag action's distance delta. Higher numbers cause more movement.
  touchSensitivity: .25
  # Custom callbacks for touch/drag events. Each one is invoked with a relevant
  # value so they can be used to manipulate objects outside of the OriDomi
  # instance (e.g. sliding panels). x values are returned when folding left and
  # right, y values for top and bottom. The second argument passed is the original
  # touch or mouse event. These are empty functions by default. Invoked with
  # starting coordinate as first argument.
  touchStartCallback: noOp
  # Invoked with the folded angle.
  touchMoveCallback: noOp
  # Inkoked with ending point.
  touchEndCallback: noOp


# Constructor
# ===========

class OriDomi

  constructor: (@el, options = {}) ->
    return unless isSupported
    # Prevent constructor calls made without `new`.
    return new OriDomi arguments... unless @ instanceof OriDomi
    # Support selector strings as well as elements.
    @el = document.querySelector @el if typeof @el is 'string'
    # Make sure element is valid.
    unless @el and @el.nodeType is 1
      console?.warn 'OriDomi: First argument must be a DOM element'
      return

    # Fill in passed options with defaults.
    @_config = new ->
      for k, v of defaults
        if options[k]?
          @[k] = options[k]
        else
          @[k] = v
      @

    # The ripple setting is converted to a number to allow boolean settings.
    @_config.ripple = Number @_config.ripple
    # The queue holds animation sequences.
    @_queue   = []
    @_panels  = {}
    @_stages  = {}
    # Set the starting anchor to left.
    @_lastOp  = anchor: anchorList[0]
    @_shading = @_config.shading
    # Alias `shading: true` as hard shading.
    @_shading = 'hard' if @_shading is true

    # The shader elements are constructed in a conditional so the process can be
    # skipped if shading is disabled.
    if @_shading
      @_shaders    = {}
      shaderProtos = {}
      shaderProto  = createEl 'shader'
      shaderProto.style[css.transitionDuration]       = @_config.speed + 'ms'
      shaderProto.style[css.transitionTimingFunction] = @_config.easingMethod

    stageProto = createEl 'stage'
    stageProto.style[css.perspective] = @_config.perspective + 'px'

    for anchor in anchorList
      # Each anchor has a unique set of panels.
      @_panels[anchor] = []
      @_stages[anchor] = cloneEl stageProto, false, 'stage' + capitalize anchor
      if @_shading
        @_shaders[anchor] = {}
        if anchor in anchorListV
          @_shaders[anchor][side] = [] for side in anchorListV
        else
          @_shaders[anchor][side] = [] for side in anchorListH

        shaderProtos[anchor] = cloneEl shaderProto, false, 'shader' + capitalize anchor

    contentHolder = cloneEl @el, true, 'content'

    maskProto = createEl 'mask'
    maskProto.appendChild contentHolder

    panelProto = createEl 'panel'
    panelProto.style[css.transitionDuration]       = @_config.speed + 'ms'
    panelProto.style[css.transitionTimingFunction] = @_config.easingMethod

    # This loop builds all of the panels.
    for axis in ['x', 'y']
      if axis is 'x'
        anchorSet   = anchorListV
        count       = @_config.vPanels
        metric      = 'width'
        classSuffix = 'V'
      else
        anchorSet   = anchorListH
        count       = @_config.hPanels
        metric      = 'height'
        classSuffix = 'H'

      # Set the panel dimension to a percentage of the container.
      percent = 100 / count

      mask    = cloneEl maskProto, true, 'mask' + classSuffix
      content = mask.children[0]
      # The inner content retains the original dimensions of the element
      # while being inside a small slice. By multiplying 100% by the number of
      # panels on this axis, the size reduction of the parent in undone and
      # sizing flexibility is achieved.
      content.style.width   = content.style.height = '100%'
      content.style[metric] = content.style['max' + capitalize metric] = count * 100 + '%'
      if @_shading
        mask.appendChild shaderProtos[anchor] for anchor in anchorSet

      proto = cloneEl panelProto, false, 'panel' + classSuffix
      proto.appendChild mask

      for anchor, n in anchorSet
        for panelN in [0...count]
          panel = proto.cloneNode true
          # Only the first panel has its size set to a percentage since subsequent
          # panels are nested children and will match its size.
          panel.style[metric] = percent + '%' if panelN is 0
          content = panel.children[0].children[0]

          # The inner content of each panel is offset relative to the panel
          # index to display a contiguous composition.
          if n is 0
            content.style[anchor] = -panelN * 100 + '%'
            if panelN is 0
              panel.style[anchor] = '0'
            else
              panel.style[anchor] = '100%'
          else
            content.style[anchorSet[0]] = (count - panelN - 1) * -100 + '%'
            panel.style[css.origin] = anchor
            if panelN is 0
              panel.style[anchorSet[0]] = 100 - percent + '%'
            else
              panel.style[anchorSet[0]] = '-100%'

          if @_shading
            for a, i in anchorSet
              @_shaders[anchor][a][panelN] = panel.children[0].children[i + 1]

          @_panels[anchor][panelN] = panel
          # Panels are nested inside each other.
          @_panels[anchor][panelN - 1].appendChild panel unless panelN is 0

        # Append the first panel to each stage.
        @_stages[anchor].appendChild @_panels[anchor][0]

    @_stageHolder = createEl 'holder'
    @_stageHolder.appendChild @_stages[anchor] for anchor in anchorList

    # Override default styling if original positioning is absolute.
    if window.getComputedStyle(@el).position is 'absolute'
      @el.style.position = 'absolute'

    @el.classList.add elClasses.active
    showEl @_stages.left
    # The original element is cloned and hidden via transforms so the dimensions
    # of the OriDomi content are maintained by it.
    @_cloneEl = cloneEl @el, true, 'clone'
    @_cloneEl.classList.remove elClasses.active
    hideEl @_cloneEl
    # Once the clone is stored the original element is emptied and appened with
    # the clone and the OriDomi content.
    @el.innerHTML   = ''
    @el.appendChild @_cloneEl
    @el.appendChild @_stageHolder
    # This ensures mouse events work correctly when panels are transformed
    # away from the viewer.
    @el.parentNode.style[css.transformStyle] = 'preserve-3d'

    # An effect method is called since touch events rely on using the last
    # method called.
    @accordion 0
    @setRipple @_config.ripple if @_config.ripple
    @enableTouch() if @_config.touchEnabled


  # Internal Methods
  # ================

  # This method is called for the action shifted off the queue.
  _step: =>
    # Return if the composition is currently in transition or the queue is empty.
    return if @_inTrans or !@_queue.length
    @_inTrans = true
    # Destructure action arguments from the front of the queue.
    [fn, angle, anchor, options] = @_queue.shift()
    @unfreeze() if @isFrozen

    # A local function for the next action is created should the call need to be
    # deferred (if the stage is folded up or on the wrong anchor).
    next = =>
      @_setCallback {angle, anchor, options, fn}
      args = [angle, anchor, options]
      args.shift() if fn.length < 3
      fn.apply @, args

    if @isFoldedUp
      if fn.length is 2
        next()
      else
        @_unfold next
    else if anchor isnt @_lastOp.anchor
      @_stageReset anchor, next
    else
      next()


  # This method tests if the called action is identical to the previous one.
  # If two identical operations were called in a row, the transition callback
  # wouldn't be called due to no animation taking place. This method reasons if
  # movement has taken place, avoiding this pitfall of transition listeners.
  _isIdenticalOperation: (op) ->
    return true unless @_lastOp.fn
    return false if @_lastOp.reset
    (return false if @_lastOp[key] isnt op[key]) for key in ['angle', 'anchor', 'fn']
    (return false if v isnt @_lastOp.options[k] and k isnt 'callback') for k, v of op.options
    true


  # This method normalizes callback handling for all public methods.
  _setCallback: (operation) ->
    # If there was no transformation, invoke the callback immediately.
    if !@_config.speed or @_isIdenticalOperation operation
      @_conclude operation.options.callback
    # Otherwise, attach an event listener to be called on the transition's end.
    else
      @_panels[@_lastOp.anchor][0].addEventListener css.transitionEnd, @_onTransitionEnd, false

    (@_lastOp = operation).reset = false


  # Handler called when a CSS transition ends.
  _onTransitionEnd: (e) =>
    # Remove the event listener immediately to prevent bubbling.
    e.currentTarget.removeEventListener css.transitionEnd, @_onTransitionEnd, false
    # Initialize the transition teardown process.
    @_conclude @_lastOp.options.callback, e


  # Used to handle the end process of transitions and to initialize queued operations.
  _conclude: (cb, event) =>
    defer =>
      @_inTrans = false
      @_step()
      cb? event, @


  # Transforms a given element based on angle, anchor, and fracture boolean.
  _transformPanel: (el, angle, anchor, fracture) ->
    # The values of 1 and -1 are used to try to prevent small gaps from
    # appearing between panels during transforms.
    x = y = z = 0
    switch anchor
      when 'left'
        y = angle
        translate = 'X(-1'
      when 'right'
        y = -angle
        translate = 'X(1'
      when 'top'
        x = -angle
        translate = 'Y(-1'
      when 'bottom'
        x = angle
        translate = 'Y(1'

    # Rotate on every axis in fracture mode.
    x = y = z = angle if fracture

    el.style[css.transform] = """
                              rotateX(#{ x }deg)
                              rotateY(#{ y }deg)
                              rotateZ(#{ z }deg)
                              translate#{ translate }px)
                              """


  # This validates a given angle by making sure it's a float and by
  # keeping it within the maximum range specified in the instance settings.
  _normalizeAngle: (angle) ->
    angle = parseFloat angle, 10
    max   = @_config.maxAngle
    if isNaN angle
      0
    else if angle > max
      max
    else if angle < -max
      -max
    else
      angle


  # Allows other methods to change the transiton duration/delay or disable it altogether.
  _setTrans: (duration, delay, anchor = @_lastOp.anchor) ->
    @_iterate anchor, (panel, i, len) => @_setPanelTrans anchor, arguments..., duration, delay


  # This method changes the transition duration and delay of panels and shaders.
  _setPanelTrans: (anchor, panel, i, len, duration, delay) ->
    delayMs  = do =>
      # Delay is a `ripple` value. The milliseconds are derived based on the
      # speed setting and the number of panels.
      switch delay
        when 0 then 0
        when 1 then @_config.speed / len * i
        when 2 then @_config.speed / len * (len - i - 1)

    panel.style[css.transitionDuration] = duration + 'ms'
    panel.style[css.transitionDelay]    = delayMs  + 'ms'
    if @_shading
      for side in (if anchor in anchorListV then anchorListV else anchorListH)
        shader = @_shaders[anchor][side][i]
        shader.style[css.transitionDuration] = duration + 'ms'
        shader.style[css.transitionDelay]    = delayMs  + 'ms'

    delayMs


  # Determines a shader's opacity based upon panel position, anchor, and angle.
  _setShader: (n, anchor, angle) ->
    # Store the angle's absolute value and generate an opacity based on `shadingIntensity`.
    abs     = Math.abs angle
    opacity = abs / 90 * @_config.shadingIntensity

    # With hard shading, opacity is reduced and `angle` is based on the global
    # `lastAngle` so all panels' shaders share the same direction. Soft shaders
    # have alternating directions.
    if @_shading is 'hard'
      opacity *= .15
      if @_lastOp.angle < 0
        angle = abs
      else
        angle = -abs
    else
      opacity *= .4

    # This block makes sure left and top shaders appear for negative angles and right
    # and bottom shaders appear for positive ones.
    if anchor in anchorListV
      if angle < 0
        a = opacity
        b = 0
      else
        a = 0
        b = opacity
      @_shaders[anchor].left[n].style.opacity  = a
      @_shaders[anchor].right[n].style.opacity = b
    else
      if angle < 0
        a = 0
        b = opacity
      else
        a = opacity
        b = 0
      @_shaders[anchor].top[n].style.opacity    = a
      @_shaders[anchor].bottom[n].style.opacity = b


  # This method shows the requested stage element and sets a reference to it as
  # the current stage.
  _showStage: (anchor) ->
    if anchor isnt @_lastOp.anchor
      hideEl @_stages[@_lastOp.anchor]
      @_lastOp.anchor = anchor
      @_lastOp.reset  = true
      @_stages[anchor].style[css.transform] = 'translate3d(' + do =>
        switch anchor
          when 'left'
            '0, 0, 0)'
          when 'right'
            "-#{ @_config.vPanels * 1 }px, 0, 0)"
          when 'top'
            '0, 0, 0)'
          when 'bottom'
            "0, -#{ (@_config.hPanels + 2) * 1 }px, 0)"


  # If the composition needs to switch stages or fold up, it must first unfold
  # all panels to 0 degrees.
  _stageReset: (anchor, cb) =>
    fn = (e) =>
      e.currentTarget.removeEventListener css.transitionEnd, fn, false if e
      @_showStage anchor
      defer cb

    # If already unfolded to 0, immediately invoke the change function.
    return fn() if @_lastOp.angle is 0
    @_panels[@_lastOp.anchor][0].addEventListener css.transitionEnd, fn, false

    @_iterate @_lastOp.anchor, (panel, i) =>
      @_transformPanel panel, 0, @_lastOp.anchor
      @_setShader i, @_lastOp.anchor, 0 if @_shading


  # Converts a shorthand anchor name to a full one.
  _getLonghandAnchor: (shorthand) ->
    switch shorthand.toString()
      when 'left',   'l', '4'
        'left'
      when 'right',  'r', '2'
        'right'
      when 'top',    't', '1'
        'top'
      when 'bottom', 'b', '3'
        'bottom'
      else
        # Left is always default.
        'left'


  # Gives the element a resize cursor to prompt the user to drag the mouse.
  _setCursor: (bool = @_touchEnabled) ->
    if bool
      @el.style.cursor = css.grab
    else
      @el.style.cursor = 'default'


  # Touch / Drag Event Handlers
  # ===========================

  # Adds or removes handlers from the element based on the boolean argument given.
  _setTouch: (toggle) ->
    if toggle
      return @ if @_touchEnabled
      listenFn = 'addEventListener'
    else
      return @ unless @_touchEnabled
      listenFn = 'removeEventListener'

    @_touchEnabled = toggle
    @_setCursor()
    # Array of event type pairs.
    eventPairs = [['TouchStart', 'MouseDown'], ['TouchEnd', 'MouseUp'],
                  ['TouchMove', 'MouseMove'], ['TouchLeave', 'MouseLeave']]
    # Detect native `mouseleave` support.
    mouseLeaveSupport = 'onmouseleave' of window
    # Attach touch/drag event listeners in related pairs.
    for eventPair in eventPairs
      for eString in eventPair
        unless eString is 'TouchLeave' and !mouseLeaveSupport
          @el[listenFn] eString.toLowerCase(), @['_on' + eventPair[0]], false
        else
          @el[listenFn] 'mouseout', @_onMouseOut, false
          break
    @


  # This method is called when a finger or mouse button is pressed on the element.
  _onTouchStart: (e) =>
    return if !@_touchEnabled or @isFoldedUp
    e.preventDefault()
    # Clear queued animations.
    @emptyQueue()
    # Set a property to track touch starts.
    @_touchStarted = true
    # Change the cursor to the active `grabbing` state.
    @el.style.cursor = css.grabbing
    # Disable tweening to enable instant 1 to 1 movement.
    @_setTrans 0, 0
    # Derive the axis to fold on.
    @_touchAxis = if @_lastOp.anchor in anchorListV then 'x' else 'y'
    # Set a reference to the last folded angle to accurately derive deltas.
    @["_#{ @_touchAxis }Last"] = @_lastOp.angle
    axis1 = "_#{ @_touchAxis }1"
    # Determine the starting tap's coordinate for touch and mouse events.
    if e.type is 'mousedown'
      @[axis1] = e["page#{ @_touchAxis.toUpperCase() }"]
    else
      @[axis1] = e.targetTouches[0]["page#{ @_touchAxis.toUpperCase() }"]

    # Return that value to an external listener.
    @_config.touchStartCallback @[axis1], e


  # Called on touch/mouse movement.
  _onTouchMove: (e) =>
    return unless @_touchEnabled and @_touchStarted
    e.preventDefault()
    # Set a reference to the current x or y position.
    if e.type is 'mousemove'
      current = e["page#{ @_touchAxis.toUpperCase() }"]
    else
      current = e.targetTouches[0]["page#{ @_touchAxis.toUpperCase() }"]

    # Calculate distance and multiply by `touchSensitivity`.
    distance = (current - @["_#{ @_touchAxis }1"]) * @_config.touchSensitivity

    # Calculate final delta based on starting angle, anchor, and what side of zero
    # the last operation was on.
    if @_lastOp.angle < 0
      if @_lastOp.anchor is 'right' or @_lastOp.anchor is 'bottom'
        delta = @["_#{ @_touchAxis }Last"] - distance
      else
        delta = @["_#{ @_touchAxis }Last"] + distance
      delta = 0 if delta > 0
    else
      if @_lastOp.anchor is 'right' or @_lastOp.anchor is 'bottom'
        delta = @["_#{ @_touchAxis }Last"] + distance
      else
        delta = @["_#{ @_touchAxis }Last"] - distance
      delta = 0 if delta < 0


    @_lastOp.angle = delta = @_normalizeAngle delta
    @_lastOp.fn.call @, delta, @_lastOp.anchor, @_lastOp.options
    @_config.touchMoveCallback delta, e



  # Teardown process when touch/drag event ends.
  _onTouchEnd: (e) =>
    return unless @_touchEnabled
    # Restore the initial touch status and cursor.
    @_touchStarted = @_inTrans = false
    @el.style.cursor = css.grab
    # Enable tweening again.
    @_setTrans @_config.speed, @_config.ripple
    # Pass callback final coordinate.
    @_config.touchEndCallback @["_#{ @_touchAxis }Last"], e


  # End folding when the mouse or finger leaves the composition.
  _onTouchLeave: (e) =>
    return unless @_touchEnabled and @_touchStarted
    @_onTouchEnd e


  # A fallback for browsers that don't support `mouseleave`.
  _onMouseOut: (e) =>
    return unless @_touchEnabled and @_touchStarted
    @_onTouchEnd e if e.toElement and !@el.contains e.toElement


  # This method unfolds the composition after it's been folded up. It's private
  # and doesn't use the decorator because it's used internally by other methods
  # and skips the queue. Its public counterpart is a queued alias.
  _unfold: (callback) ->
    @_inTrans = true
    {anchor}  = @_lastOp
    @_iterate anchor, (panel, i, len) =>
      delay = @_setPanelTrans anchor, arguments..., @_config.speed, 1

      do (panel, i, delay) =>
        defer =>
          @_transformPanel panel, 0, @_lastOp.anchor
          setTimeout =>
            showEl panel.children[0]
            if i is len - 1
              @_inTrans = @isFoldedUp = false
              callback?()
              @_lastOp.fn    = @accordion
              @_lastOp.angle = 0
            defer => panel.style[css.transitionDuration] = @_config.speed
          , delay + @_config.speed * .25


  # This method is used by many others to iterate among panels within a given anchor.
  _iterate: (anchor, fn) ->
    fn.call @, panel, i, panels.length for panel, i in panels = @_panels[anchor]


  # Public Methods
  # ==============


  # Enables touch events.
  enableTouch: ->
    @_setTouch true


  # Disables touch events.
  disableTouch: ->
    @_setTouch false


  # Public setter for transition durations.
  setSpeed: (speed) ->
    for anchor in anchorList
      @_setTrans (@_config.speed = speed), @_config.ripple, anchor
    @


  # Disables OriDomi slicing by showing the original, untouched target element.
  # This is useful for certain user interactions on the inner content.
  freeze: (callback) ->
    # Return if already frozen.
    if @isFrozen
      callback?()
    else
      # Make sure to reset folding first.
      @_stageReset @_lastOp.anchor, =>
        @isFrozen = true
        # Swap the visibility of the elements.
        hideEl @_stageHolder
        showEl @_cloneEl
        @_setCursor false
        callback?()
    @


  # Restores the OriDomi version of the element for folding purposes.
  unfreeze: ->
    # Only unfreeze if already frozen.
    if @isFrozen
      @isFrozen = false
      # Swap the visibility of the elements.
      hideEl @_cloneEl
      showEl @_stageHolder
      @_setCursor()
      # Set `lastAngle` to 0 so an immediately subsequent call to `freeze` triggers the callback.
      @_lastOp.angle = 0
    @


  # Removes the OriDomi element and restores the original element.
  destroy: (callback) ->
    # First restore the original element.
    @freeze =>
      # Remove event listeners.
      @_setTouch false
      # Remove the data reference if using jQuery.
      $.data @el, baseName, null if $
      # Remove the OriDomi element from the DOM.
      @el.innerHTML = @_cloneEl.innerHTML
      # Reset original styling.
      @el.classList.remove elClasses.active
      callback?()
    null


  # Empties the queue should you want to cancel scheduled animations.
  emptyQueue: ->
    @_queue = []
    defer => @_inTrans = false
    @


  # Enable or disable ripple. 1 is forwards, 2 is backwards, 0 is disabled.
  setRipple: (dir = 1) ->
    @_config.ripple = Number dir
    @setSpeed @_config.speed
    @


  # Setter method for `maxAngle`.
  constrainAngle: (angle) ->
    @_config.maxAngle = parseFloat(angle, 10) or defaults.maxAngle
    @


  # Pause in the midst of an animation sequence, in milliseconds.
  # E.g.: el.reveal(20).wait()
  wait: (ms) ->
    fn = => setTimeout @_conclude, ms
    if @_inTrans
      @_queue.push [fn, @_lastOp.angle, @_lastOp.anchor, @_lastOp.options]
    else
      fn()
    @


  # This method is used to externally manipulate the styling or contents of the
  # composition. Manipulation instructions can be supplied via a function (invoked
  # with each panel element), or a map of selectors with instructions.
  # Instruction values can be text to implicitly update `innerHTML` content or
  # objects with `style` and/or `content` keys. Style keys should contain object
  # literals with camel-cased CSS properties as keys.
  modifyContent: (fn) ->
    if typeof fn isnt 'function'
      selectors = fn

      set = (el, content, style) ->
        el.innerHTML = content if content
        if style
          el.style[key] = value for key, value of style
          null

      fn = (el) ->
        for selector, value of selectors
          content = style = null
          if typeof value is 'string'
            content = value
          else
            {content, style} = value

          if selector is ''
            set el, content, style
            continue

          set match, content, style for match in el.querySelectorAll selector

        null

    for anchor in anchorList
      for panel, i in @_panels[anchor]
        fn panel.children[0].children[0], i, anchor
    @


  # Effect Methods
  # ==============


  # Base effect with alternating peaks and valleys.
  # `reveal` relies on it by calling it with `sticky: true` to keep the first
  # panel flat.
  accordion: prep (angle, anchor, options) ->
    @_iterate anchor, (panel, i) =>
      # With an odd-numbered panel, reverse the angle.
      if i % 2 isnt 0 and !options.twist
        deg = -angle
      else
        deg = angle

      # If sticky, keep the first panel flat.
      if options.sticky
        if i is 0
          deg = 0
        else if i > 1 or options.stairs
          deg *= 2
      else
        # Double the angle to counteract the angle of the parent panel.
        deg *= 2 unless i is 0

      # In stairs mode, keep all the angles on the same side of 0.
      deg *= -1 if options.stairs

      # Set the CSS transformation.
      @_transformPanel panel, deg, anchor, options.fracture

      if @_shading and !(i is 0 and options.sticky) and Math.abs(deg) isnt 180
        @_setShader i, anchor, deg


  # This effect appears to bend rather than fold the paper. Its curves can
  # appear smoother with higher panel counts.
  curl: prep (angle, anchor, options) ->
    # Reduce the angle based on the number of panels in this axis.
    angle /= if anchor in anchorListV then @_config.vPanels else @_config.hPanels

    @_iterate anchor, (panel, i) =>
      @_transformPanel panel, angle, anchor
      @_setShader i, anchor, 0 if @_shading


  # Lifts up all panels after the first one.
  ramp: prep (angle, anchor, options) ->
    # Rotate the second panel for the lift up.
    @_transformPanel @_panels[anchor][1], angle, anchor

    # For all but the second panel, set the angle to 0.
    @_iterate anchor, (panel, i) =>
      @_transformPanel panel, 0, anchor if i isnt 1
      @_setShader i, anchor, 0 if @_shading


  # Hides the element by folding each panel in a cascade of animations.
  foldUp: prep (anchor, callback) ->
    return callback?() if @isFoldedUp
    @_stageReset anchor, =>
      @_inTrans = @isFoldedUp = true

      @_iterate anchor, (panel, i, len) =>
        duration  = @_config.speed
        duration /= 2 if i is 0
        delay     = @_setPanelTrans anchor, arguments..., duration, 2

        do (panel, i, delay) =>
          defer =>
            @_transformPanel panel, (if i is 0 then 90 else 170), anchor
            setTimeout =>
              if i is 0
                @_inTrans = false
                callback?()
              else
                hideEl panel.children[0]

            , delay + @_config.speed * .25


  # This is the queued version of `_unfold`.
  unfold: prep (callback) -> @_unfold arguments...


  # For custom folding behavior, you can pass a function to map that will
  # determine the folding angle applied to each panel. The passed function
  # is supplied with the input angle, the panel index, and the number of
  # panels in the active anchor. Calling map returns a new function bound to
  # the instance and the lambda, e.g. `oridomi.map(randomFn)(30).reveal(20)`.
  map: (fn) ->
    prep (angle, anchor, options) =>
      @_iterate anchor, (panel, i, len) =>
        @_transformPanel panel, fn(angle, i, len), anchor, options.fracture
    .bind @


  # Convenience Methods
  # ===================


  # Resets all panels back to zero degrees.
  reset: (callback) ->
    @accordion 0, {callback}


  # Simply proxy for calling `accordion` with `sticky` enabled.
  # Keeps first panel flat on page.
  reveal: (angle, anchor, options = {}) ->
    options.sticky = true
    @accordion angle, anchor, options


  # Proxy to enable stairs mode on `accordion`.
  stairs: (angle, anchor, options = {}) ->
    options.stairs = options.sticky =  true
    @accordion angle, anchor, options


  # The composition is split apart by its panels rather than folded.
  fracture: (angle, anchor, options = {}) ->
    options.fracture = true
    @accordion angle, anchor, options


  # Similar to `fracture`, but the panels are twisted as well.
  twist: (angle, anchor, options = {}) ->
    options.fracture = options.twist = true
    @accordion angle / 10, anchor, options


  # Convenience proxy to accordion-fold instance to maximum angle.
  collapse: (anchor, options = {}) ->
    options.sticky = false
    @accordion -@_config.maxAngle, anchor, options


  # Same as `collapse`, but uses positive angle for slightly different effect.
  collapseAlt: (anchor, options = {}) ->
    options.sticky = false
    @accordion @_config.maxAngle, anchor, options


  # Statics
  # =======


  # Set a version flag for easy external retrieval.
  @VERSION = '1.0.4'

  # Externally check if OriDomi is supported by the browser.
  @isSupported = isSupported


# Expose the OriDomi constructor via CommonJS, AMD, or the window object.
if module?.exports
  module.exports = OriDomi
else if define?.amd
  define -> OriDomi
else
  window.OriDomi = OriDomi



# Plugin Bridge
# =============


# Only create bridge if jQuery (or an imitation supporting `data()`) exists.
return unless $
# Attach an `OriDomi` method to `$`'s prototype.
$::oriDomi = (options) ->
  # Return selection if OriDomi is unsupported by the browser.
  return @ unless isSupported
  return $.data @[0], baseName if options is true

  # If `options` is a string, assume it's a method call.
  if typeof options is 'string'
    methodName = options
    # Check if method exists and warn if it doesn't.
    unless typeof (method = OriDomi::[methodName]) is 'function'
      console?.warn "OriDomi: No such method `#{ methodName }`"
      return @

    for el in @

      unless instance = $.data el, baseName
        instance = $.data el, baseName, new OriDomi el, options

      # Call the requested method with arguments.
      method.apply instance, Array::slice.call(arguments)[1...]


  # If not calling a method, initialize OriDomi on the selection.
  else
    for el in @
      # If the element in the selection already has an instance of OriDomi
      # attached to it, return the instance.
      if instance = $.data el, baseName
        continue
      else
        # Create an instance of OriDomi and attach it to the element.
        $.data el, baseName, new OriDomi el, options


  # Return the selection.
  @