ver 2009.12.14 → 2010.02

data/lib/ver/status/mode.rb

@@ -0,0 +1,15 @@
+module VER
+  class Status
+    class Mode < Label
+      def setup
+        register :mode
+      end
+
+      def to_s
+        major = text.major_mode
+        string = [ major.name, *major.minors.map(&:name) ].join(', ')
+        "[#{string}]"
+      end
+    end
+  end
+end

data/lib/ver/status/nano_help.rb

@@ -0,0 +1,71 @@
+module VER
+  class Status
+    class NanoHelp < Tk::Tile::Frame
+      attr_reader :status, :weight, :row, :column, :sticky
+
+      def initialize(status, options = {})
+        @status = status
+        @weight = options.delete(:weight) || 0
+        @row = options.delete(:row)
+        @column = options.delete(:column)
+        @sticky = options.delete(:sticky)
+        @font = status.text.options.font
+
+        super
+
+        @long_labels = []
+        @short_labels = []
+
+        add 0, 0, '^G', ' Get Help'
+        add 0, 1, '^O', ' WriteOut'
+        add 0, 2, '^R', ' Read File'
+        add 0, 3, '^Y', ' Prev Page'
+        add 0, 4, '^K', ' Cut Text'
+        add 0, 5, '^C', ' Cur Pos'
+        add 1, 0, '^X', ' Exit'
+        add 1, 1, '^J', ' Justify'
+        add 1, 2, '^W', ' Where Is'
+        add 1, 3, '^V', ' Next Page'
+        add 1, 4, '^U', ' UnCut Text'
+        add 1, 5, '^T', ' To Spell'
+
+        0.upto 11 do |col|
+          weight = col % 2 == 0 ? 0 : 1
+          grid_columnconfigure(col, weight: weight)
+        end
+      end
+
+      def add(row, col, short, long)
+        short_label = Tk::Tile::Label.new(
+          self, font: @font, background: 'white', foreground: 'black', text: short)
+        long_label  = Tk::Tile::Label.new(
+          self, font: @font, background: 'black', foreground: 'white', text: long)
+        short_col = col * 2
+        long_col = short_col + 1
+
+        short_label.grid_configure(row: row, column: short_col, sticky: :w)
+        long_label.grid_configure(row: row, column: long_col, sticky: :we)
+
+        @long_labels << long_label
+        @short_labels << short_label
+      end
+
+      def style=(config)
+        # @long_labels.each{|label| label.configure(config) }
+      end
+
+      def toggle
+        info = grid_info
+
+        if info.empty?
+          grid_configure(@last_grid_info)
+          true
+        else
+          @last_grid_info = info
+          grid_forget
+          false
+        end
+      end
+    end
+  end
+end

data/lib/ver/status/nano_position.rb

@@ -0,0 +1,38 @@
+module VER
+  class Status
+    class NanoPosition < Label
+      def setup
+        register :position
+      end
+
+      def style=(config)
+        configure(config)
+      end
+
+      def to_s
+        line_now     = text.count(1.0, :insert, :lines) + 1
+        line_total   = text.count(1.0, :end, :lines)
+        line_percent = ((100.0 / line_total) * line_now)
+        line_percent = 0 if line_percent.nan?
+
+        col_now     = text.count('insert linestart', :insert, :chars) + 1
+        col_total   = text.count('insert linestart', 'insert lineend', :chars) + 1
+        col_percent = ((100.0 / col_total) * col_now)
+        col_percent = 0 if col_percent.nan?
+
+        char_now   = text.count(1.0, :insert, :chars)
+        char_total = text.count(1.0, :end, :chars) - 1
+        char_percent = ((100.0 / char_total) * char_now)
+        char_percent = 0 if char_percent.nan?
+
+        inner = "%d/%d (%d%%), %d/%d (%d%%), %d/%d (%d%%)" % [
+          line_now, line_total, line_percent.round,
+          col_now,  col_total,  col_percent.round,
+          char_now, char_total, char_percent.round,
+        ]
+
+        "[ #{inner} ]"
+      end
+    end
+  end
+end

data/lib/ver/status/percent.rb

@@ -0,0 +1,17 @@
+module VER
+  class Status
+    class Percent < Position
+      def to_s
+        here = text.count(1.0, :insert, :lines)
+        total = text.count(1.0, :end, :lines)
+        percent = ((100.0 / total) * here).round
+
+        case percent
+        when 100, 99; 'Bot'
+        when 0      ; 'Top'
+        else        ; '%2d%%' % percent
+        end
+      end
+    end
+  end
+end

data/lib/ver/status/position.rb

@@ -0,0 +1,16 @@
+module VER
+  class Status
+    class Position < Label
+      def setup
+        register :position
+      end
+
+      def to_s
+        "%4d,%3d" % [
+          text.count('1.0', 'insert', :lines) + 1,
+          text.count('insert linestart', 'insert', :displaychars)
+        ]
+      end
+    end
+  end
+end

data/lib/ver/status/separator.rb

@@ -0,0 +1,20 @@
+module VER
+  class Status
+    class Separator < Tk::Tile::Separator
+      attr_reader :status, :weight, :row, :column, :sticky
+
+      def initialize(status, options = {})
+        @status = status
+        @weight = options.delete(:weight) || 0
+        @row = options.delete(:row)
+        @column = options.delete(:column)
+        @sticky = options.delete(:sticky)
+
+        super
+      end
+
+      def style=(conf)
+      end
+    end
+  end
+end

data/lib/ver/status/short_filename.rb

@@ -0,0 +1,13 @@
+module VER
+  class Status
+    class ShortFilename < Label
+      def setup
+        register :filename
+      end
+
+      def to_s
+        text.short_filename
+      end
+    end
+  end
+end

data/lib/ver/status/syntax.rb

@@ -0,0 +1,13 @@
+module VER
+  class Status
+    class Syntax < Label
+      def setup
+        register :syntax
+      end
+
+      def to_s
+        format % text.syntax.name
+      end
+    end
+  end
+end

data/lib/ver/syntax.rb

@@ -4,7 +4,7 @@ module VER
     autoload :Processor, 'ver/syntax/processor'
 
     def self.list
-      VER.loadpath.map{|path| Dir[(path/'syntax/*.json').to_s] }.flatten
+      VER.loadpath.map{|path| Dir[(path/'syntax/*.rb').to_s] }.flatten
     end
 
     def self.from_filename(filename)
@@ -16,7 +16,7 @@ module VER
     end
 
     def self.find(syntax_name)
-      VER.find_in_loadpath("syntax/#{syntax_name}.json")
+      VER.find_in_loadpath("syntax/#{syntax_name}.rb")
     end
 
     def self.load(file)
@@ -40,30 +40,25 @@ module VER
       @theme  = theme || Theme.find_and_load(VER.options[:theme])
     end
 
-    def highlight(textarea, code, lineno = nil, from = '1.0', to = 'end')
+    def highlight(widget, lineno, from, to)
+      check_for_theme_change(widget)
+
+      processor = Processor.new(widget, @theme, lineno)
+      @theme.remove_tags_on(widget, from, to)
+      code = widget.get(from, to)
+      parser.parse(code, processor)
+    end
+
+    def check_for_theme_change(widget)
       if @old_theme
-        @old_theme.delete_tags_on(textarea)
+        @old_theme.delete_tags_on(widget)
         @old_theme = nil
       end
 
       if @first_highlight
-        @theme.create_tags_on(textarea)
-        @theme.apply_default_on(textarea)
+        @theme.create_tags_on(widget)
+        @theme.apply_default_on(widget)
         @first_highlight = false
-      else
-        @theme.remove_tags_on(textarea, from, to)
-      end
-
-      pr = Processor.new(textarea, @theme, lineno || 0)
-
-      if lineno
-        pr.start_parsing(parser.scopeName)
-        stack = [[parser, nil]]
-        parser.parse_line(stack, code, pr)
-        pr.end_parsing(parser.scopeName)
-      else
-        @theme.remove_tags_on(textarea, from, to)
-        parser.parse(code, pr)
       end
     end
 

data/lib/ver/syntax/detector.rb

@@ -29,25 +29,19 @@ module VER
 
       def detect_ext(path)
         basename = path.basename.to_s
-        return unless basename =~ /\./
-
-        scores = {}
 
         EXTS_LIST.each do |name, exts|
-          lowest = nil
-          exts.find do |ext|
-            if basename.end_with?(ext)
-              distance = Levenshtein.distance(basename, ext)
-              lowest ||= distance
-              lowest = distance if lowest > distance
+          exts.each do |ext|
+            if ext == basename
+              return name
+            elsif basename.end_with?(".#{ext}")
+              return name
             end
-            # return name if basename.end_with?(ext)
           end
-          scores[name] = lowest if lowest
+
         end
 
-        found = scores.sort_by{|k,v| v }.first
-        return found.first if found
+        nil
       end
 
       def detect_head(path)

data/lib/ver/syntax/processor.rb

@@ -10,7 +10,7 @@ module VER
       def end_parsing(syntax_name)
         tags.each do |name, indices|
           tag_name = theme.get(name) || name
-          textarea.fast_tag_add(tag_name, *indices)
+          textarea.tag_add(tag_name, *indices)
         end
 
         @tag_stack.uniq!
@@ -24,7 +24,7 @@ module VER
       end
 
       def open_tag(name, pos)
-        stack << [name, pos]
+        stack << [name, lineno, pos]
 
         if tag_name = theme.get(name)
           if stack.size > 1
@@ -37,9 +37,9 @@ module VER
       end
 
       def close_tag(name, mark)
-        sname, pos = stack.pop
+        from_name, from_lineno, pos = stack.pop
 
-        tags[name] << "#{lineno}.#{pos}" << "#{lineno}.#{mark}"
+        tags[name] << "#{from_lineno}.#{pos}" << "#{lineno}.#{mark}"
       rescue RuntimeError => exception
         # if you modify near the end of the textarea, sometimes the last tag
         # cannot be closed because the contents of the textarea changed since

data/lib/ver/text.rb

@@ -1,72 +1,169 @@
 module VER
   class Text < Tk::Text
     autoload :Index, 'ver/text/index'
-    include Methods
-
-    MODE_CURSOR = {
-      :insert       => {insertbackground: 'red',    blockcursor: false},
-      :control      => {insertbackground: 'green',  blockcursor: true},
-      :select_char  => {insertbackground: 'yellow', blockcursor: true},
-      :select_line  => {insertbackground: 'yellow', blockcursor: true},
-      :select_block => {insertbackground: 'yellow', blockcursor: true},
-    }
-
-    GUESS_ENCODING_ORDER = [
-      Encoding::US_ASCII,
-      Encoding::UTF_8,
-      Encoding::Shift_JIS,
-      Encoding::EUC_JP,
-      Encoding::EucJP_ms,
-      Encoding::Big5,
-      Encoding::UTF_16BE,
-      Encoding::UTF_16LE,
-      Encoding::UTF_32BE,
-      Encoding::UTF_32LE,
-      Encoding::CP949,
-      Encoding::Emacs_Mule,
-      Encoding::EUC_KR,
-      Encoding::EUC_TW,
-      Encoding::GB18030,
-      Encoding::GBK,
-      Encoding::Stateless_ISO_2022_JP,
-      Encoding::CP51932,
-      Encoding::EUC_CN,
-      Encoding::GB12345,
-      Encoding::Windows_31J,
-      Encoding::MacJapanese,
-      Encoding::UTF8_MAC,
-      Encoding::BINARY,
-    ]
+    include Keymapped
 
+    None = Object.new
     MATCH_WORD_RIGHT =  /[^a-zA-Z0-9]+[a-zA-Z0-9'"{}\[\]\n-]/
     MATCH_WORD_LEFT =  /(^|\b)\S+(\b|$)/
+    MODE_STYLES = {
+      :insert   => {insertbackground: 'red', blockcursor: false},
+      /select/  => {insertbackground: 'yellow', blockcursor: true},
+      /replace/ => {insertbackground: 'orange', blockcursor: true},
+    }
+
+    attr_accessor(:buffer, :status, :project_root, :project_repo,
+                  :undoer, :pristine, :prefix_arg, :readonly)
+    attr_reader(:filename, :options, :snippets, :preferences, :store_hash,
+                :default_theme_config, :encoding, :syntax, :name)
+
+    def initialize(buffer, options = {})
+      @project_repo = @project_root = @highlighter = nil
+
+      if peer = options.delete(:peer)
+        @tag_commands = {}
+        @tk_parent = buffer
+        @store_hash = peer.store_hash
+        @default_theme_config = peer.default_theme_config
+        Tk.execute(peer.tk_pathname, 'peer', 'create', assign_pathname, options)
+        self.filename = peer.filename
+        configure(peer.configure)
+      else
+        @default_theme_config = nil
+        @store_hash = Hash.new{|h,k| h[k] = {} }
+        super
+      end
+
+      widget_setup(buffer)
+    end
+
+    # This is a noop, it simply provides a target with a sane name.
+    def update_prefix_arg(widget)
+      numbers = []
+
+      major_mode.event_history.reverse_each do |event|
+        break unless event[:sequence] =~ /^(\d+)$/
+        numbers << $1
+      end
+
+      if numbers.any? && numbers != ['0']
+        self.prefix_arg = numbers.reverse.join.to_i
+      else
+        self.prefix_arg = nil
+      end
+    end
+
+    # Same as [prefix_arg], but returns 1 if there is no argument.
+    # Useful for [Move] methods and the like.
+    # Please note that calling this method is destructive.
+    # It will reset the state of the prefix_arg in order to avoid persistent
+    # arguments.
+    # So use it only once while your action is running, and store the result in a
+    # variable if you need it more than once.
+    def prefix_count
+      count = prefix_arg || 1
+      update_prefix_arg(self)
+      count
+    end
 
-    attr_accessor :keymap, :view, :status
-    attr_reader :filename, :encoding, :pristine, :syntax, :undoer
+    def persisted?
+      return false unless filename
+      return false unless filename.file?
+      require 'digest/md5'
 
-    # attributes for diverse functionality
-    attr_accessor :selection_mode, :selection_start
+      on_disk = Digest::MD5.hexdigest(filename.read)
+      in_memory = Digest::MD5.hexdigest(value)
+      on_disk == in_memory
+    end
+
+    def store(namespace, key, value = None)
+      if None == value
+        @store_hash[namespace][key]
+      else
+        @store_hash[namespace][key] = value
+      end
+    end
 
-    def initialize(view, options = {})
+    def inspect
+      details = {
+        mode: major_mode
+      }.map{|key, value| "%s=%p" % [key, value ] }.join(' ')
+      "#<VER::Text #{details}>"
+    end
+
+    def value=(string)
       super
-      self.view = view
-      @options = Options.new(:text, VER.options)
+      touch!('1.0', 'end')
+    end
 
-      keymap_name = @options.keymap
-      self.keymap = Keymap.get(name: keymap_name, receiver: self)
+    def peer_create(buffer)
+      self.class.new(buffer, peer: self)
+    end
 
-      apply_mode_style(keymap.mode) # for startup
-      setup_tags
+    def widget_setup(buffer)
+      self.buffer = buffer
+      @options = Options.new(:text, VER.options)
 
       @undoer = VER::Undo::Tree.new(self)
 
-      self.selection_start = nil
+      self.major_mode = :Fundamental
+
+      sync_mode_style
+      setup_tags
+
       @pristine = true
       @syntax = nil
-      @encoding = Encoding.default_internal
-      @dirty_indices = []
+      self.encoding = Encoding.default_internal
+
+      event_setup
+    end
 
-      self.mode = keymap.mode
+    def event_setup
+      bind '<<EnterMinorMode>>' do |event|
+        sync_mode_status
+        sync_mode_style(event.detail)
+      end
+
+      bind '<<Modified>>' do |event|
+        see :insert
+        sync_position_status
+      end
+
+      bind '<<Movement>>' do |event|
+        see :insert
+        Methods::Selection.refresh(self)
+        show_matching_brace
+        sync_position_status
+      end
+
+      bind('<FocusIn>') do |event|
+        on_focus_in(event)
+        Tk.callback_break
+      end
+
+      bind('<FocusOut>') do |event|
+        on_focus_out(event)
+        Tk.callback_break
+      end
+
+      bind '<Destroy>' do |event|
+        VER.cancel_block(@highlighter)
+      end
+    end
+
+    def on_focus_in(event)
+      Dir.chdir(filename.dirname.to_s) if options.auto_chdir
+      set_window_title
+      see(:insert)
+      Tk::Tile::Style.configure(buffer.style, border: 1, background: '#f00')
+    end
+
+    def on_focus_out(event)
+      Tk::Tile::Style.configure(buffer.style, border: 1, background: '#fff')
+    end
+
+    def pristine?
+      @pristine
     end
 
     def index(idx)
@@ -74,39 +171,63 @@ module VER
     end
 
     def message(*args)
-      status.message(*args)
+      VER.message(*args)
     end
 
     def noop(*args)
-      message "Noop %p in mode %p" % [args, keymap.mode]
+      # message "Noop %p in mode %p" % [args, keymap.mode]
     end
 
     def short_filename
-      filename.sub(Dir.pwd + '/', '') if filename
+      if filename
+        if root = @project_root
+          filename.relative_path_from(root).to_s
+        else
+          filename.sub(Dir.pwd + '/', '').to_s
+        end
+      elsif name
+        name.to_s
+      end
+    end
+
+    def name=(name)
+      @name = name
+      status.event :filename if status
     end
 
     def filename=(path)
       @filename = Pathname(path.to_s).expand_path
+      status.event :filename if status
+    end
+
+    def syntax=(syn)
+      @syntax = syn
+      status.event :syntax if syn && status
+    end
+
+    def encoding=(enc)
+      @encoding = enc
+      status.event :encoding if enc && status
     end
 
     def layout
-      view.layout
+      buffer.layout
     end
 
-    def status_projection(into)
-      format = options.statusline.dup
+    def sync_mode_status
+      status.event :mode
+    end
 
-      format.gsub!(/%([[:alpha:]]+)/, '#{\1()}')
-      format.gsub!(/%_([[:alpha:]]+)/, '#{(_ = \1()) ? " #{_}" : ""}')
-      format.gsub!(/%([+-]?\d+)([[:alpha:]]+)/, '#{\2(\1)}')
-      format = "%{#{format}}"
+    def sync_position_status
+      status.event :position, :percent
+    end
 
-      context = Status::Context.new(self)
-      line = context.instance_eval(format)
+    def sync_encoding_status
+      status.event :encoding
+    end
 
-      into.value = line
-    rescue => ex
-      puts ex, ex.backtrace
+    def sync_percent_status
+      status.event :percent
     end
 
     TAG_ALL_MATCHING_OPTIONS = { from: '1.0', to: 'end - 1 chars' }
@@ -125,39 +246,61 @@ module VER
 
       search_all(regexp, from, to) do |match, match_from, match_to|
         name = yield(match, match_from, match_to) if block_given?
-        fast_tag_add name, match_from, match_to
+        tag_add name, match_from, match_to
       end
     end
 
-    def search_all(regexp, from = '1.0', to = 'end - 1 chars')
-      return Enumerator.new(self, :search_all, regexp, from) unless block_given?
-      from, to = from.to_s, to.to_s
+    def search_all(regexp, start = '1.0', stop = 'end - 1 chars')
+      unless block_given?
+        return Enumerator.new(self, :search_all, regexp, start, stop)
+      end
 
-      while result = search(regexp, from, to, :count)
+      while result = search(regexp, start, stop, :count)
         pos, len = result
-        break if !pos || len == 0
+        return if !pos || len == 0
 
-        match = get(pos, "#{pos} + #{len} chars")
-        from = "#{pos} + #{len} chars"
+        from  = index(pos)
+        to    = index("#{pos} + #{len} chars")
+        match = get(from, to)
 
-        yield(match, pos, from)
+        yield(match, from, to)
+
+        start = to
       end
     end
 
-    def rsearch_all(regexp, from = 'end', to = '1.0')
-      return Enumerator.new(self, :rsearch_all, regexp, from) unless block_given?
+    def rsearch_all(regexp, start = 'end', stop = '1.0')
+      unless block_given?
+        return Enumerator.new(self, :rsearch_all, regexp, start, stop)
+      end
 
-      while result = rsearch(regexp, from, to, :count)
+      while result = rsearch(regexp, start, stop, :count)
         pos, len = result
         break if !pos || len == 0
 
-        match = get(pos, "#{pos} + #{len} chars")
-        from = index("#{pos} - #{len} chars")
+        from = index(pos)
+        to   = index("#{pos} + #{len} chars")
+        match = get(from, to)
 
-        yield(match, pos, from)
+        yield(match, from, to)
+
+        start = from
       end
     end
 
+    def up_down_line(count)
+      insert = index(:insert)
+
+      @udl_pos_orig = insert if @udl_pos_prev != insert
+
+      lines = count(@udl_pos_orig, insert, :displaylines)
+      target = index("#@udl_pos_orig + #{lines + count} displaylines")
+      @udl_pos_prev = target
+
+      @udl_pos_orig = target if target.x == @udl_pos_orig.x
+      target
+    end
+
     def tag_exists?(given_path)
       tag_names.include?(given_path)
     rescue RuntimeError => ex
@@ -171,11 +314,11 @@ module VER
       Tk::Event.generate(self, '<<Movement>>')
     end
 
-    def insert(index, string)
+    def insert(index, string, tag = Tk::None)
       index = index(index) unless index.respond_to?(:to_index)
 
-      undo_record do |record|
-        record.insert(index, string)
+      Methods::Undo.record self do |record|
+        record.insert(index, string, tag)
       end
     end
 
@@ -197,21 +340,13 @@ module VER
       index2 = index(index2) unless index2.respond_to?(:to_index)
       return if index1 == index2
 
-      undo_record do |record|
+      Methods::Undo.record self do |record|
         record.replace(index1, index2, string)
       end
     end
 
-    def focus
-      super
-      Tk::Event.generate(self, '<<Focus>>')
-    end
-
-    def fast_tag_add(tag, *indices)
-      execute('tag', 'add', tag, *indices)
-      self
-    rescue RuntimeError => ex
-      VER.error(ex)
+    def delete(*indices)
+      Methods::Delete.delete(self, *indices)
     end
 
     def set_window_title
@@ -225,6 +360,8 @@ module VER
         else
           title = "#{file} (#{dir_relative_to_home}) - VER"
         end
+      elsif name
+        title = "[#{name}] - VER"
       else
         title = "[No Name] - VER"
       end
@@ -233,67 +370,31 @@ module VER
     end
 
     def setup_highlight
-      return unless filename
-      return if @encoding == Encoding::BINARY
-
-      if @syntax = Syntax.from_filename(filename)
-        defer{ syntax.highlight(self, value) }
-        status_projection(status) if status
-      end
-    end
-
-    def schedule_line_highlight(raw_index)
-      return unless @syntax
-      index = index(raw_index)
-      schedule_line_highlight!(index.y - 1, index.linestart, index.lineend)
-    end
-
-    def schedule_highlight(options = {})
-      return unless @syntax
-      schedule_highlight!
+      setup_highlight_for(Syntax.from_filename(filename)) if filename
     end
 
-    # TODO: maybe we can make this one faster when many lines are going to be
-    #       highlighted at once by bundling them.
-    def touch!(*args)
-      args.each{|arg| schedule_line_highlight(arg) } if @syntax
-      Tk::Event.generate(self, '<<Modified>>')
-    end
+    def setup_highlight_for(syntax)
+      return if encoding == Encoding::BINARY
+      return unless syntax
 
-    private
+      self.syntax = syntax
+      VER.cancel_block(@highlighter)
 
-    def schedule_highlight!(*args)
-      defer do
-        syntax.highlight(self, value)
-        tag_all_trailing_whitespace
-        tag_all_uris
-      end
-    end
+      interval = options.syntax_highlight_interval.to_int
+      @highlighter = VER.when_inactive_for(interval){
+        handle_pending_syntax_highlights
+      }
 
-    # TODO: only tag the current line.
-    def schedule_line_highlight!(line, from, to)
-      defer do
-        syntax.highlight(self, get(from, to), line, from, to)
-        tag_all_trailing_whitespace(from: from, to: to)
-        tag_all_uris(from: from, to: to)
-      end
-    end
+      touch!('1.0', 'end')
 
-    def mode=(name)
-      keymap.mode = mode = name.to_sym
-      undo_separator
-      apply_mode_style(mode)
-      status_projection(status) if status
+      sync_mode_status
     end
 
-    def apply_mode_style(mode)
-      cursor = MODE_CURSOR[mode]
-      return unless cursor
-      configure cursor
-
-      return unless status && color = cursor[:insertbackground]
-      style = status.style
-      Tk::Tile::Style.configure style, fieldbackground: color
+    # TODO: maybe we can make this one faster when many lines are going to be
+    #       highlighted at once by bundling them.
+    def touch!(*indices)
+      tag_add('ver.highlight.pending', *indices) if @syntax
+      Tk::Event.generate(self, '<<Modified>>')
     end
 
     def load_theme(name)
@@ -301,7 +402,7 @@ module VER
       return unless found = Theme.find(name)
 
       syntax.theme = Theme.load(found)
-      schedule_highlight
+      touch!('1.0', 'end')
 
       message "Theme #{found} loaded"
     end
@@ -312,40 +413,108 @@ module VER
       theme = syntax.theme
 
       if name.is_a?(Syntax)
-        @syntax = Syntax.new(name.name, theme)
+        self.syntax = Syntax.new(name.name, theme)
       elsif found = Syntax.find(name)
-        @syntax = Syntax.new(name, theme)
+        self.syntax = Syntax.new(name, theme)
       else
         return false
       end
 
-      schedule_highlight
+      message "Syntax #{syntax.name} loaded"
+    end
+
+    def handle_pending_syntax_highlights
+      ignore_tags = %w[ver.highlight.pending sel]
+      tag_ranges('ver.highlight.pending').each do |from, to|
+        (tag_names(from) - ignore_tags).each do |tag_name|
+          tag_from, _ = tag_prevrange(tag_name, from)
+          from = tag_from if tag_from && from > tag_from
+        end
+
+        (tag_names(to) - ignore_tags).each do |tag_name|
+          _, tag_to = tag_nextrange(tag_name, to)
+          to = tag_to if tag_to && to < tag_to
+        end
+
+        from, to = index(from).linestart, index(to).lineend
+        lineno = from.y - 1
+        syntax.highlight(self, lineno, from, to)
+        tag_all_trailing_whitespace(from: from, to: to)
+        tag_all_uris(from: from, to: to)
+        tag_remove('ver.highlight.pending', from, to)
+      end
+    end
+
+    def default_theme_config=(config)
+      @default_theme_config = config
+      sync_mode_style
+    end
 
-      message "Syntax #{@syntax.name} loaded"
+    def ask(prompt, options = {}, &action)
+      options[:caller] ||= self
+      VER.minibuf.ask(prompt, options, &action)
     end
 
     def load_preferences
-      return unless @syntax
+      return unless syntax
+
+      name = syntax.name
+      return unless file = VER.find_in_loadpath("preferences/#{name}.rb")
+      @preferences = eval(file.read)
+    rescue Errno::ENOENT, TypeError => ex
+      VER.error(ex)
+    end
+
+    def load_snippets
+      return unless syntax
 
-      name = @syntax.name
-      file = VER.find_in_loadpath("preferences/#{name}.json")
-      @preferences = JSON.load(File.read(file))
+      name = syntax.name
+      return unless file = VER.find_in_loadpath("snippets/#{name}.rb")
+      @snippets = eval(file.read)
     rescue Errno::ENOENT, TypeError => ex
       VER.error(ex)
     end
 
+    def sync_mode_style(given_mode = nil)
+      config = (default_theme_config || {}).merge(blockcursor: false)
+
+      modes = given_mode ? [given_mode] : major_mode.minors
+
+      modes.each do |mode|
+        mode = MinorMode[mode]
+
+        MODE_STYLES.each do |pattern, style|
+          config.merge!(style) if pattern === mode.name
+        end
+      end
+
+      configure(config)
+      return unless status && color = config[:insertbackground]
+
+      status.style = {
+        background: cget(:background),
+        foreground: color,
+      }
+    end
+
+    private
+
     def setup_tags
       setup_highlight_trailing_whitespace
       setup_highlight_links
+      setup_highlight_pending
+    end
+
+    def setup_highlight_pending
+      # tag_configure 'ver.highlight.pending', underline: true
     end
 
     def setup_highlight_trailing_whitespace
-      tag_configure 'invalid.trailing-whitespace', background: '#f00'
-      tag_all_trailing_whitespace
+      tag_configure 'invalid.trailing-whitespace', background: '#400'
     end
 
     def setup_highlight_links
-      tag_configure 'markup.underline.link' , underline: true, foreground: '#00f'
+      tag_configure 'markup.underline.link' , underline: true, foreground: '#0ff'
 
       tag_bind('markup.underline.link', '<1>') do |event|
         pos = index("@#{event.x},#{event.y}")
@@ -362,25 +531,23 @@ module VER
           message "%p opens the uri: %s" % [browser, uri]
         end
       end
-
-      tag_all_uris
     end
 
     def tag_all_uris(given_options = {})
-      tag_all_matching('markup.underline.link', /https?:\/\/[^)\]}\s'"]+/, given_options)
+      tag_all_matching('markup.underline.link', /https?:\/\/[^<>)\]}\s'"]+/, given_options)
     end
 
     def tag_all_trailing_whitespace(given_options = {})
       tag_all_matching('invalid.trailing-whitespace', /[ \t]+$/, given_options)
     end
 
-    def defer
-      Tk::After.idle do
-        begin
-          yield
-        rescue Exception => ex
-          VER.error(ex)
-        end
+    def show_matching_brace(index = :insert)
+      tag = 'ver.highlight.brace'
+      tag_remove(tag, '1.0', 'end')
+
+      if pos = Methods::Move.matching_brace_pos(self, index)
+        tag_configure(tag, background: '#ff0', foreground: '#00f')
+        tag_add(tag, 'insert', 'insert + 1 chars', pos, "#{pos} + 1 chars")
       end
     end