1 /* menu.c- generic menu, used for root menu, application menus etc.
3 * Window Maker window manager
5 * Copyright (c) 1997-2003 Alfredo K. Kojima
6 * Copyright (c) 1998-2003 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>
36 #include "WindowMaker.h"
45 #include "workspace.h"
47 /****** Global Variables ******/
49 extern Cursor wCursor
[WCUR_LAST
];
51 extern XContext wWinContext
;
53 extern WPreferences wPreferences
;
55 #define MOD_MASK wPreferences.modifier_mask
57 #define MENU_SCROLL_STEP menuScrollParameters[(int)wPreferences.menu_scroll_speed].steps
58 #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)
63 /***** Local Stuff ******/
65 #define WSS_ROOTMENU (1<<0)
66 #define WSS_SWITCHMENU (1<<1)
67 #define WSS_WSMENU (1<<2)
72 } menuScrollParameters
[5] = {
74 MENU_SCROLL_STEPS_UF
, MENU_SCROLL_DELAY_UF
}, {
75 MENU_SCROLL_STEPS_F
, MENU_SCROLL_DELAY_F
}, {
76 MENU_SCROLL_STEPS_M
, MENU_SCROLL_DELAY_M
}, {
77 MENU_SCROLL_STEPS_S
, MENU_SCROLL_DELAY_S
}, {
78 MENU_SCROLL_STEPS_US
, MENU_SCROLL_DELAY_US
}};
80 static void menuMouseDown(WObjDescriptor
* desc
, XEvent
* event
);
81 static void menuExpose(WObjDescriptor
* desc
, XEvent
* event
);
82 static void menuTitleDoubleClick(WCoreWindow
* sender
, void *data
, XEvent
* event
);
83 static void menuTitleMouseDown(WCoreWindow
* sender
, void *data
, XEvent
* event
);
84 static void menuCloseClick(WCoreWindow
* sender
, void *data
, XEvent
* event
);
85 static void updateTexture(WMenu
* menu
);
86 static int saveMenuRecurs(WMPropList
* menus
, WScreen
* scr
, WMenu
* menu
);
87 static int restoreMenuRecurs(WScreen
* scr
, WMPropList
* menus
, WMenu
* menu
, char *path
);
88 static void selectEntry(WMenu
* menu
, int entry_no
);
89 static void closeCascade(WMenu
* menu
);
91 /****** Notification Observers ******/
93 static void appearanceObserver(void *self
, WMNotification
* notif
)
95 WMenu
*menu
= (WMenu
*) self
;
96 uintptr_t flags
= (uintptr_t)WMGetNotificationClientData(notif
);
98 if (!menu
->flags
.realized
)
101 if (WMGetNotificationName(notif
) == WNMenuAppearanceSettingsChanged
) {
102 if (flags
& WFontSettings
) {
103 menu
->flags
.realized
= 0;
106 if (flags
& WTextureSettings
) {
107 if (!menu
->flags
.brother
)
110 if (flags
& (WTextureSettings
| WColorSettings
)) {
113 } else if (menu
->flags
.titled
) {
115 if (flags
& WFontSettings
) {
116 menu
->flags
.realized
= 0;
119 if (flags
& WTextureSettings
) {
120 menu
->frame
->flags
.need_texture_remake
= 1;
122 if (flags
& (WColorSettings
| WTextureSettings
)) {
123 wFrameWindowPaint(menu
->frame
);
128 /************************************/
131 *----------------------------------------------------------------------
133 * Creates a new empty menu with the specified title. If main_menu
134 * is True, the created menu will be a main menu, which has some special
135 * properties such as being placed over other normal menus.
136 * If title is NULL, the menu will have no titlebar.
140 *----------------------------------------------------------------------
142 WMenu
*wMenuCreate(WScreen
* screen
, char *title
, int main_menu
)
145 static int brother
= 0;
148 menu
= wmalloc(sizeof(WMenu
));
150 memset(menu
, 0, sizeof(WMenu
));
152 #ifdef SINGLE_MENULEVEL
153 tmp
= WMSubmenuLevel
;
155 tmp
= (main_menu
? WMMainMenuLevel
: WMSubmenuLevel
);
158 flags
= WFF_SINGLE_STATE
| WFF_BORDER
;
160 flags
|= WFF_TITLEBAR
| WFF_RIGHT_BUTTON
;
161 menu
->flags
.titled
= 1;
164 wFrameWindowCreate(screen
, tmp
, 8, 2, 1, 1, &wPreferences
.menu_title_clearance
, flags
,
165 screen
->menu_title_texture
, NULL
,
166 screen
->menu_title_color
, &screen
->menu_title_font
);
168 menu
->frame
->core
->descriptor
.parent
= menu
;
169 menu
->frame
->core
->descriptor
.parent_type
= WCLASS_MENU
;
170 menu
->frame
->core
->descriptor
.handle_mousedown
= menuMouseDown
;
172 wFrameWindowHideButton(menu
->frame
, WFF_RIGHT_BUTTON
);
175 menu
->frame
->title
= wstrdup(title
);
178 menu
->frame
->flags
.justification
= WTJ_LEFT
;
180 menu
->frame
->rbutton_image
= screen
->b_pixmaps
[WBUT_CLOSE
];
183 menu
->alloced_entries
= 0;
184 menu
->selected_entry
= -1;
185 menu
->entries
= NULL
;
187 menu
->frame_x
= screen
->app_menu_x
;
188 menu
->frame_y
= screen
->app_menu_y
;
190 menu
->frame
->child
= menu
;
192 menu
->flags
.lowered
= 0;
196 /* setup object descriptors */
197 menu
->frame
->on_mousedown_titlebar
= menuTitleMouseDown
;
198 menu
->frame
->on_dblclick_titlebar
= menuTitleDoubleClick
;
201 menu
->frame
->on_click_right
= menuCloseClick
;
203 menu
->menu
= wCoreCreate(menu
->frame
->core
, 0, menu
->frame
->top_width
, menu
->frame
->core
->width
, 10);
205 menu
->menu
->descriptor
.parent
= menu
;
206 menu
->menu
->descriptor
.parent_type
= WCLASS_MENU
;
207 menu
->menu
->descriptor
.handle_expose
= menuExpose
;
208 menu
->menu
->descriptor
.handle_mousedown
= menuMouseDown
;
210 menu
->menu_texture_data
= None
;
212 XMapWindow(dpy
, menu
->menu
->window
);
218 menu
->brother
= wMenuCreate(screen
, title
, main_menu
);
220 menu
->brother
->flags
.brother
= 1;
221 menu
->brother
->brother
= menu
;
223 WMAddNotificationObserver(appearanceObserver
, menu
, WNMenuAppearanceSettingsChanged
, menu
);
225 WMAddNotificationObserver(appearanceObserver
, menu
, WNMenuTitleAppearanceSettingsChanged
, menu
);
230 WMenu
*wMenuCreateForApp(WScreen
* screen
, char *title
, int main_menu
)
234 menu
= wMenuCreate(screen
, title
, main_menu
);
237 menu
->flags
.app_menu
= 1;
238 menu
->brother
->flags
.app_menu
= 1;
243 static void insertEntry(WMenu
* menu
, WMenuEntry
* entry
, int index
)
247 for (i
= menu
->entry_no
- 1; i
>= index
; i
--) {
248 menu
->entries
[i
]->order
++;
249 menu
->entries
[i
+ 1] = menu
->entries
[i
];
251 menu
->entries
[index
] = entry
;
254 WMenuEntry
*wMenuInsertCallback(WMenu
* menu
, int index
, char *text
,
255 void (*callback
) (WMenu
* menu
, WMenuEntry
* entry
), void *clientdata
)
259 menu
->flags
.realized
= 0;
260 menu
->brother
->flags
.realized
= 0;
262 /* reallocate array if it's too small */
263 if (menu
->entry_no
>= menu
->alloced_entries
) {
266 tmp
= wrealloc(menu
->entries
, sizeof(WMenuEntry
) * (menu
->alloced_entries
+ 5));
269 menu
->alloced_entries
+= 5;
271 menu
->brother
->entries
= tmp
;
272 menu
->brother
->alloced_entries
= menu
->alloced_entries
;
274 entry
= wmalloc(sizeof(WMenuEntry
));
275 memset(entry
, 0, sizeof(WMenuEntry
));
276 entry
->flags
.enabled
= 1;
277 entry
->text
= wstrdup(text
);
279 entry
->clientdata
= clientdata
;
280 entry
->callback
= callback
;
281 if (index
< 0 || index
>= menu
->entry_no
) {
282 entry
->order
= menu
->entry_no
;
283 menu
->entries
[menu
->entry_no
] = entry
;
285 entry
->order
= index
;
286 insertEntry(menu
, entry
, index
);
290 menu
->brother
->entry_no
= menu
->entry_no
;
295 void wMenuEntrySetCascade(WMenu
* menu
, WMenuEntry
* entry
, WMenu
* cascade
)
297 WMenu
*brother
= menu
->brother
;
300 assert(menu
->flags
.brother
== 0);
302 if (entry
->cascade
>= 0) {
303 menu
->flags
.realized
= 0;
304 brother
->flags
.realized
= 0;
307 cascade
->parent
= menu
;
309 cascade
->brother
->parent
= brother
;
312 for (i
= 0; i
< menu
->cascade_no
; i
++) {
313 if (menu
->cascades
[i
] == NULL
) {
314 menu
->cascades
[i
] = cascade
;
315 brother
->cascades
[i
] = cascade
->brother
;
322 entry
->cascade
= menu
->cascade_no
;
324 menu
->cascades
= wrealloc(menu
->cascades
, sizeof(WMenu
) * (menu
->cascade_no
+ 1));
325 menu
->cascades
[menu
->cascade_no
++] = cascade
;
327 brother
->cascades
= wrealloc(brother
->cascades
, sizeof(WMenu
) * (brother
->cascade_no
+ 1));
328 brother
->cascades
[brother
->cascade_no
++] = cascade
->brother
;
331 if (menu
->flags
.lowered
) {
333 cascade
->flags
.lowered
= 1;
334 ChangeStackingLevel(cascade
->frame
->core
, WMNormalLevel
);
336 cascade
->brother
->flags
.lowered
= 1;
337 ChangeStackingLevel(cascade
->brother
->frame
->core
, WMNormalLevel
);
340 if (!menu
->flags
.realized
)
344 void wMenuEntryRemoveCascade(WMenu
* menu
, WMenuEntry
* entry
)
346 assert(menu
->flags
.brother
== 0);
348 /* destroy cascade menu */
349 if (entry
->cascade
>= 0 && menu
->cascades
&& menu
->cascades
[entry
->cascade
] != NULL
) {
351 wMenuDestroy(menu
->cascades
[entry
->cascade
], True
);
353 menu
->cascades
[entry
->cascade
] = NULL
;
354 menu
->brother
->cascades
[entry
->cascade
] = NULL
;
360 void wMenuRemoveItem(WMenu
* menu
, int index
)
364 if (menu
->flags
.brother
) {
365 wMenuRemoveItem(menu
->brother
, index
);
369 if (index
>= menu
->entry_no
)
372 /* destroy cascade menu */
373 wMenuEntryRemoveCascade(menu
, menu
->entries
[index
]);
375 /* destroy unshared data */
377 if (menu
->entries
[index
]->text
)
378 wfree(menu
->entries
[index
]->text
);
380 if (menu
->entries
[index
]->rtext
)
381 wfree(menu
->entries
[index
]->rtext
);
383 if (menu
->entries
[index
]->free_cdata
&& menu
->entries
[index
]->clientdata
)
384 (*menu
->entries
[index
]->free_cdata
) (menu
->entries
[index
]->clientdata
);
386 wfree(menu
->entries
[index
]);
388 for (i
= index
; i
< menu
->entry_no
- 1; i
++) {
389 menu
->entries
[i
+ 1]->order
--;
390 menu
->entries
[i
] = menu
->entries
[i
+ 1];
393 menu
->brother
->entry_no
--;
396 static Pixmap
renderTexture(WMenu
* menu
)
404 WScreen
*scr
= menu
->menu
->screen_ptr
;
405 WTexture
*texture
= scr
->menu_item_texture
;
407 if (wPreferences
.menu_style
== MS_NORMAL
) {
408 img
= wTextureRenderImage(texture
, menu
->menu
->width
, menu
->entry_height
, WREL_MENUENTRY
);
410 img
= wTextureRenderImage(texture
, menu
->menu
->width
, menu
->menu
->height
+ 1, WREL_MENUENTRY
);
413 wwarning(_("could not render texture: %s"), RMessageForError(RErrorCode
));
418 if (wPreferences
.menu_style
== MS_SINGLE_TEXTURE
) {
420 light
.red
= light
.green
= light
.blue
= 80;
423 dark
.red
= dark
.green
= dark
.blue
= 0;
426 mid
.red
= mid
.green
= mid
.blue
= 40;
428 for (i
= 1; i
< menu
->entry_no
; i
++) {
429 ROperateLine(img
, RSubtractOperation
, 0, i
* menu
->entry_height
- 2,
430 menu
->menu
->width
- 1, i
* menu
->entry_height
- 2, &mid
);
432 RDrawLine(img
, 0, i
* menu
->entry_height
- 1,
433 menu
->menu
->width
- 1, i
* menu
->entry_height
- 1, &dark
);
435 ROperateLine(img
, RAddOperation
, 0, i
* menu
->entry_height
,
436 menu
->menu
->width
- 1, i
* menu
->entry_height
, &light
);
439 if (!RConvertImage(scr
->rcontext
, img
, &pix
)) {
440 wwarning(_("error rendering image:%s"), RMessageForError(RErrorCode
));
447 static void updateTexture(WMenu
* menu
)
449 WScreen
*scr
= menu
->menu
->screen_ptr
;
451 /* setup background texture */
452 if (scr
->menu_item_texture
->any
.type
!= WTEX_SOLID
) {
453 if (!menu
->flags
.brother
) {
454 FREE_PIXMAP(menu
->menu_texture_data
);
456 menu
->menu_texture_data
= renderTexture(menu
);
458 XSetWindowBackgroundPixmap(dpy
, menu
->menu
->window
, menu
->menu_texture_data
);
459 XClearWindow(dpy
, menu
->menu
->window
);
461 XSetWindowBackgroundPixmap(dpy
, menu
->brother
->menu
->window
, menu
->menu_texture_data
);
462 XClearWindow(dpy
, menu
->brother
->menu
->window
);
465 XSetWindowBackground(dpy
, menu
->menu
->window
, scr
->menu_item_texture
->any
.color
.pixel
);
466 XClearWindow(dpy
, menu
->menu
->window
);
470 void wMenuRealize(WMenu
* menu
)
473 int width
, rwidth
, mrwidth
, mwidth
;
474 int theight
, twidth
, eheight
;
475 WScreen
*scr
= menu
->frame
->screen_ptr
;
476 static int brother_done
= 0;
481 wMenuRealize(menu
->brother
);
485 flags
= WFF_SINGLE_STATE
| WFF_BORDER
;
486 if (menu
->flags
.titled
)
487 flags
|= WFF_TITLEBAR
| WFF_RIGHT_BUTTON
;
489 wFrameWindowUpdateBorders(menu
->frame
, flags
);
491 if (menu
->flags
.titled
) {
492 twidth
= WMWidthOfString(scr
->menu_title_font
, menu
->frame
->title
, strlen(menu
->frame
->title
));
493 theight
= menu
->frame
->top_width
;
494 twidth
+= theight
+ (wPreferences
.new_style
? 16 : 8);
499 eheight
= WMFontHeight(scr
->menu_entry_font
) + 6 + wPreferences
.menu_text_clearance
* 2;
500 menu
->entry_height
= eheight
;
503 for (i
= 0; i
< menu
->entry_no
; i
++) {
506 /* search widest text */
507 text
= menu
->entries
[i
]->text
;
508 width
= WMWidthOfString(scr
->menu_entry_font
, text
, strlen(text
)) + 10;
510 if (menu
->entries
[i
]->flags
.indicator
) {
511 width
+= MENU_INDICATOR_SPACE
;
517 /* search widest text on right */
518 text
= menu
->entries
[i
]->rtext
;
520 rwidth
= WMWidthOfString(scr
->menu_entry_font
, text
, strlen(text
))
522 else if (menu
->entries
[i
]->cascade
>= 0)
527 if (rwidth
> mrwidth
)
535 wCoreConfigure(menu
->menu
, 0, theight
, mwidth
, menu
->entry_no
* eheight
- 1);
537 wFrameWindowResize(menu
->frame
, mwidth
, menu
->entry_no
* eheight
- 1
538 + menu
->frame
->top_width
+ menu
->frame
->bottom_width
);
542 menu
->flags
.realized
= 1;
544 if (menu
->flags
.mapped
)
546 if (menu
->brother
->flags
.mapped
)
547 wMenuPaint(menu
->brother
);
550 void wMenuDestroy(WMenu
* menu
, int recurse
)
554 WMRemoveNotificationObserver(menu
);
556 /* remove any pending timers */
558 WMDeleteTimerHandler(menu
->timer
);
561 /* call destroy handler */
562 if (menu
->on_destroy
)
563 (*menu
->on_destroy
) (menu
);
565 /* Destroy items if this menu own them. If this is the "brother" menu,
566 * leave them alone as it is shared by them.
568 if (!menu
->flags
.brother
) {
569 for (i
= 0; i
< menu
->entry_no
; i
++) {
571 wfree(menu
->entries
[i
]->text
);
573 if (menu
->entries
[i
]->rtext
)
574 wfree(menu
->entries
[i
]->rtext
);
577 if (menu
->entries
[i
]->instances
) {
578 WMReleasePropList(menu
->entries
[i
]->instances
);
580 #endif /* USER_MENU */
582 if (menu
->entries
[i
]->free_cdata
&& menu
->entries
[i
]->clientdata
) {
583 (*menu
->entries
[i
]->free_cdata
) (menu
->entries
[i
]->clientdata
);
585 wfree(menu
->entries
[i
]);
589 for (i
= 0; i
< menu
->cascade_no
; i
++) {
590 if (menu
->cascades
[i
]) {
591 if (menu
->cascades
[i
]->flags
.brother
)
592 wMenuDestroy(menu
->cascades
[i
]->brother
, recurse
);
594 wMenuDestroy(menu
->cascades
[i
], recurse
);
600 wfree(menu
->entries
);
604 FREE_PIXMAP(menu
->menu_texture_data
);
607 wfree(menu
->cascades
);
609 wCoreDestroy(menu
->menu
);
610 wFrameWindowDestroy(menu
->frame
);
612 /* destroy copy of this menu */
613 if (!menu
->flags
.brother
&& menu
->brother
)
614 wMenuDestroy(menu
->brother
, False
);
624 static void drawFrame(WScreen
* scr
, Drawable win
, int y
, int w
, int h
, int type
)
630 segs
[i
].x1
= segs
[i
].x2
= w
- 1;
632 segs
[i
].y2
= y
+ h
- 1;
634 if (type
!= F_TOP
&& type
!= F_NONE
) {
636 segs
[i
].y1
= segs
[i
].y2
= y
+ h
- 2;
640 XDrawSegments(dpy
, win
, scr
->menu_item_auxtexture
->dim_gc
, segs
, i
);
646 segs
[i
].y2
= y
+ h
- 1;
648 if (type
!= F_BOTTOM
&& type
!= F_NONE
) {
655 XDrawSegments(dpy
, win
, scr
->menu_item_auxtexture
->light_gc
, segs
, i
);
657 if (type
!= F_TOP
&& type
!= F_NONE
)
658 XDrawLine(dpy
, win
, scr
->menu_item_auxtexture
->dark_gc
, 0, y
+ h
- 1, w
- 1, y
+ h
- 1);
661 static void paintEntry(WMenu
* menu
, int index
, int selected
)
663 WScreen
*scr
= menu
->frame
->screen_ptr
;
664 Window win
= menu
->menu
->window
;
665 WMenuEntry
*entry
= menu
->entries
[index
];
671 if (!menu
->flags
.realized
)
673 h
= menu
->entry_height
;
674 w
= menu
->menu
->width
;
677 light
= scr
->menu_item_auxtexture
->light_gc
;
678 dim
= scr
->menu_item_auxtexture
->dim_gc
;
679 dark
= scr
->menu_item_auxtexture
->dark_gc
;
681 if (wPreferences
.menu_style
== MS_FLAT
&& menu
->entry_no
> 1) {
684 else if (index
== menu
->entry_no
- 1)
692 /* paint background */
694 XFillRectangle(dpy
, win
, WMColorGC(scr
->select_color
), 1, y
+ 1, w
- 2, h
- 3);
695 if (scr
->menu_item_texture
->any
.type
== WTEX_SOLID
)
696 drawFrame(scr
, win
, y
, w
, h
, type
);
698 if (scr
->menu_item_texture
->any
.type
== WTEX_SOLID
) {
699 XClearArea(dpy
, win
, 0, y
+ 1, w
- 1, h
- 3, False
);
701 drawFrame(scr
, win
, y
, w
, h
, type
);
703 XClearArea(dpy
, win
, 0, y
, w
, h
, False
);
708 if (entry
->flags
.enabled
)
709 color
= scr
->select_text_color
;
711 color
= scr
->dtext_color
;
712 } else if (!entry
->flags
.enabled
) {
713 color
= scr
->dtext_color
;
715 color
= scr
->mtext_color
;
719 if (entry
->flags
.indicator
)
720 x
+= MENU_INDICATOR_SPACE
+ 2;
722 WMDrawString(scr
->wmscreen
, win
, color
, scr
->menu_entry_font
,
723 x
, 3 + y
+ wPreferences
.menu_text_clearance
, entry
->text
, strlen(entry
->text
));
725 if (entry
->cascade
>= 0) {
726 /* draw the cascade indicator */
727 XDrawLine(dpy
, win
, dim
, w
- 11, y
+ 6, w
- 6, y
+ h
/ 2 - 1);
728 XDrawLine(dpy
, win
, light
, w
- 11, y
+ h
- 8, w
- 6, y
+ h
/ 2 - 1);
729 XDrawLine(dpy
, win
, dark
, w
- 12, y
+ 6, w
- 12, y
+ h
- 8);
733 if (entry
->flags
.indicator
&& entry
->flags
.indicator_on
) {
737 switch (entry
->flags
.indicator_type
) {
739 indicator
= scr
->menu_check_indicator
;
742 indicator
= scr
->menu_mini_indicator
;
745 indicator
= scr
->menu_hide_indicator
;
748 indicator
= scr
->menu_shade_indicator
;
752 indicator
= scr
->menu_radio_indicator
;
756 iw
= indicator
->width
;
757 ih
= indicator
->height
;
758 XSetClipMask(dpy
, scr
->copy_gc
, indicator
->mask
);
759 XSetClipOrigin(dpy
, scr
->copy_gc
, 5, y
+ (h
- ih
) / 2);
761 if (entry
->flags
.enabled
) {
762 XSetForeground(dpy
, scr
->copy_gc
, WMColorPixel(scr
->select_text_color
));
764 XSetForeground(dpy
, scr
->copy_gc
, WMColorPixel(scr
->dtext_color
));
767 if (entry
->flags
.enabled
) {
768 XSetForeground(dpy
, scr
->copy_gc
, WMColorPixel(scr
->mtext_color
));
770 XSetForeground(dpy
, scr
->copy_gc
, WMColorPixel(scr
->dtext_color
));
773 XFillRectangle(dpy
, win
, scr
->copy_gc
, 5, y
+ (h
- ih
) / 2, iw
, ih
);
775 XCopyArea(dpy, indicator->image, win, scr->copy_gc, 0, 0,
776 iw, ih, 5, y+(h-ih)/2);
778 XSetClipOrigin(dpy
, scr
->copy_gc
, 0, 0);
781 /* draw right text */
783 if (entry
->rtext
&& entry
->cascade
< 0) {
784 tw
= WMWidthOfString(scr
->menu_entry_font
, entry
->rtext
, strlen(entry
->rtext
));
786 WMDrawString(scr
->wmscreen
, win
, color
, scr
->menu_entry_font
, w
- 6 - tw
,
787 y
+ 3 + wPreferences
.menu_text_clearance
, entry
->rtext
, strlen(entry
->rtext
));
791 static void move_menus(WMenu
* menu
, int x
, int y
)
793 while (menu
->parent
) {
796 if (!wPreferences
.align_menus
&& menu
->selected_entry
>= 0) {
797 y
-= menu
->selected_entry
* menu
->entry_height
;
800 wMenuMove(menu
, x
, y
, True
);
803 static void makeVisible(WMenu
* menu
)
805 WScreen
*scr
= menu
->frame
->screen_ptr
;
806 int x1
, y1
, x2
, y2
, new_x
, new_y
, move
;
807 WMRect rect
= wGetRectForHead(scr
, wGetHeadForPointerLocation(scr
));
809 if (menu
->entry_no
< 0)
813 y1
= menu
->frame_y
+ menu
->frame
->top_width
+ menu
->selected_entry
* menu
->entry_height
;
814 x2
= x1
+ MENUW(menu
);
815 y2
= y1
+ menu
->entry_height
;
821 if (x1
< rect
.pos
.x
) {
824 } else if (x2
>= rect
.pos
.x
+ rect
.size
.width
) {
825 new_x
= rect
.pos
.x
+ rect
.size
.width
- MENUW(menu
) - 1;
829 if (y1
< rect
.pos
.y
) {
832 } else if (y2
>= rect
.pos
.y
+ rect
.size
.height
) {
833 new_y
= rect
.pos
.y
+ rect
.size
.height
- menu
->entry_height
- 1;
837 new_y
= new_y
- menu
->frame
->top_width
- menu
->selected_entry
* menu
->entry_height
;
838 move_menus(menu
, new_x
, new_y
);
841 static int check_key(WMenu
* menu
, XKeyEvent
* event
)
846 if (XLookupString(event
, buffer
, 32, NULL
, NULL
) < 1)
849 ch
= toupper(buffer
[0]);
851 s
= (menu
->selected_entry
>= 0 ? menu
->selected_entry
+ 1 : 0);
854 for (i
= s
; i
< menu
->entry_no
; i
++) {
855 if (ch
== toupper(menu
->entries
[i
]->text
[0])) {
859 /* no match. Retry from start, if previous started from a selected entry */
867 static int keyboardMenu(WMenu
* menu
)
870 KeySym ksym
= NoSymbol
;
874 int old_pos_x
= menu
->frame_x
;
875 int old_pos_y
= menu
->frame_y
;
876 int new_x
= old_pos_x
, new_y
= old_pos_y
;
877 WMRect rect
= wGetRectForHead(menu
->frame
->screen_ptr
,
878 wGetHeadForPointerLocation(menu
->frame
->screen_ptr
));
880 if (menu
->flags
.editing
)
883 XGrabKeyboard(dpy
, menu
->frame
->core
->window
, True
, GrabModeAsync
, GrabModeAsync
, CurrentTime
);
885 if (menu
->frame_y
+ menu
->frame
->top_width
>= rect
.pos
.y
+ rect
.size
.height
)
886 new_y
= rect
.pos
.y
+ rect
.size
.height
- menu
->frame
->top_width
;
888 if (menu
->frame_x
+ MENUW(menu
) >= rect
.pos
.x
+ rect
.size
.width
)
889 new_x
= rect
.pos
.x
+ rect
.size
.width
- MENUW(menu
) - 1;
891 move_menus(menu
, new_x
, new_y
);
893 while (!done
&& menu
->flags
.mapped
) {
894 XAllowEvents(dpy
, AsyncKeyboard
, CurrentTime
);
895 WMMaskEvent(dpy
, ExposureMask
| ButtonMotionMask
| ButtonPressMask
896 | ButtonReleaseMask
| KeyPressMask
| KeyReleaseMask
| SubstructureNotifyMask
, &event
);
898 switch (event
.type
) {
900 ksym
= XLookupKeysym(&event
.xkey
, 0);
910 selectEntry(menu
, 0);
918 selectEntry(menu
, menu
->entry_no
- 1);
929 if (menu
->selected_entry
<= 0)
930 selectEntry(menu
, menu
->entry_no
- 1);
932 selectEntry(menu
, menu
->selected_entry
- 1);
943 if (menu
->selected_entry
< 0)
944 selectEntry(menu
, 0);
945 else if (menu
->selected_entry
== menu
->entry_no
- 1)
946 selectEntry(menu
, 0);
947 else if (menu
->selected_entry
< menu
->entry_no
- 1)
948 selectEntry(menu
, menu
->selected_entry
+ 1);
959 if (menu
->selected_entry
>= 0) {
961 entry
= menu
->entries
[menu
->selected_entry
];
963 if (entry
->cascade
>= 0 && menu
->cascades
964 && menu
->cascades
[entry
->cascade
]->entry_no
> 0) {
966 XUngrabKeyboard(dpy
, CurrentTime
);
968 selectEntry(menu
->cascades
[entry
->cascade
], 0);
969 if (!keyboardMenu(menu
->cascades
[entry
->cascade
]))
972 XGrabKeyboard(dpy
, menu
->frame
->core
->window
, True
,
973 GrabModeAsync
, GrabModeAsync
, CurrentTime
);
985 if (menu
->parent
!= NULL
&& menu
->parent
->selected_entry
>= 0) {
986 selectEntry(menu
, -1);
987 move_menus(menu
, old_pos_x
, old_pos_y
);
1000 index
= check_key(menu
, &event
.xkey
);
1002 selectEntry(menu
, index
);
1008 if (event
.type
== ButtonPress
)
1011 WMHandleEvent(&event
);
1015 XUngrabKeyboard(dpy
, CurrentTime
);
1017 if (done
== 2 && menu
->selected_entry
>= 0) {
1018 entry
= menu
->entries
[menu
->selected_entry
];
1023 if (entry
&& entry
->callback
!= NULL
&& entry
->flags
.enabled
&& entry
->cascade
< 0) {
1024 #if (MENU_BLINK_COUNT > 0)
1025 int sel
= menu
->selected_entry
;
1028 for (i
= 0; i
< MENU_BLINK_COUNT
; i
++) {
1029 paintEntry(menu
, sel
, False
);
1031 wusleep(MENU_BLINK_DELAY
);
1032 paintEntry(menu
, sel
, True
);
1034 wusleep(MENU_BLINK_DELAY
);
1037 selectEntry(menu
, -1);
1039 if (!menu
->flags
.buttoned
) {
1041 move_menus(menu
, old_pos_x
, old_pos_y
);
1045 (*entry
->callback
) (menu
, entry
);
1047 if (!menu
->flags
.buttoned
) {
1049 move_menus(menu
, old_pos_x
, old_pos_y
);
1051 selectEntry(menu
, -1);
1054 /* returns True if returning from a submenu to a parent menu,
1055 * False if exiting from menu */
1059 void wMenuMapAt(WMenu
* menu
, int x
, int y
, int keyboard
)
1061 WMRect rect
= wGetRectForHead(menu
->frame
->screen_ptr
,
1062 wGetHeadForPointerLocation(menu
->frame
->screen_ptr
));
1064 if (!menu
->flags
.realized
) {
1065 menu
->flags
.realized
= 1;
1068 if (!menu
->flags
.mapped
) {
1069 if (wPreferences
.wrap_menus
) {
1074 if (x
+ MENUW(menu
) > rect
.pos
.x
+ rect
.size
.width
)
1075 x
= rect
.pos
.x
+ rect
.size
.width
- MENUW(menu
);
1076 if (y
+ MENUH(menu
) > rect
.pos
.y
+ rect
.size
.height
)
1077 y
= rect
.pos
.y
+ rect
.size
.height
- MENUH(menu
);
1080 XMoveWindow(dpy
, menu
->frame
->core
->window
, x
, y
);
1081 menu
->frame_x
= (x
< 0) ? 0 : x
;
1082 menu
->frame_y
= (y
< 0) ? 0 : y
;
1083 XMapWindow(dpy
, menu
->frame
->core
->window
);
1084 wRaiseFrame(menu
->frame
->core
);
1085 menu
->flags
.mapped
= 1;
1087 selectEntry(menu
, 0);
1094 void wMenuMap(WMenu
* menu
)
1096 if (!menu
->flags
.realized
) {
1097 menu
->flags
.realized
= 1;
1100 if (menu
->flags
.app_menu
&& menu
->parent
== NULL
) {
1101 menu
->frame_x
= menu
->frame
->screen_ptr
->app_menu_x
;
1102 menu
->frame_y
= menu
->frame
->screen_ptr
->app_menu_y
;
1103 XMoveWindow(dpy
, menu
->frame
->core
->window
, menu
->frame_x
, menu
->frame_y
);
1105 XMapWindow(dpy
, menu
->frame
->core
->window
);
1106 wRaiseFrame(menu
->frame
->core
);
1107 menu
->flags
.mapped
= 1;
1110 void wMenuUnmap(WMenu
* menu
)
1114 XUnmapWindow(dpy
, menu
->frame
->core
->window
);
1115 if (menu
->flags
.titled
&& menu
->flags
.buttoned
) {
1116 wFrameWindowHideButton(menu
->frame
, WFF_RIGHT_BUTTON
);
1118 menu
->flags
.buttoned
= 0;
1119 menu
->flags
.mapped
= 0;
1120 menu
->flags
.open_to_left
= 0;
1122 for (i
= 0; i
< menu
->cascade_no
; i
++) {
1123 if (menu
->cascades
[i
] != NULL
1124 && menu
->cascades
[i
]->flags
.mapped
&& !menu
->cascades
[i
]->flags
.buttoned
) {
1126 wMenuUnmap(menu
->cascades
[i
]);
1129 menu
->selected_entry
= -1;
1132 void wMenuPaint(WMenu
* menu
)
1136 if (!menu
->flags
.mapped
) {
1141 for (i
= 0; i
< menu
->entry_no
; i
++) {
1142 paintEntry(menu
, i
, i
== menu
->selected_entry
);
1146 void wMenuSetEnabled(WMenu
* menu
, int index
, int enable
)
1148 if (index
>= menu
->entry_no
)
1150 menu
->entries
[index
]->flags
.enabled
= enable
;
1151 paintEntry(menu
, index
, index
== menu
->selected_entry
);
1152 paintEntry(menu
->brother
, index
, index
== menu
->selected_entry
);
1155 /* ====================================================================== */
1157 static void editEntry(WMenu
* menu
, WMenuEntry
* entry
)
1161 WObjDescriptor
*desc
;
1167 menu
->flags
.editing
= 1;
1169 text
= wTextCreate(menu
->menu
, 1, menu
->entry_height
* entry
->order
,
1170 menu
->menu
->width
- 2, menu
->entry_height
- 1);
1172 wTextPutText(text
, entry
->text
);
1173 XGetInputFocus(dpy
, &old_focus
, &old_revert
);
1174 XSetInputFocus(dpy
, text
->core
->window
, RevertToNone
, CurrentTime
);
1176 if (XGrabKeyboard(dpy
, text
->core
->window
, True
, GrabModeAsync
, GrabModeAsync
, CurrentTime
) != GrabSuccess
) {
1177 wwarning(_("could not grab keyboard"));
1180 wSetFocusTo(menu
->frame
->screen_ptr
, menu
->frame
->screen_ptr
->focused_window
);
1184 while (!done
&& !text
->done
) {
1186 XAllowEvents(dpy
, AsyncKeyboard
| AsyncPointer
, CurrentTime
);
1188 WMNextEvent(dpy
, &event
);
1190 if (XFindContext(dpy
, event
.xany
.window
, wWinContext
, (XPointer
*) & desc
) == XCNOENT
)
1193 if ((desc
!= NULL
) && (desc
->handle_anything
!= NULL
)) {
1195 (*desc
->handle_anything
) (desc
, &event
);
1198 switch (event
.type
) {
1200 XAllowEvents(dpy
, ReplayPointer
, CurrentTime
);
1204 WMHandleEvent(&event
);
1210 XSetInputFocus(dpy
, old_focus
, old_revert
, CurrentTime
);
1212 wSetFocusTo(menu
->frame
->screen_ptr
, menu
->frame
->screen_ptr
->focused_window
);
1214 t
= wTextGetText(text
);
1215 /* if !t, the user has canceled editing */
1219 entry
->text
= wstrdup(t
);
1221 menu
->flags
.realized
= 0;
1225 XUngrabKeyboard(dpy
, CurrentTime
);
1227 if (t
&& menu
->on_edit
)
1228 (*menu
->on_edit
) (menu
, entry
);
1230 menu
->flags
.editing
= 0;
1232 if (!menu
->flags
.realized
)
1236 static void selectEntry(WMenu
* menu
, int entry_no
)
1242 if (menu
->entries
== NULL
)
1245 if (entry_no
>= menu
->entry_no
)
1248 old_entry
= menu
->selected_entry
;
1249 menu
->selected_entry
= entry_no
;
1251 if (old_entry
!= entry_no
) {
1253 /* unselect previous entry */
1254 if (old_entry
>= 0) {
1255 paintEntry(menu
, old_entry
, False
);
1256 entry
= menu
->entries
[old_entry
];
1259 if (entry
->cascade
>= 0 && menu
->cascades
) {
1260 if (!menu
->cascades
[entry
->cascade
]->flags
.buttoned
) {
1261 wMenuUnmap(menu
->cascades
[entry
->cascade
]);
1267 menu
->selected_entry
= -1;
1270 entry
= menu
->entries
[entry_no
];
1272 if (entry
->cascade
>= 0 && menu
->cascades
&& entry
->flags
.enabled
) {
1273 /* Callback for when the submenu is opened.
1275 submenu
= menu
->cascades
[entry
->cascade
];
1276 if (submenu
&& submenu
->flags
.brother
)
1277 submenu
= submenu
->brother
;
1279 if (entry
->callback
) {
1280 /* Only call the callback if the submenu is not yet mapped.
1282 if (menu
->flags
.brother
) {
1283 if (!submenu
|| !submenu
->flags
.mapped
)
1284 (*entry
->callback
) (menu
->brother
, entry
);
1286 if (!submenu
|| !submenu
->flags
.buttoned
)
1287 (*entry
->callback
) (menu
, entry
);
1291 /* the submenu menu might have changed */
1292 submenu
= menu
->cascades
[entry
->cascade
];
1295 if (!submenu
->flags
.mapped
) {
1298 if (!submenu
->flags
.realized
)
1299 wMenuRealize(submenu
);
1300 if (wPreferences
.wrap_menus
) {
1301 if (menu
->flags
.open_to_left
)
1302 submenu
->flags
.open_to_left
= 1;
1304 if (submenu
->flags
.open_to_left
) {
1305 x
= menu
->frame_x
- MENUW(submenu
);
1308 submenu
->flags
.open_to_left
= 0;
1311 x
= menu
->frame_x
+ MENUW(menu
);
1313 if (x
+ MENUW(submenu
)
1314 >= menu
->frame
->screen_ptr
->scr_width
) {
1316 x
= menu
->frame_x
- MENUW(submenu
);
1317 submenu
->flags
.open_to_left
= 1;
1321 x
= menu
->frame_x
+ MENUW(menu
);
1324 if (wPreferences
.align_menus
) {
1327 y
= menu
->frame_y
+ menu
->entry_height
* entry_no
;
1328 if (menu
->flags
.titled
)
1329 y
+= menu
->frame
->top_width
;
1330 if (menu
->cascades
[entry
->cascade
]->flags
.titled
)
1331 y
-= menu
->cascades
[entry
->cascade
]->frame
->top_width
;
1334 wMenuMapAt(menu
->cascades
[entry
->cascade
], x
, y
, False
);
1335 menu
->cascades
[entry
->cascade
]->parent
= menu
;
1340 paintEntry(menu
, entry_no
, True
);
1344 static WMenu
*findMenu(WScreen
* scr
, int *x_ret
, int *y_ret
)
1347 WObjDescriptor
*desc
;
1348 Window root_ret
, win
, junk_win
;
1352 XQueryPointer(dpy
, scr
->root_win
, &root_ret
, &win
, &x
, &y
, &wx
, &wy
, &mask
);
1357 if (XFindContext(dpy
, win
, wWinContext
, (XPointer
*) & desc
) == XCNOENT
)
1360 if (desc
->parent_type
== WCLASS_MENU
) {
1361 menu
= (WMenu
*) desc
->parent
;
1362 XTranslateCoordinates(dpy
, root_ret
, menu
->menu
->window
, wx
, wy
, x_ret
, y_ret
, &junk_win
);
1368 static void closeCascade(WMenu
* menu
)
1370 WMenu
*parent
= menu
->parent
;
1372 if (menu
->flags
.brother
|| (!menu
->flags
.buttoned
&& (!menu
->flags
.app_menu
|| menu
->parent
!= NULL
))) {
1374 selectEntry(menu
, -1);
1376 #if (MENU_BLINK_DELAY > 2)
1377 wusleep(MENU_BLINK_DELAY
/ 2);
1380 while (parent
!= NULL
1381 && (parent
->parent
!= NULL
|| !parent
->flags
.app_menu
|| parent
->flags
.brother
)
1382 && !parent
->flags
.buttoned
) {
1383 selectEntry(parent
, -1);
1385 parent
= parent
->parent
;
1388 selectEntry(parent
, -1);
1392 static void closeBrotherCascadesOf(WMenu
* menu
)
1397 for (i
= 0; i
< menu
->cascade_no
; i
++) {
1398 if (menu
->cascades
[i
]->flags
.brother
) {
1399 tmp
= menu
->cascades
[i
];
1401 tmp
= menu
->cascades
[i
]->brother
;
1403 if (tmp
->flags
.mapped
) {
1404 selectEntry(tmp
->parent
, -1);
1405 closeBrotherCascadesOf(tmp
);
1411 #define getEntryAt(menu, x, y) ((y)<0 ? -1 : (y)/(menu->entry_height))
1413 static WMenu
*parentMenu(WMenu
* menu
)
1418 if (menu
->flags
.buttoned
)
1421 while (menu
->parent
&& menu
->parent
->flags
.mapped
) {
1422 parent
= menu
->parent
;
1423 if (parent
->selected_entry
< 0)
1425 entry
= parent
->entries
[parent
->selected_entry
];
1426 if (!entry
->flags
.enabled
|| entry
->cascade
< 0 || !parent
->cascades
||
1427 parent
->cascades
[entry
->cascade
] != menu
)
1430 if (menu
->flags
.buttoned
)
1438 * Will raise the passed menu, if submenu = 0
1439 * If submenu > 0 will also raise all mapped submenus
1440 * until the first buttoned one
1441 * If submenu < 0 will also raise all mapped parent menus
1442 * until the first buttoned one
1445 static void raiseMenus(WMenu
* menu
, int submenus
)
1453 wRaiseFrame(menu
->frame
->core
);
1455 if (submenus
> 0 && menu
->selected_entry
>= 0) {
1456 i
= menu
->entries
[menu
->selected_entry
]->cascade
;
1457 if (i
>= 0 && menu
->cascades
) {
1458 submenu
= menu
->cascades
[i
];
1459 if (submenu
->flags
.mapped
&& !submenu
->flags
.buttoned
)
1460 raiseMenus(submenu
, submenus
);
1463 if (submenus
< 0 && !menu
->flags
.buttoned
&& menu
->parent
&& menu
->parent
->flags
.mapped
)
1464 raiseMenus(menu
->parent
, submenus
);
1467 WMenu
*wMenuUnderPointer(WScreen
* screen
)
1469 WObjDescriptor
*desc
;
1470 Window root_ret
, win
;
1474 XQueryPointer(dpy
, screen
->root_win
, &root_ret
, &win
, &dummy
, &dummy
, &dummy
, &dummy
, &mask
);
1479 if (XFindContext(dpy
, win
, wWinContext
, (XPointer
*) & desc
) == XCNOENT
)
1482 if (desc
->parent_type
== WCLASS_MENU
)
1483 return (WMenu
*) desc
->parent
;
1487 static void getPointerPosition(WScreen
* scr
, int *x
, int *y
)
1489 Window root_ret
, win
;
1493 XQueryPointer(dpy
, scr
->root_win
, &root_ret
, &win
, x
, y
, &wx
, &wy
, &mask
);
1496 static void getScrollAmount(WMenu
* menu
, int *hamount
, int *vamount
)
1498 WScreen
*scr
= menu
->menu
->screen_ptr
;
1499 int menuX1
= menu
->frame_x
;
1500 int menuY1
= menu
->frame_y
;
1501 int menuX2
= menu
->frame_x
+ MENUW(menu
);
1502 int menuY2
= menu
->frame_y
+ MENUH(menu
);
1504 WMRect rect
= wGetRectForHead(scr
, wGetHeadForPointerLocation(scr
));
1509 getPointerPosition(scr
, &xroot
, &yroot
);
1511 if (xroot
<= (rect
.pos
.x
+ 1) && menuX1
< rect
.pos
.x
) {
1512 /* scroll to the right */
1513 *hamount
= WMIN(MENU_SCROLL_STEP
, abs(menuX1
));
1515 } else if (xroot
>= (rect
.pos
.x
+ rect
.size
.width
- 2) && menuX2
> (rect
.pos
.x
+ rect
.size
.width
- 1)) {
1516 /* scroll to the left */
1517 *hamount
= WMIN(MENU_SCROLL_STEP
, abs(menuX2
- rect
.pos
.x
- rect
.size
.width
- 1));
1522 *hamount
= -*hamount
;
1525 if (yroot
<= (rect
.pos
.y
+ 1) && menuY1
< rect
.pos
.y
) {
1527 *vamount
= WMIN(MENU_SCROLL_STEP
, abs(menuY1
));
1529 } else if (yroot
>= (rect
.pos
.y
+ rect
.size
.height
- 2) && menuY2
> (rect
.pos
.y
+ rect
.size
.height
- 1)) {
1531 *vamount
= WMIN(MENU_SCROLL_STEP
, abs(menuY2
- rect
.pos
.y
- rect
.size
.height
- 2));
1533 *vamount
= -*vamount
;
1537 static void dragScrollMenuCallback(void *data
)
1539 WMenu
*menu
= (WMenu
*) data
;
1540 WScreen
*scr
= menu
->menu
->screen_ptr
;
1541 WMenu
*parent
= parentMenu(menu
);
1542 int hamount
, vamount
;
1544 int newSelectedEntry
;
1546 getScrollAmount(menu
, &hamount
, &vamount
);
1548 if (hamount
!= 0 || vamount
!= 0) {
1549 wMenuMove(parent
, parent
->frame_x
+ hamount
, parent
->frame_y
+ vamount
, True
);
1550 if (findMenu(scr
, &x
, &y
)) {
1551 newSelectedEntry
= getEntryAt(menu
, x
, y
);
1552 selectEntry(menu
, newSelectedEntry
);
1554 /* Pointer fell outside of menu. If the selected entry is
1555 * not a submenu, unselect it */
1556 if (menu
->selected_entry
>= 0 && menu
->entries
[menu
->selected_entry
]->cascade
< 0)
1557 selectEntry(menu
, -1);
1558 newSelectedEntry
= 0;
1561 /* paranoid check */
1562 if (newSelectedEntry
>= 0) {
1563 /* keep scrolling */
1564 menu
->timer
= WMAddTimerHandler(MENU_SCROLL_DELAY
, dragScrollMenuCallback
, menu
);
1569 /* don't need to scroll anymore */
1571 if (findMenu(scr
, &x
, &y
)) {
1572 newSelectedEntry
= getEntryAt(menu
, x
, y
);
1573 selectEntry(menu
, newSelectedEntry
);
1578 static void scrollMenuCallback(void *data
)
1580 WMenu
*menu
= (WMenu
*) data
;
1581 WMenu
*parent
= parentMenu(menu
);
1582 int hamount
= 0; /* amount to scroll */
1585 #ifdef VIRTUAL_DESKTOP
1586 /* don't scroll if it is in vdesk mode */
1587 if (!wPreferences
.vdesk_enable
)
1589 getScrollAmount(menu
, &hamount
, &vamount
);
1591 if (hamount
!= 0 || vamount
!= 0) {
1592 wMenuMove(parent
, parent
->frame_x
+ hamount
, parent
->frame_y
+ vamount
, True
);
1594 /* keep scrolling */
1595 menu
->timer
= WMAddTimerHandler(MENU_SCROLL_DELAY
, scrollMenuCallback
, menu
);
1597 /* don't need to scroll anymore */
1602 #define MENU_SCROLL_BORDER 5
1604 static int isPointNearBoder(WMenu
* menu
, int x
, int y
)
1606 int menuX1
= menu
->frame_x
;
1607 int menuY1
= menu
->frame_y
;
1608 int menuX2
= menu
->frame_x
+ MENUW(menu
);
1609 int menuY2
= menu
->frame_y
+ MENUH(menu
);
1611 int head
= wGetHeadForPoint(menu
->frame
->screen_ptr
, wmkpoint(x
, y
));
1612 WMRect rect
= wGetRectForHead(menu
->frame
->screen_ptr
, head
);
1614 /* XXX: handle screen joins properly !! */
1616 if (x
>= menuX1
&& x
<= menuX2
&&
1617 (y
< rect
.pos
.y
+ MENU_SCROLL_BORDER
|| y
>= rect
.pos
.y
+ rect
.size
.height
- MENU_SCROLL_BORDER
))
1619 else if (y
>= menuY1
&& y
<= menuY2
&&
1620 (x
< rect
.pos
.x
+ MENU_SCROLL_BORDER
|| x
>= rect
.pos
.x
+ rect
.size
.width
- MENU_SCROLL_BORDER
))
1626 typedef struct _delay
{
1631 static void leaving(_delay
* dl
)
1633 wMenuMove(dl
->menu
, dl
->ox
, dl
->oy
, True
);
1634 dl
->menu
->jump_back
= NULL
;
1635 dl
->menu
->menu
->screen_ptr
->flags
.jump_back_pending
= 0;
1639 void wMenuScroll(WMenu
* menu
, XEvent
* event
)
1642 WMenu
*omenu
= parentMenu(menu
);
1643 WScreen
*scr
= menu
->frame
->screen_ptr
;
1646 int old_frame_x
= omenu
->frame_x
;
1647 int old_frame_y
= omenu
->frame_y
;
1650 if (omenu
->jump_back
)
1651 WMDeleteTimerWithClientData(omenu
->jump_back
);
1653 if (( /*omenu->flags.buttoned && */ !wPreferences
.wrap_menus
)
1654 || omenu
->flags
.app_menu
) {
1658 if (!wPreferences
.wrap_menus
)
1659 raiseMenus(omenu
, True
);
1661 raiseMenus(menu
, False
);
1664 scrollMenuCallback(menu
);
1667 int x
, y
, on_border
, on_x_edge
, on_y_edge
, on_title
;
1670 WMNextEvent(dpy
, &ev
);
1675 x
= (ev
.type
== MotionNotify
) ? ev
.xmotion
.x_root
: ev
.xcrossing
.x_root
;
1676 y
= (ev
.type
== MotionNotify
) ? ev
.xmotion
.y_root
: ev
.xcrossing
.y_root
;
1678 /* on_border is != 0 if the pointer is between the menu
1679 * and the screen border and is close enough to the border */
1680 on_border
= isPointNearBoder(menu
, x
, y
);
1682 smenu
= wMenuUnderPointer(scr
);
1684 if ((smenu
== NULL
&& !on_border
) || (smenu
&& parentMenu(smenu
) != omenu
)) {
1689 rect
= wGetRectForHead(scr
, wGetHeadForPoint(scr
, wmkpoint(x
, y
)));
1690 on_x_edge
= x
<= rect
.pos
.x
+ 1 || x
>= rect
.pos
.x
+ rect
.size
.width
- 2;
1691 on_y_edge
= y
<= rect
.pos
.y
+ 1 || y
>= rect
.pos
.y
+ rect
.size
.height
- 2;
1692 on_border
= on_x_edge
|| on_y_edge
;
1694 if (!on_border
&& !jump_back
) {
1699 if (menu
->timer
&& (smenu
!= menu
|| (!on_y_edge
&& !on_x_edge
))) {
1700 WMDeleteTimerHandler(menu
->timer
);
1708 scrollMenuCallback(menu
);
1711 /* True if we push on title, or drag the omenu to other position */
1712 on_title
= ev
.xbutton
.x_root
>= omenu
->frame_x
&&
1713 ev
.xbutton
.x_root
<= omenu
->frame_x
+ MENUW(omenu
) &&
1714 ev
.xbutton
.y_root
>= omenu
->frame_y
&&
1715 ev
.xbutton
.y_root
<= omenu
->frame_y
+ omenu
->frame
->top_width
;
1717 smenu
= wMenuUnderPointer(scr
);
1718 if (smenu
== NULL
|| (smenu
&& smenu
->flags
.buttoned
&& smenu
!= omenu
))
1720 else if (smenu
== omenu
&& on_title
) {
1734 WMDeleteTimerHandler(menu
->timer
);
1740 if (!omenu
->jump_back
) {
1741 delayer
= wmalloc(sizeof(_delay
));
1742 delayer
->menu
= omenu
;
1743 delayer
->ox
= old_frame_x
;
1744 delayer
->oy
= old_frame_y
;
1745 omenu
->jump_back
= delayer
;
1746 scr
->flags
.jump_back_pending
= 1;
1748 delayer
= omenu
->jump_back
;
1749 WMAddTimerHandler(MENU_JUMP_BACK_DELAY
, (WMCallback
*) leaving
, delayer
);
1753 static void menuExpose(WObjDescriptor
* desc
, XEvent
* event
)
1755 wMenuPaint(desc
->parent
);
1759 int *delayed_select
;
1764 static void delaySelection(void *data
)
1766 delay_data
*d
= (delay_data
*) data
;
1772 menu
= findMenu(d
->menu
->menu
->screen_ptr
, &x
, &y
);
1773 if (menu
&& (d
->menu
== menu
|| d
->delayed_select
)) {
1774 entry_no
= getEntryAt(menu
, x
, y
);
1775 selectEntry(menu
, entry_no
);
1777 if (d
->delayed_select
)
1778 *(d
->delayed_select
) = 0;
1781 static void menuMouseDown(WObjDescriptor
* desc
, XEvent
* event
)
1783 XButtonEvent
*bev
= &event
->xbutton
;
1784 WMenu
*menu
= desc
->parent
;
1786 WScreen
*scr
= menu
->frame
->screen_ptr
;
1787 WMenuEntry
*entry
= NULL
;
1789 int close_on_exit
= 0;
1791 int delayed_select
= 0;
1795 int old_frame_x
= 0;
1796 int old_frame_y
= 0;
1797 delay_data d_data
= { NULL
, NULL
, NULL
};
1799 /* Doesn't seem to be needed anymore (if delayed selection handler is
1800 * added only if not present). there seem to be no other side effects
1801 * from removing this and it is also possible that it was only added
1802 * to avoid problems with adding the delayed selection timer handler
1805 /*if (menu->flags.inside_handler) {
1808 menu
->flags
.inside_handler
= 1;
1810 if (!wPreferences
.wrap_menus
) {
1811 smenu
= parentMenu(menu
);
1812 old_frame_x
= smenu
->frame_x
;
1813 old_frame_y
= smenu
->frame_y
;
1814 } else if (event
->xbutton
.window
== menu
->frame
->core
->window
) {
1815 /* This is true if the menu was launched with right click on root window */
1816 if (!d_data
.magic
) {
1818 d_data
.delayed_select
= &delayed_select
;
1820 d_data
.magic
= WMAddTimerHandler(wPreferences
.dblclick_time
, delaySelection
, &d_data
);
1824 wRaiseFrame(menu
->frame
->core
);
1826 close_on_exit
= (bev
->send_event
|| menu
->flags
.brother
);
1828 smenu
= findMenu(scr
, &x
, &y
);
1836 if (menu
->flags
.editing
) {
1839 entry_no
= getEntryAt(menu
, x
, y
);
1840 if (entry_no
>= 0) {
1841 entry
= menu
->entries
[entry_no
];
1843 if (!close_on_exit
&& (bev
->state
& ControlMask
) && smenu
&& entry
->flags
.editable
) {
1844 editEntry(smenu
, entry
);
1846 } else if (bev
->state
& ControlMask
) {
1850 if (entry
->flags
.enabled
&& entry
->cascade
>= 0 && menu
->cascades
) {
1851 WMenu
*submenu
= menu
->cascades
[entry
->cascade
];
1853 if (submenu
->flags
.mapped
&& !submenu
->flags
.buttoned
&& menu
->selected_entry
!= entry_no
) {
1854 wMenuUnmap(submenu
);
1856 if (!submenu
->flags
.mapped
&& !delayed_select
) {
1857 selectEntry(menu
, entry_no
);
1858 } else if (!submenu
->flags
.buttoned
) {
1859 selectEntry(menu
, -1);
1862 } else if (!delayed_select
) {
1863 selectEntry(menu
, entry_no
);
1866 if (!wPreferences
.wrap_menus
&& !wPreferences
.scrollable_menus
) {
1868 dragScrollMenuCallback(menu
);
1871 #ifdef VIRTUAL_DESKTOP
1872 if (wPreferences
.vdesk_enable
) {
1873 wWorkspaceLowerEdge(scr
);
1877 prevx
= bev
->x_root
;
1878 prevy
= bev
->y_root
;
1882 XAllowEvents(dpy
, AsyncPointer
| SyncPointer
, CurrentTime
);
1884 WMMaskEvent(dpy
, ExposureMask
| ButtonMotionMask
| ButtonReleaseMask
| ButtonPressMask
, &ev
);
1887 smenu
= findMenu(scr
, &x
, &y
);
1889 if (smenu
== NULL
) {
1890 /* moved mouse out of menu */
1892 if (!delayed_select
&& d_data
.magic
) {
1893 WMDeleteTimerHandler(d_data
.magic
);
1894 d_data
.magic
= NULL
;
1897 || (menu
->selected_entry
>= 0
1898 && menu
->entries
[menu
->selected_entry
]->cascade
>= 0)) {
1899 prevx
= ev
.xmotion
.x_root
;
1900 prevy
= ev
.xmotion
.y_root
;
1904 selectEntry(menu
, -1);
1906 prevx
= ev
.xmotion
.x_root
;
1907 prevy
= ev
.xmotion
.y_root
;
1909 } else if (menu
&& menu
!= smenu
1910 && (menu
->selected_entry
< 0
1911 || menu
->entries
[menu
->selected_entry
]->cascade
< 0)) {
1912 selectEntry(menu
, -1);
1914 if (!delayed_select
&& d_data
.magic
) {
1915 WMDeleteTimerHandler(d_data
.magic
);
1916 d_data
.magic
= NULL
;
1920 /* hysteresis for item selection */
1922 /* check if the motion was to the side, indicating that
1923 * the user may want to cross to a submenu */
1924 if (!delayed_select
&& menu
) {
1926 Bool moved_to_submenu
; /* moved to direction of submenu */
1928 dx
= abs(prevx
- ev
.xmotion
.x_root
);
1930 moved_to_submenu
= False
;
1931 if (dx
> 0 /* if moved enough to the side */
1932 /* maybe a open submenu */
1933 && menu
->selected_entry
>= 0
1934 /* moving to the right direction */
1935 && (wPreferences
.align_menus
|| ev
.xmotion
.y_root
>= prevy
)) {
1938 index
= menu
->entries
[menu
->selected_entry
]->cascade
;
1940 if (menu
->cascades
[index
]->frame_x
> menu
->frame_x
) {
1941 if (prevx
< ev
.xmotion
.x_root
)
1942 moved_to_submenu
= True
;
1944 if (prevx
> ev
.xmotion
.x_root
)
1945 moved_to_submenu
= True
;
1950 if (menu
!= smenu
) {
1952 WMDeleteTimerHandler(d_data
.magic
);
1953 d_data
.magic
= NULL
;
1955 } else if (moved_to_submenu
) {
1956 /* while we are moving, postpone the selection */
1958 WMDeleteTimerHandler(d_data
.magic
);
1960 d_data
.delayed_select
= NULL
;
1962 d_data
.magic
= WMAddTimerHandler(MENU_SELECT_DELAY
,
1963 delaySelection
, &d_data
);
1964 prevx
= ev
.xmotion
.x_root
;
1965 prevy
= ev
.xmotion
.y_root
;
1969 WMDeleteTimerHandler(d_data
.magic
);
1970 d_data
.magic
= NULL
;
1975 prevx
= ev
.xmotion
.x_root
;
1976 prevy
= ev
.xmotion
.y_root
;
1977 if (menu
!= smenu
) {
1978 /* pointer crossed menus */
1979 if (menu
&& menu
->timer
) {
1980 WMDeleteTimerHandler(menu
->timer
);
1984 dragScrollMenuCallback(smenu
);
1988 dragScrollMenuCallback(menu
);
1990 if (!delayed_select
) {
1991 entry_no
= getEntryAt(menu
, x
, y
);
1992 if (entry_no
>= 0) {
1993 entry
= menu
->entries
[entry_no
];
1994 if (entry
->flags
.enabled
&& entry
->cascade
>= 0 && menu
->cascades
) {
1995 WMenu
*submenu
= menu
->cascades
[entry
->cascade
];
1996 if (submenu
->flags
.mapped
&& !submenu
->flags
.buttoned
1997 && menu
->selected_entry
!= entry_no
) {
1998 wMenuUnmap(submenu
);
2002 selectEntry(menu
, entry_no
);
2010 if (ev
.xbutton
.button
== event
->xbutton
.button
)
2016 #ifdef VIRTUAL_DESKTOP
2017 /* since expose will raise edge up.. I need another ugly hack here */
2018 if (wPreferences
.vdesk_enable
) {
2019 wWorkspaceLowerEdge(scr
);
2026 if (menu
&& menu
->timer
) {
2027 WMDeleteTimerHandler(menu
->timer
);
2030 if (d_data
.magic
!= NULL
) {
2031 WMDeleteTimerHandler(d_data
.magic
);
2032 d_data
.magic
= NULL
;
2035 if (menu
&& menu
->selected_entry
>= 0) {
2036 entry
= menu
->entries
[menu
->selected_entry
];
2037 if (entry
->callback
!= NULL
&& entry
->flags
.enabled
&& entry
->cascade
< 0) {
2038 /* blink and erase menu selection */
2039 #if (MENU_BLINK_DELAY > 0)
2040 int sel
= menu
->selected_entry
;
2043 for (i
= 0; i
< MENU_BLINK_COUNT
; i
++) {
2044 paintEntry(menu
, sel
, False
);
2046 wusleep(MENU_BLINK_DELAY
);
2047 paintEntry(menu
, sel
, True
);
2049 wusleep(MENU_BLINK_DELAY
);
2052 /* unmap the menu, it's parents and call the callback */
2053 if (!menu
->flags
.buttoned
&& (!menu
->flags
.app_menu
|| menu
->parent
!= NULL
)) {
2056 selectEntry(menu
, -1);
2058 (*entry
->callback
) (menu
, entry
);
2060 /* If the user double clicks an entry, the entry will
2061 * be executed twice, which is not good for things like
2062 * the root menu. So, ignore any clicks that were generated
2063 * while the entry was being executed */
2064 while (XCheckTypedWindowEvent(dpy
, menu
->menu
->window
, ButtonPress
, &ev
)) ;
2065 } else if (entry
->callback
!= NULL
&& entry
->cascade
< 0) {
2066 selectEntry(menu
, -1);
2068 if (entry
->cascade
>= 0 && menu
->cascades
&& menu
->cascades
[entry
->cascade
]->flags
.brother
) {
2069 selectEntry(menu
, -1);
2074 if (((WMenu
*) desc
->parent
)->flags
.brother
|| close_on_exit
|| !smenu
)
2075 closeCascade(desc
->parent
);
2077 /* close the cascade windows that should not remain opened */
2078 closeBrotherCascadesOf(desc
->parent
);
2080 if (!wPreferences
.wrap_menus
)
2081 wMenuMove(parentMenu(desc
->parent
), old_frame_x
, old_frame_y
, True
);
2084 /* Just to be sure in case we skip the 2 above because of a goto byebye */
2085 if (menu
&& menu
->timer
) {
2086 WMDeleteTimerHandler(menu
->timer
);
2089 if (d_data
.magic
!= NULL
) {
2090 WMDeleteTimerHandler(d_data
.magic
);
2091 d_data
.magic
= NULL
;
2094 ((WMenu
*) desc
->parent
)->flags
.inside_handler
= 0;
2095 #ifdef VIRTUAL_DESKTOP
2096 wWorkspaceRaiseEdge(scr
);
2100 void wMenuMove(WMenu
* menu
, int x
, int y
, int submenus
)
2110 XMoveWindow(dpy
, menu
->frame
->core
->window
, x
, y
);
2112 if (submenus
> 0 && menu
->selected_entry
>= 0) {
2113 i
= menu
->entries
[menu
->selected_entry
]->cascade
;
2115 if (i
>= 0 && menu
->cascades
) {
2116 submenu
= menu
->cascades
[i
];
2117 if (submenu
->flags
.mapped
&& !submenu
->flags
.buttoned
) {
2118 if (wPreferences
.align_menus
) {
2119 wMenuMove(submenu
, x
+ MENUW(menu
), y
, submenus
);
2121 wMenuMove(submenu
, x
+ MENUW(menu
),
2122 y
+ submenu
->entry_height
* menu
->selected_entry
, submenus
);
2127 if (submenus
< 0 && menu
->parent
!= NULL
&& menu
->parent
->flags
.mapped
&& !menu
->parent
->flags
.buttoned
) {
2128 if (wPreferences
.align_menus
) {
2129 wMenuMove(menu
->parent
, x
- MENUW(menu
->parent
), y
, submenus
);
2131 wMenuMove(menu
->parent
, x
- MENUW(menu
->parent
), menu
->frame_y
2132 - menu
->parent
->entry_height
* menu
->parent
->selected_entry
, submenus
);
2137 static void changeMenuLevels(WMenu
* menu
, int lower
)
2142 ChangeStackingLevel(menu
->frame
->core
, (!menu
->parent
? WMMainMenuLevel
: WMSubmenuLevel
));
2143 wRaiseFrame(menu
->frame
->core
);
2144 menu
->flags
.lowered
= 0;
2146 ChangeStackingLevel(menu
->frame
->core
, WMNormalLevel
);
2147 wLowerFrame(menu
->frame
->core
);
2148 menu
->flags
.lowered
= 1;
2150 for (i
= 0; i
< menu
->cascade_no
; i
++) {
2151 if (menu
->cascades
[i
]
2152 && !menu
->cascades
[i
]->flags
.buttoned
&& menu
->cascades
[i
]->flags
.lowered
!= lower
) {
2153 changeMenuLevels(menu
->cascades
[i
], lower
);
2158 static void menuTitleDoubleClick(WCoreWindow
* sender
, void *data
, XEvent
* event
)
2163 if (event
->xbutton
.state
& MOD_MASK
) {
2164 if (menu
->flags
.lowered
) {
2169 changeMenuLevels(menu
, lower
);
2173 static void menuTitleMouseDown(WCoreWindow
* sender
, void *data
, XEvent
* event
)
2178 int x
= menu
->frame_x
, y
= menu
->frame_y
;
2179 int dx
= event
->xbutton
.x_root
, dy
= event
->xbutton
.y_root
;
2183 /* can't touch the menu copy */
2184 if (menu
->flags
.brother
)
2187 if (event
->xbutton
.button
!= Button1
&& event
->xbutton
.button
!= Button2
)
2190 if (event
->xbutton
.state
& MOD_MASK
) {
2191 wLowerFrame(menu
->frame
->core
);
2194 wRaiseFrame(menu
->frame
->core
);
2199 /* lower/raise all submenus */
2201 if (tmp
->selected_entry
>= 0 && tmp
->cascades
&& tmp
->entries
[tmp
->selected_entry
]->cascade
>= 0) {
2202 tmp
= tmp
->cascades
[tmp
->entries
[tmp
->selected_entry
]->cascade
];
2203 if (!tmp
|| !tmp
->flags
.mapped
)
2206 wLowerFrame(tmp
->frame
->core
);
2208 wRaiseFrame(tmp
->frame
->core
);
2214 /* tear off the menu if it's a root menu or a cascade
2216 if (!menu
->flags
.buttoned
&& !menu
->flags
.brother
&& (!menu
->flags
.app_menu
|| menu
->parent
!= NULL
)) {
2217 menu
->flags
.buttoned
= 1;
2218 wFrameWindowShowButton(menu
->frame
, WFF_RIGHT_BUTTON
);
2220 /* turn off selected menu entry in parent menu */
2221 selectEntry(menu
->parent
, -1);
2223 /* make parent map the copy in place of the original */
2224 for (i
= 0; i
< menu
->parent
->cascade_no
; i
++) {
2225 if (menu
->parent
->cascades
[i
] == menu
) {
2226 menu
->parent
->cascades
[i
] = menu
->brother
;
2235 WMMaskEvent(dpy
, ButtonMotionMask
| ButtonReleaseMask
| ButtonPressMask
| ExposureMask
, &ev
);
2239 x
+= ev
.xmotion
.x_root
- dx
;
2240 y
+= ev
.xmotion
.y_root
- dy
;
2241 dx
= ev
.xmotion
.x_root
;
2242 dy
= ev
.xmotion
.y_root
;
2243 wMenuMove(menu
, x
, y
, True
);
2245 if (abs(ev
.xmotion
.x_root
- dx
) > MOVE_THRESHOLD
2246 || abs(ev
.xmotion
.y_root
- dy
) > MOVE_THRESHOLD
) {
2248 XGrabPointer(dpy
, menu
->frame
->titlebar
->window
, False
,
2249 ButtonMotionMask
| ButtonReleaseMask
2251 GrabModeAsync
, GrabModeAsync
, None
,
2252 wCursor
[WCUR_MOVE
], CurrentTime
);
2261 if (ev
.xbutton
.button
!= event
->xbutton
.button
)
2263 XUngrabPointer(dpy
, CurrentTime
);
2274 *----------------------------------------------------------------------
2276 * Handles mouse click on the close button of menus. The menu is
2277 * closed when the button is clicked.
2280 * The closed menu is reinserted at it's parent menus
2282 *----------------------------------------------------------------------
2284 static void menuCloseClick(WCoreWindow
* sender
, void *data
, XEvent
* event
)
2286 WMenu
*menu
= (WMenu
*) data
;
2287 WMenu
*parent
= menu
->parent
;
2291 for (i
= 0; i
< parent
->cascade_no
; i
++) {
2292 /* find the entry that points to the copy */
2293 if (parent
->cascades
[i
] == menu
->brother
) {
2294 /* make it point to the original */
2295 parent
->cascades
[i
] = menu
;
2296 menu
->parent
= parent
;
2304 static void saveMenuInfo(WMPropList
* dict
, WMenu
* menu
, WMPropList
* key
)
2306 WMPropList
*value
, *list
;
2309 snprintf(buffer
, sizeof(buffer
), "%i,%i", menu
->frame_x
, menu
->frame_y
);
2310 value
= WMCreatePLString(buffer
);
2311 list
= WMCreatePLArray(value
, NULL
);
2312 if (menu
->flags
.lowered
)
2313 WMAddToPLArray(list
, WMCreatePLString("lowered"));
2314 WMPutInPLDictionary(dict
, key
, list
);
2315 WMReleasePropList(value
);
2316 WMReleasePropList(list
);
2319 void wMenuSaveState(WScreen
* scr
)
2321 WMPropList
*menus
, *key
;
2324 menus
= WMCreatePLDictionary(NULL
, NULL
);
2326 if (scr
->switch_menu
&& scr
->switch_menu
->flags
.buttoned
) {
2327 key
= WMCreatePLString("SwitchMenu");
2328 saveMenuInfo(menus
, scr
->switch_menu
, key
);
2329 WMReleasePropList(key
);
2333 if (saveMenuRecurs(menus
, scr
, scr
->root_menu
))
2336 if (scr
->workspace_menu
&& scr
->workspace_menu
->flags
.buttoned
) {
2337 key
= WMCreatePLString("WorkspaceMenu");
2338 saveMenuInfo(menus
, scr
->workspace_menu
, key
);
2339 WMReleasePropList(key
);
2344 key
= WMCreatePLString("Menus");
2345 WMPutInPLDictionary(scr
->session_state
, key
, menus
);
2346 WMReleasePropList(key
);
2348 WMReleasePropList(menus
);
2351 static Bool
getMenuPath(WMenu
* menu
, char *buffer
, int bufSize
)
2356 if (!menu
->flags
.titled
|| !menu
->frame
->title
[0])
2359 len
= strlen(menu
->frame
->title
);
2364 ok
= getMenuPath(menu
->parent
, buffer
, bufSize
- len
- 1);
2369 strcat(buffer
, "\\");
2370 strcat(buffer
, menu
->frame
->title
);
2375 static Bool
saveMenuRecurs(WMPropList
* menus
, WScreen
* scr
, WMenu
* menu
)
2378 int save_menus
= 0, i
;
2382 if (menu
->flags
.brother
)
2383 menu
= menu
->brother
;
2385 if (menu
->flags
.buttoned
&& menu
!= scr
->switch_menu
) {
2388 ok
= getMenuPath(menu
, buffer
, 510);
2391 key
= WMCreatePLString(buffer
);
2392 saveMenuInfo(menus
, menu
, key
);
2393 WMReleasePropList(key
);
2399 for (i
= 0; i
< menu
->cascade_no
; i
++) {
2400 if (saveMenuRecurs(menus
, scr
, menu
->cascades
[i
]))
2407 #define COMPLAIN(key) wwarning(_("bad value in menus state info: %s"), key)
2409 static Bool
getMenuInfo(WMPropList
* info
, int *x
, int *y
, Bool
* lowered
)
2415 if (WMIsPLArray(info
)) {
2417 pos
= WMGetFromPLArray(info
, 0);
2418 flags
= WMGetFromPLArray(info
, 1);
2419 if (flags
!= NULL
&& WMIsPLString(flags
) && WMGetFromPLString(flags
) != NULL
2420 && strcmp(WMGetFromPLString(flags
), "lowered") == 0) {
2427 if (pos
!= NULL
&& WMIsPLString(pos
)) {
2428 if (sscanf(WMGetFromPLString(pos
), "%i,%i", x
, y
) != 2)
2429 COMPLAIN("Position");
2431 COMPLAIN("(position, flags...)");
2438 static int restoreMenu(WScreen
* scr
, WMPropList
* menu
, int which
)
2441 Bool lowered
= False
;
2442 WMenu
*pmenu
= NULL
;
2447 if (!getMenuInfo(menu
, &x
, &y
, &lowered
))
2450 if (which
& WSS_SWITCHMENU
) {
2451 OpenSwitchMenu(scr
, x
, y
, False
);
2452 pmenu
= scr
->switch_menu
;
2456 int width
= MENUW(pmenu
);
2457 int height
= MENUH(pmenu
);
2458 WMRect rect
= wGetRectForHead(scr
, wGetHeadForPointerLocation(scr
));
2461 changeMenuLevels(pmenu
, True
);
2464 if (x
< rect
.pos
.x
- width
)
2466 if (x
> rect
.pos
.x
+ rect
.size
.width
)
2467 x
= rect
.pos
.x
+ rect
.size
.width
- width
;
2470 if (y
> rect
.pos
.y
+ rect
.size
.height
)
2471 y
= rect
.pos
.y
+ rect
.size
.height
- height
;
2473 wMenuMove(pmenu
, x
, y
, True
);
2474 pmenu
->flags
.buttoned
= 1;
2475 wFrameWindowShowButton(pmenu
->frame
, WFF_RIGHT_BUTTON
);
2481 static int restoreMenuRecurs(WScreen
* scr
, WMPropList
* menus
, WMenu
* menu
, char *path
)
2483 WMPropList
*key
, *entry
;
2488 if (strlen(path
) + strlen(menu
->frame
->title
) > 510)
2491 snprintf(buffer
, sizeof(buffer
), "%s\\%s", path
, menu
->frame
->title
);
2492 key
= WMCreatePLString(buffer
);
2493 entry
= WMGetFromPLDictionary(menus
, key
);
2496 if (entry
&& getMenuInfo(entry
, &x
, &y
, &lowered
)) {
2498 if (!menu
->flags
.mapped
) {
2499 int width
= MENUW(menu
);
2500 int height
= MENUH(menu
);
2501 WMRect rect
= wGetRectForHead(scr
, wGetHeadForPointerLocation(scr
));
2503 wMenuMapAt(menu
, x
, y
, False
);
2506 /* make parent map the copy in place of the original */
2507 for (i
= 0; i
< menu
->parent
->cascade_no
; i
++) {
2508 if (menu
->parent
->cascades
[i
] == menu
) {
2509 menu
->parent
->cascades
[i
] = menu
->brother
;
2515 changeMenuLevels(menu
, True
);
2518 if (x
< rect
.pos
.x
- width
)
2520 if (x
> rect
.pos
.x
+ rect
.size
.width
)
2521 x
= rect
.pos
.x
+ rect
.size
.width
- width
;
2524 if (y
> rect
.pos
.y
+ rect
.size
.height
)
2525 y
= rect
.pos
.y
+ rect
.size
.height
- height
;
2527 wMenuMove(menu
, x
, y
, True
);
2528 menu
->flags
.buttoned
= 1;
2529 wFrameWindowShowButton(menu
->frame
, WFF_RIGHT_BUTTON
);
2534 WMReleasePropList(key
);
2536 for (i
= 0; i
< menu
->cascade_no
; i
++) {
2537 if (restoreMenuRecurs(scr
, menus
, menu
->cascades
[i
], buffer
) != False
)
2544 void wMenuRestoreState(WScreen
* scr
)
2546 WMPropList
*menus
, *menu
, *key
, *skey
;
2548 if (!scr
->session_state
) {
2552 key
= WMCreatePLString("Menus");
2553 menus
= WMGetFromPLDictionary(scr
->session_state
, key
);
2554 WMReleasePropList(key
);
2561 skey
= WMCreatePLString("SwitchMenu");
2562 menu
= WMGetFromPLDictionary(menus
, skey
);
2563 WMReleasePropList(skey
);
2564 restoreMenu(scr
, menu
, WSS_SWITCHMENU
);
2566 if (!scr
->root_menu
) {
2567 OpenRootMenu(scr
, scr
->scr_width
* 2, 0, False
);
2568 wMenuUnmap(scr
->root_menu
);
2570 restoreMenuRecurs(scr
, menus
, scr
->root_menu
, "");
2573 void OpenWorkspaceMenu(WScreen
* scr
, int x
, int y
)
2575 WMenu
*menu
, *parent
;
2578 if (!scr
->root_menu
) {
2579 OpenRootMenu(scr
, scr
->scr_width
* 2, 0, False
);
2580 wMenuUnmap(scr
->root_menu
);
2583 menu
= scr
->workspace_menu
;
2585 if (menu
->flags
.mapped
) {
2586 if (!menu
->flags
.buttoned
) {
2588 parent
= menu
->parent
;
2589 if (parent
&& parent
->selected_entry
>= 0) {
2590 entry
= parent
->entries
[parent
->selected_entry
];
2591 if (parent
->cascades
[entry
->cascade
] == menu
) {
2592 selectEntry(parent
, -1);
2593 wMenuMapAt(menu
, x
, y
, False
);
2597 wRaiseFrame(menu
->frame
->core
);
2598 wMenuMapCopyAt(menu
, x
, y
);
2601 wMenuMapAt(menu
, x
, y
, False
);