cosmos 3.4.2 → 3.5.0

data/lib/cosmos/tools/data_viewer/data_viewer.rb

@@ -180,28 +180,20 @@ module Cosmos
     end
 
     def find
-      unless @find_dialog
-        @find_dialog = FindReplaceDialog.new(@script, false)
-        @find_dialog.connect(SIGNAL('find_next()')) do
-          current_component do |component|
-            component.find(@find_dialog)
-          end
-        end
+      current_component do |component|
+        FindReplaceDialog.show_find(component.text)
       end
-      @find_dialog.show
-      @find_dialog.raise
-      @find_dialog.activateWindow
     end
 
     def find_next
       current_component do |component|
-        component.find_next(@find_dialog) if @find_dialog
+        FindReplaceDialog.find_next(component.text)
       end
     end
 
     def find_previous
       current_component do |component|
-        component.find_previous(@find_dialog) if @find_dialog
+        FindReplaceDialog.find_previous(component.text)
       end
     end
 
@@ -435,6 +427,7 @@ module Cosmos
               file_size = File.size(filename).to_f
               dialog.append_text("Processing: #{filename}")
 
+              Cosmos.check_log_configuration(@packet_log_reader, filename)
               @packet_log_reader.each(filename, true, @time_start, @time_end) do |packet|
                 break if @cancel_progress
                 progress = @packet_log_reader.bytes_read.to_f / file_size

data/lib/cosmos/tools/data_viewer/data_viewer_component.rb

@@ -15,8 +15,12 @@ module Cosmos
   class DataViewerComponent < Qt::Widget
     attr_reader :tab_name
     attr_reader :packets
+    attr_reader :text
 
-    # Initialize the Data Viewer Component
+    # Create a component to go inside the DataViewer
+    #
+    # @param parent [Qt::Widget] Parent widget
+    # @param tab_name [String] Name of the tab which displays this widget
     def initialize(parent, tab_name)
       super(parent)
       @tab_name = tab_name
@@ -28,6 +32,9 @@ module Cosmos
     end
 
     # Adds a packet to the list of packets this components processes
+    #
+    # @param target_name [String] Name of the target
+    # @param packet_name [String] Name of the packet
     def add_packet(target_name, packet_name)
       @packets << [target_name, packet_name]
     end
@@ -39,11 +46,7 @@ module Cosmos
       @text = Qt::PlainTextEdit.new
       @text.setReadOnly(true)
       @text.setMaximumBlockCount(@max_block_count)
-      if Kernel.is_windows?
-        @text.font = Cosmos.getFont("courier", 9)
-      else
-        @text.font = Cosmos.getFont("courier", 12)
-      end
+      @text.font = Cosmos.get_default_small_font
       @text.setWordWrapMode(Qt::TextOption::NoWrap)
       @top_layout.addWidget(@text)
 
@@ -93,49 +96,12 @@ module Cosmos
       @text.setPlainText("")
     end
 
-    def find(dialog)
-      found = @text.find(dialog.find_text, dialog.find_flags)
-      if not found and dialog.wrap_around?
-        cursor = @text.textCursor
-        if dialog.find_up?
-          cursor.movePosition(Qt::TextCursor::End)
-        else
-          cursor.movePosition(Qt::TextCursor::Start)
-        end
-        @text.setTextCursor(cursor)
-        @text.find(dialog.find_text, dialog.find_flags)
-      end
-    end
-
-    def find_next(dialog)
-      flags = dialog.find_flags
-      flags &= ~Qt::TextDocument::FindBackward.to_i
-      found = @text.find(dialog.find_text, flags)
-      if not found and dialog.wrap_around?
-        cursor = @text.textCursor
-        cursor.movePosition(Qt::TextCursor::Start)
-        @text.setTextCursor(cursor)
-        @text.find(dialog.find_text, flags)
-      end
-    end
-
-    def find_previous(dialog)
-      flags = dialog.find_flags
-      flags |= Qt::TextDocument::FindBackward.to_i
-      found = @text.find(dialog.find_text, flags)
-      if not found and dialog.wrap_around?
-        cursor = @text.textCursor
-        cursor.movePosition(Qt::TextCursor::End)
-        @text.setTextCursor(cursor)
-        @text.find(dialog.find_text, flags)
-      end
-    end
-
     def showEvent(event)
-      # When the tab is shown we want to ensure the scroll bar is at the maximum to allow
-      # the PlainTextArea to automatically hold the scroll at the bottom of the display while
-      # appending things. If this is not done, switching tabs will cause the scroll bar to "stick"
-      # and not stay at the bottom with the newest text.
+      # When the tab is shown we want to ensure the scroll bar is at the
+      # maximum to allow the PlainTextArea to automatically hold the scroll
+      # at the bottom of the display while appending things.
+      # If this is not done, switching tabs will cause the scroll bar
+      # to "stick" and not stay at the bottom with the newest text.
       @timer.start(100)
     end
 

data/lib/cosmos/tools/handbook_creator/handbook_creator_config.rb

@@ -83,11 +83,7 @@ module Cosmos
         if @pdf
           if progress_dialog
             Qt.execute_in_main_thread(true) do
-              if Kernel.is_windows?
-                progress_dialog.set_text_font(Cosmos.getFont("courier",10))
-              else
-                progress_dialog.set_text_font(Cosmos.getFont("courier",14))
-              end
+              progress_dialog.set_text_font(Cosmos.get_default_font)
             end
           end
           Cosmos.set_working_dir do

data/lib/cosmos/tools/launcher/launcher.rb

@@ -23,6 +23,10 @@ module Cosmos
 
     def initialize(options)
       super(options) # MUST BE FIRST - All code before super is executed twice in RubyQt Based classes
+
+      # Set environment variable of COSMOS_USERPATH so that all launched apps know where to find the configuration
+      ENV['COSMOS_USERPATH'] = Cosmos::USERPATH
+
       Cosmos.load_cosmos_icon("launcher.png")
       layout.setSizeConstraint(Qt::Layout::SetFixedSize)
 

data/lib/cosmos/tools/launcher/launcher_config.rb

@@ -11,6 +11,7 @@
 require 'cosmos'
 require 'cosmos/config/config_parser'
 require 'ostruct'
+require 'bundler'
 
 module Cosmos
 
@@ -62,6 +63,9 @@ module Cosmos
         # Handle each keyword
         case keyword
 
+        when 'AUTO_GEM_TOOLS'
+          parse_gem_tool(parser)
+
         when 'TOOL'
           parse_tool(parser, params, multitool)
 
@@ -140,6 +144,25 @@ module Cosmos
 
     protected
 
+    def parse_gem_tool(parser)
+      parser.verify_num_parameters(0, 0, parser.keyword)
+      Bundler.load.specs.each do |spec|
+        spec_name_split = spec.name.split('-')
+        if spec_name_split.length > 1 and spec_name_split[0] == 'cosmos'
+          # Filter to just tools and not targets
+          if File.exist?(File.join(spec.gem_dir, 'tools'))
+            Dir[File.join(spec.gem_dir, 'tools', '*')].each do |filename|
+              if File.extname(filename) == ''
+                @items << [:TOOL, File.basename(filename), format_shell_command(parser, "LAUNCH_GEM #{File.basename(filename)}"), true, File.basename(filename).class_name_to_filename(false) + '.png', nil]
+              end
+            end
+          end
+        end
+      end
+    rescue Bundler::GemfileNotFound
+      # No Gemfile - so no gem based tools
+    end
+
     def parse_tool(parser, params, multitool)
       if multitool
         parser.verify_num_parameters(1, 1, "TOOL <Shell command>")
@@ -165,6 +188,8 @@ module Cosmos
         formatted_command = parse_launch(shell_command)
       when 'LAUNCH_TERMINAL'
         formatted_command = parse_launch_terminal(shell_command)
+      when 'LAUNCH_GEM'
+        formatted_command = parse_launch_gem(shell_command)
       else
         # Nothing to do if they aren't using our keywords
         formatted_command = shell_command
@@ -201,6 +226,31 @@ module Cosmos
       formatted
     end
 
+    def parse_launch_gem(command)
+      split = command.split
+
+      # Find the gem with this file
+      begin
+        Bundler.load.specs.each do |spec|
+          spec_name_split = spec.name.split('-')
+          if spec_name_split.length > 1 and spec_name_split[0] == 'cosmos'
+            # Filter to just tools and not targets
+            if File.exist?(File.join(spec.gem_dir, 'tools', split[1]))
+              if Kernel.is_mac? and File.exist?(File.join(USERPATH, 'tools', 'mac'))
+                return "open #{spec.gem_dir}/tools/mac/#{split[1]}.app --args #{split[2..-1].join(' ')}".strip
+              else
+                return "RUBYW #{spec.gem_dir}/tools/#{split[1]} #{split[2..-1].join(' ')}".strip
+              end
+            end
+          end
+        end
+      rescue Bundler::GemfileNotFound
+        # No Gemfile - so no gem based tools
+      end
+
+      raise "Could not find gem containing tool: #{split[1]} - Make sure the appropriate gem is in your Gemfile"
+    end
+
   end # class LauncherConfig
 
 end # module Cosmos

data/lib/cosmos/tools/launcher/launcher_tool.rb

@@ -12,7 +12,6 @@ require 'cosmos'
 require 'cosmos/gui/qt'
 
 module Cosmos
-
   class LauncherTool < Qt::Object
     slots 'button_clicked()'
 
@@ -26,7 +25,7 @@ module Cosmos
 
     def button_clicked
       if @variable_parameters
-        parameters = parameters_dialog()
+        parameters = parameters_dialog
         if parameters
           if @capture_io
             Cosmos.run_process_check_output(@shell_command + ' ' + parameters)
@@ -44,7 +43,7 @@ module Cosmos
     end
 
     def parameters_dialog
-      dialog = Qt::Dialog.new(self.parent)
+      dialog = Qt::Dialog.new(parent)
       dialog.window_title = "#{@button_text} Options"
       layout = Qt::VBoxLayout.new
       dialog.layout = layout
@@ -53,10 +52,24 @@ module Cosmos
       @variable_parameters.each do |parameter_name, parameter_value|
         hlayout = Qt::HBoxLayout.new
         hlayout.addWidget(Qt::Label.new(parameter_name))
-        line_edit = Qt::LineEdit.new()
-        line_edit.setText(parameter_value)
-        hlayout.addWidget(line_edit)
-        widgets << line_edit
+        parameter_options = parameter_value.split('|')
+        if parameter_options.length > 1
+          combo_box = Qt::ComboBox.new
+          combo_box.setEditable(true)
+          idx = 0
+          parameter_options.each do |option|
+            combo_box.insertItem(idx, option)
+            idx += 1
+          end
+          combo_box.setCurrentIndex(0) # Default Option is the first one
+          hlayout.addWidget(combo_box)
+          widgets << combo_box
+        else
+          line_edit = Qt::LineEdit.new
+          line_edit.setText(parameter_value)
+          hlayout.addWidget(line_edit)
+          widgets << line_edit
+        end
         layout.addLayout(hlayout)
       end
 
@@ -85,7 +98,7 @@ module Cosmos
       if result == Qt::Dialog::Accepted
         parameters = ''
         index = 0
-        @variable_parameters.each do |parameter_name, parameter_value|
+        @variable_parameters.each do |parameter_name, _parameter_value|
           parameters << parameter_name
           parameters << ' '
           parameters << widgets[index].text
@@ -100,5 +113,4 @@ module Cosmos
       end
     end
   end
-
 end

data/lib/cosmos/tools/limits_monitor/limits_monitor.rb

@@ -15,232 +15,460 @@ Cosmos.catch_fatal_exception do
   require 'cosmos/gui/dialogs/cmd_tlm_raw_dialog'
   require 'cosmos/script'
   require 'cosmos/tools/tlm_viewer/widgets/labelvaluelimitsbar_widget'
+  require 'cosmos/tools/tlm_viewer/widgets/label_widget'
+  require 'pathname'
 end
 
+# Extend Array to search for and delete telemetry items.
+# Telemetry items are Arrays of [target name, packet name, item name].
 class Array
   def includes_item?(item)
-    self.each do |target, pkt_name, item_name|
-      if ((target == item[0]) and (pkt_name == item[1]) and (item_name == item[2]))
-        return true
-      end
-    end
-    return false
+    found, index = find_item(item)
+    return found
   end
 
   def delete_item(item)
+    found, index = find_item(item)
+    self.delete_at(index) if found
+    return index
+  end
+
+  private
+  def find_item(item)
+    found = false
     index = 0
-    delete_index = nil
-    self.each do |target, pkt_name, item_name|
-      if ((target == item[0]) and (pkt_name == item[1]) and (item_name == item[2]))
-        delete_index = index
+    self.each do |target_name, packet_name, item_name|
+      if ((target_name == item[0]) &&
+          (packet_name == item[1]) &&
+          # If the item name is nil we're dealing with a packet
+          (item_name == item[2] || item_name.nil?))
+        found = true
         break
       end
       index += 1
     end
-
-    self.delete_at(delete_index) if delete_index
-    return delete_index
+    return found, index
   end
 end
 
 module Cosmos
 
-  # The LimitsMonitor application displays all the out of limits items
-  # encountered by the COSMOS server. It provides the ability to ignore and
-  # restore limits as well as logs all limits events.
-  class LimitsMonitor < QtTool
-    slots 'options()'
-    slots 'reset()'
-    slots 'handle_clear_ignored_items()'
-    slots 'handle_view_ignored_items()'
-    slots 'handle_save_ignored_items()'
-    slots 'handle_open_ignored_items()'
-
-    # Set up class variables, tab-book with main panel and log panel, menus, and
-    # status bar on main panel.
-    #
-    # @param options [Options] Contains the options for the window.
-    def initialize(options)
-      super(options)
-      Cosmos.load_cosmos_icon("limits_monitor.png")
-
-      @out_of_limits_items = []
+  class LimitsItems
+    # @return [Array<String,String,String>] Target name, packet name, item name
+    attr_reader :ignored
+    # @return [Boolean] Whether the limits items have been fetched from the server
+    attr_reader :initialized
+
+    UNKNOWN_ARRAY = ['UNKNOWN', 'UNKNOWN', nil]
+
+    # @param new_item_callback [Proc] Method to create a new item in the GUI
+    # @param update_item_callback [Proc] Method to update an item in the GUI
+    # @param clear_items_callback [Proc] Method to clear all items in the GUI
+    def initialize(new_item_callback, update_item_callback, clear_items_callback)
+      @new_item_callback = new_item_callback
+      @update_item_callback = update_item_callback
+      @clear_items_callback = clear_items_callback
+      @ignored = []
+      @items = {}
+      @out_of_limits = []
       @queue_id = nil
-      @limits_set = nil
-      @widgets = []
-      @widget_hframes = []
-      @value_limits_set = nil
-      @items = []
-      @new_items = []
+      @limits_set = :DEFAULT
+      request_reset()
+    end
+
+    # Request that the limits items be refreshed from the server
+    def request_reset
       @initialized = false
-      @overall_limits_state = :STALE
-      @ignored_items = []
-      @ignored_filename = nil
-      @colorblind = false
-      @new_widgets = []
-      @buttons = []
-      @cancel_thread = false
-      @limits_sleeper = Sleeper.new
-      @value_sleeper = Sleeper.new
+    end
 
-      statusBar.showMessage(tr(""))
+    # Ignore an item. Don't display it in the GUI if it goes out of limits
+    # and don't have it count towards the overall limit state. Still display
+    # its limits transitions in the log.
+    #
+    # @param item [Array<String,String,String>] Target name, packet name,
+    #   item name to ignore
+    def ignore(item)
+      index = @out_of_limits.delete_item(item)
+      @items.delete("#{item[0]} #{item[1]} #{item[2]}") if index
+      unless @ignored.includes_item?(item)
+        @ignored << item
+      end
+    end
 
-      initialize_actions()
-      initialize_menus()
-      complete_initialize()
+    # Remove an item from the ignored list to have it be displayed and
+    # count towards the overall limits state.
+    #
+    # @param item [Array<String,String,String> Target name, packet name,
+    #   item name to remove from ignored list
+    def remove_ignored(item)
+      index = @ignored.delete_item(item)
+      if index
+        # If we deleted a packet we need to recalculate the stale packets
+        if item[2].empty?
+          get_stale(true).each do |target, packet|
+            stale_packet(target, packet)
+          end
+        # We deleted an item so get all the current out of limit items
+        else
+          get_out_of_limits().each do |target, packet, item, state|
+            limits_change(target, packet, item, state)
+          end
+        end
+      end
+    rescue DRb::DRbConnError
+      # Do nothing
+    end
 
-      @tabbook = Qt::TabWidget.new(self)
-      setCentralWidget(@tabbook)
-      @widget = Qt::Widget.new
-      @layout = Qt::VBoxLayout.new(@widget)
+    # @return [Boolean] Whether there are any items being ignored
+    def ignored_items?
+      !@ignored.empty?
+    end
 
-      @monitored_state_text_field = Qt::LineEdit.new(self)
-      @monitored_state_text_field.setText('Stale')
-      @monitored_state_text_field.setAlignment(Qt::AlignCenter)
-      @monitored_state_text_field.setReadOnly(true)
-      @palette = Qt::Palette.new()
-      @palette.setColor(Qt::Palette::Base, Qt::Color.new(255,0,255))
-      @monitored_state_text_field.setPalette(@palette)
-      @state_label = Qt::Label.new('Monitored Limits State: ')
+    # @return [Symbol] The overall limits state. Returns :STALE if there
+    #   is no connection to the server.
+    def overall_state
+      get_overall_limits_state(@ignored)
+    rescue DRb::DRbConnError
+      :STALE
+    end
 
-      @monitored_state_frame = Qt::HBoxLayout.new
-      @monitored_state_frame.addWidget(@state_label)
-      @monitored_state_frame.addWidget(@monitored_state_text_field)
-      label = Qt::Label.new
-      filename = File.join(::Cosmos::PATH, 'data', 'spinner.gif')
-      movie = Qt::Movie.new(filename)
-      label.setMovie(movie)
-      movie.start
-      @monitored_state_frame.addWidget(label)
+    # Calls get_limits_event to process all the server limits events that
+    # were subscribed to. This method should be called continuously until
+    # it returns nil which indicates no more events.
+    #
+    # @return [Array<String,Symbol] String describing the event and a symbol
+    #   indicating how the event string should be colored (:BLACK, :BLUE,
+    #   :GREEN, :YELLOW, or :RED)
+    def process_events
+      result = nil
+      type = nil
+      data = nil
+      begin
+        reset() unless @initialized
+        # Get events non-blocking which is why we rescue ThreadError
+        type, data = get_limits_event(@queue_id, true)
+      rescue ThreadError
+        # Do nothing (nominal exception if there are no events)
+      rescue DRb::DRbConnError
+        # The server is down so request a reset
+        request_reset()
+      end
+      return result unless type
+
+      case type
+      when :LIMITS_CHANGE
+        # The most common event: target, packet, item, state
+        result = limits_change(data[0], data[1], data[2], data[4])
+
+      when :LIMITS_SET
+        # Check if the overall limits set changed. If so we need to reset
+        # to incorporate all the new limits.
+        if @limits_set != data
+          request_reset()
+          result = ["INFO: Limits Set Changed to: #{data}\n", :BLACK]
+        end
 
-      @monitored_state_frame.setAlignment(Qt::AlignTop)
+      when :LIMITS_SETTINGS
+        # The limits settings for an individual item changed. Set our local tool
+        # knowledge of the limits to match the server.
+        begin
+          System.limits.set(data[0], data[1], data[2], data[6], data[7], data[8], data[9], data[10], data[11], data[3], data[4], data[5])
+          result = ["INFO: Limits Settings Changed: #{data}\n", :BLACK]
+        rescue
+          # This can fail if we missed setting the DEFAULT limits set earlier
+        end
 
-      @scroll = Qt::ScrollArea.new
-      @scroll_widget = Qt::Widget.new
-      @scroll_layout = Qt::VBoxLayout.new(@scroll_widget)
-      @scroll_layout.setSizeConstraint(Qt::Layout::SetMinAndMaxSize)
+      when :STALE_PACKET
+        # A packet has gone stale: target, packet
+        result = stale_packet(data[0], data[1])
+      end
+      result
+    end
 
-      @scroll.setWidget(@scroll_widget)
+    # Update the values for all the out of limits items being tracked.
+    def update_values
+      # Reject any out of limits packets as they don't have values
+      items = @out_of_limits.reject {|item| item[2].nil? }
 
-      @layout.addLayout(@monitored_state_frame)
-      @layout.addWidget(@scroll)
+      values, limits_states, limits_settings, limits_set = get_tlm_values(items, :WITH_UNITS)
+      index = 0
+      items.each do |target_name, packet_name, item_name|
+        begin
+          # Update the limits settings each time we update values
+          # to stay in sync with the Server. Responding to :LIMITS_SETTINGS
+          # events isn't enough since we don't get those upon startup.
+          System.limits.set(target_name, packet_name, item_name,
+            limits_settings[index][0], limits_settings[index][1],
+            limits_settings[index][2], limits_settings[index][3],
+            limits_settings[index][4], limits_settings[index][5],
+            limits_set) if limits_settings[index]
+        rescue
+          # This can fail if we missed setting the DEFAULT limits set earlier
+        end
+        name = "#{target_name} #{packet_name} #{item_name}"
+        @update_item_callback.call(@items[name], values[index], limits_states[index], limits_set)
+        index += 1
+      end
+    rescue DRb::DRbConnError
+      # Do nothing
+    end
 
-      @log_output = Qt::PlainTextEdit.new
-      @log_output.setReadOnly(true)
-      @log_output.setMaximumBlockCount(100)
+    # Load a new configuration of ignored items and packets and reset
+    #
+    # @param config_file [String] Configuration file base name which will be
+    #   expanded to find a file in the config/tools/limits_monitor dir.
+    # @return [String] Message indicating success or fail
+    def open_config(filename)
+      return "" unless filename
+
+      unless Pathname.new(filename).absolute?
+        filename = File.join(::Cosmos::USERPATH, 'config', 'tools', 'limits_monitor', filename)
+      end
+      return "Configuration file #{filename} not found!" unless File.exist?(filename)
 
-      @tabbook.addTab(@widget, "Limits")
-      @tabbook.addTab(@log_output, "Log")
+      @ignored = []
+      begin
+        parser = ConfigParser.new
+        parser.parse_file(filename) do |keyword, params|
+          case keyword
+          # TODO: Eventually we can deprecate 'IGNORE' in favor
+          # of 'IGNORE_ITEM' now that we also have 'IGNORE_PACKET'
+          when 'IGNORE', 'IGNORE_ITEM'
+            @ignored << ([params[0], params[1], params[2]])
+          when 'IGNORE_PACKET'
+            @ignored << ([params[0], params[1], nil])
+          end
+        end
+        result = "#{filename} loaded. "
+        result << "Warning: Some items ignored" if ignored_items?
+      rescue => e
+        result = "Error loading configuration : #{e.message}"
+      end
+      # Since we may have loaded new ignored items we need to reset
+      request_reset()
+      result
+    end
 
-      # Process config file if present
-      process_config(File.join(::Cosmos::USERPATH, 'config', 'tools', 'limits_monitor', options.config_file)) if options.config_file
+    # Save the current configuration of ignored items and packets.
+    #
+    # @param config_file [String] Configuration file to save.
+    # @return [String] Message indicating success or fail
+    def save_config(filename)
+      begin
+        File.open(filename, "w") do |file|
+          @ignored.each do |target, pkt_name, item_name|
+            if item_name
+              file.puts("IGNORE_ITEM #{target} #{pkt_name} #{item_name}")
+            else
+              file.puts("IGNORE_PACKET #{target} #{pkt_name}")
+            end
+          end
+        end
+        result = "#{filename} saved"
+      rescue => e
+        result = "Error saving configuration : #{e.message}"
+      end
+      result
+    end
 
-      # Start thread to monitor limits
-      value_thread()
-      limits_thread()
-    end # initialize
+    private
 
-    # Slot to add items to the front panel when they are out of limits.
+    # Clear all tracked out of limits items and resubscribe to the server
+    # limits events. Clear the GUI and re-create all out of limits items
+    # and stale packets.
     #
-    # @param target_name [String] Target name of out of limits item.
-    # @param packet_name [String] Packet name of out of limits item.
-    # @param item_name [String] Item name of out of limits item.
-    def add_items(target_name, packet_name, item_name)
-      Qt.execute_in_main_thread(true) do
-        hlayout = Qt::HBoxLayout.new
-        hlayout.setSpacing(0)
-        hlayout.setContentsMargins(0,0,0,0)
-        @scroll_layout.addLayout(hlayout)
+    # Note this method can raise a DRb::DRbConnError error!
+    def reset
+      @items = {}
+      @out_of_limits = []
+      @limits_set = get_limits_set()
+      unsubscribe_limits_events(@queue_id) if @queue_id
+      @queue_id = subscribe_limits_events(100000)
+      @clear_items_callback.call
+      get_out_of_limits().each do |target, packet, item, state|
+        limits_change(target, packet, item, state)
+      end
+      get_stale(true).each do |target, packet|
+        stale_packet(target, packet)
+      end
 
-        item = [target_name, packet_name, item_name]
-        new_widget = LabelvaluelimitsbarWidget.new(hlayout, target_name, packet_name, item_name)
-        new_widget.set_setting('COLORBLIND', [@colorblind])
-        new_widget.process_settings
+      @initialized = true
+    end
 
-        ignore_button = Qt::PushButton.new('Ignore')
-        ignore_button.connect(SIGNAL('clicked()')) do
-          ignore_item(item)
-        end
+    # Process a limits_change event by recoloring out of limits events
+    # and creating a log message.
+    def limits_change(target_name, packet_name, item_name, state)
+      message = ''
+      color = :BLACK
+      item = [target_name, packet_name, item_name]
+
+      case state
+      when :YELLOW, :YELLOW_HIGH, :YELLOW_LOW
+        message << "WARN: "
+        color = :YELLOW
+        out_of_limit(item)
+      when :RED, :RED_HIGH, :RED_LOW
+        message << "ERROR: "
+        color = :RED
+        out_of_limit(item)
+      when :GREEN, :GREEN_HIGH, :GREEN_LOW
+        message << "INFO: "
+        color = :GREEN
+      when :BLUE
+        message << "INFO: "
+        color = :BLUE
+      end
+      value = tlm(target_name, packet_name, item_name)
+      message << "#{target_name} #{packet_name} #{item_name} = #{value} is #{state}\n"
+      [message, color]
+    end
 
-        hlayout.addWidget(ignore_button)
+    # Record the stale packet and generate a log message
+    def stale_packet(target_name, packet_name)
+      out_of_limit([target_name, packet_name, nil])
+      return ["INFO: Packet #{target_name} #{packet_name} is STALE\n", :BLACK]
+    end
 
-        @widget_hframes << hlayout
-        @new_widgets << new_widget
-        @widgets << new_widget
-        @buttons << ignore_button
+    # Record an out of limits item and call the new item callback.
+    # Existing out of limits and ignored items are not recorded.
+    def out_of_limit(item)
+      unless (@out_of_limits.includes_item?(item) || @ignored.includes_item?(item) || UNKNOWN_ARRAY.includes_item?(item))
+        @out_of_limits << item
+        @items["#{item[0]} #{item[1]} #{item[2]}"] = @new_item_callback.call(*item)
       end
     end
+  end
 
-    # Slot to update the log panel with limits change information.
-    #
-    # @param to_add [String] Text string with information about which item is out of
-    #   limits, what its value is, and what limit was broken (red_low, yellow_low, etc.)
-    # @param color [int] Integer representing color of text to add.
-    def update_log(to_add, color)
-      return if @cancel_thread
-      Qt.execute_in_main_thread(true) do
-        @tf = Qt::TextCharFormat.new
-        case color
-        when 0
-          brush = Cosmos.getBrush(Cosmos::GREEN)
-        when 1
-          brush = Cosmos.getBrush(Cosmos::YELLOW)
-        when 2
-          brush = Cosmos.getBrush(Cosmos::RED)
-        when 3
-          brush = Cosmos.getBrush(Cosmos::BLUE)
+  # The LimitsMonitor application displays all the out of limits items
+  # encountered by the COSMOS server. It provides the ability to ignore and
+  # restore limits as well as logs all limits events.
+  class LimitsMonitor < QtTool
+    # LimitsWidget displays either a stale packet using the Label widget
+    # or more commonly an out of limits item using the Labelvaluelimitsbar
+    # Widget.
+    class LimitsWidget < Qt::Widget
+      # @return [Widget] The widget which displays the value
+      attr_accessor :value
+
+      # @parent [Qt::Widget] Parent widget (the LimitsMonitor tool)
+      # @target_name [String] Target name
+      # @packet_name [String] Packet name
+      # @item_name [String] Telemetry item name (nil for stale packets)
+      def initialize(parent, target_name, packet_name, item_name)
+        super(parent)
+        @layout = Qt::HBoxLayout.new
+        @layout.setSpacing(0)
+        @layout.setContentsMargins(0,0,0,0)
+        setLayout(@layout)
+
+        item = [target_name, packet_name, item_name]
+        if item_name
+          @value = LabelvaluelimitsbarWidget.new(@layout, target_name, packet_name, item_name)
+          @value.set_setting('COLORBLIND', [@colorblind])
+          @value.process_settings
         else
-          brush = Cosmos.getBrush(Cosmos::BLACK)
+          @value = LabelWidget.new(layout, "#{target_name} #{packet_name} is STALE")
+        end
+
+        @ignore_button = Qt::PushButton.new('Ignore')
+        @ignore_button.connect(SIGNAL('clicked()')) { parent.ignore(self, item) }
+        @layout.addWidget(@ignore_button)
+      end
+
+      # Update the widget's value, limits_state, and limits_set
+      def set_values(value, limits_state, limits_set)
+        if LabelvaluelimitsbarWidget === @value
+          @value.value = value
+          @value.limits_state = limits_state
+          @value.limits_set = limits_set
+        end
+      end
+
+      # Enable or disable Colorblind mode
+      def set_colorblind(enabled)
+        if LabelvaluelimitsbarWidget === @value
+          @value.set_setting('COLORBLIND', [enabled])
+          @value.process_settings
         end
-        @tf.setForeground(brush)
-        @log_output.setCurrentCharFormat(@tf)
-        @log_output.appendPlainText(to_add.chomp)
-        @tf.dispose
+      end
+
+      # Dispose of the widget
+      def dispose
+        @ignore_button.dispose
+        @value.dispose
+        @layout.dispose
+        super()
       end
     end
 
-    # Sets up the menu bar with selectable options and the signal/slot combinations
-    # for when those options are selected.
-    def initialize_menus
-      # File Menu
-      @file_menu = menuBar.addMenu(tr('&File'))
+    # Create the main application GUI. Start the limits thread which responds to
+    # asynchronous limits events from the server and the value thread which
+    # polls the server at 1Hz for the out of limits items values.
+    #
+    # @param options [Options] Contains the options for the window.
+    def initialize(options)
+      super(options)
+      Cosmos.load_cosmos_icon("limits_monitor.png")
+
+      @cancel_thread = false
+      @limits_sleeper = Sleeper.new
+      @value_sleeper = Sleeper.new
+
+      initialize_actions()
+      initialize_menus()
+      initialize_central_widget()
+      complete_initialize()
+
+      @limits_items = LimitsItems.new(
+        method(:new_gui_item), method(:update_gui_item), method(:clear_gui_items))
+      result = @limits_items.open_config(options.config_file)
+      statusBar.showMessage(tr(result))
+
+      limits_thread()
+      value_thread()
+    end
+
+    # Initialize all the actions in the application Menu
+    def initialize_actions
+      super
 
       @options_action = Qt::Action.new(tr('O&ptions'), self)
       @options_action.statusTip = tr('Open the options dialog')
-      connect(@options_action, SIGNAL('triggered()'), self, SLOT('options()'))
+      @options_action.connect(SIGNAL('triggered()')) { show_options_dialog() }
 
       @reset_action = Qt::Action.new(tr('&Reset'), self)
       @reset_action_keyseq = Qt::KeySequence.new(tr('Ctrl+R'))
       @reset_action.shortcut = @reset_action_keyseq
       @reset_action.statusTip = tr('Reset connection and clear all items. This does not modify the ignored items.')
-      connect(@reset_action, SIGNAL('triggered()'), self, SLOT('reset()'))
+      @reset_action.connect(SIGNAL('triggered()')) { @limits_items.request_reset() }
 
       @open_ignored_action = Qt::Action.new(Cosmos.get_icon('open.png'),
                                             tr('&Open Config'), self)
       @open_ignored_action_keyseq = Qt::KeySequence.new(tr('Ctrl+O'))
       @open_ignored_action.shortcut = @open_ignored_action_keyseq
       @open_ignored_action.statusTip = tr('Open ignored telemetry items configuration file')
-      connect(@open_ignored_action, SIGNAL('triggered()'), self, SLOT('handle_open_ignored_items()'))
+      @open_ignored_action.connect(SIGNAL('triggered()')) { open_config_file() }
 
       @save_ignored_action = Qt::Action.new(Cosmos.get_icon('save.png'),
                                             tr('&Save Config'), self)
       @save_ignored_action_keyseq = Qt::KeySequence.new(tr('Ctrl+S'))
       @save_ignored_action.shortcut = @save_ignored_action_keyseq
       @save_ignored_action.statusTip = tr('Save all ignored telemetry items in a configuration file')
-      connect(@save_ignored_action, SIGNAL('triggered()'), self, SLOT('handle_save_ignored_items()'))
+      @save_ignored_action.connect(SIGNAL('triggered()')) { save_config_file() }
 
-      @clear_ignored_action = Qt::Action.new(tr('&Clear Ignored'), self)
-      @clear_ignored_action.statusTip = tr('Clear all ignored telemetry items so they become monitored')
-      connect(@clear_ignored_action, SIGNAL('triggered()'), self, SLOT('handle_clear_ignored_items()'))
-
-      @view_ignored_action = Qt::Action.new(tr('&View Ignored'), self)
-      @view_ignored_action.statusTip = tr('View the ignored telemetry items list')
-      connect(@view_ignored_action, SIGNAL('triggered()'), self, SLOT('handle_view_ignored_items()'))
+      @edit_ignored_action = Qt::Action.new(tr('&Edit Ignored'), self)
+      @edit_ignored_action_keyseq = Qt::KeySequence.new(tr('Ctrl+E'))
+      @edit_ignored_action.shortcut = @edit_ignored_action_keyseq
+      @edit_ignored_action.statusTip = tr('Edit the ignored telemetry items list')
+      @edit_ignored_action.connect(SIGNAL('triggered()')) { edit_ignored_items() }
+    end
 
+    # Initialize the application menu bar options
+    def initialize_menus
+      @file_menu = menuBar.addMenu(tr('&File'))
       @file_menu.addAction(@open_ignored_action)
       @file_menu.addAction(@save_ignored_action)
-      @file_menu.addAction(@clear_ignored_action)
-      @file_menu.addAction(@view_ignored_action)
+      @file_menu.addAction(@edit_ignored_action)
       @file_menu.addSeparator()
       @file_menu.addAction(@reset_action)
       @file_menu.addAction(@options_action)
@@ -253,29 +481,67 @@ module Cosmos
       initialize_help_menu()
     end
 
-    # Slot to handle the options menu item when selected.
-    def options
+    # Layout the main GUI tab widget with a view of all the out of limits items
+    # in one tab and a log tab showing all limits events.
+    def initialize_central_widget
+      @tabbook = Qt::TabWidget.new(self)
+      setCentralWidget(@tabbook)
+      @widget = Qt::Widget.new
+      @layout = Qt::VBoxLayout.new(@widget)
+
+      @monitored_state_text_field = Qt::LineEdit.new(self)
+      @monitored_state_text_field.setText('Stale')
+      @monitored_state_text_field.setAlignment(Qt::AlignCenter)
+      @monitored_state_text_field.setReadOnly(true)
+      @palette = Qt::Palette.new()
+      @palette.setColor(Qt::Palette::Base, Qt::Color.new(255,0,255))
+      @monitored_state_text_field.setPalette(@palette)
+      @state_label = Qt::Label.new('Monitored Limits State: ')
+
+      @monitored_state_frame = Qt::HBoxLayout.new
+      @monitored_state_frame.addWidget(@state_label)
+      @monitored_state_frame.addWidget(@monitored_state_text_field)
+      label = Qt::Label.new
+      filename = File.join(::Cosmos::PATH, 'data', 'spinner.gif')
+      movie = Qt::Movie.new(filename)
+      label.setMovie(movie)
+      movie.start
+      @monitored_state_frame.addWidget(label)
+      @monitored_state_frame.setAlignment(Qt::AlignTop)
+      @layout.addLayout(@monitored_state_frame)
+
+      @scroll = Qt::ScrollArea.new
+      @scroll_widget = Qt::Widget.new
+      @scroll.setWidget(@scroll_widget)
+      @scroll_layout = Qt::VBoxLayout.new(@scroll_widget)
+      @scroll_layout.setSizeConstraint(Qt::Layout::SetMinAndMaxSize)
+      @layout.addWidget(@scroll)
+
+      @log_output = Qt::PlainTextEdit.new
+      @log_output.setReadOnly(true)
+      @log_output.setMaximumBlockCount(100)
+
+      @tabbook.addTab(@widget, "Limits")
+      @tabbook.addTab(@log_output, "Log")
+    end
+
+    def show_options_dialog
       Qt::Dialog.new(self) do |dialog|
         dialog.setWindowTitle('Options')
 
         colorblind_box = Qt::CheckBox.new('Colorblind Mode Enabled', self)
-        if (@colorblind)
-          colorblind_box.setCheckState(Qt::Checked)
-        end
+        colorblind_box.setCheckState(Qt::Checked) if @colorblind
 
         ok = Qt::PushButton.new('Ok') do
           connect(SIGNAL('clicked()')) { dialog.accept }
         end
-
         cancel = Qt::PushButton.new('Cancel') do
           connect(SIGNAL('clicked()')) { dialog.reject }
         end
-
         buttons = Qt::HBoxLayout.new do
           addWidget(ok)
           addWidget(cancel)
         end
-
         dialog.layout = Qt::VBoxLayout.new do
           addWidget(colorblind_box)
           addLayout(buttons)
@@ -288,471 +554,247 @@ module Cosmos
           else
             @colorblind = false
           end
-          @widgets.each do |widget|
-            widget.set_setting('COLORBLIND', [@colorblind])
-            widget.process_settings
+          (0...@scroll_layout.count).each do |index|
+            @scroll_layout.itemAt(index).widget.set_colorblind(@colorblind)
           end
         end
         dialog.dispose
       end
     end
 
-    # Slot to handle the resent menu item when selected.
-    def reset
-      @initialized = false
+    # @return [String] Fully qualified path to the configuration file
+    def config_path
+      # If the config file has been set then just return it
+      return @filename if @filename
+      # This is the default path to the configuration files
+      File.join(::Cosmos::USERPATH, 'config', 'tools', 'limits_monitor', 'limits_monitor.txt')
     end
 
-    # Sets up the thread to monitor for broken limits and add them to the log and
-    # front panel when found.
-    def limits_thread
-      @limits_thread = Thread.new do
-        begin
-          while true
-            break if @cancel_thread
-            begin
-              initialized = nil
-              break if @cancel_thread
-              Qt.execute_in_main_thread(true) do
-                initialized = @initialized
-              end
-              unless initialized
-                @limits_set = nil
-                break if @cancel_thread
-                Qt.execute_in_main_thread(true) do
-                  @out_of_limits_items = []
-                end
-                unsubscribe_limits_events(@queue_id) if @queue_id
-                @queue_id = nil
-
-                handle_reset()
-
-                # Get the current limits set
-                @limits_set = get_limits_set()
-
-                # Subscribe to limits notifications
-                @queue_id = subscribe_limits_events(100000)
-
-                # Get initial list of out of limits items
-                items = get_out_of_limits()
-                unless items.empty?
-                  break if @cancel_thread
-                  Qt.execute_in_main_thread(true) do
-                    items.each do |item|
-                      unless @ignored_items.includes_item?(item) and !@items.includes_item?(item)
-                        @new_items << [item[0], item[1], item[2]]
-                        @out_of_limits_items << [item[0], item[1], item[2]]
-                      end
-                    end
-                    handle_new_items()
-                  end
-                end
-
-                break if @cancel_thread
-                Qt.execute_in_main_thread(true) do
-                  @initialized = true
-                  if @ignored_items.empty?
-                    statusBar.showMessage(tr(""))
-                  else
-                    statusBar.showMessage('Warning: Some Telemetry Items are Ignored')
-                  end
-                end
-
-              end
-
-              begin
-                break if @cancel_thread
-                type, data = get_limits_event(@queue_id, true)
-                break if @cancel_thread
-              rescue ThreadError
-                break if @cancel_thread
-                break if @limits_sleeper.sleep(1)
-                next
-              end
-
-              break if @cancel_thread
-
-              case type
-              when :LIMITS_CHANGE
-                item = [data[0], data[1], data[2]]
-                if data[4] != :GREEN and data[4] != :GREEN_HIGH and data[4] != :GREEN_LOW and data[4] != :BLUE and data[4] != nil
-                  case data[4]
-                  when :YELLOW, :YELLOW_HIGH, :YELLOW_LOW
-                    to_print = Time.now.formatted << '  ' << "WARN: #{data[0]} #{data[1]} #{data[2]} = #{tlm(data[0], data[1], data[2])} is #{data[4]}\n"
-                    update_log(to_print, 1)
-                  when :RED, :RED_HIGH, :RED_LOW
-                    to_print = Time.now.formatted << '  ' << "ERROR: #{data[0]} #{data[1]} #{data[2]} = #{tlm(data[0], data[1], data[2])} is #{data[4]}\n"
-                    update_log(to_print, 2)
-                  end
-
-                  # Limits changed to non-green
-                  unless @out_of_limits_items.includes_item?(item) or @ignored_items.includes_item?(item)
-                    @out_of_limits_items << item
-                    @new_items << item
-                    handle_new_items()
-                  end
-                elsif data[4] == :GREEN or data[4] == :GREEN_HIGH or data[4] == :GREEN_LOW or data[4] == :BLUE
-                  to_print = Time.now.formatted << '  ' << "INFO: #{data[0]} #{data[1]} #{data[2]} = #{tlm(data[0], data[1], data[2])} returned to GREEN\n"
-
-                  if data[4] == :BLUE
-                    update_log(to_print, 3)
-                  else
-                    update_log(to_print, 0)
-                  end
-                end
-
-              when :LIMITS_SET
-                if @limits_set != data
-                  break if @cancel_thread
-                  Qt.execute_in_main_thread(true) do
-                    statusBar.showMessage('Limits Set Changed - Reseting')
-                    @initialized = false
-                    to_print = Time.now.formatted << '  ' << "INFO: Limits Set Changed to: #{data}\n"
-                    update_log(to_print, 4)
-                  end
-                  break if @cancel_thread
-                end
-
-              when :LIMITS_SETTINGS
-                begin
-                  System.limits.set(data[0], data[1], data[2], data[6], data[7], data[8], data[9], data[10], data[11], data[3], data[4], data[5])
-                  break if @cancel_thread
-                  Qt.execute_in_main_thread(true) do
-                    statusBar.showMessage('Limits Settings Changed - Reseting')
-                    @initialized = false
-                    to_print = Time.now.formatted << '  ' << "INFO: Limits Settings Changed: #{data}\n"
-                    update_log(to_print, 4)
-                  end
-                  break if @cancel_thread
-                rescue
-                  # This can fail if we missed setting the DEFAULT limits set earlier - Oh well
-                end
-              end
-
-            rescue DRb::DRbConnError
-              break if @cancel_thread
-              @queue_id = nil
-              break if @cancel_thread
-              Qt.execute_in_main_thread(true) do
-                statusBar.showMessage('Error Connecting to Command and Telemetry Server - Reseting')
-                @initialized = false
-              end
-              break if @cancel_thread
-              break if @limits_sleeper.sleep(1)
-            end
-          end # loop
-        rescue Exception => error
-          Cosmos.handle_fatal_exception(error)
-        end
+    # Opens the configuration file and loads the ignored items
+    def open_config_file
+      filename = Qt::FileDialog::getOpenFileName(self,
+        "Open Configuration File", config_path())
+      unless filename.nil? || filename.empty?
+        result = @limits_items.open_config(filename)
+        statusBar.showMessage(tr(result))
       end
     end
 
-    # Sets up the thread to monitor the limits values and update them when they
-    # change, as well as updating the status bar at the top of the front panel.
-    def value_thread
-      @value_thread = Thread.new do
-        begin
-          while true
-            break if @cancel_thread
-            unless @items.empty?
-              Qt.execute_in_main_thread(true) do
-                begin
-                  # Gather items for  widgets
-                  values, limits_states, limits_settings, limits_set = get_tlm_values(@items, :WITH_UNITS)
-                  index = 0
-                  @items.each do |target_name, packet_name, item_name|
-                    begin
-                      System.limits.set(target_name, packet_name, item_name, limits_settings[index][0], limits_settings[index][1], limits_settings[index][2], limits_settings[index][3], limits_settings[index][4], limits_settings[index][5], limits_set) if limits_settings[index]
-                    rescue
-                      # This can fail if we missed setting the DEFAULT limits set earlier - Oh well
-                    end
-                    index += 1
-                  end
-
-                  # Handle change in limits set
-                  if limits_set != @value_limits_set
-                    @value_limits_set = limits_set
-                    @widgets.each do |widget|
-                      widget.limits_set = @value_limits_set
-                    end
-                  end
-
-                  # Update widgets with values and limits_states
-                  @overall_limits_state = :STALE
-                  (0..(values.length - 1)).each do |widget_index|
-                    limits_state = limits_states[widget_index]
-                    @widgets[widget_index].limits_state = limits_state
-                    @widgets[widget_index].value = values[widget_index]
-                  end
-
-                  # Update overall limits state
-                  modify_overall_limits_state(get_overall_limits_state(@ignored_items))
-                  update_overall_limits_state()
-                rescue DRb::DRbConnError
-                  # Do nothing
-                end
-              end
-            else
-              @overall_limits_state = :STALE
-              break if @cancel_thread
-              Qt.execute_in_main_thread(true) do
-                begin
-                  modify_overall_limits_state(get_overall_limits_state(@ignored_items))
-                rescue DRb::DRbConnError
-                  # Do nothing
-                end
-                update_overall_limits_state()
-              end
-            end
-
-            # Sleep until next polling period
-            break if @value_sleeper.sleep(1)
-          end
-        rescue Exception => error
-          Cosmos.handle_fatal_exception(error)
-        end
+    # Saves the ignored items to the configuration file
+    def save_config_file
+      filename = Qt::FileDialog.getSaveFileName(self,
+        'Save As...', config_path(), 'Configuration Files (*.txt)')
+      unless filename.nil? || filename.empty?
+        result = @limits_items.save_config(filename)
+        statusBar.showMessage(tr(result))
+        @filename = filename
       end
     end
 
-    # Checks for the current worst limits state.
-    #
-    # @param limits_state [Symbol] State of the current limit being checked.
-    def modify_overall_limits_state(limits_state)
-      case @overall_limits_state
-      when :STALE
-        @overall_limits_state = limits_state
-      when :BLUE
-        if limits_state != nil and limits_state != :STALE
-          @overall_limits_state = limits_state
-        end
-      when :GREEN, :GREEN_HIGH, :GREEN_LOW
-        if limits_state != nil and limits_state != :STALE and limits_state != :BLUE
-          @overall_limits_state = limits_state
-        end
-      when :YELLOW, :YELLOW_HIGH, :YELLOW_LOW
-        if limits_state == :RED or limits_state == :RED_HIGH or limits_state == :RED_LOW
-          @overall_limits_state = limits_state
-        end
-      end
-    end
-
-    # Changes the limits state on the status bar at the top of the screen.
-    def update_overall_limits_state
-      text = ''
-      case @overall_limits_state
-      when :STALE
-        palette = Cosmos.getPalette(Cosmos.getColor(0, 0, 0), Cosmos.getColor(255,0,255))
-        @monitored_state_text_field.setPalette(palette)
-        text = 'Stale'
-      when :GREEN, :GREEN_HIGH, :GREEN_LOW
-        palette = Cosmos.getPalette(Cosmos.getColor(0, 0, 0), Cosmos.getColor(0,255,0))
-        @monitored_state_text_field.setPalette(palette)
-        text = 'Green'
-      when :YELLOW, :YELLOW_HIGH, :YELLOW_LOW
-        palette = Cosmos.getPalette(Cosmos.getColor(0, 0, 0), Cosmos.getColor(255,255,0))
-        @monitored_state_text_field.setPalette(palette)
-        text = 'Yellow'
-      when :RED, :RED_HIGH, :RED_LOW
-        palette = Cosmos.getPalette(Cosmos.getColor(0, 0, 0), Cosmos.getColor(255,0,0))
-        @monitored_state_text_field.setPalette(palette)
-        text = 'Red'
-      when :BLUE
-        palette = Cosmos.getPalette(Cosmos.getColor(0, 0, 0), Cosmos.getColor(0,0,255))
-        @monitored_state_text_field.setPalette(palette)
-        text = 'Blue'
-      end
-      text << ' - Some Items Ignored' unless @ignored_items.empty?
-      @monitored_state_text_field.text = text
-    end
-
-    # Slot to handle when the clear ignored items menu option is selected.
-    def handle_clear_ignored_items
-      @ignored_items.clear
-      @initialized = false
-      statusBar.showMessage('')
-    end
-
-    # Slot to handle when the view ignored items menu option is selected.
-    def handle_view_ignored_items
-      # Turn Command into scripting text string
-      string = ''
-      @ignored_items.each do |item|
-        string << "#{item[0]} #{item[1]} #{item[2]}\n"
+    # Opens a dialog to allow the user to remove ignored items
+    def edit_ignored_items
+      items = []
+      index = 0
+      @limits_items.ignored.each do |target_name, packet_name, item_name|
+        item = Qt::ListWidgetItem.new("#{target_name} #{packet_name} #{item_name}")
+        item.setData(Qt::UserRole, Qt::Variant.new(@limits_items.ignored[index]))
+        items << item
+        index += 1
       end
 
-      # Show Dialog box with text displaying ignored items
       Qt::Dialog.new(self) do |dialog|
         dialog.setWindowTitle('Ignored Telemetry Items')
-        text = Qt::PlainTextEdit.new
-        text.setReadOnly(true)
-        text.setPlainText(string) if string
+        list = Qt::ListWidget.new
+        list.setFocus()
+        # Allow multiple sections
+        list.setSelectionMode(Qt::AbstractItemView::ExtendedSelection)
+        items.each {|item| list.addItem(item) }
+
+        shortcut = Qt::Shortcut.new(Qt::KeySequence.new(Qt::KeySequence::Delete), list)
+        list.connect(shortcut, SIGNAL('activated()')) do
+          items = list.selectedItems()
+          (0...items.length).each do |index|
+            @limits_items.remove_ignored(items[index].data(Qt::UserRole).value)
+          end
+          list.remove_selected_items
+          list.setCurrentRow(0)
+        end
+        # Preselect the first row (works if list is empty) so the keyboard
+        # works instantly without having to click the list
+        list.setCurrentRow(0)
 
         ok = Qt::PushButton.new('Ok') do
           connect(SIGNAL('clicked()')) { dialog.done(0) }
         end
-
-        dialog.layout = Qt::VBoxLayout.new do
-          addWidget(text)
+        remove = Qt::PushButton.new('Remove Selected') do
+          connect(SIGNAL('clicked()')) { shortcut.activated() }
+        end
+        button_layout = Qt::HBoxLayout.new do
           addWidget(ok)
+          addStretch(1)
+          addWidget(remove)
+        end
+        dialog.layout = Qt::VBoxLayout.new do
+          addWidget(list)
+          addLayout(button_layout)
         end
-
         dialog.resize(500, 200)
         dialog.exec
         dialog.dispose
       end
     end
 
-    # Slot to handle when the save ignored items menu option is selected.
-    def handle_save_ignored_items
-      if @ignored_filename
-        filename = Qt::FileDialog.getSaveFileName(self, 'Save As...', @ignored_filename, 'Configuration Files (*.txt)')
-      else
-        filename = Qt::FileDialog.getSaveFileName(self, 'Save As...', File.join(::Cosmos::USERPATH, 'config', 'tools', 'limits_monitor', 'limits_monitor.txt'), 'Configuration Files (*.txt)')
-      end
-      unless filename.nil? or filename.empty?
-        begin
-          File.open(filename, "w") do |file|
-            @ignored_items.each do |target, pkt_name, item_name|
-              file.puts("IGNORE #{target} #{pkt_name} #{item_name}")
-            end
+    # Thread to monitor for broken limits and add them to the log and
+    # front panel when found.
+    def limits_thread
+      result = nil
+      color = nil
+      @limits_thread = Thread.new do
+        while true
+          break if @cancel_thread
+          Qt.execute_in_main_thread(true) do
+            result, color = @limits_items.process_events()
+          end
+          if result
+            update_log(result, color)
+          else
+            break if @limits_sleeper.sleep(1)
           end
-          statusBar.showMessage("#{filename} saved")
-        rescue => e
-          statusBar.showMessage("Error Saving Configuration : #{e.message}")
         end
       end
+    rescue Exception => error
+      Cosmos.handle_fatal_exception(error)
     end
 
-    # Slot to handle when the load ignored items menu option is selected.
-    def handle_open_ignored_items
-      if @ignored_filename
-        filename = Qt::FileDialog::getOpenFileName(self, "Open Configuration File", @ignored_filename)
-      else
-        filename = Qt::FileDialog::getOpenFileName(self, "Open Configuration File", File.join(::Cosmos::USERPATH, 'config', 'tools', 'limits_monitor', 'limits_monitor.txt'))
-      end
-      unless filename.nil? or filename.empty?
-        process_config(filename)
+    # Add new out of limit item or stale packet
+    #
+    # @param target_name [String] Target name of out of limits item.
+    # @param packet_name [String] Packet name of out of limits item.
+    # @param item_name [String] Item name of out of limits item or nil
+    #   if its a stale packet
+    # @return [Qt::Widget] The new widget that was created
+    def new_gui_item(target_name, packet_name, item_name)
+      widget = nil
+      Qt.execute_in_main_thread(true) do
+        widget = LimitsWidget.new(self, target_name, packet_name, item_name)
+        @scroll_layout.addWidget(widget)
       end
+      widget
     end
 
-    # Handle config file if present.
+    # Update out of limit item with a values
     #
-    # @param filename [String] Filename for the config file if present.
-    def process_config(filename)
-      @initialized = false
-      @ignored_items = []
-
-      begin
-        parser = ConfigParser.new
-        parser.parse_file(filename) do |keyword, params|
-          case keyword
-          when 'IGNORE'
-            ignore_item([params[0], params[1], params[2]])
-          end
-        end
-        statusBar.showMessage("#{filename} loaded")
-      rescue => e
-        statusBar.showMessage("Error Loading Configuration : #{e.message}")
+    # @param target_name [String] Target name of out of limits item.
+    # @param packet_name [String] Packet name of out of limits item.
+    # @param item_name [String] Item name of out of limits item or nil
+    #   if its a stale packet
+    def update_gui_item(widget, value, limits_state, limits_set)
+      Qt.execute_in_main_thread(true) do
+        widget.set_values(value, limits_state, limits_set) if widget
       end
     end
 
+    # Reset the GUI by clearing all items
+    def clear_gui_items
+      Qt.execute_in_main_thread(true) { @scroll_layout.removeAll }
+    end
+
     # Update front panel to ignore an item when the corresponding button is pressed.
     #
-    # @param item [Array] Array containing the target, packet, and item name of the
-    #   item to ignore.
-    def ignore_item(item)
+    # @param item [Array<String,String,String] Array containing the target name,
+    #   packet name, and item name of the item to ignore.
+    def ignore(widget, item)
+      @limits_items.ignore(item)
       Qt.execute_in_main_thread(true) do
-        @ignored_items << item
-        delete_index = @items.delete_item(item)
-        if delete_index
-          hframe_to_dispose = @widget_hframes[delete_index]
-          widget_to_dispose = @widgets[delete_index]
-          button_to_dispose = @buttons[delete_index]
-          @widgets.delete_at(delete_index)
-          @buttons.delete_at(delete_index)
-          @widget_hframes.delete_at(delete_index)
-          @scroll_layout.removeItem(hframe_to_dispose)
-          widget_to_dispose.dispose
-          button_to_dispose.dispose
-          hframe_to_dispose.dispose
-          @scroll.repaint
-        end
+        @scroll_layout.removeWidget(widget)
+        widget.dispose
+        @scroll_widget.adjustSize
         statusBar.showMessage('Warning: Some Telemetry Items are Ignored')
       end
     end
 
-    # Process any new items that become out of limits.
-    def handle_new_items
-      @new_widgets = []
-
+    # Update the log panel with limits change information.
+    #
+    # @param message [String] Text string with information about which item is out of
+    #   limits, what its value is, and what limit was broken (red_low, yellow_low, etc.)
+    # @param color [Symbol] Color of text to add.
+    def update_log(message, color)
+      return if @cancel_thread
       Qt.execute_in_main_thread(true) do
-        @new_items.each do |target, pkt_name, item_name|
-          # Create widgets for new items
-          add_items(target, pkt_name, item_name)
+        @tf ||= Qt::TextCharFormat.new
+        case color
+        when :GREEN
+          brush = Cosmos.getBrush(Cosmos::GREEN)
+        when :YELLOW
+          brush = Cosmos.getBrush(Cosmos::YELLOW)
+        when :RED
+          brush = Cosmos.getBrush(Cosmos::RED)
+        when :BLUE
+          brush = Cosmos.getBrush(Cosmos::BLUE)
+        else # :BLACK
+          brush = Cosmos.getBrush(Cosmos::BLACK)
         end
+        @tf.setForeground(brush)
+        @log_output.setCurrentCharFormat(@tf)
+        @log_output.appendPlainText(message.chomp)
       end
+    end
 
-      # Set initial values
-
-      Qt.execute_in_main_thread(true) do
-        begin
-          values, limits_states, limits_settings, limits_set = get_tlm_values(@new_items, :WITH_UNITS)
-          index = 0
-          @new_items.each do |target_name, packet_name, item_name|
-            begin
-              System.limits.set(target_name, packet_name, item_name, limits_settings[index][0], limits_settings[index][1], limits_settings[index][2], limits_settings[index][3], limits_settings[index][4], limits_settings[index][5], limits_set) if limits_settings[index]
-            rescue
-              # This can fail if we missed setting the DEFAULT limits set earlier - Oh well
+    # Thread to request the out of limits values and update them at 1Hz.
+    # Also updates the status bar at the top of the front panel indicating
+    # the overall limits value of the system.
+    def value_thread
+      @value_thread = Thread.new do
+        while true
+          break if @cancel_thread
+          Qt.execute_in_main_thread(true) do
+            if @limits_items.initialized
+              @limits_items.update_values()
+              update_overall_limits_state(@limits_items.overall_state())
+            else
+              # Set the status bar message to expire in 2s since this runs at 1Hz
+              statusBar.showMessage('Error Connecting to Command and Telemetry Server', 2000)
             end
-            index += 1
-          end
-          index = 0
-
-          @new_widgets.each do |widget|
-            limits_state = limits_states[index]
-            widget.limits_set = limits_set
-            widget.limits_state = limits_state
-            widget.value = values[index]
-            index += 1
-            modify_overall_limits_state(limits_state)
-          end
-
-          update_overall_limits_state()
-
-          @new_items.each do |item|
-            @items << item
           end
-          @new_items = []
-        rescue DRb::DRbConnError
-          statusBar.showMessage('Error Connecting to Command and Telemetry Server - Reseting')
-          @initialized = false
+          break if @value_sleeper.sleep(1)
         end
       end
+    rescue Exception => error
+      Cosmos.handle_fatal_exception(error)
     end
 
-    # Reset front panel and log when the reset menu option is selected.
-    def handle_reset
+    # Changes the limits state on the status bar at the top of the screen.
+    def update_overall_limits_state(state)
       Qt.execute_in_main_thread(true) do
-        @widgets.each {|widget| widget.dispose}
-        @buttons.each {|button| button.dispose}
-        @widget_hframes.each do |hframe|
-          @scroll_layout.removeItem(hframe)
-          hframe.dispose
+        text = ''
+        case state
+        when :STALE
+          palette = Cosmos.getPalette(Cosmos.getColor(0, 0, 0), Cosmos.getColor(255,0,255))
+          @monitored_state_text_field.setPalette(palette)
+          text = 'Stale'
+        when :GREEN, :GREEN_HIGH, :GREEN_LOW
+          palette = Cosmos.getPalette(Cosmos.getColor(0, 0, 0), Cosmos.getColor(0,255,0))
+          @monitored_state_text_field.setPalette(palette)
+          text = 'Green'
+        when :YELLOW, :YELLOW_HIGH, :YELLOW_LOW
+          palette = Cosmos.getPalette(Cosmos.getColor(0, 0, 0), Cosmos.getColor(255,255,0))
+          @monitored_state_text_field.setPalette(palette)
+          text = 'Yellow'
+        when :RED, :RED_HIGH, :RED_LOW
+          palette = Cosmos.getPalette(Cosmos.getColor(0, 0, 0), Cosmos.getColor(255,0,0))
+          @monitored_state_text_field.setPalette(palette)
+          text = 'Red'
+        when :BLUE
+          palette = Cosmos.getPalette(Cosmos.getColor(0, 0, 0), Cosmos.getColor(0,0,255))
+          @monitored_state_text_field.setPalette(palette)
+          text = 'Blue'
         end
-        @scroll.repaint
-
-        @widgets = []
-        @new_widgets = []
-        @buttons = []
-        @widget_hframes = []
-        @items = []
-        @value_limits_set = :DEFAULT
-
-        @overall_limits_state = :STALE
-        update_overall_limits_state()
+        text << ' - Some Items Ignored' if @limits_items.ignored_items?
+        @monitored_state_text_field.text = text
       end
     end
 
-    # Handle the window closing.
+    # Handle the window closing
     def closeEvent(event)
       @cancel_thread = true
       @value_sleeper.cancel
@@ -792,5 +834,4 @@ module Cosmos
     end
 
   end # class LimitsMonitor
-
 end # module Cosmos