flms 0.0.3 → 0.1.0

data/app/controllers/flms/embed_layers_controller.rb

@@ -0,0 +1,24 @@
+module Flms
+  class EmbedLayersController < AbstractLayerController
+
+    def new
+      @layer = EmbedLayer.new.build_default_keyframes
+    end
+
+    def create
+      @layer = EmbedLayer.new params[:embed_layer]
+      do_create
+    end
+
+    def update
+      do_update @layer.update_attributes(params[:embed_layer])
+    end
+
+  protected
+
+    def load_layer
+      @layer = EmbedLayer.find params[:id]
+    end
+
+  end
+end

data/app/controllers/flms/image_layers_controller.rb

@@ -1,74 +1,26 @@
-require_dependency "flms/application_controller"
-
 module Flms
-  class ImageLayersController < ApplicationController
-    layout 'flms/admin'
-    before_filter :authenticate_user!
-    before_filter :load_page
-    before_filter :load_block
-    before_filter :load_layer, only: [:show, :edit, :update, :delete]
-
-    def index
-    end
-
-    def show
-    end
+  class ImageLayersController < AbstractLayerController
 
     def new
-      @layer = ImageLayer.new
-    end
-
-    def edit
+      @layer = ImageLayer.new.build_default_keyframes
     end
 
     def create
       @layer = ImageLayer.new params[:image_layer]
       @layer.image = params[:image_layer][:image]
-      @layer.block = @block
-      if @layer.save
-        redirect_to page_block_path(@page, @block), notice: 'Layer created'
-      else
-        render action: "new"
-      end
+      do_create
     end
 
     def update
-      if @layer.update_attributes(params[:image_layer])
-        redirect_to [@page, @block], notice: 'Layer updated'
-      else
-        render action: "edit"
-      end
+      do_update @layer.update_attributes(params[:image_layer])
     end
 
-    def update_all
-      params[:layer_data].each_with_index do |layer_data, pos|
-        position = @page.position_for_layer layer_data[:id].to_i
-        position.active = layer_data[:active]
-        position.ordering = pos
-        position.save!
-      end
-      render text: ''
-    end
-
-    def destroy
-      @layer.destroy
-      redirect_to page_blocks_path(@page), notice: 'Layer deleted'
-    end
-
-
-    private
-
-    def load_page
-      @page = Page.find_by_url params[:page_id]
-    end
-
-    def load_block
-      @block = Block.find params[:block_id]
-    end
+  protected
 
     def load_layer
       @layer = ImageLayer.find params[:id]
     end
+
   end
 end
 

data/app/controllers/flms/layers_controller.rb

@@ -4,21 +4,15 @@ module Flms
   class LayersController < ApplicationController
     layout 'flms/admin'
     before_filter :authenticate_user!
-    before_filter :load_page
     before_filter :load_block
-    before_filter :load_layer, only: [:show, :edit, :update, :destroy]
+    before_filter :load_layer, only: [:show, :update, :destroy]
 
     def destroy
       @layer.destroy
-      redirect_to page_block_path(@page, @block), notice: 'Layer deleted'
+      redirect_to edit_block_path(@block), notice: 'Layer deleted'
     end
 
-
-    private
-
-    def load_page
-      @page = Page.find_by_url params[:page_id]
-    end
+  private
 
     def load_block
       @block = Block.find params[:block_id]
@@ -29,4 +23,3 @@ module Flms
     end
   end
 end
-

data/app/controllers/flms/pages_controller.rb

@@ -2,14 +2,22 @@ require_dependency "flms/application_controller"
 
 module Flms
   class PagesController < ApplicationController
-    before_filter :authenticate_user!
-    layout 'flms/admin'
+    before_filter :authenticate_user!, except: [ :show ]
+    before_filter :load_page, except: [ :index, :new, :create ]
+    layout :resolve_layout
 
     def index
       @pages = Page.all
     end
 
     def show
+      respond_to do |format|
+        format.plain_html { with_format('html') { render partial: 'flms/elements/page', formats: [:html],
+                                                         layout: 'flms/plain_styling',
+                                                         locals: { page: @page } } }
+        format.html
+        format.json { render json: @page }
+      end
     end
 
     def new
@@ -17,7 +25,7 @@ module Flms
     end
 
     def edit
-      @page = Page.find_by_url params[:id]
+      @available_blocks = Block.all - @page.blocks
     end
 
     def create
@@ -30,7 +38,6 @@ module Flms
     end
 
     def update
-      @page = Page.find_by_url params[:id]
       if @page.update_attributes params[:page]
         redirect_to pages_path, notice: 'Page was successfully updated.'
       else
@@ -39,9 +46,41 @@ module Flms
     end
 
     def destroy
-      @page = Page.find_by_url params[:id]
       @page.destroy
       redirect_to pages_url
     end
+
+    def add_block
+      @block = Block.find params[:block][:id]
+      @page.blocks << @block
+      redirect_to edit_page_path(@page), notice: 'Block added.'
+    end
+
+    def remove_block
+      @block = Block.find params[:block_id]
+      @page.blocks.delete @block
+      redirect_to edit_page_path(@page), notice: 'Block removed.'
+    end
+
+    def update_blocks
+      params[:block_data].each_with_index do |block_data, pos|
+        position = @page.position_for_block block_data[:id].to_i
+        position.active = block_data[:active]
+        position.ordering = pos
+        position.save!
+      end
+      render text: ''
+    end
+
+  protected
+
+    def load_page
+      @page = Page.find_by_url(params[:id]) || Page.find_by_url(params[:page_id]) || raise(ActionController::RoutingError.new('Page Not Found'))
+    end
+
+    def resolve_layout
+      action_name == 'show' ? 'flms/public' : 'flms/admin'
+    end
+
   end
 end

data/app/controllers/flms/paragraph_layers_controller.rb

@@ -0,0 +1,24 @@
+module Flms
+  class ParagraphLayersController < AbstractLayerController
+
+    def new
+      @layer = ParagraphLayer.new.build_default_keyframes
+    end
+
+    def create
+      @layer = ParagraphLayer.new params[:paragraph_layer]
+      do_create
+    end
+
+    def update
+      do_update @layer.update_attributes(params[:paragraph_layer])
+    end
+
+  protected
+
+    def load_layer
+      @layer = ParagraphLayer.find params[:id]
+    end
+  end
+end
+

data/app/controllers/flms/text_layers_controller.rb

@@ -0,0 +1,24 @@
+module Flms
+  class TextLayersController < AbstractLayerController
+
+    def new
+      @layer = TextLayer.new.build_default_keyframes
+    end
+
+    def create
+      @layer = TextLayer.new params[:text_layer]
+      do_create
+    end
+
+    def update
+      do_update @layer.update_attributes(params[:text_layer])
+    end
+
+  protected
+
+    def load_layer
+      @layer = TextLayer.find params[:id]
+    end
+  end
+end
+

data/app/helpers/flms/application_helper.rb

@@ -1,4 +1,17 @@
 module Flms
   module ApplicationHelper
+
+    # Return 'active' if the current request is to the specified controller,
+    # otherwise return an empty string.
+    def nav_active_class controller_path
+      params[:controller] == controller_path ? 'active' : ''
+    end
+
+    # Get a background-image style for the specified block.
+    # If the block doesn't have a thumbnail, return an empty string.
+    def block_thumbnail_div_background_style block
+      block.thumbnail? ? "background-image: url(#{ block.thumbnail.small.url })" : ''
+    end
+
   end
 end

data/app/models/flms/animation_layer.rb

@@ -0,0 +1,33 @@
+module Flms
+  class AnimationLayer < Layer
+    attr_accessible :image, :image_cache,
+                    :frame_count, :frame_rate,
+                    :image_width, :image_height,
+                    :image_display_mode
+
+    mount_uploader :image, ImageUploader
+    before_save :retain_geometry
+
+    validates_inclusion_of :image_display_mode, in: Flms::Layer::IMAGE_DISPLAY_MODES
+    validates_numericality_of :frame_count, greater_than_or_equal_to: 1
+    validates_numericality_of :frame_rate, greater_than_or_equal_to: 1
+
+    def view_object
+      @view_object ||= Flms::AnimationLayerViewObject.new(self)
+    end
+
+    def uploaded_filename
+      File.basename(image.path) if image?
+    end
+
+    # Pull geometry information out of uploaded file and store as attributes in
+    # model prior to save.  See image_uploader.rb#get_geometry.
+    def retain_geometry
+      geometry = self.image.normal.geometry
+      if geometry
+        self.image_width = geometry[0]
+        self.image_height = geometry[1]
+      end
+    end
+  end
+end

data/app/models/flms/block.rb

@@ -1,11 +1,27 @@
 module Flms
   class Block < ActiveRecord::Base
-    attr_accessible :active, :name
+    attr_accessible :name, :title, :thumbnail
 
     has_many :blocks_pages, class_name: 'Flms::BlocksPage', dependent: :destroy
     has_many :pages, through: :blocks_pages, class_name: 'Flms::Page'
     has_many :layers
 
+    mount_uploader :thumbnail, ThumbnailImageUploader
+
     validates :name, presence: true
+    validates :name, :'flms/css_name' => true
+
+    scope :ordered, order('ordering')
+
+    # Return the total scroll duration for this block, taking in to account the fact that
+    # layers can and will overlap.  Return 0 if block has no layers.
+    def scroll_duration
+      layers.map(&:scroll_end).max || 0
+    end
+
+  def thumbnail_uploaded_filename
+    File.basename(thumbnail.path) if thumbnail?
+  end
+
   end
 end

data/app/models/flms/blocks_page.rb

@@ -4,5 +4,8 @@ module Flms
 
     belongs_to :block, class_name: 'Flms::Block'
     belongs_to :page, class_name: 'Flms::Page'
+
+    scope :ordered, order('ordering').includes(:block)
+    scope :is_active, where(active: true )
   end
 end

data/app/models/flms/embed_layer.rb

@@ -0,0 +1,12 @@
+module Flms
+  class EmbedLayer < Layer
+    attr_accessible :embed_code
+
+    validates :embed_code, presence: true
+
+    def view_object
+      @view_object ||= Flms::EmbedLayerViewObject.new(self)
+    end
+
+  end
+end

data/app/models/flms/end_state_keyframe.rb

@@ -0,0 +1,17 @@
+module Flms
+  class EndStateKeyframe < Keyframe
+    after_initialize :set_default_values
+
+    def set_default_values
+      # scroll_start is auto-calculated in layer prior to saving the records
+      self.scroll_duration ||= 100
+      self.width ||= 1.0
+      self.height ||= 1.0
+      self.position_x ||= 0.5
+      self.position_y ||= 0.5
+      self.opacity ||= 0.0
+      self.scale ||= 1.0
+      self.blur ||= 0.0
+    end
+  end
+end

data/app/models/flms/image_layer.rb

@@ -1,8 +1,30 @@
 module Flms
   class ImageLayer < Layer
-    attr_accessible :image
+    attr_accessible :image, :image_cache, :image_display_mode,
+                    :image_width, :image_height
+
+    validates_inclusion_of :image_display_mode, in: Flms::Layer::IMAGE_DISPLAY_MODES
 
     mount_uploader :image, ImageUploader
+    before_save :retain_geometry
+
+    def view_object
+      @view_object ||= Flms::ImageLayerViewObject.new(self)
+    end
+
+    def uploaded_filename
+      File.basename(image.path) if image?
+    end
+
+    # Pull geometry information out of uploaded file and store as attributes in
+    # model prior to save.  See image_uploader.rb#get_geometry.
+    def retain_geometry
+      geometry = self.image.normal.geometry
+      if geometry
+        self.image_width = geometry[0]
+        self.image_height = geometry[1]
+      end
+    end
   end
 end
 

data/app/models/flms/keyframe.rb

@@ -0,0 +1,130 @@
+module Flms
+  class Keyframe < ActiveRecord::Base
+    attr_accessible :layer,
+                    :scroll_start, :scroll_duration,
+                    :width, :height,
+                    :margin_left, :margin_top,
+                    :position_x, :position_y,
+                    :opacity, :scale, :blur,
+                    :width_percent, :height_percent,
+                    :margin_left_percent, :margin_top_percent,
+                    :opacity_percent, :scale_percent, :blur_percent, :position_name, :top_percent, :left_percent
+
+    belongs_to :layer
+
+    validates_numericality_of :scroll_start, greater_than_or_equal_to: 0, allow_nil: true
+    validates_numericality_of :scroll_duration, greater_than_or_equal_to: 0, allow_nil: true
+    validates_numericality_of :width, greater_than_or_equal_to: 0, allow_nil: true
+    validates_numericality_of :height, greater_than_or_equal_to: 0, allow_nil: true
+    validates_numericality_of :margin_left
+    validates_numericality_of :margin_top
+    validates_numericality_of :opacity, greater_than_or_equal_to: 0, less_than_or_equal_to: 1, allow_nil: true
+    validates_numericality_of :scale, greater_than_or_equal_to: 0, allow_nil: true
+
+    # Flms provides some 'friendly' position values to hide the details of setting x,y values for CSS positioning of layers.
+    # Below we store a list of valid position names, and corresponding x,y coordinates for each
+    POSITION_NAMES = %w[center top-left top top-right right bottom-right bottom bottom-left left]
+    POSITION_COORDINATES = [[0.5, 0.5], [0.0, 0.0], [0.5, 0.0], [1.0, 0.0], [1.0, 0.5], [1.0, 1.0], [0.5, 1.0], [0.0, 1.0], [0.0, 0.5]]
+
+    def position_name_valid? position_name
+      POSITION_NAMES.include?(position_name)
+    end
+
+    def position_coordinates_valid? position_coordinates
+      POSITION_COORDINATES.include? position_coordinates
+    end
+
+    def position_name_to_coordinates position_name
+      raise 'position name invalid' unless position_name_valid?(position_name)
+      POSITION_COORDINATES[POSITION_NAMES.index(position_name)]
+    end
+
+    def position_coordinates_to_name position_coordinates
+      raise 'position coordinates invalid' unless position_coordinates_valid?(position_coordinates)
+      POSITION_NAMES[POSITION_COORDINATES.index(position_coordinates)]
+    end
+
+    def width_percent
+      (self.width * 100).to_i
+    end
+
+    def width_percent= val
+      self.width = val.to_i / 100.0
+    end
+
+    def height_percent
+      (self.height * 100).to_i
+    end
+
+    def height_percent= val
+      self.height = val.to_i / 100.0
+    end
+
+    def margin_left_percent
+      (self.margin_left * 100).to_i
+    end
+
+    def margin_left_percent= val
+      self.margin_left = val.to_i / 100.0
+    end
+
+    def margin_top_percent
+      (self.margin_top * 100).to_i
+    end
+
+    def margin_top_percent= val
+      self.margin_top = val.to_i / 100.0
+    end
+
+    def opacity_percent
+      (self.opacity * 100).to_i
+    end
+
+    def opacity_percent= val
+      self.opacity = val.to_i / 100.0
+    end
+
+    def scale_percent
+      (self.scale * 100).to_i
+    end
+
+    def scale_percent= val
+      self.scale = val.to_i / 100.0
+    end
+
+    def blur_percent
+      (self.blur * 100).to_i
+    end
+
+    def blur_percent= val
+      self.blur = val.to_i / 100.0
+    end
+
+    def left_percent
+      (self.position_x * 100).to_i
+    end
+
+    def left_percent= val
+      self.position_x = val.to_i / 100.0
+    end
+
+    def top_percent
+      (self.position_y * 100).to_i
+    end
+
+    def top_percent= val
+      self.position_y = val.to_i / 100.0
+    end
+
+    def position_name
+      position_coordinates_to_name [self.position_x, self.position_y]
+    end
+
+    def position_name= val
+      coordinates = position_name_to_coordinates val
+      self.position_x = coordinates[0]
+      self.position_y = coordinates[1]
+    end
+
+  end
+end