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 along
  18  *  with this program; if not, write to the Free Software Foundation, Inc.,
  19  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "wconfig.h"
  23
  24 #include <stdlib.h>
  25 #include <X11/Xlib.h>
  26 #include <X11/Xutil.h>
  27 #include <X11/keysym.h>
  28
  29 #include "WindowMaker.h"
  30 #include "GNUstep.h"
  31 #include "screen.h"
  32 #include "window.h"
  33 #include "framewin.h"
  34 #include "keybind.h"
  35 #include "actions.h"
  36 #include "stacking.h"
  37 #include "funcs.h"
  38 #include "xinerama.h"
  39 #include "switchpanel.h"
  40
  41 /* Globals */
  42 extern WPreferences wPreferences;
  43
  44 extern WShortKey wKeyBindings[WKBD_LAST];
  45
  46 static void raiseWindow(WSwitchPanel * swpanel, WWindow * wwin)
  47 {
  48         Window swwin = wSwitchPanelGetWindow(swpanel);
  49
  50         if (wwin->flags.mapped) {
  51                 if (swwin != None) {
  52                         Window win[2];
  53
  54                         win[0] = swwin;
  55                         win[1] = wwin->frame->core->window;
  56
  57                         XRestackWindows(dpy, win, 2);
  58                 } else
  59                         XRaiseWindow(dpy, wwin->frame->core->window);
  60         }
  61 }
  62
  63 static WWindow *change_focus_and_raise(WWindow *newFocused, WWindow *oldFocused,
  64                                        WSwitchPanel *swpanel, WScreen *scr, Bool esc_cancel)
  65 {
  66         if (!newFocused)
  67                 return oldFocused;
  68
  69         wWindowFocus(newFocused, oldFocused);
  70         oldFocused = newFocused;
  71
  72         if (wPreferences.circ_raise) {
  73                 CommitStacking(scr);
  74
  75                 if (!esc_cancel)
  76                         raiseWindow(swpanel, newFocused);
  77         }
  78
  79         return oldFocused;
  80 }
  81
  82 void StartWindozeCycle(WWindow * wwin, XEvent * event, Bool next, Bool class_only)
  83 {
  84
  85         XModifierKeymap *keymap        = NULL;
  86         WSwitchPanel    *swpanel       = NULL;
  87         WScreen         *scr           = wScreenForRootWindow(event->xkey.root);
  88         KeyCode         leftKey        = XKeysymToKeycode(dpy, XK_Left);
  89         KeyCode         rightKey       = XKeysymToKeycode(dpy, XK_Right);
  90         KeyCode         homeKey        = XKeysymToKeycode(dpy, XK_Home);
  91         KeyCode         endKey         = XKeysymToKeycode(dpy, XK_End);
  92         KeyCode         shiftLKey      = XKeysymToKeycode(dpy, XK_Shift_L);
  93         KeyCode         shiftRKey      = XKeysymToKeycode(dpy, XK_Shift_R);
  94         KeyCode         escapeKey      = XKeysymToKeycode(dpy, XK_Escape);
  95         Bool            esc_cancel     = False;
  96         Bool            somethingElse  = False;
  97         Bool            done           = False;
  98         Bool            hasModifier;
  99         int             modifiers;
 100         WWindow         *newFocused;
 101         WWindow         *oldFocused;
 102         XEvent          ev;
 103
 104
 105         if (!wwin)
 106                 return;
 107
 108         if (next) {
 109                 if (class_only)
 110                         hasModifier = (wKeyBindings[WKBD_GROUPNEXT].modifier != 0);
 111                 else
 112                         hasModifier = (wKeyBindings[WKBD_FOCUSNEXT].modifier != 0);
 113         } else {
 114                 if (class_only)
 115                         hasModifier = (wKeyBindings[WKBD_GROUPPREV].modifier != 0);
 116                 else
 117                         hasModifier = (wKeyBindings[WKBD_FOCUSPREV].modifier != 0);
 118         }
 119
 120         if (hasModifier) {
 121                 keymap = XGetModifierMapping(dpy);
 122                 XGrabKeyboard(dpy, scr->root_win, False, GrabModeAsync, GrabModeAsync, CurrentTime);
 123         }
 124
 125         scr->flags.doing_alt_tab = 1;
 126
 127         swpanel = wInitSwitchPanel(scr, wwin, class_only);
 128         oldFocused = wwin;
 129
 130         if (swpanel) {
 131
 132                 if (wwin->flags.mapped)
 133                         newFocused = wSwitchPanelSelectNext(swpanel, !next, True, False);
 134                 else
 135                         newFocused = wSwitchPanelSelectFirst(swpanel, False);
 136
 137                 oldFocused = change_focus_and_raise(newFocused, oldFocused, swpanel, scr, False);
 138         } else {
 139                 if (wwin->frame->workspace == scr->current_workspace)
 140                         newFocused = wwin;
 141                 else
 142                         newFocused = NULL;
 143         }
 144
 145         while (hasModifier && !done) {
 146                 int i;
 147
 148                 WMMaskEvent(dpy, KeyPressMask | KeyReleaseMask | ExposureMask
 149                             | PointerMotionMask | ButtonReleaseMask | EnterWindowMask, &ev);
 150
 151                 /* ignore CapsLock */
 152                 modifiers = ev.xkey.state & ValidModMask;
 153
 154                 if (!swpanel)
 155                         done = True;
 156
 157                 switch (ev.type) {
 158
 159                 case KeyPress:
 160
 161                         if ((wKeyBindings[WKBD_FOCUSNEXT].keycode == ev.xkey.keycode
 162                              && wKeyBindings[WKBD_FOCUSNEXT].modifier == modifiers)
 163                             || (wKeyBindings[WKBD_GROUPNEXT].keycode == ev.xkey.keycode
 164                             && wKeyBindings[WKBD_GROUPNEXT].modifier == modifiers)
 165                             || ev.xkey.keycode == rightKey) {
 166
 167                                 newFocused = wSwitchPanelSelectNext(swpanel, False, ev.xkey.keycode != rightKey, (!class_only && wKeyBindings[WKBD_GROUPNEXT].keycode == ev.xkey.keycode && wKeyBindings[WKBD_GROUPNEXT].modifier == modifiers));
 168                                 oldFocused = change_focus_and_raise(newFocused, oldFocused, swpanel, scr, False);
 169
 170                         } else if ((wKeyBindings[WKBD_FOCUSPREV].keycode == ev.xkey.keycode
 171                                     && wKeyBindings[WKBD_FOCUSPREV].modifier == modifiers)
 172                             || (wKeyBindings[WKBD_GROUPPREV].keycode == ev.xkey.keycode
 173                             && wKeyBindings[WKBD_GROUPPREV].modifier == modifiers)
 174                                    || ev.xkey.keycode == leftKey) {
 175
 176                                 newFocused = wSwitchPanelSelectNext(swpanel, True, ev.xkey.keycode != leftKey, (!class_only && wKeyBindings[WKBD_GROUPPREV].keycode == ev.xkey.keycode && wKeyBindings[WKBD_GROUPPREV].modifier == modifiers));
 177                                 oldFocused = change_focus_and_raise(newFocused, oldFocused, swpanel, scr, False);
 178
 179                         } else if (ev.xkey.keycode == homeKey || ev.xkey.keycode == endKey) {
 180
 181                                 newFocused = wSwitchPanelSelectFirst(swpanel, ev.xkey.keycode != homeKey);
 182                                 oldFocused = change_focus_and_raise(newFocused, oldFocused, swpanel, scr, False);
 183
 184                         } else if (ev.xkey.keycode == escapeKey) {
 185
 186                                 /* Focus the first window of the swpanel, despite the 'False' */
 187                                 newFocused = wSwitchPanelSelectFirst(swpanel, False);
 188                                 oldFocused = change_focus_and_raise(newFocused, oldFocused, swpanel, scr, True);
 189                                 esc_cancel = True;
 190                                 done = True;
 191
 192                         } else if (ev.xkey.keycode != shiftLKey && ev.xkey.keycode != shiftRKey) {
 193
 194                                 somethingElse = True;
 195                                 done = True;
 196                         }
 197                         break;
 198
 199                 case KeyRelease:
 200
 201                         if (ev.xkey.keycode == shiftLKey || ev.xkey.keycode == shiftRKey)
 202                                 if (wPreferences.strict_windoze_cycle)
 203                                         break;
 204
 205                         for (i = 0; i < 8 * keymap->max_keypermod; i++) {
 206
 207                                 int mask = 1 << (i / keymap->max_keypermod);
 208
 209                                 if (keymap->modifiermap[i] == ev.xkey.keycode &&
 210                                     ((wKeyBindings[WKBD_FOCUSNEXT].modifier & mask)
 211                                      || (wKeyBindings[WKBD_FOCUSPREV].modifier & mask)
 212                                      || (wKeyBindings[WKBD_GROUPNEXT].modifier & mask)
 213                                      || (wKeyBindings[WKBD_GROUPPREV].modifier & mask))) {
 214                                         done = True;
 215                                         break;
 216                                 }
 217                         }
 218                         break;
 219
 220                 case EnterNotify:
 221
 222                         /* ignore unwanted EnterNotify's */
 223                         break;
 224
 225                 case LeaveNotify:
 226                 case MotionNotify:
 227
 228                 case ButtonRelease:
 229                         {
 230                                 WWindow *tmp;
 231                                 tmp = wSwitchPanelHandleEvent(swpanel, &ev);
 232                                 if (tmp) {
 233                                         newFocused = tmp;
 234                                         oldFocused = change_focus_and_raise(newFocused, oldFocused, swpanel, scr, False);
 235
 236                                         if (ev.type == ButtonRelease)
 237                                                 done = True;
 238                                 }
 239                         }
 240                         break;
 241
 242                 default:
 243                         WMHandleEvent(&ev);
 244                         break;
 245                 }
 246         }
 247         if (keymap)
 248                 XFreeModifiermap(keymap);
 249
 250         if (hasModifier) {
 251
 252                 XUngrabKeyboard(dpy, CurrentTime);
 253         }
 254
 255         if (swpanel)
 256                 wSwitchPanelDestroy(swpanel);
 257
 258         if (newFocused && !esc_cancel) {
 259                 wRaiseFrame(newFocused->frame->core);
 260                 CommitStacking(scr);
 261                 if (!newFocused->flags.mapped)
 262                         wMakeWindowVisible(newFocused);
 263                 wSetFocusTo(scr, newFocused);
 264         }
 265
 266         scr->flags.doing_alt_tab = 0;
 267
 268         if (somethingElse)
 269                 WMHandleEvent(&ev);
 270 }