rmagick4j 0.3.4-java → 0.3.9-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f9fe85a77a4fd7dbca1d624dc8bcb95da616a9a8
+  data.tar.gz: afe8cb688221536949ff56d56ba3e6431dbc9e61
+SHA512:
+  metadata.gz: 7181ab773dd7a4faf83bdbe39c9f80339a153aaa15329c765a83ca824fc4658b82fae6c8f00f289ee5a0d42cea27e07af1a9c094b8c9ff8a18f2c7997ffc23f3
+  data.tar.gz: c450e9072b1df82bc954cb6b80a60e60be0751760a075b44f2c566881c3f7ac00fcebad868b9b80938a797ffc38f5d1257f203241c0e1f9acc6357dbca2e842a

data/History.txt

@@ -0,0 +1,84 @@
+== 0.3.5
+
+- Implemented Draw primitives (affice, arc, pattern, path)
+
+- Improved Image and ImageList:
+  - crop ( http://www.imagemagick.org/RMagick/doc/image1.html#crop )
+  - rotate ( http://www.imagemagick.org/RMagick/doc/image3.html#rotate )
+  - store_pixels (http://www.imagemagick.org/RMagick/doc/image3.html#store_pixels )
+  - flatten_images (http://www.imagemagick.org/RMagick/doc/ilist.html#flatten_images )
+
+- Implemented more of Pixel (from_HSL, to_HSL, <=>, cmp, intensity)
+
+- Implemented the fill classes (http://www.imagemagick.org/RMagick/doc/struct.html#fill )
+
+- Added a side-by-side (MRI vs JRuby) image testing tool named Bullseye
+
+- Added 680 color names. It can search, but not retrieve the name correctly capitalized.
+
+== 0.3.4
+
+- No bugfixes nor new features, just added compatibility with JRuby 1.1. 
+
+== 0.3.3
+
+- This is a bug fix release to support updates to the string byte array conversion changes in recent versions of JRuby. This release was tested against JRuby 1.0.0RC3. 
+
+== 0.3.2 
+
+Full RMagick required for RMagick4J is included. The gem also includes JH Labs Filters and SVG Salamander, but they aren't much used yet.
+
+Use it like so for now:
+
+require 'rubygems'
+gem PLATFORM == 'java' ? 'rmagick4j' : 'rmagick'
+require 'RMagick'
+
+Also see the project home page at http://code.google.com/p/rmagick4j/
+
+== 0.3.1
+
+Functionally equivalent to 0.3 release, but it supports JRuby 0.9.8 now. Also, it's a gem. It works along with a standard rmagick gem already installed (for those who keep gems in one place for multiple Ruby installs). For instance, I've tested this as working under both ruby and jruby:
+
+require 'rubygems'
+gem 'rmagick4j'
+gem 'rmagick'
+require 'gruff'
+
+I hope to release a full rmagick gem in the near future for those who want to use apps unchanged and have a local GEM_HOME just for jruby.
+
+== 0.3.0 
+
+More complete Draw features. Supports most Gruff Graphs unit tests. 
+
+== 0.2
+
+More I/O support including basic handling of write, to_blob, and from_blob. Also upgraded RMagick libs to 1.14.0 and bundled JRuby to 0.9.1. Also reorganized the directory layout better. Moved JRuby files to its own folder. Moved draw support into magickjr package. 
+
+== 0.1
+
+Hello,
+
+I've tagged an "m1" release of RMagickJr. Here are the main good things to say about it:
+
+- At varying degrees of quality and hackishness, it runs all these samples: http://rmagick.rubyforge.org/portfolio.html
+- The build.xml works and by default shows a sample picture.
+
+Put together, this means that other people might be able to run it, and they might be able to put it to some simple use. Well, except that it doesn't support real data export yet. It just displays pictures.
+
+Here are some bad things to say about it:
+
+- I've tested only on a Mac so far.
+- Some things are super hacks, and some implementation is super shallow.
+- Some of the pictures don't look quite right.
+- Fixing some of what's off (especially the convolution/blurring) will be nontrivial for me.
+- Some project organization is less than ideal. Still need to understand RubyGems, extensions/ext concepts, and rake better.
+- Not much attention paid to super performance.
+- My progress is slow, but that was expected.
+- Probably a lot more.
+
+But it's still progress, and I'm actually reading the pick axe (v2 - I'd looked at v1 online a few years ago), so maybe I'll start grokking the Ruby world better soon.
+
+Maybe by m2 or m3 (or sometime), I could try to find a real app using RMagick and try to make it work with my version. For the next moment, though, I'll probably try tackling page 2 or 3 of the "portfolio" samples at the RMagick web site. And eventually go into class by class and method by method depth. Or something. I'm just trying to work with tracer bullets for now.
+
+And I might rename the project to "rmagick4j" or "rmagick-jruby" or something at some point. Not sure what's best, so I'm sticking with "jr" for now. And that's an accurate representation for now, anyway.

data/LICENSE.txt

@@ -0,0 +1,31 @@
+The file observer.rb comes from JRuby's distribution of standard Ruby libraries. The file jruby.jar also comes from the JRuby project.
+
+RMagick.rb, clown.jpg, most of rmagick.gemspec, and the contents of rvg come from the RMagick project. Much of the content of the test demos (currently in "RMagickTestSuite.rb") come from the RMagick web site.
+
+See these respective projects for the licenses and ownership of these files.
+
+Other files lies under MIT license.
+
+Copyright (c) 2010 Tom Palmer, Sergio Arbeo, Patrick Hurley, Karl Palmskog
+
+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.

data/README.txt

@@ -0,0 +1,25 @@
+RMagick is a Ruby binding to ImageMagick and GraphicsMagick. RMagick4J implements ImageMagick functionality and the C portions of RMagick for use with JRuby. 
+
+== Authors
+
+This project was written by Thomas Palmer, Sergio Rodríguez Arbeo, and Thomas Enebo with lots of help from the JRuby community.
+
+== License
+
+The file observer.rb comes from JRuby's distribution of standard Ruby libraries. The file jruby.jar also comes from the JRuby project.
+
+RMagick.rb, clown.jpg, most of rmagick.gemspec, and the contents of rvg come from the RMagick project. Much of the content of the test demos (currently in "RMagickTestSuite.rb") come from the RMagick web site.
+
+See these respective projects for the licenses and ownership of these files.
+
+Other files in RMagickJr are hereby placed in the public domain.
+
+== Creating
+
+To create a gem you should run rake.  The useful targets are :clean, :compile, :gem, :release, :test (hoe has more -- see hoe docs).  In order to run rake you must have hoe installed.
+
+To create a new release, you should:
+
+* Add new version entry to History.txt
+* Update lib/rmagick4j/version.rb to contain new version
+* rake release VERSION={{{{YOUR NEW VERSION (e.g. 1.1.1)}}}}

data/Rakefile

@@ -0,0 +1,65 @@
+require 'rake'
+require 'rake/testtask'
+require 'bundler/gem_tasks'
+
+task :default => [:test, :gruff_test, :gem]
+task :gem => :build
+
+jar_file = File.join(%w(lib magick4j.jar))
+
+desc 'Clean up any generated file.'
+task :clean do
+  rm_rf 'pkg'
+end
+
+desc 'Run gruff unit tests.'
+task :gruff_test do
+  FileList['test/gruff_tests/test/test_*.rb'].each do |file|
+    puts `ruby #{file}`
+    puts ''
+  end
+end
+
+desc 'Run a live sample using RMagick4j.'
+task :sample do
+  load_paths = '-Ijruby -Ilib -Ipkg'
+  sh "java #{classpath(jar_file)} org.jruby.Main #{load_paths} test/RMagickTestSuite.rb addWatermark"
+end
+
+task :spec do
+  require 'spec/rake/spectask'
+  desc 'Runs Java Integration Specs'
+  
+  Spec::Rake::SpecTask.new do |t|
+    t.spec_opts ||= []
+    t.spec_files =  if ENV['class'].nil?
+                      FileList['test/spec/**']
+                    else
+                      File.join('test', 'spec', ENV['class']+'_spec.rb')
+                    end
+  end
+
+end
+
+task :stories do
+  if ENV['file'].nil?
+    FileList['test/spec/stories/**/*_runner.rb'].each do |runner|
+      require runner
+    end
+  else
+    require File.join('test', 'spec', 'stories', ENV['file']+'_runner.rb')
+  end
+end
+
+%w(package install_gem debug_gem).each { |t| task t => :compile }
+
+# helper methods below
+
+def classpath(extra_jars=nil)
+  jruby_cpath = Java::java.lang.System.getProperty 'java.class.path'
+  path = jruby_cpath ? jruby_cpath.split(File::PATH_SEPARATOR) : []
+  path << FileList['lib/*.jar']
+  path << extra_jars.split(File::PATH_SEPARATOR) if extra_jars
+  "-cp #{path.flatten.join(File::PATH_SEPARATOR)}"
+end
+

data/lib/{RMagick.rb → rmagick.rb}

@@ -1,15 +1,15 @@
-# $Id: RMagick.rb,v 1.51 2007/01/20 23:13:50 rmagick Exp $
+# $Id: RMagick.rb,v 1.80 2009/01/02 21:08:14 rmagick Exp $
 #==============================================================================
-#                  Copyright (C) 2007 by Timothy P. Hunter
+#                  Copyright (C) 2008 by Timothy P. Hunter
 #   Name:       RMagick.rb
 #   Author:     Tim Hunter
 #   Purpose:    Extend Ruby to interface with ImageMagick.
-#   Notes:      RMagick.so defines the classes. The code below adds methods
+#   Notes:      RMagick2.so defines the classes. The code below adds methods
 #               to the classes.
 #==============================================================================
 
-#require 'RMagick.so'
-require "rmagick4j/rmagick4j"
+require File.join(File.dirname(__FILE__), 'rmagick4j', 'rmagick4j.rb')
+
 module Magick
     @@formats = nil
 
@@ -23,79 +23,106 @@ def Magick.formats(&block)
     end
 end
 
+class << self
+    attr_writer :trace_proc
+end
 
 # Geometry class and related enum constants
 class GeometryValue < Enum
     # no methods
 end
 
-PercentGeometry  = GeometryValue.new(:PercentGeometry, 1)
-AspectGeometry   = GeometryValue.new(:AspectGeometry, 2)
-LessGeometry     = GeometryValue.new(:LessGeometry, 3)
-GreaterGeometry  = GeometryValue.new(:GreaterGeometry, 4)
-AreaGeometry     = GeometryValue.new(:AreaGeometry, 5)
+PercentGeometry  = GeometryValue.new(:PercentGeometry, 1).freeze
+AspectGeometry   = GeometryValue.new(:AspectGeometry, 2).freeze
+LessGeometry     = GeometryValue.new(:LessGeometry, 3).freeze
+GreaterGeometry  = GeometryValue.new(:GreaterGeometry, 4).freeze
+AreaGeometry     = GeometryValue.new(:AreaGeometry, 5).freeze
+MinimumGeometry  = GeometryValue.new(:MinimumGeometry, 6).freeze
 
 class Geometry
-    FLAGS = ['', '%', '!', '<', '>', '@']
+    FLAGS = ['', '%', '!', '<', '>', '@', '^']
     RFLAGS = { '%' => PercentGeometry,
                '!' => AspectGeometry,
                '<' => LessGeometry,
                '>' => GreaterGeometry,
-               '@' => AreaGeometry }
+               '@' => AreaGeometry,
+               '^' => MinimumGeometry }
 
     attr_accessor :width, :height, :x, :y, :flag
 
     def initialize(width=nil, height=nil, x=nil, y=nil, flag=nil)
+        raise(ArgumentError, "width set to #{width.to_s}") if width.is_a? GeometryValue
+        raise(ArgumentError, "height set to #{height.to_s}") if height.is_a? GeometryValue
+        raise(ArgumentError, "x set to #{x.to_s}") if x.is_a? GeometryValue
+        raise(ArgumentError, "y set to #{y.to_s}") if y.is_a? GeometryValue
 
         # Support floating-point width and height arguments so Geometry
         # objects can be used to specify Image#density= arguments.
-        if width == nil
-            @width = 0
-        elsif width.to_f >= 0.0
-            @width = width.to_f
-        else
-            Kernel.raise ArgumentError, "width must be >= 0: #{width}"
+        if width && width.to_f >= 0.0
+          @width = width.to_f
+        elsif width
+          Kernel.raise ArgumentError, "width must be >= 0: #{width}"
         end
-        if height == nil
-            @height = 0
-        elsif height.to_f >= 0.0
-            @height = height.to_f
-        else
-            Kernel.raise ArgumentError, "height must be >= 0: #{height}"
+
+        if height && height.to_f >= 0.0
+          @height = height.to_f
+        elsif height
+          Kernel.raise ArgumentError, "height must be >= 0: #{height}"
         end
 
         @x    = x.to_i
         @y    = y.to_i
         @flag = flag
+
     end
 
     # Construct an object from a geometry string
-    RE = /\A(\d*)(?:x(\d+))?([-+]\d+)?([-+]\d+)?([%!<>@]?)\Z/
+    W = /(\d+\.\d+%?)|(\d*%?)/
+    H = W
+    X = /(?:([-+]\d+))?/
+    Y = X
+    RE = /\A#{W}x?#{H}#{X}#{Y}([!<>@\^]?)\Z/
 
     def Geometry.from_s(str)
-        Kernel.raise(ArgumentError, "no geometry string specified") unless str
-
         m = RE.match(str)
         if m
-            width  = m[1].to_i
-            height = m[2].to_i
-            x      = m[3].to_i
-            y      = m[4].to_i
-            flag   = RFLAGS[m[5]]
+            width  = m[1].nil? && m[2].empty? ? nil : (m[1] || m[2]).to_f
+            height = m[3].nil? && m[4].empty? ? nil : (m[3] || m[4]).to_f
+            x      = m[5].to_i
+            y      = m[6].to_i
+            flag   = RFLAGS[m[7]]
         else
             Kernel.raise ArgumentError, "invalid geometry format"
         end
+        if str['%']
+          flag = PercentGeometry
+        end
         Geometry.new(width, height, x, y, flag)
     end
 
     # Convert object to a geometry string
     def to_s
         str = ''
-        str << sprintf("%g", @width) if @width > 0
-        str << 'x' if (@width > 0 || @height > 0)
-        str << sprintf("%g", @height) if @height > 0
+        if @width && @width > 0
+          fmt = @width.truncate == @width ? "%d" : "%.2f"
+          str << sprintf(fmt, @width)
+          str << '%' if @flag == PercentGeometry
+        end
+
+        if (@width && @width > 0 && @flag != PercentGeometry) || (@height && @height > 0)
+          str << 'x'
+        end
+
+        if @height && @height > 0
+          fmt = @height.truncate == @height ? "%d" : "%.2f"
+          str << sprintf(fmt, @height)
+          str << '%' if @flag == PercentGeometry
+        end
         str << sprintf("%+d%+d", @x, @y) if (@x != 0 || @y != 0)
-        str << FLAGS[@flag.to_i]
+        if @flag != PercentGeometry
+          str << FLAGS[@flag.to_i]
+        end
+        str
     end
 end
 
@@ -250,7 +277,7 @@ class Draw
     def define_clip_path(name)
         begin
             push('defs')
-            push('clip-path ', name)
+            push('clip-path', name)
             push('graphic-context')
             yield
         ensure
@@ -333,6 +360,30 @@ class Draw
         primitive "gravity #{GRAVITY_NAMES[grav.to_i]}"
     end
 
+    # IM 6.4.8-3 and later
+    def interword_spacing(space)
+        begin
+            Float(space)
+        rescue ArgumentError
+            Kernel.raise ArgumentError, "invalid value for interword_spacing"
+        rescue TypeError
+            Kernel.raise TypeError, "can't convert #{space.class} into Float"
+        end
+        primitive "interword-spacing #{space}"
+    end
+
+    # IM 6.4.8-3 and later
+    def kerning(space)
+        begin
+            Float(space)
+        rescue ArgumentError
+            Kernel.raise ArgumentError, "invalid value for kerning"
+        rescue TypeError
+            Kernel.raise TypeError, "can't convert #{space.class} into Float"
+        end
+        primitive "kerning #{space}"
+    end
+
     # Draw a line
     def line(startX, startY, endX, endY)
         primitive "line " + sprintf("%g,%g %g,%g", startX, startY, endX, endY)
@@ -424,7 +475,7 @@ class Draw
             primitive "pop graphic-context"
         else
             # to_s allows a Symbol to be used instead of a String
-            primitive "pop " + what.to_s
+            primitive "pop " + what.map {|w| w.to_s}.join(' ')
         end
     end
 
@@ -438,7 +489,7 @@ class Draw
             primitive "push graphic-context"
         else
             # to_s allows a Symbol to be used instead of a String
-            primitive "push " + what.to_s
+            primitive "push " + what.map {|w| w.to_s}.join(' ')
         end
     end
 
@@ -612,7 +663,7 @@ module IPTC
     end
 
     module Application
-       #Record_Version                         = "2:00" abends with IM 6.2.9
+        Record_Version                         = "2:00"
         Object_Type_Reference                  = "2:03"
         Object_Name                            = "2:05"
         Title                                  = "2:05"
@@ -703,9 +754,12 @@ end # module Magick::IPTC
 class Image
     include Comparable
 
+    alias_method :affinity, :remap
+
     # Provide an alternate version of Draw#annotate, for folks who
     # want to find it in this class.
     def annotate(draw, width, height, x, y, text, &block)
+      check_destroyed
       draw.annotate(self, width, height, x, y, text, &block)
       self
     end
@@ -746,26 +800,19 @@ class Image
         self
     end
 
-    # Force an image to exact dimensions without changing the aspect ratio.
-    # Resize and crop if necessary. (Thanks to Jerett Taylor!)
-    def crop_resized(ncols, nrows, gravity=CenterGravity)
-        copy.crop_resized!(ncols, nrows, gravity)
-    end
-
-    def crop_resized!(ncols, nrows, gravity=CenterGravity)
-        if ncols != columns || nrows != rows
-            scale = [ncols/columns.to_f, nrows/rows.to_f].max
-            resize!(scale*columns+0.5, scale*rows+0.5)
-        end
-        crop!(gravity, ncols, nrows, true) if ncols != columns || nrows != rows
-        self
-    end
-
     # Used by ImageList methods - see ImageList#cur_image
     def cur_image
         self
     end
 
+    # Thanks to Russell Norris!
+    def each_pixel
+      get_pixels(0, 0, columns, rows).each_with_index do |p, n|
+        yield(p, n%columns, n/columns)
+      end
+      self
+    end
+
     # Retrieve EXIF data by entry or all. If one or more entry names specified,
     # return the values associated with the entries. If no entries specified,
     # return all entries and values. The return value is an array of [name,value]
@@ -778,6 +825,7 @@ class Image
                 exif_data.split("\n").each { |exif| ary.push(exif.split('=')) }
             end
         else
+            get_exif_by_entry()     # ensure properties is populated with exif data
             entry.each do |name|
                 rval = self["EXIF:#{name}"]
                 ary.push([name, rval])
@@ -799,8 +847,9 @@ class Image
                 end
             end
         else
+            get_exif_by_number()    # ensure properties is populated with exif data
             tag.each do |num|
-                rval = self["EXIF:#{'#%04X' % num}"]
+                rval = self['#%04X' % num.to_i]
                 hash[num] = rval == 'unknown' ? nil : rval
             end
         end
@@ -841,7 +890,7 @@ class Image
     def level(black_point=0.0, white_point=nil, gamma=nil)
         black_point = Float(black_point)
 
-        white_point ||= Magick::MaxRGB - black_point
+        white_point ||= Magick::QuantumRange - black_point
         white_point = Float(white_point)
 
         gamma_arg = gamma
@@ -851,7 +900,7 @@ class Image
         if gamma.abs > 10.0 || white_point.abs <= 10.0 || white_point.abs < gamma.abs
             gamma, white_point = white_point, gamma
             unless gamma_arg
-                white_point = Magick::MaxRGB - black_point
+                white_point = Magick::QuantumRange - black_point
             end
         end
 
@@ -915,15 +964,37 @@ class Image
         resize(width, height)
     end
 
+    # Force an image to exact dimensions without changing the aspect ratio.
+    # Resize and crop if necessary. (Thanks to Jerett Taylor!)
+    def resize_to_fill(ncols, nrows=nil, gravity=CenterGravity)
+        copy.resize_to_fill!(ncols, nrows, gravity)
+    end
+
+    def resize_to_fill!(ncols, nrows=nil, gravity=CenterGravity)
+        nrows ||= ncols
+        if ncols != columns || nrows != rows
+            scale = [ncols/columns.to_f, nrows/rows.to_f].max
+            resize!(scale*columns+0.5, scale*rows+0.5)
+        end
+        crop!(gravity, ncols, nrows, true) if ncols != columns || nrows != rows
+        self
+    end
+
+    # Preserve aliases used < RMagick 2.0.1
+    alias_method :crop_resized, :resize_to_fill
+    alias_method :crop_resized!, :resize_to_fill!
+
     # Convenience method to resize retaining the aspect ratio.
     # (Thanks to Robert Manni!)
-    def resize_to_fit(cols, rows)
+    def resize_to_fit(cols, rows=nil)
+        rows ||= cols
         change_geometry(Geometry.new(cols, rows)) do |ncols, nrows|
             resize(ncols, nrows)
         end
     end
 
-    def resize_to_fit!(cols, rows)
+    def resize_to_fit!(cols, rows=nil)
+        rows ||= cols
         change_geometry(Geometry.new(cols, rows)) do |ncols, nrows|
             resize!(ncols, nrows)
         end
@@ -963,6 +1034,7 @@ class Image
         attr_accessor :dirty
 
         def initialize(img, x, y, width, height)
+            img.check_destroyed
             if width <= 0 || height <= 0
                 Kernel.raise ArgumentError, "invalid geometry (#{width}x#{height}+#{x}+#{y})"
             end
@@ -1194,24 +1266,21 @@ class Image
 
 end # class Magick::Image
 
-class ImageList < Array
+class ImageList
 
     include Comparable
+    include Enumerable
+    attr_reader :scene
 
-    undef_method :assoc
-    undef_method :flatten!      # These methods are undefined
-    undef_method :flatten       # because they're not useful
-    undef_method :join          # for an ImageList object
-    undef_method :pack
-    undef_method :rassoc
-    undef_method :transpose if Array.instance_methods(false).include? 'transpose'
-    undef_method :zip if Array.instance_methods(false).include? 'zip'
+private
 
-    attr_reader :scene
+    def get_current()
+        return @images[@scene].__id__ rescue nil
+    end
 
 protected
 
-    def is_a_image(obj)
+    def is_an_image(obj)
         unless obj.kind_of? Magick::Image
             Kernel.raise ArgumentError, "Magick::Image required (#{obj.class} given)"
         end
@@ -1219,33 +1288,36 @@ protected
     end
 
     # Ensure array is always an array of Magick::Image objects
-    def is_a_image_array(ary)
+    def is_an_image_array(ary)
         unless ary.respond_to? :each
             Kernel.raise ArgumentError, "Magick::ImageList or array of Magick::Images required (#{ary.class} given)"
         end
-        ary.each { |obj| is_a_image obj }
+        ary.each { |obj| is_an_image obj }
         true
     end
 
-    # Find old current image, update @scene
-    # cfid is the id of the old current image.
-    def set_cf(cfid)
-        if length == 0
-            @scene = nil
+    # Find old current image, update scene number
+    # current is the id of the old current image.
+    def set_current(current)
+        if length() == 0
+            self.scene = nil
             return
         # Don't bother looking for current image
-        elsif @scene == nil || @scene >= length
-            @scene = length - 1
+        elsif scene() == nil || scene() >= length()
+            self.scene = length() - 1
             return
-        elsif cfid != nil
+        elsif current != nil
+            # Find last instance of "current" in the list.
+            # If "current" isn't in the list, set current to last image.
+            self.scene = length() - 1
             each_with_index do |f,i|
-                if f.__id__ == cfid
-                    @scene = i
-                    return
+                if f.__id__ == current
+                    self.scene = i
                 end
             end
+            return
         end
-        @scene = length - 1
+        self.scene = length() - 1
     end
 
 public
@@ -1253,10 +1325,10 @@ public
     # Allow scene to be set to nil
     def scene=(n)
         if n.nil?
-            Kernel.raise IndexError, "scene number out of bounds" unless length == 0
+            Kernel.raise IndexError, "scene number out of bounds" unless @images.length == 0
             @scene = nil
             return @scene
-        elsif length == 0
+        elsif @images.length == 0
             Kernel.raise IndexError, "scene number out of bounds"
         end
 
@@ -1268,307 +1340,46 @@ public
         return @scene
     end
 
-    def [](*args)
-        if (args.length > 1) || args[0].kind_of?(Range)
-            self.class.new.replace super
-        else
-            super
-        end
-    end
-
-    def []=(*args)
-        if args.length == 3             # f[start,length] = [f1,f2...]
-            args[2].kind_of?(Magick::Image) || is_a_image_array(args[2])
-            super
-            args[0] = args[0] + length if (args[0] < 0)
-            args[1] = length - args[0] if (args[0] + args[1] > length)
-            if args[2].kind_of?(Magick::Image)
-                @scene = args[0]
-            else
-                @scene = args[0] + args[2].length - 1
+    # All the binary operators work the same way.
+    # 'other' should be either an ImageList or an Array
+    %w{& + - |}.each do |op|
+        module_eval <<-END_BINOPS
+            def #{op}(other)
+                ilist = self.class.new
+                begin
+                    a = other #{op} @images
+                rescue TypeError
+                    Kernel.raise ArgumentError, "Magick::ImageList expected, got " + other.class.to_s
+                end
+                current = get_current()
+                a.each do |image|
+                    is_an_image image
+                    ilist << image
+                end
+                ilist.set_current current
+                return ilist
             end
-        elsif args[0].kind_of? Range    # f[first..last] = [f1,f2...]
-            args[1].kind_of?(Magick::Image) || is_a_image_array(args[1])
-            super
-            @scene = args[0].end
-        else                            # f[index] = f1
-            is_a_image args[1]
-            super                       # index can be negative
-            @scene = args[0] < 0 ? length + args[0] : args[0]
-        end
-        args.last                       # return value is always assigned value
-    end
-
-    def &(other)
-        is_a_image_array other
-        cfid = self[@scene].__id__ rescue nil
-        a = self.class.new.replace super
-        a.set_cf cfid
-        return a
+        END_BINOPS
     end
 
     def *(n)
         unless n.kind_of? Integer
             Kernel.raise ArgumentError, "Integer required (#{n.class} given)"
         end
-        cfid = self[@scene].__id__ rescue nil
-        a = self.class.new.replace super
-        a.set_cf cfid
-        return a
-    end
-
-    def +(other)
-        cfid = self[@scene].__id__ rescue nil
-        a = self.class.new.replace super
-        a.set_cf cfid
-        return a
-    end
-
-    def -(other)
-        is_a_image_array other
-        cfid = self[@scene].__id__ rescue nil
-        a = self.class.new.replace super
-        a.set_cf cfid
-        return a
+        current = get_current()
+        ilist = self.class.new
+        (@images * n).each {|image| ilist << image}
+        ilist.set_current current
+        return ilist
     end
 
     def <<(obj)
-        is_a_image obj
-        a = super
-        @scene = length-1
-        return a
-    end
-
-    def |(other)
-        is_a_image_array other
-        cfid = self[@scene].__id__ rescue nil
-        a = self.class.new.replace super
-        a.set_cf cfid
-        return a
-    end
-
-    def clear
-        @scene = nil
-        super
-    end
-
-    def collect(&block)
-        cfid = self[@scene].__id__ rescue nil
-        a = self.class.new.replace super
-        a.set_cf cfid
-        return a
-    end
-
-    def collect!(&block)
-        super
-        is_a_image_array self
+        is_an_image obj
+        @images << obj
+        @scene = @images.length - 1
         self
     end
 
-    def compact
-        cfid = self[@scene].__id__ rescue nil
-        a = self.class.new.replace super
-        a.set_cf cfid
-        return a
-    end
-
-    def compact!
-        cfid = self[@scene].__id__ rescue nil
-        a = super          # returns nil if no changes were made
-        set_cf cfid
-        return a
-    end
-
-    def concat(other)
-        is_a_image_array other
-        a = super
-        @scene = length-1
-        return a
-    end
-
-    def delete(obj, &block)
-        is_a_image obj
-        cfid = self[@scene].__id__ rescue nil
-        a = super
-        set_cf cfid
-        return a
-    end
-
-    def delete_at(ndx)
-        cfid = self[@scene].__id__ rescue nil
-        a = super
-        set_cf cfid
-        return a
-    end
-
-    def delete_if(&block)
-        cfid = self[@scene].__id__ rescue nil
-        a = super
-        set_cf cfid
-        return a
-    end
-
-    def fill(*args, &block)
-        is_a_image args[0] unless block_given?
-        cfid = self[@scene].__id__ rescue nil
-        super
-        is_a_image_array self
-        set_cf cfid
-        return self
-    end
-
-    def find_all(&block)
-        cfid = self[@scene].__id__ rescue nil
-        a = super
-        a.set_cf cfid
-        return a
-    end
-
-    if self.superclass.instance_methods(true).include? 'insert' then
-        def insert(*args)
-            Kernel.raise(ArgumentError, "can't insert nil") unless args.length > 1
-            is_a_image_array args[1,args.length-1]
-            cfid = self[@scene].__id__ rescue nil
-            super
-            set_cf cfid
-            return self
-        end
-    end
-
-    # Enumerable (or Array) has a #map method that conflicts with our
-    # own #map method. RMagick.so has defined a synonym for that #map
-    # called Array#__ary_map__. Here, we define Magick::ImageList#__map__
-    # to allow the use of the Enumerable/Array#map method on ImageList objects.
-    def __map__(&block)
-        cfid = self[@scene].__id__ rescue nil
-        ensure_image = Proc.new do |img|
-            rv = block.call(img)
-            is_a_image rv
-            return rv
-        end
-        a = self.class.new.replace __ary_map__(&ensure_image)
-        a.set_cf cfid
-        return a
-    end
-
-    def map!(&block)
-        ensure_image = Proc.new do |img|
-            rv = block.call(img)
-            is_a_image rv
-            return rv
-        end
-        super(&ensure_image)
-    end
-
-    def pop
-        cfid = self[@scene].__id__ rescue nil
-        a = super       # can return nil
-        set_cf cfid
-        return a
-    end
-
-    def push(*objs)
-        objs.each { |o| is_a_image o }
-        super
-        @scene = length - 1
-        self
-    end
-
-    def reject(&block)
-        cfid = self[@scene].__id__ rescue nil
-        a = self.class.new.replace super
-        a.set_cf cfid
-        return a
-    end
-
-    def reject!(&block)
-        cfid = self[@scene].__id__ rescue nil
-        a = super       # can return nil
-        set_cf cfid
-        return a
-    end
-
-    def replace(other)
-        is_a_image_array other
-        # Since replace gets called so frequently when @scene == nil
-        # test for it instead of letting rescue catch it.
-        cfid = nil
-        if @scene then
-            cfid = self[@scene].__id__ rescue nil
-        end
-        super
-        # set_cf will fail if the new list has fewer images
-        # than the scene number indicates.
-        @scene = self.length == 0 ? nil : 0
-        set_cf cfid
-        self
-    end
-
-    def reverse
-        cfid = self[@scene].__id__ rescue nil
-        a = self.class.new.replace super
-        a.set_cf cfid
-        return a
-    end
-
-    def reverse!
-        cfid = self[@scene].__id__ rescue nil
-        a = super
-        set_cf cfid
-        return a
-    end
-
-    def select(&block)
-        cfid = self[@scene].__id__ rescue nil
-        a = self.class.new.replace super
-        a.set_cf cfid
-        return a
-    end
-
-    def shift
-        cfid = self[@scene].__id__ rescue nil
-        a = super
-        set_cf cfid
-        return a
-    end
-
-    def slice(*args)
-        self[*args]
-    end
-
-    def slice!(*args)
-        cfid = self[@scene].__id__ rescue nil
-        if args.length > 1 || args[0].kind_of?(Range)
-            a = self.class.new.replace super
-        else
-            a = super
-        end
-        set_cf cfid
-        return a
-    end
-
-    def uniq
-        cfid = self[@scene].__id__ rescue nil
-        a = self.class.new.replace super
-        a.set_cf cfid
-        return a
-    end
-
-    def uniq!(*args)
-        cfid = self[@scene].__id__ rescue nil
-        a = super
-        set_cf cfid
-        return a
-    end
-
-    # @scene -> new object
-    def unshift(obj)
-        is_a_image obj
-        a = super
-        @scene = 0
-        return a
-    end
-
     # Compare ImageLists
     # Compare each image in turn until the result of a comparison
     # is not 0. If all comparisons return 0, then
@@ -1595,16 +1406,78 @@ public
         return self.length <=> other.length
     end
 
+    def [](*args)
+        a = @images[*args]
+        if a.respond_to?(:each) then
+            ilist = self.class.new
+            a.each {|image| ilist << image}
+            a = ilist
+        end
+        return a
+    end
+
+    def []=(*args)
+        obj = @images.[]=(*args)
+        if obj && obj.respond_to?(:each) then
+            is_an_image_array(obj)
+            set_current obj.last.__id__
+        elsif obj
+            is_an_image(obj)
+            set_current obj.__id__
+        else
+            set_current nil
+        end
+        return obj
+    end
+
+    [:at, :each, :each_index, :empty?, :fetch,
+     :first, :hash, :include?, :index, :length, :rindex, :sort!].each do |mth|
+        module_eval <<-END_SIMPLE_DELEGATES
+            def #{mth}(*args, &block)
+                @images.#{mth}(*args, &block)
+            end
+        END_SIMPLE_DELEGATES
+    end
+    alias_method :size, :length
+
+    # Array#nitems is not available in 1.9
+    if Array.instance_methods.include?("nitems")
+       def nitems()
+          @images.nitems()
+       end
+    end
+
+    def clear
+        @scene = nil
+        @images.clear
+    end
+
     def clone
         ditto = dup
         ditto.freeze if frozen?
         return ditto
     end
 
+    # override Enumerable#collect
+    def collect(&block)
+        current = get_current()
+        a = @images.collect(&block)
+        ilist = self.class.new
+        a.each {|image| ilist << image}
+        ilist.set_current current
+        return ilist
+    end
+
+    def collect!(&block)
+        @images.collect!(&block)
+        is_an_image_array @images
+        self
+    end
+
     # Make a deep copy
     def copy
         ditto = self.class.new
-        each { |f| ditto << f.copy }
+        @images.each { |f| ditto << f.copy }
         ditto.scene = @scene
         ditto.taint if tainted?
         return ditto
@@ -1615,7 +1488,38 @@ public
         if ! @scene
             Kernel.raise IndexError, "no images in this list"
         end
-        self[@scene]
+        @images[@scene]
+    end
+
+    # ImageList#map took over the "map" name. Use alternatives.
+    alias_method :__map__, :collect
+    alias_method :map!, :collect!
+    alias_method :__map__!, :collect!
+
+    # ImageMagic used affinity in 6.4.3, switch to remap in 6.4.4.
+    alias_method :affinity, :remap
+
+    def compact
+        current = get_current()
+        ilist = self.class.new
+        a = @images.compact
+        a.each {|image| ilist << image}
+        ilist.set_current current
+        return ilist
+    end
+
+    def compact!
+        current = get_current()
+        a = @images.compact!    # returns nil if no changes were made
+        set_current current
+        return a.nil? ? nil : self
+    end
+
+    def concat(other)
+        is_an_image_array other
+        other.each {|image| @images << image}
+        @scene = length-1
+        return self
     end
 
     # Set same delay for all images
@@ -1623,40 +1527,87 @@ public
         if Integer(d) < 0
             raise ArgumentError, "delay must be greater than or equal to 0"
         end
-        each { |f| f.delay = Integer(d) }
+        @images.each { |f| f.delay = Integer(d) }
     end
 
-    def ticks_per_second=(t)
-        if Integer(t) < 0
-            Kernel.raise ArgumentError, "ticks_per_second must be greater than or equal to 0"
-        end
-        each { |f| f.ticks_per_second = Integer(t) }
+    def delete(obj, &block)
+        is_an_image obj
+        current = get_current()
+        a = @images.delete(obj, &block)
+        set_current current
+        return a
+    end
+
+    def delete_at(ndx)
+        current = get_current()
+        a = @images.delete_at(ndx)
+        set_current current
+        return a
+    end
+
+    def delete_if(&block)
+        current = get_current()
+        @images.delete_if(&block)
+        set_current current
+        self
     end
 
     def dup
         ditto = self.class.new
-        each {|img| ditto << img}
+        @images.each {|img| ditto << img}
         ditto.scene = @scene
         ditto.taint if tainted?
         return ditto
     end
 
+    def eql?(other)
+      is_an_image_array other
+      eql = other.eql?(@images)
+      begin # "other" is another ImageList
+        eql &&= @scene == other.scene
+      rescue NoMethodError
+        # "other" is a plain Array
+      end
+      return eql
+    end
+
+    def fill(*args, &block)
+        is_an_image args[0] unless block_given?
+        current = get_current()
+        @images.fill(*args, &block)
+        is_an_image_array self
+        set_current current
+        self
+    end
+
+    # Override Enumerable's find_all
+    def find_all(&block)
+        current = get_current()
+        a = @images.find_all(&block)
+        ilist = self.class.new
+        a.each {|image| ilist << image}
+        ilist.set_current current
+        return ilist
+    end
+    alias_method :select, :find_all
+
     def from_blob(*blobs, &block)
         if (blobs.length == 0)
             Kernel.raise ArgumentError, "no blobs given"
         end
         blobs.each { |b|
-            Magick::Image.from_blob(b, &block).each { |n| self << n  }
+            Magick::Image.from_blob(b, &block).each { |n| @images << n  }
             }
         @scene = length - 1
         self
     end
 
     # Initialize new instances
-    def initialize(*filenames)
+    def initialize(*filenames, &block)
+        @images = []
         @scene = nil
         filenames.each { |f|
-            Magick::Image.read(f).each { |n| self << n }
+            Magick::Image.read(f, &block).each { |n| @images << n }
             }
         if length > 0
             @scene = length - 1     # last image in array
@@ -1664,11 +1615,19 @@ public
         self
     end
 
+    def insert(index, *args)
+        args.each {|image| is_an_image image}
+        current = get_current()
+        @images.insert(index, *args)
+        set_current current
+        return self
+    end
+
     # Call inspect for all the images
     def inspect
-        ins = '['
-        each {|image| ins << image.inspect << "\n"}
-        ins.chomp("\n") + "]\nscene=#{@scene}"
+        img = []
+        @images.each {|image| img << image.inspect }
+        img = "[" + img.join(",\n") + "]\nscene=#{@scene}"
     end
 
     # Set the number of iterations of an animated GIF
@@ -1677,10 +1636,36 @@ public
         if n < 0 || n > 65535
             Kernel.raise ArgumentError, "iterations must be between 0 and 65535"
         end
-        each {|f| f.iterations=n}
+        @images.each {|f| f.iterations=n}
         self
     end
 
+    def last(*args)
+        if args.length == 0
+          a = @images.last
+        else
+          a = @images.last(*args)
+          ilist = self.class.new
+          a.each {|img| ilist << img}
+          @scene = a.length - 1
+          a = ilist
+        end
+        return a
+    end
+
+    # Custom marshal/unmarshal for Ruby 1.8.
+    def marshal_dump()
+       ary = [@scene]
+       @images.each {|i| ary << Marshal.dump(i)}
+       ary
+    end
+
+    def marshal_load(ary)
+       @scene = ary.shift
+       @images = []
+       ary.each {|a| @images << Marshal.load(a)}
+    end
+
     # The ImageList class supports the Magick::Image class methods by simply sending
     # the method to the current image. If the method isn't explicitly supported,
     # send it to the current image in the array. If there are no images, send
@@ -1688,7 +1673,7 @@ public
     def method_missing(methID, *args, &block)
         begin
             if @scene
-                self[@scene].send(methID, *args, &block)
+                @images[@scene].send(methID, *args, &block)
             else
                 super
             end
@@ -1700,47 +1685,230 @@ public
         end
     end
 
-    # Ensure respond_to? answers correctly when we are delegating to Image
-    alias_method :__respond_to__?, :respond_to?
-    def respond_to?(methID, priv=false)
-        return true if __respond_to__?(methID, priv)
-        if @scene
-            self[@scene].respond_to?(methID, priv)
-        else
-            super
-        end
-    end
-
     # Create a new image and add it to the end
     def new_image(cols, rows, *fill, &info_blk)
         self << Magick::Image.new(cols, rows, *fill, &info_blk)
     end
 
+    def partition(&block)
+      a = @images.partition(&block)
+      t = self.class.new
+      a[0].each { |img| t << img}
+      t.set_current nil
+      f = self.class.new
+      a[1].each { |img| f << img}
+      f.set_current nil
+      [t, f]
+    end
+
     # Ping files and concatenate the new images
     def ping(*files, &block)
         if (files.length == 0)
             Kernel.raise ArgumentError, "no files given"
         end
         files.each { |f|
-            Magick::Image.ping(f, &block).each { |n| self << n }
+            Magick::Image.ping(f, &block).each { |n| @images << n }
             }
         @scene = length - 1
         self
     end
 
+    def pop
+        current = get_current()
+        a = @images.pop       # can return nil
+        set_current current
+        return a
+    end
+
+    def push(*objs)
+        objs.each do |image|
+            is_an_image image
+            @images << image
+        end
+        @scene = length - 1
+        self
+    end
+
     # Read files and concatenate the new images
     def read(*files, &block)
         if (files.length == 0)
             Kernel.raise ArgumentError, "no files given"
         end
         files.each { |f|
-            Magick::Image.read(f, &block).each { |n| self << n }
+            Magick::Image.read(f, &block).each { |n| @images << n }
             }
         @scene = length - 1
         self
     end
+
+    # override Enumerable's reject
+    def reject(&block)
+        current = get_current()
+        ilist = self.class.new
+        a = @images.reject(&block)
+        a.each {|image| ilist << image}
+        ilist.set_current current
+        return ilist
+    end
+
+    def reject!(&block)
+        current = get_current()
+        a = @images.reject!(&block)
+        @images = a if !a.nil?
+        set_current current
+        return a.nil? ? nil : self
+    end
+
+    def replace(other)
+        is_an_image_array other
+        current = get_current()
+        @images.clear
+        other.each {|image| @images << image}
+        @scene = self.length == 0 ? nil : 0
+        set_current current
+        self
+    end
+
+    # Ensure respond_to? answers correctly when we are delegating to Image
+    alias_method :__respond_to__?, :respond_to?
+    def respond_to?(methID, priv=false)
+        return true if __respond_to__?(methID, priv)
+        if @scene
+            @images[@scene].respond_to?(methID, priv)
+        else
+            super
+        end
+    end
+
+    def reverse
+        current = get_current()
+        a = self.class.new
+        @images.reverse_each {|image| a << image}
+        a.set_current current
+        return a
+    end
+
+    def reverse!
+        current = get_current()
+        @images.reverse!
+        set_current current
+        self
+    end
+
+    def reverse_each
+        @images.reverse_each {|image| yield(image)}
+        self
+    end
+
+    def shift
+        current = get_current()
+        a = @images.shift
+        set_current current
+        return a
+    end
+
+    def slice(*args)
+        current = get_current()
+        slice = @images.slice(*args)
+        if slice
+            ilist = self.class.new
+            if slice.respond_to?(:each) then
+                slice.each {|image| ilist << image}
+            else
+                ilist << slice
+            end
+        else
+            ilist = nil
+        end
+        return ilist
+    end
+
+    def slice!(*args)
+        current = get_current()
+        a = @images.slice!(*args)
+        set_current current
+        return a
+    end
+
+    def ticks_per_second=(t)
+        if Integer(t) < 0
+            Kernel.raise ArgumentError, "ticks_per_second must be greater than or equal to 0"
+        end
+        @images.each { |f| f.ticks_per_second = Integer(t) }
+    end
+
+    def to_a
+        a = Array.new
+        @images.each {|image| a << image}
+        return a
+    end
+
+    def uniq
+        current = get_current()
+        a = self.class.new
+        @images.uniq.each {|image| a << image}
+        a.set_current current
+        return a
+    end
+
+    def uniq!(*args)
+        current = get_current()
+        a = @images.uniq!
+        set_current current
+        return a.nil? ? nil : self
+    end
+
+    # @scene -> new object
+    def unshift(obj)
+        is_an_image obj
+        @images.unshift(obj)
+        @scene = 0
+        self
+    end
+
+    def values_at(*args)
+        a = @images.values_at(*args)
+        a = self.class.new
+        @images.values_at(*args).each {|image| a << image}
+        a.scene = a.length - 1
+        return a
+    end
+    alias_method :indexes, :values_at
+    alias_method :indices, :values_at
+
 end # Magick::ImageList
 
+
+#  Collects non-specific optional method arguments
+class OptionalMethodArguments
+    def initialize(img)
+       @img = img
+    end
+
+    # miscellaneous options like -verbose
+    def method_missing(mth, val)
+       @img.define(mth.to_s.tr('_', '-'), val)
+    end
+
+    # set(key, val) corresponds to -set option:key val
+    def define(key, val = nil)
+       @img.define(key, val)
+    end
+
+    # accepts Pixel object or color name
+    def highlight_color=(color)
+       color = @img.to_color(color) if color.respond_to?(:to_color)
+       @img.define("highlight-color", color)
+    end
+
+    # accepts Pixel object or color name
+    def lowlight_color=(color)
+       color = @img.to_color(color) if color.respond_to?(:to_color)
+       @img.define("lowlight-color", color)
+    end
+end
+
+
 # Example fill class. Fills the image with the specified background
 # color, then crosshatches with the specified crosshatch color.
 # @dist is the number of pixels between hatch lines.
@@ -1766,3 +1934,4 @@ class HatchFill
 end
 
 end # Magick
+