cosmos 4.0.3-java

data/lib/cosmos/gui/choosers/combobox_chooser.rb

@@ -0,0 +1,141 @@
+# 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'
+
+module Cosmos
+  # Widget which creates a horizontally laid out label, and combobox.
+  # A callback can be specified which is called once the combobox is changed.
+  class ComboboxChooser < Qt::Widget
+    # Width of the button in the combobox
+    COMBOBOX_BUTTON_WIDTH = 30
+    # Optional callback for when the combobox value changes
+    attr_accessor :sel_command_callback
+
+    # @param parent [Qt::Widget] Widget to parent this widget to
+    # @param label_text [String] Text to place in the label
+    # @param items [Array<#to_s>] Array of items to add to the combobox
+    # @param allow_user_entry [Boolean] Whether to allow the user to enter an
+    #   arbitrary string in the combobox
+    # @param compact_combobox [Boolean] Whether to fix the size of the combobox
+    #   or let it expand to fill the space
+    # @param color_chooser [Boolean] Whether to create a rectangular color
+    #   swatch based on each item name
+    def initialize(
+      parent, label_text, items, # required
+      allow_user_entry: false, compact_combobox: true, color_chooser: false
+    )
+      super(parent)
+      layout = Qt::HBoxLayout.new(self)
+      layout.setContentsMargins(0, 0, 0, 0)
+      @combo_label = Qt::Label.new(label_text)
+      @combo_label.setSizePolicy(Qt::SizePolicy::Fixed, Qt::SizePolicy::Fixed) unless compact_combobox
+      layout.addWidget(@combo_label)
+      @combo_value = Qt::ComboBox.new
+      @combo_value.setEditable(allow_user_entry)
+      string_items = items.map {|item| item.to_s }
+      @combo_value.addItems(string_items)
+      @color_chooser = color_chooser
+      set_colors(string_items) if @color_chooser
+      @combo_value.connect(SIGNAL('currentIndexChanged(int)')) {|index| handle_combobox_sel_command(index) }
+      if items.length < 20
+        @combo_value.setMaxVisibleItems(items.length)
+      else
+        @combo_value.setMaxVisibleItems(20)
+      end
+      layout.addStretch if compact_combobox
+      layout.addWidget(@combo_value)
+
+      setLayout(layout)
+      @sel_command_callback = nil
+    end
+
+    # Clears the combobox and adds new items
+    # @param items [Array<String>] Items to add to the combobox
+    # @param include_blank [Boolean] Whether to add a blank item as the first
+    #   combobox item. This is typically done to indicate to the user that a
+    #   value must be selected.
+    def update_items(items, include_blank = true)
+      @combo_value.clearItems
+      @combo_value.addItem(' ') if include_blank
+      string_items = items.map {|item| item.to_s }
+      @combo_value.addItems(string_items)
+      set_colors(string_items) if @color_chooser
+      if items.length < 20
+        @combo_value.setMaxVisibleItems(items.length)
+      else
+        @combo_value.setMaxVisibleItems(20)
+      end
+    end
+
+    # @param text [String] Text to set in the current combobox item
+    def set_current(text)
+      @combo_value.setCurrentText(text.to_s)
+    end
+
+    # @return [Integer] Current item as an integer
+    def integer
+      Integer(@combo_value.currentText)
+    end
+
+    # @return [Float] Current item as a float
+    def float
+      @combo_value.currentText.to_f if @combo_value.currentText
+    end
+
+    # @return [String] Current item as a string
+    def string
+      @combo_value.currentText
+    end
+
+    # @return [Symbol] Current item as a symbol
+    def symbol
+      @combo_value.currentText.intern if @combo_value.currentText
+    end
+
+    protected
+
+    # Calls the combobox selection changed callback if it exists
+    def handle_combobox_sel_command(index)
+      if index >= 0
+        @sel_command_callback.call(string()) if @sel_command_callback
+      end
+      0
+    end
+
+    # Creates a rectangle of color based on the combobox item name
+    def set_colors(string_items)
+      # Create an image we can draw into
+      img = Qt::Image.new(16, 16, Qt::Image::Format_RGB32)
+      # Grab a rectangle offset by 1 pixel inside the image
+      rect = img.rect().adjusted(1, 1, -1, -1)
+      p = Qt::Painter.new
+      # Start painting on the image
+      p.begin(img)
+      # Fill the original image with black (this paints the outline)
+      p.fillRect(img.rect(), Qt::black)
+
+      string_items.each_with_index do |string_item, index|
+        unless string_item.strip.empty?
+          # Fill the offsetted rectangle with the color
+          p.fillRect(rect, Cosmos.getColor(string_item))
+          # Create a variant from the image pixmap
+          variant = Qt::Variant.fromValue(Qt::Pixmap::fromImage(img))
+          @combo_value.setItemData(index, variant, Qt::DecorationRole)
+          variant.dispose
+        end
+      end
+      p.end # Stop painting
+      rect.dispose
+      img.dispose
+      p.dispose
+    end
+  end
+end

data/lib/cosmos/gui/choosers/file_chooser.rb

@@ -0,0 +1,85 @@
+# 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'
+
+module Cosmos
+  # Widget which creates a horizontally laid out label, value, and button that
+  # opens a FileDialog to choose a file. A callback can be specified which is
+  # called once the file is selected by the FileDialog.
+  class FileChooser < Qt::Widget
+    # Callback for a chosen filename
+    attr_accessor :callback
+
+    # @param parent [Qt::Widget] Widget to parent this widget to
+    # @param label_text [String] Text to place in the label
+    # @param initial_value [String] Initial value to put in the value box. Note
+    #   this has no impact on the FileDialog.
+    # @param button_text [String] Text to place on the button which launches
+    #   the FileDialog
+    # @param file_path [String] Default path which is used when initially
+    #   opening the FileDialog
+    # @param field_width [Integer] Minimum width of the value field
+    # @param fill [Boolean] Whether to make this widget fill up the horizontal
+    #   space allocated to it or be fixed width.
+    # @param extensions [String] List of file filters which can be selected by
+    #   the user. Must be formatted with the filter name followed by the
+    #   extension in parens. Multiple filters must be separated by double
+    #   semicolons. For example:
+    #     "Images (*.png *.jpg);;Text files (*.txt)"
+    def initialize(
+      parent, label_text, initial_value, button_text, file_path,
+      field_width = 20, fill = false, extensions = nil
+    )
+      super(parent)
+
+      layout = Qt::HBoxLayout.new(self)
+      layout.setContentsMargins(0,0,0,0)
+
+      @file_label = Qt::Label.new(label_text)
+      @file_label.setSizePolicy(Qt::SizePolicy::Fixed, Qt::SizePolicy::Fixed) if fill
+      layout.addWidget(@file_label)
+      layout.addStretch unless fill
+
+      @filename_value = Qt::LineEdit.new(initial_value.to_s)
+      @filename_value.setMinimumWidth(field_width)
+      @filename_value.setReadOnly(true)
+      layout.addWidget(@filename_value)
+
+      @select_button = Qt::PushButton.new(button_text)
+      @select_button.connect(SIGNAL('clicked()')) do
+        if extensions
+          filename = Qt::FileDialog.getOpenFileName(self, button_text, file_path, extensions)
+        else
+          filename = Qt::FileDialog.getOpenFileName(self, button_text, file_path)
+        end
+        if !filename.to_s.empty?
+          @filename_value.text = filename.to_s
+          @callback.call(@filename_value.text) if @callback
+        end
+      end
+      layout.addWidget(@select_button)
+
+      setLayout(layout)
+
+      @callback = nil
+    end
+
+    # @return [String] The selected filename
+    def filename
+      @filename_value.text
+    end
+
+    # @param filename [String] Filename to set the value to
+    def filename=(filename)
+      @filename_value.text = filename.to_s
+    end
+  end
+end

data/lib/cosmos/gui/choosers/float_chooser.rb

@@ -0,0 +1,67 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos'
+require 'cosmos/gui/choosers/value_chooser'
+
+module Cosmos
+  class FloatChooserDoubleValidator < Qt::DoubleValidator
+    def fixup(input)
+      begin
+        value = input.to_f
+        if value < bottom()
+          # Handle less than bottom
+          parent().setText(bottom().to_s)
+        elsif value > top()
+          # Handle greater than top
+          parent().setText(top().to_s)
+        end
+      rescue Exception => err
+        # Oh well no fixup
+      end
+    end
+  end
+
+  # Widget which creates a horizontally laid out label and editable float value.
+  # Minimum and maximum values can be specified to perform input validation.
+  # A callback can be specified which is called once the value is changed.
+  class FloatChooser < ValueChooser
+    # @param parent (see ValueChooser#initialize)
+    # @param label_text (see ValueChooser#initialize)
+    # @param initial_value (see ValueChooser#initialize)
+    # @param minimum_value [Float] Minimum allowable value
+    # @param maximum_value [Float] Maximum allowable value
+    # @param field_width (see ValueChooser#initialize)
+    # @param fill (see ValueChooser#initialize)
+    def initialize(parent, label_text, initial_value,
+                   minimum_value = nil, maximum_value = nil,
+                   field_width = 20, fill = false)
+      super(parent, label_text, initial_value, field_width, fill)
+      @minimum_value = minimum_value
+      @maximum_value = maximum_value
+
+      validator = FloatChooserDoubleValidator.new(@value)
+      validator.setBottom(minimum_value) if minimum_value
+      validator.setTop(maximum_value) if maximum_value
+      validator.setNotation(Qt::DoubleValidator::StandardNotation)
+      @value.setValidator(validator)
+    end
+
+    # @return [Float] Value as a float. If minimum and/or maximum values were
+    #   specified and the the value falls outside, it will be set to the
+    #   minimum or maximum as appropriate.
+    def value
+      float_value = @value.text.to_f
+      float_value = @minimum_value if @minimum_value && float_value < @minimum_value
+      float_value = @maximum_value if @maximum_value && float_value > @maximum_value
+      float_value
+    end
+  end
+end

data/lib/cosmos/gui/choosers/integer_chooser.rb

@@ -0,0 +1,69 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos'
+require 'cosmos/gui/choosers/value_chooser'
+
+module Cosmos
+  class IntegerChooserIntValidator < Qt::IntValidator
+    def fixup(input)
+      begin
+        value = input.to_i
+        if value < bottom()
+          # Handle less than bottom
+          parent().setText(bottom().to_s)
+        elsif value > top()
+          # Handle greater than top
+          parent().setText(top().to_s)
+        elsif input != value.to_s
+          # Handle poorly formatted (only known case is float given as starting value)
+          parent().setText(value.to_s)
+        end
+      rescue Exception => err
+        # Oh well no fixup
+      end
+    end
+  end
+
+  # Widget which creates a horizontally laid out label and editable integer value.
+  # Minimum and maximum values can be specified to perform input validation.
+  # A callback can be specified which is called once the value is changed.
+  class IntegerChooser < ValueChooser
+    # @param parent (see ValueChooser#initialize)
+    # @param label_text (see ValueChooser#initialize)
+    # @param initial_value (see ValueChooser#initialize)
+    # @param minimum_value [Integer] Minimum allowable value
+    # @param maximum_value [Integer] Maximum allowable value
+    # @param field_width (see ValueChooser#initialize)
+    # @param fill (see ValueChooser#initialize)
+    def initialize(parent, label_text, initial_value,
+                   minimum_value = nil, maximum_value = nil,
+                   field_width = 20, fill = false)
+      super(parent, label_text, initial_value, field_width, fill)
+      @minimum_value = minimum_value
+      @maximum_value = maximum_value
+
+      validator = IntegerChooserIntValidator.new(@value)
+      validator.setBottom(minimum_value) if minimum_value
+      validator.setTop(maximum_value) if maximum_value
+      @value.setValidator(validator)
+    end
+
+    # @return [Integer] Value as an integer. If minimum and/or maximum values were
+    #   specified and the the value falls outside, it will be set to the
+    #   minimum or maximum as appropriate.
+    def value
+      integer_value = @value.text.to_i
+      integer_value = @minimum_value if @minimum_value && integer_value < @minimum_value
+      integer_value = @maximum_value if @maximum_value && integer_value > @maximum_value
+      integer_value
+    end
+  end
+end

data/lib/cosmos/gui/choosers/string_chooser.rb

@@ -0,0 +1,35 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos'
+require 'cosmos/gui/choosers/value_chooser'
+
+module Cosmos
+  # Widget which creates a horizontally laid out label and editable string value.
+  # A callback can be specified which is called once the value is changed.
+  class StringChooser < ValueChooser
+    # @param parent (see ValueChooser#initialize)
+    # @param label_text (see ValueChooser#initialize)
+    # @param initial_value (see ValueChooser#initialize)
+    # @param field_width (see ValueChooser#initialize)
+    # @param fill (see ValueChooser#initialize)
+    # @param read_only [Boolean] Whether the string is editable
+    # @param alignment [Integer] The alignment of the string value field
+    def initialize(
+      parent, label_text, initial_value,
+      field_width = 20, fill = false, read_only = false,
+      alignment = Qt::AlignLeft | Qt::AlignVCenter
+    )
+      super(parent, label_text, initial_value, field_width, fill)
+      @value.setReadOnly(true) if read_only
+      @value.setAlignment(alignment)
+    end
+  end
+end

data/lib/cosmos/gui/choosers/telemetry_chooser.rb

@@ -0,0 +1,326 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos'
+require 'cosmos/gui/qt'
+require 'cosmos/system/system'
+
+module Cosmos
+  # Provides dropdowns to select from all the defined Targets, Packets, and
+  # Items. Callbacks can be added when any of the dropdown values are changed
+  # as well as when the select button is pressed. Provides an option to orient
+  # the dropdowns horizontally or vertically.
+  class TelemetryChooser < Qt::Widget
+    # Width of the button in the Combobox
+    COMBOBOX_BUTTON_WIDTH = 30
+
+    # Callback called when the target is changed - call(target_name)
+    attr_accessor :target_changed_callback
+
+    # Callback called when the packet is changed - call(target_name, packet_name)
+    attr_accessor :packet_changed_callback
+
+    # Callback called when the item is changed - call(target_name, packet_name, item_name)
+    attr_accessor :item_changed_callback
+
+    # Callback called when the select button is pressed - call(target_name, packet_name, item_name)
+    attr_accessor :select_button_callback
+
+    # Label for the target
+    attr_accessor :target_label
+
+    # Label for the packet
+    attr_accessor :packet_label
+
+    # Label for the item
+    attr_accessor :item_label
+
+    # Custom error which we raise and catch
+    class NotFoundError < StandardError
+      # @param msg [String] The error message
+      def initialize(msg)
+        super(msg)
+      end
+    end
+
+    # @param parent [Qt::Widget] Parent of this widget
+    # @param orientation [Integer] Must be Qt::Horizontal or Qt::Vertical
+    # @param choose_item [Boolean] Whether to allow choosing items. Choosing
+    #   targets and packets are alway enabled.
+    # @param select_button [Boolean] Whether to display the "Select" button.
+    #   You can disable the button if you just want to implement the dropdown
+    #   change callbacks.
+    # @param support_latest [Boolean] Whether to add LATEST to the list of packets
+    # @param fill [Boolean] Whether to allow this widget to take all available
+    #   space or have a fixed width/height
+    def initialize(
+      parent,
+      orientation = Qt::Horizontal,
+      choose_item = true,
+      select_button = true,
+      support_latest = false,
+      fill = false
+    )
+      super(parent)
+      if orientation == Qt::Horizontal
+        # Horizontal Frame for overall widget
+        @overall_frame = Qt::HBoxLayout.new(self)
+      else
+        # Vertical Frame for overall widget
+        @overall_frame = Qt::VBoxLayout.new(self)
+      end
+      @overall_frame.setContentsMargins(0, 0, 0, 0)
+
+      # Target Selection
+      @target_layout = Qt::HBoxLayout.new
+      @target_label = Qt::Label.new('Target:')
+      @target_label.setSizePolicy(Qt::SizePolicy::Fixed, Qt::SizePolicy::Fixed) if fill
+      @target_layout.addWidget(@target_label)
+      @target_layout.addStretch unless fill
+      @target_combobox = Qt::ComboBox.new
+      # This allows the comboboxes to automatically adjust when we change the contents - awesome!
+      @target_combobox.setSizeAdjustPolicy(Qt::ComboBox::AdjustToContents)
+      @target_combobox.connect(SIGNAL('activated(int)')) do
+        update_packets()
+        @target_changed_callback.call(target_name()) if @target_changed_callback
+      end
+      @target_layout.addWidget(@target_combobox)
+      @overall_frame.addLayout(@target_layout)
+
+      # Packet Selection
+      @packet_layout = Qt::HBoxLayout.new
+      @packet_label = Qt::Label.new('Packet:')
+      @packet_label.setSizePolicy(Qt::SizePolicy::Fixed, Qt::SizePolicy::Fixed) if fill
+      @packet_layout.addWidget(@packet_label)
+      @packet_layout.addStretch unless fill
+      @packet_combobox = Qt::ComboBox.new
+      @packet_combobox.setSizeAdjustPolicy(Qt::ComboBox::AdjustToContents)
+      @packet_combobox.connect(SIGNAL('activated(int)')) do
+        update_items()
+        @packet_changed_callback.call(target_name(), packet_name()) if @packet_changed_callback
+      end
+      @packet_layout.addWidget(@packet_combobox)
+      @overall_frame.addLayout(@packet_layout)
+
+      @item_combobox = nil
+      if choose_item
+        # Item Selection
+        @item_layout = Qt::HBoxLayout.new
+        @item_label = Qt::Label.new('Item:')
+        @item_label.setSizePolicy(Qt::SizePolicy::Fixed, Qt::SizePolicy::Fixed) if fill
+        @item_layout.addWidget(@item_label)
+        @item_layout.addStretch unless fill
+        @item_combobox = Qt::ComboBox.new
+        @item_combobox.setSizeAdjustPolicy(Qt::ComboBox::AdjustToContents)
+        @item_combobox.connect(SIGNAL('activated(int)')) do
+          @item_changed_callback.call(target_name(), packet_name(), item_name()) if @item_changed_callback
+        end
+        @item_layout.addWidget(@item_combobox)
+        @overall_frame.addLayout(@item_layout)
+      end
+
+      if select_button
+        @select_button = Qt::PushButton.new('Select')
+        @select_button.connect(SIGNAL('clicked()')) do
+          @select_button_callback.call(target_name(), packet_name(), item_name()) if @select_button_callback
+        end
+        @overall_frame.addWidget(@select_button)
+      end
+
+      # Initialize instance variables
+      @target_changed_callback = nil
+      @packet_changed_callback = nil
+      @item_changed_callback = nil
+      @select_button_callback = nil
+      @support_latest = support_latest
+    end
+
+    # Update all items in all comboboxes. If a previous item was selected that
+    # item will be reselected if it still exists.
+    def update
+      current_target_name = target_name()
+      current_packet_name = packet_name()
+      current_item_name = item_name()
+      update_targets()
+      if current_target_name && current_packet_name && (current_item_name || !@item_combobox)
+        begin
+          set_item(current_target_name, current_packet_name, current_item_name)
+        rescue NotFoundError
+          # Oh well - Tried to keep the same item
+        end
+      end
+    end
+
+    # @param text [String] Select button text
+    def button_text=(text)
+      @select_button.setText(text)
+    end
+
+    # @return [String] Selected target name
+    def target_name
+      @target_combobox.text
+    end
+
+    # @return [String] Selected packet name
+    def packet_name
+      @packet_combobox.text
+    end
+
+    # @return [String] Selected item name
+    def item_name
+      @item_combobox ? @item_combobox.text : nil
+    end
+
+    # @return [Array<String>] List of all target names in the target combobox
+    def target_names
+      target_names_array = []
+      @target_combobox.each {|item_text, _item_data| target_names_array << item_text}
+      target_names_array
+    end
+
+    # @return [Array<String>] List of all packet names in the packet combobox
+    def packet_names
+      packet_names_array = []
+      @packet_combobox.each {|item_text, _item_data| packet_names_array << item_text}
+      packet_names_array
+    end
+
+    # @return [Array<String>] List of all item names in the item combobox
+    def item_names
+      item_names_array = []
+      if @item_combobox
+        @item_combobox.each {|item_text, _item_data| item_names_array << item_text}
+      end
+      item_names_array
+    end
+
+    # Sets the packet combobox
+    # @param target_name [String] Name of the target
+    # @param packet_name [String] Name of the packet
+    def set_packet(target_name, packet_name)
+      # Select desired target
+      index = 0
+      found = false
+      @target_combobox.each do |item_text, _item_data|
+        if target_name.casecmp(item_text).zero?
+          found = true
+          break
+        end
+        index += 1
+      end
+      raise NotFoundError, "TelemetryChooser unknown target_name #{target_name}" unless found
+      @target_combobox.setCurrentIndex(index)
+      update_packets()
+
+      # Select desired packet
+      index = 0
+      found = false
+      @packet_combobox.each do |item_text, _item_data|
+        if packet_name.casecmp(item_text).zero?
+          found = true
+          break
+        end
+        index += 1
+      end
+      raise NotFoundError, "TelemetryChooser unknown packet_name #{packet_name}" unless found
+      @packet_combobox.setCurrentIndex(index)
+      update_items()
+    end
+
+    # Sets the item combobox
+    # @param target_name [String] Name of the target
+    # @param packet_name [String] Name of the packet
+    # @param item_name [String] Name of the item
+    def set_item(target_name, packet_name, item_name)
+      set_packet(target_name, packet_name)
+      return unless @item_combobox
+
+      index = 0
+      found = false
+      @item_combobox.each do |item_text, _item_data|
+        if item_name.casecmp(item_text).zero?
+          found = true
+          break
+        end
+        index += 1
+      end
+      raise NotFoundError, "TelemetryChooser unknown item_name #{item_name}" unless found
+      @item_combobox.setCurrentIndex(index)
+    end
+
+    protected
+
+    # Updates all comboboxs based on a change
+    def update_targets
+      @target_combobox.clearItems()
+      target_names = System.telemetry.target_names
+
+      # Delete targets with only hidden packets
+      target_names_to_delete = []
+      target_names.each do |target_name|
+        packets = System.telemetry.packets(target_name)
+        has_non_hidden = false
+        packets.each do |packet_name, packet|
+          has_non_hidden = true unless packet.hidden
+        end
+        target_names_to_delete << target_name unless has_non_hidden
+      end
+      target_names_to_delete.each do |target_name|
+        target_names.delete(target_name)
+      end
+
+      target_names.each do |name|
+        @target_combobox.addItem(name)
+      end
+      if target_names.length > 20
+        @target_combobox.setMaxVisibleItems(20)
+      else
+        @target_combobox.setMaxVisibleItems(target_names.length)
+      end
+      update_packets()
+    end
+
+    # Updates the packet names and item names based on a change
+    def update_packets
+      return unless target_name()
+      @packet_combobox.clearItems()
+      packets = System.telemetry.packets(target_name())
+      packet_names = []
+      packets.each { |packet_name, packet| packet_names << packet.packet_name unless packet.hidden }
+      packet_names << Telemetry::LATEST_PACKET_NAME if @support_latest
+      packet_names.sort!
+      packet_names.each do |name|
+        @packet_combobox.addItem(name)
+      end
+      if packet_names.length > 20
+        @packet_combobox.setMaxVisibleItems(20)
+      else
+        @packet_combobox.setMaxVisibleItems(packet_names.length)
+      end
+      update_items()
+    end
+
+    # Updates the item names based on a change
+    def update_items
+      return unless target_name() && packet_name() && @item_combobox
+      @item_combobox.clearItems()
+      item_names = System.telemetry.item_names(target_name(), packet_name())
+      item_names.sort!
+      item_names.each do |name|
+        @item_combobox.addItem(name)
+      end
+      if item_names.length > 20
+        @item_combobox.setMaxVisibleItems(20)
+      else
+        @item_combobox.setMaxVisibleItems(item_names.length)
+      end
+    end
+  end
+end