bio-graphics 1.2 → 1.4

data/lib/bio/graphics/feature.rb

@@ -1,440 +1,212 @@
-require 'yaml'
-# 
-# = bio/graphics/feature.rb - feature class
-#
-# Copyright::   Copyright (C) 2007
-#               Jan Aerts <jan.aerts@bbsrc.ac.uk>
-# License::     The Ruby License
-# 
-module Bio
-  module Graphics
-    class Panel
-      class Track
-        # The Bio::Graphics::Track::Feature class describes features to be
-        # placed on the graph. See Bio::Graphics documentation for explanation
-        # of interplay between different classes.
-        #
-        # The position of the Feature is a Bio::Locations object to make it possible
-        # to transparently work with simple and spliced features.
-        class Feature
-          # !!Not to be used directly. Use
-          # Bio::Graphics::Panel::Track.add_feature instead!!
-          # A feature can not exist except within the confines of a
-          # Bio::Graphics::Panel::Track object.
-          #
-          #--
-          # This is necessary because the feature needs to know the colour and glyph,
-          # both of which are defined within the panel.
-          #++
-          #
-          # ---
-          # *Arguments*:
-          # * _panel_ (required) :: Bio::Graphics::Panel::Track object that this
-          #   feature belongs to
-          # * _name_ (required) :: Name of the feature
-          # * _location_ :: Bio::Locations object. Default = whole panel, forward strand
-          # * _link_ :: URL for clickable images
-          # *Returns*:: Bio::Graphics::Track::Feature object
-          def initialize(track, name, location = Bio::Locations.new('1..' + track.panel.length.to_s), link = nil)
-            @track = track
-            @name = name
-            @location = location
-            @start = location.collect{|l| l.from}.min.to_i
-            @stop = location.collect{|l| l.to}.max.to_i
-            @strand = location[0].strand.to_i
-            @link = link
-            @pixel_range_collection = Array.new
-            @chopped_at_start = false
-            @chopped_at_stop = false
-            @hidden_subfeatures_at_start = false
-            @hidden_subfeatures_at_stop = false
-
-            # Get all pixel ranges for the subfeatures
-            location.each do |l|
-              #   xxxxxx  [          ]
-              if l.to < track.panel.display_start
-                @hidden_subfeatures_at_start = true
-                next
-              #           [          ]   xxxxx
-              elsif l.from > track.panel.display_stop
-                @hidden_subfeatures_at_stop = true
-                next
-              #      xxxx[xxx       ]
-              elsif l.from < track.panel.display_start and l.to > track.panel.display_start
-                start_pixel = 1
-                stop_pixel = ( l.to - track.panel.display_start ).to_f / track.panel.rescale_factor
-                @chopped_at_start = true
-              #          [      xxxx]xxxx
-              elsif l.from < track.panel.display_stop and l.to > track.panel.display_stop
-                start_pixel = ( l.from - track.panel.display_start ).to_f / track.panel.rescale_factor
-                stop_pixel = track.panel.width
-                @chopped_at_stop = true
-              #      xxxx[xxxxxxxxxx]xxxx
-              elsif l.from < track.panel.display_start and l.to > track.panel.display_stop
-                start_pixel = 1
-                stop_pixel = track.panel.width
-                @chopped_at_start = true
-                @chopped_at_stop = true
-              #          [   xxxxx  ]
-              else
-                start_pixel = ( l.from - track.panel.display_start ).to_f / track.panel.rescale_factor
-                stop_pixel = ( l.to - track.panel.display_start ).to_f / track.panel.rescale_factor
-              end
-              
-              @pixel_range_collection.push(PixelRange.new(start_pixel, stop_pixel))
-              
-            end
-          end
-          
-          # The track that this feature belongs to
-          attr_accessor :track
-          
-          # The name of the feature
-          attr_accessor :name
-          
-          # The location of the feature (which is a Bio::Locations object)
-          attr_accessor :location
-          
-          # The start position of the feature (in bp)
-          attr_accessor :start
-          
-          # The stop position of the feature (in bp)
-          attr_accessor :stop
-          
-          # The strand of the feature
-          attr_accessor :strand
-          
-          # The URL to be followed when the glyph for this feature is clicked
-          attr_accessor :link
-          
-          # The array keeping the pixel ranges for the sub-features. Unspliced
-          # features will just have one element, while spliced features will
-          # have more than one.
-          attr_accessor :pixel_range_collection
-          
-          # Is the first subfeature incomplete?
-          attr_accessor :chopped_at_start
-          
-          # Is the last subfeature incomplete?
-          attr_accessor :chopped_at_stop
-          
-          # Are there subfeatures out of view at the left side of the picture?
-          attr_accessor :hidden_subfeatures_at_start
-          
-          # Are there subfeatures out of view at the right side of the picture?
-          attr_accessor :hidden_subfeatures_at_stop
-
-          # Method to draw the arrows of directed glyphs. Not to be used
-          # directly, but called by Feature#draw.
-          def arrow(track,direction,x,y,size)
-            case direction
-            when :right
-              track.move_to(x,y)
-              track.rel_line_to(size,size)
-              track.rel_line_to(-size,size)
-              track.close_path.fill
-            when :left
-              track.move_to(x,y)
-              track.rel_line_to(-size,size)
-              track.rel_line_to(size,size)
-              track.close_path.fill
-            when :north
-              track.move_to(x-size,y+size)
-              track.rel_line_to(size,-size)
-              track.rel_line_to(size,size)
-              track.close_path.fill
-            when :south
-              track.move_to(x-size,y-size)
-              track.rel_line_to(size,size)
-              track.rel_line_to(size,-size)
-              track.close_path.fill
-            end
-          end
-
-          # Method to draw the connections (introns) of spliced glyphs. Not to
-          # be used directly, but called by Feature#draw.
-          def connector(track,from,to,top, color)
-            line_width = track.line_width
-            track.set_source_rgb([0,0,0])
-            track.set_line_width(0.5)
-            middle = from + ((to - from)/2)
-            track.move_to(from, top+2)
-            track.line_to(middle, top+7)
-            track.line_to(to, top+2)
-            track.stroke
-            track.set_line_width(line_width)
-            track.set_source_rgb(color)
-          end
-          
-          # Adds the feature to the track cairo context. This method should not 
-          # be used directly by the user, but is called by
-          # Bio::Graphics::Panel::Track.draw
-          # ---
-          # *Arguments*:
-          # * _trackdrawing_ (required) :: the track cairo object
-          # * _row_ (required) :: row within the track that this feature has 
-          #                       been bumped to
-          # *Returns*:: FIXME: I don't know
-          def draw(track_drawing)
-            # We have to check if we want to change the glyph type from directed to
-            #    undirected
-            # There are 2 cases where we don't want to draw arrows on
-            # features:
-            # (a) when the picture is really zoomed out, features are
-            #     so small that the arrow itself is too big
-            # (b) if a directed feature on the fw strand extends beyond
-            #     the end of the picture, the arrow is out of view. This
-            #     is the same as considering the feature as undirected.
-            #     The same obviously goes for features on the reverse
-            #     strand that extend beyond the left side of the image.
-            #
-            # (a) Zoomed out
-            replace_directed_with_undirected = false
-            if (self.stop - self.start).to_f/self.track.panel.rescale_factor.to_f < 2
-              replace_directed_with_undirected = true
-            end
-            # (b) Extending beyond borders picture
-            if ( self.chopped_at_stop and self.strand = 1 ) or ( self.chopped_at_start and self.strand = -1 )
-              replace_directed_with_undirected = true
-            end
-
-            local_feature_glyph = nil
-            if self.track.glyph == :directed_generic and replace_directed_with_undirected
-              local_feature_glyph = :generic
-            elsif self.track.glyph == :directed_spliced and replace_directed_with_undirected
-              local_feature_glyph = :spliced
-            else
-              local_feature_glyph = self.track.glyph
-            end
-
-            # And draw the thing.
-            row = self.find_row
-            top_pixel_of_feature = FEATURE_V_DISTANCE + (FEATURE_HEIGHT+FEATURE_V_DISTANCE)*row
-            bottom_pixel_of_feature = top_pixel_of_feature + FEATURE_HEIGHT
-
-            case local_feature_glyph
-              # triangles are typical for features which have a 1 bp position (start == stop)
-              when :triangle
-                raise "Start and stop are not the same (necessary if you want triangle glyphs)" if self.start != self.stop
- 
-                # Need to get this for the imagemap
-                left_pixel_of_feature = self.pixel_range_collection[0].start_pixel - FEATURE_ARROW_LENGTH
-                right_pixel_of_feature = self.pixel_range_collection[0].stop_pixel + FEATURE_ARROW_LENGTH
-                arrow(track_drawing,:north,left_pixel_of_feature + FEATURE_ARROW_LENGTH, top_pixel_of_feature, FEATURE_ARROW_LENGTH)
-                track_drawing.close_path.stroke
-              when :line
-                left_pixel_of_feature = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[0].start_pixel
-                right_pixel_of_feature = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[-1].stop_pixel
-                track_drawing.move_to(left_pixel_of_feature,top_pixel_of_feature+FEATURE_ARROW_LENGTH)               
-                track_drawing.line_to(right_pixel_of_feature,top_pixel_of_feature+FEATURE_ARROW_LENGTH)
-                track_drawing.stroke
-
-                track_drawing.set_source_rgb([0,0,0])
-                arrow(track_drawing,:right,left_pixel_of_feature,top_pixel_of_feature,FEATURE_ARROW_LENGTH)
-                track_drawing.close_path.stroke              
-                arrow(track_drawing,:left,right_pixel_of_feature,top_pixel_of_feature,FEATURE_ARROW_LENGTH)
-                track_drawing.close_path.stroke
-
-                track_drawing.set_source_rgb(self.track.colour)
-            when :directed_generic
-                # Need to get this for the imagemap
-                left_pixel_of_feature = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[0].start_pixel
-                right_pixel_of_feature = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[-1].stop_pixel
-                if self.strand == -1 # Reverse strand
-                  track_drawing.rectangle(left_pixel_of_feature+FEATURE_ARROW_LENGTH, top_pixel_of_feature, right_pixel_of_feature - left_pixel_of_feature - FEATURE_ARROW_LENGTH, FEATURE_HEIGHT).fill
-                  arrow(track_drawing,:left,left_pixel_of_feature+FEATURE_ARROW_LENGTH,top_pixel_of_feature,FEATURE_ARROW_LENGTH)
-                  track_drawing.close_path.fill
-                else #default is forward strand
-                  track_drawing.rectangle(left_pixel_of_feature, top_pixel_of_feature, right_pixel_of_feature - left_pixel_of_feature - FEATURE_ARROW_LENGTH, FEATURE_HEIGHT).fill
-                  arrow(track_drawing,:right,right_pixel_of_feature-FEATURE_ARROW_LENGTH,top_pixel_of_feature,FEATURE_ARROW_LENGTH)
-                  track_drawing.close_path.fill
-                end
-              when :spliced
-                gap_starts = Array.new
-                gap_stops = Array.new
-
-                # Need to get this for the imagemap
-                left_pixel_of_feature = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[0].start_pixel
-                right_pixel_of_feature = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[-1].stop_pixel
-
-                # First draw the parts
-                self.pixel_range_collection.sort_by{|pr| pr.start_pixel}.each do |pr|
-                  track_drawing.rectangle(pr.start_pixel, top_pixel_of_feature, (pr.stop_pixel - pr.start_pixel), FEATURE_HEIGHT).fill
-                  gap_starts.push(pr.stop_pixel)
-                  gap_stops.push(pr.start_pixel)
-                end
-
-                # And then draw the connections in the gaps
-                # Start with removing the very first start and the very last stop.
-                gap_starts.sort!.pop
-                gap_stops.sort!.shift
-
-                gap_starts.length.times do |gap_number|
-                  connector(track_drawing,gap_starts[gap_number].to_f,gap_stops[gap_number].to_f,top_pixel_of_feature,track.colour)
-                end
-
-                if self.hidden_subfeatures_at_stop
-                  from = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[-1].stop_pixel
-                  to = self.track.panel.width
-                  track_drawing.move_to(from, top_pixel_of_feature+5)
-                  track_drawing.line_to(to, top_pixel_of_feature+5)
-                  track_drawing.stroke
-                end
-
-                if self.hidden_subfeatures_at_start
-                  from = 1
-                  to = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[0].start_pixel
-                  track_drawing.move_to(from, top_pixel_of_feature+5)
-                  track_drawing.line_to(to, top_pixel_of_feature+5)
-                  track_drawing.stroke
-                end
-
-              when :directed_spliced
-                gap_starts = Array.new
-                gap_stops = Array.new
-                # First draw the parts
-                locations = self.location.sort_by{|l| l.from}
-
-                # Need to get this for the imagemap
-                left_pixel_of_feature = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[0].start_pixel
-                right_pixel_of_feature = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[-1].stop_pixel
-
-                #   Start with the one with the arrow
-                pixel_ranges = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}
-                range_with_arrow = nil
-                if self.strand == -1 # reverse strand => box with arrow is first one
-                  range_with_arrow = pixel_ranges.shift
-                  track_drawing.rectangle((range_with_arrow.start_pixel)+FEATURE_ARROW_LENGTH, top_pixel_of_feature, range_with_arrow.stop_pixel - range_with_arrow.start_pixel - FEATURE_ARROW_LENGTH, FEATURE_HEIGHT).fill
-                  arrow(track_drawing,:left,range_with_arrow.start_pixel+FEATURE_ARROW_LENGTH, top_pixel_of_feature,FEATURE_ARROW_LENGTH)
-                  track_drawing.close_path.fill
-                else # forward strand => box with arrow is last one
-                  range_with_arrow = pixel_ranges.pop
-                  track_drawing.rectangle(range_with_arrow.start_pixel, top_pixel_of_feature, range_with_arrow.stop_pixel - range_with_arrow.start_pixel - FEATURE_ARROW_LENGTH, FEATURE_HEIGHT).fill
-                  arrow(track_drawing,:right,range_with_arrow.stop_pixel-FEATURE_ARROW_LENGTH, top_pixel_of_feature,FEATURE_ARROW_LENGTH)
-                  track_drawing.close_path.fill
-                end
-                gap_starts.push(range_with_arrow.stop_pixel)
-                gap_stops.push(range_with_arrow.start_pixel)
-
-                #   And then add the others
-                pixel_ranges.each do |range|
-                  track_drawing.rectangle(range.start_pixel, top_pixel_of_feature, range.stop_pixel - range.start_pixel, FEATURE_HEIGHT).fill
-                  gap_starts.push(range.stop_pixel)
-                  gap_stops.push(range.start_pixel)
-                end
-
-                # And then draw the connections in the gaps
-                # Start with removing the very first start and the very last stop.
-                gap_starts.sort!.pop
-                gap_stops.sort!.shift
-
-                gap_starts.length.times do |gap_number|
-                  connector(track_drawing,gap_starts[gap_number].to_f,gap_stops[gap_number].to_f,top_pixel_of_feature,track.colour)
-                end
-
-                if self.hidden_subfeatures_at_stop
-                  from = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[-1].stop_pixel
-                  to = self.track.panel.width
-                  track_drawing.move_to(from, top_pixel_of_feature+FEATURE_ARROW_LENGTH)
-                  track_drawing.line_to(to, top_pixel_of_feature+FEATURE_ARROW_LENGTH)
-                  track_drawing.stroke
-                end
-
-                if self.hidden_subfeatures_at_start
-                  from = 1
-                  to = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[0].start_pixel
-                  track_drawing.move_to(from, top_pixel_of_feature+FEATURE_ARROW_LENGTH)
-                  track_drawing.line_to(to, top_pixel_of_feature+FEATURE_ARROW_LENGTH)
-                  track_drawing.stroke
-                end
-
-              else #treat as 'generic'
-                left_pixel_of_feature, right_pixel_of_feature = self.pixel_range_collection[0].start_pixel, self.pixel_range_collection[0].stop_pixel
-                track_drawing.rectangle(left_pixel_of_feature, top_pixel_of_feature, (right_pixel_of_feature - left_pixel_of_feature), FEATURE_HEIGHT).fill
-            end
-
-            # Add the label for the feature
-            if self.track.show_label
-              pango_layout = track_drawing.create_pango_layout
-              pango_layout.text = self.name
-              fdesc = Pango::FontDescription.new('Sans Serif')
-              fdesc.set_size(8 * Pango::SCALE)
-              pango_layout.font_description = fdesc
-  
-              text_range = self.start.floor..(self.start.floor + pango_layout.pixel_size[0]*self.track.panel.rescale_factor)
-              if self.track.grid[row+1].nil?
-                self.track.grid[row+1] = Array.new
-              end
-              self.track.grid[row].push(text_range)
-              self.track.grid[row+1].push(text_range)
-              track_drawing.move_to(left_pixel_of_feature, top_pixel_of_feature + TRACK_HEADER_HEIGHT)
-              track_drawing.set_source_rgb(0,0,0)
-              track_drawing.show_pango_layout(pango_layout)
-              track_drawing.set_source_rgb(self.track.colour)
-            end
-            
-            
-            # And add the region to the image map
-            if self.track.panel.clickable
-              # Comment: we have to add the vertical_offset and TRACK_HEADER_HEIGHT!
-              self.track.panel.image_map.elements.push(ImageMap::ImageMapElement.new(left_pixel_of_feature,
-                                                                                     top_pixel_of_feature + self.track.vertical_offset + TRACK_HEADER_HEIGHT,
-                                                                                     right_pixel_of_feature,
-                                                                                     bottom_pixel_of_feature + self.track.vertical_offset + TRACK_HEADER_HEIGHT,
-                                                                                     self.link
-                                                                                    ))
-            end
-          end
-          
-          # Calculates the row within the track where this feature should be
-          # drawn. This method should not 
-          # be used directly by the user, but is called by
-          # Bio::Graphics::Panel::Track::Feature.draw
-          # ---
-          # *Arguments*:: none
-          # *Returns*:: row number
-          def find_row
-            row_found = false
-            
-            # We've got to find out what row to draw the feature on. If two 
-            # features overlap, one of them has to be 'bumped' down. So we'll
-            # first try to draw a new feature at the top of the track. If
-            # it however would overlap with another one, we'll bump it down
-            # to the next row.
-            feature_range = (self.start.floor..self.stop.ceil)
-            row = 1
-            row_available = true
-            until row_found
-              if ! self.track.grid[row].nil?
-                self.track.grid[row].each do |covered|
-                  if feature_range.include?(covered.first) or covered.include?(feature_range.first)
-                    row_available = false
-                  end
-                end
-              end
-  
-              if ! row_available
-                row += 1
-                row_available = true
-              else # We've found the place where to draw the feature.
-                if self.track.grid[row].nil?
-                  self.track.grid[row] = Array.new
-                end
-                self.track.grid[row].push(feature_range)
-                row_found = true
-              end
-            end
-            return row
-          end
-
-          class PixelRange
-            def initialize(start_pixel, stop_pixel)
-              @start_pixel, @stop_pixel = start_pixel, stop_pixel
-            end
-            attr_accessor :start_pixel, :stop_pixel
-          end
-        end #Feature
-      end #Track
-    end #Panel
-  end #Graphics
-end #Bio
+# 
+# = bio/graphics/feature.rb - feature class
+#
+# Copyright::   Copyright (C) 2007, 2008
+#               Jan Aerts <jan.aerts@bbsrc.ac.uk>
+#               Charles Comstock <dgtized@gmail.com>
+# License::     The Ruby License
+# 
+
+# The Bio::Graphics::Feature class describes features to be
+# placed on the graph. See Bio::Graphics documentation for explanation
+# of interplay between different classes.
+#
+# The position of the Feature is a Bio::Locations object to make it possible
+# to transparently work with simple and spliced features.
+#
+# The Bio::Graphics::Feature class inherits from Bio::Feature.
+class Bio::Graphics::Feature
+  # !!Not to be used directly. Use
+  # Bio::Graphics::Track.add_feature instead!!
+  # A feature can not exist except within the confines of a
+  # Bio::Graphics::Track object.
+  #
+  #--
+  # This is necessary because the feature needs to know the colour and glyph,
+  # both of which are defined within the panel.
+  #++
+  #
+  # ---
+  # *Arguments*:
+  # * _track_ (required) :: Bio::Graphics::Track object that this
+  #   feature belongs to
+  # * _feature_ _object_ (required) :: A Bio::Feature object (see bioruby)
+  # * _:label_ :: Label of the feature. Default = 'anonymous'
+  # * _:link_ :: URL for clickable images. Default = nil
+  # * _:glyph_ :: Glyph to use. Default = glyph of the track
+  # * _:colour_ :: Colour. Default = colour of the track
+  # *Returns*:: Bio::Graphics::Feature object
+  def initialize(track, feature_object, opts = {})
+    @track = track
+    @feature_object = feature_object
+    opts = {
+      :label => 'anonymous',
+      :link => nil,
+      :glyph => @track.glyph,
+      :colour => @track.colour
+    }.merge(opts)
+    
+    @label = opts[:label]
+    @link = opts[:link]
+    @glyph = opts[:glyph]
+    @colour = opts[:colour]
+    
+    @locations = @feature_object.locations
+
+    @start = @locations.collect{|l| l.from}.min.to_i
+    @stop = @locations.collect{|l| l.to}.max.to_i
+
+    # Create Bio::Graphics SubFeatures
+    # The drawing is handled by subfeatures. If there are no defined, the
+    # subfeatures array will just hold one element: the @feature_object of
+    # self.
+    @subfeatures = Array.new
+    if ! @feature_object.subfeatures.empty?
+      @feature_object.subfeatures.each do |subfeature|
+        @subfeatures.push(Bio::Graphics::SubFeature.new(self, subfeature, :glyph => @glyph, :colour => @colour))
+      end
+    else
+      @subfeatures.push(Bio::Graphics::SubFeature.new(self, @feature_object, :glyph => @glyph, :colour => @colour))
+    end
+
+    @left_pixel_of_subfeatures = Array.new
+    @right_pixel_of_subfeatures = Array.new
+  end
+
+  # The bioruby Bio::Feature object
+  attr_accessor :feature_object
+
+  attr_accessor :locations
+
+  # The Bio::Graphics SubFeatures
+  attr_accessor :subfeatures
+
+  # The track that this feature belongs to
+  attr_accessor :track
+
+  # The label of the feature
+  attr_accessor :label
+  alias :name :label
+
+  # The URL to be followed when the glyph for this feature is clicked
+  attr_accessor :link
+
+  # The glyph to use to draw this (sub)feature
+  attr_accessor :glyph
+
+  # The colour to use to draw this (sub)feature
+  attr_accessor :colour
+
+  attr_accessor :start, :stop
+  attr_accessor :left_pixel_of_feature, :top_pixel_of_feature
+  attr_accessor :left_pixel_of_subfeatures, :right_pixel_of_subfeatures
+  
+  attr_accessor :vertical_offset
+
+  # Adds the feature to the track cairo context. This method should not 
+  # be used directly by the user, but is called by
+  # Bio::Graphics::Track.draw
+  # ---
+  # *Arguments*:
+  # * _track_drawing_ (required) :: the track cairo object
+  # *Returns*:: FIXME: I don't know
+  def draw(panel_destination)
+    feature_context = Cairo::Context.new(panel_destination)
+
+    # Move the feature drawing down based on track it's in and the number
+    # of times is has to be bumped
+    row = self.find_row
+
+    @vertical_offset = self.track.vertical_offset + Bio::Graphics::TRACK_HEADER_HEIGHT + Bio::Graphics::FEATURE_V_DISTANCE
+    @vertical_offset += (Bio::Graphics::FEATURE_HEIGHT+Bio::Graphics::FEATURE_V_DISTANCE)*row
+    
+    feature_context.translate(0, @vertical_offset)
+
+    # Let the subfeatures do the drawing.
+    @subfeatures.each do |subfeature|
+      subfeature.draw(feature_context)
+    end
+
+    @left_pixel_of_feature = @left_pixel_of_subfeatures.min
+    @right_pixel_of_feature = @right_pixel_of_subfeatures.max
+    
+    # Add the label for the feature
+    if @track.show_label
+      pango_layout = feature_context.create_pango_layout
+      pango_layout.text = @label
+      fdesc = Pango::FontDescription.new('Sans Serif')
+      fdesc.set_size(8 * Pango::SCALE)
+      pango_layout.font_description = fdesc
+
+      text_range = @start.floor..(@start.floor + pango_layout.pixel_size[0]*@track.panel.rescale_factor)
+      if @track.grid[row+1].nil?
+        @track.grid[row+1] = Array.new
+      end
+      @track.grid[row].push(text_range)
+      @track.grid[row+1].push(text_range)
+      feature_context.move_to(@left_pixel_of_feature, Bio::Graphics::TRACK_HEADER_HEIGHT)
+      feature_context.set_source_rgb(0,0,0)
+      feature_context.show_pango_layout(pango_layout)
+      feature_context.set_source_rgb(@colour)
+    end
+
+
+    # And add the region to the image map
+    # Comment: we have to add the vertical_offset and TRACK_HEADER_HEIGHT!
+    @track.panel.image_map.add_element(@left_pixel_of_feature,
+                                       @vertical_offset,
+                                       @right_pixel_of_feature,
+                                       @vertical_offset + Bio::Graphics::FEATURE_HEIGHT,
+                                       @link
+                                       )
+  end
+
+  # Calculates the row within the track where this feature should be
+  # drawn. This method should not 
+  # be used directly by the user, but is called by
+  # Bio::Graphics::Feature.draw
+  # ---
+  # *Arguments*:: none
+  # *Returns*:: row number
+  def find_row
+    row_found = false
+
+    # We've got to find out what row to draw the feature on. If two 
+    # features overlap, one of them has to be 'bumped' down. So we'll
+    # first try to draw a new feature at the top of the track. If
+    # it however would overlap with another one, we'll bump it down
+    # to the next row.
+    feature_range = (@start.floor - 1..@stop.ceil + 1)
+    row = 1
+    row_available = true
+    until row_found
+      if ! @track.grid[row].nil?
+        @track.grid[row].each do |covered|
+          if feature_range.include?(covered.first) or covered.include?(feature_range.first)
+            row_available = false
+          end
+        end
+        if ! @track.grid[row+1].nil? #Still have to check if there is no label there.
+          @track.grid[row+1].each do |covered|
+            if feature_range.include?(covered.first) or covered.include?(feature_range.first)
+              row_available = false
+            end
+          end
+        end
+      end
+
+      if ! row_available
+        row += 1
+        row_available = true
+      else # We've found the place where to draw the feature.
+        if @track.grid[row].nil?
+          @track.grid[row] = Array.new
+        end
+        @track.grid[row].push(feature_range)
+        row_found = true
+      end
+    end
+    return row
+  end
+     
+end #Feature