cosmos 4.2.4 → 4.5.0

data/lib/cosmos/tools/cmd_sequence/cmd_sequence.rb

@@ -11,14 +11,15 @@
 require 'time'
 require 'cosmos'
 Cosmos.catch_fatal_exception do
-  require 'cosmos/script'
-  require 'cosmos/config/config_parser'
   require 'cosmos/gui/qt_tool'
   require 'cosmos/gui/utilities/script_module_gui'
   require 'cosmos/gui/dialogs/splash'
   require 'cosmos/gui/widgets/realtime_button_bar'
   require 'cosmos/gui/choosers/file_chooser'
+  require 'cosmos/config/config_parser'
   require 'cosmos/tools/cmd_sequence/sequence_list'
+  require 'cosmos/gui/widgets/full_text_search_line_edit'
+  require 'cosmos/script'
 end
 
 module Cosmos
@@ -85,6 +86,20 @@ module Cosmos
           @target_select.setCurrentText(options.packet[0]) if options.packet
           update_commands()
           @cmd_select.setCurrentText(options.packet[1]) if options.packet
+
+          # Handle searching entries
+          @search_box.completion_list = System.commands.all_packet_strings(true, splash)
+          @search_box.callback = lambda do |cmd|
+            split_cmd = cmd.split(" ")
+            if split_cmd.length == 2
+              target_name = split_cmd[0].upcase
+              @target_select.setCurrentText(target_name)
+              update_commands()
+              command_name = split_cmd[1]
+              @cmd_select.setCurrentText(command_name)
+              add_command()
+            end
+          end
         end
         # Unconfigure CosmosConfig to interact with splash screen
         ConfigParser.splash = nil
@@ -96,59 +111,63 @@ module Cosmos
     def initialize_actions
       super()
 
-      @file_new = Qt::Action.new(Cosmos.get_icon('file.png'), tr('&New'), self)
-      @file_new_keyseq = Qt::KeySequence.new(tr('Ctrl+N'))
+      @file_new = Qt::Action.new(Cosmos.get_icon('file.png'), '&New', self)
+      @file_new_keyseq = Qt::KeySequence.new('Ctrl+N')
       @file_new.shortcut  = @file_new_keyseq
-      @file_new.statusTip = tr('Start a new sequence')
+      @file_new.statusTip = 'Start a new sequence'
       @file_new.connect(SIGNAL('triggered()')) { file_new() }
 
-      @file_save = Qt::Action.new(Cosmos.get_icon('save.png'), tr('&Save'), self)
-      @file_save_keyseq = Qt::KeySequence.new(tr('Ctrl+S'))
+      @file_save = Qt::Action.new(Cosmos.get_icon('save.png'), '&Save', self)
+      @file_save_keyseq = Qt::KeySequence.new('Ctrl+S')
       @file_save.shortcut  = @file_save_keyseq
-      @file_save.statusTip = tr('Save the sequence')
+      @file_save.statusTip = 'Save the sequence'
       @file_save.connect(SIGNAL('triggered()')) { file_save(false) }
 
-      @file_save_as = Qt::Action.new(Cosmos.get_icon('save_as.png'), tr('Save &As'), self)
-      @file_save_as.statusTip = tr('Save the sequence')
+      @file_save_as = Qt::Action.new(Cosmos.get_icon('save_as.png'), 'Save &As', self)
+      @file_save_as.statusTip = 'Save the sequence'
       @file_save_as.connect(SIGNAL('triggered()')) { file_save(true) }
 
-      @file_export = Qt::Action.new(tr('&Export Sequence'), self)
-      @file_export.shortcut = Qt::KeySequence.new(tr('Ctrl+E'))
-      @file_export.statusTip = tr('Export the current sequence to a custom binary format')
+      @file_export = Qt::Action.new('&Export Sequence', self)
+      @file_export.shortcut = Qt::KeySequence.new('Ctrl+E')
+      @file_export.statusTip = 'Export the current sequence to a custom binary format'
       @file_export.connect(SIGNAL('triggered()')) { file_export() }
 
-      @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)
-      @show_ignored.connect(SIGNAL('toggled(bool)')) do |bool|
-        @sequence_list.map {|item| item.show_ignored(bool) }
+      @show_ignored.setChecked(CmdParams.show_ignored)
+      @show_ignored.connect(SIGNAL('toggled(bool)')) do |checked|
+        # In case there aren't any sequences open, make sure to store the current value
+        CmdParams.show_ignored = checked
+        @sequence_list.map {|item| item.show_ignored(checked) }
       end
 
-      @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)
-      @states_in_hex.connect(SIGNAL('toggled(bool)')) do |bool|
-        @sequence_list.map {|item| item.states_in_hex(bool) }
+      @states_in_hex.setChecked(CmdParams.states_in_hex)
+      @states_in_hex.connect(SIGNAL('toggled(bool)')) do |checked|
+        # In case there aren't any sequences open, make sure to store the current value
+        CmdParams.states_in_hex = checked
+        @sequence_list.map {|item| item.states_in_hex(checked) }
       end
 
-      @expand_action = Qt::Action.new(tr('&Expand All'), self)
-      @expand_action.statusTip = tr('Expand all currently visible commands')
+      @expand_action = Qt::Action.new('&Expand All', self)
+      @expand_action.statusTip = 'Expand all currently visible commands'
       @expand_action.connect(SIGNAL('triggered()')) do
         @sequence_list.map {|item| item.expand }
       end
 
-      @collapse_action = Qt::Action.new(tr('&Collapse All'), self)
-      @collapse_action.statusTip = tr('Collapse all currently visible commands')
+      @collapse_action = Qt::Action.new('&Collapse All', self)
+      @collapse_action.statusTip = 'Collapse all currently visible commands'
       @collapse_action.connect(SIGNAL('triggered()')) do
         @sequence_list.map {|item| item.collapse }
       end
 
-      @script_disconnect = Qt::Action.new(Cosmos.get_icon('disconnected.png'), tr('&Toggle Disconnect'), self)
-      @script_disconnect_keyseq = Qt::KeySequence.new(tr('Ctrl+T'))
+      @script_disconnect = Qt::Action.new(Cosmos.get_icon('disconnected.png'), '&Toggle Disconnect', self)
+      @script_disconnect_keyseq = Qt::KeySequence.new('Ctrl+T')
       @script_disconnect.shortcut  = @script_disconnect_keyseq
-      @script_disconnect.statusTip = tr('Toggle disconnect from the server')
+      @script_disconnect.statusTip = 'Toggle disconnect from the server'
       @script_disconnect.connect(SIGNAL('triggered()')) do
         @server_config_file ||= CmdTlmServer::DEFAULT_CONFIG_FILE
         @server_config_file = toggle_disconnect(@server_config_file)
@@ -157,15 +176,15 @@ module Cosmos
 
     # Create the application menus and assign the actions
     def initialize_menus
-      file_menu = menuBar.addMenu(tr('&File'))
+      file_menu = menuBar.addMenu('&File')
       file_menu.addAction(@file_new)
 
       open_action = Qt::Action.new(self)
-      open_action.shortcut = Qt::KeySequence.new(tr('Ctrl+O'))
+      open_action.shortcut = Qt::KeySequence.new('Ctrl+O')
       open_action.connect(SIGNAL('triggered()')) { file_open(@sequence_dir) }
       self.addAction(open_action)
 
-      file_open = file_menu.addMenu(tr('&Open'))
+      file_open = file_menu.addMenu('&Open')
       file_open.setIcon(Cosmos.get_icon('open.png'))
       target_dirs_action(file_open, System.paths['SEQUENCES'], 'sequences', method(:file_open))
 
@@ -178,7 +197,7 @@ module Cosmos
       file_menu.addSeparator()
       file_menu.addAction(@exit_action)
 
-      action_menu = menuBar.addMenu(tr('&Actions'))
+      action_menu = menuBar.addMenu('&Actions')
       action_menu.addAction(@show_ignored)
       action_menu.addAction(@states_in_hex)
       action_menu.addSeparator()
@@ -205,27 +224,23 @@ module Cosmos
       @realtime_button_bar.state = 'Stopped'
       central_layout.addWidget(@realtime_button_bar)
 
+      # Mnemonic Search Box
+      @search_box = FullTextSearchLineEdit.new(self)
+      central_layout.addWidget(@search_box)
+
       @target_select = Qt::ComboBox.new
       @target_select.setMaxVisibleItems(6)
-      @target_select.connect(SIGNAL('activated(const QString&)')) do |target|
-        target_changed()
-      end
-      target_label = Qt::Label.new(tr("&Target:"))
+      @target_select.connect(SIGNAL('activated(const QString&)')) {|target| target_changed() }
+      target_label = Qt::Label.new("&Target:")
       target_label.setBuddy(@target_select)
 
       @cmd_select = Qt::ComboBox.new
       @cmd_select.setMaxVisibleItems(20)
-      cmd_label = Qt::Label.new(tr("&Command:"))
+      cmd_label = Qt::Label.new("&Command:")
       cmd_label.setBuddy(@cmd_select)
 
       add = Qt::PushButton.new("Add")
-      add.connect(SIGNAL('clicked()')) do
-        command = System.commands.packet(@target_select.text, @cmd_select.text).dup
-        command.restore_defaults
-        item = @sequence_list.add(command)
-        item.show_ignored(@show_ignored.isChecked())
-        item.states_in_hex(@states_in_hex.isChecked())
-      end
+      add.connect(SIGNAL('clicked()')) { add_command() }
 
       # Layout the target and command selection with Add button
       select_layout = Qt::HBoxLayout.new
@@ -240,7 +255,7 @@ module Cosmos
       splitter = Qt::Splitter.new(Qt::Vertical, self)
       central_layout.addWidget(splitter)
 
-      @sequence_list = SequenceList.new
+      @sequence_list = SequenceList.new(self)
       @sequence_list.connect(SIGNAL("modified()")) { update_title }
 
       @scroll = Qt::ScrollArea.new()
@@ -264,10 +279,18 @@ module Cosmos
       splitter.setStretchFactor(1,0)
     end
 
+    def add_command
+      item = @sequence_list.add(@target_select.text.strip, @cmd_select.text.strip)
+    end
+
     # Export the sequence list into a custom binary format
     def file_export
       return if @sequence_list.empty? || @exporter.nil?
-      @exporter.export(@filename, @sequence_dir, @sequence_list)
+      begin
+        @exporter.export(@filename, @sequence_dir, @sequence_list)
+      rescue => error
+        ExceptionDialog.new(self, error, 'Export Error', false)
+      end
     end
 
     # Clears the sequence list
@@ -275,6 +298,7 @@ module Cosmos
       return unless prompt_for_save_if_needed()
       @sequence_list.clear
       @filename = "Untitled"
+      update_title()
     end
 
     # Opens a sequence list file and populates the GUI
@@ -289,8 +313,6 @@ module Cosmos
       if !filename.nil? && File.exist?(filename) && !File.directory?(filename)
         # Try to open and load the file. Errors are handled here.
         @sequence_list.open(filename)
-        @sequence_list.map {|item| item.show_ignored(@show_ignored.isChecked()) }
-        @sequence_list.map {|item| item.states_in_hex(@states_in_hex.isChecked()) }
         @filename = filename
         @sequence_dir = File.dirname(filename)
         @sequence_dir << '/' if @sequence_dir[-1..-1] != '/' and @sequence_dir[-1..-1] != '\\'
@@ -341,7 +363,7 @@ module Cosmos
     #   process when creating the disconnected server
     def toggle_disconnect(config_file, ask_for_config_file = true)
       dialog = Qt::Dialog.new(self, Qt::WindowTitleHint | Qt::WindowSystemMenuHint)
-      dialog.setWindowTitle(tr("Disconnect Settings"))
+      dialog.setWindowTitle("Disconnect Settings")
       dialog_layout = Qt::VBoxLayout.new
       dialog_layout.addWidget(Qt::Label.new("Targets checked will be disconnected."))
 
@@ -431,7 +453,7 @@ module Cosmos
           Splash.execute(self) do |splash|
             ConfigParser.splash = splash
             splash.message = "Initializing Command and Telemetry Server"
-            set_disconnected_targets(targets, config_file)
+            set_disconnected_targets(targets, targets.length == all_targets.length, config_file)
             ConfigParser.splash = nil
           end
         end

data/lib/cosmos/tools/cmd_sequence/sequence_item.rb

@@ -14,7 +14,7 @@ Cosmos.catch_fatal_exception do
   require 'cosmos/script'
   require 'cosmos/gui/dialogs/calendar_dialog'
   require 'cosmos/gui/dialogs/cmd_details_dialog'
-  require 'cosmos/tools/cmd_sender/cmd_param_table_item_delegate'
+  require 'cosmos/tools/cmd_sender/cmd_params'
 end
 
 module Cosmos
@@ -26,36 +26,18 @@ module Cosmos
     signals 'modified()'
     MANUALLY = "MANUALLY ENTERED"
 
-    # Parse a time and command string into a SequenceItem which is returned
-    # @param time [String] Time (absolute or relative delay). Supports a single
-    #   float value (relative delay) or a absolute time specified as
-    #   "YYYY/MM/DD HH:MM:SS.MS"
-    # @param command [String] Command String which should not be
-    #   quoted and is everything inside the quotes of a command.
-    #   For example: TGT PKT with STRING 'HI', VALUE 12. Parse errors are
-    #   raised as execptions which must be handled by higher level code.
-    # @return [SequenceItem] SequenceItem which the line represents
-    def self.parse(time, command)
-      tgt_name, pkt_name, cmd_params = extract_fields_from_cmd_text(command)
-      packet = System.commands.packet(tgt_name, pkt_name).dup
-      packet.restore_defaults
-      cmd_params.each do |param_name, param_value|
-        packet.write(param_name, param_value)
-      end
-      SequenceItem.new(packet, time)
-    end
-
     # Create a new SequenceItem based on the given command with the given delay
-    # @param command [Packet] Command packet
     # @param time [String] Absolute time in YYYY/MM/DD HH:MM:SS format or a
     #   single float value representing the delta delay time
-    def initialize(command, time = nil)
+    def initialize(parent, target_name, packet_name, params = nil, time = nil)
       super()
-      @command = command
-      @table = nil
-      @param_widgets = []
-      @show_ignored = false
-      @states_in_hex = false
+      @cmd_params = CmdParams.new
+      # Propagate the modified signal up
+      @cmd_params.connect(SIGNAL('modified()')) do
+        set_cmd_name_info()
+        emit modified
+      end
+      @command = System.commands.packet(target_name, packet_name)
       @expanded = false
       @file_dir = System.paths['LOGS']
 
@@ -66,50 +48,30 @@ module Cosmos
       top_layout = Qt::VBoxLayout.new
       top_layout.setContentsMargins(2, 0, 0, 0)
       setLayout(top_layout)
-      top_layout.addLayout(create_cmd_layout(command, time))
+      top_layout.addLayout(create_cmd_layout(target_name, packet_name, time))
       top_layout.addWidget(create_parameters())
-      update_cmd_params()
+      add_table(@cmd_params.update_cmd_params(@command, existing: params))
       set_cmd_name_info()
     end
 
-    # Set or clear read only status on the item
-    # @param bool [Boolean] Whether to make the item read only
-    def read_only(bool)
-      @time.setReadOnly(bool)
+    def add_table(table)
+      return unless table
+      @table_layout.addWidget(table) 
     end
-
-    # Show or hide ignored parameters
-    # @param bool [Boolean] Whether to show ignored command items
-    def show_ignored(bool)
-      @show_ignored = bool
-      update_cmd_params(bool)
+      
+    def states_in_hex(checked)
+      @cmd_params.states_in_hex(checked)
     end
 
-    # Display state values in hex (or decimal)
-    # @param bool [Boolean] Whether to display state values in hex
-    def states_in_hex(bool)
-      @states_in_hex = bool
-      @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 bool
-            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
+    def show_ignored(checked)
+      add_table(@cmd_params.update_cmd_params(@command, show_ignored: checked))
+      set_cmd_name_info()
+    end
 
+    # Set or clear read only status on the item
+    # @param bool [Boolean] Whether to make the item read only
+    def read_only(bool)
+      @time.setReadOnly(bool)
     end
 
     # Show the command parameters part of the GUI
@@ -124,33 +86,9 @@ module Cosmos
       @parameters.hide
     end
 
-    # @return [Hash] All the parameter item values keyed by their name
-    def command_params
-      params = {}
-      @param_widgets.each do |packet_item, value_item, state_value_item|
-        text = ''
-        Qt.execute_in_main_thread do
-          text = value_item.text
-          text = state_value_item.text if state_value_item && (text == MANUALLY)
-        end
-        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
-      params
-    end
-
     # @return [String] Command to be executed with no quotes or other decorations
     def command_string
-      output_string =  System.commands.build_cmd_output_string(@command.target_name, @command.packet_name, command_params(), false)
+      output_string =  System.commands.build_cmd_output_string(@command.target_name, @command.packet_name, @cmd_params.params_text, false)
       if output_string =~ /[\x00-\x08\x0B-\x0C\x0E-\x1F\x7F-\xFF]/
         output_string = output_string.inspect.remove_quotes
       end
@@ -165,7 +103,7 @@ module Cosmos
     end
 
     def command
-      System.commands.build_cmd(@command.target_name, @command.packet_name, command_params(), false)
+      System.commands.build_cmd(@command.target_name, @command.packet_name, @cmd_params.params_text, false)
     end
 
     # @return [String] Time and command string
@@ -193,12 +131,12 @@ module Cosmos
     # and the delete button to remove the sequence item.
     # @param command [Packet] Command packet
     # @param time [String] Execution delay in absolute or relative time
-    def create_cmd_layout(command, time)
+    def create_cmd_layout(target_name, packet_name, time)
       cmd_layout = Qt::HBoxLayout.new
       cmd_layout.setContentsMargins(0, 0, 0, 0)
       cmd_layout.addWidget(create_time_edit(time))
 
-      @cmd_name = Qt::Label.new("#{command.target_name} #{command.packet_name}")
+      @cmd_name = Qt::Label.new("#{target_name} #{packet_name}")
       cmd_layout.addWidget(@cmd_name)
       @cmd_info = Qt::Label.new("") # Label for the hazardous designation
       cmd_layout.addWidget(@cmd_info)
@@ -246,7 +184,7 @@ module Cosmos
       @parameters = Qt::Widget.new
       parameters_layout = Qt::VBoxLayout.new
       # Command Description Label
-      dec_label = Qt::Label.new(tr("Description:"))
+      dec_label = Qt::Label.new("Description:")
       description = Qt::Label.new(@command.description)
       description.setWordWrap(true)
       desc_layout = Qt::HBoxLayout.new
@@ -254,7 +192,7 @@ module Cosmos
       desc_layout.addWidget(description, 1)
       parameters_layout.addLayout(desc_layout)
 
-      param_label = Qt::Label.new(tr("Parameters:"))
+      param_label = Qt::Label.new("Parameters:")
       parameters_layout.addWidget(param_label)
       @table_layout = Qt::VBoxLayout.new
       parameters_layout.addLayout(@table_layout, 500)
@@ -263,252 +201,21 @@ module Cosmos
       @parameters
     end
 
-    # Update the command parameters table for the given command
-    # @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
-
-      target = System.targets[@command.target_name]
-      packet_items = @command.sorted_items
-      shown_packet_items = []
-      packet_items.each do |packet_item|
-        if target && target.ignored_parameters.include?(packet_item.name) && !@show_ignored
-          if @param_widgets.empty? # First time rendering the parameters
-            if packet_item.states
-              # Skip this if the default matches the saved value
-              next if @command.read_item(packet_item, :RAW) == packet_item.default
-            else
-              # Skip this if the default matches the saved value
-              next if @command.read_item(packet_item) == packet_item.default
-            end
-          else # Check the current values
-            result = @param_widgets.select {|item,_,_| item == packet_item }
-            next if result.empty?
-            _, value_item, state_value_item = result[0]
-            value = state_value_item ? state_value_item.text : value_item.text
-            # Skip this if the default matches the current value
-            next if packet_item.default.to_s == value
-          end
-        end
-        shown_packet_items << packet_item
-      end
-
-      @table.dispose if @table
-      @table = nil
-
-      # Update Parameters
-      @param_widgets = []
-      drawn_header = false
-
-      row = 0
-      shown_packet_items.each do |packet_item|
-        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.verticalHeader.setVisible(false)
-          @table.setItemDelegate(CmdParamTableItemDelegate.new(@table, @param_widgets))
-          @table.setEditTriggers(Qt::AbstractItemView::DoubleClicked | Qt::AbstractItemView::SelectedClicked | Qt::AbstractItemView::AnyKeyPressed)
-          @table.setSelectionMode(Qt::AbstractItemView::NoSelection)
-          @table.setContextMenuPolicy(Qt::CustomContextMenu)
-          @table.connect(SIGNAL('customContextMenuRequested(const QPoint&)')) do |point|
-            context_menu(point)
-          end
-          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 = @command.read_item(packet_item, :RAW)
-          default_state = packet_item.states.key(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)
-            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 && packet_item.default.kind_of?(Integer)
-              state_value_item = Qt::TableWidgetItem.new(sprintf("0x%X", default))
-            else
-              default_str = 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)
-          state_value_item.setFlags(Qt::NoItemFlags | Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable)
-          @table.setItem(row, 2, state_value_item)
-        else # Parameter Value
-          if old_params[packet_item.name]
-            value_item = Qt::TableWidgetItem.new(old_params[packet_item.name])
-          else
-            default = @command.read_item(packet_item)
-            if packet_item.format_string
-              begin
-                value_text = sprintf(packet_item.format_string, default)
-              rescue
-                # Oh well - Don't use the format string
-                value_text = default.to_s
-              end
-            else
-              value_text = default.to_s
-            end
-            if !value_text.is_printable?
-              value_text = "0x" + value_text.simple_formatted
-            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
-        connect_table_item_changed()
-        @table.setSizePolicy(Qt::SizePolicy.Minimum, Qt::SizePolicy.Minimum)
-        @table.setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff)
-        @table.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff)
-        @table.resizeColumnsToContents()
-        @table.resizeRowsToContents()
-        @table.setFixedSize(@table.horizontalHeader.length + @table.verticalHeader.width,
-                            2 + @table.verticalHeader.length + @table.horizontalHeader.height)
-        @table_layout.addWidget(@table)
-      end
-    end
-
     # Sets the @cmd_name label to the command that will be sent. Also udpates
     # the @cmd_info with whether this command is hazardous or not.
     def set_cmd_name_info
-      @cmd_name.text = command_string
-      hazardous, _ = System.commands.cmd_hazardous?(@command.target_name, @command.packet_name, command_params())
-      if hazardous
-        @cmd_info.text = "(Hazarous)"
-      else
-        @cmd_info.text = ""
+      Qt.execute_in_main_thread do
+        @cmd_name.text = command_string
+        hazardous, _ = System.commands.cmd_hazardous?(@command.target_name, @command.packet_name, @cmd_params.params_text)
+        if hazardous
+          @cmd_info.text = "(Hazardous)"
+        else
+          @cmd_info.text = ""
+        end
       end
     rescue => error
       @cmd_info.text = "(Error)"
-      Qt::MessageBox.warning(self, 'Error', error.message)
-    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 = @command.target_name
-      packet_name = @command.packet_name
-      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
-        end
-      end # if item
-    end
-
-    # Connect the itemChanged signal to the table so we can handle user edits
-    # of the table parameters. This method emits the modified signal.
-    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]
-            @table.blockSignals(true)
-            if @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
-        set_cmd_name_info()
-        emit modified # Tell the higher level that something changed
-      end
+      Qt::MessageBox.warning(self, 'Error', "Error parsing #{@command.target_name} #{@command.packet_name} due to #{error.message}")
     end
   end
 end