cosmos 4.0.3-java

data/lib/cosmos/gui/dialogs/tlm_details_dialog.rb

@@ -0,0 +1,201 @@
+# 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
+
+# This file contains the implementation and TlmDetailsDialog class.   This class
+# is used to view a telemetry items settings typically on a right click.
+
+require 'cosmos'
+require 'cosmos/gui/dialogs/details_dialog'
+require 'cosmos/packets/packet'
+
+module Cosmos
+  # Creates a dialog which shows the details of the given telemetry item.
+  class TlmDetailsDialog < DetailsDialog
+    slots 'value_update_timeout()'
+
+    # Period for the update thread which updates the dialog values
+    VALUE_UPDATE_PERIOD_MS = 1000
+
+    # @param parent (see DetailsDialog#initialize)
+    # @param target_name (see DetailsDialog#initialize)
+    # @param packet_name (see DetailsDialog#initialize)
+    # @param item_name (see DetailsDialog#initialize)
+    # @param packet [Packet] If a Packet is given the dialog will read the
+    #   value from the given packet and will not update. If the packet
+    #   parameters is nil the value will be read continously from the System.
+    def initialize(parent, target_name, packet_name, item_name, packet = nil)
+      super(parent, target_name, packet_name, item_name)
+
+      @item_array = [[@target_name, @packet_name, @item_name],
+                     [@target_name, @packet_name, @item_name],
+                     [@target_name, @packet_name, @item_name],
+                     [@target_name, @packet_name, @item_name]]
+
+      begin
+        update = false
+        if !packet
+          update = true
+          _, item = System.telemetry.packet_and_item(target_name, packet_name, item_name)
+        else
+          item = packet.get_item(item_name)
+        end
+
+        setWindowTitle("#{@target_name} #{@packet_name} #{@item_name} Details")
+
+        layout = Qt::VBoxLayout.new
+        layout.addWidget(Qt::Label.new(tr("#{target_name} #{packet_name} #{item_name}")))
+
+        # Display the item values
+        item_values = Qt::GroupBox.new(tr("Item Values"))
+
+        values_layout = Qt::FormLayout.new
+        @raw_value = Qt::LineEdit.new
+        @raw_value.setReadOnly(true)
+        values_layout.addRow(tr("Raw Value:"), @raw_value)
+        @hex_raw_value = nil
+        @hex_raw_num_digits = 0
+        case item.data_type
+        when :INT, :UINT
+          if item.bit_size >= 0
+            @hex_raw_value = Qt::LineEdit.new
+            @hex_raw_value.setReadOnly(true)
+            @hex_raw_num_digits = (((item.bit_size - 1) / 8) + 1) * 2
+            values_layout.addRow(tr("Hex Raw Value:"), @hex_raw_value)
+          end
+        end
+        @converted_value = Qt::LineEdit.new
+        @converted_value.setReadOnly(true)
+        values_layout.addRow(tr("Converted Value:"), @converted_value)
+        @formatted_value = Qt::LineEdit.new
+        @formatted_value.setReadOnly(true)
+        values_layout.addRow(tr("Formatted Value:"), @formatted_value)
+        @formatted_with_units_value = Qt::LineEdit.new
+        @formatted_with_units_value.setReadOnly(true)
+        values_layout.addRow(tr("Formatted with Units Value:"), @formatted_with_units_value)
+        @limits_state = Qt::LineEdit.new
+        @limits_state.setReadOnly(true)
+        values_layout.addRow(tr("Limits State:"), @limits_state)
+
+        item_values.setLayout(values_layout)
+        layout.addWidget(item_values)
+
+        if update
+          @timer = Qt::Timer.new
+          connect(@timer, SIGNAL('timeout()'), self, SLOT('value_update_timeout()'))
+          @timer.method_missing(:start, VALUE_UPDATE_PERIOD_MS)
+          value_update_timeout()
+        else
+          raw_value = packet.read(item_name, :RAW).to_s
+          @raw_value.text = raw_value
+          set_hex_value(raw_value) if @hex_raw_value
+          @converted_value.text = packet.read(item_name, :CONVERTED).to_s
+          @formatted_value.text = packet.read(item_name, :FORMATTED).to_s
+          @formatted_with_units_value.text = packet.read(item_name, :WITH_UNITS).to_s
+        end
+
+        # Display the item details
+        item_details = Qt::GroupBox.new(tr("Item Details"))
+        item_details.setLayout(build_details_layout(item, :TLM))
+        layout.addWidget(item_details)
+
+        # Add the OK button
+        ok = Qt::PushButton.new("Ok")
+        connect(ok, SIGNAL('clicked()'), self, SLOT('close()'))
+        if update
+          connect(self, SIGNAL('finished(int)')) do |result|
+            @timer.stop
+          end
+        end
+        layout.addWidget(ok)
+
+        self.setLayout(layout)
+        self.show
+        self.raise
+      rescue DRb::DRbConnError
+        # Just do nothing
+      end
+    end
+
+    def value_update_timeout
+      # Gather updated values
+      values, limits_states, limits_settings, limits_set = get_tlm_values(@item_array, Packet::VALUE_TYPES)
+      update_limits_details(limits_settings, limits_set)
+      update_text_fields(values, limits_states[0])
+    rescue DRb::DRbConnError
+      # Just do nothing
+    end
+
+    protected
+
+    def set_hex_value(value)
+      if Array === value
+        text = "["
+        value[0..-2].each do |part|
+          text << sprintf("0x%0#{@hex_raw_num_digits}X, ", part.to_i)
+        end
+        text << sprintf("0x%0#{@hex_raw_num_digits}X", value[-1].to_i) if value[-1]
+        text << "]"
+        @hex_raw_value.text = text
+      else
+        @hex_raw_value.text = sprintf("0x%0#{@hex_raw_num_digits}X", value.to_i)
+      end
+    end
+
+    def update_limits_details(limits_settings, limits_set)
+      return unless limits_settings[0]
+      label_text = "RL/#{limits_settings[0][0]} YL/#{limits_settings[0][1]} YH/#{limits_settings[0][2]} RH/#{limits_settings[0][3]}"
+      if limits_settings[0][4] && limits_settings[0][5]
+        label_text << " GL/#{limits_settings[0][4]} GH/#{limits_settings[0][5]}"
+      end
+      if @limits_labels[limits_set]
+        @limits_labels[limits_set].text = label_text
+      elsif @limits_layout
+        label = Qt::Label.new(label_text)
+        @limits_labels[limits_set] = label
+        @limits_layout.addRow(tr("#{limits_set}:"), label)
+      end
+    end
+
+    def determine_limits_color(limit_state)
+      case limit_state
+      when :RED, :RED_HIGH, :RED_LOW
+        Cosmos::RED
+      when :YELLOW, :YELLOW_HIGH, :YELLOW_LOW
+        Cosmos::YELLOW
+      when :GREEN, :GREEN_HIGH, :GREEN_LOW
+        Cosmos::GREEN
+      when :BLUE
+        Cosmos::BLUE
+      when :STALE
+        Cosmos::PURPLE
+      else
+        Cosmos::BLACK
+      end
+    end
+
+    def update_text_fields(values, limits_state)
+      color = determine_limits_color(limits_state)
+      @raw_value.setColors(color, Cosmos::WHITE)
+      @raw_value.text = values[0].to_s
+      if @hex_raw_value
+        @hex_raw_value.setColors(color, Cosmos::WHITE)
+        set_hex_value(values[0])
+      end
+      @converted_value.setColors(color, Cosmos::WHITE)
+      @converted_value.text = values[1].to_s
+      @formatted_value.setColors(color, Cosmos::WHITE)
+      @formatted_value.text = values[2].to_s
+      @formatted_with_units_value.setColors(color, Cosmos::WHITE)
+      @formatted_with_units_value.text = values[3].to_s
+      @limits_state.setColors(color, Cosmos::WHITE)
+      @limits_state.text = limits_state.to_s
+    end
+  end
+end

data/lib/cosmos/gui/dialogs/tlm_edit_dialog.rb

@@ -0,0 +1,79 @@
+# 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
+
+# This file contains the implementation and TlmEditDialog class.   This class
+# is used to edit a telemetry items settings typically on a right click.
+
+require 'cosmos'
+require 'cosmos/gui/qt'
+require 'cosmos/script'
+
+module Cosmos
+  # Dialog which allows the user to enable or disable limits checking for the
+  # given item.
+  class TlmEditDialog
+    # @param parent [Qt::Widget] Dialog parent
+    # @param target_name [String] Name of the target
+    # @param packet_name [String] Name of the packet
+    # @param item_name [String] Name of the item
+    def initialize(parent, target_name, packet_name, item_name)
+      begin
+        limits_enabled = limits_enabled?(target_name, packet_name, item_name)
+      rescue RuntimeError
+        # Error most likely due to LATEST packet - Ignore
+        limits_enabled = nil
+      end
+
+      # Check for nil because true and false are both valid values
+      if limits_enabled.nil?
+        Qt::MessageBox.information(parent, "Edit Settings for #{target_name} #{packet_name} #{item_name}",
+          'No Editable Fields for this Item')
+        return
+      end
+
+      dialog = Qt::Dialog.new(parent, Qt::WindowTitleHint | Qt::WindowSystemMenuHint)
+      dialog.setWindowTitle("Edit Settings for #{target_name} #{packet_name} #{item_name}")
+      dialog_layout = Qt::VBoxLayout.new
+      dialog_layout.addWidget(Qt::Label.new("Warning: Edits affect all COSMOS tools, not just this application!"))
+
+      check_layout = Qt::HBoxLayout.new
+      check_label = Qt::Label.new("Limits Checking Enabled:")
+      checkbox = Qt::CheckBox.new
+      checkbox.setChecked(limits_enabled)
+      check_label.setBuddy(checkbox)
+      check_layout.addWidget(check_label)
+      check_layout.addWidget(checkbox)
+      dialog_layout.addLayout(check_layout)
+
+      button_layout = Qt::HBoxLayout.new
+      ok = Qt::PushButton.new("Ok")
+      ok.connect(SIGNAL('clicked()')) { dialog.accept }
+      button_layout.addWidget(ok)
+      cancel = Qt::PushButton.new("Cancel")
+      cancel.connect(SIGNAL('clicked()')) { dialog.reject }
+      button_layout.addWidget(cancel)
+      dialog_layout.addLayout(button_layout)
+
+      dialog.setLayout(dialog_layout)
+      dialog.show
+      dialog.raise
+      if dialog.exec == Qt::Dialog::Accepted
+        if checkbox.isChecked()
+          enable_limits(target_name, packet_name, item_name)
+        else
+          disable_limits(target_name, packet_name, item_name)
+        end
+      end
+      dialog.dispose
+    rescue DRb::DRbConnError
+      # Just do nothing
+    end
+  end
+end

data/lib/cosmos/gui/dialogs/tlm_graph_dialog.rb

@@ -0,0 +1,108 @@
+# 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
+
+# This file contains the implementation and TlmGraphDialog class.   This class
+# is used to open a telemetry grapher to graph a telemetry item, typically on
+# a right click.
+
+require 'cosmos'
+require 'cosmos/gui/qt'
+require 'cosmos/gui/choosers/integer_chooser'
+require 'cosmos/script'
+
+module Cosmos
+  # Dialog which allows the user to start graphing the given item.  If the
+  # item is a fixed-size array, this allows the user to determine whether to
+  # graph a single index within the array or all indices within the array.
+  # If the item is a variable-sized array, this allows the user to select a
+  # single index to graph.
+  class TlmGraphDialog
+    # @param parent [Qt::Widget] Dialog parent
+    # @param target_name [String] Name of the target
+    # @param packet_name [String] Name of the packet
+    # @param item_name [String] Name of the item
+    def initialize(parent, target_name, packet_name, item_name)
+      packet, item = System.telemetry.packet_and_item(target_name, packet_name, item_name)
+
+      num_array_elements = 0
+      if item.array_size
+        if item.array_size > 0
+          # Fixed size array
+          num_array_elements = item.array_size / item.bit_size
+        else
+          # Variable size array
+          num_array_elements = -1
+        end
+      end
+
+      item_string = ""
+
+      if num_array_elements != 0
+        dialog = Qt::Dialog.new(parent, Qt::WindowTitleHint | Qt::WindowSystemMenuHint)
+        dialog.setWindowTitle("Select array index")
+        dialog_layout = Qt::VBoxLayout.new
+        dialog_layout.addWidget(Qt::Label.new("#{target_name} #{packet_name} #{item_name} is an array."))
+
+        if num_array_elements > 0
+          dialog_layout.addWidget(Qt::Label.new("Select array index to graph or graph all:"))
+          index_chooser = IntegerChooser.new(parent, 'Array Index:', 0, 0, num_array_elements-1)
+        else
+          dialog_layout.addWidget(Qt::Label.new("Select array index to graph:"))
+          index_chooser = IntegerChooser.new(parent, 'Array Index:', 0, 0)
+        end
+        dialog_layout.addWidget(index_chooser)
+
+        checkbox = nil
+        if num_array_elements > 0
+          check_layout = Qt::HBoxLayout.new
+          check_label = Qt::Label.new("Graph all:")
+          checkbox = Qt::CheckBox.new
+          checkbox.setChecked(false)
+          check_label.setBuddy(checkbox)
+          check_layout.addWidget(check_label)
+          check_layout.addWidget(checkbox)
+          dialog_layout.addLayout(check_layout)
+        end
+
+        button_layout = Qt::HBoxLayout.new
+        ok = Qt::PushButton.new("Ok")
+        ok.connect(SIGNAL('clicked()')) { dialog.accept }
+        button_layout.addWidget(ok)
+        cancel = Qt::PushButton.new("Cancel")
+        cancel.connect(SIGNAL('clicked()')) { dialog.reject }
+        button_layout.addWidget(cancel)
+        dialog_layout.addLayout(button_layout)
+
+        dialog.setLayout(dialog_layout)
+        dialog.show
+        dialog.raise
+        if dialog.exec == Qt::Dialog::Accepted
+          indices_to_graph = [index_chooser.value.to_i]
+          if num_array_elements > 0 and checkbox.isChecked()
+            indices_to_graph = (0..num_array_elements-1).to_a
+          end
+          indices_to_graph.each {|i| item_string << "-i \"#{target_name} #{packet_name} #{item_name}[#{i}]\" "}
+        else
+          # Cancel - graph nothing.
+          item_string = ""
+        end
+        dialog.dispose
+      else
+        # This is not an array item, we don't need to create a dialog box...
+        item_string << "-i \"#{target_name} #{packet_name} #{item_name}\" "
+      end
+
+      # Start grapher if necessary
+      if !item_string.empty?
+        Cosmos.run_cosmos_tool("TlmGrapher", "#{item_string} --system #{File.basename(System.initial_filename)}")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,482 @@
+# 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/ext/line_graph' # Only supported with MRI
+require 'cosmos/gui/qt'
+require 'cosmos/gui/dialogs/exception_dialog'
+require 'cosmos/gui/line_graph/lines'
+require 'cosmos/gui/line_graph/line_graph_drawing'
+require 'cosmos/gui/line_graph/line_graph_scaling'
+require 'cosmos/gui/line_graph/line_graph_popups'
+
+module Cosmos
+  # Widget which displays a line graph. Graph provides decorations such as
+  # titles, labels, grid lines, and a legend. Mouse tracking is provided to allow
+  # popups on graph values. Automatic scaling is provided to scale the X and Y
+  # axis according to the data values.
+  class LineGraph < Qt::Widget
+    # Create attr_accessors that automatically set the redraw_needed flag when
+    # they are set
+    def self.attr_accessor_with_redraw(*symbols)
+     symbols.each do |name|
+        self.class_eval("def #{name}; @#{name}; end")
+        self.class_eval(%Q{
+          def #{name}=(value)
+            @#{name} = value
+            @redraw_needed = true
+          end
+        })
+      end
+    end
+
+    # Max seconds between clicks for a double click
+    DOUBLE_CLICK_SECONDS = 0.2
+
+    #########################################################################
+    # Configurable Attributes which when set result in a redraw needed
+    #########################################################################
+
+    # Draw a small square at each data point of this size
+    attr_accessor_with_redraw :point_size
+    # Draws the lines between points - true/false
+    attr_accessor_with_redraw :show_lines
+    # Show x and y gridlines - true/false
+    attr_accessor_with_redraw :show_x_grid_lines, :show_y_grid_lines
+    # Manual distance between x and y gridlines
+    # Note that right y grid lines are slave to left y grid lines
+    # unless there are only right lines
+    attr_accessor_with_redraw :manual_x_grid_line_scale, :manual_y_grid_line_scale
+    # Draw Legend - true/false
+    attr_accessor_with_redraw :show_legend
+    # Draw cursor / popups - true/false
+    attr_accessor_with_redraw :show_cursor_and_popups
+    # Overall frame color and size in pixels
+    attr_accessor_with_redraw :frame_color, :frame_size
+    # Canvas and graph background color
+    attr_accessor_with_redraw :back_color, :graph_back_color
+    # Label and Border Text Color
+    attr_accessor_with_redraw :label_and_border_color
+    # Graph Title Text
+    attr_accessor_with_redraw :title
+    # X axis and left and right Y axis text
+    attr_accessor_with_redraw :x_axis_title, :left_y_axis_title, :right_y_axis_title
+    # Maximum number of characters to show for a x and y axis label
+    attr_accessor_with_redraw :max_x_characters, :max_y_characters
+    # Minimum width and height of graph
+    attr_accessor_with_redraw :minimum_width, :minimum_height
+    # Error associated with the graph
+    attr_accessor_with_redraw :error
+    # Flag indicating if x data is ordered or not
+    attr_accessor_with_redraw :ordered_x_values
+    # Flag indicating if popups should always show both x and y values
+    attr_accessor_with_redraw :show_popup_x_y
+    # Use x_value as floating point UTC timestamp with unix epoch
+    attr_accessor_with_redraw :unix_epoch_x_values
+    # Display x_value as UTC timestamp
+    attr_accessor_with_redraw :utc_time
+    # Display legend on bottom or right side
+    attr_accessor_with_redraw :legend_position
+
+    #########################################################################
+    # Callback attributes
+    #########################################################################
+
+    # Callback called when a cursor line is drawn - call(self, graph_x, @left_button_pressed)
+    attr_accessor :draw_cursor_line_callback
+    # Callback called when the mouse leaves a graph - call(self)
+    attr_accessor :mouse_leave_callback
+    # Callback called when the mouse left button is pressed - call(self)
+    attr_accessor :mouse_left_button_press_callback
+    # Callback called before exception popup is displayed - call(self)
+    attr_accessor :pre_error_callback
+    # Callback called after exception popup is displayed - call(self)
+    attr_accessor :post_error_callback
+
+    #########################################################################
+    # Readable Attributes
+    #########################################################################
+
+    # Minimum and maximum shown x values
+    attr_reader :x_min, :x_max
+    # Minimum and maximum shown x value label
+    attr_reader :x_min_label, :x_max_label
+    # Minimm and maximum shown left y value
+    attr_reader :left_y_min, :left_y_max
+    # Minimum and maximum shown right y value
+    attr_reader :right_y_min, :right_y_max
+    # Extra horizontal lines
+    attr_reader :horizontal_lines
+
+    #########################################################################
+    # Public Interface Methods
+    #########################################################################
+
+    def initialize(parent = nil)
+      super(parent)
+
+      #######################################################################
+      # Initialize configurable attributes to default values
+      #######################################################################
+      @point_size = 5
+      @show_lines = true
+      @show_x_grid_lines = false
+      @manual_x_grid_line_scale = nil
+      @show_y_grid_lines = false
+      @manual_y_grid_line_scale = nil
+      @show_legend = false
+      @show_cursor_and_popups = true
+      @frame_color = 'black'
+      @frame_size = 0
+      @back_color = 'white'
+      @graph_back_color = 'grey'
+      @label_and_border_color = 'black'
+      @title = nil
+      @x_axis_title = nil
+      @left_y_axis_title = nil
+      @right_y_axis_title = nil
+      @max_x_characters = 15
+      @max_y_characters = 8
+      @minimum_width = 250
+      @minimum_height = 100
+      @error = nil
+      @ordered_x_values = true
+      @show_popup_x_y = false
+      @unix_epoch_x_values = true
+      @utc_time = false
+      @legend_position = :bottom # :bottom or :right
+
+      # Initialize the callbacks
+      @draw_cursor_line_callback = nil
+      @mouse_leave_callback = nil
+      @mouse_left_button_press_callback = nil
+      @pre_error_callback = nil
+      @post_error_callback = nil
+
+      #######################################################################
+      # Initialize read-only attributes to default values
+      #######################################################################
+
+      @x_max = 1
+      @x_min = -1
+      @x_max_label = nil
+      @x_min_label = nil
+      @left_y_max = 1
+      @left_y_min = -1
+      @right_y_max = 1
+      @right_y_min = -1
+      @horizontal_lines = []
+
+      ###########################
+      # Initialize internal state
+      ###########################
+
+      # Create line data
+      @lines = Lines.new
+
+      # Painter to do all the drawing with
+      @painter = nil
+
+      # Value used to scale a x value to a x graph coordinate
+      @x_scale = 0
+
+      # Value used to scale a left y value to a y graph coordinate
+      @left_y_scale = 0
+
+      # Value used to scale a right y value to a y graph coordinate
+      @right_y_scale = 0
+
+      # Size of the font used to display text
+      @font_size = 10
+
+      # The font class used to display text
+      @font = Cosmos.getFont("Helvetica", @font_size)
+
+      # The font class used for titles
+      @title_font = Cosmos.getFont("Helvetica", @font_size + 4, Qt::Font::Bold)
+
+      # Auto scale left y-axis setting
+      @left_y_auto_scale = true
+
+      # Auto scale right y-axis setting
+      @right_y_auto_scale = true
+
+      # Auto scale x-axis setting
+      @x_auto_scale = true
+
+      # Values of x gridlines
+      @x_grid_lines = []
+
+      # Values of y gridlines on left x-axis unless no left lines
+      @y_grid_lines = []
+
+      # Distance between gridlines on the left y-axis unless no left lines
+      @y_grid_line_scale = 0.1
+
+      # Distance between gridlines on the x-axis
+      @x_grid_line_scale = 0.1
+
+      # Flag to note if the mouse in the the graph window
+      @mouse_in_window = false
+
+      # Graph right boundary in window coordinates
+      @graph_right_x = 0
+
+      # Graph left boundary in window coordinates
+      @graph_left_x = 0
+
+      # Graph top boundary in window coordinates
+      @graph_top_y = 0
+
+      # Graph bottom boundary in window coordinates
+      @graph_bottom_y = 0
+
+      # Array containing popup information
+      @popups = []
+
+      # Position of cursor line
+      @cursor_line_x = nil
+
+      # Indicates state of left mouse button
+      @left_button_pressed = false
+
+      # Flag to prevent recursion in update_graph_size
+      @in_update_graph_size = false
+
+      # Time of previous left button release
+      @previous_left_button_release_time = Time.now.sys
+
+      # List of line colors to use
+      @color_list = ['blue','red','green','darkorange', 'gold', 'purple', 'hotpink', 'lime', 'cornflowerblue', 'brown', 'coral', 'crimson', 'indigo', 'tan', 'lightblue', 'cyan', 'peru', 'maroon','orange','navy','teal','black']
+
+      @redraw_needed = true
+
+      setContentsMargins(0,0,0,0)
+
+      #setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff)
+      #setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff)
+
+      # Cause this widget to have a white background which we don't have to worry about painting
+      # This may leak memory - but it is only in initialize so that is ok.
+      p = palette()
+      p.setBrush(Qt::Palette::Active, Qt::Palette::Window, Cosmos.getBrush(Qt::white))
+      setPalette(p)
+      setBackgroundRole(Qt::Palette::Window)
+      setAutoFillBackground(true)
+
+      update_graph_size()
+
+      setMouseTracking(true) # enable mouseMoveEvents even when the mouse isn't pressed
+    end # def initialize
+
+    # Once a GraphicsView is displayed the size hint it set based on the initial display size.
+    # This causes a single GraphicsView in a layout takes to take a very large size hint.
+    # If this GraphicsView is then added to a new layout it will continue to remember that size hint
+    # and force other Widgets in that layout to be smaller than we want.
+    # Thus we set the sizeHint to 0 and allow the layout manager to do the right thing
+    #~ def sizeHint
+      #~ return Qt::Size.new(100, 100)
+    #~ end
+
+    # Handler for leaveEvent
+    def leaveEvent(event)
+      # Note that the mouse is no longer in the window
+      @mouse_in_window = false
+
+      # Clear cursor line
+      @cursor_line_x = nil
+
+      # Redraw the graph (to remove popups and cursor line)
+      graph()
+
+      # Call mouse_leave_callback so that cursor lines can be removed from
+      # other line graphs if needed
+      @mouse_leave_callback.call(self) if @mouse_leave_callback
+    end # def leaveEvent
+
+    # Handler for mouseMoveEvent
+    def mouseMoveEvent(event)
+      # Note that the mouse is in the window
+      @mouse_in_window = true
+
+      # Redraw the graph (to update popups and cursor line)
+      graph()
+    end # def mouseMoveEvent
+
+    # Handler for mousePressEvent
+    def mousePressEvent(event)
+      # Note that the left button is pressed
+      @left_button_pressed = true
+
+      @mouse_left_button_press_callback.call(self) if @mouse_left_button_press_callback
+
+      # Redraw the graph (to update popups)
+      graph()
+    end # def mousePressEvent
+
+    def mouseReleaseEvent(event)
+      left_button_release_time = Time.now.sys
+
+      if @error and ((left_button_release_time - @previous_left_button_release_time) < DOUBLE_CLICK_SECONDS)
+        @pre_error_callback.call(self) if @pre_error_callback
+        if @error.is_a? FatalError
+          ExceptionDialog.new(self, @error, 'LineGraph', false, false) # don't log it, it is known
+        else
+          ExceptionDialog.new(self, @error, 'LineGraph', false, true) # log the error
+        end
+        @post_error_callback.call(self) if @post_error_callback
+        @error = nil
+      end
+
+      # Note that the left button is not pressed
+      @left_button_pressed = false
+
+      # Redraw the graph (to update popups)
+      graph()
+
+      # Update Previous left button release time
+      @previous_left_button_release_time = left_button_release_time
+    end
+
+    # Handler for paintEvent
+    def paintEvent(event)
+      return if @painter
+      @painter = Qt::Painter.new(self)
+      @painter.setFont(@font)
+      # Seems like on initialization sometimes we get some weird bad conditions so check for them
+      if @painter.isActive and @painter.paintEngine
+        draw_graph_into_back_buffer() if @redraw_needed
+        draw_graph_to_screen()
+      end
+      @painter.dispose
+      @painter = nil
+    end
+
+    # Handler for ResizeEvent
+    def resizeEvent(event)
+      # Update internal buffer to new graph size
+      update_graph_size()
+
+      # Force a complete redraw of the graph to handle the new size
+      @redraw_needed = true
+      graph()
+    end # def resizeEvent
+
+    # Clears all knowledge of line data - the graph is a clean slate
+    def clear_lines
+      @lines.clear
+      @redraw_needed = true
+    end # def clear_lines
+
+    # Adds a line to the graph - Afterwards the graph is ready to be drawn
+    #  color = 'auto' automatically determines color from index based lookup
+    def add_line(legend_text, y, x = nil, y_labels = nil, x_labels = nil, y_states = nil, x_states = nil, color = 'auto', axis = :LEFT, max_points_plotted = nil)
+      @unix_epoch_x_values = false unless x
+
+      # if color specified as auto, do lookup
+      if (color == 'auto')
+        # If the number of lines is less than number of available colors,
+        #   choose an unused color
+        if (@lines.num_lines < @color_list.length)
+          unused_colors = @color_list.dup
+          @lines.legend.each do |name, line_color, axis|
+            unused_colors.delete(line_color)
+          end
+          color = unused_colors[0]
+        else
+          # Get an index within the color list for the next line index
+          line_color_idx = @lines.num_lines % (@color_list.length)
+          color = @color_list[line_color_idx]
+        end
+      end
+
+      @lines.add_line(legend_text, y, x, y_labels, x_labels, y_states, x_states, color, axis, max_points_plotted)
+
+      # Adding a line implies a redraw is needed
+      @redraw_needed = true
+    end # def add_line
+
+    # Draws the graph
+    def graph
+      method_missing(:update)
+    end
+
+    # Start auto scaling of the x axis
+    def auto_scale_x
+      @x_auto_scale  = true
+      @redraw_needed = true
+      graph()
+    end # def auto_scale_x
+
+    # Start auto scaling of the y axis
+    def auto_scale_y(axis)
+      if axis == :LEFT
+        @left_y_auto_scale = true
+      else # axis == :RIGHT
+        @right_y_auto_scale = true
+      end
+      @redraw_needed = true
+      graph()
+    end # def auto_scale_y
+
+    # Start manual scaling of x axis
+    def manual_scale_x(x_min, x_max, redraw_now = true)
+      if x_min <= x_max
+        @x_max = x_max
+        @x_min = x_min
+        @x_max_label = nil
+        @x_min_label = nil
+        @x_auto_scale = false
+      else
+        Kernel.raise ArgumentError, "GraphView Manual X Max must be greater than X Min"
+      end
+      @redraw_needed = true
+      graph() if redraw_now
+    end # def manual_scale_x
+
+    # Start manual scaling of y axis
+    def manual_scale_y(y_min, y_max, axis)
+      if y_min < y_max
+        if axis == :LEFT
+          @left_y_auto_scale = false
+          @left_y_max        = y_max
+          @left_y_min        = y_min
+        else
+          @right_y_auto_scale = false
+          @right_y_max        = y_max
+          @right_y_min        = y_min
+        end
+      else
+        Kernel.raise ArgumentError, "GraphView Manual Y Max must be greater than Y Min"
+      end
+      @redraw_needed = true
+      graph()
+    end # def manual_scale_y
+
+    # Set the cursor position remotely
+    def remote_draw_cursor_line_at_x(x, left_button_pressed)
+      @cursor_line_x = x
+      @left_button_pressed = left_button_pressed
+      graph()
+    end # def remote_draw_cursor_line_at_x
+
+    # Clears all horizontal lines on the graph
+    def clear_horizontal_lines
+      @horizontal_lines = []
+      @redraw_needed = true
+    end
+
+    # Add a horizontal line to the graph
+    def add_horizontal_line(y_value, color, axis = :LEFT)
+      @horizontal_lines << [y_value, color, axis]
+      @redraw_needed = true
+    end
+  end
+end