src/usermenu.c

   1 /* usermenu.c- user defined menu
   2  *
   3  *  Window Maker window manager
   4  *
   5  *  Copyright (c) hmmm... Should I put everybody's name here?
   6  *  Where's my lawyer?? -- ]d :D
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License along
  19  *  with this program; if not, write to the Free Software Foundation, Inc.,
  20  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21  *
  22  * * * * * * * * *
  23  * User defined menu is good, but beer's always better
  24  * if someone wanna start hacking something, He heard...
  25  * TODO
  26  *  - enhance commands. (eg, exit, hide, list all app's member
  27  *    window and etc)
  28  *  - cache menu... dunno.. if people really use this feature :P
  29  *  - Violins, senseless violins!
  30  *  that's all, right now :P
  31  *  - external! WINGs menu editor.
  32  *  TODONOT
  33  *  - allow applications to share their menu. ] think it
  34  *    looks weird since there still are more than 1 appicon.
  35  *
  36  *  Syntax...
  37  *  (
  38  *    "Program Name",
  39  *    ("Command 1", SHORTCUT, 1),
  40  *    ("Command 2", SHORTCUT, 2, ("Allowed_instant_1", "Allowed_instant_2")),
  41  *    ("Command 3", SHORTCUT, (3,4,5), ("Allowed_instant_1")),
  42  *    (
  43  *      "Submenu",
  44  *      ("Kill Command", KILL),
  45  *      ("Hide Command", HIDE),
  46  *      ("Hide Others Command", HIDE_OTHERS),
  47  *      ("Members", MEMBERS),
  48  *      ("Exit Command", EXIT)
  49  *    )
  50  *  )
  51  *
  52  *  Tips:
  53  *  - If you don't want short cut keys to be listed
  54  *    in the right side of entries, you can just put them
  55  *    in array instead of using the string directly.
  56  *
  57  */
  58
  59 #include "wconfig.h"
  60
  61 #ifdef USER_MENU
  62
  63 #include <X11/Xlib.h>
  64 #include <X11/Xutil.h>
  65 #include <X11/Xproto.h>
  66 #include <X11/Xatom.h>
  67 #include <stdlib.h>
  68 #include <string.h>
  69 #include <stdio.h>
  70 #include <unistd.h>
  71
  72 #include "WindowMaker.h"
  73 #include "menu.h"
  74 #include "actions.h"
  75 #include "keybind.h"
  76 #include "xmodifier.h"
  77 #include "misc.h"
  78
  79 #include "framewin.h"
  80
  81 #define MAX_SHORTCUT_LENGTH 32
  82
  83
  84 typedef struct {
  85         WScreen *screen;
  86         WShortKey *key;
  87         int key_no;
  88 } WUserMenuData;
  89
  90 static void notifyClient(WMenu *menu, WMenuEntry *entry)
  91 {
  92         XEvent event;
  93         WUserMenuData *data = entry->clientdata;
  94         WScreen *scr = data->screen;
  95         Window window;
  96         int i;
  97
  98         (void) menu;
  99
 100         window = scr->focused_window->client_win;
 101
 102         for (i = 0; i < data->key_no; i++) {
 103                 event.xkey.type = KeyPress;
 104                 event.xkey.display = dpy;
 105                 event.xkey.window = window;
 106                 event.xkey.root = DefaultRootWindow(dpy);
 107                 event.xkey.subwindow = (Window) None;
 108                 event.xkey.x = 0x0;
 109                 event.xkey.y = 0x0;
 110                 event.xkey.x_root = 0x0;
 111                 event.xkey.y_root = 0x0;
 112                 event.xkey.keycode = data->key[i].keycode;
 113                 event.xkey.state = data->key[i].modifier;
 114                 event.xkey.same_screen = True;
 115                 event.xkey.time = CurrentTime;
 116                 if (XSendEvent(dpy, window, False, KeyPressMask, &event)) {
 117                         event.xkey.type = KeyRelease;
 118                         event.xkey.time = CurrentTime;
 119                         XSendEvent(dpy, window, True, KeyReleaseMask, &event);
 120                 }
 121         }
 122 }
 123
 124 static void removeUserMenudata(void *menudata)
 125 {
 126         WUserMenuData *data = menudata;
 127         if (data->key)
 128                 wfree(data->key);
 129
 130         wfree(data);
 131 }
 132
 133 static WUserMenuData *convertShortcuts(WScreen *scr, WMPropList *shortcut)
 134 {
 135         WUserMenuData *data;
 136         KeySym ksym;
 137         char *k, buf[MAX_SHORTCUT_LENGTH], *b;
 138         int keycount, i, j, mod;
 139
 140         if (WMIsPLString(shortcut))
 141                 keycount = 1;
 142         else if (WMIsPLArray(shortcut))
 143                 keycount = WMGetPropListItemCount(shortcut);
 144         else
 145                 return NULL;
 146
 147         data = wmalloc(sizeof(WUserMenuData));
 148         if (!data)
 149                 return NULL;
 150
 151         data->key = wmalloc(sizeof(WShortKey) * keycount);
 152         if (!data->key) {
 153                 wfree(data);
 154                 return NULL;
 155         }
 156
 157         for (i = 0, j = 0; i < keycount; i++) {
 158                 data->key[j].modifier = 0;
 159                 if (WMIsPLArray(shortcut))
 160                         wstrlcpy(buf, WMGetFromPLString(WMGetFromPLArray(shortcut, i)), MAX_SHORTCUT_LENGTH);
 161                 else
 162                         wstrlcpy(buf, WMGetFromPLString(shortcut), MAX_SHORTCUT_LENGTH);
 163
 164                 b = (char *) buf;
 165
 166                 while ((k = strchr(b, '+')) != NULL) {
 167                         *k = 0;
 168                         mod = wXModifierFromKey(b);
 169                         if (mod < 0)
 170                                 break;
 171
 172                         data->key[j].modifier |= mod;
 173                         b = k + 1;
 174                 }
 175
 176                 ksym = XStringToKeysym(b);
 177                 if (ksym == NoSymbol)
 178                         continue;
 179
 180                 data->key[j].keycode = XKeysymToKeycode(dpy, ksym);
 181                 if (data->key[j].keycode)
 182                         j++;
 183         }
 184
 185         /* get key */
 186         if (!j) {
 187                 puts("fatal j");
 188                 wfree(data->key);
 189                 wfree(data);
 190                 return NULL;
 191         }
 192
 193         data->key_no = j;
 194         data->screen = scr;
 195
 196         return data;
 197 }
 198
 199 static WMenu *configureUserMenu(WScreen *scr, WMPropList *plum)
 200 {
 201         char *mtitle;
 202         WMenu *menu = NULL;
 203         WMPropList *elem, *title, *command, *params = NULL;
 204         int count, i;
 205         WUserMenuData *data;
 206
 207         if (!plum)
 208                 return NULL;
 209
 210         if (!WMIsPLArray(plum))
 211                 return NULL;
 212
 213         count = WMGetPropListItemCount(plum);
 214         if (!count)
 215                 return NULL;
 216
 217         elem = WMGetFromPLArray(plum, 0);
 218         if (!WMIsPLString(elem))
 219                 return NULL;
 220
 221         mtitle = WMGetFromPLString(elem);
 222         menu = wMenuCreateForApp(scr, mtitle, True);
 223
 224         for (i = 1; i < count; i++) {
 225                 elem = WMGetFromPLArray(plum, i);
 226                 if (WMIsPLArray(WMGetFromPLArray(elem, 1))) {
 227                         WMenu *submenu;
 228                         WMenuEntry *mentry = NULL;
 229
 230                         submenu = configureUserMenu(scr, elem);
 231                         if (submenu)
 232                                 mentry = wMenuAddCallback(menu, submenu->frame->title, NULL, NULL);
 233
 234                         wMenuEntrySetCascade(menu, mentry, submenu);
 235                 } else {
 236                         int idx = 0;
 237                         WMPropList *instances = 0;
 238
 239                         title = WMGetFromPLArray(elem, idx++);
 240                         command = WMGetFromPLArray(elem, idx++);
 241                         if (WMGetPropListItemCount(elem) >= 3)
 242                                 params = WMGetFromPLArray(elem, idx++);
 243
 244                         if (!title || !command)
 245                                 return menu;
 246
 247                         if (!strcmp("SHORTCUT", WMGetFromPLString(command))) {
 248                                 WMenuEntry *entry;
 249
 250                                 data = convertShortcuts(scr, params);
 251                                 if (data) {
 252                                         entry = wMenuAddCallback(menu, WMGetFromPLString(title),
 253                                                                  notifyClient, data);
 254
 255                                         if (entry) {
 256                                                 if (WMIsPLString(params))
 257                                                         entry->rtext =
 258                                                             GetShortcutString(WMGetFromPLString(params));
 259
 260                                                 entry->free_cdata = removeUserMenudata;
 261
 262                                                 if (WMGetPropListItemCount(elem) >= 4) {
 263                                                         instances = WMGetFromPLArray(elem, idx++);
 264                                                         if (WMIsPLArray(instances))
 265                                                                 if (instances && WMGetPropListItemCount(instances)
 266                                                                     && WMIsPLArray(instances)) {
 267                                                                         entry->instances =
 268                                                                             WMRetainPropList(instances);
 269                                                                 }
 270                                                 }
 271                                         }
 272                                 }
 273                         }
 274
 275                 }
 276         }
 277         return menu;
 278 }
 279
 280 void wUserMenuRefreshInstances(WMenu *menu, WWindow *wwin)
 281 {
 282         int i, j, count, paintflag;
 283
 284         paintflag = 0;
 285
 286         if (!menu)
 287                 return;
 288
 289         for (i = 0; i < menu->entry_no; i++) {
 290                 if (menu->entries[i]->instances) {
 291                         WMPropList *ins;
 292                         int oldflag;
 293                         count = WMGetPropListItemCount(menu->entries[i]->instances);
 294
 295                         oldflag = menu->entries[i]->flags.enabled;
 296                         menu->entries[i]->flags.enabled = 0;
 297                         for (j = 0; j < count; j++) {
 298                                 ins = WMGetFromPLArray(menu->entries[i]->instances, j);
 299                                 if (!strcmp(wwin->wm_instance, WMGetFromPLString(ins))) {
 300                                         menu->entries[i]->flags.enabled = 1;
 301                                         break;
 302                                 }
 303                         }
 304
 305                         if (oldflag != menu->entries[i]->flags.enabled)
 306                                 paintflag = 1;
 307                 }
 308         }
 309
 310         for (i = 0; i < menu->cascade_no; i++) {
 311                 if (!menu->cascades[i]->flags.brother)
 312                         wUserMenuRefreshInstances(menu->cascades[i], wwin);
 313                 else
 314                         wUserMenuRefreshInstances(menu->cascades[i]->brother, wwin);
 315         }
 316
 317         if (paintflag)
 318                 wMenuPaint(menu);
 319 }
 320
 321 static WMenu *readUserMenuFile(WScreen *scr, const char *file_name)
 322 {
 323         WMenu *menu = NULL;
 324         WMPropList *plum;
 325
 326         plum = WMReadPropListFromFile(file_name);
 327         if (plum) {
 328                 menu = configureUserMenu(scr, plum);
 329                 WMReleasePropList(plum);
 330         }
 331
 332         return menu;
 333 }
 334
 335 WMenu *wUserMenuGet(WScreen *scr, WWindow *wwin)
 336 {
 337         WMenu *menu = NULL;
 338         char *tmp, *path = NULL;
 339
 340         if (wwin && wwin->wm_instance && wwin->wm_class) {
 341                 int len = strlen(wwin->wm_instance) + strlen(wwin->wm_class) + 7;
 342                 tmp = wmalloc(len);
 343                 snprintf(tmp, len, "%s.%s.menu", wwin->wm_instance, wwin->wm_class);
 344                 path = wfindfile(DEF_USER_MENU_PATHS, tmp);
 345                 wfree(tmp);
 346
 347                 if (!path)
 348                         return NULL;
 349
 350                 menu = readUserMenuFile(scr, path);
 351                 wfree(path);
 352         }
 353
 354         return menu;
 355 }
 356
 357 #endif                          /* USER_MENU */