kamelopard 0.0.4 → 0.0.5

data/lib/kamelopard/classes.rb

@@ -7,8 +7,8 @@
 module Kamelopard
     require 'singleton'
     require 'kamelopard/pointlist'
-    require 'rexml/document'
-    require 'rexml/element'
+    require 'xml'
+    require 'yaml'
 
     @@sequence = 0
 
@@ -37,10 +37,14 @@ module Kamelopard
             if ! a[0].nil? then
                 if a[1].kind_of? Proc then
                     a[1].call(e)
+                elsif a[0].kind_of? XML::Node then
+                    d = XML::Node.new(a[1])
+                    d << a[0]
+                    e << d
                 else
-                    t = REXML::Element.new a[1]
-                    t.text = a[0].to_s
-                    e.elements.add t
+                    t = XML::Node.new a[1]
+                    t << a[0].to_s
+                    e << t
                 end
             end
         end
@@ -90,32 +94,63 @@ module Kamelopard
     def Kamelopard.add_altitudeMode(mode, e)
         return if mode.nil?
         if mode == :clampToGround or mode == :relativeToGround or mode == :absolute then
-            t = REXML::Element.new 'altitudeMode'
+            t = XML::Node.new 'altitudeMode'
         else
-            t = REXML::Element.new 'gx:altitudeMode'
+            t = XML::Node.new 'gx:altitudeMode'
         end
-        t.text = mode
-        e.elements.add t
+        t << mode.to_s
+        e << t
     end
 
     # Base class for all Kamelopard objects. Manages object ID and a single
     # comment string associated with the object
     class Object
-        attr_accessor :id, :comment
+        attr_accessor :kml_id
+        attr_reader :comment
 
-        def initialize(comment = nil)
-            @id = "#{self.class.name.gsub('Kamelopard::', '')}_#{ Kamelopard.get_next_id }"
-            @comment = comment.gsub(/</, '&lt;') unless comment.nil?
+        def initialize(options = {})
+            @kml_id = "#{self.class.name.gsub('Kamelopard::', '')}_#{ Kamelopard.get_next_id }"
+
+            options.each do |k, v|
+                method = "#{k}=".to_sym
+                if self.respond_to? method then
+                    self.method(method).call(v)
+                else
+                    raise "Warning: couldn't find attribute for options hash key #{k}"
+                end
+            end
+        end
+
+        def comment=(a)
+            if a.respond_to? :gsub then
+                @comment = a.gsub(/</, '&lt;')
+            else
+                @comment = a
+            end
         end
 
         # Returns KML string for this object. Objects should override this method
         def to_kml(elem)
-            elem.attributes['id'] = @id
+            elem.attributes['id'] = @kml_id.to_s
             if not @comment.nil? and @comment != '' then
-                c = REXML::Comment.new " #{@comment} ", elem
+                c = XML::Node.new_comment " #{@comment} "
+                elem << c
                 return c
             end
         end
+
+        # Generates a <Change> element suitable for changing the given field of
+        # an object to the given value
+        def change(field, value)
+            c = XML::Node.new 'Change'
+            o = XML::Node.new self.class.name.sub!(/Kamelopard::/, '')
+            o.attributes['targetId'] = self.kml_id
+            e = XML::Node.new field
+            e.content = value.to_s
+            o << e
+            c << o
+            c
+        end
     end
 
     # Abstract base class for Point and several other classes
@@ -124,69 +159,71 @@ module Kamelopard
 
     # Represents a Point in KML.
     class Point < Geometry
-        attr_accessor :longitude, :latitude, :altitude, :altitudeMode, :extrude
-        def initialize(long, lat, alt=0, altmode=:clampToGround, extrude=false)
-            super()
+        attr_reader :longitude, :latitude
+        attr_accessor :altitude, :altitudeMode, :extrude
+
+        def initialize(longitude = nil, latitude = nil, altitude = nil, options = {})
+            super options
+            @longitude = longitude unless longitude.nil?
+            @latitude = latitude unless latitude.nil?
+            @altitude = altitude unless altitude.nil?
+        end
+
+        def longitude=(long)
             @longitude = Kamelopard.convert_coord(long)
+        end
+
+        def latitude=(lat)
             @latitude = Kamelopard.convert_coord(lat)
-            @altitude = alt
-            @altitudeMode = altmode
-            @extrude = extrude
         end
-        
+
         def to_s
             "Point (#{@longitude}, #{@latitude}, #{@altitude}, mode = #{@altitudeMode}, #{ @extrude ? 'extruded' : 'not extruded' })"
         end
 
-        def to_kml(short = false)
-            e = REXML::Element.new 'Point'
+        def to_kml(elem = nil, short = false)
+            e = XML::Node.new 'Point'
             super(e)
-            e.attributes['id'] = @id
-            c = REXML::Element.new 'coordinates'
-            c.text = "#{ @longitude }, #{ @latitude }, #{ @altitude }"
-            e.elements.add c
+            e.attributes['id'] = @kml_id
+            c = XML::Node.new 'coordinates'
+            c << "#{ @longitude }, #{ @latitude }, #{ @altitude }"
+            e << c
 
             if not short then
-                c = REXML::Element.new 'extrude'
-                c.text = @extrude ? 1 : 0
-                e.elements.add c
+                c = XML::Node.new 'extrude'
+                c << ( @extrude ? 1 : 0 ).to_s
+                e << c
 
                 Kamelopard.add_altitudeMode(@altitudeMode, e)
             end
 
-            d = REXML::Document.new
-            d.add_element e
-            d
+            elem << e unless elem.nil?
+            e
         end
     end
 
     # Helper class for KML objects which need to know about several points at once
-    class CoordinateList
+    module CoordinateList
         attr_reader :coordinates
 
-        # Accepts an optional array of coordinates in any format add_element
-        # accepts
-        def initialize(coords = nil)
-            # Internally we store coordinates as an array of three-element
-            # arrays
-            @coordinates = []
-            if not coords.nil? then
-                add_element coords
+        def coordinates=(a)
+            if a.nil? then
+                coordinates = []
             else
-                @coordinates = []
+                add_element a
             end
         end
 
-        def to_kml(elem = nil)
-            e = REXML::Element.new 'coordinates'
+        def coordinates_to_kml(elem = nil)
+            e = XML::Node.new 'coordinates'
             t = ''
             @coordinates.each do |a|
                 t << "#{ a[0] },#{ a[1] }"
                 t << ",#{ a[2] }" if a.size > 2
                 t << ' '
             end
-            e.text = t.chomp(' ')
-            elem.elements.add e unless elem.nil?
+            e << t.chomp(' ')
+            elem << e unless elem.nil?
             e
         end
 
@@ -204,6 +241,9 @@ module Kamelopard
         # Note that this will not accept a one-dimensional array of numbers to add
         # a single point. Instead, create a Point with those numbers, and pass
         # it to add_element
+        #-
+        # XXX The above stipulation is a weakness that needs fixing
+        #+
         def add_element(a)
             if a.kind_of? Enumerable then
                 # We've got some sort of array or list. It could be a list of
@@ -252,31 +292,17 @@ module Kamelopard
 
     # Corresponds to the KML LineString object
     class LineString < Geometry
+        include CoordinateList
         attr_accessor :altitudeOffset, :extrude, :tessellate, :altitudeMode, :drawOrder, :longitude, :latitude, :altitude
-        attr_reader :coordinates
 
-        def initialize(coords, altMode = :clampToGround)
-            super()
-            @altitudeMode = altMode
-            set_coords coords
-        end
-
-        # Sets @coordinates element
-        def set_coords(a)
-            if a.kind_of? CoordinateList then
-                @coordinates = a
-            else
-                @coordinates = CoordinateList.new(a)
-            end
-        end
-
-        # Appends an element to this LineString's CoordinateList. See CoordinateList#add_element
-        def <<(a)
-            @coordinates << a
+        def initialize(coordinates = [], options = {})
+            @coordinates = []
+            super options
+            self.coordinates=(coordinates) unless coordinates.nil?
         end
 
         def to_kml(elem = nil)
-            k = REXML::Element.new 'LineString'
+            k = XML::Node.new 'LineString'
             super(k)
             Kamelopard.kml_array(k, [
                 [@altitudeOffset, 'gx:altitudeOffset'],
@@ -284,48 +310,30 @@ module Kamelopard
                 [@tessellate, 'tessellate'],
                 [@drawOrder, 'gx:drawOrder']
             ])
-            @coordinates.to_kml(k) unless @coordinates.nil?
+            coordinates_to_kml(k) unless @coordinates.nil?
             Kamelopard.add_altitudeMode @altitudeMode, k
-            elem.elements << k unless elem.nil?
+            elem << k unless elem.nil?
             k
         end
     end
 
     # Corresponds to KML's LinearRing object
     class LinearRing < Geometry
-        attr_accessor :altitudeOffset, :extrude, :tessellate, :altitudeMode, :coordinates
-
-        def initialize(coordinates = nil, tessellate = 0, extrude = 0, altitudeMode = :clampToGround, altitudeOffset = nil)
-            super()
-            if coordinates.nil? then
-                @coordinates = nil
-            elsif coordinates.kind_of? CoordinateList then
-                @coordinates = coordinates
-            else
-                @coordinates = CoordinateList.new(coordinates)
-            end
-            @tessellate = tessellate
-            @extrude = extrude
-            @altitudeMode = altitudeMode
-            @altitudeOffset = altitudeOffset
-        end
+        attr_accessor :altitudeOffset, :extrude, :tessellate, :altitudeMode
+        include CoordinateList
 
-        # Sets @coordinates element
-        def set_coords(a)
-            if a.kind_of? CoordinateList then
-                @coordinates = a
-            else
-                @coordinates = CoordinateList.new(a)
-            end
-        end
+        def initialize(coordinates = [], options = {})
+            @tessellate = 0
+            @extrude = 0
+            @altitudeMode = :clampToGround
+            @coordinates = []
 
-        # Appends an element to this LinearRing's CoordinateList. See CoordinateList#add_element
-        def <<(a)
-            @coordinates << a
+            super options
+            self.coordinates=(coordinates) unless coordinates.nil?
         end
 
         def to_kml(elem = nil)
-            k = REXML::Element.new 'LinearRing'
+            k = XML::Node.new 'LinearRing'
             super(k)
             Kamelopard.kml_array(k, [
                 [ @altitudeOffset, 'gx:altitudeOffset' ],
@@ -333,39 +341,44 @@ module Kamelopard
                 [ @extrude, 'extrude' ]
             ])
             Kamelopard.add_altitudeMode(@altitudeMode, k)
-            @coordinates.to_kml(k)
-            elem.elements << k unless elem.nil?
+            coordinates_to_kml(k) unless @coordinates.nil?
+            elem << k unless elem.nil?
             k
         end
     end
 
     # Abstract class corresponding to KML's AbstractView object
     class AbstractView < Object
-        attr_accessor :timestamp, :timespan, :options, :point, :heading, :tilt, :roll, :range, :altitudeMode
-        def initialize(className, point = nil, heading = 0, tilt = 0, roll = 0, range = 0, altitudeMode = :clampToGround)
+        attr_accessor :timestamp, :timespan, :viewerOptions, :heading, :tilt, :roll, :range, :altitudeMode
+        attr_reader :className, :point
+
+        def initialize(className, point, options = {})
             raise "className argument must not be nil" if className.nil?
-            super()
-            @point = point
-            @options = {}
+
+            @heading = 0
+            @tilt = 0
+            @roll = 0
+            @range = 0
+            @altitudeMode = :clampToGround
+            @viewerOptions = {}
+
+            super options
+
             @className = className
+            self.point= point unless point.nil?
+        end
+
+        def point=(point)
             if point.nil? then
                 @point = nil
-            elsif point.kind_of? Placemark then
-                @point = point.point
             else
-                @point = point
+                if point.respond_to? :point then
+                    a = point.point
+                else
+                    a = point
+                end
+                @point = Point.new a.longitude, a.latitude, a.altitude
             end
-            @heading = heading
-            @tilt = tilt
-            @roll = roll
-            @range = range
-            @altitudeMode = altitudeMode
-        end
-
-        def point=(point)
-            @point.longitude = point.longitude
-            @point.latitude = point.latitude
-            @point.altitude = point.altitude
         end
 
         def longitude
@@ -405,7 +418,7 @@ module Kamelopard
         end
 
         def to_kml(elem = nil)
-            t = REXML::Element.new @className
+            t = XML::Node.new @className
             super(t)
             Kamelopard.kml_array(t, [
                 [ @point.nil? ? nil : @point.longitude, 'longitude' ],
@@ -417,27 +430,27 @@ module Kamelopard
                 [ @roll, 'roll' ]
             ])
             Kamelopard.add_altitudeMode(@altitudeMode, t)
-            if @options.keys.length > 0 then
-                vo = REXML::Element.new 'gx:ViewerOptions'
-                @options.each do |k, v|
-                    o = REXML::Element.new 'gx:option'
-                    o.attributes['name'] = k
+            if @viewerOptions.keys.length > 0 then
+                vo = XML::Node.new 'gx:ViewerOptions'
+                @viewerOptions.each do |k, v|
+                    o = XML::Node.new 'gx:option'
+                    o.attributes['name'] = k.to_s
                     o.attributes['enabled'] = v ? 'true' : 'false'
-                    vo.elements << o
+                    vo << o
                 end
-                t.elements << vo
+                t << vo
             end
             if not @timestamp.nil? then
                 @timestamp.to_kml(t, 'gx')
             elsif not @timespan.nil? then
                 @timespan.to_kml(t, 'gx')
             end
-            elem.elements << t unless elem.nil?
+            elem << t unless elem.nil?
             t
         end
 
         def [](a)
-            return @options[a]
+            return @viewerOptions[a]
         end
 
         def []=(a, b)
@@ -447,14 +460,14 @@ module Kamelopard
             if a != :streetview and a != :historicalimagery and a != :sunlight then
                 raise 'Option index must be :streetview, :historicalimagery, or :sunlight'
             end
-            @options[a] = b
+            @viewerOptions[a] = b
         end
     end
 
     # Corresponds to KML's Camera object
     class Camera < AbstractView
-        def initialize(point = nil, heading = 0, tilt = 0, roll = 0, altitudeMode = :clampToGround)
-            super('Camera', point, heading, tilt, roll, nil, altitudeMode)
+        def initialize(point = nil, options = {})
+            super('Camera', point, options)
         end
 
         def range
@@ -468,8 +481,8 @@ module Kamelopard
 
     # Corresponds to KML's LookAt object
     class LookAt < AbstractView
-        def initialize(point = nil, heading = 0, tilt = 0, range = 0, altitudeMode = :clampToGround)
-            super('LookAt', point, heading, tilt, nil, range, altitudeMode)
+        def initialize(point = nil, options = {})
+            super('LookAt', point, options)
         end
 
         def roll
@@ -488,21 +501,21 @@ module Kamelopard
     # Corresponds to KML's TimeStamp object. The @when attribute must be in a format KML understands.
     class TimeStamp < TimePrimitive
         attr_accessor :when
-        def initialize(t_when)
-            super()
-            @when = t_when
+        def initialize(ts_when = nil, options = {})
+            super options
+            @when = ts_when unless ts_when.nil?
         end
 
         def to_kml(elem = nil, ns = nil)
             prefix = ''
             prefix = ns + ':' unless ns.nil?
-            
-            k = REXML::Element.new "#{prefix}TimeStamp"
+
+            k = XML::Node.new "#{prefix}TimeStamp"
             super(k)
-            w = REXML::Element.new 'when'
-            w.text = @when
-            k.elements << w
-            elem.elements << k unless elem.nil?
+            w = XML::Node.new 'when'
+            w << @when
+            k << w
+            elem << k unless elem.nil?
             k
         end
     end
@@ -511,65 +524,85 @@ module Kamelopard
     # understands.
     class TimeSpan < TimePrimitive
         attr_accessor :begin, :end
-        def initialize(t_begin, t_end)
-            super()
-            @begin = t_begin
-            @end = t_end
+        def initialize(ts_begin = nil, ts_end = nil, options = {})
+            super options
+            @begin = ts_begin unless ts_begin.nil?
+            @end = ts_end unless ts_end.nil?
         end
 
         def to_kml(elem = nil, ns = nil)
             prefix = ''
             prefix = ns + ':' unless ns.nil?
-            
-            k = REXML::Element.new "#{prefix}TimeSpan"
+
+            k = XML::Node.new "#{prefix}TimeSpan"
             super(k)
             if not @begin.nil? then
-                w = REXML::Element.new 'begin'
-                w.text = @begin
-                k.elements << w
+                w = XML::Node.new 'begin'
+                w << @begin
+                k << w
             end
             if not @end.nil? then
-                w = REXML::Element.new 'end'
-                w.text = @end
-                k.elements << w
-                elem.elements << k unless elem.nil?
+                w = XML::Node.new 'end'
+                w << @end
+                k << w
+                elem << k unless elem.nil?
             end
             k
         end
     end
 
     # Support class for Feature object
-    class Snippet
-        attr_accessor :text, :maxLines
-        def initialize(text = nil, maxLines = 2)
-            @text = text
-            @maxLines = maxLines
-        end
-
-        def to_kml(elem = nil)
-            e = REXML::Element.new 'Snippet'
-            e.attributes['maxLines'] = @maxLines
-            e.text = @text
-            elem.elements << e unless elem.nil?
+    module Snippet
+        attr_accessor :snippet_text, :maxLines
+
+        def snippet_to_kml(elem = nil)
+            e = XML::Node.new 'Snippet'
+            e.attributes['maxLines'] = @maxLines.to_s
+            e << @snippet_text
+            elem << e unless elem.nil?
             e
         end
     end
 
     # Abstract class corresponding to KML's Feature object.
     class Feature < Object
-        # Abatract class
+        # Abstract class
         attr_accessor :visibility, :open, :atom_author, :atom_link, :name,
-            :phoneNumber, :snippet, :description, :abstractView,
+            :phoneNumber, :description, :abstractView,
             :timeprimitive, :styleUrl, :styleSelector, :region, :metadata,
             :extendedData, :styles
-        attr_reader :addressDetails
+        attr_reader :addressDetails, :snippet
 
-        def initialize (name = nil)
-            super()
-            @name = name
+        include Snippet
+
+        def initialize (name = nil, options = {})
             @visibility = true
             @open = false
             @styles = []
+            super options
+            @name = name unless name.nil?
+        end
+
+        def styles=(a)
+            if a.is_a? Array then
+                @styles = a
+            elsif @styles.nil? then
+                @styles = []
+            else
+                @styles = [a]
+            end
+        end
+
+        # Hides the object. Note that this governs only whether the object is
+        # initially visible or invisible; to show or hide the feature
+        # dynamically during a tour, use an AnimatedUpdate object
+        def hide
+            @visibility = false
+        end
+
+        # Shows the object. See note for hide() method
+        def show
+            @visibility = true
         end
 
         def timestamp
@@ -598,28 +631,28 @@ module Kamelopard
         end
 
         # This function accepts either a StyleSelector object, or a string
-        # containing the desired StyleSelector's @id
+        # containing the desired StyleSelector's @kml_id
         def styleUrl=(a)
             if a.is_a? String then
                 @styleUrl = a
             elsif a.respond_to? 'id' then
-                @styleUrl = "##{ a.id }"
+                @styleUrl = "##{ a.kml_id }"
             else
                 @styleUrl = a.to_s
             end
         end
 
         def self.add_author(o, a)
-            e = REXML::Element.new 'atom:name'
-            e.text = a
-            f = REXML::Element.new 'atom:author'
+            e = XML::Node.new 'atom:name'
+            e << a.to_s
+            f = XML::Node.new 'atom:author'
             f << e
             o << f
         end
 
         def to_kml(elem = nil)
-            elem = REXML::Element.new 'Feature' if elem.nil?
-            super(elem)
+            elem = XML::Node.new 'Feature' if elem.nil?
+            super elem
             Kamelopard.kml_array(elem, [
                     [@name, 'name'],
                     [(@visibility.nil? || @visibility) ? 1 : 0, 'visibility'],
@@ -636,14 +669,14 @@ module Kamelopard
                     [@extendedData, 'ExtendedData' ]
                 ])
             styles_to_kml(elem)
-            @snippet.to_kml(elem) unless @snippet.nil?
+            snippet_to_kml(elem) unless @snippet_text.nil?
             @abstractView.to_kml(elem) unless @abstractView.nil?
             @timeprimitive.to_kml(elem) unless @timeprimitive.nil?
             @region.to_kml(elem) unless @region.nil?
             yield(elem) if block_given?
-            elem 
+            elem
         end
-        
+
         def styles_to_kml(elem)
             @styles.each do |a|
                 a.to_kml(elem)
@@ -653,9 +686,17 @@ module Kamelopard
 
     # Abstract class corresponding to KML's Container object.
     class Container < Feature
-        def initialize
-            super
+        def initialize(name = nil, options = {})
             @features = []
+            super
+        end
+
+        def features=(a)
+            if a.respond_to? :[] then
+                @features = a
+            else
+                @features = [a]
+            end
         end
 
         # Adds a new object to this container.
@@ -668,16 +709,31 @@ module Kamelopard
     class Folder < Container
         attr_accessor :styles, :folders, :parent_folder
 
-        def initialize(name = nil)
-            super()
-            @name = name
+        def initialize(name = nil, options = {})
             @styles = []
             @folders = []
+            super
             Document.instance.folders << self
         end
 
+        def styles=(a)
+            if a.respond_to? :[] then
+                @styles = a
+            else
+                @styles = [a]
+            end
+        end
+
+        def folders=(a)
+            if a.respond_to? :[] then
+                @folders = a
+            else
+                @folders = [a]
+            end
+        end
+
         def to_kml(elem = nil)
-            h = REXML::Element.new 'Folder'
+            h = XML::Node.new 'Folder'
             super h
             @features.each do |a|
                 a.to_kml(h)
@@ -685,7 +741,7 @@ module Kamelopard
             @folders.each do |a|
                 a.to_kml(h)
             end
-            elem.elements << h unless elem.nil?
+            elem << h unless elem.nil?
             h
         end
 
@@ -711,36 +767,35 @@ module Kamelopard
     # scripts can (for now) manage only one Document at a time.
     class Document < Container
         include Singleton
-        attr_accessor :flyto_mode, :folders, :tours, :uses_xal
+        attr_accessor :flyto_mode, :doc_folders, :doc_tours, :uses_xal, :doc_styles
 
-        def initialize
+        def initialize(options = {})
+            @doc_tours = []
+            @doc_folders = []
+            @doc_styles = []
             super
-            @tours = []
-            @folders = []
-            @styles = []
         end
 
         # Returns the current Tour object
         def tour
-            @tours << Tour.new if @tours.length == 0
-            @tours.last
+            Tour.new if @doc_tours.length == 0
+            @doc_tours.last
         end
 
         # Returns the current Folder object
         def folder
-            if @folders.size == 0 then
+            if @doc_folders.size == 0 then
                 Folder.new
             end
-            @folders.last
+            @doc_folders.last
         end
 
-    #    def styles_to_kml(elem = nil)
-    #    end
-
         def get_kml_document
-            k = REXML::Document.new
-            k << REXML::XMLDecl.default
-            r = REXML::Element.new('kml')
+            k = XML::Document.new
+            # XXX fix this
+            #k << XML::XMLDecl.default
+            k.root = XML::Node.new('kml')
+            r = k.root
             if @uses_xal then
                 r.attributes['xmlns:xal'] = "urn:oasis:names:tc:ciq:xsdschema:xAL:2.0"
             end
@@ -749,25 +804,24 @@ module Kamelopard
             r.attributes['xmlns:gx'] = 'http://www.google.com/kml/ext/2.2'
             r.attributes['xmlns:kml'] = 'http://www.opengis.net/kml/2.2'
             r.attributes['xmlns:atom'] = 'http://www.w3.org/2005/Atom'
-            r.elements << self.to_kml
-            k << r
+            r << self.to_kml
             k
         end
 
         def to_kml
-            d = REXML::Element.new 'Document'
-            super(d)
+            d = XML::Node.new 'Document'
+            super d
 
             # Print styles first
-            @styles.map do |a| a.to_kml(d) unless a.attached? end
+            @doc_styles.map do |a| d << a.to_kml unless a.attached? end
 
             # then folders
-            @folders.map do |a|
+            @doc_folders.map do |a|
                 a.to_kml(d) unless a.has_parent?
             end
 
             # then tours
-            @tours.map do |a| a.to_kml(d) end
+            @doc_tours.map do |a| a.to_kml(d) end
 
             d
         end
@@ -779,13 +833,10 @@ module Kamelopard
     class ColorStyle < Object
         attr_accessor :color
         attr_reader :colorMode
-        
-        def initialize(color, colorMode = :normal)
-            super()
-            # Note: color element order is aabbggrr
-            @color = color
-            validate_colorMode colorMode
-            @colorMode = colorMode # Can be :normal or :random
+
+        def initialize(color = nil, options = {})
+            super options
+            @color = color unless color.nil?
         end
 
         def validate_colorMode(a)
@@ -830,14 +881,14 @@ module Kamelopard
         end
 
         def to_kml(elem = nil)
-            k = elem.nil? ? REXML::Element.new('ColorStyle') : elem
+            k = elem.nil? ? XML::Node.new('ColorStyle') : elem
             super k
-            e = REXML::Element.new 'color'
-            e.text = @color
-            k.elements << e
-            e = REXML::Element.new 'colorMode'
-            e.text = @colorMode
-            k.elements << e
+            e = XML::Node.new 'color'
+            e << @color
+            k << e
+            e = XML::Node.new 'colorMode'
+            e << @colorMode
+            k << e
             k
         end
     end
@@ -849,16 +900,17 @@ module Kamelopard
         attr_accessor :bgColor, :text, :textColor, :displayMode
 
         # Note: color element order is aabbggrr
-        def initialize(text = '', textColor = 'ff000000', bgColor = 'ffffffff', displayMode = :default)
-            super()
-            @bgColor = bgColor
-            @text = text
-            @textColor = textColor
-            @displayMode = displayMode
+        def initialize(text = nil, options = {})
+        #text = '', textColor = 'ff000000', bgColor = 'ffffffff', displayMode = :default)
+            @bgColor = 'ffffffff'
+            @textColor = 'ff000000'
+            @displayMode = :default
+            super options
+            @text = text unless text.nil?
         end
 
         def to_kml(elem = nil)
-            k = REXML::Element.new 'BalloonStyle'
+            k = XML::Node.new 'BalloonStyle'
             super k
             Kamelopard.kml_array(k, [
                 [ @bgColor, 'bgColor' ],
@@ -882,28 +934,29 @@ module Kamelopard
         end
 
         def to_kml(name, elem = nil)
-            k = REXML::Element.new name
-            k.attributes['x'] = @x
-            k.attributes['y'] = @y
-            k.attributes['xunits'] = @xunits
-            k.attributes['yunits'] = @yunits
-            elem.elements << k unless elem.nil?
+            k = XML::Node.new name
+            k.attributes['x'] = @x.to_s
+            k.attributes['y'] = @y.to_s
+            k.attributes['xunits'] = @xunits.to_s
+            k.attributes['yunits'] = @yunits.to_s
+            elem << k unless elem.nil?
             k
         end
     end
 
     # Corresponds to the KML Icon object
-    class Icon
-        attr_accessor :id, :href, :x, :y, :w, :h, :refreshMode, :refreshInterval, :viewRefreshMode, :viewRefreshTime, :viewBoundScale, :viewFormat, :httpQuery
+    module Icon
+       attr_accessor :href, :x, :y, :w, :h, :refreshMode, :refreshInterval, :viewRefreshMode, :viewRefreshTime, :viewBoundScale, :viewFormat, :httpQuery
 
-        def initialize(href = nil)
-            @href = href
-            @id = "Icon_#{ Kamelopard.get_next_id }"
+        def href=(h)
+            @icon_id = "Icon_#{Kamelopard.get_next_id}" if @icon_id.nil?
+            @href = h
         end
 
-        def to_kml(elem = nil)
-            k = REXML::Element.new 'Icon'
-            k.attributes['id'] = @id
+        def icon_to_kml(elem = nil)
+            @icon_id = "Icon_#{Kamelopard.get_next_id}" if @icon_id.nil?
+            k = XML::Node.new 'Icon'
+            k.attributes['id'] = @icon_id
             Kamelopard.kml_array(k, [
                 [@href, 'href'],
                 [@x, 'gx:x'],
@@ -918,40 +971,56 @@ module Kamelopard
                 [@viewFormat, 'viewFormat'],
                 [@httpQuery, 'httpQuery'],
             ])
-            elem.elements << k unless elem.nil?
+            elem << k unless elem.nil?
             k
         end
     end
 
     # Corresponds to KML's IconStyle object.
     class IconStyle < ColorStyle
-        attr_accessor :scale, :heading, :hotspot, :icon
+        attr_accessor :scale, :heading, :hotspot
 
-        def initialize(href, scale = 1, heading = 0, hs_x = 0.5, hs_y = 0.5, hs_xunits = :fraction, hs_yunits = :fraction, color = 'ffffffff', colormode = :normal)
-            super(color, colormode)
-            @scale = scale
-            @heading = heading
-            @icon = Icon.new(href) unless href.nil?
-            @hotspot = XY.new(hs_x, hs_y, hs_xunits, hs_yunits) unless (hs_x.nil? and hs_y.nil? and hs_xunits.nil? and hs_yunits.nil?)
+        include Icon
+
+        def initialize(href = nil, options = {})
+            @hotspot = XY.new(0.5, 0.5, :fraction, :fraction)
+            super nil, options
+            @href = href unless href.nil?
+        end
+
+        def hs_x=(a)
+            @hotspot.x = a
+        end
+
+        def hs_y=(a)
+            @hotspot.y = a
+        end
+
+        def hs_xunits=(a)
+            @hotspot.xunits = a
+        end
+
+        def hs_yunits=(a)
+            @hotspot.yunits = a
         end
 
         def to_kml(elem = nil)
-            k = REXML::Element.new 'IconStyle'
+            k = XML::Node.new 'IconStyle'
             super(k)
             Kamelopard.kml_array( k, [
                 [ @scale, 'scale' ],
                 [ @heading, 'heading' ]
             ])
             if not @hotspot.nil? then
-                h = REXML::Element.new 'hotSpot'
-                h.attributes['x'] = @hotspot.x
-                h.attributes['y'] = @hotspot.y
-                h.attributes['xunits'] = @hotspot.xunits
-                h.attributes['yunits'] = @hotspot.yunits
-                k.elements << h
+                h = XML::Node.new 'hotSpot'
+                h.attributes['x'] = @hotspot.x.to_s
+                h.attributes['y'] = @hotspot.y.to_s
+                h.attributes['xunits'] = @hotspot.xunits.to_s
+                h.attributes['yunits'] = @hotspot.yunits.to_s
+                k << h
             end
-            @icon.to_kml(k) unless @icon.nil?
-            elem.elements << k unless elem.nil?
+            icon_to_kml(k)
+            elem << k unless elem.nil?
             k
         end
     end
@@ -960,18 +1029,18 @@ module Kamelopard
     class LabelStyle < ColorStyle
         attr_accessor :scale
 
-        def initialize(scale = 1, color = 'ffffffff', colormode = :normal)
-            super(color, colormode)
-            @scale = scale
+        def initialize(scale = 1, options = {})
+            @scale = scale 
+            super nil, options
         end
 
         def to_kml(elem = nil)
-            k = REXML::Element.new 'LabelStyle'
+            k = XML::Node.new 'LabelStyle'
             super k
-            s = REXML::Element.new 'scale'
-            s.text = @scale
-            k.elements << s
-            elem.elements << k unless elem.nil?
+            s = XML::Node.new 'scale'
+            s << @scale.to_s
+            k << s
+            elem << k unless elem.nil?
             k
         end
     end
@@ -980,18 +1049,20 @@ module Kamelopard
     # string, with two characters each of alpha, blue, green, and red values, in
     # that order, matching the ordering the KML spec demands.
     class LineStyle < ColorStyle
-        attr_accessor :outerColor, :outerWidth, :physicalWidth, :width
+        attr_accessor :outerColor, :outerWidth, :physicalWidth, :width, :labelVisibility
+
+        def initialize(options = {})
+            @outerColor = 'ffffffff'
+            @width = 1
+            @outerWidth = 0
+            @physicalWidth = 0
+            @labelVisibility = 0
 
-        def initialize(width = 1, outercolor = 'ffffffff', outerwidth = 0, physicalwidth = 0, color = 'ffffffff', colormode = :normal)
-            super(color, colormode)
-            @width = width
-            @outerColor = outercolor
-            @outerWidth = outerwidth
-            @physicalWidth = physicalwidth
+            super nil, options
         end
 
         def to_kml(elem = nil)
-            k = REXML::Element.new 'LineStyle'
+            k = XML::Node.new 'LineStyle'
             super k
             Kamelopard.kml_array(k, [
                 [ @width, 'width' ],
@@ -999,7 +1070,7 @@ module Kamelopard
                 [ @outerWidth, 'gx:outerWidth' ],
                 [ @physicalWidth, 'gx:physicalWidth' ],
             ])
-            elem.elements << k unless elem.nil?
+            elem << k unless elem.nil?
             k
         end
     end
@@ -1007,33 +1078,38 @@ module Kamelopard
     # Corresponds to KML's ListStyle object. Color is stored as an 8-character hex
     # string, with two characters each of alpha, blue, green, and red values, in
     # that order, matching the ordering the KML spec demands.
-    class ListStyle < ColorStyle
+    #--
+    # This doesn't descend from ColorStyle because I don't want the to_kml()
+    # call to super() adding color and colorMode elements to the KML -- Google
+    # Earth complains about 'em
+    #++
+    class ListStyle < Object
         attr_accessor :listItemType, :bgColor, :state, :href
 
-        def initialize(bgcolor = nil, state = nil, href = nil, listitemtype = nil)
-            super(nil, :normal)
-            @bgcolor = bgcolor
-            @state = state
-            @href = href
-            @listitemtype = listitemtype
+        def initialize(options = {})
+        #bgcolor = nil, state = nil, href = nil, listitemtype = nil)
+            @state = :open
+            @bgColor = 'ffffffff'
+            super
         end
 
         def to_kml(elem = nil)
-            k = REXML::Element.new 'ListStyle'
+            k = XML::Node.new 'ListStyle'
+
             super k
             Kamelopard.kml_array(k, [
-                [@listitemtype, 'listItemType'],
-                [@bgcolor, 'bgColor']
+                [@listItemType, 'listItemType'],
+                [@bgColor, 'bgColor']
             ])
             if (! @state.nil? or ! @href.nil?) then
-                i = REXML::Element.new 'ItemIcon'
+                i = XML::Node.new 'ItemIcon'
                 Kamelopard.kml_array(i, [
                     [ @state, 'state' ],
                     [ @href, 'href' ]
                 ])
-                k.elements << i
+                k << i
             end
-            elem.elements << k unless elem.nil?
+            elem << k unless elem.nil?
             k
         end
     end
@@ -1044,31 +1120,32 @@ module Kamelopard
     class PolyStyle < ColorStyle
         attr_accessor :fill, :outline
 
-        def initialize(fill = 1, outline = 1, color = 'ffffffff', colormode = :normal)
-            super(color, colormode)
-            @fill = fill
-            @outline = outline
+        def initialize(options = {})
+#fill = 1, outline = 1, color = 'ffffffff', colormode = :normal)
+            @fill = 1
+            @outline = 1
+            super nil, options
         end
 
         def to_kml(elem = nil)
-            k = REXML::Element.new 'PolyStyle'
+            k = XML::Node.new 'PolyStyle'
             super k
             Kamelopard.kml_array( k, [
                 [ @fill, 'fill' ],
                 [ @outline, 'outline' ]
             ])
-            elem.elements << k unless elem.nil?
+            elem << k unless elem.nil?
             k
         end
     end
 
     # Abstract class corresponding to KML's StyleSelector object.
     class StyleSelector < Object
-        attr_accessor :attached
-        def initialize
+
+        def initialize(options = {})
             super
             @attached = false
-            Document.instance.styles << self
+            Document.instance.doc_styles << self
         end
 
         def attached?
@@ -1081,7 +1158,7 @@ module Kamelopard
         end
 
         def to_kml(elem = nil)
-            elem = REXML::Element.new 'StyleSelector' if elem.nil?
+            elem = XML::Node.new 'StyleSelector' if elem.nil?
             super elem
             elem
         end
@@ -1091,26 +1168,17 @@ module Kamelopard
     # LabelStyle, LineStyle, PolyStyle, BalloonStyle, and ListStyle objects.
     class Style < StyleSelector
         attr_accessor :icon, :label, :line, :poly, :balloon, :list
-        def initialize(icon = nil, label = nil, line = nil, poly = nil, balloon = nil, list = nil)
-            super()
-            @icon = icon
-            @label = label
-            @line = line
-            @poly = poly
-            @balloon = balloon
-            @list = list
-        end
 
         def to_kml(elem = nil)
-            k = REXML::Element.new 'Style'
-            super(k)
+            k = XML::Node.new 'Style'
+            super k
             @icon.to_kml(k) unless @icon.nil?
             @label.to_kml(k) unless @label.nil?
             @line.to_kml(k) unless @line.nil?
             @poly.to_kml(k) unless @poly.nil?
             @balloon.to_kml(k) unless @balloon.nil?
             @list.to_kml(k) unless @list.nil?
-            elem.elements << k unless elem.nil?
+            elem << k unless elem.nil?
             k
         end
     end
@@ -1120,8 +1188,8 @@ module Kamelopard
         # StyleMap manages pairs. The first entry in each pair is a string key, the
         # second is either a Style or a styleUrl. It will be assumed to be the
         # latter if its kind_of? method doesn't claim it's a Style object
-        def initialize(pairs = {})
-            super()
+        def initialize(pairs = {}, options = {})
+            super options
             @pairs = pairs
         end
 
@@ -1131,23 +1199,23 @@ module Kamelopard
         end
 
         def to_kml(elem = nil)
-            t = REXML::Element.new 'StyleMap'
+            t = XML::Node.new 'StyleMap'
             super t
             @pairs.each do |k, v|
-                p = REXML::Element.new 'Pair'
-                key = REXML::Element.new 'key'
-                key.text = k
-                p.elements << key 
+                p = XML::Node.new 'Pair'
+                key = XML::Node.new 'key'
+                key << k.to_s
+                p. << key
                 if v.kind_of? Style then
                     v.to_kml(p)
                 else
-                    s = REXML::Element.new 'styleUrl'
-                    s.text = v
-                    p.elements << s
+                    s = XML::Node.new 'styleUrl'
+                    s << v.to_s
+                    p << s
                 end
-                t.elements << p
+                t << p
             end
-            elem.elements << t unless elem.nil?
+            elem << t unless elem.nil?
             t
         end
     end
@@ -1156,25 +1224,22 @@ module Kamelopard
     # descendant of Geometry
     class Placemark < Feature
         attr_accessor :name, :geometry
-        def initialize(name = nil, geo = nil)
-            super(name)
-            if geo.respond_to? '[]' then
-                @geometry = geo
-            else
-                @geometry = [ geo ]
-            end
+
+        def initialize(name = nil, options = {})
+            super
+            @name = name unless name.nil?
         end
-        
+
         def to_kml(elem = nil)
-            k = REXML::Element.new 'Placemark'
+            k = XML::Node.new 'Placemark'
             super k
-            @geometry.each do |i| i.to_kml(k) unless i.nil? end
+            @geometry.to_kml(k) unless @geometry.nil?
             elem << k unless elem.nil?
             k
         end
 
         def to_s
-            "Placemark id #{ @id } named #{ @name }"
+            "Placemark id #{ @kml_id } named #{ @name }"
         end
 
         def longitude
@@ -1194,8 +1259,8 @@ module Kamelopard
         end
 
         def point
-            if @geometry[0].kind_of? Point then
-                @geometry[0]
+            if @geometry.kind_of? Point then
+                @geometry
             else
                 raise "This placemark uses a non-point geometry, but the operation you're trying requires a point object"
             end
@@ -1205,7 +1270,7 @@ module Kamelopard
     # Abstract class corresponding to KML's gx:TourPrimitive object. Tours are made up
     # of descendants of these.
     class TourPrimitive < Object
-        def initialize
+        def initialize(options = {})
             Document.instance.tour << self
             super
         end
@@ -1216,22 +1281,29 @@ module Kamelopard
     class FlyTo < TourPrimitive
         attr_accessor :duration, :mode, :view
 
-        def initialize(view = nil, range = nil, duration = 0, mode = :bounce)
-            @duration = duration
-            @mode = mode
+        def initialize(view = nil, options = {})
+            @duration = 0
+            @mode = :bounce
+            super options
+            self.view= view unless view.nil?
+        end
+
+        def view=(view)
             if view.kind_of? AbstractView then
                 @view = view
             else
-                @view = LookAt.new(view)
+                @view = LookAt.new view
             end
+        end
+
+        def range=(range)
             if view.respond_to? 'range' and not range.nil? then
                 @view.range = range
             end
-            super()
         end
 
         def to_kml(elem = nil)
-            k = REXML::Element.new 'gx:FlyTo'
+            k = XML::Node.new 'gx:FlyTo'
             super k
             Kamelopard.kml_array(k, [
                 [ @duration, 'gx:duration' ],
@@ -1249,43 +1321,60 @@ module Kamelopard
     class AnimatedUpdate < TourPrimitive
         # XXX For now, the user has to specify the change / create / delete elements in
         # the <Update> manually, rather than creating objects.
-        attr_accessor :target, :delayedStart, :updates, :duration
+        attr_accessor :target, :delayedStart, :duration
+        attr_reader :updates
 
         # The updates argument is an array of strings containing <Change> elements
-        def initialize(updates = [], duration = 0, target = '', delayedstart = nil)
-            super()
-            begin
-                raise "incorrect object type" unless @target.kind_of? Object
-                @target = target.id
-            rescue RuntimeError
+        def initialize(updates, options = {})
+         #duration = 0, target = '', delayedstart = nil)
+            @updates = []
+            super options
+            @updates = updates unless updates.nil? or updates.size == 0
+        end
+
+        def target=(target)
+            if target.kind_of? Object then
+                @target = target.kml_id
+            else
                 @target = target
             end
-            @updates = updates
-            @duration = duration
-            @delayedStart = delayedstart
+        end
+
+        def updates=(a)
+            updates.each do |u| self.<<(u) end
         end
 
         # Adds another update string, presumably containing a <Change> element
         def <<(a)
-            @updates << REXML::Document.new(a).root
+            @updates << a
         end
 
         def to_kml(elem = nil)
-            k = REXML::Element.new 'gx:AnimatedUpdate'
+            k = XML::Node.new 'gx:AnimatedUpdate'
             super(k)
-            d = REXML::Element.new 'gx:duration'
-            d.text = @duration
+            d = XML::Node.new 'gx:duration'
+            d << @duration.to_s
             k << d
             if not @delayedStart.nil? then
-                d = REXML::Element.new 'gx:delayedStart'
-                d.text = @delayedStart
+                d = XML::Node.new 'gx:delayedStart'
+                d << @delayedStart.to_s
                 k << d
             end
-            d = REXML::Element.new 'Update'
-            q = REXML::Element.new 'targetHref'
-            q.text = @target
+            d = XML::Node.new 'Update'
+            q = XML::Node.new 'targetHref'
+            q << @target.to_s
             d << q
-            @updates.each do |i| d << i end
+            @updates.each do |i|
+                if i.is_a? XML::Node then
+                    d << i
+                else
+                    parser = reader = XML::Parser.string(i)
+                    doc = parser.parse
+                    node = doc.child
+                    n = node.copy true
+                    d << n
+                end
+            end
             k << d
             elem << k unless elem.nil?
             k
@@ -1294,15 +1383,12 @@ module Kamelopard
 
     # Corresponds to a KML gx:TourControl object
     class TourControl < TourPrimitive
-        def initialize
-            super
-        end
 
         def to_kml(elem = nil)
-            k = REXML::Element.new 'gx:TourControl'
+            k = XML::Node.new 'gx:TourControl'
             super(k)
-            q = REXML::Element.new 'gx:playMode'
-            q.text = 'pause'
+            q = XML::Node.new 'gx:playMode'
+            q << 'pause'
             k << q
             elem << k unless elem.nil?
             k
@@ -1312,16 +1398,16 @@ module Kamelopard
     # Corresponds to a KML gx:Wait object
     class Wait < TourPrimitive
         attr_accessor :duration
-        def initialize(duration = 0)
-            super()
+        def initialize(duration = 0, options = {})
+            super options
             @duration = duration
         end
 
         def to_kml(elem = nil)
-            k = REXML::Element.new 'gx:Wait'
+            k = XML::Node.new 'gx:Wait'
             super k
-            d = REXML::Element.new 'gx:duration'
-            d.text = @duration
+            d = XML::Node.new 'gx:duration'
+            d << @duration.to_s
             k << d
             elem << k unless elem.nil?
             k
@@ -1338,14 +1424,14 @@ module Kamelopard
         end
 
         def to_kml(elem = nil)
-            k = REXML::Element.new 'gx:SoundCue'
+            k = XML::Node.new 'gx:SoundCue'
             super k
-            d = REXML::Element.new 'href'
-            d.text = @href
+            d = XML::Node.new 'href'
+            d << @href.to_s
             k << d
             if not @delayedStart.nil? then
-                d = REXML::Element.new 'gx:delayedStart'
-                d.text = @delayedStart
+                d = XML::Node.new 'gx:delayedStart'
+                d << @delayedStart.to_s
                 k << d
             end
             elem << k unless elem.nil?
@@ -1371,13 +1457,13 @@ module Kamelopard
         end
 
         def to_kml(elem = nil)
-            k = REXML::Element.new 'gx:Tour'
+            k = XML::Node.new 'gx:Tour'
             super k
             Kamelopard.kml_array(k, [
                 [ @name, 'name' ],
                 [ @description, 'description' ],
             ])
-            p = REXML::Element.new 'gx:Playlist'
+            p = XML::Node.new 'gx:Playlist'
             @items.map do |a| a.to_kml p end
             k << p
             elem << k unless elem.nil?
@@ -1387,16 +1473,13 @@ module Kamelopard
 
     # Abstract class corresponding to the KML Overlay object
     class Overlay < Feature
-        attr_accessor :color, :drawOrder, :icon
+        attr_accessor :color, :drawOrder
 
-        def initialize(icon, name = nil)
-            super(name)
+        include Icon
+
+        def initialize(options = {})
+            super nil, options
             Document.instance.folder << self
-            if icon.respond_to?('to_kml') then
-                @icon = icon
-            elsif not icon.nil?
-                @icon = Icon.new(icon.to_s)
-            end
         end
 
         def to_kml(elem)
@@ -1405,7 +1488,7 @@ module Kamelopard
                 [ @color, 'color' ],
                 [ @drawOrder, 'drawOrder' ],
             ])
-            @icon.to_kml(elem) unless @icon.nil?
+            icon_to_kml(elem)
             elem
         end
     end
@@ -1413,25 +1496,17 @@ module Kamelopard
     # Corresponds to KML's ScreenOverlay object
     class ScreenOverlay < Overlay
         attr_accessor :overlayXY, :screenXY, :rotationXY, :size, :rotation
-        def initialize(icon, name  = nil, size = nil, rotation = nil, overlayXY = nil, screenXY = nil, rotationXY = nil)
-            super(icon, name)
-            @overlayXY = overlayXY
-            @screenXY = screenXY
-            @rotationXY = rotationXY
-            @size = size
-            @rotation = rotation
-        end
 
         def to_kml(elem = nil)
-            k = REXML::Element.new 'ScreenOverlay'
+            k = XML::Node.new 'ScreenOverlay'
             super k
             @overlayXY.to_kml('overlayXY', k)   unless @overlayXY.nil?
             @screenXY.to_kml('screenXY', k)     unless @screenXY.nil?
             @rotationXY.to_kml('rotationXY', k) unless @rotationXY.nil?
             @size.to_kml('size', k)             unless @size.nil?
             if ! @rotation.nil? then
-                d = REXML::Element.new 'rotation'
-                d.text = @rotation
+                d = XML::Node.new 'rotation'
+                d << @rotation.to_s
                 k << d
             end
             elem << k unless elem.nil?
@@ -1439,19 +1514,12 @@ module Kamelopard
         end
     end
 
-    # Supporting object for the PhotoOverlay class
-    class ViewVolume
+    # Supporting module for the PhotoOverlay class
+    module ViewVolume
         attr_accessor :leftFov, :rightFov, :bottomFov, :topFov, :near
-        def initialize(near, leftFov = -45, rightFov = 45, bottomFov = -45, topFov = 45)
-            @leftFov = leftFov
-            @rightFov = rightFov
-            @bottomFov = bottomFov
-            @topFov = topFov
-            @near = near
-        end
 
-        def to_kml(elem = nil)
-            p = REXML::Element.new 'ViewVolume'
+        def viewVolume_to_kml(elem = nil)
+            p = XML::Node.new 'ViewVolume'
             {
                 :near => @near,
                 :leftFov => @leftFov,
@@ -1459,8 +1527,9 @@ module Kamelopard
                 :topFov => @topFov,
                 :bottomFov => @bottomFov
             }.each do |k, v|
-                d = REXML::Element.new k.to_s
-                d.text = v
+                d = XML::Node.new k.to_s
+                v = 0 if v.nil?
+                d << v.to_s
                 p << d
             end
             elem << p unless elem.nil?
@@ -1468,27 +1537,22 @@ module Kamelopard
         end
     end
 
-    # Supporting object for the PhotoOverlay class
-    class ImagePyramid
+    # Supporting module for the PhotoOverlay class
+    module ImagePyramid
         attr_accessor :tileSize, :maxWidth, :maxHeight, :gridOrigin
 
-        def initialize(maxWidth, maxHeight, gridOrigin, tileSize = 256)
-            @tileSize = tileSize
-            @maxWidth = maxWidth
-            @maxHeight = maxHeight
-            @gridOrigin = gridOrigin
-        end
-
-        def to_kml(elem = nil)
-            p = REXML::Element.new 'ImagePyramid'
+        def imagePyramid_to_kml(elem = nil)
+            @tileSize = 256 if @tileSize.nil?
+            p = XML::Node.new 'ImagePyramid'
             {
                 :tileSize => @tileSize,
                 :maxWidth => @maxWidth,
                 :maxHeight => @maxHeight,
                 :gridOrigin => @gridOrigin
             }.each do |k, v|
-                d = REXML::Element.new k.to_s
-                d.text = v
+                d = XML::Node.new k.to_s
+                v = 0 if v.nil?
+                d << v.to_s
                 p << d
             end
             elem << p unless elem.nil?
@@ -1498,33 +1562,35 @@ module Kamelopard
 
     # Corresponds to KML's PhotoOverlay class
     class PhotoOverlay < Overlay
-        attr_accessor :rotation, :viewvolume, :imagepyramid, :point, :shape
+        attr_accessor :rotation, :point, :shape
 
-        def initialize(icon, point, rotation = 0, viewvolume = nil, imagepyramid = nil, shape = :rectangle)
-            super(icon)
+        include ViewVolume
+        include ImagePyramid
+
+        def initialize(options = {})
+            super
+        end
+
+        def point=(point)
             if point.respond_to?('point')
                 @point = point.point
             else
                 @point = point
             end
-            @rotation = rotation
-            @viewVolume = viewvolume
-            @imagePyramid = imagepyramid
-            @shape = shape
         end
 
         def to_kml(elem = nil)
-            p = REXML::Element.new 'PhotoOverlay'
+            p = XML::Node.new 'PhotoOverlay'
             super p
-            @viewVolume.to_kml p   unless @viewVolume.nil?
-            @imagePyramid.to_kml p unless @imagePyramid.nil?
-            p << @point.to_kml(true)
+            viewVolume_to_kml p
+            imagePyramid_to_kml p
+            p << @point.to_kml(nil, true)
             {
                 :rotation => @rotation,
                 :shape => @shape
             }.each do |k, v|
-                d = REXML::Element.new k.to_s
-                d.text = v
+                d = XML::Node.new k.to_s
+                d << v.to_s
                 p << d
             end
             elem << p unless elem.nil?
@@ -1566,28 +1632,28 @@ module Kamelopard
 
         def to_kml(elem = nil, alt = false)
             name = alt ? 'LatLonAltBox' : 'LatLonBox'
-            k = REXML::Element.new name
+            k = XML::Node.new name
             [
-                ['north', @north], 
-                ['south', @south], 
-                ['east', @east], 
+                ['north', @north],
+                ['south', @south],
+                ['east', @east],
                 ['west', @west],
                 ['minAltitude', @minAltitude],
                 ['maxAltitude', @maxAltitude]
             ].each do |a|
                 if not a[1].nil? then
-                    m = REXML::Element.new a[0]
-                    m.text = a[1]
-                    k.elements << m
+                    m = XML::Node.new a[0]
+                    m << a[1].to_s
+                    k << m
                 end
             end
             if (not @minAltitude.nil? or not @maxAltitude.nil?) then
                 Kamelopard.add_altitudeMode(@altitudeMode, k)
             end
-            m = REXML::Element.new 'rotation'
-            m.text = @rotation
-            k.elements << m
-            elem.elements << k unless elem.nil?
+            m = XML::Node.new 'rotation'
+            m = @rotation.to_s
+            k << m
+            elem << k unless elem.nil?
             k
         end
     end
@@ -1603,9 +1669,9 @@ module Kamelopard
         end
 
         def to_kml(elem = nil)
-            k = REXML::Element.new 'gx:LatLonQuad'
-            d = REXML::Element.new 'coordinates'
-            d.text = "#{ @lowerLeft.longitude },#{ @lowerLeft.latitude } #{ @lowerRight.longitude },#{ @lowerRight.latitude } #{ @upperRight.longitude },#{ @upperRight.latitude } #{ @upperLeft.longitude },#{ @upperLeft.latitude }"
+            k = XML::Node.new 'gx:LatLonQuad'
+            d = XML::Node.new 'coordinates'
+            d << "#{ @lowerLeft.longitude },#{ @lowerLeft.latitude } #{ @lowerRight.longitude },#{ @lowerRight.latitude } #{ @upperRight.longitude },#{ @upperRight.latitude } #{ @upperLeft.longitude },#{ @upperLeft.latitude }"
             k << d
             elem << k unless elem.nil?
             k
@@ -1615,8 +1681,10 @@ module Kamelopard
     # Corresponds to KML's GroundOverlay object
     class GroundOverlay < Overlay
         attr_accessor :altitude, :altitudeMode, :latlonbox, :latlonquad
-        def initialize(icon, latlonbox = nil, latlonquad = nil, altitude = 0, altitudeMode = :clampToGround)
-            super(icon)
+        def initialize(icon, options = {})
+            @altitude = 0
+            @altitudeMode = :clampToGround
+            super options
             @latlonbox = latlonbox
             @latlonquad = latlonquad
             @altitude = altitude
@@ -1625,10 +1693,10 @@ module Kamelopard
 
         def to_kml(elem = nil)
             raise "Either latlonbox or latlonquad must be non-nil" if @latlonbox.nil? and @latlonquad.nil?
-            k = REXML::Element.new 'GroundOverlay'
+            k = XML::Node.new 'GroundOverlay'
             super k
-            d = REXML::Element.new 'altitude'
-            d.text = @altitude
+            d = XML::Node.new 'altitude'
+            d << @altitude.to_s
             k << d
             Kamelopard.add_altitudeMode(@altitudeMode, k)
             @latlonbox.to_kml(k) unless @latlonbox.nil?
@@ -1649,20 +1717,20 @@ module Kamelopard
         end
 
         def to_kml(elem = nil)
-            k = REXML::Element.new 'Lod'
-            m = REXML::Element.new 'minLodPixels'
-            m.text = @minpixels
-            k.elements << m
-            m = REXML::Element.new 'maxLodPixels'
-            m.text = @maxpixels
-            k.elements << m
-            m = REXML::Element.new 'minFadeExtent'
-            m.text = @minfade
-            k.elements << m
-            m = REXML::Element.new 'maxFadeExtent'
-            m.text = @maxfade
-            k.elements << m
-            elem.elements << k unless elem.nil?
+            k = XML::Node.new 'Lod'
+            m = XML::Node.new 'minLodPixels'
+            m << @minpixels.to_s
+            k << m
+            m = XML::Node.new 'maxLodPixels'
+            m << @maxpixels.to_s
+            k << m
+            m = XML::Node.new 'minFadeExtent'
+            m << @minfade.to_s
+            k << m
+            m = XML::Node.new 'maxFadeExtent'
+            m << @maxfade.to_s
+            k << m
+            elem << k unless elem.nil?
             k
         end
     end
@@ -1671,18 +1739,16 @@ module Kamelopard
     class Region < Object
         attr_accessor :latlonaltbox, :lod
 
-        def initialize(latlonaltbox, lod)
-            super()
-            @latlonaltbox = latlonaltbox
-            @lod = lod
+        def initialize(options = {})
+            super
         end
 
         def to_kml(elem = nil)
-            k = REXML::Element.new 'Region'
-            super(k)
+            k = XML::Node.new 'Region'
+            super k
             @latlonaltbox.to_kml(k, true) unless @latlonaltbox.nil?
             @lod.to_kml(k) unless @lod.nil?
-            elem.elements << k unless elem.nil?
+            elem << k unless elem.nil?
             k
         end
     end
@@ -1703,14 +1769,14 @@ module Kamelopard
         end
 
         def to_kml(elem = nil)
-            x = REXML::Element.new 'Orientation'
+            x = XML::Node.new 'Orientation'
             {
                 :heading => @heading,
                 :tilt => @tilt,
                 :roll => @roll
             }.each do |k, v|
-                d = REXML::Element.new k.to_s
-                d.text = v
+                d = XML::Node.new k.to_s
+                d << v.to_s
                 x << d
             end
             elem << x unless elem.nil?
@@ -1728,14 +1794,14 @@ module Kamelopard
         end
 
         def to_kml(elem = nil)
-            x = REXML::Element.new 'Scale'
+            x = XML::Node.new 'Scale'
             {
                 :x => @x,
                 :y => @y,
                 :z => @z
             }.each do |k, v|
-                d = REXML::Element.new k.to_s
-                d.text = v
+                d = XML::Node.new k.to_s
+                d << v.to_s
                 x << d
             end
             elem << x unless elem.nil?
@@ -1752,13 +1818,13 @@ module Kamelopard
         end
 
         def to_kml(elem = nil)
-            x = REXML::Element.new 'Alias'
+            x = XML::Node.new 'Alias'
             {
                 :targetHref => @targetHref,
                 :sourceHref => @sourceHref,
             }.each do |k, v|
-                d = REXML::Element.new k.to_s
-                d.text = v
+                d = XML::Node.new k.to_s
+                d << v.to_s
                 x << d
             end
             elem << x unless elem.nil?
@@ -1781,7 +1847,7 @@ module Kamelopard
         end
 
         def to_kml(elem = nil)
-            k = REXML::Element.new 'ResourceMap'
+            k = XML::Node.new 'ResourceMap'
             @aliases.each do |a| k << a.to_kml(k) end
             elem << k unless elem.nil?
             k
@@ -1791,23 +1857,22 @@ module Kamelopard
     # Corresponds to KML's Link object
     class Link < Object
         attr_accessor :href, :refreshMode, :refreshInterval, :viewRefreshMode, :viewBoundScale, :viewFormat, :httpQuery
-        def initialize(href = '', refreshMode = :onChange, viewRefreshMode = :never)
-            super()
-            @href = href
-            @refreshMode = refreshMode
-            @viewRefreshMode = viewRefreshMode
+
+        def initialize(href = '', options = {})
+            super options
+            @href = href unless href == ''
         end
 
         def to_kml(elem = nil)
-            x = REXML::Element.new 'Link'
+            x = XML::Node.new 'Link'
             super x
             {
                 :href => @href,
                 :refreshMode => @refreshMode,
                 :viewRefreshMode => @viewRefreshMode,
             }.each do |k, v|
-                d = REXML::Element.new k.to_s
-                d.text = v
+                d = XML::Node.new k.to_s
+                d << v.to_s
                 x << d
             end
             Kamelopard.kml_array(x, [
@@ -1828,26 +1893,22 @@ module Kamelopard
         # location should be a Point, or some object that can behave like one,
         # including a Placemark. Model will get its Location and altitudeMode data
         # from this attribute
-        def initialize(link, location, orientation, scale, resourceMap)
-            super()
-            @link = link
-            @location = location
-            @orientation = orientation
-            @scale = scale
-            @resourceMap = resourceMap
+        def initialize(options = {})
+         #link, location, orientation, scale, resourceMap)
+            super
         end
 
         def to_kml(elem = nil)
-            x = REXML::Element.new 'Model'
+            x = XML::Node.new 'Model'
             super x
-            loc = REXML::Element.new 'Location'
+            loc = XML::Node.new 'Location'
             {
                 :longitude => @location.longitude,
                 :latitude => @location.latitude,
                 :altitude => @location.altitude,
             }.each do |k, v|
-                d = REXML::Element.new k.to_s
-                d.text = v
+                d = XML::Node.new k.to_s
+                d << v.to_s
                 loc << d
             end
             x << loc
@@ -1861,5 +1922,122 @@ module Kamelopard
         end
     end
 
+    # Corresponds to the KML Polygon class
+    class Polygon < Geometry
+        # NB!  No support for tessellate, because Google Earth doesn't support it, it seems
+        attr_accessor :outer, :inner, :altitudeMode, :extrude
+
+        def initialize(outer, options = {})
+          #extrude = 0, altitudeMode = :clampToGround)
+            @extrude = 0
+            @altitudeMode = :clampToGround
+            @inner = []
+            super options
+        end
+
+        def inner=(a)
+            if a.kind_of? Array then
+                @inner = a
+            else
+                @inner = [ a ]
+            end
+        end
+
+        def <<(a)
+            @inner << a
+        end
+
+        def to_kml(elem = nil)
+            k = XML::Node.new 'Polygon'
+            super k
+            e = XML::Node.new 'extrude'
+            e << @extrude.to_s
+            k << e
+            Kamelopard.add_altitudeMode @altitudeMode, k
+            e = XML::Node.new('outerBoundaryIs')
+            e << @outer.to_kml
+            k << e
+            @inner.each do |i|
+                e = XML::Node.new('innerBoundaryIs')
+                e << i.to_kml
+                k << e
+            end
+            elem << k unless elem.nil?
+            k
+        end
+    end
+
+    class MultiGeometry < Geometry
+        attr_accessor :geometries
+
+        def initialize(a = nil, options = {})
+            @geometries = []
+            @geometries << a unless a.nil?
+            super options
+        end
+
+        def <<(a)
+            @geometries << a
+        end
+
+        def to_kml(elem = nil)
+            e = XML::Node.new 'MultiGeometry'
+            @geometries.each do |g|
+                g.to_kml e
+            end
+            elem << e unless elem.nil?
+            e
+        end
+    end
+
+    class NetworkLink < Feature
+        attr_accessor :refreshVisibility, :flyToView, :link
+
+        def initialize(href = '', options = {})
+            @refreshMode = :onChange
+            @viewRefreshMode = :never
+            super options
+            @link = Link.new(href, refreshMode, viewRefreshMode)
+            @refreshVisibility = 0
+            @flyToView = 0
+        end
+
+        def refreshMode
+            link.refreshMode
+        end
+
+        def viewRefreshMode
+            link.viewRefreshMode
+        end
+
+        def href
+            link.href
+        end
+
+        def refreshMode=(a)
+            link.refreshMode = a
+        end
+
+        def viewRefreshMode=(a)
+            link.viewRefreshMode = a
+        end
+
+        def href=(a)
+            link.href = a
+        end
+
+        def to_kml(elem = nil)
+            e = XML::Node.new 'NetworkLink'
+            super e
+            @link.to_kml e
+            Kamelopard.kml_array(e, [
+                [@flyToView, 'flyToView'],
+                [@refreshVisibility, 'refreshVisibility']
+            ])
+            elem << e unless elem.nil?
+            e
+        end
+    end
+
 end
 # End of Kamelopard module