.sawfishrc

;; -*- mode: sawfish -*-

(require 'sawfish.wm.util.keymap)
(require 'sawfish.wm.state.maximize)
(require 'rep.data.ring)

(load-file "~/system-config/.sawfish/bhj-draw-wininfo.jl")
(load-file "~/system-config/.sawfish/bhj-draw-notification.jl")
(require 'bhj-draw-notification)
(require 'bhj-run-application)
(require 'bhj-draw-wininfo)
(require 'sawfish.wm.commands.move-cursor)
(defun bind-both-global&window-keymaps (key map)
  (bind-keys global-keymap key map)
  (bind-keys window-keymap key map))
(defun unbind-both-global&window-keymaps (key)
  (unbind-keys global-keymap key)
  (unbind-keys window-keymap key))

(bind-both-global&window-keymaps "C-F23" '(move-cursor-left))
(bind-both-global&window-keymaps "C-F24" '(move-cursor-right))
(bind-both-global&window-keymaps "Super-F23" '(move-cursor-up))
(bind-both-global&window-keymaps "Super-F24" '(move-cursor-down))

(define (sc-move-window-center w)
  "Move the window to the center from the current screen."
  (move-window-to w
                  (+ (car (current-head-offset w))
                     (quotient (- (car (current-head-dimensions w))
                                  (car (window-frame-dimensions w))) 2))
                  (+ (cdr (current-head-offset w))
                     (quotient (- (cdr (current-head-dimensions w))
                                  (cdr (window-frame-dimensions w))) 2))))

;; gtk window does not support XSendEvent, must use xdotool or libxdo
(setq bhj-current-window-is-gtk? nil)

(setq warp-to-window-offset 50
      warp-to-window-enabled t)

(setq
 s-h-keymap (make-keymap)
 print-keymap (make-keymap)
 c-x-esc-keymap (make-keymap)
 c-x-map (make-keymap)
 esc-map (make-keymap)
 esc-x-keymap (make-keymap)
 esc-g-map (make-keymap))

;; start code-generator "^\\s *;*\\s *"
;; for x in $(grep 'make'-keymap ~/.sawfishrc|pn 1); do
;; cat <<EOF
;; (bind-keys $x "Super-h" '(system "sawfish-help-key $x&"))
;; EOF
;; done
;; end code-generator
;; start generated code
(bind-keys s-h-keymap "Super-h" '(system "sawfish-help-key s-h-keymap&"))
(bind-keys print-keymap "Super-h" '(system "sawfish-help-key print-keymap&"))
(bind-keys c-x-esc-keymap "Super-h" '(system "sawfish-help-key c-x-esc-keymap&"))
(bind-keys c-x-map "Super-h" '(system "sawfish-help-key c-x-map&"))
(bind-keys esc-map "Super-h" '(system "sawfish-help-key esc-map&"))
(bind-keys esc-x-keymap "Super-h" '(system "sawfish-help-key esc-x-keymap&"))
(bind-keys esc-g-map "Super-h" '(system "sawfish-help-key esc-g-map&"))

;; end generated code

(bind-keys s-h-keymap "q" '(synthesize-event-gnome? (read-event-quietly "Press the key you wanna send") (input-focus)))

(defun sc-maxmize-window-toggle (&optional w)
  (setq w (or w (input-focus)))
  (when w
    (if (window-maximized-p w)
        (unmaximize-window w)
      (maximize-window w))))

(bind-both-global&window-keymaps "Super-F1" '(sc-maxmize-window-toggle))

(defun delete-window-class-safely (class)
  "Delete all windows of the same CLASS"
  (mapc (lambda (window)
          (when (equal (bhj-window-class window) class)
            (delete-window-safely window)))
        (managed-windows)))

(bind-keys s-h-keymap "ESC" '(let ((key (concat "M-" (event-name (read-event-quietly "M-")))))
                               (synthesize-event-gnome? key (input-focus))))

(setq esc-g-remap-alist
      '(("M-g g" . '((t "C-g") (qpdfview "C-j") (acroread "M-v" "g" "p"))))) ; go to page in acroread



(defun multi-bind-keys (map what &rest keys)
  "for each key in KEYS, bind it in MAP to do WHAT"
  (mapc (lambda (key)
          (bind-keys map key what))
        keys))
(setq move-lock-when-maximized nil)


(load-file "~/system-config/.sawfish/iswitch-window.jl")

(defun bhj-global-cycle-class (window)
  (let ((class (bhj-window-class window)))
    (cond
     ((string-match im-class class 0 t)
      im-class)
     ((string-match br-class class 0 t)
      br-class)
     ((string-match dc-class class 0 t)
      dc-class)
     (t
      class))))

(defun bhj-window-class (window)
  (let ((class (or (window-class window) "")))
    (if (string= class "Wine")
        (translate-string (substring (caddr (get-x-property window (quote WM_CLASS))) 0) ":")
      class)))

(bind-keys s-h-keymap "s"  '(system "EMACS=t s&"))
(bind-keys s-h-keymap "F1"  '(system "EMACS=t do-capture&"))
(bind-keys s-h-keymap "F2"  '(system "Wrench.sh&"))
(bind-keys s-h-keymap "F3"  '(system "find-or-exec gjiten gjiten&"))
(bind-keys s-h-keymap "S"  '(system "os&"))
(bind-keys s-h-keymap "n"  '(system "netease-music next&"))
(bind-both-global&window-keymaps "KP_Multiply" '(system "netease-music like&"))
(bind-both-global&window-keymaps "Super-KP_Multiply" '(system "netease-music loop-same-author&"))
(bind-both-global&window-keymaps "KP_Divide" '(system "netease-music unlike&"))
(bind-both-global&window-keymaps "Super-Down"  '(system "netease-music info&"))
(bind-both-global&window-keymaps "Super-Right"  '(system "sawfish-move-to-next-screen&"))
(bind-both-global&window-keymaps "Super-Left"  '(system "sawfish-move-to-prev-screen&"))
(bind-both-global&window-keymaps "Super-S-Right"  '(system "netease-music forth&"))
(bind-both-global&window-keymaps "Super-S-Left"  '(system "netease-music back&"))
(bind-both-global&window-keymaps "XF86AudioNext"  '(system "netease-music next&"))
(bind-both-global&window-keymaps "XF86AudioPrev"  '(system "netease-music prev&"))
(bind-both-global&window-keymaps "Super-KP_Right"  '(system "netease-music forward&"))
(bind-both-global&window-keymaps "Super-KP_Left"  '(system "netease-music back&"))
(bind-both-global&window-keymaps "XF86AudioPlay"  '(system "netease-music pause&"))
(bind-both-global&window-keymaps "Super-Scroll_Lock"  '(system "netease-music pause&"))
(bind-both-global&window-keymaps "C-XF86AudioPlay"  '(system "netease-music lyrics&"))

(bind-keys s-h-keymap "p"  '(system "emacs-get-android-clipboard&"))
(bind-keys s-h-keymap "R"  '(system "Wrench-reply&"))
(bind-keys s-h-keymap "P"  '(system "emacs-get-android-phone&"))
(bind-both-global&window-keymaps "XF86Launch5" '(system "EMACS=t do-capture&"))
(bind-both-global&window-keymaps "Super-F4" '(system "EMACS=t do-capture&"))

(bind-both-global&window-keymaps "XF86Launch6" '(system "Wrench.sh&"))
(bind-both-global&window-keymaps "Super-F5" '(system "Wrench-or-Emacs&"))

(bind-keys s-h-keymap "XF86Launch6" '(system "Wrench.sh&"))
(bind-both-global&window-keymaps "XF86Launch7" '(system "find-or-exec gjiten gjiten&"))
(bind-both-global&window-keymaps "Super-F6" '(system "find-or-exec gjiten gjiten&"))

(bind-both-global&window-keymaps "XF86Launch8" '(system "custom-command&"))
(bind-both-global&window-keymaps "Super-F7" '(system "custom-command&"))

(bind-both-global&window-keymaps "XF86Launch9" '(system "EMACS=t ssssh&"))
(bind-both-global&window-keymaps "Super-F8" '(system "EMACS=t ssssh&"))

(bind-both-global&window-keymaps "XF86AudioMute" '(system "sound-toggle&"))

(defun bhj-wm-class (window)
  (translate-string (substring (caddr (get-x-property window (quote WM_CLASS))) 0) ":"))

(bind-both-global&window-keymaps "Super-XF86KbdBrightnessUp"  '(system "switch-touchpad enable&")) ; for mac
(bind-both-global&window-keymaps "Super-XF86KbdBrightnessDown"  '(system "switch-touchpad enable&")) ; for mac
(bind-keys s-h-keymap "Super-i" '(read-event (format nil "Window: %s\nWM_CLASS: %s\nWindow class: %s\nWindow name:%s\nWindow pid:%s\n\nPress any key to continue..."
                                                     (input-focus)
                                                     (translate-string (substring (caddr (get-x-property (input-focus) (quote WM_CLASS))) 0) ":")
                                                     (bhj-window-class (input-focus))
                                                     (window-name (input-focus))
                                                     (window-pid (input-focus)))))
(bind-keys s-h-keymap "i" '(system "indent-clipboard&"))
(bind-keys s-h-keymap "I" '(system "deindent-clipboard&"))
(bind-keys s-h-keymap "Insert" '(system "sync-x-clip&"))

(defun bhj-activate-window (window)
  (if (window-iconified-p window)
      (uniconify-window window))
  (activate-window window))

(defun window-exists-p (wclass)
  (if (eq 'wFound
          (catch 'wFound
            (mapc (lambda (window)
                    (when (string-match wclass (bhj-window-class window) 0 t)
                      (throw 'wFound 'wFound)))
                  (stacking-order))))
      t
    nil))

(defun find-window-or-exec (wclass-or-lambda #!optional wcommand)
  (unless (eq (catch 'wFound
                (mapc (lambda (window)
                        (when (if (stringp wclass-or-lambda)
                                  (if (string-match "%" wclass-or-lambda)
                                      (and (string-match (string-replace "%.*" "" wclass-or-lambda) (window-name window) 0 t)
                                           (string-match (string-replace ".*%" "" wclass-or-lambda) (bhj-window-class window) 0 t))
                                    (string-match wclass-or-lambda (bhj-window-class window) 0 t))
                                (when functionp wclass-or-lambda
                                      (wclass-or-lambda window)))
                          (bhj-activate-window window)
                          (throw 'wFound 'wFound)))
                      (remove-if (lambda (w) (window-get w 'special)) (stacking-order))))
              'wFound)
    (when wcommand
      (system (concat wcommand "&")))))

(mapc
 (lambda (args)
   (let ((key (car args))
         (wclass (cadr args))
         (wcommand (caddr args)))
     (bind-keys s-h-keymap key
                (lambda ()
                  (find-window-or-exec (eval wclass) wcommand)))))
 '(
   ("Super-m"          "Emacs" "emacs.bhj")
   ("v"                "adjust-volume" "adjust-volume")
   ("Super-t"          (lambda (w) (and
                               (string-match "konsole|gnome-terminal|xterm|lxterminal|xfce4-terminal" (bhj-window-class w) 0 t)
                               (not (string= "emacs" (window-name w))))) "konsole.bhj")
   ("d"                "hello world no such thing" "my-dict")
   ("Meta-Scroll_Lock" "hello world no such thing" "lock-screen")
   ("Super-XF86AudioRaiseVolume" "hello world no such thing" "lock-screen")
   ("Super-x" "xcalc" "xcalc")
   ("XF86Switch_VT_12" "konsole" "konsole -e ~/system-config/bin/myscr")
   ("Shift-ESC" "konsole" "konsole --hide-menubar -e ~/system-config/bin/myscr")))

(bind-keys s-h-keymap "Super-n" '(system "find-or-exec -p $HOME/external/firefox\\|chromium firefox firefox&"))
(bind-keys s-h-keymap "Super-b" '(system "find-or-exec -p \"$HOME/.cache/private-firefox-1/firefox\" firefox private-firefox&"))
(bind-keys s-h-keymap "Super-B" '(system "find-or-exec -p \"$HOME/.cache/private-firefox-1/firefox\" firefox private-firefox&"))

;; (bind-both-global&window-keymaps "Super-Button1-Click"  '(system "xdotool-when-keyboard-clear keydown Control click 1 keyup Control&"))
(bind-both-global&window-keymaps "Super-Button3-Click" '(system "EMACS=t SAWFISH_CLICK=t s&"))
(bind-both-global&window-keymaps "Super-Button2-Click" '(system "EMACS=t SAWFISH_CLICK=t s&"))
(bind-both-global&window-keymaps "XF86Search" '(system "sawfish-xf86search&"))
(bind-both-global&window-keymaps "Super-F2" '(system "sawfish-xf86search&"))

(bind-both-global&window-keymaps "C-S-XF86PowerOff"  '(system "lock-screen&"))
(bind-both-global&window-keymaps "C-S-DEL"  '(system "lock-screen&"))

(bind-both-global&window-keymaps "XF86AudioRaiseVolume"  '(system "adjust-volume&"))
(bind-both-global&window-keymaps "XF86AudioLowerVolume"  '(system "adjust-volume&"))
(bind-keys s-h-keymap "N" '(system "private-firefox -i 1&"))
(bind-keys s-h-keymap "Super-N" '(system "private-firefox -i 2&"))

(defun classed-key-synthesize (from to)
  (when (eq (car to) 'quote)
    (setq to (cadr to)))
  (let* ((fw (input-focus))
         (class (bhj-window-class fw))
         (map-to (or
                  (cdr (or (assoc (intern class) to)
                           (assoc t to)))
                  from)))
    (mapc (lambda (map-1)
            (synthesize-event-gnome? map-1 (input-focus)))
          map-to)))

(defun get-window-map (window-map-assoc class)
  (setq window-map-assoc (cadr window-map-assoc))
  (cadr (or (assoc class window-map-assoc)
            (assoc t window-map-assoc))))

(defun bind-keys-nil-unbind (keymap key action)
  (if action
      (progn
        (when (eq keymap global-keymap)
          (bind-keys window-keymap key action))
        (bind-keys keymap key action))
    (unbind-keys keymap key)
    (when (eq keymap global-keymap)
      (unbind-keys window-keymap key))))

(setq emacs-style-window-class-re "rdesktop|wrench|emacs|lxterminal|xfce4-terminal|konsole|gnome-terminal|urxvt|krdc|vncviewer|xterm")
(defvar global-emacs-remap-alist nil
  "Window specific remap list")


(defun update-firefox-keys (alist from-key firefox-keys)
  (let* ((elem (assoc from-key alist))
         (is-quote (eq 'quote (cadr elem)))
         (mapped-list (cdr elem)))
    (when is-quote
      (setq mapped-list (cadr mapped-list)))
    (setq mapped-list
          (remove-if
           (lambda (e) (or
                        (eq (car e) 'Firefox)
                        (eq (car e) 'Firefox-esr)
                        (eq (car e) 'Iceweasel)))
           mapped-list))
    (setq mapped-list (nconc `((Firefox . ,firefox-keys)
                               (Firefox-esr . ,firefox-keys)
                               (Iceweasel . ,firefox-keys))
                             mapped-list))
    (when is-quote
      (setq mapped-list (list 'quote mapped-list)))

    (if (null elem)
        (setq elem (cons from-key mapped-list)
              alist (cons elem alist))
      (setcdr elem mapped-list)))
  alist)

(defun update-all-firefox-keys (alist &rest keymaps)
  (while keymaps
    (let ((from-key (car keymaps))
          (firefox-keys (cadr keymaps)))
      (setq keymaps (cddr keymaps))
      (setq alist (update-firefox-keys alist from-key firefox-keys))))
  alist)


(setq global-emacs-remap-alist
      '(("C-a" . '((t "Home")))
        ("C-z" . '((Lxterminal "C-S-z" "z") (XTerm "C-z" "z") (Gnome-terminal "C-S-z" "z") (Xfce4-terminal "C-S-z" "z")))
        ("Super-z" . '((Lxterminal "C-S-z" "z") (XTerm "C-S-z" "z") (Gnome-terminal "ctrl+shift+z" "z") (Xfce4-terminal "C-S-z" "z") (t "C-z")))
        ("Super-SPC" . '((Special-Notice "Check your ibus hotkey!") (Lxterminal "C-S-z") (XTerm "C-S-z") (Gnome-terminal "ctrl+shift+z") (Xfce4-terminal "C-z") (t "next")))
        ("C-g" . '((t "ESC")))
        ("Next" . '((qpdfview "SPC")))
        ("Prior" . '((qpdfview "BS")))
        ("C-d" . '((t "DEL")))
        ("C-e" . '((t "End")))
        ("C-q" . '((Firefox this-key-is-dead))) ; should not exit whole firefox
        ("C-b" . '((Firefox "Left") (Firefox-esr "Left") (Iceweasel "Left") (t "Left")))
        ("C-y" . '((t "C-v")))
        ("C-f" . '((t "Right")))
        ("M-b" . '((t "C-Left"))) ; this is for Escape only, not Alt
        ("M-f" . '((t "C-Right")))
        ("M-B" . '((t "C-S-Left")))
        ("M-F" . '((t "C-S-Right")))
        ("C-s" . '((Firefox "C-f") (Firefox-esr "C-f")
                   (Iceweasel "C-f")
                   (Okular "F3")
                   (Gjiten "M-s" "ISO_Left_Tab" "ISO_Left_Tab" "ISO_Left_Tab" "ISO_Left_Tab" "ISO_Left_Tab" "Home" "S-End" "RET")
                   (t "C-g")))
        ("C-v" . '((qpdfview "SPC") (t "Next")))
        ("SPC" . '((Fbreader "Next")
                   (kindle.exe:Wine: kindle-scroll)))
        ("BS" . '((Fbreader "Prior")
                  (kindle.exe:Wine: kindle-scroll)))
        ("C-." . '((Lxterminal "ESC" ".") (XTerm "ESC" ".") (Gnome-terminal "ESC" ".") (Xfce4-terminal "ESC" ".")))
        ("C-," . '((Lxterminal "ESC" ",") (XTerm "ESC" ",") (Gnome-terminal "ESC" ",") (Xfce4-terminal "ESC" ",")))
        ("C-?" . '((Lxterminal "ESC" "?") (XTerm "ESC" "?") (Gnome-terminal "ESC" "?") (Xfce4-terminal "ESC" "?")))
        ("M-v" . '((qpdfview "BS") (t "Prior")))
        ("M-<" . '((qpdfview "Home")
                   (t "C-Home")))
        ("M-d" . '((t "C-S-Right" "DEL")))
        ("M->" . '((qpdfview "End")
                   (t "C-End")))
        ("C-r" . '((Firefox "C-g") (Firefox-esr "C-g") (Iceweasel "C-g") (Okular "S-F3") (t "C-S-g")))
        ("C-k" . '((t "S-End" "DEL")))
        ("M-BS" . '((t "C-S-Left" "DEL")))
        ("C-p" . '((t "Up")))
        ("C-n" . '((t "Down")))
        ("M-Left" . '((qpdfview "C-RET")
                      (t nil)))
        ("M-Right" . '((qpdfview "C-S-RET")))
        ("C-x" . '((t c-x-map)))
        ("Super-&" . '((Wrench "Meta-&")))
        ("F11" . '((Wine mm6-drop)))
        ("F12" . '((Wine mm6-heal)))
        ("Super-*" . '((Wrench "Meta-*")))))

(setq wine-global-emacs-remap-alist
      '(("o" . '((Wine "s")))
        ("F1" . '((Wine mm6-save)))
        ("F2" . '((Wine mm6-load)))
        ("F3" . '((Wine mm6-bless)))
        ("F4" . '((Wine mm6-heroism)))
        ("F5" . '((Wine mm6-dragon-fly)))
        ("F6" . '((Wine mm6-wizard-eye)))
        ("F7" . '((Wine mm6-torch)))
        ("F8" . '((Wine mm6-cure-weakness)))
        ("F9" . '((Wine mm6-stone-skin)))
        ("F10" . '((Wine mm6-regeneration)))
        ("ISO_Left_Tab" . '((Wine mm6-reverse-tab)))
        ("&" . '((Wine mm6-1)))
        ("[" . '((Wine mm6-2)))
        ("{" . '((Wine mm6-3)))
        ("}" . '((Wine mm6-4)))
        ("(" . '((Wine mm6-5)))
        ("=" . '((Wine mm6-drop)))
        ("j" . '((Wine mm6-c)))
        ("F23" . '((Wine "F2")))))


(when (file-exists-p "~/.config/system-config/playing-mm6")
  (setq global-emacs-remap-alist (append global-emacs-remap-alist wine-global-emacs-remap-alist)))

(defun mm6-reverse-tab ()
  (system "xdotool-when-keyboard-clear key Tab Tab Tab&"))

(defun mm6-c ()
  (system "xdotool-when-keyboard-clear key c&"))

(defun mm6-drop ()
  (system "mm6 drop&"))

(defun mm6-heal ()
  (system "mm6 cast heal&"))

(defun this-key-is-dead ()
  (system "alarm 0m This key is dead, check your ~/.sawfishrc&"))

(defun kindle-scroll ()
  (system (format nil "kindle-scroll '%s'&" (event-name (current-event)))))

(defun mm6-dragon-fly ()
  (system "mm6 cast air.fly&"))

(defun mm6-bless ()
  (system "mm6 cast bless&"))

(defun mm6-regeneration ()
  (system "mm6 cast regeneration&"))

(defun mm6-shield ()
  (system "mm6 cast shield&"))

(defun mm6-stone-skin ()
  (system "mm6 cast stone.skin&"))

(defun mm6-heroism ()
  (system "mm6 cast heroism&"))

(defun mm6-wizard-eye ()
  (system "mm6 cast eye&"))

(defun mm6-torch ()
  (system "mm6 cast torch&"))

(defun mm6-cure-weakness ()
  (system "mm6 cast cure.weakness&"))

(defun mm6-1 ()
  (system "mm6 1&"))

(defun mm6-2 ()
  (system "mm6 2&"))

(defun mm6-3 ()
  (system "mm6 3&"))

(defun mm6-4 ()
  (system "mm6 4&"))

(defun mm6-5 ()
  (system "mm6 5&"))

(defun mm6-save ()
  (system "mm6 save&"))

(defun mm6-load ()
  (system "mm6 load&"))

(bind-both-global&window-keymaps "Super-XF86Favorites" '(system "sawfish-gimp-stroke&"))

(defun do-bind-keys-nil-unbind (keymap from to window-mapped-to class)
  (bind-keys-nil-unbind
   keymap
   from
   (cond
    ((null window-mapped-to)
     nil)
    ((symbolp window-mapped-to)
     (symbol-value (get-window-map to class)))
    (t
     `(classed-key-synthesize ,from ,to)))))

;;; sawfish 和 xdotools 好像不能一起用，必须做成异步的。另外，如果
;;; Escape 还被绑定成 esc-map 的话，再怎么发送这个键，还是不停地调用 esc-map
(defun send-esc ()
  (system "
# {%sh-mode%}
  (
      sawfish-client -e '(unbind-both-global&window-keymaps \"ESC\")';
      sleep .1;
      xdotool key Escape;
      sawfish-client -e '(bind-both-global&window-keymaps \"ESC\" esc-map)'
  )&
# {%/sh-mode%}
EOF856ceee4ab57
"))

(defun do-global-emacs-remap(class)
  (mapc (lambda (key-map-1)
          (let* ((from (car key-map-1))
                 (to (cdr key-map-1))
                 (window-mapped-to (get-window-map to class)))
            (when (string-match "^M-" from 0 nil)
              (bind-keys esc-map (substring from 2) `(classed-key-synthesize ,from ,to)))
            (bind-keys c-x-map from `(synthesize-event-gnome? ,from ,(input-focus)))
            (do-bind-keys-nil-unbind global-keymap from to window-mapped-to class)))
        global-emacs-remap-alist)
  (mapc (lambda (key-map-1)
          (let* ((from (substring (car key-map-1) 4))
                 (to (cdr key-map-1))
                 (window-mapped-to (get-window-map to class)))
            (do-bind-keys-nil-unbind esc-g-map from to window-mapped-to class)))
        esc-g-remap-alist)
  (bind-both-global&window-keymaps "ESC" esc-map)
  (bind-keys esc-map "ESC" '(send-esc))
  (bind-keys s-h-keymap "C-x" c-x-map)
  (bind-keys esc-map "g" esc-g-map))

(defun undo-global-emacs-remap(class)
  (mapc (lambda (key-map-1)
          (let ((from (car key-map-1))
                (to (cdr key-map-1))
                window-mapped-to)
            (if (assoc class (cadr to))
                (progn
                  (setq window-mapped-to (get-window-map to class))
                  (do-bind-keys-nil-unbind global-keymap from to window-mapped-to class))
              (unbind-both-global&window-keymaps from))))
        global-emacs-remap-alist)
  (unbind-both-global&window-keymaps "C-x")
  (unbind-both-global&window-keymaps "ESC"))

(setq no-tap-drag-window-class-re "acroread")

(defun do-focus-global-remap-hook (w focus-mode)
  (do-focus-global-remap w focus-mode))

(defun on-window-deleted (&optional w)
  (activate-window (car (stacking-order))))

(add-hook 'destroy-notify-hook on-window-deleted)

(defun focus-debug (w focus-debug)
  (message "focus in/out"))

; (add-hook 'focus-in-hook focus-debug)

(defun do-focus-global-remap (w focus-mode)
  (let ((class (bhj-window-class w)))
    (if (string-match emacs-style-window-class-re class 0 t)
        (undo-global-emacs-remap (intern class)) ; it will map emacs style windows if specified
      (do-global-emacs-remap (intern class)))
    (if (string-match x11-windows-re class 0 t)
        (setq bhj-current-window-is-gtk? nil)
      (setq bhj-current-window-is-gtk? t))
    (if (string-match no-tap-drag-window-class-re class 0 t)
        (system "synclient TapAndDragGesture=0&")
      (system "synclient TapAndDragGesture=1&"))))
(add-hook 'focus-in-hook do-focus-global-remap-hook)

;; (setq focus-in-hook (cons (nth 2 focus-in-hook)
;;                         (cons (nth 4 focus-in-hook))))

;; to clear it: (setq visibility-notify-hook nil)

(bind-keys s-h-keymap "Super-s" 'iswitch-window)
(bind-keys s-h-keymap "Super-f" '(maximize-window-fullscreen-toggle (input-focus)))

(bind-keys window-keymap "Button1-Click" 'raise-and-pass-through-click)

(mapc
 (lambda (arg)
   (let ((wclass nil) (wmark nil))
     (bind-both-global&window-keymaps (concat "C-M-" (format nil "%d" arg))
                                      (lambda ()
                                        (setq wmark (input-focus))
                                        (setq wclass (bhj-window-class (input-focus)))))
     (bind-both-global&window-keymaps (concat "Super-" (format nil "%d" arg))
                                      (lambda ()
                                        (if (and  (windowp wmark) (window-mapped-p wmark))
                                            (bhj-activate-window wmark)
                                          (if wclass
                                              (find-window-or-exec wclass)))))))
 '(0 1 2 3 4 5 6 7 8 9))

(defvar super-key-window-remap nil
  "Window specific remap list for super-keys")

(setq super-key-window-remap
      `(("v" . ((Dia . "C-v")
                (Lxterminal . "C-S-v")
                (Gnome-terminal . "C-S-v")
                (Xfce4-terminal . "C-S-v")
                (QtCreator . ("M-e" "p"))
                (XTerm . ,(lambda () (system "paste-xterm&")))
                (t . "S-Insert")))
        ("n" . ((Firefox . "Down") (Firefox-esr . "Down") (Iceweasel . "Down")))
        ("y" . ((Dia . "S-C-z")
                (Qtcreator . "S-C-z")))
        ("f" . ((t . "C-f")))
        ("b" . ((t . "C-b")))
        ("c" . ((Emacs . "M-w")
                (Konsole . "C-S-c")
                (QtCreator . ("M-e" "c"))
                (Lxterminal . "C-S-c")
                (XTerm . ,(lambda () (system "xclip-to-gclip&")))
                (Xfce4-terminal . "C-S-c")
                (Gnome-terminal . "C-S-c")
                (t . "C-c")))
        ("s" . ((Gimp . ("C-M-s"))
                (Gimp-2.8 . ("C-M-s"))
                (Gjiten . ("M-x" "TAB" "TAB" "TAB" "TAB" "TAB" "TAB" "RET"))
                (Qtcreator . "C-S-s")))))
(setq super-key-window-remap
      (update-all-firefox-keys super-key-window-remap
                               "f" '("C-Next")
                               "b" '("C-Prior")))

(setq x11-windows-re "firefox|emacs|xterm|wrench|gjiten|gimp")

;; ref. /usr/include/X11/keysymdef.h
(defun rewrite-event-for-xdotool (event)
  (let* ((keys-break-down (string-split "-" event))
         (modifiers (reverse (cdr (reverse keys-break-down))))
         (main-key (last keys-break-down))
         (result ""))
    (while modifiers
      (case (intern (car modifiers))
        ((C Control)
         (setq result (concat result "ctrl+")))
        ((S Shift)
         (setq result (concat result "shift+")))
        ((M Meta)
         (setq result (concat result "alt+")))
        ((Super)
         (setq result (concat result "super+"))))
      (setq modifiers (cdr modifiers)))
    (cond
     ((string= main-key "RET")
      (setq main-key "Return"))
     ((string= main-key "DEL")
      (setq main-key "Delete"))
     ((string= main-key "ESC")
      (setq main-key "Escape")))
    (setq result (concat result main-key))))

(define (read-event-quietly #!optional prompt)
  (call-with-keyboard-grabbed
   (lambda ()
     (unwind-protect
         (let
             ((override-keymap '(keymap))
              (unbound-key-hook
               (list (lambda ()
                       (throw 'read-event (current-event))))))
           (catch 'read-event
             (recursive-edit)))))))

(defun synthesize-event-gnome? (event window)
  ;;(message (format nil "doing event %s for %s" event (event-name (current-event))))
  (if (not bhj-current-window-is-gtk?)
      (synthesize-event event window)
    (let ((current-key (string-replace ".*-" "" (event-name (current-event))))
          (current-key-xdo-release))
      (when (string= current-key "")
        (setq current-key "-"))
      (setq event (rewrite-event-for-xdotool event)
            current-key (rewrite-event-for-xdotool current-key))
      (setq current-key-xdo-release (format nil "-%s" current-key))
      (if (boundp 'xdo-event)
          (xdo-events (list current-key-xdo-release event))
        (system
         ;;(format nil "export LD_LIBRARY_PATH=/home/bhj/src/reading/xdotool-3.20160805.1; export DEBUG=true; (set -x; xdotool keyup %s; xdotool key --clearmodifiers %s) > ~/tmp/xdoxdo.log 2>&1"
         (format nil "xdotool keyup %s; xdotool key --clearmodifiers %s"
                 current-key
                 event))))))

(defun my-debug (fmt &rest args)
  (message (apply format nil fmt args)))

(defun super-key-binding (key)
  ;; (message (format nil "calling %s for %s" key (bhj-window-class (input-focus)) ))
  (let* ((fw (input-focus))
         (class (bhj-window-class fw))
         (map-to (or (cdr (or (assoc (intern class) (assoc key super-key-window-remap))
                              (assoc t (assoc key super-key-window-remap))))
                     (concat "C-" key))))
    (cond
     ((functionp map-to)
      (funcall map-to))
     ((listp map-to)
      (mapc (lambda (map-1)
              (synthesize-event-gnome? map-1 (input-focus)))
            map-to))
     (t (synthesize-event-gnome? map-to (input-focus))))))

(defun bind-super-key (key)
  (bind-both-global&window-keymaps
   (concat "Super-" key)
   `(super-key-binding ,key)))

(mapc
 #'bind-super-key
 '("a" "b" "c" "d" "e" "f" "g" "i" "j" "k" "l" "m" "n" "o" "p" "r" "s" "t" "u" "v" "w" "x" "y" "z"))

(bind-both-global&window-keymaps "Super-Insert"  '(system "send-key&"))
(bind-both-global&window-keymaps "Super-S-RET"  '(system "send-key&"))
(bind-both-global&window-keymaps "Super-RET" '(synthesize-event "Menu" (input-focus)))
(bind-both-global&window-keymaps "Super-BS" '(synthesize-event "Prior" (input-focus)))
(bind-both-global&window-keymaps "Super-Control-o"  '(system "emacsclient -n ~/system-config/doc/notes.org&"))


(bind-keys s-h-keymap "Super-d"
           (lambda ()
             (if (not (showing-desktop-p))
                 (show-desktop)
               (hide-desktop))))

(bind-keys s-h-keymap "r" 'bhj-run-application)
(bind-keys s-h-keymap "Super-r" '(system "run&"))

(require 'sawfish.wm.commands.x-cycle)

(setq im-class "QQ.exe|kopete|Pidgin" ;; im = instant messanger
      br-class "iceweasel|Navigator|firefox|epiphany-browser|chromium|Download|Google-chrome" ;; br = browser
      dc-class "libreoffice|DocumentWindow|VCLSalFrame|openoffice|Okular|AcroRd32.exe|kindle.exe|Gimp|Display-|acroread|evince|Gnumeric|mupdf" ;; dc = doc
      mg-class "meld|gimp|gitk|tkdiff|rdesktop" ;; mg = meld/gimp
      fm-class "nautilus|file-roller" ;; fm = file manager
      bhj-cycle-groups (list im-class
                             br-class
                             dc-class))

(define-cycle-command-pair
  'cycle-class-bhj 'cycle-class-bhj-backwards
  (lambda (w)
    (let ((class (bhj-global-cycle-class w)))
      (delete-if-not window-in-cycle-p
                     (filter-windows
                      (lambda (x)
                        (equal (bhj-global-cycle-class x) class))
                      (window-order)))))
  #:spec "%W")

(bind-keys s-h-keymap "Super-c" 'cycle-class-bhj)
(bind-both-global&window-keymaps "Super-$" 'cycle-class-bhj)
(bind-keys s-h-keymap "c"  '(system "EMACS=t do-capture&"))

(define-cycle-command-pair
  'cycle-im-window 'cycle-im-windows-backwards
  (lambda () (filter-windows
              (lambda (x) (string-match im-class (bhj-window-class x)))
              (stacking-order))))

(define-cycle-command-pair
  'cycle-br-window 'cycle-br-window-backwards
  (lambda () (filter-windows
              (lambda (x) (string-match br-class (bhj-window-class x)))
              (stacking-order))))

(define-cycle-command-pair
  'cycle-dc-window 'cycle-dc-window-backwards
  (lambda () (filter-windows
              (lambda (x) (string-match dc-class (bhj-window-class x)))
              (stacking-order))))

(define-cycle-command-pair
  'cycle-mg-window 'cycle-mg-window-backwards
  (lambda () (filter-windows
              (lambda (x) (string-match mg-class (bhj-window-class x)))
              (stacking-order))))

(define-cycle-command-pair
  'cycle-fm-window 'cycle-fm-window-backwards
  (lambda () (filter-windows
         (lambda (x) (and (string-match fm-class (bhj-window-class x))
                     (not (string-match "x-nautilus-desktop" (window-name x)))))
         (stacking-order))))

(bind-both-global&window-keymaps "C-ESC" '(synthesize-event "ESC" (input-focus)))
(bind-keys s-h-keymap "g"  '(system "find-or-exec Gimp&"))
(bind-keys s-h-keymap "w"  '(system "find-or-exec wine&"))
(bind-keys s-h-keymap "m" 'move-window-interactively)
(bind-keys s-h-keymap "y" '(system "em kill-ring&"))
(bind-keys s-h-keymap "l" '(system "sawfish-move-to-laptop&"))
(bind-keys s-h-keymap "Super-l" '(system "switch-to-laptop&"))
(bind-keys s-h-keymap "L" '(system "sawfish-move-to-home-screen&"))
(bind-keys s-h-keymap "Super-p" '(system "illPass&"))
(bind-keys s-h-keymap "Super-P" '(system "illPass --confirm&"))
(bind-keys s-h-keymap "Super-a" '(system "abbrevs&"))
(bind-keys s-h-keymap "Super-SPC" '(synthesize-event-gnome? "Menu" (input-focus)))
(bind-keys s-h-keymap "Super-+" '(system "terminal-font-change +&"))
(bind-keys s-h-keymap "Super--" '(system "terminal-font-change -&"))

(defun ime-toggle-hook (w focus-mode)
  (ime-toggle w focus-mode))

(defun ime-toggle (w focus-mode)
  (if (string= (bhj-window-class w) "rdesktop")
      (bind-both-global&window-keymaps "M-C-RET" '(system "toggle-rdesktop-keys&"))
    (system "toggle-rdesktop-keys off&"))
  (if (string= (bhj-window-class w) "Emacs")
      (unbind-both-global&window-keymaps "Super-\\")
    (bind-both-global&window-keymaps "Super-\\"  '(system "xdotool-when-keyboard-clear key shift+F12&"))))

(add-hook 'focus-in-hook ime-toggle-hook)

(system "~/system-config/bin/sawfish-auto-start&")
(bind-keys esc-map "x" esc-x-keymap)

(mapc (lambda (start-and-end)
        (let ((start (car start-and-end))
              (end (cdr start-and-end)))
          (do ((c start))
              ((> c end) nil)
            (setq cs (format nil "%c" c))
            (bind-keys esc-x-keymap cs `(synthesize-event-gnome? ,(format nil "M-%s" cs) (input-focus)))
            (setq c (1+ c)
                  cs (format nil "%c" c)))))
      '((?a . ?z) (?A . ?Z)))

(bind-keys esc-x-keymap "RET" '(synthesize-event-gnome? "M-RET" (input-focus)))

(defun synthesize-multiple-events (&rest events)
  (mapc (lambda (e)
          (synthesize-event e (input-focus)))
        events))


(bind-both-global&window-keymaps "XF86Calculator"  '(system "sawfish-window-custom-menu&"))
(bind-both-global&window-keymaps "Pause"  '(system "sawfish-window-custom-menu&"))

(defun unload-keys-in-file (file)
  (let* ((file (open-file file 'read))
         (event "")
         (line ""))
    (while (setq line (read-line file))
      (when (string-match "bind-both-global&window-keymaps\\s+\"(.*?)\"" line)
        (setq event (expand-last-match "\\1"))
        (unbind-both-global&window-keymaps event)))
    (close-file file)))

(bind-both-global&window-keymaps "XF86ScrollUp" '(system "am dvp&"))
(bind-both-global&window-keymaps "XF86ScrollDown" '(system "am dvp&"))
(bind-both-global&window-keymaps "Super-M-C-m" '(system "am dvp&"))
(bind-both-global&window-keymaps "Super-M-C-M" '(system "ma&"))
                                        ; some times the keyboard itself got scrambled
(bind-both-global&window-keymaps "M-Mod1-C-m" '(system "am dvp&"))

(defun keypad-number-on ()
  (unload-keys-in-file "~/system-config/.sawfish/lisp/keypad-music.jl")
  (load-file "~/system-config/.sawfish/lisp/keypad.jl"))

(defun keypad-number-off ()
  (load-file "~/system-config/.sawfish/lisp/keypad-music.jl"))

(bind-both-global&window-keymaps "Super-KP_Enter" '(system "toggle-number-lock&"))
(bind-both-global&window-keymaps "Super-M-C-DEL" '(system "toggle-number-lock&"))

(bind-keys s-h-keymap "?"
           '(read-event (format nil "%s" (lookup-event-binding (read-event)))))

(bind-keys s-h-keymap "F12" '(system "toggle-dvp-us.sh&"))
(bind-both-global&window-keymaps "Super-(" '(system "sawfish-start-macro&"))
(bind-keys s-h-keymap "e" '(system "sawfish-play-macro&"))
(bind-both-global&window-keymaps "XF86Mail" '(synthesize-multiple-events "C-x" "C-s" "C-x" "#"))
(bind-both-global&window-keymaps "Super-F3" '(synthesize-multiple-events "C-x" "C-s" "C-x" "#"))
(bind-both-global&window-keymaps "XF86HomePage" '(system "edit-with-emacs&"))
(bind-keys s-h-keymap "Super-F1" '(system "edit-with-emacs region&"))
(bind-keys s-h-keymap "k" '(system "sawfish-help-key&"))
(bind-keys s-h-keymap "Super-k" '(system "sawfish-help-key-ask-map&"))
(bind-both-global&window-keymaps "Super-ESC" '(system "sawfish-clean-screen&"))
(bind-both-global&window-keymaps "Print" print-keymap)
(bind-keys print-keymap "Print" '(system "screenshot --full&"))
(bind-keys print-keymap "f" '(system "screenshot --full&"))
(bind-keys print-keymap "d" '(system "screenshot -d&"))
(bind-keys print-keymap "w" '(system "screenshot -d&"))
(bind-keys print-keymap "s" '(system "screenshot --selected&"))
(bind-keys print-keymap "S" '(system "screenshot --selected --edit&"))
(bind-keys print-keymap "c" '(system "screenshot --current&"))
(bind-keys print-keymap "k" '(system "sawfish-get-screen-shot-whole&"))
(bind-keys print-keymap "e" '(system "e-screen-exchange&"))
(bind-keys print-keymap "t" '(system "edit-terminal-capture&"))
(bind-keys print-keymap "p" '(system "adb-get-screenshot-for-emacs-org&"))
(bind-keys s-h-keymap "a" '(system "find-or-exec 'qpdfview|okular|kindle|Display|Gimp|Yad|libreoffice'&"))
(bind-keys s-h-keymap "A" '(system "adb-ignite-device&"))
(bind-both-global&window-keymaps "Super-Control-F1" '(system "sawfish-force-maximize&"))
(bind-keys s-h-keymap "Super-XF86Favorites" '(let ((w (input-focus))) (hide-window w) (show-window w)))
(bind-keys s-h-keymap "Super-v" '(system "sendtext-sawfish&"))
(bind-keys s-h-keymap "C-p" '(system "sawfish-show-pointer&"))
(bind-keys s-h-keymap "M-C-p" '(system "sawfish-show-pointer&"))
(bind-keys s-h-keymap "M-C-c" '(system "sawfish-get-pointer-color&"))
(bind-keys s-h-keymap "C-XF86Favorites" '(system "mm6 all&"))
(bind-keys s-h-keymap "F23" '(raise-window-depth (input-focus)))
(bind-keys s-h-keymap "F24" '(lower-window-depth (input-focus)))
(bind-keys s-h-keymap "SPC" '(set-window-depth (input-focus) 0))

(bind-both-global&window-keymaps "XF86Favorites" '(system "wrench-show-notifications.sh&"))
(bind-both-global&window-keymaps "Super-F9" '(system "wrench-show-notifications.sh&"))


(defun get-window-xy-size (class)
  (let ((x 100000)
        (y 100000)
        (X 0)
        (Y 0))
    (mapcar (lambda (w) (let* ((wx (+ (car (window-position w))))
                          (wy (+ (cdr (window-position w))))
                          (wX (+ wx (car (window-frame-dimensions w))))
                          (wY (+ wy (cdr (window-frame-dimensions w)))))
                     (when (> x wx)
                       (setq x wx))
                     (when (> y wy)
                       (setq y wy))
                     (when (< X wX)
                       (setq X wX))
                     (when (< Y wY)
                       (setq Y wY))))
            (filter (lambda (w) (string-equal class (bhj-window-class w))) (managed-windows)))
    (format nil "-x %d -y %d --width %d --height %d" x y (- X x) (- Y y))))

(bind-keys window-keymap "Super-q"
           (lambda ()
             (let ((window (input-focus)))
               (unless (equal (bhj-window-class window) "Xfce4-panel")
                 (delete-window-safely window)))))

(bind-both-global&window-keymaps "Super-Q"
                                 (lambda ()
                                   (let* ((window (input-focus))
                                          (class (bhj-window-class window)))
                                     (unless (equal class "Xfce4-panel")
                                       (delete-window-class-safely class)))))

(bind-both-global&window-keymaps "Super-h" s-h-keymap)
(bind-both-global&window-keymaps "Super-Menu" '(system "sawfish-fix-key&"))
(bind-both-global&window-keymaps "Super-S-Menu" '(system "sawfish-fix-key -a&"))
(defun xdo-events (events)
  (when (stringp events)
    (setq events (cons events)))
  (while events
    (xdo-event (car events) (input-focus))
    (setq events (cdr events))))

(bind-keys s-h-keymap "F1" '(system "ewe&"))
(bind-keys s-h-keymap "F2" '(system "sawfish-xf86search&"))
(bind-keys s-h-keymap "F3" '(synthesize-multiple-events "C-x" "C-s" "C-x" "#"))
(bind-keys s-h-keymap "F4" '(system "EMACS=t do-capture&"))
(bind-keys s-h-keymap "F5" '(system "Wrench-or-Emacs&"))
(bind-keys s-h-keymap "F6" '(system "find-or-exec gjiten gjiten&"))
(bind-keys s-h-keymap "F7" '(system "custom-command&"))
(bind-keys s-h-keymap "F8" '(system "EMACS=t ssssh&"))
(bind-keys s-h-keymap "F9" '(system "wrench-show-notifications.sh&"))
(bind-keys s-h-keymap "F10" '(system "sawfish-window-custom-menu&"))


;;; some keys for debugging
(bind-both-global&window-keymaps "Super-F11" '(xdo-events '("-F11" "d")))
(bind-keys s-h-keymap "F11" '(xdo-events '("-F11" "d")))
;; (bind-both-global&window-keymaps "Super-F11" '(synthesize-event "c" (input-focus)))
;; (bind-both-global&window-keymaps "Super-F11" (lambda ()))
(system "bhj-notify sawfish 'load complete'&")