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