Re: [Sawfish] sawinlist : provides emacs functions for listing and manipulating x-windows managed by sawfish

[ Thread Index | Date Index | More Archives ]

Here it is. I've just included the two files inline as I was not sure what you meant by your gzip suggestion (don't know how to post gzip). I have found in other lists that posting source code sometimes results in redundant linefeeds, but for emacs source that *may* not matter. However, since I see the sawfish listserv thoughtfully translated my email addr to xxx's, I'll put it here again in not-too-hard-to-understand form - if you want the gzip file, post here or send email to in the next line, remove underscore and change (word1 word2) to at-sign||word1.word2 (omit ||)
john_lumby(hotmail com)

In this package:

sawinlist.el     the emacs functions that interface with sawfish  (using sawfish-client command)
;;; sawinlist.el --- functions for listing and manipulating x-windows managed by sawfish

;; Copyright (C) 2011 by the author: John Lumby johnlumby@xxxxxxxxxxx

;; This file may be used in conjunction with GNU Emacs.

;; Both this file and GNU Emacs are free software; you may redistribute them and/or modify
;; them under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.

;; Both this file and GNU Emacs are distributed in the hope that they will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to
;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.

(provide 'sawinlist)

(defun sawinlist-raise (this-point)
 "raise the sawfish window whose name is the string at or near point;
a Ctl-g<windowid>  sequence,  if present for disambiguation,
may be removed prior to selecting the line,  to cause selection of most recent with that name"
      tempoint nextpoint temp len curchar index nextindx window-name
       cur-is-ctl-g prev-was-ctl-g
       escape-type ; values "["<=>  octal sequence,  "<"<=>  window-id
;;     (coding-system-for-read 'no-conversion)
;;     (coding-system-for-write 'no-conversion)
      (coding-system-for-read 'undecided)
      (coding-system-for-write 'iso-latin-1)
      (cur-line-num 0) ; line number of current line counted backwards from the last as 0
      windownum        ; window-id of window on this line according to sawinlist-window-ids
      override-window-id ;  window-id (printable) from override in line in buffer
;;   count lines backwards from last to current point
   (goto-char (point-max))
   (while (>  (point) this-point)
     (setq cur-line-num (1+ cur-line-num))
     (forward-line -1)
   (goto-char this-point)
   (setq tempoint (progn (beginning-of-line) (point)))
   (setq nextpoint (progn (end-of-line) (point)))
;  window-name is from start of line to end,  minus any appended window-id
   (setq temp (buffer-substring-no-properties tempoint nextpoint))
;  quote backslash and double-quote, and convert the \C-G sequences back to control chars
   (setq index 0)
   (setq len (length temp))
   (setq window-name "")
   (setq override-window-id nil)
   (setq prev-was-ctl-g nil)
   (setq escape-type nil)
;   crawl through characters
       (while (<  index len)
     (setq nextindx (1+ index))
     (setq curchar (substring temp index nextindx))
     (setq cur-is-ctl-g (string= curchar ""))
      (cur-is-ctl-g                            ; start of a \C-G sequence - merely remember
       (setq prev-was-ctl-g t)
       (setq escape-type nil))                 ; next char determines escape-type
      ((and prev-was-ctl-g (not cur-is-ctl-g) (not escape-type)) ; continuation of a \C-G sequence - identify escape type
        (if (or
              (string= curchar "[")               ; octal sequence
                  (string= curchar "<"))              ; window-id of non-unique window name
               (setq escape-type curchar) )
            (setq prev-was-ctl-g nil)
      (escape-type ; prev char was the escape type,  current is start of sequence
         ( (string= escape-type "[")               ; octal sequence
               (setq nextindx (+ index 3))
               (setq window-name (concat window-name (car (read-from-string (concat "\"\\" (substring temp index nextindx) "\"")))))
               (setq nextindx (1+ nextindx))           ; for the terminating "]"
             ( (string= escape-type "<")               ; window-id of non-unique window name
;;     in this case, set override-window-id to force selection by window-id
           (if (string-match "\\([0-9]+\\)>" temp index)
           (setq override-window-id (match-string-no-properties 1 temp)))
               (setq nextindx len)                     ; and exclude this from the true window-name
       (setq escape-type nil)
;;   not a \C-G sequence - take the character as is or quoted
       (setq prev-was-ctl-g nil)
           (if (or (string= curchar "\\")
                   (string= curchar "\"")
;   quote the character
             (setq window-name (concat window-name "\\")))
           (setq window-name (concat window-name curchar))
     (setq index nextindx)
       (setq windownum (aref sawinlist-window-ids cur-line-num)) ;  save this before refresh
;;     always refresh
;;     (message window-name)
;;     if an override window-id of non-unique window name was found,  then get window using that window id.
;;     otherwise,  the following or clause first tries to find the window by name, and then if that fails, by window id.
;;     reason why not to use window id first is that, when there are multiple windows with same name,
;;     (and assuming that the user deleted the Ctl-g<windowid>  sequence at the end of the name so that this function does not see it),
;;     empirically, sawfish always finds the one we want (most recent) whereas use of window id would not.
;;     however, where an app continually changes its name, such as Lotus Notes, mozilla, etc,
;;     we want to locate that window based on id
;;     be careful with formatting of the windownum  -   we want an integer but it may be stored as a float with .0 as fractional part
;; (message (concat "(let ((chosen-window " (cond (override-window-id (concat "(get-window-by-id " override-window-id ")")) (t (concat "(or (get-window-by-name \"" window-name "\") (get-window-by-id " (format "%.0f" windownum) "))"))) ")) (if (window-iconified-p chosen-window) (uniconify-window chosen-window)) (activate-window chosen-window))"))
   (call-process "sawfish-client" nil nil nil "-e" (concat "(let ((chosen-window " (cond (override-window-id (concat "(get-window-by-id " override-window-id ")")) (t (concat "(or (get-window-by-name \"" window-name "\") (get-window-by-id " (format "%.0f" windownum) "))"))) ")) (if (window-iconified-p chosen-window) (uniconify-window chosen-window)) (activate-window chosen-window))"))

(defun sawinlist-raise-from-kbd (this-point)
 "raise the sawfish window whose name is the string at or near point"
 (interactive "d")
  (sawinlist-raise this-point)

(defun sawinlist-raise-from-mouse (eventp)
  "raise the sawfish window whose name is the string at or near mouse position"
  (interactive "e")
  (mouse-set-point eventp)
    (let ( (this-point (point)) )
;; as a convenience, treat right-click at end of buffer as request to refresh it
      (if (= this-point (point-max))
;;     else
      (sawinlist-raise this-point)

(defun sawinlist-build ()
 "build list of sawfish windows in *SAWINLIST* buffer
for manipulation by user - e.g. to raise and lower windows"
;;  the following returns the window list
;;  bash -c 'sawfish-client -e "(let ((winlist (managed-windows)) tcar tcdr (repout \"\`\") temp) (setq tcdr winlist) (while (setq tcar (car tcdr)) (setq tcdr (cdr tcdr)) (setq temp (prin1-to-string (window-name tcar))) (setq repout (concat repout (substring temp 1 (1- (length temp))) \"\`\"))) (princ repout))" | tr "\`" "\n"'
;; and the following raises a named window
;; sawfish-client -e '(activate-window (get-window-by-name "labvm"))'
;; and the following renames a named window
;; sawfish-client -e "(set-x-property (get-window-by-name \"lumby@lumbyrnt:~\") 'WM_NAME \"redpine-screen\" 'STRING 8)"
;; and the following deletes a named window
;; sawfish-client -e '(delete-window (get-window-by-name "Smile!"))'
;; quoting is tricky:   there are up to three levels of nesting of quoting:
;;     level      where                                                       what quoted
;; .     1    inside a lisp string                                                  \ "
;; .      2   inside the shell command (string attached to -c)                      \ " ` $
;; .       3  inside a lisp string inside sawfish-client parmstring                 \ "
;; transparency schemes:
;; two transparency schemes are used:
;;   .  sawfish ==>>  this program           :    printable-ascii char whose value is in symbol transp-char
;;   .  this program ==>>  *SAWINLIST* buffer  :    non-printable control char Ctl-G
;; details of each are given where deployed.    the rationale for these choices and why they are different is :
;;   .  sawfish ==>>  this program
;;       we *must* use a printable-ascii since non-printable chars are translated into quoted octal sequences before we receive them;
;;       note that this character is internal to this program and its use for control sequences is not visible to the user.
;;   .  this program ==>>  *SAWINLIST* buffer
;;       we *prefer* to use a non-printable-ascii since the chosen character is visible to the user
;;       and non-printable is less likely to appear as itself in a name,   i.e. results in less confusion when displayed.
     (transp-char "`") ; printable-ascii char used to delimit control sequences in data sawfish ==>>  this program - see above and below
     (cbuf (current-buffer))
     (sawbuf (get-buffer-create "*SAWINLIST*"))
     sawfish-string ;  the string passed to sawfish -e
     temp ix replacement tempoint windowid windownum (winid-list (list))
;    (coding-system-for-read 'no-conversion)
;    (coding-system-for-write 'no-conversion)
     (coding-system-for-read 'undecided)
     (coding-system-for-write 'iso-latin-1)
     window-name prev_name
     start-of-windowid-section end-of-windowid-section predecessor-windowid
     current-repeated-name ; indicates whether this window name is a repetition of its predecessor
     prev-repeated-name    ; prev value of current-repeated-name : indicates whether the previous window name was a repetition of its predecessor (cur - 2)
;; (call-process "bash" nil "*SAWINLIST*" nil "-c" "sawfish-client -e \"(let ((junk \\\"junkword\\\") temp) (princ junk))\"")
   (switch-to-buffer sawbuf)
;; in the following:
;; the sawfish lambda builds the list of names using a transparent control char,  default back-tick :
;;    single transp-char in name is replaced by two transp-chars
;;    names are separated by sequence forward-slash transp-char forward-slash, which is replaced by newline in the bash one-line-command
;;    any name ending in "- [- a-zA-Z0-9_.:]+" will have this suffix prepended as prefix, on assumption that it is a constant,
;;               separated by sequence blank transp-char blank
;;    window-id integer is appended to each name separated by asterisk transp-char asterisk
;; none of these sequences is a part of any other sequence regardless of neighbouring characters
;; the purpose of the if not string= test is to exclude the name of the current window since we are already in it

(setq sawfish-string (concat "(let ((winlist (managed-windows)) tcar tcdr (repout \"/" transp-char "/\")
     temp index previndx nextindx curchar len dashpos transtr)
  (setq tcdr winlist)
  (while (setq tcar (car tcdr))
   (setq tcdr (cdr tcdr))
   (setq temp (prin1-to-string (window-name tcar) t))
   (setq temp (substring temp 1 (1- (length temp))))
;        (princ temp)
;        ignore current window
     ((string= temp \"" (or (cdr (assoc 'title (frame-parameters (selected-frame)))) (cdr (assoc 'name (frame-parameters (selected-frame))))) "\"))
       (setq index 0)
       (setq dashpos nil)
       (setq transtr \"\")
       (setq len (length temp))
;   crawl through characters
       (while (<  index len)
;        (princ index)
     (setq nextindx (1+ index))
     (setq curchar (substring temp index nextindx))
     (setq transtr (concat transtr curchar))
       ((string= curchar \"-\")
          (if (and (>  index 1) (<  index (- len 4))
               (string= (substring temp previndx index) \" \")
               (string= (substring temp nextindx (1+ nextindx)) \" \")
;   found candidate dash
          (setq dashpos index)))
;   check if valid suffix character ...
       ((string-match \"[ a-zA-Z0-9_.:]\" curchar))
;   ... if not ...
           (setq dashpos nil)
           (if (string= curchar \"" transp-char "\")
;   repeat the transp-char
           (setq transtr (concat transtr curchar)))
     (setq previndx index)
     (setq index nextindx)
       (if (and dashpos (<  (- len dashpos) 44))
;   prepend the dash suffix
       (setq transtr (concat (substring temp (+ dashpos 2)) \" " transp-char " \" transtr)))
;   append the window-id as well
       (setq repout (concat repout transtr \"*" transp-char "*\" (prin1-to-string (window-id tcar) t) \"/" transp-char "/\"))))

;; (call-process "echo" nil "*SAWINLIST*" nil sawfish-string) ; to debug
(call-process "sawfish-client" nil "*SAWINLIST*" nil "-e" sawfish-string)
;; post-processing
;; any non-printable characters in original window names appear as a doubly-quoted octal-read-syntax
;; these are unambiguously distinguished from a clear sequence of such characters (e.g. \\253)
;; because, fortunately, original backslashes appear as a sequence of four backslashes (don't know why ...)
;; so the non-printables are distinguishable by leading with a pair of backslashes NOT preceded by backslash;
;; also note we don't want any clear linefeeds to be translated back to clear linefeeds since our name parsing and sorting relies on one name per line;
;; replace each octal-read-syntax character by :
;;  . if in range 000-037 ( the control chars , including \C-G)  \C-g[octal-sequence] (control-G followed by octal-read-syntax in square-brackets)
;;       (note - the above range includes linefeed - 012 )
;;  . otherwise    the single character
;; note - for reason given below, this works inside emacs started with no .emacs profile but not in my heavily customized emacs -
;;        although the resulting translation is made, sawfish does not find the window -
;;        it seems that in the customized emacs, the special characters are translated once more
;;        with some kind of special leading character
;;        at some point before being sent to sawfish in sawinlist-raise.
;;        explanation found - relating to coding system used for writing to / reading from subprocesses:
;;        although both emacs's had enable-multibyte-characters t nonascii-insert-offset 0
;;        .   customized emacs - had default-process-coding-system (mule-utf-8 . mule-utf-8)
;;        . uncustomized emacs - had default-process-coding-system (undecided . iso-latin-1)
;;        I don't know why these defaults were different, but
;;        setting both coding-system-for-read and coding-system-for-write as for uncustomized emacs makes it work!
;;        I also am NOT sure that this will correctly handle all character sets appearing in window titles ...
   (goto-char (point-min))
   (while (re-search-forward "\\(^\\|[^\\]\\)\\(\\\\\\\\[0-7][0-7][0-7]\\)" nil t)
;;   (match-string-no-properties 2) is the octal sequence including two leading backslashes
     (setq temp (substring (match-string-no-properties 2) 1)) ; octal sequence including one leading backslash
     (setq ix (car (read-from-string (concat "?" temp)))) ; numeric value
      ((<  ix 32)
       (setq replacement (concat "[" (substring temp 1) "]")))
       (setq replacement (car (read-from-string (concat "\"" temp "\""))))) ; character value as a string - default replacement
     (replace-match replacement t t nil 2)
;; back up behind last replacement char in case another sequence follows immediately
;; (note the matching regexp includes one character or line-start preceding the octal sequence)
;; replace each transparent linefeed sequence by a single linefeed
   (goto-char (point-min))
   (while (search-forward (concat "/" transp-char "/") nil t)
     (replace-match "\n" t t nil)
;; delete each line containing only single double-quote
   (goto-char (point-min))
   (while (re-search-forward "^\"$" nil t)
     (delete-region (1- (point)) (1+ (point)))
;; sort the buffer
;; note that the window-ids are still present but at the end of lines so we may use sort-lines
   (goto-char (point-min))
   (sort-lines nil (point-min) (point-max))
;; save window ids in our persistent defvar - format is a vector of window-ids in linenumber sequence
;; if window name key is unique, remove window id
;; otherwise, for any sequence of repeated lines (identical window name key,  i.e. non-unique window names) :
;;      IF   that name is valid (there is still a window of that name)
;;      THEN leave the window-id in place
;;           (changing the transp-char sequence into the sequence Ctl-G<windowid>
;;            to make it disambiguable by sawinlist-raise)
   (makunbound 'sawinlist-window-ids)
   (goto-char (point-min))
   (setq prev-name "")
   (setq prev-repeated-name nil)
   (while (re-search-forward (concat "\\(\\*" transp-char "\\*\\)\\([0-9]+\\)") nil t)
     (setq windowid (match-string-no-properties 2))
     (setq windownum (string-to-number windowid))
     (setq start-of-windowid-section (match-beginning 0))
     (setq end-of-windowid-section (match-end 0))
;;   always delete the windowid section  -
;;   the corresponding ctl-G sequence will be inserted on next loop if needed
     (delete-region start-of-windowid-section end-of-windowid-section)
     (setq tempoint (point)) ; end of current window-name
     (setq window-name (buffer-substring (point) start-of-windowid-section))
      ((string= window-name prev-name)
       (setq current-repeated-name t)
      (t  ; else different
       (setq current-repeated-name nil)
       (setq prev-name window-name)
;;   save its windowid
     (setq winid-list (cons windownum winid-list))
;;   insert window-id sequence at end of predecessor unless its name was distinct from its predecessor and ours
       ( (or prev-repeated-name current-repeated-name)
         (forward-line -1)
         (insert (concat "<" (format "%d" predecessor-windowid)">"))
         (forward-line 1)
     (setq prev-repeated-name current-repeated-name)
     (setq predecessor-windowid windownum)
     ( prev-repeated-name
       (insert (concat "<" (format "%.0f" predecessor-windowid)">"))
   (defvar sawinlist-window-ids (vconcat winid-list) "vector of sawinlist window ids")
;; replace each sequence of three backslashes followed by double-quote by a single double-quote
   (goto-char (point-min))
   (while (search-forward "\\\\\\\"" nil t)
     (replace-match "\"" t t nil)
;; replace each sequence of four backslashes by a single backslash
   (goto-char (point-min))
   (while (search-forward "\\\\\\\\" nil t)
     (replace-match "\\" t t nil)
;; chop off the prepended dash-suffices
   (goto-char (point-min))
   (while (re-search-forward (concat "^.* " transp-char " ") nil t)
     (replace-match "" t t nil)
;; replace each sequence of two transp-chars by a single transp-char
   (goto-char (point-min))
   (while (search-forward (concat transp-char transp-char) nil t)
     (replace-match transp-char t t nil)



sawlist.el       example of user's own load file to run in the emacs frame to initialise the sawinlist


;;   example of an emacs load file to initialise a sawinlist frame
(require 'sawinlist)
(defvar sawin_keymap (copy-keymap (current-global-map))) ;; keymap to be in effect in our buffer

;;   frame-related user customizations --- change anything in the following
;;   local keymap bindings
(define-key sawin_keymap [(control ?3)] 'sawinlist-raise-from-kbd)
(define-key sawin_keymap [(control ?4)] 'sawinlist-build)
(define-key sawin_keymap [f8] 'toggle-truncate-lines)
(define-key sawin_keymap [mouse-3] 'mouse-set-point) ; to prevent altering selection
(define-key sawin_keymap [down-mouse-3] 'sawinlist-raise-from-mouse)
(define-key sawin_keymap "\C-xc" 'dired)
(define-key sawin_keymap "\C-x\C-c" 'dired)
(define-prefix-command 'Ctl-z); define Ctl-z to be a symbolic prefix key
(define-key sawin_keymap "\C-z" 'Ctl-z); define ctl-z to be the prev'ly def'd prefix key
(define-prefix-command 'Ctl-z-Ctl-x)
(define-key sawin_keymap "\C-z\C-x" 'Ctl-z-Ctl-x)
(define-key sawin_keymap "\C-z\C-x\C-c" 'save-buffers-kill-emacs)

;;   load this file into a buffer in case we want to modify it on the fly
(if (file-readable-p load-file-name)
  (find-file load-file-name))

;; odds and ends to make the frame appear as we wish
; (set-frame-height (selected-frame) 64)
; (set-frame-width (selected-frame) 18)
; (set-default-font "6x13")
; (modify-frame-parameters (selected-frame) (list '(mouse-color . "black")))
; (modify-frame-parameters (selected-frame) (list '(background-color . "#E0EDED")))
; (modify-frame-parameters (selected-frame) (list '(foreground-color . "#751503")))
; the above are commented out since usually best to set them from the emacs command line
(modify-frame-parameters (selected-frame) '((menu-bar-lines . 0)))
(tool-bar-mode -1)
;;   frame-related user customizations ---  change anything in the above

;; preferably do not change the next part
;; build the list in the current buffer and set buffer name
(set-buffer "*SAWINLIST*") ;; preferably dont change this name,  as it is hard-coded in sawinlist.el
(if (and (boundp 'sawin_keymap) (keymapp sawin_keymap)) ;; check in case user changed the suggested defvar
  (use-local-map sawin_keymap))
;; preferably do not change the above part

;;   buffer-related user customizations  ---  change anything in the following block
;;   faces and some content that must be run after the terminal-specific init
(set-face-font 'modeline "-adobe-courier-bold-r-normal--12-120-75-75-m-70-iso8859-1")
(set-face-background 'default "#E0EDED")
(set-face-foreground 'default "#751503")
(progn (face-set-after-frame-default (selected-frame)) (set-face-background 'default (cdr (assoc 'background-color (frame-parameters (selected-frame))))) (set-face-background 'fringe (cdr (assoc 'background-color (frame-parameters (selected-frame))))) (set-face-foreground 'default (cdr (assoc 'foreground-color (frame-parameters (selected-frame))))))
(goto-char (point-max))
;;    insert text of some emacs functions that we might want to modify and run into the buffer
(insert "\n(progn (modify-frame-parameters (selected-frame) '((menu-bar-lines . 0)))\n(set-default-font \"6x13\")\n(set-face-font 'modeline \"-adobe-courier-bold-r-normal--12-120-75-75-m-70-iso8859-1\")\n (face-set-after-frame-default (selected-frame)) (set-face-background 'default (cdr (assoc 'background-color (frame-parameters (selected-frame))))) (set-face-background 'fringe (cdr (assoc 'background-color (frame-parameters (selected-frame))))) (set-face-foreground 'default (cdr (assoc 'foreground-color (frame-parameters (selected-frame)))))\n(modify-frame-parameters (selected-frame) (list (cons 'vertical-scroll-bars nil)))\n(server-start))")
;; maybe we want to start a shell???  for example ...
;; (let ((explicit-shell-file-name "/bin/bash") (explicit-bash-args (list "-i"))) (shell "*XSET*"))
;; (sleep-for 1)
;; (set-buffer "*XSET*")
;; (goto-char (point-max))
;; (insert "export LANG=C DISPLAY=:0;for keycode in 10 11 12 13 14 15 16 17 18 19 22 24 25 26 27 28 29 30 31 32 33 38 39 40 41 42 43 44 45 46 52 53 54 55 56 57 58 65 75 76 98 99 100 102 104 105 107;do xset r ${keycode};done;xset r rate 450 40")
;;   buffer-related user customizations  ---  change anything in the above    block


and the readme again :


Copyright (C) 2011 by the author: John Lumby johnlumby@xxxxxxxxxxx
Refer to license in sawinlist.el before using this package


sawinlist provides emacs functions for listing and manipulating x-windows managed by sawfish.

The idea is simple  -
   An emacs buffer containing a list of all the current desktop's windows,
allowing some window-manager-like manipulation of those windows from the emacs buffer.
   For example,   right-click a window name to raise it.

The obvious question - why would I want this when sawfish provides a perfectly good menu? Because an emacs buffer provides facilities which make it an even better menu : . can be permanently displayed if desired ("nailed-down") or iconified
     .   can be resized easily (since it is itself a window)
. can use cut'n'paste etc inside it - in fact, can do any emacs'y thing inside it.

In this package:

sawinlist.el the emacs functions that interface with sawfish (using sawfish-client command) sawlist.el example of user's own load file to run in the emacs frame to initialise the sawinlist
sawinlist.readme this file

Installation and Operation:

  .   put sawinlist.el somewhere in your emacs load-path
  .   put sawlist.el anywhere that can be accessed (e.g. in your home)
  .   customize sawlist.el as desired (see instructions in example)
  .   verify that the sawfish-client command is available
          and works in your environment  -  try running this command:
sawfish-client -e "(let ((winlist (managed-windows)) tcar tcdr (repout \"\`\") temp) (setq tcdr winlist) (while (setq tcar (car tcdr)) (setq tcdr (cdr tcdr)) (setq temp (prin1-to-string (window-name tcar))) (setq repout (concat repout (substring temp 1 (1- (length temp))) \"\`\"))) (princ repout))" | tr "\`" "\n"
          it should return a list of all windows managed by sawfish
          (sawinlist.el uses this command to build its list)
  .   start the emacs frame by running an emacs command such as
emacs --geometry=26x64+6+6 --name=sawinlist --title=sawinlist -ms "#146a2b" -cr red -fn "6x13" -bg "#E0EDED" -fg "#751503" -q -load sawlist.el </dev/null & (where all the options except for the -load sawlist.el are optional and whatever you wish)
  .   if you used the example's key bindings,  then :
      .   right-clicking at the end of the buffer refreshes it
====>>>>> N.B. do this first if there are any emacs forms in the buffer - nothing happens if the buffer content is not a valid list of window names!
      .   right-clicking on any window-name line raises it

Miscellaneous notes:

1. window names are displayed one per line, sorted alphabetically on their names; Exception to sort-sequence - any name ending in "- [- a-zA-Z0-9_.:]+" (dash, space, stuff) will have this suffix prepended as prefix to the sort key (only for sorting purposes). This is in order to try to keep those windows from jumping around in the buffer, since in many cases, especially web browsers, the name changes frequently but the suffix remains constant,
      e.g. "sawfish - Google Search - Google Chrome"
2. any non-printable characters in range octal 000-037 (i.e. the ascii control characters)
      in a window name will appear as the sequence ^G[octal-sequence]
      (control-G followed by octal-read-syntax in square-brackets)
      note that this includes ^G itself and ^J (linefeed)
3. if a subset of windows all have the same name, the suffix ^G<windowid> is appended to disambiguate, where <windowid> is angle-bracket followed by sawfish's internal window id followed by angle-bracket.
      In this case,   there is a feature which may sometimes be useful -
the ^G<windowid> suffix may be removed (by simply editing the name in the buffer) *before* right-clicking, in which case sawinlist will select the most recently created with that name. 4. Bug/feature - the window list is refreshed only when you click in the sawinlist window, not continuously. So sawinlist does not "notice" new/changed windows until after the next click. However, if a window name changes and you then click on the (old) name, then provided there is no new window with the old name, sawinlist will still raise the correct window, as it first tries to find the window by name, and then if that fails, by window id, which remains unchanged. 5. The only window-manger currently (July 2011) implemented is "raise" (activate-window sawfish function);
      others could easily be implemented if desired.

On 07/30/11 01:01, Teika Kazura wrote:
On Tue, 26 Jul 2011 21:07:51 -0400, John Lumby wrote:
I saw there is a web app on the wiki page for uploading sawfish scripts,  but this is an emacs library, not a sawfish script.
However I would guess it belongs more to sawfish than to emacs.
Is there some more generic upload capability on the wiki?    (And is this the right place to ask that?)
Sorry for inconvenience. Our wiki doesn't allow it, so please post it
here. You can make the wiki page, and put a pointer to the cdoe
in the mailing list archives, which are listed here:

If you post it in a plain text, many of archives show it inline,
following the message text, so it may be better to gzip for download

Thanks a lot.

Teika (Teika kazura)

Sawfish ML

Mail converted by MHonArc 2.6.19+