cosmos 4.5.2 → 5.0.3

data/lib/cosmos/tools/cmd_sender/cmd_sender.rb

@@ -1,533 +0,0 @@
-# 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'
-Cosmos.catch_fatal_exception do
-  require 'cosmos/gui/qt_tool'
-  require 'cosmos/gui/text/completion'
-  require 'cosmos/gui/utilities/script_module_gui'
-  require 'cosmos/gui/dialogs/splash'
-  require 'cosmos/gui/dialogs/cmd_details_dialog'
-  require 'cosmos/gui/widgets/full_text_search_line_edit'
-  require 'cosmos/tools/cmd_sender/cmd_sender_text_edit'
-  require 'cosmos/tools/cmd_sender/cmd_params'
-  require 'cosmos/tools/cmd_sender/cmd_param_table_item_delegate'
-  require 'cosmos/config/config_parser'
-  require 'cosmos/script'
-end
-
-module Cosmos
-  Cosmos.disable_warnings do
-    module Script
-      def prompt_for_script_abort
-        window = get_cmd_tlm_gui_window()
-        window.statusBar.showMessage("Hazardous command not sent")
-        return true # Aborted - Don't retry
-      end
-    end
-  end
-
-  $eval_binding = binding()
-
-  # Command Sender sends commands to the COSMOS server. It gives the user
-  # a drop down to select the target and then command to send.
-  # It then displays all the command parameters. Once a
-  # command is sent it is added to the command history window which allows the
-  # user to resend the command or copy it for use in a script.
-  class CmdSender < QtTool
-    MANUALLY = CmdParamTableItemDelegate::MANUALLY
-
-    # @return [Integer] Number of commands sent
-    def self.send_count
-      @@send_count
-    end
-
-    # @param val [Integer] Number of commands sent
-    def self.send_count=(val)
-      @@send_count = val
-    end
-
-    # Create the application by building the GUI and loading an initial target
-    # and command packet. This can be passed on the command line or the first
-    # target and packet will be loaded.
-    # @param (see QtTool#initialize)
-    def initialize(options)
-      # MUST BE FIRST - All code before super is executed twice in RubyQt Based classes
-      super(options)
-      Cosmos.load_cosmos_icon("cmd_sender.png")
-
-      @message_log = MessageLog.new('cmdsender')
-      @production = options.production
-      @send_raw_dir = nil
-      @@send_count = 0
-      @cmd_params = CmdParams.new
-
-      initialize_actions()
-      initialize_menus()
-      initialize_central_widget()
-      complete_initialize() # defined in qt_tool
-
-      # 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
-
-        System.commands
-        Qt.execute_in_main_thread(true) do
-          update_targets()
-          @target_select.setCurrentText(options.packet[0]) if options.packet
-          update_commands()
-          @cmd_select.setCurrentText(options.packet[1]) if options.packet
-          update_cmd_params()
-
-          # Handle searching entries
-          @search_box.completion_list = System.commands.all_packet_strings(true, splash)
-          @search_box.callback = lambda do |cmd|
-            split_cmd = cmd.split(" ")
-            if split_cmd.length == 2
-              target_name = split_cmd[0].upcase
-              @target_select.setCurrentText(target_name)
-              update_commands()
-              command_name = split_cmd[1]
-              @cmd_select.setCurrentText(command_name)
-              update_cmd_params()
-            end
-          end
-
-        end
-
-        # Unconfigure CosmosConfig to interact with splash screen
-        ConfigParser.splash = nil
-      end
-    end
-
-    # Create the File and Mode menu actions
-    def initialize_actions
-      super()
-      # File menu actions
-      @send_raw_action = Qt::Action.new(Cosmos.get_icon('send_file.png'),
-                                        '&Send Raw',
-                                        self)
-      @send_raw_action.shortcut  = Qt::KeySequence.new('Ctrl+S')
-      tip = 'Send raw data from a file'
-      if @production
-        tip += ' - Disabled in Production Mode'
-        @send_raw_action.setEnabled(false)
-      end
-      @send_raw_action.statusTip = tip
-      @send_raw_action.connect(SIGNAL('triggered()')) { file_send_raw }
-
-      # Mode menu actions
-      @ignore_range = Qt::Action.new('&Ignore Range Checks', self)
-      tip = 'Ignore range checks when processing command'
-      if @production
-        tip += ' - Disabled in Production Mode'
-        @ignore_range.setEnabled(false)
-      end
-      @ignore_range.statusTip = tip
-      @ignore_range.setCheckable(true)
-      @ignore_range.setChecked(false)
-
-      @states_in_hex = Qt::Action.new('&Display State Values in Hex', self)
-      @states_in_hex.statusTip = 'Display states values in hex instead of decimal'
-      @states_in_hex.setCheckable(true)
-      @states_in_hex.setChecked(CmdParams.states_in_hex)
-      @states_in_hex.connect(SIGNAL('toggled(bool)')) do |checked|
-        @cmd_params.states_in_hex(checked)
-      end
-
-      @show_ignored = Qt::Action.new('&Show Ignored Parameters', self)
-      @show_ignored.statusTip = 'Show ignored parameters which are normally hidden'
-      @show_ignored.setCheckable(true)
-      @show_ignored.setChecked(CmdParams.show_ignored)
-      @show_ignored.connect(SIGNAL('toggled(bool)')) do |checked|
-        update_cmd_params(checked)
-      end
-
-      @cmd_raw = Qt::Action.new('Disable &Parameter Conversions', self)
-      tip = 'Send the command without running write or state conversions'
-      if @production
-        tip += ' - Disabled in Production Mode'
-        @cmd_raw.setEnabled(false)
-      end
-      @cmd_raw.statusTip = tip
-      @cmd_raw.setCheckable(true)
-      @cmd_raw.setChecked(false)
-    end
-
-    # Create the File and Mode menus and initialize the help menu
-    def initialize_menus
-      file_menu = menuBar.addMenu('&File')
-      file_menu.addAction(@send_raw_action)
-      file_menu.addAction(@exit_action)
-      file_menu.insertSeparator(@exit_action)
-
-      mode_menu = menuBar.addMenu('&Mode')
-      mode_menu.addAction(@ignore_range)
-      mode_menu.addAction(@states_in_hex)
-      mode_menu.addAction(@show_ignored)
-      mode_menu.addAction(@cmd_raw)
-
-      @about_string = "Command Sender allows the user to send any command defined in the system."
-      initialize_help_menu()
-    end
-
-    # Create the GUI which consists of a split window and add the top and
-    # bottom half widgets. The top half contains the command sender and the
-    # bottom half contains the history.
-    def initialize_central_widget
-      central_widget = Qt::Widget.new
-      setCentralWidget(central_widget)
-
-      splitter = Qt::Splitter.new(central_widget)
-      splitter.setOrientation(Qt::Vertical)
-      splitter.addWidget(create_sender_widget)
-      splitter.addWidget(create_history_widget)
-      splitter.setStretchFactor(0,10)
-      splitter.setStretchFactor(1,1)
-
-      layout = Qt::VBoxLayout.new
-      layout.setSpacing(1)
-      layout.setContentsMargins(1, 1, 1, 1)
-      layout.setSizeConstraint(Qt::Layout::SetMaximumSize)
-      layout.addWidget(splitter)
-      central_widget.layout = layout
-
-      # Mark this window as the window for popups
-      set_cmd_tlm_gui_window(self)
-    end
-
-    # Create the top half widget which contains target and packet combobox
-    # selections that update a table of command parameters.
-    def create_sender_widget
-      # Create the top half of the splitter window
-      sender = Qt::Widget.new
-
-      # Create the top level vertical layout
-      top_layout = Qt::VBoxLayout.new(sender)
-      # Set the size constraint to always respect the minimum sizes of the child widgets
-      # If this is not set then when we refresh the command parameters they'll all be squished
-      top_layout.setSizeConstraint(Qt::Layout::SetMinimumSize)
-
-      # Mnemonic Search Box
-      @search_box = FullTextSearchLineEdit.new(self)
-      top_layout.addWidget(@search_box)
-
-      # Set the target combobox selection
-      @target_select = Qt::ComboBox.new
-      @target_select.setMaxVisibleItems(6)
-      @target_select.connect(SIGNAL('activated(const QString&)')) do |target|
-        update_commands()
-        update_cmd_params()
-      end
-      target_label = Qt::Label.new("&Target:")
-      target_label.setBuddy(@target_select)
-
-      # Set the comamnd combobox selection
-      @cmd_select = Qt::ComboBox.new
-      @cmd_select.setMaxVisibleItems(20)
-      @cmd_select.connect(SIGNAL('activated(const QString&)')) {|command| update_cmd_params }
-      cmd_label = Qt::Label.new("&Command:")
-      cmd_label.setBuddy(@cmd_select)
-
-      # Button to send command
-      send = Qt::PushButton.new("Send")
-      send.connect(SIGNAL('clicked()')) { send_button }
-
-      # Layout the top level selection
-      select_layout = Qt::HBoxLayout.new
-      select_layout.addWidget(target_label)
-      select_layout.addWidget(@target_select, 1)
-      select_layout.addWidget(cmd_label)
-      select_layout.addWidget(@cmd_select, 1)
-      select_layout.addWidget(send)
-      top_layout.addLayout(select_layout)
-
-      # Separator Between Command Selection and Command Description
-      sep1 = Qt::Frame.new(sender)
-      sep1.setFrameStyle(Qt::Frame::HLine | Qt::Frame::Sunken)
-      top_layout.addWidget(sep1)
-
-      # Command Description Label
-      dec_label = Qt::Label.new("Description:")
-      @description = Qt::Label.new('')
-      @description.setWordWrap(true)
-      desc_layout = Qt::HBoxLayout.new
-      desc_layout.addWidget(dec_label)
-      desc_layout.addWidget(@description, 1)
-      top_layout.addLayout(desc_layout)
-
-      # Separator Between Command Selection and Description
-      sep2 = Qt::Frame.new(sender)
-      sep2.setFrameStyle(Qt::Frame::HLine | Qt::Frame::Sunken)
-      top_layout.addWidget(sep2)
-
-      # Parameters Label
-      param_label = Qt::Label.new("Parameters:")
-      top_layout.addWidget(param_label)
-
-      # Grid Layout for Parameters
-      @table_layout = Qt::VBoxLayout.new
-      top_layout.addLayout(@table_layout, 500)
-
-      # Add stretch to force everything to fit against the top of the window
-      # otherwise the selection window, description, and parameters all try
-      # to get equal space.
-      top_layout.addStretch(1)
-
-      # Create the scroll area
-      scroll = Qt::ScrollArea.new
-      scroll.setMinimumSize(500, 150)
-      scroll.setWidgetResizable(true)
-      scroll.setWidget(sender)
-      scroll
-    end
-
-    # Create the history widget which consists of a {CmdSenderTextEdit} that
-    # displays the history of sent commands.
-    def create_history_widget
-      # Create the text edit where previously issued commands go and where
-      # commands can be manually typed in and re-executed
-      @input = CmdSenderTextEdit.new(statusBar)
-      @input.setFocus()
-
-      layout = Qt::VBoxLayout.new
-      layout.setSpacing(1)
-      layout.setContentsMargins(1, 1, 1, 1)
-      layout.setSizeConstraint(Qt::Layout::SetMaximumSize)
-      layout.addWidget(Qt::Label.new("Command History: (Pressing Enter on the line re-executes the command)"))
-      layout.addWidget(@input)
-      history = Qt::Widget.new
-      history.layout = layout
-      history
-    end
-
-    # Opens a dialog which allows the user to select a file to read and send
-    # directly over the interface.
-    def file_send_raw
-      dialog = Qt::Dialog.new(self, Qt::WindowTitleHint | Qt::WindowSystemMenuHint)
-      dialog.setWindowTitle("Send Raw Data From File")
-      layout = Qt::GridLayout.new
-      interfaces = Qt::ComboBox.new
-      interfaces.addItems(get_interface_names())
-      interfaces.setMaxVisibleItems(30)
-      layout.addWidget(interfaces, 0, 1)
-      int_label = Qt::Label.new("&Interface:")
-      int_label.setBuddy(interfaces)
-      layout.addWidget(int_label, 0, 0)
-
-      file_line = Qt::LineEdit.new(@send_raw_dir)
-      file_line.setMinimumSize(250, 0)
-      file_label = Qt::Label.new("&Filename:")
-      file_label.setBuddy(file_line)
-      get_file = Qt::PushButton.new("Select")
-      file_layout = Qt::BoxLayout.new(Qt::Horizontal)
-      file_layout.addWidget(get_file)
-      file_layout.addWidget(file_line)
-      get_file.connect(SIGNAL('clicked()')) do
-        Cosmos.set_working_dir do
-          file_line.text = Qt::FileDialog::getOpenFileName(self, "Select File", @send_raw_dir, "Binary Files (*.bin);;All Files (*)")
-        end
-      end
-
-      layout.addWidget(file_label, 1, 0)
-      layout.addLayout(file_layout, 1, 1)
-
-      button_layout = Qt::BoxLayout.new(Qt::Horizontal)
-      ok = Qt::PushButton.new("Ok")
-      connect(ok, SIGNAL('clicked()'), dialog, SLOT('accept()'))
-      button_layout.addWidget(ok)
-      cancel = Qt::PushButton.new("Cancel")
-      connect(cancel, SIGNAL('clicked()'), dialog, SLOT('reject()'))
-      button_layout.addWidget(cancel)
-      layout.addLayout(button_layout, 2, 0, 1 ,2)
-
-      dialog.setLayout(layout)
-      if dialog.exec == Qt::Dialog::Accepted
-        @send_raw_dir = file_line.text
-        Cosmos.set_working_dir do
-          send_raw_file(interfaces.text, file_line.text)
-        end
-      end
-      dialog.dispose
-    rescue Exception => err
-      message = "Error sending raw file due to #{err}"
-      @message_log.write(Time.now.formatted + '  ' + message + "\n")
-      statusBar.showMessage(message)
-    rescue DRb::DRbConnError
-      message = "Error Connecting to Command and Telemetry Server"
-      @message_log.write(Time.now.formatted + '  ' + message + "\n")
-      statusBar.showMessage(message)
-    end
-
-    # (see QtTool#closeEvent)
-    def closeEvent(event)
-      shutdown_cmd_tlm()
-      @message_log.stop
-      super(event)
-    end
-
-    # Sends the current command and parameters to the target
-    def send_button
-      target_name = @target_select.text
-      packet_name = @cmd_select.text
-      if target_name and packet_name
-        output_string, params = view_as_script()
-        @message_log.write(Time.now.sys.formatted + '  ' + output_string + "\n")
-        if @cmd_raw.checked?
-          if @ignore_range.checked?
-            cmd_raw_no_range_check(target_name, packet_name, params)
-          else
-            cmd_raw(target_name, packet_name, params)
-          end
-        else
-          if @ignore_range.checked?
-            cmd_no_range_check(target_name, packet_name, params)
-          else
-            cmd(target_name, packet_name, params)
-          end
-        end
-        if statusBar.currentMessage != 'Hazardous command not sent'
-          @@send_count += 1
-          statusBar.showMessage("#{output_string} sent. (#{@@send_count})")
-          @input.append(output_string)
-          @input.moveCursor(Qt::TextCursor::End)
-          @input.ensureCursorVisible()
-        end
-      end
-    rescue DRb::DRbConnError
-      message = "Error Connecting to Command and Telemetry Server"
-      @message_log.write(Time.now.formatted + '  ' + message + "\n")
-      statusBar.showMessage(message)
-      Qt::MessageBox.critical(self, 'Error', message)
-    rescue Exception => err
-      message = "Error sending #{target_name} #{packet_name} due to #{err}"
-      @message_log.write(Time.now.formatted + '  ' + message + "\n")
-      statusBar.showMessage(message)
-      Qt::MessageBox.critical(self, 'Error', message)
-    end
-
-    # @return [String, Hash] Command as it would appear in a ScriptRunner script
-    def view_as_script
-      statusBar.clearMessage()
-      params = @cmd_params.params_text(@cmd_raw.checked?)
-      output_string = System.commands.build_cmd_output_string(@target_select.text, @cmd_select.text, params, @cmd_raw.checked?)
-      if output_string =~ /[\x00-\x08\x0B-\x0C\x0E-\x1F\x7F-\xFF]/
-        output_string = output_string.inspect.remove_quotes
-      end
-
-      if @cmd_raw.checked?
-        if @ignore_range.checked?
-          output_string.insert(7, '_no_range_check')
-        end
-      else
-        if @ignore_range.checked?
-          output_string.insert(3, '_no_range_check')
-        end
-      end
-
-      return output_string, params
-    end
-
-    # Updates the targets combobox
-    def update_targets
-      @target_select.clearItems()
-      target_names = System.commands.target_names
-      target_names_to_delete = []
-      target_names.each do |target_name|
-        found_non_hidden = false
-        begin
-          packets = System.commands.packets(target_name)
-          packets.each do |packet_name, packet|
-            found_non_hidden = true unless packet.hidden
-          end
-        rescue
-          # Don't do anything
-        end
-        target_names_to_delete << target_name unless found_non_hidden
-      end
-      target_names_to_delete.each do |target_name|
-        target_names.delete(target_name)
-      end
-      target_names.each do |target_name|
-        @target_select.addItem(target_name)
-      end
-    end
-
-    # Updates the commands combobox based on the selected target
-    def update_commands
-      @cmd_select.clearItems()
-      target_name = @target_select.text
-      if target_name
-        commands = System.commands.packets(@target_select.text)
-        command_names = []
-        commands.each do |command_name, command|
-          command_names << command_name unless command.hidden
-        end
-        command_names.sort!
-        command_names.each do |command_name|
-          @cmd_select.addItem(command_name)
-        end
-      end
-    end
-
-    # Updates the command parameters table based on the selected target and
-    # packet comboboxes
-    # @param checked [Boolean] Whether the show ignored parameters option
-    #   is checked. Pass nil (the default) to keep the existing setting.
-    def update_cmd_params(checked = nil)
-      # Clear Status Bar
-      statusBar.showMessage("")
-
-      target_name = @target_select.text
-      target = System.targets[target_name]
-      packet_name = @cmd_select.text
-      if target_name && packet_name
-        packet = System.commands.packet(target_name, packet_name)
-        # Directly update packet description ... safe because always in GUI thread
-        hazardous, _ = System.commands.cmd_hazardous?(target_name, packet_name)
-        if hazardous
-          @description.text = "(Hazardous) #{packet.description}"
-        else
-          @description.text = packet.description
-        end
-        table = @cmd_params.update_cmd_params(packet, show_ignored: checked)
-        @table_layout.addWidget(table, 500) if table
-      end
-    end
-
-    # (see QtTool.run)
-    def self.run(option_parser = nil, options = nil)
-      Cosmos.catch_fatal_exception do
-        unless option_parser && options
-          option_parser, options = create_default_options()
-          options.width = 600
-          options.height = 425
-          options.title = 'Command Sender'
-          options.production = false
-          option_parser.separator "Command Sender Specific Options:"
-          option_parser.on("-p", "--packet 'TARGET_NAME PACKET_NAME'", "Start with the specified command selected") do |arg|
-            split = arg.split
-            if split.length != 2
-              puts "Packet must be specified as 'TARGET_NAME PACKET_NAME' in quotes"
-              exit
-            end
-            options.packet = split
-          end
-          option_parser.on(nil, "--production", "Run in production mode which disables the ability to manually enter data.") do |arg|
-            options.production = true
-          end
-        end
-
-        super(option_parser, options)
-      end
-    end
-  end
-end

data/lib/cosmos/tools/cmd_sender/cmd_sender_text_edit.rb

@@ -1,70 +0,0 @@
-# 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
-  # CmdSenderTextEdit is a subclass of TextEdit that creates a CosmosCompletion class to
-  # allow for code completion when creating new commands in the command history
-  # window. It also monitors for the Enter key to allow for commands in the
-  # command history to be executed.
-  class CmdSenderTextEdit < Qt::TextEdit
-    def initialize(status_bar)
-      super()
-      @status_bar = status_bar
-      @c = Completion.new(self)
-    end
-
-    def keyPressEvent(event)
-      # If the completion popup is visible then ignore the event and allow the popup to handle it
-      if (@c and @c.popup.isVisible)
-        case event.key
-        when Qt::Key_Return, Qt::Key_Enter
-          event.ignore
-          return
-        end
-      end
-
-      case event.key
-      # The return key means we need to execute the current line
-      when Qt::Key_Return, Qt::Key_Enter
-        # If the cursor is at the beginning of the line allow the newline
-        if textCursor.atBlockStart
-          super(event)
-        # If the line isn't blank then execute it
-        elsif textCursor.block.text.strip != ""
-          begin
-            eval(textCursor.block.text, $eval_binding)
-            CmdSender.send_count += 1
-            @status_bar.showMessage("#{textCursor.block.text} sent. (#{CmdSender.send_count})")
-          rescue Exception => error
-            if error.class == DRb::DRbConnError
-              message = "Error Connecting to Command and Telemetry Server"
-            else
-              message = "Error sending command due to #{error}"
-            end
-            @status_bar.showMessage(message)
-            Qt::MessageBox.critical(self, 'Error', message)
-          end
-        end
-      # Handle Key_Down to automatically create a newline if they Key_Down at
-      # the bottom of the document
-      when Qt::Key_Down
-        # If the number of lines equals the current line (plus one since it is 0
-        # based) then we append a newline to allow the Key_Down to go to a new line
-        if self.toPlainText.split("\n").length == (textCursor.block.blockNumber + 1)
-          self.append("")
-        end
-        super(event)
-      else # All other keys are handled by this widget as well as being passed to the completion handler
-        super(event)
-        @c.handle_keypress(event)
-      end
-    end
-  end
-end # module Cosmos