src/winmenu.c

   1 /* winmenu.c - command menu for windows
   2  *
   3  *  WindowMaker window manager
   4  *
   5  *  Copyright (c) 1997, 1998 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 <stdio.h>
  26 #include <stdlib.h>
  27 #include <unistd.h>
  28 #include <string.h>
  29
  30 #include <X11/Xlib.h>
  31 #include <X11/Xutil.h>
  32
  33 #include "WindowMaker.h"
  34 #include "actions.h"
  35 #include "menu.h"
  36 #include "funcs.h"
  37 #include "window.h"
  38 #include "client.h"
  39 #include "application.h"
  40 #include "keybind.h"
  41 #include "framewin.h"
  42 #include "workspace.h"
  43 #include "winspector.h"
  44 #include "dialog.h"
  45
  46 #define MC_MAXIMIZE     0
  47 #define MC_MINIATURIZE  1
  48 #define MC_SHADE        2
  49 #define MC_HIDE         3
  50 #define MC_HIDE_OTHERS  4
  51 #define MC_SELECT       5
  52 #define MC_DUMMY_MOVETO 6
  53 #define MC_PROPERTIES   7
  54
  55 #define MC_CLOSE        8
  56 #define MC_KILL         9
  57
  58
  59
  60 /**** Global data ***/
  61 extern Time LastTimestamp;
  62 extern Atom _XA_WM_DELETE_WINDOW;
  63 extern Atom _XA_WINDOWMAKER_WM_MINIATURIZE_WINDOW;
  64
  65 extern WShortKey wKeyBindings[WKBD_LAST];
  66
  67 extern WPreferences wPreferences;
  68
  69 static void
  70 execMenuCommand(WMenu *menu, WMenuEntry *entry)
  71 {
  72     WWindow *wwin = (WWindow*)entry->clientdata;
  73     WApplication *wapp;
  74
  75     CloseWindowMenu(menu->frame->screen_ptr);
  76
  77     switch (entry->order) {
  78      case MC_CLOSE:
  79         /* send delete message */
  80         wClientSendProtocol(wwin, _XA_WM_DELETE_WINDOW, LastTimestamp);
  81         break;
  82      case MC_KILL:
  83         wretain(wwin);
  84         if (wPreferences.dont_confirm_kill
  85             || wMessageDialog(menu->frame->screen_ptr, _("Kill Application"),
  86                            _("This will kill the application.\nAny unsaved changes will be lost.\nPlease confirm."),
  87                            _("Yes"), _("No"), NULL)==WAPRDefault) {
  88             if (!wwin->flags.destroyed)
  89                 wClientKill(wwin);
  90         }
  91         wrelease(wwin);
  92         break;
  93      case MC_MINIATURIZE:
  94         if (wwin->protocols.MINIATURIZE_WINDOW) {
  95             wClientSendProtocol(wwin, _XA_WINDOWMAKER_WM_MINIATURIZE_WINDOW,
  96                                 LastTimestamp);
  97         } else {
  98             wIconifyWindow(wwin);
  99         }
 100         break;
 101      case MC_MAXIMIZE:
 102         if (wwin->flags.maximized)
 103             wUnmaximizeWindow(wwin);
 104         else
 105             wMaximizeWindow(wwin, MAX_VERTICAL|MAX_HORIZONTAL);
 106         break;
 107      case MC_SHADE:
 108         if (wwin->flags.shaded)
 109             wUnshadeWindow(wwin);
 110         else
 111             wShadeWindow(wwin);
 112         break;
 113      case MC_SELECT:
 114         wSelectWindow(wwin);
 115         break;
 116      case MC_PROPERTIES:
 117         if (wwin->wm_class || wwin->wm_instance)
 118             wShowInspectorForWindow(wwin);
 119         break;
 120
 121      case MC_HIDE:
 122         wapp = wApplicationOf(wwin->main_window);
 123         wHideApplication(wapp);
 124         break;
 125      case MC_HIDE_OTHERS:
 126         wHideOtherApplications(wwin);
 127         break;
 128     }
 129 }
 130
 131
 132 static void
 133 switchWSCommand(WMenu *menu, WMenuEntry *entry)
 134 {
 135     WWindow *wwin = (WWindow*)entry->clientdata;
 136
 137     if (wwin->flags.selected)
 138         wSelectWindow(wwin);
 139     wWindowChangeWorkspace(wwin, entry->order);
 140 }
 141
 142
 143 static void
 144 updateWorkspaceMenu(WMenu *menu)
 145 {
 146     WScreen *scr = menu->frame->screen_ptr;
 147     char title[MAX_WORKSPACENAME_WIDTH+1];
 148     int i;
 149
 150     if (!menu)
 151         return;
 152
 153     for (i=0; i<scr->workspace_count; i++) {
 154         if (i < menu->entry_no) {
 155             if (strcmp(menu->entries[i]->text,scr->workspaces[i]->name)!=0) {
 156                 free(menu->entries[i]->text);
 157                 strcpy(title, scr->workspaces[i]->name);
 158                 menu->entries[i]->text = wstrdup(title);
 159                 menu->flags.realized = 0;
 160             }
 161         } else {
 162             strcpy(title, scr->workspaces[i]->name);
 163
 164             wMenuAddCallback(menu, title, switchWSCommand, NULL);
 165
 166             menu->flags.realized = 0;
 167         }
 168     }
 169
 170     if (!menu->flags.realized)
 171         wMenuRealize(menu);
 172 }
 173
 174
 175 static WMenu*
 176 makeWorkspaceMenu(WScreen *scr)
 177 {
 178     WMenu *menu;
 179
 180     menu = wMenuCreate(scr, NULL, False);
 181     if (!menu)
 182         wwarning(_("could not create workspace submenu for window menu"));
 183
 184     updateWorkspaceMenu(menu);
 185
 186     return menu;
 187 }
 188
 189
 190 static WMenu*
 191 createWindowMenu(WScreen *scr)
 192 {
 193     WMenu *menu;
 194     KeyCode kcode;
 195     WMenuEntry *entry;
 196     char *tmp;
 197
 198     menu = wMenuCreate(scr, NULL, False);
 199     /*
 200      * Warning: If you make some change that affects the order of the
 201      * entries, you must update the command #defines in the top of
 202      * this file.
 203      */
 204     entry = wMenuAddCallback(menu, _("(Un)Maximize"), execMenuCommand, NULL);
 205     if (wKeyBindings[WKBD_MAXIMIZE].keycode!=0) {
 206         kcode = wKeyBindings[WKBD_MAXIMIZE].keycode;
 207
 208         if (kcode && (tmp = XKeysymToString(XKeycodeToKeysym(dpy, kcode, 0))))
 209           entry->rtext = wstrdup(tmp);
 210     }
 211
 212     entry = wMenuAddCallback(menu, _("Miniaturize"), execMenuCommand, NULL);
 213
 214     if (wKeyBindings[WKBD_MINIATURIZE].keycode!=0) {
 215         kcode = wKeyBindings[WKBD_MINIATURIZE].keycode;
 216
 217         if (kcode && (tmp = XKeysymToString(XKeycodeToKeysym(dpy, kcode, 0))))
 218           entry->rtext = wstrdup(tmp);
 219     }
 220
 221     entry = wMenuAddCallback(menu, _("(Un)Shade"), execMenuCommand, NULL);
 222     if (wKeyBindings[WKBD_SHADE].keycode!=0) {
 223         kcode = wKeyBindings[WKBD_SHADE].keycode;
 224
 225         if (kcode && (tmp = XKeysymToString(XKeycodeToKeysym(dpy, kcode, 0))))
 226           entry->rtext = wstrdup(tmp);
 227     }
 228
 229     entry = wMenuAddCallback(menu, _("Hide"), execMenuCommand, NULL);
 230     if (wKeyBindings[WKBD_HIDE].keycode!=0) {
 231         kcode = wKeyBindings[WKBD_HIDE].keycode;
 232
 233         if (kcode && (tmp = XKeysymToString(XKeycodeToKeysym(dpy, kcode, 0))))
 234           entry->rtext = wstrdup(tmp);
 235     }
 236     entry = wMenuAddCallback(menu, _("Hide Others"), execMenuCommand, NULL);
 237
 238     entry = wMenuAddCallback(menu, _("Select"), execMenuCommand, NULL);
 239     if (wKeyBindings[WKBD_SELECT].keycode!=0) {
 240         kcode = wKeyBindings[WKBD_SELECT].keycode;
 241
 242         if (kcode && (tmp = XKeysymToString(XKeycodeToKeysym(dpy, kcode, 0))))
 243           entry->rtext = wstrdup(tmp);
 244     }
 245
 246     entry = wMenuAddCallback(menu, _("Move To"), NULL, NULL);
 247     scr->workspace_submenu = makeWorkspaceMenu(scr);
 248     if (scr->workspace_submenu)
 249         wMenuEntrySetCascade(menu, entry, scr->workspace_submenu);
 250
 251     entry = wMenuAddCallback(menu, _("Attributes..."), execMenuCommand, NULL);
 252
 253     entry = wMenuAddCallback(menu, _("Close"), execMenuCommand, NULL);
 254     if (wKeyBindings[WKBD_CLOSE].keycode!=0) {
 255         kcode = wKeyBindings[WKBD_CLOSE].keycode;
 256         if (kcode && (tmp = XKeysymToString(XKeycodeToKeysym(dpy, kcode, 0))))
 257           entry->rtext = wstrdup(tmp);
 258     }
 259
 260     entry = wMenuAddCallback(menu, _("Kill"), execMenuCommand, NULL);
 261
 262     return menu;
 263 }
 264
 265
 266 void
 267 CloseWindowMenu(WScreen *scr)
 268 {
 269     if (scr->window_menu && scr->window_menu->flags.mapped)
 270       wMenuUnmap(scr->window_menu);
 271
 272 }
 273
 274
 275 void
 276 OpenWindowMenu(WWindow *wwin, int x, int y, int keyboard)
 277 {
 278     WMenu *menu;
 279     WApplication *wapp = wApplicationOf(wwin->main_window);
 280     WScreen *scr = wwin->screen_ptr;
 281     int i;
 282
 283     if (!scr->window_menu) {
 284         scr->window_menu = createWindowMenu(scr);
 285     } else {
 286         updateWorkspaceMenu(scr->workspace_submenu);
 287     }
 288     menu = scr->window_menu;
 289     if (menu->flags.mapped) {
 290         wMenuUnmap(menu);
 291         if (menu->entries[0]->clientdata==wwin) {
 292             return;
 293         }
 294     }
 295
 296     wMenuSetEnabled(menu, MC_HIDE, wapp!=NULL
 297                     && !wapp->main_window_desc->window_flags.no_appicon);
 298
 299     wMenuSetEnabled(menu, MC_CLOSE,
 300                     (wwin->protocols.DELETE_WINDOW
 301                      && !wwin->window_flags.no_closable));
 302
 303     wMenuSetEnabled(menu, MC_MINIATURIZE, !wwin->window_flags.no_miniaturizable);
 304
 305     wMenuSetEnabled(menu, MC_SHADE, !wwin->window_flags.no_shadeable);
 306
 307     wMenuSetEnabled(menu, MC_DUMMY_MOVETO, !wwin->window_flags.omnipresent);
 308
 309     if ((wwin->wm_class || wwin->wm_instance) && !wwin->flags.inspector_open) {
 310         wMenuSetEnabled(menu, MC_PROPERTIES, True);
 311     } else {
 312         wMenuSetEnabled(menu, MC_PROPERTIES, False);
 313     }
 314
 315     /* set the client data of the entries to the window */
 316     for (i = 0; i < menu->entry_no; i++) {
 317         menu->entries[i]->clientdata = wwin;
 318     }
 319     for (i = 0; i < scr->workspace_submenu->entry_no; i++) {
 320         scr->workspace_submenu->entries[i]->clientdata = wwin;
 321         if (i == scr->current_workspace) {
 322             wMenuSetEnabled(scr->workspace_submenu, i, False);
 323         } else {
 324             wMenuSetEnabled(scr->workspace_submenu, i, True);
 325         }
 326     }
 327
 328     if (!menu->flags.realized)
 329         wMenuRealize(menu);
 330
 331     x -= menu->frame->core->width/2;
 332     if (x + menu->frame->core->width > wwin->frame_x+wwin->frame->core->width)
 333         x = wwin->frame_x+wwin->frame->core->width - menu->frame->core->width;
 334     if (x < wwin->frame_x)
 335         x = wwin->frame_x;
 336
 337     if (!wwin->flags.internal_window)
 338         wMenuMapAt(menu, x, y, keyboard);
 339 }