cosmos 4.5.2 → 5.0.2.pre.beta2

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

@@ -1,159 +0,0 @@
-# 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/qt'
-require 'cosmos/tools/cmd_tlm_server/cmd_tlm_server'
-require 'cosmos/tools/cmd_tlm_server/api'
-
-module Cosmos
-  # Dialog which parses the specified packet and creates labels and values for
-  # each packet item. Items with states are displayed as comboboxes. The user
-  # can change any of the values and upon clicking the done button the values
-  # are written back into the packet.
-  class SetTlmDialog < Qt::Dialog
-    # @return [Array<String>] Items which should not be displayed in the dialog
-    IGNORED_ITEMS = ['PACKET_TIMESECONDS', 'PACKET_TIMEFORMATTED', 'RECEIVED_TIMESECONDS', 'RECEIVED_TIMEFORMATTED', 'RECEIVED_COUNT', 'PKTID', 'CONFIG']
-
-    # @return [String] Errors encountered when trying to set the values back
-    #   into the packet
-    attr_reader :error_label
-    # @return [String] Name of the item which has encountered an error
-    attr_accessor :current_item_name
-
-    # @param parent [Qt::Widget] Parent of this dialog
-    # @param title [String] Dialog title
-    # @param done_button [String] Text to place on the button which will close
-    #   the dialog and update the packet
-    # @param cancel_button [String] Text to place on the button which will close
-    #   the dialog without setting the packet
-    # @param target_name [String] Name of the target
-    # @param packet_name [String] Name of the packet
-    # @param packet [Packet] If the packet is given the items will be taken
-    #   from the packet instead of using the target_name and packet_name to look
-    #   up the packet from the system.
-    def initialize(parent,
-                   title,
-                   done_button,
-                   cancel_button,
-                   target_name,
-                   packet_name,
-                   packet = nil)
-      super(parent, Qt::WindowTitleHint | Qt::WindowSystemMenuHint)
-      @target_name = target_name
-      @packet_name = packet_name
-
-      extend Api if CmdTlmServer.instance
-
-      if !packet
-        @items = get_tlm_packet(@target_name, @packet_name)
-      else
-        @items = packet.read_all_with_limits_states
-      end
-      @items.delete_if {|item_name, _, _| IGNORED_ITEMS.include?(item_name)}
-
-      setWindowTitle(title)
-      Cosmos.load_cosmos_icon
-
-      layout = Qt::VBoxLayout.new
-      @tab_book = Qt::TabWidget.new
-      values_layout = Qt::FormLayout.new
-      widget = Qt::Widget.new
-      widget.layout = values_layout
-      page_count = 1
-      @tab_book.addTab(widget, "Page #{page_count}")
-      @editors = []
-      @items.each do |item_name, item_value, _|
-        _, item = System.telemetry.packet_and_item(@target_name, @packet_name, item_name)
-        if item.states
-          @editors << Qt::ComboBox.new
-          @editors[-1].setSizeAdjustPolicy(Qt::ComboBox::AdjustToContents)
-          current_index = 0
-          index = 0
-          item.states.each do |state_name, state_value|
-            @editors[-1].addItem(state_name)
-            current_index = index if state_name == item_value
-            index += 1
-          end
-          if item.states.length > 20
-            @editors[-1].setMaxVisibleItems(20)
-          else
-            @editors[-1].setMaxVisibleItems(item.states.length)
-          end
-          @editors[-1].setCurrentIndex(current_index)
-        else
-          @editors << Qt::LineEdit.new
-          @editors[-1].text = item_value.to_s
-        end
-        if item.meta.keys && item.meta.keys.include?("READ_ONLY")
-          @editors[-1].setEnabled(false)
-        end
-        values_layout.addRow(item_name, @editors[-1])
-        if (@editors.length % 10 == 0) && (@items.length > @editors.length)
-          values_layout = Qt::FormLayout.new
-          widget = Qt::Widget.new
-          widget.layout = values_layout
-          page_count += 1
-          @tab_book.addTab(widget, "Page #{page_count}")
-        end
-      end
-
-      layout.addWidget(@tab_book)
-      @error_label = Qt::Label.new('')
-      layout.addWidget(@error_label)
-
-      button_layout = Qt::HBoxLayout.new
-      # Create Done Button
-      done_button = Qt::PushButton.new(done_button)
-      connect(done_button, SIGNAL('clicked()'), self, SLOT('accept()'))
-      button_layout.addWidget(done_button)
-
-      # Create Cancel Button
-      cancel_button = Qt::PushButton.new(cancel_button)
-      connect(cancel_button, SIGNAL('clicked()'), self, SLOT('reject()'))
-      button_layout.addWidget(cancel_button)
-      layout.addLayout(button_layout)
-
-      self.setLayout(layout)
-    end
-
-    # Set all user edited items from the dialog back into the packet
-    def set_items
-      index = 0
-      item_hash = {}
-      @items.each do |item_name, _, _|
-        item_hash[item_name] = @editors[index].text
-        index += 1
-      end
-      # Send to routers, and start new logs (which should inject the META packet)
-      inject_tlm(@target_name, @packet_name, item_hash, :CONVERTED, true, false, true)
-    end
-
-    # (see #initialize)
-    def self.execute(parent, title, done_button, cancel_button, target_name, packet_name, packet = nil)
-      dialog = self.new(parent, title, done_button, cancel_button, target_name, packet_name, packet)
-      begin
-        dialog.raise
-        if dialog.exec == Qt::Dialog::Accepted
-          dialog.set_items
-          result = true
-        else
-          result = false
-        end
-      rescue => err
-        dialog.error_label.setText("Error Setting #{dialog.current_item_name}: " + err.message)
-        retry
-      ensure
-        dialog.dispose
-      end
-      result
-    end
-  end
-end

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

@@ -1,145 +0,0 @@
-# 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 for the COSMOS Splash Screen
-
-require 'cosmos'
-require 'cosmos/gui/qt_tool'
-require 'cosmos/gui/dialogs/exception_dialog'
-
-module Cosmos
-  # Provides a single class method which creates a splash screen dialog box.
-  # This dialog has both a text message box and progress bar.
-  class Splash
-    # Creates a dialog with a message box and a progress bar.
-    class SplashDialogBox < Qt::Dialog
-      # @param parent [Qt::Widget] The dialog parent
-      def initialize(parent)
-        super(parent, Qt::WindowTitleHint | Qt::CustomizeWindowHint)
-        setWindowTitle(parent.windowTitle)
-        setModal(true)
-        layout = Qt::VBoxLayout.new
-
-        splash_image_filename = File.join(::Cosmos::USERPATH, 'config', 'data', 'splash.gif')
-        splash_image_filename = File.join(::Cosmos::PATH, 'data', 'splash.gif') unless File.exist?(splash_image_filename)
-        image = Qt::Pixmap.new(splash_image_filename)
-        label = Qt::Label.new
-        label.setPixmap(image)
-        layout.addWidget(label)
-
-        @message_box = Qt::LineEdit.new
-        @message_box.setReadOnly(true)
-        layout.addWidget(@message_box)
-        @progress_bar = Qt::ProgressBar.new
-        layout.addWidget(@progress_bar)
-        setLayout(layout)
-
-        @progress = 0
-        @complete = false
-      end
-
-      # @param message [String] Text to place in the message box. Text is
-      #   replaced and not appended.
-      def message=(message)
-        unless @complete
-          Qt.execute_in_main_thread(false) do
-            @message_box.setText(message)
-          end
-        end
-      end
-
-      # @param progress [Float] Set the progress bar to a percentage from 0 to 1
-      def progress=(progress)
-        progress_int = (progress * 100).to_i
-        if !@complete && (@progress != progress_int)
-          @progress = progress_int
-          Qt.execute_in_main_thread(false) do
-            @progress_bar.setValue(progress_int)
-          end
-        end
-      end
-
-      # @return [Method] message= method
-      def message_callback
-        method(:message=)
-      end
-
-      # @return [Method] progress= method
-      def progress_callback
-        method(:progress=)
-      end
-
-      # Override keyPressEvent to prevent Esc from closing the splash dialog
-      # @param event [Qt::KeyEvent] Pressed key event
-      def keyPressEvent(event)
-        # Don't allow the Escape key to close this dialog
-        if event.key == Qt::Key_Escape
-          event.ignore
-        else
-          super(event)
-        end
-      end
-    end
-
-    # @param parent [Qt::Widget] Dialog parent
-    # @param wait_for_complete [Boolean] Whether to call dialog.exec and block
-    #   other threads from running until this dialog is closed
-    # @yieldparam dialog [SplashDialogBox] The dialog box
-    def self.execute(parent, wait_for_complete = false, &block)
-      # Create the dialog and show it
-      dialog = SplashDialogBox.new(parent)
-      dialog.show unless wait_for_complete
-      dialog.raise
-
-      # Create a new thread to run the block
-      # WARNING! If you need to update your own gui you must wrap it with:
-      #   Qt.execute_in_main_thread(true) do
-      #     < Update the GUI >
-      #   end
-      Thread.new do
-        error = nil
-        begin
-          yield dialog
-        rescue Exception => e
-          error = e
-        end
-
-        @complete = true
-
-        # If the block threw an error show it before allowing the application to crash
-        if error
-          Qt.execute_in_main_thread(true) do
-            ExceptionDialog.new(parent, error, "Error During Startup")
-          end
-        end
-
-        Qt.execute_in_main_thread(true) do
-          # Once the block has completed we hide and dispose the dialog to allow the main application to take over
-          dialog.hide
-
-          unless wait_for_complete
-            # Need to make sure all Qt.execute_in_main_thread() have completed before disposing or
-            # we will segfault
-            Qt::RubyThreadFix.queue.pop.call until Qt::RubyThreadFix.queue.empty?
-
-            dialog.dispose
-          end
-        end
-      end
-      if wait_for_complete
-        dialog.exec
-        # Need to make sure all Qt.execute_in_main_thread() have completed
-        # before disposing or we will segfault
-        Qt::RubyThreadFix.queue.pop.call until Qt::RubyThreadFix.queue.empty?
-        dialog.dispose
-      end
-    end
-  end
-end

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

@@ -1,202 +0,0 @@
-# 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("#{target_name} #{packet_name} #{item_name}"))
-
-        # Display the item values
-        item_values = Qt::GroupBox.new("Item Values")
-
-        values_layout = Qt::FormLayout.new
-        @raw_value = Qt::LineEdit.new
-        @raw_value.setReadOnly(true)
-        values_layout.addRow("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("Hex Raw Value:", @hex_raw_value)
-          end
-        end
-        @converted_value = Qt::LineEdit.new
-        @converted_value.setReadOnly(true)
-        values_layout.addRow("Converted Value:", @converted_value)
-        @formatted_value = Qt::LineEdit.new
-        @formatted_value.setReadOnly(true)
-        values_layout.addRow("Formatted Value:", @formatted_value)
-        @formatted_with_units_value = Qt::LineEdit.new
-        @formatted_with_units_value.setReadOnly(true)
-        values_layout.addRow("Formatted with Units Value:", @formatted_with_units_value)
-        @limits_state = Qt::LineEdit.new
-        @limits_state.setReadOnly(true)
-        values_layout.addRow("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("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("#{limits_set}:", label)
-      end
-      update_limits_checking()
-    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

@@ -1,79 +0,0 @@
-# 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

@@ -1,110 +0,0 @@
-# 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, replay = false)
-      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?
-        options = "#{item_string} --system #{File.basename(System.initial_filename)}"
-        options += " --replay" if replay
-        Cosmos.run_cosmos_tool("TlmGrapher", options)
-      end
-    end
-  end
-end