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 #include <X11/XKBlib.h>
  32
  33 #include "WindowMaker.h"
  34 #include "actions.h"
  35 #include "menu.h"
  36 #include "main.h"
  37 #include "window.h"
  38 #include "client.h"
  39 #include "application.h"
  40 #include "keybind.h"
  41 #include "misc.h"
  42 #include "framewin.h"
  43 #include "workspace.h"
  44 #include "winspector.h"
  45 #include "dialog.h"
  46 #include "stacking.h"
  47 #include "icon.h"
  48 #include "xinerama.h"
  49 #include "winmenu.h"
  50
  51 #define MC_MAXIMIZE     0
  52 #define MC_MINIATURIZE  1
  53 #define MC_SHADE        2
  54 #define MC_HIDE         3
  55 #define MC_MOVERESIZE   4
  56 #define MC_SELECT       5
  57 #define MC_DUMMY_MOVETO 6
  58 #define MC_PROPERTIES   7
  59 #define MC_OPTIONS      8
  60 #define MC_SHORTCUT     8
  61 #define MC_RELAUNCH     9
  62
  63 #define MC_CLOSE        10
  64 #define MC_KILL         11
  65
  66 #define WO_KEEP_ON_TOP          0
  67 #define WO_KEEP_AT_BOTTOM       1
  68 #define WO_OMNIPRESENT          2
  69 #define WO_ENTRIES              3
  70
  71 /**** Global data ***/
  72 extern WShortKey wKeyBindings[WKBD_LAST];
  73
  74
  75 static void updateOptionsMenu(WMenu * menu, WWindow * wwin);
  76
  77 static void execWindowOptionCommand(WMenu * menu, WMenuEntry * entry)
  78 {
  79         WWindow *wwin = (WWindow *) entry->clientdata;
  80
  81         switch (entry->order) {
  82         case WO_KEEP_ON_TOP:
  83                 if (wwin->frame->core->stacking->window_level != WMFloatingLevel)
  84                         ChangeStackingLevel(wwin->frame->core, WMFloatingLevel);
  85                 else
  86                         ChangeStackingLevel(wwin->frame->core, WMNormalLevel);
  87                 break;
  88
  89         case WO_KEEP_AT_BOTTOM:
  90                 if (wwin->frame->core->stacking->window_level != WMSunkenLevel)
  91                         ChangeStackingLevel(wwin->frame->core, WMSunkenLevel);
  92                 else
  93                         ChangeStackingLevel(wwin->frame->core, WMNormalLevel);
  94                 break;
  95
  96         case WO_OMNIPRESENT:
  97                 wWindowSetOmnipresent(wwin, !wwin->flags.omnipresent);
  98                 break;
  99         }
 100 }
 101
 102 static void execMenuCommand(WMenu * menu, WMenuEntry * entry)
 103 {
 104         WWindow *wwin = (WWindow *) entry->clientdata;
 105         WApplication *wapp;
 106
 107         CloseWindowMenu(menu->frame->screen_ptr);
 108
 109         switch (entry->order) {
 110         case MC_CLOSE:
 111                 /* send delete message */
 112                 wClientSendProtocol(wwin, w_global.atom.wm.delete_window,
 113                                                                   w_global.timestamp.last_event);
 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, w_global.atom.gnustep.wm_miniaturize_window,
 135                                                                                   w_global.timestamp.last_event);
 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 (w_global.shortcut.windows[index]) {
 197                 WMFreeArray(w_global.shortcut.windows[index]);
 198                 w_global.shortcut.windows[index] = NULL;
 199         }
 200
 201         if (wwin->flags.selected && scr->selected_windows) {
 202                 w_global.shortcut.windows[index] = WMDuplicateArray(scr->selected_windows);
 203         } else {
 204                 w_global.shortcut.windows[index] = WMCreateArray(4);
 205                 WMAddToArray(w_global.shortcut.windows[index], wwin);
 206         }
 207
 208         wSelectWindow(wwin, !wwin->flags.selected);
 209         XFlush(dpy);
 210         wusleep(3000);
 211         wSelectWindow(wwin, !wwin->flags.selected);
 212         XFlush(dpy);
 213 }
 214
 215 static void updateWorkspaceMenu(WMenu * menu)
 216 {
 217         char title[MAX_WORKSPACENAME_WIDTH + 1];
 218         WMenuEntry *entry;
 219         int i;
 220
 221         for (i = 0; i < w_global.workspace.count; i++) {
 222                 if (i < menu->entry_no) {
 223
 224                         entry = menu->entries[i];
 225                         if (strcmp(entry->text, w_global.workspace.array[i]->name) != 0) {
 226                                 wfree(entry->text);
 227                                 strncpy(title, w_global.workspace.array[i]->name, MAX_WORKSPACENAME_WIDTH);
 228                                 title[MAX_WORKSPACENAME_WIDTH] = 0;
 229                                 menu->entries[i]->text = wstrdup(title);
 230                                 menu->entries[i]->rtext = GetShortcutKey(wKeyBindings[WKBD_MOVE_WORKSPACE1 + i]);
 231                                 menu->flags.realized = 0;
 232                         }
 233                 } else {
 234                         strncpy(title, w_global.workspace.array[i]->name, MAX_WORKSPACENAME_WIDTH);
 235                         title[MAX_WORKSPACENAME_WIDTH] = 0;
 236
 237                         entry = wMenuAddCallback(menu, title, switchWSCommand, NULL);
 238                         entry->rtext = GetShortcutKey(wKeyBindings[WKBD_MOVE_WORKSPACE1 + i]);
 239
 240                         menu->flags.realized = 0;
 241                 }
 242
 243                 /* workspace shortcut labels */
 244                 if (i / 10 == w_global.workspace.current / 10)
 245                         entry->rtext = GetShortcutKey(wKeyBindings[WKBD_MOVE_WORKSPACE1 + (i % 10)]);
 246                 else
 247                         entry->rtext = NULL;
 248         }
 249
 250         if (!menu->flags.realized)
 251                 wMenuRealize(menu);
 252 }
 253
 254 static void updateMakeShortcutMenu(WMenu *menu, WWindow *wwin)
 255 {
 256         WMenu *smenu = menu->cascades[menu->entries[MC_SHORTCUT]->cascade];
 257         int i;
 258         char *buffer;
 259         int buflen;
 260         KeyCode kcode;
 261
 262         if (!smenu)
 263                 return;
 264
 265         buflen = strlen(_("Set Shortcut")) + 16;
 266         buffer = wmalloc(buflen);
 267
 268         for (i = WO_ENTRIES; i < smenu->entry_no; i++) {
 269                 char *tmp;
 270                 int shortcutNo = i - WO_ENTRIES;
 271                 WMenuEntry *entry = smenu->entries[i];
 272                 WMArray *shortSelWindows = w_global.shortcut.windows[shortcutNo];
 273
 274                 snprintf(buffer, buflen, "%s %i", _("Set Shortcut"), shortcutNo + 1);
 275
 276                 if (!shortSelWindows) {
 277                         entry->flags.indicator_on = 0;
 278                 } else {
 279                         entry->flags.indicator_on = 1;
 280                         if (WMCountInArray(shortSelWindows, wwin))
 281                                 entry->flags.indicator_type = MI_DIAMOND;
 282                         else
 283                                 entry->flags.indicator_type = MI_CHECK;
 284                 }
 285
 286                 if (strcmp(buffer, entry->text) != 0) {
 287                         wfree(entry->text);
 288                         entry->text = wstrdup(buffer);
 289                         smenu->flags.realized = 0;
 290                 }
 291
 292                 kcode = wKeyBindings[WKBD_WINDOW1 + shortcutNo].keycode;
 293
 294                 if (kcode) {
 295                         if ((tmp = GetShortcutKey(wKeyBindings[WKBD_WINDOW1 + shortcutNo]))
 296                             && (!entry->rtext || strcmp(tmp, entry->rtext) != 0)) {
 297                                 if (entry->rtext)
 298                                         wfree(entry->rtext);
 299                                 entry->rtext = tmp;
 300                                 smenu->flags.realized = 0;
 301                         }
 302                         wMenuSetEnabled(smenu, i, True);
 303                 } else {
 304                         wMenuSetEnabled(smenu, i, False);
 305                         if (entry->rtext) {
 306                                 wfree(entry->rtext);
 307                                 entry->rtext = NULL;
 308                                 smenu->flags.realized = 0;
 309                         }
 310                 }
 311                 entry->clientdata = wwin;
 312         }
 313         wfree(buffer);
 314         if (!smenu->flags.realized)
 315                 wMenuRealize(smenu);
 316 }
 317
 318 static void updateOptionsMenu(WMenu * menu, WWindow * wwin)
 319 {
 320         WMenu *smenu = menu->cascades[menu->entries[MC_OPTIONS]->cascade];
 321
 322         /* keep on top check */
 323         smenu->entries[WO_KEEP_ON_TOP]->clientdata = wwin;
 324         smenu->entries[WO_KEEP_ON_TOP]->flags.indicator_on =
 325             (wwin->frame->core->stacking->window_level == WMFloatingLevel) ? 1 : 0;
 326         wMenuSetEnabled(smenu, WO_KEEP_ON_TOP, !wwin->flags.miniaturized);
 327
 328         /* keep at bottom check */
 329         smenu->entries[WO_KEEP_AT_BOTTOM]->clientdata = wwin;
 330         smenu->entries[WO_KEEP_AT_BOTTOM]->flags.indicator_on =
 331             (wwin->frame->core->stacking->window_level == WMSunkenLevel) ? 1 : 0;
 332         wMenuSetEnabled(smenu, WO_KEEP_AT_BOTTOM, !wwin->flags.miniaturized);
 333
 334         /* omnipresent check */
 335         smenu->entries[WO_OMNIPRESENT]->clientdata = wwin;
 336         smenu->entries[WO_OMNIPRESENT]->flags.indicator_on = IS_OMNIPRESENT(wwin);
 337
 338         smenu->flags.realized = 0;
 339         wMenuRealize(smenu);
 340 }
 341
 342 static WMenu *makeWorkspaceMenu(WScreen * scr)
 343 {
 344         WMenu *menu;
 345
 346         menu = wMenuCreate(scr, NULL, False);
 347         if (!menu) {
 348                 wwarning(_("could not create submenu for window menu"));
 349                 return NULL;
 350         }
 351
 352         updateWorkspaceMenu(menu);
 353
 354         return menu;
 355 }
 356
 357 static WMenu *makeMakeShortcutMenu(WMenu *menu)
 358 {
 359         int i;
 360
 361         for (i = 0; i < MAX_WINDOW_SHORTCUTS; i++) {
 362                 WMenuEntry *entry;
 363                 entry = wMenuAddCallback(menu, "", makeShortcutCommand, NULL);
 364
 365                 entry->flags.indicator = 1;
 366         }
 367
 368         return menu;
 369 }
 370
 371 static WMenu *makeOptionsMenu(WScreen * scr)
 372 {
 373         WMenu *menu;
 374         WMenuEntry *entry;
 375
 376         menu = wMenuCreate(scr, NULL, False);
 377         if (!menu) {
 378                 wwarning(_("could not create submenu for window menu"));
 379                 return NULL;
 380         }
 381
 382         entry = wMenuAddCallback(menu, _("Keep on top"), execWindowOptionCommand, NULL);
 383         entry->flags.indicator = 1;
 384         entry->flags.indicator_type = MI_CHECK;
 385
 386         entry = wMenuAddCallback(menu, _("Keep at bottom"), execWindowOptionCommand, NULL);
 387         entry->flags.indicator = 1;
 388         entry->flags.indicator_type = MI_CHECK;
 389
 390         entry = wMenuAddCallback(menu, _("Omnipresent"), execWindowOptionCommand, NULL);
 391         entry->flags.indicator = 1;
 392         entry->flags.indicator_type = MI_CHECK;
 393
 394         return menu;
 395 }
 396
 397 static WMenu *createWindowMenu(WScreen * scr)
 398 {
 399         WMenu *menu;
 400         WMenuEntry *entry;
 401
 402         menu = wMenuCreate(scr, NULL, False);
 403         /*
 404          * Warning: If you make some change that affects the order of the
 405          * entries, you must update the command #defines in the top of
 406          * this file.
 407          */
 408         entry = wMenuAddCallback(menu, _("Maximize"), execMenuCommand, NULL);
 409         entry->rtext = GetShortcutKey(wKeyBindings[WKBD_MAXIMIZE]);
 410
 411         entry = wMenuAddCallback(menu, _("Miniaturize"), execMenuCommand, NULL);
 412         entry->rtext = GetShortcutKey(wKeyBindings[WKBD_MINIATURIZE]);
 413
 414         entry = wMenuAddCallback(menu, _("Shade"), execMenuCommand, NULL);
 415         entry->rtext = GetShortcutKey(wKeyBindings[WKBD_SHADE]);
 416
 417         entry = wMenuAddCallback(menu, _("Hide"), execMenuCommand, NULL);
 418         entry->rtext = GetShortcutKey(wKeyBindings[WKBD_HIDE]);
 419
 420         entry = wMenuAddCallback(menu, _("Resize/Move"), execMenuCommand, NULL);
 421         entry->rtext = GetShortcutKey(wKeyBindings[WKBD_MOVERESIZE]);
 422
 423         entry = wMenuAddCallback(menu, _("Select"), execMenuCommand, NULL);
 424         entry->rtext = GetShortcutKey(wKeyBindings[WKBD_SELECT]);
 425
 426         entry = wMenuAddCallback(menu, _("Move To"), NULL, NULL);
 427         w_global.workspace.submenu = makeWorkspaceMenu(scr);
 428         if (w_global.workspace.submenu)
 429                 wMenuEntrySetCascade(menu, entry, w_global.workspace.submenu);
 430
 431         entry = wMenuAddCallback(menu, _("Attributes..."), execMenuCommand, NULL);
 432
 433         entry = wMenuAddCallback(menu, _("Options"), NULL, NULL);
 434         wMenuEntrySetCascade(menu, entry, makeMakeShortcutMenu(makeOptionsMenu(scr)));
 435
 436         entry = wMenuAddCallback(menu, _("Launch"), execMenuCommand, NULL);
 437         entry->rtext = GetShortcutKey(wKeyBindings[WKBD_RELAUNCH]);
 438
 439         entry = wMenuAddCallback(menu, _("Close"), execMenuCommand, NULL);
 440         entry->rtext = GetShortcutKey(wKeyBindings[WKBD_CLOSE]);
 441
 442         entry = wMenuAddCallback(menu, _("Kill"), execMenuCommand, NULL);
 443
 444         return menu;
 445 }
 446
 447 void CloseWindowMenu(WScreen * scr)
 448 {
 449         if (scr->window_menu) {
 450                 if (scr->window_menu->flags.mapped)
 451                         wMenuUnmap(scr->window_menu);
 452
 453                 if (scr->window_menu->entries[0]->clientdata) {
 454                         WWindow *wwin = (WWindow *) scr->window_menu->entries[0]->clientdata;
 455
 456                         wwin->flags.menu_open_for_me = 0;
 457                 }
 458                 scr->window_menu->entries[0]->clientdata = NULL;
 459         }
 460 }
 461
 462 static void updateMenuForWindow(WMenu * menu, WWindow * wwin)
 463 {
 464         WApplication *wapp = wApplicationOf(wwin->main_window);
 465         int i;
 466
 467         updateOptionsMenu(menu, wwin);
 468
 469         updateMakeShortcutMenu(menu, wwin);
 470
 471         wMenuSetEnabled(menu, MC_HIDE, wapp != NULL && !WFLAGP(wapp->main_window_desc, no_appicon));
 472
 473         wMenuSetEnabled(menu, MC_CLOSE, (wwin->protocols.DELETE_WINDOW && !WFLAGP(wwin, no_closable)));
 474
 475         if (wwin->flags.miniaturized) {
 476                 static char *text = NULL;
 477                 if (!text)
 478                         text = _("Deminiaturize");
 479
 480                 menu->entries[MC_MINIATURIZE]->text = text;
 481         } else {
 482                 static char *text = NULL;
 483                 if (!text)
 484                         text = _("Miniaturize");
 485
 486                 menu->entries[MC_MINIATURIZE]->text = text;
 487         }
 488
 489         wMenuSetEnabled(menu, MC_MINIATURIZE, !WFLAGP(wwin, no_miniaturizable));
 490
 491         if (wwin->flags.maximized) {
 492                 static char *text = NULL;
 493                 if (!text)
 494                         text = _("Unmaximize");
 495
 496                 menu->entries[MC_MAXIMIZE]->text = text;
 497         } else {
 498                 static char *text = NULL;
 499                 if (!text)
 500                         text = _("Maximize");
 501
 502                 menu->entries[MC_MAXIMIZE]->text = text;
 503         }
 504         wMenuSetEnabled(menu, MC_MAXIMIZE, IS_RESIZABLE(wwin));
 505
 506         wMenuSetEnabled(menu, MC_MOVERESIZE, IS_RESIZABLE(wwin)
 507                         && !wwin->flags.miniaturized);
 508
 509         if (wwin->flags.shaded) {
 510                 static char *text = NULL;
 511                 if (!text)
 512                         text = _("Unshade");
 513
 514                 menu->entries[MC_SHADE]->text = text;
 515         } else {
 516                 static char *text = NULL;
 517                 if (!text)
 518                         text = _("Shade");
 519
 520                 menu->entries[MC_SHADE]->text = text;
 521         }
 522
 523         wMenuSetEnabled(menu, MC_SHADE, !WFLAGP(wwin, no_shadeable)
 524                         && !wwin->flags.miniaturized);
 525
 526         if (wwin->flags.selected) {
 527                 static char *text = NULL;
 528                 if (!text)
 529                         text = _("Deselect");
 530
 531                 menu->entries[MC_SELECT]->text = text;
 532         } else {
 533                 static char *text = NULL;
 534                 if (!text)
 535                         text = _("Select");
 536
 537                 menu->entries[MC_SELECT]->text = text;
 538         }
 539
 540         wMenuSetEnabled(menu, MC_DUMMY_MOVETO, !IS_OMNIPRESENT(wwin));
 541
 542         if (!wwin->flags.inspector_open) {
 543                 wMenuSetEnabled(menu, MC_PROPERTIES, True);
 544         } else {
 545                 wMenuSetEnabled(menu, MC_PROPERTIES, False);
 546         }
 547
 548         /* set the client data of the entries to the window */
 549         for (i = 0; i < menu->entry_no; i++) {
 550                 menu->entries[i]->clientdata = wwin;
 551         }
 552
 553         for (i = 0; i < w_global.workspace.submenu->entry_no; i++) {
 554                 w_global.workspace.submenu->entries[i]->clientdata = wwin;
 555
 556                 if (i == w_global.workspace.current)
 557                         wMenuSetEnabled(w_global.workspace.submenu, i, False);
 558                 else
 559                         wMenuSetEnabled(w_global.workspace.submenu, i, True);
 560         }
 561
 562         menu->flags.realized = 0;
 563         wMenuRealize(menu);
 564 }
 565
 566 static WMenu *open_window_menu_core(WWindow *wwin, int x, int y)
 567 {
 568         WScreen *scr = wwin->screen_ptr;
 569         WMenu *menu;
 570
 571         wwin->flags.menu_open_for_me = 1;
 572
 573         if (!scr->window_menu) {
 574                 scr->window_menu = createWindowMenu(scr);
 575
 576                 /* hack to save some memory allocation/deallocation */
 577                 wfree(scr->window_menu->entries[MC_MINIATURIZE]->text);
 578                 wfree(scr->window_menu->entries[MC_MAXIMIZE]->text);
 579                 wfree(scr->window_menu->entries[MC_SHADE]->text);
 580                 wfree(scr->window_menu->entries[MC_SELECT]->text);
 581         } else {
 582                 updateWorkspaceMenu(w_global.workspace.submenu);
 583         }
 584
 585         menu = scr->window_menu;
 586         if (menu->flags.mapped) {
 587                 wMenuUnmap(menu);
 588                 if (menu->entries[0]->clientdata == wwin)
 589                         return NULL;
 590         }
 591
 592         updateMenuForWindow(menu, wwin);
 593
 594         return menu;
 595 }
 596
 597 static void prepare_menu_position(WMenu *menu, int x, int y)
 598 {
 599         WMRect rect;
 600
 601         rect = wGetRectForHead(menu->frame->screen_ptr,
 602                                wGetHeadForPointerLocation(menu->frame->screen_ptr));
 603         if (x < rect.pos.x - menu->frame->core->width / 2)
 604                 x = rect.pos.x - menu->frame->core->width / 2;
 605         if (y < rect.pos.y)
 606                 y = rect.pos.y;
 607 }
 608
 609 void OpenWindowMenu(WWindow *wwin, int x, int y, int keyboard)
 610 {
 611         WMenu *menu;
 612
 613         menu = open_window_menu_core(wwin, x, y);
 614         if (!menu)
 615                 return;
 616
 617         /* Specific menu position */
 618         x -= menu->frame->core->width / 2;
 619         if (x + menu->frame->core->width > wwin->frame_x + wwin->frame->core->width)
 620                 x = wwin->frame_x + wwin->frame->core->width - menu->frame->core->width;
 621         if (x < wwin->frame_x)
 622                 x = wwin->frame_x;
 623
 624         /* Common menu position */
 625         prepare_menu_position(menu, x, y);
 626
 627         if (!wwin->flags.internal_window)
 628                 wMenuMapAt(menu, x, y, keyboard);
 629 }
 630
 631 void OpenWindowMenu2(WWindow *wwin, int x, int y, int keyboard)
 632 {
 633         int i;
 634         WMenu *menu;
 635
 636         menu = open_window_menu_core(wwin, x, y);
 637         if (!menu)
 638                 return;
 639
 640         /* Specific menu position */
 641         for (i = 0; i < w_global.workspace.submenu->entry_no; i++) {
 642                 w_global.workspace.submenu->entries[i]->clientdata = wwin;
 643                 wMenuSetEnabled(w_global.workspace.submenu, i, True);
 644         }
 645
 646         x -= menu->frame->core->width / 2;
 647
 648         /* Common menu position */
 649         prepare_menu_position(menu, x, y);
 650
 651         if (!wwin->flags.internal_window)
 652                 wMenuMapAt(menu, x, y, keyboard);
 653 }
 654
 655 void OpenMiniwindowMenu(WWindow * wwin, int x, int y)
 656 {
 657         WMenu *menu;
 658
 659         menu = open_window_menu_core(wwin, x, y);
 660         if (!menu)
 661                 return;
 662
 663         x -= menu->frame->core->width / 2;
 664
 665         wMenuMapAt(menu, x, y, False);
 666 }
 667
 668 void DestroyWindowMenu(WScreen *scr)
 669 {
 670         if (scr->window_menu) {
 671                 scr->window_menu->entries[MC_MINIATURIZE]->text = NULL;
 672                 scr->window_menu->entries[MC_MAXIMIZE]->text = NULL;
 673                 scr->window_menu->entries[MC_SHADE]->text = NULL;
 674                 scr->window_menu->entries[MC_SELECT]->text = NULL;
 675                 wMenuDestroy(scr->window_menu, True);
 676                 scr->window_menu = NULL;
 677         }
 678 }