src/winmenu.c

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