1 /* menu.c- generic menu, used for root menu, application menus etc.
3 * Window Maker window manager
5 * Copyright (c) 1997, 1998 Alfredo K. Kojima
6 * Copyright (c) 1997, 1998 Dan Pascu
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
27 #include <X11/Xutil.h>
28 #include <X11/keysym.h>
35 #include "WindowMaker.h"
45 /****** Global Variables ******/
47 extern Cursor wCursor
[WCUR_LAST
];
49 extern XContext wWinContext
;
51 extern WPreferences wPreferences
;
53 #define MOD_MASK wPreferences.modifier_mask
55 #define MENU_SCROLL_STEP menuScrollParameters[(int)wPreferences.menu_scroll_speed].steps
56 #define MENU_SCROLL_DELAY menuScrollParameters[(int)wPreferences.menu_scroll_speed].delay
60 #define MENUW(m) ((m)->frame->core->width+2*FRAME_BORDER_WIDTH)
61 #define MENUH(m) ((m)->frame->core->height+2*FRAME_BORDER_WIDTH)
64 /***** Local Stuff ******/
69 } menuScrollParameters
[5] = {
70 {MENU_SCROLL_STEPS_UF
, MENU_SCROLL_DELAY_UF
},
71 {MENU_SCROLL_STEPS_F
, MENU_SCROLL_DELAY_F
},
72 {MENU_SCROLL_STEPS_M
, MENU_SCROLL_DELAY_M
},
73 {MENU_SCROLL_STEPS_S
, MENU_SCROLL_DELAY_S
},
74 {MENU_SCROLL_STEPS_U
, MENU_SCROLL_DELAY_U
}};
77 static void menuMouseDown(WObjDescriptor
*desc
, XEvent
*event
);
78 static void menuExpose(WObjDescriptor
*desc
, XEvent
*event
);
80 static void menuTitleDoubleClick(WCoreWindow
*sender
, void *data
, XEvent
*event
);
81 static void menuTitleMouseDown(WCoreWindow
*sender
, void *data
, XEvent
*event
);
83 static void menuCloseClick(WCoreWindow
*sender
, void *data
, XEvent
*event
);
85 static void updateTexture(WMenu
*menu
);
88 static int saveMenuRecurs(proplist_t menus
, WScreen
*scr
, WMenu
*menu
);
89 static int restoreMenuRecurs(WScreen
*scr
, proplist_t menus
, WMenu
*menu
, char *path
);
92 static void selectEntry(WMenu
*menu
, int entry_no
);
93 static void closeCascade(WMenu
*menu
);
96 /****** Notification Observers ******/
99 appearanceObserver(void *self
, WMNotification
*notif
)
101 WMenu
*menu
= (WMenu
*)self
;
102 int flags
= (int)WMGetNotificationClientData(notif
);
104 if (!menu
->flags
.realized
)
107 if (WMGetNotificationName(notif
) == WNMenuAppearanceSettingsChanged
) {
108 if (flags
& WFontSettings
) {
109 menu
->flags
.realized
= 0;
112 if (flags
& WTextureSettings
) {
113 if (!menu
->flags
.brother
)
116 if (flags
& (WTextureSettings
|WColorSettings
)) {
119 } else if (menu
->flags
.titled
) {
121 if (flags
& WFontSettings
) {
122 menu
->flags
.realized
= 0;
125 if (flags
& WTextureSettings
) {
126 menu
->frame
->flags
.need_texture_remake
= 1;
128 if (flags
& (WColorSettings
|WTextureSettings
)) {
129 #ifdef DRAWSTRING_PLUGIN
130 XClearWindow(dpy
, menu
->frame
->titlebar
->window
);
132 wFrameWindowPaint(menu
->frame
);
137 /************************************/
141 *----------------------------------------------------------------------
143 * Creates a new empty menu with the specified title. If main_menu
144 * is True, the created menu will be a main menu, which has some special
145 * properties such as being placed over other normal menus.
146 * If title is NULL, the menu will have no titlebar.
150 *----------------------------------------------------------------------
153 wMenuCreate(WScreen
*screen
, char *title
, int main_menu
)
156 static int brother
=0;
159 menu
= wmalloc(sizeof(WMenu
));
161 memset(menu
, 0, sizeof(WMenu
));
163 #ifdef SINGLE_MENULEVEL
164 tmp
= WMSubmenuLevel
;
166 tmp
= (main_menu
? WMMainMenuLevel
: WMSubmenuLevel
);
169 flags
= WFF_SINGLE_STATE
;
171 flags
|= WFF_TITLEBAR
|WFF_RIGHT_BUTTON
;
172 menu
->flags
.titled
= 1;
175 wFrameWindowCreate(screen
, tmp
, 8, 2, 1, 1, flags
,
176 screen
->menu_title_texture
, NULL
,
177 screen
->menu_title_pixel
,
178 #ifdef DRAWSTRING_PLUGIN
181 &screen
->menu_title_gc
,
182 &screen
->menu_title_font
);
184 menu
->frame
->core
->descriptor
.parent
= menu
;
185 menu
->frame
->core
->descriptor
.parent_type
= WCLASS_MENU
;
186 menu
->frame
->core
->descriptor
.handle_mousedown
= menuMouseDown
;
188 wFrameWindowHideButton(menu
->frame
, WFF_RIGHT_BUTTON
);
191 menu
->frame
->title
= wstrdup(title
);
194 menu
->frame
->flags
.justification
= WTJ_LEFT
;
196 menu
->frame
->rbutton_image
= screen
->b_pixmaps
[WBUT_CLOSE
];
199 menu
->alloced_entries
= 0;
200 menu
->selected_entry
= -1;
201 menu
->entries
= NULL
;
203 menu
->frame_x
= screen
->app_menu_x
;
204 menu
->frame_y
= screen
->app_menu_y
;
206 menu
->frame
->child
= menu
;
208 menu
->flags
.lowered
= 0;
212 /* setup object descriptors */
213 menu
->frame
->on_mousedown_titlebar
= menuTitleMouseDown
;
214 menu
->frame
->on_dblclick_titlebar
= menuTitleDoubleClick
;
217 menu
->frame
->on_click_right
= menuCloseClick
;
220 menu
->menu
= wCoreCreate(menu
->frame
->core
, 0, menu
->frame
->top_width
,
221 menu
->frame
->core
->width
, 10);
223 menu
->menu
->descriptor
.parent
= menu
;
224 menu
->menu
->descriptor
.parent_type
= WCLASS_MENU
;
225 menu
->menu
->descriptor
.handle_expose
= menuExpose
;
226 menu
->menu
->descriptor
.handle_mousedown
= menuMouseDown
;
228 menu
->menu_texture_data
= None
;
230 XMapWindow(dpy
, menu
->menu
->window
);
236 menu
->brother
= wMenuCreate(screen
, title
, main_menu
);
238 menu
->brother
->flags
.brother
= 1;
239 menu
->brother
->brother
= menu
;
241 WMAddNotificationObserver(appearanceObserver
, menu
,
242 WNMenuAppearanceSettingsChanged
, menu
);
244 WMAddNotificationObserver(appearanceObserver
, menu
,
245 WNMenuTitleAppearanceSettingsChanged
, menu
);
255 wMenuCreateForApp(WScreen
*screen
, char *title
, int main_menu
)
259 menu
= wMenuCreate(screen
, title
, main_menu
);
262 menu
->flags
.app_menu
= 1;
263 menu
->brother
->flags
.app_menu
= 1;
271 insertEntry(WMenu
*menu
, WMenuEntry
*entry
, int index
)
275 for (i
= menu
->entry_no
-1; i
>= index
; i
--) {
276 menu
->entries
[i
]->order
++;
277 menu
->entries
[i
+1] = menu
->entries
[i
];
279 menu
->entries
[index
] = entry
;
284 wMenuInsertCallback(WMenu
*menu
, int index
, char *text
,
285 void (*callback
)(WMenu
*menu
, WMenuEntry
*entry
),
292 printf("Passed NULL as menu parameter to wMenuAddCallback() \n");
297 assert(menu
->flags
.brother
==0);
298 menu
->flags
.realized
= 0;
299 menu
->brother
->flags
.realized
= 0;
301 /* reallocate array if it's too small */
302 if (menu
->entry_no
>= menu
->alloced_entries
) {
305 puts("doing wrealloc()");
307 tmp
= wrealloc(menu
->entries
,
308 sizeof(WMenuEntry
)*(menu
->alloced_entries
+5));
310 wwarning(_("wrealloc() failed while trying to add menu item"));
315 menu
->alloced_entries
+= 5;
317 menu
->brother
->entries
= tmp
;
318 menu
->brother
->alloced_entries
= menu
->alloced_entries
;
320 entry
= wmalloc(sizeof(WMenuEntry
));
321 memset(entry
, 0, sizeof(WMenuEntry
));
322 entry
->flags
.enabled
= 1;
323 entry
->text
= wstrdup(text
);
325 entry
->clientdata
= clientdata
;
326 entry
->callback
= callback
;
327 if (index
<0 || index
>=menu
->entry_no
) {
328 entry
->order
= menu
->entry_no
;
329 menu
->entries
[menu
->entry_no
] = entry
;
331 entry
->order
= index
;
332 insertEntry(menu
, entry
, index
);
336 menu
->brother
->entry_no
= menu
->entry_no
;
344 wMenuEntrySetCascade(WMenu
*menu
, WMenuEntry
*entry
, WMenu
*cascade
)
346 WMenu
*brother
= menu
->brother
;
349 assert(menu
->flags
.brother
==0);
351 if (entry
->cascade
>=0) {
352 menu
->flags
.realized
= 0;
353 brother
->flags
.realized
= 0;
356 cascade
->parent
= menu
;
358 cascade
->brother
->parent
= brother
;
361 for (i
=0; i
<menu
->cascade_no
; i
++) {
362 if (menu
->cascades
[i
]==NULL
) {
363 menu
->cascades
[i
] = cascade
;
364 brother
->cascades
[i
] = cascade
->brother
;
371 entry
->cascade
= menu
->cascade_no
;
373 menu
->cascades
= wrealloc(menu
->cascades
,
374 sizeof(WMenu
)*(menu
->cascade_no
+1));
375 menu
->cascades
[menu
->cascade_no
++] = cascade
;
378 brother
->cascades
= wrealloc(brother
->cascades
,
379 sizeof(WMenu
)*(brother
->cascade_no
+1));
380 brother
->cascades
[brother
->cascade_no
++] = cascade
->brother
;
384 if (menu
->flags
.lowered
) {
386 cascade
->flags
.lowered
= 1;
387 ChangeStackingLevel(cascade
->frame
->core
, WMNormalLevel
);
389 cascade
->brother
->flags
.lowered
= 1;
390 ChangeStackingLevel(cascade
->brother
->frame
->core
, WMNormalLevel
);
393 if (!menu
->flags
.realized
)
399 wMenuEntryRemoveCascade(WMenu
*menu
, WMenuEntry
*entry
)
401 assert(menu
->flags
.brother
==0);
403 /* destroy cascade menu */
404 if (entry
->cascade
>=0 && menu
->cascades
405 && menu
->cascades
[entry
->cascade
]!=NULL
) {
407 wMenuDestroy(menu
->cascades
[entry
->cascade
], True
);
409 menu
->cascades
[entry
->cascade
] = NULL
;
410 menu
->brother
->cascades
[entry
->cascade
] = NULL
;
418 wMenuRemoveItem(WMenu
*menu
, int index
)
422 if (menu
->flags
.brother
) {
423 wMenuRemoveItem(menu
->brother
, index
);
427 if (index
>=menu
->entry_no
) return;
429 /* destroy cascade menu */
430 wMenuEntryRemoveCascade(menu
, menu
->entries
[index
]);
432 /* destroy unshared data */
434 if (menu
->entries
[index
]->text
)
435 free(menu
->entries
[index
]->text
);
437 if (menu
->entries
[index
]->rtext
)
438 free(menu
->entries
[index
]->rtext
);
440 if (menu
->entries
[index
]->free_cdata
&& menu
->entries
[index
]->clientdata
)
441 (*menu
->entries
[index
]->free_cdata
)(menu
->entries
[index
]->clientdata
);
443 free(menu
->entries
[index
]);
445 for (i
=index
; i
<menu
->entry_no
-1; i
++) {
446 menu
->entries
[i
+1]->order
--;
447 menu
->entries
[i
]=menu
->entries
[i
+1];
450 menu
->brother
->entry_no
--;
455 renderTexture(WMenu
*menu
)
463 WScreen
*scr
= menu
->menu
->screen_ptr
;
464 WTexture
*texture
= scr
->menu_item_texture
;
466 if (wPreferences
.menu_style
== MS_NORMAL
) {
467 img
= wTextureRenderImage(texture
, menu
->menu
->width
,
468 menu
->entry_height
, WREL_MENUENTRY
);
470 img
= wTextureRenderImage(texture
, menu
->menu
->width
,
471 menu
->menu
->height
+1, WREL_MENUENTRY
);
474 wwarning(_("could not render texture: %s"),
475 RMessageForError(RErrorCode
));
480 if (wPreferences
.menu_style
== MS_SINGLE_TEXTURE
) {
482 light
.red
= light
.green
= light
.blue
= 80;
485 dark
.red
= dark
.green
= dark
.blue
= 0;
488 mid
.red
= mid
.green
= mid
.blue
= 40;
490 for (i
= 1; i
< menu
->entry_no
; i
++) {
491 ROperateLine(img
, RSubtractOperation
, 0, i
*menu
->entry_height
-2,
492 menu
->menu
->width
-1, i
*menu
->entry_height
-2, &mid
);
494 RDrawLine(img
, 0, i
*menu
->entry_height
-1,
495 menu
->menu
->width
-1, i
*menu
->entry_height
-1, &dark
);
497 ROperateLine(img
, RAddOperation
, 0, i
*menu
->entry_height
,
498 menu
->menu
->width
-1, i
*menu
->entry_height
,
502 if (!RConvertImage(scr
->rcontext
, img
, &pix
)) {
503 wwarning(_("error rendering image:%s"), RMessageForError(RErrorCode
));
512 updateTexture(WMenu
*menu
)
514 WScreen
*scr
= menu
->menu
->screen_ptr
;
516 /* setup background texture */
517 if (scr
->menu_item_texture
->any
.type
!= WTEX_SOLID
) {
518 if (!menu
->flags
.brother
) {
519 FREE_PIXMAP(menu
->menu_texture_data
);
521 menu
->menu_texture_data
= renderTexture(menu
);
523 XSetWindowBackgroundPixmap(dpy
, menu
->menu
->window
,
524 menu
->menu_texture_data
);
525 XClearWindow(dpy
, menu
->menu
->window
);
527 XSetWindowBackgroundPixmap(dpy
, menu
->brother
->menu
->window
,
528 menu
->menu_texture_data
);
529 XClearWindow(dpy
, menu
->brother
->menu
->window
);
532 XSetWindowBackground(dpy
, menu
->menu
->window
,
533 scr
->menu_item_texture
->any
.color
.pixel
);
534 XClearWindow(dpy
, menu
->menu
->window
);
540 wMenuRealize(WMenu
*menu
)
543 int width
, rwidth
, mrwidth
, mwidth
;
544 int theight
, twidth
, eheight
;
545 WScreen
*scr
= menu
->frame
->screen_ptr
;
546 static int brother_done
=0;
551 wMenuRealize(menu
->brother
);
555 flags
= WFF_SINGLE_STATE
;
556 if (menu
->flags
.titled
)
557 flags
|= WFF_TITLEBAR
|WFF_RIGHT_BUTTON
;
559 wFrameWindowUpdateBorders(menu
->frame
, flags
);
561 if (menu
->flags
.titled
) {
562 twidth
= WMWidthOfString(scr
->menu_title_font
, menu
->frame
->title
,
563 strlen(menu
->frame
->title
));
564 theight
= menu
->frame
->top_width
;
565 twidth
+= theight
+ (wPreferences
.new_style
? 16 : 8);
570 eheight
= WMFontHeight(scr
->menu_entry_font
) + 6;
571 menu
->entry_height
= eheight
;
574 for (i
=0; i
<menu
->entry_no
; i
++) {
577 /* search widest text */
578 text
= menu
->entries
[i
]->text
;
579 width
= WMWidthOfString(scr
->menu_entry_font
, text
, strlen(text
))+10;
581 if (menu
->entries
[i
]->flags
.indicator
) {
582 width
+= MENU_INDICATOR_SPACE
;
588 /* search widest text on right */
589 text
= menu
->entries
[i
]->rtext
;
591 rwidth
= WMWidthOfString(scr
->menu_entry_font
, text
, strlen(text
))
593 else if (menu
->entries
[i
]->cascade
>=0)
598 if (rwidth
> mrwidth
)
607 wCoreConfigure(menu
->menu
, 0, theight
, mwidth
, menu
->entry_no
*eheight
-1);
609 wFrameWindowResize(menu
->frame
, mwidth
, menu
->entry_no
*eheight
-1
610 + menu
->frame
->top_width
+ menu
->frame
->bottom_width
);
615 menu
->flags
.realized
= 1;
617 if (menu
->flags
.mapped
)
619 if (menu
->brother
->flags
.mapped
)
620 wMenuPaint(menu
->brother
);
625 wMenuDestroy(WMenu
*menu
, int recurse
)
629 WMRemoveNotificationObserver(menu
);
631 /* remove any pending timers */
633 WMDeleteTimerHandler(menu
->timer
);
636 /* call destroy handler */
637 if (menu
->on_destroy
)
638 (*menu
->on_destroy
)(menu
);
640 /* Destroy items if this menu own them. If this is the "brother" menu,
641 * leave them alone as it is shared by them.
643 if (!menu
->flags
.brother
) {
644 for (i
=0; i
<menu
->entry_no
; i
++) {
646 free(menu
->entries
[i
]->text
);
648 if (menu
->entries
[i
]->rtext
)
649 free(menu
->entries
[i
]->rtext
);
652 if (menu
->entries
[i
]->instances
){
653 PLRelease(menu
->entries
[i
]->instances
);
655 #endif /* USER_MENU */
657 if (menu
->entries
[i
]->free_cdata
&& menu
->entries
[i
]->clientdata
) {
658 (*menu
->entries
[i
]->free_cdata
)(menu
->entries
[i
]->clientdata
);
660 free(menu
->entries
[i
]);
664 for (i
=0; i
<menu
->cascade_no
; i
++) {
665 if (menu
->cascades
[i
]) {
666 if (menu
->cascades
[i
]->flags
.brother
)
667 wMenuDestroy(menu
->cascades
[i
]->brother
, recurse
);
669 wMenuDestroy(menu
->cascades
[i
], recurse
);
679 FREE_PIXMAP(menu
->menu_texture_data
);
682 free(menu
->cascades
);
684 wCoreDestroy(menu
->menu
);
685 wFrameWindowDestroy(menu
->frame
);
687 /* destroy copy of this menu */
688 if (!menu
->flags
.brother
&& menu
->brother
)
689 wMenuDestroy(menu
->brother
, False
);
701 drawFrame(WScreen
*scr
, Window win
, int y
, int w
, int h
, int type
)
707 segs
[i
].x1
= segs
[i
].x2
= w
-1;
709 segs
[i
].y2
= y
+ h
- 1;
711 if (type
!= F_TOP
&& type
!= F_NONE
) {
713 segs
[i
].y1
= segs
[i
].y2
= y
+ h
-2;
717 XDrawSegments(dpy
, win
, scr
->menu_item_auxtexture
->dim_gc
, segs
, i
);
723 segs
[i
].y2
= y
+ h
- 1;
725 if (type
!= F_BOTTOM
&& type
!= F_NONE
) {
732 XDrawSegments(dpy
, win
, scr
->menu_item_auxtexture
->light_gc
, segs
, i
);
734 if (type
!= F_TOP
&& type
!= F_NONE
)
735 XDrawLine(dpy
, win
, scr
->menu_item_auxtexture
->dark_gc
, 0, y
+h
-1,
741 paintEntry(WMenu
*menu
, int index
, int selected
)
745 GC light
, dim
, dark
, textGC
;
746 WScreen
*scr
=menu
->frame
->screen_ptr
;
747 Window win
= menu
->menu
->window
;
748 WMenuEntry
*entry
=menu
->entries
[index
];
750 if (!menu
->flags
.realized
) return;
751 h
= menu
->entry_height
;
752 w
= menu
->menu
->width
;
755 light
= scr
->menu_item_auxtexture
->light_gc
;
756 dim
= scr
->menu_item_auxtexture
->dim_gc
;
757 dark
= scr
->menu_item_auxtexture
->dark_gc
;
759 if (wPreferences
.menu_style
== MS_FLAT
&& menu
->entry_no
> 1) {
762 else if (index
== menu
->entry_no
- 1)
770 /* paint background */
772 XSetForeground(dpy
, scr
->select_menu_gc
, scr
->select_pixel
);
773 XFillRectangle(dpy
, win
, scr
->select_menu_gc
, 1, y
+1, w
-2, h
-3);
774 if (scr
->menu_item_texture
->any
.type
== WTEX_SOLID
)
775 drawFrame(scr
, win
, y
, w
, h
, type
);
777 if (scr
->menu_item_texture
->any
.type
== WTEX_SOLID
) {
778 XClearArea(dpy
, win
, 0, y
+ 1, w
- 1, h
- 3, False
);
780 drawFrame(scr
, win
, y
, w
, h
, type
);
782 XClearArea(dpy
, win
, 0, y
, w
, h
, False
);
787 textGC
= scr
->select_menu_gc
;
788 if (entry
->flags
.enabled
)
789 XSetForeground(dpy
, textGC
, scr
->select_text_pixel
);
791 XSetForeground(dpy
, textGC
, scr
->dtext_pixel
);
792 } else if (!entry
->flags
.enabled
) {
793 textGC
= scr
->disabled_menu_entry_gc
;
795 textGC
= scr
->menu_entry_gc
;
799 if (entry
->flags
.indicator
)
800 x
+= MENU_INDICATOR_SPACE
+ 2;
802 WMDrawString(scr
->wmscreen
, win
, textGC
, scr
->menu_entry_font
,
803 x
, 3 + y
, entry
->text
, strlen(entry
->text
));
805 if (entry
->cascade
>=0) {
806 /* draw the cascade indicator */
807 XDrawLine(dpy
,win
,dim
, w
-11, y
+6, w
-6, y
+h
/2-1);
808 XDrawLine(dpy
,win
,light
, w
-11, y
+h
-8, w
-6, y
+h
/2-1);
809 XDrawLine(dpy
,win
,dark
, w
-12, y
+6, w
-12, y
+h
-8);
813 if (entry
->flags
.indicator
&& entry
->flags
.indicator_on
) {
818 switch (entry
->flags
.indicator_type
) {
820 indicator
= scr
->menu_check_indicator
;
823 indicator
= scr
->menu_mini_indicator
;
826 indicator
= scr
->menu_hide_indicator
;
829 indicator
= scr
->menu_shade_indicator
;
833 indicator
= scr
->menu_radio_indicator
;
837 iw
= indicator
->width
;
838 ih
= indicator
->height
;
839 XSetClipMask(dpy
, scr
->copy_gc
, indicator
->mask
);
840 XSetClipOrigin(dpy
, scr
->copy_gc
, 5, y
+(h
-ih
)/2);
842 XSetForeground(dpy
, scr
->copy_gc
, scr
->black_pixel
);
844 XSetForeground(dpy
, scr
->copy_gc
, scr
->mtext_pixel
);
845 XFillRectangle(dpy
, win
, scr
->copy_gc
, 5, y
+(h
-ih
)/2, iw
, ih
);
847 XCopyArea(dpy, indicator->image, win, scr->copy_gc, 0, 0,
848 iw, ih, 5, y+(h-ih)/2);
850 XSetClipOrigin(dpy
, scr
->copy_gc
, 0, 0);
853 /* draw right text */
855 if (entry
->rtext
&& entry
->cascade
<0) {
856 tw
= WMWidthOfString(scr
->menu_entry_font
, entry
->rtext
,
857 strlen(entry
->rtext
));
859 WMDrawString(scr
->wmscreen
, win
, textGC
, scr
->menu_entry_font
, w
-6-tw
,
860 y
+ 3, entry
->rtext
, strlen(entry
->rtext
));
866 move_menus(WMenu
*menu
, int x
, int y
)
868 while (menu
->parent
) {
871 if (!wPreferences
.align_menus
&& menu
->selected_entry
>=0) {
872 y
-= menu
->selected_entry
*menu
->entry_height
;
875 wMenuMove(menu
, x
, y
, True
);
879 makeVisible(WMenu
*menu
)
881 WScreen
*scr
= menu
->frame
->screen_ptr
;
882 int x1
, y1
, x2
, y2
, new_x
, new_y
, move
;
884 if (menu
->entry_no
<0) return;
887 y1
= menu
->frame_y
+menu
->frame
->top_width
888 + menu
->selected_entry
*menu
->entry_height
;
889 x2
= x1
+ MENUW(menu
);
890 y2
= y1
+ menu
->entry_height
;
899 } else if (x2
>= scr
->scr_width
) {
900 new_x
= scr
->scr_width
- MENUW(menu
) - 1;
907 } else if (y2
>= scr
->scr_height
) {
908 new_y
= scr
->scr_height
- menu
->entry_height
- 1;
912 new_y
= new_y
- menu
->frame
->top_width
913 - menu
->selected_entry
*menu
->entry_height
;
914 move_menus(menu
, new_x
, new_y
);
919 check_key(WMenu
*menu
, XKeyEvent
*event
)
924 if (XLookupString(event
, buffer
, 32, NULL
, NULL
)<1)
927 ch
= toupper(buffer
[0]);
929 s
= (menu
->selected_entry
>=0 ? menu
->selected_entry
+1 : 0);
932 for (i
=s
; i
<menu
->entry_no
; i
++) {
933 if (ch
==toupper(menu
->entries
[i
]->text
[0])) {
937 /* no match. Retry from start, if previous started from a selected entry */
947 keyboardMenu(WMenu
*menu
)
950 KeySym ksym
=NoSymbol
;
954 int old_pos_x
= menu
->frame_x
;
955 int old_pos_y
= menu
->frame_y
;
956 int new_x
= old_pos_x
, new_y
= old_pos_y
;
957 int scr_width
= menu
->frame
->screen_ptr
->scr_width
;
958 int scr_height
= menu
->frame
->screen_ptr
->scr_height
;
960 if (menu
->flags
.editing
)
964 XGrabKeyboard(dpy
, menu
->frame
->core
->window
, True
, GrabModeAsync
,
965 GrabModeAsync
, CurrentTime
);
967 if (menu
->frame_y
+menu
->frame
->top_width
>= scr_height
)
968 new_y
= scr_height
- menu
->frame
->top_width
;
970 if (menu
->frame_x
+MENUW(menu
) >= scr_width
)
971 new_x
= scr_width
-MENUW(menu
)-1;
973 move_menus(menu
, new_x
, new_y
);
975 while (!done
&& menu
->flags
.mapped
) {
976 XAllowEvents(dpy
, AsyncKeyboard
, CurrentTime
);
977 WMMaskEvent(dpy
, ExposureMask
|ButtonMotionMask
|ButtonPressMask
978 |ButtonReleaseMask
|KeyPressMask
|KeyReleaseMask
979 |SubstructureNotifyMask
, &event
);
981 switch (event
.type
) {
983 ksym
= XLookupKeysym(&event
.xkey
, 0);
991 selectEntry(menu
, 0);
997 selectEntry(menu
, menu
->entry_no
-1);
1002 #ifdef ARROWLESS_KBD
1006 if (menu
->selected_entry
<= 0)
1007 selectEntry(menu
, menu
->entry_no
-1);
1009 selectEntry(menu
, menu
->selected_entry
-1);
1014 #ifdef ARROWLESS_KBD
1018 if (menu
->selected_entry
<0)
1019 selectEntry(menu
, 0);
1020 else if (menu
->selected_entry
== menu
->entry_no
-1)
1021 selectEntry(menu
, 0);
1022 else if (menu
->selected_entry
< menu
->entry_no
-1)
1023 selectEntry(menu
, menu
->selected_entry
+1);
1028 #ifdef ARROWLESS_KBD
1032 if (menu
->selected_entry
>=0) {
1034 entry
= menu
->entries
[menu
->selected_entry
];
1036 if (entry
->cascade
>= 0 && menu
->cascades
1037 && menu
->cascades
[entry
->cascade
]->entry_no
> 0) {
1039 XUngrabKeyboard(dpy
, CurrentTime
);
1041 selectEntry(menu
->cascades
[entry
->cascade
], 0);
1042 if (!keyboardMenu(menu
->cascades
[entry
->cascade
]))
1045 XGrabKeyboard(dpy
, menu
->frame
->core
->window
, True
,
1046 GrabModeAsync
, GrabModeAsync
,
1053 #ifdef ARROWLESS_KBD
1057 if (menu
->parent
!=NULL
&& menu
->parent
->selected_entry
>=0) {
1058 selectEntry(menu
, -1);
1059 move_menus(menu
, old_pos_x
, old_pos_y
);
1069 index
= check_key(menu
, &event
.xkey
);
1071 selectEntry(menu
, index
);
1077 if (event
.type
==ButtonPress
)
1080 WMHandleEvent(&event
);
1084 XUngrabKeyboard(dpy
, CurrentTime
);
1086 if (done
==2 && menu
->selected_entry
>=0) {
1087 entry
= menu
->entries
[menu
->selected_entry
];
1092 if (entry
&& entry
->callback
!=NULL
&& entry
->flags
.enabled
1093 && entry
->cascade
< 0) {
1094 #if (MENU_BLINK_COUNT > 0)
1095 int sel
= menu
->selected_entry
;
1098 for (i
=0; i
<MENU_BLINK_COUNT
; i
++) {
1099 paintEntry(menu
, sel
, False
);
1101 wusleep(MENU_BLINK_DELAY
);
1102 paintEntry(menu
, sel
, True
);
1104 wusleep(MENU_BLINK_DELAY
);
1107 selectEntry(menu
, -1);
1109 if (!menu
->flags
.buttoned
) {
1111 move_menus(menu
, old_pos_x
, old_pos_y
);
1115 (*entry
->callback
)(menu
, entry
);
1117 if (!menu
->flags
.buttoned
) {
1119 move_menus(menu
, old_pos_x
, old_pos_y
);
1121 selectEntry(menu
, -1);
1125 /* returns True if returning from a submenu to a parent menu,
1126 * False if exiting from menu */
1132 wMenuMapAt(WMenu
*menu
, int x
, int y
, int keyboard
)
1134 int scr_width
= menu
->frame
->screen_ptr
->scr_width
;
1135 int scr_height
= menu
->frame
->screen_ptr
->scr_height
;
1137 if (!menu
->flags
.realized
) {
1138 menu
->flags
.realized
=1;
1141 if (!menu
->flags
.mapped
) {
1142 if (wPreferences
.wrap_menus
) {
1145 if (x
+MENUW(menu
) > scr_width
)
1146 x
= scr_width
- MENUW(menu
);
1147 if (y
+MENUH(menu
) > scr_height
)
1148 y
= scr_height
- MENUH(menu
);
1151 XMoveWindow(dpy
, menu
->frame
->core
->window
, x
, y
);
1154 XMapWindow(dpy
, menu
->frame
->core
->window
);
1155 wRaiseFrame(menu
->frame
->core
);
1156 menu
->flags
.mapped
= 1;
1158 selectEntry(menu
, 0);
1167 wMenuMap(WMenu
*menu
)
1169 if (!menu
->flags
.realized
) {
1170 menu
->flags
.realized
=1;
1173 if (menu
->flags
.app_menu
&& menu
->parent
==NULL
) {
1174 menu
->frame_x
= menu
->frame
->screen_ptr
->app_menu_x
;
1175 menu
->frame_y
= menu
->frame
->screen_ptr
->app_menu_y
;
1176 XMoveWindow(dpy
, menu
->frame
->core
->window
, menu
->frame_x
, menu
->frame_y
);
1178 XMapWindow(dpy
, menu
->frame
->core
->window
);
1179 wRaiseFrame(menu
->frame
->core
);
1180 menu
->flags
.mapped
= 1;
1185 wMenuUnmap(WMenu
*menu
)
1189 XUnmapWindow(dpy
, menu
->frame
->core
->window
);
1190 if (menu
->flags
.titled
&& menu
->flags
.buttoned
) {
1191 wFrameWindowHideButton(menu
->frame
, WFF_RIGHT_BUTTON
);
1193 menu
->flags
.buttoned
= 0;
1194 menu
->flags
.mapped
= 0;
1195 menu
->flags
.open_to_left
= 0;
1197 for (i
=0; i
<menu
->cascade_no
; i
++) {
1198 if (menu
->cascades
[i
]!=NULL
1199 && menu
->cascades
[i
]->flags
.mapped
1200 && !menu
->cascades
[i
]->flags
.buttoned
) {
1202 wMenuUnmap(menu
->cascades
[i
]);
1205 menu
->selected_entry
= -1;
1211 wMenuPaint(WMenu
*menu
)
1215 if (!menu
->flags
.mapped
) {
1220 for (i
=0; i
<menu
->entry_no
; i
++) {
1221 paintEntry(menu
, i
, i
==menu
->selected_entry
);
1227 wMenuSetEnabled(WMenu
*menu
, int index
, int enable
)
1229 if (index
>=menu
->entry_no
) return;
1230 menu
->entries
[index
]->flags
.enabled
=enable
;
1231 paintEntry(menu
, index
, index
==menu
->selected_entry
);
1232 paintEntry(menu
->brother
, index
, index
==menu
->selected_entry
);
1236 /* ====================================================================== */
1240 editEntry(WMenu
*menu
, WMenuEntry
*entry
)
1244 WObjDescriptor
*desc
;
1250 menu
->flags
.editing
= 1;
1252 text
= wTextCreate(menu
->menu
, 1, menu
->entry_height
* entry
->order
,
1253 menu
->menu
->width
- 2, menu
->entry_height
- 1);
1255 wTextPutText(text
, entry
->text
);
1256 XGetInputFocus(dpy
, &old_focus
, &old_revert
);
1257 XSetInputFocus(dpy
, text
->core
->window
, RevertToNone
, CurrentTime
);
1259 if (XGrabKeyboard(dpy
, text
->core
->window
, True
, GrabModeAsync
,
1260 GrabModeAsync
, CurrentTime
)!=GrabSuccess
) {
1261 wwarning("could not grab keyboard");
1264 wSetFocusTo(menu
->frame
->screen_ptr
,
1265 menu
->frame
->screen_ptr
->focused_window
);
1270 while (!done
&& !text
->done
) {
1272 XAllowEvents(dpy
, AsyncKeyboard
|AsyncPointer
, CurrentTime
);
1274 WMNextEvent(dpy
, &event
);
1276 if (XFindContext(dpy
, event
.xany
.window
, wWinContext
,
1277 (XPointer
*)&desc
)==XCNOENT
)
1280 if ((desc
!= NULL
) && (desc
->handle_anything
!= NULL
)) {
1282 (*desc
->handle_anything
)(desc
, &event
);
1285 switch (event
.type
) {
1287 XAllowEvents(dpy
, ReplayPointer
, CurrentTime
);
1291 WMHandleEvent(&event
);
1297 XSetInputFocus(dpy
, old_focus
, old_revert
, CurrentTime
);
1299 wSetFocusTo(menu
->frame
->screen_ptr
,
1300 menu
->frame
->screen_ptr
->focused_window
);
1303 t
= wTextGetText(text
);
1304 /* if !t, the user has canceled editing */
1308 entry
->text
= wstrdup(t
);
1310 menu
->flags
.realized
= 0;
1314 XUngrabKeyboard(dpy
, CurrentTime
);
1316 if (t
&& menu
->on_edit
)
1317 (*menu
->on_edit
)(menu
, entry
);
1319 menu
->flags
.editing
= 0;
1321 if (!menu
->flags
.realized
)
1327 selectEntry(WMenu
*menu
, int entry_no
)
1333 if (menu
->entries
==NULL
)
1336 if (entry_no
>= menu
->entry_no
)
1339 old_entry
= menu
->selected_entry
;
1340 menu
->selected_entry
= entry_no
;
1342 if (old_entry
!=entry_no
) {
1344 /* unselect previous entry */
1346 paintEntry(menu
, old_entry
, False
);
1347 entry
= menu
->entries
[old_entry
];
1350 if (entry
->cascade
>=0 && menu
->cascades
) {
1351 if (!menu
->cascades
[entry
->cascade
]->flags
.buttoned
) {
1352 wMenuUnmap(menu
->cascades
[entry
->cascade
]);
1358 menu
->selected_entry
= -1;
1361 entry
= menu
->entries
[entry_no
];
1363 if (entry
->cascade
>=0 && menu
->cascades
&& entry
->flags
.enabled
) {
1364 /* Callback for when the submenu is opened.
1366 submenu
= menu
->cascades
[entry
->cascade
];
1367 if (submenu
&& submenu
->flags
.brother
)
1368 submenu
= submenu
->brother
;
1370 if (entry
->callback
) {
1371 /* Only call the callback if the submenu is not yet mapped.
1373 if (menu
->flags
.brother
) {
1374 if (!submenu
|| !submenu
->flags
.mapped
)
1375 (*entry
->callback
)(menu
->brother
, entry
);
1377 if (!submenu
|| !submenu
->flags
.buttoned
)
1378 (*entry
->callback
)(menu
, entry
);
1382 /* the submenu menu might have changed */
1383 submenu
= menu
->cascades
[entry
->cascade
];
1386 if (!submenu
->flags
.mapped
) {
1389 if (!submenu
->flags
.realized
)
1390 wMenuRealize(submenu
);
1391 if (wPreferences
.wrap_menus
) {
1392 if (menu
->flags
.open_to_left
)
1393 submenu
->flags
.open_to_left
= 1;
1395 if (submenu
->flags
.open_to_left
) {
1396 x
= menu
->frame_x
- MENUW(submenu
);
1399 submenu
->flags
.open_to_left
= 0;
1402 x
= menu
->frame_x
+ MENUW(menu
);
1404 if (x
+ MENUW(submenu
)
1405 >= menu
->frame
->screen_ptr
->scr_width
) {
1407 x
= menu
->frame_x
- MENUW(submenu
);
1408 submenu
->flags
.open_to_left
= 1;
1412 x
= menu
->frame_x
+ MENUW(menu
);
1415 if (wPreferences
.align_menus
) {
1418 y
= menu
->frame_y
+ menu
->entry_height
*entry_no
;
1419 if (menu
->flags
.titled
)
1420 y
+= menu
->frame
->top_width
;
1421 if (menu
->cascades
[entry
->cascade
]->flags
.titled
)
1422 y
-= menu
->cascades
[entry
->cascade
]->frame
->top_width
;
1425 wMenuMapAt(menu
->cascades
[entry
->cascade
], x
, y
, False
);
1426 menu
->cascades
[entry
->cascade
]->parent
= menu
;
1431 paintEntry(menu
, entry_no
, True
);
1437 findMenu(WScreen
*scr
, int *x_ret
, int *y_ret
)
1440 WObjDescriptor
*desc
;
1441 Window root_ret
, win
, junk_win
;
1445 XQueryPointer(dpy
, scr
->root_win
, &root_ret
, &win
, &x
, &y
, &wx
, &wy
,
1448 if (win
==None
) return NULL
;
1450 if (XFindContext(dpy
, win
, wWinContext
, (XPointer
*)&desc
)==XCNOENT
)
1453 if (desc
->parent_type
== WCLASS_MENU
) {
1454 menu
= (WMenu
*)desc
->parent
;
1455 XTranslateCoordinates(dpy
, root_ret
, menu
->menu
->window
, wx
, wy
,
1456 x_ret
, y_ret
, &junk_win
);
1466 closeCascade(WMenu
*menu
)
1468 WMenu
*parent
=menu
->parent
;
1470 if (menu
->flags
.brother
1471 || (!menu
->flags
.buttoned
1472 && (!menu
->flags
.app_menu
||menu
->parent
!=NULL
))) {
1474 selectEntry(menu
, -1);
1476 #if (MENU_BLINK_DELAY > 2)
1477 wusleep(MENU_BLINK_DELAY
/2);
1481 && (parent
->parent
!=NULL
|| !parent
->flags
.app_menu
1482 || parent
->flags
.brother
)
1483 && !parent
->flags
.buttoned
) {
1484 selectEntry(parent
, -1);
1486 parent
= parent
->parent
;
1489 selectEntry(parent
, -1);
1495 closeBrotherCascadesOf(WMenu
*menu
)
1500 for (i
=0; i
<menu
->cascade_no
; i
++) {
1501 if (menu
->cascades
[i
]->flags
.brother
) {
1502 tmp
= menu
->cascades
[i
];
1504 tmp
= menu
->cascades
[i
]->brother
;
1506 if (tmp
->flags
.mapped
) {
1507 selectEntry(tmp
->parent
, -1);
1508 closeBrotherCascadesOf(tmp
);
1515 #define getEntryAt(menu, x, y) ((y)<0 ? -1 : (y)/(menu->entry_height))
1519 parentMenu(WMenu
*menu
)
1524 if (menu
->flags
.buttoned
)
1527 while (menu
->parent
&& menu
->parent
->flags
.mapped
) {
1528 parent
= menu
->parent
;
1529 if (parent
->selected_entry
< 0)
1531 entry
= parent
->entries
[parent
->selected_entry
];
1532 if (!entry
->flags
.enabled
|| entry
->cascade
<0 || !parent
->cascades
||
1533 parent
->cascades
[entry
->cascade
] != menu
)
1536 if (menu
->flags
.buttoned
)
1546 * Will raise the passed menu, if submenu = 0
1547 * If submenu > 0 will also raise all mapped submenus
1548 * until the first buttoned one
1549 * If submenu < 0 will also raise all mapped parent menus
1550 * until the first buttoned one
1554 raiseMenus(WMenu
*menu
, int submenus
)
1561 wRaiseFrame(menu
->frame
->core
);
1563 if (submenus
>0 && menu
->selected_entry
>=0) {
1564 i
= menu
->entries
[menu
->selected_entry
]->cascade
;
1565 if (i
>=0 && menu
->cascades
) {
1566 submenu
= menu
->cascades
[i
];
1567 if (submenu
->flags
.mapped
&& !submenu
->flags
.buttoned
)
1568 raiseMenus(submenu
, submenus
);
1571 if (submenus
<0 && !menu
->flags
.buttoned
&&
1572 menu
->parent
&& menu
->parent
->flags
.mapped
)
1573 raiseMenus(menu
->parent
, submenus
);
1578 wMenuUnderPointer(WScreen
*screen
)
1580 WObjDescriptor
*desc
;
1581 Window root_ret
, win
;
1585 XQueryPointer(dpy
, screen
->root_win
, &root_ret
, &win
, &dummy
, &dummy
,
1586 &dummy
, &dummy
, &mask
);
1588 if (win
==None
) return NULL
;
1590 if (XFindContext(dpy
, win
, wWinContext
, (XPointer
*)&desc
)==XCNOENT
)
1593 if (desc
->parent_type
== WCLASS_MENU
)
1594 return (WMenu
*)desc
->parent
;
1600 #define MIN(a,b) (((a) > (b)) ? (b) : (a))
1604 getPointerPosition(WScreen
*scr
, int *x
, int *y
)
1606 Window root_ret
, win
;
1610 XQueryPointer(dpy
, scr
->root_win
, &root_ret
, &win
, x
, y
, &wx
, &wy
, &mask
);
1615 getScrollAmount(WMenu
*menu
, int *hamount
, int *vamount
)
1617 WScreen
*scr
= menu
->menu
->screen_ptr
;
1618 int menuX1
= menu
->frame_x
;
1619 int menuY1
= menu
->frame_y
;
1620 int menuX2
= menu
->frame_x
+ MENUW(menu
);
1621 int menuY2
= menu
->frame_y
+ MENUH(menu
);
1622 int screenW
= scr
->scr_width
;
1623 int screenH
= scr
->scr_height
;
1629 getPointerPosition(scr
, &xroot
, &yroot
);
1632 if (xroot
<= 1 && menuX1
< 0) {
1633 /* scroll to the right */
1634 *hamount
= MIN(MENU_SCROLL_STEP
, abs(menuX1
));
1636 } else if (xroot
>= screenW
-2 && menuX2
> screenW
-1) {
1637 /* scroll to the left */
1638 *hamount
= MIN(MENU_SCROLL_STEP
, abs(menuX2
-screenW
-1));
1643 *hamount
= -*hamount
;
1646 if (yroot
<= 1 && menuY1
< 0) {
1648 *vamount
= MIN(MENU_SCROLL_STEP
, abs(menuY1
));
1650 } else if (yroot
>= screenH
-2 && menuY2
> screenH
-1) {
1652 *vamount
= MIN(MENU_SCROLL_STEP
, abs(menuY2
-screenH
-2));
1654 *vamount
= -*vamount
;
1660 dragScrollMenuCallback(void *data
)
1662 WMenu
*menu
= (WMenu
*)data
;
1663 WScreen
*scr
= menu
->menu
->screen_ptr
;
1664 WMenu
*parent
= parentMenu(menu
);
1665 int hamount
, vamount
;
1667 int newSelectedEntry
;
1669 getScrollAmount(menu
, &hamount
, &vamount
);
1672 if (hamount
!= 0 || vamount
!= 0) {
1673 wMenuMove(parent
, parent
->frame_x
+ hamount
,
1674 parent
->frame_y
+ vamount
, True
);
1675 if (findMenu(scr
, &x
, &y
)) {
1676 newSelectedEntry
= getEntryAt(menu
, x
, y
);
1677 selectEntry(menu
, newSelectedEntry
);
1679 /* Pointer fell outside of menu. If the selected entry is
1680 * not a submenu, unselect it */
1681 if (menu
->selected_entry
>= 0
1682 && menu
->entries
[menu
->selected_entry
]->cascade
<0)
1683 selectEntry(menu
, -1);
1684 newSelectedEntry
= 0;
1687 /* paranoid check */
1688 if (newSelectedEntry
>= 0) {
1689 /* keep scrolling */
1690 menu
->timer
= WMAddTimerHandler(MENU_SCROLL_DELAY
,
1691 dragScrollMenuCallback
, menu
);
1696 /* don't need to scroll anymore */
1698 if (findMenu(scr
, &x
, &y
)) {
1699 newSelectedEntry
= getEntryAt(menu
, x
, y
);
1700 selectEntry(menu
, newSelectedEntry
);
1707 scrollMenuCallback(void *data
)
1709 WMenu
*menu
= (WMenu
*)data
;
1710 WMenu
*parent
= parentMenu(menu
);
1711 int hamount
= 0; /* amount to scroll */
1714 getScrollAmount(menu
, &hamount
, &vamount
);
1716 if (hamount
!= 0 || vamount
!= 0) {
1717 wMenuMove(parent
, parent
->frame_x
+ hamount
,
1718 parent
->frame_y
+ vamount
, True
);
1720 /* keep scrolling */
1721 menu
->timer
= WMAddTimerHandler(MENU_SCROLL_DELAY
,
1722 scrollMenuCallback
, menu
);
1724 /* don't need to scroll anymore */
1731 #define MENU_SCROLL_BORDER 5
1734 isPointNearBoder(WMenu
*menu
, int x
, int y
)
1736 int menuX1
= menu
->frame_x
;
1737 int menuY1
= menu
->frame_y
;
1738 int menuX2
= menu
->frame_x
+ MENUW(menu
);
1739 int menuY2
= menu
->frame_y
+ MENUH(menu
);
1740 int scrXe
= menu
->menu
->screen_ptr
->scr_width
-1;
1741 int scrYe
= menu
->menu
->screen_ptr
->scr_height
-1;
1744 if (x
>= menuX1
&& x
<= menuX2
&& (y
< MENU_SCROLL_BORDER
1745 || y
> scrYe
-MENU_SCROLL_BORDER
))
1747 else if (y
>= menuY1
&& y
<= menuY2
&& (x
< MENU_SCROLL_BORDER
1748 || x
> scrXe
-MENU_SCROLL_BORDER
))
1755 typedef struct _delay
{
1763 _leaving(_delay
*dl
)
1765 wMenuMove(dl
->menu
, dl
->ox
, dl
->oy
, True
);
1766 dl
->menu
->jump_back
=NULL
;
1767 dl
->menu
->menu
->screen_ptr
->flags
.jump_back_pending
= 0;
1773 wMenuScroll(WMenu
*menu
, XEvent
*event
)
1776 WMenu
*omenu
= parentMenu(menu
);
1777 WScreen
*scr
= menu
->frame
->screen_ptr
;
1780 int old_frame_x
= omenu
->frame_x
;
1781 int old_frame_y
= omenu
->frame_y
;
1785 puts("Entering menu Scroll");
1788 if (omenu
->jump_back
)
1789 WMDeleteTimerWithClientData(omenu
->jump_back
);
1792 if ((/*omenu->flags.buttoned &&*/ !wPreferences
.wrap_menus
)
1793 || omenu
->flags
.app_menu
) {
1797 if (!wPreferences
.wrap_menus
)
1798 raiseMenus(omenu
, True
);
1800 raiseMenus(menu
, False
);
1803 scrollMenuCallback(menu
);
1806 int x
, y
, on_border
, on_x_edge
, on_y_edge
, on_title
;
1808 WMNextEvent(dpy
, &ev
);
1813 x
= (ev
.type
==MotionNotify
) ? ev
.xmotion
.x_root
: ev
.xcrossing
.x_root
;
1814 y
= (ev
.type
==MotionNotify
) ? ev
.xmotion
.y_root
: ev
.xcrossing
.y_root
;
1816 /* on_border is != 0 if the pointer is between the menu
1817 * and the screen border and is close enough to the border */
1818 on_border
= isPointNearBoder(menu
, x
, y
);
1820 smenu
= wMenuUnderPointer(scr
);
1822 if ((smenu
==NULL
&& !on_border
) || (smenu
&& parentMenu(smenu
)!=omenu
)) {
1827 on_x_edge
= x
<= 1 || x
>= scr
->scr_width
- 2;
1828 on_y_edge
= y
<= 1 || y
>= scr
->scr_height
- 2;
1829 on_border
= on_x_edge
|| on_y_edge
;
1831 if (!on_border
&& !jump_back
) {
1836 if (menu
->timer
&& (smenu
!=menu
|| (!on_y_edge
&& !on_x_edge
))) {
1837 WMDeleteTimerHandler(menu
->timer
);
1845 scrollMenuCallback(menu
);
1848 /* True if we push on title, or drag the omenu to other position */
1849 on_title
= ev
.xbutton
.x_root
>= omenu
->frame_x
&&
1850 ev
.xbutton
.x_root
<= omenu
->frame_x
+ MENUW(omenu
) &&
1851 ev
.xbutton
.y_root
>= omenu
->frame_y
&&
1852 ev
.xbutton
.y_root
<= omenu
->frame_y
+ omenu
->frame
->top_width
;
1854 smenu
= wMenuUnderPointer(scr
);
1855 if (smenu
== NULL
|| (smenu
&& smenu
->flags
.buttoned
&& smenu
!= omenu
))
1857 else if (smenu
==omenu
&& on_title
) {
1871 WMDeleteTimerHandler(menu
->timer
);
1877 if (!omenu
->jump_back
) {
1878 delayer
=wmalloc(sizeof(_delay
));
1879 delayer
->menu
=omenu
;
1880 delayer
->ox
=old_frame_x
;
1881 delayer
->oy
=old_frame_y
;
1882 omenu
->jump_back
=delayer
;
1883 scr
->flags
.jump_back_pending
= 1;
1885 else delayer
= omenu
->jump_back
;
1886 WMAddTimerHandler(MENU_JUMP_BACK_DELAY
,(WMCallback
*)_leaving
, delayer
);
1891 puts("Leaving menu Scroll");
1898 menuExpose(WObjDescriptor
*desc
, XEvent
*event
)
1900 wMenuPaint(desc
->parent
);
1904 int *delayed_select
;
1911 delaySelection(void *data
)
1913 delay_data
*d
= (delay_data
*)data
;
1919 menu
= findMenu(d
->menu
->menu
->screen_ptr
, &x
, &y
);
1920 if (menu
&& (d
->menu
== menu
|| d
->delayed_select
)) {
1921 entry_no
= getEntryAt(menu
, x
, y
);
1922 selectEntry(menu
, entry_no
);
1924 if (d
->delayed_select
)
1925 *(d
->delayed_select
) = 0;
1930 menuMouseDown(WObjDescriptor
*desc
, XEvent
*event
)
1932 XButtonEvent
*bev
= &event
->xbutton
;
1933 WMenu
*menu
= desc
->parent
;
1935 WScreen
*scr
=menu
->frame
->screen_ptr
;
1936 WMenuEntry
*entry
=NULL
;
1938 int close_on_exit
=0;
1940 int delayed_select
= 0;
1944 int old_frame_x
= 0;
1945 int old_frame_y
= 0;
1946 delay_data d_data
= {NULL
, NULL
, NULL
};
1948 if (!wPreferences
.wrap_menus
) {
1949 smenu
= parentMenu(menu
);
1950 old_frame_x
= smenu
->frame_x
;
1951 old_frame_y
= smenu
->frame_y
;
1952 } else if (event
->xbutton
.window
== menu
->frame
->core
->window
) {
1953 /* This is true if the menu was launched with right click on root window */
1955 d_data
.delayed_select
= &delayed_select
;
1957 d_data
.magic
= WMAddTimerHandler(wPreferences
.dblclick_time
,
1958 delaySelection
, &d_data
);
1961 wRaiseFrame(menu
->frame
->core
);
1963 close_on_exit
= (bev
->send_event
|| menu
->flags
.brother
);
1965 smenu
= findMenu(scr
, &x
, &y
);
1973 if (menu
->flags
.editing
) {
1976 entry_no
= getEntryAt(menu
, x
, y
);
1978 entry
= menu
->entries
[entry_no
];
1980 if (!close_on_exit
&& (bev
->state
& ControlMask
) && smenu
1981 && entry
->flags
.editable
) {
1982 editEntry(smenu
, entry
);
1984 } else if (bev
->state
& ControlMask
) {
1988 if (entry
->flags
.enabled
&& entry
->cascade
>=0 && menu
->cascades
) {
1989 WMenu
*submenu
= menu
->cascades
[entry
->cascade
];
1991 if (submenu
->flags
.mapped
&& !submenu
->flags
.buttoned
&&
1992 menu
->selected_entry
!=entry_no
) {
1993 wMenuUnmap(submenu
);
1995 if (!submenu
->flags
.mapped
&& !delayed_select
) {
1996 selectEntry(menu
, entry_no
);
1997 } else if (!submenu
->flags
.buttoned
) {
1998 selectEntry(menu
, -1);
2001 } else if (!delayed_select
) {
2002 selectEntry(menu
, entry_no
);
2005 if (!wPreferences
.wrap_menus
&& !wPreferences
.scrollable_menus
) {
2007 dragScrollMenuCallback(menu
);
2011 prevx
= bev
->x_root
;
2012 prevy
= bev
->y_root
;
2016 XAllowEvents(dpy
, SyncPointer
, CurrentTime
);
2018 WMMaskEvent(dpy
, ExposureMask
|ButtonMotionMask
|ButtonReleaseMask
2019 |ButtonPressMask
, &ev
);
2022 smenu
= findMenu(scr
, &x
, &y
);
2024 if (smenu
== NULL
) {
2025 /* moved mouse out of menu */
2027 if (!delayed_select
&& d_data
.magic
) {
2028 WMDeleteTimerHandler(d_data
.magic
);
2029 d_data
.magic
= NULL
;
2032 || (menu
->selected_entry
>=0
2033 && menu
->entries
[menu
->selected_entry
]->cascade
>=0)) {
2034 prevx
= ev
.xmotion
.x_root
;
2035 prevy
= ev
.xmotion
.y_root
;
2039 selectEntry(menu
, -1);
2041 prevx
= ev
.xmotion
.x_root
;
2042 prevy
= ev
.xmotion
.y_root
;
2044 } else if (menu
&& menu
!=smenu
2045 && (menu
->selected_entry
<0
2046 || menu
->entries
[menu
->selected_entry
]->cascade
<0)) {
2047 selectEntry(menu
, -1);
2049 if (!delayed_select
&& d_data
.magic
) {
2050 WMDeleteTimerHandler(d_data
.magic
);
2051 d_data
.magic
= NULL
;
2055 /* hysteresis for item selection */
2057 /* check if the motion was to the side, indicating that
2058 * the user may want to cross to a submenu */
2059 if (!delayed_select
&& menu
) {
2061 Bool moved_to_submenu
;/* moved to direction of submenu */
2063 dx
= abs(prevx
- ev
.xmotion
.x_root
);
2065 moved_to_submenu
= False
;
2066 if (dx
> 0 /* if moved enough to the side */
2067 /* maybe a open submenu */
2068 && menu
->selected_entry
>=0
2069 /* moving to the right direction */
2070 && (wPreferences
.align_menus
2071 || ev
.xmotion
.y_root
>= prevy
)) {
2074 index
= menu
->entries
[menu
->selected_entry
]->cascade
;
2076 if (menu
->cascades
[index
]->frame_x
>menu
->frame_x
) {
2077 if (prevx
< ev
.xmotion
.x_root
)
2078 moved_to_submenu
= True
;
2080 if (prevx
> ev
.xmotion
.x_root
)
2081 moved_to_submenu
= True
;
2087 if (menu
!= smenu
) {
2089 WMDeleteTimerHandler(d_data
.magic
);
2091 d_data
.magic
= NULL
;
2092 } else if (moved_to_submenu
) {
2093 /* while we are moving, postpone the selection */
2095 WMDeleteTimerHandler(d_data
.magic
);
2097 d_data
.delayed_select
= NULL
;
2099 d_data
.magic
= WMAddTimerHandler(MENU_SELECT_DELAY
,
2102 prevx
= ev
.xmotion
.x_root
;
2103 prevy
= ev
.xmotion
.y_root
;
2107 WMDeleteTimerHandler(d_data
.magic
);
2108 d_data
.magic
= NULL
;
2112 prevx
= ev
.xmotion
.x_root
;
2113 prevy
= ev
.xmotion
.y_root
;
2115 /* pointer crossed menus */
2116 if (menu
&& menu
->timer
) {
2117 WMDeleteTimerHandler(menu
->timer
);
2121 dragScrollMenuCallback(smenu
);
2125 dragScrollMenuCallback(menu
);
2127 if (!delayed_select
) {
2128 entry_no
= getEntryAt(menu
, x
, y
);
2130 entry
= menu
->entries
[entry_no
];
2131 if (entry
->flags
.enabled
&& entry
->cascade
>=0 &&
2133 WMenu
*submenu
= menu
->cascades
[entry
->cascade
];
2134 if (submenu
->flags
.mapped
&& !submenu
->flags
.buttoned
2135 && menu
->selected_entry
!=entry_no
) {
2136 wMenuUnmap(submenu
);
2140 selectEntry(menu
, entry_no
);
2148 if (ev
.xbutton
.button
== event
->xbutton
.button
)
2158 if (menu
&& menu
->timer
) {
2159 WMDeleteTimerHandler(menu
->timer
);
2162 if (d_data
.magic
!=NULL
)
2163 WMDeleteTimerHandler(d_data
.magic
);
2165 if (menu
&& menu
->selected_entry
>=0) {
2166 entry
= menu
->entries
[menu
->selected_entry
];
2167 if (entry
->callback
!=NULL
&& entry
->flags
.enabled
2168 && entry
->cascade
< 0) {
2169 /* blink and erase menu selection */
2170 #if (MENU_BLINK_DELAY > 0)
2171 int sel
= menu
->selected_entry
;
2174 for (i
=0; i
<MENU_BLINK_COUNT
; i
++) {
2175 paintEntry(menu
, sel
, False
);
2177 wusleep(MENU_BLINK_DELAY
);
2178 paintEntry(menu
, sel
, True
);
2180 wusleep(MENU_BLINK_DELAY
);
2183 /* unmap the menu, it's parents and call the callback */
2184 if (!menu
->flags
.buttoned
&&
2185 (!menu
->flags
.app_menu
||menu
->parent
!=NULL
)) {
2188 selectEntry(menu
, -1);
2190 (*entry
->callback
)(menu
, entry
);
2192 /* If the user double clicks an entry, the entry will
2193 * be executed twice, which is not good for things like
2194 * the root menu. So, ignore any clicks that were generated
2195 * while the entry was being executed */
2196 while (XCheckTypedWindowEvent(dpy
, menu
->menu
->window
,
2198 } else if (entry
->callback
!=NULL
&& entry
->cascade
<0) {
2199 selectEntry(menu
, -1);
2201 if (entry
->cascade
>=0 && menu
->cascades
2202 && menu
->cascades
[entry
->cascade
]->flags
.brother
) {
2203 selectEntry(menu
, -1);
2208 if (((WMenu
*)desc
->parent
)->flags
.brother
|| close_on_exit
|| !smenu
)
2209 closeCascade(desc
->parent
);
2211 /* close the cascade windows that should not remain opened */
2212 closeBrotherCascadesOf(desc
->parent
);
2214 if (!wPreferences
.wrap_menus
)
2215 wMenuMove(parentMenu(desc
->parent
), old_frame_x
, old_frame_y
, True
);
2220 wMenuMove(WMenu
*menu
, int x
, int y
, int submenus
)
2229 XMoveWindow(dpy
, menu
->frame
->core
->window
, x
, y
);
2231 if (submenus
>0 && menu
->selected_entry
>=0) {
2232 i
= menu
->entries
[menu
->selected_entry
]->cascade
;
2234 if (i
>=0 && menu
->cascades
) {
2235 submenu
= menu
->cascades
[i
];
2236 if (submenu
->flags
.mapped
&& !submenu
->flags
.buttoned
)
2237 if (wPreferences
.align_menus
) {
2238 wMenuMove(submenu
, x
+ MENUW(menu
), y
, submenus
);
2240 wMenuMove(submenu
, x
+ MENUW(menu
),
2241 y
+ submenu
->entry_height
*menu
->selected_entry
,
2246 if (submenus
<0 && menu
->parent
!=NULL
&& menu
->parent
->flags
.mapped
&&
2247 !menu
->parent
->flags
.buttoned
) {
2248 if (wPreferences
.align_menus
) {
2249 wMenuMove(menu
->parent
, x
- MENUW(menu
->parent
), y
, submenus
);
2251 wMenuMove(menu
->parent
, x
- MENUW(menu
->parent
), menu
->frame_y
2252 - menu
->parent
->entry_height
*menu
->parent
->selected_entry
,
2260 changeMenuLevels(WMenu
*menu
, int lower
)
2265 ChangeStackingLevel(menu
->frame
->core
, (!menu
->parent
? WMMainMenuLevel
2267 wRaiseFrame(menu
->frame
->core
);
2268 menu
->flags
.lowered
= 0;
2270 ChangeStackingLevel(menu
->frame
->core
, WMNormalLevel
);
2271 wLowerFrame(menu
->frame
->core
);
2272 menu
->flags
.lowered
= 1;
2274 for (i
=0; i
<menu
->cascade_no
; i
++) {
2275 if (menu
->cascades
[i
]
2276 && !menu
->cascades
[i
]->flags
.buttoned
2277 && menu
->cascades
[i
]->flags
.lowered
!=lower
) {
2278 changeMenuLevels(menu
->cascades
[i
], lower
);
2286 menuTitleDoubleClick(WCoreWindow
*sender
, void *data
, XEvent
*event
)
2291 if (event
->xbutton
.state
& MOD_MASK
) {
2292 if (menu
->flags
.lowered
) {
2297 changeMenuLevels(menu
, lower
);
2303 menuTitleMouseDown(WCoreWindow
*sender
, void *data
, XEvent
*event
)
2308 int x
=menu
->frame_x
, y
=menu
->frame_y
;
2309 int dx
=event
->xbutton
.x_root
, dy
=event
->xbutton
.y_root
;
2314 printf("Moving menu\n");
2317 /* can't touch the menu copy */
2318 if (menu
->flags
.brother
)
2321 if (event
->xbutton
.button
!= Button1
&& event
->xbutton
.button
!= Button2
)
2324 if (event
->xbutton
.state
& MOD_MASK
) {
2325 wLowerFrame(menu
->frame
->core
);
2328 wRaiseFrame(menu
->frame
->core
);
2333 /* lower/raise all submenus */
2335 if (tmp
->selected_entry
>=0 && tmp
->cascades
2336 && tmp
->entries
[tmp
->selected_entry
]->cascade
>=0) {
2337 tmp
= tmp
->cascades
[tmp
->entries
[tmp
->selected_entry
]->cascade
];
2338 if (!tmp
|| !tmp
->flags
.mapped
)
2341 wLowerFrame(tmp
->frame
->core
);
2343 wRaiseFrame(tmp
->frame
->core
);
2349 /* tear off the menu if it's a root menu or a cascade
2351 if (!menu
->flags
.buttoned
&& !menu
->flags
.brother
2352 && (!menu
->flags
.app_menu
||menu
->parent
!=NULL
)) {
2353 menu
->flags
.buttoned
=1;
2354 wFrameWindowShowButton(menu
->frame
, WFF_RIGHT_BUTTON
);
2356 /* turn off selected menu entry in parent menu */
2357 selectEntry(menu
->parent
, -1);
2359 /* make parent map the copy in place of the original */
2360 for (i
=0; i
<menu
->parent
->cascade_no
; i
++) {
2361 if (menu
->parent
->cascades
[i
] == menu
) {
2362 menu
->parent
->cascades
[i
] = menu
->brother
;
2371 WMMaskEvent(dpy
, ButtonMotionMask
|ButtonReleaseMask
|ButtonPressMask
2372 |ExposureMask
, &ev
);
2376 x
+= ev
.xmotion
.x_root
- dx
;
2377 y
+= ev
.xmotion
.y_root
- dy
;
2378 dx
= ev
.xmotion
.x_root
;
2379 dy
= ev
.xmotion
.y_root
;
2380 wMenuMove(menu
, x
, y
, True
);
2382 if (abs(ev
.xmotion
.x_root
- dx
) > MOVE_THRESHOLD
2383 || abs(ev
.xmotion
.y_root
- dy
) > MOVE_THRESHOLD
) {
2385 XGrabPointer(dpy
, menu
->frame
->titlebar
->window
, False
,
2386 ButtonMotionMask
|ButtonReleaseMask
2388 GrabModeAsync
, GrabModeAsync
, None
,
2389 wCursor
[WCUR_MOVE
], CurrentTime
);
2398 if (ev
.xbutton
.button
!= event
->xbutton
.button
)
2401 printf("End menu move\n");
2403 XUngrabPointer(dpy
, CurrentTime
);
2414 *----------------------------------------------------------------------
2416 * Handles mouse click on the close button of menus. The menu is
2417 * closed when the button is clicked.
2420 * The closed menu is reinserted at it's parent menus
2422 *----------------------------------------------------------------------
2425 menuCloseClick(WCoreWindow
*sender
, void *data
, XEvent
*event
)
2427 WMenu
*menu
= (WMenu
*)data
;
2428 WMenu
*parent
= menu
->parent
;
2432 for (i
=0; i
<parent
->cascade_no
; i
++) {
2433 /* find the entry that points to the copy */
2434 if (parent
->cascades
[i
] == menu
->brother
) {
2435 /* make it point to the original */
2436 parent
->cascades
[i
] = menu
;
2437 menu
->parent
= parent
;
2447 wMenuSaveState(WScreen
*scr
)
2449 proplist_t menus
, key
, value
;
2454 menus
= PLMakeDictionaryFromEntries(NULL
, NULL
, NULL
);
2457 if (scr
->switch_menu
&& scr
->switch_menu
->flags
.buttoned
) {
2458 sprintf(buffer
, "%i,%i", scr
->switch_menu
->frame_x
,
2459 scr
->switch_menu
->frame_y
);
2460 key
= PLMakeString("SwitchMenu");
2461 value
= PLMakeString(buffer
);
2462 PLInsertDictionaryEntry(menus
, key
, value
);
2468 if (saveMenuRecurs(menus
, scr
, scr
->root_menu
))
2472 if (scr
->workspace_menu
&& scr
->workspace_menu
->flags
.buttoned
) {
2473 sprintf(buffer
, "%i,%i", scr
->workspace_menu
->frame_x
,
2474 scr
->workspace_menu
->frame_y
);
2475 key
= PLMakeString("WorkspaceMenu");
2476 value
= PLMakeString(buffer
);
2477 PLInsertDictionaryEntry(menus
, key
, value
);
2484 key
= PLMakeString("Menus");
2485 PLInsertDictionaryEntry(scr
->session_state
, key
, menus
);
2495 getMenuPath(WMenu
*menu
, char *buffer
, int bufSize
)
2500 if (!menu
->flags
.titled
|| !menu
->frame
->title
[0])
2503 len
= strlen(menu
->frame
->title
);
2508 ok
= getMenuPath(menu
->parent
, buffer
, bufSize
- len
- 1);
2513 strcat(buffer
, "\\");
2514 strcat(buffer
, menu
->frame
->title
);
2520 saveMenuRecurs(proplist_t menus
, WScreen
*scr
, WMenu
*menu
)
2522 proplist_t key
, value
;
2523 int save_menus
= 0, i
;
2528 if (menu
->flags
.brother
)
2529 menu
= menu
->brother
;
2531 if (menu
->flags
.buttoned
&& menu
!= scr
->switch_menu
) {
2533 sprintf(buffer
, "%i,%i", menu
->frame_x
, menu
->frame_y
);
2534 value
= PLMakeString(buffer
);
2537 ok
= getMenuPath(menu
, buffer
, 510);
2540 key
= PLMakeString(buffer
);
2541 PLInsertDictionaryEntry(menus
, key
, value
);
2549 for (i
= 0; i
< menu
->cascade_no
; i
++) {
2550 if (saveMenuRecurs(menus
, scr
, menu
->cascades
[i
]))
2559 #define COMPLAIN(key) wwarning(_("bad value in menus state info:%s"), key)
2563 restoreMenu(WScreen
*scr
, proplist_t menu
, int which
)
2566 WMenu
*pmenu
= NULL
;
2571 if (!PLIsString(menu
)) {
2572 COMPLAIN("Position");
2576 if (sscanf(PLGetString(menu
), "%i,%i", &x
, &y
)!=2)
2577 COMPLAIN("Position");
2580 if (which
& WSS_SWITCHMENU
) {
2581 OpenSwitchMenu(scr
, x
, y
, False
);
2582 pmenu
= scr
->switch_menu
;
2587 int width
= MENUW(pmenu
);
2588 int height
= MENUH(pmenu
);
2590 x
= (x
< -width
) ? 0 : x
;
2591 x
= (x
> scr
->scr_width
) ? scr
->scr_width
- width
: x
;
2592 y
= (y
< 0) ? 0 : y
;
2593 y
= (y
> scr
->scr_height
) ? scr
->scr_height
- height
: y
;
2594 wMenuMove(pmenu
, x
, y
, True
);
2595 pmenu
->flags
.buttoned
= 1;
2596 wFrameWindowShowButton(pmenu
->frame
, WFF_RIGHT_BUTTON
);
2605 restoreMenuRecurs(WScreen
*scr
, proplist_t menus
, WMenu
*menu
, char *path
)
2607 proplist_t key
, entry
;
2611 if (strlen(path
) + strlen(menu
->frame
->title
) > 510)
2614 sprintf(buffer
, "%s\\%s", path
, menu
->frame
->title
);
2615 key
= PLMakeString(buffer
);
2616 entry
= PLGetDictionaryEntry(menus
, key
);
2619 if (entry
&& PLIsString(entry
)) {
2621 if (sscanf(PLGetString(entry
), "%i,%i", &x
, &y
) != 2)
2622 COMPLAIN("Position");
2624 if (!menu
->flags
.mapped
) {
2625 int width
= MENUW(menu
);
2626 int height
= MENUH(menu
);
2628 wMenuMapAt(menu
, x
, y
, False
);
2631 /* make parent map the copy in place of the original */
2632 for (i
=0; i
<menu
->parent
->cascade_no
; i
++) {
2633 if (menu
->parent
->cascades
[i
] == menu
) {
2634 menu
->parent
->cascades
[i
] = menu
->brother
;
2639 x
= (x
< -width
) ? 0 : x
;
2640 x
= (x
> scr
->scr_width
) ? scr
->scr_width
- width
: x
;
2641 y
= (y
< 0) ? 0 : y
;
2642 y
= (y
> scr
->scr_height
) ? scr
->scr_height
- height
: y
;
2643 wMenuMove(menu
, x
, y
, True
);
2644 menu
->flags
.buttoned
= 1;
2645 wFrameWindowShowButton(menu
->frame
, WFF_RIGHT_BUTTON
);
2652 for (i
=0; i
<menu
->cascade_no
; i
++) {
2653 if (restoreMenuRecurs(scr
, menus
, menu
->cascades
[i
], buffer
) != False
)
2663 wMenuRestoreState(WScreen
*scr
)
2665 proplist_t menus
, menu
, key
, skey
;
2667 key
= PLMakeString("Menus");
2668 menus
= PLGetDictionaryEntry(scr
->session_state
, key
);
2676 skey
= PLMakeString("SwitchMenu");
2677 menu
= PLGetDictionaryEntry(menus
, skey
);
2678 restoreMenu(scr
, menu
, WSS_SWITCHMENU
);
2681 if (!scr
->root_menu
) {
2682 OpenRootMenu(scr
, scr
->scr_width
*2, 0, False
);
2683 wMenuUnmap(scr
->root_menu
);
2685 restoreMenuRecurs(scr
, menus
, scr
->root_menu
, "");
2693 OpenWorkspaceMenu(WScreen
*scr
, int x
, int y
)
2695 WMenu
*menu
, *parent
;
2699 if (!scr
->root_menu
) {
2700 OpenRootMenu(scr
, scr
->scr_width
*2, 0, False
);
2701 wMenuUnmap(scr
->root_menu
);
2704 menu
= scr
->workspace_menu
;
2706 if (menu
->flags
.mapped
) {
2707 if (!menu
->flags
.buttoned
) {
2709 parent
= menu
->parent
;
2710 if (parent
&& parent
->selected_entry
>= 0) {
2711 entry
= parent
->entries
[parent
->selected_entry
];
2712 if (parent
->cascades
[entry
->cascade
] == menu
) {
2713 selectEntry(parent
, -1);
2714 wMenuMapAt(menu
, x
, y
, False
);
2718 wRaiseFrame(menu
->frame
->core
);
2719 wMenuMapCopyAt(menu
, x
, y
);
2722 wMenuMapAt(menu
, x
, y
, False
);