src/winmenu.c

   1 /* winmenu.c - command menu for windows
   2  *
   3  *  Window Maker window manager
   4  *
   5  *  Copyright (c) 1997-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 <stdio.h>
  25 #include <stdlib.h>
  26 #include <unistd.h>
  27 #include <string.h>
  28
  29 #include <X11/Xlib.h>
  30 #include <X11/Xutil.h>
  31
  32 #include "WindowMaker.h"
  33 #include "actions.h"
  34 #include "menu.h"
  35 #include "funcs.h"
  36 #include "window.h"
  37 #include "client.h"
  38 #include "application.h"
  39 #include "keybind.h"
  40 #include "framewin.h"
  41 #include "workspace.h"
  42 #include "winspector.h"
  43 #include "dialog.h"
  44 #include "stacking.h"
  45 #include "icon.h"
  46 #include "xinerama.h"
  47
  48 #define MC_MAXIMIZE     0
  49 #define MC_MINIATURIZE  1
  50 #define MC_SHADE        2
  51 #define MC_HIDE         3
  52 #define MC_MOVERESIZE   4
  53 #define MC_SELECT       5
  54 #define MC_DUMMY_MOVETO 6
  55 #define MC_PROPERTIES   7
  56 #define MC_OPTIONS      8
  57 #define MC_SHORTCUT     8
  58 #define MC_RELAUNCH     9
  59
  60 #define MC_CLOSE        10
  61 #define MC_KILL         11
  62
  63 #define WO_KEEP_ON_TOP          0
  64 #define WO_KEEP_AT_BOTTOM       1
  65 #define WO_OMNIPRESENT          2
  66 #define WO_ENTRIES              3
  67
  68 /**** Global data ***/
  69 extern Time LastTimestamp;
  70 extern Atom _XA_WM_DELETE_WINDOW;
  71 extern Atom _XA_GNUSTEP_WM_MINIATURIZE_WINDOW;
  72
  73 extern WShortKey wKeyBindings[WKBD_LAST];
  74
  75 extern WPreferences wPreferences;
  76
  77 static void updateOptionsMenu(WMenu * menu, WWindow * wwin);
  78
  79 static void execWindowOptionCommand(WMenu * menu, WMenuEntry * entry)
  80 {
  81         WWindow *wwin = (WWindow *) entry->clientdata;
  82
  83         switch (entry->order) {
  84         case WO_KEEP_ON_TOP:
  85                 if (wwin->frame->core->stacking->window_level != WMFloatingLevel)
  86                         ChangeStackingLevel(wwin->frame->core, WMFloatingLevel);
  87                 else
  88                         ChangeStackingLevel(wwin->frame->core, WMNormalLevel);
  89                 break;
  90
  91         case WO_KEEP_AT_BOTTOM:
  92                 if (wwin->frame->core->stacking->window_level != WMSunkenLevel)
  93                         ChangeStackingLevel(wwin->frame->core, WMSunkenLevel);
  94                 else
  95                         ChangeStackingLevel(wwin->frame->core, WMNormalLevel);
  96                 break;
  97
  98         case WO_OMNIPRESENT:
  99                 wWindowSetOmnipresent(wwin, !wwin->flags.omnipresent);
 100                 break;
 101         }
 102 }
 103
 104 static void execMenuCommand(WMenu * menu, WMenuEntry * entry)
 105 {
 106         WWindow *wwin = (WWindow *) entry->clientdata;
 107         WApplication *wapp;
 108
 109         CloseWindowMenu(menu->frame->screen_ptr);
 110
 111         switch (entry->order) {
 112         case MC_CLOSE:
 113                 /* send delete message */
 114                 wClientSendProtocol(wwin, _XA_WM_DELETE_WINDOW, LastTimestamp);
 115                 break;
 116
 117         case MC_KILL:
 118                 wretain(wwin);
 119                 if (wPreferences.dont_confirm_kill
 120                     || wMessageDialog(menu->frame->screen_ptr, _("Kill Application"),
 121                                       _
 122                                       ("This will kill the application.\nAny unsaved changes will be lost.\nPlease confirm."),
 123                                       _("Yes"), _("No"), NULL) == WAPRDefault) {
 124                         if (!wwin->flags.destroyed)
 125                                 wClientKill(wwin);
 126                 }
 127                 wrelease(wwin);
 128                 break;
 129
 130         case MC_MINIATURIZE:
 131                 if (wwin->flags.miniaturized) {
 132                         wDeiconifyWindow(wwin);
 133                 } else {
 134                         if (wwin->protocols.MINIATURIZE_WINDOW) {
 135                                 wClientSendProtocol(wwin, _XA_GNUSTEP_WM_MINIATURIZE_WINDOW, LastTimestamp);
 136                         } else {
 137                                 wIconifyWindow(wwin);
 138                         }
 139                 }
 140                 break;
 141
 142         case MC_MAXIMIZE:
 143                 if (wwin->flags.maximized)
 144                         wUnmaximizeWindow(wwin);
 145                 else
 146                         wMaximizeWindow(wwin, MAX_VERTICAL | MAX_HORIZONTAL);
 147                 break;
 148
 149         case MC_SHADE:
 150                 if (wwin->flags.shaded)
 151                         wUnshadeWindow(wwin);
 152                 else
 153                         wShadeWindow(wwin);
 154                 break;
 155
 156         case MC_SELECT:
 157                 if (!wwin->flags.miniaturized)
 158                         wSelectWindow(wwin, !wwin->flags.selected);
 159                 else
 160                         wIconSelect(wwin->icon);
 161                 break;
 162
 163         case MC_MOVERESIZE:
 164                 wKeyboardMoveResizeWindow(wwin);
 165                 break;
 166
 167         case MC_PROPERTIES:
 168                 wShowInspectorForWindow(wwin);
 169                 break;
 170
 171         case MC_RELAUNCH:
 172                 (void) RelaunchWindow(wwin);
 173                 break;
 174
 175         case MC_HIDE:
 176                 wapp = wApplicationOf(wwin->main_window);
 177                 wHideApplication(wapp);
 178                 break;
 179         }
 180 }
 181
 182 static void switchWSCommand(WMenu * menu, WMenuEntry * entry)
 183 {
 184         WWindow *wwin = (WWindow *) entry->clientdata;
 185
 186         wSelectWindow(wwin, False);
 187         wWindowChangeWorkspace(wwin, entry->order);
 188 }
 189
 190 static void makeShortcutCommand(WMenu * menu, WMenuEntry * entry)
 191 {
 192         WWindow *wwin = (WWindow *) entry->clientdata;
 193         WScreen *scr = wwin->screen_ptr;
 194         int index = entry->order - WO_ENTRIES;
 195
 196         if (scr->shortcutWindows[index]) {
 197                 WMFreeArray(scr->shortcutWindows[index]);
 198                 scr->shortcutWindows[index] = NULL;
 199         }
 200
 201         if (wwin->flags.selected && scr->selected_windows) {
 202                 scr->shortcutWindows[index] = WMDuplicateArray(scr->selected_windows);
 203                 /*WMRemoveFromArray(scr->shortcutWindows[index], wwin);
 204                    WMInsertInArray(scr->shortcutWindows[index], 0, wwin); */
 205         } else {
 206                 scr->shortcutWindows[index] = WMCreateArray(4);
 207                 WMAddToArray(scr->shortcutWindows[index], wwin);
 208         }
 209
 210         wSelectWindow(wwin, !wwin->flags.selected);
 211         XFlush(dpy);
 212         wusleep(3000);
 213         wSelectWindow(wwin, !wwin->flags.selected);
 214         XFlush(dpy);
 215 }
 216
 217 static void updateWorkspaceMenu(WMenu * menu)
 218 {
 219         WScreen *scr = menu->frame->screen_ptr;
 220         char title[MAX_WORKSPACENAME_WIDTH + 1];
 221         int i;
 222
 223         for (i = 0; i < scr->workspace_count; i++) {
 224                 if (i < menu->entry_no) {
 225                         if (strcmp(menu->entries[i]->text, scr->workspaces[i]->name) != 0) {
 226                                 wfree(menu->entries[i]->text);
 227                                 strncpy(title, scr->workspaces[i]->name, MAX_WORKSPACENAME_WIDTH);
 228                                 title[MAX_WORKSPACENAME_WIDTH] = 0;
 229                                 menu->entries[i]->text = wstrdup(title);
 230                                 menu->flags.realized = 0;
 231                         }
 232                 } else {
 233                         strncpy(title, scr->workspaces[i]->name, MAX_WORKSPACENAME_WIDTH);
 234                         title[MAX_WORKSPACENAME_WIDTH] = 0;
 235
 236                         wMenuAddCallback(menu, title, switchWSCommand, NULL);
 237
 238                         menu->flags.realized = 0;
 239                 }
 240         }
 241
 242         if (!menu->flags.realized)
 243                 wMenuRealize(menu);
 244 }
 245
 246 static char *getShortcutString(WShortKey key)
 247 {
 248         char *tmp = NULL;
 249         char *k = XKeysymToString(XKeycodeToKeysym(dpy, key.keycode, 0));
 250         if (!k) return NULL;
 251
 252         char **m = wPreferences.modifier_labels;
 253         if (key.modifier & ControlMask) tmp = wstrappend(tmp, m[1] ? m[1] : "Ctrl+");
 254         if (key.modifier & ShiftMask)   tmp = wstrappend(tmp, m[0] ? m[0] : "Shift+");
 255         if (key.modifier & Mod1Mask)    tmp = wstrappend(tmp, m[2] ? m[2] : "Mod1+");
 256         if (key.modifier & Mod2Mask)    tmp = wstrappend(tmp, m[3] ? m[3] : "Mod2+");
 257         if (key.modifier & Mod3Mask)    tmp = wstrappend(tmp, m[4] ? m[4] : "Mod3+");
 258         if (key.modifier & Mod4Mask)    tmp = wstrappend(tmp, m[5] ? m[5] : "Mod4+");
 259         if (key.modifier & Mod5Mask)    tmp = wstrappend(tmp, m[6] ? m[6] : "Mod5+");
 260         tmp = wstrappend(tmp, k);
 261
 262         return tmp;
 263 }
 264
 265 static void updateMakeShortcutMenu(WMenu * menu, WWindow * wwin)
 266 {
 267         WMenu *smenu = menu->cascades[menu->entries[MC_SHORTCUT]->cascade];
 268         int i;
 269         char *buffer;
 270         int buflen;
 271         KeyCode kcode;
 272
 273         if (!smenu)
 274                 return;
 275
 276         buflen = strlen(_("Set Shortcut")) + 16;
 277         buffer = wmalloc(buflen);
 278
 279         for (i = WO_ENTRIES; i < smenu->entry_no; i++) {
 280                 char *tmp;
 281                 int shortcutNo = i - WO_ENTRIES;
 282                 WMenuEntry *entry = smenu->entries[i];
 283                 WMArray *shortSelWindows = wwin->screen_ptr->shortcutWindows[shortcutNo];
 284
 285                 snprintf(buffer, buflen, "%s %i", _("Set Shortcut"), shortcutNo + 1);
 286
 287                 if (!shortSelWindows) {
 288                         entry->flags.indicator_on = 0;
 289                 } else {
 290                         entry->flags.indicator_on = 1;
 291                         if (WMCountInArray(shortSelWindows, wwin))
 292                                 entry->flags.indicator_type = MI_DIAMOND;
 293                         else
 294                                 entry->flags.indicator_type = MI_CHECK;
 295                 }
 296
 297                 if (strcmp(buffer, entry->text) != 0) {
 298                         wfree(entry->text);
 299                         entry->text = wstrdup(buffer);
 300                         smenu->flags.realized = 0;
 301                 }
 302
 303                 kcode = wKeyBindings[WKBD_WINDOW1 + shortcutNo].keycode;
 304
 305                 if (kcode) {
 306                         if ((tmp = getShortcutString(wKeyBindings[WKBD_WINDOW1 + shortcutNo]))
 307                             && (!entry->rtext || strcmp(tmp, entry->rtext) != 0)) {
 308                                 if (entry->rtext)
 309                                         wfree(entry->rtext);
 310                                 entry->rtext = tmp;
 311                                 smenu->flags.realized = 0;
 312                         }
 313                         wMenuSetEnabled(smenu, i, True);
 314                 } else {
 315                         wMenuSetEnabled(smenu, i, False);
 316                         if (entry->rtext) {
 317                                 wfree(entry->rtext);
 318                                 entry->rtext = NULL;
 319                                 smenu->flags.realized = 0;
 320                         }
 321                 }
 322                 entry->clientdata = wwin;
 323         }
 324         wfree(buffer);
 325         if (!smenu->flags.realized)
 326                 wMenuRealize(smenu);
 327 }
 328
 329 static void updateOptionsMenu(WMenu * menu, WWindow * wwin)
 330 {
 331         WMenu *smenu = menu->cascades[menu->entries[MC_OPTIONS]->cascade];
 332
 333         /* keep on top check */
 334         smenu->entries[WO_KEEP_ON_TOP]->clientdata = wwin;
 335         smenu->entries[WO_KEEP_ON_TOP]->flags.indicator_on =
 336             (wwin->frame->core->stacking->window_level == WMFloatingLevel) ? 1 : 0;
 337         wMenuSetEnabled(smenu, WO_KEEP_ON_TOP, !wwin->flags.miniaturized);
 338
 339         /* keep at bottom check */
 340         smenu->entries[WO_KEEP_AT_BOTTOM]->clientdata = wwin;
 341         smenu->entries[WO_KEEP_AT_BOTTOM]->flags.indicator_on =
 342             (wwin->frame->core->stacking->window_level == WMSunkenLevel) ? 1 : 0;
 343         wMenuSetEnabled(smenu, WO_KEEP_AT_BOTTOM, !wwin->flags.miniaturized);
 344
 345         /* omnipresent check */
 346         smenu->entries[WO_OMNIPRESENT]->clientdata = wwin;
 347         smenu->entries[WO_OMNIPRESENT]->flags.indicator_on = IS_OMNIPRESENT(wwin);
 348
 349         smenu->flags.realized = 0;
 350         wMenuRealize(smenu);
 351 }
 352
 353 static WMenu *makeWorkspaceMenu(WScreen * scr)
 354 {
 355         WMenu *menu;
 356
 357         menu = wMenuCreate(scr, NULL, False);
 358         if (!menu) {
 359                 wwarning(_("could not create submenu for window menu"));
 360                 return NULL;
 361         }
 362
 363         updateWorkspaceMenu(menu);
 364
 365         return menu;
 366 }
 367
 368 static WMenu *makeMakeShortcutMenu(WScreen * scr, WMenu * menu)
 369 {
 370         /*
 371            WMenu *menu;
 372          */
 373         int i;
 374         /*
 375            menu = wMenuCreate(scr, NULL, False);
 376            if (!menu) {
 377            wwarning(_("could not create submenu for window menu"));
 378            return NULL;
 379            }
 380          */
 381
 382         for (i = 0; i < MAX_WINDOW_SHORTCUTS; i++) {
 383                 WMenuEntry *entry;
 384                 entry = wMenuAddCallback(menu, "", makeShortcutCommand, NULL);
 385
 386                 entry->flags.indicator = 1;
 387         }
 388
 389         return menu;
 390 }
 391
 392 static WMenu *makeOptionsMenu(WScreen * scr)
 393 {
 394         WMenu *menu;
 395         WMenuEntry *entry;
 396
 397         menu = wMenuCreate(scr, NULL, False);
 398         if (!menu) {
 399                 wwarning(_("could not create submenu for window menu"));
 400                 return NULL;
 401         }
 402
 403         entry = wMenuAddCallback(menu, _("Keep on top"), execWindowOptionCommand, NULL);
 404         entry->flags.indicator = 1;
 405         entry->flags.indicator_type = MI_CHECK;
 406
 407         entry = wMenuAddCallback(menu, _("Keep at bottom"), execWindowOptionCommand, NULL);
 408         entry->flags.indicator = 1;
 409         entry->flags.indicator_type = MI_CHECK;
 410
 411         entry = wMenuAddCallback(menu, _("Omnipresent"), execWindowOptionCommand, NULL);
 412         entry->flags.indicator = 1;
 413         entry->flags.indicator_type = MI_CHECK;
 414
 415         return menu;
 416 }
 417
 418 static WMenu *createWindowMenu(WScreen * scr)
 419 {
 420         WMenu *menu;
 421         WMenuEntry *entry;
 422
 423         menu = wMenuCreate(scr, NULL, False);
 424         /*
 425          * Warning: If you make some change that affects the order of the
 426          * entries, you must update the command #defines in the top of
 427          * this file.
 428          */
 429         entry = wMenuAddCallback(menu, _("Maximize"), execMenuCommand, NULL);
 430         entry->rtext = getShortcutString(wKeyBindings[WKBD_MAXIMIZE]);
 431
 432         entry = wMenuAddCallback(menu, _("Miniaturize"), execMenuCommand, NULL);
 433         entry->rtext = getShortcutString(wKeyBindings[WKBD_MINIATURIZE]);
 434
 435         entry = wMenuAddCallback(menu, _("Shade"), execMenuCommand, NULL);
 436         entry->rtext = getShortcutString(wKeyBindings[WKBD_SHADE]);
 437
 438         entry = wMenuAddCallback(menu, _("Hide"), execMenuCommand, NULL);
 439         entry->rtext = getShortcutString(wKeyBindings[WKBD_HIDE]);
 440
 441         entry = wMenuAddCallback(menu, _("Resize/Move"), execMenuCommand, NULL);
 442         entry->rtext = getShortcutString(wKeyBindings[WKBD_MOVERESIZE]);
 443
 444         entry = wMenuAddCallback(menu, _("Select"), execMenuCommand, NULL);
 445         entry->rtext = getShortcutString(wKeyBindings[WKBD_SELECT]);
 446
 447         entry = wMenuAddCallback(menu, _("Move To"), NULL, NULL);
 448         scr->workspace_submenu = makeWorkspaceMenu(scr);
 449         if (scr->workspace_submenu)
 450                 wMenuEntrySetCascade(menu, entry, scr->workspace_submenu);
 451
 452         entry = wMenuAddCallback(menu, _("Attributes..."), execMenuCommand, NULL);
 453
 454         entry = wMenuAddCallback(menu, _("Options"), NULL, NULL);
 455         wMenuEntrySetCascade(menu, entry, makeMakeShortcutMenu(scr, makeOptionsMenu(scr)));
 456
 457         /*
 458            entry = wMenuAddCallback(menu, _("Select Shortcut"), NULL, NULL);
 459            wMenuEntrySetCascade(menu, entry, makeMakeShortcutMenu(scr));
 460          */
 461
 462         entry = wMenuAddCallback(menu, _("Launch"), execMenuCommand, NULL);
 463         entry->rtext = getShortcutString(wKeyBindings[WKBD_RELAUNCH]);
 464
 465         entry = wMenuAddCallback(menu, _("Close"), execMenuCommand, NULL);
 466         entry->rtext = getShortcutString(wKeyBindings[WKBD_CLOSE]);
 467
 468         entry = wMenuAddCallback(menu, _("Kill"), execMenuCommand, NULL);
 469
 470         return menu;
 471 }
 472
 473 void CloseWindowMenu(WScreen * scr)
 474 {
 475         if (scr->window_menu) {
 476                 if (scr->window_menu->flags.mapped)
 477                         wMenuUnmap(scr->window_menu);
 478
 479                 if (scr->window_menu->entries[0]->clientdata) {
 480                         WWindow *wwin = (WWindow *) scr->window_menu->entries[0]->clientdata;
 481
 482                         wwin->flags.menu_open_for_me = 0;
 483                 }
 484                 scr->window_menu->entries[0]->clientdata = NULL;
 485         }
 486 }
 487
 488 static void updateMenuForWindow(WMenu * menu, WWindow * wwin)
 489 {
 490         WApplication *wapp = wApplicationOf(wwin->main_window);
 491         WScreen *scr = wwin->screen_ptr;
 492         int i;
 493
 494         updateOptionsMenu(menu, wwin);
 495
 496         updateMakeShortcutMenu(menu, wwin);
 497
 498         wMenuSetEnabled(menu, MC_HIDE, wapp != NULL && !WFLAGP(wapp->main_window_desc, no_appicon));
 499
 500         wMenuSetEnabled(menu, MC_CLOSE, (wwin->protocols.DELETE_WINDOW && !WFLAGP(wwin, no_closable)));
 501
 502         if (wwin->flags.miniaturized) {
 503                 static char *text = NULL;
 504                 if (!text)
 505                         text = _("Deminiaturize");
 506
 507                 menu->entries[MC_MINIATURIZE]->text = text;
 508         } else {
 509                 static char *text = NULL;
 510                 if (!text)
 511                         text = _("Miniaturize");
 512
 513                 menu->entries[MC_MINIATURIZE]->text = text;
 514         }
 515
 516         wMenuSetEnabled(menu, MC_MINIATURIZE, !WFLAGP(wwin, no_miniaturizable));
 517
 518         if (wwin->flags.maximized) {
 519                 static char *text = NULL;
 520                 if (!text)
 521                         text = _("Unmaximize");
 522
 523                 menu->entries[MC_MAXIMIZE]->text = text;
 524         } else {
 525                 static char *text = NULL;
 526                 if (!text)
 527                         text = _("Maximize");
 528
 529                 menu->entries[MC_MAXIMIZE]->text = text;
 530         }
 531         wMenuSetEnabled(menu, MC_MAXIMIZE, IS_RESIZABLE(wwin));
 532
 533         wMenuSetEnabled(menu, MC_MOVERESIZE, IS_RESIZABLE(wwin)
 534                         && !wwin->flags.miniaturized);
 535
 536         if (wwin->flags.shaded) {
 537                 static char *text = NULL;
 538                 if (!text)
 539                         text = _("Unshade");
 540
 541                 menu->entries[MC_SHADE]->text = text;
 542         } else {
 543                 static char *text = NULL;
 544                 if (!text)
 545                         text = _("Shade");
 546
 547                 menu->entries[MC_SHADE]->text = text;
 548         }
 549
 550         wMenuSetEnabled(menu, MC_SHADE, !WFLAGP(wwin, no_shadeable)
 551                         && !wwin->flags.miniaturized);
 552
 553         wMenuSetEnabled(menu, MC_DUMMY_MOVETO, !IS_OMNIPRESENT(wwin));
 554
 555         if (!wwin->flags.inspector_open) {
 556                 wMenuSetEnabled(menu, MC_PROPERTIES, True);
 557         } else {
 558                 wMenuSetEnabled(menu, MC_PROPERTIES, False);
 559         }
 560
 561         /* set the client data of the entries to the window */
 562         for (i = 0; i < menu->entry_no; i++) {
 563                 menu->entries[i]->clientdata = wwin;
 564         }
 565
 566         for (i = 0; i < scr->workspace_submenu->entry_no; i++) {
 567                 scr->workspace_submenu->entries[i]->clientdata = wwin;
 568                 if (i == scr->current_workspace) {
 569                         wMenuSetEnabled(scr->workspace_submenu, i, False);
 570                 } else {
 571                         wMenuSetEnabled(scr->workspace_submenu, i, True);
 572                 }
 573         }
 574
 575         menu->flags.realized = 0;
 576         wMenuRealize(menu);
 577 }
 578
 579 void OpenWindowMenu(WWindow * wwin, int x, int y, int keyboard)
 580 {
 581         WMenu *menu;
 582         WScreen *scr = wwin->screen_ptr;
 583         WMRect rect;
 584
 585         wwin->flags.menu_open_for_me = 1;
 586
 587         if (!scr->window_menu) {
 588                 scr->window_menu = createWindowMenu(scr);
 589
 590                 /* hack to save some memory allocation/deallocation */
 591                 wfree(scr->window_menu->entries[MC_MINIATURIZE]->text);
 592                 wfree(scr->window_menu->entries[MC_MAXIMIZE]->text);
 593                 wfree(scr->window_menu->entries[MC_SHADE]->text);
 594         } else {
 595                 updateWorkspaceMenu(scr->workspace_submenu);
 596         }
 597
 598         menu = scr->window_menu;
 599         if (menu->flags.mapped) {
 600                 wMenuUnmap(menu);
 601                 if (menu->entries[0]->clientdata == wwin) {
 602                         return;
 603                 }
 604         }
 605
 606         updateMenuForWindow(menu, wwin);
 607
 608         x -= menu->frame->core->width / 2;
 609         if (x + menu->frame->core->width > wwin->frame_x + wwin->frame->core->width)
 610                 x = wwin->frame_x + wwin->frame->core->width - menu->frame->core->width;
 611         if (x < wwin->frame_x)
 612                 x = wwin->frame_x;
 613
 614         rect = wGetRectForHead(menu->frame->screen_ptr,
 615                                wGetHeadForPointerLocation(menu->frame->screen_ptr));
 616         if (x < rect.pos.x - menu->frame->core->width / 2)
 617                 x = rect.pos.x - menu->frame->core->width / 2;
 618         if (y < rect.pos.y)
 619                 y = rect.pos.y;
 620
 621         if (!wwin->flags.internal_window)
 622                 wMenuMapAt(menu, x, y, keyboard);
 623 }
 624
 625 void OpenWindowMenu2(WWindow *wwin, int x, int y, int keyboard)
 626 {
 627         int i;
 628         WMenu *menu;
 629         WScreen *scr = wwin->screen_ptr;
 630         WMRect rect;
 631
 632         wwin->flags.menu_open_for_me = 1;
 633
 634         if (!scr->window_menu) {
 635                 scr->window_menu = createWindowMenu(scr);
 636
 637                 /* hack to save some memory allocation/deallocation */
 638                 wfree(scr->window_menu->entries[MC_MINIATURIZE]->text);
 639                 wfree(scr->window_menu->entries[MC_MAXIMIZE]->text);
 640                 wfree(scr->window_menu->entries[MC_SHADE]->text);
 641         } else {
 642                 updateWorkspaceMenu(scr->workspace_submenu);
 643         }
 644
 645         menu = scr->window_menu;
 646         if (menu->flags.mapped) {
 647                 wMenuUnmap(menu);
 648                 if (menu->entries[0]->clientdata == wwin) {
 649                         return;
 650                 }
 651         }
 652
 653         updateMenuForWindow(menu, wwin);
 654
 655         for (i = 0; i < scr->workspace_submenu->entry_no; i++) {
 656                 scr->workspace_submenu->entries[i]->clientdata = wwin;
 657                 wMenuSetEnabled(scr->workspace_submenu, i, True);
 658         }
 659
 660         x -= menu->frame->core->width / 2;
 661
 662         rect = wGetRectForHead(menu->frame->screen_ptr,
 663                                wGetHeadForPointerLocation(menu->frame->screen_ptr));
 664         if (x < rect.pos.x - menu->frame->core->width / 2)
 665                 x = rect.pos.x - menu->frame->core->width / 2;
 666         if (y < rect.pos.y)
 667                 y = rect.pos.y;
 668
 669         if (!wwin->flags.internal_window)
 670                 wMenuMapAt(menu, x, y, keyboard);
 671 }
 672
 673 void OpenMiniwindowMenu(WWindow * wwin, int x, int y)
 674 {
 675         WMenu *menu;
 676         WScreen *scr = wwin->screen_ptr;
 677
 678         wwin->flags.menu_open_for_me = 1;
 679
 680         if (!scr->window_menu) {
 681                 scr->window_menu = createWindowMenu(scr);
 682
 683                 /* hack to save some memory allocation/deallocation */
 684                 wfree(scr->window_menu->entries[MC_MINIATURIZE]->text);
 685                 wfree(scr->window_menu->entries[MC_MAXIMIZE]->text);
 686                 wfree(scr->window_menu->entries[MC_SHADE]->text);
 687         } else {
 688                 updateWorkspaceMenu(scr->workspace_submenu);
 689         }
 690
 691         menu = scr->window_menu;
 692         if (menu->flags.mapped) {
 693                 wMenuUnmap(menu);
 694                 if (menu->entries[0]->clientdata == wwin) {
 695                         return;
 696                 }
 697         }
 698
 699         updateMenuForWindow(menu, wwin);
 700
 701         x -= menu->frame->core->width / 2;
 702
 703         wMenuMapAt(menu, x, y, False);
 704 }
 705
 706 void DestroyWindowMenu(WScreen *scr)
 707 {
 708         if (scr->window_menu) {
 709                 scr->window_menu->entries[MC_MINIATURIZE]->text = NULL;
 710                 scr->window_menu->entries[MC_MAXIMIZE]->text = NULL;
 711                 scr->window_menu->entries[MC_SHADE]->text = NULL;
 712                 wMenuDestroy(scr->window_menu, True);
 713                 scr->window_menu = NULL;
 714         }
 715 }