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