cosmos 4.4.0-java → 4.4.1-java

data/lib/cosmos/packets/structure.rb

@@ -303,6 +303,23 @@ module Cosmos
       end
     end
 
+    # @param name [String] Name of the item to delete in the items Hash
+    def delete_item(name)
+      item = @items[name.upcase]
+      raise ArgumentError, "Unknown item: #{name}" unless item
+
+      # Find the item to delete in the sorted_items array
+      item_index = nil
+      @sorted_items.each_with_index do |sorted_item, index|
+        if sorted_item.name == item.name
+          item_index = index
+          break
+        end
+      end
+      @sorted_items.delete_at(item_index)
+      @items.delete(name.upcase)
+    end
+
     # Write a value to the buffer based on the item definition
     #
     # @param item [StructureItem] Instance of StructureItem or one of its subclasses

data/lib/cosmos/packets/structure_item.rb

@@ -11,7 +11,6 @@
 require 'cosmos/ext/packet' if RUBY_ENGINE == 'ruby' and !ENV['COSMOS_NO_EXT']
 
 module Cosmos
-
   # Maintains knowledge of an item in a Structure. Multiple StructureItems
   # compose a Structure.
   class StructureItem
@@ -59,6 +58,9 @@ module Cosmos
     # @return [Symbol] {BinaryAccessor::OVERFLOW_TYPES}
     attr_reader :overflow
 
+    # @return [Boolean] Whether this structure item can overlap another item in the same packet
+    attr_accessor :overlap
+
     # A large buffer size in bits (1 Megabyte)
     LARGE_BUFFER_SIZE_BITS = 1024 * 1024 * 8
 
@@ -73,6 +75,7 @@ module Cosmos
     # @param endianness [Symbol] {BinaryAccessor::ENDIANNESS}
     # @param array_size [Integer, nil] Size of the array item in bits. For
     #   example, if the bit_size is 8, an array_size of 16 holds two values.
+    # @param overflow [Symbol] {BinaryAccessor::OVERFLOW_TYPES}
     def initialize(name, bit_offset, bit_size, data_type, endianness, array_size = nil, overflow = :ERROR)
       @structure_item_constructed = false
       # Assignment order matters due to verifications!
@@ -83,6 +86,7 @@ module Cosmos
       self.bit_size = bit_size
       self.array_size = array_size
       self.overflow = overflow
+      self.overlap = false
       @create_index = @@create_index
       @@create_index += 1
       @structure_item_constructed = true

data/lib/cosmos/packets/telemetry.rb

@@ -437,7 +437,13 @@ module Cosmos
           splash.progress = index / total
         end
 
-        ignored_items = System.targets[target_name].ignored_items
+        # Note: System only has declared target structures but telemetry may have more
+        system_target = System.targets[target_name]
+        if system_target
+          ignored_items = system_target.ignored_items
+        else
+          ignored_items = []
+        end
 
         packets(target_name).each do |packet_name, packet|
           # We don't audit against hidden or disabled packets

data/lib/cosmos/system/system.rb

@@ -20,6 +20,7 @@ require 'drb/acl'
 require 'zip'
 require 'zip/filesystem'
 require 'bundler'
+require 'thread'
 
 module Cosmos
   # System is the primary entry point into the COSMOS framework. It captures
@@ -77,9 +78,9 @@ module Cosmos
     instance_attr_reader :hashing_algorithm
 
     # Known COSMOS ports
-    KNOWN_PORTS = ['CTS_API', 'TLMVIEWER_API', 'CTS_PREIDENTIFIED', 'CTS_CMD_ROUTER', 'REPLAY_API', 'REPLAY_PREIDENTIFIED', 'REPLAY_CMD_ROUTER', 'DART_STREAM', 'DART_DECOM']
+    KNOWN_PORTS = ['CTS_API', 'TLMVIEWER_API', 'CTS_PREIDENTIFIED', 'CTS_CMD_ROUTER', 'REPLAY_API', 'REPLAY_PREIDENTIFIED', 'REPLAY_CMD_ROUTER', 'DART_STREAM', 'DART_DECOM', 'DART_MASTER']
     # Known COSMOS hosts
-    KNOWN_HOSTS = ['CTS_API', 'TLMVIEWER_API', 'CTS_PREIDENTIFIED', 'CTS_CMD_ROUTER', 'REPLAY_API', 'REPLAY_PREIDENTIFIED', 'REPLAY_CMD_ROUTER', 'DART_STREAM', 'DART_DECOM']
+    KNOWN_HOSTS = ['CTS_API', 'TLMVIEWER_API', 'CTS_PREIDENTIFIED', 'CTS_CMD_ROUTER', 'REPLAY_API', 'REPLAY_PREIDENTIFIED', 'REPLAY_CMD_ROUTER', 'DART_STREAM', 'DART_DECOM', 'DART_MASTER']
     # Known COSMOS paths
     KNOWN_PATHS = ['LOGS', 'TMP', 'SAVED_CONFIG', 'TABLES', 'HANDBOOKS', 'PROCEDURES', 'SEQUENCES', 'DART_DATA', 'DART_LOGS']
     # Supported hashing algorithms
@@ -195,6 +196,7 @@ module Cosmos
       @targets = {}
       # Set config to nil so things will lazy load later
       @config = nil
+      @meta_init_filename = nil
       @use_utc = false
       acl_list = []
       all_allowed = false
@@ -207,7 +209,7 @@ module Cosmos
         # First pass - Everything except targets
         parser.parse_file(filename) do |keyword, parameters|
           case keyword
-          when 'AUTO_DECLARE_TARGETS', 'DECLARE_TARGET', 'DECLARE_GEM_TARGET'
+          when 'AUTO_DECLARE_TARGETS', 'DECLARE_TARGET', 'DECLARE_GEM_TARGET', 'DECLARE_GEM_MULTI_TARGET'
             # Will be handled by second pass
 
           when 'PORT'
@@ -458,6 +460,19 @@ module Cosmos
           target = Target.new(target_name, substitute_name, configuration_directory, ConfigParser.handle_nil(parameters[2]), gem_dir)
           @targets[target.name] = target
 
+        when 'DECLARE_GEM_MULTI_TARGET'
+          usage = "#{keyword} <GEM NAME> <TARGET NAME> <SUBSTITUTE TARGET NAME (Optional)> <TARGET FILENAME (Optional - defaults to target.txt)>"
+          parser.verify_num_parameters(2, 4, usage)
+
+          target_name = parameters[1].to_s.upcase
+          substitute_name = nil
+          substitute_name = ConfigParser.handle_nil(parameters[2])
+          substitute_name.to_s.upcase if substitute_name
+          gem_dir = Gem::Specification.find_by_name(parameters[0]).gem_dir
+          gem_dir = File.join(gem_dir, target_name)
+          target = Target.new(target_name, substitute_name, configuration_directory, ConfigParser.handle_nil(parameters[3]), gem_dir)
+          @targets[target.name] = target
+
         end # case keyword
       end # parser.parse_file
 
@@ -476,48 +491,65 @@ module Cosmos
     #   configuration. Pass nil to load the default configuration.
     # @return [String, Exception/nil] The actual configuration loaded
     def load_configuration(name = nil)
-      unless @config
-        # Ensure packets have been lazy loaded
-        System.commands
-      end
+      # Ensure packets have been lazy loaded
+      load_packets() unless @config
 
-      if name && @config
-        # Make sure they're requesting something other than the current
-        # configuration.
-        if name != @config.name
-          # If they want the initial configuration we can just swap out the
-          # current configuration without doing any file processing
-          if name == @initial_config.name
-            update_config(@initial_config)
-          else
-            # Look for the requested configuration in the saved configurations
-            configuration = find_configuration(name)
-            if configuration
-              # We found the configuration requested. Reprocess the system.txt
-              # and reload the packets
-              begin
-                unless File.directory?(configuration)
-                  # Zip file configuration so unzip and reset configuration path
-                  configuration = unzip(configuration)
+      @@instance_mutex.synchronize do
+        if @config_blacklist[name]
+          Logger.warn "Ignoring failed config #{name}"
+          update_config(@initial_config)
+          return @config.name, RuntimeError.new("Ignoring failed config #{name}")
+        end
+
+        if name && @config
+          # Make sure they're requesting something other than the current
+          # configuration.
+          if name != @config.name
+            # If they want the initial configuration we can just swap out the
+            # current configuration without doing any file processing
+            if name == @initial_config.name
+              Logger.info "Switching to initial configuration: #{name}"
+              update_config(@initial_config)
+            else
+              # Look for the requested configuration in the saved configurations
+              configuration = find_configuration(name)
+              if configuration
+                # We found the configuration requested. Reprocess the system.txt
+                # and reload the packets
+                begin
+                  unless File.directory?(configuration)
+                    # Zip file configuration so unzip and reset configuration path
+                    configuration = unzip(configuration)
+                  end
+                  
+                  Logger.info "Switching to configuration: #{name}"
+                  process_file(File.join(configuration, 'system.txt'), configuration)
+                  load_packets(name, false)
+                rescue Exception => error
+                  # Failed to load - Restore initial
+                  @config_blacklist[name] = true # Prevent wasting time trying to load the bad configuration again
+                  Logger.error "Problem loading configuration from #{configuration}: #{error.class}:#{error.message}\n#{error.backtrace.join("\n")}\n"
+                  Logger.info "Switching to initial configuration: #{@initial_config.name}"
+                  update_config(@initial_config)
+                  return @config.name, error
                 end
-                process_file(File.join(configuration, 'system.txt'), configuration)
-                load_packets(name)
-              rescue Exception => error
-                # Failed to load - Restore initial
+              else
+                # We couldn't find the configuration request. Reload the
+                # initial configuration
+                Logger.error "Unable to find configuration: #{name}"
+                Logger.info "Switching to initial configuration: #{@initial_config.name}"
                 update_config(@initial_config)
-                return @config.name, error
+                return @config.name, RuntimeError.new("Unable to find configuration: #{name}")
               end
-            else
-              # We couldn't find the configuration request. Reload the
-              # initial configuration
-              update_config(@initial_config)
             end
           end
+        else
+          Logger.info "Switching to initial configuration: #{@initial_config.name}"
+          update_config(@initial_config)
         end
-      else
-        update_config(@initial_config)
+        
+        return @config.name, nil
       end
-      return @config.name, nil
     end
 
     # (see #load_configuration)
@@ -530,7 +562,6 @@ module Cosmos
     # @param filename [String] Path to system.txt config file to process. Defaults to config/system/system.txt
     def reset_variables(filename = nil)
       @targets = {}
-      @targets['UNKNOWN'] = Target.new('UNKNOWN')
       @config = nil
       @commands = nil
       @telemetry = nil
@@ -557,8 +588,10 @@ module Cosmos
       @ports['REPLAY_API'] = 7877
       @ports['REPLAY_PREIDENTIFIED'] = 7879
       @ports['REPLAY_CMD_ROUTER'] = 7880
-      @ports['DART_DECOM'] = 8777
-      @ports['DART_STREAM'] = 8779
+
+      @ports['DART_STREAM'] = 8777
+      @ports['DART_DECOM'] = 8779
+      @ports['DART_MASTER'] = 8780
 
       @listen_hosts = {}
       @listen_hosts['CTS_API'] = '127.0.0.1'
@@ -572,6 +605,7 @@ module Cosmos
       @listen_hosts['REPLAY_CMD_ROUTER'] = '0.0.0.0'
       @listen_hosts['DART_STREAM'] = '0.0.0.0'
       @listen_hosts['DART_DECOM'] = '0.0.0.0'
+      @listen_hosts['DART_MASTER'] = '0.0.0.0'
 
       @connect_hosts = {}
       @connect_hosts['CTS_API'] = '127.0.0.1'
@@ -583,6 +617,7 @@ module Cosmos
       @connect_hosts['REPLAY_CMD_ROUTER'] = '127.0.0.1'
       @connect_hosts['DART_STREAM'] = '127.0.0.1'
       @connect_hosts['DART_DECOM'] = '127.0.0.1'
+      @connect_hosts['DART_MASTER'] = '127.0.0.1'
 
       @paths = {}
       @paths['LOGS'] = File.join(USERPATH, 'outputs', 'logs')
@@ -611,6 +646,7 @@ module Cosmos
 
       @initial_filename = filename
       @initial_config = nil
+      @config_blacklist = {}
     end
 
     # Reset variables and load packets
@@ -689,11 +725,31 @@ module Cosmos
       Bundler.load.specs.each do |spec|
         spec_name_split = spec.name.split('-')
         if spec_name_split.length > 1 && (spec_name_split[0] == 'cosmos')
-          # Filter to just targets and not tools and other extensions
-          if File.exist?(File.join(spec.gem_dir, 'cmd_tlm'))
-            target_name = spec_name_split[1..-1].join('-').to_s.upcase
-            target = Target.new(target_name, nil, nil, nil, spec.gem_dir)
-            @targets[target.name] = target
+          # search for multiple targets packaged in a single gem
+          dirs = []
+          Dir.foreach(spec.gem_dir) { |dir_filename| dirs << dir_filename }
+          dirs.sort!
+          dirs.each do |dir_filename|
+            if dir_filename == "."
+              # check the base directory
+              curr_dir = spec.gem_dir
+              target_name = spec_name_split[1..-1].join('-').to_s.upcase
+            else
+              #check for targets in other directories 1 level deep
+              next if dir_filename[0] == '.'               #skip dot directories and ".."
+              next if dir_filename != dir_filename.upcase  #skip non uppercase directories
+              curr_dir = File.join(spec.gem_dir, dir_filename)
+              target_name = dir_filename
+            end
+            # check for the cmd_tlm directory - if it has it, then we have found a target
+            if File.directory?(File.join(curr_dir,'cmd_tlm'))
+              # If any of the targets original directory name matches the
+              # current directory then it must have been already processed by
+              # DECLARE_TARGET so we skip it.
+              next if @targets.select {|name, target| target.original_name == target_name }.length > 0
+              target = Target.new(target_name,nil, nil, nil, spec.gem_dir)
+              @targets[target.name] = target
+           end
           end
         end
       end
@@ -722,9 +778,10 @@ module Cosmos
         configuration = find_configuration(@config.name)
         configuration = File.join(@paths['SAVED_CONFIG'], File.build_timestamped_filename([@config.name], '.zip')) unless configuration
         unless File.exist?(configuration)
+          configuration_tmp = File.join(@paths['SAVED_CONFIG'], File.build_timestamped_filename(['tmp_' + @config.name], '.zip.tmp'))
           begin
             Zip.continue_on_exists_proc = true
-            Zip::File.open(configuration, Zip::File::CREATE) do |zipfile|
+            Zip::File.open(configuration_tmp, Zip::File::CREATE) do |zipfile|
               zip_file_path = File.basename(configuration, ".zip")
               zipfile.mkdir zip_file_path
 
@@ -756,6 +813,7 @@ module Cosmos
                 end
               end
             end
+            File.rename(configuration_tmp, configuration)
             File.chmod(0444, configuration) # Mark readonly
           rescue Exception => error
             Logger.error "Problem saving configuration to #{configuration}: #{error.class}:#{error.message}\n#{error.backtrace.join("\n")}\n"
@@ -764,7 +822,7 @@ module Cosmos
       end
     end
 
-    def load_packets(configuration_name = nil)
+    def load_packets_internal(configuration_name = nil)
       # Determine hashing over all targets cmd_tlm files
       cmd_tlm_files = []
       additional_data = ''
@@ -785,7 +843,6 @@ module Cosmos
       # Only use at most, 32 characters of the hex
       hash_string = hash_string[-32..-1] if hash_string.length >= 32
 
-
       # Build filename for marshal file
       marshal_filename = File.join(@paths['TMP'], 'marshal_' << hash_string << '.bin')
 
@@ -831,6 +888,16 @@ module Cosmos
       save_configuration()
     end
 
+    def load_packets(configuration_name = nil, take_mutex = true)
+      if take_mutex
+        @@instance_mutex.synchronize do
+          load_packets_internal(configuration_name)
+        end
+      else
+        load_packets_internal(configuration_name)
+      end
+    end
+
     def setup_system_meta
       # Ensure SYSTEM META is defined and defined correctly
       begin

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

@@ -0,0 +1,360 @@
+# 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 = "'#{packet_item.default}'"
+      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]
+            @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
+        emit modified()
+      end
+      @table.resizeColumnsToContents()
+      @table.resizeRowsToContents()
+    end
+  end
+end