mirror of
https://github.com/pestctrl/emacs-config.git
synced 2026-02-16 08:14:15 +00:00
29 KiB
29 KiB
- e2wm
- desktop-environment
- Meta
- Naming Windows
- exwm-x stuff and naming windows
- Youtube split
- Disable simulation keys on an emacs window
- Custom keymap
- exwm-background
- toggle dedicated
- This is so that I can send fullscreen windows to the back
- Switch window
- Multimonitor support
- Keybindings
- Helper functions
- Simulation keys
- Startup
- Shutdown
- Xephyr launches in tiling-mode
- Wallpaper
- Volume
- exwm-edit
- workspace manipulation
- Floating windows don't need that many faces ^_^
e2wm
(use-package e2wm
:bind (("M-+" . e2wm:start-management)))desktop-environment
(use-package desktop-environment
:init
(desktop-environment-mode))Meta
(use-package exwm)
(require 'exwm-config)
(exwm-config-default)Naming Windows
(defvar my/window-name nil)
(defun exwmx-name-buffer ()
(interactive)
(let* ((xprograms (mapcar (lambda (a) (plist-get a :instance)) (exwmx-appconfig--get-all-appconfigs)))
(name (completing-read "Name: " xprograms)))
(if (and (get-buffer name)
(not (equal (get-buffer name) (current-buffer)))
(y-or-n-p (format "Already a buffer named \"%s\". Would you like to swap?" name)))
(let ((oname (completing-read "Name of other buffer: " xprograms)))
(exwm-workspace-rename-buffer "This is a stupid name that no one would ever choose for a buffer, hopefully")
(save-window-excursion
(switch-to-buffer (get-buffer name))
(exwm-workspace-rename-buffer oname)
(setq-local exwm-instance-name oname))
(exwm-workspace-rename-buffer name)
(setq-local exwm-instance-name name))
(exwm-workspace-rename-buffer name)
(setq-local exwm-instance-name name))))
(defun exwm-rename-buffer ()
(interactive)
(when my/window-name
(exwm-workspace-rename-buffer my/window-name)
(setq-local exwm-instance-name my/window-name)
(setq my/window-name nil)))
;; Add these hooks in a suitable place (e.g., as done in exwm-config-default)
(add-hook 'exwm-manage-finish-hook 'exwm-rename-buffer)
(defun launch-program-with-name (cmd name)
(interactive)
(when name (setq my/window-name name))
(start-process-shell-command cmd nil cmd))exwm-x stuff and naming windows
(use-package exwm-x)
(require 'exwmx-quickrun)
(defun exwmx-quickrun (command &optional search-alias ruler)
(exwmx--switch-window)
(let* ((ruler-plist-p (and ruler (exwmx--plist-p ruler)))
(keys
;; Deal with ruler which is like (:class :instance :title)
(if (and ruler (listp ruler) (not ruler-plist-p))
(exwmx--clean-keylist ruler)
'(:class :instance)))
(appconfigs (exwmx-appconfig--get-all-appconfigs))
(cmd (if search-alias
(or (plist-get (exwmx-appconfig--search
`((:alias ,command)))
:command)
(when appconfigs
(let ((appconfig (exwmx-appconfig--select-appconfig)))
(plist-put appconfig :alias command)
(exwmx-appconfig--add-appconfig appconfig)
(plist-get appconfig :command))))
command))
(buffer (or (if search-alias
(exwmx-quickrun--find-buffer
(if ruler-plist-p
ruler
(exwmx-appconfig--get-subset
(exwmx-appconfig--search
`((:alias ,command)))
keys)))
(exwmx-quickrun--find-buffer
(if ruler-plist-p
ruler
(exwmx-appconfig--get-subset
(exwmx-appconfig--search
`((:command ,command)))
keys)))))))
(if (and search-alias (not cmd))
(message "EXWM-X: please run `exwmx-appconfig' to add appconfig.")
(message "EXWM-X Quick Run: %s" cmd))
;; If current application window is a floating-window, minumize it.
(when (and (eq major-mode 'exwm-mode)
exwm--floating-frame)
(exwm-floating-hide))
(if buffer
(exwm-workspace-switch-to-buffer buffer)
(when cmd
(launch-program-with-name cmd (plist-get ruler :instance))))))
(defun exwmx-quickrun--find-buffer (ruler)
"Find a exwm buffer which match `ruler', ruler is
a plist with three keys: :class, :instance and :title."
(let ((current (current-buffer))
(buffers (buffer-list))
(result '()))
(while buffers
(let ((buffer (pop buffers))
(class (plist-get ruler :class))
(instance (plist-get ruler :instance))
(title (plist-get ruler :title)))
(with-current-buffer buffer
(when (and (or class instance title)
(exwmx--string-match-p (or class ".*") exwm-class-name)
(exwmx--string-match-p (or (concat "^" instance "$") ".*") exwm-instance-name)
(exwmx--string-match-p (or title ".*") exwm-title))
(push buffer result)))))
(setq result (reverse result))
;; If two more buffers are found, switch between these buffer.
(if (and (cadr result)
(eq (car result) current))
(cadr result)
(car result))))
(defmacro quickrun-lambda (cmd instance)
(if (null instance)
`(lambda ()
(interactive)
(exwmx-quickrun ,cmd))
`(lambda ()
(interactive)
(exwmx-quickrun ,cmd nil '(:class ".*" :instance ,instance)))))
(use-package dmenu)
(make-thread
#'dmenu--cache-executable-files)
(defun read-program ()
(funcall #'ido-completing-read "$ "
(append dmenu--history-list
(cl-remove-if (lambda (x)
(member x dmenu--history-list))
dmenu--cache-executable-files))))
(defun launch-program (command &optional process-name)
(interactive (list (read-program)))
(setq dmenu--history-list (cons command (remove command dmenu--history-list)))
(when (> (length dmenu--history-list)
dmenu-history-size)
(setcdr (nthcdr (- dmenu-history-size 1)
dmenu--history-list)
nil))
(let ((name (or process-name command)))
(start-process-shell-command name nil command)))
(defun exwmx-launch-program (command &optional process-name)
(interactive (list (read-program)))
(setq dmenu--history-list (cons command (remove command dmenu--history-list)))
(when (> (length dmenu--history-list)
dmenu-history-size)
(setcdr (nthcdr (- dmenu-history-size 1)
dmenu--history-list)
nil))
(exwmx-quickrun command))
;; (exwmx-quickrun "firefox" nil '(:class ".*" :instance "School"))
;; (exwmx-quickrun--find-buffer '(:class ".*" :instance "Hello"))Youtube split
(defun youtube-split (arg)
(interactive "P")
(let ((buf (get-buffer "youtube"))
(back (current-buffer)))
(delete-other-windows)
(if buf
(switch-to-buffer buf)
(when arg
(launch-program-with-name "firefox" "youtube")))
(side-window-op 'left 472 buf)
(switch-to-buffer back)))
(defun big-youtube-split (arg)
(interactive "P")
(delete-other-windows)
(let ((buf (get-buffer "youtube")))
(if buf
(switch-to-buffer buf)
(when arg
(launch-program-with-name "firefox" "youtube")))
(side-window-op 'left 630 buf)))
(defun side-window-op (side &optional size buffer)
(let ((prev-win (selected-window))
(win (display-buffer-in-side-window
(or buffer (current-buffer))
`((side . ,side)))))
(select-window win)
(set-window-dedicated-p win t)
(set-window-parameter win 'no-delete-other-windows t)
(when size
(window-resize win (- size (window-pixel-width)) t nil t))
(select-window prev-win)))
(defun side-left-window ()
(interactive)
(side-window-op 'left))
(defun side-right-window ()
(interactive)
(side-window-op 'right))
(defun side-bottom-window ()
(interactive)
(side-window-op 'bottom))
(setq window-sides-vertical t)Disable simulation keys on an emacs window
(add-hook 'exwm-manage-finish-hook
(lambda ()
(when (and exwm-class-name (string= exwm-class-name "Emacs"))
(exwm-input-set-local-simulation-keys nil))))Custom keymap
(use-package vterm)
(defmacro exec (body)
`(lambda ()
(interactive)
,body))
(defun toggle-notifications ()
(interactive)
(shell-command "kill -s USR1 $(pidof deadd-notification-center)"))
(add-to-list 'exwm-input-prefix-keys ?\C-t)
(defun simulate-C-t (arg)
(interactive "P")
(if (eq major-mode 'exwm-mode)
(exwm-input--fake-key ?\C-t)
(transpose-chars arg)))
(use-package zeal-at-point)
(define-key *root-map* (kbd "C-d") (quickrun-lambda "zeal" "zeal"))
(define-key *root-map* (kbd "d") #'zeal-at-point)
(define-key *root-map* (kbd "C-t") 'simulate-C-t)
(define-key *root-map* (kbd "C-p") 'exwmx-launch-program)
(define-key *root-map* (kbd "e") (quickrun-lambda "emacs" "emacs"))
(define-key *root-map* (kbd "s") (quickrun-lambda "steam" nil))
(define-key *root-map* (kbd "V") (quickrun-lambda "VBoxManage startvm \"Windows 7\"" "VirtualBox Machine"))
(define-key *root-map* (kbd "r") 'exwmx-name-buffer)
(define-key *root-map* (kbd ")") (lambda () (interactive) (leaving-computer) (shell-command "sleep 2s ; xset dpms force off")))
(define-prefix-command '*window-map*)
(define-key *root-map* (kbd "w") '*window-map*)
(define-key *window-map* (kbd "y") 'youtube-split)
(define-key *window-map* (kbd "Y") 'big-youtube-split)
(define-key *window-map* (kbd "j") 'side-bottom-window)
(define-key *window-map* (kbd "h") 'side-left-window)
(define-key *window-map* (kbd "l") 'side-right-window)
(define-key *window-map* (kbd "d") 'window-toggle-side-windows)
(define-prefix-command '*firefox-map*)
(define-key *firefox-map* (kbd "c") (quickrun-lambda "google-chrome-stable" "chrome"))
(define-key *firefox-map* (kbd "f") (quickrun-lambda "firefox" "firefox"))
(define-key *firefox-map* (kbd "1") (quickrun-lambda "firefox" "firefox1"))
(define-key *firefox-map* (kbd "2") (quickrun-lambda "firefox" "firefox2"))
(define-key *firefox-map* (kbd "3") (quickrun-lambda "firefox" "firefox3"))
(define-key *firefox-map* (kbd "4") (quickrun-lambda "firefox" "firefox4"))
(define-key *firefox-map* (kbd "d") (quickrun-lambda "firefox" "development"))
(define-key *firefox-map* (kbd "s") (quickrun-lambda "firefox" "school"))
(define-key *firefox-map* (kbd "w") (quickrun-lambda "firefox" "work"))
(define-key *firefox-map* (kbd "y") (quickrun-lambda "firefox" "youtube"))
(define-key *root-map* (kbd "f") '*firefox-map*)
(define-prefix-command '*music-map*)
(define-key *music-map* (kbd "SPC") (exec (shell-command "clementine -t")))
(define-key *music-map* (kbd "n") (exec (shell-command "clementine --next")))
(define-key *music-map* (kbd "p") (exec (shell-command "clementine --previous")))
(define-key *music-map* (kbd "r") (exec (shell-command "clementine --restart-or-previous")))
(defhydra clementine-volume-hydra (*music-map* "v")
"Clementine volume up and down"
("j" (lambda () (interactive) (shell-command "clementine --volume-down")))
("J" (lambda () (interactive) (shell-command "clementine --volume-decrease-by 25")))
("k" (lambda () (interactive) (shell-command "clementine --volume-up")))
("K" (lambda () (interactive) (shell-command "clementine --volume-increase-by 25")))
("q" nil))
(define-key *root-map* (kbd "m") '*music-map*)exwm-background
(add-to-list 'load-path "~/.emacs.d/submodule/exwm-background/")
(require 'exwm-background)
(define-key *window-map* (kbd "t") 'exwm-background/window-transparency-hydra/body)
(setq window-system-default-frame-alist `((x . ((alpha . (,exwm-background/current-transparency . 50))))))
(exwm-global-set-key (kbd "s-v") #'exwm-background/toggle-viewing-background)
(exwm-global-set-key (kbd "s-b") #'exwm-background/exwm-background-window) ;; TODO: Fix keybinding
(define-key desktop-environment-mode-map (kbd "<S-XF86MonBrightnessDown>") #'exwm-background/decrease-transparency)
(define-key desktop-environment-mode-map (kbd "<S-XF86MonBrightnessUp>") #'exwm-background/increase-transparency)
(define-key *window-map* (kbd "b") #'exwm-background/exwm-background-window)
(define-key *root-map* (kbd "k") #'exwm-background/exwm-send-key-to-background)
(define-key *root-map* (kbd "C-k") #'exwm-background/exwm-send-key-to-background-loop)toggle dedicated
(defun my/toggle-dedicated-window ()
(interactive)
(let ((win (selected-window)))
(set-window-dedicated-p win (not (window-dedicated-p win)))))This is so that I can send fullscreen windows to the back
(cl-defun my/exwm-layout-set-fullscreen (&optional id)
"Make window ID fullscreen."
(interactive)
(exwm--log "id=#x%x" (or id 0))
(unless (and (or id (derived-mode-p 'exwm-mode))
(not (exwm-layout--fullscreen-p)))
(cl-return-from exwm-layout-set-fullscreen))
(with-current-buffer (if id (exwm--id->buffer id) (window-buffer))
;; Expand the X window to fill the whole screen.
(with-slots (x y width height) (exwm-workspace--get-geometry exwm--frame)
(exwm--set-geometry exwm--id x y width height))
;; Raise the X window.
(xcb:+request exwm--connection
(make-instance 'xcb:ConfigureWindow
:window exwm--id
:value-mask (logior xcb:ConfigWindow:BorderWidth
xcb:ConfigWindow:StackMode)
:border-width 0
:stack-mode xcb:StackMode:Above))
(xcb:+request exwm--connection
(make-instance 'xcb:ewmh:set-_NET_WM_STATE
:window exwm--id
:data (vector xcb:Atom:_NET_WM_STATE_FULLSCREEN)))
(xcb:flush exwm--connection)
;;(set-window-dedicated-p (get-buffer-window) t)
(cl-pushnew xcb:Atom:_NET_WM_STATE_FULLSCREEN exwm--ewmh-state)
(exwm-input--release-keyboard exwm--id)))
(advice-add #'exwm-layout-set-fullscreen :override #'my/exwm-layout-set-fullscreen)Switch window
(setq switch-window-input-style 'minibuffer)Multimonitor support
(require 'exwm-randr)
(exwm-randr-enable)Keybindings
(use-package transpose-frame)
(exwm-global-set-key (kbd "s-r") #'exwm-reset)
(exwm-global-set-key (kbd "s-l") #'lock-screen)
(exwm-global-set-key (kbd "s-c") #'org-capture)
(exwm-global-set-key (kbd "s-n") #'switch-window)
(exwm-global-set-key (kbd "s-k") #'kill-this-buffer)
(exwm-global-set-key (kbd "s-z") #'resize-window)
(exwm-global-set-key (kbd "s-s") #'youtube-split)
(exwm-global-set-key (kbd "s-n") #'switch-to-next-buffer)
(exwm-global-set-key (kbd "s-p") #'switch-to-prev-buffer)
(exwm-global-set-key (kbd "s-a") #'my/toggle-keyboard)
(exwm-global-set-key my/keymap-key '*root-map*)
(exwm-global-set-key (kbd "s-h") 'windmove-left)
(exwm-global-set-key (kbd "s-l") 'windmove-right)
(define-key desktop-environment-mode-map (kbd "s-l") nil)
(defun dvorak? ()
(string-match-p "de(neo_dvorak)"
(shell-command-to-string "setxkbmap -v | grep symbols")))
(defun set-keyboard (layout)
(shell-command (format "setxkbmap %s" layout)))
(defun my/toggle-keyboard ()
(interactive)
(if (dvorak?)
(set-keyboard "us")
(set-keyboard "de neo_dvorak")))
;; Don't do this one, causes blinking
(global-set-key (kbd "C-x p") 'launch-program)
;; These have issues, presumably utf8 or something
(global-set-key (kbd "M-…") 'multi-term)
(global-set-key (kbd "C-ü") 'undo-tree-undo)
(defun prompt-workspace (&optional prompt)
"Prompt for a workspace, returning the workspace frame."
(exwm-workspace--update-switch-history)
(let* ((current-idx (exwm-workspace--position exwm-workspace--current))
(history-add-new-input nil) ;prevent modifying history
(history-idx (read-from-minibuffer
(or prompt "Workspace: ")
(elt exwm-workspace--switch-history current-idx)
exwm-workspace--switch-map nil
`(exwm-workspace--switch-history . ,current-idx)))
(workspace-idx (mod (1- (cl-position history-idx exwm-workspace--switch-history
:test #'equal))
10)))
(elt exwm-workspace--list workspace-idx)))
(advice-add 'exwm-workspace--prompt-for-workspace
:override
#'prompt-workspace)Helper functions
(defvar wallpaper-path "/home/benson/.emacs.d/res/digital_space_universe_4k_8k-wide.jpg")
(defvar live-wallpaper-path "/home/benson/MEGA/pictures/wallpapers/videos/bg.mp4")
(setq i3-string "Xephyr -br -ac -noreset -resizeable -screen 1920x1080 :8 & sleep 1s; DISPLAY=:8 i3")
(setq xfce4-string "Xephyr -br -ac -noreset -resizeable -screen 1920x1080 :8 & sleep 1s; DISPLAY=:8 xfce4-session")
(setq kde-string "Xephyr -br -ac -noreset -resizeable -screen 1920x1080 :8 & sleep 1s; DISPLAY=:8 startkde")
(setq kde+exwm-string "Xephyr -br -ac -noreset -resizeable -screen 1920x1080 :8 & sleep 1s; DISPLAY=:8 KDEWM=/usr/bin/emacs startkde")
(defvar exwm-startup-programs
'("megasync"
"deadd-notification-center"
"/usr/lib/kdeconnectd"
("compton -f -i .7 -b")
;; ("compton -f -i .7 -b --backend glx --blur-background --blur-method kawase --blur-strength 2")
("/usr/lib/polkit-gnome/polkit-gnome-authentication-agent-1")
("/usr/lib/notification-daemon-1.0/notification-daemon")
("nm-applet")
))
(defvar hard-drive-space "")
(defun launch-i3 ()
(interactive)
(launch-program i3-string))
(defun launch-xfce ()
(interactive)
(launch-program xfce4-string))
(defun launch-kde ()
(interactive)
(launch-program kde-string))
(defun launch-kde+emacs ()
(interactive)
(launch-program kde-string))
(defun lock-screen ()
(interactive)
(shell-command "~/Github/my-projects/i3lock-fancy/i3lock-fancy & disown"))
(setq enable-recursive-minibuffers t)
(defun counsel-shell-command ()
"Forward to `shell-command'."
(interactive)
(ivy-read "Shell Command: "
shell-command-history
:caller 'counsel-shell-command))
(defun dmenu-run ()
(interactive)
(shell-command "dmenu" nil "dmenu_run -b"))
(defun call-startup-programs ()
(dolist (program exwm-startup-programs)
(if (listp program)
(launch-program (car program) (cadr program))
(launch-program program))))
(defun setup-wallpaper ()
(launch-program (concat "feh --bg-fill " wallpaper-path) "feh"))
(defun setup-live-wallpaper ()
(if (get-process "xwinwrap")
(delete-process "xwinwrap"))
(launch-program (concat "xwinwrap -ni -ov -g 1920x1080+1280+0 -s -st -sp -nf -- mpv --loop=inf -wid WID " live-wallpaper-path) "xwinwrap"))
(defun get-hard-drive-space ()
(shell-command-to-string "df -h -P -l / | tail -n 1 | tr -s ' ' | cut -d ' ' -f 4"))
(defun update-hard-drive-space-string ()
(setq hard-drive-space
(let ((space-left (get-hard-drive-space)))
(propertize (concat " "
(substring space-left
0
(1- (length space-left))))
'face 'sml/time))))
(defun display-hard-drive-space-mode ()
(if (not (member 'hard-drive-space
global-mode-string))
(add-to-list 'global-mode-string
'hard-drive-space
t)))Simulation keys
(setq exwm-input-simulation-keys
'(
;; movement
([?\C-b] . left)
([?\M-b] . C-left)
([?\C-f] . right)
([?\M-f] . C-right)
([?\C-p] . up)
([?\C-n] . down)
([?\C-a] . home)
([?\C-e] . end)
([?\M-v] . prior)
([?\C-v] . next)
([?\C-d] . delete)
([?\M-d] . backspace)
([?\C-k] . (S-end delete))
;; cut/paste.
([?\C-w] . ?\C-x)
([?\M-w] . ?\C-c)
([?\C-y] . ?\C-v)
;; search
([?\C-s] . ?\C-f)
([?\C-.] . ?\C-w)
([?\C-/] . ?\C-z)
([?\M-s] . ?\C-s)
))Startup
Emacs server, startup programs, wallpaper
(add-hook 'exwm-init-hook 'server-start)
; Reminder: Hooks execute in order. Make sure megasync launches after systemtray is enabled
(add-hook 'exwm-init-hook 'call-startup-programs)
(defvar my/monitor-primary "eDP1")
(defvar my/monitor-secondary nil)
(defun my/get-screens ()
(-> "xrandr | grep ' connected ' | cut -d ' ' -f 1"
(shell-command-to-string)
(split-string "\n")
(reverse)
(cdr)
(reverse)
(cl-sort (lambda (a b)
(cond ((string-match-p "^eDP" a) a)
((string-match-p "^eDP" b) b)
(t a))))))
(defun position-screen (screen relative-to)
(interactive (cl-destructuring-bind (primary . secondary) (my/get-screens)
(list (completing-read "Which screen? " secondary)
(completing-read "Against which screen? " (cons primary secondary)))))
(let ((response (completing-read (format "Resolution for %s? " screen) '("2560x1440" "1920x1080" "3840x2160") nil t "^"))
(pos (completing-read "Position? " '("left-of" "above") nil t "^")))
(shell-command (format "xrandr --output %s --mode %s --%s %s" screen response pos relative-to))))
(defun my/setup-screens ()
(interactive)
(cl-destructuring-bind (primary . secondaries) (my/get-screens)
(loop for secondary in secondaries
do (when (y-or-n-p (format "Monitor %s detected. Setup? " secondary))
(position-screen secondary primary))))
(setup-workspace-monitors)
(setup-wallpaper))
(defun my/disconnect-screen (screen)
(interactive (list (let ((screens (cdr (my/get-screens))))
(or (and (zerop (1- (length screens)))
(car screens))
(completing-read "Which screen? " (cdr (my/get-screens)))))))
(shell-command (format "xrandr --output %s --off" screen))
(setq exwm-randr-workspace-monitor-plist nil)
(setq my/monitor-secondary nil)
(exwm-randr-refresh)
(setup-wallpaper))
(add-hook 'exwm-init-hook 'my/setup-screens)
(define-minor-mode exwm-presentation-mode
"Make both screen outputs display the same thing"
nil nil nil
(cond (exwm-presentation-mode
(cl-destructuring-bind (primary . secondary) (my/get-screens)
(shell-command
(format "xrandr --output %s --mode 1920x1080 --same-as %s"
(car secondary)
primary))
(setq exwm-randr-workspace-monitor-plist nil)
(exwm-randr-refresh)))
(t
(my/setup-screens))))System tray, display time, display battery, display hard-drive-space
(require 'exwm-systemtray)
(exwm-systemtray-enable)
(setq display-time-day-and-date t)
(defvar my/exclude-buffer-modes '(helm-major-mode messages-buffer-mode special-mode))
(defun my-buffer-predicate (buf)
(with-current-buffer buf
(if (memq major-mode my/exclude-buffer-modes)
nil
(exwm-layout--other-buffer-predicate buf))))
(add-hook 'exwm-init-hook
(lambda ()
(interactive)
(modify-all-frames-parameters
'((buffer-predicate . my-buffer-predicate)))))
;; Display hard drive space
(add-hook 'display-time-hook 'update-hard-drive-space-string)
(display-time-mode)
(display-battery-mode)
(display-hard-drive-space-mode)Shutdown
(add-hook 'exwm-exit-hook 'org-save-all-org-buffers)
;;(add-hook 'exwm-exit-hook 'save-org-agenda-files)
(eval-after-load "term"
'(progn
(define-key term-raw-map (kbd "C-c C-y") 'term-paste)
(define-key term-raw-map (kbd "M-x") 'helm-M-x)))Xephyr launches in tiling-mode
(setq exwm-manage-configurations `(((equal exwm-class-name "Xephyr")
floating nil
char-mode t
fullscreen t)
((equal exwm-class-name "plasmashell")
floating t)))Wallpaper
(setq wallpaper-path "/home/benson/.emacs.d/res/digital_space_universe_4k_8k-wide.jpg")Volume
(use-package volume)
(define-key *root-map* (kbd "v") 'volume)exwm-edit
(use-package exwm-edit)workspace manipulation
(setq exwm-workspace-show-all-buffers t
exwm-layout-show-all-buffers t)
(let ((monitors (my/get-screens)))
(setq exwm-workspace-number (length monitors)))
(defvar exwm-randr/current-offset 0)
(defun setup-workspace-monitors ()
(setq exwm-randr/current-offset 0)
(setq exwm-randr-workspace-monitor-plist
(loop for m in (my/get-screens)
for i from 0
collect i
collect m)))
(defun my/get-next-workspace-number ()
(-> exwm-workspace-current-index
1+
(mod 2)))
(defun my/next-workspace ()
(interactive)
(exwm-workspace-switch (my/get-next-workspace-number)))
(exwm-global-set-key (kbd "<s-tab>") #'my/next-workspace)
(defun my/swap-screens ()
(interactive)
(clj-swap exwm-randr/current-offset
(lambda (x)
(mod (1+ x)
2)))
(let ((monitors (my/get-screens)))
(setq exwm-randr-workspace-monitor-plist
(loop for i from 0 below exwm-workspace-number
for m = (nth (mod (+ i exwm-randr/current-offset)
exwm-workspace-number)
monitors)
collect i
collect m)))
(exwm-randr-refresh)
(exwm-workspace-switch (mod (1- exwm-workspace-current-index)
2)))Floating windows don't need that many faces ^_^
(defun my/frame-dont-copy-faces (frame &optional parameters)
"Initialize the frame-local faces of FRAME.
Calculate the face definitions using the face specs, custom theme
settings, X resources, and `face-new-frame-defaults'.
Finally, apply any relevant face attributes found amongst the
frame parameters in PARAMETERS."
;; The `reverse' is so that `default' goes first.
;; (dolist (face (nreverse (face-list)))
;; (condition-case ()
;; (progn
;; ;; Initialize faces from face spec and custom theme.
;; (face-spec-recalc face frame)
;; ;; Apply attributes specified by face-new-frame-defaults
;; (internal-merge-in-global-face face frame))
;; ;; Don't let invalid specs prevent frame creation.
;; (error nil)))
;; Apply attributes specified by frame parameters.
(let ((face-params '((foreground-color default :foreground)
(background-color default :background)
(font default :font)
(border-color border :background)
(cursor-color cursor :background)
(scroll-bar-foreground scroll-bar :foreground)
(scroll-bar-background scroll-bar :background)
(mouse-color mouse :background))))
(dolist (param face-params)
(let* ((param-name (nth 0 param))
(value (cdr (assq param-name parameters))))
(if value
(set-face-attribute (nth 1 param) frame
(nth 2 param) value))))))
(defun my/exwm-floating--advise-make-frame (orig id)
(advice-add 'face-set-after-frame-default
:override
'my/frame-dont-copy-faces)
(funcall orig id)
(advice-remove 'face-set-after-frame-default
'my/frame-dont-copy-faces))
(advice-add #'exwm-floating--set-floating
:around
#'my/exwm-floating--advise-make-frame) (exwm-global-set-key (kbd "s-b") #'wg-undo-wconfig-change)