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