?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix segfault when creating a tearoff menu using a Pixmap background.
[fvwm.git] / fvwm / menuitem.c
blob3e4ea2cee0eb4b79affa59e2c7ac37c8721b742b
1 /* -*-c-*- */
2 /* This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15 */
16
17 /* ---------------------------- included header files ---------------------- */
18
19 #include "config.h"
20
21 #include <stdio.h>
22
23 #include "libs/fvwmlib.h"
24 #include "libs/Picture.h"
25 #include "libs/Graphics.h"
26 #include "libs/PictureGraphics.h"
27 #include "libs/Rectangles.h"
28 #include "fvwm.h"
29 #include "externs.h"
30 #include "execcontext.h"
31 #include "misc.h"
32 #include "screen.h"
33 #include "menudim.h"
34 #include "menustyle.h"
35 #include "menuitem.h"
36 #include "decorations.h"
37
38 /* ---------------------------- local definitions -------------------------- */
39
40 /* ---------------------------- local macros ------------------------------- */
41
42 /* ---------------------------- imports ------------------------------------ */
43
44 /* ---------------------------- included code files ------------------------ */
45
46 /* ---------------------------- local types -------------------------------- */
47
48 /* ---------------------------- forward declarations ----------------------- */
49
50 /* ---------------------------- local variables ---------------------------- */
51
52 /* ---------------------------- exported variables (globals) --------------- */
53
54 /* ---------------------------- local functions ---------------------------- */
55 static void clear_menu_item_background(
56 MenuPaintItemParameters *mpip, int x, int y, int w, int h)
57 {
58 MenuStyle *ms = mpip->ms;
59
60 if (!ST_HAS_MENU_CSET(ms) &&
61 ST_FACE(ms).type == GradientMenu &&
62 (ST_FACE(ms).gradient_type == D_GRADIENT ||
63 ST_FACE(ms).gradient_type == B_GRADIENT))
64 {
65 XEvent e;
66
67 e.xexpose.x = x;
68 e.xexpose.y = y;
69 e.xexpose.width = w;
70 e.xexpose.height = h;
71 mpip->cb_reset_bg(mpip->cb_mr, &e);
72 }
73 else
74 {
75 XClearArea(dpy, mpip->w, x, y, w, h, False);
76 }
77 }
78
79 /*
80 *
81 * Draws two horizontal lines to form a separator
82 *
83 */
84 static void draw_separator(
85 Window w, GC TopGC, GC BottomGC, int x1, int y, int x2)
86 {
87 XDrawLine(dpy, w, TopGC , x1, y, x2, y);
88 XDrawLine(dpy, w, BottomGC, x1-1, y+1, x2+1, y+1);
89
90 return;
91 }
92
93 /*
94 *
95 * Draws a tear off bar. Similar to a separator, but with a dashed line.
96 *
97 */
98 static void draw_tear_off_bar(
99 Window w, GC TopGC, GC BottomGC, int x1, int y, int x2)
100 {
101 XGCValues xgcv;
102 int width;
103 int offset;
104
105 xgcv.line_style = LineOnOffDash;
106 xgcv.dashes = MENU_TEAR_OFF_BAR_DASH_WIDTH;
107 XChangeGC(dpy, TopGC, GCLineStyle | GCDashList, &xgcv);
108 XChangeGC(dpy, BottomGC, GCLineStyle | GCDashList, &xgcv);
109 width = (x2 - x1 + 1);
110 offset = (width / MENU_TEAR_OFF_BAR_DASH_WIDTH) *
111 MENU_TEAR_OFF_BAR_DASH_WIDTH;
112 offset = (width - offset) / 2;
113 x1 += offset;
114 x2 += offset;
115 XDrawLine(dpy, w, TopGC, x1, y, x2, y);
116 XDrawLine(dpy, w, BottomGC, x1, y + 1, x2, y + 1);
117 xgcv.line_style = LineSolid;
118 XChangeGC(dpy, TopGC, GCLineStyle, &xgcv);
119 XChangeGC(dpy, BottomGC, GCLineStyle, &xgcv);
120
121 return;
122 }
123
124 static void draw_highlight_background(
125 struct MenuPaintItemParameters *mpip, int x, int y, int width,
126 int height, colorset_t *cs, GC gc)
127 {
128 if (cs != NULL && cs->pixmap && cs->pixmap_type != PIXMAP_TILED)
129 {
130 Pixmap p;
131
132 p = CreateOffsetBackgroundPixmap(
133 dpy, mpip->w, 0, 0, width, height, cs, Pdepth, gc,
134 False);
135 switch (cs->pixmap_type)
136 {
137 case PIXMAP_STRETCH_X:
138 /* todo: optimize to only create one pixmap and gc per
139 * mr. */
140 case PIXMAP_STRETCH_Y:
141 {
142 XGCValues gcv;
143 int gcm;
144 GC bgc;
145
146 gcv.tile = p;
147 gcv.fill_style = FillTiled;
148 gcm = GCFillStyle | GCTile;
149
150 /* vertcal gradients has to be aligned properly */
151 if (cs->pixmap_type == PIXMAP_STRETCH_Y)
152 {
153 gcv.ts_y_origin = y;
154 gcm|=GCTileStipYOrigin;
155 }
156 else if (cs->pixmap_type == PIXMAP_STRETCH_X)
157 {
158 gcv.ts_x_origin = x;
159 gcm|=GCTileStipXOrigin;
160 }
161 bgc = fvwmlib_XCreateGC(dpy, mpip->w, gcm, &gcv);
162 XFillRectangle(dpy, mpip->w, bgc, x, y, width, height);
163 XFreeGC(dpy, bgc);
164 break;
165 }
166 default:
167 XCopyArea(dpy, p, mpip->w, gc, 0, 0, width, height,
168 x, y);
169 break;
170 }
171 XFreePixmap(dpy, p);
172 }
173 else
174 {
175 XFillRectangle(dpy, mpip->w, gc, x, y, width, height);
176 }
177 }
178
179 /* ---------------------------- interface functions ------------------------ */
180
181 /* Allocates a new, empty menu item */
182 struct MenuItem *menuitem_create(void)
183 {
184 MenuItem *mi;
185
186 mi = (MenuItem *)safemalloc(sizeof(MenuItem));
187 memset(mi, 0, sizeof(MenuItem));
188
189 return mi;
190 }
191
192 /* Frees a menu item and all of its allocated resources. */
193 void menuitem_free(struct MenuItem *mi)
194 {
195 int i;
196
197 if (!mi)
198 {
199 return;
200 }
201 for (i = 0; i < MAX_MENU_ITEM_LABELS; i++)
202 {
203 if (MI_LABEL(mi)[i] != NULL)
204 {
205 free(MI_LABEL(mi)[i]);
206 }
207 }
208 if (MI_ACTION(mi) != NULL)
209 {
210 free(MI_ACTION(mi));
211 }
212 if (MI_PICTURE(mi))
213 {
214 PDestroyFvwmPicture(dpy, MI_PICTURE(mi));
215 }
216 for (i = 0; i < MAX_MENU_ITEM_MINI_ICONS; i++)
217 {
218 if (MI_MINI_ICON(mi)[i])
219 {
220 PDestroyFvwmPicture(dpy, MI_MINI_ICON(mi)[i]);
221 }
222 }
223 free(mi);
224
225 return;
226 }
227
228 /* Duplicate a menu item into newly allocated memory. The new item is
229 * completely independent of the old one. */
230 struct MenuItem *menuitem_clone(struct MenuItem *mi)
231 {
232 MenuItem *new_mi;
233 int i;
234
235 /* copy everything */
236 new_mi = (MenuItem *)safemalloc(sizeof(MenuItem));
237 memcpy(new_mi, mi, sizeof(MenuItem));
238 /* special treatment for a few parts */
239 MI_NEXT_ITEM(new_mi) = NULL;
240 MI_PREV_ITEM(new_mi) = NULL;
241 MI_WAS_DESELECTED(new_mi) = 0;
242 if (MI_ACTION(mi) != NULL)
243 {
244 MI_ACTION(new_mi) = safestrdup(MI_ACTION(mi));
245 }
246 for (i = 0; i < MAX_MENU_ITEM_LABELS; i++)
247 {
248 if (MI_LABEL(mi)[i] != NULL)
249 {
250 MI_LABEL(new_mi)[i] = strdup(MI_LABEL(mi)[i]);
251 }
252 }
253 if (MI_PICTURE(mi) != NULL)
254 {
255 MI_PICTURE(new_mi) = PCloneFvwmPicture(MI_PICTURE(mi));
256 }
257 for (i = 0; i < MAX_MENU_ITEM_MINI_ICONS; i++)
258 {
259 if (MI_MINI_ICON(mi)[i] != NULL)
260 {
261 MI_MINI_ICON(new_mi)[i] =
262 PCloneFvwmPicture(MI_MINI_ICON(mi)[i]);
263 }
264 }
265
266 return new_mi;
267 }
268
269 /* Calculate the size of the various parts of the item. The sizes are returned
270 * through mipst. */
271 void menuitem_get_size(
272 struct MenuItem *mi, struct MenuItemPartSizesT *mipst,
273 FlocaleFont *font, Bool do_reverse_icon_order)
274 {
275 int i;
276 int j;
277 int w;
278
279 memset(mipst, 0, sizeof(MenuItemPartSizesT));
280 if (MI_IS_POPUP(mi))
281 {
282 mipst->triangle_width = MENU_TRIANGLE_WIDTH;
283 }
284 else if (MI_IS_TITLE(mi) && !MI_HAS_PICTURE(mi))
285 {
286 Bool is_formatted = False;
287
288 /* titles stretch over the whole menu width, so count the
289 * maximum separately if the title is unformatted. */
290 for (j = 1; j < MAX_MENU_ITEM_LABELS; j++)
291 {
292 if (MI_LABEL(mi)[j] != NULL)
293 {
294 is_formatted = True;
295 break;
296 }
297 else
298 {
299 MI_LABEL_OFFSET(mi)[j] = 0;
300 }
301 }
302 if (!is_formatted && MI_LABEL(mi)[0] != NULL)
303 {
304 MI_LABEL_STRLEN(mi)[0] =
305 strlen(MI_LABEL(mi)[0]);
306 w = FlocaleTextWidth(
307 font, MI_LABEL(mi)[0], MI_LABEL_STRLEN(mi)[0]);
308 MI_LABEL_OFFSET(mi)[0] = w;
309 MI_IS_TITLE_CENTERED(mi) = True;
310 if (mipst->title_width < w)
311 {
312 mipst->title_width = w;
313 }
314 return;
315 }
316 }
317 /* regular item or formatted title */
318 for (i = 0; i < MAX_MENU_ITEM_LABELS; i++)
319 {
320 if (MI_LABEL(mi)[i])
321 {
322 MI_LABEL_STRLEN(mi)[i] = strlen(MI_LABEL(mi)[i]);
323 w = FlocaleTextWidth(
324 font, MI_LABEL(mi)[i], MI_LABEL_STRLEN(mi)[i]);
325 MI_LABEL_OFFSET(mi)[i] = w;
326 if (mipst->label_width[i] < w)
327 {
328 mipst->label_width[i] = w;
329 }
330 }
331 }
332 if (MI_PICTURE(mi) && mipst->picture_width < MI_PICTURE(mi)->width)
333 {
334 mipst->picture_width = MI_PICTURE(mi)->width;
335 }
336 for (i = 0; i < MAX_MENU_ITEM_MINI_ICONS; i++)
337 {
338 if (MI_MINI_ICON(mi)[i])
339 {
340 int k;
341
342 /* Reverse mini icon order for left submenu style. */
343 k = (do_reverse_icon_order == True) ?
344 MAX_MENU_ITEM_MINI_ICONS - 1 - i : i;
345 mipst->icon_width[k] = MI_MINI_ICON(mi)[i]->width;
346 }
347 }
348
349 return;
350 }
351
352 /*
353 *
354 * Procedure:
355 * menuitem_paint - draws a single entry in a popped up menu
356 *
357 * mr - the menu instance that holds the menu item
358 * mi - the menu item to redraw
359 * fw - the FvwmWindow structure to check against allowed functions
360 *
361 */
362 void menuitem_paint(
363 struct MenuItem *mi, struct MenuPaintItemParameters *mpip)
364 {
365 struct MenuStyle *ms = mpip->ms;
366 struct MenuDimensions *dim = mpip->dim;
367
368 static FlocaleWinString *fws = NULL;
369 int y_offset;
370 int text_y;
371 int y_height;
372 int x;
373 int y;
374 int lit_x_start;
375 int lit_x_end;
376 gc_quad_t gcs;
377 gc_quad_t off_gcs;
378 int cs = -1;
379 int off_cs;
380 FvwmRenderAttributes fra;
381 /*Pixel fg, fgsh;*/
382 int relief_thickness = ST_RELIEF_THICKNESS(ms);
383 Bool is_item_selected;
384 Bool item_cleared = False;
385 Bool xft_clear = False;
386 Bool empty_inter = False;
387 XRectangle b;
388 Region region = None;
389 int i;
390 int sx1;
391 int sx2;
392 FlocaleFont* font;
393
394 if (!mi)
395 {
396 return;
397 }
398 is_item_selected = (mi == mpip->selected_item);
399
400 if (MI_IS_TITLE(mi))
401 {
402 font = ST_PTITLEFONT(ms);
403 }
404 else
405 {
406 font = ST_PSTDFONT(ms);
407 }
408
409 y_offset = MI_Y_OFFSET(mi);
410 y_height = MI_HEIGHT(mi);
411 if (MI_IS_SELECTABLE(mi))
412 {
413 text_y = y_offset + MDIM_ITEM_TEXT_Y_OFFSET(*dim);
414 }
415 else
416 {
417 text_y = y_offset + font->ascent +
418 ST_TITLE_GAP_ABOVE(ms);
419 }
420 /* center text vertically if the pixmap is taller */
421 if (MI_PICTURE(mi))
422 {
423 text_y += MI_PICTURE(mi)->height;
424 }
425 for (i = 0; i < mpip->used_mini_icons; i++)
426 {
427 y = 0;
428 if (MI_MINI_ICON(mi)[i])
429 {
430 if (MI_MINI_ICON(mi)[i]->height > y)
431 {
432 y = MI_MINI_ICON(mi)[i]->height;
433 }
434 }
435 y -= font->height;
436 if (y > 1)
437 {
438 text_y += y / 2;
439 }
440 }
441
442 off_cs = ST_HAS_MENU_CSET(ms) ? ST_CSET_MENU(ms) : -1;
443 /* Note: it's ok to pass a NULL label to is_function_allowed. */
444 if (
445 !IS_EWMH_DESKTOP_FW(mpip->fw) &&
446 !is_function_allowed(
447 MI_FUNC_TYPE(mi), MI_LABEL(mi)[0], mpip->fw,
448 RQORIG_PROGRAM_US, False))
449 {
450 gcs = ST_MENU_STIPPLE_GCS(ms);
451 off_gcs = gcs;
452 off_cs = ST_HAS_GREYED_CSET(ms) ? ST_CSET_GREYED(ms) : -1;
453 }
454 else if (is_item_selected)
455 {
456 gcs = ST_MENU_ACTIVE_GCS(ms);
457 off_gcs = ST_MENU_INACTIVE_GCS(ms);
458 }
459 else if (MI_IS_TITLE(mi))
460 {
461 gcs = ST_MENU_TITLE_GCS(ms);
462 off_gcs = ST_MENU_INACTIVE_GCS(ms);
463 }
464 else
465 {
466 gcs = ST_MENU_INACTIVE_GCS(ms);
467 off_gcs = ST_MENU_INACTIVE_GCS(ms);
468 }
469 if (is_item_selected)
470 {
471 cs = (ST_HAS_ACTIVE_CSET(ms)) ? ST_CSET_ACTIVE(ms) : -1;
472 }
473 else if (MI_IS_TITLE(mi))
474 {
475 cs = (ST_HAS_TITLE_CSET(ms)) ? ST_CSET_TITLE(ms) : off_cs;
476 }
477 else
478 {
479 cs = off_cs;
480 }
481
482 /*
483 * Hilight the item.
484 */
485 if (FftSupport && ST_PSTDFONT(ms)->fftf.fftfont != NULL)
486 {
487 xft_clear = True;
488 }
489
490 /* Hilight or clear the background. */
491 lit_x_start = -1;
492 lit_x_end = -1;
493 if (is_item_selected &&
494 (ST_DO_HILIGHT_BACK(ms) || ST_DO_HILIGHT_FORE(ms)))
495 {
496 /* Hilight the background. */
497 if (MDIM_HILIGHT_WIDTH(*dim) - 2 * relief_thickness > 0)
498 {
499 lit_x_start = MDIM_HILIGHT_X_OFFSET(*dim) +
500 relief_thickness;
501 lit_x_end = lit_x_start + MDIM_HILIGHT_WIDTH(*dim) -
502 2 * relief_thickness;
503 if (ST_DO_HILIGHT_BACK(ms))
504 {
505 draw_highlight_background(
506 mpip, lit_x_start,
507 y_offset + relief_thickness,
508 lit_x_end - lit_x_start,
509 y_height - relief_thickness,
510 (cs >= 0 ? &Colorset[cs] : NULL),
511 gcs.back_gc);
512 item_cleared = True;
513 }
514 }
515 }
516 else if ((MI_WAS_DESELECTED(mi) &&
517 (relief_thickness > 0 ||
518 ST_DO_HILIGHT_BACK(ms) || ST_DO_HILIGHT_FORE(ms)) &&
519 (ST_FACE(ms).type != GradientMenu || ST_HAS_MENU_CSET(ms))))
520 {
521 int x1;
522 int x2;
523 /* we clear if xft_clear and !ST_HAS_MENU_CSET(ms) as the
524 * non colorset code is too complicate ... olicha */
525 int d = 0;
526
527 if (MI_PREV_ITEM(mi) &&
528 mpip->selected_item == MI_PREV_ITEM(mi))
529 {
530 /* Don't paint over the hilight relief. */
531 d = relief_thickness;
532 }
533 /* Undo the hilighting. */
534 x1 = min(
535 MDIM_HILIGHT_X_OFFSET(*dim), MDIM_ITEM_X_OFFSET(*dim));
536 x2 = max(
537 MDIM_HILIGHT_X_OFFSET(*dim) + MDIM_HILIGHT_WIDTH(*dim),
538 MDIM_ITEM_X_OFFSET(*dim) + MDIM_ITEM_WIDTH(*dim));
539 clear_menu_item_background(
540 mpip, x1, y_offset + d, x2 - x1,
541 y_height + relief_thickness - d);
542 item_cleared = True;
543 }
544 else if (MI_IS_TITLE(mi))
545 {
546 lit_x_start = MDIM_ITEM_X_OFFSET(*dim);
547 lit_x_end = lit_x_start + MDIM_ITEM_WIDTH(*dim);
548 /* Hilight the background. */
549 if (
550 MDIM_HILIGHT_WIDTH(*dim) > 0 &&
551 ST_DO_HILIGHT_TITLE_BACK(ms))
552 {
553 draw_highlight_background(
554 mpip, lit_x_start,
555 y_offset + relief_thickness,
556 lit_x_end - lit_x_start,
557 y_height - relief_thickness,
558 (cs >= 0 ? &Colorset[cs] : NULL),
559 gcs.back_gc);
560 item_cleared = True;
561 }
562 }
563
564 MI_WAS_DESELECTED(mi) = False;
565 memset(&fra, 0, sizeof(fra));
566 fra.mask = 0;
567
568 /* Hilight 3D */
569 if (is_item_selected && relief_thickness > 0)
570 {
571 GC rgc;
572 GC sgc;
573
574 rgc = gcs.hilight_gc;
575 sgc = gcs.shadow_gc;
576 if (ST_IS_ITEM_RELIEF_REVERSED(ms))
577 {
578 GC tgc = rgc;
579
580 /* swap gcs for reversed relief */
581 rgc = sgc;
582 sgc = tgc;
583 }
584 if (MDIM_HILIGHT_WIDTH(*dim) - 2 * relief_thickness > 0)
585 {
586 /* The relief reaches down into the next item, hence
587 * the value for the second y coordinate:
588 * MI_HEIGHT(mi) + 1 */
589 RelieveRectangle(
590 dpy, mpip->w, MDIM_HILIGHT_X_OFFSET(*dim),
591 y_offset, MDIM_HILIGHT_WIDTH(*dim) - 1,
592 MI_HEIGHT(mi) - 1 + relief_thickness, rgc, sgc,
593 relief_thickness);
594 }
595 }
596
597
598 /*
599 * Draw the item itself.
600 */
601
602 /* Calculate the separator offsets. */
603 if (ST_HAS_LONG_SEPARATORS(ms))
604 {
605 sx1 = MDIM_ITEM_X_OFFSET(*dim) + relief_thickness;
606 sx2 = MDIM_ITEM_X_OFFSET(*dim) + MDIM_ITEM_WIDTH(*dim) - 1 -
607 relief_thickness;
608 }
609 else
610 {
611 sx1 = MDIM_ITEM_X_OFFSET(*dim) + relief_thickness +
612 MENU_SEPARATOR_SHORT_X_OFFSET;
613 sx2 = MDIM_ITEM_X_OFFSET(*dim) + MDIM_ITEM_WIDTH(*dim) - 1 -
614 relief_thickness - MENU_SEPARATOR_SHORT_X_OFFSET;
615 }
616 if (MI_IS_SEPARATOR(mi))
617 {
618 if (sx1 < sx2)
619 {
620 /* It's a separator. */
621 draw_separator(
622 mpip->w, gcs.shadow_gc, gcs.hilight_gc, sx1,
623 y_offset + y_height - MENU_SEPARATOR_HEIGHT,
624 sx2);
625 /* Nothing else to do. */
626 }
627 return;
628 }
629 else if (MI_IS_TEAR_OFF_BAR(mi))
630 {
631 int tx1;
632 int tx2;
633
634 tx1 = MDIM_ITEM_X_OFFSET(*dim) + relief_thickness +
635 MENU_TEAR_OFF_BAR_X_OFFSET;
636 tx2 = MDIM_ITEM_X_OFFSET(*dim) + MDIM_ITEM_WIDTH(*dim) - 1 -
637 relief_thickness -
638 MENU_TEAR_OFF_BAR_X_OFFSET;
639 if (tx1 < tx2)
640 {
641
642 /* It's a tear off bar. */
643 draw_tear_off_bar(
644 mpip->w, gcs.shadow_gc, gcs.hilight_gc, tx1,
645 y_offset + relief_thickness +
646 MENU_TEAR_OFF_BAR_Y_OFFSET, tx2);
647 }
648 /* Nothing else to do. */
649 return;
650 }
651 else if (MI_IS_TITLE(mi))
652 {
653 /* Separate the title. */
654 if (ST_TITLE_UNDERLINES(ms) > 0 && !mpip->flags.is_first_item)
655 {
656 int add = (MI_IS_SELECTABLE(MI_PREV_ITEM(mi))) ?
657 relief_thickness : 0;
658
659 text_y += MENU_SEPARATOR_HEIGHT + add;
660 y = y_offset + add;
661 if (sx1 < sx2)
662 {
663 draw_separator(
664 mpip->w, gcs.shadow_gc, gcs.hilight_gc,
665 sx1, y, sx2);
666 }
667 }
668 /* Underline the title. */
669 switch (ST_TITLE_UNDERLINES(ms))
670 {
671 case 0:
672 break;
673 case 1:
674 if (MI_NEXT_ITEM(mi) != NULL)
675 {
676 y = y_offset + y_height - MENU_SEPARATOR_HEIGHT;
677 draw_separator(
678 mpip->w, gcs.shadow_gc, gcs.hilight_gc,
679 sx1, y, sx2);
680 }
681 break;
682 default:
683 for (i = ST_TITLE_UNDERLINES(ms); i-- > 0; )
684 {
685 y = y_offset + y_height - 1 -
686 i * MENU_UNDERLINE_HEIGHT;
687 XDrawLine(
688 dpy, mpip->w, gcs.shadow_gc, sx1, y,
689 sx2, y);
690 }
691 break;
692 }
693 }
694
695 /*
696 * Draw the labels.
697 */
698 if (fws == NULL)
699 {
700 FlocaleAllocateWinString(&fws);
701 }
702 fws->win = mpip->w;
703 fws->y = text_y;
704 fws->flags.has_colorset = 0;
705 b.y = text_y - font->ascent;
706 b.height = font->height + 1; /* ? */
707 if (!item_cleared && mpip->ev)
708 {
709 int u,v;
710 if (!frect_get_seg_intersection(
711 mpip->ev->xexpose.y, mpip->ev->xexpose.height,
712 b.y, b.height, &u, &v))
713 {
714 /* empty intersection */
715 empty_inter = True;
716 }
717 b.y = u;
718 b.height = v;
719 }
720
721 for (i = MAX_MENU_ITEM_LABELS; i-- > 0; )
722 {
723 if (!empty_inter && MI_LABEL(mi)[i] && *(MI_LABEL(mi)[i]))
724 {
725 Bool draw_string = True;
726 int text_width;
727 int tmp_cs;
728
729 if (MI_LABEL_OFFSET(mi)[i] >= lit_x_start &&
730 MI_LABEL_OFFSET(mi)[i] < lit_x_end)
731 {
732 /* label is in hilighted area */
733 fws->gc = gcs.fore_gc;
734 tmp_cs = cs;
735 }
736 else
737 {
738 /* label is in unhilighted area */
739 fws->gc = off_gcs.fore_gc;
740 tmp_cs = off_cs;
741 }
742 if (tmp_cs >= 0)
743 {
744 fws->colorset = &Colorset[tmp_cs];
745 fws->flags.has_colorset = 1;
746 }
747 fws->str = MI_LABEL(mi)[i];
748 b.x = fws->x = MI_LABEL_OFFSET(mi)[i];
749 b.width = text_width = FlocaleTextWidth(
750 font, fws->str, strlen(fws->str));
751
752 if (!item_cleared && mpip->ev)
753 {
754 int s_x,s_w;
755 if (frect_get_seg_intersection(
756 mpip->ev->xexpose.x,
757 mpip->ev->xexpose.width,
758 fws->x, text_width,
759 &s_x, &s_w))
760 {
761 b.x = s_x;
762 b.width = s_w;
763 region = XCreateRegion();
764 XUnionRectWithRegion(
765 &b, region, region);
766 fws->flags.has_clip_region = True;
767 fws->clip_region = region;
768 draw_string = True;
769 XSetRegion(dpy, fws->gc, region);
770 }
771 else
772 {
773 /* empty intersection */
774 draw_string = False;
775 }
776 }
777 if (draw_string)
778 {
779 if (!item_cleared && xft_clear)
780 {
781 clear_menu_item_background(
782 mpip, b.x, b.y, b.width,
783 b.height);
784 }
785 FlocaleDrawString(dpy, font, fws, 0);
786
787 /* hot key */
788 if (MI_HAS_HOTKEY(mi) && !MI_IS_TITLE(mi) &&
789 (!MI_IS_HOTKEY_AUTOMATIC(mi) ||
790 ST_USE_AUTOMATIC_HOTKEYS(ms)) &&
791 MI_HOTKEY_COLUMN(mi) == i)
792 {
793 FlocaleDrawUnderline(
794 dpy, ST_PSTDFONT(ms), fws,
795 MI_HOTKEY_COFFSET(mi));
796 }
797 }
798 }
799 if (region)
800 {
801 XDestroyRegion(region);
802 region = None;
803 fws->flags.has_clip_region = False;
804 fws->clip_region = None;
805 XSetClipMask(dpy, fws->gc, None);
806 }
807 }
808
809 /*
810 * Draw the submenu triangle.
811 */
812
813 if (MI_IS_POPUP(mi))
814 {
815 GC tmp_gc;
816
817 if (MDIM_TRIANGLE_X_OFFSET(*dim) >= lit_x_start &&
818 MDIM_TRIANGLE_X_OFFSET(*dim) < lit_x_end &&
819 is_item_selected)
820 {
821 /* triangle is in hilighted area */
822 if (ST_TRIANGLES_USE_FORE(ms))
823 {
824 tmp_gc = gcs.fore_gc;
825 }
826 else
827 {
828 tmp_gc = gcs.hilight_gc;
829 }
830 }
831 else
832 {
833 /* triangle is in unhilighted area */
834 if (ST_TRIANGLES_USE_FORE(ms))
835 {
836 tmp_gc = off_gcs.fore_gc;
837 }
838 else
839 {
840 tmp_gc = off_gcs.hilight_gc;
841 }
842 }
843 y = y_offset + (y_height - MENU_TRIANGLE_HEIGHT +
844 relief_thickness) / 2;
845
846 if (ST_TRIANGLES_USE_FORE(ms))
847 {
848 DrawTrianglePattern(
849 dpy, mpip->w, tmp_gc, tmp_gc, tmp_gc,
850 MDIM_TRIANGLE_X_OFFSET(*dim), y,
851 MENU_TRIANGLE_WIDTH, MENU_TRIANGLE_HEIGHT, 0,
852 (mpip->flags.is_left_triangle) ? 'l' : 'r',
853 ST_HAS_TRIANGLE_RELIEF(ms),
854 !ST_HAS_TRIANGLE_RELIEF(ms), is_item_selected);
855
856 }
857 else
858 {
859 DrawTrianglePattern(
860 dpy, mpip->w, gcs.hilight_gc, gcs.shadow_gc,
861 tmp_gc, MDIM_TRIANGLE_X_OFFSET(*dim), y,
862 MENU_TRIANGLE_WIDTH, MENU_TRIANGLE_HEIGHT, 0,
863 (mpip->flags.is_left_triangle) ? 'l' : 'r',
864 ST_HAS_TRIANGLE_RELIEF(ms),
865 !ST_HAS_TRIANGLE_RELIEF(ms), is_item_selected);
866 }
867 }
868
869 /*
870 * Draw the item picture.
871 */
872
873 if (MI_PICTURE(mi))
874 {
875 GC tmp_gc;
876 int tmp_cs;
877 Bool draw_picture = True;
878
879 x = menudim_middle_x_offset(mpip->dim) -
880 MI_PICTURE(mi)->width / 2;
881 y = y_offset + ((MI_IS_SELECTABLE(mi)) ? relief_thickness : 0);
882 if (x >= lit_x_start && x < lit_x_end)
883 {
884 tmp_gc = gcs.fore_gc;
885 tmp_cs = cs;
886 }
887 else
888 {
889 tmp_gc = off_gcs.fore_gc;
890 tmp_cs = off_cs;
891 }
892 fra.mask = FRAM_DEST_IS_A_WINDOW;
893 if (tmp_cs >= 0)
894 {
895 fra.mask |= FRAM_HAVE_ICON_CSET;
896 fra.colorset = &Colorset[tmp_cs];
897 }
898 b.x = x;
899 b.y = y;
900 b.width = MI_PICTURE(mi)->width;
901 b.height = MI_PICTURE(mi)->height;
902 if (!item_cleared && mpip->ev)
903 {
904 if (!frect_get_intersection(
905 mpip->ev->xexpose.x, mpip->ev->xexpose.y,
906 mpip->ev->xexpose.width,
907 mpip->ev->xexpose.height,
908 b.x, b.y, b.width, b.height, &b))
909 {
910 draw_picture = False;
911 }
912 }
913 if (draw_picture)
914 {
915 if (
916 !item_cleared &&
917 (MI_PICTURE(mi)->alpha != None ||
918 (tmp_cs >=0 &&
919 Colorset[tmp_cs].icon_alpha_percent < 100)))
920 {
921 clear_menu_item_background(
922 mpip, b.x, b.y, b.width, b.height);
923 }
924 PGraphicsRenderPicture(
925 dpy, mpip->w, MI_PICTURE(mi), &fra,
926 mpip->w, tmp_gc, Scr.MonoGC, Scr.AlphaGC,
927 b.x - x, b.y - y, b.width, b.height,
928 b.x, b.y, b.width, b.height, False);
929 }
930 }
931
932 /*
933 * Draw the mini icons.
934 */
935
936 for (i = 0; i < mpip->used_mini_icons; i++)
937 {
938 int k;
939 Bool draw_picture = True;
940
941 /* We need to reverse the mini icon order for left submenu
942 * style. */
943 k = (ST_USE_LEFT_SUBMENUS(ms)) ?
944 mpip->used_mini_icons - 1 - i : i;
945
946 if (MI_MINI_ICON(mi)[i])
947 {
948 GC tmp_gc;
949 int tmp_cs;
950
951 if (MI_PICTURE(mi))
952 {
953 y = y_offset + MI_HEIGHT(mi) -
954 MI_MINI_ICON(mi)[i]->height;
955 }
956 else
957 {
958 y = y_offset +
959 (MI_HEIGHT(mi) +
960 ((MI_IS_SELECTABLE(mi)) ?
961 relief_thickness : 0) -
962 MI_MINI_ICON(mi)[i]->height) / 2;
963 }
964 if (MDIM_ICON_X_OFFSET(*dim)[k] >= lit_x_start &&
965 MDIM_ICON_X_OFFSET(*dim)[k] < lit_x_end)
966 {
967 /* icon is in hilighted area */
968 tmp_gc = gcs.fore_gc;
969 tmp_cs = cs;
970 }
971 else
972 {
973 /* icon is in unhilighted area */
974 tmp_gc = off_gcs.fore_gc;
975 tmp_cs = off_cs;
976 }
977 fra.mask = FRAM_DEST_IS_A_WINDOW;
978 if (tmp_cs >= 0)
979 {
980 fra.mask |= FRAM_HAVE_ICON_CSET;
981 fra.colorset = &Colorset[tmp_cs];
982 }
983 b.x = MDIM_ICON_X_OFFSET(*dim)[k];
984 b.y = y;
985 b.width = MI_MINI_ICON(mi)[i]->width;
986 b.height = MI_MINI_ICON(mi)[i]->height;
987 if (!item_cleared && mpip->ev)
988 {
989 if (!frect_get_intersection(
990 mpip->ev->xexpose.x,
991 mpip->ev->xexpose.y,
992 mpip->ev->xexpose.width,
993 mpip->ev->xexpose.height,
994 b.x, b.y, b.width, b.height, &b))
995 {
996 draw_picture = False;
997 }
998 }
999 if (draw_picture)
1000 {
1001 if (!item_cleared &&
1002 (MI_MINI_ICON(mi)[i]->alpha != None
1003 || (tmp_cs >=0 &&
1004 Colorset[tmp_cs].icon_alpha_percent <
1005 100)))
1006 {
1007 clear_menu_item_background(
1008 mpip,
1009 b.x, b.y, b.width, b.height);
1010 }
1011 PGraphicsRenderPicture(
1012 dpy, mpip->w, MI_MINI_ICON(mi)[i],
1013 &fra, mpip->w, tmp_gc, Scr.MonoGC,
1014 Scr.AlphaGC,
1015 b.x - MDIM_ICON_X_OFFSET(*dim)[k],
1016 b.y - y, b.width, b.height,
1017 b.x, b.y, b.width, b.height, False);
1018 }
1019 }
1020 }
1021
1022 return;
1023 }
1024
1025 /* returns the center y coordinate of the menu item */
1026 int menuitem_middle_y_offset(struct MenuItem *mi, struct MenuStyle *ms)
1027 {
1028 int r;
1029
1030 if (!mi)
1031 {
1032 return ST_BORDER_WIDTH(ms);
1033 }
1034 r = (MI_IS_SELECTABLE(mi)) ? ST_RELIEF_THICKNESS(ms) : 0;
1035
1036 return MI_Y_OFFSET(mi) + (MI_HEIGHT(mi) + r) / 2;
1037 }
CVS import of FVWM to Git.