wxruby3-shapes 0.9.0.pre.beta.3

data/lib/wx/shapes/shapes/control_shape.rb

@@ -0,0 +1,483 @@
+# Wx::SF::ControlShape - control shape class
+# Copyright (c) M.J.N. Corino, The Netherlands
+
+require 'wx/shapes/shapes/rect_shape'
+
+module Wx::SF
+
+  FIT_SHAPE_TO_CONTROL = true
+  FIT_CONTROL_TO_SHAPE = false
+
+  # Class encapsulates a special shape able to manage assigned GUI controls (widgets). The GUI control's
+  # position and size can by modified via parent control shape. User can also specify how events incoming from the
+  # managed GUI control are processed.
+  #
+  # Note that the managed controls use a shape canvas as their parent window so these shapes cannot be used
+  # without existing and properly initialized shape canvas. Moreover, managed GUI controls are not serialized in any
+  # way internally so it is completely up to the user to provide this functionality if needed.
+  class ControlShape < RectShape
+
+    # Auxiliary class used by Wx::SF::ControlShape. All events generated by a GUI control (widget)
+    # managed by parent control shape are redirected to this event sink which invokes a default event handler
+    # or send a copy of the event to shape canvas if requested.
+    class EventSink < Wx::EvtHandler
+
+      # @overload initialize()
+      #   Default constructor.
+      # @overload initialize(parent)
+      #   User constructor.
+      #   @param [ControlShape] parent parent control shape
+      def initialize(parent = nil)
+        @parent_shape = parent
+      end
+      
+      # Event handler used for delayed processing of a mouse button events.
+      # The handler creates new key event instance and sends it to a shape canvas for further processing.
+	    # @param [Wx::MouseEvent] event Mouse event
+      def _on_mouse_button(event)
+        if (@parent_shape.get_event_processing & EVTPROCESSING::MOUSE2CANVAS) != 0
+            updated_event = event.clone
+
+            update_mouse_event(updated_event)
+            send_event(updated_event)
+        end
+
+        # process the event also by an original handler if requested
+        event.skip if (@parent_shape.get_event_processing & EVTPROCESSING::MOUSE2GUI) != 0
+      end
+
+      # Event handler used for delayed processing of a mouse event (mouse movement).
+      # The handler creates new key event instance and sends it to a shape canvas for further processing.
+      # @param [Wx::MouseEvent] event Mouse event
+      def _on_mouse_move(event)
+        if (@parent_shape.get_event_processing & EVTPROCESSING::MOUSE2CANVAS) != 0
+          updated_event = event.clone
+
+          update_mouse_event(updated_event)
+          send_event(updated_event)
+        end
+
+        # process the event also by an original handler if requested
+        event.skip if (@parent_shape.get_event_processing & EVTPROCESSING::MOUSE2GUI) != 0
+      end
+
+      # Event handler used for delayed processing of a key event.
+      # The handler creates new key event instance and sends it to a shape canvas for further processing.
+	    # @param [Wx::KeyEvent] event Keyboard event
+      def _on_key_down(event)
+        send_event(event) if (@parent_shape.get_event_processing & EVTPROCESSING::KEY2CANVAS) !=0
+
+        # process the event also by an original handler if requested
+        event.skip if (@parent_shape.get_event_processing & EVTPROCESSING::KEY2GUI) != 0
+      end
+
+      # Event handler used for adjusting the parent shape's size in accordance to size of managed GUI control.
+      # @param [Wx::SizeEvent] event Size event
+      def _on_size(event)
+        event.skip
+
+        @parent_shape.update_shape
+      end
+
+      protected
+
+      # Send copy of incoming event to a shape canvas.
+      # @param [Wx::Event] event Event to be send
+      def send_event(event)
+        if @parent_shape && @parent_shape.get_diagram
+            canvas = @parent_shape.get_diagram.get_shape_canvas
+            # send copy of the event to the shape canvas
+            Wx.post_event(canvas, event) if canvas
+        end
+      end
+
+      # Modify given mouse event (recalculate the event's position in accordance to parent control
+      # shape's position.
+      # @param [Wx::MouseEvent] event Mouse event to be updated
+      def update_mouse_event(event)
+        abs_pos = @parent_shape.get_absolute_position
+
+        x, y = @parent_shape.get_parent_canvas.calc_unscrolled_position(0, 0)
+
+        event.x += (abs_pos.x.to_i + @parent_shape.get_control_offset - x)
+        event.y += (abs_pos.y.to_i + @parent_shape.get_control_offset - y)
+      end
+
+    end
+
+    # Way of processing of GUI control's events.
+    class EVTPROCESSING < Wx::Enum
+        # Event isn't processed.
+        NONE = self.new(0)
+        # Keyboard events are processed by the GUI control.
+        KEY2GUI = self.new(1)
+        # Keyboard events are send to a shape canvas. 
+        KEY2CANVAS = self.new(2)
+        # Mouse events are processed by the GUI control. 
+        MOUSE2GUI = self.new(4)
+        # Mouse events are send to a shape canvas. 
+        MOUSE2CANVAS = self.new(8)
+    end
+
+    # Defaults
+    module DEFAULT
+      CONTROLOFFSET = 0
+      PROCESSEVENTS = EVTPROCESSING::KEY2CANVAS | EVTPROCESSING::MOUSE2CANVAS
+      MODFILL = Wx::Brush.new(Wx::BLUE, Wx::BrushStyle::BRUSHSTYLE_BDIAGONAL_HATCH) if Wx::App.is_main_loop_running
+      Wx.add_delayed_constant(self, :MODFILL) { Wx::Brush.new(Wx::BLUE, Wx::BrushStyle::BRUSHSTYLE_BDIAGONAL_HATCH) }
+      MODBORDER = Wx::Pen.new(Wx::BLUE, 1, Wx::PenStyle::PENSTYLE_SOLID) if Wx::App.is_main_loop_running
+      Wx.add_delayed_constant(self, :MODBORDER) { Wx::Pen.new(Wx::BLUE, 1, Wx::PenStyle::PENSTYLE_SOLID) }
+    end
+
+    property :event_processing, :control_offset, :mod_fill, :mod_border
+
+    # @overload initialize()
+    #   Default constructor.
+    # @overload initialize(pos, size, diagram)
+    #   User constructor.
+    #   @param [Wx::Window] ctrl managed GUI control
+    #   @param [Wx::RealPoint] pos Initial position
+    #   @param [Wx::RealPoint] size Initial size
+    #   @param [Wx::SF::Diagram] diagram parent diagram
+    def initialize(*args)
+      if args.empty?
+        super
+        @control = nil
+      else
+        ctrl = args.shift
+        super(*args)
+        set_control(ctrl)
+      end
+      add_style(Shape::STYLE::PROCESS_DEL)
+      @process_events = DEFAULT::PROCESSEVENTS
+      @mod_fill = DEFAULT::MODFILL
+      @mod_border = DEFAULT::MODBORDER
+      @control_offset = DEFAULT::CONTROLOFFSET
+
+      @event_sink = EventSink.new(self)
+
+      @prev_parent = nil
+      @prev_style = 0
+      @prev_fill = nil
+      @prev_border = nil
+
+      @fill = Wx::TRANSPARENT_BRUSH
+      @border = Wx::TRANSPARENT_PEN
+    end
+
+    # Set managed GUI control.
+    # @param [Wx::Window] ctrl existing manager GUI control
+    # @param [Boolean] fit true if the control shape should be resized in accordance to the given GUI control
+    def set_control(ctrl, fit = FIT_SHAPE_TO_CONTROL)
+      if @control
+        @control.disconnect(Wx::ID_ANY, Wx::ID_ANY, Wx::EVT_LEFT_DOWN)
+        @control.disconnect(Wx::ID_ANY, Wx::ID_ANY, Wx::EVT_RIGHT_DOWN)
+        @control.disconnect(Wx::ID_ANY, Wx::ID_ANY, Wx::EVT_LEFT_UP)
+        @control.disconnect(Wx::ID_ANY, Wx::ID_ANY, Wx::EVT_RIGHT_UP)
+        @control.disconnect(Wx::ID_ANY, Wx::ID_ANY, Wx::EVT_LEFT_DCLICK)
+        @control.disconnect(Wx::ID_ANY, Wx::ID_ANY, Wx::EVT_RIGHT_DCLICK)
+        @control.disconnect(Wx::ID_ANY, Wx::ID_ANY, Wx::EVT_MOTION)
+        @control.disconnect(Wx::ID_ANY, Wx::ID_ANY, Wx::EVT_KEY_DOWN)
+        @control.disconnect(Wx::ID_ANY, Wx::ID_ANY, Wx::EVT_SIZE)
+        @control.hide
+        @control.reparent(@prev_parent)
+      end
+
+      @control = ctrl
+  
+      if @control
+        @prev_parent = ctrl.get_parent
+        if @diagram
+          canvas = @diagram.get_shape_canvas
+
+          # reparent GUI control if necessary
+          @control.reparent(canvas) if canvas && canvas != @prev_parent
+
+          # redirect mouse events to the event sink for their delayed processing
+          @control.evt_left_down { |evt| @event_sink._on_mouse_button(evt) }
+          @control.evt_right_down { |evt| @event_sink._on_mouse_button(evt) }
+          @control.evt_left_up { |evt| @event_sink._on_mouse_button(evt) }
+          @control.evt_right_up { |evt| @event_sink._on_mouse_button(evt) }
+          @control.evt_left_dclick { |evt| @event_sink._on_mouse_button(evt) }
+          @control.evt_right_dclick { |evt| @event_sink._on_mouse_button(evt) }
+          @control.evt_motion { |evt| @event_sink._on_mouse_move(evt) }
+          @control.evt_key_down { |evt| @event_sink._on_key_down(evt) }
+          @control.evt_size { |evt| @event_sink._on_size(evt) }
+        end
+
+        update_shape if fit
+
+        update_control
+      end
+    end
+
+    # Get managed GUI control.
+    # @return [Wx::Window] the GUI control
+    def get_control
+      @control
+    end
+
+    # Set the way how GUI control's events are processed.
+    # @param [EVTPROCESSING] mask Event processing
+    # @see EVTPROCESSING
+    def set_event_processing(mask)
+      @process_events = mask
+    end
+
+    # Get the way how GUI control's events are processed.
+    # @return [EVTPROCESSING] Combination of EVTPROCESSING flags
+    # @see EVTPROCESSING
+    def get_event_processing
+      @process_events
+    end
+
+    # Set control shape's background style used during its modification.
+    # @param [Wx::Brush] brush Reference to used brush
+    def set_mod_fill(brush)
+      @mod_fill = brush
+    end
+
+    # Get control shape's background style used during its modification.
+    # @return [Wx::Brush] Used brush
+    def get_mod_fill
+      @mod_fill
+    end
+
+    # Set control shape's border style used during its modification.
+    # @param [Wx::Pen] pen Reference to used pen
+    def set_mod_border(pen)
+      @mod_border = pen
+    end
+
+    # Get control shape's border style used during its modification.
+    # @return [Wx::Pen] Used pen
+    def get_mod_border
+      @mod_border
+    end
+
+    # Set control shape's offset (a gap between the shape's border and managed GUI control).
+    # @param [Integer] offset Offset size
+    def set_control_offset(offset)
+      @control_offset = offset
+    end
+
+    # Get control shape's offset (a gap between the shape's border and managed GUI control).
+    # @return [Integer] Offset size
+    def get_control_offset
+      @control_offset
+    end
+
+    # Update size and position of the managed control according to the parent shape.
+    def update_control
+      if @control
+        min_bb = @control.get_min_size
+        rct_bb = get_bounding_box.deflate!(@control_offset, @control_offset)
+
+        if rct_bb.width < min_bb.width
+          rct_bb.width = min_bb.width
+          @rect_size.x = min_bb.width + 2*@control_offset
+        end
+        if rct_bb.height < min_bb.height
+          rct_bb.height = min_bb.height
+          @rect_size.y = min_bb.height + 2*@control_offset
+        end
+
+        x, y = get_parent_canvas.calc_unscrolled_position(0, 0)
+
+        # set the control's dimensions and position according to the parent control shape
+        @control.set_size([rct_bb.width, rct_bb.height])
+        @control.move(rct_bb.left - x, rct_bb.top - y)
+      end
+    end
+
+    # Update size of the shape position according to the managed control.
+    def update_shape
+      if @control
+        ctrl_size = @control.size
+
+        @rect_size.x = ctrl_size.x + 2*@control_offset
+        @rect_size.y = ctrl_size.y + 2*@control_offset
+
+        get_parent_canvas.refresh(false)
+      end
+    end
+
+    # Set parent shape object
+    # @param [Wx::SF::Shape] parent
+    def set_parent_shape(parent)
+      super
+      update
+    end
+    alias :parent_shape= :set_parent_shape
+
+	  # Scale the shape size by in both directions. The function can be overridden if necessary
+    # (new implementation should call default one ore scale shape's children manually if necessary).
+    # @param [Float] x Horizontal scale factor
+    # @param [Float] y Vertical scale factor
+    # @param children true if the shape's children should be scaled as well, otherwise the shape will be updated after scaling via update() function.
+    def scale(x, y, children = WITHCHILDREN)
+      super
+      update_control
+    end
+
+	  # Move the shape to the given absolute position. The function can be overridden if necessary.
+	  # @param [Float] x X coordinate
+	  # @param [Float] y Y coordinate
+    def move_to(x, y)
+      super
+      update_control
+    end
+    
+	  # Move the shape by the given offset. The function can be overridden if necessary.
+	  # @param [Float] x X offset
+	  # @param [Float] y Y offset
+    def move_by(x, y)
+      super
+      update_control
+    end
+	
+	  # Update shape (align all child shapes an resize it to fit them)
+    def update
+      super
+      update_control
+    end
+
+    # Resize the shape to bound all child shapes. The function can be overridden if necessary.
+    def fit_to_children
+      bb_rct = get_bounding_box
+
+      ctrl_rct = if @control
+                   Wx::Rect.new(@control.position, @control.size)
+                 else
+                   bb_rct
+                 end
+
+      super
+
+      update_shape if bb_rct.intersects(ctrl_rct) && !bb_rct.contains(ctrl_rct)
+    end
+
+	  # Event handler called at the beginning of the shape dragging process.
+	  # The function can be overridden if necessary.
+	  #
+	  # The function is called by the framework (by the shape canvas).
+    # @param [Wx::Point] pos Current mouse position
+	  # @see ShapeCanvas
+    def on_begin_drag(pos)
+      @prev_fill = @fill
+      @fill = @mod_fill
+      canvas = get_parent_canvas
+      if canvas
+        @prev_style = canvas.get_style
+        canvas.remove_style(ShapeCanvas::STYLE::DND)
+      end
+      if @control
+        @control.hide
+        @control.disconnect(Wx::ID_ANY, Wx::ID_ANY, Wx::EVT_SIZE)
+      end
+
+      super
+    end
+
+	  # Event handler called at the end of the shape dragging process.
+	  # The function can be overridden if necessary.
+	  #
+	  # The function is called by the framework (by the shape canvas).
+	  # @param [Wx::Point] pos Current mouse position
+	  # @see ShapeCanvas
+    def on_end_drag(pos)
+      @fill = @prev_fill
+      canvas = get_parent_canvas
+      canvas.set_style(@prev_style) if canvas
+      update_control
+      if @control
+        @control.evt_size { |evt| @event_sink._on_size(evt) }
+        @control.show
+        @control.set_focus
+      end
+
+      super
+    end
+
+	  # Event handler called when the user started to drag the shape handle.
+	  # The function can be overridden if necessary.
+	  #
+	  # The function is called by the framework (by the shape canvas).
+	  # @param [Shape::Handle] handle Reference to dragged handle
+    def on_begin_handle(handle)
+      @prev_border = @border
+      @border = @mod_border
+      @prev_fill = @fill
+      @fill = @mod_fill
+  
+      if @control
+        @control.hide
+        @control.disconnect(Wx::ID_ANY, Wx::ID_ANY, Wx::EVT_SIZE)
+      end
+    
+      # call default handler
+      super
+    end
+
+	  # Event handler called during dragging of the shape handle.
+	  # The function can be overridden if necessary.
+	  #
+	  # The function is called by the framework (by the shape canvas).
+    # @param [Shape::Handle] handle Reference to dragged handle
+    def on_handle(handle)
+      super
+      update_control
+    end
+
+	  # Event handler called when the user finished dragging of the shape handle.
+	  # The function can be overridden if necessary.
+	  #
+	  # The function is called by the framework (by the shape canvas).
+    # @param [Shape::Handle] handle Reference to dragged handle
+    def on_end_handle(handle)
+      @border = @prev_border
+      @fill = @prev_fill
+  
+      if @control
+        @control.show
+        @control.set_focus
+        @control.evt_size { |evt| @event_sink._on_size(evt) }
+      end
+    
+      # call default handler
+      super
+    end
+
+    protected
+
+    # Event handler called by ShapeCanvas to request,report canvas changes.
+    # @param [ShapeCanvas::CHANGE] change change type indicator
+    # @param [Array] args any additional arguments
+    # @return [Boolean,nil]
+    def _on_canvas(change, *args)
+      case change
+      when ShapeCanvas::CHANGE::SET_SCALE
+        msg = args.shift
+        msg << 'rescaling control (GUI) shapes not supported'
+        return false
+      when ShapeCanvas::CHANGE::VIRTUAL_SIZE
+        self.update
+      end
+      super
+    end
+
+    private
+
+    def _on_key(key)
+      super
+      if key == Wx::K_DELETE
+        set_control(nil)
+        if @diagram
+          @diagram.remove_shape(self, false)
+        end
+      end
+    end
+
+  end
+
+end

data/lib/wx/shapes/shapes/curve_shape.rb

@@ -0,0 +1,231 @@
+# Wx::SF::CurveShape - curved line shape class
+# Copyright (c) M.J.N. Corino, The Netherlands
+
+require 'wx/shapes/shapes/line_shape'
+
+module Wx::SF
+
+  # Interpolation line shape. The class extends LineShape class and allows
+  # user to create curved connection line.
+  class CurveShape < LineShape
+
+    # @overload initialize()
+    #   default constructor
+    # @overload initialize(src, trg, path, manager)
+    #   @param [Wx::SF::Serializable::ID] src ID of the source shape
+    #   @param [Wx::SF::Serializable::ID] trg ID of the target shape
+    #   @param [Array<Wx::RealPoint>] path List of the line control points (can be empty)
+    #   @param [Diagram] diagram containing diagram
+    # @overload initialize(src, trg, path, manager)
+    #   @param [Wx::RealPoint] src starting line point
+    #   @param [Wx::RealPoint] trg end line point
+    #   @param [Array<Wx::RealPoint>,nil] path List of the line control points (can be empty or nil)
+    #   @param [Diagram] diagram containing diagram
+    def initialize(*args)
+      super
+    end
+
+    # Get line's bounding box. The function can be overridden if necessary.
+    # @return [Wx::Rect] Bounding rectangle
+    def get_bounding_box
+      super.inflate(20, 20)
+    end
+
+    # Get a line point laying on the given line segment and shifted
+    # from the beginning of the segment by given offset.
+    # @param [Integer] segment Zero-based index of the line segment
+    # @param [Float] offset Real value in the range from 0 to 1 which determines
+    # the line-point offset inside the line segment
+    # @return [Wx::RealPoint] Line point
+    def get_point(segment, offset)
+      if segment <= @lst_points.size
+        a,b,c,d = get_segment_quaternion(segment)
+        coord_catmul_rom_kubika(a, b, c, d, offset)
+      else
+        Wx::RealPoint.new
+      end
+    end
+
+    protected
+
+    # Internal function used for drawing of completed line shape.
+    # @param [Wx::DC] dc Reference of the device context where the shape will be drawn to
+    def draw_complete_line(dc)
+      case @mode
+      when LINEMODE::READY
+        # draw line segments
+        b = c = nil
+        if !@lst_points.empty?
+          (0..@lst_points.size).each do |i|
+            a,b,c,d = get_segment_quaternion(i)
+            catmul_rom_kubika(a, b, c, d, dc)
+          end
+        else
+          b,c = get_direct_line
+          dc.draw_line(b.to_point, c.to_point)
+        end
+        # draw target arrow
+        @trg_arrow.draw(b, c, dc) if @trg_arrow
+        b, c = get_line_segment(0)
+        # draw source arrow
+        @src_arrow.draw(c, b, dc) if @src_arrow
+
+      when LINEMODE::UNDERCONSTRUCTION
+        # draw basic line parts
+        c = nil
+        unless @lst_points.empty?
+          @lst_points.size.times do |i|
+            a,b,c,d = get_segment_quaternion(i)
+            catmul_rom_kubika(a, b, c, d, dc)
+          end
+        end
+        # draw unfinished line segment if any (for interactive line creation)
+        dc.with_pen(Wx::Pen.new(Wx::BLACK, 1, Wx::PenStyle::PENSTYLE_DOT)) do
+          if @lst_points.size > 1
+            dc.draw_line(c.to_point, @unfinished_point)
+          elsif @src_shape_id
+            # draw unfinished line segment if any (for interactive line creation)
+            dc.with_pen(Wx::Pen.new(Wx::BLACK, 1, Wx::PenStyle::PENSTYLE_DOT)) do
+              src_shape = @diagram.find_shape(@src_shape_id)
+              if src_shape
+                if src_shape.get_connection_points.empty?
+                  dc.draw_line((src_shape.get_border_point(src_shape.get_center, @unfinished_point.to_real)).to_point,
+                               @unfinished_point)
+                else
+                  dc.draw_line(get_mod_src_point.to_point, @unfinished_point)
+                end
+              end
+            end
+          end
+        end
+
+      when LINEMODE::SRCCHANGE
+        # draw basic line parts
+        c = nil
+        @lst_points.size.times do |i|
+          a,b,c,d = get_segment_quaternion(i+1)
+          catmul_rom_kubika(a, b, c, d, dc)
+        end
+        # draw linesegment being updated
+        dc.with_pen(Wx::Pen.new(Wx::BLACK, 1, Wx::PenStyle::PENSTYLE_DOT)) do
+          if !@lst_points.empty?
+            _,_,c,_ = get_segment_quaternion(0)
+          else
+            _,c = get_direct_line
+          end
+          dc.draw_line(@unfinished_point, c.to_point)
+        end
+
+      when LINEMODE::TRGCHANGE
+        # draw basic line parts
+        c = nil
+        if !@lst_points.empty?
+          @lst_points.size.times do |i|
+            a,b,c,d = get_segment_quaternion(i)
+            catmul_rom_kubika(a, b, c, d, dc)
+          end
+        else
+          c = get_src_point
+        end
+        # draw linesegment being updated
+        dc.with_pen(Wx::Pen.new(Wx::BLACK, 1, Wx::PenStyle::PENSTYLE_DOT)) do
+          dc.draw_line(@unfinished_point, c.to_point)
+        end
+      end
+    end
+
+    private
+
+	  # Auxiliary drawing function.
+    # @param [Integer] segment
+    # @return [Array(Wx::RealPoint,Wx::RealPoint,Wx::RealPoint,Wx::RealPoint)]
+    def get_segment_quaternion(segment)
+      quart = [nil,nil,nil,nil]
+      # wxXS::RealPointList::compatibility_iterator node
+      index = 2 - segment
+
+      quart[index - 1] = get_src_point if (index - 1) >= 0
+      quart[index - 2] = get_mod_src_point if (index - 2) >= 0
+      
+      if index >= 0
+        pt = @lst_points.at(ix_pt = 0)
+      else
+        pt = @lst_points.at(ix_pt = index.abs)
+        index = 0
+      end
+         
+      while index < 4
+        if pt
+          quart[index] = pt
+          ix_pt += 1
+          pt = @lst_points.at(ix_pt)
+        else
+          if index == 2
+            quart[2] = get_trg_point
+          elsif index == 3
+            if @mode == LINEMODE::UNDERCONSTRUCTION
+              quart[3] = @unfinished_point.to_real
+            elsif @trg_shape_id
+              quart[3] = get_mod_trg_point
+            end
+          end
+        end
+        index += 1
+      end
+
+      quart
+    end
+
+	  # Auxiliary drawing function.
+    # @param [Wx::RealPoint] a
+    # @param [Wx::RealPoint] b
+    # @param [Wx::RealPoint] c
+    # @param [Wx::RealPoint] d
+    # @param [Wx::DC] dc
+    def catmul_rom_kubika(a, b, c, d, dc)
+      # the beginning of the curve is in the B point
+      point0 = b
+
+      optim_steps = b.distance_to(c).to_f / 10
+      optim_steps = 10 if optim_steps < 10
+    
+      # draw the curve
+      t = 0.0
+      while t <= (1 + (1.0 / optim_steps))
+        point1 = coord_catmul_rom_kubika(a,b,c,d,t)
+        dc.draw_line(point0.x.to_i, point0.y.to_i, point1.x.to_i, point1.y.to_i)
+        point0 = point1
+        t += 1.0 / (optim_steps-1)
+      end
+      point1 = coord_catmul_rom_kubika(a,b,c,d,1)
+      dc.draw_line(point0.x.to_i, point0.y.to_i, point1.x.to_i, point1.y.to_i)
+    end
+
+    # Auxiliary drawing function.
+    # @param [Wx::RealPoint] p1
+    # @param [Wx::RealPoint] p2
+    # @param [Wx::RealPoint] p3
+    # @param [Wx::RealPoint] p4
+    # @param [Float] t
+    # @return [Wx::RealPoint]
+    def coord_catmul_rom_kubika(p1, p2, p3, p4, t)
+      # auxiliary variables
+      pom1 = t - 1
+      pom2 = t * t
+
+      # used polynomials
+      c1 = (-pom2*t + 2*pom2 - t)  / 2
+      c2 = (3*pom2*t - 5*pom2 + 2) / 2
+      c3 = (-3*pom2*t + 4*pom2 + t) / 2
+      c4 = pom1*pom2 / 2
+
+      # calculation of curve point for t = <0,1>
+      x = c1*p1.x + c2*p2.x + c3*p3.x + c4*p4.x
+      y = c1*p1.y + c2*p2.y + c3*p3.y + c4*p4.y
+
+      Wx::RealPoint.new(x,y)
+    end
+    
+  end
+
+end