bench9000 0.1

data/vendor/psd.rb/lib/psd/image_modes/rgb.rb

@@ -0,0 +1,32 @@
+class PSD
+  module ImageMode
+    # Combines the channel data from the image into RGB pixel values
+    module RGB
+      private
+
+      def combine_rgb_channel
+        PSD.logger.debug "Beginning RGB processing"
+
+        (0...@num_pixels).step(pixel_step) do |i|
+          r = g = b = 0
+          a = 255
+
+          @channels_info.each_with_index do |chan, index|
+            next if chan[:id] == -2
+            
+            val = @channel_data[i + (@channel_length * index)]
+
+            case chan[:id]
+            when -1 then  a = val
+            when 0 then   r = val
+            when 1 then   g = val
+            when 2 then   b = val
+            end
+          end
+
+          @pixel_data.push ChunkyPNG::Color.rgba(r, g, b, a)
+        end
+      end
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/layer.rb

@@ -0,0 +1,77 @@
+class PSD
+  # Represents a single layer and all of the data associated with
+  # that layer.
+  class Layer
+    include Section
+    include BlendModes
+    include BlendingRanges
+    include ChannelImage
+    include Exporting
+    include Helpers
+    include Info
+    include Mask
+    include Name
+    include PathComponents
+    include PositionAndChannels
+
+    attr_reader :id, :info_keys, :header
+    attr_accessor :group_layer, :node, :file
+
+    # Initializes all of the defaults for the layer.
+    def initialize(file, header)
+      @file = file
+      @header = header
+
+      @mask = {}
+      @blending_ranges = {}
+      @adjustments = {}
+      @channels_info = []
+      @blend_mode = {}
+      @group_layer = nil
+
+      @blending_mode = 'normal'
+      @opacity = 255
+
+      # Just used for tracking which layer adjustments we're parsing.
+      # Not essential.
+      @info_keys = []
+    end
+
+    # Parse the layer and all of it's sub-sections.
+    def parse(index=nil)
+      start_section
+
+      @id = index
+
+      parse_position_and_channels
+      parse_blend_modes
+
+      extra_len = @file.read_int
+      @layer_end = @file.tell + extra_len
+
+      parse_mask_data
+      parse_blending_ranges
+      parse_legacy_layer_name
+      parse_layer_info
+
+      PSD.logger.debug "Layer name = #{name}"
+
+      @file.seek @layer_end # Skip over any filler zeros
+
+      end_section
+      return self
+    end
+
+    # We just delegate this to a normal method call.
+    def [](val)
+      self.send(val)
+    end
+
+    # We delegate all missing method calls to the extra layer info to make it easier
+    # to access that data.
+    def method_missing(method, *args, &block)
+      return @adjustments[method] if @adjustments.has_key?(method)
+      super
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/layer/blend_modes.rb

@@ -0,0 +1,30 @@
+class PSD
+  class Layer
+    module BlendModes
+      attr_reader :blend_mode, :opacity
+
+      def blending_mode
+        if !info[:section_divider].nil? && info[:section_divider].blend_mode
+          BlendMode::BLEND_MODES[info[:section_divider].blend_mode.strip.to_sym]
+        else
+          @blending_mode
+        end
+      end
+
+      # Is the layer below this one a clipping mask?
+      def clipped?
+        @blend_mode.clipping == 1
+      end
+
+      private
+      
+      def parse_blend_modes
+        @blend_mode = BlendMode.read(@file)
+
+        @blending_mode = @blend_mode.mode
+        @opacity = @blend_mode.opacity
+        @visible = @blend_mode.visible
+      end
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/layer/blending_ranges.rb

@@ -0,0 +1,62 @@
+class PSD
+  class Layer
+    module BlendingRanges
+      attr_reader :blending_ranges
+
+      private
+      
+      def parse_blending_ranges
+        length = @file.read_int
+
+        # Composite gray blend. Contains 2 black values followed by 2 white values. 
+        # Present but irrelevant for Lab & Grayscale.
+        @blending_ranges[:grey] = {
+          source: {
+            black: [@file.read_byte, @file.read_byte],
+            white: [@file.read_byte, @file.read_byte]
+          },
+          dest: {
+            black: [@file.read_byte, @file.read_byte],
+            white: [@file.read_byte, @file.read_byte]
+          }
+        }
+
+        @blending_ranges[:num_channels] = (length - 8) / 8
+
+        @blending_ranges[:channels] = []
+        @blending_ranges[:num_channels].times do
+          @blending_ranges[:channels] << {
+            source: {
+              black: [@file.read_byte, @file.read_byte],
+              white: [@file.read_byte, @file.read_byte]
+            },
+            dest: {
+              black: [@file.read_byte, @file.read_byte],
+              white: [@file.read_byte, @file.read_byte]
+            }
+          }
+        end
+      end
+
+      def export_blending_ranges(outfile)
+        length = 4 * 2 # greys
+        length += @blending_ranges[:num_channels] * 8
+        outfile.write_int length
+
+        outfile.write @blending_ranges[:grey][:source][:black].pack('CC')
+        outfile.write @blending_ranges[:grey][:source][:white].pack('CC')
+        outfile.write @blending_ranges[:grey][:dest][:black].pack('CC')
+        outfile.write @blending_ranges[:grey][:dest][:white].pack('CC')
+
+        @blending_ranges[:num_channels].times do |i|
+          outfile.write @blending_ranges[:channels][i][:source][:black].pack('CC')
+          outfile.write @blending_ranges[:channels][i][:source][:white].pack('CC')
+          outfile.write @blending_ranges[:channels][i][:dest][:black].pack('CC')
+          outfile.write @blending_ranges[:channels][i][:dest][:white].pack('CC')
+        end
+
+        @file.seek length + 4, IO::SEEK_CUR
+      end
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/layer/channel_image.rb

@@ -0,0 +1,15 @@
+class PSD
+  class Layer
+    module ChannelImage
+      attr_reader :image
+
+      def parse_channel_image(header)
+        image = PSD::ChannelImage.new(@file, header, self)
+        @image = LazyExecute.new(image, @file)
+          .now(:skip)
+          .later(:parse)
+          .ignore(:width, :height)
+      end
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/layer/exporting.rb

@@ -0,0 +1,28 @@
+class PSD
+  class Layer
+    module Exporting
+      # Export the layer to file. May or may not work.
+      def export(outfile)
+        export_position_and_channels(outfile)
+
+        @blend_mode.write(outfile)
+        @file.seek(@blend_mode.num_bytes, IO::SEEK_CUR)
+
+        export_mask_data(outfile)
+        export_blending_ranges(outfile)
+        export_legacy_layer_name(outfile)
+        export_extra_data(outfile)
+
+        outfile.write @file.read(end_of_section - @file.tell)
+      end
+
+      def write_vector_mask(outfile)
+        outfile.write @file.read(8)
+        # outfile.write_int 3
+        # outfile.write_int @vector_tag
+
+        @path_components.each{ |pc| pc.write(outfile); @file.seek(26, IO::SEEK_CUR) }
+      end
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/layer/helpers.rb

@@ -0,0 +1,77 @@
+class PSD
+  class Layer
+    module Helpers
+      # Does this layer represent the start of a folder section?
+      def folder?
+        if info.has_key?(:section_divider)
+          info[:section_divider].is_folder
+        elsif info.has_key?(:nested_section_divider)
+          info[:nested_section_divider].is_folder
+        else
+          name == "<Layer group>"
+        end
+      end
+
+      # Does this layer represent the end of a folder section?
+      def folder_end?
+        if info.has_key?(:section_divider)
+          info[:section_divider].is_hidden
+        elsif info.has_key?(:nested_section_divider)
+          info[:nested_section_divider].is_hidden
+        else
+          name == "</Layer group>"
+        end
+      end
+
+      # Is the layer completely locked?
+      def all_locked?
+        return false unless info.has_key?(:locked)
+        info[:locked].all_locked
+      end
+
+      # Is the layer position locked?
+      def position_locked?
+        return false unless info.has_key?(:locked)
+        info[:locked].position_locked
+      end
+
+      # Is the layer composite locked?
+      def composite_locked?
+        return false unless info.has_key?(:locked)
+        info[:locked].composite_locked
+      end
+
+      # Is the layer transparency locked?
+      def transparency_locked?
+        return false unless info.has_key?(:locked)
+        info[:locked].transparency_locked
+      end
+
+      # Is this layer visible?
+      def visible?
+        @visible
+      end
+
+      # Is this layer hidden?
+      def hidden?
+        !@visible
+      end
+
+      # Helper that exports the text data in this layer, if any.
+      def text
+        return nil unless info[:type]
+        info[:type].to_hash
+      end
+
+      def layer_type
+        return 'normal' unless info.has_key?(:section_divider)
+        info[:section_divider].layer_type
+      end
+
+      def fill_opacity
+        return 255 unless info.has_key?(:fill_opacity)
+        info[:fill_opacity].value
+      end
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/layer/info.rb

@@ -0,0 +1,74 @@
+class PSD
+  class Layer
+    module Info
+      # All of the extra layer info sections that we know how to parse.
+      LAYER_INFO = {
+        blend_clipping_elements: BlendClippingElements,
+        blend_interior_elements: BlendInteriorElements,
+        type: TypeTool,
+        legacy_type: LegacyTypeTool,
+        metadata: MetadataSetting,
+        layer_name_source: LayerNameSource,
+        object_effects: ObjectEffects,
+        name: UnicodeName,
+        section_divider: LayerSectionDivider,
+        nested_section_divider: NestedLayerDivider,
+        reference_point: ReferencePoint,
+        layer_id: LayerID,
+        fill_opacity: FillOpacity,
+        placed_layer: PlacedLayer,
+        locked: Locked,
+        vector_mask: VectorMask,
+        vector_mask_2: VectorMask2,
+        vector_stroke: VectorStroke,
+        vector_stroke_content: VectorStrokeContent
+      }
+
+      attr_reader :adjustments
+      alias :info :adjustments
+
+      private
+
+      # This section is a bit tricky to parse because it represents all of the
+      # extra data that describes this layer.
+      def parse_layer_info
+        @extra_data_begin = @file.tell
+
+        while @file.tell < @layer_end
+          # Signature, don't need
+          @file.seek 4, IO::SEEK_CUR
+
+          # Key, very important
+          key = @file.read_string(4)
+          @info_keys << key
+
+          length = Util.pad2 @file.read_int
+          pos = @file.tell
+
+          key_parseable = false
+          LAYER_INFO.each do |name, info|
+            next unless info.key == key
+
+            PSD.logger.debug "Layer Info: key = #{key}, start = #{pos}, length = #{length}"
+
+            i = info.new(self, length)
+            @adjustments[name] = LazyExecute.new(i, @file).now(:skip).later(:parse)
+              
+            key_parseable = true and break
+          end
+
+          unless key_parseable
+            PSD.logger.debug "Skipping unknown layer info block: key = #{key}, length = #{length}"
+            @file.seek length, IO::SEEK_CUR
+          end
+        end
+
+        @extra_data_end = @file.tell
+      end
+
+      def vector_mask
+        info[:vector_mask_2] || info[:vector_mask]
+      end
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/layer/mask.rb

@@ -0,0 +1,19 @@
+class PSD
+  class Layer
+    module Mask
+      attr_reader :mask
+      
+      private
+
+      def parse_mask_data
+        @mask_begin = @file.tell
+        @mask = PSD::Mask.read(@file)
+        @mask_end = @file.tell
+      end
+
+      def export_mask_data(outfile)
+        outfile.write @file.read(@mask_end - @mask_begin + 4)
+      end
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/layer/name.rb

@@ -0,0 +1,33 @@
+class PSD
+  class Layer
+    module Name
+      # Gets the name of this layer. If the PSD file is from an even remotely
+      # recent version of Photoshop, this data is stored as extra layer info and
+      # as a UTF-16 name. Otherwise, it's stored in a legacy block.
+      def name
+        if @adjustments.has_key?(:name)
+          return @adjustments[:name].data
+        end
+
+        return @legacy_name
+      end
+
+      private
+
+      # The old school layer names are encoded in MacRoman format,
+      # not UTF-8. Luckily Ruby kicks ass at character conversion.
+      def parse_legacy_layer_name
+        @legacy_name_start = @file.tell
+
+        len = Util.pad4 @file.read(1).bytes.to_a[0]
+        @legacy_name = @file.read_string(len)
+
+        @legacy_name_end = @file.tell
+      end
+
+      def export_legacy_layer_name(outfile)
+        outfile.write @file.read(@legacy_name_end - @legacy_name_start)
+      end
+    end
+  end
+end