cosmos 3.0.0

data/lib/cosmos/gui/widgets/full_text_search_line_edit.rb

@@ -0,0 +1,161 @@
+# 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
+
+module Cosmos
+  class FullTextSearchLineEdit < Qt::LineEdit
+
+    attr_accessor :completion_list
+    attr_accessor :callback
+
+    def initialize(parent)
+      super(parent)
+      @listView = Qt::ListWidget.new(parent)
+      @listView.setWindowFlags(0xc | 0x1) # Qt::ToolTip
+      @completion_list = []
+      @filtered_list = []
+      @callback = nil
+      connect(self, SIGNAL("textChanged(const QString &)")) do |text|
+        handleTextChanged()
+      end
+      connect(@listView, SIGNAL("itemClicked(QListWidgetItem*)")) do |item|
+        text = item.text
+        setText(text)
+        @callback.call(text) if @callback
+        @listView.hide
+      end
+    end
+
+    def focusOutEvent(e)
+      Qt.execute_in_main_thread(false, 0.001, true) do
+        unless @listView.hasFocus
+          @listView.hide
+        end
+      end
+      super(e)
+    end
+
+    def keyPressEvent(e)
+      key = e.key
+      if !@listView.isHidden
+        count = @filtered_list.length
+        row = @listView.currentRow
+
+        # Move through list
+        if (key == Qt::Key_Down || key == Qt::Key_Up)
+          case(key)
+          when Qt::Key_Down
+            row += 1
+            row = 0 if row >= count
+          when Qt::Key_Up
+            row -= 1
+            row = count - 1 if row < 0
+          end
+
+          if @listView.isEnabled
+            @listView.setCurrentRow(row)
+          end
+
+        # Accept choice
+        elsif ((Qt::Key_Enter == key || Qt::Key_Return == key) && @listView.isEnabled)
+          if row >= 0
+            text = @listView.item(row).text
+            setText(text)
+            @listView.hide
+            handleTextChanged()
+            @callback.call(text) if @callback
+            @listView.hide
+          else
+            super(e)
+          end
+
+        # Cancel
+        elsif Qt::Key_Escape == key
+          @listView.hide
+
+        # More data entry
+        else
+          @listView.hide
+          super(e)
+        end
+
+      else
+        # Up/down potentially after cancel
+        if (key == Qt::Key_Down || key == Qt::Key_Up)
+          handleTextChanged()
+
+          if !@listView.isHidden
+            case(key)
+            when Qt::Key_Down
+              row = 0
+            when Qt::Key_Up
+              row = @filtered_list.length - 1
+            end
+
+            if @listView.isEnabled
+              @listView.setCurrentRow(row)
+            end
+          end
+
+        # More data entry
+        else
+          if ((Qt::Key_Enter == key || Qt::Key_Return == key))
+            @callback.call(self.text) if @callback
+            @listView.hide
+          end
+          super(e)
+        end
+      end
+    end
+
+    def handleTextChanged
+      text = self.text
+      if text.empty?
+        @listView.hide
+        return
+      end
+
+      updateFilteredList(text)
+
+      if @filtered_list.length == 0 or (@filtered_list.length ==1 and text == @filtered_list[0])
+        @listView.hide
+        return
+      end
+
+      maxVisibleRows = 10
+      p = Qt::Point.new(0, height())
+      x = mapToGlobal(p).x
+      y = mapToGlobal(p).y + 1
+      p.dispose
+      @listView.move(x, y)
+      @listView.setMinimumWidth(width())
+      @listView.setMaximumWidth(width())
+      if @filtered_list.length > maxVisibleRows
+        @listView.setFixedHeight(maxVisibleRows * (@listView.fontMetrics.height + 2) + 2)
+      else
+        @listView.setFixedHeight((@filtered_list.length + 1) * (@listView.fontMetrics.height + 2) + 2)
+      end
+
+      @listView.show
+      @listView.raise
+    end
+
+    def updateFilteredList(text)
+      @filtered_list = []
+      regex = Regexp.new(Regexp.quote(text), Regexp::IGNORECASE)
+      @completion_list.each do |string|
+        @filtered_list << string if string =~ regex
+      end
+      @listView.clear
+      @listView.addItems(@filtered_list)
+      @listView.setCurrentRow(0) if @filtered_list.length > 0
+    end
+
+  end # class FullTextSearchLineEdit
+end # module Cosmos

data/lib/cosmos/gui/widgets/packet_log_frame.rb

@@ -0,0 +1,305 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos'
+require 'cosmos/gui/qt'
+require 'cosmos/gui/dialogs/calendar_dialog'
+
+module Cosmos
+
+  class PacketLogFrame < Qt::Widget
+
+    # Start time of packets to process
+    attr_reader :time_start
+
+    # End time of packets to process
+    attr_reader :time_end
+
+    # Log reader to use
+    attr_reader :packet_log_reader
+
+    # Output filename filter
+    attr_accessor :output_filename_filter
+
+    # Callback called when something changes
+    attr_accessor :change_callback
+
+    def initialize(parent,
+                   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)
+      super(parent)
+
+      @output_select = :FILE
+      @input_filename_filter = input_filename_filter
+      @output_filename_filter = output_filename_filter
+      @log_directory = log_directory
+      if initial_output_filename
+        @output_directory = File.dirname(initial_output_filename)
+      else
+        @output_directory = log_directory.clone
+      end
+      @packet_log_reader = packet_log_reader
+      @time_start = nil
+      @time_end = nil
+      @change_callback = nil
+
+      @layout = Qt::GridLayout.new
+      @layout.setContentsMargins(0,0,0,0)
+
+      row = 0
+
+      # Chooser for Log Files
+      label = Qt::Label.new('Log Files:')
+      @layout.addWidget(label, row, 0, 1, 2)
+      @browse_button = Qt::PushButton.new('Browse...')
+      @browse_button.connect(SIGNAL('clicked()')) { handle_browse_button() }
+      @layout.addWidget(@browse_button, row, 2)
+      @remove_button = Qt::PushButton.new('Remove')
+      @remove_button.connect(SIGNAL('clicked()')) { handle_remove_button() }
+      @layout.addWidget(@remove_button, row, 3)
+      row += 1
+
+      @filenames = Qt::ListWidget.new(self)
+      @filenames.setSelectionMode(Qt::AbstractItemView::ExtendedSelection)
+      @filenames.setSortingEnabled(true)
+      initial_filenames.each {|filename| @filenames.addItem(filename)}
+      @filenames.setMinimumHeight(90)
+      @layout.addWidget(@filenames, row, 0, 3, 4)
+      row += 3
+
+      if show_output_filename
+        @output_filename_label = Qt::Label.new('Output File:')
+        @layout.addWidget(@output_filename_label, row, 0)
+        @output_filename = Qt::LineEdit.new(initial_output_filename.to_s)
+        @output_filename.setMinimumWidth(340)
+        @output_filename.setReadOnly(true)
+        @layout.addWidget(@output_filename, row, 1, 1, 2)
+        @output_filename_select_button = Qt::PushButton.new('Select')
+        @output_filename_select_button.connect(SIGNAL('clicked()')) { handle_output_file_button() }
+        @layout.addWidget(@output_filename_select_button, row, 3)
+        row += 1
+      end
+
+      @time_start_field = Qt::LineEdit.new('N/A')
+      @time_end_field = Qt::LineEdit.new('N/A')
+      if show_time
+        %w(Start End).each do |time|
+          time_label = Qt::Label.new("Time Period #{time}:")
+          @layout.addWidget(time_label, row, 0)
+          if time == 'Start'
+            time_field = @time_start_field
+          else
+            time_field = @time_end_field
+          end
+          time_field.setMinimumWidth(340)
+          time_field.setReadOnly(true)
+          @layout.addWidget(time_field, row, 1)
+          time_clear_button = Qt::PushButton.new('Clear')
+          time_clear_button.connect(SIGNAL('clicked()')) { handle_time_clear_button(time, time_field) }
+          @layout.addWidget(time_clear_button, row, 2)
+          time_button = Qt::PushButton.new('Select')
+          time_button.connect(SIGNAL('clicked()')) { handle_time_select_button(time, time_field) }
+          @layout.addWidget(time_button, row, 3)
+          row += 1
+        end
+      end
+
+      if show_log_reader
+        @packet_log_reader = PacketLogReader.new unless @packet_log_reader
+
+        # Chooser or label for log reader
+        label = Qt::Label.new('Packet Log Reader:')
+        @layout.addWidget(label, row, 0)
+        @packet_log_reader_field = Qt::LineEdit.new(@packet_log_reader.class.to_s)
+        @packet_log_reader_field.setMinimumWidth(340)
+        @packet_log_reader_field.setReadOnly(true)
+        @layout.addWidget(@packet_log_reader_field, row, 1, 1, 2)
+        select_button = Qt::PushButton.new('Select')
+        select_button.connect(SIGNAL('clicked()')) { handle_log_reader_button() }
+        @layout.addWidget(select_button, row, 3)
+        row += 1
+      end
+
+      setLayout(@layout)
+    end # def initialize
+
+    # Returns the chosen filenames
+    def filenames
+      filename_array = []
+      @filenames.each {|list_item| filename_array << list_item.text}
+      filename_array
+    end
+
+    # Return the output filename
+    def output_filename
+      @output_filename.text
+    end
+
+    # Set the output filename
+    def output_filename= (new_output_filename)
+      @output_filename.setText(new_output_filename.to_s)
+    end
+
+    def select_output_file
+      @output_filename_label.text = 'Output File:'
+      @output_select = :FILE
+    end
+
+    def select_output_dir
+      @output_filename_label.text = 'Output Dir:'
+      @output_select = :DIR
+    end
+
+    # Set the start time
+    def time_start=(new_time_start)
+      @time_start = new_time_start
+      if @time_start
+        @time_start_field.setText(@time_start.formatted)
+      else
+        @time_start_field.setText('N/A')
+      end
+    end
+
+    # Set the end time
+    def time_end=(new_time_end)
+      @time_end = new_time_end
+      if @time_end
+        @time_end_field.setText(@time_end.formatted)
+      else
+        @time_end_field.setText('N/A')
+      end
+    end
+
+    protected
+
+    # Handles removing a selected filename
+    def handle_remove_button
+      @filenames.remove_selected_items
+      @change_callback.call(:INPUT_FILES) if @change_callback
+    end
+
+    # Handles browsing for log files
+    def handle_browse_button
+      Cosmos.set_working_dir do
+        filenames = Qt::FileDialog::getOpenFileNames(
+          self, "Select Log File(s):", @log_directory, @input_filename_filter)
+        if filenames and not filenames.empty?
+          @log_directory.replace(File.dirname(filenames[0]) + '/')
+          filenames.each {|filename| @filenames.addItem(filename) if @filenames.findItems(filename, Qt::MatchExactly).empty? }
+        end
+        @change_callback.call(:INPUT_FILES) if @change_callback
+      end
+    end
+
+    # Handles browsing for output file
+    def handle_output_file_button
+      Cosmos.set_working_dir do
+        if @output_select == :FILE
+          if @output_filename.text.strip != ''
+            filename = Qt::FileDialog::getSaveFileName(
+              self, "Select Output File:", @output_filename.text, @output_filename_filter)
+          else
+            filename = Qt::FileDialog::getSaveFileName(
+              self, "Select Output File:", @output_directory, @output_filename_filter)
+          end
+          if filename and not filename.empty?
+            @output_filename.setText(filename)
+            @output_directory.replace(File.dirname(filename))
+          end
+          @change_callback.call(:OUTPUT_FILE) if @change_callback
+        else
+          if @output_filename.text.strip != ''
+            filename = Qt::FileDialog::getExistingDirectory(
+              self, "Select Output Dir:", @output_filename.text)
+          else
+            filename = Qt::FileDialog::getExistingDirectory(
+              self, "Select Output File:", @output_directory)
+          end
+          if filename and not filename.empty?
+            @output_filename.setText(filename)
+            @output_directory.replace(File.dirname(filename))
+          end
+          @change_callback.call(:OUTPUT_DIR) if @change_callback
+        end
+      end
+    end
+
+    # Handles choosing a time
+    def handle_time_select_button(time_period, time_field)
+      if time_period == 'Start'
+        time = @time_start
+        time = @time_end unless @time_start
+      else
+        time = @time_end
+        time = @time_start unless @time_end
+      end
+      dialog = CalendarDialog.new(self, "Select Time Period #{time_period}:", time)
+      case dialog.exec
+      when Qt::Dialog::Accepted
+        time_field.setText(dialog.time.formatted)
+        if time_period == 'Start'
+          @time_start = dialog.time
+          @change_callback.call(:TIME_START) if @change_callback
+        else
+          @time_end = dialog.time
+          @change_callback.call(:TIME_END) if @change_callback
+        end
+      end
+    end
+
+    # Clears the time
+    def handle_time_clear_button(time_period, time_field)
+      current_text = time_field.text
+      time_field.setText('N/A')
+      if time_period == 'Start'
+        @time_start = nil
+        @change_callback.call(:TIME_START) if @change_callback and current_text != 'N/A'
+      else
+        @time_end = nil
+        @change_callback.call(:TIME_END) if @change_callback and current_text != 'N/A'
+      end
+    end
+
+    # Handles choosing a log reader
+    def handle_log_reader_button
+      Cosmos.set_working_dir do
+        log_reader_class_name = @packet_log_reader.class.to_s
+        log_reader_file_name = log_reader_class_name.class_name_to_filename
+        filename = File.find_in_search_path(log_reader_file_name)
+        if filename
+          log_reader_directory = filename
+        else
+          log_reader_directory = File.join(Cosmos::USERPATH, 'lib')
+          log_reader_directory << '/'
+        end
+        filename = Qt::FileDialog::getOpenFileName(self, "Select Packet Log Reader:", log_reader_directory, "Ruby File (*.rb);;All Files (*)")
+        if filename and not filename.empty? and filename =~ /_log_reader\.rb/
+          begin
+            packet_log_reader_class = Cosmos.require_class(filename)
+            @packet_log_reader = packet_log_reader_class.new
+            @packet_log_reader_field.setText(@packet_log_reader.class.to_s)
+          rescue Exception
+            # No change
+          end
+        end
+        @change_callback.call(:LOG_READER) if @change_callback
+      end
+    end
+
+  end # class PacketLogFrame
+
+end # module Cosmos

data/lib/cosmos/gui/widgets/realtime_button_bar.rb

@@ -0,0 +1,98 @@
+# 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 RealtimeButtonBar
+# This provides a reusable set of realtime controls.
+
+require 'cosmos'
+require 'cosmos/gui/qt'
+
+module Cosmos
+
+  # RealtimeButtonBar class
+  #
+  # This class implements the RealtimeButtonBar
+  #
+  class RealtimeButtonBar < Qt::Widget
+
+    # Accessors for callbacks
+    attr_accessor :start_callback
+    attr_accessor :pause_callback
+    attr_accessor :stop_callback
+
+    # Readers for buttons
+    attr_reader :start_button
+    attr_reader :pause_button
+    attr_reader :stop_button
+
+    # Constructor
+    def initialize (parent, orientation = Qt::Horizontal)
+      super(parent)
+      if orientation == Qt::Horizontal
+        # Horizontal Frame for overall widget
+        @overall_frame = Qt::HBoxLayout.new(self)
+        @state = Qt::LineEdit.new
+      else
+        # Vertical Frame for overall widget
+        @overall_frame = Qt::VBoxLayout.new(self)
+        @state = Qt::LineEdit.new
+      end
+      @overall_frame.setContentsMargins(0,0,0,0)
+      @state.setAlignment(Qt::AlignCenter)
+      @state.setText('Connecting')
+      @state.setReadOnly(true)
+      @overall_frame.addWidget(@state)
+
+      if orientation == Qt::Horizontal
+        @overall_frame.addStretch
+        # Buttons
+        @stop_button  = Qt::PushButton.new('Stop')
+        @pause_button = Qt::PushButton.new('Pause')
+        @start_button = Qt::PushButton.new('Start')
+        @overall_frame.addWidget(@start_button)
+        @overall_frame.addWidget(@pause_button)
+        @overall_frame.addWidget(@stop_button)
+      else
+        # Buttons
+        @button_frame = Qt::HBoxLayout.new
+        @start_button = Qt::PushButton.new('Start')
+        @pause_button = Qt::PushButton.new('Pause')
+        @stop_button  = Qt::PushButton.new('Stop')
+        @button_frame.addWidget(@start_button)
+        @button_frame.addWidget(@pause_button)
+        @button_frame.addWidget(@stop_button)
+        @overall_frame.addLayout(@button_frame)
+      end
+
+      setLayout(@overall_frame)
+
+      # Connect handlers
+      @stop_button.connect(SIGNAL('clicked()')) { @stop_callback.call if @stop_callback }
+      @pause_button.connect(SIGNAL('clicked()'))  { @pause_callback.call if @pause_callback }
+      @start_button.connect(SIGNAL('clicked()'))  { @start_callback.call if @start_callback }
+
+      @start_callback = nil
+      @pause_callback = nil
+      @stop_callback  = nil
+    end
+
+    # Returns the text in the state field
+    def state
+      return @state.text
+    end
+
+    # Sets the text in the state field
+    def state= (new_state)
+      @state.setText(new_state.to_s)
+    end
+
+  end # class RealtimeButtonBar
+
+end # module Cosmos

data/lib/cosmos/interfaces/cmd_tlm_server_interface.rb

@@ -0,0 +1,149 @@
+# 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/interfaces/interface'
+
+module Cosmos
+
+  # Allows commands to be sent and telemetry received from the the
+  # CmdTlmServer.
+  class CmdTlmServerInterface < Interface
+
+    # Create the interface and disallow raw writes
+    def initialize
+      super()
+      @raw_logger_pair = nil
+      @write_raw_allowed = false
+      @limit_id = nil
+    end
+
+    # Start the limits event subscription
+    def connect
+      @limit_id = CmdTlmServer.instance.subscribe_limits_events
+    end
+
+    # @return [Boolean] Always returns true
+    def connected?
+      if @limit_id
+        return true
+      else
+        return false
+      end
+    end
+
+    # Read from the CmdTlmServer interface by first getting the COSMOS VERSION
+    # packet and then continuously waiting for limits events and returning
+    # COSMOS LIMITS_CHANGE packets.
+    #
+    # @return [Packet] Initially returns the COSMOS VERSION packet and then
+    #   returns COSMOS LIMITS_CHANGE packets as limits events are generated.
+    def read
+      if @read_count == 0
+        begin
+          packet = System.telemetry.packet("COSMOS","VERSION")
+          packet.write('PKT_ID',1)
+          packet.write('COSMOS', Cosmos::VERSION)
+          packet.write('RUBY', "#{RUBY_VERSION}p#{RUBY_PATCHLEVEL}")
+          packet.write('CTDB', System.cmd_tlm_version)
+          packet.write('USER', USER_VERSION) if defined? USER_VERSION
+          @read_count += 1
+          return packet
+        rescue # if they haven't defined COSMOS VERSION we just fall through
+        end
+      end
+
+      while true
+        begin
+          event = CmdTlmServer.instance.get_limits_event(@limit_id)
+          if event[0] == :LIMITS_CHANGE
+            data = event[1]
+            packet ||= System.telemetry.packet("COSMOS","LIMITS_CHANGE")
+            packet.received_time = Time.now
+            packet.write('PKT_ID',2)
+            packet.write('TARGET', data[0])
+            packet.write('PACKET', data[1])
+            packet.write('ITEM', data[2])
+            # For the first limits change the old_state is nil
+            # so set it to a usable string
+            data[3] = 'UNKNOWN' unless data[3]
+            packet.write('OLD_STATE', data[3])
+            packet.write('NEW_STATE', data[4])
+            @read_count += 1
+            return packet
+          end
+        rescue => error
+          puts error.formatted
+          # if they haven't defined COSMOS LIMITS_CHANGE we fall through
+          # and break the loop because nothing will work
+          break
+        end
+      end
+      # Block forever
+      Thread.stop
+    end
+
+    # Write a packet to the CmdTlmServer to change various settings.
+    #
+    # @param packet [Packet] Must be one of COSMOS SETLOGLABEL, STARTLOGGING,
+    #   STARTCMDLOG, STARTTLMLOG, STOPLOGGING, STOPCMDLOG or STOPTLMLOG.
+    def write(packet)
+      @write_count += 1
+      command_data = packet.buffer
+      @bytes_written += command_data.length
+
+      identified_command = System.commands.identify(command_data, ['COSMOS'])
+      if identified_command
+        case identified_command.packet_name
+        when 'STARTLOGGING'
+          interface_name = identified_command.read('interface')
+          label = identified_command.read('label')
+          CmdTlmServer.instance.start_logging(interface_name, label)
+        when 'STARTCMDLOG'
+          interface_name = identified_command.read('interface')
+          CmdTlmServer.instance.start_cmd_log(interface_name)
+        when 'STARTTLMLOG'
+          interface_name = identified_command.read('interface')
+          CmdTlmServer.instance.start_tlm_log(interface_name)
+        when 'STOPLOGGING'
+          interface_name = identified_command.read('interface')
+          CmdTlmServer.instance.stop_logging(interface_name)
+        when 'STOPCMDLOG'
+          interface_name = identified_command.read('interface')
+          CmdTlmServer.instance.stop_cmd_log(interface_name)
+        when 'STOPTLMLOG'
+          interface_name = identified_command.read('interface')
+          CmdTlmServer.instance.stop_tlm_log(interface_name)
+        else
+          raise "Command unhandled at COSMOS server interface. : #{identifed_command.packet_name}"
+        end
+      else
+        raise "Unknown command received at COSMOS Server Interface."
+      end
+    end
+
+    # Raise an error because this method is not implemented for this interface
+    def write_raw(data)
+      raise "write_raw not implemented for CmdTlmServerInterface"
+    end
+
+    # Raise an error because raw logging is not supported for this interface
+    def raw_logger_pair=(raw_logger_pair)
+      raise "Raw logging not supported for CmdTlmServerInterface"
+    end
+
+    # Unsubscribe from the limits events
+    def disconnect
+      CmdTlmServer.instance.unsubscribe_limits_events(@limit_id) if @limit_id
+      @limit_id = nil
+    end
+
+  end # end class CmdTlmServerInterface
+
+end # module Cosmos