cornerstone-source 0.1.1

data/source/javascripts/_cornerstone/bindable.js.coffee

@@ -0,0 +1,125 @@
+###*
+Bindable module.
+
+    player = Core
+      x: 5
+      y: 10
+    
+    player.bind "update", ->
+      updatePlayer()
+    # => Uncaught TypeError: Object has no method 'bind'
+    
+    player.include(Bindable)
+    
+    player.bind "update", ->
+      updatePlayer()
+    # => this will call updatePlayer each time through the main loop
+
+@name Bindable
+@module
+@constructor
+###
+Bindable = (I={}, self) -> 
+  eventCallbacks = {}
+
+  bind: (args...) ->
+    self.on(args...)
+
+  unbind: (args...) ->
+    self.off(args...)
+
+  ###*
+  Adds a function as an event listener.
+
+      # this will call coolEventHandler after
+      # yourObject.trigger "someCustomEvent" is called.
+      yourObject.on "someCustomEvent", coolEventHandler
+    
+      #or
+      yourObject.on "anotherCustomEvent", ->
+        doSomething()
+
+  @name on
+  @methodOf Bindable#
+  @param {String} event The event to listen to.
+  @param {Function} callback The function to be called when the specified event
+  is triggered.
+  ###
+  on: (namespacedEvent, callback) ->
+    [event, namespace] = namespacedEvent.split(".")
+
+    # HACK: Here we annotate the callback function with namespace metadata
+    # This will probably lead to some strange edge cases, but should work fine
+    # for simple cases.
+    if namespace
+      callback.__PIXIE ||= {}
+      callback.__PIXIE[namespace] = true
+
+    eventCallbacks[event] ||= []
+    eventCallbacks[event].push(callback)
+
+    return this
+
+  ###*
+  Removes a specific event listener, or all event listeners if
+  no specific listener is given.
+
+      #  removes the handler coolEventHandler from the event
+      # "someCustomEvent" while leaving the other events intact.
+      yourObject.off "someCustomEvent", coolEventHandler
+    
+      # removes all handlers attached to "anotherCustomEvent" 
+      yourObject.off "anotherCustomEvent"
+
+  @name off
+  @methodOf Bindable#
+  @param {String} event The event to remove the listener from.
+  @param {Function} [callback] The listener to remove.
+  ###
+  off: (namespacedEvent, callback) ->
+    [event, namespace] = namespacedEvent.split(".")
+
+    if event
+      eventCallbacks[event] ||= []
+      
+      if namespace
+        # Select only the callbacks that do not have this namespace metadata
+        eventCallbacks[event] = eventCallbacks.select (callback) ->
+          !callback.__PIXIE?[namespace]?
+
+      else
+        if callback
+          eventCallbacks[event].remove(callback)
+        else
+          eventCallbacks[event] = []
+    else if namespace
+      # No event given
+      # Select only the callbacks that do not have this namespace metadata
+      # for any events bound
+      for key, callbacks of eventCallbacks
+        eventCallbacks[key] = callbacks.select (callback) ->
+          !callback.__PIXIE?[namespace]?
+
+    return this
+
+  ###*
+  Calls all listeners attached to the specified event.
+
+      # calls each event handler bound to "someCustomEvent"
+      yourObject.trigger "someCustomEvent"
+
+  @name trigger
+  @methodOf Bindable#
+  @param {String} event The event to trigger.
+  @param {Array} [parameters] Additional parameters to pass to the event listener.
+  ###
+  trigger: (event, parameters...) ->
+    callbacks = eventCallbacks[event]
+
+    if callbacks && callbacks.length
+      self = this
+
+      callbacks.each (callback) ->
+        callback.apply(self, parameters)
+
+(exports ? this)["Bindable"] = Bindable

data/source/javascripts/_cornerstone/command_stack.js.coffee

@@ -0,0 +1,36 @@
+CommandStack = ->
+  stack = []
+  index = 0
+
+  execute: (command) ->
+    stack[index] = command
+    command.execute()
+
+    # Be sure to blast obsolete redos
+    stack.length = index += 1
+
+  undo: ->
+    if @canUndo()
+      index -= 1
+
+      command = stack[index]
+      command.undo()
+
+      return command
+
+  redo: ->
+    if @canRedo()
+      command = stack[index]
+      command.execute()
+
+      index += 1
+
+      return command
+
+  canUndo: ->
+    index > 0
+
+  canRedo: ->
+    stack[index]?
+
+(exports ? this)["CommandStack"] = CommandStack

data/source/javascripts/_cornerstone/core_object.js.coffee

@@ -0,0 +1,183 @@
+###*
+The Core class is used to add extended functionality to objects without
+extending the object class directly. Inherit from Core to gain its utility
+methods.
+
+@name Core
+@constructor
+
+@param {Object} I Instance variables
+###
+
+( ->
+  root = exports ? this
+
+  root.Core = (I={}) ->
+    Object.reverseMerge I,
+      includedModules: []
+
+    self =
+      ###*
+      External access to instance variables. Use of this property should be avoided
+      in general, but can come in handy from time to time.
+  
+          I =
+            r: 255
+            g: 0
+            b: 100
+      
+          myObject = Core(I)
+      
+          # a bad idea most of the time, but it's 
+          # pretty convenient to have available.
+          myObject.I.r
+          # => 255
+      
+          myObject.I.g
+          # => 0
+      
+          myObject.I.b
+          # => 100
+  
+      @name I
+      @fieldOf Core#
+      ###
+      I: I
+  
+      ###*
+      Generates a public jQuery style getter / setter method for each 
+      String argument.
+  
+          myObject = Core
+            r: 255
+            g: 0
+            b: 100
+      
+          myObject.attrAccessor "r", "g", "b"
+      
+          myObject.r(254)
+          myObject.r()
+      
+          => 254
+  
+      @name attrAccessor
+      @methodOf Core#
+      ###
+      attrAccessor: (attrNames...) ->
+        attrNames.each (attrName) ->
+          self[attrName] = (newValue) ->
+            if newValue?
+              I[attrName] = newValue
+              return self
+            else
+              I[attrName]
+  
+      ###*
+      Generates a public jQuery style getter method for each String argument.
+  
+          myObject = Core
+            r: 255
+            g: 0
+            b: 100
+      
+          myObject.attrReader "r", "g", "b"
+      
+          myObject.r()
+          => 255
+      
+          myObject.g()
+          => 0
+      
+          myObject.b()
+          => 100
+  
+      @name attrReader
+      @methodOf Core#
+      ###
+      attrReader: (attrNames...) ->
+        attrNames.each (attrName) ->
+          self[attrName] = ->
+            I[attrName]
+  
+      ###*
+      Extends this object with methods from the passed in object. A shortcut for Object.extend(self, methods)
+  
+          I =
+            x: 30
+            y: 40
+            maxSpeed: 5
+      
+          # we are using extend to give player
+          # additional methods that Core doesn't have
+          player = Core(I).extend
+            increaseSpeed: ->
+              I.maxSpeed += 1
+      
+          player.I.maxSpeed
+          => 5
+      
+          player.increaseSpeed()
+      
+          player.I.maxSpeed
+          => 6
+  
+      @name extend
+      @methodOf Core#
+      @see Object.extend
+      @returns self
+      ###
+      extend: (options) ->
+        Object.extend self, options
+  
+        return self
+  
+      ###*
+      Includes a module in this object.
+  
+          myObject = Core()
+          myObject.include(Bindable)
+      
+          # now you can bind handlers to functions
+          myObject.bind "someEvent", ->
+            alert("wow. that was easy.")
+  
+      @name include
+      @methodOf Core#
+      @param {String} Module the module to include. A module is a constructor that takes two parameters, I and self, and returns an object containing the public methods to extend the including object with.
+      ###
+      include: (modules...) ->
+        for Module in modules
+          if Module.isString?()
+            moduleName = Module
+            Module = Module.constantize()
+          else if moduleName = Module._name
+            # Nothing, captured name in if condition
+          else
+            # Attempt to look up module in global namespace
+            for key, value of root
+              if value is Module
+                Module._name = moduleName = key # Cache module name
+
+          if moduleName
+            unless I.includedModules.include moduleName
+              I.includedModules.push moduleName
+              self.extend Module(I, self)
+          else
+            warn "Unable to discover name for module: ", Module, "\nSerialization issues may occur."
+            self.extend Module(I, self)
+  
+        return self
+
+      send: (name, args...) ->
+        self[name](args...)
+
+    # Include Bindable by default
+    self.include "Bindable"
+
+    # Initial module inclue, for reconstructing objects from JSON
+    for moduleName in I.includedModules
+      Module = moduleName.constantize()
+      self.extend Module(I, self)
+
+    return self
+)()

data/source/javascripts/_cornerstone/function_extensions.js.coffee

@@ -0,0 +1,60 @@
+Function::once = ->
+  func = this
+
+  ran = false
+  memo = undefined
+
+  return ->
+    return memo if ran
+    ran = true
+
+    return memo = func.apply(this, arguments)
+
+###*
+Calling a debounced function will postpone its execution until after 
+wait milliseconds have elapsed since the last time the function was 
+invoked. Useful for implementing behavior that should only happen after 
+the input has stopped arriving. For example: rendering a preview of a 
+Markdown comment, recalculating a layout after the window has stopped 
+being resized...
+
+    lazyLayout = calculateLayout.debounce(300)
+    $(window).resize(lazyLayout)
+
+@name debounce
+@methodOf Function#
+@returns {Function} The debounced version of this function.
+###
+Function::debounce = (wait) ->
+  timeout = null
+  func = this
+
+  return ->
+    context = this
+    args = arguments
+
+    later = ->
+      timeout = null
+      func.apply(context, args)
+
+    clearTimeout(timeout)
+    timeout = setTimeout(later, wait)
+
+# Not sure about the future of this, but trying it out
+Function::returning = (x) ->
+  func = this
+
+  ->
+    func.apply(this, arguments)
+    return x
+
+Function::delay = (wait, args...) ->
+  func = this
+
+  setTimeout ->
+    func.apply(null, args)
+  , wait
+
+Function::defer = (args...) ->
+  this.delay.apply this, [1].concat(args)
+

data/source/javascripts/_cornerstone/logging.js.coffee

@@ -0,0 +1,19 @@
+###*
+@name Logging
+@namespace
+
+Gives you some convenience methods for outputting data while developing. 
+
+      log "Testing123"
+      info "Hey, this is happening"
+      warn "Be careful, this might be a problem"
+      error "Kaboom!"
+###
+
+["log", "info", "warn", "error"].each (name) ->
+  if typeof console != "undefined"
+    (exports ? this)[name] = (args...) ->
+      if console[name]
+        console[name](args...)
+  else
+    (exports ? this)[name] = ->

data/source/javascripts/_cornerstone/matrix.js.coffee

@@ -0,0 +1,337 @@
+###*
+* Matrix.js v1.3.0pre
+* 
+* Copyright (c) 2010 STRd6
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+*
+* Loosely based on flash:
+* http://www.adobe.com/livedocs/flash/9.0/ActionScriptLangRefV3/flash/geom/Matrix.html
+###
+( ->
+  ###*
+  <pre>
+     _        _
+    | a  c tx  |
+    | b  d ty  |
+    |_0  0  1 _|
+  </pre>
+  Creates a matrix for 2d affine transformations.
+
+  concat, inverse, rotate, scale and translate return new matrices with the
+  transformations applied. The matrix is not modified in place.
+
+  Returns the identity matrix when called with no arguments.
+
+  @name Matrix
+  @param {Number} [a]
+  @param {Number} [b]
+  @param {Number} [c]
+  @param {Number} [d]
+  @param {Number} [tx]
+  @param {Number} [ty]
+  @constructor
+  ###
+  Matrix = (a, b, c, d, tx, ty) ->
+    if Object.isObject(a)
+      {a, b, c, d, tx, ty} = a
+
+    __proto__: Matrix::
+    ###*
+    @name a
+    @fieldOf Matrix#
+    ###
+    a: if a? then a else 1
+
+    ###*
+    @name b
+    @fieldOf Matrix#
+    ###
+    b: b || 0
+
+    ###*
+    @name c
+    @fieldOf Matrix#
+    ###
+    c: c || 0,
+
+    ###*
+    @name d
+    @fieldOf Matrix#
+    ###
+    d: if d? then d else 1
+
+    ###*
+    @name tx
+    @fieldOf Matrix#
+    ###
+    tx: tx || 0
+
+    ###*
+    @name ty
+    @fieldOf Matrix#
+    ###
+    ty: ty || 0
+
+  Matrix:: =
+    ###*
+    Returns the result of this matrix multiplied by another matrix
+    combining the geometric effects of the two. In mathematical terms, 
+    concatenating two matrixes is the same as combining them using matrix multiplication.
+    If this matrix is A and the matrix passed in is B, the resulting matrix is A x B
+    http://mathworld.wolfram.com/MatrixMultiplication.html
+    @name concat
+    @methodOf Matrix#
+    @param {Matrix} matrix The matrix to multiply this matrix by.
+    @returns {Matrix} The result of the matrix multiplication, a new matrix.
+    ###
+    concat: (matrix) ->
+      Matrix(
+        @a * matrix.a + @c * matrix.b,
+        @b * matrix.a + @d * matrix.b,
+        @a * matrix.c + @c * matrix.d,
+        @b * matrix.c + @d * matrix.d,
+        @a * matrix.tx + @c * matrix.ty + @tx,
+        @b * matrix.tx + @d * matrix.ty + @ty
+      )
+
+    ###*
+    Copy this matrix.
+    @name copy
+    @methodOf Matrix#
+    @returns {Matrix} A copy of this matrix.
+    ###
+    copy: ->
+      Matrix(@a, @b, @c, @d, @tx, @ty)
+
+    ###*
+    Given a point in the pretransform coordinate space, returns the coordinates of 
+    that point after the transformation occurs. Unlike the standard transformation 
+    applied using the transformPoint() method, the deltaTransformPoint() method 
+    does not consider the translation parameters tx and ty.
+    @name deltaTransformPoint
+    @methodOf Matrix#
+    @see #transformPoint
+    @return {Point} A new point transformed by this matrix ignoring tx and ty.
+    ###
+    deltaTransformPoint: (point) ->
+      Point(
+        @a * point.x + @c * point.y,
+        @b * point.x + @d * point.y
+      )
+
+    ###*
+    Returns the inverse of the matrix.
+    http://mathworld.wolfram.com/MatrixInverse.html
+    @name inverse
+    @methodOf Matrix#
+    @returns {Matrix} A new matrix that is the inverse of this matrix.
+    ###
+    inverse: ->
+      determinant = @a * @d - @b * @c
+
+      Matrix(
+        @d / determinant,
+        -@b / determinant,
+        -@c / determinant,
+        @a / determinant,
+        (@c * @ty - @d * @tx) / determinant,
+        (@b * @tx - @a * @ty) / determinant
+      )
+
+    ###*
+    Returns a new matrix that corresponds this matrix multiplied by a
+    a rotation matrix.
+    @name rotate
+    @methodOf Matrix#
+    @see Matrix.rotation
+    @param {Number} theta Amount to rotate in radians.
+    @param {Point} [aboutPoint] The point about which this rotation occurs. Defaults to (0,0).
+    @returns {Matrix} A new matrix, rotated by the specified amount.
+    ###
+    rotate: (theta, aboutPoint) ->
+      @concat(Matrix.rotation(theta, aboutPoint))
+
+    ###*
+    Returns a new matrix that corresponds this matrix multiplied by a
+    a scaling matrix.
+    @name scale
+    @methodOf Matrix#
+    @see Matrix.scale
+    @param {Number} sx
+    @param {Number} [sy]
+    @param {Point} [aboutPoint] The point that remains fixed during the scaling
+    @returns {Matrix} A new Matrix. The original multiplied by a scaling matrix.
+    ###
+    scale: (sx, sy, aboutPoint) ->
+      @concat(Matrix.scale(sx, sy, aboutPoint))
+
+    ###*
+    Returns a new matrix that corresponds this matrix multiplied by a
+    a skewing matrix.
+
+    @name skew
+    @methodOf Matrix#
+    @see Matrix.skew
+    @param {Number} skewX The angle of skew in the x dimension.
+    @param {Number} skewY The angle of skew in the y dimension.
+    ###
+    skew: (skewX, skewY) ->
+      @concat(Matrix.skew(skewX, skewY))
+
+    ###*
+    Returns a string representation of this matrix.
+
+    @name toString
+    @methodOf Matrix#
+    @returns {String} A string reperesentation of this matrix.
+    ###
+    toString: ->
+      "Matrix(#{@a}, #{@b}, #{@c}, #{@d}, #{@tx}, #{@ty})"
+
+    ###*
+    Returns the result of applying the geometric transformation represented by the 
+    Matrix object to the specified point.
+    @name transformPoint
+    @methodOf Matrix#
+    @see #deltaTransformPoint
+    @returns {Point} A new point with the transformation applied.
+    ###
+    transformPoint: (point) ->
+      Point(
+        @a * point.x + @c * point.y + @tx,
+        @b * point.x + @d * point.y + @ty
+      )
+
+    ###*
+    Translates the matrix along the x and y axes, as specified by the tx and ty parameters.
+    @name translate
+    @methodOf Matrix#
+    @see Matrix.translation
+    @param {Number} tx The translation along the x axis.
+    @param {Number} ty The translation along the y axis.
+    @returns {Matrix} A new matrix with the translation applied.
+    ###
+    translate: (tx, ty) ->
+      @concat(Matrix.translation(tx, ty))
+
+  ###*
+  Creates a matrix transformation that corresponds to the given rotation,
+  around (0,0) or the specified point.
+  @see Matrix#rotate
+  @param {Number} theta Rotation in radians.
+  @param {Point} [aboutPoint] The point about which this rotation occurs. Defaults to (0,0).
+  @returns {Matrix} A new matrix rotated by the given amount.
+  ###
+  Matrix.rotate = Matrix.rotation = (theta, aboutPoint) ->
+    rotationMatrix = Matrix(
+      Math.cos(theta),
+      Math.sin(theta),
+      -Math.sin(theta),
+      Math.cos(theta)
+    )
+
+    if aboutPoint?
+      rotationMatrix =
+        Matrix.translation(aboutPoint.x, aboutPoint.y).concat(
+          rotationMatrix
+        ).concat(
+          Matrix.translation(-aboutPoint.x, -aboutPoint.y)
+        )
+
+    return rotationMatrix
+
+  ###*
+  Returns a matrix that corresponds to scaling by factors of sx, sy along
+  the x and y axis respectively.
+  If only one parameter is given the matrix is scaled uniformly along both axis.
+  If the optional aboutPoint parameter is given the scaling takes place
+  about the given point.
+  @see Matrix#scale
+  @param {Number} sx The amount to scale by along the x axis or uniformly if no sy is given.
+  @param {Number} [sy] The amount to scale by along the y axis.
+  @param {Point} [aboutPoint] The point about which the scaling occurs. Defaults to (0,0).
+  @returns {Matrix} A matrix transformation representing scaling by sx and sy.
+  ###
+  Matrix.scale = (sx, sy, aboutPoint) ->
+    sy = sy || sx
+
+    scaleMatrix = Matrix(sx, 0, 0, sy)
+
+    if aboutPoint
+      scaleMatrix =
+        Matrix.translation(aboutPoint.x, aboutPoint.y).concat(
+          scaleMatrix
+        ).concat(
+          Matrix.translation(-aboutPoint.x, -aboutPoint.y)
+        )
+
+    return scaleMatrix
+
+  ###*
+  Returns a matrix that corresponds to a skew of skewX, skewY.
+
+  @see Matrix#skew
+  @param {Number} skewX The angle of skew in the x dimension.
+  @param {Number} skewY The angle of skew in the y dimension.
+  @return {Matrix} A matrix transformation representing a skew by skewX and skewY.
+  ###
+  Matrix.skew = (skewX, skewY) ->
+    Matrix(0, Math.tan(skewY), Math.tan(skewX), 0)
+
+  ###*
+  Returns a matrix that corresponds to a translation of tx, ty.
+  @see Matrix#translate
+  @param {Number} tx The amount to translate in the x direction.
+  @param {Number} ty The amount to translate in the y direction.
+  @return {Matrix} A matrix transformation representing a translation by tx and ty.
+  ###
+  Matrix.translate = Matrix.translation = (tx, ty) ->
+    Matrix(1, 0, 0, 1, tx, ty)
+
+  ###*
+  A constant representing the identity matrix.
+  @name IDENTITY
+  @fieldOf Matrix
+  ###
+  Matrix.IDENTITY = Matrix()
+
+  ###*
+  A constant representing the horizontal flip transformation matrix.
+  @name HORIZONTAL_FLIP
+  @fieldOf Matrix
+  ###
+  Matrix.HORIZONTAL_FLIP = Matrix(-1, 0, 0, 1)
+
+  ###*
+  A constant representing the vertical flip transformation matrix.
+  @name VERTICAL_FLIP
+  @fieldOf Matrix
+  ###
+  Matrix.VERTICAL_FLIP = Matrix(1, 0, 0, -1)
+
+  if Object.freeze
+    Object.freeze Matrix.IDENTITY
+    Object.freeze Matrix.HORIZONTAL_FLIP
+    Object.freeze Matrix.VERTICAL_FLIP
+
+  # Export to window
+  (exports ? this)["Matrix"] = Matrix
+)()
+