src/cycling.c

   1 /* cycling.c- window cycling
   2  *
   3  *  Window Maker window manager
   4  *
   5  *  Copyright (c) 2000-2003 Alfredo K. Kojima
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20  *  USA.
  21  */
  22
  23 #include "wconfig.h"
  24
  25 #include <X11/Xlib.h>
  26 #include <X11/Xutil.h>
  27 #include <X11/keysym.h>
  28
  29 // TODO: remove non-MOX_CYCLING junk
  30 //       fix the stacking/window raising during alt-tabbing
  31 //       allow selection of icons with mouse
  32
  33 #include "WindowMaker.h"
  34 #include "GNUstep.h"
  35 #include "screen.h"
  36 #include "wcore.h"
  37 #include "window.h"
  38 #include "framewin.h"
  39 #include "keybind.h"
  40 #include "actions.h"
  41 #include "stacking.h"
  42 #include "funcs.h"
  43 #include "xinerama.h"
  44 #include "switchpanel.h"
  45
  46 /* Globals */
  47 extern WPreferences wPreferences;
  48
  49 extern WShortKey wKeyBindings[WKBD_LAST];
  50
  51
  52 static void raiseWindow(WSwitchPanel *swpanel, WWindow *wwin)
  53 {
  54     if (wwin->flags.mapped) {
  55         Window win[2];
  56
  57         win[0]= wSwitchPanelGetWindow(swpanel);
  58         win[1]= wwin->frame->core->window;
  59
  60         XRestackWindows(dpy, win, 2);
  61     }
  62 }
  63
  64
  65
  66 void
  67 StartWindozeCycle(WWindow *wwin, XEvent *event, Bool next)
  68 {
  69     WScreen *scr = wScreenForRootWindow(event->xkey.root);
  70     Bool done = False;
  71     WWindow *newFocused;
  72     WWindow *oldFocused;
  73     int modifiers;
  74     XModifierKeymap *keymap = NULL;
  75     Bool hasModifier;
  76     Bool somethingElse = False;
  77     XEvent ev;
  78     WSwitchPanel *swpanel = NULL;
  79     KeyCode leftKey, rightKey, homeKey, endKey;
  80
  81     if (!wwin || wwin->frame->workspace != scr->current_workspace)
  82         return;
  83
  84     leftKey = XKeysymToKeycode(dpy, XK_Left);
  85     rightKey = XKeysymToKeycode(dpy, XK_Right);
  86     homeKey = XKeysymToKeycode(dpy, XK_Home);
  87     endKey = XKeysymToKeycode(dpy, XK_End);
  88
  89     if (next)
  90         hasModifier = (wKeyBindings[WKBD_FOCUSNEXT].modifier != 0);
  91     else
  92         hasModifier = (wKeyBindings[WKBD_FOCUSPREV].modifier != 0);
  93
  94     if (hasModifier) {
  95         keymap = XGetModifierMapping(dpy);
  96
  97 #ifdef DEBUG
  98         printf("Grabbing keyboard\n");
  99 #endif
 100         XGrabKeyboard(dpy, scr->root_win, False, GrabModeAsync, GrabModeAsync,
 101                       CurrentTime);
 102     }
 103
 104     scr->flags.doing_alt_tab = 1;
 105
 106     swpanel =  wInitSwitchPanel(scr, wwin, scr->current_workspace);
 107     oldFocused = wwin;
 108
 109     if (swpanel) {
 110         newFocused = wSwitchPanelSelectNext(swpanel, !next);
 111         if (newFocused) {
 112             wWindowFocus(newFocused, oldFocused);
 113             oldFocused = newFocused;
 114
 115             if (wPreferences.circ_raise)
 116               raiseWindow(swpanel, newFocused);
 117         }
 118     }
 119     else
 120       newFocused= wwin;
 121
 122     while (hasModifier && !done) {
 123         WMMaskEvent(dpy, KeyPressMask|KeyReleaseMask|ExposureMask|PointerMotionMask, &ev);
 124
 125         if (ev.type != KeyRelease && ev.type != KeyPress) {
 126             WMHandleEvent(&ev);
 127             continue;
 128         }
 129         /* ignore CapsLock */
 130         modifiers = ev.xkey.state & ValidModMask;
 131
 132         if (ev.type == KeyPress) {
 133 #ifdef DEBUG
 134             printf("Got key press\n");
 135 #endif
 136             if ((wKeyBindings[WKBD_FOCUSNEXT].keycode == ev.xkey.keycode
 137                 && wKeyBindings[WKBD_FOCUSNEXT].modifier == modifiers)
 138                 || ev.xkey.keycode == rightKey) {
 139
 140                 if (swpanel) {
 141                     newFocused = wSwitchPanelSelectNext(swpanel, False);
 142                     if (newFocused) {
 143                         wWindowFocus(newFocused, oldFocused);
 144                         oldFocused = newFocused;
 145
 146                         if (wPreferences.circ_raise) {
 147                             CommitStacking(scr);
 148                             raiseWindow(swpanel, newFocused);
 149                         }
 150                     }
 151                 }
 152             } else if ((wKeyBindings[WKBD_FOCUSPREV].keycode == ev.xkey.keycode
 153                         && wKeyBindings[WKBD_FOCUSPREV].modifier == modifiers)
 154                        || ev.xkey.keycode == leftKey) {
 155
 156                 if (swpanel) {
 157                     newFocused = wSwitchPanelSelectNext(swpanel, True);
 158                     if (newFocused) {
 159                         wWindowFocus(newFocused, oldFocused);
 160                         oldFocused = newFocused;
 161
 162                         if (wPreferences.circ_raise) {
 163                             CommitStacking(scr);
 164                             raiseWindow(swpanel, newFocused);
 165                         }
 166                     }
 167                 }
 168             } else if (ev.xkey.keycode == homeKey || ev.xkey.keycode == endKey) {
 169                 if (swpanel) {
 170                     newFocused = wSwitchPanelSelectFirst(swpanel, ev.xkey.keycode != homeKey);
 171                     if (newFocused) {
 172                         wWindowFocus(newFocused, oldFocused);
 173                         oldFocused = newFocused;
 174
 175                         if (wPreferences.circ_raise) {
 176                             CommitStacking(scr);
 177                             raiseWindow(swpanel, newFocused);
 178                         }
 179                     }
 180                 }
 181             } else if (ev.type == MotionNotify) {
 182                 WWindow *tmp;
 183                 if (swpanel) {
 184                     tmp = wSwitchPanelHandleEvent(swpanel, &ev);
 185                     if (tmp) {
 186                         newFocused = tmp;
 187                         wWindowFocus(newFocused, oldFocused);
 188                         oldFocused = newFocused;
 189                     }
 190                 }
 191             } else {
 192 #ifdef DEBUG
 193                 printf("Got something else\n");
 194 #endif
 195                 somethingElse = True;
 196                 done = True;
 197             }
 198         } else if (ev.type == KeyRelease) {
 199             int i;
 200
 201 #ifdef DEBUG
 202             printf("Got key release\n");
 203 #endif
 204             for (i = 0; i < 8 * keymap->max_keypermod; i++) {
 205                 if (keymap->modifiermap[i] == ev.xkey.keycode &&
 206                     wKeyBindings[WKBD_FOCUSNEXT].modifier
 207                     & 1<<(i/keymap->max_keypermod)) {
 208                     done = True;
 209                     break;
 210                 }
 211             }
 212         }
 213     }
 214     if (keymap)
 215         XFreeModifiermap(keymap);
 216
 217     if (hasModifier) {
 218 #ifdef DEBUG
 219         printf("Ungrabbing keyboard\n");
 220 #endif
 221         XUngrabKeyboard(dpy, CurrentTime);
 222     }
 223
 224     if (newFocused) {
 225         CommitStacking(scr);
 226         if (!newFocused->flags.mapped)
 227             wMakeWindowVisible(newFocused);
 228         wSetFocusTo(scr, newFocused);
 229         wRaiseFrame(newFocused->frame->core);
 230     }
 231
 232     if (swpanel)
 233         wSwitchPanelDestroy(swpanel);
 234
 235     scr->flags.doing_alt_tab = 0;
 236
 237     if (somethingElse)
 238         WMHandleEvent(&ev);
 239 }
 240
 241