cosmos 3.1.1 → 3.1.2

data/lib/cosmos/tools/cmd_tlm_server/gui/status_tab.rb

@@ -0,0 +1,240 @@
+# 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
+
+  # Implements the status tab in the Command and Telemetry Server GUI
+  class StatusTab
+
+    # Create the status tab and add it to the tab_widget
+    #
+    # @param tab_widget [Qt::TabWidget] The tab widget to add the tab to
+    def populate(tab_widget)
+      scroll = Qt::ScrollArea.new
+      widget = Qt::Widget.new
+      layout = Qt::VBoxLayout.new(widget)
+
+      populate_limits_status(layout)
+      populate_api_status(layout)
+      populate_system_status(layout)
+      populate_background_status(layout)
+
+      # Set the scroll area widget last now that all the items have been layed out
+      scroll.setWidget(widget)
+      tab_widget.addTab(scroll, "Status")
+    end
+
+    # Update the status tab in the GUI
+    #
+    # @param previous_request_count [Integer] The previous number of
+    def update(previous_request_count)
+      update_limits_set
+      update_api_status(previous_request_count)
+      update_system_status
+      update_background_task_status
+    end
+
+    private
+
+    def populate_limits_status(layout)
+      limits = Qt::GroupBox.new(Qt::Object.tr("Limits Status"))
+      limits_layout = Qt::FormLayout.new(limits)
+      current_limits_set = System.limits_set.to_s
+
+      known_limits_sets = System.limits.sets
+      known_limits_sets = known_limits_sets.map {|x| x.to_s}.sort
+      current_index = known_limits_sets.index(current_limits_set.to_s)
+
+      @limits_set_combo = Qt::ComboBox.new
+      limits_layout.addRow("Limits Set:", @limits_set_combo)
+      layout.addWidget(limits)
+
+      known_limits_sets.sort.each do |limits_set|
+        @limits_set_combo.addItem(limits_set.to_s)
+      end
+      @limits_set_combo.setMaxVisibleItems(6)
+      @limits_set_combo.setCurrentIndex(current_index)
+      # Only connect to the signal that is sent when the user chooses an item.
+      # If the limits set is changed programatically the code in
+      # handle_status_tab will pick up the change.
+      @limits_set_combo.connect(SIGNAL('activated(int)')) do
+        selected_limits_set = @limits_set_combo.currentText
+        if selected_limits_set
+          System.limits_set = selected_limits_set.intern if System.limits_set != selected_limits_set.intern
+        end
+      end
+    end
+
+    def populate_api_status(layout)
+      api = Qt::GroupBox.new(Qt::Object.tr("API Status"))
+      api_layout = Qt::VBoxLayout.new(api)
+      @api_table = Qt::TableWidget.new()
+      @api_table.verticalHeader.hide()
+      @api_table.setRowCount(1)
+      @api_table.setColumnCount(6)
+      @api_table.setHorizontalHeaderLabels(["Port", "Num Clients", "Requests", "Requests/Sec", "Avg Request Time", "Estimated Utilization"])
+
+      @api_table.setItem(0, 0, Qt::TableWidgetItem.new(Qt::Object.tr(System.ports['CTS_API'].to_s)))
+      item0 = Qt::TableWidgetItem.new(Qt::Object.tr(CmdTlmServer.json_drb.num_clients.to_s))
+      item0.setTextAlignment(Qt::AlignCenter)
+      @api_table.setItem(0, 1, item0)
+      item = Qt::TableWidgetItem.new(Qt::Object.tr(CmdTlmServer.json_drb.request_count.to_s))
+      item.setTextAlignment(Qt::AlignCenter)
+      @api_table.setItem(0, 2, item)
+      item2 = Qt::TableWidgetItem.new("0.0")
+      item2.setTextAlignment(Qt::AlignCenter)
+      @api_table.setItem(0, 3, item2)
+      item3 = Qt::TableWidgetItem.new("0.0")
+      item3.setTextAlignment(Qt::AlignCenter)
+      @api_table.setItem(0, 4, item3)
+      item4 = Qt::TableWidgetItem.new("0.0")
+      item4.setTextAlignment(Qt::AlignCenter)
+      @api_table.setItem(0, 5, item4)
+      @api_table.displayFullSize
+      api_layout.addWidget(@api_table)
+      layout.addWidget(api)
+    end
+
+    def populate_system_status(layout)
+      system = Qt::GroupBox.new(Qt::Object.tr("System Status"))
+      system_layout = Qt::VBoxLayout.new(system)
+      @system_table = Qt::TableWidget.new()
+      @system_table.verticalHeader.hide()
+      @system_table.setRowCount(1)
+      @system_table.setColumnCount(4)
+      @system_table.setHorizontalHeaderLabels(["Threads", "Total Objs", "Free Objs", "Allocated Objs"])
+
+      item0 = Qt::TableWidgetItem.new("0")
+      item0.setTextAlignment(Qt::AlignCenter)
+      @system_table.setItem(0, 0, item0)
+      item1 = Qt::TableWidgetItem.new("0.0")
+      item1.setTextAlignment(Qt::AlignCenter)
+      @system_table.setItem(0, 1, item1)
+      item2 = Qt::TableWidgetItem.new("0.0")
+      item2.setTextAlignment(Qt::AlignCenter)
+      @system_table.setItem(0, 2, item2)
+      item3 = Qt::TableWidgetItem.new("0.0")
+      item3.setTextAlignment(Qt::AlignCenter)
+      @system_table.setItem(0, 3, item3)
+      @system_table.displayFullSize
+      system_layout.addWidget(@system_table)
+      layout.addWidget(system)
+    end
+
+    def populate_background_status(layout)
+      background_tasks_groupbox = Qt::GroupBox.new(Qt::Object.tr("Background Tasks"))
+      background_tasks_layout = Qt::VBoxLayout.new(background_tasks_groupbox)
+      @background_tasks_table = Qt::TableWidget.new()
+      @background_tasks_table.verticalHeader.hide()
+      @background_tasks_table.setRowCount(CmdTlmServer.background_tasks.all.length)
+      @background_tasks_table.setColumnCount(3)
+      @background_tasks_table.setHorizontalHeaderLabels(["Name", "State", "Status"])
+
+      background_tasks = CmdTlmServer.background_tasks.all
+      if background_tasks.length > 0
+        row = 0
+        background_tasks.each_with_index do |background_task, index|
+          background_task_name = background_task.name
+          background_task_name = "Background Task ##{index + 1}" unless background_task_name
+          background_task_name_widget = Qt::TableWidgetItem.new(background_task_name)
+          background_task_name_widget.setTextAlignment(Qt::AlignCenter)
+          @background_tasks_table.setItem(row, 0, background_task_name_widget)
+          if background_task.thread
+            status = background_task.thread.status
+            status = 'complete' if status == false
+            background_task_state_widget = Qt::TableWidgetItem.new(status.to_s)
+          else
+            background_task_state_widget = Qt::TableWidgetItem.new('no thread')
+          end
+          background_task_state_widget.setTextAlignment(Qt::AlignCenter)
+          background_task_state_widget.setSizeHint(Qt::Size.new(80, 30))
+          @background_tasks_table.setItem(row, 1, background_task_state_widget)
+          background_task_status_widget = Qt::TableWidgetItem.new(background_task.status.to_s)
+          background_task_status_widget.setTextAlignment(Qt::AlignCenter)
+          background_task_status_widget.setSizeHint(Qt::Size.new(500, 30))
+          @background_tasks_table.setItem(row, 2, background_task_status_widget)
+
+          row += 1
+        end
+      end
+      @background_tasks_table.displayFullSize
+      background_tasks_layout.addWidget(@background_tasks_table)
+      layout.addWidget(background_tasks_groupbox)
+    end
+
+    # Update the current limits set in the GUI
+    def update_limits_set
+      current_limits_set = System.limits_set.to_s
+      if @limits_set_combo.currentText != current_limits_set
+        known_limits_sets = System.limits.sets
+        known_limits_sets = known_limits_sets.map {|x| x.to_s}.sort
+        current_index = known_limits_sets.index(current_limits_set.to_s)
+        @limits_set_combo.clear
+        known_limits_sets.sort.each do |limits_set|
+          @limits_set_combo.addItem(limits_set.to_s)
+        end
+        @limits_set_combo.setCurrentIndex(current_index)
+      end
+    end
+
+    # Update the API statistics in the GUI
+    def update_api_status(previous_request_count)
+      if CmdTlmServer.json_drb
+        @api_table.item(0,1).setText(CmdTlmServer.json_drb.num_clients.to_s)
+        @api_table.item(0,2).setText(CmdTlmServer.json_drb.request_count.to_s)
+        request_count = CmdTlmServer.json_drb.request_count
+        requests_per_second = request_count - previous_request_count
+        @api_table.item(0,3).setText(requests_per_second.to_s)
+        previous_request_count = request_count
+        average_request_time = CmdTlmServer.json_drb.average_request_time
+        @api_table.item(0,4).setText(sprintf("%0.6f s", average_request_time))
+        estimated_utilization = requests_per_second * average_request_time * 100.0
+        @api_table.item(0,5).setText(sprintf("%0.2f %", estimated_utilization))
+      end
+    end
+
+    # Update the Ruby system statistics in the GUI
+    def update_system_status
+      @system_table.item(0,0).setText(Thread.list.length.to_s)
+      objs = ObjectSpace.count_objects
+      @system_table.item(0,1).setText(objs[:TOTAL].to_s)
+      @system_table.item(0,2).setText(objs[:FREE].to_s)
+      total = 0
+      objs.each do |key, val|
+        next if key == :TOTAL || key == :FREE
+        total += val
+      end
+      @system_table.item(0,3).setText(total.to_s)
+    end
+
+    # Update the background task status in the GUI
+    def update_background_task_status
+      background_tasks = CmdTlmServer.background_tasks.all
+      if background_tasks.length > 0
+        row = 0
+        background_tasks.each_with_index do |background_task, index|
+          if background_task.thread
+            status = background_task.thread.status
+            status = 'complete' if status == false
+            @background_tasks_table.item(row, 1).setText(status.to_s)
+          else
+            @background_tasks_table.item(row, 1).setText('no thread')
+          end
+          @background_tasks_table.item(row, 2).setText(background_task.status.to_s)
+          row += 1
+        end
+      end
+    end
+
+  end
+end # module Cosmos

data/lib/cosmos/tools/cmd_tlm_server/gui/targets_tab.rb

@@ -0,0 +1,90 @@
+# 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
+
+  # Implements the targets tab in the Command and Telemetry Server GUI
+  class TargetsTab
+
+    # Create the targets tab and add it to the tab_widget
+    #
+    # @param tab_widget [Qt::TabWidget] The tab widget to add the tab to
+    def populate(tab_widget)
+      num_targets = System.targets.length
+      if num_targets > 0
+        return if num_targets == 1 and System.targets['SYSTEM']
+        num_targets -= 1 if System.targets['SYSTEM']
+
+        scroll = Qt::ScrollArea.new
+        widget = Qt::Widget.new
+        layout = Qt::VBoxLayout.new(widget)
+        # Since the layout will be inside a scroll area make sure it respects the sizes we set
+        layout.setSizeConstraint(Qt::Layout::SetMinAndMaxSize)
+
+        @targets_table = Qt::TableWidget.new()
+        @targets_table.verticalHeader.hide()
+        @targets_table.setRowCount(num_targets)
+        @targets_table.setColumnCount(4)
+        @targets_table.setHorizontalHeaderLabels(["Target Name", "Interface", "Command Count", "Telemetry Count"])
+
+        populate_targets_table()
+
+        @targets_table.displayFullSize
+
+        layout.addWidget(@targets_table)
+        scroll.setWidget(widget)
+        tab_widget.addTab(scroll, "Targets")
+      end
+    end
+
+    # Update the targets tab gui
+    def update
+      row = 0
+      System.targets.sort.each do |target_name, target|
+        next if target_name == 'SYSTEM'
+        @targets_table.item(row,2).setText(target.cmd_cnt.to_s)
+        @targets_table.item(row,3).setText(target.tlm_cnt.to_s)
+        row += 1
+      end
+    end
+
+    private
+
+    def populate_targets_table
+      row = 0
+      System.targets.sort.each do |target_name, target|
+        next if target_name == 'SYSTEM'
+        target_name_widget = Qt::TableWidgetItem.new(Qt::Object.tr(target_name))
+        target_name_widget.setTextAlignment(Qt::AlignCenter)
+        @targets_table.setItem(row, 0, target_name_widget)
+        if target.interface
+          interface_name_widget = Qt::TableWidgetItem.new(Qt::Object.tr(target.interface.name.to_s))
+        else
+          interface_name_widget = Qt::TableWidgetItem.new(Qt::Object.tr(''))
+        end
+        interface_name_widget.setTextAlignment(Qt::AlignCenter)
+        @targets_table.setItem(row, 1, interface_name_widget)
+        cmd_cnt = Qt::TableWidgetItem.new(Qt::Object.tr(target.cmd_cnt.to_s))
+        cmd_cnt.setTextAlignment(Qt::AlignCenter)
+        @targets_table.setItem(row, 2, cmd_cnt)
+
+        tlm_cnt = Qt::TableWidgetItem.new(Qt::Object.tr(target.tlm_cnt.to_s))
+        tlm_cnt.setTextAlignment(Qt::AlignCenter)
+        @targets_table.setItem(row, 3, tlm_cnt)
+
+        row += 1
+      end
+    end
+
+  end
+end # module Cosmos

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

@@ -10,6 +10,7 @@
 
 require 'cosmos'
 require 'cosmos/config/config_parser'
+require 'ostruct'
 
 module Cosmos
 
@@ -33,8 +34,9 @@ module Cosmos
     attr_reader :num_columns
 
     # Processes a file and adds in the configuration defined in the file
+    #
+    # @param filename [String] Name of the configuration file to parse
     def initialize(filename)
-      # Initialize instance variables
       @title = 'COSMOS Launcher'
       @tool_font_settings  = ['Arial', 12]
       @label_font_settings = ['Arial', 16]
@@ -42,132 +44,162 @@ module Cosmos
       @items = []
 
       if File.exist?(filename.to_s)
-        multitool = false
-        multitool_text = nil
-        multitool_icon_filename = nil
-        multitool_settings = nil
-
-        # Loop over each line of the configuration file
-        parser = ConfigParser.new
-        parser.parse_file(filename) do |keyword, params|
-          # Handle each keyword
-          case keyword
-
-          when 'TOOL'
-            if multitool
-              parser.verify_num_parameters(1, 1, "TOOL <Shell command>")
-              multitool_settings << [:TOOL, format_shell_command(params[0]), true]
-            else
-              parser.verify_num_parameters(2, nil, "TOOL <Button Text> <Shell command> <Icon Filename (optional)> <Parameter Name #1 (optional)> <Parameter Value #1 (optional)> ...")
-              variable_params = nil
-              if params.length > 3
-                raise parser.error("Unbalanced variable params for #{params[0]}") if (params.length % 2) != 1
-                variable_params = []
-                params[3..-1].each_slice(2) { |variable_parameter| variable_params << variable_parameter }
-              end
-              @items << [:TOOL, params[0], format_shell_command(params[1]), true, ConfigParser.handle_nil(params[2]), variable_params]
-            end
+        parse_file(filename)
+      else
+        raise "Launcher configuration file does not exist: #{filename}"
+      end
+    end # def initialize
 
-          when 'MULTITOOL_START'
-            parser.verify_num_parameters(1, 2, "MULTITOOL_START <Button Text> <Icon Filename (optional)>")
-            multitool = true
-            multitool_text = params[0]
-            multitool_icon_filename = ConfigParser.handle_nil(params[1])
-            multitool_icon_filename = 'multi.png' unless multitool_icon_filename
-            multitool_settings = []
-
-          when 'MULTITOOL_END'
-            parser.verify_num_parameters(0, 0, "MULTITOOL_END")
-            @items << [:MULTITOOL, multitool_text, multitool_settings, true, multitool_icon_filename, nil]
-            multitool = false
-            multitool_text = nil
-            multitool_icon_filename = nil
-            multitool_settings = nil
-
-          when 'DELAY'
-            if multitool
-              parser.verify_num_parameters(1, 1, "DELAY <Delay in seconds>")
-              multitool_settings << [:DELAY, Float(params[0]), true]
-            else
-              raise parser.error("DELAY keyword only valid within MULTITOOL")
+    # Create a ConfigParser and parse all the lines in the configuration file
+    #
+    # @param filename [String] Name of the configuration file to parse
+    def parse_file(filename)
+      multitool = nil
+
+      # Loop over each line of the configuration file
+      parser = ConfigParser.new
+      parser.parse_file(filename) do |keyword, params|
+        # Handle each keyword
+        case keyword
+
+        when 'TOOL'
+          parse_tool(parser, params, multitool)
+
+        when 'MULTITOOL_START'
+          parser.verify_num_parameters(1, 2, "MULTITOOL_START <Button Text> <Icon Filename (optional)>")
+          multitool = OpenStruct.new
+          multitool.text = params[0]
+          multitool.icon_filename = ConfigParser.handle_nil(params[1])
+          multitool.icon_filename = 'multi.png' unless multitool.icon_filename
+          multitool.settings = []
+
+        when 'MULTITOOL_END'
+          parser.verify_num_parameters(0, 0, "MULTITOOL_END")
+          raise parser.error("No TOOLs defined within the MULTITOOL") if multitool.settings.select {|setting| setting[0] == :TOOL }.empty?
+          @items << [:MULTITOOL, multitool.text, multitool.settings, true, multitool.icon_filename, nil]
+          multitool = nil
+
+        when 'DELAY'
+          if multitool
+            parser.verify_num_parameters(1, 1, "DELAY <Delay in seconds>")
+            multitool.settings << [:DELAY, Float(params[0]), true]
+          else
+            raise parser.error("DELAY keyword only valid within MULTITOOL")
+          end
+
+        when 'DIVIDER'
+          parser.verify_num_parameters(0, 0, "DIVIDER")
+          @items << [:DIVIDER, nil, nil, nil, nil]
+
+        when 'LABEL'
+          parser.verify_num_parameters(1, 1, "LABEL <Label Text>")
+          @items << [:LABEL, params[0], nil, nil, nil]
+
+        when 'TOOL_FONT', 'LABEL_FONT'
+          usage = "#{keyword} <Font Name> <Font Size>"
+          parser.verify_num_parameters(2, 2, usage)
+          begin
+            @tool_font_settings = [params[0], Integer(params[1])] if keyword == 'TOOL_FONT'
+            @label_font_settings = [params[0], Integer(params[1])] if keyword == 'LABEL_FONT'
+          rescue ArgumentError
+            raise parser.error("#{usage} passed '#{params[0]} #{params[1]}'")
+          end
+
+        when 'TITLE'
+          parser.verify_num_parameters(1, 1, "TITLE <Title Text>")
+          @title = params[0]
+
+        when 'NUM_COLUMNS'
+          usage = "NUM_COLUMNS <Num Columns>"
+          parser.verify_num_parameters(1, 1, usage)
+          begin
+            @num_columns = Integer(params[0])
+          rescue ArgumentError
+            raise parser.error("#{usage} passed '#{params[0]}'")
+          end
+
+        when 'DONT_CAPTURE_IO'
+          parser.verify_num_parameters(0, 0, "DONT_CAPTURE_IO")
+          if multitool
+            if multitool.settings[-1].nil? || multitool.settings[-1][0] != :TOOL
+              raise parser.error("DONT_CAPTURE_IO must follow a TOOL")
             end
-
-          when 'DIVIDER'
-            parser.verify_num_parameters(0, 0, "DIVIDER")
-            @items << [:DIVIDER, nil, nil, nil, nil]
-
-          when 'LABEL'
-            parser.verify_num_parameters(1, 1, "LABEL <Label Text>")
-            @items << [:LABEL, params[0], nil, nil, nil]
-
-          when 'TOOL_FONT'
-            parser.verify_num_parameters(2, 2, "TOOL_FONT <Font Name> <Font Size>")
-            @tool_font_settings = [params[0], Integer(params[1])]
-
-          when 'LABEL_FONT'
-            parser.verify_num_parameters(2, 2, "LABEL_FONT <Font Name> <Font Size>")
-            @label_font_settings = [params[0], Integer(params[1])]
-
-          when 'TITLE'
-            parser.verify_num_parameters(1, 1, "TITLE <Title Text>")
-            @title = params[0]
-
-          when 'NUM_COLUMNS'
-            parser.verify_num_parameters(1, 1, "NUM_COLUMNS <Num Columns>")
-            @num_columns = params[0].to_i
-
-          when 'DONT_CAPTURE_IO'
-            parser.verify_num_parameters(0, 0, "DONT_CAPTURE_IO")
-            if multitool
-              if multitool_settings[-1].nil? || multitool_settings[-1][0] != :TOOL
-                raise parser.error("DONT_CAPTURE_IO must follow a TOOL")
-              end
-              multitool_settings[-1][2] = false
-            else
-              if @items[-1].nil? || @items[-1][0] != :TOOL
-                raise parser.error("DONT_CAPTURE_IO must follow a TOOL")
-              end
-              @items[-1][3] = false
+            multitool.settings[-1][2] = false
+          else
+            if @items[-1].nil? || @items[-1][0] != :TOOL
+              raise parser.error("DONT_CAPTURE_IO must follow a TOOL")
             end
+            @items[-1][3] = false
+          end
 
-          else # UNKNOWN
-            raise parser.error("Unknown keyword '#{keyword}'.") if keyword
+        else # UNKNOWN
+          raise parser.error("Unknown keyword '#{keyword}'.") if keyword
+        end # case keyword
+      end # parser.parse_file
+    end
 
-          end # case keyword
+    protected
 
-        end # parser.parse_file
+    def parse_tool(parser, params, multitool)
+      if multitool
+        parser.verify_num_parameters(1, 1, "TOOL <Shell command>")
+        multitool.settings << [:TOOL, format_shell_command(parser, params[0]), true]
+      else
+        parser.verify_num_parameters(2, nil, "TOOL <Button Text> <Shell command> <Icon Filename (optional)> <Parameter Name #1 (optional)> <Parameter Value #1 (optional)> ...")
+        variable_params = nil
+        # Determine if there are parameters which will be displayed in a GUI
+        # dialog when the tool starts
+        if params.length > 3
+          raise parser.error("Unbalanced variable params for #{params[0]}") if (params.length % 2) != 1
+          variable_params = []
+          params[3..-1].each_slice(2) { |variable_parameter| variable_params << variable_parameter }
+        end
+        @items << [:TOOL, params[0], format_shell_command(parser, params[1]), true, ConfigParser.handle_nil(params[2]), variable_params]
+      end
+    end
 
+    def format_shell_command(parser, shell_command)
+      formatted_command = ''
+      case shell_command.split[0]
+      when 'LAUNCH'
+        formatted_command = parse_launch(shell_command)
+      when 'LAUNCH_TERMINAL'
+        formatted_command = parse_launch_terminal(shell_command)
       else
-        raise "Launcher configuration file does not exist: #{filename}"
+        # Nothing to do if they aren't using our keywords
+        formatted_command = shell_command
       end
+      formatted_command
+    end
 
-    end # def initialize
+    def parse_launch(command)
+      split = command.split
+      if Kernel.is_mac? and File.exist?(File.join(USERPATH, 'tools', 'mac'))
+        formatted = "open tools/mac/#{split[1]}.app --args #{split[2..-1].join(' ')}".strip
+      else
+        formatted = "RUBYW tools/#{split[1]} #{split[2..-1].join(' ')}".strip
+      end
+      formatted
+    end
+
+    def parse_launch_terminal(command)
+      split = command.split
+      if Kernel.is_mac?
+        formatted = "osascript -e 'tell application \"Terminal\" to do script \"cd #{File.expand_path(USERPATH)} && ruby tools/#{split[1]} #{split[2..-1].join(' ')}\"' -e 'return'"
+      elsif Kernel.is_windows?
+        formatted = "start ruby tools/#{split[1]} #{split[2..-1].join(' ')}".strip
+      else
+        formatted = "gnome-terminal -e \"ruby tools/#{split[1]} #{split[2..-1].join(' ')}\""
+      end
 
-    def format_shell_command(shell_command)
       if Kernel.is_windows?
         rubyw_sub = 'rubyw'
       else
         rubyw_sub = 'ruby'
       end
 
-      split_command = shell_command.split
-      if split_command[0] == 'LAUNCH'
-        if Kernel.is_mac? and File.exist?(File.join(USERPATH, 'tools', 'mac'))
-          shell_command = "open tools/mac/#{split_command[1]}.app --args #{split_command[2..-1].join(' ')}"
-        else
-          shell_command = "RUBYW tools/#{split_command[1]} #{split_command[2..-1].join(' ')}"
-        end
-      elsif split_command[0] == 'LAUNCH_TERMINAL'
-        if Kernel.is_mac?
-          shell_command = "osascript -e 'tell application \"Terminal\" to do script \"cd #{File.expand_path(USERPATH)} && ruby tools/#{split_command[1]} #{split_command[2..-1].join(' ')}\"' -e 'return'"
-        elsif Kernel.is_windows?
-          shell_command = "start ruby tools/#{split_command[1]} #{split_command[2..-1].join(' ')}"
-        else
-          shell_command = "gnome-terminal -e \"ruby tools/#{split_command[1]} #{split_command[2..-1].join(' ')}\""
-        end
-      end
-      shell_command.gsub!('RUBYW', rubyw_sub)
-      shell_command
+      formatted.gsub!('RUBYW', rubyw_sub)
+      formatted
     end
 
   end # class LauncherConfig