cosmos 4.0.3 → 4.1.0

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

@@ -20,38 +20,51 @@ module Cosmos
     ROUTERS = 'Routers'
     ALIGN_CENTER = Qt::AlignCenter
 
-    def initialize(server_gui)
+    def initialize(server_gui, name, tab_widget)
       @server_gui = server_gui
-      @interfaces_table = {}
+      @name = name
+      @widget = nil
+      reset()
+      @scroll = Qt::ScrollArea.new
+      @scroll.setMinimumSize(800, 150)
+      tab_widget.addTab(@scroll, @name)
+    end
+
+    def reset
+      Qt.execute_in_main_thread(true) do
+        @widget.destroy if @widget
+        @widget = nil
+        @interfaces_table = nil
+      end
     end
 
     # Create the interfaces tab and add it to the tab_widget
     #
     # @param tab_widget [Qt::TabWidget] The tab widget to add the tab to
-    def populate_interfaces(tab_widget)
-      populate(INTERFACES, CmdTlmServer.interfaces, tab_widget)
+    def populate_interfaces
+      populate(CmdTlmServer.interfaces)
     end
 
     # Create the routers tab and add it to the tab_widget
     #
     # @param tab_widget [Qt::TabWidget] The tab widget to add the tab to
-    def populate_routers(tab_widget)
-      populate(ROUTERS, CmdTlmServer.routers, tab_widget)
+    def populate_routers
+      populate(CmdTlmServer.routers)
     end
 
     # Update the interfaces or routers tab
     #
     # @param name [String] Must be Interfaces or Routers
-    def update(name)
-      if name == ROUTERS
+    def update
+      if @name == ROUTERS
         interfaces = CmdTlmServer.routers
       else
         interfaces = CmdTlmServer.interfaces
       end
       row = 0
       interfaces.all.each do |interface_name, interface|
-        button = @interfaces_table[name].cellWidget(row,1)
-        state = @interfaces_table[name].item(row,2)
+        button = @interfaces_table.cellWidget(row,1)
+        state = @interfaces_table.item(row,2)
         if interface.connected? and interface.thread
           button.setText('Disconnect')
           button.setDisabled(true) if interface.disable_disconnect
@@ -73,17 +86,17 @@ module Cosmos
           state.setText('false')
           state.textColor = Cosmos::BLACK
         end
-        @interfaces_table[name].item(row,3).setText(interface.num_clients.to_s)
-        @interfaces_table[name].item(row,4).setText(interface.write_queue_size.to_s)
-        @interfaces_table[name].item(row,5).setText(interface.read_queue_size.to_s)
-        @interfaces_table[name].item(row,6).setText(interface.bytes_written.to_s)
-        @interfaces_table[name].item(row,7).setText(interface.bytes_read.to_s)
-        if name == ROUTERS
-          @interfaces_table[name].item(row,8).setText(interface.read_count.to_s)
-          @interfaces_table[name].item(row,9).setText(interface.write_count.to_s)
+        @interfaces_table.item(row,3).setText(interface.num_clients.to_s)
+        @interfaces_table.item(row,4).setText(interface.write_queue_size.to_s)
+        @interfaces_table.item(row,5).setText(interface.read_queue_size.to_s)
+        @interfaces_table.item(row,6).setText(interface.bytes_written.to_s)
+        @interfaces_table.item(row,7).setText(interface.bytes_read.to_s)
+        if @name == ROUTERS
+          @interfaces_table.item(row,8).setText(interface.read_count.to_s)
+          @interfaces_table.item(row,9).setText(interface.write_count.to_s)
         else
-          @interfaces_table[name].item(row,8).setText(interface.write_count.to_s)
-          @interfaces_table[name].item(row,9).setText(interface.read_count.to_s)
+          @interfaces_table.item(row,8).setText(interface.write_count.to_s)
+          @interfaces_table.item(row,9).setText(interface.read_count.to_s)
         end
         row += 1
       end
@@ -91,13 +104,12 @@ module Cosmos
 
     private
 
-    def populate(name, interfaces, tab_widget)
+    def populate(interfaces)
+      reset()
       return if interfaces.all.empty?
 
-      scroll = Qt::ScrollArea.new
-      scroll.setMinimumSize(800, 150)
-      widget = Qt::Widget.new
-      layout = Qt::VBoxLayout.new(widget)
+      @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)
 
@@ -105,28 +117,27 @@ module Cosmos
       interfaces_table.verticalHeader.hide()
       interfaces_table.setRowCount(interfaces.all.length)
       interfaces_table.setColumnCount(11)
-      if name == ROUTERS
+      if @name == ROUTERS
         interfaces_table.setHorizontalHeaderLabels(["Router", "Connect/Disconnect", "Connected?", "Clients", "Tx Q Size", "Rx Q Size", "   Bytes Tx   ", "   Bytes Rx   ", "  Pkts Rcvd  ", "  Pkts Sent  ", "View Raw"])
       else
         interfaces_table.setHorizontalHeaderLabels(["Interface", "Connect/Disconnect", "Connected?", "Clients", "Tx Q Size", "Rx Q Size", "   Bytes Tx   ", "   Bytes Rx   ", "  Cmd Pkts  ", "  Tlm Pkts ", "View Raw"])
       end
 
-      populate_interface_table(name, interfaces, interfaces_table)
+      populate_interface_table(interfaces, interfaces_table)
       interfaces_table.displayFullSize
 
       layout.addWidget(interfaces_table)
-      scroll.setWidget(widget)
-      @interfaces_table[name] = interfaces_table
-      tab_widget.addTab(scroll, name)
+      @scroll.setWidget(@widget)
+      @interfaces_table = interfaces_table
     end
 
-    def populate_interface_table(name, interfaces, interfaces_table)
+    def populate_interface_table(interfaces, interfaces_table)
       row = 0
       interfaces.all.each do |interface_name, interface|
         item = Qt::TableWidgetItem.new(Qt::Object.tr(interface_name))
         item.setTextAlignment(ALIGN_CENTER)
         interfaces_table.setItem(row, 0, item)
-        interfaces_table.setCellWidget(row, 1, create_button(name, interface, interface_name))
+        interfaces_table.setCellWidget(row, 1, create_button(interface, interface_name))
         interfaces_table.setItem(row, 2, create_state(interface))
 
         index = 3
@@ -142,7 +153,7 @@ module Cosmos
         view_raw = Qt::PushButton.new("View Raw")
         view_raw.connect(SIGNAL('clicked()')) do
           @raw_dialogs ||= []
-          if name == ROUTERS
+          if @name == ROUTERS
             current_interface = CmdTlmServer.routers.all[interface_name]
           else
             current_interface = CmdTlmServer.interfaces.all[interface_name]
@@ -154,7 +165,7 @@ module Cosmos
       end
     end
 
-    def create_button(name, interface, interface_name)
+    def create_button(interface, interface_name)
       if interface.connected? and interface.thread
         button_text = 'Disconnect'
       elsif interface.thread
@@ -165,7 +176,7 @@ module Cosmos
         button_text = 'Connect'
       end
       button = Qt::PushButton.new(button_text)
-      if name == ROUTERS
+      if @name == ROUTERS
         button.connect(SIGNAL('clicked()')) do
           if CmdTlmServer.routers.all[interface_name].thread
             Logger.info "User disconnecting router #{interface_name}"

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

@@ -16,18 +16,29 @@ module Cosmos
   # Implements the logging tab in the Command and Telemetry Server GUI
   class LoggingTab
 
-    def initialize(production)
+    def initialize(production, tab_widget)
       @production = production
-      @logging_layouts = {}
+      @widget = nil
+      reset()
+      @scroll = Qt::ScrollArea.new
+      tab_widget.addTab(@scroll, "Logging")
+    end
+
+    def reset
+      Qt.execute_in_main_thread(true) do
+        @widget.destroy if @widget
+        @widget = nil
+        @logging_layouts = {}
+      end
     end
 
     # Create the logging 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)
+    def populate
+      reset()
+      @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)
@@ -38,8 +49,7 @@ module Cosmos
       populate_log_file_info(layout)
 
       # Set the scroll area widget last now that all the items have been layed out
-      scroll.setWidget(widget)
-      tab_widget.addTab(scroll, "Logging")
+      @scroll.setWidget(@widget)
     end
 
     def update

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

@@ -19,23 +19,37 @@ module Cosmos
     COMMANDS = "Commands"
     TELEMETRY = "Telemetry"
 
-    def initialize(server_gui)
+    def initialize(server_gui, name, tab_widget)
       @server_gui = server_gui
-      @packets_table = {}
+      @name = name
+      @widget = nil
+      reset()
+      @scroll = Qt::ScrollArea.new
+      tab_name = "Cmd Packets" if name == COMMANDS
+      tab_name = "Tlm Packets" if name == TELEMETRY
+      tab_widget.addTab(@scroll, tab_name)
     end
 
-    def populate_commands(tab_widget)
-      populate(COMMANDS, System.commands, tab_widget)
+    def reset
+      Qt.execute_in_main_thread(true) do
+        @widget.destroy if @widget
+        @widget = nil
+        @packets_table = nil
+      end
     end
 
-    def populate_telemetry(tab_widget)
-      populate(TELEMETRY, System.telemetry, tab_widget)
+    def populate_commands
+      populate(System.commands)
     end
 
-    def update(name)
+    def populate_telemetry
+      populate(System.telemetry)
+    end
+
+    def update
       cmd_tlm = nil
-      cmd_tlm = System.commands if name == COMMANDS
-      cmd_tlm = System.telemetry if name == TELEMETRY
+      cmd_tlm = System.commands if @name == COMMANDS
+      cmd_tlm = System.telemetry if @name == TELEMETRY
       return if cmd_tlm.nil? || cmd_tlm.target_names.empty?
 
       row = 0
@@ -43,18 +57,19 @@ module Cosmos
         packets = cmd_tlm.packets(target_name)
         packets.sort.each do |packet_name, packet|
           next if packet.hidden
-          @packets_table[name].item(row, 2).setText(packet.received_count.to_s)
+          @packets_table.item(row, 2).setText(packet.received_count.to_s)
           row += 1
         end
       end
       packet = cmd_tlm.packet('UNKNOWN', 'UNKNOWN')
-      @packets_table[name].item(row, 2).setText(packet.received_count.to_s)
+      @packets_table.item(row, 2).setText(packet.received_count.to_s)
       row += 1
     end
 
     private
 
-    def populate(name, cmd_tlm, tab_widget)
+    def populate(cmd_tlm)
+      reset()
       return if cmd_tlm.target_names.empty?
 
       count = 0
@@ -66,9 +81,8 @@ module Cosmos
       end
       count += 1 # For UNKNOWN UNKNOWN
 
-      scroll = Qt::ScrollArea.new
-      widget = Qt::Widget.new
-      layout = Qt::VBoxLayout.new(widget)
+      @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)
@@ -81,23 +95,20 @@ module Cosmos
       # Force the last section to fill all available space in the frame
       #~ table.horizontalHeader.setStretchLastSection(true)
       headers = ["Target Name", "Packet Name", "Packet Count", "View Raw"]
-      headers << "View in Command Sender" if name == COMMANDS
-      headers << "View in Packet Viewer" if name == TELEMETRY
+      headers << "View in Command Sender" if @name == COMMANDS
+      headers << "View in Packet Viewer" if @name == TELEMETRY
       table.setHorizontalHeaderLabels(headers)
 
-      populate_packets_table(name, cmd_tlm, table)
+      populate_packets_table(cmd_tlm, table)
       table.displayFullSize
 
       layout.addWidget(table)
-      scroll.setWidget(widget)
-      tab_name = "Cmd Packets" if name == COMMANDS
-      tab_name = "Tlm Packets" if name == TELEMETRY
-      tab_widget.addTab(scroll, tab_name)
+      @scroll.setWidget(@widget)
 
-      @packets_table[name] = table
+      @packets_table = table
     end
 
-    def populate_packets_table(name, cmd_tlm, table)
+    def populate_packets_table(cmd_tlm, table)
       row = 0
       target_names = cmd_tlm.target_names
       target_names << 'UNKNOWN'.freeze
@@ -116,14 +127,14 @@ module Cosmos
           view_raw = Qt::PushButton.new("View Raw")
           view_raw.connect(SIGNAL('clicked()')) do
             @raw_dialogs ||= []
-            @raw_dialogs << CmdRawDialog.new(@server_gui, target_name, packet_name) if name == COMMANDS
-            @raw_dialogs << TlmRawDialog.new(@server_gui, target_name, packet_name) if name == TELEMETRY
+            @raw_dialogs << CmdRawDialog.new(@server_gui, target_name, packet_name) if @name == COMMANDS
+            @raw_dialogs << TlmRawDialog.new(@server_gui, target_name, packet_name) if @name == TELEMETRY
           end
           table.setCellWidget(row, 3, view_raw)
 
-          if name == COMMANDS
+          if @name == COMMANDS
             add_tool_button(table, row, target_name, packet_name, "Command Sender")
-          elsif name == TELEMETRY
+          elsif @name == TELEMETRY
             add_tool_button(table, row, target_name, packet_name, "Packet Viewer")
           end
 

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

@@ -0,0 +1,242 @@
+# 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/choosers/string_chooser'
+require 'cosmos/gui/dialogs/packet_log_dialog'
+require 'cosmos/gui/dialogs/progress_dialog'
+
+module Cosmos
+
+  # Implements the replay tab in the Command and Telemetry Server GUI
+  class ReplayTab
+
+    attr_accessor :widget
+
+    def initialize(tab_widget)
+      @widget = nil
+      @update_slider = true
+      @file_max_index = 0
+      reset()
+      @scroll = Qt::ScrollArea.new
+      tab_widget.addTab(@scroll, "Replay")
+    end
+
+    def reset
+      CmdTlmServer.replay_backend.reset if CmdTlmServer.instance
+      Qt.execute_in_main_thread(true) do
+        @widget.destroy if @widget
+        @widget = nil
+      end
+    end
+
+    # 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
+      return if @widget
+
+      @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)
+
+      @log_widget = Qt::Widget.new
+      @log_widget.setSizePolicy(Qt::SizePolicy::MinimumExpanding, Qt::SizePolicy::MinimumExpanding)
+      @log_layout = Qt::VBoxLayout.new()
+
+      # This widget goes inside the top layout so we want 0 contents margins
+      @log_layout.setContentsMargins(0,0,0,0)
+      @log_widget.setLayout(@log_layout)
+
+      # Create the log file GUI
+      @log_file_selection = Qt::GroupBox.new("Log File Selection")
+      @log_select = Qt::HBoxLayout.new(@log_file_selection)
+      @log_name = Qt::LineEdit.new
+      @log_name.setReadOnly(true)
+      @log_select.addWidget(@log_name)
+      @log_open = Qt::PushButton.new("Browse...")
+      @log_select.addWidget(@log_open)
+      @log_layout.addWidget(@log_file_selection)
+
+      @log_open.connect(SIGNAL('clicked()')) { select_log_file() }
+
+      # Create the operation buttons GUI
+      @op = Qt::GroupBox.new("Playback Control")
+      @op_layout = Qt::VBoxLayout.new(@op)
+      @op_button_layout = Qt::HBoxLayout.new
+      @move_start = Qt::PushButton.new(Cosmos.get_icon('skip_to_start-26.png'), '')
+      @move_start.connect(SIGNAL('clicked()')) { CmdTlmServer.replay_backend.move_start() }
+      @op_button_layout.addWidget(@move_start)
+      @step_back = Qt::PushButton.new(Cosmos.get_icon('rewind-26.png'), '')
+      @step_back_timer = Qt::Timer.new
+      @step_back_timeout = 100
+      @step_back_timer.connect(SIGNAL('timeout()')) { CmdTlmServer.replay_backend.step_back(); @step_back_timeout = (@step_back_timeout / 2).to_i; @step_back_timer.start(@step_back_timeout) }
+      @step_back.connect(SIGNAL('pressed()')) { CmdTlmServer.replay_backend.step_back(); @step_back_timeout = 300; @step_back_timer.start(@step_back_timeout) }
+      @step_back.connect(SIGNAL('released()')) { @step_back_timer.stop }
+      @op_button_layout.addWidget(@step_back)
+      @reverse_play = Qt::PushButton.new(Cosmos.get_icon('reverse-play-26.png'), '')
+      @reverse_play.connect(SIGNAL('clicked()')) { CmdTlmServer.replay_backend.reverse_play() }
+      @op_button_layout.addWidget(@reverse_play)
+      @stop = Qt::PushButton.new(Cosmos.get_icon('stop-26.png'), '')
+      @stop.connect(SIGNAL('clicked()')) { CmdTlmServer.replay_backend.stop() }
+      @op_button_layout.addWidget(@stop)
+      @play = Qt::PushButton.new(Cosmos.get_icon('play-26.png'), '')
+      @play.connect(SIGNAL('clicked()')) { CmdTlmServer.replay_backend.play() }
+      @op_button_layout.addWidget(@play)
+      @step_forward = Qt::PushButton.new(Cosmos.get_icon('fast_forward-26.png'), '')
+      @step_forward_timer = Qt::Timer.new
+      @step_forward_timeout = 100
+      @step_forward_timer.connect(SIGNAL('timeout()')) { CmdTlmServer.replay_backend.step_forward(); @step_forward_timeout = (@step_forward_timeout / 2).to_i; @step_forward_timer.start(@step_forward_timeout) }
+      @step_forward.connect(SIGNAL('pressed()')) { CmdTlmServer.replay_backend.step_forward(); @step_forward_timeout = 300; @step_forward_timer.start(@step_forward_timeout) }
+      @step_forward.connect(SIGNAL('released()')) { @step_forward_timer.stop }
+      @op_button_layout.addWidget(@step_forward)
+      @move_end = Qt::PushButton.new(Cosmos.get_icon('end-26.png'), '')
+      @move_end.connect(SIGNAL('clicked()')) { CmdTlmServer.replay_backend.move_end() }
+      @op_button_layout.addWidget(@move_end)
+      @op_layout.addLayout(@op_button_layout)
+
+      # Speed Selection
+      @playback_delay = nil
+      @speed_select = Qt::ComboBox.new
+      @variants = []
+      @variants << [Qt::Variant.new(0.0), 0.0]
+      @speed_select.addItem("No Delay", @variants[-1][0])
+      @variants << [Qt::Variant.new(0.001), 0.001]
+      @speed_select.addItem("1ms Delay", @variants[-1][0])
+      @variants << [Qt::Variant.new(0.002), 0.002]
+      @speed_select.addItem("2ms Delay", @variants[-1][0])
+      @variants << [Qt::Variant.new(0.005), 0.005]
+      @speed_select.addItem("5ms Delay", @variants[-1][0])
+      @variants << [Qt::Variant.new(0.01), 0.01]
+      @speed_select.addItem("10ms Delay", @variants[-1][0])
+      @variants << [Qt::Variant.new(0.05), 0.05]
+      @speed_select.addItem("50ms Delay", @variants[-1][0])
+      @variants << [Qt::Variant.new(0.125), 0.125]
+      @speed_select.addItem("125ms Delay", @variants[-1][0])
+      @variants << [Qt::Variant.new(0.25), 0.25]
+      @speed_select.addItem("250ms Delay", @variants[-1][0])
+      @variants << [Qt::Variant.new(0.5), 0.5]
+      @speed_select.addItem("500ms Delay", @variants[-1][0])
+      @variants << [Qt::Variant.new(1.0), 1.0]
+      @speed_select.addItem("1s Delay", @variants[-1][0])
+      @variants << [Qt::Variant.new(nil), nil]
+      @speed_select.addItem("Realtime", @variants[-1][0])
+      @speed_select.setMaxVisibleItems(11)
+      @speed_select.connect(SIGNAL('currentIndexChanged(int)')) do
+        CmdTlmServer.replay_backend.set_playback_delay(@speed_select.itemData(@speed_select.currentIndex).value)
+      end
+      @speed_layout = Qt::FormLayout.new()
+      @speed_layout.addRow("&Delay:", @speed_select)
+      @status = Qt::LineEdit.new
+      @status.setReadOnly(true)
+      @status.setText('Stopped')
+      @speed_layout.addRow("&Status:", @status)
+      @op_layout.addLayout(@speed_layout)
+      @log_layout.addWidget(@op)
+
+      @file_pos = Qt::GroupBox.new("File Position")
+      @file_pos_layout = Qt::VBoxLayout.new(@file_pos)
+      @slider = Qt::Slider.new(Qt::Horizontal)
+      @slider.setRange(0, 10000)
+      @slider.setTickInterval(1000)
+      @slider.setTickPosition(Qt::Slider::TicksBothSides)
+      @slider.setTracking(false)
+      @slider.connect(SIGNAL('sliderPressed()')) { slider_pressed() }
+      @slider.connect(SIGNAL('sliderReleased()')) { slider_released() }
+      @time_layout = Qt::HBoxLayout.new()
+      @start_time = StringChooser.new(@widget, 'Start:', '', 200, true, true, Qt::AlignCenter | Qt::AlignVCenter)
+      @end_time = StringChooser.new(@widget, 'End:', '', 200, true, true, Qt::AlignCenter | Qt::AlignVCenter)
+      @current_time = StringChooser.new(@widget, 'Current:', '', 200, true, true, Qt::AlignCenter | Qt::AlignVCenter)
+      @time_layout.addWidget(@start_time)
+      @time_layout.addWidget(@current_time)
+      @time_layout.addWidget(@end_time)
+      @file_pos_layout.addLayout(@time_layout)
+      @file_pos_layout.addWidget(@slider)
+      @log_layout.addWidget(@file_pos)
+      layout.addWidget(@log_widget)
+
+      @scroll.setWidget(@widget)
+    end
+
+    # Update the replay tab gui
+    def update
+      status, playback_delay, filename, file_start, file_current, file_end, file_index, @file_max_index = CmdTlmServer.replay_backend.status
+      @status.setText(status)
+      @log_name.text = filename
+      found = false
+      @variants.each_with_index do |data, index|
+        value = data[1]
+        if !playback_delay.nil? and !value.nil?
+          if (playback_delay >= (value - 0.0001)) and (playback_delay <= (value + 0.0001))
+            @speed_select.currentIndex = index
+            found = true
+            break
+          end
+        else
+          if playback_delay == value
+            @speed_select.currentIndex = index
+            found = true
+            break
+          end
+        end
+      end
+      unless found
+        @variants << [Qt::Variant.new(playback_delay.to_f), playback_delay.to_f]
+        @speed_select.addItem("#{(playback_delay.to_f * 1000.0).to_i}ms Delay", @variants[-1][0])
+        @speed_select.currentIndex = @variants.length - 1
+      end
+      @start_time.value = file_start
+      @current_time.value = file_current
+      @end_time.value = file_end
+
+      if @update_slider
+        if @file_max_index != 0
+          value = (((file_index - 1).to_f / @file_max_index.to_f) * 10000.0).to_i
+        else
+          value = 0
+        end
+        @slider.setSliderPosition(value)
+        @slider.setValue(value)
+      end
+    end
+
+    def slider_pressed
+      @update_slider = false
+      CmdTlmServer.replay_backend.stop
+    end
+
+    def slider_released
+      CmdTlmServer.replay_backend.move_index(((@slider.sliderPosition / 10000.0) * (@file_max_index - 1)).to_i)
+      @update_slider = true
+    end
+
+    def shutdown
+      CmdTlmServer.replay_backend.shutdown
+    end
+
+    private
+
+    def select_log_file
+      packet_log_dialog = PacketLogDialog.new(
+        @widget, 'Select Log File', CmdTlmServer.replay_backend.log_directory, CmdTlmServer.replay_backend.packet_log_reader,
+        [], nil, false, false, true, Cosmos::TLM_FILE_PATTERN,
+        Cosmos::BIN_FILE_PATTERN, false
+      )
+      case packet_log_dialog.exec
+      when Qt::Dialog::Accepted
+        CmdTlmServer.replay_backend.select_file(packet_log_dialog.filenames[0], packet_log_dialog.packet_log_reader)
+      end
+    end
+
+  end
+end # module Cosmos