cosmos 4.2.4 → 4.5.0

data/lib/cosmos/tools/cmd_sender/cmd_param_table_item_delegate.rb

@@ -42,6 +42,9 @@ module Cosmos
     def paint(painter, option, index)
       packet_item, _, _ = @widgets[index.row]
       if index.column == 1 and packet_item and packet_item.states
+        painter.save
+        option = Qt::StyleOptionViewItemV4.new(option)
+        initStyleOption(option, index)
         # This code simply draws the current combo box text inside a button to
         # give the user an idea that they have to click it to activate it
         opt = Qt::StyleOptionButton.new
@@ -49,6 +52,18 @@ module Cosmos
         opt.text = @table.item(index.row, index.column).text.to_s
         Qt::Application.style.drawControl(Qt::Style::CE_PushButton, opt, painter)
         opt.dispose
+        painter.restore
+      # Not sure why but once we re-implement paint() the word wrapping
+      # doesn't work when we simply call super(painter, option, index)
+      # Thus we implement this to support word wrapping on the description
+      elsif index.column == 4
+        painter.save
+        option = Qt::StyleOptionViewItemV4.new(option)
+        initStyleOption(option, index)
+        option.text = index.data().toString()
+        option.features = Qt::StyleOptionViewItemV2::WrapText
+        self.parent().style().drawControl(Qt::Style.CE_ItemViewItem, option, painter)
+        painter.restore
       else
         super(painter, option, index)
       end

data/lib/cosmos/tools/cmd_sender/cmd_params.rb

@@ -0,0 +1,382 @@
+# 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'
+Cosmos.catch_fatal_exception do
+  require 'cosmos/tools/cmd_sender/cmd_param_table_item_delegate'
+  require 'cosmos/gui/dialogs/cmd_details_dialog'
+end
+
+module Cosmos
+  # Builds a command parameter widget for use in Command Sender and Command Sequence.
+  # The main method is update_cmd_params which builds all the widgets. It can take
+  # existing values for use in populating the command parameter widgets.
+  class CmdParams < Qt::Widget
+    # Class instance variables which apply to all command parameters
+    @states_in_hex = false
+    @show_ignored = false
+    class << self
+      attr_accessor :states_in_hex, :show_ignored
+    end
+    MANUALLY = CmdParamTableItemDelegate::MANUALLY
+    # Emit the modified signal to allow changes to propagate upwards
+    signals 'modified()'
+
+    def initialize
+      super()
+      @param_widgets = []
+      @table = nil
+      @packet = nil
+      @file_dir = System.paths['LOGS']
+    end
+
+    # Changes the display of items with states to hex if checked is true.
+    # Otherwise state values are displayed as decimal.
+    # @param checked [Boolean] Whether to display state values in hex
+    def states_in_hex(checked)
+      CmdParams.states_in_hex = checked
+      @param_widgets.each do |_, _, state_value_item|
+        next unless state_value_item
+        text = state_value_item.text
+        quotes_removed = text.remove_quotes
+        if text == quotes_removed
+          if checked
+            if text.is_int?
+              @table.blockSignals(true)
+              state_value_item.text = sprintf("0x%X", text.to_i)
+              @table.blockSignals(false)
+            end
+          else
+            if text.is_hex?
+              @table.blockSignals(true)
+              state_value_item.text = Integer(text).to_s
+              @table.blockSignals(false)
+            end
+          end
+        end
+      end
+    end
+
+    # @return [Hash] Hash keyed by parameter name with String formatted value
+    def params_text(raw = false)
+      params = {}
+      Qt.execute_in_main_thread do
+        @param_widgets.each do |packet_item, value_item, state_value_item|
+          text = value_item.text
+          text = state_value_item.text if state_value_item && (text == MANUALLY or raw)
+          quotes_removed = text.remove_quotes
+          if text == quotes_removed
+            if (packet_item.data_type == :STRING or packet_item.data_type == :BLOCK) and text.upcase.start_with?("0X")
+              params[packet_item.name] = text.hex_to_byte_string
+            else
+              params[packet_item.name] = text.convert_to_value
+            end
+          else
+            params[packet_item.name] = quotes_removed
+          end
+          Kernel.raise "#{packet_item.name} is required." if quotes_removed == '' && packet_item.required
+        end
+      end
+      params
+    end
+
+    # Primary method which builds the command parameter table. The passed in command packet
+    # is used to get all the command parameters to build. Existing parameters can be passed
+    # in to set the initial values for all command parameters. You can also specify whether
+    # to display the ignored parameters when building the command parameter table. Note that
+    # each time this method is called the TableWidget is disposed and rebuilt.
+    #
+    # @param packet [Packet] The command packet to build a parameter list for
+    # @param existing [Hash] Hash keyed by parameter name with text values.
+    #   These values will be used as the defaults for all command parameters.
+    # @param show_ignored [Boolean] Whether to display the ignored
+    #   parameters. Pass nil (the default) to keep the existing setting.
+    def update_cmd_params(packet, existing: nil, show_ignored: nil)
+      @packet = packet
+      old_params = {}
+      old_params = get_params(show_ignored) if !show_ignored.nil?
+      old_params = set_existing(packet, existing) if existing
+
+      # Determine which items to display
+      target = System.targets[packet.target_name]
+      packet_items = packet.sorted_items
+      shown_packet_items = []
+      packet_items.each do |packet_item|
+        next if target && target.ignored_parameters.include?(packet_item.name) && !CmdParams.show_ignored
+        shown_packet_items << packet_item
+      end
+
+      # Destroy the old table widget and parameters
+      @table.dispose if @table
+      @table = nil
+      @param_widgets = []
+      row = 0
+      shown_packet_items.each do |packet_item|
+        value_item = nil
+        state_value_item = nil
+        @table = create_table(shown_packet_items.length) unless @table
+
+        # Parameter Name
+        item = Qt::TableWidgetItem.new("#{packet_item.name}:")
+        item.setTextAlignment(Qt::AlignRight | Qt::AlignVCenter)
+        item.setFlags(Qt::NoItemFlags | Qt::ItemIsSelectable | Qt::ItemIsEnabled)
+        @table.setItem(row, 0, item)
+
+        # Parameter Value
+        if packet_item.states
+          value_item, state_value_item = create_state_item(packet_item, old_params, row)
+        else
+          value_item = create_item(packet_item, old_params, row)
+        end
+
+        # Units
+        item = Qt::TableWidgetItem.new(packet_item.units.to_s)
+        item.setTextAlignment(Qt::AlignRight | Qt::AlignVCenter)
+        item.setFlags(Qt::NoItemFlags | Qt::ItemIsSelectable | Qt::ItemIsEnabled)
+        @table.setItem(row, 3, item)
+
+        # Description
+        item = Qt::TableWidgetItem.new(packet_item.description.to_s)
+        item.setTextAlignment(Qt::AlignLeft | Qt::AlignVCenter)
+        item.setFlags(Qt::NoItemFlags | Qt::ItemIsSelectable | Qt::ItemIsEnabled)
+        @table.setItem(row, 4, item)
+
+        @param_widgets << [packet_item, value_item, state_value_item]
+        row += 1
+      end
+
+      connect_table_item_changed() if @table
+      @table
+    end
+
+    # If the user right clicks over a table item, this method displays a context
+    # menu with various options.
+    # @param point [Qt::Point] Point to display the context menu
+    def context_menu(point)
+      item = @table.itemAt(point)
+      if item
+        target_name = @packet.target_name
+        packet_name = @packet.packet_name
+        item_name = @table.item(item.row, 0).text[0..-2] # Remove :
+        if target_name.length > 0 && packet_name.length > 0 && item_name.length > 0
+          menu = Qt::Menu.new()
+
+          details_action = Qt::Action.new("Details #{target_name} #{packet_name} #{item_name}", self)
+          details_action.statusTip = "Popup details about #{target_name} #{packet_name} #{item_name}"
+          details_action.connect(SIGNAL('triggered()')) do
+            CmdDetailsDialog.new(nil, target_name, packet_name, item_name)
+          end
+          menu.addAction(details_action)
+
+          file_chooser_action = Qt::Action.new("Insert Filename", self)
+          file_chooser_action.statusTip = "Select a file and place its name into this parameter"
+          file_chooser_action.connect(SIGNAL('triggered()')) do
+            filename = Qt::FileDialog::getOpenFileName(self, "Insert Filename:", @file_dir, "All Files (*)")
+            if filename && !filename.empty?
+              @file_dir = File.dirname(filename)
+              _, value_item, state_value_item = @param_widgets[item.row]
+              if state_value_item
+                state_value_item.setText(filename)
+              elsif value_item
+                value_item.setText(filename)
+              end
+            end
+          end
+          menu.addAction(file_chooser_action)
+
+          menu.exec(@table.mapToGlobal(point))
+          menu.dispose
+        end
+      end
+    end
+
+    private
+
+    def get_params(show_ignored)
+      params = {}
+      CmdParams.show_ignored = show_ignored
+      # Save parameter values
+      @param_widgets.each do |packet_item, value_item, state_value_item|
+        text = value_item.text
+        if state_value_item
+          params[packet_item.name] = [text, state_value_item.text]
+        else
+          params[packet_item.name] = text
+        end
+      end
+      params
+    end
+
+    def set_existing(packet, existing)
+      params = {}
+      existing.each do |param_name, param_value|
+        packet_item = packet.items[param_name]
+        if packet_item.states
+          state_value = packet_item.states[param_value]
+          unless state_value # If we couldn't lookup the value by the name it's manual
+            state_value = param_value
+            param_value = MANUALLY
+          end
+          params[param_name] = [param_value.to_s, state_value.to_s]
+        else
+          params[param_name] = param_value.to_s
+        end
+      end
+      params
+    end
+
+    def create_table(length)
+      table = Qt::TableWidget.new()
+      table.setSizePolicy(Qt::SizePolicy::Expanding, Qt::SizePolicy::Expanding)
+      table.setWordWrap(true)
+      table.setRowCount(length)
+      table.setColumnCount(5)
+      table.setHorizontalHeaderLabels(['Name', '         Value or State         ', '         ', 'Units', 'Description'])
+      table.horizontalHeader.setStretchLastSection(true)
+      table.verticalHeader.setVisible(false)
+      table.setItemDelegate(CmdParamTableItemDelegate.new(table, @param_widgets, @production))
+      table.setContextMenuPolicy(Qt::CustomContextMenu)
+      table.verticalHeader.setResizeMode(Qt::HeaderView::ResizeToContents)
+      table.setEditTriggers(Qt::AbstractItemView::DoubleClicked | Qt::AbstractItemView::SelectedClicked | Qt::AbstractItemView::AnyKeyPressed)
+      table.setSelectionMode(Qt::AbstractItemView::NoSelection)
+      table.connect(SIGNAL('customContextMenuRequested(const QPoint&)')) {|point| context_menu(point) }
+      table.connect(SIGNAL('itemClicked(QTableWidgetItem*)')) do |item|
+        table.editItem(item) if (item.flags & Qt::ItemIsEditable) != 0
+      end
+      return table
+    end
+
+    def create_state_item(packet_item, old_params, row)
+      default_state = packet_item.states.key(packet_item.default)
+      if old_params[packet_item.name]
+        value_item = Qt::TableWidgetItem.new(old_params[packet_item.name][0])
+      else
+        if default_state
+          value_item = Qt::TableWidgetItem.new(default_state.to_s)
+        elsif @production
+          value_item = Qt::TableWidgetItem.new(packet_item.states.keys[0])
+        else
+          value_item = Qt::TableWidgetItem.new(MANUALLY)
+        end
+      end
+      value_item.setTextAlignment(Qt::AlignRight | Qt::AlignVCenter)
+      value_item.setFlags(Qt::NoItemFlags | Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable)
+      @table.setItem(row, 1, value_item)
+
+      state_value = packet_item.default.to_s
+      if old_params[packet_item.name]
+        state_value = old_params[packet_item.name][1]
+      end
+      is_integer = Integer(state_value) rescue false
+      if CmdParams.states_in_hex && is_integer
+        state_value_item = Qt::TableWidgetItem.new(sprintf("0x%X", state_value))
+      else
+        if state_value.is_printable?
+          state_value_item = Qt::TableWidgetItem.new(state_value)
+        else
+          state_value_item = Qt::TableWidgetItem.new("0x" + state_value.simple_formatted)
+        end
+      end
+      state_value_item.setTextAlignment(Qt::AlignRight | Qt::AlignVCenter)
+      if @production
+        state_value_item.setFlags(Qt::NoItemFlags)
+      else
+        state_value_item.setFlags(Qt::NoItemFlags | Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable)
+      end
+      @table.setItem(row, 2, state_value_item)
+
+      # If the parameter is required clear the combobox and
+      # clear the value field so they have to choose something
+      if packet_item.required && !old_params[packet_item.name]
+        value_item.setText('')
+        state_value_item.setText('')
+      end
+      return [value_item, state_value_item]
+    end
+
+    def create_item(packet_item, old_params, row)
+      if old_params[packet_item.name]
+        value_text = old_params[packet_item.name]
+      elsif packet_item.required
+        value_text = ''
+      else
+        if packet_item.format_string
+          begin
+            value_text = sprintf(packet_item.format_string, packet_item.default)
+          rescue
+            # Oh well - Don't use the format string
+            value_text = packet_item.default.to_s
+          end
+        else
+          value_text = packet_item.default.to_s
+        end
+      end
+      if !value_text.is_printable?
+        value_text = "0x" + value_text.simple_formatted
+      # Add quotes around STRING or BLOCK defaults so they are interpreted correctly
+      elsif (packet_item.data_type == :STRING or packet_item.data_type == :BLOCK)
+        value_text = "'#{value_text}'"
+      end
+      value_item = Qt::TableWidgetItem.new(value_text)
+      value_item.setTextAlignment(Qt::AlignRight | Qt::AlignVCenter)
+      value_item.setFlags(Qt::NoItemFlags | Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable)
+      @table.setItem(row, 1, value_item)
+      @table.setSpan(row, 1, 1, 2)
+      return value_item
+    end
+
+    def connect_table_item_changed
+      @table.connect(SIGNAL('itemChanged(QTableWidgetItem*)')) do |item|
+        packet_item, value_item, state_value_item = @param_widgets[item.row]
+        if item.column == 1
+          if packet_item.states
+            value = packet_item.states[value_item.text]
+            if packet_item.hazardous && packet_item.hazardous.key?(value_item.text)
+              desc = packet_item.hazardous[value]
+              # Hazardous states aren't required to have a description so use the item description
+              desc = packet_item.description unless desc
+              @table.item(item.row, 4).setText("(Hazardous) #{desc}")
+            else
+              @table.item(item.row, 4).setText(packet_item.description)
+            end
+            @table.blockSignals(true)
+            if CmdParams.states_in_hex && value.kind_of?(Integer)
+              state_value_item.setText(sprintf("0x%X", value))
+            else
+              state_value_item.setText(value.to_s)
+            end
+            @table.blockSignals(false)
+          end
+        elsif item.column == 2
+          @table.blockSignals(true)
+          @table.item(item.row, 1).setText(MANUALLY)
+          @table.blockSignals(false)
+        end
+        calculate_height()
+        emit modified()
+      end
+      calculate_height()
+    end
+
+    def calculate_height
+      @table.resizeColumnsToContents()
+      @table.resizeRowsToContents()
+      height = @table.horizontalHeader.height + 2 # 2 = Header frame?
+      @table.rowCount.times do |i|
+        # TODO: rowHeight does not reflect word wrapping ... it's always 37
+        height += @table.rowHeight(i)
+        # NOTE: Checking the fontMetrics boundingRect also does not refect word wrapping
+        #   e.g. Cosmos.getFontMetrics(@table.font).boundingRect(@table.item(x,y).text).height
+      end
+      @table.setMaximumHeight(height)
+      @table.setMinimumHeight(height)
+    end
+  end
+end

data/lib/cosmos/tools/cmd_sender/cmd_sender.rb

@@ -10,16 +10,17 @@
 
 require 'cosmos'
 Cosmos.catch_fatal_exception do
-  require 'cosmos/script'
   require 'cosmos/gui/qt_tool'
-  require 'cosmos/config/config_parser'
   require 'cosmos/gui/text/completion'
   require 'cosmos/gui/utilities/script_module_gui'
   require 'cosmos/gui/dialogs/splash'
   require 'cosmos/gui/dialogs/cmd_details_dialog'
+  require 'cosmos/gui/widgets/full_text_search_line_edit'
   require 'cosmos/tools/cmd_sender/cmd_sender_text_edit'
+  require 'cosmos/tools/cmd_sender/cmd_params'
   require 'cosmos/tools/cmd_sender/cmd_param_table_item_delegate'
-  require 'cosmos/gui/widgets/full_text_search_line_edit'
+  require 'cosmos/config/config_parser'
+  require 'cosmos/script'
 end
 
 module Cosmos
@@ -27,7 +28,7 @@ module Cosmos
     module Script
       def prompt_for_script_abort
         window = get_cmd_tlm_gui_window()
-        window.statusBar.showMessage(tr("Hazardous command not sent"))
+        window.statusBar.showMessage("Hazardous command not sent")
         return true # Aborted - Don't retry
       end
     end
@@ -41,15 +42,6 @@ module Cosmos
   # command is sent it is added to the command history window which allows the
   # user to resend the command or copy it for use in a script.
   class CmdSender < QtTool
-    slots 'file_send_raw()'
-    slots 'update_cmd_params(bool)'
-    slots 'menu_states_in_hex(bool)'
-    slots 'target_changed(const QString&)'
-    slots 'cmd_changed(const QString&)'
-    slots 'send_button()'
-    slots 'context_menu(const QPoint&)'
-    slots 'click_callback(QTableWidgetItem*)'
-
     MANUALLY = CmdParamTableItemDelegate::MANUALLY
 
     # @return [Integer] Number of commands sent
@@ -62,20 +54,6 @@ module Cosmos
       @@send_count = val
     end
 
-    # @return [Array<PacketItem, Qt::TableWidgetItem, Qt::TableWidgetItem>]
-    #   Array of the packet item, the table widget item representing the value,
-    #   and the table widget item representing states if the packet item has
-    #   states.
-    def self.param_widgets
-      @@param_widgets
-    end
-
-    # @return [Qt::TableWidget] Table holding the command parameters. Each
-    #   parameter is a separate row in the table.
-    def self.table
-      @@table
-    end
-
     # Create the application by building the GUI and loading an initial target
     # and command packet. This can be passed on the command line or the first
     # target and packet will be loaded.
@@ -85,13 +63,11 @@ module Cosmos
       super(options)
       Cosmos.load_cosmos_icon("cmd_sender.png")
 
-      @file_dir = System.paths['LOGS']
       @message_log = MessageLog.new('cmdsender')
       @production = options.production
       @send_raw_dir = nil
       @@send_count = 0
-      @@param_widgets = []
-      @@table = nil
+      @cmd_params = CmdParams.new
 
       initialize_actions()
       initialize_menus()
@@ -137,59 +113,63 @@ module Cosmos
       super()
       # File menu actions
       @send_raw_action = Qt::Action.new(Cosmos.get_icon('send_file.png'),
-                                        tr('&Send Raw'),
+                                        '&Send Raw',
                                         self)
-      @send_raw_action.shortcut  = Qt::KeySequence.new(tr('Ctrl+S'))
+      @send_raw_action.shortcut  = Qt::KeySequence.new('Ctrl+S')
       tip = 'Send raw data from a file'
       if @production
         tip += ' - Disabled in Production Mode'
         @send_raw_action.setEnabled(false)
       end
-      @send_raw_action.statusTip = tr(tip)
-      connect(@send_raw_action, SIGNAL('triggered()'), self, SLOT('file_send_raw()'))
+      @send_raw_action.statusTip = tip
+      @send_raw_action.connect(SIGNAL('triggered()')) { file_send_raw }
 
       # Mode menu actions
-      @ignore_range = Qt::Action.new(tr('&Ignore Range Checks'), self)
+      @ignore_range = Qt::Action.new('&Ignore Range Checks', self)
       tip = 'Ignore range checks when processing command'
       if @production
         tip += ' - Disabled in Production Mode'
         @ignore_range.setEnabled(false)
       end
-      @ignore_range.statusTip = tr(tip)
+      @ignore_range.statusTip = tip
       @ignore_range.setCheckable(true)
       @ignore_range.setChecked(false)
 
-      @states_in_hex = Qt::Action.new(tr('&Display State Values in Hex'), self)
-      @states_in_hex.statusTip = tr('Display states values in hex instead of decimal')
+      @states_in_hex = Qt::Action.new('&Display State Values in Hex', self)
+      @states_in_hex.statusTip = 'Display states values in hex instead of decimal'
       @states_in_hex.setCheckable(true)
-      @states_in_hex.setChecked(false)
-      connect(@states_in_hex, SIGNAL('toggled(bool)'), self, SLOT('menu_states_in_hex(bool)'))
+      @states_in_hex.setChecked(CmdParams.states_in_hex)
+      @states_in_hex.connect(SIGNAL('toggled(bool)')) do |checked|
+        @cmd_params.states_in_hex(checked)
+      end
 
-      @show_ignored = Qt::Action.new(tr('&Show Ignored Parameters'), self)
-      @show_ignored.statusTip = tr('Show ignored parameters which are normally hidden')
+      @show_ignored = Qt::Action.new('&Show Ignored Parameters', self)
+      @show_ignored.statusTip = 'Show ignored parameters which are normally hidden'
       @show_ignored.setCheckable(true)
-      @show_ignored.setChecked(false)
-      connect(@show_ignored, SIGNAL('toggled(bool)'), self, SLOT('update_cmd_params(bool)'))
+      @show_ignored.setChecked(CmdParams.show_ignored)
+      @show_ignored.connect(SIGNAL('toggled(bool)')) do |checked|
+        update_cmd_params(checked)
+      end
 
-      @cmd_raw = Qt::Action.new(tr('Disable &Parameter Conversions'), self)
+      @cmd_raw = Qt::Action.new('Disable &Parameter Conversions', self)
       tip = 'Send the command without running write or state conversions'
       if @production
         tip += ' - Disabled in Production Mode'
         @cmd_raw.setEnabled(false)
       end
-      @cmd_raw.statusTip = tr(tip)
+      @cmd_raw.statusTip = tip
       @cmd_raw.setCheckable(true)
       @cmd_raw.setChecked(false)
     end
 
     # Create the File and Mode menus and initialize the help menu
     def initialize_menus
-      file_menu = menuBar.addMenu(tr('&File'))
+      file_menu = menuBar.addMenu('&File')
       file_menu.addAction(@send_raw_action)
       file_menu.addAction(@exit_action)
       file_menu.insertSeparator(@exit_action)
 
-      mode_menu = menuBar.addMenu(tr('&Mode'))
+      mode_menu = menuBar.addMenu('&Mode')
       mode_menu.addAction(@ignore_range)
       mode_menu.addAction(@states_in_hex)
       mode_menu.addAction(@show_ignored)
@@ -243,20 +223,23 @@ module Cosmos
       # Set the target combobox selection
       @target_select = Qt::ComboBox.new
       @target_select.setMaxVisibleItems(6)
-      connect(@target_select, SIGNAL('activated(const QString&)'), self, SLOT('target_changed(const QString&)'))
-      target_label = Qt::Label.new(tr("&Target:"))
+      @target_select.connect(SIGNAL('activated(const QString&)')) do |target|
+        update_commands()
+        update_cmd_params()
+      end
+      target_label = Qt::Label.new("&Target:")
       target_label.setBuddy(@target_select)
 
       # Set the comamnd combobox selection
       @cmd_select = Qt::ComboBox.new
       @cmd_select.setMaxVisibleItems(20)
-      connect(@cmd_select, SIGNAL('activated(const QString&)'), self, SLOT('cmd_changed(const QString&)'))
-      cmd_label = Qt::Label.new(tr("&Command:"))
+      @cmd_select.connect(SIGNAL('activated(const QString&)')) {|command| update_cmd_params }
+      cmd_label = Qt::Label.new("&Command:")
       cmd_label.setBuddy(@cmd_select)
 
       # Button to send command
       send = Qt::PushButton.new("Send")
-      connect(send, SIGNAL('clicked()'), self, SLOT('send_button()'))
+      send.connect(SIGNAL('clicked()')) { send_button }
 
       # Layout the top level selection
       select_layout = Qt::HBoxLayout.new
@@ -273,7 +256,7 @@ module Cosmos
       top_layout.addWidget(sep1)
 
       # Command Description Label
-      dec_label = Qt::Label.new(tr("Description:"))
+      dec_label = Qt::Label.new("Description:")
       @description = Qt::Label.new('')
       @description.setWordWrap(true)
       desc_layout = Qt::HBoxLayout.new
@@ -287,7 +270,7 @@ module Cosmos
       top_layout.addWidget(sep2)
 
       # Parameters Label
-      param_label = Qt::Label.new(tr("Parameters:"))
+      param_label = Qt::Label.new("Parameters:")
       top_layout.addWidget(param_label)
 
       # Grid Layout for Parameters
@@ -326,32 +309,6 @@ module Cosmos
       history
     end
 
-    # Changes the display of items with states to hex if checked is true.
-    # Otherwise state values are displayed as decimal.
-    # @param checked [Boolean] Whether to display state values in hex
-    def menu_states_in_hex(checked)
-      @@param_widgets.each do |_, _, state_value_item|
-        next unless state_value_item
-        text = state_value_item.text
-        quotes_removed = text.remove_quotes
-        if text == quotes_removed
-          if checked
-            if text.is_int?
-              @@table.blockSignals(true)
-              state_value_item.text = sprintf("0x%X", text.to_i)
-              @@table.blockSignals(false)
-            end
-          else
-            if text.is_hex?
-              @@table.blockSignals(true)
-              state_value_item.text = Integer(text).to_s
-              @@table.blockSignals(false)
-            end
-          end
-        end
-      end
-    end
-
     # Opens a dialog which allows the user to select a file to read and send
     # directly over the interface.
     def file_send_raw
@@ -362,13 +319,13 @@ module Cosmos
       interfaces.addItems(get_interface_names())
       interfaces.setMaxVisibleItems(30)
       layout.addWidget(interfaces, 0, 1)
-      int_label = Qt::Label.new(tr("&Interface:"))
+      int_label = Qt::Label.new("&Interface:")
       int_label.setBuddy(interfaces)
       layout.addWidget(int_label, 0, 0)
 
       file_line = Qt::LineEdit.new(@send_raw_dir)
       file_line.setMinimumSize(250, 0)
-      file_label = Qt::Label.new(tr("&Filename:"))
+      file_label = Qt::Label.new("&Filename:")
       file_label.setBuddy(file_line)
       get_file = Qt::PushButton.new("Select")
       file_layout = Qt::BoxLayout.new(Qt::Horizontal)
@@ -376,7 +333,7 @@ module Cosmos
       file_layout.addWidget(file_line)
       get_file.connect(SIGNAL('clicked()')) do
         Cosmos.set_working_dir do
-          file_line.text = Qt::FileDialog::getOpenFileName(self, "Select File", @send_raw_dir, tr("Binary Files (*.bin);;All Files (*)"))
+          file_line.text = Qt::FileDialog::getOpenFileName(self, "Select File", @send_raw_dir, "Binary Files (*.bin);;All Files (*)")
         end
       end
 
@@ -417,17 +374,6 @@ module Cosmos
       super(event)
     end
 
-    # Updates the commands combobox and command parameters table
-    def target_changed(_)
-      update_commands()
-      update_cmd_params()
-    end
-
-    # Updates the command parameters table
-    def cmd_changed(_)
-      update_cmd_params()
-    end
-
     # Sends the current command and parameters to the target
     def send_button
       target_name = @target_select.text
@@ -470,26 +416,8 @@ module Cosmos
 
     # @return [String, Hash] Command as it would appear in a ScriptRunner script
     def view_as_script
-      params = {}
-
-      @@param_widgets.each do |packet_item, value_item, state_value_item|
-        text = value_item.text
-
-        text = state_value_item.text if state_value_item && (text == MANUALLY or @cmd_raw.checked?)
-        quotes_removed = text.remove_quotes
-        if text == quotes_removed
-          if (packet_item.data_type == :STRING or packet_item.data_type == :BLOCK) and text.upcase.start_with?("0X")
-            params[packet_item.name] = text.hex_to_byte_string
-          else
-            params[packet_item.name] = text.convert_to_value
-          end
-        else
-          params[packet_item.name] = quotes_removed
-        end
-        raise "#{packet_item.name} is required." if quotes_removed == '' && packet_item.required
-      end
       statusBar.clearMessage()
-
+      params = @cmd_params.params_text(@cmd_raw.checked?)
       output_string = System.commands.build_cmd_output_string(@target_select.text, @cmd_select.text, params, @cmd_raw.checked?)
       if output_string =~ /[\x00-\x08\x0B-\x0C\x0E-\x1F\x7F-\xFF]/
         output_string = output_string.inspect.remove_quotes
@@ -552,243 +480,29 @@ module Cosmos
 
     # Updates the command parameters table based on the selected target and
     # packet comboboxes
-    # @param ignored_toggle [Boolean] Whether to display the ignored
-    #   parameters. Pass nil (the default) to keep the existing setting.
-    def update_cmd_params(ignored_toggle = nil)
-      old_params = {}
-      if !ignored_toggle.nil?
-        # Save parameter values
-        @@param_widgets.each do |packet_item, value_item, state_value_item|
-          text = value_item.text
-          if state_value_item
-            old_params[packet_item.name] = [text, state_value_item.text]
-          else
-            old_params[packet_item.name] = text
-          end
-        end
-      end
-
+    # @param checked [Boolean] Whether the show ignored parameters option
+    #   is checked. Pass nil (the default) to keep the existing setting.
+    def update_cmd_params(checked = nil)
       # Clear Status Bar
-      statusBar.showMessage(tr(""))
+      statusBar.showMessage("")
 
       target_name = @target_select.text
       target = System.targets[target_name]
       packet_name = @cmd_select.text
       if target_name && packet_name
         packet = System.commands.packet(target_name, packet_name)
-        packet_items = packet.sorted_items
-        shown_packet_items = []
-        packet_items.each do |packet_item|
-          next if target && target.ignored_parameters.include?(packet_item.name) && !@show_ignored.checked?
-          shown_packet_items << packet_item
-        end
-
-        # Update Command Description
-        @description.text = packet.description.to_s
-
-        # Destroy the old table widget
-        @@table.dispose if @@table
-        @@table = nil
-
-        # Update Parameters
-        @@param_widgets = []
-        drawn_header = false
-
-        row = 0
-        shown_packet_items.each do |packet_item|
-          next if target && target.ignored_parameters.include?(packet_item.name) && !@show_ignored.checked?
-          value_item = nil
-          state_value_item = nil
-
-          unless drawn_header
-            @@table = Qt::TableWidget.new()
-            @@table.setSizePolicy(Qt::SizePolicy::Expanding, Qt::SizePolicy::Expanding)
-            @@table.setWordWrap(true)
-            @@table.setRowCount(shown_packet_items.length)
-            @@table.setColumnCount(5)
-            @@table.setHorizontalHeaderLabels(['Name', '         Value or State         ', '         ', 'Units', 'Description'])
-            @@table.horizontalHeader.setStretchLastSection(true)
-            @@table.verticalHeader.setVisible(false)
-            @@table.setItemDelegate(CmdParamTableItemDelegate.new(@@table, @@param_widgets, @production))
-            @@table.setContextMenuPolicy(Qt::CustomContextMenu)
-            @@table.verticalHeader.setResizeMode(Qt::HeaderView::ResizeToContents)
-            @@table.setEditTriggers(Qt::AbstractItemView::DoubleClicked | Qt::AbstractItemView::SelectedClicked | Qt::AbstractItemView::AnyKeyPressed)
-            @@table.setSelectionMode(Qt::AbstractItemView::NoSelection)
-            connect(@@table, SIGNAL('customContextMenuRequested(const QPoint&)'), self, SLOT('context_menu(const QPoint&)'))
-            connect(@@table, SIGNAL('itemClicked(QTableWidgetItem*)'), self, SLOT('click_callback(QTableWidgetItem*)'))
-            drawn_header = true
-          end
-
-          # Parameter Name
-          item = Qt::TableWidgetItem.new("#{packet_item.name}:")
-          item.setTextAlignment(Qt::AlignRight | Qt::AlignVCenter)
-          item.setFlags(Qt::NoItemFlags | Qt::ItemIsSelectable | Qt::ItemIsEnabled)
-          @@table.setItem(row, 0, item)
-
-          if packet_item.states
-            default_state = packet_item.states.key(packet_item.default)
-            if old_params[packet_item.name]
-              value_item = Qt::TableWidgetItem.new(old_params[packet_item.name][0])
-            else
-              if default_state
-                value_item = Qt::TableWidgetItem.new(default_state.to_s)
-              elsif @production
-                value_item = Qt::TableWidgetItem.new(packet_item.states.keys[0])
-              else
-                value_item = Qt::TableWidgetItem.new(MANUALLY)
-              end
-            end
-            value_item.setTextAlignment(Qt::AlignRight | Qt::AlignVCenter)
-            value_item.setFlags(Qt::NoItemFlags | Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable)
-            @@table.setItem(row, 1, value_item)
-
-            if old_params[packet_item.name]
-              state_value_item = Qt::TableWidgetItem.new(old_params[packet_item.name][1])
-            else
-              if @states_in_hex.checked? && packet_item.default.kind_of?(Integer)
-                state_value_item = Qt::TableWidgetItem.new(sprintf("0x%X", packet_item.default))
-              else
-                default_str = packet_item.default.to_s
-                if default_str.is_printable?
-                  state_value_item = Qt::TableWidgetItem.new(default_str)
-                else
-                  state_value_item = Qt::TableWidgetItem.new("0x" + default_str.simple_formatted)
-                end
-              end
-            end
-            state_value_item.setTextAlignment(Qt::AlignRight | Qt::AlignVCenter)
-            if @production
-              state_value_item.setFlags(Qt::NoItemFlags)
-            else
-              state_value_item.setFlags(Qt::NoItemFlags | Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable)
-            end
-            @@table.setItem(row, 2, state_value_item)
-
-            # If the parameter is required clear the combobox and
-            # clear the value field so they have to choose something
-            if packet_item.required && !old_params[packet_item.name]
-              value_item.setText('')
-              state_value_item.setText('')
-            end
-          else
-            # Parameter Value
-            if old_params[packet_item.name]
-              value_item = Qt::TableWidgetItem.new(old_params[packet_item.name])
-            else
-              if packet_item.required
-                value_text = ''
-              else
-                if packet_item.format_string
-                  begin
-                    value_text = sprintf(packet_item.format_string, packet_item.default)
-                  rescue
-                    # Oh well - Don't use the format string
-                    value_text = packet_item.default.to_s
-                  end
-                else
-                  value_text = packet_item.default.to_s
-                end
-                if !value_text.is_printable?
-                  value_text = "0x" + value_text.simple_formatted
-                end
-              end
-              value_item = Qt::TableWidgetItem.new(value_text)
-            end
-            value_item.setTextAlignment(Qt::AlignRight | Qt::AlignVCenter)
-            value_item.setFlags(Qt::NoItemFlags | Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable)
-            @@table.setItem(row, 1, value_item)
-            @@table.setSpan(row, 1, 1, 2)
-          end
-
-          # Units
-          item = Qt::TableWidgetItem.new(packet_item.units.to_s)
-          item.setTextAlignment(Qt::AlignRight | Qt::AlignVCenter)
-          item.setFlags(Qt::NoItemFlags | Qt::ItemIsSelectable | Qt::ItemIsEnabled)
-          @@table.setItem(row, 3, item)
-
-          # Description
-          item = Qt::TableWidgetItem.new(packet_item.description.to_s)
-          item.setTextAlignment(Qt::AlignLeft | Qt::AlignVCenter)
-          item.setFlags(Qt::NoItemFlags | Qt::ItemIsSelectable | Qt::ItemIsEnabled)
-          @@table.setItem(row, 4, item)
-
-          @@param_widgets << [packet_item, value_item, state_value_item]
-          row += 1
-        end
-
-        if @@table
-          @@table.connect(SIGNAL('itemChanged(QTableWidgetItem*)')) do |item|
-            packet_item, value_item, state_value_item = @@param_widgets[item.row]
-            if item.column == 1
-              if packet_item.states
-                value = packet_item.states[value_item.text]
-                @@table.blockSignals(true)
-                if @states_in_hex.checked? && value.kind_of?(Integer)
-                  state_value_item.setText(sprintf("0x%X", value))
-                else
-                  state_value_item.setText(value.to_s)
-                end
-                @@table.blockSignals(false)
-              end
-            elsif item.column == 2
-              @@table.blockSignals(true)
-              @@table.item(item.row, 1).setText(MANUALLY)
-              @@table.blockSignals(false)
-            end
-          end
-          @table_layout.addWidget(@@table, 500)
-          @@table.resizeColumnsToContents()
-          @@table.resizeRowsToContents()
-        end
-      end # if target_name && packet_name
-    end
-
-    # If the user right clicks over a table item, this method displays a context
-    # menu with various options.
-    # @param point [Qt::Point] Point to display the context menu
-    def context_menu(point)
-      target_name = @target_select.text
-      packet_name = @cmd_select.text
-      item = @@table.itemAt(point)
-      if item
-        item_name = @@table.item(item.row, 0).text[0..-2] # Remove :
-        if target_name.length > 0 && packet_name.length > 0 && item_name.length > 0
-          menu = Qt::Menu.new()
-
-          details_action = Qt::Action.new(tr("Details #{target_name} #{packet_name} #{item_name}"), self)
-          details_action.statusTip = tr("Popup details about #{target_name} #{packet_name} #{item_name}")
-          details_action.connect(SIGNAL('triggered()')) do
-            CmdDetailsDialog.new(nil, target_name, packet_name, item_name)
-          end
-          menu.addAction(details_action)
-
-          file_chooser_action = Qt::Action.new(tr("Insert Filename"), self)
-          file_chooser_action.statusTip = tr("Select a file and place its name into this parameter")
-          file_chooser_action.connect(SIGNAL('triggered()')) do
-            filename = Qt::FileDialog::getOpenFileName(self, "Insert Filename:", @file_dir, "All Files (*)")
-            if filename && !filename.empty?
-              @file_dir = File.dirname(filename)
-              _, value_item, state_value_item = @@param_widgets[item.row]
-              if state_value_item
-                state_value_item.setText(filename)
-              elsif value_item
-                value_item.setText(filename)
-              end
-            end
-          end
-          menu.addAction(file_chooser_action)
-
-          menu.exec(@@table.mapToGlobal(point))
-          menu.dispose
+        # Directly update packet description ... safe because always in GUI thread
+        hazardous, _ = System.commands.cmd_hazardous?(target_name, packet_name)
+        if hazardous
+          @description.text = "(Hazardous) #{packet.description}"
+        else
+          @description.text = packet.description
         end
+        table = @cmd_params.update_cmd_params(packet, show_ignored: checked)
+        @table_layout.addWidget(table, 500) if table
       end
     end
 
-    # @param item [Qt::TableWidgetItem] Item which was left clicked
-    def click_callback(item)
-      @@table.editItem(item) if (item.flags & Qt::ItemIsEditable) != 0
-    end
-
     # (see QtTool.run)
     def self.run(option_parser = nil, options = nil)
       Cosmos.catch_fatal_exception do