cosmos 4.0.3-java

data/lib/cosmos/tools/tlm_grapher/tabbed_plots_tool/tabbed_plots_logfile_thread.rb

@@ -0,0 +1,114 @@
+# 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'
+
+module Cosmos
+
+  # Thread used to gather telemetry from log file(s) and process it using a TabbedPlotsDefinition
+  class TabbedPlotsLogfileThread
+    # Number of packets between updating the progress bar
+    PROGRESS_UPDATE_PACKET_COUNT = 100
+
+    # Array of exceptions that occurred processing the log file
+    attr_reader :errors
+
+    # Create a new TabbedPlotsLogfileThread
+    def initialize(log_files, packet_log_reader, tabbed_plots_config, progress_dialog = nil, time_start = nil, time_end = nil)
+      super()
+      @packet_log_reader = packet_log_reader
+      @tabbed_plots_config = tabbed_plots_config
+      @errors = []
+      @done = false
+      @cancel = false
+
+      if progress_dialog
+        progress_dialog.cancel_callback = method(:kill)
+        progress_dialog.enable_cancel_button
+      end
+
+      @thread = Thread.new do
+        begin
+          log_file_count = 1
+          log_files.each do |log_file|
+            break if @cancel
+            begin
+              file_size = File.size(log_file).to_f
+              break if @cancel
+              progress_dialog.append_text("Procesing File #{log_file_count}/#{log_files.length}: #{log_file}\n") if progress_dialog
+              break if @cancel
+              progress_dialog.set_step_progress(0) if progress_dialog
+              break if @cancel
+              packet_count = 0
+              if progress_dialog
+                Cosmos.check_log_configuration(@packet_log_reader, log_file)
+              end
+              @packet_log_reader.each(log_file, true, time_start, time_end) do |packet|
+                break if @cancel
+                if progress_dialog and packet_count % PROGRESS_UPDATE_PACKET_COUNT == 0
+                  progress_dialog.set_step_progress(@packet_log_reader.bytes_read / file_size)
+                end
+                break if @cancel
+                @tabbed_plots_config.process_packet(packet)
+                packet_count += 1
+              end
+              break if @cancel
+              progress_dialog.set_step_progress(1.0) if progress_dialog and not @cancel
+              break if @cancel
+              progress_dialog.set_overall_progress(log_file_count.to_f / log_files.length.to_f) if progress_dialog and not @cancel
+              break if @cancel
+            rescue Exception => error
+              @errors << error
+              break if @cancel
+              progress_dialog.append_text("Error processing #{log_file}:\n#{error.class} : #{error.message}\n#{error.backtrace.join("\n")}\n", 2) if progress_dialog
+              # If a progress dialog is shown we can't just bail on this error or
+              # it will close and the user will have no idea what happened
+              # Thus we'll spin here waiting for them to close the dialog
+              break if @cancel
+              if progress_dialog
+                sleep(0.1) until progress_dialog.complete?
+              end
+              break # Bail out because something bad happened
+            end
+            log_file_count += 1
+          end
+        ensure
+          if !@cancel
+            progress_dialog.complete if progress_dialog
+            sleep(0.1) # Give the user a chance to see something if we process really fast
+          end
+          @done = true
+        end
+      end
+    end # def initialize
+
+    # Indicates if processing is complete
+    def done?
+      @done
+    end
+
+    # Kills the log file processing thread
+    def kill(progress_dialog = nil)
+      @cancel = true
+      Cosmos.kill_thread(self, @thread)
+      progress_dialog.complete if progress_dialog
+      @thread = nil
+      @done = true
+      return true, false
+    end # def kill
+
+    def graceful_kill
+      # Just to remove warnings
+    end
+
+  end # class TabbedPlotsLogfileThread
+
+end # module Cosmos

data/lib/cosmos/tools/tlm_grapher/tabbed_plots_tool/tabbed_plots_plot_editor.rb

@@ -0,0 +1,101 @@
+# 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/tools/tlm_grapher/plot_editors/linegraph_plot_editor'
+require 'cosmos/tools/tlm_grapher/plot_editors/xy_plot_editor'
+require 'cosmos/tools/tlm_grapher/plot_editors/singlexy_plot_editor'
+
+module Cosmos
+
+  # Dialog to edit the plot
+  class TabbedPlotsPlotEditor < Qt::Dialog
+
+    def initialize(parent, title, plot_types, plot = nil)
+      super(parent)
+      setWindowTitle(title)
+
+      @layout = Qt::VBoxLayout.new
+
+      unless plot
+        # Create combobox to select plot type
+        @combobox = Qt::ComboBox.new(self)
+        plot_types.each {|plot_type| @combobox.addItem(plot_type.to_s.upcase)}
+        @combobox.setMaxVisibleItems(plot_types.length)
+        @combobox.connect(SIGNAL('currentIndexChanged(int)')) { handle_plot_type_change() }
+        @combo_layout = Qt::FormLayout.new()
+        @combo_layout.addRow('Plot Type:', @combobox)
+        @layout.addLayout(@combo_layout)
+
+        # Separator before actual editing dialog
+        @sep1 = Qt::Frame.new
+        @sep1.setFrameStyle(Qt::Frame::HLine | Qt::Frame::Sunken)
+        @layout.addWidget(@sep1)
+      else
+        setWindowTitle(title + " : #{plot.plot_type}")
+      end
+
+      # Create editor class for specific plot type
+      # Defaults to plot_types[0] if a plot was not given
+      if plot
+        plot_type = plot.class.to_s[0..-5].downcase
+        plot_type = plot_type.split('::')[-1] # Remove Cosmos:: if present
+      else
+        plot_type = plot_types[0].to_s.downcase
+      end
+      @editor_layout = Qt::VBoxLayout.new
+      @layout.addLayout(@editor_layout)
+      @editor = Cosmos.require_class(plot_type + '_plot_editor.rb').new(self, plot)
+      @editor_layout.addWidget(@editor)
+
+      # Separator before buttons
+      @sep2 = Qt::Frame.new
+      @sep2.setFrameStyle(Qt::Frame::HLine | Qt::Frame::Sunken)
+      @layout.addWidget(@sep2)
+      @layout.addStretch
+
+      # Create OK and Cancel buttons
+      @ok_button = Qt::PushButton.new('Ok')
+      @ok_button.setDefault(true)
+      connect(@ok_button, SIGNAL('clicked()'), self, SLOT('accept()'))
+      @cancel_button = Qt::PushButton.new('Cancel')
+      connect(@cancel_button, SIGNAL('clicked()'), self, SLOT('reject()'))
+      @button_layout = Qt::HBoxLayout.new()
+      @button_layout.addWidget(@ok_button)
+      @button_layout.addWidget(@cancel_button)
+      @layout.addLayout(@button_layout)
+      @ok_button.setDefault(true)
+
+      setLayout(@layout)
+    end # def initialize
+
+    # Executes the plot editor dialog box
+    def execute
+      return_value = nil
+      result = exec()
+      if result == Qt::Dialog::Accepted
+        return_value = @editor.plot
+      end
+      return return_value
+    end # def execute
+
+    protected
+
+    # Handles plot type being changed
+    def handle_plot_type_change
+      plot_type = @combobox.currentText.downcase
+      @editor.dispose
+      @editor = Cosmos.require_class(plot_type.capitalize + '_plot_editor.rb').new(self)
+      @editor_layout.addWidget(@editor)
+    end
+
+  end # class TabbedPlotsPlotEditor
+
+end # module Cosmos

data/lib/cosmos/tools/tlm_grapher/tabbed_plots_tool/tabbed_plots_realtime_thread.rb

@@ -0,0 +1,78 @@
+# 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/tools/cmd_tlm_server/interface_thread'
+require 'cosmos/interfaces/tcpip_client_interface'
+
+module Cosmos
+
+  # Thread used to gather telemetry in realtime and process it using a TabbedPlotsDefinition
+  class TabbedPlotsRealtimeThread < InterfaceThread
+
+    # Create a new TabbedPlotsRealtimeThread
+    def initialize(tabbed_plots_config, connection_success_callback = nil, connection_failed_callback = nil, connection_lost_callback = nil, fatal_exception_callback = nil)
+      interface = TcpipClientInterface.new(System.connect_hosts['CTS_PREIDENTIFIED'], nil, System.ports['CTS_PREIDENTIFIED'], nil, tabbed_plots_config.cts_timeout, 'PREIDENTIFIED')
+      super(interface)
+
+      @queue = Queue.new
+      @tabbed_plots_config = tabbed_plots_config
+
+      # Connect callbacks
+      self.identified_packet_callback = method(:received_packet_callback)
+      self.connection_success_callback = connection_success_callback
+      self.connection_failed_callback = connection_failed_callback
+      self.connection_lost_callback = connection_lost_callback
+      self.fatal_exception_callback = fatal_exception_callback
+
+      @process_thread = Thread.new do
+        begin
+          loop do
+            packet = @queue.pop
+            break unless packet
+            @tabbed_plots_config.process_packet(packet)
+          end
+        rescue Exception => error
+          if self.fatal_exception_callback
+            self.fatal_exception_callback.call(error)
+          end
+        end
+      end
+
+      # Start interface thread
+      start()
+    end # def initialize
+
+    # Callback to the system definition when a packet is received
+    def received_packet_callback(packet)
+      @queue << packet.clone
+    end
+
+    # Kills the realtime thread
+    def kill
+      @queue << nil
+      stop()
+      Cosmos.kill_thread(self, @process_thread)
+      @process_thread = nil
+    end # def kill
+
+    def graceful_kill
+      # Allow the callbacks a chance to update the GUI so that they can die gracefully
+      if defined? Qt and Thread.current == Thread.main
+        5.times do
+          Qt::CoreApplication.instance.processEvents
+          sleep(0.05)
+        end
+      end
+    end
+
+  end # class TabbedPlotsRealtimeThread
+
+end # module Cosmos

data/lib/cosmos/tools/tlm_grapher/tabbed_plots_tool/tabbed_plots_tab.rb

@@ -0,0 +1,57 @@
+# 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
+
+  # Represents a tab in a tabbed plots definition
+  class TabbedPlotsTab
+
+    # Text to display in a tab
+    attr_accessor :tab_text
+
+    # Array of plots in the tab
+    attr_accessor :plots
+
+    # Gui object for tab item
+    attr_accessor :gui_item
+
+    # Gui object for tab frame
+    attr_accessor :gui_frame
+
+    # Gui object for tab layout
+    attr_accessor :gui_layout
+
+    # Create a new TabbedPlotsTab
+    def initialize(tab_text = nil)
+      @tab_text = tab_text
+      @plots = []
+      @gui_item = nil
+      @gui_frame = nil
+      @gui_layout = nil
+    end # def initialize
+
+    # Returns the configuration lines used to create this tab
+    def configuration_string
+      if @tab_text
+        string = "TAB \"#{@tab_text}\"\n"
+      else
+        string = "TAB\n"
+      end
+      @plots.each do |plot|
+        string << plot.configuration_string
+      end
+      string
+    end # def configuration_string
+
+  end # class TabbedPlotsTab
+
+end # module Cosmos

data/lib/cosmos/tools/tlm_grapher/tabbed_plots_tool/tabbed_plots_tool.rb

@@ -0,0 +1,1004 @@
+# 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/gui/qt'
+require 'cosmos/gui/qt_tool'
+require 'cosmos/gui/dialogs/splash'
+require 'cosmos/packet_logs/packet_log_reader'
+require 'cosmos/tools/tlm_grapher/tabbed_plots_tool/tabbed_plots_config'
+require 'cosmos/tools/tlm_grapher/tabbed_plots_tool/tabbed_plots_realtime_thread'
+require 'cosmos/tools/tlm_grapher/tabbed_plots_tool/tabbed_plots_logfile_thread'
+require 'cosmos/gui/widgets/realtime_button_bar'
+require 'cosmos/gui/dialogs/exception_list_dialog'
+require 'cosmos/gui/dialogs/packet_log_dialog'
+require 'cosmos/gui/dialogs/progress_dialog'
+require 'cosmos/tools/tlm_grapher/tabbed_plots/overview_tabbed_plots'
+
+module Cosmos
+
+  # Displays multiple plots that perform various analysis on data.
+  class TabbedPlotsTool < QtTool
+
+    MINIMUM_LEFT_PANEL_WIDTH = 200
+    DEFAULT_LEFT_PANEL_WIDTH = 250
+
+    def initialize(options)
+      super(options) # MUST BE FIRST - All code before super is executed twice in RubyQt Based classes
+      @base_title = self.windowTitle
+      Cosmos.load_cosmos_icon("tlm_grapher.png")
+
+      statusBar.showMessage(tr("")) # Show blank message to initialize status bar
+
+      initialize_actions()
+      initialize_menus(options)
+      initialize_central_widget()
+      complete_initialize()
+
+      # Define instance variables
+      @log_filenames = []
+      @log_dir = System.paths['LOGS']
+      @log_dir += '/' unless @log_dir[-1..-1] == '\\' or @log_dir[-1..-1] == '/'
+      @time_start = nil
+      @time_end = nil
+      @screenshot_dir = @log_dir.clone
+      @export_dir = @log_dir.clone
+      @data_object_types = options.data_object_types
+      @adder_orientation = options.adder_orientation
+      @adder_types = options.adder_types
+      @tool_short_name = options.tool_short_name
+      @plot_types = options.plot_types
+      @tabbed_plots_type = options.tabbed_plots_type
+      @items = options.items
+      @plot_type_to_data_object_type_mapping = options.plot_type_to_data_object_type_mapping
+      @start = options.start
+      @packet_log_reader = PacketLogReader.new
+      @tabbed_plots_config = nil
+      @tabbed_plots = nil
+      @realtime_thread = nil
+      @config_modified = false
+
+      # Bring up slash screen for long duration tasks after creation
+      Splash.execute(self) do |splash|
+        # Configure CosmosConfig to interact with splash screen
+        ConfigParser.splash = splash
+
+        # Load telemetry
+        System.telemetry
+
+        # Create tabbed plots definition
+        @config_filename = File.join(Cosmos::USERPATH, 'config', 'tools', options.config_dir, options.config_file)
+        Qt.execute_in_main_thread(true) do
+          load_configuration()
+        end
+
+        # Unconfigure CosmosConfig to interact with splash screen
+        ConfigParser.splash = nil
+      end
+    end
+
+    def initialize_actions
+      super()
+
+      # File Menu Actions
+      @file_process = Qt::Action.new(tr('&Open Log'), self)
+      @file_process_keyseq = Qt::KeySequence.new(tr('Ctrl+O'))
+      @file_process.shortcut = @file_process_keyseq
+      @file_process.statusTip = tr('Open Log File')
+      @file_process.connect(SIGNAL('triggered()')) { on_file_process_log() }
+
+      @file_load = Qt::Action.new(Cosmos.get_icon('open.png'), tr('&Load Config'), self)
+      @file_load.statusTip = tr('Load Saved Configuration')
+      @file_load.connect(SIGNAL('triggered()')) { on_file_load_config() }
+
+      @file_save = Qt::Action.new(Cosmos.get_icon('save.png'), tr('&Save Config'), self)
+      @file_save_keyseq = Qt::KeySequence.new(tr('Ctrl+S'))
+      @file_save.shortcut = @file_save_keyseq
+      @file_save.statusTip = tr('Save Current Configuration')
+      @file_save.connect(SIGNAL('triggered()')) { on_file_save_config() }
+
+      @file_screenshot = Qt::Action.new(Cosmos.get_icon('screenshot.png'), tr('Screensho&t'), self)
+      @file_screenshot.statusTip = tr('Screenshot of Application')
+      @file_screenshot.connect(SIGNAL('triggered()')) { on_file_screenshot() }
+
+      # Tab Menu Actions
+      @tab_add = Qt::Action.new(Cosmos.get_icon('add_tab.png'), tr('&Add Tab'), self)
+      @tab_add.statusTip = tr('Add New Tab')
+      @tab_add.connect(SIGNAL('triggered()')) { on_tab_add() }
+
+      @tab_delete = Qt::Action.new(Cosmos.get_icon('delete_tab.png'), tr('&Delete Tab'), self)
+      @tab_delete.statusTip = tr('Delete Active Tab')
+      @tab_delete.connect(SIGNAL('triggered()')) { on_tab_delete() }
+
+      @tab_edit = Qt::Action.new(Cosmos.get_icon('edit_tab.png'), tr('&Edit Tab'), self)
+      @tab_edit.statusTip = tr('Edit Active Tab')
+      @tab_edit.connect(SIGNAL('triggered()')) { on_tab_edit() }
+
+      @tab_screenshot = Qt::Action.new(Cosmos.get_icon('screenshot.png'), tr('&Screenshot Tab'), self)
+      @tab_screenshot.statusTip = tr('Screenshot of Active Tab')
+      @tab_screenshot.connect(SIGNAL('triggered()')) { on_tab_screenshot() }
+
+      @tab_export = Qt::Action.new(tr('E&xport Tab Data Objects'), self)
+      @tab_export.statusTip = tr('Export Tab Data Object(s)')
+      @tab_export.connect(SIGNAL('triggered()')) { on_tab_export() }
+
+      @tab_reset = Qt::Action.new(tr('&Reset Tab Data Objects'), self)
+      @tab_reset.statusTip = tr('Reset Tab Data Object(s)')
+      @tab_reset.connect(SIGNAL('triggered()')) { on_tab_reset() }
+
+      # Plot Menu Actions
+      @plot_add = Qt::Action.new(Cosmos.get_icon('add_plot.png'), tr('&Add Plot'), self)
+      @plot_add.statusTip = tr('Add New Plot')
+      @plot_add.connect(SIGNAL('triggered()')) { on_plot_add() }
+
+      @plot_delete = Qt::Action.new(Cosmos.get_icon('delete_plot.png'), tr('&Delete Plot'), self)
+      @plot_delete.statusTip = tr('Delete Selected Plot')
+      @plot_delete.connect(SIGNAL('triggered()')) { on_plot_delete() }
+
+      @plot_edit = Qt::Action.new(Cosmos.get_icon('edit_plot.png'), tr('&Edit Plot'), self)
+      @plot_edit.statusTip = tr('Edit Selected Plot')
+      @plot_edit.connect(SIGNAL('triggered()')) { on_plot_edit() }
+
+      @plot_screenshot = Qt::Action.new(Cosmos.get_icon('screenshot.png'), tr('&Screenshot Plot'), self)
+      @plot_screenshot.statusTip = tr('Screenshot Selected Plot')
+      @plot_screenshot.connect(SIGNAL('triggered()')) { on_plot_screenshot() }
+
+      @plot_add_data = Qt::Action.new(Cosmos.get_icon('add_database.png'), tr('Add Data &Object'), self)
+      @plot_add_data.statusTip = tr('Add Data Object')
+      @plot_add_data.connect(SIGNAL('triggered()')) { on_data_object_add() }
+
+      @plot_edit_data = Qt::Action.new(Cosmos.get_icon('edit_database.png'), tr('Edit &Plot Data Objects'), self)
+      @plot_edit_data.statusTip = tr('Edit Plot Data Object(s)')
+      @plot_edit_data.connect(SIGNAL('triggered()')) { on_plot_data_object_edit() }
+
+      @plot_export = Qt::Action.new(tr('E&xport Plot Data Objects'), self)
+      @plot_export.statusTip = tr('Export Plot Data Object(s)')
+      @plot_export.connect(SIGNAL('triggered()')) { on_plot_export() }
+
+      @plot_reset = Qt::Action.new(tr('&Reset Plot Data Objects'), self)
+      @plot_reset.statusTip = tr('Reset Plot Data Object(s)')
+      @plot_reset.connect(SIGNAL('triggered()')) { on_plot_reset() }
+
+      # Data Object Menu
+      @data_add = Qt::Action.new(Cosmos.get_icon('add_database.png'), tr('&Add Data Object'), self)
+      @data_add.statusTip = tr('Add Data Object')
+      @data_add.connect(SIGNAL('triggered()')) { on_data_object_add() }
+
+      @data_delete = Qt::Action.new(Cosmos.get_icon('delete_database.png'), tr('&Delete Data Object'), self)
+      @data_delete.statusTip = tr('Delete Selected Data Object(s)')
+      @data_delete.connect(SIGNAL('triggered()')) { on_data_object_delete() }
+
+      @data_edit = Qt::Action.new(Cosmos.get_icon('edit_database.png'), tr('&Edit Data Object'), self)
+      @data_edit.statusTip = tr('Edit Selected Data Object(s)')
+      @data_edit.connect(SIGNAL('triggered()')) { on_data_object_edit() }
+
+      @data_duplicate = Qt::Action.new(tr('Du&plicate Data Object'), self)
+      @data_duplicate.statusTip = tr('Duplicate Selected Data Object(s)')
+      @data_duplicate.connect(SIGNAL('triggered()')) { on_data_object_duplicate() }
+
+      @data_export = Qt::Action.new(tr('E&xport Data Object'), self)
+      @data_export.statusTip = tr('Export Selected Data Object(s)')
+      @data_export.connect(SIGNAL('triggered()')) { on_data_object_export() }
+
+      @data_export_all = Qt::Action.new(tr('Expor&t All Data Objects'), self)
+      @data_export_all.statusTip = tr('Export All Data Objects')
+      @data_export_all.connect(SIGNAL('triggered()')) { on_data_object_export_all() }
+
+      @data_reset = Qt::Action.new(tr('&Reset Data Object'), self)
+      @data_reset.statusTip = tr('Reset Selected Data Object(s)')
+      @data_reset.connect(SIGNAL('triggered()')) { on_data_object_reset() }
+
+      @data_reset_all = Qt::Action.new(tr('Re&set All Data Objects'), self)
+      @data_reset_all.statusTip = tr('Reset All Data Objects')
+      @data_reset_all.connect(SIGNAL('triggered()')) { on_data_object_reset_all() }
+    end
+
+    def initialize_menus(options)
+      # File Menu
+      @file_menu = menuBar.addMenu(tr('&File'))
+      @file_menu.addAction(@file_process)
+      @file_menu.addSeparator()
+      @file_menu.addAction(@file_load)
+      @file_menu.addAction(@file_save)
+      @file_menu.addSeparator()
+      @file_menu.addAction(@file_screenshot)
+      @file_menu.addSeparator()
+      @file_menu.addAction(@exit_action)
+
+      @tab_menu = menuBar.addMenu(tr('&Tab'))
+      @tab_menu.addAction(@tab_add)
+      @tab_menu.addAction(@tab_delete)
+      @tab_menu.addAction(@tab_edit)
+      @tab_menu.addSeparator()
+      @tab_menu.addAction(@tab_screenshot)
+      @tab_menu.addAction(@tab_export)
+      @tab_menu.addSeparator()
+      @tab_menu.addAction(@tab_reset)
+
+      @plot_menu = menuBar.addMenu(tr('&Plot'))
+      @plot_menu.addAction(@plot_add)
+      @plot_menu.addAction(@plot_delete)
+      @plot_menu.addAction(@plot_edit)
+      @plot_menu.addSeparator()
+      @plot_menu.addAction(@plot_add_data)
+      @plot_menu.addAction(@plot_edit_data)
+      @plot_menu.addSeparator()
+      @plot_menu.addAction(@plot_screenshot)
+      @plot_menu.addAction(@plot_export)
+      @plot_menu.addSeparator()
+      @plot_menu.addAction(@plot_reset)
+
+      @data_menu = menuBar.addMenu(tr('&Data Object'))
+      @data_menu.addAction(@data_add)
+      @data_menu.addAction(@data_delete)
+      @data_menu.addAction(@data_edit)
+      @data_menu.addSeparator()
+      @data_menu.addAction(@data_duplicate)
+      @data_menu.addAction(@data_export)
+      @data_menu.addAction(@data_export_all)
+      @data_menu.addSeparator()
+      @data_menu.addAction(@data_reset)
+      @data_menu.addAction(@data_reset_all)
+
+      # Help Menu
+      @about_string = options.about_string
+      initialize_help_menu()
+    end
+
+    def initialize_central_widget
+      # Create a splitter to break application into to halves
+      @splitter = Qt::Splitter.new(Qt::Horizontal, central_widget)
+      setCentralWidget(@splitter)
+
+      # Create a Vertical Frame for the left contents
+      @left_widget = Qt::Widget.new(self)
+      @left_frame = Qt::VBoxLayout.new
+      @left_widget.setLayout(@left_frame)
+      @splitter.addWidget(@left_widget)
+
+      # Create a Vertical Frame for the right contents
+      @right_widget = Qt::Widget.new(self)
+      @right_frame = Qt::VBoxLayout.new
+      @right_widget.setLayout(@right_frame)
+      @splitter.addWidget(@right_widget)
+      @splitter.setStretchFactor(0,0) # Set the left side stretch factor to 0
+      @splitter.setStretchFactor(1,1) # Set the right side stretch factor to 1 to give it priority for space
+
+      # Realtime Button Bar
+      @realtime_button_bar = RealtimeButtonBar.new(self, Qt::Vertical)
+      @realtime_button_bar.start_callback = method(:handle_start)
+      @realtime_button_bar.pause_callback = method(:handle_pause)
+      @realtime_button_bar.stop_callback = method(:handle_stop)
+      @realtime_button_bar.state = 'Stopped'
+      @left_frame.addWidget(@realtime_button_bar)
+
+      # Separator after RBB
+      @sep = Qt::Frame.new
+      @sep.setFrameStyle(Qt::Frame::HLine | Qt::Frame::Sunken)
+      @left_frame.addWidget(@sep)
+    end # def initialize
+
+    protected
+
+    ###############################################################################
+    # Protected Methods Used During Initialization
+    ###############################################################################
+
+    # Loads in a new configuration file
+    def load_configuration
+      # Shutdown TabbedPlots if one already exists
+      @tabbed_plots.shutdown if @tabbed_plots
+
+      if @items && !@items.empty?
+        # Don't use config file and handle items passed in from the command line
+        @tabbed_plots_config = TabbedPlotsConfig.new(nil,
+                                                     @plot_types,
+                                                     @data_object_types,
+                                                     @plot_type_to_data_object_type_mapping)
+        handle_items()
+      else
+        # Create new tabbed plots definition from config file
+        @tabbed_plots_config = TabbedPlotsConfig.new(@config_filename,
+                                                     @plot_types,
+                                                     @data_object_types,
+                                                     @plot_type_to_data_object_type_mapping)
+      end
+      @config_modified = false
+
+      # Handle configuration errors
+      unless @tabbed_plots_config.configuration_errors.empty?
+        ExceptionListDialog.new('Errors Encountered in Configuration File:',
+                                @tabbed_plots_config.configuration_errors)
+      end
+
+      # Add a TabbedPlots widget to show all the plots
+      if @tabbed_plots
+        @tabbed_plots.config_modified_callback = nil
+      else
+        # Require tabbed plots file
+        tabbed_plots_filename = @tabbed_plots_type + '_tabbed_plots.rb'
+        tabbed_plots_class = Cosmos.require_class(tabbed_plots_filename)
+        @tabbed_plots = tabbed_plots_class.new(self, @left_frame, @right_frame, statusBar)
+        @tabbed_plots.tab_item_right_button_release_callback = method(:handle_tab_right_click)
+        @tabbed_plots.plot_right_button_release_callback = method(:handle_plot_right_click)
+        @tabbed_plots.data_object_right_button_release_callback = method(:handle_data_object_right_click)
+      end
+      @tabbed_plots.startup(@tabbed_plots_config, @adder_orientation, @adder_types)
+      @tabbed_plots.config_modified_callback = method(:handle_config_modified)
+      @tabbed_plots.pause
+
+      # Start realtime collection if given an item or told to start
+      if (@items and not @items.empty?) or @start
+        handle_start()
+        @items = nil
+        @start = false
+      end
+
+      if !File.exist?(@config_filename)
+        # Warn if the configuration file did not exist
+        statusBar.showMessage(tr("Configuration File does not exist: #{@config_filename}. Using default configuration."))
+      end
+      update_window_title()
+    end # def load_configuration
+
+    def update_window_title
+      if File.exist?(@config_filename)
+        if @config_modified
+          self.windowTitle = @base_title + ' - ' + @config_filename + '*'
+        else
+          self.windowTitle = @base_title + ' - ' + @config_filename
+        end
+      else
+        self.windowTitle = @base_title
+      end
+    end
+
+    # Override this method to handle items passed in from command line
+    def handle_items
+      # Do nothing by default
+    end # def handle_items
+
+    def screenshot
+      screenshot_filename = File.join(@screenshot_dir,
+        File.build_timestamped_filename([@tool_short_name, 'screenshot'], '.png'))
+      filename = Qt::FileDialog::getSaveFileName(self,
+                                                 "Save Screen Shot",
+                                                 screenshot_filename,
+                                                 "Screenshots (*.png);;All Files (*)")
+      unless filename.nil? or filename.empty?
+        Qt.execute_in_main_thread(true) do
+          begin
+            yield filename
+            @screenshot_dir = File.dirname(filename)
+            statusBar.showMessage(tr("Screenshot saved to: #{filename}"))
+          rescue Exception => error
+            statusBar.showMessage(tr("Screenshot creation failed"))
+            Qt::MessageBox.warning(
+              self,
+              "Screenshot Creation Error",
+              "Could not create file: #{filename}\n#{error.class} : #{error.message}")
+          end
+        end
+      end
+    end
+
+    def export
+      export_filename = File.join(@export_dir,
+        File.build_timestamped_filename([@tool_short_name, 'export'], '.txt'))
+      filename = Qt::FileDialog::getSaveFileName(self,
+                                                 "Export Filename",
+                                                 export_filename,
+                                                 "Export Files (*.txt);;All Files (*)")
+      unless filename.nil? or filename.empty?
+        filename << '.txt' if File.extname(filename).empty?
+        begin
+          ProgressDialog.execute(self, "Export Progress", 500, 100, true, false, true, true, true) do |dialog|
+            yield filename, dialog
+            dialog.append_text("\n\nExported to #{filename}")
+            dialog.set_overall_progress(1.0)
+            dialog.complete
+          end
+          @export_dir = File.dirname(filename)
+          statusBar.showMessage(tr("Exported to #{filename}"))
+        rescue Exception => error
+          statusBar.showMessage(tr("Export Failed"))
+          Qt::MessageBox.warning(
+            self,
+            "Export Error",
+            "Could not create file: #{filename}\n#{error.class} : #{error.message}")
+        end
+      end
+    end
+
+    def reset_or_delete(item, delete)
+      action = "reset"
+      action = "delete" if delete
+      result = Qt::MessageBox.warning(self,
+                                      'Warning!',
+                                      "Are you sure you want to #{action} the #{item}?",
+                                      Qt::MessageBox::Yes | Qt::MessageBox::No,
+                                      Qt::MessageBox::No)
+      if result == Qt::MessageBox::Yes
+        yield
+        @config_modified = true if delete
+        update_window_title() if delete
+        statusBar.showMessage(tr("#{action.capitalize} #{item} successful"))
+      else
+        statusBar.showMessage(tr("#{action.capitalize} #{item} canceled"))
+      end
+    end
+    def reset(item)
+      reset_or_delete(item, false) do
+        yield
+      end
+    end
+    def delete(item)
+      reset_or_delete(item, true) do
+        yield
+      end
+    end
+
+    ###############################################################################
+    # Application Close Handler
+    ###############################################################################
+
+    # Prompts for save if the current configuration has been modified
+    def prompt_for_save_if_needed
+      safe_to_continue = true
+      if @config_modified and File.exist?(@config_filename)
+        case Qt::MessageBox.question(
+          self,    # parent
+          'Save?', # title
+          "Save changes to '#{@config_filename}'?", # text
+          Qt::MessageBox::Yes | Qt::MessageBox::No | Qt::MessageBox::Cancel, # buttons
+          Qt::MessageBox::Cancel) # default button
+        when Qt::MessageBox::Cancel
+          safe_to_continue = false
+        when Qt::MessageBox::Yes
+          saved = on_file_save_config()
+          if not saved
+            safe_to_continue = false
+          end
+        end
+      end
+      return safe_to_continue
+    end
+
+    # Handles application window closing
+    def closeEvent(event)
+      if prompt_for_save_if_needed()
+        super(event)
+        @realtime_thread.kill if @realtime_thread
+        @realtime_thread = nil
+      else
+        event.ignore()
+      end
+    end
+
+    ###############################################################################
+    # File Menu Handlers
+    ###############################################################################
+
+    # Handles processing log files
+    def on_file_process_log
+      paused = @tabbed_plots.paused?
+      @tabbed_plots.pause
+      dialog = PacketLogDialog.new(self,
+                                   'Process Log File(s):',
+                                   @log_dir,
+                                   @packet_log_reader,
+                                   @log_filenames)
+      dialog.time_start = @time_start
+      dialog.time_end = @time_end
+      result = dialog.exec
+      if result != 0
+        @time_start = dialog.time_start
+        @time_end = dialog.time_end
+        handle_stop()
+        System.telemetry.reset
+        @tabbed_plots.reset_all_data_objects
+        @realtime_button_bar.state = 'Log File'
+        @packet_log_reader = dialog.packet_log_reader
+        @log_filenames = dialog.filenames.clone
+        filenames = dialog.filenames.sort
+
+        ProgressDialog.execute(self, 'Log File Progress', 500, 300) do |progress_dialog|
+          logfile_thread = TabbedPlotsLogfileThread.new(filenames,
+                                                        @packet_log_reader,
+                                                        @tabbed_plots_config,
+                                                        progress_dialog,
+                                                        @time_start,
+                                                        @time_end)
+          sleep(0.1) until logfile_thread.done?
+          progress_dialog.close_done
+        end
+
+        @tabbed_plots.redraw_plots(true, true)
+        @tabbed_plots.update
+      else
+        @tabbed_plots.resume unless paused
+      end
+      dialog.dispose
+    end # def on_file_process_log
+
+    # Handles loading a configuration file
+    def on_file_load_config
+      paused = @tabbed_plots.paused?
+      @tabbed_plots.pause
+
+      if prompt_for_save_if_needed()
+        filename = Qt::FileDialog.getOpenFileName(self,
+                                                  "Load Configuration",
+                                                  @config_filename,
+                                                  "Config File (*.txt);;All Files (*)")
+        if filename and not filename.empty?
+          @config_filename = filename
+          if @realtime_thread then running = true else running = false end
+          handle_stop()
+          load_configuration()
+          handle_start() if running
+          handle_pause() if paused
+        else
+          @tabbed_plots.resume unless paused
+        end
+      end
+    end # def on_file_load_config
+
+    # Handles saving the current configuration to a file
+    def on_file_save_config
+      saved = false
+      paused = @tabbed_plots.paused?
+      @tabbed_plots.pause
+      filename = Qt::FileDialog.getSaveFileName(self,
+                                                "Save Configuration",
+                                                @config_filename,
+                                                "Config File (*.txt);;All Files (*)")
+      if filename and not filename.empty?
+        filename << '.txt' if File.extname(filename).empty?
+        File.open(filename, 'w') {|file| file.write(@tabbed_plots_config.configuration_string)}
+        @config_filename = filename
+        @config_modified = false
+        update_window_title()
+        saved = true
+      end
+      @tabbed_plots.resume unless paused
+      return saved
+    end # def on_file_save_config
+
+    # Handles taking a screenshot of the tool
+    def on_file_screenshot
+      paused = @tabbed_plots.paused?
+      @tabbed_plots.pause
+      screenshot do |filename|
+        Screenshot.screenshot_window(self, filename)
+      end
+      @tabbed_plots.resume unless paused
+    end # def on_file_screenshot
+
+    ###############################################################################
+    # Tab Menu Handlers
+    ###############################################################################
+
+    # Common method to check for the existance of a tab before yielding
+    def tab_selected?
+      paused = @tabbed_plots.paused?
+      @tabbed_plots.pause
+      if @tabbed_plots.current_tab_index
+        yield
+      else
+        Qt::MessageBox.information(self, 'Info', "No tabs exist")
+      end
+      @tabbed_plots.resume unless paused
+    end
+
+    # Handles adding a new tab
+    def on_tab_add
+      paused = @tabbed_plots.paused?
+      @tabbed_plots.pause
+      @tabbed_plots.add_tab
+      statusBar.showMessage(tr("Tab Added"))
+      @config_modified = true
+      update_window_title()
+      @tabbed_plots.resume unless paused
+    end # def on_tab_add
+
+    # Handles deleting the current tab
+    def on_tab_delete
+      tab_selected? do
+        delete("tab") do
+          @tabbed_plots.delete_tab
+        end
+      end
+    end # def on_tab_delete
+
+    # Handles editing the current tab
+    def on_tab_edit
+      tab_selected? do
+        edited = @tabbed_plots.edit_tab
+        if edited
+          statusBar.showMessage(tr("Tab Edited"))
+          @config_modified = true
+          update_window_title()
+        end
+      end
+    end # def on_tab_edit
+
+    # Handles taking a screenshot of the current tab
+    def on_tab_screenshot
+      tab_selected? do
+        screenshot do |filename|
+          @tabbed_plots.screenshot_tab(filename)
+        end
+      end
+    end
+
+    # Handles exporting all data objects on the current tab
+    def on_tab_export
+      tab_selected? do
+        if @tabbed_plots.tab_has_data_objects?
+          export do |filename, progress_dialog|
+            @tabbed_plots.export_tab(filename, progress_dialog)
+          end
+        else
+          Qt::MessageBox.information(self, 'Info', "No data objects exist on this tab")
+        end
+      end
+    end # def on_tab_export
+
+    # Handles reseting all data objects on the current tab
+    def on_tab_reset
+      tab_selected? do
+        reset("data objects on the current tab") do
+          @tabbed_plots.reset_tab
+        end
+      end
+    end # def on_tab_reset
+
+    ###############################################################################
+    # Plot Menu Handlers
+    ###############################################################################
+
+    # Common method to check for a selected plot before yielding
+    def plot_selected?
+      paused = @tabbed_plots.paused?
+      @tabbed_plots.pause
+      if @tabbed_plots.selected_plot_index
+        yield
+      else
+        Qt::MessageBox.information(self, 'Info', "Please select a plot")
+      end
+      @tabbed_plots.resume unless paused
+    end
+
+    # Common method to check for the existance of data objects before yielding
+    def plot_data_objects?
+      if @tabbed_plots.plot_has_data_objects?
+        yield
+      else
+        Qt::MessageBox.information(self, 'Info', "No data objects exist on this plot")
+      end
+    end
+
+    # Handles adding a new plot to the current tab
+    def on_plot_add
+      paused = @tabbed_plots.paused?
+      @tabbed_plots.pause
+      added = @tabbed_plots.add_plot
+      if added
+        @config_modified = true
+        update_window_title()
+      end
+      @tabbed_plots.resume unless paused
+    end # def on_plot_add
+
+    # Handles deleting the selected plot
+    def on_plot_delete
+      plot_selected? do
+        delete("plot") do
+          @tabbed_plots.delete_plot
+        end
+      end
+    end # def on_plot_delete
+
+    # Handles editing the selected plot
+    def on_plot_edit
+      plot_selected? do
+        edited = @tabbed_plots.edit_plot
+        if edited
+          @config_modified = true
+          update_window_title()
+        end
+      end
+    end # def on_plot_edit
+
+    # Handles taking a screenshot of the selected plot
+    def on_plot_screenshot
+      plot_selected? do
+        screenshot do |filename|
+          @tabbed_plots.screenshot_plot(filename)
+        end
+      end
+    end # def on_plot_screenshot
+
+    def on_plot_data_object_edit
+      edited = false
+      plot_selected? do
+        plot_data_objects? do
+          tab_index = @tabbed_plots.current_tab_index
+          plot_index =  @tabbed_plots.selected_plot_index
+          @tabbed_plots_config.tabs[tab_index].plots[plot_index].data_objects.each_with_index do |object, index|
+            edited |= @tabbed_plots.edit_data_object(tab_index, plot_index, index)
+          end
+          if edited
+            @config_modified = true
+            update_window_title()
+          end
+        end
+      end
+    end
+
+    # Handles exporting the data objects on the selected plot
+    def on_plot_export
+      plot_selected? do
+        plot_data_objects? do
+          export do |filename, progress_dialog|
+            @tabbed_plots.export_plot(filename, progress_dialog)
+          end
+        end
+      end
+    end # def on_plot_export
+
+    # Handles reseting the data objects on the selected plot
+    def on_plot_reset
+      plot_selected? do
+        plot_data_objects? do
+          reset("data objects on the selected plot") do
+            @tabbed_plots.reset_plot
+          end
+        end
+      end
+    end # def on_plot_reset
+
+    ###############################################################################
+    # Data Object Menu Handlers
+    ###############################################################################
+
+    def data_objects_selected?
+      paused = @tabbed_plots.paused?
+      @tabbed_plots.pause
+      unless @tabbed_plots.selected_data_object_indexes.empty?
+        yield
+      else
+        Qt::MessageBox.information(self, 'Information', "Please select one or more data objects")
+      end
+      @tabbed_plots.resume unless paused
+    end
+
+    def data_objects_exist?
+      paused = @tabbed_plots.paused?
+      @tabbed_plots.pause
+      if @tabbed_plots.plot_has_data_objects?
+        yield
+      else
+        Qt::MessageBox.information(self, 'Information', "No data objects exist on this plot")
+      end
+      @tabbed_plots.resume unless paused
+    end
+
+    # Handles adding a data object to the selected plot
+    def on_data_object_add
+      paused = @tabbed_plots.paused?
+      @tabbed_plots.pause
+      added = @tabbed_plots.add_data_object
+      if added
+        @config_modified = true
+        update_window_title()
+      end
+      @tabbed_plots.resume unless paused
+    end # def on_data_object_add
+
+    # Handles editing the selected data object(s)
+    def on_data_object_edit
+      data_objects_selected? do
+        edited = @tabbed_plots.edit_data_object
+        if edited
+          @config_modified = true
+          update_window_title()
+        end
+      end
+    end # def on_data_object_edit
+
+    # Handles duplicating the selected data object(s)
+    def on_data_object_duplicate
+      data_objects_selected? do
+        @tabbed_plots.duplicate_data_object
+        @config_modified = true
+        update_window_title()
+      end
+    end # def on_data_object_duplicate
+
+    # Handles deleting the selected data object(s)
+    def on_data_object_delete
+      data_objects_selected? do
+        delete("selected data object(s)") do
+          @tabbed_plots.delete_data_object
+        end
+      end
+    end # def on_data_object_delete
+
+    # Handles exporting the selected data object(s)
+    def on_data_object_export
+      data_objects_selected? do
+        export do |filename, progress_dialog|
+          @tabbed_plots.export_data_object(filename, progress_dialog)
+        end
+      end
+    end # def on_data_object_export
+
+    # Handles exporting all data objects
+    def on_data_object_export_all
+      data_objects_exist? do
+        export do |filename, progress_dialog|
+          @tabbed_plots.export_all_data_objects(filename, progress_dialog)
+        end
+      end
+    end # def on_data_object_export_all
+
+    # Handles reseting the selected data object(s)
+    def on_data_object_reset
+      data_objects_selected? do
+        reset("selected data objects") do
+          @tabbed_plots.reset_data_object
+        end
+      end
+    end # def on_data_object_reset
+
+    # Handles reseting all data objects
+    def on_data_object_reset_all
+      data_objects_exist? do
+        reset("all data objects") do
+          @tabbed_plots.reset_all_data_objects
+        end
+      end
+    end # def on_data_object_reset_all
+
+    ###############################################################################
+    # Right-Click Handlers
+    ###############################################################################
+
+    # Handles right clicking for tabs
+    def handle_tab_right_click(point)
+      # Popup menu
+      @tab_menu.exec(point)
+    end # def handle_tab_right_click
+
+    # Handles right clicking for plots
+    def handle_plot_right_click(point)
+      # Popup menu
+      @plot_menu.exec(point)
+    end # def handle_plot_right_click
+
+    # Handles right clicking for data objects
+    def handle_data_object_right_click(point)
+      # Popup menu
+      @data_menu.exec(point)
+    end # def handle_data_object_right_click
+
+    ###############################################################################
+    # Other Tabbed Plots Handlers
+    ###############################################################################
+
+    def handle_config_modified
+      @config_modified = true
+      update_window_title()
+    end
+
+    ###############################################################################
+    # Realtime Button Bar Button Handlers
+    ###############################################################################
+
+    # Handle start button
+    def handle_start
+      if @realtime_thread
+        # Resume plotting in case it was paused
+        @tabbed_plots.resume
+        statusBar.showMessage(tr("Plot Updates Resumed"))
+        @realtime_button_bar.state = 'Running'
+      else
+        System.load_configuration
+        if @realtime_button_bar.state == 'Log File'
+          System.telemetry.reset
+          @tabbed_plots.reset_all_data_objects
+        end
+        @tabbed_plots.resume
+
+        # Startup realtime thread
+        @realtime_button_bar.state = 'Connecting'
+        statusBar.showMessage(tr("Connecting to COSMOS Server"))
+        @realtime_thread = TabbedPlotsRealtimeThread.new(@tabbed_plots_config, method(:realtime_thread_connection_success_callback), method(:realtime_thread_connection_failed_callback), method(:realtime_thread_connection_lost_callback), method(:realtime_thread_fatal_exception_callback))
+      end
+    end # def handle_start
+
+    # Handle pause button
+    def handle_pause
+      if @realtime_thread
+        # Pause plotting
+        @tabbed_plots.pause
+        statusBar.showMessage(tr("Plot Updates Paused - Still Collecting Data in the Background"))
+        @realtime_button_bar.state = 'Paused'
+      else
+        # Do Nothing
+      end
+    end # def handle_pause
+
+    # Handle stop button
+    def handle_stop
+      @tabbed_plots.pause
+      if @realtime_thread
+        # Kill realtime thread
+        @realtime_thread.kill
+        @realtime_thread = nil
+        @realtime_button_bar.state = 'Stopped'
+        statusBar.showMessage(tr("Disconnection from COSMOS Server Successful"))
+      else
+        # Do Nothing
+      end
+    end # def handle_stop
+
+    ###############################################################################
+    # Realtime Thread Callbacks - Not executed in GUI context - No Direct GUI
+    #                             interaction allowed!
+    ###############################################################################
+
+    # Handle succesful realtime thread connection
+    def realtime_thread_connection_success_callback
+      # Notify user of connection success
+      Qt.execute_in_main_thread(true) do
+        statusBar.showMessage(tr("Connection to COSMOS Server Successful"))
+        if @tabbed_plots.paused?
+          @realtime_button_bar.state = 'Paused'
+        else
+          @realtime_button_bar.state = 'Running'
+        end
+      end
+    end # def realtime_thread_connection_success_callback
+
+    # Handle realtime thread connection failure
+    def realtime_thread_connection_failed_callback(error)
+      # Notify user connection failed
+      Qt.execute_in_main_thread(true) do
+        statusBar.showMessage(tr("Connection to COSMOS Server Failed : #{error.class} : #{error.message}"))
+        @realtime_button_bar.state = 'Connecting'
+      end
+    end # def realtime_thread_connection_failed_callback
+
+    # Handle realtime thread connection lost
+    def realtime_thread_connection_lost_callback(error)
+      # Notify user of connection lost
+      if error
+        Qt.execute_in_main_thread(true) do
+          statusBar.showMessage(tr("Connection to COSMOS Server Lost : #{error.class} : #{error.message}"))
+          @realtime_button_bar.state = 'Connecting'
+        end
+      else
+        Qt.execute_in_main_thread(true) do
+          statusBar.showMessage(tr("Connection to COSMOS Server Lost"))
+          @realtime_button_bar.state = 'Connecting'
+        end
+      end
+    end # def realtime_thread_connection_lost_callback
+
+    # Handle realtime thread fatal exception
+    def realtime_thread_fatal_exception_callback(error)
+      Cosmos.handle_fatal_exception(error)
+    end # def realtime_thread_fatal_exception_callback
+
+  end # class TabbedPlotsTool
+
+end # module Cosmos