ver 2009.12.14 → 2010.02

data/lib/ver/keymap/keymapped.rb

@@ -0,0 +1,25 @@
+module VER
+  module Keymapped
+    attr_reader :major_mode
+
+    def major_mode=(new_mode)
+      old_mode = self.major_mode
+      new_mode = WidgetMajorMode.new(self, new_mode)
+
+      return if old_mode == new_mode
+
+      new_mode.replaces old_mode do
+        @major_mode = new_mode
+      end
+    end
+
+    def minor_mode(*args, old, new)
+      major_mode.replace_minor(old, new)
+    end
+
+    def minor_mode?(name)
+      name = name.to_sym
+      major_mode.minors.find{|minor| minor.to_sym == name }
+    end
+  end
+end

data/lib/ver/keysyms.rb

@@ -0,0 +1,104 @@
+module VER
+  # A Hash containing the Tk keysyms.
+  # The key is the ascii character, the value is the name as used in tk binds.
+  KEYSYMS = {
+    " "  => "<space>",
+    "!"  => "<exclam>",
+    "#"  => "<numbersign>",
+    "$"  => "<dollar>",
+    "%"  => "<percent>",
+    "&"  => "<ampersand>",
+    "'"  => "<quoteright>",
+    "("  => "<parenleft>",
+    ")"  => "<parenright>",
+    "*"  => "<asterisk>",
+    "+"  => "<plus>",
+    ","  => "<comma>",
+    "-"  => "<minus>",
+    "."  => "<period>",
+    "/"  => "<slash>",
+    ":"  => "<colon>",
+    ";"  => "<semicolon>",
+    "<"  => "<less>",
+    "="  => "<equal>",
+    ">"  => "<greater>",
+    "?"  => "<question>",
+    "@"  => "<at>",
+    "["  => "<bracketleft>",
+    "\\" => "<backslash>",
+    "]"  => "<bracketright>",
+    "^"  => "<asciicircum>",
+    "_"  => "<underscore>",
+    "`"  => "<quoteleft>",
+    "{"  => "<braceleft>",
+    "|"  => "<bar>",
+    "}"  => "<braceright>",
+    "~"  => "<asciitilde>",
+    '"'  => "<quotedbl>",
+    '0' => '0',
+    '1' => '1',
+    '2' => '2',
+    '3' => '3',
+    '4' => '4',
+    '5' => '5',
+    '6' => '6',
+    '7' => '7',
+    '8' => '8',
+    '9' => '9',
+    'A' => 'A',
+    'B' => 'B',
+    'C' => 'C',
+    'D' => 'D',
+    'E' => 'E',
+    'F' => 'F',
+    'G' => 'G',
+    'H' => 'H',
+    'I' => 'I',
+    'J' => 'J',
+    'K' => 'K',
+    'L' => 'L',
+    'M' => 'M',
+    'N' => 'N',
+    'O' => 'O',
+    'P' => 'P',
+    'Q' => 'Q',
+    'R' => 'R',
+    'S' => 'S',
+    'T' => 'T',
+    'U' => 'U',
+    'V' => 'V',
+    'W' => 'W',
+    'X' => 'X',
+    'Y' => 'Y',
+    'Z' => 'Z',
+    'a' => 'a',
+    'b' => 'b',
+    'c' => 'c',
+    'd' => 'd',
+    'e' => 'e',
+    'f' => 'f',
+    'g' => 'g',
+    'h' => 'h',
+    'i' => 'i',
+    'j' => 'j',
+    'k' => 'k',
+    'l' => 'l',
+    'm' => 'm',
+    'n' => 'n',
+    'o' => 'o',
+    'p' => 'p',
+    'q' => 'q',
+    'r' => 'r',
+    's' => 's',
+    't' => 't',
+    'u' => 'u',
+    'v' => 'v',
+    'w' => 'w',
+    'x' => 'x',
+    'y' => 'y',
+    'z' => 'z',
+  }
+
+  # Inversion of KEYSYMS for fast lookup in {WidgetMajorMode}
+  SYMKEYS = KEYSYMS.invert
+end

data/lib/ver/layout/notebook.rb

@@ -0,0 +1,74 @@
+module VER
+  class NotebookLayout < Tk::Tile::LabelFrame
+    attr_reader :strategy, :stack, :options, :note
+
+    class Notebook < Tk::Tile::Notebook
+    end
+
+    def initialize(parent, options = {})
+      super
+      pack(fill: :both, expand: true)
+      @stack = []
+      @options = {}
+      @note = Notebook.new(self)
+      @note.pack fill: :both, expand: true
+    end
+
+    def create_buffer(options = {})
+      buffer = Buffer.new(self, options)
+      yield buffer
+      note.add(buffer, text: buffer.text.short_filename)
+      note.select(buffer)
+      buffer.focus
+    end
+
+    def close_buffer(buffer)
+      note.forget(buffer)
+      buffer.destroy
+    end
+
+    def focus_next(current)
+      index = note.index(current)
+      total = note.index('end') - 1
+
+      note.select(index == total ? 0 : index + 1)
+      Tk::Focus.focus(note.select)
+    end
+
+    def focus_prev(current)
+      index = note.index(current)
+
+      note.select(index == 0 ? (note.index('end') - 1) : index - 1)
+      Tk::Focus.focus(note.select)
+    end
+
+    def push_up(current)
+      index = note.index(current)
+
+      if index == 0
+        note.insert('end', index)
+      else
+        note.insert(index - 1, index)
+      end
+    end
+
+    def push_down(current)
+      index = note.index(current)
+      total = note.index('end') - 1
+
+      if index == total
+        note.insert(0, index)
+      else
+        note.insert(index + 1, index)
+      end
+    end
+
+    def push_top(current)
+      note.insert(0, current)
+    end
+
+    def push_bottom(current)
+      note.insert('end', current)
+    end
+  end
+end

data/lib/ver/layout/paned.rb

@@ -0,0 +1,184 @@
+module VER
+  class PanedLayout < Tk::Tile::LabelFrame
+    # contains the buffers in the order they are displayed
+    attr_reader :stack
+
+    # contains the master and slave pane
+    attr_reader :layout_pane
+
+    # contains master buffers
+    attr_reader :master_pane
+
+    # contains slave buffers
+    attr_reader :slave_pane
+
+    # options specific for the paned layout
+    attr_reader :options
+
+    # default options
+    OPTIONS = {masters: 1, slaves: 3, center: 0.5}
+
+    # Create a new PanedLayout for given +parent+ and +options+.
+    # The +options+ may contain :masters and :slaves, which will be merged with
+    # the default [OPTIONS].
+    def initialize(parent, options = {})
+      @options = OPTIONS.dup
+      @options[:masters] = options.delete(:masters) if options.key?(:masters)
+      @options[:slaves]  = options.delete(:slaves)  if options.key?(:slaves)
+
+      super
+
+      pack(fill: :both, expand: true)
+
+      @stack = []
+
+      @layout_pane = Tk::Tile::PanedWindow.new(self, orient: :horizontal)
+      @master_pane = Tk::Tile::PanedWindow.new(@layout_pane, orient: :vertical)
+      @slave_pane  = Tk::Tile::PanedWindow.new(@layout_pane, orient: :vertical)
+      @layout_pane.pack fill: :both, expand: true
+      @layout_pane.add(@master_pane, weight: 1)
+      @layout_pane.add(@slave_pane, weight: 1)
+
+      @layout_pane.bind('<Map>'){ apply }
+    end
+
+    # Add the given +buffer+ to the {stack}, apply, and focus +buffer+.
+    def add_buffer(buffer)
+      stack.unshift(buffer)
+      apply
+      buffer.focus
+    end
+
+    # Remove given +buffer+ from {stack} and apply.
+    def forget_buffer(buffer)
+      stack.delete(buffer)
+      apply
+    end
+
+    # Create a new {Buffer} inside the {PanedLayout}, +options+ are passed to
+    # {Buffer.new}.
+    # The new {Buffer} will be at top of the {stack}.
+    #
+    # @see add_buffer
+    def create_buffer(options = {})
+      buffer = Buffer.new(self, options)
+      yield buffer
+      add_buffer(buffer)
+      buffer
+    end
+
+    # Forget and destroy the given +buffer+.
+    #
+    # @see forget_buffer
+    def close_buffer(buffer)
+      forget_buffer(buffer)
+      buffer.destroy
+
+      if previous = visible.first
+        previous.focus
+      else
+        Methods::Save.quit(nil)
+      end
+    end
+
+    def apply
+      masters, slaves = masters_slaves
+
+      (master_pane.panes - masters.map{|bff| bff.tk_pathname }).each do |bff|
+        master_pane.forget(bff)
+      end
+
+      (slave_pane.panes - slaves.map{|bff| bff.tk_pathname }).each do |bff|
+        slave_pane.forget(bff)
+      end
+
+      masters.each{|bff| master_pane.insert(:end, bff, weight: 1) }
+      slaves.each{|bff| slave_pane.insert(:end, bff, weight: 1) }
+
+      if slaves.empty?
+        layout_pane.forget(slave_pane) rescue nil
+      else
+        layout_pane.add(slave_pane, weight: 1) rescue nil
+
+        width = layout_pane.winfo_width
+        center = (width * options[:center]).to_i
+
+        # layout_pane.sashpos(0, center)
+      end
+    end
+
+    def masters_slaves
+      masters_max, slaves_max = options.values_at(:masters, :slaves)
+      stack.compact!
+      possible = stack.select{|buffer| buffer.shown? }
+      return [*possible[0, masters_max]], [*possible[masters_max, slaves_max]]
+    end
+
+    def visible?(buffer)
+      visible.index(buffer)
+    end
+
+    def visible
+      masters_slaves.flatten
+    end
+
+    def focus_next(buffer)
+      return unless index = visible.index(buffer)
+
+      found = visible[index + 1] || visible[0]
+      found.focus
+    end
+
+    def focus_prev(buffer)
+      return unless index = visible.index(buffer)
+
+      found = visible[index - 1]
+      found.focus
+    end
+
+    def push_up(buffer)
+      return unless index = stack.index(buffer)
+      previous = stack[index - 1]
+      buffer.raise(previous)
+      stack[index - 1], stack[index] = buffer, previous
+
+      apply
+      previous.focus unless visible?(buffer)
+    end
+
+    def push_down(buffer)
+      return unless index = stack.index(buffer)
+      following = stack[index + 1] || stack[0]
+      buffer.raise(following)
+      stack[stack.index(following)], stack[index] = buffer, following
+
+      apply
+      following.focus unless visible?(buffer)
+    end
+
+    def push_top(buffer)
+      stack.unshift(stack.delete(buffer))
+      apply
+    end
+
+    def push_bottom(buffer)
+      stack.push(stack.delete(buffer))
+      apply
+      stack.last.focus unless visible?(buffer)
+    end
+
+    def cycle_next(buffer)
+      return unless index = stack.index(buffer)
+      stack.push(stack.shift)
+      apply
+      stack[index].focus
+    end
+
+    def cycle_prev(buffer)
+      return unless index = stack.index(buffer)
+      stack.unshift(stack.pop)
+      apply
+      stack[index].focus
+    end
+  end
+end

data/lib/ver/layout/tiling.rb

@@ -0,0 +1,135 @@
+module VER
+  class TilingLayout < Tk::Tile::LabelFrame
+    autoload :CommonTiling, 'ver/layout/tiling/common'
+    autoload :HorizontalTiling, 'ver/layout/tiling/horizontal'
+    autoload :VerticalTiling, 'ver/layout/tiling/vertical'
+
+    attr_reader :strategy, :stack, :options
+
+    def initialize(parent, options = {})
+      super
+
+      pack(fill: :both, expand: true)
+
+      # @stack contains the buffers in the order they are displayed
+      @stack = []
+      @options = {}
+      self.strategy = VerticalTiling
+    end
+
+    def strategy=(mod)
+      @strategy = mod
+      apply if stack.any?
+    end
+
+    def create_buffer(options = {})
+      buffer = Buffer.new(self, options)
+      yield buffer
+      stack.unshift(buffer)
+
+      apply
+      buffer.focus
+    end
+
+    def close_buffer(buffer)
+      stack.delete(buffer)
+      buffer.destroy
+
+      if previous = stack.first
+        apply
+        previous.focus
+      else
+        VER.exit
+      end
+    end
+
+    def focus_next(current)
+      visible = head_tail_hidden.first(2).flatten
+      return unless index = visible.index(current)
+
+      found = visible[index + 1] || visible[0]
+      found.focus
+    end
+
+    def focus_prev(current)
+      visible = head_tail_hidden.first(2).flatten
+
+      return unless index = visible.index(current)
+
+      found = visible[index - 1]
+      found.focus
+    end
+
+    # called on #3
+    # +-----+-----+ > +-----+-----+ > +-----+-----+ > +-----+-----+
+    # |     |  2  | > |     |  3  | > |     |  1  | > |     |  1  |
+    # |  1  +-----+ > |  1  +-----+ > |  3  +-----+ > |  3  +-----+
+    # |     |  3  | > |     |  2  | > |     |  2  | > |     |  2  |
+    # +-----+-----+ > +-----+-----+ > +-----+-----+ > +-----+-----+
+    def push_up(current)
+      return unless index = stack.index(current)
+      previous = stack[index - 1]
+      current.raise(previous)
+      stack[index - 1], stack[index] = current, previous
+
+      apply
+      previous.focus unless visible?(current)
+    end
+
+    # called on #3
+    # +-----+-----+ > +-----+-----+ > +-----+-----+ > +-----+-----+
+    # |     |  2  | > |     |  1  | > |     |  3  | > |     |  2  |
+    # |  1  +-----+ > |  3  +-----+ > |  1  +-----+ > |  1  +-----+
+    # |     |  3  | > |     |  2  | > |     |  2  | > |     |  3  |
+    # +-----+-----+ > +-----+-----+ > +-----+-----+ > +-----+-----+
+    def push_down(current)
+      return unless index = stack.index(current)
+      following = stack[index + 1] || stack[0]
+      current.raise(following)
+      stack[stack.index(following)], stack[index] = current, following
+
+      apply
+      following.focus unless visible?(current)
+    end
+
+    def push_top(current)
+      stack.unshift(stack.delete(current))
+      apply
+    end
+
+    def push_bottom(buffer)
+      stack.push(stack.delete(buffer))
+      apply
+      stack.first.focus unless visible?(buffer)
+    end
+
+    def cycle_next(current)
+      return unless index = stack.index(current)
+      stack.push(stack.shift)
+      apply
+      stack[index].focus
+    end
+
+    def cycle_prev(current)
+      return unless index = stack.index(current)
+      stack.unshift(stack.pop)
+      apply
+      stack[index].focus
+    end
+
+    def apply(options = {})
+      @options.merge!(options)
+      strategy.apply(self, @options)
+    end
+
+    def head_tail_hidden(options = {})
+      @options.merge!(options)
+      strategy.prepare(self, @options).first(3)
+    end
+
+    def visible?(buffer)
+      visible = head_tail_hidden.first(2).flatten
+      visible.include?(buffer)
+    end
+  end
+end