[clfswm-cvs] r55 - in clfswm: . src
pbrochard at common-lisp.net
pbrochard at common-lisp.net
Tue Mar 25 23:02:25 UTC 2008
Author: pbrochard
Date: Tue Mar 25 18:02:17 2008
New Revision: 55
Modified:
clfswm/ChangeLog
clfswm/TODO
clfswm/clfswm.asd
clfswm/src/bindings-second-mode.lisp
clfswm/src/bindings.lisp
clfswm/src/clfswm-info.lisp
clfswm/src/clfswm-internal.lisp
clfswm/src/clfswm-layout.lisp
clfswm/src/clfswm-nw-hooks.lisp
clfswm/src/clfswm-pack.lisp
clfswm/src/clfswm-second-mode.lisp
clfswm/src/clfswm-util.lisp
clfswm/src/clfswm.lisp
clfswm/src/package.lisp
clfswm/src/xlib-util.lisp
Log:
Rename 'group' in 'frame'. Rename 'childs' in 'children'. keys-from-list new clfswm-info function
Modified: clfswm/ChangeLog
==============================================================================
--- clfswm/ChangeLog (original)
+++ clfswm/ChangeLog Tue Mar 25 18:02:17 2008
@@ -1,3 +1,11 @@
+2008-03-25 Philippe Brochard <hocwp at free.fr>
+
+ * src/clfswm-info.lisp (keys-from-list): new function.
+
+ * src/*: rename 'childs' in 'children'.
+
+ * src/*: rename 'group' in 'frame'.
+
2008-03-22 Philippe Brochard <hocwp at free.fr>
* src/clfswm-pack.lisp (explode-group/explode-current-group): new functions.
Modified: clfswm/TODO
==============================================================================
--- clfswm/TODO (original)
+++ clfswm/TODO Tue Mar 25 18:02:17 2008
@@ -15,7 +15,7 @@
If not -> bind the key to the current-child
Bind alt+control+1/2/3/4... to remove binding on a child.
-- Hook to open next window in named/numbered group [Philippe]
+- Hook to open next window in named/numbered frame [Philippe]
- Undo/redo (any idea to implement this is welcome)
@@ -23,12 +23,16 @@
- Float->Screen Screen->Float: convert geometry from 0 to 1 to pixel and from pixel to 0 to 1. [Philippe]
-- Raise/lower group [Philippe]
+- Raise/lower frame [Philippe]
-- Hide/Unhide group [Philippe]
+- Hide/Unhide frame [Philippe]
- Add boundaries in the info window [Philippe]
+- get-frame-by-name (path) [Philippe]
+ get-frame-by-name (path): return the frame that its own frame has this name if it exists such a frame
+ get-window-by-name (path): return the window that its own frame that its own frame has this name if it exists such a window.
+
MAYBE
=====
@@ -53,6 +57,9 @@
* up
* down
+- Remote access to the clfswm REPL [Philippe]
+
+- cd/pwd a la shell to navigate throu frames. [Philippe]
NEVER
Modified: clfswm/clfswm.asd
==============================================================================
--- clfswm/clfswm.asd (original)
+++ clfswm/clfswm.asd Tue Mar 25 18:02:17 2008
@@ -51,7 +51,7 @@
(:file "bindings"
:depends-on ("clfswm" "clfswm-internal"))
(:file "bindings-second-mode"
- :depends-on ("clfswm" "clfswm-util" "clfswm-query" "bindings"))))))
+ :depends-on ("clfswm" "clfswm-util" "clfswm-query" "bindings" "clfswm-pack"))))))
Modified: clfswm/src/bindings-second-mode.lisp
==============================================================================
--- clfswm/src/bindings-second-mode.lisp (original)
+++ clfswm/src/bindings-second-mode.lisp Tue Mar 25 18:02:17 2008
@@ -38,157 +38,154 @@
;;;;;;;;;;;;;;;
;; Menu entry
;;;;;;;;;;;;;;;
-(defun group-adding-menu ()
- "Adding group menu"
- (info-mode-menu '((#\a add-default-group)
- (#\p add-placed-group))))
-
-(defun group-layout-menu ()
- "Group layout menu"
- (info-mode-menu (loop for l in *layout-list*
- for i from 0
- collect (list (code-char (+ (char-code #\a) i)) l))))
-
-(defun group-nw-hook-menu ()
- "Group new window hook menu"
- (info-mode-menu (loop for l in *nw-hook-list*
- for i from 0
- collect (list (code-char (+ (char-code #\a) i)) l))))
+(defun frame-adding-menu ()
+ "Adding frame menu"
+ (info-mode-menu '((#\a add-default-frame)
+ (#\p add-placed-frame))))
+
+(defun frame-layout-menu ()
+ "Frame layout menu"
+ (info-mode-menu (keys-from-list *layout-list*)))
+
+(defun frame-nw-hook-menu ()
+ "Frame new window hook menu"
+ (info-mode-menu (keys-from-list *nw-hook-list*)))
-(defun group-pack-menu ()
- "Group pack menu"
- (info-mode-menu '(("Up" current-group-pack-up)
- ("Down" current-group-pack-down)
- ("Left" current-group-pack-left)
- ("Right" current-group-pack-right))))
-
-
-(defun group-fill-menu ()
- "Group fill menu"
- (info-mode-menu '(("Up" current-group-fill-up)
- ("Down" current-group-fill-down)
- ("Left" current-group-fill-left)
- ("Right" current-group-fill-right)
- (#\a current-group-fill-all-dir)
- (#\v current-group-fill-vertical)
- (#\h current-group-fill-horizontal))))
-
-(defun group-resize-menu ()
- "Group resize menu"
- (info-mode-menu '(("Up" current-group-resize-up)
- ("Down" current-group-resize-down)
- ("Left" current-group-resize-left)
- ("Right" current-group-resize-right)
- (#\d current-group-resize-all-dir)
- (#\a current-group-resize-all-dir-minimal))))
-
-
-(defun group-movement-menu ()
- "Group movement menu"
- (info-mode-menu '((#\p group-pack-menu)
- (#\f group-fill-menu)
- (#\r group-resize-menu)
- (#\c center-current-group))))
+(defun frame-pack-menu ()
+ "Frame pack menu"
+ (info-mode-menu '(("Up" current-frame-pack-up)
+ ("Down" current-frame-pack-down)
+ ("Left" current-frame-pack-left)
+ ("Right" current-frame-pack-right))))
+
+
+(defun frame-fill-menu ()
+ "Frame fill menu"
+ (info-mode-menu '(("Up" current-frame-fill-up)
+ ("Down" current-frame-fill-down)
+ ("Left" current-frame-fill-left)
+ ("Right" current-frame-fill-right)
+ (#\a current-frame-fill-all-dir)
+ (#\v current-frame-fill-vertical)
+ (#\h current-frame-fill-horizontal))))
+
+(defun frame-resize-menu ()
+ "Frame resize menu"
+ (info-mode-menu '(("Up" current-frame-resize-up)
+ ("Down" current-frame-resize-down)
+ ("Left" current-frame-resize-left)
+ ("Right" current-frame-resize-right)
+ (#\d current-frame-resize-all-dir)
+ (#\a current-frame-resize-all-dir-minimal))))
+
+
+(defun frame-movement-menu ()
+ "Frame movement menu"
+ (info-mode-menu '((#\p frame-pack-menu)
+ (#\f frame-fill-menu)
+ (#\r frame-resize-menu)
+ (#\c center-current-frame)))
+ (leave-second-mode))
(defmacro with-movement (&body body)
- `(when (group-p *current-child*)
+ `(when (frame-p *current-child*)
, at body
- (show-all-childs)
+ (show-all-children)
(draw-second-mode-window)
- (group-movement-menu)))
+ (frame-movement-menu)))
;;; Pack
-(defun current-group-pack-up ()
- "Pack the current group up"
- (with-movement (pack-group-up *current-child* (find-father-group *current-child* *current-root*))))
-
-(defun current-group-pack-down ()
- "Pack the current group down"
- (with-movement (pack-group-down *current-child* (find-father-group *current-child* *current-root*))))
-
-(defun current-group-pack-left ()
- "Pack the current group left"
- (with-movement (pack-group-left *current-child* (find-father-group *current-child* *current-root*))))
-
-(defun current-group-pack-right ()
- "Pack the current group right"
- (with-movement (pack-group-right *current-child* (find-father-group *current-child* *current-root*))))
+(defun current-frame-pack-up ()
+ "Pack the current frame up"
+ (with-movement (pack-frame-up *current-child* (find-father-frame *current-child* *current-root*))))
+
+(defun current-frame-pack-down ()
+ "Pack the current frame down"
+ (with-movement (pack-frame-down *current-child* (find-father-frame *current-child* *current-root*))))
+
+(defun current-frame-pack-left ()
+ "Pack the current frame left"
+ (with-movement (pack-frame-left *current-child* (find-father-frame *current-child* *current-root*))))
+
+(defun current-frame-pack-right ()
+ "Pack the current frame right"
+ (with-movement (pack-frame-right *current-child* (find-father-frame *current-child* *current-root*))))
;;; Center
-(defun center-current-group ()
- "Center the current group"
- (with-movement (center-group *current-child*)))
+(defun center-current-frame ()
+ "Center the current frame"
+ (with-movement (center-frame *current-child*)))
;;; Fill
-(defun current-group-fill-up ()
- "Fill the current group up"
- (with-movement (fill-group-up *current-child* (find-father-group *current-child* *current-root*))))
-
-(defun current-group-fill-down ()
- "Fill the current group down"
- (with-movement (fill-group-down *current-child* (find-father-group *current-child* *current-root*))))
-
-(defun current-group-fill-left ()
- "Fill the current group left"
- (with-movement (fill-group-left *current-child* (find-father-group *current-child* *current-root*))))
-
-(defun current-group-fill-right ()
- "Fill the current group right"
- (with-movement (fill-group-right *current-child* (find-father-group *current-child* *current-root*))))
+(defun current-frame-fill-up ()
+ "Fill the current frame up"
+ (with-movement (fill-frame-up *current-child* (find-father-frame *current-child* *current-root*))))
+
+(defun current-frame-fill-down ()
+ "Fill the current frame down"
+ (with-movement (fill-frame-down *current-child* (find-father-frame *current-child* *current-root*))))
+
+(defun current-frame-fill-left ()
+ "Fill the current frame left"
+ (with-movement (fill-frame-left *current-child* (find-father-frame *current-child* *current-root*))))
+
+(defun current-frame-fill-right ()
+ "Fill the current frame right"
+ (with-movement (fill-frame-right *current-child* (find-father-frame *current-child* *current-root*))))
-(defun current-group-fill-all-dir ()
- "Fill the current group in all directions"
+(defun current-frame-fill-all-dir ()
+ "Fill the current frame in all directions"
(with-movement
- (let ((father (find-father-group *current-child* *current-root*)))
- (fill-group-up *current-child* father)
- (fill-group-down *current-child* father)
- (fill-group-left *current-child* father)
- (fill-group-right *current-child* father))))
+ (let ((father (find-father-frame *current-child* *current-root*)))
+ (fill-frame-up *current-child* father)
+ (fill-frame-down *current-child* father)
+ (fill-frame-left *current-child* father)
+ (fill-frame-right *current-child* father))))
-(defun current-group-fill-vertical ()
- "Fill the current group vertically"
+(defun current-frame-fill-vertical ()
+ "Fill the current frame vertically"
(with-movement
- (let ((father (find-father-group *current-child* *current-root*)))
- (fill-group-up *current-child* father)
- (fill-group-down *current-child* father))))
+ (let ((father (find-father-frame *current-child* *current-root*)))
+ (fill-frame-up *current-child* father)
+ (fill-frame-down *current-child* father))))
-(defun current-group-fill-horizontal ()
- "Fill the current group horizontally"
+(defun current-frame-fill-horizontal ()
+ "Fill the current frame horizontally"
(with-movement
- (let ((father (find-father-group *current-child* *current-root*)))
- (fill-group-left *current-child* father)
- (fill-group-right *current-child* father))))
+ (let ((father (find-father-frame *current-child* *current-root*)))
+ (fill-frame-left *current-child* father)
+ (fill-frame-right *current-child* father))))
;;; Resize
-(defun current-group-resize-up ()
- "Resize the current group up to its half height"
+(defun current-frame-resize-up ()
+ "Resize the current frame up to its half height"
(with-movement (resize-half-height-up *current-child*)))
-(defun current-group-resize-down ()
- "Resize the current group down to its half height"
+(defun current-frame-resize-down ()
+ "Resize the current frame down to its half height"
(with-movement (resize-half-height-down *current-child*)))
-(defun current-group-resize-left ()
- "Resize the current group left to its half width"
+(defun current-frame-resize-left ()
+ "Resize the current frame left to its half width"
(with-movement (resize-half-width-left *current-child*)))
-(defun current-group-resize-right ()
- "Resize the current group right to its half width"
+(defun current-frame-resize-right ()
+ "Resize the current frame right to its half width"
(with-movement (resize-half-width-right *current-child*)))
-(defun current-group-resize-all-dir ()
- "Resize down the current group"
- (with-movement (resize-group-down *current-child*)))
-
-(defun current-group-resize-all-dir-minimal ()
- "Resize down the current group to its minimal size"
- (with-movement (resize-minimal-group *current-child*)))
+(defun current-frame-resize-all-dir ()
+ "Resize down the current frame"
+ (with-movement (resize-frame-down *current-child*)))
+
+(defun current-frame-resize-all-dir-minimal ()
+ "Resize down the current frame to its minimal size"
+ (with-movement (resize-minimal-frame *current-child*)))
@@ -198,42 +195,42 @@
(defun action-by-name-menu ()
"Actions by name menu"
- (info-mode-menu '((#\f focus-group-by-name)
- (#\o open-group-by-name)
- (#\d delete-group-by-name)
+ (info-mode-menu '((#\f focus-frame-by-name)
+ (#\o open-frame-by-name)
+ (#\d delete-frame-by-name)
(#\m move-current-child-by-name)
(#\c copy-current-child-by-name))))
(defun action-by-number-menu ()
"Actions by number menu"
- (info-mode-menu '((#\f focus-group-by-number)
- (#\o open-group-by-number)
- (#\d delete-group-by-number)
+ (info-mode-menu '((#\f focus-frame-by-number)
+ (#\o open-frame-by-number)
+ (#\d delete-frame-by-number)
(#\m move-current-child-by-number)
(#\c copy-current-child-by-number))))
-(defun group-info-menu ()
- "Group information menu"
- (info-mode-menu '((#\s show-all-groups-info)
- (#\h hide-all-groups-info))))
+(defun frame-info-menu ()
+ "Frame information menu"
+ (info-mode-menu '((#\s show-all-frames-info)
+ (#\h hide-all-frames-info))))
-(defun group-menu ()
- "Group menu"
- (info-mode-menu '((#\a group-adding-menu)
- (#\l group-layout-menu)
- (#\n group-nw-hook-menu)
- (#\m group-movement-menu)
+(defun frame-menu ()
+ "Frame menu"
+ (info-mode-menu '((#\a frame-adding-menu)
+ (#\l frame-layout-menu)
+ (#\n frame-nw-hook-menu)
+ (#\m frame-movement-menu)
(#\r rename-current-child)
- (#\u renumber-current-group)
- (#\i group-info-menu)
- (#\x explode-current-group))))
+ (#\u renumber-current-frame)
+ (#\i frame-info-menu)
+ (#\x explode-current-frame))))
(defun window-menu ()
"Window menu"
- (info-mode-menu '((#\i force-window-in-group)
- (#\c force-window-center-in-group))))
+ (info-mode-menu '((#\i force-window-in-frame)
+ (#\c force-window-center-in-frame))))
@@ -255,7 +252,7 @@
(defun main-menu ()
"Open the main menu"
- (info-mode-menu '((#\g group-menu)
+ (info-mode-menu '((#\f frame-menu)
(#\w window-menu)
(#\s selection-menu)
(#\n action-by-name-menu)
@@ -270,7 +267,7 @@
(define-second-key ("F1" :mod-1) 'help-on-second-mode)
(define-second-key ("m") 'main-menu)
-(define-second-key ("g") 'group-menu)
+(define-second-key ("f") 'frame-menu)
(define-second-key ("n") 'action-by-name-menu)
(define-second-key ("u") 'action-by-number-menu)
@@ -304,17 +301,17 @@
(define-second-key ("Tab" :mod-1) 'select-next-child)
(define-second-key ("ISO_Left_Tab" :mod-1 :shift) 'select-previous-child)
-(define-second-key ("Return" :mod-1) 'enter-group)
-(define-second-key ("Return" :mod-1 :shift) 'leave-group)
+(define-second-key ("Return" :mod-1) 'enter-frame)
+(define-second-key ("Return" :mod-1 :shift) 'leave-frame)
-(define-second-key ("Home" :mod-1) 'switch-to-root-group)
-(define-second-key ("Home" :mod-1 :shift) 'switch-and-select-root-group)
+(define-second-key ("Home" :mod-1) 'switch-to-root-frame)
+(define-second-key ("Home" :mod-1 :shift) 'switch-and-select-root-frame)
-(define-second-key ("Menu") 'toggle-show-root-group)
+(define-second-key ("Menu") 'toggle-show-root-frame)
(define-second-key (#\b :mod-1) 'banish-pointer)
-(define-second-key (#\o) 'set-open-in-new-group-in-root-group-nw-hook)
+(define-second-key (#\o) 'set-open-in-new-frame-in-root-frame-nw-hook)
;;;; Escape
@@ -351,9 +348,9 @@
(define-shell (#\h) b-start-xclock "start an xclock" "exec xclock -d")
-(define-second-key ("Menu") 'show-all-groups-info-key)
-(define-second-key ("Menu" :shift) 'show-all-groups-info)
-(define-second-key ("Menu" :control) 'toggle-show-root-group)
+(define-second-key ("Menu") 'show-all-frames-info-key)
+(define-second-key ("Menu" :shift) 'show-all-frames-info)
+(define-second-key ("Menu" :control) 'toggle-show-root-frame)
@@ -374,7 +371,7 @@
(defun sm-mouse-select-next-level (window root-x root-y)
- "Select the next level in group"
+ "Select the next level in frame"
(declare (ignore window root-x root-y))
(select-next-level))
@@ -382,23 +379,23 @@
(defun sm-mouse-select-previous-level (window root-x root-y)
- "Select the previous level in group"
+ "Select the previous level in frame"
(declare (ignore window root-x root-y))
(select-previous-level))
-(defun sm-mouse-enter-group (window root-x root-y)
- "Enter in the selected group - ie make it the root group"
+(defun sm-mouse-enter-frame (window root-x root-y)
+ "Enter in the selected frame - ie make it the root frame"
(declare (ignore window root-x root-y))
- (enter-group))
+ (enter-frame))
-(defun sm-mouse-leave-group (window root-x root-y)
- "Leave the selected group - ie make its father the root group"
+(defun sm-mouse-leave-frame (window root-x root-y)
+ "Leave the selected frame - ie make its father the root frame"
(declare (ignore window root-x root-y))
- (leave-group))
+ (leave-frame))
@@ -408,8 +405,8 @@
(define-second-mouse (4) 'sm-mouse-select-next-level)
(define-second-mouse (5) 'sm-mouse-select-previous-level)
-(define-second-mouse (4 :mod-1) 'sm-mouse-enter-group)
-(define-second-mouse (5 :mod-1) 'sm-mouse-leave-group)
+(define-second-mouse (4 :mod-1) 'sm-mouse-enter-frame)
+(define-second-mouse (5 :mod-1) 'sm-mouse-leave-frame)
@@ -420,31 +417,31 @@
;;(define-second-key ("Escape" :control :shift) 'delete-current-window)
;;(define-second-key ("Escape" :mod-1 :control :shift) 'destroy-current-window)
;;(define-second-key ("Escape" :control) 'remove-current-window)
-;;(define-second-key ("Escape" :shift) 'unhide-all-windows-in-current-group)
+;;(define-second-key ("Escape" :shift) 'unhide-all-windows-in-current-frame)
;;
;;
;;;; Up
-;;(define-second-key ("Up" :mod-1) 'circulate-group-up)
-;;(define-second-key ("Up" :mod-1 :shift) 'circulate-group-up-move-window)
-;;(define-second-key ("Up" :mod-1 :shift :control) 'circulate-group-up-copy-window)
+;;(define-second-key ("Up" :mod-1) 'circulate-frame-up)
+;;(define-second-key ("Up" :mod-1 :shift) 'circulate-frame-up-move-window)
+;;(define-second-key ("Up" :mod-1 :shift :control) 'circulate-frame-up-copy-window)
;;
;;
;;;; Down
-;;(define-second-key ("Down" :mod-1) 'circulate-group-down)
-;;(define-second-key ("Down" :mod-1 :shift) 'circulate-group-down-move-window)
-;;(define-second-key ("Down" :mod-1 :shift :control) 'circulate-group-down-copy-window)
+;;(define-second-key ("Down" :mod-1) 'circulate-frame-down)
+;;(define-second-key ("Down" :mod-1 :shift) 'circulate-frame-down-move-window)
+;;(define-second-key ("Down" :mod-1 :shift :control) 'circulate-frame-down-copy-window)
;;
;;
;;;; Right
;;(define-second-key ("Right" :mod-1) 'circulate-workspace-up)
-;;(define-second-key ("Right" :mod-1 :shift) 'circulate-workspace-up-move-group)
-;;(define-second-key ("Right" :mod-1 :shift :control) 'circulate-workspace-up-copy-group)
+;;(define-second-key ("Right" :mod-1 :shift) 'circulate-workspace-up-move-frame)
+;;(define-second-key ("Right" :mod-1 :shift :control) 'circulate-workspace-up-copy-frame)
;;
;;
;;;; Left
;;(define-second-key ("Left" :mod-1) 'circulate-workspace-down)
-;;(define-second-key ("Left" :mod-1 :shift) 'circulate-workspace-down-move-group)
-;;(define-second-key ("Left" :mod-1 :shift :control) 'circulate-workspace-down-copy-group)
+;;(define-second-key ("Left" :mod-1 :shift) 'circulate-workspace-down-move-frame)
+;;(define-second-key ("Left" :mod-1 :shift :control) 'circulate-workspace-down-copy-frame)
;;
;;
;;(defmacro define-second-focus-workspace-by-number (key number)
@@ -477,7 +474,7 @@
;;
;;(define-second-key (#\b) 'banish-pointer)
;;
-;;(define-second-key (#\b :mod-1) 'toggle-maximize-current-group)
+;;(define-second-key (#\b :mod-1) 'toggle-maximize-current-frame)
;;
;;(define-second-key (#\x) 'pager-mode)
;;
@@ -486,8 +483,8 @@
;;(define-second-key (#\k) 'remove-current-window)
;;
;;
-;;(define-second-key (#\g) 'create-new-default-group)
-;;(define-second-key (#\g :mod-1) 'remove-current-group)
+;;(define-second-key (#\g) 'create-new-default-frame)
+;;(define-second-key (#\g :mod-1) 'remove-current-frame)
;;
;;(define-second-key (#\w) 'create-new-default-workspace)
;;(define-second-key (#\w :mod-1) 'remove-current-workspace)
@@ -509,15 +506,15 @@
;;
;;
;;(define-second-key (#\o :mod-1)
-;; (defun b-open-next-window-in-new-group-once ()
-;; "Open the next window in a new group and all others in the same group"
-;; (setf *open-next-window-in-new-group* :once)
+;; (defun b-open-next-window-in-new-frame-once ()
+;; "Open the next window in a new frame and all others in the same frame"
+;; (setf *open-next-window-in-new-frame* :once)
;; (leave-second-mode)))
;;
;;(define-second-key (#\o :mod-1 :control)
-;; (defun b-open-next-window-in-new-group ()
-;; "Open each next window in a new group"
-;; (setf *open-next-window-in-new-group* t)
+;; (defun b-open-next-window-in-new-frame ()
+;; "Open each next window in a new frame"
+;; (setf *open-next-window-in-new-frame* t)
;; (leave-second-mode)))
;;
;;
@@ -538,8 +535,8 @@
;;(define-shell (#\h) b-start-xclock "start an xclock" "exec xclock -d")
;;
;;
-;;(define-second-key (#\a) 'force-window-center-in-group)
-;;(define-second-key (#\a :mod-1) 'force-window-in-group)
+;;(define-second-key (#\a) 'force-window-center-in-frame)
+;;(define-second-key (#\a :mod-1) 'force-window-in-frame)
;;
;;
;;(define-second-key (#\d :mod-1)
@@ -554,145 +551,145 @@
;;
;;(define-second-key (#\y) 'tile-current-workspace-to)
;;(define-second-key (#\y :mod-1) 'reconfigure-tile-workspace)
-;;(define-second-key (#\y :control) 'explode-current-group)
-;;(define-second-key (#\y :control :shift) 'implode-current-group)
+;;(define-second-key (#\y :control) 'explode-current-frame)
+;;(define-second-key (#\y :control :shift) 'implode-current-frame)
;;
;;;;;,-----
-;;;;;| Moving/Resizing groups
+;;;;;| Moving/Resizing frames
;;;;;`-----
;;(define-second-key (#\p)
-;; (defun b-pack-group-on-next-arrow ()
-;; "Pack group on next arrow action"
+;; (defun b-pack-frame-on-next-arrow ()
+;; "Pack frame on next arrow action"
;; (setf *arrow-action* :pack)))
;;
;;
-;;(defun fill-group-in-all-directions ()
-;; "Fill group in all directions"
-;; (fill-current-group-up)
-;; (fill-current-group-left)
-;; (fill-current-group-right)
-;; (fill-current-group-down))
+;;(defun fill-frame-in-all-directions ()
+;; "Fill frame in all directions"
+;; (fill-current-frame-up)
+;; (fill-current-frame-left)
+;; (fill-current-frame-right)
+;; (fill-current-frame-down))
;;
;;
;;(define-second-key (#\f)
-;; (defun b-fill-group ()
-;; "Fill group on next arrow action (fill in all directions on second f keypress)"
+;; (defun b-fill-frame ()
+;; "Fill frame on next arrow action (fill in all directions on second f keypress)"
;; (case *arrow-action*
-;; (:fill (fill-group-in-all-directions)
+;; (:fill (fill-frame-in-all-directions)
;; (setf *arrow-action* nil))
;; (t (setf *arrow-action* :fill)))))
;;
-;;(define-second-key (#\f :mod-1) 'fill-group-in-all-directions)
+;;(define-second-key (#\f :mod-1) 'fill-frame-in-all-directions)
;;
;;(define-second-key (#\f :shift)
-;; (defun b-fill-group-vert ()
-;; "Fill group vertically"
-;; (fill-current-group-up)
-;; (fill-current-group-down)))
+;; (defun b-fill-frame-vert ()
+;; "Fill frame vertically"
+;; (fill-current-frame-up)
+;; (fill-current-frame-down)))
;;
;;(define-second-key (#\f :control)
-;; (defun b-fill-group-horiz ()
-;; "Fill group horizontally"
-;; (fill-current-group-left)
-;; (fill-current-group-right)))
+;; (defun b-fill-frame-horiz ()
+;; "Fill frame horizontally"
+;; (fill-current-frame-left)
+;; (fill-current-frame-right)))
;;
;;
;;(define-second-key (#\r)
;; (defun b-resize-half ()
-;; "Resize group to its half width or heigth on next arraw action"
+;; "Resize frame to its half width or heigth on next arraw action"
;; (setf *arrow-action* :resize-half)))
;;
;;
-;;(define-second-key (#\l) 'resize-minimal-current-group)
-;;(define-second-key (#\l :mod-1) 'resize-down-current-group)
+;;(define-second-key (#\l) 'resize-minimal-current-frame)
+;;(define-second-key (#\l :mod-1) 'resize-down-current-frame)
;;
;;
-;;(define-second-key (#\m) 'center-current-group)
+;;(define-second-key (#\m) 'center-current-frame)
;;
;;
;;(define-second-key ("Up")
;; (defun b-move-or-pack-up ()
-;; "Move, pack, fill or resize group up"
+;; "Move, pack, fill or resize frame up"
;; (case *arrow-action*
-;; (:pack (pack-current-group-up))
-;; (:fill (fill-current-group-up))
-;; (:resize-half (resize-half-height-up-current-group))
-;; (t (move-group (current-group) 0 -10)))
+;; (:pack (pack-current-frame-up))
+;; (:fill (fill-current-frame-up))
+;; (:resize-half (resize-half-height-up-current-frame))
+;; (t (move-frame (current-frame) 0 -10)))
;; (setf *arrow-action* nil)))
;;
;;(define-second-key ("Down")
;; (defun b-move-or-pack-down ()
-;; "Move, pack, fill or resize group down"
+;; "Move, pack, fill or resize frame down"
;; (case *arrow-action*
-;; (:pack (pack-current-group-down))
-;; (:fill (fill-current-group-down))
-;; (:resize-half (resize-half-height-down-current-group))
-;; (t (move-group (current-group) 0 +10)))
+;; (:pack (pack-current-frame-down))
+;; (:fill (fill-current-frame-down))
+;; (:resize-half (resize-half-height-down-current-frame))
+;; (t (move-frame (current-frame) 0 +10)))
;; (setf *arrow-action* nil)))
;;
;;(define-second-key ("Right")
;; (defun b-move-or-pack-right ()
-;; "Move, pack, fill or resize group right"
+;; "Move, pack, fill or resize frame right"
;; (case *arrow-action*
-;; (:pack (pack-current-group-right))
-;; (:fill (fill-current-group-right))
-;; (:resize-half (resize-half-width-right-current-group))
-;; (t (move-group (current-group) +10 0)))
+;; (:pack (pack-current-frame-right))
+;; (:fill (fill-current-frame-right))
+;; (:resize-half (resize-half-width-right-current-frame))
+;; (t (move-frame (current-frame) +10 0)))
;; (setf *arrow-action* nil)))
;;
;;(define-second-key ("Left")
;; (defun b-move-or-pack-left ()
-;; "Move, pack, fill or resize group left"
+;; "Move, pack, fill or resize frame left"
;; (case *arrow-action*
-;; (:pack (pack-current-group-left))
-;; (:fill (fill-current-group-left))
-;; (:resize-half (resize-half-width-left-current-group))
-;; (t (move-group (current-group) -10 0)))
+;; (:pack (pack-current-frame-left))
+;; (:fill (fill-current-frame-left))
+;; (:resize-half (resize-half-width-left-current-frame))
+;; (t (move-frame (current-frame) -10 0)))
;; (setf *arrow-action* nil)))
;;
;;
;;(define-second-key ("Up" :shift)
;; (defun b-resize-up ()
-;; "Resize group up"
-;; (resize-group (current-group) 0 -10)))
+;; "Resize frame up"
+;; (resize-frame (current-frame) 0 -10)))
;;
;;(define-second-key ("Down" :shift)
;; (defun b-resize-down ()
-;; "Resize group down"
-;; (resize-group (current-group) 0 +10)))
+;; "Resize frame down"
+;; (resize-frame (current-frame) 0 +10)))
;;
;;(define-second-key ("Right" :shift)
;; (defun b-resize-right ()
-;; "Resize group right"
-;; (resize-group (current-group) +10 0)))
+;; "Resize frame right"
+;; (resize-frame (current-frame) +10 0)))
;;
;;(define-second-key ("Left" :shift)
;; (defun b-resize-left ()
-;; "Resize group left"
-;; (resize-group (current-group) -10 0)))
+;; "Resize frame left"
+;; (resize-frame (current-frame) -10 0)))
;;
;;
;;;;;,-----
;;;;;| Mouse second mode functions
;;;;;`-----
-;;(defun select-group-under-mouse (root-x root-y)
-;; (let ((group (find-group-under-mouse root-x root-y)))
-;; (when group
+;;(defun select-frame-under-mouse (root-x root-y)
+;; (let ((frame (find-frame-under-mouse root-x root-y)))
+;; (when frame
;; (no-focus)
-;; (focus-group group (current-workspace))
+;; (focus-frame frame (current-workspace))
;; (focus-window (current-window))
-;; (show-all-group (current-workspace) nil))))
+;; (show-all-frame (current-workspace) nil))))
;;
;;(defun mouse-leave-second-mode-maximize (root-x root-y)
-;; "Leave second mode and maximize current group"
-;; (select-group-under-mouse root-x root-y)
-;; (maximize-group (current-group))
+;; "Leave second mode and maximize current frame"
+;; (select-frame-under-mouse root-x root-y)
+;; (maximize-frame (current-frame))
;; (show-all-windows-in-workspace (current-workspace))
;; (throw 'exit-second-loop nil))
;;
;;(defun mouse-leave-second-mode (root-x root-y)
;; "Leave second mode"
-;; (select-group-under-mouse root-x root-y)
+;; (select-frame-under-mouse root-x root-y)
;; (show-all-windows-in-workspace (current-workspace))
;; (throw 'exit-second-loop nil))
;;
@@ -729,160 +726,160 @@
;;(defun init-motion-vars ()
;; (setf *motion-action* nil
;; *motion-object* nil
-;; *motion-start-group* nil
+;; *motion-start-frame* nil
;; *motion-dx* nil
;; *motion-dy* nil))
;;
;;
;;(let ((accept-motion t)
-;; (selected-group nil))
+;; (selected-frame nil))
;; (defun mouse-motion (root-x root-y)
-;; "Move or resize group. Move window from a group to another.
+;; "Move or resize frame. Move window from a frame to another.
;;Go to top left or rigth corner to change workspaces."
-;; (let ((group (find-group-under-mouse root-x root-y)))
-;; (unless (equal selected-group group)
-;; (select-group-under-mouse root-x root-y)
-;; (setf selected-group group)))
+;; (let ((frame (find-frame-under-mouse root-x root-y)))
+;; (unless (equal selected-frame frame)
+;; (select-frame-under-mouse root-x root-y)
+;; (setf selected-frame frame)))
;; (if (<= root-y 5)
;; (cond ((and accept-motion (<= root-x 5))
;; (case *motion-action*
-;; (:move-group
-;; (remove-group-in-workspace *motion-object* (current-workspace))))
+;; (:move-frame
+;; (remove-frame-in-workspace *motion-object* (current-workspace))))
;; (circulate-workspace-down)
-;; (minimize-group (current-group))
+;; (minimize-frame (current-frame))
;; (case *motion-action*
-;; (:move-group
-;; (add-group-in-workspace *motion-object* (current-workspace))))
+;; (:move-frame
+;; (add-frame-in-workspace *motion-object* (current-workspace))))
;; (warp-pointer *root* (1- (xlib:screen-width *screen*)) 100)
;; (setf accept-motion nil))
;; ((and accept-motion (>= root-x (- (xlib:screen-width *screen*) 5)))
;; (case *motion-action*
-;; (:move-group
-;; (remove-group-in-workspace *motion-object* (current-workspace))))
+;; (:move-frame
+;; (remove-frame-in-workspace *motion-object* (current-workspace))))
;; (circulate-workspace-up)
-;; (minimize-group (current-group))
+;; (minimize-frame (current-frame))
;; (case *motion-action*
-;; (:move-group
-;; (add-group-in-workspace *motion-object* (current-workspace))))
+;; (:move-frame
+;; (add-frame-in-workspace *motion-object* (current-workspace))))
;; (warp-pointer *root* 0 100)
;; (setf accept-motion nil))
;; (t (setf accept-motion t)))
;; (setf accept-motion t))
;; (case *motion-action*
-;; (:move-group
-;; (hide-group *root* *motion-object*)
-;; (setf (group-x *motion-object*) (+ root-x *motion-dx*)
-;; (group-y *motion-object*) (+ root-y *motion-dy*))
-;; (show-group *root* *root-gc* *motion-object*)
-;; (adapt-all-window-in-group *motion-object*)
-;; (show-all-group (current-workspace) nil))
-;; (:resize-group
-;; (hide-group *root* *motion-object*)
-;; (setf (group-width *motion-object*) (max (+ (group-width *motion-object*) (- root-x *motion-dx*)) 100)
-;; (group-height *motion-object*) (max (+ (group-height *motion-object*) (- root-y *motion-dy*)) 100)
+;; (:move-frame
+;; (hide-frame *root* *motion-object*)
+;; (setf (frame-x *motion-object*) (+ root-x *motion-dx*)
+;; (frame-y *motion-object*) (+ root-y *motion-dy*))
+;; (show-frame *root* *root-gc* *motion-object*)
+;; (adapt-all-window-in-frame *motion-object*)
+;; (show-all-frame (current-workspace) nil))
+;; (:resize-frame
+;; (hide-frame *root* *motion-object*)
+;; (setf (frame-width *motion-object*) (max (+ (frame-width *motion-object*) (- root-x *motion-dx*)) 100)
+;; (frame-height *motion-object*) (max (+ (frame-height *motion-object*) (- root-y *motion-dy*)) 100)
;; *motion-dx* root-x *motion-dy* root-y)
-;; (show-group *root* *root-gc* *motion-object*)
-;; (adapt-all-window-in-group *motion-object*)
-;; (show-all-group (current-workspace) nil)))))
+;; (show-frame *root* *root-gc* *motion-object*)
+;; (adapt-all-window-in-frame *motion-object*)
+;; (show-all-frame (current-workspace) nil)))))
;;
;;
;;
-;;(defun move-selected-group (root-x root-y)
-;; "Move selected group or create a new group on the root window"
-;; (select-group-under-mouse root-x root-y)
-;; (setf *motion-object* (find-group-under-mouse root-x root-y))
+;;(defun move-selected-frame (root-x root-y)
+;; "Move selected frame or create a new frame on the root window"
+;; (select-frame-under-mouse root-x root-y)
+;; (setf *motion-object* (find-frame-under-mouse root-x root-y))
;; (if *motion-object*
-;; (setf *motion-action* :move-group
-;; *motion-dx* (- (group-x *motion-object*) root-x)
-;; *motion-dy* (- (group-y *motion-object*) root-y))
+;; (setf *motion-action* :move-frame
+;; *motion-dx* (- (frame-x *motion-object*) root-x)
+;; *motion-dy* (- (frame-y *motion-object*) root-y))
;; (progn
-;; (setf *motion-object* (make-group :x root-x :y root-y :width 100 :height 100 :fullscreenp nil))
+;; (setf *motion-object* (make-frame :x root-x :y root-y :width 100 :height 100 :fullscreenp nil))
;; (warp-pointer *root* (+ root-x 100) (+ root-y 100))
-;; (add-group-in-workspace *motion-object* (current-workspace))
-;; (show-all-group (current-workspace))
-;; (setf *motion-action* :resize-group
+;; (add-frame-in-workspace *motion-object* (current-workspace))
+;; (show-all-frame (current-workspace))
+;; (setf *motion-action* :resize-frame
;; *motion-dx* (+ root-x 100)
;; *motion-dy* (+ root-y 100)))))
;;
;;
;;
-;;(defun copy-selected-group (root-x root-y)
-;; "Copy selected group"
+;;(defun copy-selected-frame (root-x root-y)
+;; "Copy selected frame"
;; (xgrab-pointer *root* 50 51)
-;; (select-group-under-mouse root-x root-y)
-;; (setf *motion-object* (find-group-under-mouse root-x root-y))
+;; (select-frame-under-mouse root-x root-y)
+;; (setf *motion-object* (find-frame-under-mouse root-x root-y))
;; (when *motion-object*
-;; (setf *motion-action* :copy-group
-;; *motion-object* (copy-group *motion-object*)
-;; *motion-dx* (- (group-x *motion-object*) root-x)
-;; *motion-dy* (- (group-y *motion-object*) root-y))))
-;;;; (add-group-in-workspace *motion-object* (current-workspace))))
+;; (setf *motion-action* :copy-frame
+;; *motion-object* (copy-frame *motion-object*)
+;; *motion-dx* (- (frame-x *motion-object*) root-x)
+;; *motion-dy* (- (frame-y *motion-object*) root-y))))
+;;;; (add-frame-in-workspace *motion-object* (current-workspace))))
;;
;;
;;
-;;(defun release-move-selected-group (root-x root-y)
+;;(defun release-move-selected-frame (root-x root-y)
;; "Release button"
;; (when *motion-object*
;; (case *motion-action*
-;; (:move-group
-;; (move-group-to *motion-object* (+ root-x *motion-dx*) (+ root-y *motion-dy*)))
-;; (:resize-group
-;; (resize-group *motion-object* 0 0))))
+;; (:move-frame
+;; (move-frame-to *motion-object* (+ root-x *motion-dx*) (+ root-y *motion-dy*)))
+;; (:resize-frame
+;; (resize-frame *motion-object* 0 0))))
;; (init-motion-vars)
-;; (select-group-under-mouse root-x root-y))
+;; (select-frame-under-mouse root-x root-y))
;;
;;
-;;(defun release-copy-selected-group (root-x root-y)
+;;(defun release-copy-selected-frame (root-x root-y)
;; "Release button"
;; (xgrab-pointer *root* 66 67)
;; (when *motion-object*
-;; (unless (group-windows-already-in-workspace *motion-object* (current-workspace))
-;; (add-group-in-workspace *motion-object* (current-workspace))
-;; (move-group-to *motion-object* (+ root-x *motion-dx*) (+ root-y *motion-dy*))))
+;; (unless (frame-windows-already-in-workspace *motion-object* (current-workspace))
+;; (add-frame-in-workspace *motion-object* (current-workspace))
+;; (move-frame-to *motion-object* (+ root-x *motion-dx*) (+ root-y *motion-dy*))))
;; (init-motion-vars)
-;; (select-group-under-mouse root-x root-y)
+;; (select-frame-under-mouse root-x root-y)
;; (show-all-windows-in-workspace (current-workspace)))
;;
;;
;;
-;;(defun resize-selected-group (root-x root-y)
-;; "Resize selected group"
-;; (select-group-under-mouse root-x root-y)
-;; (setf *motion-object* (find-group-under-mouse root-x root-y))
+;;(defun resize-selected-frame (root-x root-y)
+;; "Resize selected frame"
+;; (select-frame-under-mouse root-x root-y)
+;; (setf *motion-object* (find-frame-under-mouse root-x root-y))
;; (when *motion-object*
-;; (setf *motion-action* :resize-group
+;; (setf *motion-action* :resize-frame
;; *motion-dx* root-x
;; *motion-dy* root-y)))
;;
;;
-;;(defun release-resize-selected-group (root-x root-y)
+;;(defun release-resize-selected-frame (root-x root-y)
;; "Release button"
;; (when *motion-object*
-;; (resize-group *motion-object* 0 0))
+;; (resize-frame *motion-object* 0 0))
;; (init-motion-vars)
-;; (select-group-under-mouse root-x root-y))
+;; (select-frame-under-mouse root-x root-y))
;;
;;
;;
;;(defun move-selected-window (root-x root-y)
;; "Move selected window"
;; (xgrab-pointer *root* 50 51)
-;; (select-group-under-mouse root-x root-y)
+;; (select-frame-under-mouse root-x root-y)
;; (setf *motion-object* (current-window)
;; *motion-action* :move-window)
;; (when *motion-object*
-;; (setf *motion-start-group* (current-group))))
+;; (setf *motion-start-frame* (current-frame))))
;;
;;
;;(defun release-move-selected-window (root-x root-y)
;; "Release button"
;; (xgrab-pointer *root* 66 67)
-;; (select-group-under-mouse root-x root-y)
+;; (select-frame-under-mouse root-x root-y)
;; (when *motion-object*
-;; (remove-window-in-group *motion-object* *motion-start-group*)
-;; (add-window-in-group *motion-object* (current-group)))
+;; (remove-window-in-frame *motion-object* *motion-start-frame*)
+;; (add-window-in-frame *motion-object* (current-frame)))
;; (init-motion-vars)
-;; (select-group-under-mouse root-x root-y)
+;; (select-frame-under-mouse root-x root-y)
;; (show-all-windows-in-workspace (current-workspace)))
;;
;;
@@ -895,12 +892,12 @@
;;(defun release-copy-selected-window (root-x root-y)
;; "Release button"
;; (xgrab-pointer *root* 66 67)
-;; (select-group-under-mouse root-x root-y)
+;; (select-frame-under-mouse root-x root-y)
;; (when *motion-object*
;; (unless (window-already-in-workspace *motion-object* (current-workspace))
-;; (add-window-in-group *motion-object* (current-group))))
+;; (add-window-in-frame *motion-object* (current-frame))))
;; (init-motion-vars)
-;; (select-group-under-mouse root-x root-y)
+;; (select-frame-under-mouse root-x root-y)
;; (show-all-windows-in-workspace (current-workspace)))
;;
;;
@@ -908,9 +905,9 @@
;;
;;
;;
-;;(define-second-mouse (1) 'move-selected-group 'release-move-selected-group)
-;;(define-second-mouse (1 :mod-1) 'resize-selected-group 'release-resize-selected-group)
-;;(define-second-mouse (1 :control) 'copy-selected-group 'release-copy-selected-group)
+;;(define-second-mouse (1) 'move-selected-frame 'release-move-selected-frame)
+;;(define-second-mouse (1 :mod-1) 'resize-selected-frame 'release-resize-selected-frame)
+;;(define-second-mouse (1 :control) 'copy-selected-frame 'release-copy-selected-frame)
;;
;;(define-second-mouse (2) nil 'mouse-leave-second-mode-maximize)
;;(define-second-mouse (2 :control) nil 'mouse-leave-second-mode)
Modified: clfswm/src/bindings.lisp
==============================================================================
--- clfswm/src/bindings.lisp (original)
+++ clfswm/src/bindings.lisp Tue Mar 25 18:02:17 2008
@@ -49,16 +49,16 @@
(define-main-key ("Tab" :mod-1) 'select-next-child)
(define-main-key ("ISO_Left_Tab" :mod-1 :shift) 'select-previous-child)
-(define-main-key ("Return" :mod-1) 'enter-group)
-(define-main-key ("Return" :mod-1 :shift) 'leave-group)
+(define-main-key ("Return" :mod-1) 'enter-frame)
+(define-main-key ("Return" :mod-1 :shift) 'leave-frame)
-(define-main-key ("Home" :mod-1) 'switch-to-root-group)
-(define-main-key ("Home" :mod-1 :shift) 'switch-and-select-root-group)
+(define-main-key ("Home" :mod-1) 'switch-to-root-frame)
+(define-main-key ("Home" :mod-1 :shift) 'switch-and-select-root-frame)
-(define-main-key ("Menu") 'show-all-groups-info-key)
-(define-main-key ("Menu" :shift) 'show-all-groups-info)
-(define-main-key ("Menu" :control) 'toggle-show-root-group)
+(define-main-key ("Menu") 'show-all-frames-info-key)
+(define-main-key ("Menu" :shift) 'show-all-frames-info)
+(define-main-key ("Menu" :control) 'toggle-show-root-frame)
(define-main-key (#\b :mod-1) 'banish-pointer)
@@ -81,16 +81,16 @@
;;; Mouse actions
(defun mouse-click-to-focus (window root-x root-y)
- "Focus the current group or the current window father"
+ "Focus the current frame or the current window father"
(declare (ignore root-x root-y))
(let ((to-replay t)
(child window)
- (father (find-father-group window *current-root*)))
+ (father (find-father-frame window *current-root*)))
(unless father
- (setf child (find-group-window window *current-root*)
- father (find-father-group child *current-root*)))
- (when (and child father (focus-all-childs child father))
- (show-all-childs)
+ (setf child (find-frame-window window *current-root*)
+ father (find-father-frame child *current-root*)))
+ (when (and child father (focus-all-children child father))
+ (show-all-children)
(setf to-replay nil))
(if to-replay
(replay-button-event)
@@ -104,41 +104,41 @@
(defun mouse-select-next-level (window root-x root-y)
- "Select the next level in group"
+ "Select the next level in frame"
(declare (ignore root-x root-y))
- (let ((group (find-group-window window)))
- (when (or group (xlib:window-equal window *root*))
+ (let ((frame (find-frame-window window)))
+ (when (or frame (xlib:window-equal window *root*))
(select-next-level))
(replay-button-event)))
(defun mouse-select-previous-level (window root-x root-y)
- "Select the previous level in group"
+ "Select the previous level in frame"
(declare (ignore root-x root-y))
- (let ((group (find-group-window window)))
- (when (or group (xlib:window-equal window *root*))
+ (let ((frame (find-frame-window window)))
+ (when (or frame (xlib:window-equal window *root*))
(select-previous-level))
(replay-button-event)))
-(defun mouse-enter-group (window root-x root-y)
- "Enter in the selected group - ie make it the root group"
+(defun mouse-enter-frame (window root-x root-y)
+ "Enter in the selected frame - ie make it the root frame"
(declare (ignore root-x root-y))
- (let ((group (find-group-window window)))
- (when (or group (xlib:window-equal window *root*))
- (enter-group))
+ (let ((frame (find-frame-window window)))
+ (when (or frame (xlib:window-equal window *root*))
+ (enter-frame))
(replay-button-event)))
-(defun mouse-leave-group (window root-x root-y)
- "Leave the selected group - ie make its father the root group"
+(defun mouse-leave-frame (window root-x root-y)
+ "Leave the selected frame - ie make its father the root frame"
(declare (ignore root-x root-y))
- (let ((group (find-group-window window)))
- (when (or group (xlib:window-equal window *root*))
- (leave-group))
+ (let ((frame (find-frame-window window)))
+ (when (or frame (xlib:window-equal window *root*))
+ (leave-frame))
(replay-button-event)))
@@ -147,8 +147,8 @@
(define-main-mouse (4) 'mouse-select-next-level)
(define-main-mouse (5) 'mouse-select-previous-level)
-(define-main-mouse (4 :mod-1) 'mouse-enter-group)
-(define-main-mouse (5 :mod-1) 'mouse-leave-group)
+(define-main-mouse (4 :mod-1) 'mouse-enter-frame)
+(define-main-mouse (5 :mod-1) 'mouse-leave-frame)
;;(define-main-mouse (1) 'handle-click-to-focus 'test-mouse-binding)
;;(define-main-mouse ('motion) 'test-mouse-binding)
@@ -156,7 +156,7 @@
;;(define-main-key ("a") (lambda ()
;; (dbg 'key-a)
-;; (show-all-childs *root-group*)))
+;; (show-all-children *root-frame*)))
;;
;;(define-main-key ("b") (lambda ()
;; (dbg 'key-b)
@@ -200,37 +200,37 @@
;;(define-main-key ("Tab" :mod-1 :shift) 'rotate-window-down)
;;
;;(define-main-key (#\b :mod-1) 'banish-pointer)
-;;(define-main-key (#\b :mod-1 :control) 'toggle-maximize-current-group)
+;;(define-main-key (#\b :mod-1 :control) 'toggle-maximize-current-frame)
;;
;;;; Escape
;;(define-main-key ("Escape" :control :shift) 'delete-current-window)
;;(define-main-key ("Escape" :mod-1 :control :shift) 'destroy-current-window)
;;(define-main-key ("Escape" :control) 'remove-current-window)
-;;(define-main-key ("Escape" :shift) 'unhide-all-windows-in-current-group)
+;;(define-main-key ("Escape" :shift) 'unhide-all-windows-in-current-frame)
;;
;;
;;;; Up
-;;(define-main-key ("Up" :mod-1) 'circulate-group-up)
-;;(define-main-key ("Up" :mod-1 :shift) 'circulate-group-up-move-window)
-;;(define-main-key ("Up" :mod-1 :shift :control) 'circulate-group-up-copy-window)
+;;(define-main-key ("Up" :mod-1) 'circulate-frame-up)
+;;(define-main-key ("Up" :mod-1 :shift) 'circulate-frame-up-move-window)
+;;(define-main-key ("Up" :mod-1 :shift :control) 'circulate-frame-up-copy-window)
;;
;;
;;;; Down
-;;(define-main-key ("Down" :mod-1) 'circulate-group-down)
-;;(define-main-key ("Down" :mod-1 :shift) 'circulate-group-down-move-window)
-;;(define-main-key ("Down" :mod-1 :shift :control) 'circulate-group-down-copy-window)
+;;(define-main-key ("Down" :mod-1) 'circulate-frame-down)
+;;(define-main-key ("Down" :mod-1 :shift) 'circulate-frame-down-move-window)
+;;(define-main-key ("Down" :mod-1 :shift :control) 'circulate-frame-down-copy-window)
;;
;;
;;;; Right
;;(define-main-key ("Right" :mod-1) 'circulate-workspace-up)
-;;(define-main-key ("Right" :mod-1 :shift) 'circulate-workspace-up-move-group)
-;;(define-main-key ("Right" :mod-1 :shift :control) 'circulate-workspace-up-copy-group)
+;;(define-main-key ("Right" :mod-1 :shift) 'circulate-workspace-up-move-frame)
+;;(define-main-key ("Right" :mod-1 :shift :control) 'circulate-workspace-up-copy-frame)
;;
;;
;;;; Left
;;(define-main-key ("Left" :mod-1) 'circulate-workspace-down)
-;;(define-main-key ("Left" :mod-1 :shift) 'circulate-workspace-down-move-group)
-;;(define-main-key ("Left" :mod-1 :shift :control) 'circulate-workspace-down-copy-group)
+;;(define-main-key ("Left" :mod-1 :shift) 'circulate-workspace-down-move-frame)
+;;(define-main-key ("Left" :mod-1 :shift :control) 'circulate-workspace-down-copy-frame)
;;
;;
;;
Modified: clfswm/src/clfswm-info.lisp
==============================================================================
--- clfswm/src/clfswm-info.lisp (original)
+++ clfswm/src/clfswm-info.lisp Tue Mar 25 18:02:17 2008
@@ -317,6 +317,13 @@
+(defun keys-from-list (list)
+ "Produce a key menu based on list item"
+ (loop for l in list
+ for i from 0
+ collect (list (code-char (+ (char-code #\a) i)) l)))
+
+
;;;,-----
;;;| CONFIG - Info mode functions
;;;`-----
Modified: clfswm/src/clfswm-internal.lisp
==============================================================================
--- clfswm/src/clfswm-internal.lisp (original)
+++ clfswm/src/clfswm-internal.lisp Tue Mar 25 18:02:17 2008
@@ -43,31 +43,31 @@
-(defgeneric group-p (group))
-(defmethod group-p ((group group))
- (declare (ignore group))
+(defgeneric frame-p (frame))
+(defmethod frame-p ((frame frame))
+ (declare (ignore frame))
t)
-(defmethod group-p (group)
- (declare (ignore group))
+(defmethod frame-p (frame)
+ (declare (ignore frame))
nil)
-;;; Group data manipulation functions
-(defun group-data-slot (group slot)
+;;; Frame data manipulation functions
+(defun frame-data-slot (frame slot)
"Return the value associated to data slot"
- (when (group-p group)
- (second (assoc slot (group-data group)))))
+ (when (frame-p frame)
+ (second (assoc slot (frame-data frame)))))
-(defun set-group-data-slot (group slot value)
+(defun set-frame-data-slot (frame slot value)
"Set the value associated to data slot"
- (when (group-p group)
- (with-slots (data) group
+ (when (frame-p frame)
+ (with-slots (data) frame
(setf data (remove (assoc slot data) data))
(push (list slot value) data))
value))
-(defsetf group-data-slot set-group-data-slot)
+(defsetf frame-data-slot set-frame-data-slot)
@@ -79,8 +79,8 @@
(defmethod child-name ((child xlib:window))
(xlib:wm-name child))
-(defmethod child-name ((child group))
- (group-name child))
+(defmethod child-name ((child frame))
+ (frame-name child))
(defmethod child-name (child)
(declare (ignore child))
@@ -90,8 +90,8 @@
(defgeneric rename-child (child name))
-(defmethod rename-child ((child group) name)
- (setf (group-name child) name))
+(defmethod rename-child ((child frame) name)
+ (setf (frame-name child) name))
(defmethod rename-child ((child xlib:window) name)
(setf (xlib:wm-name child) name))
@@ -101,66 +101,66 @@
-;; (with-all-childs (*root-group* child) (typecase child (xlib:window (print child)) (group (print (group-number child)))))
-(defmacro with-all-childs ((root child) &body body)
+;; (with-all-children (*root-frame* child) (typecase child (xlib:window (print child)) (frame (print (frame-number child)))))
+(defmacro with-all-children ((root child) &body body)
(let ((rec (gensym))
(sub-child (gensym)))
`(labels ((,rec (,child)
, at body
- (when (group-p ,child)
- (dolist (,sub-child (group-child ,child))
+ (when (frame-p ,child)
+ (dolist (,sub-child (frame-child ,child))
(,rec ,sub-child)))))
(,rec ,root))))
-;; (with-all-group (*root-group* group) (print (group-number group)))
-(defmacro with-all-groups ((root group) &body body)
+;; (with-all-frames (*root-frame* frame) (print (frame-number frame)))
+(defmacro with-all-frames ((root frame) &body body)
(let ((rec (gensym))
(child (gensym)))
- `(labels ((,rec (,group)
- (when (group-p ,group)
+ `(labels ((,rec (,frame)
+ (when (frame-p ,frame)
, at body
- (dolist (,child (group-child ,group))
+ (dolist (,child (frame-child ,frame))
(,rec ,child)))))
(,rec ,root))))
-;; (with-all-windows (*root-group* window) (print window))
+;; (with-all-windows (*root-frame* window) (print window))
(defmacro with-all-windows ((root window) &body body)
(let ((rec (gensym))
(child (gensym)))
`(labels ((,rec (,window)
(when (xlib:window-p ,window)
, at body)
- (when (group-p ,window)
- (dolist (,child (group-child ,window))
+ (when (frame-p ,window)
+ (dolist (,child (frame-child ,window))
(,rec ,child)))))
(,rec ,root))))
-;; (with-all-groups-windows (*root-group* child) (print child) (print (group-number child)))
-(defmacro with-all-windows-groups ((root child) body-window body-group)
+;; (with-all-frames-windows (*root-frame* child) (print child) (print (frame-number child)))
+(defmacro with-all-windows-frames ((root child) body-window body-frame)
(let ((rec (gensym))
(sub-child (gensym)))
`(labels ((,rec (,child)
(typecase ,child
(xlib:window ,body-window)
- (group ,body-group
- (dolist (,sub-child (group-child ,child))
+ (frame ,body-frame
+ (dolist (,sub-child (frame-child ,child))
(,rec ,sub-child))))))
(,rec ,root))))
-(defun group-find-free-number ()
+(defun frame-find-free-number ()
(let ((all-numbers nil))
- (with-all-groups (*root-group* group)
- (push (group-number group) all-numbers))
+ (with-all-frames (*root-frame* frame)
+ (push (frame-number frame) all-numbers))
(find-free-number all-numbers)))
-(defun create-group (&rest args &key (number (group-find-free-number)) &allow-other-keys)
+(defun create-frame (&rest args &key (number (frame-find-free-number)) &allow-other-keys)
(let* ((window (xlib:create-window :parent *root*
:x 0
:y 0
@@ -176,12 +176,12 @@
:background (get-color "Black")
:font *default-font*
:line-style :solid)))
- (apply #'make-instance 'group :number number :window window :gc gc args)))
+ (apply #'make-instance 'frame :number number :window window :gc gc args)))
-(defun add-group (group father)
- (push group (group-child father)))
+(defun add-frame (frame father)
+ (push frame (frame-child father)))
@@ -190,56 +190,56 @@
(defun get-current-child ()
"Return the current focused child"
- (unless (equal *current-child* *root-group*)
+ (unless (equal *current-child* *root-frame*)
(typecase *current-child*
(xlib:window *current-child*)
- (group (if (xlib:window-p (first (group-child *current-child*)))
- (first (group-child *current-child*))
+ (frame (if (xlib:window-p (first (frame-child *current-child*)))
+ (first (frame-child *current-child*))
*current-child*)))))
(defun find-child (to-find root)
- "Find to-find in root or in its childs"
- (with-all-childs (root child)
+ "Find to-find in root or in its children"
+ (with-all-children (root child)
(when (equal child to-find)
(return-from find-child t))))
-(defun find-father-group (to-find &optional (root *root-group*))
- "Return the father group of to-find"
- (with-all-groups (root group)
- (when (member to-find (group-child group))
- (return-from find-father-group group))))
+(defun find-father-frame (to-find &optional (root *root-frame*))
+ "Return the father frame of to-find"
+ (with-all-frames (root frame)
+ (when (member to-find (frame-child frame))
+ (return-from find-father-frame frame))))
-(defun find-group-window (window &optional (root *root-group*))
- "Return the group with the window window"
- (with-all-groups (root group)
- (when (xlib:window-equal window (group-window group))
- (return-from find-group-window group))))
+(defun find-frame-window (window &optional (root *root-frame*))
+ "Return the frame with the window window"
+ (with-all-frames (root frame)
+ (when (xlib:window-equal window (frame-window frame))
+ (return-from find-frame-window frame))))
-(defun find-group-by-name (name)
- "Find a group from its name"
+(defun find-frame-by-name (name)
+ "Find a frame from its name"
(when name
- (with-all-groups (*root-group* group)
- (when (string-equal name (group-name group))
- (return-from find-group-by-name group)))))
+ (with-all-frames (*root-frame* frame)
+ (when (string-equal name (frame-name frame))
+ (return-from find-frame-by-name frame)))))
-(defun find-group-by-number (number)
- "Find a group from its number"
+(defun find-frame-by-number (number)
+ "Find a frame from its number"
(when (numberp number)
- (with-all-groups (*root-group* group)
- (when (= number (group-number group))
- (return-from find-group-by-number group)))))
+ (with-all-frames (*root-frame* frame)
+ (when (= number (frame-number frame))
+ (return-from find-frame-by-number frame)))))
-(defun get-all-windows (&optional (root *root-group*))
- "Return all windows in root and in its childs"
+(defun get-all-windows (&optional (root *root-frame*))
+ "Return all windows in root and in its children"
(let ((acc nil))
(with-all-windows (root window)
(push window acc))
@@ -256,20 +256,20 @@
-(defun display-group-info (group)
+(defun display-frame-info (frame)
(let ((dy (+ (xlib:max-char-ascent *default-font*) (xlib:max-char-descent *default-font*))))
- (with-slots (name number gc window child) group
- (when (equal group *current-root*)
+ (with-slots (name number gc window child) frame
+ (when (equal frame *current-root*)
(xlib:clear-area window))
- (setf (xlib:gcontext-foreground gc) (get-color (if (and (equal group *current-root*)
- (equal group *current-child*))
+ (setf (xlib:gcontext-foreground gc) (get-color (if (and (equal frame *current-root*)
+ (equal frame *current-child*))
"Red" "Green")))
(xlib:draw-image-glyphs window gc 5 dy
- (format nil "Group: ~A~A "
+ (format nil "Frame: ~A~A "
number
(if name (format nil " - ~A" name) "")))
(let ((pos dy))
- (when (equal group *current-root*)
+ (when (equal frame *current-root*)
(xlib:draw-image-glyphs window gc 5 (incf pos dy)
(format nil "~A hidden windows " (length (get-hidden-windows))))
(when *child-selection*
@@ -279,8 +279,8 @@
(dolist (child *child-selection*)
(typecase child
(xlib:window (format str "~A " (xlib:wm-name child)))
- (group (format str "group:~A[~A] " (group-number child)
- (aif (group-name child) it "")))))
+ (frame (format str "frame:~A[~A] " (frame-number child)
+ (aif (frame-name child) it "")))))
(format str " ")))))
(dolist (ch child)
(when (xlib:window-p ch)
@@ -296,8 +296,8 @@
(defun get-father-layout (child father)
- (if (group-p father)
- (aif (group-layout father)
+ (if (frame-p father)
+ (aif (frame-layout father)
(funcall it child father)
(no-layout child father))
(get-fullscreen-size)))
@@ -315,11 +315,11 @@
(xlib:drawable-height window) nh)
raise-p)))
-(defmethod adapt-child-to-father ((group group) father)
+(defmethod adapt-child-to-father ((frame frame) father)
(with-xlib-protect
(multiple-value-bind (nx ny nw nh raise-p)
- (get-father-layout group father)
- (with-slots (rx ry rw rh window) group
+ (get-father-layout frame father)
+ (with-slots (rx ry rw rh window) frame
(setf rx nx ry ny rw nw rh nh)
(setf (xlib:drawable-x window) rx
(xlib:drawable-y window) ry
@@ -332,21 +332,21 @@
(defgeneric show-child (child father))
(defgeneric hide-child (child))
-(defmethod show-child ((group group) father)
+(defmethod show-child ((frame frame) father)
(with-xlib-protect
- (with-slots (window) group
- (let ((raise-p (adapt-child-to-father group father)))
- (when (or *show-root-group-p* (not (equal group *current-root*)))
+ (with-slots (window) frame
+ (let ((raise-p (adapt-child-to-father frame father)))
+ (when (or *show-root-frame-p* (not (equal frame *current-root*)))
(setf (xlib:window-background window) (get-color "Black"))
(xlib:map-window window)
(when raise-p
(raise-window window))
- (display-group-info group))))))
+ (display-frame-info frame))))))
-(defmethod hide-child ((group group))
+(defmethod hide-child ((frame frame))
(with-xlib-protect
- (with-slots (window) group
+ (with-slots (window) frame
(xlib:unmap-window window))))
@@ -369,10 +369,10 @@
(defgeneric select-child (child selected))
-(defmethod select-child ((group group) selected)
+(defmethod select-child ((frame frame) selected)
(with-xlib-protect
- (when (and (group-p group) (group-window group))
- (setf (xlib:window-border (group-window group))
+ (when (and (frame-p frame) (frame-window frame))
+ (setf (xlib:window-border (frame-window frame))
(get-color (cond ((equal selected :maybe) *color-maybe-selected*)
((equal selected nil) *color-unselected*)
(selected *color-selected*)))))))
@@ -384,7 +384,7 @@
((equal selected nil) *color-unselected*)
(selected *color-selected*))))))
-(defun select-current-group (selected)
+(defun select-current-frame (selected)
(select-child *current-child* selected))
@@ -393,7 +393,7 @@
(labels ((rec (child)
(typecase child
(xlib:window (focus-window child))
- (group (rec (first (group-child child)))))))
+ (frame (rec (first (frame-child child)))))))
(no-focus)
(rec *current-child*)))
@@ -401,15 +401,15 @@
-(defun show-all-childs ()
- "Show all childs from *current-root*"
+(defun show-all-children ()
+ "Show all children from *current-root*"
(labels ((rec (root father first-p)
(show-child root father)
(select-child root (if (equal root *current-child*) t
(if first-p :maybe nil)))
- (when (group-p root)
- (let ((first-child (first (group-child root))))
- (dolist (child (reverse (group-child root)))
+ (when (frame-p root)
+ (let ((first-child (first (frame-child root))))
+ (dolist (child (reverse (frame-child root)))
(rec child root (and first-p (equal child first-child))))))))
(rec *current-root* nil t)
(set-focus-to-current-child)))
@@ -417,65 +417,65 @@
-(defun hide-all-childs (root)
+(defun hide-all-children (root)
(hide-child root)
- (when (group-p root)
- (dolist (child (group-child root))
- (hide-all-childs child))))
+ (when (frame-p root)
+ (dolist (child (frame-child root))
+ (hide-all-children child))))
(defun select-next/previous-brother (fun-rotate)
- "Select the next/previous brother group"
- (let ((group-is-root? (and (equal *current-root* *current-child*)
- (not (equal *current-root* *root-group*)))))
- (if group-is-root?
- (hide-all-childs *current-root*)
- (select-current-group nil))
- (let ((father (find-father-group *current-child*)))
- (when (group-p father)
+ "Select the next/previous brother frame"
+ (let ((frame-is-root? (and (equal *current-root* *current-child*)
+ (not (equal *current-root* *root-frame*)))))
+ (if frame-is-root?
+ (hide-all-children *current-root*)
+ (select-current-frame nil))
+ (let ((father (find-father-frame *current-child*)))
+ (when (frame-p father)
(with-slots (child) father
(setf child (funcall fun-rotate child))
(setf *current-child* (first child)))))
- (when group-is-root?
+ (when frame-is-root?
(setf *current-root* *current-child*))
- (show-all-childs)))
+ (show-all-children)))
(defun select-next-brother ()
- "Select the next brother group"
+ "Select the next brother frame"
(select-next/previous-brother #'anti-rotate-list))
(defun select-previous-brother ()
- "Select the previous brother group"
+ "Select the previous brother frame"
(select-next/previous-brother #'rotate-list))
(defun select-next-level ()
- "Select the next level in group"
- (select-current-group nil)
- (when (group-p *current-child*)
- (awhen (first (group-child *current-child*))
+ "Select the next level in frame"
+ (select-current-frame nil)
+ (when (frame-p *current-child*)
+ (awhen (first (frame-child *current-child*))
(setf *current-child* it)))
- (show-all-childs))
+ (show-all-children))
(defun select-previous-level ()
- "Select the previous level in group"
+ "Select the previous level in frame"
(unless (equal *current-child* *current-root*)
- (select-current-group nil)
- (awhen (find-father-group *current-child*)
+ (select-current-frame nil)
+ (awhen (find-father-frame *current-child*)
(setf *current-child* it))
- (show-all-childs)))
+ (show-all-children)))
(defun select-next/previous-child (fun-rotate)
"Select the next/previous child"
- (when (group-p *current-child*)
+ (when (frame-p *current-child*)
(with-slots (child) *current-child*
(setf child (funcall fun-rotate child)))
- (show-all-childs)))
+ (show-all-children)))
(defun select-next-child ()
@@ -488,49 +488,49 @@
-(defun enter-group ()
- "Enter in the selected group - ie make it the root group"
- (hide-all-childs *current-root*)
+(defun enter-frame ()
+ "Enter in the selected frame - ie make it the root frame"
+ (hide-all-children *current-root*)
(setf *current-root* *current-child*)
- (show-all-childs))
+ (show-all-children))
-(defun leave-group ()
- "Leave the selected group - ie make its father the root group"
- (hide-all-childs *current-root*)
- (awhen (find-father-group *current-root*)
- (when (group-p it)
+(defun leave-frame ()
+ "Leave the selected frame - ie make its father the root frame"
+ (hide-all-children *current-root*)
+ (awhen (find-father-frame *current-root*)
+ (when (frame-p it)
(setf *current-root* it)))
- (show-all-childs))
+ (show-all-children))
-(defun switch-to-root-group ()
- "Switch to the root group"
- (hide-all-childs *current-root*)
- (setf *current-root* *root-group*)
- (show-all-childs))
-
-(defun switch-and-select-root-group ()
- "Switch and select the root group"
- (hide-all-childs *current-root*)
- (setf *current-root* *root-group*)
+(defun switch-to-root-frame ()
+ "Switch to the root frame"
+ (hide-all-children *current-root*)
+ (setf *current-root* *root-frame*)
+ (show-all-children))
+
+(defun switch-and-select-root-frame ()
+ "Switch and select the root frame"
+ (hide-all-children *current-root*)
+ (setf *current-root* *root-frame*)
(setf *current-child* *current-root*)
- (show-all-childs))
+ (show-all-children))
-(defun toggle-show-root-group ()
- "Show/Hide the root group"
- (hide-all-childs *current-root*)
- (setf *show-root-group-p* (not *show-root-group-p*))
- (show-all-childs))
+(defun toggle-show-root-frame ()
+ "Show/Hide the root frame"
+ (hide-all-children *current-root*)
+ (setf *show-root-frame-p* (not *show-root-frame-p*))
+ (show-all-children))
(defun focus-child (child father)
"Focus child - Return true if something has change"
- (when (and (group-p father)
- (member child (group-child father)))
- (when (not (equal child (first (group-child father))))
- (loop until (equal child (first (group-child father)))
- do (setf (group-child father) (rotate-list (group-child father))))
+ (when (and (frame-p father)
+ (member child (frame-child father)))
+ (when (not (equal child (first (frame-child father))))
+ (loop until (equal child (first (frame-child father)))
+ do (setf (frame-child father) (rotate-list (frame-child father))))
t)))
(defun focus-child-rec (child father)
@@ -540,16 +540,16 @@
(when (focus-child child father)
(setf change t))
(when father
- (rec father (find-father-group father)))))
+ (rec father (find-father-frame father)))))
(rec child father))
change))
(defun set-current-child (child father)
"Set *current-child* to child - Return t if something has change"
- (cond ((and (group-p child) (not (equal *current-child* child)))
+ (cond ((and (frame-p child) (not (equal *current-child* child)))
(setf *current-child* child)
t)
- ((and (group-p father) (not (equal *current-child* father)))
+ ((and (frame-p father) (not (equal *current-child* father)))
(setf *current-child* father)
t)))
@@ -559,8 +559,8 @@
(setf *current-root* father)))
-(defun focus-all-childs (child father)
- "Focus child and its fathers - Set current group to father"
+(defun focus-all-children (child father)
+ "Focus child and its fathers - Set current frame to father"
(let ((new-focus (focus-child-rec child father))
(new-current-child (set-current-child child father))
(new-root (set-current-root father)))
@@ -568,27 +568,27 @@
-(defun remove-child-in-group (child group)
- "Remove the child in group"
- (when (group-p group)
- (setf (group-child group) (remove child (group-child group) :test #'equal))))
-
-(defun remove-child-in-groups (child root)
- "Remove child in the group root and in all its childs"
- (with-all-groups (root group)
- (remove-child-in-group child group))
+(defun remove-child-in-frame (child frame)
+ "Remove the child in frame"
+ (when (frame-p frame)
+ (setf (frame-child frame) (remove child (frame-child frame) :test #'equal))))
+
+(defun remove-child-in-frames (child root)
+ "Remove child in the frame root and in all its children"
+ (with-all-frames (root frame)
+ (remove-child-in-frame child frame))
(when (xlib:window-p child)
(netwm-remove-in-client-list child)))
-(defun remove-child-in-all-groups (child)
- "Remove child in all groups from *root-group*"
+(defun remove-child-in-all-frames (child)
+ "Remove child in all frames from *root-frame*"
(when (equal child *current-root*)
- (setf *current-root* (find-father-group child)))
+ (setf *current-root* (find-father-frame child)))
(when (equal child *current-child*)
(setf *current-child* *current-root*))
- (remove-child-in-groups child *root-group*))
+ (remove-child-in-frames child *root-frame*))
@@ -608,33 +608,33 @@
(xlib:drawable-height window))))
(setf (xlib:drawable-width window) (min (max min-width rwidth) max-width)
(xlib:drawable-height window) (min (max min-height rheight) max-height))
- (setf (xlib:drawable-x window) (truncate (+ (group-rx *current-child*) (/ (- (group-rw *current-child*) (xlib:drawable-width window)) 2)))
- (xlib:drawable-y window) (truncate (+ (group-ry *current-child*) (/ (- (group-rh *current-child*) (xlib:drawable-height window)) 2)))))))
+ (setf (xlib:drawable-x window) (truncate (+ (frame-rx *current-child*) (/ (- (frame-rw *current-child*) (xlib:drawable-width window)) 2)))
+ (xlib:drawable-y window) (truncate (+ (frame-ry *current-child*) (/ (- (frame-rh *current-child*) (xlib:drawable-height window)) 2)))))))
-;;(defun do-all-groups-nw-hook (window)
-;; "Call nw-hook of each group. A hook must return one value or a list of two values.
+;;(defun do-all-frames-nw-hook (window)
+;; "Call nw-hook of each frame. A hook must return one value or a list of two values.
;;If the value or the first value is true then the default nw-hook is not executed.
-;;If the second value is true then no more group can do an action with the window (ie leave the loop)."
+;;If the second value is true then no more frame can do an action with the window (ie leave the loop)."
;; (let ((result nil))
-;; (with-all-groups (*root-group* group)
-;; (let ((ret (call-hook (group-nw-hook group) (list group window))))
+;; (with-all-frames (*root-frame* frame)
+;; (let ((ret (call-hook (frame-nw-hook frame) (list frame window))))
;; (typecase ret
;; (cons (when (first ret)
;; (setf result t))
;; (when (second ret)
-;; (return-from do-all-groups-nw-hook result)))
+;; (return-from do-all-frames-nw-hook result)))
;; (t (when ret
;; (setf result t))))))
;; result))
-(defun do-all-groups-nw-hook (window)
- "Call nw-hook of each group."
+(defun do-all-frames-nw-hook (window)
+ "Call nw-hook of each frame."
(let ((found nil))
- (with-all-groups (*root-group* group)
- (awhen (group-nw-hook group)
- (call-hook it (list group window))
+ (with-all-frames (*root-frame* frame)
+ (awhen (frame-nw-hook frame)
+ (call-hook it (list frame window))
(setf found t)))
found))
@@ -653,10 +653,10 @@
(:transient 1)
(t 1)))
(grab-all-buttons window)
-;; (when (group-p *current-child*) ;; PHIL: Remove this!!!
-;; (setf (group-nw-hook *current-child*) #'open-in-new-group-nw-hook))
- (unless (do-all-groups-nw-hook window)
- (default-group-nw-hook nil window))
+;; (when (frame-p *current-child*) ;; PHIL: Remove this!!!
+;; (setf (frame-nw-hook *current-child*) #'open-in-new-frame-nw-hook))
+ (unless (do-all-frames-nw-hook window)
+ (default-frame-nw-hook nil window))
(netwm-add-in-client-list window)))
Modified: clfswm/src/clfswm-layout.lisp
==============================================================================
--- clfswm/src/clfswm-layout.lisp (original)
+++ clfswm/src/clfswm-layout.lisp Tue Mar 25 18:02:17 2008
@@ -32,7 +32,7 @@
;;; 1- define your own layout: a method returning the real size of the
;;; child in screen size (integer) as 5 values (rx, ry, rw, rh, raise-p).
;;; This method can use the float size of the child (x, y ,w , h).
-;;; It can be specialised for xlib:window or group
+;;; It can be specialised for xlib:window or frame
;;; 2- Define a seter function for your layout
;;; 3- Register your new layout with register-layout.
@@ -42,38 +42,38 @@
;;; Generic functions
(defun set-layout (layout)
"Set the layout of the current child"
- (when (group-p *current-child*)
- (setf (group-layout *current-child*) layout)
+ (when (frame-p *current-child*)
+ (setf (frame-layout *current-child*) layout)
(leave-second-mode)))
(defun get-managed-child (father)
"Return only window in normal mode who can be tiled"
- (when (group-p father)
+ (when (frame-p father)
(remove-if #'(lambda (x)
(and (xlib:window-p x) (not (eql (window-type x) :normal))))
- (group-child father))))
+ (frame-child father))))
(defun register-layout (layout)
(setf *layout-list* (append *layout-list* (list layout))))
(defun layout-ask-size (msg slot &optional (min 80))
- (when (group-p *current-child*)
- (let ((new-size (/ (or (query-number msg (* (group-data-slot *current-child* slot) 100)) min) 100)))
+ (when (frame-p *current-child*)
+ (let ((new-size (/ (or (query-number msg (* (frame-data-slot *current-child* slot) 100)) min) 100)))
(when (<= 0 new-size 1)
- (setf (group-data-slot *current-child* slot) new-size)))))
+ (setf (frame-data-slot *current-child* slot) new-size)))))
;;; No layout
(defgeneric no-layout (child father)
- (:documentation "Maximize windows in there group - leave group to there size"))
+ (:documentation "Maximize windows in there frame - leave frame to there size (no layout)"))
(defmethod no-layout ((child xlib:window) father)
(with-slots (rx ry rw rh) father
- (values (1+ rx) (1+ ry) (- rw 2) (- rh 2) nil)))
+ (values (1+ rx) (1+ ry) (- rw 2) (- rh 2) t)))
-(defmethod no-layout ((child group) father)
+(defmethod no-layout ((child frame) father)
(with-slots ((cx x) (cy y) (cw w) (ch h)) child
(with-slots ((frx rx) (fry ry) (frw rw) (frh rh)) father
(values (round (+ (* cx frw) frx))
@@ -83,7 +83,7 @@
t))))
(defun set-no-layout ()
- "Maximize windows in there group - leave group to there size"
+ "Maximize windows in there frame - leave frame to there size (no layout)"
(set-layout #'no-layout))
(register-layout 'set-no-layout)
@@ -93,23 +93,23 @@
;;; Tile layout
(defgeneric tile-layout (child father)
- (:documentation "Tile child in its group"))
+ (:documentation "Tile child in its frame"))
(defmethod tile-layout (child father)
- (let* ((managed-childs (get-managed-child father))
- (pos (position child managed-childs))
- (len (length managed-childs))
+ (let* ((managed-children (get-managed-child father))
+ (pos (position child managed-children))
+ (len (length managed-children))
(n (ceiling (sqrt len)))
- (dx (/ (group-rw father) n))
- (dy (/ (group-rh father) (ceiling (/ len n)))))
- (values (round (+ (group-rx father) (truncate (* (mod pos n) dx)) 1))
- (round (+ (group-ry father) (truncate (* (truncate (/ pos n)) dy)) 1))
+ (dx (/ (frame-rw father) n))
+ (dy (/ (frame-rh father) (ceiling (/ len n)))))
+ (values (round (+ (frame-rx father) (truncate (* (mod pos n) dx)) 1))
+ (round (+ (frame-ry father) (truncate (* (truncate (/ pos n)) dy)) 1))
(round (- dx 2))
(round (- dy 2))
nil)))
(defun set-tile-layout ()
- "Tile child in its group"
+ "Tile child in its frame"
(set-layout #'tile-layout))
(register-layout 'set-tile-layout)
@@ -121,11 +121,11 @@
(defmethod tile-left-layout (child father)
(with-slots (rx ry rw rh) father
- (let* ((managed-childs (get-managed-child father))
- (pos (position child managed-childs))
- (len (max (1- (length managed-childs)) 1))
+ (let* ((managed-children (get-managed-child father))
+ (pos (position child managed-children))
+ (len (max (1- (length managed-children)) 1))
(dy (/ rh len))
- (size (or (group-data-slot father :tile-size) 0.8)))
+ (size (or (frame-data-slot father :tile-size) 0.8)))
(if (= pos 0)
(values (1+ rx)
(1+ ry)
@@ -154,11 +154,11 @@
(defmethod tile-right-layout (child father)
(with-slots (rx ry rw rh) father
- (let* ((managed-childs (get-managed-child father))
- (pos (position child managed-childs))
- (len (max (1- (length managed-childs)) 1))
+ (let* ((managed-children (get-managed-child father))
+ (pos (position child managed-children))
+ (len (max (1- (length managed-children)) 1))
(dy (/ rh len))
- (size (or (group-data-slot father :tile-size) 0.8)))
+ (size (or (frame-data-slot father :tile-size) 0.8)))
(if (= pos 0)
(values (1+ (round (+ rx (* rw (- 1 size)))))
(1+ ry)
@@ -189,11 +189,11 @@
(defmethod tile-top-layout (child father)
(with-slots (rx ry rw rh) father
- (let* ((managed-childs (get-managed-child father))
- (pos (position child managed-childs))
- (len (max (1- (length managed-childs)) 1))
+ (let* ((managed-children (get-managed-child father))
+ (pos (position child managed-children))
+ (len (max (1- (length managed-children)) 1))
(dx (/ rw len))
- (size (or (group-data-slot father :tile-size) 0.8)))
+ (size (or (frame-data-slot father :tile-size) 0.8)))
(if (= pos 0)
(values (1+ rx)
(1+ ry)
@@ -222,11 +222,11 @@
(defmethod tile-bottom-layout (child father)
(with-slots (rx ry rw rh) father
- (let* ((managed-childs (get-managed-child father))
- (pos (position child managed-childs))
- (len (max (1- (length managed-childs)) 1))
+ (let* ((managed-children (get-managed-child father))
+ (pos (position child managed-children))
+ (len (max (1- (length managed-children)) 1))
(dx (/ rw len))
- (size (or (group-data-slot father :tile-size) 0.8)))
+ (size (or (frame-data-slot father :tile-size) 0.8)))
(if (= pos 0)
(values (1+ rx)
(1+ (round (+ ry (* rh (- 1 size)))))
@@ -255,17 +255,17 @@
;;; Space layout
(defgeneric tile-space-layout (child father)
- (:documentation "Tile Space: tile child in its group leaving spaces between them"))
+ (:documentation "Tile Space: tile child in its frame leaving spaces between them"))
(defmethod tile-space-layout (child father)
(with-slots (rx ry rw rh) father
- (let* ((managed-childs (get-managed-child father))
- (pos (position child managed-childs))
- (len (length managed-childs))
+ (let* ((managed-children (get-managed-child father))
+ (pos (position child managed-children))
+ (len (length managed-children))
(n (ceiling (sqrt len)))
(dx (/ rw n))
(dy (/ rh (ceiling (/ len n))))
- (size (or (group-data-slot father :tile-space-size) 0.1)))
+ (size (or (frame-data-slot father :tile-space-size) 0.1)))
(when (> size 0.5) (setf size 0.45))
(values (round (+ rx (truncate (* (mod pos n) dx)) (* dx size) 1))
(round (+ ry (truncate (* (truncate (/ pos n)) dy)) (* dy size) 1))
@@ -274,7 +274,7 @@
t))))
(defun set-space-tile-layout ()
- "Tile Space: tile child in its group leaving spaces between them"
+ "Tile Space: tile child in its frame leaving spaces between them"
(layout-ask-size "Space size in percent (%)" :tile-space-size 10)
(set-layout #'tile-space-layout))
Modified: clfswm/src/clfswm-nw-hooks.lisp
==============================================================================
--- clfswm/src/clfswm-nw-hooks.lisp (original)
+++ clfswm/src/clfswm-nw-hooks.lisp Tue Mar 25 18:02:17 2008
@@ -4,7 +4,7 @@
;;; --------------------------------------------------------------------------
;;; Documentation: New window Hooks
;;;
-;;; Those hooks can be set for each group to manage new window when they are
+;;; Those hooks can be set for each frame to manage new window when they are
;;; mapped.
;;; --------------------------------------------------------------------------
;;;
@@ -40,53 +40,53 @@
(defun set-nw-hook (hook)
"Set the hook of the current child"
- (let ((group (if (xlib:window-p *current-child*)
- (find-father-group *current-child*)
+ (let ((frame (if (xlib:window-p *current-child*)
+ (find-father-frame *current-child*)
*current-child*)))
- (setf (group-nw-hook group) hook)
+ (setf (frame-nw-hook frame) hook)
(leave-second-mode)))
(defun register-nw-hook (hook)
(setf *nw-hook-list* (append *nw-hook-list* (list hook))))
-(defun default-window-placement (group window)
+(defun default-window-placement (frame window)
(case (window-type window)
- (:normal (adapt-child-to-father window group))
+ (:normal (adapt-child-to-father window frame))
(t (place-window-from-hints window))))
-(defun leave-if-not-group (child)
- "Leave the child if it's not a group"
+(defun leave-if-not-frame (child)
+ "Leave the child if it's not a frame"
(when (xlib:window-p child)
- (leave-group)
+ (leave-frame)
(select-previous-level)))
-;;; Default group new window hook
-(defun default-group-nw-hook (group window)
- "Open the next window in the current group"
- (declare (ignore group))
- (leave-if-not-group *current-child*)
- (when (group-p *current-child*)
- (pushnew window (group-child *current-child*)))
+;;; Default frame new window hook
+(defun default-frame-nw-hook (frame window)
+ "Open the next window in the current frame"
+ (declare (ignore frame))
+ (leave-if-not-frame *current-child*)
+ (when (frame-p *current-child*)
+ (pushnew window (frame-child *current-child*)))
(default-window-placement *current-child* window))
-(defun set-default-group-nw-hook ()
- "Open the next window in the current group"
- (set-nw-hook #'default-group-nw-hook))
+(defun set-default-frame-nw-hook ()
+ "Open the next window in the current frame"
+ (set-nw-hook #'default-frame-nw-hook))
-(register-nw-hook 'set-default-group-nw-hook)
+(register-nw-hook 'set-default-frame-nw-hook)
;;; Open new window in current root hook
-(defun open-in-current-root-nw-hook (group window)
+(defun open-in-current-root-nw-hook (frame window)
"Open the next window in the current root"
- (leave-if-not-group *current-root*)
- (pushnew window (group-child *current-root*))
- (setf *current-child* (first (group-child *current-root*)))
+ (leave-if-not-frame *current-root*)
+ (pushnew window (frame-child *current-root*))
+ (setf *current-child* (first (frame-child *current-root*)))
(default-window-placement *current-root* window)
- (setf (group-nw-hook group) nil))
+ (setf (frame-nw-hook frame) nil))
(defun set-open-in-current-root-nw-hook ()
"Open the next window in the current root"
@@ -95,37 +95,37 @@
(register-nw-hook 'set-open-in-current-root-nw-hook)
-;;; Open new window in a new group in the current root hook
-(defun open-in-new-group-in-current-root-nw-hook (group window)
- "Open the next window in a new group in the current root"
- (leave-if-not-group *current-root*)
- (let ((new-group (create-group)))
- (pushnew new-group (group-child *current-root*))
- (pushnew window (group-child new-group))
- (setf *current-child* new-group)
- (default-window-placement new-group window))
- (setf (group-nw-hook group) nil))
-
-(defun set-open-in-new-group-in-current-root-nw-hook ()
- "Open the next window in a new group in the current root"
- (set-nw-hook #'open-in-new-group-in-current-root-nw-hook))
-
-(register-nw-hook 'set-open-in-new-group-in-current-root-nw-hook)
-
-
-;;; Open new window in a new group in the root group hook
-(defun open-in-new-group-in-root-group-nw-hook (group window)
- "Open the next window in a new group in the root group"
- (let ((new-group (create-group)))
- (pushnew new-group (group-child *root-group*))
- (pushnew window (group-child new-group))
- (switch-to-root-group)
- (setf *current-child* new-group)
- (default-window-placement new-group window))
- (setf (group-nw-hook group) nil))
-
-(defun set-open-in-new-group-in-root-group-nw-hook ()
- "Open the next window in a new group in the root group"
- (set-nw-hook #'open-in-new-group-in-root-group-nw-hook))
+;;; Open new window in a new frame in the current root hook
+(defun open-in-new-frame-in-current-root-nw-hook (frame window)
+ "Open the next window in a new frame in the current root"
+ (leave-if-not-frame *current-root*)
+ (let ((new-frame (create-frame)))
+ (pushnew new-frame (frame-child *current-root*))
+ (pushnew window (frame-child new-frame))
+ (setf *current-child* new-frame)
+ (default-window-placement new-frame window))
+ (setf (frame-nw-hook frame) nil))
+
+(defun set-open-in-new-frame-in-current-root-nw-hook ()
+ "Open the next window in a new frame in the current root"
+ (set-nw-hook #'open-in-new-frame-in-current-root-nw-hook))
+
+(register-nw-hook 'set-open-in-new-frame-in-current-root-nw-hook)
+
+
+;;; Open new window in a new frame in the root frame hook
+(defun open-in-new-frame-in-root-frame-nw-hook (frame window)
+ "Open the next window in a new frame in the root frame"
+ (let ((new-frame (create-frame)))
+ (pushnew new-frame (frame-child *root-frame*))
+ (pushnew window (frame-child new-frame))
+ (switch-to-root-frame)
+ (setf *current-child* new-frame)
+ (default-window-placement new-frame window))
+ (setf (frame-nw-hook frame) nil))
+
+(defun set-open-in-new-frame-in-root-frame-nw-hook ()
+ "Open the next window in a new frame in the root frame"
+ (set-nw-hook #'open-in-new-frame-in-root-frame-nw-hook))
-(register-nw-hook 'set-open-in-new-group-in-root-group-nw-hook)
+(register-nw-hook 'set-open-in-new-frame-in-root-frame-nw-hook)
Modified: clfswm/src/clfswm-pack.lisp
==============================================================================
--- clfswm/src/clfswm-pack.lisp (original)
+++ clfswm/src/clfswm-pack.lisp Tue Mar 25 18:02:17 2008
@@ -28,56 +28,56 @@
;;;,-----
;;;| Edges functions
;;;`-----
-(defun group-x2 (group)
- (+ (group-x group) (group-w group)))
+(defun frame-x2 (frame)
+ (+ (frame-x frame) (frame-w frame)))
-(defun group-y2 (group)
- (+ (group-y group) (group-h group)))
+(defun frame-y2 (frame)
+ (+ (frame-y frame) (frame-h frame)))
-(defun find-edge-up (current-group father)
+(defun find-edge-up (current-frame father)
(let ((y-found 0))
- (dolist (group (group-child father))
- (when (and (group-p group)
- (not (equal group current-group))
- (<= (group-y2 group) (group-y current-group))
- (>= (group-x2 group) (group-x current-group))
- (<= (group-x group) (group-x2 current-group)))
- (setf y-found (max y-found (group-y2 group)))))
+ (dolist (frame (frame-child father))
+ (when (and (frame-p frame)
+ (not (equal frame current-frame))
+ (<= (frame-y2 frame) (frame-y current-frame))
+ (>= (frame-x2 frame) (frame-x current-frame))
+ (<= (frame-x frame) (frame-x2 current-frame)))
+ (setf y-found (max y-found (frame-y2 frame)))))
y-found))
-(defun find-edge-down (current-group father)
+(defun find-edge-down (current-frame father)
(let ((y-found 1))
- (dolist (group (group-child father))
- (when (and (group-p group)
- (not (equal group current-group))
- (>= (group-y group) (group-y2 current-group))
- (>= (group-x2 group) (group-x current-group))
- (<= (group-x group) (group-x2 current-group)))
- (setf y-found (min y-found (group-y group)))))
+ (dolist (frame (frame-child father))
+ (when (and (frame-p frame)
+ (not (equal frame current-frame))
+ (>= (frame-y frame) (frame-y2 current-frame))
+ (>= (frame-x2 frame) (frame-x current-frame))
+ (<= (frame-x frame) (frame-x2 current-frame)))
+ (setf y-found (min y-found (frame-y frame)))))
y-found))
-(defun find-edge-right (current-group father)
+(defun find-edge-right (current-frame father)
(let ((x-found 1))
- (dolist (group (group-child father))
- (when (and (group-p group)
- (not (equal group current-group))
- (>= (group-x group) (group-x2 current-group))
- (>= (group-y2 group) (group-y current-group))
- (<= (group-y group) (group-y2 current-group)))
- (setf x-found (min x-found (group-x group)))))
+ (dolist (frame (frame-child father))
+ (when (and (frame-p frame)
+ (not (equal frame current-frame))
+ (>= (frame-x frame) (frame-x2 current-frame))
+ (>= (frame-y2 frame) (frame-y current-frame))
+ (<= (frame-y frame) (frame-y2 current-frame)))
+ (setf x-found (min x-found (frame-x frame)))))
x-found))
-(defun find-edge-left (current-group father)
+(defun find-edge-left (current-frame father)
(let ((x-found 0))
- (dolist (group (group-child father))
- (when (and (group-p group)
- (not (equal group current-group))
- (<= (group-x2 group) (group-x current-group))
- (>= (group-y2 group) (group-y current-group))
- (<= (group-y group) (group-y2 current-group)))
- (setf x-found (max x-found (group-x2 group)))))
+ (dolist (frame (frame-child father))
+ (when (and (frame-p frame)
+ (not (equal frame current-frame))
+ (<= (frame-x2 frame) (frame-x current-frame))
+ (>= (frame-y2 frame) (frame-y current-frame))
+ (<= (frame-y frame) (frame-y2 current-frame)))
+ (setf x-found (max x-found (frame-x2 frame)))))
x-found))
@@ -85,107 +85,107 @@
;;;,-----
;;;| Pack functions
;;;`-----
-(defun pack-group-up (group father)
- "Pack group to up"
- (let ((y-found (find-edge-up group father)))
- (setf (group-y group) y-found)))
+(defun pack-frame-up (frame father)
+ "Pack frame to up"
+ (let ((y-found (find-edge-up frame father)))
+ (setf (frame-y frame) y-found)))
-(defun pack-group-down (group father)
- "Pack group to down"
- (let ((y-found (find-edge-down group father)))
- (setf (group-y group) (- y-found (group-h group)))))
+(defun pack-frame-down (frame father)
+ "Pack frame to down"
+ (let ((y-found (find-edge-down frame father)))
+ (setf (frame-y frame) (- y-found (frame-h frame)))))
-(defun pack-group-right (group father)
- "Pack group to right"
- (let ((x-found (find-edge-right group father)))
- (setf (group-x group) (- x-found (group-w group)))))
+(defun pack-frame-right (frame father)
+ "Pack frame to right"
+ (let ((x-found (find-edge-right frame father)))
+ (setf (frame-x frame) (- x-found (frame-w frame)))))
-(defun pack-group-left (group father)
- "Pack group to left"
- (let ((x-found (find-edge-left group father)))
- (setf (group-x group) x-found)))
+(defun pack-frame-left (frame father)
+ "Pack frame to left"
+ (let ((x-found (find-edge-left frame father)))
+ (setf (frame-x frame) x-found)))
-(defun center-group (group)
- "Center group"
- (setf (group-x group) (/ (- 1 (group-w group)) 2)
- (group-y group) (/ (- 1 (group-h group)) 2)))
+(defun center-frame (frame)
+ "Center frame"
+ (setf (frame-x frame) (/ (- 1 (frame-w frame)) 2)
+ (frame-y frame) (/ (- 1 (frame-h frame)) 2)))
;;;,-----
;;;| Fill functions
;;;`-----
-(defun fill-group-up (group father)
- "Fill a group up"
- (let* ((y-found (find-edge-up group father))
- (dy (- (group-y group) y-found)))
- (setf (group-y group) y-found
- (group-h group) (+ (group-h group) dy))))
-
-(defun fill-group-down (group father)
- "Fill a group down"
- (let* ((y-found (find-edge-down group father))
- (dy (- y-found (group-y2 group))))
- (setf (group-h group) (+ (group-h group) dy))))
-
-
-(defun fill-group-left (group father)
- "Fill a group left"
- (let* ((x-found (find-edge-left group father))
- (dx (- (group-x group) x-found)))
- (setf (group-x group) x-found
- (group-w group) (+ (group-w group) dx))))
-
-(defun fill-group-right (group father)
- "Fill a group rigth"
- (let* ((x-found (find-edge-right group father))
- (dx (- x-found (group-x2 group))))
- (setf (group-w group) (+ (group-w group) dx))))
+(defun fill-frame-up (frame father)
+ "Fill a frame up"
+ (let* ((y-found (find-edge-up frame father))
+ (dy (- (frame-y frame) y-found)))
+ (setf (frame-y frame) y-found
+ (frame-h frame) (+ (frame-h frame) dy))))
+
+(defun fill-frame-down (frame father)
+ "Fill a frame down"
+ (let* ((y-found (find-edge-down frame father))
+ (dy (- y-found (frame-y2 frame))))
+ (setf (frame-h frame) (+ (frame-h frame) dy))))
+
+
+(defun fill-frame-left (frame father)
+ "Fill a frame left"
+ (let* ((x-found (find-edge-left frame father))
+ (dx (- (frame-x frame) x-found)))
+ (setf (frame-x frame) x-found
+ (frame-w frame) (+ (frame-w frame) dx))))
+
+(defun fill-frame-right (frame father)
+ "Fill a frame rigth"
+ (let* ((x-found (find-edge-right frame father))
+ (dx (- x-found (frame-x2 frame))))
+ (setf (frame-w frame) (+ (frame-w frame) dx))))
;;;,-----
;;;| Lower functions
;;;`-----
-(defun resize-group-down (group)
- "Resize down a group"
- (when (> (group-w group) 0.1)
- (setf (group-x group) (+ (group-x group) 0.01)
- (group-w group) (max (- (group-w group) 0.02) 0.01)))
- (when (> (group-h group) 0.1)
- (setf (group-y group) (+ (group-y group) 0.01)
- (group-h group) (max (- (group-h group) 0.02) 0.01))))
+(defun resize-frame-down (frame)
+ "Resize down a frame"
+ (when (> (frame-w frame) 0.1)
+ (setf (frame-x frame) (+ (frame-x frame) 0.01)
+ (frame-w frame) (max (- (frame-w frame) 0.02) 0.01)))
+ (when (> (frame-h frame) 0.1)
+ (setf (frame-y frame) (+ (frame-y frame) 0.01)
+ (frame-h frame) (max (- (frame-h frame) 0.02) 0.01))))
-(defun resize-minimal-group (group)
- "Resize down a group to its minimal size"
+(defun resize-minimal-frame (frame)
+ "Resize down a frame to its minimal size"
(dotimes (i 100)
- (resize-group-down group)))
+ (resize-frame-down frame)))
-(defun resize-half-width-left (group)
- (setf (group-w group)(/ (group-w group) 2)))
+(defun resize-half-width-left (frame)
+ (setf (frame-w frame)(/ (frame-w frame) 2)))
-(defun resize-half-width-right (group)
- (let* ((new-size (/ (group-w group) 2))
- (dx (- (group-w group) new-size)))
- (setf (group-w group) new-size)
- (incf (group-x group) (max dx 0))))
+(defun resize-half-width-right (frame)
+ (let* ((new-size (/ (frame-w frame) 2))
+ (dx (- (frame-w frame) new-size)))
+ (setf (frame-w frame) new-size)
+ (incf (frame-x frame) (max dx 0))))
-(defun resize-half-height-up (group)
- (setf (group-h group) (/ (group-h group) 2)))
+(defun resize-half-height-up (frame)
+ (setf (frame-h frame) (/ (frame-h frame) 2)))
-(defun resize-half-height-down (group)
- (let* ((new-size (/ (group-h group) 2))
- (dy (- (group-h group) new-size)))
- (setf (group-h group) new-size)
- (incf (group-y group) (max dy 0))))
+(defun resize-half-height-down (frame)
+ (let* ((new-size (/ (frame-h frame) 2))
+ (dy (- (frame-h frame) new-size)))
+ (setf (frame-h frame) new-size)
+ (incf (frame-y frame) (max dy 0))))
@@ -193,18 +193,18 @@
;;;;;,-----
;;;;;| Explode/Implode functions
;;;;;`-----
-(defun explode-group (group)
- "Create a new group for each window in group"
- (when (group-p group)
- (let ((windows (loop :for child :in (group-child group)
+(defun explode-frame (frame)
+ "Create a new frame for each window in frame"
+ (when (frame-p frame)
+ (let ((windows (loop :for child :in (frame-child frame)
:when (xlib:window-p child)
:collect child)))
(dolist (win windows)
- (add-group (create-group :child (list win)) group)
- (remove-child-in-group win group)))))
+ (add-frame (create-frame :child (list win)) frame)
+ (remove-child-in-frame win frame)))))
-(defun explode-current-group ()
- "Create a new group for each window in group"
- (explode-group *current-child*)
+(defun explode-current-frame ()
+ "Create a new frame for each window in frame"
+ (explode-frame *current-child*)
(leave-second-mode))
Modified: clfswm/src/clfswm-second-mode.lisp
==============================================================================
--- clfswm/src/clfswm-second-mode.lisp (original)
+++ clfswm/src/clfswm-second-mode.lisp Tue Mar 25 18:02:17 2008
@@ -43,8 +43,8 @@
;; (format nil ">W:~A" *open-next-window-in-new-workspace*))
;; (*open-next-window-in-new-workspace* ">W")
;; (t ""))
-;; (cond ((equal *open-next-window-in-new-group* :once) ">G")
-;; (*open-next-window-in-new-group* ">G+")
+;; (cond ((equal *open-next-window-in-new-frame* :once) ">G")
+;; (*open-next-window-in-new-frame* ">G+")
;; (t ""))))
;; (len (length text)))
;; (xlib:draw-image-glyphs *sm-window* *sm-gc*
@@ -74,7 +74,7 @@
(defun sm-handle-enter-notify (&rest event-slots &key root-x root-y &allow-other-keys)
(declare (ignore event-slots root-x root-y))
- ;; (focus-group-under-mouse root-x root-y)
+ ;; (focus-frame-under-mouse root-x root-y)
(draw-second-mode-window))
(defun sm-handle-motion-notify (&rest event-slots &key root-x root-y &allow-other-keys)
@@ -203,7 +203,7 @@
(xungrab-keyboard)
(xungrab-pointer)
(grab-main-keys)
- (show-all-childs))
+ (show-all-children))
(wait-no-key-or-button-press)
(when *second-mode-program*
(do-shell *second-mode-program*)
Modified: clfswm/src/clfswm-util.lisp
==============================================================================
--- clfswm/src/clfswm-util.lisp (original)
+++ clfswm/src/clfswm-util.lisp Tue Mar 25 18:02:17 2008
@@ -43,66 +43,66 @@
(leave-second-mode)))
-(defun renumber-current-group ()
- "Renumber the current group"
- (when (group-p *current-child*)
- (let ((number (query-number (format nil "New child number: (last: ~A)" (group-number *current-child*))
- (group-number *current-child*))))
- (setf (group-number *current-child*) number)
+(defun renumber-current-frame ()
+ "Renumber the current frame"
+ (when (frame-p *current-child*)
+ (let ((number (query-number (format nil "New child number: (last: ~A)" (frame-number *current-child*))
+ (frame-number *current-child*))))
+ (setf (frame-number *current-child*) number)
(leave-second-mode))))
-(defun add-default-group ()
- "Add a default group"
- (when (group-p *current-child*)
- (let ((name (query-string "Group name")))
- (push (create-group :name name) (group-child *current-child*))))
+(defun add-default-frame ()
+ "Add a default frame"
+ (when (frame-p *current-child*)
+ (let ((name (query-string "Frame name")))
+ (push (create-frame :name name) (frame-child *current-child*))))
(leave-second-mode))
-(defun add-placed-group ()
- "Add a placed group"
- (when (group-p *current-child*)
- (let ((name (query-string "Group name"))
- (x (/ (query-number "Group x in percent (%)") 100))
- (y (/ (query-number "Group y in percent (%)") 100))
- (w (/ (query-number "Group width in percent (%)") 100))
- (h (/ (query-number "Group height in percent (%)") 100)))
- (push (create-group :name name :x x :y y :w w :h h)
- (group-child *current-child*))))
+(defun add-placed-frame ()
+ "Add a placed frame"
+ (when (frame-p *current-child*)
+ (let ((name (query-string "Frame name"))
+ (x (/ (query-number "Frame x in percent (%)") 100))
+ (y (/ (query-number "Frame y in percent (%)") 100))
+ (w (/ (query-number "Frame width in percent (%)") 100))
+ (h (/ (query-number "Frame height in percent (%)") 100)))
+ (push (create-frame :name name :x x :y y :w w :h h)
+ (frame-child *current-child*))))
(leave-second-mode))
(defun delete-focus-window ()
- "Delete the focus window in all groups and workspaces"
+ "Delete the focus window in all frames and workspaces"
(let ((window (xlib:input-focus *display*)))
(when (and window (not (xlib:window-equal window *no-focus-window*)))
(setf *current-child* *current-root*)
- (remove-child-in-all-groups window)
+ (remove-child-in-all-frames window)
(send-client-message window :WM_PROTOCOLS
(xlib:intern-atom *display* "WM_DELETE_WINDOW"))
- (show-all-childs))))
+ (show-all-children))))
(defun destroy-focus-window ()
- "Destroy the focus window in all groups and workspaces"
+ "Destroy the focus window in all frames and workspaces"
(let ((window (xlib:input-focus *display*)))
(when (and window (not (xlib:window-equal window *no-focus-window*)))
(setf *current-child* *current-root*)
- (remove-child-in-all-groups window)
+ (remove-child-in-all-frames window)
(xlib:kill-client *display* (xlib:window-id window))
- (show-all-childs))))
+ (show-all-children))))
(defun remove-focus-window ()
- "Remove the focus window in the current group"
+ "Remove the focus window in the current frame"
(let ((window (xlib:input-focus *display*)))
(when (and window (not (xlib:window-equal window *no-focus-window*)))
(setf *current-child* *current-root*)
(hide-child window)
- (remove-child-in-group window (find-father-group window))
- (show-all-childs))))
+ (remove-child-in-frame window (find-father-frame window))
+ (show-all-children))))
(defun unhide-all-windows-in-current-child ()
@@ -112,7 +112,7 @@
(unhide-window window)
(process-new-window window)
(xlib:map-window window)))
- (show-all-childs))
+ (show-all-children))
@@ -121,13 +121,13 @@
"Return the child window under the mouse"
(with-xlib-protect
(let ((win nil))
- (with-all-windows-groups (*current-root* child)
+ (with-all-windows-frames (*current-root* child)
(when (and (<= (xlib:drawable-x child) x (+ (xlib:drawable-x child) (xlib:drawable-width child)))
(<= (xlib:drawable-y child) y (+ (xlib:drawable-y child) (xlib:drawable-height child))))
(setf win child))
- (when (and (<= (group-rx child) x (+ (group-rx child) (group-rw child)))
- (<= (group-ry child) y (+ (group-ry child) (group-rh child))))
- (setf win (group-window child))))
+ (when (and (<= (frame-rx child) x (+ (frame-rx child) (frame-rw child)))
+ (<= (frame-ry child) y (+ (frame-ry child) (frame-rh child))))
+ (setf win (frame-window child))))
win)))
@@ -135,12 +135,12 @@
"Return the child under the mouse"
(with-xlib-protect
(let ((ret nil))
- (with-all-windows-groups (*current-root* child)
+ (with-all-windows-frames (*current-root* child)
(when (and (<= (xlib:drawable-x child) x (+ (xlib:drawable-x child) (xlib:drawable-width child)))
(<= (xlib:drawable-y child) y (+ (xlib:drawable-y child) (xlib:drawable-height child))))
(setf ret child))
- (when (and (<= (group-rx child) x (+ (group-rx child) (group-rw child)))
- (<= (group-ry child) y (+ (group-ry child) (group-rh child))))
+ (when (and (<= (frame-rx child) x (+ (frame-rx child) (frame-rw child)))
+ (<= (frame-ry child) y (+ (frame-ry child) (frame-rh child))))
(setf ret child)))
ret)))
@@ -152,45 +152,45 @@
(defun clear-selection ()
"Clear the current selection"
(setf *child-selection* nil)
- (display-group-info *current-root*))
+ (display-frame-info *current-root*))
(defun copy-current-child ()
"Copy the current child to the selection"
(pushnew *current-child* *child-selection*)
- (display-group-info *current-root*))
+ (display-frame-info *current-root*))
(defun cut-current-child ()
"Cut the current child to the selection"
(copy-current-child)
- (hide-all-childs *current-child*)
- (remove-child-in-group *current-child* (find-father-group *current-child* *current-root*))
+ (hide-all-children *current-child*)
+ (remove-child-in-frame *current-child* (find-father-frame *current-child* *current-root*))
(setf *current-child* *current-root*)
- (show-all-childs))
+ (show-all-children))
(defun remove-current-child ()
- "Remove the current child from its father group"
- (hide-all-childs *current-child*)
- (remove-child-in-group *current-child* (find-father-group *current-child* *current-root*))
+ "Remove the current child from its father frame"
+ (hide-all-children *current-child*)
+ (remove-child-in-frame *current-child* (find-father-frame *current-child* *current-root*))
(setf *current-child* *current-root*)
(leave-second-mode))
(defun paste-selection-no-clear ()
- "Paste the selection in the current group - Do not clear the selection after paste"
- (let ((group-dest (typecase *current-child*
- (xlib:window (find-father-group *current-child* *current-root*))
- (group *current-child*))))
- (when group-dest
+ "Paste the selection in the current frame - Do not clear the selection after paste"
+ (let ((frame-dest (typecase *current-child*
+ (xlib:window (find-father-frame *current-child* *current-root*))
+ (frame *current-child*))))
+ (when frame-dest
(dolist (child *child-selection*)
- (pushnew child (group-child group-dest)))
- (show-all-childs))))
+ (pushnew child (frame-child frame-dest)))
+ (show-all-children))))
(defun paste-selection ()
- "Paste the selection in the current group"
+ "Paste the selection in the current frame"
(paste-selection-no-clear)
(setf *child-selection* nil)
- (display-group-info *current-root*))
+ (display-frame-info *current-root*))
@@ -300,18 +300,18 @@
-;;; Group name actions
+;;; Frame name actions
;;;(loop :for str :in '("The Gimp" "The klm" "klm" "abc") ;; Test
;;; :when (zerop (or (search "ThE" str :test #'string-equal) -1))
;;; :collect str)
-(defun ask-group-name (msg)
- "Ask a group name"
- (let ((all-group-name nil)
+(defun ask-frame-name (msg)
+ "Ask a frame name"
+ (let ((all-frame-name nil)
(name ""))
- (with-all-groups (*root-group* group)
- (awhen (group-name group) (push it all-group-name)))
+ (with-all-frames (*root-frame* frame)
+ (awhen (frame-name frame) (push it all-frame-name)))
(labels ((selected-names ()
- (loop :for str :in all-group-name
+ (loop :for str :in all-frame-name
:when (zerop (or (search name str :test #'string-equal) -1))
:collect str))
(complet-alone (req sel)
@@ -330,107 +330,107 @@
;;; Focus by functions
-(defun focus-group-by (group)
- (when (group-p group)
- (hide-all-childs *current-root*)
- (focus-all-childs group (or (find-father-group group *current-root*)
- (find-father-group group)
- *root-group*))))
-
-
-(defun focus-group-by-name ()
- "Focus a group by name"
- (focus-group-by (find-group-by-name (ask-group-name "Focus group")))
- (leave-second-mode))
-
-(defun focus-group-by-number ()
- "Focus a group by number"
- (focus-group-by (find-group-by-number (query-number "Focus group by number:")))
+(defun focus-frame-by (frame)
+ (when (frame-p frame)
+ (hide-all-children *current-root*)
+ (focus-all-children frame (or (find-father-frame frame *current-root*)
+ (find-father-frame frame)
+ *root-frame*))))
+
+
+(defun focus-frame-by-name ()
+ "Focus a frame by name"
+ (focus-frame-by (find-frame-by-name (ask-frame-name "Focus frame")))
+ (leave-second-mode))
+
+(defun focus-frame-by-number ()
+ "Focus a frame by number"
+ (focus-frame-by (find-frame-by-number (query-number "Focus frame by number:")))
(leave-second-mode))
;;; Open by functions
-(defun open-group-by (group)
- (when (group-p group)
- (push (create-group :name (query-string "Group name")) (group-child group))))
+(defun open-frame-by (frame)
+ (when (frame-p frame)
+ (push (create-frame :name (query-string "Frame name")) (frame-child frame))))
-(defun open-group-by-name ()
- "Open a new group in a named group"
- (open-group-by (find-group-by-name (ask-group-name "Open a new group in")))
+(defun open-frame-by-name ()
+ "Open a new frame in a named frame"
+ (open-frame-by (find-frame-by-name (ask-frame-name "Open a new frame in")))
(leave-second-mode))
-(defun open-group-by-number ()
- "Open a new group in a numbered group"
- (open-group-by (find-group-by-name (ask-group-name "Open a new group in the grou numbered:")))
+(defun open-frame-by-number ()
+ "Open a new frame in a numbered frame"
+ (open-frame-by (find-frame-by-name (ask-frame-name "Open a new frame in the grou numbered:")))
(leave-second-mode))
;;; Delete by functions
-(defun delete-group-by (group)
- (hide-all-childs *current-root*)
- (unless (equal group *root-group*)
- (when (equal group *current-root*)
- (setf *current-root* *root-group*))
- (when (equal group *current-child*)
+(defun delete-frame-by (frame)
+ (hide-all-children *current-root*)
+ (unless (equal frame *root-frame*)
+ (when (equal frame *current-root*)
+ (setf *current-root* *root-frame*))
+ (when (equal frame *current-child*)
(setf *current-child* *current-root*))
- (remove-child-in-group group (find-father-group group))))
+ (remove-child-in-frame frame (find-father-frame frame))))
-(defun delete-group-by-name ()
- "Delete a group by name"
- (delete-group-by (find-group-by-name (ask-group-name "Delete group")))
+(defun delete-frame-by-name ()
+ "Delete a frame by name"
+ (delete-frame-by (find-frame-by-name (ask-frame-name "Delete frame")))
(leave-second-mode))
-(defun delete-group-by-number ()
- "Delete a group by number"
- (delete-group-by (find-group-by-number (query-number "Delete group by number:")))
+(defun delete-frame-by-number ()
+ "Delete a frame by number"
+ (delete-frame-by (find-frame-by-number (query-number "Delete frame by number:")))
(leave-second-mode))
;;; Move by function
-(defun move-current-child-by (child group-dest)
- (when (and child (group-p group-dest))
- (hide-all-childs *current-root*)
- (remove-child-in-group child (find-father-group child))
- (pushnew child (group-child group-dest))
- (focus-all-childs child group-dest)))
+(defun move-current-child-by (child frame-dest)
+ (when (and child (frame-p frame-dest))
+ (hide-all-children *current-root*)
+ (remove-child-in-frame child (find-father-frame child))
+ (pushnew child (frame-child frame-dest))
+ (focus-all-children child frame-dest)))
(defun move-current-child-by-name ()
- "Move current child in a named group"
+ "Move current child in a named frame"
(move-current-child-by *current-child*
- (find-group-by-name
- (ask-group-name (format nil "Move '~A' to group" (child-name *current-child*)))))
+ (find-frame-by-name
+ (ask-frame-name (format nil "Move '~A' to frame" (child-name *current-child*)))))
(leave-second-mode))
(defun move-current-child-by-number ()
- "Move current child in a numbered group"
+ "Move current child in a numbered frame"
(move-current-child-by *current-child*
- (find-group-by-number
- (query-number (format nil "Move '~A' to group numbered:" (child-name *current-child*)))))
+ (find-frame-by-number
+ (query-number (format nil "Move '~A' to frame numbered:" (child-name *current-child*)))))
(leave-second-mode))
;;; Copy by function
-(defun copy-current-child-by (child group-dest)
- (when (and child (group-p group-dest))
- (hide-all-childs *current-root*)
- (pushnew child (group-child group-dest))
- (focus-all-childs child group-dest)))
+(defun copy-current-child-by (child frame-dest)
+ (when (and child (frame-p frame-dest))
+ (hide-all-children *current-root*)
+ (pushnew child (frame-child frame-dest))
+ (focus-all-children child frame-dest)))
(defun copy-current-child-by-name ()
- "Copy current child in a named group"
+ "Copy current child in a named frame"
(copy-current-child-by *current-child*
- (find-group-by-name
- (ask-group-name (format nil "Copy '~A' to group" (child-name *current-child*)))))
+ (find-frame-by-name
+ (ask-frame-name (format nil "Copy '~A' to frame" (child-name *current-child*)))))
(leave-second-mode))
(defun copy-current-child-by-number ()
- "Copy current child in a numbered group"
+ "Copy current child in a numbered frame"
(copy-current-child-by *current-child*
- (find-group-by-number
- (query-number (format nil "Copy '~A' to group numbered:" (child-name *current-child*)))))
+ (find-frame-by-number
+ (query-number (format nil "Copy '~A' to frame numbered:" (child-name *current-child*)))))
(leave-second-mode))
@@ -438,51 +438,51 @@
;;; Force window functions
-(defun force-window-in-group ()
- "Force the current window to move in the group (Useful only for transient windows)"
+(defun force-window-in-frame ()
+ "Force the current window to move in the frame (Useful only for transient windows)"
(when (xlib:window-p *current-child*)
- (let ((father (find-father-group *current-child*)))
+ (let ((father (find-father-frame *current-child*)))
(with-xlib-protect
- (setf (xlib:drawable-x *current-child*) (group-rx father)
- (xlib:drawable-y *current-child*) (group-ry father)))))
+ (setf (xlib:drawable-x *current-child*) (frame-rx father)
+ (xlib:drawable-y *current-child*) (frame-ry father)))))
(leave-second-mode))
-(defun force-window-center-in-group ()
- "Force the current window to move in the center of the group (Useful only for transient windows)"
+(defun force-window-center-in-frame ()
+ "Force the current window to move in the center of the frame (Useful only for transient windows)"
(when (xlib:window-p *current-child*)
- (let ((father (find-father-group *current-child*)))
+ (let ((father (find-father-frame *current-child*)))
(with-xlib-protect
- (setf (xlib:drawable-x *current-child*) (truncate (+ (group-rx father)
- (/ (- (group-rw father)
+ (setf (xlib:drawable-x *current-child*) (truncate (+ (frame-rx father)
+ (/ (- (frame-rw father)
(xlib:drawable-width *current-child*)) 2)))
- (xlib:drawable-y *current-child*) (truncate (+ (group-ry father)
- (/ (- (group-rh father)
+ (xlib:drawable-y *current-child*) (truncate (+ (frame-ry father)
+ (/ (- (frame-rh father)
(xlib:drawable-height *current-child*)) 2)))))))
(leave-second-mode))
-;;; Show group info
-(defun show-all-groups-info ()
- "Show all groups info windows"
- (let ((*show-root-group-p* t))
- (show-all-childs)
- (with-all-groups (*current-root* group)
- (raise-window (group-window group))
- (display-group-info group))))
+;;; Show frame info
+(defun show-all-frames-info ()
+ "Show all frames info windows"
+ (let ((*show-root-frame-p* t))
+ (show-all-children)
+ (with-all-frames (*current-root* frame)
+ (raise-window (frame-window frame))
+ (display-frame-info frame))))
-(defun hide-all-groups-info ()
- "Hide all groups info windows"
+(defun hide-all-frames-info ()
+ "Hide all frames info windows"
(with-all-windows (*current-root* window)
(raise-window window))
(hide-child *current-root*)
- (show-all-childs))
+ (show-all-children))
-(defun show-all-groups-info-key ()
- "Show all groups info windows until a key is release"
- (show-all-groups-info)
+(defun show-all-frames-info-key ()
+ "Show all frames info windows until a key is release"
+ (show-all-frames-info)
(wait-no-key-or-button-press)
- (hide-all-groups-info))
+ (hide-all-frames-info))
@@ -490,53 +490,53 @@
;;;;;| Various definitions
;;;;;`-----
;;(defun stop-all-pending-actions ()
-;; "Stop all pending actions (actions like open in new workspace/group)"
+;; "Stop all pending actions (actions like open in new workspace/frame)"
;; (setf *open-next-window-in-new-workspace* nil
-;; *open-next-window-in-new-group* nil
+;; *open-next-window-in-new-frame* nil
;; *arrow-action* nil
;; *pager-arrow-action* nil))
;;
;;(defun rotate-window-up ()
-;; "Rotate up windows in the current group"
-;; (setf (group-window-list (current-group))
-;; (rotate-list (group-window-list (current-group))))
-;; (adapt-window-to-group (current-window) (current-group))
+;; "Rotate up windows in the current frame"
+;; (setf (frame-window-list (current-frame))
+;; (rotate-list (frame-window-list (current-frame))))
+;; (adapt-window-to-frame (current-window) (current-frame))
;; (focus-window (current-window))
-;; (show-all-group (current-workspace)))
+;; (show-all-frame (current-workspace)))
;;
;;(defun rotate-window-down ()
-;; "Rotate down windows in the current group"
-;; (setf (group-window-list (current-group))
-;; (anti-rotate-list (group-window-list (current-group))))
-;; (adapt-window-to-group (current-window) (current-group))
-;; (focus-window (current-window))
-;; (show-all-group (current-workspace)))
+;; "Rotate down windows in the current frame"
+;; (setf (frame-window-list (current-frame))
+;; (anti-rotate-list (frame-window-list (current-frame))))
+;; (adapt-window-to-frame (current-window) (current-frame))
+;; (focus-window (current-window))
+;; (show-all-frame (current-workspace)))
;;
;;
-;;(defun maximize-group (group)
-;; "Maximize the group"
-;; (when group
-;; (unless (group-fullscreenp group)
-;; (setf (group-fullscreenp group) t)
+;;(defun maximize-frame (frame)
+;; "Maximize the frame"
+;; (when frame
+;; (unless (frame-fullscreenp frame)
+;; (setf (frame-fullscreenp frame) t)
;; (show-all-windows-in-workspace (current-workspace)))))
;;
-;;(defun minimize-group (group)
-;; "Minimize the group"
-;; (when group
-;; (when (group-fullscreenp group)
-;; (setf (group-fullscreenp group) nil)
+;;(defun minimize-frame (frame)
+;; "Minimize the frame"
+;; (when frame
+;; (when (frame-fullscreenp frame)
+;; (setf (frame-fullscreenp frame) nil)
;; (show-all-windows-in-workspace (current-workspace)))))
;;
-;;(defun toggle-maximize-group (group)
-;; "Maximize/minimize a group"
-;; (if (group-fullscreenp group)
-;; (minimize-group group)
-;; (maximize-group group)))
+;;(defun toggle-maximize-frame (frame)
+;; "Maximize/minimize a frame"
+;; (if (frame-fullscreenp frame)
+;; (minimize-frame frame)
+;; (maximize-frame frame)))
;;
;;
-;;(defun toggle-maximize-current-group ()
-;; "Maximize/minimize the current group"
-;; (toggle-maximize-group (current-group)))
+;;(defun toggle-maximize-current-frame ()
+;; "Maximize/minimize the current frame"
+;; (toggle-maximize-frame (current-frame)))
;;
;;
;;(defun renumber-workspaces ()
@@ -559,88 +559,88 @@
;;
;;
;;
-;;(defun circulate-group-up ()
-;; "Circulate up in group"
+;;(defun circulate-frame-up ()
+;; "Circulate up in frame"
;; (banish-pointer)
-;; (minimize-group (current-group))
+;; (minimize-frame (current-frame))
;; (no-focus)
-;; (setf (workspace-group-list (current-workspace))
-;; (rotate-list (workspace-group-list (current-workspace))))
-;; (adapt-window-to-group (current-window) (current-group))
+;; (setf (workspace-frame-list (current-workspace))
+;; (rotate-list (workspace-frame-list (current-workspace))))
+;; (adapt-window-to-frame (current-window) (current-frame))
;; (focus-window (current-window))
-;; (show-all-group (current-workspace)))
+;; (show-all-frame (current-workspace)))
;;
;;
-;;(defun circulate-group-up-move-window ()
-;; "Circulate up in group moving the current window in the next group"
+;;(defun circulate-frame-up-move-window ()
+;; "Circulate up in frame moving the current window in the next frame"
;; (banish-pointer)
-;; (minimize-group (current-group))
+;; (minimize-frame (current-frame))
;; (no-focus)
;; (let ((window (current-window)))
-;; (remove-window-in-group window (current-group))
+;; (remove-window-in-frame window (current-frame))
;; (focus-window (current-window))
-;; (setf (workspace-group-list (current-workspace))
-;; (rotate-list (workspace-group-list (current-workspace))))
-;; (add-window-in-group window (current-group)))
-;; (adapt-window-to-group (current-window) (current-group))
+;; (setf (workspace-frame-list (current-workspace))
+;; (rotate-list (workspace-frame-list (current-workspace))))
+;; (add-window-in-frame window (current-frame)))
+;; (adapt-window-to-frame (current-window) (current-frame))
;; (focus-window (current-window))
-;; (show-all-group (current-workspace)))
+;; (show-all-frame (current-workspace)))
;;
-;;(defun circulate-group-up-copy-window ()
-;; "Circulate up in group copying the current window in the next group"
+;;(defun circulate-frame-up-copy-window ()
+;; "Circulate up in frame copying the current window in the next frame"
;; (banish-pointer)
-;; (minimize-group (current-group))
+;; (minimize-frame (current-frame))
;; (no-focus)
;; (let ((window (current-window)))
-;; (setf (workspace-group-list (current-workspace))
-;; (rotate-list (workspace-group-list (current-workspace))))
+;; (setf (workspace-frame-list (current-workspace))
+;; (rotate-list (workspace-frame-list (current-workspace))))
;; (unless (window-already-in-workspace window (current-workspace))
-;; (add-window-in-group window (current-group))))
-;; (adapt-window-to-group (current-window) (current-group))
+;; (add-window-in-frame window (current-frame))))
+;; (adapt-window-to-frame (current-window) (current-frame))
;; (focus-window (current-window))
-;; (show-all-group (current-workspace)))
+;; (show-all-frame (current-workspace)))
;;
;;
;;
-;;(defun circulate-group-down ()
-;; "Circulate down in group"
+;;(defun circulate-frame-down ()
+;; "Circulate down in frame"
;; (banish-pointer)
-;; (minimize-group (current-group))
+;; (minimize-frame (current-frame))
;; (no-focus)
-;; (setf (workspace-group-list (current-workspace))
-;; (anti-rotate-list (workspace-group-list (current-workspace))))
-;; (adapt-window-to-group (current-window) (current-group))
+;; (setf (workspace-frame-list (current-workspace))
+;; (anti-rotate-list (workspace-frame-list (current-workspace))))
+;; (adapt-window-to-frame (current-window) (current-frame))
;; (focus-window (current-window))
-;; (show-all-group (current-workspace)))
+;; (show-all-frame (current-workspace)))
;;
-;;(defun circulate-group-down-move-window ()
-;; "Circulate down in group moving the current window in the next group"
+;;(defun circulate-frame-down-move-window ()
+;; "Circulate down in frame moving the current window in the next frame"
;; (banish-pointer)
-;; (minimize-group (current-group))
+;; (minimize-frame (current-frame))
;; (no-focus)
;; (let ((window (current-window)))
-;; (remove-window-in-group window (current-group))
+;; (remove-window-in-frame window (current-frame))
;; (focus-window (current-window))
-;; (setf (workspace-group-list (current-workspace))
-;; (anti-rotate-list (workspace-group-list (current-workspace))))
-;; (add-window-in-group window (current-group)))
-;; (adapt-window-to-group (current-window) (current-group))
+;; (setf (workspace-frame-list (current-workspace))
+;; (anti-rotate-list (workspace-frame-list (current-workspace))))
+;; (add-window-in-frame window (current-frame)))
+;; (adapt-window-to-frame (current-window) (current-frame))
;; (focus-window (current-window))
-;; (show-all-group (current-workspace)))
+;; (show-all-frame (current-workspace)))
;;
-;;(defun circulate-group-down-copy-window ()
-;; "Circulate down in group copying the current window in the next group"
+;;(defun circulate-frame-down-copy-window ()
+;; "Circulate down in frame copying the current window in the next frame"
;; (banish-pointer)
-;; (minimize-group (current-group))
+;; (minimize-frame (current-frame))
;; (no-focus)
;; (let ((window (current-window)))
-;; (setf (workspace-group-list (current-workspace))
-;; (anti-rotate-list (workspace-group-list (current-workspace))))
+;; (setf (workspace-frame-list (current-workspace))
+;; (anti-rotate-list (workspace-frame-list (current-workspace))))
;; (unless (window-already-in-workspace window (current-workspace))
-;; (add-window-in-group window (current-group))))
-;; (adapt-window-to-group (current-window) (current-group))
+;; (add-window-in-frame window (current-frame))))
+;; (adapt-window-to-frame (current-window) (current-frame))
;; (focus-window (current-window))
-;; (show-all-group (current-workspace)))
+;; (show-all-frame (current-workspace)))
;;
;;
;;
@@ -664,24 +664,24 @@
;; (setf *workspace-list* (rotate-list *workspace-list*))
;; (show-all-windows-in-workspace (current-workspace)))
;;
-;;(defun circulate-workspace-up-move-group ()
-;; "Circulate up in workspace moving current group in the next workspace"
+;;(defun circulate-workspace-up-move-frame ()
+;; "Circulate up in workspace moving current frame in the next workspace"
;; (no-focus)
;; (hide-all-windows-in-workspace (current-workspace))
-;; (let ((group (current-group)))
-;; (remove-group-in-workspace group (current-workspace))
+;; (let ((frame (current-frame)))
+;; (remove-frame-in-workspace frame (current-workspace))
;; (setf *workspace-list* (rotate-list *workspace-list*))
-;; (add-group-in-workspace (copy-group group) (current-workspace)))
+;; (add-frame-in-workspace (copy-frame frame) (current-workspace)))
;; (show-all-windows-in-workspace (current-workspace)))
;;
-;;(defun circulate-workspace-up-copy-group ()
-;; "Circulate up in workspace copying current group in the next workspace"
+;;(defun circulate-workspace-up-copy-frame ()
+;; "Circulate up in workspace copying current frame in the next workspace"
;; (no-focus)
;; (hide-all-windows-in-workspace (current-workspace))
-;; (let ((group (current-group)))
+;; (let ((frame (current-frame)))
;; (setf *workspace-list* (rotate-list *workspace-list*))
-;; (unless (group-windows-already-in-workspace group (current-workspace))
-;; (add-group-in-workspace (copy-group group) (current-workspace))))
+;; (unless (frame-windows-already-in-workspace frame (current-workspace))
+;; (add-frame-in-workspace (copy-frame frame) (current-workspace))))
;; (show-all-windows-in-workspace (current-workspace)))
;;
;;
@@ -693,30 +693,30 @@
;; (setf *workspace-list* (anti-rotate-list *workspace-list*))
;; (show-all-windows-in-workspace (current-workspace)))
;;
-;;(defun circulate-workspace-down-move-group ()
-;; "Circulate down in workspace moving current group in the next workspace"
+;;(defun circulate-workspace-down-move-frame ()
+;; "Circulate down in workspace moving current frame in the next workspace"
;; (no-focus)
;; (hide-all-windows-in-workspace (current-workspace))
-;; (let ((group (current-group)))
-;; (remove-group-in-workspace group (current-workspace))
+;; (let ((frame (current-frame)))
+;; (remove-frame-in-workspace frame (current-workspace))
;; (setf *workspace-list* (anti-rotate-list *workspace-list*))
-;; (add-group-in-workspace (copy-group group) (current-workspace)))
+;; (add-frame-in-workspace (copy-frame frame) (current-workspace)))
;; (show-all-windows-in-workspace (current-workspace)))
;;
-;;(defun circulate-workspace-down-copy-group ()
-;; "Circulate down in workspace copying current group in the next workspace"
+;;(defun circulate-workspace-down-copy-frame ()
+;; "Circulate down in workspace copying current frame in the next workspace"
;; (no-focus)
;; (hide-all-windows-in-workspace (current-workspace))
-;; (let ((group (current-group)))
+;; (let ((frame (current-frame)))
;; (setf *workspace-list* (anti-rotate-list *workspace-list*))
-;; (unless (group-windows-already-in-workspace group (current-workspace))
-;; (add-group-in-workspace (copy-group group) (current-workspace))))
+;; (unless (frame-windows-already-in-workspace frame (current-workspace))
+;; (add-frame-in-workspace (copy-frame frame) (current-workspace))))
;; (show-all-windows-in-workspace (current-workspace)))
;;
;;
;;
;;(defun delete-current-window ()
-;; "Delete the current window in all groups and workspaces"
+;; "Delete the current window in all frames and workspaces"
;; (let ((window (current-window)))
;; (when window
;; (no-focus)
@@ -724,41 +724,41 @@
;; (send-client-message window :WM_PROTOCOLS
;; (intern-atom *display* "WM_DELETE_WINDOW"))))
;; (focus-window (current-window))
-;; (show-all-group (current-workspace)))
+;; (show-all-frame (current-workspace)))
;;
;;
;;(defun destroy-current-window ()
-;; "Destroy the current window in all groups and workspaces"
+;; "Destroy the current window in all frames and workspaces"
;; (let ((window (current-window)))
;; (when window
;; (no-focus)
;; (remove-window-in-all-workspace window)
;; (kill-client *display* (xlib:window-id window))))
;; (focus-window (current-window))
-;; (show-all-group (current-workspace)))
+;; (show-all-frame (current-workspace)))
;;
;;(defun remove-current-window ()
-;; "Remove the current window in the current group"
+;; "Remove the current window in the current frame"
;; (let ((window (current-window)))
;; (when window
;; (no-focus)
;; (hide-window window)
-;; (remove-window-in-group (current-window) (current-group))))
+;; (remove-window-in-frame (current-window) (current-frame))))
;; (focus-window (current-window))
-;; (show-all-group (current-workspace)))
+;; (show-all-frame (current-workspace)))
;;
-;;(defun remove-current-group ()
-;; "Remove the current group in the current workspace"
-;; (minimize-group (current-group))
-;; (let ((group (current-group)))
-;; (when group
+;;(defun remove-current-frame ()
+;; "Remove the current frame in the current workspace"
+;; (minimize-frame (current-frame))
+;; (let ((frame (current-frame)))
+;; (when frame
;; (no-focus)
-;; (dolist (window (group-window-list group))
+;; (dolist (window (frame-window-list frame))
;; (when window
;; (hide-window window)))
-;; (remove-group-in-workspace group (current-workspace))))
+;; (remove-frame-in-workspace frame (current-workspace))))
;; (focus-window (current-window))
-;; (show-all-group (current-workspace)))
+;; (show-all-frame (current-workspace)))
;;
;;(defun remove-current-workspace ()
;; "Remove the current workspace"
@@ -769,27 +769,27 @@
;; (show-all-windows-in-workspace (current-workspace)))))
;;
;;
-;;(defun unhide-all-windows-in-current-group ()
-;; "Unhide all hidden windows into the current group"
+;;(defun unhide-all-windows-in-current-frame ()
+;; "Unhide all hidden windows into the current frame"
;; (let ((all-windows (get-all-windows))
;; (hidden-windows (remove-if-not #'window-hidden-p
;; (copy-list (xlib:query-tree *root*))))
-;; (current-group (current-group)))
+;; (current-frame (current-frame)))
;; (dolist (window (set-difference hidden-windows all-windows))
;; (unhide-window window)
;; (process-new-window window)
;; (xlib:map-window window)
-;; (adapt-window-to-group window current-group)))
+;; (adapt-window-to-frame window current-frame)))
;; (focus-window (current-window))
-;; (show-all-group (current-workspace)))
+;; (show-all-frame (current-workspace)))
;;
;;
;;
;;
-;;(defun create-new-default-group ()
-;; "Create a new default group"
-;; (minimize-group (current-group))
-;; (add-group-in-workspace (copy-group *default-group*)
+;;(defun create-new-default-frame ()
+;; "Create a new default frame"
+;; (minimize-frame (current-frame))
+;; (add-frame-in-workspace (copy-frame *default-frame*)
;; (current-workspace))
;; (show-all-windows-in-workspace (current-workspace)))
;;
@@ -804,52 +804,52 @@
;;
;;
;;;;;,-----
-;;;;;| Group moving
+;;;;;| Frame moving
;;;;;`-----
-;;(defun move-group (group dx dy)
-;; "Move group"
-;; (setf (group-x group) (+ (group-x group) dx)
-;; (group-y group) (+ (group-y group) dy))
-;; (dolist (window (group-window-list group))
-;; (adapt-window-to-group window group))
-;; (show-all-group (current-workspace)))
-;;
-;;(defun move-group-to (group x y)
-;; "Move group to"
-;; (setf (group-x group) x
-;; (group-y group) y)
-;; (dolist (window (group-window-list group))
-;; (adapt-window-to-group window group))
-;; (focus-window (current-window))
-;; (show-all-group (current-workspace)))
-;;
-;;
-;;(defun resize-group (group dx dy)
-;; "Resize group"
-;; (setf (group-width group) (max (+ (group-width group) dx) 100)
-;; (group-height group) (max (+ (group-height group) dy) 100))
-;; (dolist (window (group-window-list group))
-;; (adapt-window-to-group window group))
-;; (show-all-group (current-workspace)))
-;;
-;;(defun force-window-in-group ()
-;; "Force the current window to move in the group (Useful only for transient windows)"
-;; (let ((group (current-group))
+;;(defun move-frame (frame dx dy)
+;; "Move frame"
+;; (setf (frame-x frame) (+ (frame-x frame) dx)
+;; (frame-y frame) (+ (frame-y frame) dy))
+;; (dolist (window (frame-window-list frame))
+;; (adapt-window-to-frame window frame))
+;; (show-all-frame (current-workspace)))
+;;
+;;(defun move-frame-to (frame x y)
+;; "Move frame to"
+;; (setf (frame-x frame) x
+;; (frame-y frame) y)
+;; (dolist (window (frame-window-list frame))
+;; (adapt-window-to-frame window frame))
+;; (focus-window (current-window))
+;; (show-all-frame (current-workspace)))
+;;
+;;
+;;(defun resize-frame (frame dx dy)
+;; "Resize frame"
+;; (setf (frame-width frame) (max (+ (frame-width frame) dx) 100)
+;; (frame-height frame) (max (+ (frame-height frame) dy) 100))
+;; (dolist (window (frame-window-list frame))
+;; (adapt-window-to-frame window frame))
+;; (show-all-frame (current-workspace)))
+;;
+;;(defun force-window-in-frame ()
+;; "Force the current window to move in the frame (Useful only for transient windows)"
+;; (let ((frame (current-frame))
;; (window (current-window)))
;; (when window
-;; (setf (xlib:drawable-x window) (group-x group)
-;; (xlib:drawable-y window) (group-y group))
+;; (setf (xlib:drawable-x window) (frame-x frame)
+;; (xlib:drawable-y window) (frame-y frame))
;; (show-all-windows-in-workspace (current-workspace)))))
;;
-;;(defun force-window-center-in-group ()
-;; "Force the current window to move in the center of the group (Useful only for transient windows)"
-;; (let ((group (current-group))
+;;(defun force-window-center-in-frame ()
+;; "Force the current window to move in the center of the frame (Useful only for transient windows)"
+;; (let ((frame (current-frame))
;; (window (current-window)))
;; (when window
-;; (setf (xlib:drawable-x window) (truncate (+ (group-x group)
-;; (/ (- (group-width group) (xlib:drawable-width window)) 2)))
-;; (xlib:drawable-y window) (truncate (+ (group-y group)
-;; (/ (- (group-height group) (xlib:drawable-height window)) 2))))
+;; (setf (xlib:drawable-x window) (truncate (+ (frame-x frame)
+;; (/ (- (frame-width frame) (xlib:drawable-width window)) 2)))
+;; (xlib:drawable-y window) (truncate (+ (frame-y frame)
+;; (/ (- (frame-height frame) (xlib:drawable-height window)) 2))))
;; (show-all-windows-in-workspace (current-workspace)))))
;;
;;
Modified: clfswm/src/clfswm.lisp
==============================================================================
--- clfswm/src/clfswm.lisp (original)
+++ clfswm/src/clfswm.lisp Tue Mar 25 18:02:17 2008
@@ -35,7 +35,7 @@
(funcall-key-from-code *main-keys* code state))
-;; PHIL: TODO: focus-policy by group
+;; PHIL: TODO: focus-policy by frame
;; :click, :sloppy, :nofocus
(defun handle-button-press (&rest event-slots &key code state window root-x root-y &allow-other-keys)
(declare (ignore event-slots))
@@ -74,7 +74,7 @@
(setf (xlib:drawable-border-width window) border-width))
(if (find-child window *current-root*)
(case (window-type window)
- (:normal (adapt-child-to-father window (find-father-group window *current-root*))
+ (:normal (adapt-child-to-father window (find-father-frame window *current-root*))
(send-configuration-notify window))
(t (adjust-from-request)))
(adjust-from-request))
@@ -97,24 +97,24 @@
(unhide-window window)
(process-new-window window)
(xlib:map-window window)
- (show-all-childs)))
+ (show-all-children)))
(defun handle-unmap-notify (&rest event-slots &key send-event-p event-window window &allow-other-keys)
(declare (ignore event-slots))
(unless (and (not send-event-p)
(not (xlib:window-equal window event-window)))
- (when (find-child window *root-group*)
- (remove-child-in-all-groups window)
- (show-all-childs))))
+ (when (find-child window *root-frame*)
+ (remove-child-in-all-frames window)
+ (show-all-children))))
(defun handle-destroy-notify (&rest event-slots &key send-event-p event-window window &allow-other-keys)
(declare (ignore event-slots))
(unless (or send-event-p
(xlib:window-equal window event-window))
- (when (find-child window *root-group*)
- (remove-child-in-all-groups window)
- (show-all-childs))))
+ (when (find-child window *root-frame*)
+ (remove-child-in-all-frames window)
+ (show-all-children))))
@@ -125,8 +125,8 @@
(defun handle-exposure (&rest event-slots &key window &allow-other-keys)
(declare (ignore event-slots))
- (awhen (find-group-window window *current-root*)
- (display-group-info it)))
+ (awhen (find-frame-window window *current-root*)
+ (display-frame-info it)))
(defun handle-create-notify (&rest event-slots)
@@ -221,12 +221,12 @@
(netwm-set-properties)
(xlib:display-force-output *display*)
(setf *child-selection* nil)
- (setf *root-group* (create-group :name "Root" :number 0 :layout #'tile-space-layout)
- *current-root* *root-group*
+ (setf *root-frame* (create-frame :name "Root" :number 0 :layout #'tile-space-layout)
+ *current-root* *root-frame*
*current-child* *current-root*)
(call-hook *init-hook*)
(process-existing-windows *screen*)
- (show-all-childs)
+ (show-all-children)
(grab-main-keys)
(xlib:display-finish-output *display*))
Modified: clfswm/src/package.lisp
==============================================================================
--- clfswm/src/package.lisp (original)
+++ clfswm/src/package.lisp Tue Mar 25 18:02:17 2008
@@ -52,48 +52,48 @@
(defparameter *nw-hook-list* nil)
-;;(defstruct group (number (incf *current-group-number*)) name
+;;(defstruct frame (number (incf *current-frame-number*)) name
;; (x 0) (y 0) (w 1) (h 1) rx ry rw rh
;; layout window gc child)
-;;; CONFIG - Default group datas
-(defparameter *default-group-data*
+;;; CONFIG - Default frame datas
+(defparameter *default-frame-data*
(list '(:tile-size 0.8) '(:tile-space-size 0.1)))
-(defclass group ()
- ((name :initarg :name :accessor group-name :initform nil)
- (number :initarg :number :accessor group-number :initform 0)
+(defclass frame ()
+ ((name :initarg :name :accessor frame-name :initform nil)
+ (number :initarg :number :accessor frame-number :initform 0)
;;; Float size between 0 and 1 - Manipulate only this variable and not real size
- (x :initarg :x :accessor group-x :initform 0.1)
- (y :initarg :y :accessor group-y :initform 0.1)
- (w :initarg :w :accessor group-w :initform 0.8)
- (h :initarg :h :accessor group-h :initform 0.8)
+ (x :initarg :x :accessor frame-x :initform 0.1)
+ (y :initarg :y :accessor frame-y :initform 0.1)
+ (w :initarg :w :accessor frame-w :initform 0.8)
+ (h :initarg :h :accessor frame-h :initform 0.8)
;;; Real size (integer) in screen size - Don't set directly this variables
;;; they may be recalculated by the layout manager.
- (rx :initarg :rx :accessor group-rx :initform 0)
- (ry :initarg :ry :accessor group-ry :initform 0)
- (rw :initarg :rw :accessor group-rw :initform 800)
- (rh :initarg :rh :accessor group-rh :initform 600)
- (layout :initarg :layout :accessor group-layout :initform nil)
- (nw-hook :initarg :nw-hook :accessor group-nw-hook :initform nil
- :documentation "Hook done by the group when a new window is mapped")
- (window :initarg :window :accessor group-window :initform nil)
- (gc :initarg :gc :accessor group-gc :initform nil)
- (child :initarg :child :accessor group-child :initform nil)
- (data :initarg :data :accessor group-data
- :initform *default-group-data*
+ (rx :initarg :rx :accessor frame-rx :initform 0)
+ (ry :initarg :ry :accessor frame-ry :initform 0)
+ (rw :initarg :rw :accessor frame-rw :initform 800)
+ (rh :initarg :rh :accessor frame-rh :initform 600)
+ (layout :initarg :layout :accessor frame-layout :initform nil)
+ (nw-hook :initarg :nw-hook :accessor frame-nw-hook :initform nil
+ :documentation "Hook done by the frame when a new window is mapped")
+ (window :initarg :window :accessor frame-window :initform nil)
+ (gc :initarg :gc :accessor frame-gc :initform nil)
+ (child :initarg :child :accessor frame-child :initform nil)
+ (data :initarg :data :accessor frame-data
+ :initform *default-frame-data*
:documentation "An assoc list to store additional data")))
-(defparameter *root-group* nil
- "Root of the root - ie the root group")
+(defparameter *root-frame* nil
+ "Root of the root - ie the root frame")
(defparameter *current-root* nil
"The current fullscreen maximized child")
(defparameter *current-child* nil
"The current child with the focus")
-(defparameter *show-root-group-p* nil)
+(defparameter *show-root-frame-p* nil)
(defparameter *main-keys* (make-hash-table :test 'equal))
@@ -108,10 +108,10 @@
"Set to t to open the next window in a new workspace
or to a number to open in a numbered workspace")
-(defparameter *open-next-window-in-new-group* nil
- "Set to t to open the each next window in a new group
-or set to :once open the next window in a new group and all
-others in the same group")
+(defparameter *open-next-window-in-new-frame* nil
+ "Set to t to open the each next window in a new frame
+or set to :once open the next window in a new frame and all
+others in the same frame")
(defparameter *arrow-action* nil
"Arrow action in the second mode")
@@ -128,7 +128,7 @@
;;;
;;; See clfswm.lisp for hooks examples.
-;;; Init hook. This hook is run just after the first root group is created
+;;; Init hook. This hook is run just after the first root frame is created
(defparameter *init-hook* nil)
;;; Main mode hooks (set in clfswm.lisp)
@@ -169,7 +169,7 @@
;;; Second mode global variables
(defparameter *motion-action* nil)
(defparameter *motion-object* nil)
-(defparameter *motion-start-group* nil)
+(defparameter *motion-start-frame* nil)
(defparameter *motion-dx* nil)
(defparameter *motion-dy* nil)
Modified: clfswm/src/xlib-util.lisp
==============================================================================
--- clfswm/src/xlib-util.lisp (original)
+++ clfswm/src/xlib-util.lisp Tue Mar 25 18:02:17 2008
@@ -70,7 +70,7 @@
(progn
, at body)
((or xlib:match-error xlib:window-error xlib:drawable-error) (c)
- (declare (ignore c)))))
+ (dbg c ',body))))
More information about the clfswm-cvs
mailing list