xiki 0.5.0a

data/lib/history.rb

@@ -0,0 +1,286 @@
+class History
+
+  #   FILENAME = File.expand_path "~/.emacs.d/menu_log.notes"
+  # Unused
+  def self.menu
+    "
+    - menus) @log/
+
+    > Files
+    - .unsaved files/
+    - @edited/
+    - @files/history/
+    "
+  end
+
+  def self.prefix_times
+    prefix = Keys.prefix
+    prefix ||= 20
+    prefix = 20 if prefix == :u
+    prefix
+  end
+
+  def self.open_current options={}
+    if options[:paths]
+      paths = options[:paths]
+    elsif options[:prompt_for_bookmark]
+      bm = Keys.input(:timed => true, :prompt => "Enter bookmark to show content for: ")
+      path = Bookmarks.expand(bm, :just_bookmark => true)
+      path = File.expand_path(path)
+
+      if ! options[:all] && View.files.member?(path)
+        View.open path
+        FileTree.to_outline
+        return
+      end
+
+      paths = [path]
+    elsif options[:outline] || options[:all]
+      paths = [$el.buffer_file_name($el.buffer_list[0])]
+    else  # No options passed
+      times = Keys.prefix
+      paths = ( $el.buffer_list.map { |b| $el.buffer_file_name(b) }.select{|path| path})
+      paths = paths[0..(times-1)] if times  # Limit to number if prefix passed
+    end
+
+    if options[:enter_here]  # If entering in current file
+      path = paths.to_s
+      # If it's a dir, delegate to Open Tree
+      if path =~ /\/$/
+        FileTree.ls :here => true, :dir => path
+        return
+      end
+      View.insert "- " + FileTree.filename_to_next_line(paths.to_s)
+      $el.open_line 1
+      FileTree.enter_lines
+
+    else  # If entering in new buffer
+
+      # By default happen in same view
+      View.bar if options[:bar]  # If to go to bar
+
+      # If only one path, go to it's buffer if already open
+      if paths.size == 1
+        View.open paths[0]
+      end
+
+      View.to_buffer("*tree of current")
+      View.clear;  Notes.mode
+
+      raise "Thought this wouldn't happen :(" if paths.length > 1
+
+      dir, file = paths[0].match(/(.+\/)(.+)/)[1..2]
+      View << "- #{dir}\n  - #{file}\n"
+
+      View.to_top
+      Keys.clear_prefix
+      FileTree.select_next_file
+      if options[:all]
+        FileTree.enter_lines(//)
+      elsif options[:outline] || options[:prompt_for_bookmark]
+        FileTree.enter_lines
+      else
+        Tree.search :recursive => true
+      end
+    end
+
+  end
+
+  def self.open_edited
+    times = self.prefix_times
+    View.to_buffer("*tree of edited")
+    View.clear;  notes_mode
+    View.insert Tree.paths_to_tree($el.elvar.editedhistory_history.to_a[0..(times-1)])
+    View.to_top
+    Keys.clear_prefix
+    FileTree.select_next_file
+    Tree.search :recursive => true
+  end
+
+  def self.open_history
+    times = self.prefix_times
+    View.to_buffer("*tree of history")
+    View.clear;  notes_mode
+
+    self.insert_history times
+    View.to_top
+    Keys.clear_prefix
+    FileTree.select_next_file
+    Tree.search :recursive => true
+  end
+
+  def self.insert_history times
+    View.insert Tree.paths_to_tree($el.elvar.recentf_list.to_a[0..(times-1)])
+  end
+
+  def self.enter_history
+    orig = Location.new
+    self.insert_history self.prefix_times
+    right = $el.point
+    orig.go
+    Tree.search :recursive => true, :left => $el.point, :right => right
+  end
+
+  def self.insert_viewing times
+    paths = ( $el.buffer_list.map { |b| $el.buffer_file_name(b) }.select{|path| path})
+    paths = paths[0..(times-1)] if times  # Limit to number if prefix passed
+    View.insert Tree.paths_to_tree(paths)
+  end
+
+  def self.enter_viewing
+    orig = Location.new
+    self.insert_viewing self.prefix_times
+    right = $el.point
+    orig.go
+    Tree.search :recursive => true, :left => $el.point, :right => right
+  end
+
+  def self.unsaved_files
+
+    # Narrow down to modified buffer only
+    buffers = $el.buffer_list.to_a.
+      select{|b| $el.buffer_modified_p(b)}.
+      select{|b| $el.buffer_file_name(b)}
+
+    if (buffers.size == 0)
+      return "- No files unsaved!\n"
+    end
+
+    txt = ""
+
+    buffers.each do |b|
+      path = $el.buffer_file_name(b)
+      $el.with(:save_excursion) do
+        $el.set_buffer b
+
+        diffs = DiffLog.save_diffs :dont_log=>1
+
+        if ! diffs
+          diffs = "    | File no longer exists?\n" if ! File.exists?(path)
+          diffs ||= "    | no changes\n"
+        end
+        diffs = diffs.sub(/^.+\n.+\n/, '').gsub /^  /, ''
+
+        txt << "@#{path}\n"
+        txt << diffs
+
+      end
+    end
+
+    txt
+  end
+
+  def self.setup_editedhistory
+
+    return if ! $el
+
+    $el.el4r_lisp_eval %q<
+      (progn
+        ; Settings
+        (setq editedhistory-log "~/.editedhistory")
+
+        ; Runs upon startup.  Load log file into memory if it exists.  Run this manually if you edit the log file.
+        (defun editedhistory-load ()
+          (if (file-readable-p editedhistory-log)
+            ; Read from file into memory
+            (with-temp-buffer
+              (insert-file-contents editedhistory-log nil nil nil t)
+              (setq editedhistory-history
+                (car (read-from-string (buffer-substring (point-min) (point-max))) )))
+            ; Otherwise, initialize var
+            (set 'editedhistory-history nil)))
+
+        ; Saves on exit: 'editedhistory-history' to the file 'editedhistory-log'
+        (add-hook 'kill-emacs-hook 'editedhistory-save)
+        (defun editedhistory-save () (interactive)
+          (with-temp-buffer
+            (erase-buffer)
+            (insert (pp-to-string editedhistory-history) )
+            (if (file-writable-p editedhistory-log)
+              (write-region (point-min) (point-max) editedhistory-log)
+            )
+            (kill-buffer (current-buffer)))
+          nil)
+
+        ; Runs upon save: Track modified files
+        (defun editedhistory-remember-file ()
+          ; Remove from list in case it's already there (we want to add to beginning)
+          (when (boundp 'editedhistory-history)
+            (setq editedhistory-history (delete buffer-file-name editedhistory-history) )
+            ; Add to list
+            (add-to-list 'editedhistory-history buffer-file-name))
+          nil)   ; Return nil so we won't block writing
+        (add-hook 'write-file-hooks 'editedhistory-remember-file)
+
+        ; Load upon startup, to add hooks
+        (define-minor-mode editedhistory-mode
+          "Toggle editedhistory mode"
+          :global t
+          :group 'editedhistory
+
+          ; Load if not yet loaded
+          (pp (boundp 'editedhistory-loaded-p))
+          (unless (boundp 'editedhistory-loaded-p)
+            (setq editedhistory-loaded-p t)
+            (pp editedhistory-loaded-p)
+            ; Load log file into memory
+            (editedhistory-load)))
+
+        ; Load mode
+        (editedhistory-mode t)
+      )
+    >
+  end
+
+  def self.backup_file
+    bm = Bookmarks['$bak']
+    return View.beep "- First, set the 'bak' bookmark to a dir!" if bm == "$bak"
+
+    unless bm.any?   # If no bookmark, just show error
+      View.beep
+      return View.message("Error: create a bookmark named 'bak' first, in a dir where you backups will go.")
+    end
+
+    path = Keys.prefix_u? ?
+      View.file :
+      FileTree.tree_path_or_this_file
+
+    name = path.sub(/.+\//, '')
+
+    # Copy file xx
+    $el.copy_file path, "#{bm}#{name}.#{Time.now.strftime('%Y-%m-%d.%H-%M')}"
+
+    message = "backed up to $bak: '#{name}'"
+    View.flash "- #{message}", :times=>3
+    View.message "Successfully #{message}"
+  end
+
+  def self.diff_with_backup
+
+    if Keys.prefix_u
+      $el.ediff_files Dir["#{Bookmarks['$bak']}#{View.file_name}*"].last, View.file
+      return
+    end
+
+    backup = Dir["#{Bookmarks['$bak']}#{View.file_name}*"].last
+
+    return View.beep("- No backup exists in $bak/") if ! backup
+
+    diff = Console.run "diff -U 0 \"#{backup}\" \"#{$el.buffer_file_name}\"", :sync=>true
+
+    return Launcher.show "- No Differences!" if diff.blank?
+
+    diff = DiffLog.format diff
+
+    View.to_buffer("*diff with saved*")
+    View.clear
+    Notes.mode
+
+    $el.insert diff.count("\n") > 2 ?
+      diff :
+      "| Alert\n- ~No Differences~\n"
+
+  end
+
+end
+History.setup_editedhistory

data/lib/image.rb

@@ -0,0 +1,51 @@
+require 'ftools'
+
+class Image
+  def self.menu_before *args
+    if args[-1] =~ /\.(png|gif|jpg)\/?$/
+      path = args.join('/')
+      Notes.enter_junior
+      Image << path
+      View.cursor = Line.right - 1
+      return false   # Tell it to not continue to menu
+    end
+  end
+
+  def self.menu
+    %`
+    .log/
+    docs/
+      > Show image underneath
+      @image//tmp/draw_rect.gif
+    api/
+      > Examples
+      | Insert an image:
+      @Image << "/tmp/draw_rect.gif"
+    `
+  end
+
+  def self.>> file, txt=nil
+    txt ||= "@img/#{file}"
+    Move.to_end
+    self.<< file, txt, :enter_junior=>1
+    Move.backward
+  end
+
+  def self.<< file, txt=nil, options={}
+    txt ||= "@img/#{file}"
+
+    # Copy to place with unique name, so a cached version doesn't get displayed...
+    tmp_dir = "/tmp/img_tmp/"
+    Dir.mkdir tmp_dir if ! File.directory? tmp_dir
+
+    # Copy to place with unique name, so a cached version doesn't get displayed.
+
+    unique_tmp_file = "#{tmp_dir}#{File.basename(file).sub /.+\./, "\\0#{rand(99999)}."}"
+
+    File.copy file, unique_tmp_file
+
+    Notes.enter_junior if options[:enter_junior]
+
+    $el.insert_image $el.create_image(unique_tmp_file), txt
+  end
+end

data/lib/incrementer.rb

@@ -0,0 +1,15 @@
+# Helps you to insert "1", "2", "3"....   Useful during macros.
+class Incrementer
+  def self.start
+    Clipboard['n'] = (Keys.prefix_n || 0).to_s
+  end
+
+  def self.increment
+    Clipboard['n'] = Clipboard['n'].next
+  end
+
+  def self.enter
+    self.increment if Keys.prefix_u
+    View.insert Clipboard['n']
+  end
+end

data/lib/insert.rb

@@ -0,0 +1,7 @@
+class Insert
+
+  def self.[] txt
+    View.insert txt
+  end
+
+end

data/lib/irc.rb

@@ -0,0 +1,22 @@
+class Irc
+
+  def self.menu
+    "
+    - .logon
+    - room (o): /j merb
+    - identify (o): /m nickserv IDENTIFY #{self.pw}
+    "
+  end
+
+  def self.logon
+    View.handle_bar
+    $el.el4r_lisp_eval "(erc :server \"irc.freenode.net\" :nick \"#{@@username}\")"
+  end
+
+  def self.username= to;  @@username = to;  end
+  def self.username;  @@username;  end
+
+  def self.pw;  @@pw;  end
+  def self.pw= to;  @@pw = to;  end
+
+end

data/lib/key_bindings.rb

@@ -0,0 +1,658 @@
+class KeyBindings
+
+  # Define all keys
+  def self.keys
+    Menu.init
+
+    self.as_keys
+    self.open_keys
+    self.enter_keys
+    self.to_keys
+    self.layout_keys
+    self.do_keys
+    self.isearch
+    self.misc
+
+    Keys.add_menu_items
+  end
+
+  def self.as_keys
+    # A: as...
+    # Use A prefix for: remembering, saving
+
+    Keys.AA { Line.to_left }   # AA - beginning of line (A's default)
+    Keys.as_bookmark { Bookmarks.save }   # remember bookmark
+    Keys.as_clipboard { Clipboard.as_clipboard }   #
+    #     Keys.as_directory { FileTree.copy_path }   # copy dir to clipboard from tree
+    Keys.as_delete { Launcher.as_delete }   # copy dir to clipboard from tree
+    Keys.as_everything { Clipboard.copy_everything }
+    Keys.as_file { DiffLog.save }   # save (or, with prefix, save as)
+    Keys.as_history { History.backup_file }   # creates backup
+    Keys.as_indented { CodeTree.as_indented }
+    Keys.as_job { Macros.record }   # start recording macro
+    Keys.as_kill { Clipboard.cut(0); Location.as_spot('killed') }   # cut)
+    Keys.as_line { Clipboard.as_line }
+    Keys.as_menu { Menu.as_menu }
+    Keys.as_nav { Notes.as_nav }
+    Keys.as_open { Launcher.as_open }   # copy object / symbol at point
+    Keys.as_paragraph { Clipboard.copy_paragraph }   # copy paragraph
+    Keys.as_quick { Bookmarks.save :q }   # like AB but uses different temporary namespace
+    Keys.as_rest { Clipboard.copy_paragraph(:rest => true) }
+    Keys.as_spot { Location.as_spot }   # remember point in file
+    Keys.as_todo { Notes.as_todo }
+    Keys.as_update { Launcher.as_update }
+    # U
+
+    # TODO: make this be as_variable?
+    # like:     Keys.as_name { Clipboard.copy }   # copies using key (prompted for)
+
+
+    Keys.as_variable { Clipboard.copy }   # Copy to variable
+
+
+    # Think of another key for backing it up?
+
+    Keys.as_window { View.save }   # remember window configuration as name
+    Keys.as_you { Clipboard.as_thing }   # copy object / symbol at point
+
+    # Y
+    # Z
+    #Keys.A0 { Clipboard.copy("0") }   # As 0: copy as key "0"
+    Keys.A1 { Clipboard.copy("1") }   # As 1
+    Keys.A2 { Clipboard.copy("2") };  Keys.A3 { Clipboard.copy("3") };  Keys.A4 { Clipboard.copy("4") }
+    Keys.A5 { Clipboard.copy("5") };  Keys.A6 { Clipboard.copy("6") };  Keys.A7 { Clipboard.copy("7") }
+  end
+
+  def self.open_keys
+    # O: open...
+    # Use O prefix for: opening, jumping to files
+
+    Keys.OO { $el.open_line $el.elvar.current_prefix_arg || 1 }   # OO - open line (O's default)
+    Keys.open_a_calendar { $el.calendar }
+    #Keys.OAD { Svn.jump_to_diff }
+    Keys.open_as_file { Code.open_as_file }
+    Keys.open_as_elisp { $el.find_function_at_point }   # jump to definition of lisp function
+    Keys.open_as_highest { FileTree.open_as_upper }
+    Keys.open_as_lowest { FileTree.open_as_upper(:lowest) }
+    Keys.open_as_utf { $el.revert_buffer_with_coding_system('utf-8'.to_sym) }
+    Keys.open_as_2 { FileTree.open_as_upper(:second) }
+    Keys.open_as_root { Files.open_sudo }
+    Keys.open_a_shell { Console.open }
+    Keys.open_as_tail { Files.open_tail }
+    Keys.open_bookmark { Bookmarks.go }
+    Keys.open_current { Launcher.open("- current/") }   # open buffer list
+    Keys.open_diffs { DiffLog.open }   # shows diffs of what you've edited
+    Keys.open_edited { Files.open_edited }   # show recently edited files
+    Keys.open_file { Files.open }
+    # G: leave unmapped for escape
+    Keys.open_history { Launcher.open("- files/history/") }   # show recently viewed files
+    Keys.open_in_browser { Browser.open_in_browser }
+    Keys.open_in_left { View.open_in_bar }
+    Keys.open_in_os { Files.open_in_os }
+    Keys.open_in_right { View.open_in_right }
+    Keys.open_in_window { Files.open_in_window }   # Expose file in OS folder
+    Keys.open_just { Files.open_just }
+    Keys.open_key { Keys.jump_to_code }   # jump to ruby code of key definition
+    Keys.open_list_appointments { View.bar; Launcher.open("- Agenda.menu/") }
+    Keys.open_list_bookmarks { Launcher.open("bookmarks/list/") }
+    Keys.open_list_clipboard { Launcher.open("clipboard/log/") }
+    #     Keys.open_last_error { Code.show_el4r_error }
+    Keys.open_list_faces { Styles.list_faces }
+    #     Keys.open_list_flashes { Launcher.open "- view/flashes/" }
+    #     Keys.open_list_faces { list_faces_display }
+    Keys.open_lisp_info { $el.info "elisp" }   # Open manual
+
+    #     Keys.open_log_list { Launcher.open(Keys.prefix_u ? "- last/" : "- log/") }   # Show git diffs o 1 file
+    Keys.open_log_list { Git.show_log_one_file }   # Show git diffs o 1 file
+
+    #     Keys.open_list_styles { list_faces_display }
+    Keys.open_last_output { Ol.open_last_output }   # Show git diffs for a bookmark
+    Keys.open_log_push { Gito.show_log }   # Show git diffs for a bookmark
+    Keys.open_last_screenshot { Files.open_last_screenshot }
+    #     Keys.open_like_text { txt = View.txt; View.to_buffer "txt"; View << txt }
+    #     Keys.open_log_tree { Rails.tree_from_log }
+    Keys.open_list_databases { Launcher.open('- Couch.databases/') }
+    #     Keys.open_list_models { Launcher.open("- Merb.models/") }
+    Keys.open_list_javascript { Launcher.open("- technologies/javascript/") }
+    Keys.open_list_names { Clipboard.list }
+    Keys.open_list_ruby { Launcher.open("- technologies/ruby/") }
+    Keys.open_list_technologies { Launcher.open("- technologies/") }   # open first hyperlink on page
+    Keys.open_last_urls { Launcher.open "- last/urls/" }
+    Keys.open_menu { Xiki.open_menu }   # Open all menus and show them
+    Keys.open_not_saved { Launcher.open("- history/unsaved files/") }
+    # O: defined above - mapped to what C-o does by default
+    Keys.open_point { Bookmarks.go(nil, :point => true) }
+    Keys.open_quick { Bookmarks.open_quick }   # like OB but uses different temporary namespace
+    Keys.open_related_test { Code.open_related_rspec }
+    Keys.open_related_file { Code.open_related_file }
+    Keys.open_repository_list { Gito.show_log_one_file }   # Show git diffs o 1 file
+    # S
+    Keys.open_search { Search.outline_search }   # hide search via outline
+    Keys.open_tree { FileTree.tree }   # draw a tree, prompting for bookmark tag
+    Keys.open_up { View.show_dir }   # open enclosing dir
+    Keys.open_visualize { Code.do_list_ancestors }   # show currently open files and buffers
+    Keys.open_windows { View.restore }   # open window configuration by name
+    Keys.open_xiki_docs { Help.display_docs }
+    Keys.open_xiki_help { Launcher.open("- Help.menu/") }   #
+    # Y
+    # Z
+
+    #     Keys.O0 {}   # Open 0: open bookmarked file tagged with "0"
+
+    Keys.O1 { Files.open_nth 1 };  Keys.O2 { Files.open_nth 2 };  Keys.O3 { Files.open_nth 3 };  Keys.O4 { Files.open_nth 4 };  Keys.O5 { Files.open_nth 5 }
+    Keys.O6 { Files.open_nth 6 };  Keys.O7 { Files.open_nth 7 };  Keys.O8 { Files.open_nth 8 };  Keys.O9 { Files.open_nth 9 }
+
+    Keys.O0 { View.open("$0") }   # Open 0: open bookmarked file tagged with "0"
+
+    Keys.O8 { History.open_current :all => true, :prompt_for_bookmark => true }   # Like do_outline, but inserts all
+  end
+
+  def self.enter_keys
+    # E: enter...
+    # Use E prefix for: inserting
+
+    # TODO find different word?
+    #   - Because "enter" can be confused with the enter key?
+    #   - ideas: embed, emit, entry
+    Keys.EE { Line.to_right }   # EE - end of line (E's default)
+    Keys.enter_all { Launcher.enter_all }
+    Keys.enter_bullet { Notes.bullet }
+    Keys.enter_clipboard { Clipboard.paste("0") }   # paste
+    Keys.enter_docs { Line.enter_docs }
+    # E: defined above - mapped to what C-e does by default
+    Keys.enter_file_path { Files.enter_file }   # Given a bookmark
+    Keys.enter_firefox_tabs { Launcher.insert('- Firefox.tabs/') }   # Given a bookmark
+    Keys.enter_history { DiffLog.enter_from_difflog }   # Save point and go to difflog to search
+    Keys.enter_insert_1 { Notes.enter_do_bullet }    # insert date string (and time if C-u)
+    Keys.enter_insert_date { View.enter_date }
+    Keys.enter_insert_comment { Code.enter_insert_comment }    # insert date string (and time if C-u)
+    Keys.enter_insert_new { DiffLog.enter_new }   # Enter Old: enter newly-deleted from last save
+    Keys.enter_insert_ruby { code = Keys.input(:prompt=>"Enter ruby code to eval and insert results: "); View.insert(eval(code).to_s)}
+    Keys.enter_insert_search { Search.enter_insert_search }
+
+    Keys.enter_insert_old { DiffLog.enter_old }   # Enter Old: enter newly-deleted from last save
+
+    Keys.enter_insert_words { PauseMeansSpace.go }
+    Keys.enter_junior { Notes.enter_junior }
+    Keys.enter_key { Keys.insert_code }
+    Keys.enter_last_commands {
+      bm = Keys.input(:timed => true, :prompt => "bookmark to show commands for (space for currently open): ")
+      return Launcher.insert("- Console.tree/") if bm == " "
+      Launcher.insert("- Console.history \"$#{bm}\"/")
+    }
+    Keys.enter_list_databases { Launcher.insert('- Couch.databases/') }
+    Keys.enter_like_edits { Search.enter_like_edits }
+    Keys.enter_log_javascript { Firefox.enter_log_javascript_line }
+    Keys.enter_log_stack { Code.enter_log_stack }
+    Keys.enter_log_line { Code.enter_log_line }
+    Keys.enter_log_output { Code.enter_log_output }
+    #     Keys.enter_last_log { Launcher.insert(Keys.prefix_u ? "- last/" : "- log/") }
+    #     Keys.enter_last_launched { Launcher.enter_last_launched }
+    Keys.enter_list_ruby { Launcher.insert("technologies/ruby/") }
+    #     Keys.enter_like_test { Specs.enter_as_rspec }
+    Keys.enter_log_time { Code.enter_log_time }
+    Keys.enter_like_url { Firefox.enter_as_url }
+    Keys.enter_like_variable { insert "\#{#{Clipboard.get(0)}}" }
+
+    Keys.enter_menu { Xiki.insert_menu }   # Redundant with C-enter on blank line
+    Keys.enter_note { Notes.enter_do_bullet }   # Redundant with C-enter on blank line
+    Keys.enter_outline { Launcher.enter_outline }   # in tree, enter methods or headings
+
+    Keys.enter_push { Gito.code_tree_diff(:enter=>true) }   # Commit to repos, push, etc
+    Keys.enter_quote { FileTree.enter_quote }
+    Keys.enter_row { View.insert_line }
+
+    #     Keys.enter_search { Search.enter_search }
+    Keys.enter_snippet { Snippet.insert }
+
+    #Keys.enter_spot { Location.enter_at_spot }   # enter selected text at spot
+    Keys.enter_tree { FileTree.tree(:here=>true) }
+    Keys.enter_upper { View.enter_upper }
+    Keys.enter_value { Clipboard.paste }
+    # W
+    Keys.enter_whitespace { Code.enter_whitespace }
+    # X
+    # Y
+    # Z
+    #Keys.E0 { Clipboard.paste("0") }   # Enter 0: paste from "0" tag
+    Keys.E1 { Clipboard.paste(1) }   # Enter 1
+    Keys.E2 { Clipboard.paste(2) }   # Enter 2
+    Keys.E3 { Clipboard.paste(3) }
+    Keys.E4 { Clipboard.paste(4) };   Keys.E5 { Clipboard.paste(5) };   Keys.E6 { Clipboard.paste(6) }
+    Keys.E7 { Clipboard.paste(7) };   Keys.E7 { Clipboard.paste(8) };   Keys.E7 { Clipboard.paste(9) }
+  end
+
+  def self.do_keys
+    # D: do...
+    # Use D prefix for: things that modify text or execute code
+
+    #     Keys.D { insert "Apparently this is necessary to remap C-d" }
+    Keys.DD { $el.delete_char $el.elvar.current_prefix_arg || 1 }   # DD - delete character (D's default)
+    #     Keys.do_as_camelcase { Clipboard.do_as_camel_case }   # change word to camel case (LikeThat)
+    Keys.do_as_execute { Console.do_as_execute }   # Run shell command on tree
+    Keys.do_as_html { Firefox.do_as_html }
+    Keys.do_as_browser { Firefox.run_block }
+    Keys.do_as_javascript { Javascript.run }
+    #     Keys.do_as_launched { Launcher.do_as_launched }
+    #     Keys.do_as_php { Php.run }
+    Keys.do_as_menu { Menu.do_as_menu }   # Grab item after '@' and run it by itself
+    Keys.do_as_python { Python.run_block }
+    # Do, take numeric prefix for before and after
+    Keys.do_add_space { Code.add_space }
+    Keys.do_as_test { Code.do_as_rspec }
+    Keys.do_as_wrap { Block.do_as_wrap }
+    Keys.do_as_quote { Notes.do_as_quote }
+    Keys.do_as_xul { Firefox.do_as_xul }
+    Keys.do_backward { $el.backward_kill_word(Keys.prefix || 1) }   # delete word backward
+    Keys.do_code_align { Code.do_code_align }   # Based on input character, all matches line up
+    Keys.do_click_back { Firefox.back }
+    Keys.do_create_directory { FileTree.do_create_dir }
+    # Keys.do_click_hyperlink { Firefox.click }   # compare with last AV version
+
+    Keys.do_current_file { Files.delete_current_file }
+
+    Keys.do_compare_history { History.diff_with_backup }   # compare with last AV version
+
+    Keys.do_code_indent { Code.indent }
+    Keys.do_count_matches {  View.count_matches }
+    Keys.do_copy_next { Files.copy }   # copy file to next view
+    Keys.do_colors_off { $el.font_lock_mode }   # toggles
+    Keys.do_clean_quotes { Files.do_clean_quotes }   # Fix special chars
+
+    Keys.do_compare_repository { Gito.diff_one_file }
+
+    Keys.do_compare_saved { DiffLog.compare_with_saved }
+
+    Keys.do_copy_to { FileTree.copy_to }
+    Keys.do_compare_with { DiffLog.do_compare_with }
+    Keys.DC1 { Clipboard.diff_1_and_2 }   # Compare contents of clipboards "1" and "2"
+    # D: defined above - mapped to what C-d does by default
+    Keys.do_expand { $el.dabbrev_expand nil }   # expand abbreviation
+    Keys.do_forward { $el.kill_word(Keys.prefix || 1) }   # delete word forward
+    # H
+    # G: leave unmapped for escape
+    Keys.do_here { Launcher.do_last_launch :here=>1 }
+    Keys.do_indent { Code.indent_to }
+    Keys.do_job { Macros.run }   # do last macro
+    Keys.do_kill_all { Effects.blink :what=>:all; View.kill_all }   # kill all text in buffer
+    Keys.do_kill_indented { CodeTree.do_kill_indented }  # Delete menu or file or whatever (just passes "0") prefix
+    Keys.do_kill_matching { Search.kill_filter }
+    Keys.do_kill_nonmatching { Search.kill_filter }
+    Keys.do_kill_paragraph { View.kill_paragraph }   # kill all text in buffer
+    Keys.do_kill_rest { CodeTree.kill_rest }   # kill adjacent lines at same indent as this one
+    Keys.do_kill_siblings { CodeTree.kill_siblings }   # kill adjacent lines at same indent as this one
+    Keys.do_kill_trailing { View.gsub!(/ +$/, "") }   # Deletes trailing whitespace
+    Keys.do_list_ancestors { View.beep "- Changed to: do+visibility!" }   # Moved to do+visibility
+    Keys.do_load_browser { Firefox.reload }
+    Keys.do_last_command { Console.do_last_command }
+    Keys.do_line_duplicate { Line.duplicate_line }
+    Keys.do_load_file { Files.do_load_file }   # U prefix will auto-update / auto-refresh to relflect changes
+    Keys.do_lines_having {   # delete lines matching a regex
+      unless $el.elvar.current_prefix_arg
+        delete_matching_lines( Keys.input(:prompt => "Delete lines having: ") )
+      else
+        delete_non_matching_lines( Keys.input(:prompt => "Delete lines not having: ") )
+      end
+    }
+    Keys.do_linebreaks_linux { $el.set_buffer_file_coding_system :unix }
+    Keys.do_line_next { Line.move :next }
+    Keys.do_lines_order { Line.do_lines_sort }
+    Keys.do_line_previous { Line.move(:previous) }
+    Keys.do_lines_reverse { $el.reverse_region($el.region_beginning, $el.region_end) }
+    Keys.do_lines_shuffle { Code.randomize_lines }   # Shuffle lines
+
+    Keys.do_lines_toggle { Line.do_lines_toggle }   # Swap next N lines
+
+    Keys.do_lines_unique { Code.kill_duplicates }   # Uniqify, delete duplicates
+    Keys.do_linebreaks_windows { $el.set_buffer_file_coding_system :dos }
+    Keys.do_move_to { FileTree.move_to }
+    Keys.do_name_buffer { Buffers.rename }
+    Keys.do_notes_colors { FileTree.apply_styles; Notes.apply_styles; FileTree.apply_styles_at_end }
+    Keys.do_number_enter { Incrementer.enter }
+    Keys.do_name_files { FileTree.rename_file }
+    Keys.do_number_increment { Incrementer.increment }
+    Keys.do_next_paragraph { Code.do_next_paragraph }   # Move line to start of next paragraph
+    Keys.do_number_start { Incrementer.start }
+    Keys.do_outline { History.open_current :outline=>true, :prompt_for_bookmark=>true }
+    Keys.do_push { Gito.code_tree_diff }   # Commit to repos, push, etc
+    Keys.do_query { Search.query_replace }   # do query replace
+    Keys.do_run { Code.run }   # run code as ruby
+    $el.define_key :global_map, $el.kbd("C-d C-s"), :cua_set_rectangle_mark   # Keys.do_several
+    Keys.do_tree { FileTree.tree(:recursive=>true) }   # draw filesystem tree for current dir or bookmark
+    Keys.do_upper { Launcher.do_last_launch }
+    Keys.do_viewing { Buffers.open_viewing }   # Not great fit here
+    Keys.do_whitespace { Deletes.delete_whitespace }   # delete blank lines
+    # X
+    Keys.do_you { $el.delete_char $el.elvar.current_prefix_arg || 1 }   # Delete character
+    Keys.do_zip_next { Files.zip }
+    Keys.set("C-d C-.") {   # Do .:  Go to point/bookmark starting with "." and run it (like pressing C-. on that line)
+      input = Keys.input(:timed => true)
+      $el.with(:save_window_excursion) do
+        Bookmarks.go(".#{input}")
+        Launcher.launch
+      end
+    }
+    Keys.set("C-d C-/") { Code.comment }
+
+    Keys.D1 { Search.query_replace_nth "1", "2" }
+    Keys.D2 { Search.query_replace_nth "2", "1" }
+    Keys.D3 { Search.query_replace_nth "3", "4" }
+    Keys.D4 { Search.query_replace_nth "4", "3" }
+
+  end
+
+  def self.to_keys
+    # T: to...
+    # Use T prefix for: moving cursor, jumping to specific points
+
+    $el.el4r_lisp_eval(%Q`(global-set-key (kbd "C-\'") \'repeat)`)
+
+    Keys.TT { $el.transpose_chars $el.elvar.current_prefix_arg }   # TT - toggle character (T's default)
+    Keys.to_axis { Move.to_axis }   # to beginning of file
+    Keys.to_backward { $el.backward_word(Keys.prefix || 1) }   # move backward one word
+    Keys.to_column { Move.to_column }   # to x coordinate - ie column
+    # D
+    Keys.to_end { Move.to_end }   # To end of line
+    Keys.to_forward { $el.forward_word(Keys.prefix || 1) }   # move forward one word
+    Keys.to_highest { View.to_highest }   # to beginning of file
+    Keys.to_indent { Move.to_indent }
+    Keys.to_junior { Move.to_junior }
+    Keys.to_kind { Move.to_other_bracket }   # to matching bracket, etc
+    Keys.to_lowest { View.to_bottom }   # move to end
+    Keys.to_menu { Menu.to_menu }   # to matching bracket, etc
+    Keys.to_next { Move.to_next_paragraph }   # to next paragraph
+    Keys.to_outline { FileTree.to_outline }
+    Keys.to_previous { Move.to_previous_paragraph }   # to beginning of previous paragraph
+    Keys.to_quote { Move.to_quote }   # move to next ...|... quote
+    Keys.to_row { Move.to_line }   # go to nth line, relative to top of window
+    Keys.to_spot { Location.to_spot }
+    # T: defined above - mapped to what C-t does by default
+    Keys.to_up { Tree.to_parent }   # to parent (last line indented less)
+    Keys.to_visible { View.to_relative }   # go to nth line, relative to top of window
+    Keys.to_words { Line.to_beginning }   # move to start of words on line
+    # X
+    # Z
+
+    Keys.T0 { View.to_nth_paragraph 0 }
+    Keys.T1 { View.to_nth_paragraph 1 }
+    Keys.T2 { View.to_nth_paragraph 2 }
+    Keys.T3 { View.to_nth_paragraph 3 }
+    Keys.T4 { View.to_nth_paragraph 4 }
+    Keys.T5 { View.to_nth_paragraph 5 }
+    Keys.T6 { View.to_nth_paragraph 6 }
+    Keys.T7 { View.to_nth_paragraph 7 }
+    Keys.T8 { View.to_nth_paragraph 8 }
+    Keys.T9 { View.to_nth_paragraph 9 }
+
+    Keys.set("C-t C-/") { Code.to_comment }
+
+  end
+
+  def self.layout_keys
+    # L: layout...
+    # Use L prefix for: adjusting the layout, changing what is visible
+
+    Keys.LL { View.recenter }   # LL - recenter (L's default)
+    Keys.layout_all { View.hide_others }
+    Keys.layout_balance { 3.times { View.balance } }   # balance windows
+    Keys.layout_create { View.create }   # open new view
+
+    Keys.layout_dimensions { Launcher.open('- window/dimensions/presets/', :bar_is_fine=>1, :first_letter=>1) }
+
+    Keys.layout_expand { View.enlarge }
+    # F
+    Keys.layout_files { View.layout_files }
+    Keys.layout_hide { View.hide }   #
+    Keys.layout_indent { Hide.hide_by_indent }   # only show lines indented less than x
+    Keys.layout_jump { View.shift }
+    Keys.layout_kill { View.kill }
+    # L: defined above - mapped to what C-d does by default
+    Keys.layout_marker { Color.colorize }   # colorize line, etc
+    Keys.layout_next { View.next(:blink=>true) }   # next view
+    Keys.layout_output { View.layout_output }
+    Keys.layout_previous { View.previous(:blink=>true) }
+    # Q
+    Keys.layout_right { View.to_upper(:blink=>true) }   # Go to view to the right
+    Keys.layout_search { Keys.prefix_u? ? Search.find_in_buffers(Keys.input(:prompt=>"Search all open files for: ")) : Hide.search }
+    Keys.layout_todo { View.layout_todo }   # show bar on left with the quick bookmark named "-t"
+    Keys.layout_uncover { Hide.reveal }   # Reveal all hidden text
+    # V
+    Keys.layout_visibility { Launcher.open('- window/visibility/', :bar_is_fine=>1, :first_letter=>1) }
+    Keys.layout_wrap { $el.toggle_truncate_lines }   # wrap lines
+    # X
+    # Y
+    Keys.layout_zoom { $el.narrow_to_region($el.region_beginning, $el.region_end) }   # show selection only
+    Keys.L0 { View.recenter_top }   # Layout 0: scroll so cursor is 0 lines from top af window
+    Keys.L1 { Move.to_window(1, :blink=>true) }   # Layout 1
+    Keys.L2 { Move.to_window(2, :blink=>true) }   # Layout 2
+    Keys.L3 { Move.to_window(3, :blink=>true) };  Keys.L4 { Move.to_window(4, :blink=>true) }
+    Keys.L5 { Move.to_window(5, :blink=>true) };  Keys.L6 { Move.to_window(6, :blink=>true) };  Keys.L7 { Move.to_window(7, :blink=>true) };  Keys.L8 { Move.to_window(8, :blink=>true) }
+    Keys.L9 { Move.to_last_window(:blink=>true) }
+
+    # Todo: if prefix passed, expand window, but leave other windows open with that much space in each
+    #    Keys.LCR { Colors.highlight  }   # Layout Tree: show bar on left with the quick bookmark named "-t"
+
+    # Todo:
+    # - Make it recognize :n when opening
+    #   - If you put it at end of path or as tree node, it should make it into path
+    #     - So look at it when opening path and optionally jump
+    #  - narrow block to region:
+  end
+
+  # Control keys during isearch
+  def self.isearch
+    Keys.search_axis { Search.to_left }
+    Keys.search_bookmark { Search.bookmark }
+    # B: leave unmapped for back
+
+    Keys.search_clipboard { Search.isearch_clipboard }   # Clipboard (copy)
+
+    Keys.search_delete { Search.isearch_delete }   # Delete
+    Keys.search_enter { Search.enter }   # Enter: insert clipboard, replacing match
+    Keys.search_frontward { Search.go_to_end }   # Forward
+    Keys.search_g { Search.cancel }   # Stop searching
+    # have_...
+    $el.define_key :isearch_mode_map, $el.kbd("C-h"), nil
+    Keys.search_have_append { Search.isearch_move_to "$t", :append=>1 }
+    Keys.search_have_bullet { Search.have_label }
+    Keys.search_have_case { Search.isearch_have_case }
+    Keys.search_have_edges { Search.just_edges }   # Delete everything but chars at edges of match
+    Keys.search_have_files { View.beep "- Changed to: search+have+navigation!" }
+    Keys.search_have_highest { Search.isearch_restart :top }
+    Keys.search_have_javascript { Search.isearch_have_output_javascript }
+    Keys.search_have_line { Search.have_line }   # copy line back to search start
+    Keys.search_have_nav { Search.isearch_move_to "$f" }
+
+    Keys.search_have_output { Search.isearch_have_output }
+    Keys.search_have_push { Gito.search_just_push }   # When search match
+
+    Keys.search_have_right { Search.have_right }
+    Keys.search_have_spot { Search.insert_at_spot }
+    Keys.search_have_todo { Search.isearch_move_to "$t" }
+    Keys.search_have_variable { Search.insert_var_at_search_start }
+    Keys.search_have_within { Search.isearch_have_within }   # Grab everything except chars on edges
+
+    # AVAILABLE: search_i ?  (when nothing searched for)
+
+    # I: leave unmapped - had issues using it (messes up position)
+    # just_...
+    $el.define_key :isearch_mode_map, $el.kbd("C-j"), nil
+    Keys.search_just_adjust { Search.isearch_just_adjust }
+    Keys.search_just_bookmark { Search.just_bookmark }
+    Keys.search_just_case { Search.isearch_just_case }   # make match be camel case
+    Keys.search_just_difflog { Search.jump_to_difflog }   # find last string in difflog
+    Keys.search_just_edits { Search.just_edits }   # Search in diff of edits to this file
+    Keys.search_just_files { Search.isearch_restart "$f" }   # isearch for this string in $f
+    Keys.search_just_have { Search.just_select }   # select match
+    Keys.search_just_integer { Search.stop; Search.isearch "[0-9][0-9.]*", :regex=>1 }
+
+    Keys.search_just_menu { Search.just_menu }
+    #     Keys.search_just_mark { Search.just_marker }
+    Keys.search_just_next { Search.isearch_restart :next }
+    Keys.search_just_output { Search.isearch_restart "$o" }
+    Keys.search_just_previous { Search.isearch_restart :previous }
+    Keys.search_just_query { Search.isearch_query_replace :match }   # replace
+    Keys.search_just_right { Search.isearch_restart :right }   # Search in top-right view
+    Keys.search_just_search { Search.isearch_just_search }   # Add "##search" line in tree for match
+    Keys.search_just_todo { Search.isearch_restart "$t" }   # isearch for this string in $t
+
+    Keys.search_just_variable { Search.isearch_just_surround_with_char '#{', '}' }
+    Keys.search_just_wrap { Ol << 'search_just_wrap';  toggle_truncate_lines }   # make match be snake case
+
+    Keys.search_just_yellow { Search.just_orange }
+    Keys.search_kill { Search.cut }   # cut
+
+    $el.define_key :isearch_mode_map, $el.kbd("C-l"), nil
+
+    Keys.search_like_clipboard {
+      reverse = Search.was_reverse
+      match = Search.stop
+      Search.isearch Clipboard[0], :reverse=>reverse
+    }   # make match be camel case
+    Keys.search_like_delete { Search.like_delete }   # Delete all lines that contain the match
+    Keys.search_like_file { Search.isearch_open }
+    Keys.search_like_menu { Launcher.search_like_menu }
+    Keys.search_like_output { Search.isearch_have_output :string=>1 }
+    Keys.search_line_pull { Search.isearch_move_line }
+    Keys.search_like_quote { Search.isearch_google :quote=>true }
+    Keys.search_like_repository { Gito.search_repository }   # When not searching
+
+    Keys.search_like_synonyms { Search.search_thesaurus }
+    #     Keys.search_like_timer { Search.search_like_timer }
+
+    #     Keys.search_like_thesaurus { Search.search_thesaurus }
+    Keys.search_last_urls { Launcher.open("- Launcher.urls/") }
+    Keys.search_like_variable { Search.just_name }
+    Keys.search_like_web { Search.isearch_google }   # make match be snake case
+    Keys.search_like_xiki { View.open "$x/#{Search.stop.strip}" }
+
+    # Use search_navigated instead
+    #     Keys.search_last_launched { Search.search_last_launched }
+    #     Keys.search_log { Search.search_log }
+    # M: leave unmapped for stop
+    Keys.search_next { Search.isearch_next }   # Next, or navigated (if nothing searched for yet)
+    Keys.search_outline { Search.isearch_outline }   # Outline
+    Keys.search_paths { Search.isearch_paths }   # Just go to previous line
+    # P: leave unmapped for previous
+    # Q: leave unmapped for quoting
+    # R: leave unmapped for reverse
+    # S: leave unmapped for search
+    Keys.search_to { Search.isearch_to }   # To: open file / jump to method
+    Keys.search_usurp { Search.isearch_pull_in_sexp }   # usurp: pull sexp into search string
+    Keys.search_value { Search.insert_at_search_start }   # Value: copy value back to search start
+    # W: leave unmapped for pulling into search
+
+    Keys.search_xiki { Search.xiki }   # search+xiki+__ mapped inside this method
+
+
+    # Y: leave unmapped for yank
+    Keys.search_zap { Search.zap }   # zap - delete up until search start
+
+    # Surround with characters (quotes and brackets)
+
+    $el.define_key(:isearch_mode_map, $el.kbd("C-'")) { Search.isearch_just_surround_with_char '"' }
+    $el.define_key(:isearch_mode_map, $el.kbd("C-j C-'")) { Search.isearch_just_surround_with_char "'" }
+
+    $el.define_key(:isearch_mode_map, $el.kbd("C-j C-,")) { Search.isearch_surround_with_tag }
+
+    $el.define_key(:isearch_mode_map, $el.kbd("C-j C-SPC")) { Search.isearch_just_surround_with_char " " }
+
+    $el.define_key(:isearch_mode_map, $el.kbd("C-`")) { Search.isearch_just_surround_with_char "~" }
+
+    $el.define_key(:isearch_mode_map, $el.kbd("C-j C-/")) { Search.isearch_just_comment }
+    $el.define_key(:isearch_mode_map, $el.kbd("C-j C-=")) { Search.just_increment }
+    $el.define_key(:isearch_mode_map, $el.kbd("C-j C--")) { Search.just_increment(:decrement=>true) }
+
+    $el.define_key(:isearch_mode_map, $el.kbd("C-9")) { Search.isearch_just_surround_with_char '(', ')' }
+    $el.define_key(:isearch_mode_map, $el.kbd("C-j C-9")) { Search.isearch_just_surround_with_char '[', ']'}
+
+    $el.define_key(:isearch_mode_map, $el.kbd("C-h C-[")) { Search.isearch_just_surround_with_char '[', ']' }
+    $el.define_key(:isearch_mode_map, $el.kbd("C-j C-[")) { Search.isearch_just_surround_with_char '{', '}' }
+
+    $el.define_key(:isearch_mode_map, $el.kbd("C-h C-'")) { Search.insert_quote_at_search_start }
+
+    $el.define_key(:isearch_mode_map, $el.kbd("C-j C-1")) { Search.enter(Clipboard[1]) }   # isearch_just_1
+    $el.define_key(:isearch_mode_map, $el.kbd("C-j C-2")) { Search.enter(Clipboard[2]) }   # isearch_just_2
+    $el.define_key(:isearch_mode_map, $el.kbd("C-j C-3")) { Search.enter(Clipboard[3]) }   # isearch_just_3
+    $el.define_key(:isearch_mode_map, $el.kbd("C-h C-1")) { Search.isearch_query_replace Clipboard[1] }
+    $el.define_key(:isearch_mode_map, $el.kbd("C-h C-2")) { Search.isearch_query_replace Clipboard[2] }
+
+
+    $el.define_key(:isearch_mode_map, $el.kbd("C-h C-0")) { Search.isearch_query_replace Clipboard[0] }
+
+    $el.define_key(:isearch_mode_map, $el.kbd("C-1")) { Search.isearch_or_copy("1") }
+    $el.define_key(:isearch_mode_map, $el.kbd("C-2")) { Search.isearch_or_copy("2") }
+    $el.define_key(:isearch_mode_map, $el.kbd("C-3")) { Search.isearch_or_copy("3") }
+    $el.define_key(:isearch_mode_map, $el.kbd("C-4")) { Search.isearch_or_copy("4") }
+    $el.define_key(:isearch_mode_map, $el.kbd("C-5")) { Search.isearch_or_copy("5") }
+    $el.define_key(:isearch_mode_map, $el.kbd("C-6")) { Search.isearch_or_copy("6") }
+    $el.define_key(:isearch_mode_map, $el.kbd("C-7")) { Search.isearch_or_copy("7") }
+    $el.define_key(:isearch_mode_map, $el.kbd("C-8")) { Search.isearch_or_copy("8") }
+
+    $el.define_key(:isearch_mode_map, $el.kbd("C-=")) { $el.isearch_yank_char }   # Add one char from isearch
+    $el.define_key(:isearch_mode_map, $el.kbd("C--")) { Search.subtract }   # Remove one char from isearch
+    $el.define_key(:isearch_mode_map, $el.kbd("C-/")) { $el.isearch_delete_char }   # Remove last action from search results
+    $el.define_key(:isearch_mode_map, $el.kbd("C-,")) { Search.isearch_query_replace }   # Replace all occurrences
+
+    $el.define_key(:isearch_mode_map, $el.kbd("C-\\")) { Search.hide }   # Hide: hide non-matching
+
+    $el.define_key(:isearch_mode_map, $el.kbd("C-0")) { Search.isearch_pause_or_resume }   # isearch_just_0
+
+    # Safe mapping of C-m to Search.isearch_m (works when el4r is down)
+    $el.el4r_lisp_eval(%`(defun isearch-m () (interactive)
+      (if (eq (process-status el4r-process) 'run) (el4r-ruby-eval "Search.isearch_m") (isearch-exit)))
+      `.unindent)
+    $el.define_key :isearch_mode_map, $el.kbd("C-m"), :isearch_m   # Hide: hide non-matching
+
+  end
+
+  def self.misc
+
+    $el.define_key :global_map, $el.kbd("C-S-v"), :scroll_down
+
+    # Single character definitions
+    Keys.B { Move.backward }
+    Keys.F { Move.forward }
+    Keys.Q { Keys.timed_insert }
+    Keys.set("C-.") { Launcher.launch_or_hide(:blink=>true) }
+
+    # Alternate key for C-. (probably easier to remember)
+    Keys.set("<C-return>") { Launcher.launch_or_hide(:blink=>true) }
+    Keys.set("<M-return>") { Launcher.launch_or_hide(:blink=>true) }
+
+    if $el.locate_library "ruby-mode"
+      $el.el_require :ruby_mode
+      $el.define_key :ruby_mode_map, $el.kbd("C-\\") do
+        Hide.show
+        Hide.hide_unless /^ *(def|class|module|create_table|it|describe) /
+        $el.recenter -2
+        Hide.search
+      end
+    end
+    $el.el_require :cc_mode
+
+    # Unmap keys in modes that interfere
+    $el.el4r_lisp_eval("(require 'shell)")
+    $el.define_key :shell_mode_map, $el.kbd("C-d"), nil   # shell-mode etc. special C-d shortcuts over-ride xiki
+    $el.define_key :objc_mode_map, $el.kbd("C-d"), nil
+    $el.define_key :c_mode_map, $el.kbd("C-d"), nil
+    $el.el4r_lisp_eval("(require 'dired)")
+    $el.define_key :dired_mode_map, $el.kbd("C-o"), nil
+    $el.define_key :java_mode_map, $el.kbd("C-d"), nil
+    $el.el_require :php_mode
+    $el.define_key :php_mode_map, $el.kbd("C-d"), nil
+
+    # C-l in ediff mode
+    $el.defun(:ediff_disable_C_l) { $el.define_key(:ediff_mode_map, $el.kbd("C-l"), nil) }
+    $el.add_hook :ediff_keymap_setup_hook, :ediff_disable_C_l
+
+    ControlTab.keys
+
+    Keys.set("M-0") { Styles.font_size 120 }
+    Keys.set("M-=") { Styles.zoom }
+    Keys.set("M--") { Styles.zoom :out=>1 }
+
+    View.sensible_defaults
+  end
+
+end