marcshacks.el - marcshacks - Collection of emacs lisp and python scripts

Source path: hg/ elisp/ personal/ marcshacks.el

‹e06ee22f554b

155fca28eeeb

;; fat@svn110
;;;;;;;;;;;;;;;;;;;;;;;
;; font & appearance ;;
;;;;;;;;;;;;;;;;;;;;;;;

(defface red-face
  '((((class color) (background dark))
     (:foreground "red" )))
  "red face..")

(split-window-horizontally)
(balance-windows)
(setq user-full-name "Marc Belmont")
(scroll-bar-mode nil)
(menu-bar-mode 0)
(tool-bar-mode -1)

;;;;;;;;;;;;;;;
;; Utilities ;;
;;;;;;;;;;;;;;;

(defun char-in (c str)
  "Check if char at point is in str"
  (not (string= (remove-if-not (lambda (x) (= x c)) str) "")))

(defun shell-send (&rest commands)
  (interactive)
  (let ((buffer (get-buffer "*shell*")))
    (if (not buffer) (shell))
    (mapc (lambda (x)
	    (comint-send-string (get-buffer-process buffer)
				(format "%s\n" x)))
	  commands)))

(defun modes-enabled()
  (mode-match ".*\\(ython\\|isp\\|css\\|ava\\|script\\|presso\\|php\\|html\\|uareg\\|xml\\|tcl\\).*"))
(defun tokensep()
  "[^_a-zA-Z0-9éè-]")

(defun select-region(tokens)
  (re-search-forward tokens nil t 1)
  (goto-char (- (point) 1))
  (set-mark (point))
  (re-search-backward tokens nil t 1)
  (goto-char (+ (point) 1))
  (not (eq (point) (mark))))

(defun concat-commands (base &rest commands)
  (concat base " " (mapconcat (lambda (x) x) commands "; ")))

;;;;;;;;;;;;;;
;; settings ;;
;;;;;;;;;;;;;;

;; modes
(autoload 'apache-mode "apache-mode" nil t)
(add-to-list 'auto-mode-alist '("\\.htaccess\\'"   . apache-mode))
(add-to-list 'auto-mode-alist '("httpd\\.conf\\'"  . apache-mode))
(add-to-list 'auto-mode-alist '("srm\\.conf\\'"    . apache-mode))
(add-to-list 'auto-mode-alist '("access\\.conf\\'" . apache-mode))
(add-to-list 'auto-mode-alist '("sites-\\(available\\|enabled\\)/" . apache-mode))
(require 'nginx-mode)

(autoload 'prices-mode "prices-mode" "Prices mode." t)
(autoload 'php-mode "php-mode" "Major mode for editing php code." t)
(add-to-list 'auto-mode-alist '("\\.php$" . php-mode))
(autoload 'diff-mode- "diff-mode-" "enhanced diff mode" t)

(autoload 'goto-last-change "goto-last-change" "Set point to the position of the last change." t)
(global-set-key [C-f12] 'goto-last-change)
(global-set-key
 [f12] (lambda () (interactive)
	 (if mark-active (kill-ring-save (point) (mark)) (undo))))

(autoload 'ini-mode "ini-mode" "Major Mode for editing ini files" t)
(setq ahk-syntax-directory "c:/Program Files/AutoHotkey/Extras/Editors/Syntax/")
(add-to-list 'auto-mode-alist '("\\.ahk$" . ahk-mode))
(autoload 'ahk-mode "ahk-mode")
(load "ani-fcsh.el")

(autoload 'clojure-mode "clojure-mode" "A major mode for Clojure" t)
(add-to-list 'auto-mode-alist '("\\.clj$" . clojure-mode))

;; comint
(defun comint-show-in-minibuffer (string)
  "Display the beginning of the comint output in the minibuffer"
  (when (not (get-buffer-process (window-buffer)))
    (message (let ((s (mapconcat (lambda (x) x)
				 (butlast (split-string string "\n")) "\n"))
		   (size 256))
	       (if (> (string-width s) size)
		   (concat (substring s 0 size) "...")
		 (substring s 0))))))
(add-hook 'comint-output-filter-functions 'comint-show-in-minibuffer)

(require 'moz)
(autoload 'actionscript-mode "actionscript-mode" "actionscript-mode" t)

;; python
(autoload 'python-mode "python-mode" "Python editing mode." t)
(add-hook 'python-mode-hook
          (lambda () (font-lock-add-keywords
                      nil '(("=" . 'red-face)))))

;; yaml
(require 'yaml-mode)
(add-to-list 'auto-mode-alist '("\\.yml$" . yaml-mode))
(add-hook 'yaml-mode-hook
	  '(lambda ()
	     (define-key yaml-mode-map "\C-m" 'newline-and-indent)))

;; css
(defvar hexcolour-keywords
  '(("#[a-f[:digit:]]\\{3,6\\}"
     (0 (put-text-property
	 (match-beginning 0)
	 (+ 1 (match-beginning 0))
	 ;; (match-end 0)
	 'face (list :background (match-string-no-properties 0)
		     :foreground (match-string-no-properties 0)))))))

(defun hexcolour-add-to-font-lock ()
  (font-lock-add-keywords nil hexcolour-keywords))
(add-hook 'css-mode-hook 'hexcolour-add-to-font-lock)

;; java
(add-hook 'java-mode-hook (lambda ()
                            (setq c-basic-offset 2
                                  tab-width 2
                                  indent-tabs-mode t)))

;; tcl
(eval-after-load "Tcl"
  '(progn
     (define-key tcl-mode-map "\C-c\C-c"
       (lambda () (interactive)
	 (save-buffer (current-buffer))
	 (tcl-load-file (buffer-file-name))))))

;; javascript
(eval-after-load "js"
  '(progn
     (define-key js-mode-map ";"
       (lambda () (interactive)
	 (if (or (string-equal (save-excursion (end-of-line) (char-to-string (char-before (point)))) ";")
		 (= (point) (save-excursion (end-of-line) (point))))
	     (insert ";")
	   (save-excursion (end-of-line) (insert ";")))))))

;; org
(add-to-list 'auto-mode-alist '("\\.org$" . org-mode))
(autoload 'org-mode "org" "Org mode" t)
(autoload 'org-diary "org" "Diary entries from Org mode")
(autoload 'org-agenda "org" "Multi-file agenda from Org mode" t)
(autoload 'org-store-link "org" "Store a link to the current location" t)
(autoload 'orgtbl-mode "org" "Org tables as a minor mode" t)
(setq org-hide-leading-stars t)
(autoload 'turn-on-orgtbl "org" "Org tables as a minor mode")

(setq org-log-done 'time)
(setq org-clock-modeline-total 'today)
(setq org-clock-idle-time 10)
(setq org-highlight-sparse-tree-matches nil)
(add-hook 'org-mode-hook
	  '(lambda ()
             (set (make-local-variable 'autopair-pair-criteria) 'always)
             (set (make-local-variable 'autopair-skip-criteria) 'always)))

(defun org-time-delta-seconds (time-string seconds)
  (format-time-string
   "%Y-%m-%d"
   (seconds-to-time
    (+ (org-float-time (apply 'encode-time
			      (org-parse-time-string time-string)))
       seconds))))
(defun get-day-time-string (time-string)
  (format-time-string
   "%u"
   (seconds-to-time
    (org-float-time
     (apply 'encode-time (org-parse-time-string time-string))))))

(defun org-list-clocks-current-item (check-n-days)
  "Extract clocked hours per day of current item"
  (save-restriction
    (org-narrow-to-subtree)
    (let* ((next-day-secs (* 3600 25))
	   (ts (format-time-string "%Y-%m-%d" (seconds-to-time (- (org-float-time (current-time)) (* check-n-days 3600 24)))))
	   (te (org-time-delta-seconds ts next-day-secs))
	   (res '())
	   (dates '()))
      (while (< (org-float-time
		 (apply 'encode-time (org-parse-time-string ts)))
		(org-float-time (current-time)))
	(org-clock-sum ts te) ; slow
	(setq res (cons (/ org-clock-file-total-minutes 60.0) res)
	      dates (cons (if (equal (get-day-time-string ts) "1")
			      "M"
			    (substring ts 8 10)) dates)
	      ts te
	      te (org-time-delta-seconds ts next-day-secs)))
      (list dates res))))

(defun org-chart-clocks-current-item ()
  "Request a Google Chart with the clocked time of the current item."
  (interactive)
  (let* ((x (org-list-clocks-current-item 40))
	 (dates (reverse (car x)))
	 (res (reverse (cadr x)))
	 (active-days (length (remove-if (lambda (x) (= x 0)) res)))
	 (sum-hours (reduce (lambda (a b) (+ a b)) res)))
    (browse-url (format "http://chart.apis.google.com/chart?chxl=1:|%s&chxr=0,0,8|1,0,105&chxt=y,x&chbh=15&chs=1000x300&cht=bvg&chco=80C65A&chds=0,8&chd=t:%s&chg=0,12.5&chma=|5,10&chtt=Clocked+Activity+(%d+days,+%d+hours)&chm=h,FF0000,0,%f,1"
			(mapconcat (lambda (x) x) dates "|")
			(mapconcat (lambda (x) (format "%s" x)) res  ",")
			active-days
			sum-hours
			(/ sum-hours active-days 8)))))

(eval-after-load "org"
  '(progn
     (define-key org-mode-map "\C-p" 'org-show-todo-tree)
     (define-key org-mode-map "\C-t"
       '(lambda () (interactive)
	  (if (org-clock-is-active) (org-clock-out) (org-clock-in))))
     (define-key org-mode-map "\C-c\C-xt" 'org-timeline)
     (define-key org-mode-map [f4] 'org-chart-clocks-current-item)
     (define-key org-mode-map "\C-c\C-xd"
       '(lambda () (interactive) (org-tags-sparse-tree nil "CLOCK>=\"<-1d>\"")))
     (define-key org-mode-map "\C-c\C-xw"
       '(lambda () (interactive) (org-tags-sparse-tree nil "CLOCK>=\"<-1w>\"")))))

;; uniquify
(require 'uniquify)
(setq
 uniquify-buffer-name-style 'post-forward
 uniquify-separator ":")

;; autopair
;; (require 'autopair)
(load "autopair.el")
(autopair-global-mode)
(setq autopair-autowrap t)
(add-hook 'sldb-mode-hook
	  #'(lambda () (setq autopair-dont-activate t)))
(add-hook 'css-mode-hook
	  #'(lambda () (setq autopair-dont-activate t)))
(put 'autopair-insert-opening 'delete-selection t)
(put 'autopair-skip-close-maybe 'delete-selection t)
(put 'autopair-insert-or-skip-quote 'delete-selection t)
(put 'autopair-extra-insert-opening 'delete-selection t)
(put 'autopair-extra-skip-close-maybe 'delete-selection t)
(put 'autopair-backspace 'delete-selection 'supersede)
(put 'autopair-newline 'delete-selection t)

;; anything
(require 'anything)
(require 'anything-config)
(setq anything-sources
      '(anything-c-source-occur
	anything-c-source-fixme
	anything-c-source-kill-ring
	anything-c-source-emacs-variables))

;; buggy
(remove-hook 'kill-emacs-hook 'anything-c-adaptive-save-history)
(global-set-key [f2] 'anything)

;; yasnippet
(require 'yasnippet-bundle)
(require 'yasnippet-config)
(load "yasnippet-perso.el")


;; associations
(setq auto-mode-alist
      (append '(
                ("\\.\\(xml\\|xsl\\|rng\\|xhtml\\|ctp\\|xul\\|htm\\|html\\|rdf\\|config\\|thtml\\|component\\)\\'" . html-mode)
                ("\\.js$" . javascript-mode)
                ("\\.as$" . actionscript-mode)
                ("\\.py$" . python-mode)
                ("\\.ml[ily]?$" . tuareg-mode)
                ("\\.topml$" . tuareg-mode)
                ("\\.\\(ini\\|init\\|cfg\\)\\'" . ini-mode)
                ) auto-mode-alist))
(setq interpreter-mode-alist
      (cons '("python" . python-mode) interpreter-mode-alist))

;; vc

;; hg incoming
(defun vc-hg-incoming () (interactive)
  "Don't show the buffer if no changes were found"
  (let ((bname "*Hg incoming*"))
    (if (= 0 (vc-hg-command bname t nil "incoming" "-n"))
	(pop-to-buffer bname)
      (message "No incoming changes found"))))

;; hook to pull and push on log-edit
(defun vc-before-checkin-do ()
  (interactive)
  (when (eq 'Hg (vc-backend (buffer-file-name)))
    (vc-hg-incoming)))
(add-hook 'vc-before-checkin-hook 'vc-before-checkin-do)

(defun hg-after-commit ()
  (interactive)
  (when (eq 'Hg (vc-backend (if (buffer-file-name)
				(buffer-file-name)
			      (car (vc-dir-marked-files)))))
    (message "Pushing changes...")
    (vc-hg-command "*Hg outgoing*" t nil "push")))
(add-hook 'vc-checkin-hook 'hg-after-commit)

(setq diff-point 1)
(defun diff-points (&optional show-diff)
  (interactive)
  (let ((hasdiff t)
	(origine (buffer-name (current-buffer)))
	(buffer-diff (get-buffer "*vc-diff*")))
    (if (string-equal origine "*vc-diff*")
	(progn (quit-window) (other-window 1))
      (save-some-buffers t)
      (when (or (not buffer-diff)
		(not (save-excursion (set-buffer buffer-diff) (beginning-of-buffer) (re-search-forward origine nil t 1))))
	(setq diff-point 1))
      (setq hasdiff (vc-diff nil))
      (when hasdiff
	(quit-window)
	(other-window 1))
      (when hasdiff
	(set-buffer "*vc-diff*")
	(goto-char diff-point)
	(when (null (re-search-forward "^@@ " nil t 1))
	  (beginning-of-buffer)
	  (re-search-forward "^@@ " nil t 1))
	(forward-line 4)
	(setq diff-point (point))
	(diff-goto-source)
	(when show-diff
	  (switch-to-buffer-other-window "*vc-diff*")
	  (goto-char diff-point)
	  (other-window 1))))))

(global-set-key [f6] '(lambda () (interactive) (diff-points t)))
(global-set-key [f9] 'diff-points)

(global-set-key [C-f6] '(lambda () (interactive)
			  (save-some-buffers t)
			  (if (get-buffer "*vc-dir*")
			      (progn
				(switch-to-buffer-other-window "*vc-dir*")
				(revert-buffer))
			    (call-interactively 'vc-dir))))

;; eshell
(setq eshell-prompt-function
      (lambda ()
        (concat (eshell/pwd)
                (format-time-string ", %d %H:%M" (current-time))
                (if (= (user-uid) 0) "# " "$ ")
		"\n")))
(global-set-key [M-f5]
		'(lambda ()(interactive)
		   (if (string-equal (buffer-name (current-buffer))
				     "*eshell*")

		       (rename-buffer (concat "*eshell-" (car (last (butlast (split-string default-directory "/")))) "*") 1)
		     (eshell))))

(eval-after-load "shell"
  '(define-key shell-mode-map
     [return] '(lambda () (interactive)
		 (if (= (line-number-at-pos (point))
			(save-excursion (end-of-buffer)
					(line-number-at-pos (point))))
		     (progn
		       (when (=  (char-before (- (point) 1)) 36)
			 (comint-previous-input 1)
			 (save-some-buffers t))
		       (comint-send-input))
		   (newline)))))

;; ido
(ido-mode t)
(require 'smex)
(eval-after-load "smex" '(smex-initialize))
(global-set-key [f7] 'smex-update-and-run)
(global-set-key "\M-x" 'smex-update-and-run)
(setq ido-enable-flex-matching t)

;; world time
(setq display-time-world-list '(
				("America/Los_Angeles" "LA")
				("America/Bogota" "Quito")
				("America/New_York" "New York")
				("Europe/Paris" "Paris")
				("CST-8" "Beijing")
				("Australia/Melbourne" "Melbourne")
				))
(setq display-time-world-time-format "%A %B %d\t %T %Z\n")
(global-set-key "\M-W" 'display-time-world)

;; random settings
(prefer-coding-system 'utf-8)
(setq calendar-week-start-day 1)
(global-auto-revert-mode 1)
(desktop-save-mode 1)

(run-with-timer 10 3600 '(lambda () (desktop-save desktop-dirname)))
(add-to-list 'desktop-globals-to-save 'file-name-history)
(setq history-length 250)
(winner-mode t)
(put 'scroll-left 'disabled nil)
(global-font-lock-mode t)
(setq truncate-partial-width-windows nil)
(setq-default truncate-lines nil)
(setq inhibit-startup-message t)
(setq frame-title-format
      '("     %b" "      |      "
	global-mode-string "      |      "
	default-directory "      |      "
	"emacs " emacs-version))
(setq font-lock-maximum-decoration t)
(show-paren-mode t)
(delete-selection-mode t)
(line-number-mode t)
(setq display-time-24hr-format t)
(auto-compression-mode t)
(mouse-wheel-mode t)
(fset 'yes-or-no-p 'y-or-n-p)
(setq default-major-mode 'text-mode)
(setq ring-bell-function 'ignore)
(setq make-backup-files nil)
(add-hook 'write-file-hooks 'delete-trailing-whitespace)
(setq delete-auto-save-files t)
(setq delete-old-versions t)
(setq next-line-add-newlines nil)
(c-set-offset 'substatement-open 0)
(c-set-offset 'case-label '+)
(column-number-mode t)
(global-hl-line-mode t)

(setq x-select-enable-clipboard t)
(setq interprogram-paste-function 'x-cut-buffer-or-selection-value)

;;;;;;;;;;;;;
;; Yanking ;;
;;;;;;;;;;;;;

;; comment stuffs
(defun comment-uncomment()
  "Comments out current line."
  (interactive)
  (if (equal mark-active nil)
      (progn
        (beginning-of-line)
        (re-search-forward "[^\t \r]")
        (goto-char (- (point) 1))
        (comment-or-uncomment-region (point) (+ 1 (line-end-position)))
        (forward-line 1))
    (comment-or-uncomment-region (region-beginning) (region-end))
    (indent-for-tab-command)))
(global-set-key "\M-0" 'comment-uncomment)
(global-set-key "\C-cb" '(lambda () (interactive) (beginning-of-line) (set-mark (point)) (end-of-line) (comment-box (mark) (point) 1)))

(defmacro line-length()
  "Length of a line in number of characters"
  (length (buffer-substring (save-excursion (beginning-of-line) (point))
                            (save-excursion (end-of-line) (point)))))

(defun cut-block()
  "Cut what's inside a region delimited by {([<"
  (re-search-backward "[({[<]" nil t 1)
  (setq symb (char-to-string (char-after (point))))
  (if (equal symb "(")
      (setq nsymb ")"))
  (if (equal symb "{")
      (setq nsymb "}"))
  (if (equal symb "[")
      (setq nsymb "]"))
  (if (equal symb "<")
      (setq nsymb ">"))
  (setq st (point))
  (setq par 1)
  (save-excursion
    (while (> par 0)
      (goto-char (+ (point) 1))
      (setq temp (char-to-string (char-after (point))))
      (if (equal temp symb)
          (setq par (+ par 1)))
      (if (equal temp nsymb)
          (setq par (- par 1))))
    (message (format "cutting from %d to %d" st (point)))
    (kill-region st (+ 1 (point)))))

(defun cut-string-expr()
  (while (or (nth 3 (syntax-ppss (point))) (= (point) 1)) (backward-char))
  (setq st (point))
  (forward-char)
  (while (or (nth 3 (syntax-ppss (point))) (= (point) (point-max))) (forward-char))
  (message (format "cutting string from %d to %d" st (point)))
  (kill-region st (point)))

(defun cut-region()
  (interactive)
  (cond
   ((not (equal (nth 3 (syntax-ppss (point))) nil))
    (cut-string-expr))
   ((and (= (save-excursion (end-of-line) (point)) (point))
	 (select-region "[^ \t\n]"))
    (kill-region (point) (mark))
    (when (not (char-in (char-after (point)) "})"))
      (insert " ")))
   ((= (save-excursion (beginning-of-line) (point)) (point))
    (backward-paragraph)
    (set-mark (point))
    (forward-paragraph)
    (kill-region (point) (mark)))
   (t
    (cut-block))))
(global-set-key "\M-j" 'cut-region)

(defun bookmark-jump-noerror (bookmark)
  (if (bookmark-test bookmark)
      (bookmark-jump bookmark)))
(defun bookmark-test (bookmark)
  (if (eq (bookmark-get-bookmark bookmark t) nil)
      nil
    t))
(defun eval-string (string)
  (print (eval (car (read-from-string string)))))
(setq short-command "(message \"It works\")")
(global-set-key
 [f8] '(lambda () (interactive)
	 (eval-string short-command)))
(global-set-key
 [S-f8] '(lambda (command)
	   (interactive (list (read-from-minibuffer
			       "Command: "
			       short-command
			       nil
			       nil
			       nil)))
	   (setq short-command command)
	   (eval-string command)))
(global-set-key [f9] 'undo)

(defun copy-line()
  "copy line."
  (interactive)
  (save-excursion
    (let (
          (beg (line-beginning-position))
          (end (+ 1 (line-end-position))))
      (copy-region-as-kill beg end)
      (beginning-of-line))
    (message "lined copied")))

(global-set-key "\M-k" 'kill-whole-line)

(defun yank-line()
  "insert the yank at the beginning of the line"
  (interactive)
  (beginning-of-line)
  (yank)
  (previous-line 1)
  (indent-for-tab-command)
  (next-line 1))

(global-set-key
 [C-backspace] '(lambda () (interactive)
		  (if mark-active
		      (kill-region (point) (mark))
		    (backward-kill-word 1))))

(defun line-go-up()
  (interactive)
  (transpose-lines 1)
  (previous-logical-line 2))
(global-set-key [M-up] 'line-go-up)

(defun line-go-down()
  (interactive)
  (next-logical-line 2)
  (transpose-lines -1))
(global-set-key [M-down] 'line-go-down)

(defun insert-whatever(element1 element2)
  "insert 2 elements and place the point after the first element"
  (interactive "")
  (insert (format "%s%s" element1 element2))
  (goto-char (- (point) (length element2))))

(global-set-key "\M-[" '(lambda () (interactive)(insert-whatever "{" "}")))
(global-set-key "\M-p" '(lambda () (interactive)(insert-whatever "<?php " ";?>")))
(global-set-key "\M-b" '(lambda () (interactive)(insert-whatever "{% " " %}")))
(global-set-key "\M-`" '(lambda () (interactive) (insert "`")))

(global-set-key [S-return] '(lambda () (interactive)
                              (progn
                                (beginning-of-line)
                                (insert "\n")
                                (previous-line)
                                (indent-according-to-mode))))
(global-set-key [C-return] '(lambda () (interactive)
                              (progn
                                (end-of-line)
                                (insert "\n")
                                (indent-according-to-mode))))

;;;;;;;;;;;;;;;;;;;;
;; Move the point ;;
;;;;;;;;;;;;;;;;;;;;

(defun buffer-switchtosame()
  (interactive)
  (let ((b (current-buffer))
        (p (point)))
    (switch-to-buffer-other-window (buffer-name b))
    (goto-char p)))
(global-set-key [backtab] 'buffer-switchtosame)

(defun my-other-window () (interactive)
  (other-window 1)
  (dotimes (i 4)
    (when (< (window-height) 20)
      (other-window 1))))
(global-set-key "\C-xo" 'my-other-window)

(defun compile-reload (buffer string)
  (firefox-send "reload")
  (jump-to-register 1)
  (message "compile is done!"))

(defun mode-match (pattern)
  (string-match pattern (downcase (format-mode-line mode-name))))

;; needs merging with flexcompile
(setq apachepath "C:/Program Files/Apache Group/Apache2/bin/apache.exe")
(setq compile-errors nil)
(defun eval-multi(&optional evaltype)
  (interactive)
  (save-some-buffers t)
  (cond

   ;; flex
   ((or (equal (mode-match ".*\\(ctionscrip\\).*") 0)
        (string-match ".*\.mxml$" (buffer-name)))
    (runfcsh))

   ;; java
   ((equal (mode-match ".*\\(Java \\).*") 0)
    (if (not compile-errors)
        (window-configuration-to-register 1))
    (compile (format "javac.exe %s" (buffer-file-name)))
    (setq compilation-finish-functions
          '(lambda (buffer string) (interactive)
             (if (string-match "finished" string)
                 (let ((script
                        (format "%s%s" default-directory "view.bat")))
                   (if (file-exists-p script)
                       (shell-send script))
                   (setq compile-errors nil)
                   (jump-to-register 1))
               (setq compile-errors t)
               (compilation-next-error-function 1)))))

   ;; lisp
   ((and (equal evaltype nil)
         (equal (mode-match ".*\\(Lisp\\).*") 0))
    (save-excursion
      (end-of-line)
      (eval-last-sexp nil)))

   ;; shell
   ((string= (downcase (format-mode-line mode-name)) "shell")
    (comint-history-isearch-backward-regexp))

   ;; SQL
   ((eq major-mode 'sql-mode)
    (sql-send-paragraph))

   ;; Scala
   ((eq major-mode 'scala-mode)
    1)

   ;; involves stuff outside of emacs
   (t
    (delete-selection-mode t)
    (cond
     ((equal evaltype 1) 1)
     ;; reload firefox
     (t
      (if (equal (mode-match ".*\\(ython\\).*") 0)
	  (if (and (buffer-file-name)
		   (string-match ".*\\(models\\|views\\|tasks\\|url\\).*" (buffer-file-name)))
	      (run-with-timer 1.5 nil '(lambda () (firefox-send "reload")))
	    (py-execute-buffer))
	(firefox-send "reload")))))))

(global-set-key [f5] 'eval-multi)
(global-set-key [C-f5] '(lambda () (interactive)
                          (eval-multi 1)))

(global-set-key "\M-n" 'forward-sexp)

(global-set-key
 "\M-l" '(lambda () (interactive)
	   (cond
	    ((and (= (save-excursion (end-of-line) (point)) (point))
		  (not (= (current-column) 0)))
	     (beginning-of-line)
	     (set-mark (point))
	     (end-of-line))
	    (t
	     (if (not mark-active)
		 (progn
		   (backward-paragraph)
		   (set-mark (point))
		   (forward-paragraph))
	       (forward-paragraph))))))

(global-set-key
 "\M-i" '(lambda () (interactive)
	   (let ((x (point)))
	     (cond
	      (mark-active (kill-ring-save (point) (mark))
			   (when (and (= (point) (save-excursion (end-of-line) (point)))
				      (not (= (line-number-at-pos (point)) (line-number-at-pos (mark)))))
			     (insert "\n"))
			   (yank) (goto-char x))
	      ((= (save-excursion (beginning-of-line) (point)) (point))
	       (backward-paragraph)
	       (set-mark (point))
	       (forward-paragraph)
	       (kill-region (point) (mark))
	       (yank)
	       (yank))
	      ((= (save-excursion (end-of-line) (point)) (point))
	       (kill-whole-line) (yank))
	      (1 (kill-whole-line) (yank) (yank) (goto-char x) (next-logical-line))))))

(global-set-key
 "`" '(lambda () (interactive)
	(if (active-minibuffer-window)
	    (keyboard-escape-quit)
	  (ido-switch-buffer))))
(global-set-key
 (kbd "C-`")
 '(lambda () (interactive)
    (switch-to-buffer
     (cadr (remove-if '(lambda (x) (string-match "\\(Minibuf\\|Backtrace\\|Echo\\)" (buffer-name x)))
		      (buffer-list))))))

(global-set-key
 [f10] '(lambda () (interactive)
	  (if (= (point) (save-excursion (end-of-buffer) (point)))
	      (beginning-of-buffer)
	    (end-of-buffer))))

(defun debug-print()
  (interactive)
  (cond
   ((not (equal (mode-match ".*\\(ython\\).*") nil))
    (insert-whatever "import pprint; raise Exception(pprint.pformat(" "))"))
   ((not (equal (mode-match ".*\\(isp\\).*") nil))
    (insert-whatever "(print " ")"))
   ((not (equal (mode-match ".*\\(Java \\).*") nil))
    (insert-whatever "System.out.println(" ");"))
   ((not (equal (mode-match ".*\\(Javascript\\).*") nil))
    (insert-whatever "console.log(" ");"))
   ((not (equal (mode-match ".*\\(cript\\).*") nil))
    (insert-whatever "trace(" ");"))
   ((not (equal (mode-match ".*\\(php\\).*") nil))
    (insert-whatever "echo '<pre style=\"font-size:11px;background-color:#fff;\">';print_r(" ");echo '</pre>';die(1);"))
   ((not (equal (mode-match ".*\\(html\\).*") nil))
    (insert-whatever "<?php echo '<pre style=\"font-size:11px;background-color:#fff;\">';print_r(" ");echo '</pre>';die(1); ?>"))))
(global-set-key "\M-t" 'debug-print)

(defun getbackwardword(pos word break)
  (goto-char pos)
  (let ((start (+ (re-search-backward word nil t 1) 1))
        end)
    (setq end (+ (re-search-backward break nil t 1) 1))
    (buffer-substring start end)))
(defun backward-wordcopy(pos)
  (insert
   (save-excursion
     (let ((counter pos)
           (oldres "")
           (element (tokensep))
           res word break)
       (setq word (format "[%s]" element))
       (setq break (format "[^%s]" element))
       (re-search-backward break nil t 1)
       (while (< 0 counter)
         (setq res (getbackwardword (point) word break))
         (when (and (< 2 (length res))
                    (not (equal oldres res)))
           (setq counter (- counter 1))
           (setq oldres res)))
       res))))

(defun gettokenpos(token break)
  (if (equal (re-search-backward (format "%s%s" break target) nil t 1) nil)
      (progn
        (goto-char here)
        (re-search-forward (format "%s%s" break target) nil t 1))
    (re-search-forward target nil t 1)))

(defun completeline()
  (interactive)
  (let (target
        beginning)
    (save-excursion
      (beginning-of-line)
      (indent-according-to-mode)
      (setq start (point))
      (end-of-line)
      (setq target (buffer-substring
		    start
                    (point)))
      (beginning-of-line)
      (if (equal (re-search-backward target nil t 1) nil)
	  (progn
	    (end-of-line)
	    (re-search-forward target nil t 1)))
      (copy-line))
    (beginning-of-line)
    (setq beginning (point))
    (end-of-line)
    (delete-region beginning (+ (point) 1))
    (yank-line)
    (previous-line)
    (end-of-line)))
(global-set-key "\M-9" 'completeline)

;;;;;;;;;;;;;
;; firefox ;;
;;;;;;;;;;;;;

(setq mozh "r")
(setq mozw 0)
(setq firedoc 2)
(setq fireinit 0)
(defun firefox-send(act &optional arg)
  (set-buffer "firefox.js")
  (comint-send-string
   (inferior-moz-process)
   (format "%s;%s;"
           (buffer-string)
           (cond ((and (equal "r" mozh) (equal act "reload"))
                  (format "reload(%d)" mozw))
                 ((equal act "doc")
                  (comint-send-string (inferior-moz-process) (format "firedoc(%d)" firedoc)))
                 ((equal act "raisetabs")
                  (comint-send-string (inferior-moz-process) (format "raisetabs(\"%s\")" arg)))))))

;;;;;;;;;;;;;;;;
;; Transform  ;;
;;;;;;;;;;;;;;;;

(defun untabify-modes () (interactive)
  (let ((modes '("Emacs-Lisp"))
	(currentmode (format-mode-line mode-name)))
    (mapcar (lambda (e) (if (equal e currentmode)
			    (untabify (point-min) (point-max)) nil)) modes))
  nil)

(defun forceindent()
  (interactive)
  (save-excursion
    (let ((end (if mark-active (line-number-at-pos (region-end))
		 (- (line-number-at-pos (end-of-buffer)) 1))))
      (if mark-active
	  (goto-char (region-beginning))
	(beginning-of-buffer))
      (while (not (= (line-number-at-pos (point)) end))
	(indent-according-to-mode)
	(next-logical-line))
      (message "indent done!" ))))
(global-set-key "\M-T" 'forceindent)


(global-set-key (kbd "C-S-t") 'toggle-boolean)
(defun toggle-boolean ()
  (interactive)
  (save-excursion
    (beginning-of-line)
    (set-mark (point))
    (end-of-line)
    (let ((line (buffer-substring (mark) (point))))
      (cond
       ((search "1" line)
	(replace-string "1" "0" nil (mark) (point)))
       ((search "0" line)
	(replace-string "0" "1" nil (mark) (point)))
       ((search "true" line)
	(replace-string "true" "false" nil (mark) (point)))
       ((search "false" line)
	(replace-string "false" "true" nil (mark) (point)))
       ((search "True" line)
	(replace-string "True" "False" nil (mark) (point)))
       ((search "False" line)
	(replace-string "False" "True" nil (mark) (point)))))))

;;;;;;;;;;;
;; dired ;;
;;;;;;;;;;;

(require 'dired)
(require 'dired-details)
(dired-details-install)

;; dired open by explorer.exe
(eval-after-load "dired"
  '(define-key dired-mode-map [return]
     (lambda () (interactive)
       (if (eq system-type 'windows-nt)
	   (w32-shell-execute nil (dired-get-filename))
	 (let ((ext (file-name-extension (dired-get-filename))))
	   (if (car (file-attributes (dired-get-filename)))
	       (dired-do-shell-command "du -h" 1 (list (dired-get-filename)))
	     (eshell-command
	      (concat
	       (cond
		((string-match "\\(avi\\|rmvb\\|mp4\\|mkv\\|webm\\|flv\\|mpg\\|mp3\\|wmv\\|part\\)$" ext) "vlc")
		((string-match "\\(jpg\\|jpeg\\|gif\\|png\\)$" ext) "eog")
		((string-match "\\(pdf\\)$" ext) "evince")
		((string-match "\\(xcf\\)$" ext) "gimp")
		((string-match "\\(zip\\)$" ext) "unzip")
		((string-match "\\(rar\\)$" ext) "unrar e")
		(1 "firefox"))
	       " \"" (dired-get-filename) "\" &"))))))))

;; dired context menu
(defun w32-context-menu (filename)
  (start-process-shell-command "context" "*context*" "context" filename))
(defun w32-context-menu-dired-get-filename () (interactive )
  (w32-context-menu (concat "\"" (dired-get-filename) "\"")))

;; dired more commands
(eval-after-load "dired"
  '(progn
     (define-key dired-mode-map (kbd "p")
       '(lambda () (interactive)
          (image-dired-dired-display-image)
          (image-dired-dired-next-line)))
     (define-key dired-mode-map (kbd "y") 'dired-hide-subdir)
     (define-key dired-mode-map (kbd ";") 'dired-kill-subdir)
     (define-key dired-mode-map (kbd "c") 'w32-context-menu-dired-get-filename)
     (define-key dired-mode-map (kbd "t") 'dired-details-toggle)
     (define-key dired-mode-map (kbd "b") 'dired-up-directory)
     (define-key dired-mode-map (kbd "r") 'wdired-change-to-wdired-mode)
     (define-key dired-mode-map (kbd "f")
       '(lambda () (interactive)
          (message "%s is going to the trashcan!" (dired-get-filename))
          (setq dest (format "%s.trashcan/%d%02d/" (save-window-excursion (switch-to-buffer "temp") (goto-char 0) (dired-current-directory)) (nth 5 (decode-time)) (nth 4 (decode-time))))
          (if (eq (file-directory-p dest) nil)
              (make-directory dest)
            )
          (dired-rename-file (dired-get-filename) dest 0)))))
(setq dired-recursive-deletes 'always)
(setq dired-recursive-copies 'always)
(put 'dired-find-alternate-file 'disabled nil)
(put 'downcase-region 'disabled nil)

(defun context ()
  (interactive)
  (w32-context-menu (concat "\"" (buffer-file-name) "\"")))
(global-set-key "\M-c" 'context)

;;;;;;;;;;;;;;;;;;
;; key bindings ;;
;;;;;;;;;;;;;;;;;;

;; flex compilation
(setq flextype 1)
(defun restore-compile () (interactive)
  (fcsh-restore-compile)
  (setq flextype 1)
  (save-window-excursion
    (when (get-buffer "*compilation*")
      (switch-to-buffer "*compilation*")
      (kill-compilation)))
  (setq compilation-finish-functions nil))

(defun flexcompile (command outputpath type) (interactive)
  (progn

    ;; compile code
    (defun runfcsh()
      (interactive)
      (global-hl-line-mode t)
      (save-some-buffers t)
      (delete-selection-mode t)
      (if (= compisok 1)
          (window-configuration-to-register 1))
      (setq compilation-finish-functions 'compile-flex)
      (compile *fcsh-path*))

    ;; compilation finished hooked
    (defun compile-flex (buffer string)
      (set-buffer buffer)
      (goto-char (point-min))
      (cond ((and (string-match "finished" string)
                  (equal (re-search-forward "\\(Error\\|Warning\\)" nil t 1) nil))
             (setq compisok 1)
             (jump-to-register 1)
             (message "Build maybe successful: closing window.")
             (if (and (= flextype 1) (eq system-type 'windows-nt))
                 (w32-shell-execute nil "adl"
                                    (format "%s%s-app.xml"  *fcsh-mxmlc-output-path*
                                            (substring *fcsh-mxml-file* 0 -5)))
               (firefox-send "reload")))
            (t
             (setq compisok 0)
             (next-error)
             (message "Compilation exited abnormally: %s" string))))

    ;; setup the compilation process
    (setq compisok 0)
    (setq flextype type)
    (setq *fcsh-mxmlc-command* command)
    (setq *fcsh-mxmlc-output-path* outputpath)
    (setq *fcsh-mxml-file* (buffer-name))
    (when (not *fcsh-compile-active*)
      (setq *fcsh-compile-active* t)
      ;; this can be called only once!
      (if (not (eq (symbol-function 'compilation-start) '*fcsh-compile-old-compilation-start*))
	  (fset '*fcsh-compile-old-compilation-start*
		(symbol-function 'compilation-start)))
      (fset 'compilation-start 'fcsh-compilation-start))
    (runfcsh)))

;; random stuffs
(global-set-key "\C-v" 'yank)
(global-set-key "\M-r" 'ibuffer)
(global-set-key "\C-f" 'find-file)
(global-set-key [f4] '(lambda () (interactive)
			(progn
			  (message (concat "killed " (buffer-file-name (current-buffer))))
			  (kill-this-buffer)
			  )))
(global-set-key "\M-o" 'goto-line)
(global-set-key [f3] '(lambda () (interactive)
                        (progn
                          (call-interactively 'occur)
                          (if (get-buffer "*Occur*")
                              (switch-to-buffer-other-window "*Occur*")))))

(global-set-key "\C-b"
                '(lambda ()(interactive)
                   (if (equal mark-active nil)
                       (progn
                         (re-search-forward "https?://" nil t 1)
                         (browse-url-at-point))
                     (let ((keywords (replace-regexp-in-string
                                      "^ *\\| *$" ""
                                      (replace-regexp-in-string
                                       "[ \t\n]+" "+"
                                       (buffer-substring
                                        (region-beginning)
                                        (region-end))))))
                       (browse-url (format "http://www.google.fr/search?q=%s&ie=utf-8&oe=utf-8&aq=t&rls=org.mozilla:en-US:official&client=firefox-a" keywords))))))

;;;;;;;;;;;;;;;;;;;;;;;;;;
;; window configuration ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;

(setq alt-conf? nil)
(global-set-key [f11]
		'(lambda () (interactive)
		   (when (string= (frame-parameter nil 'name) "main")
		     (if alt-conf?
			 (progn
			   (window-configuration-to-register 'alt)
			   (unwind-protect
			       (jump-to-register 'base)
			     (window-configuration-to-register 'base))
			   (set-cursor-color "#ffff00")
			   (message "Base configuration"))
		       (window-configuration-to-register 'base)
		       (unwind-protect
			   (jump-to-register 'alt)
			 (window-configuration-to-register 'alt))
		       (set-cursor-color "#ff0000")
		       (message "Alt configuration"))
		     (setq alt-conf? (not alt-conf?)))))

(defun rf(name)
  (interactive "sNew name: ")
  (if (= 0 (length name))
      (setq name "main"))
  (set-frame-name (format "emacs [%s]" name)))
(set-frame-name "main")

(global-set-key "\M-v" 'grep-find)
(global-set-key
 "\M-V" '(lambda (a) (interactive "sList buffers regexp: ")
           (progn
             (let ((b (current-buffer)))
               (ibuffer)
               (ibuffer-do-occur a)
               (switch-to-buffer b)))))

;;;;;;;;;;;;;;;;;;;;;
;; automatic stuff ;;
;;;;;;;;;;;;;;;;;;;;;

;; hightlighting
;; (setq massivetimerh (run-at-time nil .2 'autoformat))
;; (cancel-timer massivetimerh)
(setq htoken "test")
(setq oldpoint "-1")
(setq oldline -1)
(defun autoformat()
  (interactive)
  (when (not (equal (point) oldpoint))
    (global-hl-line-mode t)
    (when (not (equal (modes-enabled) nil))
      ;; indent line
      (if (not (equal (format-mode-line mode-name) "Python"))
          (if (not (and (equal (char-to-string
                                (char-after (point))) "\n")
                        (equal (current-column) 0)))
              (progn
                ;; (indent-according-to-mode)
                t)))
      ;; place the point in a smart position
      (if (= (abs (- (line-number-at-pos) oldline)) 1)
          (let ((linepos (line-number-at-pos)))
            (goto-char (- (point) 1))
            (re-search-forward (tokensep) nil t 1)
            (if (not (equal (line-number-at-pos) linepos))
                (progn
                  (previous-line)
                  (end-of-line)))))
      ;; highlight unface
      (hi-lock-unface-buffer htoken)
      ;; highlight face
      (save-excursion
        (re-search-backward (tokensep) nil t 1)
        (goto-char (+ (point) 1))
        (setq start (point))
        (re-search-forward (tokensep) nil t 1)
        (goto-char (- (point) 1))
        (setq end (point)))
      (setq htoken (buffer-substring-no-properties start end))
      (if (< 2 (- end start))
          (hi-lock-face-buffer htoken))
      (setq oldpoint (point))
      (setq oldline (line-number-at-pos)))))

;;;;;;;;;;;;;;;
;; Expansion ;;
;;;;;;;;;;;;;;;

(defun try-expand-flexible-abbrev (old)
  "Try to complete word using flexible matching.

Flexible matching works by taking the search string and then
interspersing it with a regexp for any character. So, if you try
to do a flexible match for `foo' it will match the word
`findOtherOtter' but also `fixTheBoringOrange' and
`ifthisisboringstopreadingnow'.

The argument OLD has to be nil the first call of this function, and t
for subsequent calls (for further possible completions of the same
string).  It returns t if a new completion is found, nil otherwise."
  (if (not old)
      (progn
	(he-init-string (he-lisp-symbol-beg) (point))
	(if (not (he-string-member he-search-string he-tried-table))
	    (setq he-tried-table (cons he-search-string he-tried-table)))
	(setq he-expand-list
	      (and (not (equal he-search-string ""))
		   (he-flexible-abbrev-collect he-search-string)))))
  (while (and he-expand-list
	      (he-string-member (car he-expand-list) he-tried-table))
    (setq he-expand-list (cdr he-expand-list)))
  (if (null he-expand-list)
      (progn
	(if old (he-reset-string))
	())
    (progn
      (he-substitute-string (car he-expand-list))
      (setq he-expand-list (cdr he-expand-list))
      t)))

(defun he-flexible-abbrev-collect (str)
  "Find and collect all words that flex-matches STR.
See docstring for `try-expand-flexible-abbrev' for information
about what flexible matching means in this context."
  (let ((collection nil)
        (regexp (he-flexible-abbrev-create-regexp str)))
    (save-excursion
      (goto-char (point-min))
      (while (search-forward-regexp regexp nil t)
        ;; Is there a better or quicker way than using
        ;; `thing-at-point' here?
        (setq collection (cons (thing-at-point 'word) collection))))
    collection))

(defun he-flexible-abbrev-create-regexp (str)
  "Generate regexp for flexible matching of STR.
See docstring for `try-expand-flexible-abbrev' for information
about what flexible matching means in this context."
  (concat "\\b" (mapconcat (lambda (x) (concat "\\w*" (list x))) str "")
          "\\w*" "\\b"))

(defun my-hippie-expand-completions (&optional hippie-expand-function)
  "Return the full list of possible completions generated by `hippie-expand'. The optional argument can be generated with `make-hippie-expand-function'."
  (let ((this-command 'my-hippie-expand-completions)
	(last-command last-command)
	(buffer-modified (buffer-modified-p))
	(hippie-expand-function (or hippie-expand-function 'hippie-expand)))
    (flet ((ding)) ; avoid the (ding) when hippie-expand exhausts its options.
      (while (progn
	       (funcall hippie-expand-function nil)
	       (setq last-command 'my-hippie-expand-completions)
	       (not (equal he-num -1)))))
    ;; Evaluating the completions modifies the buffer, however we will finish
    ;; up in the same state that we began, and (save-current-buffer) seems a
    ;; bit heavyweight in the circumstances.
    (set-buffer-modified-p buffer-modified)
    ;; Provide the options in the order in which they are normally generated.
    (delete he-search-string (reverse he-tried-table))))

(defmacro my-ido-hippie-expand-with (hippie-expand-function)
  "Generate an interactively-callable function that offers ido-based completion using the specified hippie-expand function."
  `(call-interactively
    (lambda (&optional selection)
      (interactive
       (let ((options (my-hippie-expand-completions ,hippie-expand-function)))
	 (if options
	     (list (ido-completing-read "Completions: " options)))))
      (if selection
	  (he-substitute-string selection t)
	(message "No expansion found")))))

(defun my-ido-hippie-expand ()
  "Offer ido-based completion for the word at point."
  (interactive)
  (my-ido-hippie-expand-with (make-hippie-expand-function
			      '(try-expand-dabbrev-visible
				try-expand-flexible-abbrev
				try-expand-dabbrev
				try-expand-dabbrev-all-buffers) t)))
(global-set-key "\M- " 'my-ido-hippie-expand)

;;;;;;;;;;;;;;;
;; shortcuts ;;
;;;;;;;;;;;;;;;

(global-set-key [C-f1] '(lambda ()(interactive) (switch-to-buffer "Downloads") (dired-revert)))
(global-set-key [C-f2] '(lambda ()(interactive) (switch-to-buffer "temp") (dired-revert)))
(global-set-key [C-f3] '(lambda ()(interactive) (switch-to-buffer "Videos") (dired-revert)))
(global-set-key [C-f4] '(lambda ()(interactive)
			  (when (string-equal (buffer-name (current-buffer))
					      "*scratch*")
			    (rename-buffer (concat "*scratch-" (format-mode-line mode-name) "*") 1))
			  (switch-to-buffer "*scratch*")))
;;;;;;;;;;;;;;;;;;;;;;;;
;; emacs conf customs ;;
;;;;;;;;;;;;;;;;;;;;;;;;
(when nil
  (custom-set-variables
   '(auto-completion-delay 1.0)
   '(completion-auto-show-menu nil)
   '(completion-tooltip-delay 0)
   '(completion-tooltip-timeout 16)
   '(completion-use-dynamic t)
   '(completion-use-echo t)
   '(completion-use-hotkeys t)
   '(completion-use-tooltip t)
   '(py-shell-switch-buffers-on-execute nil)
   '(jabber-alert-info-message-hooks (quote (jabber-info-display)))
   '(jabber-alert-message-hooks (quote (jabber-message-scroll)))
   '(jabber-alert-muc-hooks (quote (jabber-muc-scroll)))
   '(jabber-alert-presence-hooks (quote (jabber-presence-update-roster)))
   '(jabber-nickname "marc")
   '(jabber-server "jabber.org")
   '(jabber-username "belmont")
   '(erc-nick "marcmarc")
   '(eshell-hist-move-to-end nil)
   '(eshell-buffer-maximum-lines 2048)
   '(eshell-history-size 512)
   '(eshell-output-filter-functions (quote (eshell-postoutput-scroll-to-bottom eshell-handle-control-codes eshell-handle-ansi-color eshell-watch-for-password-prompt eshell-truncate-buffer)))
   '(ido-default-buffer-method (quote selected-window))
   '(fringe-mode (quote (0 . 0)) nil (fringe))
   '(ls-lisp-ignore-case t)
   '(javascript-indent-level 2)
   '(js-indent-level 2)
   '(dired-listing-switches "-alh")
   '(ls-lisp-dirs-first t)
   '(ls-lisp-ignore-case t)
   '(org-startup-truncated nil)
   '(org-hide-leading-stars t)
   '(org-clock-modeline-total 'today)
   '(org-todo-keywords (quote ((sequence "TODO" "|" "DONE" "NOTPAID"))))
   '(org-clock-into-drawer 20)
   '(py-shell-switch-buffers-on-execute nil)
   '(tooltip-mode nil)
   '(tcl-application "tclsh85.exe")
   '(tcl-continued-indent-level 2)
   '(tcl-indent-level 2)
   '(vc-delete-logbuf-window nil)
   '(vc-hg-diff-switches "-wbB")
   '(vc-svn-diff-switches "-x -w"))

  (custom-set-faces
   '(default ((t (:background "#001" :foreground "#0c0"))))
   '(cursor ((t (:background "#ffff00"))))
   '(comint-highlight-input ((t (:foreground "#f77"))))
   '(completions-common-part ((t (:inherit default :underline t :height 1.2))))
   '(completions-first-difference ((t (:inherit bold :background "#000000" :foreground "#00ff00" :weight bold :height 1.3))))
   '(erc-notice-face ((t (:foreground "SlateBlue" :height 0.7))))
   '(diff-context ((t (:foreground "#999"))))
   '(diff-added ((t (:foreground "#0f0"))))
   '(diff-removed ((t (:foreground "#c00"))))
   '(org-todo ((t (:foreground "red" :weight normal))))
   '(dired-header ((t (:inherit font-lock-type-face :box (:line-width 2 :color "grey75") :height 1.2))))
   '(dired-directory ((t (:inherit font-lock-function-name-face))))
   '(hl-line ((t (:underline "#ff0"))))
   '(ido-first-match ((t (:foreground "yellow" :weight bold :height 2.0))))
   '(mode-line ((((class color) (min-colors 88)) (:background "#ff2" :foreground "black" :box (:line-width -1 :style released-button) :height 0.80))))
   '(org-todo ((t (:foreground "red" :weight normal))))
   '(minibuffer-prompt ((((background dark)) (:foreground "cyan" :height 2.2))))))

Show details Hide details

Change log

155fca28eeeb by Marc Belmont on Yesterday (38 hours ago) Diff

improve comment-box binding

Go to:

Project members, sign in to write a code review

Older revisions

e06ee22f554b by Marc Belmont on Yesterday (38 hours ago) Diff

add region setter

4e905ce7f379 by Marc Belmont on Yesterday (39 hours ago) Diff

fix javascript semicolon insertion

9b420923413b by Marc Belmont on May 25 (41 hours ago) Diff

force refresh of the vc-diff on same
buffer

All revisions of this file

File info

Size: 45254 bytes, 1329 lines

View raw file