WPrefs.app/KeyboardShortcuts.c

   1 /* KeyboardShortcuts.c- keyboard shortcut bindings
   2  *
   3  *  WPrefs - Window Maker Preferences Program
   4  *
   5  *  Copyright (c) 1998-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 "config.h"             /* for HAVE_XCONVERTCASE */
  23
  24 #include "WPrefs.h"
  25 #include <ctype.h>
  26
  27 #include <X11/keysym.h>
  28 #include <X11/XKBlib.h>
  29
  30 typedef struct _Panel {
  31         WMBox *box;
  32
  33         char *sectionName;
  34
  35         char *description;
  36
  37         CallbackRec callbacks;
  38
  39         WMWidget *parent;
  40
  41         WMLabel *actL;
  42         WMList *actLs;
  43
  44         WMFrame *shoF;
  45         WMTextField *shoT;
  46         WMButton *cleB;
  47         WMButton *defB;
  48
  49         WMLabel *instructionsL;
  50
  51         WMColor *white;
  52         WMColor *black;
  53         WMColor *gray;
  54         WMFont *font;
  55
  56         Bool capturing;
  57         char **shortcuts;
  58         int actionCount;
  59 } _Panel;
  60
  61 #define ICON_FILE       "keyshortcuts"
  62
  63 /*
  64  * List of user definable shortcut keys
  65  * First parameter is the internal keyword known by WMaker
  66  * Second is the text displayed to the user
  67  */
  68 static const struct {
  69         const char *key;
  70         const char *title;
  71 } keyOptions[] = {
  72         { "RootMenuKey",    N_("Open applications menu") },
  73         { "WindowListKey",  N_("Open window list menu") },
  74         { "WindowMenuKey",  N_("Open window commands menu") },
  75         { "HideKey",        N_("Hide active application") },
  76         { "HideOthersKey",  N_("Hide other applications") },
  77         { "MiniaturizeKey", N_("Miniaturize active window") },
  78         { "MinimizeAllKey", N_("Miniaturize all windows") },
  79         { "CloseKey",       N_("Close active window") },
  80         { "MaximizeKey",    N_("Maximize active window") },
  81         { "VMaximizeKey",   N_("Maximize active window vertically") },
  82         { "HMaximizeKey",   N_("Maximize active window horizontally") },
  83         { "LHMaximizeKey",  N_("Maximize active window left half") },
  84         { "RHMaximizeKey",  N_("Maximize active window right half") },
  85         { "THMaximizeKey",  N_("Maximize active window top half") },
  86         { "BHMaximizeKey",  N_("Maximize active window bottom half") },
  87         { "LTCMaximizeKey", N_("Maximize active window left top corner") },
  88         { "RTCMaximizeKey", N_("Maximize active window right top corner") },
  89         { "LBCMaximizeKey", N_("Maximize active window left bottom corner") },
  90         { "RBCMaximizeKey", N_("Maximize active window right bottom corner") },
  91         { "MaximusKey",     N_("Maximus: Tiled maximization ") },
  92         { "KeepOnTopKey",   N_("Toggle window on top status") },
  93         { "KeepAtBottomKey",N_("Toggle window at bottom status") },
  94         { "OmnipresentKey", N_("Toggle window omnipresent status") },
  95         { "RaiseKey",       N_("Raise active window") },
  96         { "LowerKey",       N_("Lower active window") },
  97         { "RaiseLowerKey",  N_("Raise/Lower window under mouse pointer") },
  98         { "ShadeKey",       N_("Shade active window") },
  99         { "MoveResizeKey",  N_("Move/Resize active window") },
 100         { "SelectKey",      N_("Select active window") },
 101         { "FocusNextKey",   N_("Focus next window") },
 102         { "FocusPrevKey",   N_("Focus previous window") },
 103         { "GroupNextKey",   N_("Focus next group window") },
 104         { "GroupPrevKey",   N_("Focus previous group window") },
 105
 106         /* Workspace Related */
 107         { "WorkspaceMapKey",  N_("Open workspace pager") },
 108         { "NextWorkspaceKey", N_("Switch to next workspace") },
 109         { "PrevWorkspaceKey", N_("Switch to previous workspace") },
 110         { "LastWorkspaceKey", N_("Switch to last used workspace") },
 111         { "NextWorkspaceLayerKey", N_("Switch to next ten workspaces") },
 112         { "PrevWorkspaceLayerKey", N_("Switch to previous ten workspaces") },
 113         { "Workspace1Key",  N_("Switch to workspace 1") },
 114         { "Workspace2Key",  N_("Switch to workspace 2") },
 115         { "Workspace3Key",  N_("Switch to workspace 3") },
 116         { "Workspace4Key",  N_("Switch to workspace 4") },
 117         { "Workspace5Key",  N_("Switch to workspace 5") },
 118         { "Workspace6Key",  N_("Switch to workspace 6") },
 119         { "Workspace7Key",  N_("Switch to workspace 7") },
 120         { "Workspace8Key",  N_("Switch to workspace 8") },
 121         { "Workspace9Key",  N_("Switch to workspace 9") },
 122         { "Workspace10Key", N_("Switch to workspace 10") },
 123         { "MoveToNextWorkspaceKey",      N_("Move window to next workspace") },
 124         { "MoveToPrevWorkspaceKey",      N_("Move window to previous workspace") },
 125         { "MoveToLastWorkspaceKey",      N_("Move window to last used workspace") },
 126         { "MoveToNextWorkspaceLayerKey", N_("Move window to next ten workspaces") },
 127         { "MoveToPrevWorkspaceLayerKey", N_("Move window to previous ten workspaces") },
 128         { "MoveToWorkspace1Key",  N_("Move window to workspace 1") },
 129         { "MoveToWorkspace2Key",  N_("Move window to workspace 2") },
 130         { "MoveToWorkspace3Key",  N_("Move window to workspace 3") },
 131         { "MoveToWorkspace4Key",  N_("Move window to workspace 4") },
 132         { "MoveToWorkspace5Key",  N_("Move window to workspace 5") },
 133         { "MoveToWorkspace6Key",  N_("Move window to workspace 6") },
 134         { "MoveToWorkspace7Key",  N_("Move window to workspace 7") },
 135         { "MoveToWorkspace8Key",  N_("Move window to workspace 8") },
 136         { "MoveToWorkspace9Key",  N_("Move window to workspace 9") },
 137         { "MoveToWorkspace10Key", N_("Move window to workspace 10") },
 138
 139         /* Window Selection */
 140         { "WindowShortcut1Key",  N_("Shortcut for window 1") },
 141         { "WindowShortcut2Key",  N_("Shortcut for window 2") },
 142         { "WindowShortcut3Key",  N_("Shortcut for window 3") },
 143         { "WindowShortcut4Key",  N_("Shortcut for window 4") },
 144         { "WindowShortcut5Key",  N_("Shortcut for window 5") },
 145         { "WindowShortcut6Key",  N_("Shortcut for window 6") },
 146         { "WindowShortcut7Key",  N_("Shortcut for window 7") },
 147         { "WindowShortcut8Key",  N_("Shortcut for window 8") },
 148         { "WindowShortcut9Key",  N_("Shortcut for window 9") },
 149         { "WindowShortcut10Key", N_("Shortcut for window 10") },
 150
 151         /* Head Selection */
 152         { "MoveTo12to6Head",     N_("Move to right/bottom/left/top head") },
 153         { "MoveTo6to12Head",    N_("Move to left/top/right/bottom head") },
 154
 155         /* Misc. */
 156         { "WindowRelaunchKey", N_("Launch new instance of application") },
 157         { "ScreenSwitchKey",   N_("Switch to Next Screen/Monitor") },
 158         { "RunKey",            N_("Run application") },
 159         { "ExitKey",            N_("Exit Window Maker") },
 160         { "DockRaiseLowerKey", N_("Raise/Lower Dock") },
 161         { "ClipRaiseLowerKey", N_("Raise/Lower Clip") }
 162 #ifdef XKB_MODELOCK
 163         ,{ "ToggleKbdModeKey", N_("Toggle keyboard language") }
 164 #endif                          /* XKB_MODELOCK */
 165 };
 166
 167 #ifndef HAVE_XCONVERTCASE
 168 /* from Xlib */
 169
 170 static void XConvertCase(register KeySym sym, KeySym * lower, KeySym * upper)
 171 {
 172         *lower = sym;
 173         *upper = sym;
 174         switch (sym >> 8) {
 175         case 0:         /* Latin 1 */
 176                 if ((sym >= XK_A) && (sym <= XK_Z))
 177                         *lower += (XK_a - XK_A);
 178                 else if ((sym >= XK_a) && (sym <= XK_z))
 179                         *upper -= (XK_a - XK_A);
 180                 else if ((sym >= XK_Agrave) && (sym <= XK_Odiaeresis))
 181                         *lower += (XK_agrave - XK_Agrave);
 182                 else if ((sym >= XK_agrave) && (sym <= XK_odiaeresis))
 183                         *upper -= (XK_agrave - XK_Agrave);
 184                 else if ((sym >= XK_Ooblique) && (sym <= XK_Thorn))
 185                         *lower += (XK_oslash - XK_Ooblique);
 186                 else if ((sym >= XK_oslash) && (sym <= XK_thorn))
 187                         *upper -= (XK_oslash - XK_Ooblique);
 188                 break;
 189         case 1:         /* Latin 2 */
 190                 /* Assume the KeySym is a legal value (ignore discontinuities) */
 191                 if (sym == XK_Aogonek)
 192                         *lower = XK_aogonek;
 193                 else if (sym >= XK_Lstroke && sym <= XK_Sacute)
 194                         *lower += (XK_lstroke - XK_Lstroke);
 195                 else if (sym >= XK_Scaron && sym <= XK_Zacute)
 196                         *lower += (XK_scaron - XK_Scaron);
 197                 else if (sym >= XK_Zcaron && sym <= XK_Zabovedot)
 198                         *lower += (XK_zcaron - XK_Zcaron);
 199                 else if (sym == XK_aogonek)
 200                         *upper = XK_Aogonek;
 201                 else if (sym >= XK_lstroke && sym <= XK_sacute)
 202                         *upper -= (XK_lstroke - XK_Lstroke);
 203                 else if (sym >= XK_scaron && sym <= XK_zacute)
 204                         *upper -= (XK_scaron - XK_Scaron);
 205                 else if (sym >= XK_zcaron && sym <= XK_zabovedot)
 206                         *upper -= (XK_zcaron - XK_Zcaron);
 207                 else if (sym >= XK_Racute && sym <= XK_Tcedilla)
 208                         *lower += (XK_racute - XK_Racute);
 209                 else if (sym >= XK_racute && sym <= XK_tcedilla)
 210                         *upper -= (XK_racute - XK_Racute);
 211                 break;
 212         case 2:         /* Latin 3 */
 213                 /* Assume the KeySym is a legal value (ignore discontinuities) */
 214                 if (sym >= XK_Hstroke && sym <= XK_Hcircumflex)
 215                         *lower += (XK_hstroke - XK_Hstroke);
 216                 else if (sym >= XK_Gbreve && sym <= XK_Jcircumflex)
 217                         *lower += (XK_gbreve - XK_Gbreve);
 218                 else if (sym >= XK_hstroke && sym <= XK_hcircumflex)
 219                         *upper -= (XK_hstroke - XK_Hstroke);
 220                 else if (sym >= XK_gbreve && sym <= XK_jcircumflex)
 221                         *upper -= (XK_gbreve - XK_Gbreve);
 222                 else if (sym >= XK_Cabovedot && sym <= XK_Scircumflex)
 223                         *lower += (XK_cabovedot - XK_Cabovedot);
 224                 else if (sym >= XK_cabovedot && sym <= XK_scircumflex)
 225                         *upper -= (XK_cabovedot - XK_Cabovedot);
 226                 break;
 227         case 3:         /* Latin 4 */
 228                 /* Assume the KeySym is a legal value (ignore discontinuities) */
 229                 if (sym >= XK_Rcedilla && sym <= XK_Tslash)
 230                         *lower += (XK_rcedilla - XK_Rcedilla);
 231                 else if (sym >= XK_rcedilla && sym <= XK_tslash)
 232                         *upper -= (XK_rcedilla - XK_Rcedilla);
 233                 else if (sym == XK_ENG)
 234                         *lower = XK_eng;
 235                 else if (sym == XK_eng)
 236                         *upper = XK_ENG;
 237                 else if (sym >= XK_Amacron && sym <= XK_Umacron)
 238                         *lower += (XK_amacron - XK_Amacron);
 239                 else if (sym >= XK_amacron && sym <= XK_umacron)
 240                         *upper -= (XK_amacron - XK_Amacron);
 241                 break;
 242         case 6:         /* Cyrillic */
 243                 /* Assume the KeySym is a legal value (ignore discontinuities) */
 244                 if (sym >= XK_Serbian_DJE && sym <= XK_Serbian_DZE)
 245                         *lower -= (XK_Serbian_DJE - XK_Serbian_dje);
 246                 else if (sym >= XK_Serbian_dje && sym <= XK_Serbian_dze)
 247                         *upper += (XK_Serbian_DJE - XK_Serbian_dje);
 248                 else if (sym >= XK_Cyrillic_YU && sym <= XK_Cyrillic_HARDSIGN)
 249                         *lower -= (XK_Cyrillic_YU - XK_Cyrillic_yu);
 250                 else if (sym >= XK_Cyrillic_yu && sym <= XK_Cyrillic_hardsign)
 251                         *upper += (XK_Cyrillic_YU - XK_Cyrillic_yu);
 252                 break;
 253         case 7:         /* Greek */
 254                 /* Assume the KeySym is a legal value (ignore discontinuities) */
 255                 if (sym >= XK_Greek_ALPHAaccent && sym <= XK_Greek_OMEGAaccent)
 256                         *lower += (XK_Greek_alphaaccent - XK_Greek_ALPHAaccent);
 257                 else if (sym >= XK_Greek_alphaaccent && sym <= XK_Greek_omegaaccent &&
 258                          sym != XK_Greek_iotaaccentdieresis && sym != XK_Greek_upsilonaccentdieresis)
 259                         *upper -= (XK_Greek_alphaaccent - XK_Greek_ALPHAaccent);
 260                 else if (sym >= XK_Greek_ALPHA && sym <= XK_Greek_OMEGA)
 261                         *lower += (XK_Greek_alpha - XK_Greek_ALPHA);
 262                 else if (sym >= XK_Greek_alpha && sym <= XK_Greek_omega && sym != XK_Greek_finalsmallsigma)
 263                         *upper -= (XK_Greek_alpha - XK_Greek_ALPHA);
 264                 break;
 265         case 0x14:              /* Armenian */
 266                 if (sym >= XK_Armenian_AYB && sym <= XK_Armenian_fe) {
 267                         *lower = sym | 1;
 268                         *upper = sym & ~1;
 269                 }
 270                 break;
 271         }
 272 }
 273 #endif
 274
 275 static int NumLockMask(Display *dpy)
 276 {
 277         int i, mask;
 278         XModifierKeymap *map;
 279         static int mask_table[8] = {
 280                 ShiftMask, LockMask, ControlMask, Mod1Mask,
 281                 Mod2Mask, Mod3Mask, Mod4Mask, Mod5Mask
 282         };
 283         KeyCode numlock_keycode = XKeysymToKeycode(dpy, XK_Num_Lock);
 284
 285         if (numlock_keycode == NoSymbol)
 286                 return 0;
 287
 288         map = XGetModifierMapping(dpy);
 289         if (!map)
 290                 return 0;
 291
 292         mask = 0;
 293         for (i = 0; i < 8 * map->max_keypermod; i++) {
 294                 if (map->modifiermap[i] == numlock_keycode && mask == 0) {
 295                         mask = mask_table[i/map->max_keypermod];
 296                         break;
 297                 }
 298         }
 299
 300         if (map)
 301                 XFreeModifiermap(map);
 302
 303         return mask;
 304 }
 305
 306 char *capture_shortcut(Display *dpy, Bool *capturing, Bool convert_case)
 307 {
 308         XEvent ev;
 309         KeySym ksym, lksym, uksym;
 310         char buffer[64];
 311         char *key = NULL;
 312         unsigned int numlock_mask;
 313
 314         while (*capturing) {
 315                 XAllowEvents(dpy, AsyncKeyboard, CurrentTime);
 316                 WMNextEvent(dpy, &ev);
 317                 if (ev.type == KeyPress && ev.xkey.keycode != 0) {
 318                         numlock_mask = NumLockMask(dpy);
 319
 320                         if (xext_xkb_supported)
 321                                 /* conditional mask check to get numeric keypad keys */
 322                                 ksym = XkbKeycodeToKeysym(dpy, ev.xkey.keycode, 0, ev.xkey.state & numlock_mask?1:0);
 323                         else
 324                                 ksym = XKeycodeToKeysym(dpy, ev.xkey.keycode, ev.xkey.state & numlock_mask?1:0);
 325
 326                         if (!IsModifierKey(ksym)) {
 327                                 if (convert_case) {
 328                                         XConvertCase(ksym, &lksym, &uksym);
 329                                         key = XKeysymToString(uksym);
 330                                 } else {
 331                                         key = XKeysymToString(ksym);
 332                                 }
 333
 334                                 *capturing = 0;
 335                                 break;
 336                         }
 337                 }
 338                 WMHandleEvent(&ev);
 339         }
 340
 341         if (!key)
 342                 return NULL;
 343
 344         buffer[0] = 0;
 345
 346         if (ev.xkey.state & ControlMask)
 347                 strcat(buffer, "Control+");
 348
 349         if (ev.xkey.state & ShiftMask)
 350                 strcat(buffer, "Shift+");
 351
 352         if ((numlock_mask != Mod1Mask) && (ev.xkey.state & Mod1Mask))
 353                 strcat(buffer, "Mod1+");
 354
 355         if ((numlock_mask != Mod2Mask) && (ev.xkey.state & Mod2Mask))
 356                 strcat(buffer, "Mod2+");
 357
 358         if ((numlock_mask != Mod3Mask) && (ev.xkey.state & Mod3Mask))
 359                 strcat(buffer, "Mod3+");
 360
 361         if ((numlock_mask != Mod4Mask) && (ev.xkey.state & Mod4Mask))
 362                 strcat(buffer, "Mod4+");
 363
 364         if ((numlock_mask != Mod5Mask) && (ev.xkey.state & Mod5Mask))
 365                 strcat(buffer, "Mod5+");
 366
 367         wstrlcat(buffer, key, sizeof(buffer));
 368
 369         return wstrdup(buffer);
 370 }
 371
 372 /*
 373  * check if the keystr entered is already set to another action
 374  * if found it returns the position in the keyOptions
 375  */
 376 static int isKeySet(_Panel *panel, char *keystr)
 377 {
 378         int i;
 379         char *str;
 380
 381         for (i = 0; i < panel->actionCount; i++) {
 382                 str = NULL;
 383                 if (panel->shortcuts[i]) {
 384                         str = wtrimspace(panel->shortcuts[i]);
 385                         if (strlen(str) == 0) {
 386                                 wfree(str);
 387                                 str = NULL;
 388                         }
 389                 }
 390                 if (str) {
 391                         if (strcmp(keystr, str) == 0) {
 392                                 wfree(str);
 393                                 return i;
 394                         }
 395                         wfree(str);
 396                 }
 397         }
 398
 399         return -1;
 400 }
 401
 402 static void captureClick(WMWidget * w, void *data)
 403 {
 404         _Panel *panel = (_Panel *) data;
 405         Display *dpy = WMScreenDisplay(WMWidgetScreen(panel->parent));
 406         char *shortcut;
 407
 408         if (!panel->capturing) {
 409                 panel->capturing = 1;
 410                 WMSetButtonText(w, _("Cancel"));
 411                 WMSetLabelText(panel->instructionsL,
 412                                _("Press the desired shortcut key(s) or click Cancel to stop capturing."));
 413                 XGrabKeyboard(dpy, WMWidgetXID(panel->parent), True, GrabModeAsync, GrabModeAsync, CurrentTime);
 414                 shortcut = capture_shortcut(dpy, &panel->capturing, 1);
 415                 if (shortcut) {
 416                         int key_idx = -1;
 417                         int row = WMGetListSelectedItemRow(panel->actLs);
 418
 419                         key_idx = isKeySet(panel, shortcut);
 420                         if (key_idx >= 0 && (key_idx != row)) {
 421                                 char *msg;
 422
 423                                 msg = wstrconcat(_("Key shortcut already in use by the "), _(keyOptions[key_idx].title));
 424                                 WMRunAlertPanel(WMWidgetScreen(w), GetWindow(),
 425                                                 _("Error"),
 426                                                 msg,
 427                                                 _("OK"), NULL, NULL);
 428                                 wfree(msg);
 429                                 wfree(shortcut);
 430                         } else {
 431                                 WMSetTextFieldText(panel->shoT, shortcut);
 432                                 if (row >= 0) {
 433                                         if (panel->shortcuts[row])
 434                                                 wfree(panel->shortcuts[row]);
 435                                         panel->shortcuts[row] = shortcut;
 436
 437                                         WMRedisplayWidget(panel->actLs);
 438                                 } else {
 439                                         wfree(shortcut);
 440                                 }
 441                         }
 442                 }
 443         }
 444         panel->capturing = 0;
 445         WMSetButtonText(w, _("Capture"));
 446         WMSetLabelText(panel->instructionsL, _("Click on Capture to interactively define the shortcut key."));
 447         XUngrabKeyboard(dpy, CurrentTime);
 448 }
 449
 450 static void clearShortcut(WMWidget * w, void *data)
 451 {
 452         _Panel *panel = (_Panel *) data;
 453         int row = WMGetListSelectedItemRow(panel->actLs);
 454
 455         /* Parameter not used, but tell the compiler that it is ok */
 456         (void) w;
 457
 458         WMSetTextFieldText(panel->shoT, NULL);
 459
 460         if (row >= 0) {
 461                 if (panel->shortcuts[row])
 462                         wfree(panel->shortcuts[row]);
 463                 panel->shortcuts[row] = NULL;
 464                 WMRedisplayWidget(panel->actLs);
 465         }
 466 }
 467
 468 static void typedKeys(void *observerData, WMNotification * notification)
 469 {
 470         _Panel *panel = (_Panel *) observerData;
 471         int row = WMGetListSelectedItemRow(panel->actLs);
 472
 473         /* Parameter not used, but tell the compiler that it is ok */
 474         (void) notification;
 475
 476         if (row < 0)
 477                 return;
 478
 479         if (panel->shortcuts[row])
 480                 wfree(panel->shortcuts[row]);
 481         panel->shortcuts[row] = WMGetTextFieldText(panel->shoT);
 482         if (strlen(panel->shortcuts[row]) == 0) {
 483                 wfree(panel->shortcuts[row]);
 484                 panel->shortcuts[row] = NULL;
 485         }
 486         WMRedisplayWidget(panel->actLs);
 487 }
 488
 489 static void listClick(WMWidget * w, void *data)
 490 {
 491         _Panel *panel = (_Panel *) data;
 492         int row = WMGetListSelectedItemRow(w);
 493
 494         WMSetTextFieldText(panel->shoT, panel->shortcuts[row]);
 495 }
 496
 497 static void showData(_Panel * panel)
 498 {
 499         char *str;
 500         int i;
 501
 502         for (i = 0; i < panel->actionCount; i++) {
 503
 504                 str = GetStringForKey(keyOptions[i].key);
 505                 if (panel->shortcuts[i])
 506                         wfree(panel->shortcuts[i]);
 507                 if (str)
 508                         panel->shortcuts[i] = wtrimspace(str);
 509                 else
 510                         panel->shortcuts[i] = NULL;
 511
 512                 if (panel->shortcuts[i] &&
 513                     (strcasecmp(panel->shortcuts[i], "none") == 0 || strlen(panel->shortcuts[i]) == 0)) {
 514                         wfree(panel->shortcuts[i]);
 515                         panel->shortcuts[i] = NULL;
 516                 }
 517         }
 518         WMRedisplayWidget(panel->actLs);
 519 }
 520
 521 static void paintItem(WMList * lPtr, int index, Drawable d, char *text, int state, WMRect * rect)
 522 {
 523         int width, height, x, y;
 524         _Panel *panel = (_Panel *) WMGetHangedData(lPtr);
 525         WMScreen *scr = WMWidgetScreen(lPtr);
 526         Display *dpy = WMScreenDisplay(scr);
 527         WMColor *backColor = (state & WLDSSelected) ? panel->white : panel->gray;
 528
 529         width = rect->size.width;
 530         height = rect->size.height;
 531         x = rect->pos.x;
 532         y = rect->pos.y;
 533
 534         XFillRectangle(dpy, d, WMColorGC(backColor), x, y, width, height);
 535
 536         if (panel->shortcuts[index]) {
 537                 WMPixmap *pix = WMGetSystemPixmap(scr, WSICheckMark);
 538                 WMSize size = WMGetPixmapSize(pix);
 539
 540                 WMDrawPixmap(pix, d, x + (20 - size.width) / 2, (height - size.height) / 2 + y);
 541                 WMReleasePixmap(pix);
 542         }
 543
 544         WMDrawString(scr, d, panel->black, panel->font, x + 20, y, text, strlen(text));
 545 }
 546
 547 static void createPanel(Panel * p)
 548 {
 549         _Panel *panel = (_Panel *) p;
 550         WMScreen *scr = WMWidgetScreen(panel->parent);
 551         WMColor *color;
 552         WMFont *boldFont;
 553         int i;
 554
 555         panel->capturing = 0;
 556
 557         panel->white = WMWhiteColor(scr);
 558         panel->black = WMBlackColor(scr);
 559         panel->gray = WMGrayColor(scr);
 560         panel->font = WMSystemFontOfSize(scr, 12);
 561
 562         panel->box = WMCreateBox(panel->parent);
 563         WMSetViewExpandsToParent(WMWidgetView(panel->box), 2, 2, 2, 2);
 564
 565         boldFont = WMBoldSystemFontOfSize(scr, 12);
 566
 567         /* **************** Actions **************** */
 568         panel->actL = WMCreateLabel(panel->box);
 569         WMResizeWidget(panel->actL, 314, 20);
 570         WMMoveWidget(panel->actL, 9, 9);
 571         WMSetLabelFont(panel->actL, boldFont);
 572         WMSetLabelText(panel->actL, _("Actions"));
 573         WMSetLabelRelief(panel->actL, WRSunken);
 574         WMSetLabelTextAlignment(panel->actL, WACenter);
 575         color = WMDarkGrayColor(scr);
 576         WMSetWidgetBackgroundColor(panel->actL, color);
 577         WMReleaseColor(color);
 578         WMSetLabelTextColor(panel->actL, panel->white);
 579
 580         panel->actLs = WMCreateList(panel->box);
 581         WMResizeWidget(panel->actLs, 314, 191);
 582         WMMoveWidget(panel->actLs, 9, 31);
 583         WMSetListUserDrawProc(panel->actLs, paintItem);
 584         WMHangData(panel->actLs, panel);
 585
 586         for (i = 0; i < wlengthof(keyOptions); i++) {
 587                 WMAddListItem(panel->actLs, _(keyOptions[i].title));
 588         }
 589         WMSetListAction(panel->actLs, listClick, panel);
 590
 591         panel->actionCount = WMGetListNumberOfRows(panel->actLs);
 592         panel->shortcuts = wmalloc(sizeof(char *) * panel->actionCount);
 593
 594     /***************** Shortcut ****************/
 595
 596         panel->shoF = WMCreateFrame(panel->box);
 597         WMResizeWidget(panel->shoF, 178, 214);
 598         WMMoveWidget(panel->shoF, 333, 8);
 599         WMSetFrameTitle(panel->shoF, _("Shortcut"));
 600
 601         panel->shoT = WMCreateTextField(panel->shoF);
 602         WMResizeWidget(panel->shoT, 160, 20);
 603         WMMoveWidget(panel->shoT, 9, 65);
 604         WMAddNotificationObserver(typedKeys, panel, WMTextDidChangeNotification, panel->shoT);
 605
 606         panel->cleB = WMCreateCommandButton(panel->shoF);
 607         WMResizeWidget(panel->cleB, 75, 24);
 608         WMMoveWidget(panel->cleB, 9, 95);
 609         WMSetButtonText(panel->cleB, _("Clear"));
 610         WMSetButtonAction(panel->cleB, clearShortcut, panel);
 611
 612         panel->defB = WMCreateCommandButton(panel->shoF);
 613         WMResizeWidget(panel->defB, 75, 24);
 614         WMMoveWidget(panel->defB, 94, 95);
 615         WMSetButtonText(panel->defB, _("Capture"));
 616         WMSetButtonAction(panel->defB, captureClick, panel);
 617
 618         panel->instructionsL = WMCreateLabel(panel->shoF);
 619         WMResizeWidget(panel->instructionsL, 160, 55);
 620         WMMoveWidget(panel->instructionsL, 9, 140);
 621         WMSetLabelTextAlignment(panel->instructionsL, WACenter);
 622         WMSetLabelWraps(panel->instructionsL, True);
 623         WMSetLabelText(panel->instructionsL, _("Click on Capture to interactively define the shortcut key."));
 624
 625         WMMapSubwidgets(panel->shoF);
 626
 627         WMReleaseFont(boldFont);
 628
 629         WMRealizeWidget(panel->box);
 630         WMMapSubwidgets(panel->box);
 631
 632         showData(panel);
 633 }
 634
 635 static void storeData(_Panel * panel)
 636 {
 637         int i;
 638         char *str;
 639
 640         for (i = 0; i < panel->actionCount; i++) {
 641                 str = NULL;
 642                 if (panel->shortcuts[i]) {
 643                         str = wtrimspace(panel->shortcuts[i]);
 644                         if (strlen(str) == 0) {
 645                                 wfree(str);
 646                                 str = NULL;
 647                         }
 648                 }
 649                 if (str) {
 650                         SetStringForKey(str, keyOptions[i].key);
 651                         wfree(str);
 652                 } else {
 653                         SetStringForKey("None", keyOptions[i].key);
 654                 }
 655         }
 656 }
 657
 658 Panel *InitKeyboardShortcuts(WMWidget *parent)
 659 {
 660         _Panel *panel;
 661
 662         panel = wmalloc(sizeof(_Panel));
 663
 664         panel->sectionName = _("Keyboard Shortcut Preferences");
 665
 666         panel->description = _("Change the keyboard shortcuts for actions such\n"
 667                                "as changing workspaces and opening menus.");
 668
 669         panel->parent = parent;
 670
 671         panel->callbacks.createWidgets = createPanel;
 672         panel->callbacks.updateDomain = storeData;
 673
 674         AddSection(panel, ICON_FILE);
 675
 676         return panel;
 677 }