wxruby3-shapes 0.9.0.pre.beta.3

data/lib/wx/shapes/auto_layout.rb

@@ -0,0 +1,358 @@
+# Wx::SF - layout algorithm classes
+# Copyright (c) M.J.N. Corino, The Netherlands
+
+module Wx::SF
+
+  # Base class for all layouting algorithms. 
+  class LayoutAlgorithm
+    
+    # Function performing the layout change. All derived classes must implement it.
+    # @param [Array<Shape>] shapes List of shapes which should be layout-ed
+    def do_layout(shapes)
+      ::Kernel.raise NotImplementedError
+    end
+    
+    protected
+    
+    # Calculate bounding box surrounding given shapes.
+    # @param [Array<Shape>] shapes List of shapes
+    # @return [Wx::Rect] Bounding box
+    def get_bounding_box(shapes)
+      shapes.inject(nil) do |rct_bb, shape|
+        rct_bb ? rct_bb.union!(shape.get_bounding_box) : shape.get_bounding_box
+      end
+    end
+
+    # Get overall extent of all given shapes calculated as a sum of their width and height.
+    # @param [Array<Shape>] shapes List of shapes
+    # @return [Wx::Size] Overall shapes extent
+    def get_shapes_extent(shapes)
+      shapes.inject(Wx::Size.new) do |ext_sz, shape|
+        sh_bb = shape.get_bounding_box
+        ext_sz.width += sh_bb.width
+        ext_sz.height += sh_bb.height
+        ext_sz
+      end
+    end
+
+    # Get center point of given shapes.
+    # @param [Array<Shape>] shapes List of shapes
+    # @return [Wx::RealPoint] Center point
+    def get_shapes_center(shapes)
+      center = shapes.inject(Wx::RealPoint.new) do |centre, shape|
+        sh_pos = shape.get_absolute_position
+        centre.x += sh_pos.x
+        centre.y += sh_pos.y
+        centre
+      end
+      center.x /= shapes.size
+      center.y /= shapes.size
+      center
+    end
+
+    # Get top-left point of bounding box surrounding given shapes.
+    # @param [Array<Shape>] shapes List of shapes
+    # @return [Wx::RealPoint] Top-left point of bounding box surrounding given shapes
+    def get_top_left(shapes)
+      shapes.inject(Wx::RealPoint.new(::Float::MAX, ::Float::MAX)) do |pos, shape|
+        sh_pos = shape.get_absolute_position
+        pos.x = sh_pos.x if sh_pos.x < pos.x
+        pos.y = sh_pos.y if sh_pos.y < pos.y
+        pos
+      end
+    end
+
+  end
+  
+
+  # pre-defined algorithms ###########################
+  
+  # Class encapsulating algorithm which layouts all top-most shapes into circle registered under "Circle" name.
+  # The algorithm doesn't optimize connection lines crossing.
+  class LayoutCircle < LayoutAlgorithm
+    
+    # Constructor.
+    def initialize
+      @distance_ratio = 1.0
+    end
+
+    # Get or set ratio in which calculated distance between shapes will be reduced. Values less than
+    # 1 means that the distance will be smaller, values bigger than 1 means that the distance will be
+    # bigger.
+    attr_accessor :distance_ratio
+
+    # Function performing the layout change.
+    # @param [Array<Shape>] shapes List of shapes which should be layout-ed
+    def do_layout(shapes)
+      size_shapes = get_shapes_extent(shapes)
+      center = get_shapes_center(shapes)
+
+      # double x, y
+      step = 360.0 / shapes.size
+      degree = 0
+      rx = (size_shapes.x / 2) * @distance_ratio
+      ry = (size_shapes.y / 2) * @distance_ratio
+
+      shapes.each do |shape|
+        x = center.x + Math.cos(degree * Math::PI / 180 ) * rx
+        y = center.y + Math.sin( degree * Math::PI / 180 ) * ry
+        degree += step
+        shape.move_to(x, y)
+      end
+    end
+
+  end
+
+  # Class encapsulating algorithm which layouts all top-most shapes into vertical tree registered under "Vertical Tree" name.
+  class LayoutVerticalTree < LayoutAlgorithm
+
+    # Constructor.
+    def initialize
+      @h_space = @v_space = 30.0
+    end
+
+    # Get or set horizontal space between shapes.
+    attr_accessor :h_space
+
+    # Get or set vertical space between shapes.
+    attr_accessor :v_space
+
+    # Function performing the layout change.
+    # @param [Array<Shape>] shapes List of shapes which should be layout-ed
+    def do_layout(shapes)
+      start = get_top_left(shapes)
+      min_x = start.x
+      # find root items
+      shapes.each do |shape|
+        lst_connections = shape.get_assigned_connections(LineShape, Shape::CONNECTMODE::ENDING)
+
+        min_x, _ = process_node(shape, start.y, min_x, 0) if lst_connections.empty?
+      end
+    end
+
+    protected
+
+    # Process single shape.
+    # @param [Wx::Shape] node processed shape.
+    # @param [Float] y Vertical position of the shape.
+    # @param [Float] min_x
+    # @param [Integer] curr_max_width
+    # @return [Array(Float, Integer)]
+    def process_node(node, y, min_x, curr_max_width)
+      if node
+        node.move_to(min_x, y)
+        
+        rct_bb = node.get_bounding_box
+        curr_max_width = rct_bb.width if rct_bb.width > curr_max_width
+        
+        lst_neighbours = node.get_neighbours(Shape, Shape::CONNECTMODE::STARTING)
+    
+        if lst_neighbours.empty?
+          min_x += curr_max_width + @h_space
+        else
+          lst_neighbours.each do |nbs|
+            unless nbs.get_parent_shape
+              min_x, curr_max_width = process_node(nbs, y + rct_bb.height + @v_space, min_x, curr_max_width)
+            end
+          end
+        end
+      end
+      [min_x, curr_max_width]
+    end
+
+  end
+
+  # Class encapsulating algorithm which layouts all top-most shapes into horizontal tree registered under "Horizontal Tree" name.
+  class LayoutHorizontalTree < LayoutAlgorithm
+
+    # Constructor.
+    def initialize
+      @h_space = @v_space = 30.0
+    end
+
+    # Get or set horizontal space between shapes.
+    attr_accessor :h_space
+
+    # Get or set vertical space between shapes.
+    attr_accessor :v_space
+
+    # Function performing the layout change.
+    # @param [Array<Shape>] shapes List of shapes which should be layout-ed
+    def do_layout(shapes)
+      start = get_top_left(shapes)
+      min_y = start.y
+      # find root items
+      shapes.each do |shape|
+        lst_connections = shape.get_assigned_connections(LineShape, Shape::CONNECTMODE::ENDING)
+
+        min_y, _ = process_node(shape, start.x, min_y, 0) if lst_connections.empty?
+      end
+    end
+
+    protected
+
+    # Process single shape.
+    # @param [Wx::Shape] node processed shape.
+    # @param [Float] x Vertical position of the shape.
+    # @param [Float] min_y
+    # @param [Integer] curr_max_height
+    # @return [Array(Float, Integer)]
+    def process_node(node, x, min_y, curr_max_height)
+      if node
+        node.move_to(x, min_y)
+
+        rct_bb = node.get_bounding_box
+        curr_max_height = rct_bb.height if rct_bb.height > curr_max_height
+
+        lst_neighbours = node.get_neighbours(Shape, Shape::CONNECTMODE::STARTING)
+
+        if lst_neighbours.empty?
+          min_y += curr_max_height + @v_space
+        else
+          lst_neighbours.each do |nbs|
+            unless nbs.get_parent_shape
+              min_y, curr_max_height = process_node(nbs, x + rct_bb.width + @h_space, min_y, curr_max_height)
+            end
+          end
+        end
+      end
+      [min_y, curr_max_height]
+    end
+
+  end
+
+  # Class encapsulating algorithm which layouts all top-most shapes into mesh registered under "Mesh" name.
+  # The algorithm doesn't optimize connection lines crossing.
+  class LayoutMesh < LayoutAlgorithm
+
+    # Constructor.
+    def initialize
+      @h_space = @v_space = 30.0
+    end
+
+    # Get or set horizontal space between shapes.
+    attr_accessor :h_space
+
+    # Get or set vertical space between shapes.
+    attr_accessor :v_space
+
+    # Function performing the layout change.
+    # @param [Array<Shape>] shapes List of shapes which should be layout-ed
+    def do_layout(shapes)
+      cols = Math.sqrt(shapes.size).floor
+      max_h = -@h_space
+      roffset = coffset = 0
+
+      start = get_top_left(shapes)
+
+      shapes.each_with_index do |shape, i|
+        if (i % cols) == 0
+          coffset = 0
+          roffset += max_h + @h_space
+          max_h = 0
+        end
+
+        shape.move_to(start.x + coffset, start.y + roffset)
+
+        rct_bb = shape.get_bounding_box
+        coffset += rct_bb.width + @v_space
+
+        max_h = rct_bb.height if rct_bb.height > max_h
+      end
+    end
+
+  end
+
+  # Module implements automatic diagram layout. The module allows to automatically layout shapes
+  # included in diagram manager/shape canvas/list of shapes by using several pre-defined layouting
+  # algorithms. The module should be used as it is.
+  module AutoLayout
+
+    class << self
+
+      def layout_algorithms_table
+        @layout_algorithms ||= {}
+      end
+      private :layout_algorithms_table
+
+      def register_layout_algorithm(name, klass)
+        layout_algorithms_table[name.to_s] = klass
+      end
+
+      def get_layout_algorithm(name)
+        layout_algorithms_table.has_key?(name.to_s) ? layout_algorithms_table[name.to_s].new : nil
+      end
+
+      def layout_algorithms
+        layout_algorithms_table.keys
+      end
+
+      def each_layout_algorithm(&block)
+        if block
+          layout_algorithms_table.each_value { |klass| block.call(klass.new) }
+        else
+          ::Enumerator.new { |y| layout_algorithms_table.each_value { |klass| y << klass.new } }
+        end
+      end
+
+      # @overload layout(shapes, algname)
+      #   Layout shapes included in given list.
+      #   @param [Array<Shape>] shapes List of shapes
+      #   @param [String] algname Algorithm name
+      #   @return [Boolean] true if layout algorithm was found and executed, false otherwise
+      # @overload layout(diagram, algname)
+      #   Layout shapes included in given diagram.
+      #   @param [Diagram] diagram Reference to diagram
+      #   @param [String] algname Algorithm name
+      #   @return [Boolean] true if layout algorithm was found and executed, false otherwise
+      # @overload layout(canvas, algname)
+      #   Layout shapes included in given shape canvas.
+      #   @param [ShapeCanvas] canvas Reference to shape canvas
+      #   @param [String] algname Algorithm name
+      #   @return [Boolean] true if layout algorithm was found and executed, false otherwise
+      def layout(shapes, algname)
+        if shapes.is_a?(::Array)
+          alg = get_layout_algorithm(algname)
+          if alg
+            shapes.first.get_diagram.set_modified unless shapes.empty? || shapes.first.get_diagram.nil?
+            alg.do_layout(shapes)
+            return true
+          end
+        elsif shapes.is_a?(Diagram) || shapes.is_a?(ShapeCanvas)
+          alg = get_layout_algorithm(algname)
+          if alg
+            diagram = shapes.is_a?(Diagram) ? shapes : shapes.get_diagram
+            # layout all top level shapes excluding the line shapes
+            alg.do_layout(diagram.get_top_shapes.reject { |shp| shp.is_a?(LineShape) })
+            diagram.move_shapes_from_negatives
+            diagram.set_modified
+            update_canvas(diagram.get_shape_canvas) if diagram.get_shape_canvas
+            return true
+          end
+        else
+          ::Kernel.raise ArgumentError, 'Expected array, diagram or canvas'
+        end
+        false
+      end
+
+      protected
+
+      # Update given shape canvas.
+      # @param [ShapeCanvas] canvas
+      def update_canvas(canvas)
+        canvas.center_shapes
+        canvas.update_virtual_size
+        canvas.update_multiedit_size
+        canvas.refresh(false)
+      end
+
+    end
+
+    register_layout_algorithm('Circle', LayoutCircle)
+    register_layout_algorithm('Mesh', LayoutMesh)
+    register_layout_algorithm('Horizontal Tree', LayoutHorizontalTree)
+    register_layout_algorithm('Vertical Tree', LayoutVerticalTree)
+
+  end
+
+end

data/lib/wx/shapes/base.rb

@@ -0,0 +1,33 @@
+# Wx::SF base definitions
+# Copyright (c) M.J.N. Corino, The Netherlands
+
+module Wx::SF
+
+  class SFException < ::Exception; end
+
+  RECURSIVE = true
+  NORECURSIVE = false
+  DIRECT = true
+  INDIRECT = false
+  WITHCHILDREN = true
+  WITHOUTCHILDREN = false
+  ANY = nil
+  DELAYED = true
+  ACCEPT_ALL = :*
+
+  INCLUDE_PARENTS = true
+  WITHOUT_PARENTS = false
+  INITIALIZE = true
+  DONT_INITIALIZE = false
+
+  DEFAULT_ME_OFFSET = 5
+  SAVE_STATE = true
+  DONT_SAVE_STATE = false
+  FROM_PAINT = true
+  NOT_FROM_PAINT = false
+  PROMPT = true
+  NO_PROMPT = false
+  WITH_BACKGROUND = true
+  WITHOUT_BACKGROUND = false
+
+end

data/lib/wx/shapes/canvas_history.rb

@@ -0,0 +1,84 @@
+# Wx::SF::CanvasHistory - canvas history class
+# Copyright (c) M.J.N. Corino, The Netherlands
+
+module Wx::SF
+
+  class CanvasHistory
+
+    module DEFAULT
+      MAX_CANVAS_STATES = 25
+    end
+
+    # Constructor.
+    def initialize
+      @canvas_states = []
+      @current_state = nil
+      @current_state_index = nil
+      @max_states = DEFAULT::MAX_CANVAS_STATES
+    end
+
+    attr_accessor :max_states
+
+    # Save current canvas state.
+    # @param [String] state serialized diagram state
+    def save_canvas_state(state)
+      # delete all states newer than the current state
+      if @current_state
+        @canvas_states.slice!(@current_state_index+1, @canvas_states.size)
+      end
+
+      # append new canvas state
+      @current_state_index = @canvas_states.size
+      @canvas_states << (@current_state = state)
+
+      # check the history bounds
+      if @canvas_states.size > @max_states
+        @canvas_states.shift
+        @current_state_index -= 1
+      end
+    end
+
+    # Perform the 'Undo' operation.
+    # @return [String] state to undo
+    def restore_older_state
+      return nil unless @current_state && @current_state_index>0
+
+      # move to previous canvas state and restore
+      @current_state_index -= 1
+      @current_state = @canvas_states[@current_state_index]
+    end
+
+    # Perform the 'Redo' operation. 
+    # @return [String] state to redo
+    def restore_newer_state
+      return nil unless @current_state && @current_state_index<(@canvas_states.size-1)
+
+      # move to next canvas state and restore
+      @current_state_index += 1
+      @current_state = @canvas_states[@current_state_index]
+    end
+
+    # Clear all canvas history. 
+    def clear
+      @canvas_states.clear
+      @current_state = nil
+      @current_state_index = nil
+    end
+
+    # The function gives information whether the 'Undo' operation is available
+    # (exists any stored canvas state older than the current one.
+    # @return [Boolean] true if the 'undo' operation can be performed, otherwise false
+    def can_undo
+      @current_state && @current_state_index>0
+    end
+
+    # The function gives information whether the 'redo' operation is available
+    # (exists any stored canvas state newer than the current one.
+    # @return true if the 'redo' operation can be performed, otherwise false
+    def can_redo
+      @current_state && @current_state_index < (@canvas_states.size - 1)
+    end
+
+  end
+
+end

data/lib/wx/shapes/connection_point.rb

@@ -0,0 +1,238 @@
+# Wx::SF::ConnectionPoint - shape connection point class
+# Copyright (c) M.J.N. Corino, The Netherlands
+
+require 'wx/shapes/serializable'
+
+module Wx::SF
+
+  class ConnectionPoint
+
+    include Wx::SF::Serializable
+
+    property :type
+    property :ortho_direction
+    property :relative_position
+
+    RADIUS = 3
+
+    # Connection point type
+    class CPTYPE < Wx::Enum
+      UNDEF = self.new(0)
+      TOPLEFT = self.new(1)
+      TOPMIDDLE = self.new(2)
+      TOPRIGHT = self.new(3)
+      CENTERLEFT = self.new(4)
+      CENTERMIDDLE = self.new(5)
+      CENTERRIGHT = self.new(6)
+      BOTTOMLEFT = self.new(7)
+      BOTTOMMIDDLE = self.new(8)
+      BOTTOMRIGHT = self.new(9)
+      CUSTOM = self.new(10)
+    end
+
+    # Direction of orthogonal connection
+    class CPORTHODIR < Wx::Enum
+      UNDEF = self.new(1)
+      HORIZONTAL = self.new(2)
+      VERTICAL = self.new(3)
+    end
+    
+    module DEFAULT
+      # Default value of Wx::SF::ConnectionPoint @rel_position data member
+      RELPOS = Wx::RealPoint.new(0, 0)
+      # Default value of Wx::SF::ConnectionPoint @ortho_dir data member
+      ORTHODIR = CPORTHODIR::UNDEF
+    end
+
+    # Constructor
+    # @overload initialize()
+    #   default ctor for deserialize
+    # @overload initialize(parent, pos, id=nil)
+    #   @param [Wx::SF::Shape] parent parent shape
+    #   @param [Wx::RealPoint,Array(Float, Float)] pos relative position in percentages
+    #   @param [Integer] id point id
+    # @overload initialize(parent, type)
+    #   @param [Wx::SF::Shape] parent parent shape
+    #   @param [Wx::SF::ConnectionPoint::CPTYPE] type connection point type
+    def initialize(*args)
+      @parent_shape, type_or_pos, id = *args
+      if type_or_pos # allow parent to be nil (mainly for testing purposes)
+        if CPTYPE === type_or_pos
+          @type = type_or_pos
+          @rel_position = DEFAULT::RELPOS
+          @id = nil
+        elsif Wx::RealPoint === type_or_pos || Array === type_or_pos
+          @type = CPTYPE::CUSTOM
+          @rel_position = Wx::RealPoint === type_or_pos ? type_or_pos : Wx::RealPoint.new(*type_or_pos)
+          @id = id
+        else
+          ::Kernel.raise ArgumentError, 'Invalid arguments'
+        end
+        @ortho_dir = DEFAULT::ORTHODIR
+        @mouse_over = false
+      end
+    end
+
+    #  Get connection point type.
+	  # @return [CPTYPE] Connection point type
+    def get_type
+      @type
+    end
+    alias :type :get_type
+
+    #  Set direction of orthogonal line's connection.
+	  # @param [CPORTHODIR] dir Required direction
+	  # @see CPORTHODIR
+    def set_ortho_direction(dir)
+      @ortho_dir = dir
+    end
+    alias :ortho_direction= :set_ortho_direction
+
+    #  Get direction of orthogonal line's connection.
+	  # @return [CPORTHODIR] Current direction
+	  # @see CPORTHODIR
+    def get_ortho_direction
+      @ortho_dir
+    end
+    alias :ortho_direction :get_ortho_direction
+
+    # Set parent shape.
+	  # @param [Wx::SF::Shape] parent parent shape
+    def set_parent_shape(parent)
+      @parent_shape = parent
+    end
+    alias :parent_shape= :set_parent_shape
+
+    # Get parent shape.
+	  # @return [Wx::SF::Shape] parent shape
+    def get_parent_shape
+      @parent_shape
+    end
+    alias :parent_shape :get_parent_shape
+
+    #  Set relative position of custom connection point.
+    #  @param [Wx::RealPoint,Array(Float, Float)] pos Relative position in percentages
+    def set_relative_position(pos)
+      @rel_position = Wx::RealPoint === pos ? pos : Wx::RealPoint.new(*pos)
+    end
+    alias :relative_position= :set_relative_position
+
+    # Get relative position of custom connection point.
+	  # @return [Wx::RealPoint] Relative position in percentages
+    def get_relative_position
+      @rel_position
+    end
+    alias :relative_position :get_relative_position
+
+    # Get absolute position of the connection point.
+	  # @return [Wx::RealPoint] Absolute position of the connection point
+    def get_connection_point
+      if @parent_shape
+        rctParent = @parent_shape.get_bounding_box
+
+        case @type 
+        when CPTYPE::TOPLEFT
+          return rctParent.top_left.to_real
+
+        when CPTYPE::TOPMIDDLE
+          return Wx::RealPoint.new((rctParent.left + rctParent.width/2).to_f, rctParent.top.to_f)
+
+        when CPTYPE::TOPRIGHT
+          return rctParent.top_right.to_real
+
+        when CPTYPE::CENTERLEFT
+          return Wx::RealPoint.new(rctParent.left.to_f, (rctParent.top + rctParent.height/2).to_f)
+
+        when CPTYPE::CENTERMIDDLE
+          return Wx::RealPoint.new((rctParent.left + rctParent.width/2).to_f, (rctParent.top + rctParent.height/2).to_f)
+
+        when CPTYPE::CENTERRIGHT
+          return Wx::RealPoint.new(rctParent.right.to_f, (rctParent.top + rctParent.height/2).to_f)
+
+        when CPTYPE::BOTTOMLEFT
+          return rctParent.bottom_left.to_real
+
+        when CPTYPE::BOTTOMMIDDLE
+          return Wx::RealPoint.new((rctParent.left + rctParent.width/2).to_f, rctParent.bottom.to_f)
+
+        when CPTYPE::BOTTOMRIGHT
+          return rctParent.bottom_right.to_real
+
+        when CPTYPE::CUSTOM
+          return Wx::RealPoint.new(rctParent.left + rctParent.width * @rel_position.x/100, rctParent.top + rctParent.height * @rel_position.y/100)
+        end
+      end
+      Wx::RealPoint.new
+    end
+    alias :connection_point :get_connection_point
+
+    #  Find out whether given point is inside the connection point.
+	  # @param [Wx::Point] pos Examined point
+	  # @return [Boolean] true if the point is inside the handle, otherwise false
+    def contains(pos)
+      # HINT: overload it for custom actions...
+      connection_point.distance_to(pos.to_real_point) < (3 * RADIUS)
+    end
+    alias :contains? :contains
+
+    #  Draw connection point.
+	  # @param [Wx::DC] dc Device context where the handle will be drawn
+    def draw(dc)
+      if @mouse_over
+        draw_hover(dc)
+      else
+        draw_normal(dc)
+      end
+    end
+
+    # Refresh (repaint) the dock point
+    def refresh
+      @parent_shape.refresh(DELAYED)
+    end
+
+    protected
+
+    #  Draw the connection point in the normal way. The function can be overridden if necessary.
+	  # @param [Wx::DC] dc Reference to device context where the shape will be drawn to
+    def draw_normal(dc)
+      # HINT: overload it for custom actions...
+    end
+
+    #  Draw the connection point in the hover mode (the mouse cursor is above the shape).
+    # The function can be overridden if necessary.
+	  # @param [Wx::DC] dc Reference to device context where the shape will be drawn to
+    def draw_hover(dc)
+      # HINT: overload it for custom actions...
+      dc.with_pen(Wx::BLACK_PEN) do
+        dc.with_brush(Wx::RED_BRUSH) do
+          dc.draw_circle(connection_point.to_point, RADIUS)
+        end
+      end
+    end
+
+    private
+
+    # For deserialization
+    def set_type(type)
+      @type = type
+    end
+
+    #  Event handler called when the mouse pointer is moving above shape canvas.
+    # @param [Wx::Point] pos Current mouse position
+    def _on_mouse_move(pos)
+      if contains?(pos)
+        unless @mouse_over
+          @mouse_over = true
+          refresh
+        end
+      else
+        if @mouse_over
+          @mouse_over = false
+          refresh
+        end
+      end
+    end
+    
+  end
+
+end