kamelopard 0.0.3 → 0.0.4

data/lib/kamelopard/classes.rb

@@ -4,1703 +4,1862 @@
 # http://code.google.com/apis/kml/documentation/kmlreference.html for a
 # description of KML
 
-require 'singleton'
-require 'kamelopard/pointlist'
-
-@@sequence = 0
-
-def get_next_id   # :nodoc
-    @@sequence += 1
-    @@sequence
-end
-
-#--
-# Print out a set of kml fields. Expects an array argument. Each entry in the
-# array is itself an array, containing two strings and a boolean. If the first
-# string is nil, the function won't print anything for that element. If it's
-# not null, it consults the boolean. True values tell the function to treat the
-# second string as a KML element name, and print it along with XML decorators
-# and the field value. False values mean just print the second string, with no
-# decorators and no other values
-#++
-def kml_array(m, indent = 0) # :nodoc
-    k = ''
-    m.map do |a|
-        r = ''
-        if ! a[0].nil? then
-            if a[2] then
-                r << "#{ ' ' * indent}<" << a[1] << '>' << a[0].to_s << '</' << a[1] << ">\n"
-            else
-                r << a[1] << "\n"
+module Kamelopard
+    require 'singleton'
+    require 'kamelopard/pointlist'
+    require 'rexml/document'
+    require 'rexml/element'
+
+    @@sequence = 0
+
+    def Kamelopard.get_document
+        Document.instance
+    end
+
+    def Kamelopard.get_next_id   # :nodoc
+        @@sequence += 1
+        @@sequence
+    end
+
+    #--
+    # Intelligently adds elements to a KML object. Expects the KML object as the
+    # first argument, an array as the second.  Each entry in the array is itself an
+    # array, containing first an Object, and second either a string or a Proc
+    # object. If the first Object is nil, nothing happens. If it's not nil, then:
+    #   * if the second element is a string, add a new element to the KML. This
+    #     string is the element name, and the stringified form of the first element
+    #     is its text value
+    #   * if the second element is a proc, call the proc, passing it the KML
+    #     object, and let the Proc (presumably) add itself to the KML
+    #++
+    def Kamelopard.kml_array(e, m) # :nodoc
+        m.map do |a|
+            if ! a[0].nil? then
+                if a[1].kind_of? Proc then
+                    a[1].call(e)
+                else
+                    t = REXML::Element.new a[1]
+                    t.text = a[0].to_s
+                    e.elements.add t
+                end
             end
         end
-        k << r
     end
-    k
-end
 
-#--
-# Accepts XdX'X.X", XDXmX.XXs, XdXmX.XXs, or X.XXXX with either +/- or N/E/S/W
-#++
-def convert_coord(a)    # :nodoc
-    a = a.to_s.upcase.strip
+    #--
+    # Accepts XdX'X.X", XDXmX.XXs, XdXmX.XXs, or X.XXXX with either +/- or N/E/S/W
+    #++
+    def Kamelopard.convert_coord(a)    # :nodoc
+        a = a.to_s.upcase.strip
 
-    mult = 1
-    if a =~ /^-/ then
-        mult *= -1
-    end
-    a = a.sub /^\+|-/, ''
-    a = a.strip
-
-    if a =~ /[SW]$/ then
-        mult *= -1
-    end
-    a = a.sub /[NESW]$/, ''
-    a = a.strip
-
-    if a =~ /^\d+(\.\d+)?$/ then
-        # coord needs no transformation
-        1
-    elsif a =~ /^\d+D\d+M\d+(\.\d+)?S$/ then
-        # coord is in dms
-        p = a.split /[D"']/
-        a = p[0].to_f + (p[2].to_f / 60.0 + p[1].to_f) / 60.0
-    elsif a =~ /^\d+D\d+'\d+(\.\d+)?"$/ then
-        # coord is in d'"
-        p = a.split /[D"']/
-        a = p[0].to_f + (p[2].to_f / 60.0 + p[1].to_f) / 60.0
-    else
-        raise "Couldn't determine coordinate format for #{a}"
-    end
-
-    # check that it's within range
-    a = a.to_f * mult
-    raise "Coordinate #{a} out of range" if a > 180 or a < -180
-    return a
-end
+        mult = 1
+        if a =~ /^-/ then
+            mult *= -1
+        end
+        a = a.sub /^\+|-/, ''
+        a = a.strip
 
-# Base class for all Kamelopard objects. Manages object ID and a single
-# comment string associated with the object
-class KMLObject
-    attr_accessor :id, :comment
+        if a =~ /[SW]$/ then
+            mult *= -1
+        end
+        a = a.sub /[NESW]$/, ''
+        a = a.strip
+
+        if a =~ /^\d+(\.\d+)?$/ then
+            # coord needs no transformation
+            1
+        elsif a =~ /^\d+D\d+M\d+(\.\d+)?S$/ then
+            # coord is in dms
+            p = a.split /[D"']/
+            a = p[0].to_f + (p[2].to_f / 60.0 + p[1].to_f) / 60.0
+        elsif a =~ /^\d+D\d+'\d+(\.\d+)?"$/ then
+            # coord is in d'"
+            p = a.split /[D"']/
+            a = p[0].to_f + (p[2].to_f / 60.0 + p[1].to_f) / 60.0
+        else
+            raise "Couldn't determine coordinate format for #{a}"
+        end
 
-    def initialize(comment = nil)
-        @id = "#{self.class.name}_#{ get_next_id }"
-        @comment = comment.gsub(/</, '&lt;') unless comment.nil?
+        # check that it's within range
+        a = a.to_f * mult
+        raise "Coordinate #{a} out of range" if a > 180 or a < -180
+        return a
     end
 
-    # Returns KML string for this object. Objects should override this method
-    def to_kml(indent = 0)
-        if @comment.nil? or @comment == '' then
-            ''
+    # Helper function for altitudeMode / gx:altitudeMode elements
+    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'
         else
-            "#{ ' ' * indent }<!-- #{ @comment } -->\n"
+            t = REXML::Element.new 'gx:altitudeMode'
         end
+        t.text = mode
+        e.elements.add t
     end
-end
 
-# Abstract base class for KMLPoint and several other classes
-class Geometry < KMLObject
-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
 
-# Represents a Point in KML.
-class KMLPoint < Geometry
-    attr_accessor :longitude, :latitude, :altitude, :altitudeMode, :extrude
-    def initialize(long, lat, alt=0, altmode=:clampToGround, extrude=false)
-        super()
-        @longitude = convert_coord(long)
-        @latitude = convert_coord(lat)
-        @altitude = alt
-        @altitudeMode = altmode
-        @extrude = extrude
+        def initialize(comment = nil)
+            @id = "#{self.class.name.gsub('Kamelopard::', '')}_#{ Kamelopard.get_next_id }"
+            @comment = comment.gsub(/</, '&lt;') unless comment.nil?
+        end
+
+        # Returns KML string for this object. Objects should override this method
+        def to_kml(elem)
+            elem.attributes['id'] = @id
+            if not @comment.nil? and @comment != '' then
+                c = REXML::Comment.new " #{@comment} ", elem
+                return c
+            end
+        end
     end
-    
-    def to_s
-        "KMLPoint (#{@longitude}, #{@latitude}, #{@altitude}, mode = #{@altitudeMode}, #{ @extrude ? 'extruded' : 'not extruded' })"
+
+    # Abstract base class for Point and several other classes
+    class Geometry < Object
     end
 
-    def to_kml(indent = 0, short = false)
-        # The short form includes only the coordinates tag
-        k = super(indent + 4) + "#{ ' ' * indent }<Point id=\"#{ @id }\">\n"
-        k << "#{ ' ' * indent }    <extrude>#{ @extrude ? 1 : 0 }</extrude>\n" unless short
-        if not short then
-            if @altitudeMode == :clampToGround or @altitudeMode == :relativeToGround or @altitudeMode == :absolute then
-                k << "#{ ' ' * indent }    <altitudeMode>#{ @altitudeMode }</altitudeMode>\n"
-            else
-                k << "#{ ' ' * indent }    <gx:altitudeMode>#{ @altitudeMode }</gx:altitudeMode>\n"
+    # 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()
+            @longitude = Kamelopard.convert_coord(long)
+            @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'
+            super(e)
+            e.attributes['id'] = @id
+            c = REXML::Element.new 'coordinates'
+            c.text = "#{ @longitude }, #{ @latitude }, #{ @altitude }"
+            e.elements.add c
+
+            if not short then
+                c = REXML::Element.new 'extrude'
+                c.text = @extrude ? 1 : 0
+                e.elements.add c
+
+                Kamelopard.add_altitudeMode(@altitudeMode, e)
             end
+
+            d = REXML::Document.new
+            d.add_element e
+            d
         end
-        k << "#{ ' ' * indent }    <coordinates>#{ @longitude }, #{ @latitude }, #{ @altitude }</coordinates>\n"
-        k << "#{ ' ' * indent }</Point>\n"
-        k
     end
-end
 
-# Helper class for KML objects which need to know about several points at once
-class 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
-        else
+    # Helper class for KML objects which need to know about several points at once
+    class 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
+            else
+                @coordinates = []
+            end
         end
-    end
 
-    def to_kml(indent = 0)
-        k = "#{ ' ' * indent }<coordinates>\n#{ ' ' * indent }    "
-        if not @coordinates.nil? then
+        def to_kml(elem = nil)
+            e = REXML::Element.new 'coordinates'
+            t = ''
             @coordinates.each do |a|
-                k << "#{ a[0] },#{ a[1] }"
-                k << ",#{ a[2] }" if a.size > 2
-                k << ' '
+                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
         end
-        k << "\n#{ ' ' * indent}</coordinates>\n"
-        k
-    end
 
-    # Alias for add_element
-    def <<(a)
-        add_element a
-    end
+        # Alias for add_element
+        def <<(a)
+            add_element a
+        end
 
-    # Adds one or more elements to this CoordinateList. The argument can be in any of several formats:
-    # * An array of arrays of numeric objects, in the form [ longitude,
-    #   latitude, altitude (optional) ]
-    # * A KMLPoint, or some other object that response to latitude, longitude, and altitude methods
-    # * An array of the above
-    # * Another CoordinateList, to append to this on
-    # Note that this will not accept a one-dimensional array of numbers to add
-    # a single point. Instead, create a KMLPoint with those numbers, and pass
-    # it to add_element
-    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
-            # floats, to become one coordinate, or it could be several
-            # coordinates
-            t = a.to_a.first
-            if t.kind_of? Enumerable then
-                # At this point we assume we've got an array of float-like
-                # objects. The second-level arrays need to have two or three
-                # entries -- long, lat, and (optionally) alt
-                a.each do |i|
-                    if i.size < 2 then
-                        raise "There aren't enough objects here to make a 2- or 3-element coordinate"
-                    elsif i.size >= 3 then
-                        @coordinates << [ i[0].to_f, i[1].to_f, i[2].to_f ]
-                    else
-                        @coordinates << [ i[0].to_f, i[1].to_f ]
+        # Adds one or more elements to this CoordinateList. The argument can be in any of several formats:
+        # * An array of arrays of numeric objects, in the form [ longitude,
+        #   latitude, altitude (optional) ]
+        # * A Point, or some other object that response to latitude, longitude, and altitude methods
+        # * An array of the above
+        # * Another CoordinateList, to append to this on
+        # 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
+        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
+                # floats, to become one coordinate, or it could be several
+                # coordinates
+                t = a.to_a.first
+                if t.kind_of? Enumerable then
+                    # At this point we assume we've got an array of float-like
+                    # objects. The second-level arrays need to have two or three
+                    # entries -- long, lat, and (optionally) alt
+                    a.each do |i|
+                        if i.size < 2 then
+                            raise "There aren't enough objects here to make a 2- or 3-element coordinate"
+                        elsif i.size >= 3 then
+                            @coordinates << [ i[0].to_f, i[1].to_f, i[2].to_f ]
+                        else
+                            @coordinates << [ i[0].to_f, i[1].to_f ]
+                        end
                     end
+                elsif t.respond_to? 'longitude' and
+                    t.respond_to? 'latitude' and
+                    t.respond_to? 'altitude' then
+                    # This object can cough up a set of coordinates
+                    a.each do |i|
+                        @coordinates << [i.longitude, i.latitude, i.altitude]
+                    end
+                else
+                    # I dunno what it is
+                    raise "Kamelopard can't understand this object as a coordinate"
                 end
-            elsif t.respond_to? 'longitude' and
-                t.respond_to? 'latitude' and
-                t.respond_to? 'altitude' then
-                # This object can cough up a set of coordinates
-                a.each do |i|
-                    @coordinates << [i.longitude, i.latitude, i.altitude]
-                end
+            elsif a.kind_of? CoordinateList then
+                # Append this coordinate list
+                @coordinates << a.coordinates
             else
-                # I dunno what it is
-                raise "Kamelopard can't understand this object as a coordinate"
-            end
-        elsif a.kind_of? CoordinateList then
-            # Append this coordinate list
-            @coordinates << a.coordinates
-        else
-            # This is one element. It better know how to make latitude, longitude, etc.
-            if a.respond_to? 'longitude' and
-                a.respond_to? 'latitude' and
-                a.respond_to? 'altitude' then
-                @coordinates << [a.longitude, a.latitude, a.altitude]
-            else
-                raise "Kamelopard can't understand this object as a coordinate"
+                # This is one element. It better know how to make latitude, longitude, etc.
+                if a.respond_to? 'longitude' and
+                    a.respond_to? 'latitude' and
+                    a.respond_to? 'altitude' then
+                    @coordinates << [a.longitude, a.latitude, a.altitude]
+                else
+                    raise "Kamelopard can't understand this object as a coordinate"
+                end
             end
         end
     end
-end
-
-# Corresponds to the KML LineString object
-class LineString < Geometry
-    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
+    # Corresponds to the KML LineString object
+    class LineString < Geometry
+        attr_accessor :altitudeOffset, :extrude, :tessellate, :altitudeMode, :drawOrder, :longitude, :latitude, :altitude
+        attr_reader :coordinates
 
-    # Sets @coordinates element
-    def set_coords(a)
-        if a.kind_of? CoordinateList then
-            @coordinates = a
-        else
-            @coordinates = CoordinateList.new(a)
+        def initialize(coords, altMode = :clampToGround)
+            super()
+            @altitudeMode = altMode
+            set_coords coords
         end
-    end
-
-    # Appends an element to this LineString's CoordinateList. See CoordinateList#add_element
-    def <<(a)
-        @coordinates << a
-    end
 
-    def to_kml(indent = 0)
-
-        k = super(indent + 4) + "#{ ' ' * indent }<LineString id =\"#{ @id }\">\n"
-        k << kml_array([
-            [@altitudeOffset, 'gx:altitudeOffset', true],
-            [@extrude, 'extrude', true],
-            [@tessellate, 'tessellate', true],
-            [@drawOrder, 'gx:drawOrder', true]
-        ], indent + 4)
-        k << @coordinates.to_kml(indent + 4) unless @coordinates.nil?
-        if @altitudeMode == :clampToGround or @altitudeMode == :relativeToGround or @altitudeMode == :absolute then
-            k << "#{ ' ' * indent }    <altitudeMode>#{ @altitudeMode }</altitudeMode>\n"
-        else
-            k << "#{ ' ' * indent }    <gx:altitudeMode>#{ @altitudeMode }</gx:altitudeMode>\n"
+        # Sets @coordinates element
+        def set_coords(a)
+            if a.kind_of? CoordinateList then
+                @coordinates = a
+            else
+                @coordinates = CoordinateList.new(a)
+            end
         end
-        k << "#{ ' ' * indent }</LineString>\n"
-        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)
+        # Appends an element to this LineString's CoordinateList. See CoordinateList#add_element
+        def <<(a)
+            @coordinates << a
         end
-        @tessellate = tessellate
-        @extrude = extrude
-        @altitudeMode = altitudeMode
-        @altitudeOffset = altitudeOffset
-    end
 
-    # Sets @coordinates element
-    def set_coords(a)
-        if a.kind_of? CoordinateList then
-            @coordinates = a
-        else
-            @coordinates = CoordinateList.new(a)
+        def to_kml(elem = nil)
+            k = REXML::Element.new 'LineString'
+            super(k)
+            Kamelopard.kml_array(k, [
+                [@altitudeOffset, 'gx:altitudeOffset'],
+                [@extrude, 'extrude'],
+                [@tessellate, 'tessellate'],
+                [@drawOrder, 'gx:drawOrder']
+            ])
+            @coordinates.to_kml(k) unless @coordinates.nil?
+            Kamelopard.add_altitudeMode @altitudeMode, k
+            elem.elements << k unless elem.nil?
+            k
         end
     end
 
-    # Appends an element to this LinearRing's CoordinateList. See CoordinateList#add_element
-    def <<(a)
-        @coordinates << a
-    end
+    # Corresponds to KML's LinearRing object
+    class LinearRing < Geometry
+        attr_accessor :altitudeOffset, :extrude, :tessellate, :altitudeMode, :coordinates
 
-    def to_kml(indent = 0)
-        k = super(indent + 4) + "#{ ' ' * indent }<LinearRing id=\"#{ @id }\">\n"
-        k << "#{ ' ' * indent }    <gx:altitudeOffset>#{ @altitudeOffset }</gx:altitudeOffset>\n" unless @altitudeOffset.nil?
-        k << "#{ ' ' * indent }    <tessellate>#{ @tessellate }</tessellate>\n" unless @tessellate.nil?
-        k << "#{ ' ' * indent }    <extrude>#{ @extrude }</extrude>\n" unless @extrude.nil?
-        if not @altitudeMode.nil? then
-            if @altitudeMode == :clampToGround or @altitudeMode == :relativeToGround or @altitudeMode == :absolute then
-                k << "#{ ' ' * indent }    <altitudeMode>#{ @altitudeMode }</altitudeMode>\n"
+        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
-                k << "#{ ' ' * indent }    <gx:altitudeMode>#{ @altitudeMode }</gx:altitudeMode>\n"
+                @coordinates = CoordinateList.new(coordinates)
             end
+            @tessellate = tessellate
+            @extrude = extrude
+            @altitudeMode = altitudeMode
+            @altitudeOffset = altitudeOffset
         end
-        k << @coordinates.to_kml(indent + 4)
-        k << "#{ ' ' * indent }</LinearRing>\n"
-        k
-    end
-end
 
-# Abstract class corresponding to KML's AbstractView object
-class AbstractView < KMLObject
-    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)
-        raise "className argument must not be nil" if className.nil?
-        super()
-        @point = point
-        @options = {}
-        @className = className
-        if point.nil? then
-            @point = nil
-        elsif point.kind_of? Placemark then
-            @point = point.point
-        else
-            @point = point
+        # Sets @coordinates element
+        def set_coords(a)
+            if a.kind_of? CoordinateList then
+                @coordinates = a
+            else
+                @coordinates = CoordinateList.new(a)
+            end
         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
+        # Appends an element to this LinearRing's CoordinateList. See CoordinateList#add_element
+        def <<(a)
+            @coordinates << a
+        end
 
-    def longitude
-        @point.nil? ? nil : @point.longitude
+        def to_kml(elem = nil)
+            k = REXML::Element.new 'LinearRing'
+            super(k)
+            Kamelopard.kml_array(k, [
+                [ @altitudeOffset, 'gx:altitudeOffset' ],
+                [ @tessellate, 'tessellate' ],
+                [ @extrude, 'extrude' ]
+            ])
+            Kamelopard.add_altitudeMode(@altitudeMode, k)
+            @coordinates.to_kml(k)
+            elem.elements << k unless elem.nil?
+            k
+        end
     end
 
-    def latitude
-        @point.nil? ? nil : @point.latitude
-    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)
+            raise "className argument must not be nil" if className.nil?
+            super()
+            @point = point
+            @options = {}
+            @className = className
+            if point.nil? then
+                @point = nil
+            elsif point.kind_of? Placemark then
+                @point = point.point
+            else
+                @point = point
+            end
+            @heading = heading
+            @tilt = tilt
+            @roll = roll
+            @range = range
+            @altitudeMode = altitudeMode
+        end
 
-    def altitude
-        @point.nil? ? nil : @point.altitude
-    end
+        def point=(point)
+            @point.longitude = point.longitude
+            @point.latitude = point.latitude
+            @point.altitude = point.altitude
+        end
 
-    def longitude=(a)
-        if @point.nil? then
-            @point = KMLPoint.new(a, 0)
-        else
-            @point.longitude = a
+        def longitude
+            @point.nil? ? nil : @point.longitude
         end
-    end
 
-    def latitude=(a)
-        if @point.nil? then
-            @point = KMLPoint.new(0, a)
-        else
-            @point.latitude = a
+        def latitude
+            @point.nil? ? nil : @point.latitude
         end
-    end
 
-    def altitude=(a)
-        if @point.nil? then
-            @point = KMLPoint.new(0, 0, a)
-        else
-            @point.altitude = a
+        def altitude
+            @point.nil? ? nil : @point.altitude
         end
-    end
 
-    def to_kml(indent = 0)
-        t = "#{ ' ' * indent }<#{ @className } id=\"#{ @id }\">\n"
-        t << super(indent)
-        t << kml_array([
-            [ @point.nil? ? nil : @point.longitude, 'longitude', true ],
-            [ @point.nil? ? nil : @point.latitude, 'latitude', true ],
-            [ @point.nil? ? nil : @point.altitude, 'altitude', true ],
-            [ @heading, 'heading', true ],
-            [ @tilt, 'tilt', true ],
-            [ @range, 'range', true ],
-            [ @roll, 'roll', true ]
-        ], indent + 4)
-        if @altitudeMode == :clampToGround or @altitudeMode == :relativeToGround or @altitudeMode == :absolute then
-            t << "#{ ' ' * indent }    <altitudeMode>#{ @altitudeMode }</altitudeMode>\n"
-        else
-            t << "#{ ' ' * indent }    <gx:altitudeMode>#{ @altitudeMode }</gx:altitudeMode>\n"
+        def longitude=(a)
+            if @point.nil? then
+                @point = Point.new(a, 0)
+            else
+                @point.longitude = a
+            end
         end
-        if @options.keys.length > 0 then
-            t << "#{ ' ' * indent }    <gx:ViewerOptions>\n"
-            @options.each do |k, v|
-                t << "#{ ' ' * ( indent + 8 ) }<gx:option name=\"#{ k }\" enabled=\"#{ v ? 'true' : 'false' }\" />\n"
+
+        def latitude=(a)
+            if @point.nil? then
+                @point = Point.new(0, a)
+            else
+                @point.latitude = a
             end
-            t << "#{ ' ' * indent }    </gx:ViewerOptions>\n"
         end
-        if not @timestamp.nil? then
-            t << @timestamp.to_kml(indent+4, 'gx')
-        elsif not @timespan.nil? then
-            t << @timespan.to_kml(indent+4, 'gx')
+
+        def altitude=(a)
+            if @point.nil? then
+                @point = Point.new(0, 0, a)
+            else
+                @point.altitude = a
+            end
         end
-        t << "#{ ' ' * indent }</#{ @className }>\n"
-        t
-    end
 
-    def [](a)
-        return @options[a]
-    end
+        def to_kml(elem = nil)
+            t = REXML::Element.new @className
+            super(t)
+            Kamelopard.kml_array(t, [
+                [ @point.nil? ? nil : @point.longitude, 'longitude' ],
+                [ @point.nil? ? nil : @point.latitude, 'latitude' ],
+                [ @point.nil? ? nil : @point.altitude, 'altitude' ],
+                [ @heading, 'heading' ],
+                [ @tilt, 'tilt' ],
+                [ @range, 'range' ],
+                [ @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
+                    o.attributes['enabled'] = v ? 'true' : 'false'
+                    vo.elements << o
+                end
+                t.elements << 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?
+            t
+        end
 
-    def []=(a, b)
-        if not b.kind_of? FalseClass and not b.kind_of? TrueClass then
-            raise 'Option value must be boolean'
+        def [](a)
+            return @options[a]
         end
-        if a != :streetview and a != :historicalimagery and a != :sunlight then
-            raise 'Option index must be :streetview, :historicalimagery, or :sunlight'
+
+        def []=(a, b)
+            if not b.kind_of? FalseClass and not b.kind_of? TrueClass then
+                raise 'Option value must be boolean'
+            end
+            if a != :streetview and a != :historicalimagery and a != :sunlight then
+                raise 'Option index must be :streetview, :historicalimagery, or :sunlight'
+            end
+            @options[a] = b
         end
-        @options[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)
-    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)
+        end
 
-    def range
-        raise "The range element is part of LookAt objects, not Camera objects"
-    end
+        def range
+            raise "The range element is part of LookAt objects, not Camera objects"
+        end
 
-    def range=
-        # The range element doesn't exist in Camera objects
+        def range=
+            # The range element doesn't exist in Camera objects
+        end
     end
-end
 
-# 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)
-    end
+    # 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)
+        end
 
-    def roll
-        raise "The roll element is part of Camera objects, not LookAt objects"
-    end
+        def roll
+            raise "The roll element is part of Camera objects, not LookAt objects"
+        end
 
-    def roll=
-        # The roll element doesn't exist in LookAt objects
+        def roll=
+            # The roll element doesn't exist in LookAt objects
+        end
     end
-end
 
-# Abstract class corresponding to KML's TimePrimitive object
-class TimePrimitive < KMLObject
-end
-
-# 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
+    # Abstract class corresponding to KML's TimePrimitive object
+    class TimePrimitive < Object
     end
 
-    def to_kml(indent = 0, ns = nil)
-        prefix = ''
-        prefix = ns + ':' unless ns.nil?
-        
-        k = super(indent + 4)
-        k << <<-timestamp
-#{ ' ' * indent }<#{ prefix }TimeStamp id="#{ @id }">
-#{ ' ' * indent }    <when>#{ @when }</when>
-#{ ' ' * indent }</#{ prefix }TimeStamp>
-        timestamp
-    end
-end
+    # 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
+        end
 
-# Corresponds to KML's TimeSpan object. @begin and @end must be in a format KML
-# understands.
-class TimeSpan < TimePrimitive
-    attr_accessor :begin, :end
-    def initialize(t_begin, t_end)
-        super()
-        @begin = t_begin
-        @end = t_end
+        def to_kml(elem = nil, ns = nil)
+            prefix = ''
+            prefix = ns + ':' unless ns.nil?
+            
+            k = REXML::Element.new "#{prefix}TimeStamp"
+            super(k)
+            w = REXML::Element.new 'when'
+            w.text = @when
+            k.elements << w
+            elem.elements << k unless elem.nil?
+            k
+        end
     end
 
-    def to_kml(indent = 0, ns = nil)
-        prefix = ''
-        prefix = ns + ':' unless ns.nil?
+    # Corresponds to KML's TimeSpan object. @begin and @end must be in a format KML
+    # understands.
+    class TimeSpan < TimePrimitive
+        attr_accessor :begin, :end
+        def initialize(t_begin, t_end)
+            super()
+            @begin = t_begin
+            @end = t_end
+        end
 
-        k = super(indent + 4) + "#{ ' ' * indent }<#{ prefix }TimeSpan id=\"#{ @id }\">\n"
-        k << "#{ ' ' * indent }    <begin>#{ @begin }</begin>\n" unless @begin.nil?
-        k << "#{ ' ' * indent }    <end>#{ @end }</end>\n" unless @end.nil?
-        k << "#{ ' ' * indent }</#{ prefix }TimeSpan>\n"
-        k
+        def to_kml(elem = nil, ns = nil)
+            prefix = ''
+            prefix = ns + ':' unless ns.nil?
+            
+            k = REXML::Element.new "#{prefix}TimeSpan"
+            super(k)
+            if not @begin.nil? then
+                w = REXML::Element.new 'begin'
+                w.text = @begin
+                k.elements << w
+            end
+            if not @end.nil? then
+                w = REXML::Element.new 'end'
+                w.text = @end
+                k.elements << w
+                elem.elements << k unless elem.nil?
+            end
+            k
+        end
     end
-end
 
-# Support class for Feature object
-class Snippet
-    attr_accessor :text, :maxLines
-    def initialize(text = nil, maxLines = 2)
-        @text = text
-        @maxLines = maxLines
-    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(indent = 0)
-        k = "#{ ' ' * indent }<Snippet maxLines=\"#{maxLines}\">"
-        k << text
-        k << "#{ ' ' * indent }</Snippet>\n"
+        def to_kml(elem = nil)
+            e = REXML::Element.new 'Snippet'
+            e.attributes['maxLines'] = @maxLines
+            e.text = @text
+            elem.elements << e unless elem.nil?
+            e
+        end
     end
-end
 
-# Abstract class corresponding to KML's Feature object.
-class Feature < KMLObject
-    # Abstract class
-    attr_accessor :visibility, :open, :atom_author, :atom_link, :name,
-        :phoneNumber, :snippet, :description, :abstractView,
-        :timeprimitive, :styleUrl, :styleSelector, :region, :metadata,
-        :extendedData, :styles
-    attr_reader :addressDetails
-
-    def initialize (name = nil)
-        super()
-        @name = name
-        @visibility = true
-        @open = false
-        @styles = []
-    end
+    # Abstract class corresponding to KML's Feature object.
+    class Feature < Object
+        # Abatract class
+        attr_accessor :visibility, :open, :atom_author, :atom_link, :name,
+            :phoneNumber, :snippet, :description, :abstractView,
+            :timeprimitive, :styleUrl, :styleSelector, :region, :metadata,
+            :extendedData, :styles
+        attr_reader :addressDetails
+
+        def initialize (name = nil)
+            super()
+            @name = name
+            @visibility = true
+            @open = false
+            @styles = []
+        end
 
-    def timestamp
-        @timeprimitive
-    end
+        def timestamp
+            @timeprimitive
+        end
 
-    def timespan
-        @timeprimitive
-    end
+        def timespan
+            @timeprimitive
+        end
 
-    def timestamp=(t)
-        @timeprimitive = t
-    end
+        def timestamp=(t)
+            @timeprimitive = t
+        end
 
-    def timespan=(t)
-        @timeprimitive = t
-    end
+        def timespan=(t)
+            @timeprimitive = t
+        end
 
-    def addressDetails=(a)
-        if a.nil? or a == '' then
-            Document.instance.uses_xal = false
-        else
-            Document.instance.uses_xal = true
+        def addressDetails=(a)
+            if a.nil? or a == '' then
+                Document.instance.uses_xal = false
+            else
+                Document.instance.uses_xal = true
+            end
+            @addressDetails = a
         end
-        @addressDetails = a
-    end
 
-    # This function accepts either a StyleSelector object, or a string
-    # containing the desired StyleSelector's @id
-    def styleUrl=(a)
-        if a.is_a? String then
-            @styleUrl = a
-        elsif a.respond_to? 'id' then
-            @styleUrl = "##{ a.id }"
-        else
-            @styleUrl = a.to_s
+        # This function accepts either a StyleSelector object, or a string
+        # containing the desired StyleSelector's @id
+        def styleUrl=(a)
+            if a.is_a? String then
+                @styleUrl = a
+            elsif a.respond_to? 'id' then
+                @styleUrl = "##{ a.id }"
+            else
+                @styleUrl = a.to_s
+            end
         end
-    end
 
-    def to_kml(indent = 0)
-        k = ''
-        if self.class == Feature then k << "#{ ' ' * indent }<Feature id=\"#{ @id }\">\n" end
-        k << super 
-        k << kml_array([
-                [@name, 'name', true],
-                [(@visibility.nil? || @visibility) ? 1 : 0, 'visibility', true],
-                [(! @open.nil? && @open) ? 1 : 0, 'open', true],
-                [@atom_author, "<atom:author><atom:name>#{ @atom_author }</atom:name></atom:author>", false],
-                [@atom_link, 'atom:link', true],
-                [@address, 'address', true],
-                [@addressDetails, 'xal:AddressDetails', true],
-                [@phoneNumber, 'phoneNumber', true],
-                [@description, 'description', true],
-                [@styleUrl, 'styleUrl', true],
-                [@styleSelector, "<styleSelector>#{@styleSelector.nil? ? '' : @styleSelector.to_kml}</styleSelector>", false ],
-                [@metadata, 'Metadata', true ],
-                [@extendedData, 'ExtendedData', true ]
-            ], (indent))
-        k << styles_to_kml(indent)
-        k << @snippet.to_kml(indent) unless @snippet.nil?
-        k << @abstractView.to_kml(indent) unless @abstractView.nil?
-        k << @timeprimitive.to_kml(indent) unless @timeprimitive.nil?
-        k << @region.to_kml(indent) unless @region.nil?
-        k << yield if block_given?
-        if self.class == Feature then k << "#{ ' ' * indent }</Feature>\n" end
-        k
-    end
-    
-    def styles_to_kml(indent = 0)
-        k = ''
-        @styles.each do |a|
-            k << a.to_kml(indent)
+        def self.add_author(o, a)
+            e = REXML::Element.new 'atom:name'
+            e.text = a
+            f = REXML::Element.new 'atom:author'
+            f << e
+            o << f
         end
-        k
-    end
-end
 
-# Abstract class corresponding to KML's Container object.
-class Container < Feature
-    def initialize
-        super
-        @features = []
+        def to_kml(elem = nil)
+            elem = REXML::Element.new 'Feature' if elem.nil?
+            super(elem)
+            Kamelopard.kml_array(elem, [
+                    [@name, 'name'],
+                    [(@visibility.nil? || @visibility) ? 1 : 0, 'visibility'],
+                    [(! @open.nil? && @open) ? 1 : 0, 'open'],
+                    [@atom_author, lambda { |o| Feature.add_author(o, @atom_author) }],
+                    [@atom_link, 'atom:link'],
+                    [@address, 'address'],
+                    [@addressDetails, 'xal:AddressDetails'],
+                    [@phoneNumber, 'phoneNumber'],
+                    [@description, 'description'],
+                    [@styleUrl, 'styleUrl'],
+                    [@styleSelector, lambda { |o| @styleSelector.to_kml(o) }],
+                    [@metadata, 'Metadata' ],
+                    [@extendedData, 'ExtendedData' ]
+                ])
+            styles_to_kml(elem)
+            @snippet.to_kml(elem) unless @snippet.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 
+        end
+        
+        def styles_to_kml(elem)
+            @styles.each do |a|
+                a.to_kml(elem)
+            end
+        end
     end
 
-    # Adds a new object to this container.
-    def <<(a)
-        @features << a
+    # Abstract class corresponding to KML's Container object.
+    class Container < Feature
+        def initialize
+            super
+            @features = []
+        end
+
+        # Adds a new object to this container.
+        def <<(a)
+            @features << a
+        end
     end
-end
 
-# Corresponds to KML's Folder object.
-class Folder < Container
-    attr_accessor :styles, :folders, :parent_folder
+    # Corresponds to KML's Folder object.
+    class Folder < Container
+        attr_accessor :styles, :folders, :parent_folder
 
-    def initialize(name = nil)
-        super()
-        @name = name
-        @styles = []
-        @folders = []
-        Document.instance.folders << self
-    end
+        def initialize(name = nil)
+            super()
+            @name = name
+            @styles = []
+            @folders = []
+            Document.instance.folders << self
+        end
 
-    def to_kml(indent = 0)
-        h = "#{ ' ' * indent }<Folder id=\"#{@id}\">\n"
-        h << super(indent + 4)
-        @features.each do |a|
-            h << a.to_kml(indent + 4)
+        def to_kml(elem = nil)
+            h = REXML::Element.new 'Folder'
+            super h
+            @features.each do |a|
+                a.to_kml(h)
+            end
+            @folders.each do |a|
+                a.to_kml(h)
+            end
+            elem.elements << h unless elem.nil?
+            h
         end
-        @folders.each do |a|
-            h << a.to_kml(indent + 4)
+
+        # Folders can have parent folders; returns true if this folder has one
+        def has_parent?
+            not @parent_folder.nil?
         end
-        h << "#{ ' ' * indent }</Folder>\n";
-        h
-    end
 
-    # Folders can have parent folders; returns true if this folder has one
-    def has_parent?
-        not @parent_folder.nil?
+        # Folders can have parent folders; sets this folder's parent
+        def parent_folder=(a)
+            @parent_folder = a
+            a.folders << self
+        end
     end
 
-    # Folders can have parent folders; sets this folder's parent
-    def parent_folder=(a)
-        @parent_folder = a
-        a.folders << self
+    def get_stack_trace   # :nodoc
+        k = ''
+        caller.each do |a| k << "#{a}\n" end
+        k
     end
-end
 
-def get_stack_trace   # :nodoc
-    k = ''
-    caller.each do |a| k << "#{a}\n" end
-    k
-end
+    # Represents KML's Document class. This is a Singleton object; 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
 
-# Represents KML's Document class. This is a Singleton object; 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
-
-    def initialize
-        @tours = []
-        @folders = []
-        @styles = []
-    end
+        def initialize
+            super
+            @tours = []
+            @folders = []
+            @styles = []
+        end
 
-    # Returns the current Tour object
-    def tour
-        @tours << Tour.new if @tours.length == 0
-        @tours.last
-    end
+        # Returns the current Tour object
+        def tour
+            @tours << Tour.new if @tours.length == 0
+            @tours.last
+        end
 
-    # Returns the current Folder object
-    def folder
-        if @folders.size == 0 then
-            Folder.new
+        # Returns the current Folder object
+        def folder
+            if @folders.size == 0 then
+                Folder.new
+            end
+            @folders.last
         end
-        @folders.last
-    end
 
-    def styles_to_kml(indent)
-        ''
-    end
+    #    def styles_to_kml(elem = nil)
+    #    end
 
-    def to_kml
-        xal = ''
-        if @uses_xal then
-            xal = ' xmlns:xal="urn:oasis:names:tc:ciq:xsdschema:xAL:2.0"'
+        def get_kml_document
+            k = REXML::Document.new
+            k << REXML::XMLDecl.default
+            r = REXML::Element.new('kml')
+            if @uses_xal then
+                r.attributes['xmlns:xal'] = "urn:oasis:names:tc:ciq:xsdschema:xAL:2.0"
+            end
+    # XXX Should this be add_namespace instead?
+            r.attributes['xmlns'] = 'http://www.opengis.net/kml/2.2'
+            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
+            k
         end
-        h = <<-doc_header
-<?xml version="1.0" encoding="UTF-8"?>
-<kml xmlns="http://www.opengis.net/kml/2.2" xmlns:gx="http://www.google.com/kml/ext/2.2" xmlns:kml="http://www.opengis.net/kml/2.2" xmlns:atom="http://www.w3.org/2005/Atom"#{ xal }>
-<Document>
-        doc_header
-
-        h << super(4)
 
-        # Print styles first
-        @styles.map do |a| h << a.to_kml(4) unless a.attached? end
+        def to_kml
+            d = REXML::Element.new 'Document'
+            super(d)
 
-        # then folders
-        @folders.map do |a| h << a.to_kml(4) unless a.has_parent? end
+            # Print styles first
+            @styles.map do |a| a.to_kml(d) unless a.attached? end
 
-        # then tours
-        @tours.map do |a| h << a.to_kml(4) end
-        h << "</Document>\n</kml>\n"
+            # then folders
+            @folders.map do |a|
+                a.to_kml(d) unless a.has_parent?
+            end
 
-        h
-    end
-end
+            # then tours
+            @tours.map do |a| a.to_kml(d) end
 
-# Corresponds to KML's ColorStyle 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 ColorStyle < KMLObject
-    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
+            d
+        end
     end
 
-    def validate_colormode(a)
-        raise "colorMode must be either \"normal\" or \"random\"" unless a == :normal or a == :random
-    end
+    # Corresponds to KML's ColorStyle 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 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
+        end
 
-    def colormode=(a)
-        validate_colormode a
-        @colormode = a
-    end
+        def validate_colorMode(a)
+            raise "colorMode must be either \"normal\" or \"random\"" unless a == :normal or a == :random
+        end
 
-    def alpha
-        @color[0,1]
-    end
+        def colorMode=(a)
+            validate_colorMode a
+            @colorMode = a
+        end
 
-    def alpha=(a)
-        @color[0,1] = a
-    end
+        def alpha
+            @color[0,2]
+        end
 
-    def blue
-        @color[2,1]
-    end
+        def alpha=(a)
+            @color[0,2] = a
+        end
 
-    def blue=(a)
-        @color[2,1] = a
-    end
+        def blue
+            @color[2,2]
+        end
 
-    def green
-        @color[4,1]
-    end
+        def blue=(a)
+            @color[2,2] = a
+        end
 
-    def green=(a)
-        @color[4,1] = a
-    end
+        def green
+            @color[4,2]
+        end
 
-    def red
-        @color[6,1]
-    end
+        def green=(a)
+            @color[4,2] = a
+        end
 
-    def red=(a)
-        @color[6,1] = a
-    end
+        def red
+            @color[6,2]
+        end
 
-    def to_kml(indent = 0)
+        def red=(a)
+            @color[6,2] = a
+        end
 
-        super + <<-colorstyle
-#{ ' ' * indent }<color>#{@color}</color>
-#{ ' ' * indent }<colorMode>#{@colormode}</colorMode>
-        colorstyle
+        def to_kml(elem = nil)
+            k = elem.nil? ? REXML::Element.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
+            k
+        end
     end
-end
 
-# Corresponds to KML's BalloonStyle 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 BalloonStyle < ColorStyle
-    attr_accessor :bgcolor, :text, :textcolor, :displaymode
-
-    # Note: color element order is aabbggrr
-    def initialize(text = '', textcolor = 'ff000000', bgcolor = 'ffffffff', displaymode = :default)
-        super(nil, :normal)
-        @bgcolor = bgcolor
-        @text = text
-        @textcolor = textcolor
-        @displaymode = displaymode
-    end
+    # Corresponds to KML's BalloonStyle 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 BalloonStyle < Object
+        attr_accessor :bgColor, :text, :textColor, :displayMode
 
-    def to_kml(indent = 0)
-        super + <<-balloonstyle
-#{ ' ' * indent }<BalloonStyle id="#{@id}">
-#{ ' ' * indent }    <bgColor>#{@bgcolor}</bgColor>
-#{ ' ' * indent }    <text>#{@text}</text>
-#{ ' ' * indent }    <textColor>#{@textcolor}</textColor>
-#{ ' ' * indent }    <displayMode>#{@displaymode}</displayMode>
-#{ ' ' * indent }</BalloonStyle>
-        balloonstyle
-    end
-end
+        # Note: color element order is aabbggrr
+        def initialize(text = '', textColor = 'ff000000', bgColor = 'ffffffff', displayMode = :default)
+            super()
+            @bgColor = bgColor
+            @text = text
+            @textColor = textColor
+            @displayMode = displayMode
+        end
 
-# Internal class used where KML requires X and Y values and units
-class KMLxy
-    attr_accessor :x, :y, :xunits, :yunits
-    def initialize(x = 0.5, y = 0.5, xunits = :fraction, yunits = :fraction)
-        @x = x
-        @y = y
-        @xunits = xunits
-        @yunits = yunits
+        def to_kml(elem = nil)
+            k = REXML::Element.new 'BalloonStyle'
+            super k
+            Kamelopard.kml_array(k, [
+                [ @bgColor, 'bgColor' ],
+                [ @text, 'text' ],
+                [ @textColor, 'textColor' ],
+                [ @displayMode, 'displayMode' ]
+            ])
+            elem << k unless elem.nil?
+            k
+        end
     end
 
-    def to_kml(name, indent = 0)
+    # Internal class used where KML requires X and Y values and units
+    class XY
+        attr_accessor :x, :y, :xunits, :yunits
+        def initialize(x = 0.5, y = 0.5, xunits = :fraction, yunits = :fraction)
+            @x = x
+            @y = y
+            @xunits = xunits
+            @yunits = yunits
+        end
 
-        <<-kmlxy
-#{ ' ' * indent}<#{ name } x="#{ @x }" y="#{ @y }" xunits="#{ @xunits }" yunits="#{ @yunits }" />
-        kmlxy
+        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
+        end
     end
-end
 
-# Corresponds to the KML Icon object
-class Icon
-    attr_accessor :href, :x, :y, :w, :h, :refreshMode, :refreshInterval, :viewRefreshMode, :viewRefreshTime, :viewBoundScale, :viewFormat, :httpQuery
+    # Corresponds to the KML Icon object
+    class Icon
+        attr_accessor :id, :href, :x, :y, :w, :h, :refreshMode, :refreshInterval, :viewRefreshMode, :viewRefreshTime, :viewBoundScale, :viewFormat, :httpQuery
 
-    def initialize(href = nil)
-        @href = href
-    end
+        def initialize(href = nil)
+            @href = href
+            @id = "Icon_#{ Kamelopard.get_next_id }"
+        end
 
-    def to_kml(indent = 0)
-        k = "#{ ' ' * indent }<Icon>\n"
-        k << kml_array([
-            [@href, 'href', true],
-            [@x, 'gx:x', true],
-            [@y, 'gx:y', true],
-            [@w, 'gx:w', true],
-            [@h, 'gx:h', true],
-            [@refreshMode, 'refreshMode', true],
-            [@refreshInterval, 'refreshInterval', true],
-            [@viewRefreshMode, 'viewRefreshMode', true],
-            [@viewBoundScale, 'viewBoundScale', true],
-            [@viewFormat, 'viewFormat', true],
-            [@httpQuery, 'httpQuery', true],
-        ], indent + 4)
-        k << "#{ ' ' * indent }</Icon>\n"
+        def to_kml(elem = nil)
+            k = REXML::Element.new 'Icon'
+            k.attributes['id'] = @id
+            Kamelopard.kml_array(k, [
+                [@href, 'href'],
+                [@x, 'gx:x'],
+                [@y, 'gx:y'],
+                [@w, 'gx:w'],
+                [@h, 'gx:h'],
+                [@refreshMode, 'refreshMode'],
+                [@refreshInterval, 'refreshInterval'],
+                [@viewRefreshMode, 'viewRefreshMode'],
+                [@viewRefreshTime, 'viewRefreshTime'],
+                [@viewBoundScale, 'viewBoundScale'],
+                [@viewFormat, 'viewFormat'],
+                [@httpQuery, 'httpQuery'],
+            ])
+            elem.elements << k unless elem.nil?
+            k
+        end
     end
-end
 
-# Corresponds to KML's IconStyle object.
-class IconStyle < ColorStyle
-    attr_accessor :scale, :heading, :hotspot, :icon
+    # Corresponds to KML's IconStyle object.
+    class IconStyle < ColorStyle
+        attr_accessor :scale, :heading, :hotspot, :icon
 
-    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 = KMLxy.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?)
-    end
+        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?)
+        end
 
-    def to_kml(indent = 0)
-        k = <<-iconstyle1
-#{ ' ' * indent }<IconStyle id="#{@id}">
-#{ super(indent + 4) }
-       iconstyle1
-       k << "#{ ' ' * indent }    <scale>#{@scale}</scale>\n" unless @scale.nil?
-       k << "#{ ' ' * indent }    <heading>#{@heading}</heading>\n" unless @heading.nil?
-       k << @icon.to_kml(indent + 4) unless @icon.nil?
-       k << "#{ ' ' * indent }    <hotSpot x=\"#{@hotspot.x}\" y=\"#{@hotspot.y}\" xunits=\"#{@hotspot.xunits}\" yunits=\"#{@hotspot.yunits}\" />\n" unless @hotspot.nil?
-       k << "#{ ' ' * indent }</IconStyle>\n"
+        def to_kml(elem = nil)
+            k = REXML::Element.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
+            end
+            @icon.to_kml(k) unless @icon.nil?
+            elem.elements << k unless elem.nil?
+            k
+        end
     end
-end
 
-# Corresponds to KML's LabelStyle object
-class LabelStyle < ColorStyle
-    attr_accessor :scale
+    # Corresponds to KML's LabelStyle object
+    class LabelStyle < ColorStyle
+        attr_accessor :scale
 
-    def initialize(scale = 1, color = 'ffffffff', colormode = :normal)
-        super(color, colormode)
-        @scale = scale
-    end
-
-    def to_kml(indent = 0)
+        def initialize(scale = 1, color = 'ffffffff', colormode = :normal)
+            super(color, colormode)
+            @scale = scale
+        end
 
-        <<-labelstyle
-#{ ' ' * indent }<LabelStyle id="#{@id}">
-#{ super(indent + 4) }
-#{ ' ' * indent }    <scale>#{@scale}</scale>
-#{ ' ' * indent }</LabelStyle>
-        labelstyle
+        def to_kml(elem = nil)
+            k = REXML::Element.new 'LabelStyle'
+            super k
+            s = REXML::Element.new 'scale'
+            s.text = @scale
+            k.elements << s
+            elem.elements << k unless elem.nil?
+            k
+        end
     end
-end
 
-# Corresponds to KML's LineStyle 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 LineStyle < ColorStyle
-    attr_accessor :outercolor, :outerwidth, :physicalwidth, :width
-
-    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
-    end
+    # Corresponds to KML's LineStyle 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 LineStyle < ColorStyle
+        attr_accessor :outerColor, :outerWidth, :physicalWidth, :width
 
-    def to_kml(indent = 0)
-
-        <<-linestyle
-#{ ' ' * indent }<LineStyle id="#{@id}">
-#{ super(indent + 4) }
-#{ ' ' * indent }    <width>#{@width}</width>
-#{ ' ' * indent }    <gx:outerColor>#{@outercolor}</gx:outerColor>
-#{ ' ' * indent }    <gx:outerWidth>#{@outerwidth}</gx:outerWidth>
-#{ ' ' * indent }    <gx:physicalWidth>#{@physicalwidth}</gx:physicalWidth>
-#{ ' ' * indent }</LineStyle>
-        linestyle
-    end
-end
+        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
+        end
 
-# 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
-    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 to_kml(elem = nil)
+            k = REXML::Element.new 'LineStyle'
+            super k
+            Kamelopard.kml_array(k, [
+                [ @width, 'width' ],
+                [ @outerColor, 'gx:outerColor' ],
+                [ @outerWidth, 'gx:outerWidth' ],
+                [ @physicalWidth, 'gx:physicalWidth' ],
+            ])
+            elem.elements << k unless elem.nil?
+            k
+        end
     end
 
-    def to_kml(indent = 0)
-        k = "#{ ' ' * indent }<ListStyle id=\"#{@id}\">\n"
-        k << kml_array([
-            [@listitemtype, 'listItemType', true],
-            [@bgcolor, 'bgColor', true]
-        ], indent + 4)
-        if (! @state.nil? or ! @href.nil?) then
-            k << "#{ ' ' * indent }    <ItemIcon>\n"
-            k << "#{ ' ' * indent }        <state>#{@state}</state>\n" unless @state.nil? 
-            k << "#{ ' ' * indent }        <href>#{@href}</href>\n" unless @href.nil? 
-            k << "#{ ' ' * indent }    </ItemIcon>\n"
-        end
-        k << "#{ ' ' * indent }</ListStyle>\n"
-        k
-    end
-end
+    # 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
+        attr_accessor :listItemType, :bgColor, :state, :href
 
-# Corresponds to KML's PolyStyle 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 PolyStyle < ColorStyle
-    attr_accessor :fill, :outline
+        def initialize(bgcolor = nil, state = nil, href = nil, listitemtype = nil)
+            super(nil, :normal)
+            @bgcolor = bgcolor
+            @state = state
+            @href = href
+            @listitemtype = listitemtype
+        end
 
-    def initialize(fill = 1, outline = 1, color = 'ffffffff', colormode = :normal)
-        super(color, colormode)
-        @fill = fill
-        @outline = outline
+        def to_kml(elem = nil)
+            k = REXML::Element.new 'ListStyle'
+            super k
+            Kamelopard.kml_array(k, [
+                [@listitemtype, 'listItemType'],
+                [@bgcolor, 'bgColor']
+            ])
+            if (! @state.nil? or ! @href.nil?) then
+                i = REXML::Element.new 'ItemIcon'
+                Kamelopard.kml_array(i, [
+                    [ @state, 'state' ],
+                    [ @href, 'href' ]
+                ])
+                k.elements << i
+            end
+            elem.elements << k unless elem.nil?
+            k
+        end
     end
 
-    def to_kml(indent = 0)
+    # Corresponds to KML's PolyStyle 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 PolyStyle < ColorStyle
+        attr_accessor :fill, :outline
 
-        k = <<-polystyle
-#{ ' ' * indent }<PolyStyle id="#{@id}">
-#{ super(indent + 4) }
-#{ ' ' * indent }    <fill>#{@fill}</fill>
-        polystyle
-        k << "#{ ' ' * indent }    <outline>#{@outline}</outline>\n" unless @outline.nil?
-        k << "#{ ' ' * indent }</PolyStyle>\n"
-        k
-    end
-end
+        def initialize(fill = 1, outline = 1, color = 'ffffffff', colormode = :normal)
+            super(color, colormode)
+            @fill = fill
+            @outline = outline
+        end
 
-# Abstract class corresponding to KML's StyleSelector object.
-class StyleSelector < KMLObject
-    attr_accessor :attached
-    def initialize
-        super
-        @attached = false
-        Document.instance.styles << self
+        def to_kml(elem = nil)
+            k = REXML::Element.new 'PolyStyle'
+            super k
+            Kamelopard.kml_array( k, [
+                [ @fill, 'fill' ],
+                [ @outline, 'outline' ]
+            ])
+            elem.elements << k unless elem.nil?
+            k
+        end
     end
 
-    def attached?
-        @attached
-    end
+    # Abstract class corresponding to KML's StyleSelector object.
+    class StyleSelector < Object
+        attr_accessor :attached
+        def initialize
+            super
+            @attached = false
+            Document.instance.styles << self
+        end
 
-    def attach(obj)
-        @attached = true
-        obj.styles << self
-    end
-end
+        def attached?
+            @attached
+        end
 
-# Corresponds to KML's Style object. Attributes are expected to be IconStyle,
-# 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 attach(obj)
+            @attached = true
+            obj.styles << self
+        end
 
-    def to_kml(indent = 0)
-        k = ''
-        k << super + "#{ ' ' * indent }<Style id=\"#{@id}\">\n"
-        k << @icon.to_kml(indent + 4) unless @icon.nil?
-        k << @label.to_kml(indent + 4) unless @label.nil?
-        k << @line.to_kml(indent + 4) unless @line.nil?
-        k << @poly.to_kml(indent + 4) unless @poly.nil?
-        k << @balloon.to_kml(indent + 4) unless @balloon.nil?
-        k << @list.to_kml(indent + 4) unless @list.nil?
-        k << "#{ ' ' * indent }</Style>\n"
-        k
+        def to_kml(elem = nil)
+            elem = REXML::Element.new 'StyleSelector' if elem.nil?
+            super elem
+            elem
+        end
     end
-end
 
-# Corresponds to KML's StyleMap object.
-class StyleMap < StyleSelector
-    # 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()
-        @pairs = pairs
-    end
+    # Corresponds to KML's Style object. Attributes are expected to be IconStyle,
+    # 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
 
-    # Adds a new Style to the StyleMap.
-    def merge(a)
-        @pairs.merge(a)
+        def to_kml(elem = nil)
+            k = REXML::Element.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?
+            k
+        end
     end
 
-    def to_kml(indent = 0)
-        t = super + "#{ ' ' * indent }<StyleMap id=\"#{@id}\">\n"
-        @pairs.each do |k, v|
-            t << "#{ ' ' * indent }    <Pair>\n"
-            t << "#{ ' ' * indent }        <key>#{ k }</key>\n"
-            if v.kind_of? Style then
-                t << ( ' ' * indent ) << v.to_kml(indent + 8)
-            else
-                t << "#{ ' ' * indent }        <styleUrl>#{ v }</styleUrl>\n"
+    # Corresponds to KML's StyleMap object.
+    class StyleMap < StyleSelector
+        # 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()
+            @pairs = pairs
+        end
+
+        # Adds a new Style to the StyleMap.
+        def merge(a)
+            @pairs.merge!(a)
+        end
+
+        def to_kml(elem = nil)
+            t = REXML::Element.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 
+                if v.kind_of? Style then
+                    v.to_kml(p)
+                else
+                    s = REXML::Element.new 'styleUrl'
+                    s.text = v
+                    p.elements << s
+                end
+                t.elements << p
             end
-            t << "#{ ' ' * indent }    </Pair>\n"
+            elem.elements << t unless elem.nil?
+            t
         end
-        t << "#{ ' ' * indent }</StyleMap>\n"
-        t
     end
-end
 
-# Corresponds to KML's Placemark objects. The geometry attribute requires a
-# descendant of Geometry
-class Placemark < Feature
-    attr_accessor :name, :geometry
-    def initialize(name = nil, geo = nil)
-        super(name)
-        Document.instance.folder << self
-        if geo.respond_to? '[]' then
-            @geometry = geo
-        else
-            @geometry = [ geo ]
+    # Corresponds to KML's Placemark objects. The geometry attribute requires a
+    # 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
         end
-    end
-    
-    def to_kml(indent = 0)
-        a = "#{ ' ' * indent }<Placemark id=\"#{ @id }\">\n"
-        a << super(indent + 4) {
-            k = ''
-            @geometry.each do |i| k << i.to_kml(indent + 4) unless i.nil? end
+        
+        def to_kml(elem = nil)
+            k = REXML::Element.new 'Placemark'
+            super k
+            @geometry.each do |i| i.to_kml(k) unless i.nil? end
+            elem << k unless elem.nil?
             k
-        }
-        a << "#{ ' ' * indent }</Placemark>\n"
-    end
-
-    def to_s
-        "Placemark id #{ @id } named #{ @name }"
-    end
+        end
 
-    def longitude
-        @geometry.longitude
-    end
+        def to_s
+            "Placemark id #{ @id } named #{ @name }"
+        end
 
-    def latitude
-        @geometry.latitude
-    end
+        def longitude
+            @geometry.longitude
+        end
 
-    def altitude
-        @geometry.altitude
-    end
+        def latitude
+            @geometry.latitude
+        end
 
-    def altitudeMode
-        @geometry.altitudeMode
-    end
+        def altitude
+            @geometry.altitude
+        end
 
-    def point
-        if @geometry[0].kind_of? KMLPoint then
-            @geometry[0]
-        else
-            raise "This placemark uses a non-point geometry, but the operation you're trying requires a point object"
+        def altitudeMode
+            @geometry.altitudeMode
         end
-    end
-end
 
-# Abstract class corresponding to KML's gx:TourPrimitive object. Tours are made up
-# of descendants of these.
-class TourPrimitive < KMLObject
-    def initialize
-        Document.instance.tour << self
+        def point
+            if @geometry[0].kind_of? Point then
+                @geometry[0]
+            else
+                raise "This placemark uses a non-point geometry, but the operation you're trying requires a point object"
+            end
+        end
     end
-end
 
-# Cooresponds to KML's gx:FlyTo object. The @view parameter needs to look like an
-# AbstractView object
-class FlyTo < TourPrimitive
-    attr_accessor :duration, :mode, :view
-
-    def initialize(view = nil, range = nil, duration = 0, mode = :bounce)
-        @duration = duration
-        @mode = mode
-        if view.kind_of? AbstractView then
-            @view = view
-        else
-            @view = LookAt.new(view)
+    # Abstract class corresponding to KML's gx:TourPrimitive object. Tours are made up
+    # of descendants of these.
+    class TourPrimitive < Object
+        def initialize
+            Document.instance.tour << self
+            super
         end
-        if view.respond_to? 'range' and not range.nil? then
-            @view.range = range
-        end
-        super()
     end
 
-    def to_kml(indent = 0)
-        k = super + "#{ ' ' * indent }<gx:FlyTo>\n"
-        k << kml_array([
-            [ @duration, 'gx:duration', true ],
-            [ @mode, 'gx:flyToMode', true ]
-        ], indent + 4)
-        k << @view.to_kml(indent + 4) unless @view.nil?
-        k << "#{ ' ' * indent }</gx:FlyTo>\n"
-    end
-end
+    # Cooresponds to KML's gx:FlyTo object. The @view parameter needs to look like an
+    # AbstractView object
+    class FlyTo < TourPrimitive
+        attr_accessor :duration, :mode, :view
 
-# Corresponds to KML's gx:AnimatedUpdate object. For now at least, this isn't very
-# intelligent; you've got to manually craft the <Change> tag(s) within the
-# object.
-class AnimatedUpdate < TourPrimitive
-    # 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
-
-    # 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? KMLObject
-            @target = target.id
-        rescue RuntimeError
-            @target = target
-        end
-        @updates = updates
-        @duration = duration
-        @delayedstart = delayedstart
-    end
+        def initialize(view = nil, range = nil, duration = 0, mode = :bounce)
+            @duration = duration
+            @mode = mode
+            if view.kind_of? AbstractView then
+                @view = view
+            else
+                @view = LookAt.new(view)
+            end
+            if view.respond_to? 'range' and not range.nil? then
+                @view.range = range
+            end
+            super()
+        end
 
-    # Adds another update string, presumably containing a <Change> element
-    def <<(a)
-        @updates << a << "\n"
+        def to_kml(elem = nil)
+            k = REXML::Element.new 'gx:FlyTo'
+            super k
+            Kamelopard.kml_array(k, [
+                [ @duration, 'gx:duration' ],
+                [ @mode, 'gx:flyToMode' ]
+            ])
+            @view.to_kml k unless @view.nil?
+            elem << k unless elem.nil?
+            k
+        end
     end
 
-    def to_kml(indent = 0)
-        k = super + <<-animatedupdate_kml
-#{ ' ' * indent }<gx:AnimatedUpdate>
-#{ ' ' * indent }    <gx:duration>#{@duration}</gx:duration>
-        animatedupdate_kml
-        k << "#{ ' ' * indent }    <gx:delayeStart>#{@delayedstart}</gx:delayedStart>\n" unless @delayedstart.nil?
-        k << "#{ ' ' * indent }    <Update>\n"
-        k << "#{ ' ' * indent }        <targetHref>#{@target}</targetHref>\n"
-        k << "#{ ' ' * indent }        " << @updates.join("\n#{ ' ' * (indent + 1) }")
-        k << "#{ ' ' * indent }    </Update>\n#{ ' ' * indent }</gx:AnimatedUpdate>\n"
-        k
-    end
-end
+    # Corresponds to KML's gx:AnimatedUpdate object. For now at least, this isn't very
+    # intelligent; you've got to manually craft the <Change> tag(s) within the
+    # object.
+    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
+
+        # 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
+                @target = target
+            end
+            @updates = updates
+            @duration = duration
+            @delayedStart = delayedstart
+        end
 
-# Corresponds to a KML gx:TourControl object
-class TourControl < TourPrimitive
-    def initialize
-        super
-    end
+        # Adds another update string, presumably containing a <Change> element
+        def <<(a)
+            @updates << REXML::Document.new(a).root
+        end
 
-    def to_kml(indent = 0)
-        k = "#{ ' ' * indent }<gx:TourControl id=\"#{ @id }\">\n"
-        k << "#{ ' ' * indent }    <gx:playMode>pause</gx:playMode>\n"
-        k << "#{ ' ' * indent }</gx:TourControl>\n"
+        def to_kml(elem = nil)
+            k = REXML::Element.new 'gx:AnimatedUpdate'
+            super(k)
+            d = REXML::Element.new 'gx:duration'
+            d.text = @duration
+            k << d
+            if not @delayedStart.nil? then
+                d = REXML::Element.new 'gx:delayedStart'
+                d.text = @delayedStart
+                k << d
+            end
+            d = REXML::Element.new 'Update'
+            q = REXML::Element.new 'targetHref'
+            q.text = @target
+            d << q
+            @updates.each do |i| d << i end
+            k << d
+            elem << k unless elem.nil?
+            k
+        end
     end
-end
 
-# Corresponds to a KML gx:Wait object
-class Wait < TourPrimitive
-    attr_accessor :duration
-    def initialize(duration = 0)
-        super()
-        @duration = duration
-    end
+    # Corresponds to a KML gx:TourControl object
+    class TourControl < TourPrimitive
+        def initialize
+            super
+        end
 
-    def to_kml(indent = 0)
-        super + <<-wait_kml
-#{ ' ' * indent }<gx:Wait><gx:duration>#{@duration}</gx:duration></gx:Wait>
-        wait_kml
+        def to_kml(elem = nil)
+            k = REXML::Element.new 'gx:TourControl'
+            super(k)
+            q = REXML::Element.new 'gx:playMode'
+            q.text = 'pause'
+            k << q
+            elem << k unless elem.nil?
+            k
+        end
     end
-end
 
-# Corresponds to a KML gx:SoundCue object
-class SoundCue < TourPrimitive
-    attr_accessor :href, :delayedStart
-    def initialize(href, delayedStart = nil)
-        super()
-        @href = href
-        @delayedStart = delayedStart
-    end
+    # Corresponds to a KML gx:Wait object
+    class Wait < TourPrimitive
+        attr_accessor :duration
+        def initialize(duration = 0)
+            super()
+            @duration = duration
+        end
 
-    def to_kml(indent = 0)
-        k = "#{ ' ' * indent }<gx:SoundCue id=\"#{ @id }\">\n"
-        k << "#{ ' ' * indent }    <href>#{ @href }</href>\n"
-        k << "#{ ' ' * indent }    <gx:delayedStart>#{ @delayedStart }</gx:delayedStart>\n" unless @delayedStart.nil?
-        k << "#{ ' ' * indent}</gx:SoundCue>\n"
+        def to_kml(elem = nil)
+            k = REXML::Element.new 'gx:Wait'
+            super k
+            d = REXML::Element.new 'gx:duration'
+            d.text = @duration
+            k << d
+            elem << k unless elem.nil?
+            k
+        end
     end
-end
 
-# Corresponds to a KML gx:Tour object
-class Tour < KMLObject
-    attr_accessor :name, :description, :last_abs_view
-    def initialize(name = nil, description = nil)
-        super()
-        @name = name
-        @description = description
-        @items = []
-    end
+    # Corresponds to a KML gx:SoundCue object
+    class SoundCue < TourPrimitive
+        attr_accessor :href, :delayedStart
+        def initialize(href, delayedStart = nil)
+            super()
+            @href = href
+            @delayedStart = delayedStart
+        end
 
-    # Add another element to this Tour
-    def <<(a)
-        @items << a
-        @last_abs_view = a.view if a.kind_of? FlyTo
+        def to_kml(elem = nil)
+            k = REXML::Element.new 'gx:SoundCue'
+            super k
+            d = REXML::Element.new 'href'
+            d.text = @href
+            k << d
+            if not @delayedStart.nil? then
+                d = REXML::Element.new 'gx:delayedStart'
+                d.text = @delayedStart
+                k << d
+            end
+            elem << k unless elem.nil?
+            k
+        end
     end
 
-    def to_kml(indent = 0)
-        k = super + "#{ ' ' * indent }<gx:Tour id=\"#{ @id }\">\n"
-        k << kml_array([
-            [ @name, 'name', true ],
-            [ @description, 'description', true ],
-        ], indent + 4)
-        k << "#{ ' ' * indent }    <gx:Playlist>\n";
+    # Corresponds to a KML gx:Tour object
+    class Tour < Object
+        attr_accessor :name, :description, :last_abs_view
+        def initialize(name = nil, description = nil)
+            super()
+            @name = name
+            @description = description
+            @items = []
+            Document.instance.tours << self
+        end
 
-        @items.map do |a| k << a.to_kml(indent + 8) << "\n" end
+        # Add another element to this Tour
+        def <<(a)
+            @items << a
+            @last_abs_view = a.view if a.kind_of? FlyTo
+        end
 
-        k << "#{ ' ' * indent }    </gx:Playlist>\n"
-        k << "#{ ' ' * indent }</gx:Tour>\n"
-        k
+        def to_kml(elem = nil)
+            k = REXML::Element.new 'gx:Tour'
+            super k
+            Kamelopard.kml_array(k, [
+                [ @name, 'name' ],
+                [ @description, 'description' ],
+            ])
+            p = REXML::Element.new 'gx:Playlist'
+            @items.map do |a| a.to_kml p end
+            k << p
+            elem << k unless elem.nil?
+            k
+        end
     end
-end
 
-# Abstract class corresponding to the KML Overlay object
-class Overlay < Feature
-    attr_accessor :color, :drawOrder, :icon
+    # Abstract class corresponding to the KML Overlay object
+    class Overlay < Feature
+        attr_accessor :color, :drawOrder, :icon
 
-    def initialize(icon, name = nil)
-        super(name)
-        if icon.respond_to?('to_kml') then
-            @icon = icon
-        elsif not icon.nil?
-            @icon = Icon.new(icon.to_s)
+        def initialize(icon, name = nil)
+            super(name)
+            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
-        Document.instance.folder << self
-    end
 
-    def to_kml(indent = 0)
-        k = super(indent) + kml_array([
-            [ @color, 'color', true ],
-            [ @drawOrder, 'drawOrder', true ],
-        ], indent + 4)
-        k << @icon.to_kml(indent) unless @icon.nil?
-        k
+        def to_kml(elem)
+            super
+            Kamelopard.kml_array(elem, [
+                [ @color, 'color' ],
+                [ @drawOrder, 'drawOrder' ],
+            ])
+            @icon.to_kml(elem) unless @icon.nil?
+            elem
+        end
     end
-end
 
-# 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
+    # 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(indent = 0)
-        k = "#{ ' ' * indent }<ScreenOverlay id=\"#{ @id }\">\n"
-        k << super(indent + 4)
-        k << @overlayXY.to_kml('overlayXY', indent + 4)   unless @overlayXY.nil?
-        k << @screenXY.to_kml('screenXY', indent + 4)     unless @screenXY.nil?
-        k << @rotationXY.to_kml('rotationXY', indent + 4) unless @rotationXY.nil?
-        k << @size.to_kml('size', indent + 4)             unless @size.nil?
-        k << "#{ ' ' * indent }    <rotation>#{ @rotation }</rotation>\n" unless @rotation.nil?
-        k << "#{ ' ' * indent }</ScreenOverlay>\n"
+        def to_kml(elem = nil)
+            k = REXML::Element.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
+                k << d
+            end
+            elem << k unless elem.nil?
+            k
+        end
     end
-end
 
-# Supporting object for the PhotoOverlay class
-class 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
+    # Supporting object for the PhotoOverlay class
+    class 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(indent = 0)
-
-        <<-viewvolume
-#{ ' ' * indent }<ViewVolume>
-#{ ' ' * indent }    <near>#{@near}</near>
-#{ ' ' * indent }    <leftFov>#{@leftFov}</leftFov>
-#{ ' ' * indent }    <rightFov>#{@rightFov}</rightFov>
-#{ ' ' * indent }    <bottomFov>#{@bottomFov}</bottomFov>
-#{ ' ' * indent }    <topFov>#{@topFov}</topFov>
-#{ ' ' * indent }</ViewVolume>
-        viewvolume
+        def to_kml(elem = nil)
+            p = REXML::Element.new 'ViewVolume'
+            {
+                :near => @near,
+                :leftFov => @leftFov,
+                :rightFov => @rightFov,
+                :topFov => @topFov,
+                :bottomFov => @bottomFov
+            }.each do |k, v|
+                d = REXML::Element.new k.to_s
+                d.text = v
+                p << d
+            end
+            elem << p unless elem.nil?
+            p
+        end
     end
-end
 
-# Supporting object for the PhotoOverlay class
-class ImagePyramid
-    attr_accessor :tileSize, :maxWidth, :maxHeight, :gridOrigin
+    # Supporting object for the PhotoOverlay class
+    class ImagePyramid
+        attr_accessor :tileSize, :maxWidth, :maxHeight, :gridOrigin
 
-    def initialize(maxWidth, maxHeight, gridOrigin, tileSize = 256)
-        @tileSize = tileSize
-        @maxWidth = maxWidth
-        @maxHeight = maxHeight
-        @gridOrigin = gridOrigin
-    end
+        def initialize(maxWidth, maxHeight, gridOrigin, tileSize = 256)
+            @tileSize = tileSize
+            @maxWidth = maxWidth
+            @maxHeight = maxHeight
+            @gridOrigin = gridOrigin
+        end
 
-    def to_kml(indent = 0)
-        
-        <<-imagepyramid
-#{ ' ' * indent }<ImagePyramid>
-#{ ' ' * indent }    <tileSize>#{@tileSize}</tileSize>
-#{ ' ' * indent }    <maxWidth>#{@maxWidth}</maxWidth>
-#{ ' ' * indent }    <maxHeight>#{@maxHeight}</maxHeight>
-#{ ' ' * indent }    <gridOrigin>#{@gridOrigin}</gridOrigin>
-#{ ' ' * indent }</ImagePyramid>
-        imagepyramid
+        def to_kml(elem = nil)
+            p = REXML::Element.new 'ImagePyramid'
+            {
+                :tileSize => @tileSize,
+                :maxWidth => @maxWidth,
+                :maxHeight => @maxHeight,
+                :gridOrigin => @gridOrigin
+            }.each do |k, v|
+                d = REXML::Element.new k.to_s
+                d.text = v
+                p << d
+            end
+            elem << p unless elem.nil?
+            p
+        end
     end
-end
 
-# Corresponds to KML's PhotoOverlay class
-class PhotoOverlay < Overlay
-    attr_accessor :rotation, :viewvolume, :imagepyramid, :point, :shape
+    # Corresponds to KML's PhotoOverlay class
+    class PhotoOverlay < Overlay
+        attr_accessor :rotation, :viewvolume, :imagepyramid, :point, :shape
 
-    def initialize(icon, point, rotation = 0, viewvolume = nil, imagepyramid = nil, shape = :rectangle)
-        super(icon)
-        if point.respond_to?('point')
-            @point = point.point
-        else
-            @point = point
+        def initialize(icon, point, rotation = 0, viewvolume = nil, imagepyramid = nil, shape = :rectangle)
+            super(icon)
+            if point.respond_to?('point')
+                @point = point.point
+            else
+                @point = point
+            end
+            @rotation = rotation
+            @viewVolume = viewvolume
+            @imagePyramid = imagepyramid
+            @shape = shape
         end
-        @rotation = rotation
-        @viewVolume = viewvolume
-        @imagePyramid = imagepyramid
-        @shape = shape
-    end
 
-    def to_kml(indent = 0)
-        k = "#{ ' ' * indent }<PhotoOverlay>\n"
-        k << super(indent + 4)
-        k << @viewVolume.to_kml(indent + 4) unless @viewVolume.nil?
-        k << @imagePyramid.to_kml(indent + 4) unless @imagePyramid.nil?
-        k << @point.to_kml(indent + 4, true)
-        k << "#{ ' ' * indent }    <rotation>#{ @rotation }</rotation>\n"
-        k << "#{ ' ' * indent }    <shape>#{ @shape }</shape>\n"
-        k << "#{ ' ' * indent }</PhotoOverlay>\n"
+        def to_kml(elem = nil)
+            p = REXML::Element.new 'PhotoOverlay'
+            super p
+            @viewVolume.to_kml p   unless @viewVolume.nil?
+            @imagePyramid.to_kml p unless @imagePyramid.nil?
+            p << @point.to_kml(true)
+            {
+                :rotation => @rotation,
+                :shape => @shape
+            }.each do |k, v|
+                d = REXML::Element.new k.to_s
+                d.text = v
+                p << d
+            end
+            elem << p unless elem.nil?
+            p
+        end
     end
-end
 
-# Corresponds to KML's LatLonBox and LatLonAltBox
-class LatLonBox
-    attr_reader :north, :south, :east, :west
-    attr_accessor :rotation, :minAltitude, :maxAltitude, :altitudeMode
-
-    def initialize(north, south, east, west, rotation = 0, minAltitude = nil, maxAltitude = nil, altitudeMode = :clampToGround)
-        @north = convert_coord north
-        @south = convert_coord south
-        @east = convert_coord east
-        @west = convert_coord west
-        @minAltitude = minAltitude
-        @maxAltitude = maxAltitude
-        @altitudeMode = altitudeMode
-        @rotation = rotation
-    end
+    # Corresponds to KML's LatLonBox and LatLonAltBox
+    class LatLonBox
+        attr_reader :north, :south, :east, :west
+        attr_accessor :rotation, :minAltitude, :maxAltitude, :altitudeMode
+
+        def initialize(north, south, east, west, rotation = 0, minAltitude = nil, maxAltitude = nil, altitudeMode = :clampToGround)
+            @north = Kamelopard.convert_coord north
+            @south = Kamelopard.convert_coord south
+            @east = Kamelopard.convert_coord east
+            @west = Kamelopard.convert_coord west
+            @minAltitude = minAltitude
+            @maxAltitude = maxAltitude
+            @altitudeMode = altitudeMode
+            @rotation = rotation
+        end
 
-    def north=(a)
-        @north = convert_coord a
-    end
+        def north=(a)
+            @north = Kamelopard.convert_coord a
+        end
 
-    def south=(a)
-        @south = convert_coord a
-    end
+        def south=(a)
+            @south = Kamelopard.convert_coord a
+        end
 
-    def east=(a)
-        @east = convert_coord a
-    end
+        def east=(a)
+            @east = Kamelopard.convert_coord a
+        end
 
-    def west=(a)
-        @west = convert_coord a
-    end
+        def west=(a)
+            @west = Kamelopard.convert_coord a
+        end
 
-    def to_kml(indent = 0, alt = false)
-        name = alt ? 'LatLonAltBox' : 'LatLonBox'
-        k = <<-latlonbox
-#{ ' ' * indent }<#{ name }>
-#{ ' ' * indent }    <north>#{ @north }</north>
-#{ ' ' * indent }    <south>#{ @south }</south>
-#{ ' ' * indent }    <east>#{ @east }</east>
-#{ ' ' * indent }    <west>#{ @west }</west>
-        latlonbox
-        k << "#{ ' ' * indent }    <minAltitude>#{ @minAltitude }</minAltitude>\n" unless @minAltitude.nil?
-        k << "#{ ' ' * indent }    <maxAltitude>#{ @maxAltitude }</maxAltitude>\n" unless @maxAltitude.nil?
-        if (not @minAltitude.nil? or not @maxAltitude.nil?) then
-            if @altitudeMode == :clampToGround or @altitudeMode == :relativeToGround or @altitudeMode == :absolute then
-                altitudeModeString = "#{ ' ' * indent }    <altitudeMode>#{ @altitudeMode }</altitudeMode>\n"
-            else
-                altitudeModeString = "#{ ' ' * indent }    <gx:altitudeMode>#{ @altitudeMode }</gx:altitudeMode>\n"
+        def to_kml(elem = nil, alt = false)
+            name = alt ? 'LatLonAltBox' : 'LatLonBox'
+            k = REXML::Element.new name
+            [
+                ['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
+                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?
+            k
         end
-        k << <<-latlonbox2
-#{ ' ' * indent }    <rotation>#{ @rotation }</rotation>
-#{ ' ' * indent }</#{ name }>
-        latlonbox2
     end
-end
-
-# Corresponds to KML's gx:LatLonQuad object
-class LatLonQuad
-    attr_accessor :lowerLeft, :lowerRight, :upperRight, :upperLeft
-    def initialize(lowerLeft, lowerRight, upperRight, upperLeft)
-        @lowerLeft = lowerLeft
-        @lowerRight = lowerRight
-        @upperRight = upperRight
-        @upperLeft = upperLeft
-    end
-
-    def to_kml(indent = 0)
 
-        <<-latlonquad
-#{ ' ' * indent }<gx:LatLonQuad>
-#{ ' ' * indent }    <coordinates>#{ @lowerLeft.longitude },#{ @lowerLeft.latitude } #{ @lowerRight.longitude },#{ @lowerRight.latitude } #{ @upperRight.longitude },#{ @upperRight.latitude } #{ @upperLeft.longitude },#{ @upperLeft.latitude }</coordinates>
-#{ ' ' * indent }</gx:LatLonQuad>
-        latlonquad
-    end
-end
+    # Corresponds to KML's gx:LatLonQuad object
+    class LatLonQuad
+        attr_accessor :lowerLeft, :lowerRight, :upperRight, :upperLeft
+        def initialize(lowerLeft, lowerRight, upperRight, upperLeft)
+            @lowerLeft = lowerLeft
+            @lowerRight = lowerRight
+            @upperRight = upperRight
+            @upperLeft = upperLeft
+        end
 
-# 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)
-        @latlonbox = latlonbox
-        @latlonquad = latlonquad
-        @altitude = altitude
-        @altitudeMode = altitudeMode
+        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 << d
+            elem << k unless elem.nil?
+            k
+        end
     end
 
-    def to_kml(indent = 0)
-        raise "Either latlonbox or latlonquad must be non-nil" if @latlonbox.nil? and @latlonquad.nil?
-
-        k = "#{ ' ' * indent}<GroundOverlay id=\"#{ @id }\">\n"
-        k << super(indent + 4)
-        k << "#{ ' ' * indent }    <altitude>#{ @altitude }</altitude>\n"
-        k << ' ' * indent
-        if @altitudeMode == :clampToGround or @altitudeMode == :relativeToGround or @altitudeMode == :absolute then
-            k << "#{ ' ' * indent }    <altitudeMode>#{ @altitudeMode }</altitudeMode>\n"
-        else
-            k << "#{ ' ' * indent }    <gx:altitudeMode>#{ @altitudeMode }</gx:altitudeMode>\n"
+    # 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)
+            @latlonbox = latlonbox
+            @latlonquad = latlonquad
+            @altitude = altitude
+            @altitudeMode = altitudeMode
         end
-        k << @latlonbox.to_kml(indent + 4) unless @latlonbox.nil?
-        k << @latlonquad.to_kml(indent + 4) unless @latlonquad.nil?
-        k << "#{ ' ' * indent }</GroundOverlay>\n"
-        k
-    end
-end
 
-# Corresponds to the LOD (Level of Detail) object
-class Lod
-    attr_accessor :minpixels, :maxpixels, :minfade, :maxfade
-    def initialize(minpixels, maxpixels, minfade, maxfade)
-        @minpixels = minpixels
-        @maxpixels = maxpixels
-        @minfade = minfade
-        @maxfade = maxfade
+        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'
+            super k
+            d = REXML::Element.new 'altitude'
+            d.text = @altitude
+            k << d
+            Kamelopard.add_altitudeMode(@altitudeMode, k)
+            @latlonbox.to_kml(k) unless @latlonbox.nil?
+            @latlonquad.to_kml(k) unless @latlonquad.nil?
+            elem << k unless elem.nil?
+            k
+        end
     end
 
-    def to_kml(indent = 0)
+    # Corresponds to the LOD (Level of Detail) object
+    class Lod
+        attr_accessor :minpixels, :maxpixels, :minfade, :maxfade
+        def initialize(minpixels, maxpixels, minfade, maxfade)
+            @minpixels = minpixels
+            @maxpixels = maxpixels
+            @minfade = minfade
+            @maxfade = maxfade
+        end
 
-        <<-lod
-#{ ' ' * indent }<Lod>
-#{ ' ' * indent }    <minLodPixels>#{ @minpixels }</minLodPixels>
-#{ ' ' * indent }    <maxLodPixels>#{ @maxpixels }</maxLodPixels>
-#{ ' ' * indent }    <minFadeExtent>#{ @minfade }</minFadeExtent>
-#{ ' ' * indent }    <maxFadeExtent>#{ @maxfade }</maxFadeExtent>
-#{ ' ' * indent }</Lod>
-        lod
+        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
+        end
     end
-end
 
-# Corresponds to the KML Region object
-class Region < KMLObject
-    attr_accessor :latlonaltbox, :lod
+    # Corresponds to the KML Region object
+    class Region < Object
+        attr_accessor :latlonaltbox, :lod
 
-    def initialize(latlonaltbox, lod)
-        super()
-        @latlonaltbox = latlonaltbox
-        @lod = lod
-    end
+        def initialize(latlonaltbox, lod)
+            super()
+            @latlonaltbox = latlonaltbox
+            @lod = lod
+        end
 
-    def to_kml(indent = 0)
-        k = "#{' ' * indent}<Region id=\"#{@id}\">\n"
-        k << @latlonaltbox.to_kml(indent + 4, true) unless @latlonaltbox.nil?
-        k << @lod.to_kml(indent + 4) unless @lod.nil?
-        k << "#{' ' * indent}</Region>\n"
-        k
+        def to_kml(elem = nil)
+            k = REXML::Element.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?
+            k
+        end
     end
-end
 
-# Sub-object in the KML Model class
-class Orientation
-    attr_accessor :heading, :tilt, :roll
-    def initialize(heading, tilt, roll)
-        @heading = heading
-        # Although the KML reference by Google is clear on these ranges, Google Earth
-        # supports values outside the ranges, and sometimes it's useful to use
-        # them. So I'm turning off this error checking
-#        raise "Heading should be between 0 and 360 inclusive; you gave #{ heading }" unless @heading <= 360 and @heading >= 0
-        @tilt = tilt
-#        raise "Tilt should be between 0 and 180 inclusive; you gave #{ tilt }" unless @tilt <= 180 and @tilt >= 0
-        @roll = roll
-#        raise "Roll should be between 0 and 180 inclusive; you gave #{ roll }" unless @roll <= 180 and @roll >= 0
-    end
+    # Sub-object in the KML Model class
+    class Orientation
+        attr_accessor :heading, :tilt, :roll
+        def initialize(heading, tilt, roll)
+            @heading = heading
+            # Although the KML reference by Google is clear on these ranges, Google Earth
+            # supports values outside the ranges, and sometimes it's useful to use
+            # them. So I'm turning off this error checking
+            #raise "Heading should be between 0 and 360 inclusive; you gave #{ heading }" unless @heading <= 360 and @heading >= 0
+            @tilt = tilt
+            #raise "Tilt should be between 0 and 180 inclusive; you gave #{ tilt }" unless @tilt <= 180 and @tilt >= 0
+            @roll = roll
+            #raise "Roll should be between 0 and 180 inclusive; you gave #{ roll }" unless @roll <= 180 and @roll >= 0
+        end
 
-    def to_kml(indent = 0)
-        k = "#{ ' ' * indent }<Orientation>\n"
-        k << "#{ ' ' * indent }    <heading>#{ @heading }</heading>\n"
-        k << "#{ ' ' * indent }    <tilt>#{ @tilt }</tilt>\n"
-        k << "#{ ' ' * indent }    <roll>#{ @roll }</roll>\n"
-        k << "#{ ' ' * indent }</Orientation>\n"
-        k
+        def to_kml(elem = nil)
+            x = REXML::Element.new 'Orientation'
+            {
+                :heading => @heading,
+                :tilt => @tilt,
+                :roll => @roll
+            }.each do |k, v|
+                d = REXML::Element.new k.to_s
+                d.text = v
+                x << d
+            end
+            elem << x unless elem.nil?
+            x
+        end
     end
-end
 
-# Sub-object in the KML Model class
-class Scale
-    attr_accessor :x, :y, :z
-    def initialize(x, y, z = 1)
-        @x = x
-        @y = y
-        @z = z
-    end
+    # Sub-object in the KML Model class
+    class Scale
+        attr_accessor :x, :y, :z
+        def initialize(x, y, z = 1)
+            @x = x
+            @y = y
+            @z = z
+        end
 
-    def to_kml(indent = 0)
-        k = "#{ ' ' * indent }<Scale>\n"
-        k << "#{ ' ' * indent }    <x>#{ x }</x>\n"
-        k << "#{ ' ' * indent }    <y>#{ y }</y>\n"
-        k << "#{ ' ' * indent }    <z>#{ z }</z>\n"
-        k << "#{ ' ' * indent }</Scale>\n"
+        def to_kml(elem = nil)
+            x = REXML::Element.new 'Scale'
+            {
+                :x => @x,
+                :y => @y,
+                :z => @z
+            }.each do |k, v|
+                d = REXML::Element.new k.to_s
+                d.text = v
+                x << d
+            end
+            elem << x unless elem.nil?
+            x
+        end
     end
-end
 
-# Sub-object in the KML ResourceMap class
-class Alias
-    attr_accessor :targetHref, :sourceHref
-    def initialize(targetHref = nil, sourceHref = nil)
-        @targetHref = targetHref
-        @sourceHref = sourceHref
-    end
+    # Sub-object in the KML ResourceMap class
+    class Alias
+        attr_accessor :targetHref, :sourceHref
+        def initialize(targetHref = nil, sourceHref = nil)
+            @targetHref = targetHref
+            @sourceHref = sourceHref
+        end
 
-    def to_kml(indent = 0)
-        k = "#{ ' ' * indent }<Alias>\n"
-        k << "#{ ' ' * indent }    <targetHref>#{ @targetHref }</targetHref>\n"
-        k << "#{ ' ' * indent }    <sourceHref>#{ @sourceHref }</sourceHref>\n"
-        k << "#{ ' ' * indent }</Alias>\n"
-        k
+        def to_kml(elem = nil)
+            x = REXML::Element.new 'Alias'
+            {
+                :targetHref => @targetHref,
+                :sourceHref => @sourceHref,
+            }.each do |k, v|
+                d = REXML::Element.new k.to_s
+                d.text = v
+                x << d
+            end
+            elem << x unless elem.nil?
+            x
+        end
     end
-end
 
-# Sub-object in the KML Model class
-class ResourceMap
-    attr_accessor :aliases
-    def initialize(aliases = [])
-        @aliases = []
-        if not aliases.nil? then
-            if aliases.kind_of? Enumerable then
-                @aliases += aliases
-            else
-                @aliases << aliases
+    # Sub-object in the KML Model class
+    class ResourceMap
+        attr_accessor :aliases
+        def initialize(aliases = [])
+            @aliases = []
+            if not aliases.nil? then
+                if aliases.kind_of? Enumerable then
+                    @aliases += aliases
+                else
+                    @aliases << aliases
+                end
             end
         end
-    end
 
-    def to_kml(indent = 0)
-        return '' if @aliases.size == 0
-        k = "#{ ' ' * indent }<ResourceMap>\n"
-        k << "#{ ' ' * indent }</ResourceMap>\n"
-        @aliases.each do |a| k << a.to_kml(indent + 4) end
-        k
+        def to_kml(elem = nil)
+            k = REXML::Element.new 'ResourceMap'
+            @aliases.each do |a| k << a.to_kml(k) end
+            elem << k unless elem.nil?
+            k
+        end
     end
-end
 
-# Corresponds to KML's Link object
-class Link < KMLObject
-    attr_accessor :href, :refreshMode, :refreshInterval, :viewRefreshMode, :viewBoundScale, :viewFormat, :httpQuery
-    def initialize(href = '', refreshMode = :onChange, viewRefreshMode = :never)
-        super()
-        @href = href
-        @refreshMode = refreshMode
-        @viewRefreshMode = viewRefreshMode
-    end
+    # 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
+        end
 
-    def to_kml(indent = 0)
-        k = "#{ ' ' * indent }<Link id=\"#{ @id }\">\n"
-        k << "#{ ' ' * indent }    <href>#{ @href }</href>\n"
-        k << "#{ ' ' * indent }    <refreshMode>#{ @refreshMode }</refreshMode>\n"
-        k << "#{ ' ' * indent }    <viewRefreshMode>#{ @viewRefreshMode }</viewRefreshMode>\n"
-        k << "#{ ' ' * indent }    <refreshInterval>#{ @refreshInterval }</refreshInterval>\n" unless @refreshInterval.nil?
-        k << "#{ ' ' * indent }    <viewBoundScale>#{ @viewBoundScale }</viewBoundScale>\n" unless @viewBoundScale.nil?
-        k << "#{ ' ' * indent }    <viewFormat>#{ @viewFormat }</viewFormat>\n" unless @viewFormat.nil?
-        k << "#{ ' ' * indent }    <httpQuery>#{ @httpQuery }</httpQuery>\n" unless @httpQuery.nil?
-        k << "#{ ' ' * indent }</Link>\n"
-        k
+        def to_kml(elem = nil)
+            x = REXML::Element.new 'Link'
+            super x
+            {
+                :href => @href,
+                :refreshMode => @refreshMode,
+                :viewRefreshMode => @viewRefreshMode,
+            }.each do |k, v|
+                d = REXML::Element.new k.to_s
+                d.text = v
+                x << d
+            end
+            Kamelopard.kml_array(x, [
+                [ @refreshInterval, 'refreshInterval' ],
+                [ @viewBoundScale, 'viewBoundScale' ],
+                [ @viewFormat, 'viewFormat' ],
+                [ @httpQuery, 'httpQuery' ]
+            ])
+            elem << x unless elem.nil?
+            x
+        end
     end
-end
 
-# Corresponds to the KML Model class
-class Model < Geometry
-    attr_accessor :link, :location, :orientation, :scale, :resourceMap
-
-    # location should be a KMLPoint, 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
-    end
+    # Corresponds to the KML Model class
+    class Model < Geometry
+        attr_accessor :link, :location, :orientation, :scale, :resourceMap
+
+        # 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
+        end
 
-    def to_kml(indent = 0)
-        k = "#{ ' ' * indent }<Model id=\"#{ @id }\">\n"
-        k << @link.to_kml(indent + 4)
-        if @location.altitudeMode == :clampToGround or @location.altitudeMode == :relativeToGround or @location.altitudeMode == :absolute then
-            k << "#{ ' ' * indent }    <altitudeMode>#{ @location.altitudeMode }</altitudeMode>\n"
-        else
-            k << "#{ ' ' * indent }    <gx:altitudeMode>#{ @location.altitudeMode }</gx:altitudeMode>\n"
-        end
-        k << "#{ ' ' * indent }    <Location>\n"
-        k << "#{ ' ' * indent }        <longitude>#{ @location.longitude }</longitude>\n"
-        k << "#{ ' ' * indent }        <latitude>#{ @location.latitude }</latitude>\n"
-        k << "#{ ' ' * indent }        <altitude>#{ @location.altitude }</altitude>\n"
-        k << "#{ ' ' * indent }    </Location>\n"
-        k << @orientation.to_kml(indent + 4)
-        k << @scale.to_kml(indent + 4)
-        k << @resourceMap.to_kml(indent + 4)
-        k << "#{ ' ' * indent }</Model>\n"
-        k
+        def to_kml(elem = nil)
+            x = REXML::Element.new 'Model'
+            super x
+            loc = REXML::Element.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
+                loc << d
+            end
+            x << loc
+            Kamelopard.add_altitudeMode(@location.altitudeMode, x)
+            @link.to_kml x
+            @orientation.to_kml x
+            @scale.to_kml x
+            @resourceMap.to_kml x
+            elem << x unless elem.nil?
+            x
+        end
     end
+
 end
+# End of Kamelopard module