cosmos 4.0.3-java

data/lib/cosmos/gui/line_graph/line_graph_script.rb

@@ -0,0 +1,81 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos'
+Qt.execute_in_main_thread do
+  require 'cosmos/gui/qt_tool'
+  require 'cosmos/gui/line_graph/line_graph_dialog'
+end
+
+# Create a new graph object and populate
+# plot (x, y, legend, [y,legend], [y,legend], ... , [opts])
+#   x           - default => [0...y_array.length]
+#   y           - Y data array to plot
+#   legend      - Line Legend to describe Y data
+#   args        - Additional y , legend pairs to plot
+#   opts        - Hash options at the end of the argument list
+#    :width => 400    - default => 800
+#    :height => 300   - default => 600
+#    :x => 100        - default => -1 # Place centered in current screen
+#    :y => 100        - default => -1 # Place centered in current screen
+#    :winTitle => "Graph 1" - default => "Graph"
+def plot (x = nil, y = nil, legend = "Line 1", *args)
+  my_opts = {:width => 800, :height => 600, :x => -1, :y => -1, :winTitle => "Graph"}
+
+  # Get the Hash options parameters from the end of the list of arguments
+  arg_idx = -1
+  while (args[arg_idx].is_a?(Hash)) do
+    my_opts.merge!(args[arg_idx])
+    arg_idx -= 1
+  end
+
+  if y
+    raise "Legend [0] must be a string" unless legend.kind_of? String
+    raise "Y [0] must be an array" unless y.kind_of? Array
+  end
+
+  # Split out the arguments for the other y arrays & legends
+  y_array = args[0..arg_idx].values_at(* args[0..arg_idx].each_index.select {|i| i.even?})
+  legend_array = args[0..arg_idx].values_at(* args[0..arg_idx].each_index.select {|i| i.odd?})
+
+  raise "Legend Argument List and Y Argument List not the same size" unless legend_array.length == y_array.length
+  (0...y_array.length).each do |i|
+    if y_array[i]
+      raise "Legend [#{i+1}] must be a string" unless legend_array[i].kind_of? String
+      raise "Y [#{i+1}] must be an array" unless y_array[i].kind_of? Array
+    end
+  end
+
+  my_line_graph = ''
+  Qt.execute_in_main_thread do
+    a = Cosmos::LineGraphDialog.new(my_opts[:winTitle], my_opts[:width], my_opts[:height])
+    if y
+      a.line_graph.add_line(legend, y, x, nil, nil, nil, nil, 'auto')
+    end
+    
+    (0...y_array.length).each do |i|
+      if y_array[i]
+        a.line_graph.add_line(legend_array[i], y_array[i], x, nil, nil, nil, nil, 'auto')
+      end
+    end
+
+    a.raise
+    a.show
+
+    my_line_graph = a.line_graph
+
+    # Move the window
+    if my_opts[:x] >= 0 && my_opts[:y] >= 0
+      a.move(my_opts[:x],my_opts[:y])
+    end
+  end
+  return my_line_graph
+end
+

data/lib/cosmos/gui/line_graph/lines.rb

@@ -0,0 +1,304 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+module Cosmos
+
+  class Lines
+    def initialize
+      @lines = []
+    end
+
+    # Clears all line data
+    def clear
+      @lines = []
+    end
+
+    # Returns which axes the lines belong to
+    #
+    # @return [Symbol] :NONE, :LEFT, :RIGHT, or :BOTH
+    def axes
+      return :NONE if @lines.empty?
+      return :LEFT if @lines.select {|line| line[7] == :RIGHT}.empty?
+      return :RIGHT if @lines.select {|line| line[7] == :LEFT}.empty?
+      return :BOTH
+    end
+
+    # @return [Array] Information needed to create the legend including
+    #   the item name, axis, and color
+    def legend
+      @lines.collect {|line| [line[8], line[6], line[7]] }
+    end
+
+    # @return [Boolean] Whether any lines are present
+    def empty?
+      @lines.empty?
+    end
+
+    # @return [Integer] Number of lines that are present
+    def num_lines
+      return @lines.length
+    end
+
+    # @return [Boolean] true if there are lines on the left y axis
+    def left_y_axis?
+      !left().empty?
+    end
+    # @return [Boolean] true if there are lines on the right y axis
+    def right_y_axis?
+      !right().empty?
+    end
+
+    # Returns the x line states
+    #
+    # @return [Hash|nil] Line states or nil if none found
+    def x_states
+      @lines.collect {|line| line[4] }.compact.uniq[0]
+    end
+
+    # @return [Array] Popup details for the left Y axis consisting of the
+    #   x value, y value, x text, y text, item name, color, and axis
+    def get_left_popup_data(x_value, value_delta, ordered_x_values, min, max)
+      get_popup_data(left(), x_value, value_delta, ordered_x_values, min, max)
+    end
+    # @return [Array] Popup details for the right Y axis consisting of the
+    #   x value, y value, x text, y text, item name, color, and axis
+    def get_right_popup_data(x_value, value_delta, ordered_x_values, min, max)
+      get_popup_data(right(), x_value, value_delta, ordered_x_values, min, max)
+    end
+
+    private # Protect this implementation detail called by the above methods
+
+    def get_popup_data(lines, x_value, value_delta, ordered_x_values, min, max)
+      # Find the data points nearest to the given x value
+      result = []
+      lines.each do |x_values, y_values, x_labels, y_labels, x_states, y_states, color, axis, item|
+        index = x_values.nearest_index(x_value, ordered_x_values)
+        if (x_values[index] - x_value).abs < value_delta
+          if y_values[index] >= min and y_values[index] <= max
+            x_text = get_display_text(x_values, x_states, x_labels, index)
+            y_text = get_display_text(y_values, y_states, y_labels, index)
+            result << [x_values[index], y_values[index], x_text, y_text, item, color, axis]
+          end
+        end
+      end
+      return result
+    end
+
+    public
+
+    # @return [Range] The range of left Y axis values
+    def left_y_value_range
+      y_value_range(left())
+    end
+    # @return [Range] The range of right Y axis values
+    def right_y_value_range
+      y_value_range(right())
+    end
+
+    private # Protect this implementation detail called by the above methods
+
+    def y_value_range(lines)
+      mins = []
+      maxs = []
+      lines.each do |line|
+        mins << line[1].min
+        maxs << line[1].max
+      end
+      (mins.min...maxs.max)
+    end
+
+    public
+
+    # Returns the x axis minimum and maximum values along with their labels (if
+    # there are any labels).
+    #
+    # @return [Array<Numeric, Numeric, String, String>]
+    def x_min_max_labels
+      x_max = 1
+      x_min = -1
+      x_max_label = nil
+      x_min_label = nil
+
+      unless @lines.empty?
+        # Use maximum and minimum values for x_max and x_min
+        line_max_values = []
+        line_min_values = []
+        line_max_labels = []
+        line_min_labels = []
+        @lines.each do |x_values, y_values, x_labels, y_labels, x_states, y_states, color|
+          maximum, maximum_index = x_values.max_with_index
+          line_max_values << maximum
+          minimum, minimum_index = x_values.min_with_index
+          line_min_values << minimum
+
+          # If there are labels then use them directly
+          if x_labels
+            line_max_labels << x_labels[maximum_index]
+            line_min_labels << x_labels[minimum_index]
+          else # Put in max and min as place holders
+            line_max_labels << maximum
+            line_min_labels << minimum
+          end
+        end
+        x_max, x_max_index = line_max_values.max_with_index
+        x_min, x_min_index = line_min_values.min_with_index
+        x_max_label        = line_max_labels[x_max_index]
+        # If the label equals the max it was a placeholder so set to nil
+        x_max_label        = nil if x_max_label == x_max
+        x_min_label        = line_min_labels[x_min_index]
+        # If the label equals the min it was a placeholder so set to nil
+        x_min_label        = nil if x_min_label == x_min
+
+        if x_min == x_max
+          if x_min == 0.0
+            x_max = 1
+            x_min = -1
+          else
+            x_max = x_max + 1
+            x_min = x_min - 1
+          end
+        end
+      end
+      return [x_min, x_max, x_min_label, x_max_label]
+    end
+
+    def get_display_text(keys, states, labels, index)
+      text = nil
+      text = labels[index] if labels
+      if states
+        text = states.key(keys[index])
+        if text
+          text = "#{text} (#{keys[index]})"
+        end
+      end
+      return text
+    end
+
+    # Search through all the lines on the given left or right y axis for
+    # defined states. If each line has identical states return the states
+    # else return nil.
+    #
+    # @param axis [Symbol] Axis which must be :LEFT or :RIGHT
+    # @return [Hash|nil] The states for the given axis or nil
+    def unique_y_states(axis)
+      lines = left() if axis == :LEFT
+      lines = right() if axis == :RIGHT
+      raise "axis must be :LEFT or :RIGHT" unless lines
+      states = lines.collect{|line| line[5] }.uniq
+      if states.length == 1
+        return states[0]
+      else
+        return nil
+      end
+    end
+
+    # If there is a single line defined with states the states will be
+    # returned. Otherwise return nil.
+    #
+    # @return [Hash|nil] The states or nil
+    def single_line_with_x_states
+      return @lines.length == 1 && @lines[0][4]
+    end
+
+    def add_line(text, y, x = nil, y_labels = nil, x_labels = nil, y_states = nil, x_states = nil, color = 'blue', axis = :LEFT, max_points_plotted = nil)
+      # Validate y data
+      raise ArgumentError, "y data must be given in an array-like class" unless y.respond_to?(:[])
+      raise ArgumentError, "y data cannot be empty" if y.empty?
+      raise ArgumentError, "y data must be Numeric" unless y[0].kind_of?(Numeric)
+
+      # Validate x data
+      if x.respond_to?(:[])
+        raise ArgumentError, "x and y data must be the same size" unless y.length == x.length
+        raise ArgumentError, "x data must be Numeric" unless x[0].kind_of?(Numeric)
+      else
+        raise ArgumentError, "x data must be given in an array-like class" unless x.nil?
+      end
+
+      # Validate y_labels data
+      if y_labels.respond_to?(:[])
+        raise ArgumentError, "y_labels and y data must be the same size" unless y.length == y_labels.length
+      else
+        raise ArgumentError, "y_labels data must be given in an array-like class" unless y_labels.nil?
+      end
+
+      # Validate x_labels data
+      if x_labels.respond_to?(:[])
+        raise ArgumentError, "x_labels and y data must be the same size" unless y.length == x_labels.length
+      else
+        raise ArgumentError, "x_labels data must be given in an array-like class" unless x_labels.nil?
+      end
+
+      # Validate y_states data
+      unless y_states.respond_to?(:index)
+        raise ArgumentError, "y_states data must be given in an hash-like class" unless y_states.nil?
+      end
+
+      # Validate x_states data
+      unless x_states.respond_to?(:index)
+        raise ArgumentError, "x_states data must be given in an hash-like class" unless x_states.nil?
+      end
+
+      if max_points_plotted and y.length > max_points_plotted
+        step = (y.length.to_f / max_points_plotted.to_f).ceil
+        y_reduced = LowFragmentationArray.new(max_points_plotted + 1)
+        x_reduced = nil
+        x_reduced = LowFragmentationArray.new(max_points_plotted + 1) if x
+        y_labels_reduced = nil
+        y_labels_reduced = LowFragmentationArray.new(max_points_plotted + 1) if y_labels
+        x_labels_reduced = nil
+        x_labels_reduced = LowFragmentationArray.new(max_points_plotted + 1) if x_labels
+        (0..(y.length - 1)).step(step) do |index|
+          y_reduced        << y[index].to_f
+          x_reduced        << x[index].to_f   if x_reduced
+          y_labels_reduced << y_labels[index] if y_labels_reduced
+          x_labels_reduced << x_labels[index] if x_labels_reduced
+        end
+        y_reduced        << y[-1].to_f
+        x_reduced        << x[-1].to_f   if x_reduced
+        y_labels_reduced << y_labels[-1] if y_labels_reduced
+        x_labels_reduced << x_labels[-1] if x_labels_reduced
+        y        = y_reduced
+        x        = x_reduced
+        y_labels = y_labels_reduced
+        x_labels = x_labels_reduced
+      else
+        # Clone data so that we don't modify the user's data
+        y        = y.clone_to_f
+        x        = x.clone_to_f   if x
+        y_labels = y_labels.clone if y_labels
+        x_labels = x_labels.clone if x_labels
+      end
+      unless x
+        x = (1..(y.length)).to_a_to_f
+      end
+
+      y_labels = y                         unless y_labels
+      # x_labels are only set if the formatted time item is used
+      y_states = y_states.clone            if y_states
+      x_states = x_states.clone            if x_states
+
+      # Update Saved Data
+      @lines << [x, y, x_labels, y_labels, x_states, y_states, color, axis, text]
+    end # def add_line
+
+    private
+
+    # @return [Array] All the lines on the left axis
+    def left
+      @lines.select {|line| line[7] == :LEFT}
+    end
+    # @return [Array] All the lines on the right axis
+    def right
+      @lines.select {|line| line[7] == :RIGHT}
+    end
+
+  end # class Lines
+
+end # module Cosmos

data/lib/cosmos/gui/line_graph/overview_graph.rb

@@ -0,0 +1,474 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos'
+require 'cosmos/gui/line_graph/line_graph'
+
+module Cosmos
+  # The overview graph provides a graph which contains the entire graph
+  # history. It provides a window with draggable bars that expands the viewport
+  # on graph. Expanding this viewport results in a callback that can be used to
+  # adjust the view on a different graph.
+  class OverviewGraph < LineGraph
+    # Default zoom when pressing the up or down arrow keys
+    DEFAULT_ZOOM_FACTOR = 0.1 # 10 percent
+    # Default pan when pressing the left or right arrow keys
+    DEFAULT_PAN_FACTOR  = 0.1 # 10 percent
+
+    # Minimum allowed size of the window in seconds plotted
+    attr_accessor :window_min_size
+    # Maximum allowed size of the window in seconds plotted
+    attr_accessor :window_max_size
+    # Callback called when the window changes
+    attr_accessor :callback
+    # Window size in seconds plotted
+    attr_reader :window_size
+    # Minimum x value in window
+    attr_reader :window_min_x
+    # Maximum x value in window
+    attr_reader :window_max_x
+
+    def initialize(parent)
+      super(parent)
+      setMaximumHeight(50)
+      setFocusPolicy(Qt::StrongFocus)
+
+      @qt_back_color = Cosmos::getColor(@back_color)
+
+      @point_size = 0
+
+      # Adjust minimum height for overview
+      @minimum_height = 50
+      @size_hint = Qt::Size.new(0, @minimum_height)
+      # Size of the window in value space
+      @window_size = 100.0
+      # Minimum size of the window
+      @window_min_size = 0.0
+      # Maximum size of the window
+      @window_max_size = nil
+      # Minimum window x value
+      @window_min_x = 0
+      # Maximum window x value
+      @window_max_x = 0
+      # Flag to indicate if we are currently dragging the window
+      @drag_window = false
+      # Cursor position at start of drag
+      @drag_start_x = nil
+      # Variable to hold callback function that indicates the window position
+      @callback = nil
+      # window_min_x in graph coordinates
+      @window_min_start = 0
+      # window_max_x in graph coordinates
+      @window_max_start = 0
+      # Flag to indicate if we are currently dragging the bar
+      @drag_bar = false
+      # Flag to indicate if the cursor is in the selection window
+      @cursor_in_window = false
+      # The true maximum x value
+      @true_max_x = 0
+      @show_cursor_and_popups = false
+      @window_left_x = 0
+      @window_right_x = 0
+    end
+
+    def sizeHint
+      return @size_hint
+    end
+
+    def set_window_size(new_window_size, use_callback)
+      @window_size = new_window_size
+      @window_size = @window_min_size if @window_min_size and @window_size < @window_min_size
+      @window_size = @window_max_size if @window_max_size and @window_size > @window_max_size
+      if @lines.empty?
+        @window_max_x = 1.0
+        @window_min_x = -1.0
+      else
+        @window_min_x = @window_max_x - @window_size
+      end
+      graph(false)
+      @callback.call(self) if use_callback and @callback
+    end
+
+    # Sets the window size
+    def window_size=(new_window_size)
+      set_window_size(new_window_size, true)
+    end
+
+    def set_window_pos(window_min_x, window_max_x, use_callback)
+      @window_min_x = window_min_x
+      @window_max_x = window_max_x
+      @callback.call(self) if use_callback and @callback
+    end
+
+    def drag_window(x)
+      @cursor = Qt::Cursor.new(Qt::ClosedHandCursor)
+      self.setCursor(@cursor)
+
+      # Calculate the movement in terms of the graph coordinates (not the x values)
+      temp_min = (@window_min_start + (x - @drag_start_x))
+      temp_max = (@window_max_start + (x - @drag_start_x))
+
+      # Only graph if the user hasn't dragged the window outside the graph
+      if temp_min >= @graph_left_x and temp_max <= @graph_right_x
+        #Now convert the graph coordinates back to the x values
+        @window_min_x = scale_graph_to_value_x(temp_min)
+        @window_max_x = scale_graph_to_value_x(temp_max)
+      else # The user dragged outside the allowable area
+        if temp_min < @graph_left_x
+          @window_min_x = @x_min
+          @window_max_x = @x_min + @window_size
+        elsif temp_max > @graph_right_x
+          @window_max_x = scale_graph_to_value_x(@graph_right_x)
+          @window_min_x = @window_max_x - @window_size
+        end
+      end
+      @window_min_x = @x_min if @window_min_x < @x_min
+      @window_max_x = @x_max if @window_max_x > @x_max
+      @redraw_needed = true
+      graph()
+    end
+
+    def drag_bar(x)
+      if @cursor_on_bar == :LEFT
+        temp_min = (@window_min_start + (x - @drag_start_x))
+        temp_max = @window_max_start
+      else
+        temp_min = @window_min_start
+        temp_max = (@window_max_start + (x - @drag_start_x))
+      end
+
+      value_temp_min = scale_graph_to_value_x(temp_min)
+      value_temp_max = scale_graph_to_value_x(temp_max)
+
+      # Verify the left bar hasn't moved past the minimum size
+      if value_temp_min > (@window_max_x - @window_min_size)
+        @window_min_x = @window_max_x - @window_min_size
+      # Verify the left bar hasn't moved past the maximum size
+      elsif @window_max_size and value_temp_min < (@window_max_x - @window_max_size)
+        @window_min_x = @window_max_x - @window_max_size
+      else
+        @window_min_x = value_temp_min
+      end
+
+      # Verify the left bar hasn't been moved past the end
+      if scale_value_to_graph_x(@window_min_x) < @graph_left_x
+        @window_min_x = @x_min
+      end
+
+      # Verify the right bar hasn't moved past the minimum size
+      if value_temp_max < (@window_min_x + @window_min_size)
+        @window_max_x = @window_min_x + @window_min_size
+      # Verify the right bar hasn't moved past the maximum size
+      elsif @window_max_size and value_temp_max > (@window_min_x + @window_max_size)
+        @window_max_x = @window_min_x + @window_max_size
+      else
+        @window_max_x = value_temp_max
+      end
+
+      # Verify the right bar hasn't been moved past the end
+      if scale_value_to_graph_x(@window_max_x) > @graph_right_x
+        @window_max_x = @x_max
+      end
+
+      # Update window size
+      @window_min_x = @x_min if @window_min_x < @x_min
+      @window_max_x = @x_max if @window_max_x > @x_max
+      @window_size = @window_max_x - @window_min_x
+
+      @redraw_needed = true
+      graph()
+    end
+
+    def drag_lasso(x)
+      if (x - @drag_start_x).abs > 5
+        @drag_bar = true
+        @window_min_start = @drag_start_x
+        @window_max_start = @drag_start_x
+        if x > @drag_start_x
+          @cursor_on_bar = :RIGHT
+        else
+          @cursor_on_bar = :LEFT
+        end
+      end
+    end
+
+    def show_cursor(x)
+      # Initially set the variables so the cursor isn't anywhere special
+      @cursor_on_bar = nil
+      @cursor_in_window = false
+
+      # Figure out if the mouse is inside the graph so we show the Hand cursor
+      gx = scale_graph_to_value_x(x)
+
+      # Allow the user to drag the white window bars to increase the main view width
+      if (scale_value_to_graph_x(@window_min_x) - x).abs < 5
+        @cursor = Qt::Cursor.new(Qt::SizeHorCursor)
+        self.setCursor(@cursor)
+        @cursor_on_bar = :LEFT
+      elsif (scale_value_to_graph_x(@window_max_x) - x).abs < 5
+        @cursor = Qt::Cursor.new(Qt::SizeHorCursor)
+        self.setCursor(@cursor)
+        @cursor_on_bar = :RIGHT
+      elsif (@window_min_x) < gx and gx < (@window_max_x)
+        @cursor = Qt::Cursor.new(Qt::OpenHandCursor)
+        self.setCursor(@cursor)
+        @cursor_in_window = true
+      else
+        self.unsetCursor()
+      end
+    end
+
+    # Handles the mouse moving over the overview graph
+    def mouseMoveEvent(event)
+      super(event)
+      # Get the cursor position
+      x = mapFromGlobal(self.cursor.pos).x
+
+      if @drag_window
+        drag_window(x)
+      elsif @drag_bar # We're in the middle of moving one of the window bars
+        drag_bar(x)
+      elsif @drag_start_x # Lasso start
+        drag_lasso(x)
+      else # We're not dragging the window, the user just moused around so show the right cursor
+        show_cursor(x)
+      end
+    end
+
+    # Handler for leaveEvent
+    def leaveEvent(event)
+      super(event)
+      self.unsetCursor()
+      @cursor_in_window = false
+      @cursor_on_bar = nil
+      @drag_start_x = nil
+      @drag_bar = false
+      @drag_window = false
+    end # def leaveEvent
+
+    # Handles the left button being pressed in the overview graph
+    def mousePressEvent(event)
+      super(event)
+
+      # Store off the mouse click x coordinate on the graph and the window x coordinates
+      @drag_start_x = mapFromGlobal(self.cursor.pos).x
+      @window_min_start = scale_value_to_graph_x(@window_min_x)
+      @window_max_start = scale_value_to_graph_x(@window_max_x)
+      @drag_window = true if @cursor_in_window
+      @drag_bar = true if @cursor_on_bar
+    end
+
+    # Handles the left button being released
+    def mouseReleaseEvent(event)
+      self.unsetCursor()
+      if !(@drag_bar or @drag_window) and @drag_start_x
+        # Figure out what x value the click corresponds to
+        xpoint = scale_graph_to_value_x(@drag_start_x)
+
+        # Move the window values to make them equidistant from the click
+        @window_min_x = xpoint - @window_size / 2
+        @window_max_x = xpoint + @window_size / 2
+
+        # Ensure we don't put the window outside the graphable points
+        if @window_min_x < @x_min
+          @window_min_x = @x_min
+          @window_max_x = @x_min + @window_size
+        elsif @window_max_x > @x_max
+          @window_max_x = @x_max
+          @window_min_x = @x_max - @window_size
+        end
+
+        @drag_window = true
+        @redraw_needed = true
+        graph()
+        @drag_window = false
+      end
+
+      @drag_start_x = nil
+      @drag_bar = false
+      @drag_window = false
+      @callback.call(self) unless @callback.nil?
+    end
+
+    # Draws the overview graph
+    def graph(move_window = false)
+      @move_window = move_window
+      determine_graph_size()
+      scale_graph()
+      calculate_scaling_factors()
+      calculate_window_lines()
+      super()
+    end
+
+    def back_color=(value)
+      super(value)
+      @qt_back_color = Cosmos::getColor(@back_color)
+    end
+
+    def zoom(zoom_factor)
+      @window_size = @window_size * zoom_factor
+      @window_size = @window_min_size if @window_min_size and @window_size < @window_min_size
+      @window_size = @window_max_size if @window_max_size and @window_size > @window_max_size
+      if @lines.empty?
+        @window_max_x = 1.0
+        @window_min_x = -1.0
+      else
+        center = (@window_max_x + @window_min_x) / 2
+        @window_min_x = center - @window_size / 2
+        @window_max_x = center + @window_size / 2
+      end
+      @window_min_x = @x_min if @window_min_x < @x_min
+      @window_max_x = @x_max if @window_max_x > @x_max
+      @drag_window = true
+      @redraw_needed = true
+      graph()
+      @drag_window = false
+      @callback.call(self) if @callback
+    end
+
+    def zoom_in
+      zoom(1 - DEFAULT_ZOOM_FACTOR)
+    end
+
+    def zoom_out
+      zoom(1 + DEFAULT_ZOOM_FACTOR)
+    end
+
+    def pan(amount)
+      # Move the window values to make them equidistant from the click
+      new_window_min_x = @window_min_x + amount
+      new_window_max_x = @window_max_x + amount
+
+      # Ensure we don't put the window outside the graphable points
+      if new_window_min_x >= @x_min and new_window_max_x <= @x_max
+        @window_min_x = new_window_min_x
+        @window_max_x = new_window_max_x
+      elsif new_window_min_x < @x_min
+        @window_min_x = @x_min
+        @window_max_x = @x_min + @window_size
+      else
+        @window_min_x = @x_max - @window_size
+        @window_max_x = @x_max
+      end
+      @window_min_x = @x_min if @window_min_x < @x_min
+      @window_max_x = @x_max if @window_max_x > @x_max
+
+      @drag_window = true
+      @redraw_needed = true
+      graph()
+      @drag_window = false
+      @callback.call(self) unless @callback.nil?
+    end
+
+    def pan_left
+      pan(-@window_size * DEFAULT_PAN_FACTOR)
+    end
+
+    def pan_right
+      pan(@window_size * DEFAULT_PAN_FACTOR)
+    end
+
+    def keyPressEvent(event)
+      case event.key
+      when Qt::Key_Up
+        zoom_in()
+      when Qt::Key_Down
+        zoom_out()
+      when Qt::Key_Left
+        pan_left()
+      when Qt::Key_Right
+        pan_right()
+      end
+      super(event)
+    end
+
+    def focusInEvent(event)
+      self.frame_color = 'gray'
+      update()
+    end
+
+    def focusOutEvent(event)
+      self.frame_color = 'black'
+      update()
+    end
+
+    protected
+
+    # Draws the graph lines into a buffer
+
+    def draw_graph_into_back_buffer
+      # Draw overall graph and origin lines and graph lines
+      draw_graph_background(@painter)
+      draw_origin_lines(@painter)
+      draw_lines(@painter, :LEFT)
+
+      draw_selection_window(@painter)
+      draw_frame(@painter)
+    end
+
+    # Determines the size of the displayed graph
+    def determine_graph_size
+      @graph_left_x = GRAPH_SPACER
+      @graph_right_x = width - GRAPH_SPACER - 1
+      @graph_top_y = GRAPH_SPACER
+      @graph_bottom_y = height - GRAPH_SPACER - 1
+    end
+
+    # Draws the selection window
+    def draw_selection_window(dc)
+      # Draw window area without stipple
+      dc.addRectColor(@graph_left_x, 1, @window_left_x - @graph_left_x, height() - 2, @qt_back_color)
+      dc.addRectColor(@window_right_x, 1, @graph_right_x - @window_right_x, height() - 2, @qt_back_color)
+
+      # Draw window lines
+      dc.addLineColor(@window_left_x,  0, @window_left_x,  height(), @label_and_border_color)
+      dc.addLineColor(@window_right_x, 0, @window_right_x, height(), @label_and_border_color)
+    end
+
+    def calculate_window_lines
+      # Determine positions of window lines
+      # If we're dragging the window then we draw the lines exactly as they have been
+      # set by the mouse click and mouse drag event handler
+      if @drag_window or @drag_bar or not @move_window
+        # The window lines are in terms of the graph x values so convert to the graph coordinate system
+        @window_left_x = scale_value_to_graph_x(@window_min_x)
+        @window_left_x = @graph_left_x if @window_left_x < @graph_left_x
+        @window_left_x = @graph_right_x if @window_left_x > @graph_right_x
+        @window_right_x = scale_value_to_graph_x(@window_max_x)
+        @window_right_x = @graph_right_x if @window_right_x > @graph_right_x
+        @window_right_x = @graph_left_x if @window_right_x < @graph_left_x
+      else # If we're not dragging the window we want to adjust the window lines automatically
+        @window_max_x = @x_max
+
+        # Graph the right window bounds line
+        @window_right_x = scale_value_to_graph_x(@window_max_x)
+        @window_right_x = @graph_right_x if @window_right_x > @graph_right_x
+
+        # Graph the left window bounds line
+        if @x_min == @x_max
+          @window_min_x = @x_min - 1.0
+          @window_max_x = @x_max + 1.0
+        end
+        if (@x_max - @x_min) > @window_size
+          # Once we have enough points the left line trails the right by the size of the window
+          @window_min_x = @window_max_x - @window_size
+          @window_left_x = scale_value_to_graph_x(@window_min_x)
+          @window_left_x = @graph_left_x if @window_left_x < @graph_left_x
+        else # Initially we don't have enough points so the left line is at the GRAPH_SPACER
+          @window_min_x = @x_min
+          @window_max_x = @x_max
+          @window_left_x = GRAPH_SPACER
+        end
+      end
+    end
+
+  end # class OverviewGraph
+
+end # module Cosmos