src/clfswm-internal.lisp

   1 ;; --------------------------------------------------------------------------
   2 ;;; CLFSWM - FullScreen Window Manager
   3 ;;;
   4 ;;; --------------------------------------------------------------------------
   5 ;;; Documentation: Main functions
   6 ;;; --------------------------------------------------------------------------
   7 ;;;
   8 ;;; (C) 2012 Philippe Brochard <pbrochard@common-lisp.net>
   9 ;;;
  10 ;;; This program is free software; you can redistribute it and/or modify
  11 ;;; it under the terms of the GNU General Public License as published by
  12 ;;; the Free Software Foundation; either version 3 of the License, or
  13 ;;; (at your option) any later version.
  14 ;;;
  15 ;;; This program is distributed in the hope that it will be useful,
  16 ;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ;;; GNU General Public License for more details.
  19 ;;;
  20 ;;; You should have received a copy of the GNU General Public License
  21 ;;; along with this program; if not, write to the Free Software
  22 ;;; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23 ;;;
  24 ;;; --------------------------------------------------------------------------
  25
  26 (in-package :clfswm)
  27
  28 (defgeneric child-border-size (child))
  29
  30 (defmethod child-border-size ((child frame))
  31   (x-drawable-border-width (frame-window child)))
  32
  33 (defmethod child-border-size ((child xlib:window))
  34   (x-drawable-border-width child))
  35
  36 (defmethod child-border-size (child)
  37   (declare (ignore child))
  38   0)
  39
  40 (defgeneric set-child-border-size (child value))
  41
  42 (defmethod set-child-border-size ((child frame) value)
  43   (setf (x-drawable-border-width (frame-window child)) value))
  44
  45 (defmethod set-child-border-size ((child xlib:window) value)
  46   (setf (x-drawable-border-width child) value))
  47
  48 (defmethod set-child-border-size (child value)
  49   (declare (ignore child value)))
  50
  51 (defsetf child-border-size set-child-border-size)
  52
  53
  54
  55 ;;; Conversion functions
  56 ;;; Float -> Pixel conversion
  57 (defun x-fl->px (x parent)
  58   "Convert float X coordinate to pixel"
  59   (round (+ (* x (frame-rw parent)) (frame-rx parent))))
  60
  61 (defun y-fl->px (y parent)
  62   "Convert float Y coordinate to pixel"
  63   (round (+ (* y (frame-rh parent)) (frame-ry parent))))
  64
  65 (defun w-fl->px (w parent)
  66   "Convert float Width coordinate to pixel"
  67   (round (* w (frame-rw parent))))
  68
  69 (defun h-fl->px (h parent)
  70   "Convert float Height coordinate to pixel"
  71   (round (* h (frame-rh parent))))
  72
  73 ;;; Pixel -> Float conversion
  74 (defun x-px->fl (x parent)
  75   "Convert pixel X coordinate to float"
  76   (/ (- x (frame-rx parent) (child-border-size parent)) (frame-rw parent)))
  77
  78 (defun y-px->fl (y parent)
  79   "Convert pixel Y coordinate to float"
  80   (/ (- y (frame-ry parent) (child-border-size parent)) (frame-rh parent)))
  81
  82 (defun w-px->fl (w parent)
  83   "Convert pixel Width coordinate to float"
  84   (/ w (frame-rw parent)))
  85
  86 (defun h-px->fl (h parent)
  87   "Convert pixel Height coordinate to float"
  88   (/ h (frame-rh parent)))
  89
  90
  91
  92 (defun rect-hidden-p (rect1 rect2)
  93   "Return T if child-rect1 hide child-rect2"
  94   (and *show-hide-policy*
  95        (funcall *show-hide-policy* (child-rect-x rect1) (child-rect-x rect2))
  96        (funcall *show-hide-policy* (child-rect-y rect1) (child-rect-y rect2))
  97        (funcall *show-hide-policy* (+ (child-rect-x rect2) (child-rect-w rect2))
  98                 (+ (child-rect-x rect1) (child-rect-w rect1)))
  99        (funcall *show-hide-policy* (+ (child-rect-y rect2) (child-rect-h rect2))
 100                 (+ (child-rect-y rect1) (child-rect-h rect1)))))
 101
 102
 103
 104 (defgeneric frame-p (frame))
 105 (defmethod frame-p ((frame frame))
 106   (declare (ignore frame))
 107   t)
 108 (defmethod frame-p (frame)
 109   (declare (ignore frame))
 110   nil)
 111
 112
 113
 114 ;;; in-*: Find if point (x,y) is in frame, window or child
 115 (defun in-rect (x y xr yr wr hr)
 116   (and (<= xr x (+ xr wr))
 117        (<= yr y (+ yr hr))))
 118
 119 (defun in-frame (frame x y)
 120   (and (frame-p frame)
 121        (in-rect x y (frame-rx frame) (frame-ry frame) (frame-rw frame) (frame-rh frame))))
 122
 123 (defun in-window (window x y)
 124   (and (xlib:window-p window)
 125        (in-rect x y
 126                 (x-drawable-x window) (x-drawable-y window)
 127                 (x-drawable-width window) (x-drawable-height window))))
 128
 129 (defgeneric in-child (child x y))
 130
 131 (defmethod in-child ((child frame) x y)
 132   (in-frame child x y))
 133 (defmethod in-child ((child xlib:window) x y)
 134   (in-window child x y))
 135 (defmethod in-child (child x y)
 136   (declare (ignore child x y))
 137   nil)
 138
 139
 140
 141
 142 (defun frame-selected-child (frame)
 143   (when (frame-p frame)
 144     (with-slots (child selected-pos) frame
 145       (let ((len (length child)))
 146         (cond ((minusp selected-pos) (setf selected-pos 0))
 147               ((>= selected-pos len) (setf selected-pos (max (1- len) 0)))))
 148       (nth selected-pos child))))
 149
 150
 151
 152
 153
 154 (defgeneric child-equal-p (child-1 child-2))
 155
 156 (defmethod child-equal-p ((child-1 xlib:window) (child-2 xlib:window))
 157   (xlib:window-equal child-1 child-2))
 158
 159 (defmethod child-equal-p ((child-1 frame) (child-2 frame))
 160   (equal child-1 child-2))
 161
 162 (defmethod child-equal-p (child-1 child-2)
 163   (declare (ignore child-1 child-2))
 164   nil)
 165
 166
 167
 168
 169 (declaim (inline child-member child-remove child-position))
 170
 171 (defun child-member (child list)
 172   (member child list :test #'child-equal-p))
 173
 174 (defun child-remove (child list)
 175   (remove child list :test #'child-equal-p))
 176
 177 (defun child-position (child list)
 178   (position child list :test #'child-equal-p))
 179
 180
 181
 182 ;;; Frame data manipulation functions
 183 (defun frame-data-slot (frame slot)
 184   "Return the value associated to data slot"
 185   (when (frame-p frame)
 186     (second (assoc slot (frame-data frame)))))
 187
 188 (defun set-frame-data-slot (frame slot value)
 189   "Set the value associated to data slot"
 190   (when (frame-p frame)
 191     (with-slots (data) frame
 192       (setf data (remove (assoc slot data) data))
 193       (push (list slot value) data))
 194     value))
 195
 196 (defsetf frame-data-slot set-frame-data-slot)
 197
 198
 199 (defun remove-frame-data-slot (frame slot)
 200   "Remove a slot in frame data slots"
 201   (when (frame-p frame)
 202     (with-slots (data) frame
 203       (setf data (remove (assoc slot data) data)))))
 204
 205
 206
 207 (defun managed-window-p (window frame)
 208   "Return t only if window is managed by frame"
 209   (if (frame-p frame)
 210       (with-slots ((managed forced-managed-window)
 211                    (unmanaged forced-unmanaged-window)) frame
 212         (and (xlib:window-p window)
 213              (not (child-member window unmanaged))
 214              (not (member (xlib:wm-name window) unmanaged :test #'string-equal-p))
 215              (or (member :all (frame-managed-type frame))
 216                  (member (window-type window) (frame-managed-type frame))
 217                  (child-member window managed)
 218                  (member (xlib:wm-name window) managed :test #'string-equal-p))))
 219       t))
 220
 221
 222 (defun add-in-never-managed-window-list (value)
 223   (pushnew value *never-managed-window-list* :test #'equal))
 224
 225 (defun never-managed-window-p (window)
 226   (when (xlib:window-p window)
 227     (dolist (type *never-managed-window-list*)
 228       (when (funcall (first type) window)
 229         (return (values t (second type)))))))
 230
 231
 232
 233 (defgeneric child-name (child))
 234
 235 (defmethod child-name ((child xlib:window))
 236   (xlib:wm-name child))
 237
 238 (defmethod child-name ((child frame))
 239   (frame-name child))
 240
 241 (defmethod child-name (child)
 242   (declare (ignore child))
 243   "???")
 244
 245
 246 (defgeneric set-child-name (child name))
 247
 248 (defmethod set-child-name ((child xlib:window) name)
 249   (setf (xlib:wm-name child) name))
 250
 251 (defmethod set-child-name ((child frame) name)
 252   (setf (frame-name child) name))
 253
 254 (defmethod set-child-name (child name)
 255   (declare (ignore child name)))
 256
 257 (defsetf child-name set-child-name)
 258
 259
 260
 261
 262 (defgeneric child-fullname (child))
 263
 264 (defmethod child-fullname ((child xlib:window))
 265   (format nil "~A (~A)" (or (xlib:wm-name child) "?") (or (xlib:get-wm-class child) "?")))
 266
 267 (defmethod child-fullname ((child frame))
 268   (aif (frame-name child)
 269        (format nil "~A (Frame ~A)" it (frame-number child))
 270        (format nil "Frame ~A" (frame-number child))))
 271
 272 (defmethod child-fullname (child)
 273   (declare (ignore child))
 274   "???")
 275
 276
 277 (defgeneric child-transparency (child))
 278
 279 (defmethod child-transparency ((child xlib:window))
 280   (window-transparency child))
 281
 282 (defmethod child-transparency ((child frame))
 283   (window-transparency (frame-window child)))
 284
 285 (defmethod child-transparency (child)
 286   (declare (ignore child))
 287   1)
 288
 289 (defgeneric set-child-transparency (child value))
 290
 291 (defmethod set-child-transparency ((child xlib:window) value)
 292   (setf (window-transparency child) value))
 293
 294 (defmethod set-child-transparency ((child frame) value)
 295   (setf (window-transparency (frame-window child)) value))
 296
 297 (defmethod set-child-transparency (child value)
 298   (declare (ignore child value)))
 299
 300 (defsetf child-transparency set-child-transparency)
 301
 302
 303
 304 (defgeneric child-x (child))
 305 (defmethod child-x ((child xlib:window))
 306   (x-drawable-x child))
 307 (defmethod child-x ((child frame))
 308   (frame-rx child))
 309
 310 (defgeneric child-y (child))
 311 (defmethod child-y ((child xlib:window))
 312   (x-drawable-y child))
 313 (defmethod child-y ((child frame))
 314   (frame-ry child))
 315
 316 (defgeneric child-width (child))
 317 (defmethod child-width ((child xlib:window))
 318   (x-drawable-width child))
 319 (defmethod child-width ((child frame))
 320   (frame-rw child))
 321
 322 (defgeneric child-height (child))
 323 (defmethod child-height ((child xlib:window))
 324   (x-drawable-height child))
 325 (defmethod child-height ((child frame))
 326   (frame-rh child))
 327
 328 (defgeneric child-x2 (child))
 329 (defmethod child-x2 ((child xlib:window))
 330   (+ (x-drawable-x child) (x-drawable-width child)))
 331 (defmethod child-x2 ((child frame))
 332   (+ (frame-rx child) (frame-rw child)))
 333
 334 (defgeneric child-y2 (child))
 335 (defmethod child-y2 ((child xlib:window))
 336   (+ (x-drawable-y child) (x-drawable-height child)))
 337 (defmethod child-y2 ((child frame))
 338   (+ (frame-ry child) (frame-rh child)))
 339
 340
 341
 342 (defgeneric child-center (child))
 343
 344 (defmethod child-center ((child xlib:window))
 345   (values (+ (x-drawable-x child) (/ (x-drawable-width child) 2))
 346           (+ (x-drawable-y child) (/ (x-drawable-height child) 2))))
 347
 348 (defmethod child-center ((child frame))
 349   (values (+ (frame-rx child) (/ (frame-rw child) 2))
 350           (+ (frame-ry child) (/ (frame-rh child) 2))))
 351
 352 (defun child-distance (child1 child2)
 353   (multiple-value-bind (x1 y1) (child-center child1)
 354     (multiple-value-bind (x2 y2) (child-center child2)
 355       (values (+ (abs (- x2 x1)) (abs (- y2 y1)))
 356               (- x2 x1)
 357               (- y2 y1)))))
 358
 359 (defun middle-child-x (child)
 360   (+ (child-x child) (/ (child-width child) 2)))
 361
 362 (defun middle-child-y (child)
 363   (+ (child-y child) (/ (child-height child) 2)))
 364
 365 (declaim (inline adj-border-xy adj-border-wh))
 366 (defgeneric adj-border-xy (value child))
 367 (defgeneric adj-border-wh (value child))
 368
 369 (defmethod adj-border-xy (v (child xlib:window))
 370   (+ v (x-drawable-border-width child)))
 371
 372 (defmethod adj-border-xy (v (child frame))
 373   (+ v (x-drawable-border-width (frame-window child))))
 374
 375 (defmethod adj-border-wh (v (child xlib:window))
 376   (- v (* (x-drawable-border-width child) 2)))
 377
 378 (defmethod adj-border-wh (v (child frame))
 379   (- v (* (x-drawable-border-width (frame-window child)) 2)))
 380
 381
 382 (declaim (inline anti-adj-border-xy anti-adj-border-wh))
 383 (defgeneric anti-adj-border-xy (value child))
 384 (defgeneric anti-adj-border-wh (value child))
 385
 386 (defmethod anti-adj-border-xy (v (child xlib:window))
 387   (- v (x-drawable-border-width child)))
 388
 389 (defmethod anti-adj-border-xy (v (child frame))
 390   (- v (x-drawable-border-width (frame-window child))))
 391
 392 (defmethod anti-adj-border-wh (v (child xlib:window))
 393   (+ v (* (x-drawable-border-width child) 2)))
 394
 395 (defmethod anti-adj-border-wh (v (child frame))
 396   (+ v (* (x-drawable-border-width (frame-window child)) 2)))
 397
 398
 399
 400
 401 (defmacro with-focus-window ((window) &body body)
 402   `(let ((,window (xlib:input-focus *display*)))
 403      (when (and ,window (not (xlib:window-equal ,window *no-focus-window*)))
 404        ,@body)))
 405
 406
 407
 408 ;; (with-all-children (*root-frame* child) (typecase child (xlib:window (print child)) (frame (print (frame-number child)))))
 409 (defmacro with-all-children ((root child) &body body)
 410   (let ((rec (gensym))
 411         (sub-child (gensym)))
 412     `(block nil
 413        (labels ((,rec (,child)
 414                   ,@body
 415                   (when (frame-p ,child)
 416                     (dolist (,sub-child (reverse (frame-child ,child)))
 417                       (,rec ,sub-child)))))
 418          (,rec ,root)))))
 419
 420
 421 ;; (with-all-children (*root-frame* child) (typecase child (xlib:window (print child)) (frame (print (frame-number child)))))
 422 (defmacro with-all-children-reversed ((root child) &body body)
 423   (let ((rec (gensym))
 424         (sub-child (gensym)))
 425     `(block nil
 426        (labels ((,rec (,child)
 427                   ,@body
 428                   (when (frame-p ,child)
 429                     (dolist (,sub-child (frame-child ,child))
 430                       (,rec ,sub-child)))))
 431          (,rec ,root)))))
 432
 433
 434
 435
 436
 437 ;; (with-all-frames (*root-frame* frame) (print (frame-number frame)))
 438 (defmacro with-all-frames ((root frame) &body body)
 439   (let ((rec (gensym))
 440         (child (gensym)))
 441     `(block nil
 442        (labels ((,rec (,frame)
 443                   (when (frame-p ,frame)
 444                     ,@body
 445                     (dolist (,child (reverse (frame-child ,frame)))
 446                       (,rec ,child)))))
 447          (,rec ,root)))))
 448
 449
 450 ;; (with-all-windows (*root-frame* window) (print window))
 451 (defmacro with-all-windows ((root window) &body body)
 452   (let ((rec (gensym))
 453         (child (gensym)))
 454     `(block nil
 455        (labels ((,rec (,window)
 456                   (when (xlib:window-p ,window)
 457                     ,@body)
 458                   (when (frame-p ,window)
 459                     (dolist (,child (reverse (frame-child ,window)))
 460                       (,rec ,child)))))
 461          (,rec ,root)))))
 462
 463
 464
 465 ;; (with-all-frames-windows (*root-frame* child) (print child) (print (frame-number child)))
 466 (defmacro with-all-windows-frames ((root child) body-window body-frame)
 467   (let ((rec (gensym))
 468         (sub-child (gensym)))
 469     `(block nil
 470        (labels ((,rec (,child)
 471                   (typecase ,child
 472                     (xlib:window ,body-window)
 473                     (frame ,body-frame
 474                            (dolist (,sub-child (reverse (frame-child ,child)))
 475                              (,rec ,sub-child))))))
 476          (,rec ,root)))))
 477
 478 (defmacro with-all-windows-frames-and-parent ((root child parent) body-window body-frame)
 479   (let ((rec (gensym))
 480         (sub-child (gensym)))
 481     `(block nil
 482        (labels ((,rec (,child ,parent)
 483                   (typecase ,child
 484                     (xlib:window ,body-window)
 485                     (frame ,body-frame
 486                            (dolist (,sub-child (reverse (frame-child ,child)))
 487                              (,rec ,sub-child ,child))))))
 488          (,rec ,root nil)))))
 489
 490
 491
 492
 493 (defun null-size-window-in-frame (frame)
 494   (let ((null-size-window-p nil))
 495     (with-all-windows (frame window)
 496       (when (null-size-window-p window)
 497         (setf null-size-window-p t)))
 498     null-size-window-p))
 499
 500
 501
 502 (defun create-frame-window ()
 503   (let ((win (xlib:create-window :parent *root*
 504                                  :x 0
 505                                  :y 0
 506                                  :width 200
 507                                  :height 200
 508                                  :background (get-color *frame-background*)
 509                                  :colormap (xlib:screen-default-colormap *screen*)
 510                                  :border-width *border-size*
 511                                  :border (get-color *color-selected*)
 512                                  :event-mask '(:exposure :button-press :button-release :pointer-motion :enter-window))))
 513     (setf (window-transparency win) *frame-transparency*)
 514     win))
 515
 516 (defun create-frame-gc (window)
 517   (xlib:create-gcontext :drawable window
 518                         :foreground (get-color *frame-foreground*)
 519                         :background (get-color *frame-background*)
 520                         :font *default-font*
 521                         :line-style :solid))
 522
 523
 524 (defun destroy-all-frames-window ()
 525   (with-all-frames (*root-frame* frame)
 526     (when (frame-gc frame)
 527       (xlib:free-gcontext (frame-gc frame))
 528       (setf (frame-gc frame) nil))
 529     (when (frame-window frame)
 530       (xlib:destroy-window (frame-window frame))
 531       (setf (frame-window frame) nil))))
 532
 533 (defun create-all-frames-window ()
 534   (with-all-frames (*root-frame* frame)
 535     (unless (frame-window frame)
 536       (setf (frame-window frame) (create-frame-window)))
 537     (unless (frame-gc frame)
 538       (setf (frame-gc frame) (create-frame-gc (frame-window frame)))))
 539   (with-all-frames (*root-frame* frame)
 540     (dolist (child (frame-child frame))
 541       (handler-case
 542           (dbg (child-fullname child))
 543         (error (c)
 544           (setf (frame-child frame) (remove child (frame-child frame) :test #'child-equal-p))
 545           (dbg c child))))))
 546
 547
 548
 549
 550 (defun frame-find-free-number ()
 551   (let ((all-numbers nil))
 552     (with-all-frames (*root-frame* frame)
 553       (pushnew (frame-number frame) all-numbers))
 554     (find-free-number all-numbers)))
 555
 556
 557 (defun create-frame (&rest args &key (number (frame-find-free-number)) &allow-other-keys)
 558   (let* ((window (create-frame-window))
 559          (gc (create-frame-gc window)))
 560     (apply #'make-instance 'frame :number number :window window :gc gc args)))
 561
 562
 563 (defun add-frame (frame parent)
 564   (push frame (frame-child parent))
 565   frame)
 566
 567
 568 (defun place-frame (frame parent prx pry prw prh)
 569   "Place a frame from real (pixel) coordinates"
 570   (when (and (frame-p frame) (frame-p parent))
 571     (with-slots (window x y w h) frame
 572       (setf (x-drawable-x window) prx
 573             (x-drawable-y window) pry
 574             (x-drawable-width window) prw
 575             (x-drawable-height window) prh
 576             x (x-px->fl prx parent)
 577             y (y-px->fl pry parent)
 578             w (w-px->fl prw parent)
 579             h (h-px->fl prh parent))
 580       (xlib:display-finish-output *display*))))
 581
 582
 583
 584 (defun find-child (to-find root)
 585   "Find to-find in root or in its children"
 586   (with-all-children (root child)
 587     (when (child-equal-p child to-find)
 588       (return-from find-child t))))
 589
 590
 591
 592 (defmacro with-find-in-all-frames (test &optional return-value)
 593   `(let (ret)
 594      (block return-block
 595        (with-all-frames (root frame)
 596          (when ,test
 597            (if first-foundp
 598                (return-from return-block (or ,return-value frame))
 599                (setf ret frame))))
 600        (or ,return-value ret))))
 601
 602 (defun find-parent-frame  (to-find &optional (root *root-frame*) first-foundp)
 603   "Return the parent frame of to-find"
 604   (with-find-in-all-frames
 605       (child-member to-find (frame-child frame))))
 606
 607 (defun find-frame-window (window &optional (root *root-frame*) first-foundp)
 608   "Return the frame with the window window"
 609   (with-find-in-all-frames
 610       (xlib:window-equal window (frame-window frame))))
 611
 612 (defun find-frame-by-name (name &optional (root *root-frame*) first-foundp)
 613   "Find a frame from its name"
 614   (when name
 615     (with-find-in-all-frames
 616         (string-equal name (frame-name frame)))))
 617
 618 (defun find-frame-by-number (number &optional (root *root-frame*) first-foundp)
 619   "Find a frame from its number"
 620   (when (numberp number)
 621     (with-find-in-all-frames
 622         (= number (frame-number frame)))))
 623
 624
 625 (defun find-child-in-parent (child base)
 626   "Return t if child is in base or in its parents"
 627   (labels ((rec (base)
 628              (when (child-equal-p child base)
 629                (return-from find-child-in-parent t))
 630              (let ((parent (find-parent-frame base)))
 631                (when parent
 632                  (rec parent)))))
 633     (rec base)))
 634
 635 ;;; Multiple roots support (replace the old *current-root* variable)
 636 (let ((root-list nil)
 637       (current-child nil))
 638   (defun get-root-list ()
 639     root-list)
 640
 641   (let ((save-root-list nil))
 642     (defun save-root-list ()
 643       (setf save-root-list nil)
 644       (dolist (root root-list)
 645         (push (copy-root root) save-root-list)))
 646     (defun restore-root-list ()
 647       (setf root-list nil)
 648       (dolist (root save-root-list)
 649         (push (copy-root root) root-list))))
 650
 651   (defmacro with-saved-root-list (() &body body)
 652     `(progn
 653        (save-root-list)
 654        ,@body
 655        (restore-root-list)))
 656
 657   (defun reset-root-list ()
 658     (setf root-list nil
 659           current-child nil))
 660
 661   (defun define-as-root (child x y width height)
 662     (push (make-root :child child :original child :current-child nil :x x :y y :w width :h height) root-list))
 663
 664   (defun find-root-by-coordinates (x y)
 665     (dolist (root root-list)
 666       (when (in-rect x y (root-x root) (root-y root) (root-w root) (root-h root))
 667         (return root))))
 668
 669   (defun root (x &optional y)
 670     "Return the root at coordinates (x,y) if y is not nil.
 671      Otherwise, return the x nth root in root-list"
 672     (if y
 673         (find-root-by-coordinates x y)
 674         (nth x root-list)))
 675
 676   (defun all-root-child ()
 677     (loop for root in root-list
 678        collect (root-child root)))
 679
 680   (defmacro with-all-root-child ((root) &body body)
 681     (let ((root-symb (gensym)))
 682       `(dolist (,root-symb (get-root-list))
 683          (let ((,root (root-child ,root-symb)))
 684            ,@body))))
 685
 686   (labels ((generic-child-root-p (child function)
 687              (dolist (root root-list)
 688                (when (child-equal-p child (funcall function root))
 689                  (return root)))))
 690     (defun child-root-p (child)
 691       (generic-child-root-p child #'root-child))
 692
 693     (defun child-original-root-p (child)
 694       (generic-child-root-p child #'root-original)))
 695
 696   (defun change-root (old-root new-child)
 697     (when (and old-root new-child)
 698       (setf (root-child old-root) new-child)))
 699
 700   (defun find-root (child)
 701     (aif (child-original-root-p child)
 702          it
 703          (awhen (find-parent-frame child)
 704            (find-root it))))
 705
 706   (defun find-child-in-all-root (child)
 707     (dolist (root root-list)
 708       (when (find-child child (root-child root))
 709         (return-from find-child-in-all-root root))))
 710
 711   (defun find-current-root ()
 712     (root-child (find-root (current-child))))
 713
 714   (defun exchange-root-geometry (root-1 root-2)
 715     (when (and root-1 root-2)
 716       (rotatef (root-x root-1) (root-x root-2))
 717       (rotatef (root-y root-1) (root-y root-2))
 718       (rotatef (root-w root-1) (root-w root-2))
 719       (rotatef (root-h root-1) (root-h root-2))))
 720
 721   (defun rotate-root-geometry ()
 722     (let* ((current (first root-list))
 723            (orig-x (root-x current))
 724            (orig-y (root-y current))
 725            (orig-w (root-w current))
 726            (orig-h (root-h current)))
 727       (dolist (elem (rest root-list))
 728         (setf (root-x current) (root-x elem)
 729               (root-y current) (root-y elem)
 730               (root-w current) (root-w elem)
 731               (root-h current) (root-h elem)
 732               current elem))
 733       (let ((last (car (last root-list))))
 734         (setf (root-x last) orig-x
 735               (root-y last) orig-y
 736               (root-w last) orig-w
 737               (root-h last) orig-h))))
 738
 739   (defun anti-rotate-root-geometry ()
 740     (setf root-list (nreverse root-list))
 741     (rotate-root-geometry)
 742     (setf root-list (nreverse root-list)))
 743
 744   ;;; Current child functions
 745   (defun current-child ()
 746     current-child)
 747
 748   (defun current-child-setter (value)
 749     (awhen (find-root value)
 750       (setf (root-current-child it) value))
 751     (setf current-child value))
 752
 753   (defmacro with-current-child ((new-child) &body body)
 754     "Temporarly change the current child"
 755     (let ((old-child (gensym))
 756           (ret (gensym)))
 757       `(let ((,old-child (current-child)))
 758          (setf (current-child) ,new-child)
 759          (let ((,ret (multiple-value-list (progn ,@body))))
 760            (setf (current-child) ,old-child)
 761            (values-list ,ret)))))
 762
 763   (defun child-is-a-current-child-p (child)
 764     (find child root-list :test #'child-equal-p :key #'root-current-child)))
 765
 766 (defsetf current-child current-child-setter)
 767
 768 (defun ensure-at-least-one-root ()
 769   (unless (get-root-list)
 770     (let ((frame (create-frame)))
 771       (add-frame frame *root-frame*)
 772       (define-as-root frame 0 0 (xlib:screen-width *screen*) (xlib:screen-height *screen*))
 773       (add-frame (create-frame) frame))))
 774
 775
 776
 777
 778
 779
 780 (defun is-in-current-child-p (child)
 781   (and (frame-p (current-child))
 782        (child-member child (frame-child (current-child)))))
 783
 784
 785
 786 (defun fixe-real-size (frame parent)
 787   "Fixe real (pixel) coordinates in float coordinates"
 788   (when (frame-p frame)
 789     (with-slots (x y w h rx ry rw rh) frame
 790       (setf x (x-px->fl rx parent)
 791             y (y-px->fl ry parent)
 792             w (w-px->fl (anti-adj-border-wh rw parent) parent)
 793             h (h-px->fl (anti-adj-border-wh rh parent) parent)))))
 794
 795 (defun fixe-real-size-current-child ()
 796   "Fixe real (pixel) coordinates in float coordinates for children in the current child"
 797   (when (frame-p (current-child))
 798     (dolist (child (frame-child (current-child)))
 799       (fixe-real-size child (current-child)))))
 800
 801
 802
 803 ;;; Multiple physical screen helper
 804 (defun add-placed-frame-tmp (frame n)   ;; For test
 805   (add-frame (create-frame :x 0.01 :y 0.01 :w 0.4 :h 0.4) frame)
 806   (add-frame (create-frame :x 0.55 :y 0.01 :w 0.4 :h 0.4) frame)
 807   (add-frame (create-frame :x 0.03 :y 0.5 :w 0.64 :h 0.44) frame)
 808   (when (plusp n)
 809     (add-placed-frame-tmp (first (frame-child frame)) (1- n))))
 810
 811 (defun parse-xinerama-info (line)
 812   (remove nil
 813           (mapcar (lambda (string)
 814                     (parse-integer string :junk-allowed t))
 815                   (split-string (substitute #\space #\x (substitute #\space #\, line))))))
 816
 817 (defun get-connected-heads-size (&optional (fake (string= (getenv "DISPLAY") ":1")))
 818   (labels ((heads-info ()
 819              (if (not fake)
 820                  (do-shell "xdpyinfo -ext XINERAMA")
 821                  (progn
 822                    (setf *show-root-frame-p* t)
 823                    (do-shell "echo '    available colormap entries:    256 per subfield
 824     red, green, blue masks:    0xff0000, 0xff00, 0xff
 825     significant bits in color specification:    8 bits
 826
 827 XINERAMA version 1.1 opcode: 150
 828   head #0: 500x300 @ 10,10
 829   head #1: 480x300 @ 520,20
 830   head #2: 600x250 @ 310,330'")))))
 831     (when (xlib:query-extension *display* "XINERAMA")
 832       (let ((output (heads-info))
 833             (sizes nil))
 834         (loop for line = (read-line output nil nil)
 835            while line
 836            do (when (search " head " line)
 837                 (destructuring-bind (w h x y)
 838                     (parse-xinerama-info line)
 839                   (push (list x y w h) sizes))))
 840         (remove-duplicates sizes :test #'equal)))))
 841         ;;'((10 10 500 300) (550 50 400 400) (100 320 400 270))))))
 842         ;;'((10 10 500 580) (540 50 470 500))))))
 843
 844
 845 (let ((last-sizes nil))
 846   (defun place-frames-from-xinerama-infos ()
 847     "Place frames according to xdpyinfo/xinerama informations"
 848     (let ((sizes (get-connected-heads-size))
 849           (width (xlib:screen-width *screen*))
 850           (height (xlib:screen-height *screen*)))
 851       (labels ((update-root-geometry ()
 852                  (loop for size in sizes
 853                     for root in (get-root-list)
 854                     do (destructuring-bind (x y w h) size
 855                          (setf (root-x root) x
 856                                (root-y root) y
 857                                (root-w root) w
 858                                (root-h root) h)))
 859                  (setf last-sizes sizes)
 860                  :update)
 861                (create-root-geometry ()
 862                  (reset-root-list)
 863                  ;; Add frames in *root-frame* until we get the same number as screen heads
 864                  (loop while (< (length (frame-child *root-frame*)) (length sizes))
 865                     do (let ((frame (create-frame)))
 866                          (add-frame frame *root-frame*)))
 867                  ;; On the opposite way: remove frames while there is more than screen heads in *root-frame*
 868                  (when (and sizes (> (length (frame-child *root-frame*)) (length sizes)))
 869                    (dotimes (i (- (length (frame-child *root-frame*)) (length sizes)))
 870                      (let ((deleted-child (pop (frame-child *root-frame*))))
 871                        (typecase deleted-child
 872                          (xlib:window (push deleted-child (frame-child (first (frame-child *root-frame*)))))
 873                          (frame (dolist (child (frame-child deleted-child))
 874                                   (push child (frame-child (first (frame-child *root-frame*)))))))
 875                        (setf (frame-layout (first (frame-child *root-frame*))) 'tile-space-layout
 876                              (frame-data-slot (first (frame-child *root-frame*)) :tile-layout-keep-position) :yes))))
 877                  (loop for size in sizes
 878                     for frame in (frame-child *root-frame*)
 879                     do (destructuring-bind (x y w h) size
 880                          (setf (frame-x frame) (float (/ x width))
 881                                (frame-y frame) (float (/ y height))
 882                                (frame-w frame) (float (/ w width))
 883                                (frame-h frame) (float (/ h height)))
 884                          ;;(add-placed-frame-tmp frame 2)  ;; For tests
 885                          (unless (frame-child frame)
 886                            (add-frame (create-frame) frame))
 887                          (define-as-root frame x y w h)))
 888                  (setf last-sizes sizes)
 889                  nil))
 890         (format t "Screen sizes: ~A~%" sizes)
 891         (if (= (length sizes) (length last-sizes))
 892             (update-root-geometry)
 893             (create-root-geometry))))))
 894
 895
 896
 897 (defun finish-configuring-root ()
 898   (ensure-at-least-one-root)
 899   (setf (current-child) (first (frame-child (first (frame-child *root-frame*))))))
 900
 901
 902
 903 (defun get-all-windows (&optional (root *root-frame*))
 904   "Return all windows in root and in its children"
 905   (let ((acc nil))
 906     (with-all-windows (root window)
 907       (push window acc))
 908     acc))
 909
 910 (defun get-all-frame-windows (&optional (root *root-frame*))
 911   "Return all frame windows in root and in its children"
 912   (let ((acc nil))
 913     (with-all-frames (root frame)
 914       (push (frame-window frame) acc))
 915     acc))
 916
 917
 918 (defun get-hidden-windows ()
 919   "Return all hiddens windows"
 920   (let ((all-windows (get-all-windows))
 921         (hidden-windows (remove-if-not #'window-hidden-p
 922                                        (copy-list (xlib:query-tree *root*)))))
 923     (set-difference hidden-windows all-windows)))
 924
 925
 926
 927 ;;; Current window utilities
 928 (defun get-current-window ()
 929   (typecase (current-child)
 930     (xlib:window  (current-child))
 931     (frame (frame-selected-child (current-child)))))
 932
 933 (defmacro with-current-window (&body body)
 934   "Bind 'window' to the current window"
 935   `(let ((window (get-current-window)))
 936       (when (xlib:window-p window)
 937         ,@body)))
 938
 939 (defun get-first-window ()
 940   (typecase (current-child)
 941     (xlib:window  (current-child))
 942     (frame (or (first (frame-child (current-child)))
 943                (current-child)))))
 944
 945
 946
 947
 948
 949 (defun display-frame-info (frame)
 950   (when (frame-p frame)
 951     (let ((dy (+ (xlib:max-char-ascent *default-font*) (xlib:max-char-descent *default-font*))))
 952       (with-slots (name number gc window child hidden-children) frame
 953         (setf (xlib:gcontext-background gc) (get-color *frame-background*)
 954               (xlib:window-background window) (get-color *frame-background*))
 955         (clear-pixmap-buffer window gc)
 956         (setf (xlib:gcontext-foreground gc) (get-color (if (and (child-root-p frame)
 957                                                                 (child-equal-p frame (current-child)))
 958                                                            *frame-foreground-root* *frame-foreground*)))
 959         (xlib:draw-glyphs *pixmap-buffer* gc 5 dy
 960                           (format nil "Frame: ~A~A"
 961                                   number
 962                                   (if name  (format nil " - ~A" name) "")))
 963         (let ((pos dy))
 964           (when (child-root-p frame)
 965             (when *child-selection*
 966               (xlib:draw-glyphs *pixmap-buffer* gc 5 (incf pos dy)
 967                                 (with-output-to-string (str)
 968                                   (format str "  Selection: ")
 969                                   (dolist (child *child-selection*)
 970                                     (typecase child
 971                                       (xlib:window (format str "  ~A " (xlib:wm-name child)))
 972                                       (frame (format str "  frame:~A[~A] " (frame-number child)
 973                                                      (aif (frame-name child) it "")))))))))
 974           (dolist (ch child)
 975             (xlib:draw-glyphs *pixmap-buffer* gc 5 (incf pos dy)
 976                               (format nil "  ~A" (ensure-printable (child-fullname ch))))))
 977         (copy-pixmap-buffer window gc)
 978         (values t t)))))
 979
 980
 981 (defgeneric rename-child (child name))
 982
 983 (defmethod rename-child ((child frame) name)
 984   (setf (frame-name child) name)
 985   (display-frame-info child))
 986
 987 (defmethod rename-child ((child xlib:window) name)
 988   (setf (xlib:wm-name child) name))
 989
 990 (defmethod rename-child (child name)
 991   (declare (ignore child name)))
 992
 993
 994 (defun get-parent-layout (child parent)
 995   (aif (child-root-p child)
 996        (values (- (root-x it) (child-border-size child)) (- (root-y it) (child-border-size child))
 997                (root-w it) (root-h it))
 998        (if (or (frame-p child) (managed-window-p child parent))
 999            (if (frame-p parent)
1000                (aif (frame-layout parent)
1001                     (funcall it child parent)
1002                     (no-layout child parent))
1003                (values (- (child-border-size child)) (- (child-border-size child))
1004                        (xlib:screen-width *screen*)
1005                        (xlib:screen-height *screen*)))
1006            (values (x-drawable-x child) (x-drawable-y child)
1007                    (x-drawable-width child) (x-drawable-height child)))))
1008
1009
1010
1011
1012
1013 (defgeneric adapt-child-to-parent (child parent))
1014
1015 (defmethod adapt-child-to-parent ((window xlib:window) parent)
1016   (when (managed-window-p window parent)
1017     (multiple-value-bind (nx ny nw nh)
1018         (get-parent-layout window parent)
1019       (setf nw (max nw 1)  nh (max nh 1))
1020       (let ((change nil))
1021         (when (or (/= (x-drawable-x window) nx)
1022                   (/= (x-drawable-y window) ny))
1023           (setf change :moved))
1024         (when (or (/= (x-drawable-width window) nw)
1025                   (/= (x-drawable-height window) nh))
1026           (setf change :resized))
1027         (when change
1028           (xlib:with-state (window)
1029             (setf (x-drawable-x window) nx
1030                   (x-drawable-y window) ny
1031                   (x-drawable-width window) nw
1032                   (x-drawable-height window) nh)))
1033         change))))
1034
1035
1036 (defmethod adapt-child-to-parent ((frame frame) parent)
1037   (declare (ignore parent))
1038     (with-slots (rx ry rw rh window) frame
1039       (let ((change nil))
1040         (when (or (/= (x-drawable-x window) rx)
1041                   (/= (x-drawable-y window) ry))
1042           (setf change :moved))
1043         (when (or (/= (x-drawable-width window) rw)
1044                   (/= (x-drawable-height window) rh))
1045           (setf change :resized))
1046         (when change
1047           (xlib:with-state (window)
1048             (setf (x-drawable-x window) rx
1049                   (x-drawable-y window) ry
1050                   (x-drawable-width window) rw
1051                   (x-drawable-height window) rh)))
1052         change)))
1053
1054 (defmethod adapt-child-to-parent (child parent)
1055   (declare (ignore child parent))
1056   nil)
1057
1058
1059 (defgeneric set-child-stack-order (window child)
1060   (:documentation "Raise window if child is NIL else put window just below child"))
1061
1062 (defmethod set-child-stack-order (window (child xlib:window))
1063   (lower-window window child))
1064
1065 (defmethod set-child-stack-order (window (child frame))
1066   (lower-window window (frame-window child)))
1067
1068 (defmethod set-child-stack-order (window child)
1069   (declare (ignore child))
1070   (raise-window window))
1071
1072
1073
1074 (defgeneric show-child (child parent previous))
1075
1076 (defmethod show-child ((frame frame) parent previous)
1077   (declare (ignore parent))
1078   (with-slots (window show-window-p) frame
1079     (if (and show-window-p
1080              (or *show-root-frame-p* (not (child-root-p frame))))
1081         (progn
1082           (map-window window)
1083           (set-child-stack-order window previous)
1084           (display-frame-info frame))
1085         (hide-window window))))
1086
1087
1088
1089 (defun hide-unmanaged-window-p (parent)
1090   (let ((action (frame-data-slot parent :unmanaged-window-action)))
1091     (case action
1092       (:hide t)
1093       (:show nil)
1094       (t *hide-unmanaged-window*))))
1095
1096
1097 (defmethod show-child ((window xlib:window) parent previous)
1098   (if (or (managed-window-p window parent)
1099           (child-equal-p window (current-child))
1100           (not (hide-unmanaged-window-p parent))
1101           (child-is-a-current-child-p parent))
1102       (progn
1103         (map-window window)
1104         (set-child-stack-order window previous))
1105       (hide-window window)))
1106
1107 (defmethod show-child (child parent raise-p)
1108   (declare (ignore child parent raise-p))
1109   ())
1110
1111
1112 (defgeneric hide-child (child))
1113
1114 (defmethod hide-child ((frame frame))
1115   (with-slots (window) frame
1116     (xlib:unmap-window window)))
1117
1118 (defmethod hide-child ((window xlib:window))
1119   (hide-window window))
1120
1121 (defmethod hide-child (child)
1122   (declare (ignore child))
1123   ())
1124
1125
1126 (defgeneric select-child (child selected))
1127
1128 (labels ((get-selected-color (child selected-p)
1129            (get-color (cond ((child-equal-p child (current-child)) *color-selected*)
1130                             (selected-p *color-maybe-selected*)
1131                             (t *color-unselected*)))))
1132   (defmethod select-child ((frame frame) selected-p)
1133     (when (and (frame-p frame) (frame-window frame))
1134       (setf (xlib:window-border (frame-window frame))
1135             (get-selected-color frame selected-p))))
1136
1137   (defmethod select-child ((window xlib:window) selected-p)
1138     (setf (xlib:window-border window)
1139           (get-selected-color window selected-p)))
1140
1141   (defmethod select-child (child selected)
1142     (declare (ignore child selected))
1143     ()))
1144
1145 (defun select-current-frame (selected)
1146   (select-child (current-child) selected))
1147
1148 (defun unselect-all-frames ()
1149   (with-all-children (*root-frame* child)
1150     (select-child child nil)))
1151
1152
1153
1154 (defun set-focus-to-current-child ()
1155   (labels ((rec (child)
1156              (typecase child
1157                (xlib:window (focus-window child))
1158                (frame (rec (frame-selected-child child))))))
1159     (no-focus)
1160     (rec (current-child))))
1161
1162
1163
1164
1165 (defun adapt-frame-to-parent (frame parent)
1166   (multiple-value-bind (nx ny nw nh)
1167       (get-parent-layout frame parent)
1168     (with-slots (rx ry rw rh window) frame
1169       (setf rx nx  ry ny
1170             rw (max nw 1)
1171             rh (max nh 1)))))
1172
1173
1174 (defun adapt-child-to-rect (rect)
1175   (let ((window (typecase (child-rect-child rect)
1176                   (xlib:window (when (managed-window-p (child-rect-child rect) (child-rect-parent rect))
1177                                  (child-rect-child rect)))
1178                   (frame (frame-window (child-rect-child rect))))))
1179     (when window
1180       (let ((change (or (/= (x-drawable-x window) (child-rect-x rect))
1181                         (/= (x-drawable-y window) (child-rect-y rect))
1182                         (/= (x-drawable-width window) (child-rect-w rect))
1183                         (/= (x-drawable-height window) (child-rect-h rect)))))
1184         (when change
1185           (setf (x-drawable-x window) (child-rect-x rect)
1186                 (x-drawable-y window) (child-rect-y rect)
1187                 (x-drawable-width window) (child-rect-w rect)
1188                 (x-drawable-height window) (child-rect-h rect)))
1189         change))))
1190
1191
1192
1193
1194 (defun show-all-children (&optional (from-root-frame nil))
1195   "Show all children and hide those not in a root frame"
1196   (declare (ignore from-root-frame))
1197   (let ((geometry-change nil)
1198         (displayed-child nil)
1199         (hidden-child nil))
1200     (labels ((in-displayed-list (child)
1201                (member child displayed-child :test (lambda (c rect)
1202                                                      (child-equal-p c (child-rect-child rect)))))
1203
1204              (add-in-hidden-list (child)
1205                (pushnew child hidden-child :test #'child-equal-p))
1206
1207              (set-geometry (child parent in-current-root child-current-root-p)
1208                (if (or in-current-root child-current-root-p)
1209                    (when (frame-p child)
1210                      (adapt-frame-to-parent child (if child-current-root-p nil parent)))
1211                    (add-in-hidden-list child)))
1212
1213              (recurse-on-frame-child (child in-current-root child-current-root-p selected-p)
1214                (let ((selected-child (frame-selected-child child)))
1215                  (dolist (sub-child (frame-child child))
1216                    (rec sub-child child
1217                         (and selected-p (child-equal-p sub-child selected-child))
1218                         (or in-current-root child-current-root-p)))))
1219
1220              (hidden-child-p (rect)
1221                (dolist (r displayed-child)
1222                  (when (and (rect-hidden-p r rect)
1223                             (or (not (xlib:window-p (child-rect-child r)))
1224                                 (eq (window-type (child-rect-child r)) :normal)))
1225                    (return t))))
1226
1227              (select-and-display (child parent selected-p)
1228                (multiple-value-bind (nx ny nw nh)
1229                    (get-parent-layout child parent)
1230                  (let ((rect (make-child-rect :child child :parent parent
1231                                               :selected-p selected-p
1232                                               :x nx :y ny :w nw :h nh)))
1233                    (if (and *show-hide-policy* (hidden-child-p rect))
1234                        (add-in-hidden-list child)
1235                        (push rect displayed-child)))))
1236
1237              (display-displayed-child ()
1238                (let ((previous nil))
1239                  (dolist (rect (nreverse displayed-child))
1240                    (when (adapt-child-to-rect rect)
1241                      (setf geometry-change t))
1242                    (select-child (child-rect-child rect) (child-rect-selected-p rect))
1243                    (show-child (child-rect-child rect)
1244                                (child-rect-parent rect)
1245                                previous)
1246                    (setf previous (child-rect-child rect)))))
1247
1248              (rec (child parent selected-p in-current-root)
1249                (let ((child-current-root-p (child-root-p child)))
1250                  (unless (in-displayed-list child)
1251                    (set-geometry child parent in-current-root child-current-root-p))
1252                  (when (frame-p child)
1253                    (recurse-on-frame-child child in-current-root child-current-root-p selected-p))
1254                  (when (and (or in-current-root child-current-root-p)
1255                             (not (in-displayed-list child)))
1256                    (select-and-display child parent selected-p)))))
1257
1258       (rec *root-frame* nil t (child-root-p *root-frame*))
1259       (display-displayed-child)
1260       (dolist (child hidden-child)
1261         (hide-child child))
1262       (set-focus-to-current-child)
1263       (xlib:display-finish-output *display*)
1264       geometry-change)))
1265
1266
1267
1268
1269 (defun hide-all-children (root &optional except)
1270   "Hide all root children"
1271   (when (and (frame-p root) (not (child-equal-p root except)))
1272     (dolist (child (frame-child root))
1273       (hide-all child except))))
1274
1275 (defun hide-all (root &optional except)
1276   "Hide root and all its children"
1277   (unless (child-equal-p root except)
1278     (hide-child root))
1279   (hide-all-children root except))
1280
1281
1282
1283
1284
1285 (defun focus-child (child parent)
1286   "Focus child - Return true if something has change"
1287   (when (and (frame-p parent)
1288              (child-member child (frame-child parent)))
1289     (when (not (child-equal-p child (frame-selected-child parent)))
1290       (with-slots ((parent-child child) selected-pos) parent
1291         (setf parent-child (nth-insert selected-pos child (child-remove child parent-child))))
1292       t)))
1293
1294 (defun focus-child-rec (child parent)
1295   "Focus child and its parents - Return true if something has change"
1296   (let ((change nil))
1297     (labels ((rec (child parent)
1298                (when (focus-child child parent)
1299                  (setf change t))
1300                (when parent
1301                  (rec parent (find-parent-frame parent)))))
1302       (rec child parent))
1303     change))
1304
1305
1306 (defun set-current-child-generic (child)
1307   (unless (child-equal-p (current-child) child)
1308     (setf (current-child) child)
1309     t))
1310
1311 (defgeneric set-current-child (child parent window-parent))
1312
1313 (defmethod set-current-child ((child xlib:window) parent window-parent)
1314   (set-current-child-generic (if window-parent parent child)))
1315
1316 (defmethod set-current-child ((child frame) parent window-parent)
1317   (declare (ignore parent window-parent))
1318   (set-current-child-generic child))
1319
1320 (defmethod set-current-child (child parent window-parent)
1321   (declare (ignore child parent window-parent))
1322   ())
1323
1324
1325 (defun set-current-root (child parent window-parent)
1326   "Set current root if parent is not in current root"
1327   (let ((root (find-root child)))
1328     (when (and root window-parent
1329                (not (child-root-p child))
1330                (not (find-child parent (root-child root))))
1331       (change-root root parent)
1332       t)))
1333
1334 (defun focus-all-children (child parent &optional (window-parent t))
1335   "Focus child and its parents -
1336 For window: set current child to window or its parent according to window-parent"
1337   (let ((new-focus (focus-child-rec child parent))
1338         (new-current-child (set-current-child child parent window-parent))
1339         (new-root (set-current-root child parent window-parent)))
1340     (or new-focus new-current-child new-root)))
1341
1342
1343
1344
1345 (defun select-next-level ()
1346   "Select the next level in frame"
1347   (select-current-frame :maybe)
1348   (when (frame-p (current-child))
1349     (awhen (frame-selected-child (current-child))
1350       (setf (current-child) it)))
1351   (show-all-children))
1352
1353 (defun select-previous-level ()
1354   "Select the previous level in frame"
1355   (unless (child-root-p (current-child))
1356     (select-current-frame :maybe)
1357     (awhen (find-parent-frame (current-child))
1358       (setf (current-child) it))
1359     (show-all-children)))
1360
1361
1362 (defun enter-frame ()
1363   "Enter in the selected frame - ie make it the root frame"
1364   (let ((root (find-root (current-child))))
1365     (when (and root (not (child-equal-p (root-child root) (current-child))))
1366       (change-root root (current-child)))
1367     (show-all-children t)))
1368
1369 (defun leave-frame ()
1370   "Leave the selected frame - ie make its parent the root frame"
1371   (let ((root (find-root (current-child))))
1372     (unless (or (child-equal-p (root-child root) *root-frame*)
1373                 (child-original-root-p (root-child root)))
1374       (awhen (and root (find-parent-frame (root-child root)))
1375         (when (frame-p it)
1376           (change-root root it)))
1377       (show-all-children))))
1378
1379
1380 ;;; Other actions (select-next-child, select-next-brother...) are in
1381 ;;; clfswm-circulate-mode.lisp
1382
1383
1384
1385 (defun frame-lower-child ()
1386   "Lower the child in the current frame"
1387   (when (frame-p (current-child))
1388     (with-slots (child selected-pos) (current-child)
1389       (unless (>= selected-pos (length child))
1390         (when (nth (1+ selected-pos) child)
1391           (rotatef (nth selected-pos child)
1392                    (nth (1+ selected-pos) child)))
1393         (incf selected-pos)))
1394     (show-all-children)))
1395
1396
1397 (defun frame-raise-child ()
1398   "Raise the child in the current frame"
1399   (when (frame-p (current-child))
1400     (with-slots (child selected-pos) (current-child)
1401       (unless (< selected-pos 1)
1402         (when (nth (1- selected-pos) child)
1403           (rotatef (nth selected-pos child)
1404                    (nth (1- selected-pos) child)))
1405         (decf selected-pos)))
1406     (show-all-children)))
1407
1408
1409 (defun frame-select-next-child ()
1410   "Select the next child in the current frame"
1411   (when (frame-p (current-child))
1412     (with-slots (child selected-pos) (current-child)
1413       (setf selected-pos (mod (1+ selected-pos) (max (length child) 1))))
1414     (show-all-children)))
1415
1416
1417 (defun frame-select-previous-child ()
1418   "Select the previous child in the current frame"
1419   (when (frame-p (current-child))
1420     (with-slots (child selected-pos) (current-child)
1421       (setf selected-pos (mod (1- selected-pos) (max (length child) 1))))
1422     (show-all-children)))
1423
1424
1425
1426 (defun switch-to-root-frame (&key (show-later nil))
1427   "Switch to the root frame"
1428   (let ((root (find-root (current-child))))
1429     (when root
1430       (change-root root (root-original root)))
1431     (unless show-later
1432       (show-all-children t))))
1433
1434 (defun switch-and-select-root-frame (&key (show-later nil))
1435   "Switch and select the root frame"
1436   (let ((root (find-root (current-child))))
1437     (when root
1438       (change-root root (root-original root))
1439       (setf (current-child) (root-original root)))
1440     (unless show-later
1441       (show-all-children t))))
1442
1443
1444 (defun toggle-show-root-frame ()
1445   "Show/Hide the root frame"
1446   (setf *show-root-frame-p* (not *show-root-frame-p*))
1447   (show-all-children))
1448
1449
1450
1451 (defun prevent-current-*-equal-child (child)
1452   " Prevent current-root and current-child equal to child"
1453   (if (child-original-root-p child)
1454       nil
1455       (progn
1456         (awhen (child-root-p child)
1457           (change-root it (find-parent-frame child)))
1458         (when (child-equal-p child (current-child))
1459           (awhen (find-root child)
1460             (setf (current-child) (root-child it))))
1461         t)))
1462
1463
1464
1465 (defun remove-child-in-frame (child frame)
1466   "Remove the child in frame"
1467   (when (frame-p frame)
1468     (setf (frame-child frame) (child-remove child (frame-child frame)))))
1469
1470 (defun remove-child-in-frames (child root)
1471   "Remove child in the frame root and in all its children"
1472   (with-all-frames (root frame)
1473     (remove-child-in-frame child frame)))
1474
1475
1476 (defun remove-child-in-all-frames (child)
1477   "Remove child in all frames from *root-frame*"
1478   (when (prevent-current-*-equal-child child)
1479     (remove-child-in-frames child *root-frame*)))
1480
1481
1482 (defun delete-child-in-frames (child root &optional (close-methode 'delete-window))
1483   "Delete child in the frame root and in all its children
1484 Warning:frame window and gc are freeed."
1485   (with-all-frames (root frame)
1486     (remove-child-in-frame child frame)
1487     (unless (find-frame-window (frame-window frame))
1488       (awhen (frame-gc frame) (xlib:free-gcontext it) (setf it nil))
1489       (awhen (frame-window frame) (xlib:destroy-window it) (setf it nil))))
1490   (when (xlib:window-p child)
1491     (funcall close-methode child)
1492     (netwm-remove-in-client-list child)))
1493
1494
1495
1496 (defun delete-child-in-all-frames (child &optional (close-methode 'delete-window))
1497   "Delete child in all frames from *root-frame*"
1498   (when (prevent-current-*-equal-child child)
1499     (delete-child-in-frames child *root-frame* close-methode)))
1500
1501 (defun delete-child-and-children-in-frames (child root &optional (close-methode 'delete-window))
1502   "Delete child and its children in the frame root and in all its children
1503 Warning:frame window and gc are freeed."
1504   (when (and (frame-p child) (frame-child child))
1505     (dolist (ch (frame-child child))
1506       (delete-child-and-children-in-frames ch root close-methode)))
1507   (delete-child-in-frames child root close-methode))
1508
1509 (defun delete-child-and-children-in-all-frames (child &optional (close-methode 'delete-window))
1510   "Delete child and its children in all frames from *root-frame*"
1511   (when (prevent-current-*-equal-child child)
1512     (when (frame-p child)
1513       (delete-child-and-children-in-frames child *root-frame* close-methode))
1514     (when (xlib:window-p child)
1515       (funcall close-methode child))))
1516
1517
1518 (defun clean-windows-in-all-frames ()
1519   "Remove all xlib:windows present in *root-frame* and not in the xlib tree"
1520   (let ((x-tree (xlib:query-tree *root*)))
1521     (with-all-frames (*root-frame* frame)
1522       (dolist (child (frame-child frame))
1523         (when (xlib:window-p child)
1524           (unless (member child x-tree :test #'xlib:window-equal)
1525             (when (prevent-current-*-equal-child child)
1526               (setf (frame-child frame)
1527                     (child-remove child (frame-child frame))))))))))
1528
1529
1530
1531 (defun do-all-frames-nw-hook (window)
1532   "Call nw-hook of each frame."
1533   (catch 'nw-hook-loop
1534     (let ((found nil))
1535       (with-all-frames (*root-frame* frame)
1536         (awhen (frame-nw-hook frame)
1537           (setf found (call-hook it frame window))))
1538       found)))
1539
1540
1541
1542 (defun process-new-window (window)
1543   "When a new window is created (or when we are scanning initial
1544 windows), this function dresses the window up and gets it ready to be
1545 managed."
1546   (setf (xlib:window-event-mask window) *window-events*)
1547   (set-window-state window +normal-state+)
1548   (setf (x-drawable-border-width window) (case (window-type window)
1549                                            (:normal *border-size*)
1550                                            (:maxsize 0)
1551                                            (:transient *border-size*)
1552                                            (:dialog *border-size*)
1553                                            (t *border-size*)))
1554   (grab-all-buttons window)
1555   (unless (never-managed-window-p window)
1556     (unless (do-all-frames-nw-hook window)
1557       (call-hook *default-nw-hook* *root-frame* window)))
1558   (netwm-add-in-client-list window))
1559
1560
1561
1562
1563 (defun with-all-mapped-windows (screen fun)
1564   (let ((all-windows (get-all-windows)))
1565     (dolist (win (xlib:query-tree (xlib:screen-root screen)))
1566       (unless (child-member win all-windows)
1567         (let ((map-state (xlib:window-map-state win))
1568               (wm-state (window-state win)))
1569           (unless (or (eql (xlib:window-override-redirect win) :on)
1570                       (eql win *no-focus-window*)
1571                       (is-notify-window-p win))
1572             (when (or (eql map-state :viewable)
1573                       (eql wm-state +iconic-state+))
1574               (funcall fun win))))))))
1575
1576 (defun store-root-background ()
1577   (with-all-mapped-windows *screen* #'hide-window)
1578   (setf *background-image* (xlib:create-pixmap :width (xlib:screen-width *screen*)
1579                                                :height (xlib:screen-height *screen*)
1580                                                :depth (xlib:screen-root-depth *screen*)
1581                                                :drawable *root*)
1582         *background-gc* (xlib:create-gcontext :drawable *background-image*
1583                                               :foreground (get-color *frame-foreground*)
1584                                               :background (get-color *frame-background*)
1585                                               :font *default-font*
1586                                               :line-style :solid))
1587   (xlib:copy-area *root* *background-gc*
1588                   0 0 (xlib:screen-width *screen*) (xlib:screen-height *screen*)
1589                   *background-image* 0 0)
1590   (with-all-mapped-windows *screen* #'unhide-window))
1591
1592
1593
1594
1595 (defun hide-existing-windows (screen)
1596   "Hide all existing windows in screen"
1597   (dolist (win (xlib:query-tree (xlib:screen-root screen)))
1598     (hide-window win)))
1599
1600
1601
1602 (defun process-existing-windows (screen)
1603   "Windows present when clfswm starts up must be absorbed by clfswm."
1604   (setf *in-process-existing-windows* t)
1605   (let ((id-list nil)
1606         (all-windows (get-all-windows))
1607         (all-frame-windows (get-all-frame-windows)))
1608     (dolist (win (xlib:query-tree (xlib:screen-root screen)))
1609       (unless (or (child-member win all-windows)
1610                   (child-member win all-frame-windows))
1611         (let ((map-state (xlib:window-map-state win))
1612               (wm-state (window-state win)))
1613           (unless (or (eql (xlib:window-override-redirect win) :on)
1614                       (eql win *no-focus-window*)
1615                       (is-notify-window-p win)
1616                       (never-managed-window-p win))
1617             (when (or (eql map-state :viewable)
1618                       (eql wm-state +iconic-state+))
1619               (format t "Processing ~S: type=~A ~S~%" (xlib:wm-name win) (window-type win) win)
1620               (unhide-window win)
1621               (process-new-window win)
1622               (map-window win)
1623               (raise-window win)
1624               (pushnew (xlib:window-id win) id-list))))))
1625     (netwm-set-client-list id-list))
1626   (setf *in-process-existing-windows* nil))
1627
1628
1629 ;;; Child order manipulation functions
1630 (defun put-child-on-top (child parent)
1631   "Put the child on top of its parent children"
1632   (when (frame-p parent)
1633     (setf (frame-child parent) (cons child (child-remove child (frame-child parent)))
1634           (frame-selected-pos parent) 0)))
1635
1636 (defun put-child-on-bottom (child parent)
1637   "Put the child at the bottom of its parent children"
1638   (when (frame-p parent)
1639     (setf (frame-child parent) (append (child-remove child (frame-child parent)) (list child))
1640           (frame-selected-pos parent) 0)))
1641
1642