wads 0.1.1 → 0.1.2

data/lib/wads/textinput.rb

@@ -9,13 +9,17 @@ class TextField < Gosu::TextInput
   PADDING = 5
   
   attr_reader :x, :y
+  attr_accessor :base_z
+  attr_accessor :old_value
   
   def initialize(window, font, x, y, original_text, default_width)
     super()
     
     @window, @font, @x, @y = window, font, x, y
     @default_width = default_width
+    @base_z = 0
     self.text = original_text
+    @old_value = self.text
   end
   
   def draw
@@ -29,7 +33,7 @@ class TextField < Gosu::TextInput
     @window.draw_quad(x - PADDING,         y - PADDING,          background_color,
                       x + width + PADDING, y - PADDING,          background_color,
                       x - PADDING,         y + height + PADDING, background_color,
-                      x + width + PADDING, y + height + PADDING, background_color, 9)
+                      x + width + PADDING, y + height + PADDING, background_color, @base_z + 9)
     
     # Calculate the position of the caret and the selection start.
     pos_x = x + @font.text_width(self.text[0...self.caret_pos])
@@ -40,16 +44,16 @@ class TextField < Gosu::TextInput
     @window.draw_quad(sel_x, y,          SELECTION_COLOR,
                       pos_x, y,          SELECTION_COLOR,
                       sel_x, y + height, SELECTION_COLOR,
-                      pos_x, y + height, SELECTION_COLOR, 50)
+                      pos_x, y + height, SELECTION_COLOR, @base_z + 10)
 
     # Draw the caret; again, only if this is the currently selected field.
     if @window.text_input == self then
       @window.draw_line(pos_x, y,          CARET_COLOR,
-                        pos_x, y + height, CARET_COLOR, 50)
+                        pos_x, y + height, CARET_COLOR, @base_z + 10)
     end
 
     # Finally, draw the text itself!
-    @font.draw_text(self.text, x, y, 50)
+    @font.draw_text(self.text, x, y, @base_z + 10)
   end
 
   # This text field grows with the text that's being entered.
@@ -71,6 +75,10 @@ class TextField < Gosu::TextInput
     mouse_x > x - PADDING and mouse_x < x + width + PADDING and
       mouse_y > y - PADDING and mouse_y < y + height + PADDING
   end
+
+  def contains_click(mouse_x, mouse_y)
+    under_point?(mouse_x, mouse_y)
+  end
   
   # Tries to move the caret to the position specifies by mouse_x
   def move_caret(mouse_x)
@@ -84,4 +92,41 @@ class TextField < Gosu::TextInput
     # Default case: user must have clicked the right edge
     self.caret_pos = self.selection_start = self.text.length
   end
+
+  def button_down(id, mouse_x, mouse_y)
+    if id == Gosu::MsLeft
+      move_caret(mouse_x)
+    else 
+      if @old_value == self.text
+        # nothing to do
+      else 
+        @old_value = self.text
+        return WidgetResult.new(false, EVENT_TEXT_INPUT, [self.text])
+      end
+    end
+  end 
+
+  def button_up(id, mouse_x, mouse_y)
+    # empty base implementation
+  end 
+
+  def update(update_count, mouse_x, mouse_y)
+    # empty base implementation
+  end
+
+  def handle_mouse_down mouse_x, mouse_y
+    # empty base implementation
+  end
+
+  def handle_mouse_up mouse_x, mouse_y
+      # empty base implementation
+  end
+
+  def handle_key_press id, mouse_x, mouse_y
+      # empty base implementation
+  end
+
+  def handle_update update_count, mouse_x, mouse_y
+      # empty base implementation
+  end
 end

data/lib/wads/version.rb

@@ -1,3 +1,3 @@
 module Wads
-    VERSION = "0.1.1"
+    VERSION = "0.1.2"
 end

data/lib/wads/widgets.rb

@@ -29,25 +29,33 @@ module Wads
     COLOR_ERROR_CODE_RED = Gosu::Color.argb(0xffe6b0aa)
 
     Z_ORDER_BACKGROUND = 2
-    Z_ORDER_WIDGET_BORDER = 3
+    Z_ORDER_BORDER = 3
     Z_ORDER_SELECTION_BACKGROUND = 4
     Z_ORDER_GRAPHIC_ELEMENTS = 5
     Z_ORDER_PLOT_POINTS = 6
-    Z_ORDER_OVERLAY_BACKGROUND = 7
-    Z_ORDER_OVERLAY_ELEMENTS = 8
-    Z_ORDER_TEXT = 10
+    Z_ORDER_FOCAL_ELEMENTS = 8
+    Z_ORDER_TEXT = 9
+
+    EVENT_OK = "ok"
+    EVENT_TEXT_INPUT = "textinput"
+    EVENT_TABLE_SELECT = "tableselect"
+    EVENT_TABLE_UNSELECT = "tableunselect"
+    EVENT_TABLE_ROW_DELETE = "tablerowdelete"
 
     class Widget 
         attr_accessor :x
         attr_accessor :y 
+        attr_accessor :base_z 
         attr_accessor :color 
+        attr_accessor :background_color
+        attr_accessor :border_color
         attr_accessor :width
         attr_accessor :height 
         attr_accessor :visible 
-        attr_accessor :children
-        attr_accessor :background_color
-        attr_accessor :border_color
         attr_accessor :font
+        attr_accessor :children
+        attr_accessor :overlay_widget
+        attr_accessor :debug_off
 
         def initialize(x, y, color = COLOR_CYAN) 
             @x = x 
@@ -57,12 +65,26 @@ module Wads
             @height = 1
             @visible = true 
             @children = []
+            @base_z = 0
+            @debug_off = true
+        end
+
+        def z_order 
+            @base_z + widget_z
+        end
+
+        def relative_z_order(relative_order)
+            @base_z + relative_order 
         end
 
         def add_child(child) 
             @children << child 
         end
 
+        def remove_child(child)
+            @children.delete(child)
+        end
+
         def clear_children 
             @children = [] 
         end
@@ -79,6 +101,10 @@ module Wads
             @font = font 
         end
 
+        def set_color(color)
+            @color = color 
+        end
+
         def set_dimensions(width, height)
             @width = width
             @height = height 
@@ -115,22 +141,21 @@ module Wads
             end 
         end
 
-        def draw_background(z_order = Z_ORDER_BACKGROUND)
-            Gosu::draw_rect(@x + 1, @y + 1, @width - 3, @height - 3, @background_color, z_order) 
+        def draw_background(z_override = nil)
+            if z_override 
+                z = relative_z_order(z_override)
+            else 
+                z = relative_z_order(Z_ORDER_BACKGROUND) 
+            end
+            Gosu::draw_rect(@x + 1, @y + 1, @width - 3, @height - 3, @background_color, z) 
         end
 
-        def draw_shadow(color, z_order = Z_ORDER_WIDGET_BORDER)
-            Gosu::draw_line @x - 1, @y - 1, color, right_edge - 1, @y - 1, color, z_order
-            Gosu::draw_line @x - 1, @y - 1, color, @x - 1, bottom_edge - 1, color, z_order
+        def draw_shadow(color)
+            Gosu::draw_line @x - 1, @y - 1, color, right_edge - 1, @y - 1, color, relative_z_order(Z_ORDER_BORDER)
+            Gosu::draw_line @x - 1, @y - 1, color, @x - 1, bottom_edge - 1, color, relative_z_order(Z_ORDER_BORDER)
         end
 
-        def render 
-            # Base implementation is empty
-            # Note that the draw method invoked by clients stills renders any added children
-            # render is for specific drawing done by the widget
-        end 
-
-        def draw_border(color = nil, zorder = Z_ORDER_WIDGET_BORDER)
+        def draw_border(color = nil)
             if color.nil? 
                 if @border_color
                     color = @border_color 
@@ -138,27 +163,234 @@ module Wads
                     color = @color 
                 end
             end
-            Gosu::draw_line @x, @y, color, right_edge, @y, color, zorder
-            Gosu::draw_line @x, @y, color, @x, bottom_edge, color, zorder
-            Gosu::draw_line @x,bottom_edge, color, right_edge, bottom_edge, color, zorder
-            Gosu::draw_line right_edge, @y, color, right_edge, bottom_edge, color, zorder
+            Gosu::draw_line @x, @y, color, right_edge, @y, color, relative_z_order(Z_ORDER_BORDER)
+            Gosu::draw_line @x, @y, color, @x, bottom_edge, color, relative_z_order(Z_ORDER_BORDER)
+            Gosu::draw_line @x,bottom_edge, color, right_edge, bottom_edge, color, relative_z_order(Z_ORDER_BORDER)
+            Gosu::draw_line right_edge, @y, color, right_edge, bottom_edge, color, relative_z_order(Z_ORDER_BORDER)
         end
 
         def contains_click(mouse_x, mouse_y)
             mouse_x >= @x and mouse_x <= right_edge and mouse_y >= @y and mouse_y <= bottom_edge
         end
 
-        def update update_count, mouse_x, mouse_y
+        def update(update_count, mouse_x, mouse_y)
+            if @overlay_widget 
+                @overlay_widget.update(update_count, mouse_x, mouse_y)
+            end
+            handle_update(update_count, mouse_x, mouse_y) 
+            @children.each do |child| 
+                child.update(update_count, mouse_x, mouse_y) 
+            end 
+        end
+
+        def button_down(id, mouse_x, mouse_y)
+            puts "Base widget #{self.class.name} button down #{id}." unless @debug_off
+            if @overlay_widget 
+                result = @overlay_widget.button_down(id, mouse_x, mouse_y)
+                if not result.nil? and result.is_a? WidgetResult
+                    intercept_widget_event(result)
+                    if result.close_widget
+                        # remove the overlay widget frmo children, set to null
+                        # hopefully this closes and gets us back to normal
+                        remove_child(@overlay_widget)
+                        @overlay_widget = nil
+                    end
+                end
+                return
+            end
+
+            if id == Gosu::MsLeft
+                result = handle_mouse_down mouse_x, mouse_y
+            elsif id == Gosu::MsRight
+                result = handle_right_mouse mouse_x, mouse_y
+            else 
+                result = handle_key_press id, mouse_x, mouse_y
+            end
+
+            if not result.nil? and result.is_a? WidgetResult
+                puts "Base widget #{self.class.name} returning own #{result}" unless @debug_off
+                return result 
+            end
+
+            @children.each do |child| 
+                if id == Gosu::MsLeft
+                    if child.contains_click(mouse_x, mouse_y) 
+                        result = child.button_down id, mouse_x, mouse_y
+                        if not result.nil? and result.is_a? WidgetResult
+                            intercept_widget_event(result)
+                            puts "Base widget #{self.class.name} returning child #{result}" unless @debug_off
+                            return result 
+                        end
+                    end 
+                else 
+                    result = child.button_down id, mouse_x, mouse_y
+                    if not result.nil? and result.is_a? WidgetResult
+                        intercept_widget_event(result)
+                        puts "Base widget #{self.class.name} returning child #{result}" unless @debug_off
+                        return result 
+                    end
+                end
+            end 
+        end
+
+        def button_up(id, mouse_x, mouse_y)
+            if @overlay_widget 
+                return @overlay_widget.button_up(id, mouse_x, mouse_y)
+            end
+            
+            if id == Gosu::MsLeft
+                result = handle_mouse_up mouse_x, mouse_y
+                if not result.nil? and result.is_a? WidgetResult
+                    return result 
+                end
+            end
+
+            @children.each do |child| 
+                if id == Gosu::MsLeft
+                    if child.contains_click(mouse_x, mouse_y) 
+                        result = child.handle_mouse_up mouse_x, mouse_y
+                        if not result.nil? and result.is_a? WidgetResult
+                            return result 
+                        end
+                    end 
+                end
+            end
+        end
+
+        def x_pixel_to_screen(x)
+            @x + x
+        end
+
+        def y_pixel_to_screen(y)
+            @y + y
+        end
+
+        def add_text(message, rel_x, rel_y)
+            new_text = Text.new(message, x_pixel_to_screen(rel_x), y_pixel_to_screen(rel_y), @font)
+            new_text.base_z = @base_z
+            add_child(new_text)
+            new_text
+        end 
+
+        def add_document(content, rel_x, rel_y, width, height)
+            new_doc = Document.new(content, x_pixel_to_screen(rel_x), y_pixel_to_screen(rel_y), width, height, @font)
+            new_doc.base_z = @base_z
+            add_child(new_doc)
+            new_doc
+        end
+
+        def add_button(label, rel_x, rel_y, width = nil, &block)
+            new_button = Button.new(label, x_pixel_to_screen(rel_x), y_pixel_to_screen(rel_y), @font)
+            if width.nil?
+                width = 60
+            end
+            new_button.width = width
+            new_button.set_action(&block)
+            new_button.base_z = @base_z
+            add_child(new_button)
+            new_button
+        end
+
+        def add_delete_button(rel_x, rel_y, &block)
+            new_delete_button = DeleteButton.new(x_pixel_to_screen(rel_x), y_pixel_to_screen(rel_y))
+            new_delete_button.set_action(&block)
+            new_delete_button.base_z = @base_z
+            add_child(new_delete_button)
+            new_delete_button 
+        end
+
+        def add_table(rel_x, rel_y, width, height, column_headers, color = COLOR_WHITE, max_visible_rows = 10)
+            new_table = Table.new(x_pixel_to_screen(rel_x), y_pixel_to_screen(rel_y),
+                              width, height, column_headers, @font, color, max_visible_rows)
+            new_table.base_z = @base_z
+            add_child(new_table)
+            new_table
+        end 
+
+        def add_single_select_table(rel_x, rel_y, width, height, column_headers, color = COLOR_WHITE, max_visible_rows = 10)
+            new_table = SingleSelectTable.new(x_pixel_to_screen(rel_x), y_pixel_to_screen(rel_y),
+                              width, height, column_headers, @font, color, max_visible_rows)
+            new_table.base_z = @base_z
+            add_child(new_table)
+            new_table
+        end 
+
+        def add_multi_select_table(rel_x, rel_y, width, height, column_headers, color = COLOR_WHITE, max_visible_rows = 10)
+            new_table = MultiSelectTable.new(x_pixel_to_screen(rel_x), y_pixel_to_screen(rel_y),
+                              width, height, column_headers, @font, color, max_visible_rows)
+            new_table.base_z = @base_z
+            add_child(new_table)
+            new_table
+        end 
+
+        def add_graph_display(rel_x, rel_y, width, height, graph)
+            new_graph = GraphWidget.new(x_pixel_to_screen(rel_x), y_pixel_to_screen(rel_y), width, height, @font, @color, graph) 
+            new_graph.base_z = @base_z
+            add_child(new_graph)
+            new_graph
+        end
+
+        def add_plot(rel_x, rel_y, width, height)
+            new_plot = Plot.new(x_pixel_to_screen(rel_x), y_pixel_to_screen(rel_y), width, height, @font) 
+            new_plot.base_z = @base_z
+            add_child(new_plot)
+            new_plot
+        end
+
+        def add_axis_lines(rel_x, rel_y, width, height, color)
+            new_axis_lines = AxisLines.new(x_pixel_to_screen(rel_x), y_pixel_to_screen(rel_y), width, height, color) 
+            new_axis_lines.base_z = @base_z
+            add_child(new_axis_lines)
+            new_axis_lines
+        end
+
+        def add_overlay(overlay)
+            overlay.base_z = @base_z + 10
+            add_child(overlay)
+            @overlay_widget = overlay
+        end
+
+        #
+        # Callbacks for subclasses to override
+        #
+        def handle_mouse_down mouse_x, mouse_y
+            # empty base implementation
+        end
+
+        def handle_mouse_up mouse_x, mouse_y
+            # empty base implementation
+        end
+
+        def handle_right_mouse mouse_x, mouse_y
             # empty base implementation
         end
 
-        def button_down id, mouse_x, mouse_y
+        def handle_key_press id, mouse_x, mouse_y
             # empty base implementation
         end
 
-        def button_up id, mouse_x, mouse_y
+        def handle_update update_count, mouse_x, mouse_y
             # empty base implementation
         end
+
+        def render 
+            # Base implementation is empty
+            # Note that the draw method invoked by clients stills renders any added children
+            # render is for specific drawing done by the widget
+        end 
+
+        def widget_z 
+            # The relative z order compared to other widgets
+            # The absolute z order is the base plus this value.
+            # Its calculated relative so that overlay widgets can be 
+            # on top of base displays.
+            0
+        end
+
+        def intercept_widget_event(result)
+            # Base implementation just relays the event
+            result
+        end
     end 
 
     class Text < Widget
@@ -169,7 +401,10 @@ module Wads
             @str = str
         end
         def render 
-            @font.draw_text(@str, @x, @y, Z_ORDER_TEXT, 1, 1, @color)
+            @font.draw_text(@str, @x, @y, z_order, 1, 1, @color)
+        end
+        def widget_z 
+            Z_ORDER_TEXT
         end
     end 
 
@@ -182,20 +417,32 @@ module Wads
     end 
 
     class PlotPoint < Widget
+        attr_accessor :data_x
+        attr_accessor :data_y
         attr_accessor :data_point_size 
 
-        def initialize(x, y, color = COLOR_MAROON, size = 4) 
-            super(x, y, color) 
+        def initialize(x, y, data_x, data_y, color = COLOR_MAROON, size = 4) 
+            super(x, y, color)
+            @data_x = data_x
+            @data_y = data_y
             @data_point_size = size
         end
 
-        def render 
-            @half_size = @data_point_size / 2
-            Gosu::draw_rect(@x - @half_size, @y - @half_size,
-                            @data_point_size, @data_point_size,
-                            @color, Z_ORDER_PLOT_POINTS) 
+        def render(override_size = nil)
+            size_to_draw = @data_point_size
+            if override_size 
+                size_to_draw = override_size 
+            end
+            half_size = size_to_draw / 2
+            Gosu::draw_rect(@x - half_size, @y - half_size,
+                            size_to_draw, size_to_draw,
+                            @color, z_order) 
         end 
 
+        def widget_z 
+            Z_ORDER_PLOT_POINTS
+        end
+
         def to_display 
             "#{@x}, #{@y}"
         end
@@ -213,7 +460,9 @@ module Wads
 
     class Button < Widget
         attr_accessor :label
+        attr_accessor :text_color
         attr_accessor :is_pressed
+        attr_accessor :action_code
 
         def initialize(label, x, y, font, width = nil, color = COLOR_DARK_GRAY, text_color = COLOR_HEADER_BRIGHT_BLUE) 
             super(x, y, color) 
@@ -226,14 +475,59 @@ module Wads
                 @width = width 
             end
             @height = 26
-            @is_pressed = false
             @text_color = text_color
+            @is_pressed = false
+            @is_pressed_update_count = -100
         end
 
         def render 
             draw_border(@color)
             text_x = center_x - (@text_pixel_width / 2)
-            @font.draw_text(@label, text_x, @y, Z_ORDER_TEXT, 1, 1, @text_color)
+            @font.draw_text(@label, text_x, @y, z_order, 1, 1, @text_color)
+        end 
+
+        def widget_z 
+            Z_ORDER_TEXT
+        end
+
+        def set_action(&block) 
+            @action_code = block
+        end
+
+        def handle_mouse_down mouse_x, mouse_y
+            @is_pressed = true
+            if @action_code
+                @action_code.call
+            end
+        end
+
+        def handle_update update_count, mouse_x, mouse_y
+            if @is_pressed
+                @is_pressed_update_count = update_count
+                @is_pressed = false
+            end
+
+            if update_count < @is_pressed_update_count + 15
+                set_background(nil)
+            elsif contains_click(mouse_x, mouse_y)
+                set_background(COLOR_LIGHT_GRAY)
+            else 
+                set_background(nil)
+            end
+        end
+    end 
+
+    class DeleteButton < Button
+        def initialize(x, y) 
+            super("ignore", x, y, Gosu::Font.new(22), 50, COLOR_GRAY)
+            set_dimensions(14, 14)
+            add_child(Line.new(@x, @y, right_edge, bottom_edge, COLOR_ERROR_CODE_RED))
+            add_child(Line.new(@x, bottom_edge, right_edge, @y, COLOR_ERROR_CODE_RED))
+            set_border(@color)
+        end
+
+        def render 
+            # do nothing, just override the parent so we don't draw a label
         end 
     end 
 
@@ -250,10 +544,14 @@ module Wads
         def render 
             y = @y + 4
             @lines.each do |line|
-                @font.draw_text(line, @x + 5, y, Z_ORDER_TEXT, 1, 1, COLOR_WHITE)
+                @font.draw_text(line, @x + 5, y, z_order, 1, 1, COLOR_WHITE)
                 y = y + 26
             end
         end 
+
+        def widget_z 
+            Z_ORDER_TEXT
+        end
     end 
 
     class InfoBox < Widget 
@@ -262,24 +560,22 @@ module Wads
             set_font(font)
             set_dimensions(width, height)
             set_border(COLOR_WHITE)
-            @title = title
-            add_child(Text.new(title, x + 5, y + 5, Gosu::Font.new(32)))
-            add_child(Document.new(content, x + 5, y + 52, width, height, font))
-            @ok_button = Button.new("OK", center_x - 50, bottom_edge - 26, @font, 100, COLOR_FORM_BUTTON)
-            add_child(@ok_button) 
-            set_background(COLOR_GRAY)
+            set_background(COLOR_OFF_GRAY)
+            @base_z = 10
+            add_text(title, 5, 5)
+            add_document(content, 5, 52, width, height - 52)
+            ok_button = add_button("OK", (@width / 2) - 50, height - 26) do
+                WidgetResult.new(true)
+            end
+            ok_button.text_color = COLOR_WHITE
+            ok_button.width = 100
         end
 
-        def button_down id, mouse_x, mouse_y
+        def handle_key_press id, mouse_x, mouse_y
             if id == Gosu::KbEscape
                 return WidgetResult.new(true) 
-            elsif id == Gosu::MsLeft
-                if @ok_button.contains_click(mouse_x, mouse_y)
-                    return WidgetResult.new(true) 
-                end
             end
-            WidgetResult.new(false)
-        end
+        end 
     end
 
     class Dialog < Widget
@@ -290,23 +586,34 @@ module Wads
             @window = window
             set_font(font)
             set_dimensions(width, height)
-            set_background(0xff566573 )
+            set_background(COLOR_OFF_GRAY)
             set_border(COLOR_WHITE)
+            @base_z = 10
             @error_message = nil
 
-            add_child(Text.new(title, x + 5, y + 5, @font))
+            add_text(title, 5, 5)
             # Forms automatically have some explanatory content
-            add_child(Document.new(content, x, y + 56, width, height, font))
+            add_document(content, 0, 56, width, height)
 
             # Forms automatically get a text input widget
             @textinput = TextField.new(@window, @font, x + 10, bottom_edge - 80, text_input_default, 600)
+            @textinput.base_z = 10
             add_child(@textinput)
 
             # Forms automatically get OK and Cancel buttons
-            @ok_button = Button.new("OK", center_x - 100, bottom_edge - 26, @font, 100, COLOR_FORM_BUTTON, COLOR_WHITE)
-            @cancel_button = Button.new("Cancel", center_x + 50, bottom_edge - 26, @font, 100, COLOR_FORM_BUTTON, COLOR_WHITE)
-            add_child(@ok_button) 
-            add_child(@cancel_button)
+            ok_button = add_button("OK", (@width / 2) - 100, height - 32) do
+                handle_ok
+            end
+            ok_button.color = COLOR_FORM_BUTTON
+            ok_button.text_color = COLOR_WHITE
+            ok_button.width = 100
+
+            cancel_button = add_button("Cancel", (@width / 2) + 50, height - 32) do
+                WidgetResult.new(true)
+            end
+            cancel_button.color = COLOR_FORM_BUTTON
+            cancel_button.text_color = COLOR_WHITE
+            cancel_button.width = 100
         end
 
         def content 
@@ -318,6 +625,7 @@ module Wads
 
         def add_error_message(msg) 
             @error_message = ErrorMessage.new(msg, x + 10, bottom_edge - 120, @font)
+            @error_message.base_z = @base_z
         end 
 
         def render 
@@ -329,21 +637,7 @@ module Wads
         def handle_ok
             # Default behavior is to do nothing except tell the caller to 
             # close the dialog
-            return WidgetResult.new(true) 
-        end
-
-        def handle_cancel
-            # Default behavior is to do nothing except tell the caller to 
-            # close the dialog
-            return WidgetResult.new(true) 
-        end
-
-        def handle_up(mouse_x, mouse_y)
-            # empty implementation of up arrow
-        end
-
-        def handle_down(mouse_x, mouse_y)
-            # empty implementation of down arrow
+            return WidgetResult.new(true, EVENT_OK) 
         end
 
         def handle_mouse_click(mouse_x, mouse_y)
@@ -351,37 +645,19 @@ module Wads
             # of standard form elements in this dialog
         end
 
-        def text_input_updated(text)
-            # empty implementation of text being updated
-            # in text widget
+        def handle_mouse_down mouse_x, mouse_y
+            # Mouse click: Select text field based on mouse position.
+            @window.text_input = [@textinput].find { |tf| tf.under_point?(mouse_x, mouse_y) }
+            # Advanced: Move caret to clicked position
+            @window.text_input.move_caret(mouse_x) unless @window.text_input.nil?
+
+            handle_mouse_click(mouse_x, mouse_y)
         end 
 
-        def button_down id, mouse_x, mouse_y
+        def handle_key_press id, mouse_x, mouse_y
             if id == Gosu::KbEscape
                 return WidgetResult.new(true) 
-            elsif id == Gosu::KbUp
-                handle_up(mouse_x, mouse_y)
-            elsif id == Gosu::KbDown
-                handle_down(mouse_x, mouse_y)
-            elsif id == Gosu::MsLeft
-                if @ok_button.contains_click(mouse_x, mouse_y)
-                    return handle_ok
-                elsif @cancel_button.contains_click(mouse_x, mouse_y)
-                    return handle_cancel 
-                else 
-                    # Mouse click: Select text field based on mouse position.
-                    @window.text_input = [@textinput].find { |tf| tf.under_point?(mouse_x, mouse_y) }
-                    # Advanced: Move caret to clicked position
-                    @window.text_input.move_caret(mouse_x) unless @window.text_input.nil?
-
-                    handle_mouse_click(mouse_x, mouse_y)
-                end
-            else 
-                if @window.text_input
-                    text_input_updated(@textinput.text)
-                end
             end
-            WidgetResult.new(false)
         end
     end 
 
@@ -408,7 +684,11 @@ module Wads
         end
 
         def render
-            Gosu::draw_line x, y, @color, x2, y2, @color, Z_ORDER_GRAPHIC_ELEMENTS
+            Gosu::draw_line x, y, @color, x2, y2, @color, z_order
+        end
+
+        def widget_z 
+            Z_ORDER_GRAPHIC_ELEMENTS
         end
     end 
 
@@ -437,10 +717,14 @@ module Wads
         def render
             text_pixel_width = @font.text_width(@label)
             Gosu::draw_line @x - 20, @y, @color,
-                            @x, @y, @color, Z_ORDER_GRAPHIC_ELEMENTS
+                            @x, @y, @color, z_order
             
             @font.draw_text(@label, @x - text_pixel_width - 28, @y - 12, 1, 1, 1, @color)
         end
+
+        def widget_z 
+            Z_ORDER_GRAPHIC_ELEMENTS
+        end
     end 
 
     class HorizontalAxisLabel < Widget
@@ -455,7 +739,11 @@ module Wads
         def render
             text_pixel_width = @font.text_width(@label)
             Gosu::draw_line @x, @y, @color, @x, @y + 20, @color
-            @font.draw_text(@label, @x - (text_pixel_width / 2), @y + 26, Z_ORDER_TEXT, 1, 1, @color)
+            @font.draw_text(@label, @x - (text_pixel_width / 2), @y + 26, z_order, 1, 1, @color)
+        end
+
+        def widget_z 
+            Z_ORDER_TEXT
         end
     end 
 
@@ -465,6 +753,7 @@ module Wads
         attr_accessor :headers
         attr_accessor :max_visible_rows
         attr_accessor :current_row
+        attr_accessor :can_delete_rows
 
         def initialize(x, y, width, height, headers, font, color = COLOR_GRAY, max_visible_rows = 10) 
             super(x, y, color) 
@@ -473,7 +762,10 @@ module Wads
             @headers = headers
             @current_row = 0
             @max_visible_rows = max_visible_rows
-            clear_rows            
+            clear_rows
+            @can_delete_rows = false
+            @delete_buttons = []
+            @next_delete_button_y = 38
         end
 
         def scroll_up 
@@ -498,6 +790,45 @@ module Wads
             @row_colors << color
         end
 
+        def add_table_delete_button 
+            if @delete_buttons.size < @max_visible_rows
+                new_button = add_delete_button(@width - 18, @next_delete_button_y) do
+                    # nothing to do here, handled in parent widget by event
+                end
+                @delete_buttons << new_button
+                @next_delete_button_y = @next_delete_button_y + 30
+            end
+        end
+
+        def remove_table_delete_button 
+            if not @delete_buttons.empty?
+                @delete_buttons.pop
+                @children.pop
+                @next_delete_button_y = @next_delete_button_y - 30
+            end
+        end
+
+        def handle_update update_count, mouse_x, mouse_y
+            # How many visible data rows are there
+            if @can_delete_rows
+                number_of_visible_rows = @data_rows.size - @current_row
+                if number_of_visible_rows > @max_visible_rows
+                    number_of_visible_rows = @max_visible_rows
+                end
+                if number_of_visible_rows > @delete_buttons.size
+                    number_to_add = number_of_visible_rows - @delete_buttons.size 
+                    number_to_add.times do 
+                        add_table_delete_button 
+                    end 
+                elsif number_of_visible_rows < @delete_buttons.size
+                    number_to_remove = @delete_buttons.size - number_of_visible_rows  
+                    number_to_remove.times do 
+                        remove_table_delete_button 
+                    end 
+                end
+            end
+        end
+
         def number_of_rows 
             @data_rows.size 
         end
@@ -523,14 +854,14 @@ module Wads
             if number_of_columns > 1
                 (0..number_of_columns-2).each do |c| 
                     x = x + column_widths[c] + 20
-                    Gosu::draw_line x, @y, @color, x, @y + @height, @color, Z_ORDER_GRAPHIC_ELEMENTS
+                    Gosu::draw_line x, @y, @color, x, @y + @height, @color, z_order
                 end 
             end
 
             y = @y             
             x = @x + 20
             (0..number_of_columns-1).each do |c| 
-                @font.draw_text(@headers[c], x, y, Z_ORDER_TEXT, 1, 1, @color)
+                @font.draw_text(@headers[c], x, y, z_order, 1, 1, @color)
                 x = x + column_widths[c] + 20
             end
             y = y + 30
@@ -542,7 +873,7 @@ module Wads
                 elsif count < @current_row + @max_visible_rows
                     x = @x + 20
                     (0..number_of_columns-1).each do |c| 
-                        @font.draw_text(row[c], x, y + 2, Z_ORDER_TEXT, 1, 1, @row_colors[count])
+                        @font.draw_text(row[c], x, y + 2, z_order, 1, 1, @row_colors[count])
                         x = x + column_widths[c] + 20
                     end
                     y = y + 30
@@ -559,6 +890,10 @@ module Wads
             end 
             row_number
         end
+
+        def widget_z 
+            Z_ORDER_TEXT
+        end
     end
 
     class SingleSelectTable < Table
@@ -589,10 +924,14 @@ module Wads
             if @selected_row 
                 if @selected_row >= @current_row and @selected_row < @current_row + @max_visible_rows
                     y = @y + 30 + ((@selected_row - @current_row) * 30)
-                    Gosu::draw_rect(@x + 20, y, @width - 30, 28, @selected_color, Z_ORDER_SELECTION_BACKGROUND) 
+                    Gosu::draw_rect(@x + 20, y, @width - 30, 28, @selected_color, relative_z_order(Z_ORDER_SELECTION_BACKGROUND)) 
                 end 
             end
         end
+
+        def widget_z 
+            Z_ORDER_TEXT
+        end
     end 
 
     class MultiSelectTable < Table
@@ -635,13 +974,52 @@ module Wads
             y = @y + 30
             row_count = @current_row
             while row_count < @data_rows.size
-                if @selected_rows.include? row_count
-                    Gosu::draw_rect(@x + 20, y, @width - 3, 28, @selection_color, Z_ORDER_SELECTION_BACKGROUND) 
+                if @selected_rows.include? row_count 
+                    width_of_selection_background = @width - 30
+                    if @can_delete_rows 
+                        width_of_selection_background = width_of_selection_background - 20
+                    end
+                    Gosu::draw_rect(@x + 20, y, width_of_selection_background, 28,
+                                    @selection_color,
+                                    relative_z_order(Z_ORDER_SELECTION_BACKGROUND)) 
                 end 
                 y = y + 30
                 row_count = row_count + 1
             end
         end
+
+        def widget_z 
+            Z_ORDER_TEXT
+        end
+
+        def handle_mouse_down mouse_x, mouse_y
+            if contains_click(mouse_x, mouse_y)
+                row_number = determine_row_number(mouse_y)
+                # First check if its the delete button that got this
+                delete_this_row = false
+                @delete_buttons.each do |db|
+                    if db.contains_click(mouse_x, mouse_y)
+                        delete_this_row = true 
+                    end 
+                end 
+                if delete_this_row
+                    if not row_number.nil?
+                       data_set_row_to_delete = @current_row + row_number
+                       data_set_name_to_delete = @data_rows[data_set_row_to_delete][1]
+                       @data_rows.delete_at(data_set_row_to_delete)
+                       return WidgetResult.new(false, EVENT_TABLE_ROW_DELETE, [data_set_name_to_delete])                       
+                    end
+                else
+                    if is_row_selected(mouse_y)
+                        unset_selected_row(mouse_y, 0)
+                        return WidgetResult.new(false, EVENT_TABLE_UNSELECT, @data_rows[row_number])
+                    else
+                        set_selected_row(mouse_y, 0)
+                        return WidgetResult.new(false, EVENT_TABLE_SELECT, @data_rows[row_number])
+                    end
+                end
+            end
+        end
     end 
 
     class Plot < Widget
@@ -650,6 +1028,7 @@ module Wads
         attr_accessor :display_grid
         attr_accessor :display_lines
         attr_accessor :zoom_level
+        attr_accessor :visibility_map
 
         def initialize(x, y, width, height, font) 
             super x, y, color 
@@ -657,39 +1036,42 @@ module Wads
             set_dimensions(width, height)
             @display_grid = false
             @display_lines = true
-            @data_set_hash = {}
-            @grid_line_color = COLOR_CYAN
+            @grid_line_color = COLOR_LIGHT_GRAY
             @cursor_line_color = COLOR_DARK_GRAY 
-            @zero_line_color = COLOR_BLUE 
+            @zero_line_color = COLOR_HEADER_BRIGHT_BLUE 
             @zoom_level = 1
+            @data_point_size = 4
+            # Hash of rendered points keyed by data set name, so we can toggle visibility
+            @points_by_data_set_name = {}
+            @visibility_map = {}
         end
 
-        def increase_data_point_size 
-            @data_set_hash.keys.each do |key|
-                data_set = @data_set_hash[key]
-                data_set.rendered_points.each do |point| 
-                    point.increase_size 
-                end
+        def toggle_visibility(data_set_name)
+            is_visible = @visibility_map[data_set_name]
+            if is_visible.nil?
+                return
             end
+            @visibility_map[data_set_name] = !is_visible
+        end
+ 
+        def increase_data_point_size
+            @data_point_size = @data_point_size + 2
         end 
 
         def decrease_data_point_size 
-            @data_set_hash.keys.each do |key|
-                data_set = @data_set_hash[key]
-                data_set.rendered_points.each do |point| 
-                    point.decrease_size 
-                end
+            if @data_point_size > 2
+                @data_point_size = @data_point_size - 2
             end
         end
 
         def zoom_out 
-            @zoom_level = @zoom_level + 0.1
+            @zoom_level = @zoom_level + 0.15
             visible_range.scale(@zoom_level)
         end 
 
         def zoom_in
             if @zoom_level > 0.11
-                @zoom_level = @zoom_level - 0.1
+                @zoom_level = @zoom_level - 0.15
             end
             visible_range.scale(@zoom_level)
         end 
@@ -713,11 +1095,6 @@ module Wads
         def define_range(range)
             @visible_range = range
             @zoom_level = 1
-            @data_set_hash.keys.each do |key|
-                data_set = @data_set_hash[key]
-                puts "Calling derive values on #{key}"
-                data_set.derive_values(range, @data_set_hash)
-            end
         end 
 
         def range_set?
@@ -725,24 +1102,25 @@ module Wads
         end 
 
         def is_on_screen(point) 
-            point.x >= @visible_range.left_x and point.x <= @visible_range.right_x and point.y >= @visible_range.bottom_y and point.y <= @visible_range.top_y
+            point.data_x >= @visible_range.left_x and point.data_x <= @visible_range.right_x and point.data_y >= @visible_range.bottom_y and point.data_y <= @visible_range.top_y
         end 
 
-        def add_data_set(data_set)
+        def add_data_set(data_set_name, rendered_points)
             if range_set?
-                @data_set_hash[data_set.name] = data_set
-                data_set.clear_rendered_points
-                data_set.derive_values(@visible_range, @data_set_hash)
-                data_set.data_points.each do |point|
-                    if is_on_screen(point) 
-                        data_set.add_rendered_point PlotPoint.new(draw_x(point.x), draw_y(point.y), data_set.color, data_set.data_point_size)
-                    end
+                @points_by_data_set_name[data_set_name] = rendered_points
+                if @visibility_map[data_set_name].nil?
+                    @visibility_map[data_set_name] = true
                 end
             else
                 puts "ERROR: range not set, cannot add data"
             end
         end 
 
+        def remove_data_set(data_set_name)
+            @points_by_data_set_name.delete(data_set_name)
+            @visibility_map.delete(data_set_name)
+        end
+
         def x_val_to_pixel(val)
             x_pct = (@visible_range.right_x - val).to_f / @visible_range.x_range 
             @width - (@width.to_f * x_pct).round
@@ -753,14 +1131,6 @@ module Wads
             (@height.to_f * y_pct).round
         end
 
-        def x_pixel_to_screen(x)
-            @x + x
-        end
-
-        def y_pixel_to_screen(y)
-            @y + y
-        end
-
         def draw_x(x)
             x_pixel_to_screen(x_val_to_pixel(x)) 
         end 
@@ -770,63 +1140,63 @@ module Wads
         end 
 
         def render
-            @data_set_hash.keys.each do |key|
-                data_set = @data_set_hash[key]
-                if data_set.visible
-                    data_set.rendered_points.each do |point| 
-                        point.draw 
+            @points_by_data_set_name.keys.each do |key|
+                if @visibility_map[key]
+                    data_set_points = @points_by_data_set_name[key]
+                    data_set_points.each do |point| 
+                        if is_on_screen(point)
+                            point.render(@data_point_size)
+                        end
                     end 
                     if @display_lines 
-                        display_lines_for_point_set(data_set.rendered_points) 
+                        display_lines_for_point_set(data_set_points) 
                     end
                 end
-            end
-            if @display_grid and range_set?
-                display_grid_lines
+                if @display_grid and range_set?
+                    display_grid_lines
+                end
             end
         end
 
         def display_lines_for_point_set(points) 
             if points.length > 1
                 points.inject(points[0]) do |last, the_next|
-                    Gosu::draw_line last.x, last.y, last.color,
-                                    the_next.x, the_next.y, last.color, Z_ORDER_GRAPHIC_ELEMENTS
+                    if last.x < the_next.x
+                        Gosu::draw_line last.x, last.y, last.color,
+                                        the_next.x, the_next.y, last.color, relative_z_order(Z_ORDER_GRAPHIC_ELEMENTS)
+                    end
                     the_next
                 end
             end
         end
 
         def display_grid_lines
-            # TODO this is bnot working well for large ranges with the given increment of 1
-            # We don't want to draw hundreds of grid lines
             grid_widgets = []
 
-            grid_x = @visible_range.left_x
-            grid_y = @visible_range.bottom_y + 1
-            while grid_y < @visible_range.top_y
+            x_lines = @visible_range.grid_line_x_values
+            y_lines = @visible_range.grid_line_y_values
+            first_x = draw_x(@visible_range.left_x)
+            last_x = draw_x(@visible_range.right_x)
+            first_y = draw_y(@visible_range.bottom_y)
+            last_y = draw_y(@visible_range.top_y)
+
+            x_lines.each do |grid_x|
                 dx = draw_x(grid_x)
-                dy = draw_y(grid_y)
-                last_x = draw_x(@visible_range.right_x)
                 color = @grid_line_color
-                if grid_y == 0 and grid_y != @visible_range.bottom_y.to_i
-                    color = @zero_line_color
-                end
-                grid_widgets << Line.new(dx, dy, last_x, dy, color) 
-                grid_y = grid_y + 1
+                if grid_x == 0 and grid_x != @visible_range.left_x.to_i
+                    color = @zero_line_color 
+                end    
+                grid_widgets << Line.new(dx, first_y, dx, last_y, color) 
             end
-            grid_x = @visible_range.left_x + 1
-            grid_y = @visible_range.bottom_y
-            while grid_x < @visible_range.right_x
-                dx = draw_x(grid_x)
+
+            y_lines.each do |grid_y| 
                 dy = draw_y(grid_y)
-                last_y = draw_y(@visible_range.top_y)
                 color = @grid_line_color
-                if grid_x == 0 and grid_x != @visible_range.left_x.to_i
-                    color = @zero_line_color 
+                if grid_y == 0 and grid_y != @visible_range.bottom_y.to_i
+                    color = @zero_line_color
                 end
-                grid_widgets << Line.new(dx, dy, dx, last_y, color) 
-                grid_x = grid_x + 1
-            end
+                grid_widgets << Line.new(first_x, dy, last_x, dy, color) 
+            end 
 
             grid_widgets.each do |gw| 
                 gw.draw 
@@ -867,15 +1237,18 @@ module Wads
 
         def render 
             super 
-            draw_background(Z_ORDER_OVERLAY_BACKGROUND)
+            draw_background(Z_ORDER_FOCAL_ELEMENTS)
             draw_shadow(COLOR_GRAY)
         end
+    
+        def widget_z 
+            Z_ORDER_TEXT
+        end
     end 
 
     class GraphWidget < Widget
         attr_accessor :graph
         attr_accessor :center_node 
-        attr_accessor :depth 
         attr_accessor :selected_node
         attr_accessor :selected_node_x_offset
         attr_accessor :selected_node_y_offset
@@ -886,50 +1259,119 @@ module Wads
             set_dimensions(width, height)
             set_border(color)
             @graph = graph 
+            set_all_nodes_for_display
         end 
 
-        def update update_count, mouse_x, mouse_y
+        def handle_update update_count, mouse_x, mouse_y
             if contains_click(mouse_x, mouse_y) and @selected_node 
                 @selected_node.x = mouse_x - @selected_node_x_offset
                 @selected_node.y = mouse_y - @selected_node_y_offset
             end
         end
 
-        def button_down id, mouse_x, mouse_y
-            if id == Gosu::MsLeft
-                # check to see if any node was selected
-                if @rendered_nodes
-                    @rendered_nodes.values.each do |rn|
-                        if rn.contains_click(mouse_x, mouse_y)
-                            @selected_node = rn 
-                            @selected_node_x_offset = mouse_x - rn.x 
-                            @selected_node_y_offset = mouse_y - rn.y
-                        end
+        def handle_mouse_down mouse_x, mouse_y
+            # check to see if any node was selected
+            if @rendered_nodes
+                @rendered_nodes.values.each do |rn|
+                    if rn.contains_click(mouse_x, mouse_y)
+                        @selected_node = rn 
+                        @selected_node_x_offset = mouse_x - rn.x 
+                        @selected_node_y_offset = mouse_y - rn.y
                     end
                 end
             end
             WidgetResult.new(false)
         end
 
-        def button_up id, mouse_x, mouse_y
-            if id == Gosu::MsLeft
-                if @selected_node 
-                    @selected_node = nil 
-                end 
+        def handle_mouse_up mouse_x, mouse_y
+            if @selected_node 
+                @selected_node = nil 
+            end 
+        end
+
+        def set_tree_display(max_depth = -1)
+            @graph.reset_visited
+            @visible_data_nodes = @graph.node_map
+            @rendered_nodes = {}
+
+            root_nodes = @graph.root_nodes
+            number_of_root_nodes = root_nodes.size 
+            width_for_each_root_tree = @width / number_of_root_nodes
+
+            start_x = 0
+            y_level = 10
+            root_nodes.each do |root|
+                set_tree_recursive(root, start_x, start_x + width_for_each_root_tree - 1, y_level)
+                start_x = start_x + width_for_each_root_tree
+                y_level = y_level + 40
+            end
+
+            @rendered_nodes.values.each do |rn|
+                rn.base_z = @base_z
+            end
+        end 
+
+        def set_tree_recursive(current_node, start_x, end_x, y_level)
+            # Draw the current node, and then recursively divide up
+            # and call again for each of the children
+            if current_node.visited 
+                return 
+            end 
+            current_node.visited = true
+
+            @rendered_nodes[current_node.name] = NodeWidget.new(
+                    current_node,
+                    x_pixel_to_screen(start_x + ((end_x - start_x) / 2)),
+                    y_pixel_to_screen(y_level),
+                    @font,
+                    get_node_color(current_node),
+                    get_node_color(current_node))
+
+            number_of_child_nodes = current_node.outputs.size 
+            if number_of_child_nodes == 0
+                return 
+            end
+            width_for_each_child_tree = (end_x - start_x) / number_of_child_nodes
+            start_child_x = start_x + 5
+
+            current_node.outputs.each do |child| 
+                if child.is_a? Edge 
+                    child = child.destination 
+                end
+                set_tree_recursive(child, start_child_x, start_child_x + width_for_each_child_tree - 1, y_level + 40)
+                start_child_x = start_child_x + width_for_each_child_tree
             end
         end
 
-        def set_display(center_node, max_depth)
+        def set_all_nodes_for_display 
+            @visible_data_nodes = @graph.node_map
+            @rendered_nodes = {}
+            populate_rendered_nodes
+        end 
+
+        def get_node_color(node)
+            color_tag = node.get_tag("color")
+            if color_tag.nil? 
+                return @color 
+            end 
+            color_tag
+        end 
+
+        def set_center_node(center_node, max_depth = -1)
             # Determine the list of nodes to draw
-            @depth = depth 
-            @visible_data_nodes = @graph.fan_out(center_node, max_depth)
+            @graph.reset_visited 
+            @visible_data_nodes = @graph.traverse_and_collect_nodes(center_node, max_depth)
 
             # Convert the data nodes to rendered nodes
             # Start by putting the center node in the center, then draw others around it
             @rendered_nodes = {}
             @rendered_nodes[center_node.name] = NodeWidget.new(center_node, center_x, center_y, @font,
-                    center_node.get_tag("color"), center_node.get_tag("color"))
+                get_node_color(center_node), get_node_color(center_node))
+
+            populate_rendered_nodes(center_node)
+        end 
 
+        def populate_rendered_nodes(center_node = nil)
             # Spread out the other nodes around the center node
             # going in a circle
             number_of_visible_nodes = @visible_data_nodes.size 
@@ -937,9 +1379,13 @@ module Wads
             current_radians = 0.05
 
             @visible_data_nodes.each do |node_name, data_node|
-                if node_name == center_node.name 
-                    # skip, we already got this one
-                else 
+                process_this_node = true
+                if center_node 
+                    if node_name == center_node.name 
+                        process_this_node = false 
+                    end 
+                end
+                if process_this_node 
                     # Use radians to spread the other nodes around the center node
                     # For now, we will randomly place them
                     node_x = center_x + ((80 + rand(200)) * Math.cos(current_radians))
@@ -963,10 +1409,13 @@ module Wads
                                                         node_x,
                                                         node_y,
                                                         @font,
-                                                        data_node.get_tag("color"),
-                                                        data_node.get_tag("color"))
+                                                        get_node_color(data_node),
+                                                        get_node_color(data_node))
                 end
             end
+            @rendered_nodes.values.each do |rn|
+                rn.base_z = @base_z
+            end
         end
 
         def render 
@@ -987,7 +1436,7 @@ module Wads
                         else
                             Gosu::draw_line rendered_node.center_x, rendered_node.center_y, rendered_node.color,
                                     connected_rendered_node.center_x, connected_rendered_node.center_y, connected_rendered_node.color,
-                                    Z_ORDER_GRAPHIC_ELEMENTS
+                                    relative_z_order(Z_ORDER_GRAPHIC_ELEMENTS)
                         end
                     end
                 end