vedeu 0.6.4 → 0.6.5

data/lib/vedeu/buffers/repository.rb

@@ -0,0 +1,24 @@
+module Vedeu
+
+  module Buffers
+
+    # Allows the storing of view buffers.
+    #
+    class Repository < Vedeu::Repository
+
+      singleton_class.send(:alias_method, :buffers, :repository)
+
+      null Vedeu::Buffers::Null
+      real Vedeu::Buffers::Buffer
+
+    end # Buffers
+
+    class Buffer
+
+      repo Vedeu::Buffers::Repository.repository
+
+    end # Buffer
+
+  end # Buffers
+
+end # Vedeu

data/lib/vedeu/buffers/virtual_buffer.rb

@@ -55,7 +55,7 @@ module Vedeu
     # @param x [Fixnum] The column/character coordinate.
     # @return [Vedeu::Views::Char]
     def read(y, x)
-      cy, cx = Vedeu::Position[y, x].as_indices
+      cy, cx = Vedeu::Geometry::Position[y, x].as_indices
 
       row  = fetch(cells, cy)
       cell = fetch(row, cx)
@@ -103,7 +103,7 @@ module Vedeu
     def write(y, x, data)
       return false unless read(y, x).is_a?(Vedeu::Cell)
 
-      cy, cx = Vedeu::Position[y, x].as_indices
+      cy, cx = Vedeu::Geometry::Position[y, x].as_indices
       cells[cy][cx] = data
 
       true

data/lib/vedeu/cursors/all.rb

@@ -0,0 +1,11 @@
+module Vedeu
+
+  module Cursors
+
+  end # Cursors
+
+end # Vedeu
+
+require 'vedeu/cursors/cursor'
+require 'vedeu/cursors/refresh'
+require 'vedeu/cursors/repository'

data/lib/vedeu/cursors/cursor.rb

@@ -0,0 +1,276 @@
+module Vedeu
+
+  module Cursors
+
+    # Each interface has its own Cursor which maintains the position and
+    # visibility of the cursor within that interface.
+    #
+    class Cursor
+
+      include Vedeu::Model
+      include Vedeu::Toggleable
+      extend Forwardable
+
+      def_delegators :border,
+                     :bx,
+                     :bxn,
+                     :by,
+                     :byn
+
+      # @!attribute [r] attributes
+      # @return [Hash]
+      attr_reader :attributes
+
+      # @!attribute [r] name
+      # @return [String]
+      attr_reader :name
+
+      # @!attribute [w] ox
+      # @return [Fixnum]
+      attr_writer :ox
+
+      # @!attribute [w] oy
+      # @return [Fixnum]
+      attr_writer :oy
+
+      # @!attribute [r] state
+      # @return [Boolean|Symbol]
+      attr_reader :state
+
+      # @!attribute [w] x
+      # @return [Fixnum]
+      attr_writer :x
+
+      # @!attribute [w] y
+      # @return [Fixnum]
+      attr_writer :y
+
+      # Returns a new instance of Vedeu::Cursors::Cursor.
+      #
+      # @param attributes [Hash]
+      # @option attributes name [String] The name of the interface this cursor
+      #   belongs to.
+      # @option attributes ox [Fixnum] The offset x coordinate.
+      # @option attributes oy [Fixnum] The offset y coordinate.
+      # @option attributes repository [Vedeu::Repository]
+      # @option attributes visible [Boolean] The visibility of the cursor.
+      # @option attributes x [Fixnum] The terminal x coordinate for the cursor.
+      # @option attributes y [Fixnum] The terminal y coordinate for the cursor.
+      #
+      # @return [Vedeu::Cursors::Cursor]
+      def initialize(attributes = {})
+        @attributes = defaults.merge!(attributes)
+
+        @attributes.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+      end
+
+      # Moves the cursor down by one row.
+      #
+      # @return [Vedeu::Cursors::Cursor]
+      def move_down
+        @oy = @oy + 1
+
+        @attributes = attributes.merge!(x:  x,
+                                        y:  coordinate.y_position,
+                                        ox: ox,
+                                        oy: oy)
+
+        Vedeu::Cursors::Cursor.new(@attributes).store
+      end
+
+      # Moves the cursor left by one column.
+      #
+      # @return [Vedeu::Cursors::Cursor]
+      def move_left
+        @ox = @ox - 1
+
+        @attributes = attributes.merge!(x:  coordinate.x_position,
+                                        y:  y,
+                                        ox: ox,
+                                        oy: oy)
+
+        Vedeu::Cursors::Cursor.new(@attributes).store
+      end
+
+      # Moves the cursor to the top left of the named interface.
+      #
+      # @return [Vedeu::Cursors::Cursor]
+      def move_origin
+        @attributes = attributes.merge!(x: bx, y: by, ox: 0, oy: 0)
+
+        Vedeu::Cursors::Cursor.new(@attributes).store
+      end
+
+      # Moves the cursor right by one column.
+      #
+      # @return [Vedeu::Cursors::Cursor]
+      def move_right
+        @ox = @ox + 1
+
+        @attributes = attributes.merge!(x:  coordinate.x_position,
+                                        y:  y,
+                                        ox: ox,
+                                        oy: oy)
+
+        Vedeu::Cursors::Cursor.new(@attributes).store
+      end
+
+      # Moves the cursor up by one row.
+      #
+      # @return [Vedeu::Cursors::Cursor]
+      def move_up
+        @oy = @oy - 1
+
+        @attributes = attributes.merge!(x:  x,
+                                        y:  coordinate.y_position,
+                                        ox: ox,
+                                        oy: oy)
+
+        Vedeu::Cursors::Cursor.new(@attributes).store
+      end
+
+      # Renders the cursor.
+      #
+      # @return [Array<Vedeu::Escape>]
+      def render
+        Vedeu::Output.render(visibility)
+      end
+
+      # Arbitrarily move the cursor to a given position.
+      #
+      # @param new_y [Fixnum] The row/line position.
+      # @param new_x [Fixnum] The column/character position.
+      # @return [Vedeu::Cursors::Cursor]
+      def reposition(new_y, new_x)
+        @attributes = attributes.merge!(x:  coordinate.x_position,
+                                        y:  coordinate.y_position,
+                                        ox: new_x,
+                                        oy: new_y)
+
+        Vedeu::Cursors::Cursor.new(@attributes).store
+      end
+
+      # Returns an escape sequence to position the cursor and set its
+      # visibility. When passed a block, will position the cursor, yield and
+      # return the original position.
+      #
+      # @return [String]
+      def to_s
+        if block_given?
+          "#{position}#{yield}#{visibility}"
+
+        else
+          "#{visibility}"
+
+        end
+      end
+      alias_method :to_str, :to_s
+
+      # Hide a named cursor, or without a name, the cursor of the currently
+      # focussed interface.
+      #
+      # @example
+      #   Vedeu.hide_cursor(name)
+      #
+      # @return [Vedeu::Escape]
+      def hide
+        super
+
+        render
+      end
+
+      # @return [Fixnum]
+      def ox
+        @ox = 0 if @ox < 0
+        @ox
+      end
+
+      # @return [Fixnum]
+      def oy
+        @oy = 0 if @oy < 0
+        @oy
+      end
+
+      # Return the position of this cursor.
+      #
+      # @return [Vedeu::Geometry::Position]
+      def position
+        @position = Vedeu::Geometry::Position[y, x]
+      end
+
+      # Show a named cursor, or without a name, the cursor of the currently
+      # focussed interface.
+      #
+      # @example
+      #   Vedeu.show_cursor(name)
+      #
+      # @return [Vedeu::Escape]
+      def show
+        super
+
+        render
+      end
+
+      # @return [Fixnum] The column/character coordinate.
+      def x
+        @x = bx  if @x < bx
+        @x = bxn if @x > bxn
+
+        @attributes[:x] = @x
+
+        @x
+      end
+
+      # @return [Fixnum] The row/line coordinate.
+      def y
+        @y = by  if @y < by
+        @y = byn if @y > byn
+
+        @attributes[:y] = @y
+
+        @y
+      end
+
+      private
+
+      # @see Vedeu::Borders::Repository#by_name
+      def border
+        @border ||= Vedeu.borders.by_name(name)
+      end
+
+      # @return [Vedeu::Geometry::Coordinate]
+      def coordinate
+        @coordinate ||= Vedeu::Geometry::Coordinate.new(name, oy, ox)
+      end
+
+      # The default values for a new instance of this class.
+      #
+      # @return [Hash]
+      def defaults
+        {
+          name:       '',
+          ox:         0,
+          oy:         0,
+          repository: Vedeu.cursors,
+          visible:    false,
+          x:          1,
+          y:          1,
+        }
+      end
+
+      # Returns the escape sequence for setting the visibility of the cursor.
+      #
+      # @return [String]
+      def visibility
+        value = visible? ? Vedeu::Esc.show_cursor : Vedeu::Esc.hide_cursor
+
+        Vedeu::Escape.new(position: position, value: value)
+      end
+
+    end # Cursor
+
+  end # Cursors
+
+end # Vedeu

data/lib/vedeu/cursors/refresh.rb

@@ -0,0 +1,84 @@
+module Vedeu
+
+  module Cursors
+
+    # Handle the refreshing (redrawing) of a cursor, without redrawing the whole
+    # interface; unless the cursor's offset has caused the view to change.
+    #
+    class Refresh
+
+      extend Forwardable
+
+      def_delegators :border,
+                     :height,
+                     :width
+
+      # @param (see #initialize)
+      def self.by_name(name = Vedeu.focus)
+        new(name).by_name
+      end
+
+      # Returns a new instance of Vedeu::Cursors::Refresh.
+      #
+      # @param name [String] The name of the cursor.
+      # @return [Vedeu::Cursors::Refresh]
+      def initialize(name)
+        @name = name
+      end
+
+      # Renders the cursor in the terminal. If the cursor's x or y offsets are
+      # greater or equal to the interface's width or height respectively, then
+      # the view is also refreshed, causing the content to be offset also.
+      #
+      # @return [Array]
+      def by_name
+        Vedeu.log(type: :info, message: "Refreshing cursor: '#{name}'")
+
+        Vedeu.trigger(:_refresh_, name) if refresh_view?
+
+        Vedeu::Terminal.output(cursor.to_s)
+      end
+
+      protected
+
+      # @!attribute [r] name
+      # @return [String]
+      attr_reader :name
+
+      private
+
+      # Returns true when the view should be refreshed. This is determined by
+      # checking that the offsets for x and y are outside the width and height
+      # of the named interface.
+      #
+      # @return [Boolean]
+      def refresh_view?
+        cursor.ox >= width || cursor.oy >= height
+      end
+
+      # @return [Vedeu::Cursors::Cursor]
+      # @see Vedeu::Cursors::Repository#by_name
+      def cursor
+        @cursor ||= Vedeu.cursors.by_name(name)
+      end
+
+      # Fetch the border by name.
+      #
+      # @note
+      #   Vedeu::Borders::Border is used in this way because when there is not a
+      #   border defined, it will fallback to a Vedeu::Borders::Null which uses
+      #   Vedeu::Geometry::Geometry to determine it's dimensions based on the
+      #   name also. When a Vedeu::Geometry::Geometry cannot be found, this
+      #   falls back to a Vedeu::Geometry::Null which uses the dimensions of the
+      #   current terminal.
+      #
+      # @return (see Vedeu::Borders::Repository#by_name)
+      def border
+        @border ||= Vedeu.borders.by_name(name)
+      end
+
+    end # Refresh
+
+  end # Cursors
+
+end # Vedeu

data/lib/vedeu/cursors/repository.rb

@@ -0,0 +1,34 @@
+module Vedeu
+
+  module Cursors
+
+    # Allows the storing of each interface's cursor.
+    #
+    class Repository < Vedeu::Repository
+
+      singleton_class.send(:alias_method, :cursors, :repository)
+
+      class << self
+
+        # @return [Vedeu::Cursors::Cursor]
+        # @see Vedeu::API.cursor
+        def cursor
+          cursors.by_name(Vedeu.focus) if Vedeu.focus
+        end
+
+      end # Eigenclass
+
+      null Vedeu::Cursors::Cursor
+      real Vedeu::Cursors::Cursor
+
+    end # Repository
+
+    class Cursor
+
+      repo Vedeu::Cursors::Repository.repository
+
+    end # Cursor
+
+  end # Cursors
+
+end # Vedeu