cosmos 4.0.3-java

data/lib/cosmos/gui/dialogs/interface_raw_dialog.rb

@@ -0,0 +1,143 @@
+# encoding: ascii-8bit
+
+# Copyright 2017 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
+  # Creates a dialog showing the most recent raw data read and written by an interface
+  class InterfaceRawDialog < Qt::Dialog
+    slots 'data_update_timeout()'
+
+    # Dialog update period
+    DATA_UPDATE_PERIOD_MS = 1000
+    # Header string to display over the dump
+    HEADER = "Address   Data                                             Ascii\n"\
+             "---------------------------------------------------------------------------\n"
+
+    # @return [Qt::Font] Font to display the dialog dump (should be monospaced)
+    @@font = nil
+
+    # @param parent [Qt::Dialog] Parent for the dialog
+    # @param interface [Interface] Interface to get data from
+    def initialize(parent, interface)
+      super(parent, Qt::WindowTitleHint | Qt::WindowSystemMenuHint)
+
+      @interface = interface
+      @done = false
+
+      begin
+        title = "Interface #{@interface.name} Raw Data"
+        setWindowTitle(title)
+
+        @timer = Qt::Timer.new
+
+        overall_layout = Qt::VBoxLayout.new
+        top_layout = Qt::HBoxLayout.new
+        text_layout = Qt::VBoxLayout.new
+
+        title_label = Qt::Label.new(tr(title))
+        text_layout.addWidget(title_label)
+        @read_raw_data_time = Qt::Label.new("Read Raw Data Time: ")
+        text_layout.addWidget(@read_raw_data_time)
+        top_layout.addLayout(text_layout)
+        top_layout.addStretch(1)
+
+        button = Qt::PushButton.new(tr("Pause"))
+        top_layout.addWidget(button)
+        button.connect(SIGNAL('clicked()')) do
+          if button.text == "Pause"
+            button.setText("Resume")
+            @timer.method_missing(:stop)
+          else
+            button.setText("Pause")
+            @timer.method_missing(:start, DATA_UPDATE_PERIOD_MS)
+          end
+        end
+        overall_layout.addLayout(top_layout)
+
+        @read_raw_data = Qt::PlainTextEdit.new
+        @read_raw_data.setReadOnly(true)
+        @read_raw_data.setWordWrapMode(Qt::TextOption::NoWrap)
+        overall_layout.addWidget(@read_raw_data)
+        if Kernel.is_windows?
+          @@font = Cosmos.getFont('Courier', 10) unless @@font
+        else
+          @@font = Cosmos.getFont('Courier', 14) unless @@font
+        end
+        @read_format = @read_raw_data.currentCharFormat()
+        @read_format.setFont(@@font)
+        @read_raw_data.setCurrentCharFormat(@read_format)
+
+        @written_raw_data_time = Qt::Label.new("Written Raw Data Time: ")
+        overall_layout.addWidget(@written_raw_data_time)
+
+        @written_raw_data = Qt::PlainTextEdit.new
+        @written_raw_data.setReadOnly(true)
+        @written_raw_data.setWordWrapMode(Qt::TextOption::NoWrap)
+        overall_layout.addWidget(@written_raw_data)
+        if Kernel.is_windows?
+          @@font = Cosmos.getFont('Courier', 10) unless @@font
+        else
+          @@font = Cosmos.getFont('Courier', 14) unless @@font
+        end
+        @written_format = @written_raw_data.currentCharFormat()
+        @written_format.setFont(@@font)
+        @written_raw_data.setCurrentCharFormat(@written_format)
+
+        connect(@timer, SIGNAL('timeout()'), self, SLOT('data_update_timeout()'))
+        @timer.method_missing(:start, DATA_UPDATE_PERIOD_MS)
+        data_update_timeout()
+
+        self.setLayout(overall_layout)
+        self.resize(700, 280)
+        self.show
+        self.raise
+      rescue DRb::DRbConnError
+        # Just do nothing
+      end
+    end
+
+    # Callback to get the latest data and update the dialog
+    def data_update_timeout
+      @read_raw_data_time.setText("Read Raw Data Time: #{@interface.read_raw_data_time.formatted}") if @interface.read_raw_data_time
+      position_x = @read_raw_data.horizontalScrollBar.value
+      position_y = @read_raw_data.verticalScrollBar.value
+      @read_raw_data.setPlainText(HEADER + @interface.read_raw_data.formatted)
+      @read_raw_data.horizontalScrollBar.setValue(position_x)
+      @read_raw_data.verticalScrollBar.setValue(position_y)
+
+      @written_raw_data_time.setText("Written Raw Data Time: #{@interface.written_raw_data_time.formatted}") if @interface.written_raw_data_time
+      position_x = @written_raw_data.horizontalScrollBar.value
+      position_y = @written_raw_data.verticalScrollBar.value
+      @written_raw_data.setPlainText(HEADER + @interface.written_raw_data.formatted)
+      @written_raw_data.horizontalScrollBar.setValue(position_x)
+      @written_raw_data.verticalScrollBar.setValue(position_y)
+    end
+
+    def reject
+      super()
+      stop_timer if @timer
+      self.dispose
+    end
+
+    def closeEvent(event)
+      super(event)
+      stop_timer if @timer
+      self.dispose
+    end
+
+    def stop_timer
+      @timer.stop
+      @timer.dispose
+      @timer = nil
+    end
+  end
+end

data/lib/cosmos/gui/dialogs/legal_dialog.rb

@@ -0,0 +1,183 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos'
+require 'cosmos/gui/qt'
+require 'open3'
+
+module Cosmos
+  # Creates a dialog displaying the COSMOS copyright information. Also
+  # calculates CRC checks across the entire project to determine if any of the
+  # COSMOS core files have been modified. This ensures the COSMOS system has
+  # not been modified since the last release.
+  class LegalDialog < Qt::Dialog
+    def initialize
+      super() # MUST BE FIRST
+      Cosmos.load_cosmos_icon
+
+      self.window_title = 'Legal Agreement'
+      layout = Qt::VBoxLayout.new
+      self.layout = layout
+
+      legal_image_filename = File.join(::Cosmos::USERPATH, 'config', 'data', 'legal.gif')
+      legal_image_filename = File.join(::Cosmos::PATH, 'data', 'legal.gif') unless File.exist?(legal_image_filename)
+      pixmap = Qt::Pixmap.new(legal_image_filename)
+      label = Qt::Label.new
+      label.setPixmap(pixmap)
+      label.setFrameStyle(Qt::Frame::Box)
+      layout.addWidget(label)
+
+      version = Qt::Label.new("COSMOS Version: " + COSMOS_VERSION)
+      version.setFont(Cosmos.getFont("Arial", 14))
+      version_layout = Qt::HBoxLayout.new
+      version_layout.addWidget(version, 0, Qt::AlignCenter)
+      layout.addLayout(version_layout)
+
+      legal_text = ''
+      legal_text_filename = File.join(::Cosmos::USERPATH, 'config', 'data', 'legal.txt')
+      legal_text_filename = File.join(::Cosmos::PATH, 'data', 'legal.txt') unless File.exist?(legal_text_filename)
+      legal_text << File.read(legal_text_filename)
+      legal_text.strip!
+      legal_text.gsub!("\r", '') unless Kernel.is_windows?
+
+      legal_label = Qt::Label.new(legal_text)
+      legal_label.setWordWrap(true)
+      legal_label.setFrameStyle(Qt::Frame::Box)
+      legal_label.setStyleSheet("QLabel { background-color : white; padding: 5px; }");
+      layout.addWidget(legal_label)
+
+      @text_crc = Qt::TextEdit.new
+      @text_crc.setMinimumHeight(100)
+      @text_crc.setReadOnly(true)
+      @text_crc.setFrameStyle(Qt::Frame::Box)
+      layout.addWidget(@text_crc)
+
+      project_error_count = check_all_crcs()
+
+      ok_button = Qt::PushButton.new('Ok')
+      connect(ok_button, SIGNAL('clicked()'), self, SLOT('accept()'))
+
+      update_crc_button = Qt::PushButton.new('Update Project CRCs')
+      update_crc_button.connect(SIGNAL('clicked()')) do
+        Cosmos.set_working_dir do
+          output, status = Open3.capture2e("rake crc")
+          project_error_count = check_all_crcs()
+          if status.success?
+            Qt::MessageBox.information(self, 'Success', 'Project CRCs updated successfully')
+          else
+            Qt::MessageBox.critical(self, 'Error', "Project CRCs update failed.\n\n#{output}")
+          end
+        end
+      end
+
+      cancel_button = Qt::PushButton.new('Cancel')
+      connect(cancel_button, SIGNAL('clicked()'), self, SLOT('reject()'))
+
+      hlayout = Qt::HBoxLayout.new
+      hlayout.addWidget(ok_button, 0, Qt::AlignLeft)
+      hlayout.addWidget(update_crc_button, 0, Qt::AlignCenter) if update_crc_button
+      hlayout.addWidget(cancel_button, 0, Qt::AlignRight)
+      layout.addLayout(hlayout)
+
+      self.show()
+      self.raise()
+      result = exec()
+      dispose()
+      exit if result != Qt::Dialog::Accepted
+    end
+
+    # Opens all the files listed in <Cosmos::PATH>/data/crc.txt and calculates their CRCs
+    # against what is listed in the file to detect any modifications. Also
+    # opens all files listed in <Cosmos::USERPATH/config/data/crc.txt to verify
+    # the user defined COSMOS configuration files.
+    #
+    # @return [String] Either a success message or warning about all files
+    #   which did not match their expected CRCs.
+    def check_all_crcs
+      result_text = ''
+      missing_text = ''
+      core_file_count, core_error_count, _, _ = check_crcs(::Cosmos::PATH, File.join(::Cosmos::PATH, 'data', 'crc.txt'), result_text, missing_text, 'CORE')
+      project_file_count = 0
+      project_error_count = 0
+      official = true
+      if File.exist?(File.join(::Cosmos::USERPATH, 'config', 'data', 'crc.txt'))
+        project_file_count, project_error_count, _, official = check_crcs(::Cosmos::USERPATH, File.join(::Cosmos::USERPATH, 'config', 'data', 'crc.txt'), result_text, missing_text, 'PROJECT')
+      end
+
+      final_text = ''
+      if (core_error_count == 0) && (project_error_count == 0)
+        if missing_text.empty? && official
+          @text_crc.setTextColor(Cosmos::GREEN)
+        else
+          @text_crc.setTextColor(Cosmos::YELLOW)
+        end
+        result_text = "COSMOS Verified #{core_file_count} Core and #{project_file_count} Project CRCs\n"
+        final_text = result_text + missing_text
+      else
+        @text_crc.setTextColor(Cosmos::YELLOW)
+        if core_error_count > 0
+          if project_error_count > 0
+            final_text = "Warning: #{core_error_count} Core and #{project_error_count} Project CRC checks failed!\n" << result_text << missing_text
+          else
+            final_text = "Warning: #{core_error_count} Core CRC checks failed!\n" << result_text << missing_text
+          end
+        else # project_error_count > 0
+          final_text = "Warning: #{project_error_count} Project CRC checks failed!\n" << result_text << missing_text
+        end
+      end
+      final_text = "Warning: Project CRC file updated by user\n  Remove USER_MODIFIED from config/data/crc.txt to clear this warning\n" << final_text unless official
+      @text_crc.text = final_text
+
+      return project_error_count
+    end
+
+    # @param base_path [String] Path to prepend to all the files in crc.txt
+    # @param filename [String] Full path to the crc.txt file
+    # @param result_text [String] String to append results of CRC checks
+    # @param missing_text [String] String to append missing files
+    # @param file_type [String] Whether the COSMOS core or project files. Must
+    #   be 'CORE' or 'PROJECT'.
+    def check_crcs(base_path, filename, result_text, missing_text, file_type)
+      file_count = 0
+      error_count = 0
+      missing_count = 0
+      official = true
+      crc = Crc32.new(Crc32::DEFAULT_POLY, Crc32::DEFAULT_SEED, true, false)
+      File.open(filename, 'r') do |file|
+        file.each_line do |line|
+          split_line = line.strip.scan(ConfigParser::PARSING_REGEX)
+          if split_line[0] == 'USER_MODIFIED'
+            official = false
+            next
+          end
+          filename = File.join(base_path, split_line[0].remove_quotes)
+          if File.exist?(filename)
+            expected_crc = Integer(split_line[1])
+            file_data = nil
+            File.open(filename, 'rb') do |crc_file|
+              file_data = crc_file.read.gsub("\x0D\x0A", "\x0A")
+            end
+            file_crc = crc.calc(file_data)
+            filename = filename.gsub(base_path + '/', '')
+            if file_crc != expected_crc
+              result_text << "#{file_type} #{filename}\n  CRC Expected: #{sprintf("0x%08X", expected_crc)}, CRC Calculated: #{sprintf("0x%08X", file_crc)}\n"
+              error_count += 1
+            end
+            file_count += 1
+          else
+            missing_text << "#{file_type} #{filename} is missing\n"
+            missing_count += 1
+          end
+        end
+      end
+      return file_count, error_count, missing_count, official
+    end
+  end
+end

data/lib/cosmos/gui/dialogs/packet_log_dialog.rb

@@ -0,0 +1,97 @@
+# 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
+
+# This file contains the implementation of the PacketLogDialog class.   This class
+# provides a dialog box to process log files.
+
+require 'cosmos'
+require 'cosmos/gui/qt'
+require 'cosmos/gui/widgets/packet_log_frame'
+
+module Cosmos
+  # Creates a dialog to allow a user to browse for a COSMOS log and select the
+  # time period to process.
+  class PacketLogDialog < Qt::Dialog
+    extend Forwardable
+    def_delegators :@packet_log_frame, :filenames, :time_start, :time_start=,\
+      :time_end, :time_end=, :packet_log_reader
+
+    # @param parent (see PacketLogFrame#initialize)
+    # @param title [String] Dialog title
+    # @param log_directory (see PacketLogFrame#initialize)
+    # @param packet_log_reader (see PacketLogFrame#initialize)
+    # @param initial_filenames (see PacketLogFrame#initialize)
+    # @param initial_output_filename (see PacketLogFrame#initialize)
+    # @param show_output_filename (see PacketLogFrame#initialize)
+    # @param show_time (see PacketLogFrame#initialize)
+    # @param show_log_reader (see PacketLogFrame#initialize)
+    # @param input_filename_filter (see PacketLogFrame#initialize)
+    # @param output_filename_filter (see PacketLogFrame#initialize)
+    # @param multiple_file_select (see PacketLogFrame#initialize)
+    def initialize(parent,
+                   title,
+                   log_directory,
+                   packet_log_reader,
+                   initial_filenames = [],
+                   initial_output_filename = nil,
+                   show_output_filename = false,
+                   show_time = true,
+                   show_log_reader = true,
+                   input_filename_filter = Cosmos::BIN_FILE_PATTERN,
+                   output_filename_filter = Cosmos::BIN_FILE_PATTERN,
+                   multiple_file_select = true)
+      super(parent)
+      setWindowTitle(title)
+
+      @layout = Qt::VBoxLayout.new
+      @packet_log_frame = PacketLogFrame.new(self,
+                                             log_directory,
+                                             packet_log_reader,
+                                             initial_filenames,
+                                             initial_output_filename,
+                                             show_output_filename,
+                                             show_time,
+                                             show_log_reader,
+                                             input_filename_filter,
+                                             output_filename_filter,
+                                             multiple_file_select)
+      @packet_log_frame.change_callback = method(:change_callback)
+      @layout.addWidget(@packet_log_frame)
+
+      # Separator before buttons
+      @sep1 = Qt::Frame.new(self)
+      @sep1.setFrameStyle(Qt::Frame::HLine | Qt::Frame::Sunken)
+      @layout.addWidget(@sep1)
+
+      # Create OK and Cancel buttons
+      @button_layout = Qt::HBoxLayout.new
+      @ok_button = Qt::PushButton.new('OK')
+      @ok_button.connect(SIGNAL('clicked()')) { System.telemetry.reset; self.accept }
+      @ok_button.setEnabled(false) if initial_filenames.empty?
+      @button_layout.addWidget(@ok_button)
+      @cancel_button = Qt::PushButton.new('Cancel')
+      @cancel_button.connect(SIGNAL('clicked()')) { self.reject }
+      @button_layout.addWidget(@cancel_button)
+
+      @layout.addLayout(@button_layout)
+      setLayout(@layout)
+    end
+
+    protected
+
+    def change_callback(item_changed)
+      if @packet_log_frame.filenames.empty?
+        @ok_button.setEnabled(false)
+      else
+        @ok_button.setEnabled(true)
+      end
+    end
+  end
+end

data/lib/cosmos/gui/dialogs/progress_dialog.rb

@@ -0,0 +1,313 @@
+# 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
+
+# This file contains the implementation and ProgressDialog class.
+
+require 'cosmos'
+require 'cosmos/gui/qt'
+require 'cosmos/gui/dialogs/exception_dialog'
+
+module Cosmos
+  # Dialog which shows a progress bar. Optionally can display two progress
+  # bars: one for overall progress and one for a sub-task. Can also optionally
+  # display informational text.
+  class ProgressDialog < Qt::Dialog
+    # @return [#call] Called when the dialog is canceled. Passed the current
+    #   instance of the ProgressDialog
+    attr_accessor :cancel_callback
+    # @return [Thread] Ruby thread associated with this dialog. If specified,
+    #   it will automatically be killed if the dialog is canceled.
+    attr_accessor :thread
+    # Accessor to set the complete flag
+    attr_writer :complete
+
+    slots 'append_text(const QString&)'
+    slots 'set_step_progress(int)'
+    slots 'set_overall_progress(int)'
+
+    # @param parent [Qt::Widget] Parent of this dialog
+    # @param title [String] Dialog title
+    # @param width [Integer] Dialog width
+    # @param height [Integer] Dialog height
+    # @param show_overall [Boolean] Whether to show the overall progress bar
+    # @param show_step [Boolean] Whether to show the individual step progress
+    #   bar
+    # @param show_text [Boolean] Whether to show informational text along with
+    #   the progress bar
+    # @param show_done [Boolean] Whether to show a "Done" button which closes
+    #   the dialog once the progress is complete
+    # @param show_cancel [Boolean] Whether to show a "Cancel" button which
+    #   cancels and closes the dialog
+    def initialize(parent,
+                   title,
+                   width = 500,
+                   height = 300,
+                   show_overall = true,
+                   show_step = true,
+                   show_text = true,
+                   show_done = true,
+                   show_cancel = true)
+      if show_cancel
+        super(parent)
+      else
+        super(parent, Qt::CustomizeWindowHint | Qt::WindowTitleHint)
+      end
+      setWindowTitle(title)
+      setMinimumWidth(width)
+      setMinimumHeight(height)
+      @overall_bar = nil
+      @step_bar = nil
+      @progress_text = nil
+      @done_button = nil
+      @cancel_button = nil
+      @@canceled = false
+      @complete = false
+
+      @overall = Qt::HBoxLayout.new
+      @overall_bar = nil
+      if show_overall
+        # Create Overall progress bar
+        @overall_bar = Qt::ProgressBar.new
+        @overall_bar.setMaximum(100)
+        @overall_label = Qt::Label.new("Overall Progress: ")
+        @overall.addWidget(@overall_label)
+        @overall.addWidget(@overall_bar)
+      end
+
+      @step = Qt::HBoxLayout.new
+      @step_bar = nil
+      if show_step
+        # Create Step progress bar
+        @step_bar = Qt::ProgressBar.new
+        @step_bar.setMaximum(100)
+        @step_label = Qt::Label.new("Step Progress: ")
+        @step.addWidget(@step_label)
+        @step.addWidget(@step_bar)
+      end
+
+      @progress_text = nil
+      if show_text
+        # Create Progress Text Notifications
+        @progress_text = Qt::PlainTextEdit.new
+        @progress_text.setReadOnly(true)
+        @progress_text.setMaximumBlockCount(100)
+      end
+
+      @button_layout = Qt::HBoxLayout.new
+      @done_button = nil
+      if show_done
+        # Create Done Button
+        @done_button = Qt::PushButton.new('Done')
+        @done_button.connect(SIGNAL('clicked()')) { self.close_done }
+        @done_button.setEnabled(false)
+        @button_layout.addWidget(@done_button)
+      end
+
+      @cancel_button = nil
+      if show_cancel
+        # Create Cancel Button
+        @cancel_button = Qt::PushButton.new('Cancel')
+        @cancel_button.connect(SIGNAL('clicked()')) { self.close_cancel }
+        @cancel_button.setEnabled(false)
+        @button_layout.addWidget(@cancel_button)
+      end
+
+      @top_layout = Qt::VBoxLayout.new
+      @top_layout.addLayout(@overall) if show_overall
+      @top_layout.addLayout(@step) if show_step
+      @top_layout.addWidget(@progress_text) if show_text
+      @top_layout.addLayout(@button_layout) if show_done || show_cancel
+
+      setLayout(@top_layout)
+
+      @thread = nil
+      @cancel_callback = nil
+      @overall_progress = 0
+      @step_progress = 0
+    end
+
+    # @return [Boolean] Whether this dialog was canceled
+    def self.canceled?
+      @@canceled
+    end
+
+    # @return [Boolean] Whether this dialog was canceled
+    def canceled?
+      @@canceled
+    end
+
+    # @return [Boolean] Whether this dialog successfully completed
+    def complete?
+      @complete
+    end
+
+    # Enable the cancel button if it was specified
+    def enable_cancel_button
+      Qt.execute_in_main_thread(true) do
+        @cancel_button.setEnabled(true) if @cancel_button
+      end
+    end
+
+    # Set complete to true and close the dialog
+    def close_done
+      Qt.execute_in_main_thread(true) do
+        @complete = true
+        self.done(0) unless self.disposed?
+      end
+    end
+
+    # Call the cancel_callback if given to determine how to proceed. Set
+    # canceled to true and kill any associated threads.
+    def close_cancel
+      Qt.execute_in_main_thread(true) do
+        kill_thread = true
+        if @cancel_callback
+          continue_cancel, kill_thread = @cancel_callback.call(self)
+          return unless continue_cancel
+        end
+        @@canceled = true
+        Thread.new do
+          if @thread
+            Cosmos.kill_thread(self, @thread) if kill_thread
+            @thread.join
+          end
+          @thread = nil
+
+          close_done()
+        end
+      end
+    end
+
+    # Empty method to remove warning
+    # @comment TODO: What warning? How does this manifest?
+    def graceful_kill
+    end
+
+    # @param font [Font] Font to apply on the progress text
+    def set_text_font(font)
+      @progress_text.setFont(font)
+    end
+
+    # @param text [String] Text to append to the progress text
+    def append_text(text)
+      unless @complete
+        Qt.execute_in_main_thread(false) do
+          if @progress_text
+            @progress_text.appendPlainText(text)
+            @progress_text.ensureCursorVisible
+          end
+        end
+      end
+    end
+
+    # Mark the dialog complete by enabling the Done and Cancel button if they
+    # were specified. This method does NOT close the dialog automatically.
+    def complete
+      Qt.execute_in_main_thread(true) do
+        @done_button.setEnabled(true) if @done_button
+        @cancel_button.setEnabled(true) if @cancel_button
+      end
+    end
+
+    # @comment TODO: Rename to step_progress=
+    # @param value [Float] Fraction from 0 to 1 of the current step that is
+    #   complete.
+    def set_step_progress(value)
+      progress_int = (value * 100).to_i
+      if !@complete && @step_progress != progress_int
+        @step_progress = progress_int
+        Qt.execute_in_main_thread(false) do
+          @step_bar.setValue(progress_int) if @step_bar
+        end
+      end
+    end
+
+    # @comment TODO: Rename to overall_progress=
+    # @param value [Float] Fraction from 0 to 1 of the overall progress that is
+    #   complete.
+    def set_overall_progress(value)
+      progress_int = (value * 100).to_i
+      if !@complete && @overall_progress != progress_int
+        @overall_progress = progress_int
+        Qt.execute_in_main_thread(false) do
+          @overall_bar.setValue(progress_int) if @overall_bar
+        end
+      end
+    end
+
+    # @comment TODO: Rename to step_progress
+    # @return [Float] Fraction from 0 to 1 of the step progress that is
+    #   complete
+    def get_step_progress
+      result = nil
+      Qt.execute_in_main_thread(true) do
+        result = (@step_bar.value.to_f / 100.0) if @step_bar
+      end
+      return result
+    end
+
+    # @comment TODO: Rename to overall_progress
+    # @return [Float] Fraction from 0 to 1 of the overall progress that is
+    #   complete
+    def get_overall_progress
+      result = nil
+      Qt.execute_in_main_thread(true) do
+        result = (@overall_bar.value.to_f / 100.0) if @overall_bar
+      end
+      return result
+    end
+
+    # (see #initialize)
+    def self.execute(parent,
+                     title,
+                     width = 500,
+                     height = 300,
+                     show_overall = true,
+                     show_step = true,
+                     show_text = true,
+                     show_done = true,
+                     show_cancel = true)
+      # Create a non-modal dialog by default
+      dialog = ProgressDialog.new(parent, title, width, height, show_overall, show_step, show_text, show_done, show_cancel)
+      dialog.setModal(true)
+      dialog.raise
+
+      dialog.thread = Thread.new do
+        dialog.thread = Thread.current
+        dialog.complete = false
+
+        begin
+          yield dialog
+        rescue Exception => error
+          Qt.execute_in_main_thread(true) do
+            # If something bad happened during the yield we'll show the error
+            # but not exit the application. Once the block has completed we
+            # hide and dispose the dialog to allow the main application to run
+            dialog.hide
+            ExceptionDialog.new(parent, error, "Error During Progress", false)
+          end
+        end
+
+        dialog.thread = nil
+        dialog.complete = true
+      end
+      dialog.exec
+      Cosmos.kill_thread(dialog, dialog.thread)
+      dialog.thread = nil
+      dialog.complete = true
+
+      # Need to make sure all Qt.execute_in_main_thread() have completed before
+      # disposing or we will segfault
+      Qt::RubyThreadFix.queue.pop.call until Qt::RubyThreadFix.queue.empty?
+
+      dialog.dispose
+    end
+  end
+end