Cass Tests

script.coffee

$ ->
  # run quaddemo?
  #runit()
  
  global = window
  BP = (options) ->
    console.log options
    alert options
  
  ERROR = (options) ->
    console.error options
  
  d4 = {}
  window.d4 = d4

  cexp = c.LinearExpression
  ceq = c.LinearEquation
  cieq = c.LinearInequality

  
  _weak = c.Strength.weak
  _medium = c.Strength.medium
  _strong = c.Strength.strong
  _required = c.Strength.required
  
  class d4.App
    constructor: ->
      @solver = new c.SimplexSolver()
      @solver.setAutosolve(true)
      @views = []
      
    staticDemo: ->
      
      box1 = new d4.View('#box1')
      @views.push box1
            
      box2 = new d4.View('#box2')
      @views.push box2
      
      box3 = new d4.View('#box3')
      @views.push box3

      @solver.addStay(box1.w).addStay(box1.h).addStay(box1.x).addStay(box1.y)
      
      # width bounds
      wMax = 500
      wMin = 250
      
      
      
      if box1.wNatural <= wMin
        @solver.addConstraint new cieq(box1.w, c.GEQ, wMin, _required)
        @solver.addConstraint new cieq(box1.w, c.LEQ, wMax, _required)        
      else  
        @solver.addConstraint new cieq(box1.w, c.LEQ, wMax, _required)
        @solver.addConstraint new cieq(box1.w, c.GEQ, wMin, _required)
      
      #@solver.addConstraint new ceq(box1.w, box1.wIntrinsic, _required)
      #@solver.addConstraint new cieq(box1.w, c.LEQ, ((wMin + wMax)/2) )
          
      
      # height bounds
      hMax = 500
      hMin = 10
      @solver.addConstraint new cieq(box1.h, c.LEQ, hMax, _required)
      @solver.addConstraint new cieq(box1.h, c.GEQ, hMin, _required)
      
      #for view in @views
      #  view._setupInternalConstraints( @solver )
      
      # left align
      
      @solver.addConstraint new ceq(box2.x, box1.r(), _required)
      @solver.addConstraint new ceq(box3.x, box1.r(), _required)
      @solver.addConstraint new ceq(box3.y, box1.y, _required)
      
      # top align w/ offset
      #@solver.addConstraint new ceq(box2.y, c.Plus(box1.y,10)) 
      
      @solver.addStay(box3.h).addStay(box3.y)
      @solver.addConstraint new ceq(box2.y, box1.b(), _weak)
      
      #@solver.addStay(box2.h).addStay(box2.y)
      #@solver.addConstraint new cieq(box1.y, c.LEQ, box2.b(), _weak)
      #box2.position {my:'y', at:'b', of:box3}, _required
      
      # window border
      for view in @views
        @solver.addConstraint new cieq(view.x, c.LEQ, 1200)
        @solver.addConstraint new cieq(view.x, c.GEQ, 100)
        $el = view.$el
          
      $(window).on 
        mousedown:(ev) =>
          view = $(ev.target).data()?.view?()
          if view
            @draggedView = view
            @draggedView.$el.addClass('dragging')
            @solver.addEditVar(@draggedView.x).addEditVar(@draggedView.y).beginEdit()
        mousemove: (ev) =>
          if @draggedView
            x = ev.pageX
            y = ev.pageY
            @solver.suggestValue(@draggedView.x,x).suggestValue(@draggedView.y,y).resolve()
            @render()
        mouseup: (ev) =>
          if @draggedView 
            @draggedView.$el.removeClass('dragging')
            @solver.endEdit()
            @render()
          @draggedView = null
        
      
          
      
      
      #box2.t = #box2.b !strong
      #@solver.addConstraint new ceq(box2.y, box3.b() )
      
      # equal widths
      #@solver.addConstraint new ceq(box1.w, box2.w)
      #@solver.addConstraint new ceq(box2.w, box3.w)


      @render()
      
      
    render: ->
      for view in @views
        view.render()
    
      
  class d4.View 
    constructor: (el) ->
      if _.isString(el) then $el = $(el)
      $el = $(el)
      $el.data().view = () =>
        return @
      @$el = $el
      @wNatural = 100
      @w = new c.Variable @wNatural
      @h = new c.Variable $el.height()
      #@wIntrinsic = new c.Variable $el.width()
      
      p = $el.position()
      @x = new c.Variable p.left
      @y = new c.Variable p.top
      @t = @y
      @cx = () ->
        exp = new cexp @w
        exp = exp.divide(2)
        exp.plus(@x)
      @cx.value = () ->
        return (@w.value() / 2)  + @x.value()
      @cy = () ->
        exp = new cexp @h
        exp = exp.divide(2)
        exp.plus(@y)
      @cy.value = () ->
        return (@h.value() / 2)  + @y.value()
      @b = () ->
        new cexp(@y).plus(@h)
      @b.value = () =>
        return @y.value() + @h.value()
      @l = @x
      @r = () ->
        new cexp(@x).plus(@w)
      @r.value = () =>
        return @x.value() + @w.value()
      #@tl = new c.Point p.left, p.top
      #@tr = new c.Point p.right, p.top

      
      $el.addClass 'cassowary-item'
          
    getSolver: () ->
      return app.solver
    
    stay:(prop)->
      
    
    position:(options, strength = _strong)->
      options or options = {}
      my = options.my or 'l'
      at = options.at or 'r'
      _of = options.of or ERROR 'position(of:)'
      offset = options.offset or 0
      solver = options.offset or @getSolver()
      if offset > 0
        solver.addConstraint new ceq( @[my], c.Plus(_of[at], offset), strength)
      else        
        solver.addConstraint new ceq( @[my], _of[at](), strength)
      #collision
      #using # ({x,y})
    lead: (options) ->
      _of = options.of 
      eq = options.eq
      offset = options.offset()
    tail: (view, eq = false) ->
    above: (view, eq = false) ->
    below: (view, eq = false) ->
        
    inside: (view, options)->       
      offset = options.offset
      
    render: () ->
      x = @x.value()
      y = @y.value()
      w = @w.value()
      h = @h.value()
      cssAttrs = 
        position: 'absolute'
        left: "0px"
        top: '0px'
        width:"#{w}px"
        height:"#{h}px"
        '-webkit-transform': "translate3d(#{x}px, #{y}px, 0px)"    
        '-moz-transform': "translate(#{x}px, #{y}px)"    
      @$el.css ( cssAttrs  )
      
      return @
    
    _setupInternalConstraints: (solver) ->
      #solver.addStay(@y)
      
      solver.addConstraint new c.LinearInequality(@w, c.LEQ, 500)
      solver.addConstraint new c.LinearInequality(@w, c.GEQ, 10)
      
      
      solver.addConstraint new c.LinearInequality(@h, c.LEQ, 500)
      solver.addConstraint new c.LinearInequality(@h, c.GEQ, 10)
      
      #solver.addConstraint new c.LinearInequality(@x, c.LEQ, 100)
      #solver.addConstraint new c.LinearInequality(@x, c.GEQ, 10)
      
      #solver.addConstraint new c.LinearInequality(@y, c.GEQ, 10)
      #solver.addConstraint new c.LinearInequality(@y, c.LEQ, 1000)
      
      
      #exp = new cexp @y
      #solver.addConstraint new c.LinearInequality(@y, c.LEQ, exp.plus(@h))
      
      #solver.addConstraint new c.LinearEquation(@tr.y, new c.LinearExpression(@tl.y))
      #solver.addConstraint new c.LinearEquation(@tr.y, new c.LinearExpression(@tl.y))
      # w = r - l
      # w <= wMax
      # w >= wMin
      # h <= hMax
      # h >= hMin
      # h = b - t
      # l = tl.x()
      # r = tr.x()
      # t = tr.y()
      # b = bl.y()
      # hMin <= b - t
      # hMax >= b - t
    
    css:(options)->
      @$el.css options
  
  
  app = new d4.App
  app.staticDemo()
  global.app = app
  ###
  
  TODO:
    - How
  
  ###
  
  
  
  
  
  
  #class rootWindowView
  #class containerView
  
  # [see](http://developer.apple.com/library/mac/#documentation/AppKit/Reference/NSLayoutConstraint_Class/NSLayoutConstraint/NSLayoutConstraint.html)
  # A constraint defines a relationship between two attributes of user interface objects that must be satisfied by the constraint-based layout system.
  # The relationship involves a first attribute, a relationship type, and a modified second value formed by multiplying an attribute by a constant factor and then adding another constant factor to it. In other words, constraints look very much like linear equations of the following form:
  # ```
  # attribute1 == multipler × attribute2 + constant
  # ```
  # The right side of this equation can be considered a modified attribute, so this equation could be described in words as “attribute one must be equal to the modified attribute two.”
  # Note that the constraint-based layout system is free to modify the attributes on either side of the equation as part of satisfying the system of constraints that apply to the objects being laid out.
  # They can also use greater than or equal (>=) or less than or equal (<=) to describe the relationship between the two attributes.
  # Constraints also have priorities, indicating to the layout system which constraint should take priority when two or more constraints are in conflict.
  #
  # Constraints can, with some restrictions, cross the view hierarchy
  #
  # A constraint cannot cross through a view that is manually laid out, or through a view that has a bounds transform. You can think of these views as barriers. There’s an inside world and an outside world, but the inside cannot be connected to the outside by constraints.
  #
  # Constraints are not directional, and there are no restrictions on cycles. Layout itself is neither top down nor bottom up. Instead, all constraints, and their relative priorities, are considered at the same time, and elements laid out in such a way that best satisfies all of the constraints.
  class LayoutConstraint
    
    constructor: ->
      #@priority = new LayoutPriority
      #@relation = new LayoutRelation
      
    # Unlike the other properties, the constant may be modified after constraint creation. Setting the constant on an existing constraint performs much better than removing the constraint and adding a new one that's just like the old but for having a new constant.
    constant: 0
    
    shouldBeArchived: true #false    
  
    _firstAttribute: null
      
    _secondAttribute: null
    
    _firstItem: null
    
    _secondItem: null
    
    setConstant: ->
  
  
  class LayoutConstraints
    add: ->
    remove: ->
  
  
  
  # [see](http://developer.apple.com/library/mac/#documentation/Cocoa/Reference/ApplicationKit/Classes/NSView_Class/Reference/NSView.html#//apple_ref/occ/instm/NSView/addConstraint:)
  # provides a structure for drawing, printing, and handling events
  #
  # View is perhaps the most important class in the Application Kit when it comes to subclassing and inheritance. 
  class View
    
    # left, right, top, bottom, leading, trailing, width, height, centerX, centerY, and baseline.
    
    constructor: () ->
      # Layout Operates on Alignment Rectangles
      @alignmentRect = null
      @tl = new c.Point()
      @tr = new c.Point()
      @bl = new c.Point()
      @br = new c.Point()
      
      #@constraints = new LayoutConstraints
    
    # The fittingSize method returns the ideal size for the view *considering only those constraints installed on the receiver’s subtree together with a preference for the view to be as small as possible*. 
    # The fitting size is not the “best” size for a view in a general sense—in the constraint-based system, a view’s “best” size if you consider everything has to be the size it currently has!
    fittingSize: ->
      
    
    # Returns the natural size for the receiving view, considering only properties of the view itself.
    # Custom views typically have content that they display of which the layout system is unaware. Overriding this method allows a custom view to communicate to the layout system what size it would like to be based on its content. This intrinsic size must be independent of the content frame, because there’s no way to dynamically communicate a changed width to the layout system based on a changed height, for example.
    intrinsicContentSize: ->
      # returns: A view can return absolute values for its width and height, or NSViewNoInstrinsicMetric for either or both to indicate that it has no preference for a given dimension.
      return null
    # Call this when something changes in your custom view that invalidates its intrinsic content size. This allows the constraint-based layout system to take the new intrinsic content size into account in its next layout pass.
    invalidateIntrinsicContentSize: ->
    
    setContentHuggingPriority:(priority, orientation)-> 
    setContentCompressionResistancePriority:(priority, orientation)->
      
    # Baseline Stuff
    #@key baseline
    #baselineOffsetFromBottom: ->
    # returns the distance between NSLayoutAttributeBottom and NSLayoutAttributeBaseline. This default return value for NSView is 0; the method is overridden by subclasses for which it makes sense to do so.
  
  # Views are arranged within an Window object, in a nested hierarchy of subviews.  
  #
  #
  
  class Views  
  
  class Window
    
  # handles dynamic views? [see](http://gentlebytes.com/2011/09/auto-layout-in-lion/)
  class ViewController