cosmos 4.5.2 → 5.0.2.pre.beta2

data/lib/cosmos/tools/handbook_creator/handbook_creator_config.rb

@@ -1,380 +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'
-require 'erb'
-require 'tempfile'
-require 'open3'
-
-module Cosmos
-  # Reads an ascii file that defines the configuration settings used to
-  # configure the Handbook Creator
-  class HandbookCreatorConfig
-    attr_reader :pages
-
-    # Builds a page for the handbook. Pages can be either :NORMAL or :TARGETS.
-    # :TARGETS page builds pages for each of the targets in the system.
-    class Page
-      attr_reader :filename
-      attr_reader :type
-      attr_reader :target_names
-      attr_reader :sections
-      attr_accessor :pdf
-      attr_accessor :pdf_cover_filename
-      attr_accessor :pdf_cover_title
-      attr_accessor :pdf_header_filename
-      attr_accessor :pdf_header_title
-      attr_accessor :pdf_footer_filename
-      attr_accessor :pdf_footer_title
-      attr_accessor :pdf_toc
-      attr_accessor :pdf_top_margin
-      attr_accessor :pdf_bottom_margin
-      attr_accessor :pdf_side_margin
-
-      def initialize(filename, type = :NORMAL)
-        @filename = filename
-        @type = type
-        @target_names = []
-        @sections = []
-        @pdf = true
-        @pdf_toc = nil
-        @pdf_cover_filename = nil
-        @pdf_cover_title = nil
-        @pdf_header_filename = nil
-        @pdf_header_title = nil
-        @pdf_footer_filename = nil
-        @pdf_footer_title = nil
-        @pdf_top_margin = 20
-        @pdf_bottom_margin = 15
-        @pdf_side_margin = 10
-      end
-
-      def add_target_name(target_name)
-        @target_names << target_name.upcase
-        @target_names.uniq!
-      end
-
-      def add_section(section)
-        @sections << section
-      end
-
-      def create_html(hide_ignored)
-        @hide_ignored = hide_ignored
-        Cosmos.set_working_dir do
-          if @type == :TARGETS
-            target_names = @target_names
-            target_names = System.commands.target_names | System.telemetry.target_names if @target_names.empty?
-            target_names.each {|target_name| create_file(target_name.downcase + @filename, [target_name], true, :HTML)}
-          else # @type == :NORMAL
-            create_file(@filename, @target_names, false, :HTML)
-          end
-        end
-      end
-
-      def create_pdf(hide_ignored, progress_dialog = nil)
-        @hide_ignored = hide_ignored
-        if @pdf
-          if progress_dialog
-            Qt.execute_in_main_thread(true) do
-              progress_dialog.set_text_font(Cosmos.get_default_font)
-            end
-          end
-          Cosmos.set_working_dir do
-            if @type == :TARGETS
-              target_names = @target_names
-              target_names = System.commands.target_names | System.telemetry.target_names if @target_names.empty?
-              target_names.each do |target_name|
-                create_pdf_file(progress_dialog, target_name)
-              end
-            else # @type == :NORMAL
-              create_pdf_file(progress_dialog)
-            end
-          end
-        end
-      end
-
-      protected
-
-      def create_pdf_file(progress_dialog, target_name = nil)
-        tmp_html_file = Tempfile.new(['pdf', '.html'], System.paths['HANDBOOKS'])
-        if target_name
-          filename = File.join(System.paths['HANDBOOKS'], target_name.downcase + @filename)
-          create_file(tmp_html_file, [target_name], true, :PDF)
-        else
-          filename = File.join(System.paths['HANDBOOKS'], @filename)
-          create_file(tmp_html_file, @target_names, false, :PDF)
-        end
-        tmp_html_file.close
-        cover, cover_file = make_pdf_detail('cover', @pdf_cover_filename, @pdf_cover_title, target_name)
-        header, header_file = make_pdf_detail('--header-spacing 3 --header-html', @pdf_header_filename, @pdf_header_title, target_name)
-        footer, footer_file = make_pdf_detail('--footer-spacing 3 --footer-html', @pdf_footer_filename, @pdf_footer_title, target_name)
-        system_call = "wkhtmltopdf --enable-local-file-access -L #{@pdf_side_margin} -R #{@pdf_side_margin} -T #{@pdf_top_margin} -B #{@pdf_bottom_margin} -s Letter #{header} #{footer} #{cover} #{@pdf_toc} \"#{tmp_html_file.path}\" \"#{File.dirname(filename)}/#{File.basename(filename, '.*')}.pdf\""
-        status = nil
-        begin
-          Cosmos.set_working_dir(System.paths['HANDBOOKS']) do
-            Open3.popen2e(system_call) do |stdin, stdout_and_stderr, wait_thr|
-              while wait_thr.alive?
-                stdout_and_stderr.each_line do |line|
-                  progress_dialog.append_text(line.chomp) if progress_dialog
-                end
-              end
-              status = wait_thr.value
-            end
-          end
-        rescue Errno::ENOENT
-          status = nil
-        end
-        tmp_html_file.unlink
-        cover_file.unlink if cover_file
-        header_file.unlink if header_file
-        footer_file.unlink if footer_file
-        raise "Call to wkhtmltopdf failed" if !status or !status.success?
-      end
-
-      def make_pdf_detail(tag, filename, title, target_name = nil)
-        if filename
-          file = Tempfile.new(['pdf', '.html'], System.paths['HANDBOOKS'])
-          if target_name
-            title = target_name + ' ' + title
-          else
-            title = title
-          end
-          file.write(ERB.new(File.read(File.join(USERPATH, 'config', 'tools', 'handbook_creator', 'templates', filename))).result(binding))
-          file.close
-          result = "#{tag} \"#{file.path}\""
-          return result, file
-        end
-        return nil, nil
-      end
-
-      def create_file(filename, target_names, target_pages, output)
-        if Tempfile === filename
-          create_file_internal(filename, target_names, target_pages, output)
-        else
-          File.open(File.join(System.paths['HANDBOOKS'], filename), "w") do |file|
-            create_file_internal(file, target_names, target_pages, output)
-          end
-        end
-      end
-
-      def create_file_internal(file, target_names, target_pages, output)
-        @sections.each do |section|
-          if section.output != :ALL
-            next unless section.output == output
-          end
-          packets = build_packets(section.type, target_names)
-          ignored = build_ignored(section.type, target_names)
-          if target_pages
-            section.create(file, target_names[0] + ' ' + section.title.to_s, packets, ignored)
-          else
-            section.create(file, section.title.to_s, packets, ignored)
-          end
-        end
-      end
-
-      def build_ignored(type, target_names)
-        ignored = {}
-        target_names = System.targets.keys if target_names.empty?
-        target_names.each do |name|
-          if @hide_ignored
-            if type == :CMD
-              ignored[name] = System.targets[name].ignored_parameters
-            elsif type == :TLM
-              ignored[name] = System.targets[name].ignored_items
-            end
-          else
-            # If we're not ignoring items the hash contains an empty array
-            ignored[name] = []
-          end
-        end
-        ignored
-      end
-
-      def build_packets(type, target_names)
-        packets = []
-        case type
-        when :CMD
-          packet_accessor = System.commands
-        when :TLM
-          packet_accessor = System.telemetry
-        else
-          # Return the empty array because there are no packets
-          return packets
-        end
-        if target_names.empty?
-          packet_accessor.all.sort.each do |target_name, target_packets|
-            target_packets.sort.each do |packet_name, packet|
-              next if packet.target_name == "UNKNOWN"
-              next if packet.hidden
-              packets << packet
-            end
-          end
-        else
-          target_names.each do |target_name|
-            begin
-              packet_accessor.packets(target_name).sort.each do |packet_name, packet|
-                next if packet.hidden
-                packets << packet
-              end
-            rescue
-              # No commands
-            end
-          end
-        end
-        packets
-      end
-    end
-
-    # Encapsulates a section of the PDF or webpage which can be :CMD, :TLM, or :NONE.
-    class Section
-      attr_reader :filename
-      attr_reader :type
-      attr_reader :title
-      attr_reader :output
-
-      def initialize(output, filename, title, type = :NONE)
-        raise "Unknown output: #{output.to_s.upcase}" unless ['ALL', 'HTML', 'PDF'].include?(output.to_s.upcase)
-        @output = output.to_s.upcase.intern
-        @filename = File.join(USERPATH, 'config', 'tools', 'handbook_creator', 'templates', filename)
-        @title = title
-        @type = type
-      end
-
-      def create(file, title, packets = [], ignored = {})
-        file.puts ERB.new(File.read(@filename)).result(binding)
-      end
-    end
-
-    # Parses the configuration file.
-    #
-    # @param filename [String] The name of the configuration file to parse
-    def initialize(filename)
-      @pages = []
-      process_file(filename)
-    end
-
-    def create_html(hide_ignored)
-      @pages.each {|page| page.create_html(hide_ignored)}
-    end
-
-    def create_pdf(hide_ignored, progress_dialog = nil)
-      begin
-        @pages.each_with_index do |page, index|
-          progress_dialog.set_overall_progress(index.to_f / @pages.length.to_f) if progress_dialog
-          page.create_pdf(hide_ignored, progress_dialog)
-        end
-        progress_dialog.set_overall_progress(1.0) if progress_dialog
-      rescue Exception => err
-        if err.message == "Call to wkhtmltopdf failed"
-          return false
-        else
-          raise err
-        end
-      end
-      true
-    end
-
-    protected
-
-    # Processes a file and adds in the configuration defined in the file
-    #
-    # @param filename [String] The name of the configuration file to parse
-    def process_file(filename)
-      current_page = nil
-      current_section = nil
-      Logger.info "Processing Handbook Creator configuration in file: #{File.expand_path(filename)}"
-
-      parser = ConfigParser.new
-      parser.parse_file(filename) do |keyword, params|
-        case keyword
-        when 'PAGE'
-          parser.verify_num_parameters(1, 1, "#{keyword} <Filename>")
-          current_page = Page.new(params[0])
-          @pages << current_page
-
-        when 'TARGET_PAGES'
-          parser.verify_num_parameters(1, 1, "#{keyword} <Filename Postfix>")
-          current_page = Page.new(params[0], :TARGETS)
-          @pages << current_page
-
-        when 'NO_PDF'
-          raise parser.error("#{keyword} must be preceded by PAGE or TARGET_PAGES") unless current_page
-          parser.verify_num_parameters(0, 0, "#{keyword}")
-          current_page.pdf = false
-
-        when 'PDF_COVER'
-          raise parser.error("#{keyword} must be preceded by PAGE or TARGET_PAGES") unless current_page
-          parser.verify_num_parameters(2, 2, "#{keyword} <Cover html.erb file> <Title Text>")
-          current_page.pdf_cover_filename = params[0].to_s
-          current_page.pdf_cover_title = params[1].to_s
-
-        when 'PDF_TOC'
-          raise parser.error("#{keyword} must be preceded by PAGE or TARGET_PAGES") unless current_page
-          parser.verify_num_parameters(0, 0, "#{keyword}")
-          current_page.pdf_toc = "toc --xsl-style-sheet \"#{File.join(USERPATH, 'config', 'tools', 'handbook_creator', 'default_toc.xsl')}\""
-
-        when 'PDF_HEADER'
-          raise parser.error("#{keyword} must be preceded by PAGE or TARGET_PAGES") unless current_page
-          parser.verify_num_parameters(2, 2, "#{keyword} <Header html.erb file> <Title Text>")
-          current_page.pdf_header_filename = params[0].to_s
-          current_page.pdf_header_title = params[1].to_s
-
-        when 'PDF_FOOTER'
-          raise parser.error("#{keyword} must be preceded by PAGE or TARGET_PAGES") unless current_page
-          parser.verify_num_parameters(2, 2, "#{keyword} <Footer html.erb file> <Title Text>")
-          current_page.pdf_footer_filename = params[0].to_s
-          current_page.pdf_footer_title = params[1].to_s
-
-        when 'PDF_TOP_MARGIN'
-          raise parser.error("#{keyword} must be preceded by PAGE or TARGET_PAGES") unless current_page
-          parser.verify_num_parameters(1, 1, "#{keyword} <Margin in mm>")
-          current_page.pdf_top_margin = params[0].to_i
-
-        when 'PDF_BOTTOM_MARGIN'
-          raise parser.error("#{keyword} must be preceded by PAGE or TARGET_PAGES") unless current_page
-          parser.verify_num_parameters(1, 1, "#{keyword} <Margin in mm>")
-          current_page.pdf_bottom_margin = params[0].to_i
-
-        when 'PDF_SIDE_MARGIN'
-          raise parser.error("#{keyword} must be preceded by PAGE or TARGET_PAGES") unless current_page
-          parser.verify_num_parameters(1, 1, "#{keyword} <Margin in mm>")
-          current_page.pdf_side_margin = params[0].to_i
-
-        when 'TARGET'
-          raise parser.error("#{keyword} must be preceded by PAGE or TARGET_PAGES") unless current_page
-          parser.verify_num_parameters(1, 1, "#{keyword} <Target Name>")
-          current_page.add_target_name(params[0])
-
-        when 'SECTION'
-          raise parser.error("#{keyword} must be preceded by PAGE or TARGET_PAGES") unless current_page
-          parser.verify_num_parameters(2, 3, "#{keyword} <Filename> <output: ALL, HTML, or PDF> <Title (optional)>")
-          current_section = Section.new(params[0], params[1], params[2])
-          current_page.add_section(current_section)
-
-        when 'CMD_SECTION'
-          raise parser.error("#{keyword} must be preceded by PAGE or TARGET_PAGES") unless current_page
-          parser.verify_num_parameters(2, 3, "#{keyword} <Filename> <output: ALL, HTML, or PDF> <Title (optional)>")
-          current_section = Section.new(params[0], params[1], params[2], :CMD)
-          current_page.add_section(current_section)
-
-        when 'TLM_SECTION'
-          raise parser.error("#{keyword} must be preceded by PAGE or TARGET_PAGES") unless current_page
-          parser.verify_num_parameters(2, 3, "#{keyword} <Filename> <output: ALL, HTML, or PDF> <Title (optional)>")
-          current_section = Section.new(params[0], params[1], params[2], :TLM)
-          current_page.add_section(current_section)
-
-        else
-          # blank lines will have a nil keyword and should not raise an exception
-          raise parser.error("Unknown keyword: #{keyword}") unless keyword.nil?
-        end
-      end # loop
-    end
-  end
-end

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

@@ -1,195 +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/tools/launcher/launcher_config'
-  require 'cosmos/tools/launcher/launcher_tool'
-  require 'cosmos/tools/launcher/launcher_multitool'
-  require 'cosmos/gui/dialogs/legal_dialog'
-end
-
-module Cosmos
-  # Provides a group of buttons which can be configured to launch any of the
-  # COSMOS tools as well as any custom applications.
-  class Launcher < QtTool
-    def initialize(options)
-      super(options) # MUST BE FIRST - All code before super is executed twice in RubyQt Based classes
-
-      # Set environment variable of COSMOS_USERPATH so that all launched apps
-      # know where to find the configuration
-      ENV['COSMOS_USERPATH'] = Cosmos::USERPATH
-
-      Cosmos.load_cosmos_icon("launcher.png")
-      layout.setSizeConstraint(Qt::Layout::SetFixedSize)
-
-      @about_string = "Launcher provides a list of applications to launch at the click of a button. "\
-        "It can also launch multiple applications and configure their exact placement on the screen."
-      initialize_actions()
-      initialize_menus()
-      initialize_central_widget()
-      complete_initialize()
-    end
-
-    def initialize_menus
-      @file_menu = menuBar().addMenu('&File')
-      @file_menu.addAction(@exit_action)
-      initialize_help_menu()
-    end
-
-    def initialize_central_widget
-      begin
-        config = LauncherConfig.new(@options.config_file)
-      rescue => error
-        ExceptionDialog.new(self, error, "Error parsing #{@options.config_file}")
-      end
-
-      self.window_title = config.title
-      central_widget = Qt::Widget.new
-      setCentralWidget(central_widget)
-
-      # Create each button or divider
-      default_icon_filename = 'COSMOS_64x64.png'
-      widgets = []
-      config.items.each do |item_type, text, shell_command_or_settings, capture_io, icon_filename, variable_parameters|
-        case item_type
-        when :TOOL, :MULTITOOL
-          if @options.mini
-            layout = Qt::HBoxLayout.new
-          else
-            layout = Qt::VBoxLayout.new
-          end
-          if icon_filename
-            icon = Cosmos.get_icon(icon_filename)
-          else
-            icon = Cosmos.get_icon(default_icon_filename)
-          end
-          button = Qt::PushButton.new('')
-          button.setIcon(icon)
-          size = @options.mini ? 20 : 64
-          button.setIconSize(Qt::Size.new(size, size))
-
-          if item_type == :TOOL
-            connect(button,
-                    SIGNAL('clicked()'),
-                    LauncherTool.new(self, text, shell_command_or_settings, capture_io, variable_parameters),
-                    SLOT('button_clicked()'))
-          else
-            connect(button,
-                    SIGNAL('clicked()'),
-                    LauncherMultitool.new(self, shell_command_or_settings),
-                    SLOT('button_clicked()'))
-          end
-          if Kernel.is_mac?
-            size = @options.mini ? 40 : 84
-            button.setFixedSize(size, size)
-          else
-            stylesheet = "padding:4px; text-align:center; " \
-              "font-family:#{config.tool_font_settings[0]}; " \
-              "font-size:#{config.tool_font_settings[1]}px"
-            button.setStyleSheet(stylesheet)
-            size = @options.mini ? 30 : 70
-            button.setFixedSize(size, size)
-          end
-          label = Qt::Label.new(text)
-          stylesheet = "text-align:center; " \
-            "font-family:#{config.tool_font_settings[0]}; " \
-            "font-size:#{config.tool_font_settings[1]}px"
-          label.setStyleSheet(stylesheet)
-          label.setObjectName("ButtonLabel")
-          unless @options.mini
-            label.wordWrap = true
-            label.setFixedWidth(70)
-            label.setSizePolicy(Qt::SizePolicy::Fixed, Qt::SizePolicy::Fixed)
-            label.setMinimumSize(label.sizeHint)
-            label.setAlignment(Qt::AlignHCenter)
-          end
-          layout.addWidget(button)
-          layout.addWidget(label)
-          unless @options.mini
-            layout.setAlignment(button, Qt::AlignHCenter)
-            layout.setAlignment(label, Qt::AlignHCenter)
-          end
-          widgets << layout
-
-        when :DIVIDER
-          divider = Qt::Frame.new
-          divider.setObjectName("Divider")
-          divider.setFrameStyle(Qt::Frame::HLine | Qt::Frame::Raised)
-          divider.setLineWidth(1)
-          divider.setMidLineWidth(1)
-          widgets << divider
-
-        when :LABEL
-          label = Qt::Label.new(text)
-          stylesheet = "text-align:center; " \
-            "font-family:#{config.label_font_settings[0]}; " \
-            "font-size:#{config.label_font_settings[1]}px"
-          label.setStyleSheet(stylesheet)
-          label.setObjectName("Label")
-          widgets << label
-
-        else
-          raise "Unhandled item type from LauncherConfig: #{item_type}"
-        end
-      end
-
-      # Add widgets to layout
-      col = 0
-      h_layout = nil
-      v_layout = Qt::VBoxLayout.new
-      central_widget.layout = v_layout
-      widgets.each do |widget|
-        if widget.is_a?(Qt::BoxLayout)
-          unless h_layout
-            h_layout = Qt::HBoxLayout.new
-            v_layout.addLayout(h_layout)
-            col = 0
-          end
-          widget.setAlignment(Qt::AlignTop | Qt::AlignLeft)
-          h_layout.addLayout(widget)
-          col += 1
-          if col >= config.num_columns
-            col = 0
-            h_layout = nil
-          end
-        else
-          # Divider or Label
-          h_layout.addStretch(0) if h_layout
-          v_layout.addWidget(widget)
-          h_layout = nil
-        end
-      end
-      h_layout.addStretch(0) if h_layout
-    end
-
-    def self.pre_window_new_hook(options)
-      # Show legal dialog
-      LegalDialog.new
-    end
-
-    def self.run(option_parser = nil, options = nil)
-      Cosmos.catch_fatal_exception do
-        unless option_parser and options
-          option_parser, options = create_default_options()
-          options.title = 'Launcher'
-          options.config_file = true # config_file is required
-        end
-        option_parser.separator "Launcher Specific Options:"
-        option_parser.on("-m", "--mini", "Create mini launcher") do |arg|
-          options.mini = true
-        end
-
-        super(option_parser, options)
-      end
-    end
-  end
-end