Commit 188e9ddb authored by Iban Hatchondo's avatar Iban Hatchondo
Browse files

- change in the movement handlers that allow undecorated windows (xmms

  for example) to moved through mouse strokes or menu.
  (input.lisp gestures.lisp move-resize.lisp wm.lisp)

- group of windows (such as described in the ICCCM) are now honored:
  transient-for windows are supposed to be stack under their
  dialogs. As another effect, iconifying or sending to another desktop
  one window of a group affect the entire group.

- a new option is now available:
   that allows to save pointer position before switching from a
   desktop to another and restore previous position when arriving on
   the new one. (misc.lisp virtual-screen.lisp) This has been done via
   a private property on the root window named:

- _NET_MOVERESIZE_WINDOW client message is now supported.

- _NET_WM_STATE_STICKY is now supported. (is it correct since Eclipse
  does not implements area's ?)

- an ECLIPSE-EXTENSIONS package is defined in order to export all
  symbols provides by future Eclipse extensions.

- bug fix in:
   - (setf window-priority)
   - dead windows during window cycling (gestures.lisp)
   - window placement (wm.lisp) decoration where incorrectly placed
     when user indicates its preferences (via the wm_normal_hints
   - minor changes in destroy-notify handling on decoration.

- man page, changelog, compliance updated.
parent cc6b9d77
-*- Mode: ChangeLog -*-
$Id: changelog,v 1.4 2002/11/07 14:54:27 hatchond Exp $
$Id: changelog,v 1.5 2003/10/06 17:57:27 ihatchondo Exp $
0.01 => 0.02
Eclipse should now compile on every ANSI-compliant Common Lisp
......@@ -195,7 +195,6 @@ pre 0.03=>0.03
- fullscreen-mode should now be correct: the spec say it would be
better to undecore the window when in fullscreen. It does now.
- maximize-window signature changes. It now expect an application
instead of a decoration.
......@@ -222,6 +221,178 @@ pre 0.03=>0.03
- Window rotation (Alt-Tab) re-designed. It now works as in almost
every window managers. Press Alt-Tab once will raise the next
application, on the current desktop, according to the current
stacking order. If Alt is released then pressing again Alt-Tab will
put back the precedent application. Otherwise if you kipped Alt down
then Tab again and the next application will be brought on top of the
others, and the precedent one is back on its depth. And so on
until you come back on the first one.
The same mechanism is available with say Alt-a. It just rotate
windows on the other sens.
- The window rotation may be verbose by displaying a small window
indicating the name and the icon, if provided, of the application
that comes on top of the others.
To disable it do (setf *verbose-window-cycling* nil) in your eclipse
config file.
- The window rotation may also cycle the current desktop iconified
applications. To disable it do (setf *cycle-icons-p* nil) in
your eclipse config file.
- Screen edges are now resistant.
- fix menu bug. They don't anymore appear below their applications.
- a maximized window does not allow anymore to be resized in the
directions in which it has been maximized.
- the message-box may now display a centered pixmap before the text.
0.08 => 0.09
- The window edges resistance is also implemented.
To configure it use *standard-window-edge-resistant-p*.
Set it to nil if you don't want to feel any resistance on
edges of window(s) you are about to overlap. Default value is t.
- minor focus change:
For application with a :no-input as focus model, we now gives the
same event mask as the others. The problem was that an application
with a globaly-active model can decide to sets the focus to one of
its satellite window that have a no-input model. This is correct
because the input model is indicate to the window manager how to
give the focus to the application. But in any case, it indicates
that the application will never have or not the focus.
- give-focus-to-next-widget-in-desktop will now gives the focus to
the first application that claims for the focus if one, or to the
first one that could receive it (from top most to bottom stack
- change-vscreen invoke give-focus-to-next-widget-in-desktop if
the focus policy is on-click.
- minor change in (setf fullscreen-mode): we now use the
no-decoration-theme instead of undecorting. This will avoid
problems in xinerama mode.
- compile-theme hacking. Should fix theme compiling problem report by
Robert Strandh.
- Fix incorect handling of the states _net_wm_state_{above, below}.
They are permanent as the other states (see inpout.lisp).
It implies that the (setf window-priority) should take those state
in account when modifying the stack order (see misc.lisp)
This have as last implication, that we should work with an external
list of window for the window circulation keystrokes. Indeed, if
one window has the _net_wm_state_above state then it will always be
on top of the others. What means, that will stay stuck on this
window during circulation. (see minor signature modification of
circulate-window in virtual-screen.lisp, and small hack in
- new file rectangles.lisp. This module computes a list of the
largest free rectangles available on a virtual screen. This will
gives us some new maximize mode such as maximize a window to fit
the largest rectangle that includes it, without creating more
overlaps than already exists.
- maximize-window modified to use the maximize-fill operation.
- new user configuration options: *maximize-fill* *maximize-modifier*
(setf maximize-modifier) function. It allow user to choose a
modifier key that will alter the maximize button behavior if the
choosen modifier down or not when pressing on maximize button. If
modifier is down then the value of (not *maximize-fill*) will be
used otherwise *maximize-fill* will be used.
- We now support the netwm-strut{-partial}, and don't overlap panels
that should not be overlapped (gnome panels for exemple)
0.09 => 0.10
- fix the problem raised by Christian. Icons have the following
- when you click on an icon it comes on top of anything else.
- when you release the mouse button after a move (otherwise the
application get de-iconified) the icon window priority goes back
at the bottom of the stack (above any desktop application of
- implementation of ICE protocol and xsmp protocol. (lib/ice lib/sm)
- eclipse now connect itself to the session manager according to the
xsmp protocol. (see the cvs commit message for more infos)
- fix forgotten added slot hint-p of motion-notify event.
- fix bug with shaded windows and virtual screen switching.
- move resize improvements:
We now use the :pointer-potion-hint in the event-mask. The server
is now free to send only one :motion-notify event, until either the
key or button state changes, the pointer leaves the event window,
or the client calls query-pointer or motion-events.
This allow us to be served only for event when we can deal with. As
effect opaque move and resize are smoother.
side effects:
decoration time slot removed.
modify event handling of motion-notify
find-corner modfication: It now looks for the cardinal point by
dichotomy in the window split in 16 pieces.
- configure-window [ function ] added for ICCCM and EWMH complience.
- support for :_NET_MOVERESIZE_WINDOW client message.
- support for :_NET_WORKAREA (ewmh says we have to set it)
implies :_net_wm_strut_partial :_net_wm_strut property notify
handling to reflect changes in the net_workarea property and
a call to update-workarea-property when changing the number of
virtual screens.
- a very little change in the define-theme syntax. Style parts are
now defined in a list (such as the class slots for example). This
allow to have the :title-bar-position :parts-to-redraw-on-focus
potions to be effectively optional. Plus a :background option has
been added. This will be useful to the one who wants to define a
no-decoration style like but with colored border. See the
documentation (for more).
- Christian point out a bug/inconsitency with emacs and multiple
frame. Changing frames with C-x 5-o was not raising frames. It is
now fix.
the fix consist in:
- add :susbstructure-redirect in the decoration event mask.
- add event handling for configure-request on decoration.
- add event handling for map-request on decoration.
- bug fix and code clean up and more hacking.
- error handling at start up.
- close-sm-connection (widget.lisp)
- (event-process selection-notify null)
- bug fix and typo in gestures.lisp
- bug fix in ewmh implementation.
- ...
O.10 => 0.11
\ No newline at end of file
.TH Eclipse 1 "(c) 2001 Iban HATCHONDO"
.\"$Id: eclipse.1,v 1.13 2004/01/15 15:35:34 ihatchondo Exp $
.\"$Id: eclipse.1,v 1.14 2004/01/21 17:48:39 ihatchondo Exp $
eclipse - a window manager in Common Lisp
......@@ -125,6 +125,11 @@ be \fIt\fP. In that case, a change will display a small window with
the number or the name (if sets) of the new desktop. If the value is
\fInil\fP, nothing will happen.
\fIboolean\fP (or t nil)
If you want the mouse pointer position to be saved and restore during
workspace switching then set it to \fIt\fP. Default value is \fInil\fP.
.B\-*move-mode*\ \fIkeyword\fP (or \fB:box :opaque\fP)
As usual :box will draw a 3x3 grid to show you the window move ;
:opaque moves the window directly. (The box mode looks good on
;;; -*- Mode: Lisp; Package: ECLIPSE-INTERNALS -*-
;;; $Id: gestures.lisp,v 1.14 2004/01/06 16:52:48 ihatchondo Exp $
;;; $Id: gestures.lisp,v 1.15 2004/01/15 15:35:34 ihatchondo Exp $
;;; ECLIPSE. The Common Lisp Window Manager.
;;; Copyright (C) 2002 Iban HATCHONDO
......@@ -289,7 +289,7 @@
(defun mouse-stroke-for-move-and-resize (event &key action)
(let ((widget (lookup-widget (event-child event))))
(unless (decoration-p widget)
(unless (or (decoration-p widget) (application-p widget))
(return-from mouse-stroke-for-move-and-resize nil))
(when (eq *focus-type* :on-click)
(focus-widget widget 0))
......@@ -338,6 +338,7 @@
(unless *depth*
(initialize-circulate-window root-win (xlib:drawable-display root-win)))
(unless *windows* (return-from circulate-window-up-and-down nil))
(setf *windows* (loop for w in *windows* if (lookup-widget w) collect w))
(lookup-widget root-win)
:direction direction
;;; -*- Mode: Lisp; Package: ECLIPSE-INTERNALS -*-
;;; $Id: global.lisp,v 1.18 2004/01/20 16:09:59 ihatchondo Exp $
;;; $Id: global.lisp,v 1.19 2004/02/02 09:43:58 ihatchondo Exp $
;;; This file is part of Eclipse.
;;; Copyright (C) 2001, 2002 Iban HATCHONDO
......@@ -73,6 +73,7 @@
(defparameter *close-display-p* t)
(defparameter *menu-1-items* nil)
(defparameter *change-desktop-message-active-p* t)
(defparameter *save-and-restore-pointer-position-during-workspace-switch* nil)
(defparameter *verbose-move* t)
(defparameter *verbose-resize* t)
(defparameter *verbose-window-cycling* t)
;;; -*- Mode: Lisp; Package: ECLIPSE-INTERNALS -*-
;;; $Id: input.lisp,v 1.30 2004/01/20 16:10:00 ihatchondo Exp $
;;; $Id: input.lisp,v 1.31 2004/01/20 21:38:11 ihatchondo Exp $
;;; ECLIPSE. The Common Lisp Window Manager.
;;; Copyright (C) 2000, 2001, 2002 Iban HATCHONDO
......@@ -54,16 +54,6 @@
(string= selection +xa-wm+)
(error 'exit-eclipse))))
(defmethod event-process :after ((event destroy-notify) (widget base-widget))
(with-slots (window) event
(when (or (decoration-p widget) (application-p (lookup-widget window)))
(if (eq *focus-type* :on-click)
(multiple-value-bind (x y s child) (xlib:query-pointer *root-window*)
(declare (ignore x y s))
(let ((e (make-event :enter-notify :kind :inferior :mode :normal)))
(event-process e (or (lookup-widget child) *root*))))))))
(defmethod event-process ((ev configure-request) (widget base-widget))
(declare (ignorable widget))
(with-slots (window value-mask x y width height above-sibling stack-mode) ev
......@@ -75,6 +65,21 @@
:stack-mode (and (logbitp 6 value-mask) stack-mode)
:sibling above-sibling)))
(defmethod event-process :after ((event destroy-notify) (widget base-widget))
(with-slots (window) event
(with-slots ((caw current-active-widget)) *root*
(when caw
(if (or (eq widget caw) (eq (lookup-widget window) caw))
(dismiss-move-resize *root*)
(return-from event-process nil))))
(when (or (decoration-p widget) (application-p (lookup-widget window)))
(if (eq *focus-type* :on-click)
(multiple-value-bind (x y s child) (xlib:query-pointer *root-window*)
(declare (ignore x y s))
(let ((e (make-event :enter-notify :kind :inferior :mode :normal)))
(event-process e (or (lookup-widget child) *root*))))))))
;; Specialized ones.
;;; Events for the root window
......@@ -84,8 +89,7 @@
(with-slots (icon) (lookup-widget (event-window event))
(when icon (uniconify icon))
(xlib:map-window (event-window event)))
(xlib:with-server-grabbed (*display*)
(procede-decoration (event-window event)))))
(procede-decoration (event-window event))))
(defmethod event-process ((event unmap-notify) (root root))
(declare (ignorable root))
......@@ -103,12 +107,9 @@
(setf (wm-state (get-child widget :application :window t)) 3))))))
(defmethod event-process ((event destroy-notify) (root root))
(xlib:with-server-grabbed (*display*)
(let ((app (lookup-widget (event-window event))))
(when (and (application-p app) (not (application-master app)))
(ignore-errors (update-lists app 0 root))
(mapc #'remove-widget (list app (application-icon app)))
(xlib:destroy-window (widget-window (application-icon app)))))))
(let ((app (lookup-widget (event-window event))))
(when (and (application-p app) (not (application-master app)))
(remove-widget app))))
(defmethod event-process ((event enter-notify) (root root))
(with-slots (resize-status move-status) root
......@@ -160,26 +161,25 @@
(defmethod event-process ((event motion-notify) (root root))
(declare (optimize (speed 3)))
(move-status resize-status (master current-active-decoration)) root
(with-slots (move-status resize-status (widget current-active-widget)) root
(when (or move-status resize-status)
(if (decoration-active-p master)
(if (slot-value widget 'active-p)
(when (event-hint-p event)
(cond (move-status
(move-widget master event *verbose-move* *move-mode*))
(move-widget widget event *verbose-move* *move-mode*))
(resize master event *verbose-resize* *resize-mode*)))
(resize widget event *verbose-resize* *resize-mode*)))
(xlib:query-pointer (widget-window root)))
(format t "The pointer has been frozen !!~%")
(setf (decoration-active-p master) t)
(setf (slot-value widget 'active-p) t)
(event-process (make-event :button-release) root))))))
(defmethod event-process ((event button-release) (root root))
(with-slots (move-status resize-status (master current-active-decoration)
(with-slots (move-status resize-status (widget current-active-widget)
menu1 menu2 menu3 window-menu) root
(cond (move-status (finish-move master *verbose-move* *move-mode*))
(resize-status (finish-resize master *verbose-resize* *resize-mode*))
(cond (move-status (finish-move widget *verbose-move* *move-mode*))
(resize-status (finish-resize widget *verbose-resize* *resize-mode*))
(with-slots (code) event
(when window-menu
......@@ -190,15 +190,18 @@
(when (= code 2) (setf menu2 nil))))))))
(defmethod event-process :after ((event button-release) (root root))
(with-slots (move-status resize-status current-active-decoration) root
(with-slots (move-status resize-status current-active-widget) root
(when (or move-status resize-status)
(xlib:ungrab-server *display*)
(xlib:ungrab-pointer *display*)
(setf (decoration-active-p current-active-decoration) nil)
(setf (values current-active-decoration move-status resize-status) nil))))
(setf (slot-value current-active-widget 'active-p) nil)
(setf (values current-active-widget move-status resize-status) nil))))
;;; Events for master (type: decoration)
(defmethod event-process ((event map-request) (master decoration))
(xlib:map-window (event-window event)))
(defmethod event-process ((event configure-notify) (master decoration))
(with-slots ((master-window event-window) (app-window window)) event
(when (application-p (lookup-widget app-window))
......@@ -215,9 +218,6 @@
(defmethod event-process ((event unmap-notify) (master decoration))
(xlib:unmap-window (widget-window master)))
(defmethod event-process ((event map-request) (master decoration))
(xlib:map-window (event-window event)))
(defmethod event-process ((event map-notify) (master decoration))
(with-slots ((app-window window) (master-window event-window)) event
(when (application-p (lookup-widget app-window))
......@@ -230,13 +230,8 @@
(wm-state app-window) 1)))))
(defmethod event-process ((event destroy-notify) (master decoration))
(with-event-mask (*root-window*)
(xlib:with-server-grabbed (*display*)
(xlib:destroy-window (widget-window master))
(ignore-errors (update-lists (get-child master :application) 0 *root*))
(mapc #'remove-widget (cons master (decoration-children master)))
(xlib:destroy-window (get-child master :icon :window t))
(dismiss-move-resize *root*))))
(xlib:destroy-window (widget-window master))
(mapc #'remove-widget (cons master (decoration-children master))))
(defmethod event-process ((event visibility-notify) (master decoration))
(event-process event (get-child master :application)))
......@@ -260,8 +255,8 @@
(set-focus input-model window (event-time event)))))
(defmethod event-process ((event button-press) (application application))
(put-on-top application)
(xlib:allow-events *display* :replay-pointer))
(unwind-protect (put-on-top application)
(xlib:allow-events *display* :replay-pointer)))
(defmethod event-process ((event focus-out) (application application))
(with-slots (master) application
......@@ -276,7 +271,7 @@
(setf (netwm:net-active-window *root-window*) window))))
(defmethod event-process ((event property-notify) (app application))
(with-slots (window master type) app
(with-slots (window master type transient-for) app
(case (event-atom event)
(when master
......@@ -292,13 +287,14 @@
((:_net_wm_strut_partial :_net_wm_strut)
(when (eq type :_net_wm_window_type_dock)
(update-workarea-property *root*)))
(update-lists app (car (wm-state window)) *root*)))))
(:wm_state (update-lists app (car (wm-state window)) *root*))
(:wm_transient_for (computes-transient-for app)))))
(defmethod event-process ((event client-message) (application application))
(with-slots (data type) event
(with-slots (master window iconic-p icon) application
(case type
(:WM_CHANGE_STATE (when (= 3 (aref data 0)) (iconify application)))
(let* ((to-change (aref data 0))
(mask (or (gnome:win-state window :result-type t) 0))
......@@ -326,47 +322,31 @@
(when (= 2 mode) (return-from event-process nil)) ; toggle.
(when (= mode (if (member p1 p) 1 0)) (setf p1 nil))
(when (= mode (if (member p2 p) 1 0)) (setf p2 nil))
(macrolet ((or-eql (val &rest vars)
`(or ,@(loop for v in vars collect `(eql ,v ,val)))))
(when (or-eql :_net_wm_state_hidden p1 p2)
(if (= mode 0) (uniconify application) (iconify application)))
(when (or-eql :_net_wm_state_fullscreen p1 p2)
(when (fullscreenable-p application)
(setf (fullscreen-mode application) (if (= mode 0) :off :on))))
(when (or-eql :_net_wm_state_maximized_vert p1 p2)
(maximize-window application 2))
(when (or-eql :_net_wm_state_maximized_horz p1 p2)
(maximize-window application 3))
(when (and master (or-eql :_net_wm_state_shaded p1 p2))
(shade master))
(flet ((set-stack-state (s)
(setf (netwm:net-wm-state window)
(if (= 0 mode) (remove s p) (pushnew s p)))))
(flet ((set-netwm-state (s mode)
(setf (netwm:net-wm-state window)
(if (= 0 mode) (setf p (remove s p)) (pushnew s p)))))
(macrolet ((or-eql (val &rest vars)
`(or ,@(loop for v in vars collect `(eql ,v ,val)))))
(when (or-eql :_net_wm_state_hidden p1 p2)
(if (= mode 0) (uniconify application) (iconify application)))
(when (or-eql :_net_wm_state_fullscreen p1 p2)
(when (fullscreenable-p application)
(setf (fullscreen-mode application)
(if (= mode 0) :off :on))))
(when (or-eql :_net_wm_state_maximized_vert p1 p2)
(maximize-window application 2))
(when (or-eql :_net_wm_state_maximized_horz p1 p2)
(maximize-window application 3))
(when (and master (or-eql :_net_wm_state_shaded p1 p2))
(shade master))
(when (or-eql :_net_wm_state_sticky p1 p2)
(set-netwm-state :_net_wm_state_sticky mode))
(when (or-eql :_net_wm_state_above p1 p2)
(set-stack-state :_net_wm_state_above)
(set-netwm-state :_net_wm_state_above mode)
(put-on-top application))
(when (or-eql :_net_wm_state_below p1 p2)
(set-stack-state :_net_wm_state_below)
(set-netwm-state :_net_wm_state_below mode)
(put-on-bottom application))))))
(let* ((cur-desk (window-desktop-num window))
(new-desk (aref data 0))
(master-window (and master (widget-window master)))
(unmap-p (/= new-desk +any-desktop+ (current-desk)))
(operation (if unmap-p #'xlib:unmap-window #'xlib:map-window))
(focused-p (focused-p application)))
(unless (= cur-desk new-desk)
(when (shaded-p application) (shade application))
(setf (window-desktop-num window) new-desk)
(with-event-mask (*root-window*)
(funcall operation (or master-window window))
(when master-window
(with-event-mask (master-window)
(funcall operation window))))
(when unmap-p
(when (and focused-p (eq *focus-type* :on-click))
(setf (application-wants-focus-p application) nil)))))
(cond ((shaded-p application) (shade application))
(iconic-p (uniconify icon)))
......@@ -381,9 +361,8 @@
:height (when (logbitp 3 value-mask) (aref data 4))
:gravity (unless (zerop gravity)
(svref xlib::*win-gravity-vector* gravity)))))
(:_NET_CLOSE_WINDOW (close-widget application))
(when (= 3 (aref data 0)) (iconify application)))))))
(:_NET_WM_DESKTOP (migrate-application application (aref data 0)))
(:_NET_CLOSE_WINDOW (close-widget application))))))
;;; Events for buttons
......@@ -444,9 +423,8 @@
;; Initialize the move process.
(defmethod event-process ((event button-press) (title title-bar))
(with-slots (master armed active-p) title
(unless (event-send-event-p event)
(initialize-move master event))))
(unless (event-send-event-p event)
(initialize-move (button-master title) event)))
;; Start the movement.
(defmethod event-process ((event motion-notify) (title title-bar))
;;; -*- Mode: Lisp; Package: ECLIPSE-INTERNALS -*-
;;; $Id: misc.lisp,v 1.22 2004/01/22 22:02:54 ihatchondo Exp $
;;; $Id: misc.lisp,v 1.23 2004/02/02 09:43:58 ihatchondo Exp $
;;; This file is part of Eclipse.
;;; Copyright (C) 2002 Iban HATCHONDO
......@@ -158,6 +158,66 @@
;;;; Miscellaneous functions.
(defun set-window-priority (stack-mode window sibling)
(when (member :_net_wm_window_type_desktop (netwm:net-wm-window-type window))
(return-from set-window-priority stack-mode))
(flet ((lookup-app-w (widget)
(when (decoration-p widget)
(get-child widget :application :window t)))
(first (windows &optional above-p)
(car (if above-p (last windows) windows)))
(restack (app sib-app priority)
(let* ((window (widget-window (or (application-master app) app)))
(sm (when sib-app (application-master sib-app)))
(sibling (when sib-app (widget-window (or sm sib-app)))))
(unless (xlib:window-equal window sibling)
(setf (xlib:window-priority window sibling) priority)))))
(let* ((win (or (lookup-app-w (lookup-widget window)) window))
(sib (or (lookup-app-w (lookup-widget sibling)) sibling))
(widget (lookup-widget win))
(above-p (eq stack-mode :above))
(wnwm-state (netwm:net-wm-state win))
(snwm-state (and sib (netwm:net-wm-state sib))))
(if (not (application-p widget))
(setf (xlib:window-priority window sibling) stack-mode)
(multiple-value-bind (b m a) (screen-windows-layers win)
(when (application-transient-for widget)
(with-slots ((lw window)) (application-leader widget)
(setf wnwm-state (nconc wnwm-state (netwm:net-wm-state lw)))))
(cond ((member :_net_wm_state_below wnwm-state)
(unless (member sib b :test #'xlib:window-equal)
(setf sib (first (or b m a) (and b above-p)))
(unless b (setf stack-mode :below))))
((member :_net_wm_state_above wnwm-state)
(unless (member sib a :test #'xlib:window-equal)
(unless (member :_net_wm_state_fullscreen snwm-state)
(setf sib (first a above-p))
(unless a (setf stack-mode :above)))))
((member :_net_wm_state_fullscreen wnwm-state)
(when (member sib b :test #'xlib:window-equal)
(setf sib (first (or m a)))
(setf stack-mode :below)))
((not (member sib m :test #'xlib:window-equal))
(setf sib (first (or m b a) (if m above-p b)))
(unless m (setf stack-mode (if b :above :below)))))
(when (or b m a)
(with-slots ((tr transient-for)) widget
(loop with seq = (application-dialogs widget)
for sib-app = (lookup-widget sib) then a
for priority = stack-mode then :below
for a in (reverse seq) do (restack a sib-app priority)
finally (unless tr (restack widget sib-app priority))))
(update-client-list-stacking *root*))
(defun grab-root-pointer (&key cursor owner-p confine-to)
:confine-to confine-to
:cursor (or cursor (root-default-cursor *root*))
:owner-p owner-p))
(defun send-wm-protocols-client-message (window atom &rest data)
"Send a client-message of type :wm-protocol to the specified window
with data being the given atom plus the rest of the function args."
......@@ -231,7 +291,7 @@
virtual screen that the given `window' argument belongs to. The given
window will be filtered."
(loop with n = (if (eql i +any-desktop+) (current-desk) i)
for w in (screen-content n)
for w in (screen-content n :skip-taskbar nil)
for nwm-state = (netwm:net-wm-state w)
unless (xlib:window-equal w window)
if (member :_net_wm_state_above nwm-state) collect w into aboves
......@@ -244,51 +304,7 @@
guaranty that stacking order constraints described in the extended window
manager protocol will be respected. Then invokes update-client-list-stacking
to reflect the new order in all the root properties that are involved in."
(with-gensym (above-p wnwm-state snwm-state win sib b m a stack-mode)
`(flet ((lookup-app-w (widget)
(when (decoration-p widget)
(get-child widget :application :window t)))