cosmos 4.5.2 → 5.0.3

data/lib/cosmos/gui/line_graph/line_graph_drawing.rb

@@ -1,521 +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
-  class LineGraph < Qt::Widget
-    # Pixels for a label tick
-    LABEL_TICK_SIZE = 3
-    FRAME_OFFSET = 3
-    LEFT_X_LABEL_WIDTH_ADJUST = 10
-
-    @@gradient = Qt::LinearGradient.new(Qt::PointF.new(0, 0), Qt::PointF.new(0, 1))
-    @@gradient.setColorAt(0, Cosmos.getColor(250, 250, 250))
-    @@gradient.setColorAt(0.6, Cosmos.getColor(235, 235, 235))
-    @@gradient.setColorAt(1, Cosmos.getColor(220, 220, 220))
-    @@gradient.setCoordinateMode(Qt::Gradient::ObjectBoundingMode)
-
-    def draw_graph_into_back_buffer
-      # Determine the scale of the graph
-      determine_graph_size()
-      scale_graph()
-      build_x_grid_lines()
-      build_y_grid_lines(@lines.axes)
-      calculate_y_labels()
-      calculate_scaling_factors()
-
-      # Draw overall graph and origin lines
-      draw_graph_background(@painter)
-      draw_origin_lines(@painter)
-
-      # Draw gridlines and titles
-      draw_x_axis_grid_lines(@painter)
-      draw_y_axis_grid_lines(@painter)
-      draw_horizontal_lines(@painter)
-      draw_title(@painter)
-      draw_x_axis_title(@painter)
-      draw_y_axis_title(@painter, :LEFT)
-      draw_y_axis_title(@painter, :RIGHT)
-
-      draw_legend(@painter)
-
-      draw_lines(@painter, :LEFT)
-      draw_lines(@painter, :RIGHT)
-    end # def draw_graph_into_buffer
-
-    # Draws the graph to the screen
-    def draw_graph_to_screen
-      draw_frame(@painter)
-
-      # Draw cursor line and popups if present
-      draw_cursor_line_and_popups(@painter) if @show_cursor_and_popups
-
-      # Draw error icon if present
-      draw_error_icon(@painter)
-    end # def draw_graph_to_screen
-
-    # Draws the colored rectangle for the graph
-    def draw_graph_background(dc)
-      dc.addRectColorFill(@graph_left_x, @graph_top_y, @graph_right_x - @graph_left_x, @graph_bottom_y - @graph_top_y, @label_and_border_color, @@gradient)
-    end
-
-    # Draws origin lines if they fall on the graph
-    def draw_origin_lines(dc)
-      if (@left_y_max > 0) and (@left_y_min < 0) and @lines.axes == :LEFT
-        y1 = scale_value_to_graph_y(0.0, :LEFT)
-        dc.addLineColor(@graph_left_x - 3, y1, @graph_right_x, y1)
-      end
-      if (@right_y_max > 0) and (@right_y_min < 0) and @lines.axes == :RIGHT
-        y1 = scale_value_to_graph_y(0.0, :RIGHT)
-        dc.addLineColor(@graph_left_x, y1, @graph_right_x + 3, y1)
-      end
-      if (@x_max > 0) and (@x_min < 0)
-        x1 = scale_value_to_graph_x(0.0)
-        dc.addLineColor(x1, @graph_bottom_y + 3, x1, @graph_top_y)
-      end
-    end # def draw_origin_lines
-
-    # Draws the gridlines for a y-axis
-    def draw_y_axis_grid_lines(dc)
-      grid_lines = []
-      @y_grid_lines.each_with_index do |value, index|
-        # Don't draw gridlines that are too close to 0
-        if ((value > (@y_grid_line_scale / 2.0)) || (value < (@y_grid_line_scale / -2.0)))
-          grid_lines << draw_y_label(dc, value, index)
-        else
-          grid_lines << draw_y_label(dc, 0, index)
-        end
-      end
-      # Now draw all the grid lines so we can use a single Pen for all
-      grid_lines.each do |y|
-        dc.addLineColor(@graph_left_x, y, @graph_right_x, y, Cosmos::DASHLINE_PEN)
-      end
-    end # def draw_y_axis_grid_lines
-
-    # Calcuate the Y axis labels as well as their width and adjust the size of
-    # the graph accordingly
-    def calculate_y_labels
-      metrics = Cosmos.getFontMetrics(@font)
-      left_widths  = [metrics.width("-1.0")]
-      right_widths = [0]
-      @left_text = []
-      @right_text = []
-
-      @y_grid_lines.each do |value|
-        value = 0 unless ((value > (@y_grid_line_scale / 2.0)) || (value < (@y_grid_line_scale / -2.0)))
-        # Get text for label(s)
-        case @lines.axes
-        when :BOTH
-          @left_text  << convert_y_value_to_text(value, @max_y_characters, :LEFT)
-          left_widths << metrics.width(@left_text[-1])
-          right_value = scale_left_to_right_y(value)
-          @right_text  << convert_y_value_to_text(right_value, @max_y_characters, :RIGHT)
-          right_widths << metrics.width(@right_text[-1])
-        when :LEFT
-          @left_text  << convert_y_value_to_text(value, @max_y_characters, :LEFT)
-          left_widths << metrics.width(@left_text[-1])
-        when :RIGHT
-          @right_text << convert_y_value_to_text(value, @max_y_characters, :RIGHT)
-          right_widths << metrics.width(@right_text[-1])
-        end
-      end
-
-      # Also include half of width of first x label into left widths.
-      value, label = @x_grid_lines[0]
-      if label
-        text = label.to_s
-      else
-        text = convert_x_value_to_text(value)
-      end
-      left_widths << ((metrics.width(text) / 2) - LEFT_X_LABEL_WIDTH_ADJUST)
-
-      @graph_left_x += left_widths.max
-      @graph_right_x -= (right_widths.max + GRAPH_SPACER)
-    end
-
-    # This function is used to draw the y labels.
-    def draw_y_label(dc, value, index)
-      left_value = value
-      right_value = value
-      left_text = @left_text[index]
-      right_text = @right_text[index]
-
-      y = nil
-      if left_text
-        metrics = Cosmos.getFontMetrics(@font)
-        text_width = metrics.width(left_text)
-        x = @graph_left_x
-        y = scale_value_to_graph_y(left_value, :LEFT)
-        if (y < @graph_top_y)
-          y = @graph_top_y
-        elsif (y > @graph_bottom_y)
-          y = @graph_bottom_y
-        end
-        dc.addLineColor(x - LABEL_TICK_SIZE + 1, y, x, y)
-
-        # Only display the label if we have room. This only affects the top
-        # side of the graph since that's where new grid lines appear.
-        if (y == @graph_top_y) || ((y - @font_size) > @graph_top_y)
-          dc.addSimpleTextAt(left_text,
-                             x - text_width - GRAPH_SPACER,
-                             y + (@font_size / 2))
-        end
-      end
-
-      if right_text
-        x = @graph_right_x
-        y = scale_value_to_graph_y(right_value, :RIGHT) unless y
-        if (y < @graph_top_y)
-          y = @graph_top_y
-        elsif (y > @graph_bottom_y)
-          y = @graph_bottom_y
-        end
-        dc.addLineColor(x, y, x + LABEL_TICK_SIZE, y)
-
-        # Only display the label if we have room. This only affects the top
-        # side of the graph since that's where new grid lines appear.
-        if (y == @graph_top_y) || ((y - @font_size) > @graph_top_y)
-          dc.addSimpleTextAt(right_text,
-                             x + 2 * GRAPH_SPACER,
-                             y + (@font_size / 2))
-        end
-      end
-      return y
-    end
-
-    # Draws the gridlines for the x-axis
-    def draw_x_axis_grid_lines(dc)
-      grid_lines = []
-      @x_grid_lines.each do |value, label|
-        # If the line has states or is far enough away from the origin
-        if @lines.x_states || ((value > (@x_grid_line_scale / 2.0)) || (value < (@x_grid_line_scale / -2.0)))
-          grid_lines << draw_x_label(dc, value, label)
-        else
-          grid_lines << draw_x_label(dc, 0, nil)
-        end
-      end
-      # Now draw all the grid lines so we can use a single Pen for all
-      grid_lines.each do |x1, y1, x2, y2|
-        dc.addLineColor(x1, y1, x2, y2, Cosmos::DASHLINE_PEN)
-      end
-    end # def draw_x_axis_grid_lines
-
-    # This function is used to draw the x labels and returns the line
-    # positions.
-    def draw_x_label(dc, value, label)
-      if label
-        text = label.to_s
-      else
-        text = convert_x_value_to_text(value)
-      end
-      metrics = Cosmos.getFontMetrics(@font)
-      text_width  = metrics.width(text)
-      text_height = metrics.height
-      x1 = scale_value_to_graph_x(value)
-      y1 = @graph_bottom_y + LABEL_TICK_SIZE
-      if (x1 < @graph_left_x)
-        x1 = @graph_left_x
-      end
-      if (x1 > @graph_right_x)
-        x1 = @graph_right_x
-      end
-      y2 = @graph_top_y
-      x2 = x1
-
-      # Only display the label if we have room. This really only affects the
-      # right side of the graph since that's where new grid lines appear. The
-      # 1.25 is because we shift the far right label over a bit to eliminate
-      # white space on the right side of the graph.
-      if (x1 == @graph_right_x) || (x1 < (@graph_right_x - (1.25 * text_width)))
-        # Shift the far right label left a bit to eliminate white space
-        text_x = x1 - text_width / 4 if x1 == @graph_right_x
-        text_x = x1 - text_width / 2 # center the text
-        dc.addSimpleTextAt(text, text_x, @graph_bottom_y + text_height + GRAPH_SPACER)
-      end
-      [x1, y1, x2, y2]
-    end # def draw_x_label_and_grid_line
-
-    # Converts a x value into text with a max number of characters
-    def convert_x_value_to_text(value, max_characters = @max_x_characters, full_date = false)
-      if !@show_popup_x_y && @unix_epoch_x_values
-        # Determine if the value is a time stamp and should be converted
-        if value > 1 && value < 2147483647
-          time = Time.at(value).sys
-          time = time.utc if @utc_time
-          if full_date
-            time.formatted # full date with day, month, year
-          else
-            time.formatted(false) # just hour, minutes, seconds
-          end
-        else
-          truncate_to_max(value.to_s, max_characters, value)
-        end
-      else
-        truncate_to_max(value.to_s, max_characters, value)
-      end
-    end
-
-    # Converts a y value into text with a max number of characters
-    def convert_y_value_to_text(value, max_characters, axis)
-      states = @lines.unique_y_states(axis)
-      if states
-        text = states.key(value)
-      else
-        text = truncate_to_max(value.to_s, max_characters, value)
-      end
-      return text
-    end
-
-    # Draws any extra horizontal lines onto the graph
-    def draw_horizontal_lines(dc)
-      @horizontal_lines.each do |y_value, color, axis|
-        y = scale_value_to_graph_y(y_value, axis)
-        if (y > @graph_top_y) and (y < @graph_bottom_y)
-          dc.addLineColor(@graph_left_x, y, @graph_right_x, y, color)
-        end
-      end
-    end
-
-    # Draw the overall graph title above the graph
-    def draw_title(dc)
-      if @title
-        metrics = Cosmos.getFontMetrics(@title_font)
-        dc.setFont(@title_font)
-        dc.addSimpleTextAt(@title, (self.width / 2) - (metrics.width(@title) / 2), metrics.height)
-        dc.setFont(@font)
-      end
-    end
-
-    # Draws the x axis title below the graph
-    def draw_x_axis_title(dc)
-      if @x_axis_title
-        metrics = Cosmos.getFontMetrics(@font)
-        text_width  = metrics.width(@x_axis_title)
-        text_height = metrics.height
-        dc.addSimpleTextAt(@x_axis_title,
-          (((@graph_right_x - @graph_left_x) / 2) + @graph_left_x) - (text_width / 2),
-          @graph_bottom_y + (2 * text_height) + GRAPH_SPACER)
-      end
-    end
-
-    # Draws titles to the left and right of the Y axis
-    def draw_y_axis_title(dc, axis)
-      metrics = Cosmos.getFontMetrics(@font)
-      if axis == :LEFT
-        y_axis_title = @left_y_axis_title
-        graph_x = GRAPH_SPACER
-      else
-        y_axis_title = @right_y_axis_title
-        graph_x = self.width - metrics.width('W') - GRAPH_SPACER - FRAME_OFFSET
-      end
-
-      if y_axis_title
-        text_height = metrics.height
-        total_height = text_height * y_axis_title.length
-        start_height = (height - total_height) / 2
-        max_width = metrics.width('W')
-        y_axis_title.length.times do |index|
-          character = y_axis_title[index..index]
-          cur_width = metrics.width(character)
-          dc.addSimpleTextAt(character, graph_x + ((max_width - cur_width) / 2), start_height + text_height * index)
-        end
-      end
-    end
-
-    # Draws the legend on the bottom of the graph
-    def draw_legend(dc)
-      return if !@show_legend || @lines.empty?
-
-      text_x, text_y, legend_width, legend_height = get_legend_position()
-      if @lines.axes == :BOTH
-        draw_legend_text(dc, :LEFT, text_x, text_y, legend_height)
-        draw_legend_text(dc, :RIGHT, text_x + (legend_width / 2), text_y, legend_height)
-      else
-        draw_legend_text(dc, false, text_x, text_y, legend_height)
-      end
-    end
-
-    # Calculate the legend x, y, width and height
-    def get_legend_position
-      metrics = Cosmos.getFontMetrics(@font)
-      legend_width = 0
-      @lines.legend.each do |legend_text, color, axis|
-        text_width   = metrics.width(legend_text)
-        legend_width = text_width if text_width > legend_width
-      end
-      legend_width += (GRAPH_SPACER * 2)
-      legend_width *= 2 if @lines.axes == :BOTH
-
-      if @legend_position == :right
-        legend_height = 0
-        if @show_legend && !@lines.empty?
-          text_y = (self.height/2) - 1 - (GRAPH_SPACER * 2)
-          text_height = metrics.height
-          if @lines.axes == :BOTH
-            left_count = 0
-            right_count = 0
-            @lines.legend.each do |text, color, axis|
-              if axis == :LEFT
-                left_count += 1
-              else
-                right_count += 1
-              end
-            end
-            if left_count < right_count
-              text_y += text_height * (right_count/2)
-            else
-              text_y += text_height * (left_count/2)
-            end
-          else
-            text_y += text_height * (@lines.size/2)
-          end
-          legend_height = self.height - text_y - GRAPH_SPACER
-        end
-
-        legend_graph_x = self.width - legend_width - GRAPH_SPACER*3
-
-        char_width   = metrics.width('W')
-        legend_graph_x -= (char_width + GRAPH_SPACER) if @right_y_axis_title
-
-        text_x = legend_graph_x + GRAPH_SPACER
-
-      else # @legend_position == :bottom or default
-        legend_graph_x = (self.width - legend_width) / 2
-
-        text_x = legend_graph_x + GRAPH_SPACER
-        text_y = self.height - metrics.height
-      end # @legend_position
-      return [text_x, text_y, legend_width, metrics.height]
-    end
-
-    def draw_legend_text(dc, specific_axis, text_x, text_y, line_height)
-      @lines.legend.reverse_each do |legend_text, color, axis|
-        if !specific_axis || specific_axis == axis
-          dc.addSimpleTextAt(legend_text, text_x, text_y, color)
-          text_y -= line_height
-        end
-      end
-    end
-
-    # Draws all lines for the given axis
-    # def draw_lines(dc, axis)
-
-    # Draws a line between two points that is clipped to fit the visible graph if necessary
-    # def draw_line(dc, x1, y1, x2, y2, show_line, point_size, axis, color)
-
-    # Draws the cursor line and popups if needed - called from drawForeground
-    def draw_cursor_line_and_popups(dc)
-      if @mouse_in_window == true
-        # Draw the cursor line at mouse position
-        x = scale_graph_to_value_x(mapFromGlobal(cursor.pos).x)
-        draw_cursor_line_and_popups_at_x(dc, x)
-
-        # Call callback when the mouse caused the cursor to draw
-        saved_callback = @draw_cursor_line_callback
-        @draw_cursor_line_callback = nil
-        saved_callback.call(self, x, @left_button_pressed) if saved_callback
-        @draw_cursor_line_callback = saved_callback
-      elsif @cursor_line_x
-        # Draw the cursor line at given position
-        draw_cursor_line_and_popups_at_x(dc, @cursor_line_x)
-      end
-    end
-
-    # Draws the cursor line at a given position and builds the popups
-    def draw_cursor_line_and_popups_at_x(dc, x)
-      # Draw cursor line
-      if @lines.left_y_axis? and x <= @x_max and x >= @x_min
-        draw_line(dc, x, @left_y_min, x, @left_y_max, true, 0, :LEFT, @back_color)
-      elsif @lines.right_y_axis? and x <= @x_max and x >= @x_min
-        draw_line(dc, x, @right_y_min, x, @right_y_max, true, 0, :RIGHT, @back_color)
-      end
-
-      # Build and draw popups
-      build_popups_from_x_value(x)
-      draw_popups(dc)
-    end
-
-    # Draws popup boxes if any
-    def draw_popups(dc)
-      unless @popups.empty?
-        # Draw each popup
-        @popups.each do |popup_text, popup_x, popup_y, popup_width, popup_height, popup_color|
-          # Draw overall rectangle
-          dc.addRectColorFill(popup_x, popup_y, popup_width, popup_height, @back_color)
-
-          # Draw border around rectangle in line color
-          dc.addRectColor(popup_x, popup_y, popup_width, popup_height, popup_color)
-
-          # Draw popup text
-          dc.addSimpleTextAt(popup_text, popup_x + 5, popup_y + popup_height - 7, @label_and_border_color)
-        end # popups.each
-      end # unless popups.empty?
-    end
-
-    # Draws the overall frame around the graph, legend, labels, etc
-    def draw_frame(dc)
-      dc.addRectColor(0,0,self.width-1,self.height-1, @frame_color)
-    end
-
-    # Draws an icon that indicates an error has occurred
-    def draw_error_icon(dc)
-      if @error
-        dc.addEllipseColor(@graph_right_x - 60, 20, 40, 40, 'red')
-        dc.addRectColorFill(@graph_right_x - 42, 25, 4, 20, 'red')
-        dc.addRectColorFill(@graph_right_x - 42, 50, 4, 4, 'red')
-      end
-    end
-
-    # Handles window resizes and enforces a minimum size
-    def update_graph_size
-      unless @in_update_graph_size
-        @in_update_graph_size = true
-
-        # Get new width and height
-        new_width  = self.width
-        new_height = self.height
-
-        # Enforce a minimum width and height
-        if (new_width < @minimum_width)
-          new_width = @minimum_width
-        end
-        if (new_height < @minimum_height)
-          new_height = @minimum_height
-        end
-
-        # Make sure everything is the correct size
-        self.resize(new_width, new_height)
-
-        @in_update_graph_size = false
-      end
-    end # def update_graph_size
-
-    protected
-
-    def truncate_to_max(text, max_characters, value)
-      if text.length > max_characters
-        # Transform the text into either decimal floating point or scientific
-        # notation, which ever results in a smaller string
-        text = sprintf("%0.#{max_characters}g", value.to_f)
-        # If the value is still too big we need a smaller decimal
-        if text.length > max_characters
-          # Subtract 5 to get the correct number of characters
-          # For example: sprintf("%0.8g", 9123123123.123) => 9.1231231e+09
-          # We wanted an 8 character string but ended up with 13. We need to
-          # remove 5 of the decimal places so subtract 5.
-          #   sprintf("%0.3g", 9123123123.123) => 9.12e+09
-          precision = max_characters - 5
-          precision = 0 if precision < 0 # Protect against negative
-          text = sprintf("%0.#{precision}g", value.to_f)
-        end
-      end
-      text
-    end
-  end
-end

data/lib/cosmos/gui/line_graph/line_graph_popups.rb

@@ -1,112 +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
-  class LineGraph < Qt::Widget
-    # Builds popups associated with an x value
-    def build_popups_from_x_value(x_value)
-      # Clear any existing popups
-      @popups = []
-
-      if x_value <= @x_max and x_value >= @x_min
-        # Determine how near in x value that the cursor must be to a point
-        value_delta = ((@x_max - @x_min).to_f / (@graph_right_x - @graph_left_x)) * 3.0 # within 3 pixels
-
-        # Add the popups
-        add_popups_for_lines(x_value, value_delta)
-
-        # Make sure popups don't overlap
-        adjust_popup_positions()
-      end
-    end # def build_popups_from_x_value
-
-    # Add popups for the lines on one axis
-    def add_popups_for_lines(x_value, value_delta)
-      popup_values = @lines.get_left_popup_data(x_value, value_delta, @ordered_x_values, @left_y_min, @left_y_max)
-      popup_values.concat(@lines.get_right_popup_data(x_value, value_delta, @ordered_x_values, @right_y_min, @right_y_max))
-      popup_values.each do |x, y, x_text, y_text, item, color, axis|
-        # The get_xxx_popup_data routine can return an empty array if there are
-        # no values for the axis so skip any empty arrays (x is nil)
-        next unless x
-
-        # Determine position in graph coordinates
-        graph_x = scale_value_to_graph_x(x)
-        graph_y = scale_value_to_graph_y(y, axis)
-
-        if @left_button_pressed
-          x_text = convert_x_value_to_text(x, 25, true) unless x_text
-          popup_text = "(#{item}) #{x_text}, #{y_text}"
-        else
-          x_text = convert_x_value_to_text(x) unless x_text
-          popup_text = "#{x_text}, #{y_text}"
-        end
-
-        # Determine popup's width and height based on width/height of text
-        metrics = Qt::FontMetrics.new(@font)
-        popup_width = metrics.width(popup_text) + 10
-        popup_height = metrics.height + 10
-
-        # Make sure that the popup stays in the graph window on the x axis.
-        graph_x_adjusted = popup_width + graph_x
-        if graph_x_adjusted > self.width
-          graph_x -= popup_width
-          graph_x = 0 if graph_x < 0
-        end
-
-        # Make sure that the popup stays in the graph window on the y axis.
-        graph_y_adjusted = popup_height + graph_y
-        if graph_y_adjusted > (self.height - 1)
-          graph_y = self.height - 1 - popup_height
-        else
-          graph_y -= popup_height
-        end
-        graph_y = 1 if graph_y < 1
-
-        # Add popup
-        @popups << [popup_text, graph_x, graph_y, popup_width, popup_height, color]
-      end
-    end # def add_popups_for_line
-
-    # Algorithm to not overlap popups
-    def adjust_popup_positions
-      # Sort popups by graph_y
-      @popups.sort! {|a,b| a[2] <=> b[2]}
-
-      # Determine if any popups overlap vertically
-      overlap = false
-      index = 0
-      max_index = @popups.length - 1
-      @popups.each do |popup_text, graph_x, graph_y, popup_width, popup_height, color|
-        break if index == max_index
-        if (graph_y + popup_height) > @popups[index + 1][2] # graph_y of next popup
-          overlap = true
-          break
-        end
-        index += 1
-      end
-
-      # Handle overlap case
-      if overlap
-        # Determine needed statistics
-        combined_height = 0
-        @popups.each do |popup_text, graph_x, graph_y, popup_width, popup_height, color|
-          combined_height += popup_height + 1
-        end
-
-        # Stack popups around center of canvas
-        next_graph_y = ((self.height / 2) - (combined_height / 2)).to_i
-        @popups.length.times do |popup_index|
-          @popups[popup_index][2] = next_graph_y
-          next_graph_y += @popups[popup_index][4] + 2
-        end
-      end
-    end
-  end
-end