Mercurial > hg > xemacs-beta
annotate lwlib/xlwmenu.c @ 5553:62edcc6a11ec
Add an assertion about argument order to #'apply-partially compiler macro
lisp/ChangeLog addition:
2011-08-24 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (apply-partially):
Add an assertion to this compiler macro, requiring that the order
of the placeholders corresponding to the arguments in the
constants vector of the constructed compiled function be the same
as the order of the arguments to #'apply-partially.
tests/ChangeLog addition:
2011-08-24 Aidan Kehoe <kehoea@parhasard.net>
* automated/lisp-tests.el:
Add a test of apply partially that depends on the relative order
of its arguments.
| author | Aidan Kehoe <kehoea@parhasard.net> |
|---|---|
| date | Wed, 24 Aug 2011 11:06:41 +0100 |
| parents | ade4c7e2c6cb |
| children | 574f0cded429 |
| rev | line source |
|---|---|
| 428 | 1 /* Implements a lightweight menubar widget. |
| 2 Copyright (C) 1992, 1993, 1994 Lucid, Inc. | |
| 3 Copyright (C) 1995 Tinker Systems and INS Engineering Corp. | |
| 4 | |
| 5 This file is part of the Lucid Widget Library. | |
| 6 | |
|
5422
ade4c7e2c6cb
Migrate lwlib/ to GPLv3.
Mike Sperber <sperber@deinprogramm.de>
parents:
4916
diff
changeset
|
7 The Lucid Widget Library is free software: you can redistribute it |
|
ade4c7e2c6cb
Migrate lwlib/ to GPLv3.
Mike Sperber <sperber@deinprogramm.de>
parents:
4916
diff
changeset
|
8 and/or modify it under the terms of the GNU General Public License as |
|
ade4c7e2c6cb
Migrate lwlib/ to GPLv3.
Mike Sperber <sperber@deinprogramm.de>
parents:
4916
diff
changeset
|
9 published by the Free Software Foundation, either version 3 of the |
|
ade4c7e2c6cb
Migrate lwlib/ to GPLv3.
Mike Sperber <sperber@deinprogramm.de>
parents:
4916
diff
changeset
|
10 License, or (at your option) any later version. |
|
ade4c7e2c6cb
Migrate lwlib/ to GPLv3.
Mike Sperber <sperber@deinprogramm.de>
parents:
4916
diff
changeset
|
11 |
|
ade4c7e2c6cb
Migrate lwlib/ to GPLv3.
Mike Sperber <sperber@deinprogramm.de>
parents:
4916
diff
changeset
|
12 The Lucid Widget Library is distributed in the hope that it will be |
|
ade4c7e2c6cb
Migrate lwlib/ to GPLv3.
Mike Sperber <sperber@deinprogramm.de>
parents:
4916
diff
changeset
|
13 useful, but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
ade4c7e2c6cb
Migrate lwlib/ to GPLv3.
Mike Sperber <sperber@deinprogramm.de>
parents:
4916
diff
changeset
|
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
ade4c7e2c6cb
Migrate lwlib/ to GPLv3.
Mike Sperber <sperber@deinprogramm.de>
parents:
4916
diff
changeset
|
15 General Public License for more details. |
| 428 | 16 |
| 17 You should have received a copy of the GNU General Public License | |
|
5422
ade4c7e2c6cb
Migrate lwlib/ to GPLv3.
Mike Sperber <sperber@deinprogramm.de>
parents:
4916
diff
changeset
|
18 along with the Lucid Widget Library. If not, see |
|
ade4c7e2c6cb
Migrate lwlib/ to GPLv3.
Mike Sperber <sperber@deinprogramm.de>
parents:
4916
diff
changeset
|
19 <http://www.gnu.org/licenses/>. */ |
| 428 | 20 |
| 21 /* Created by devin@lucid.com */ | |
| 22 | |
| 23 #include <config.h> | |
| 24 #include <stdlib.h> | |
| 25 #include <string.h> | |
| 26 #include <ctype.h> | |
| 27 #include <stdio.h> | |
| 28 #include <sys/types.h> | |
| 29 #include <limits.h> | |
| 30 #ifdef HAVE_UNISTD_H | |
| 31 #include <unistd.h> | |
| 32 #endif | |
| 33 | |
| 34 #include <X11/IntrinsicP.h> | |
| 35 #include <X11/ShellP.h> | |
| 36 #include <X11/StringDefs.h> | |
| 37 #include <X11/cursorfont.h> | |
| 38 #include <X11/bitmaps/gray> | |
| 39 | |
| 40 #ifdef NEED_MOTIF | |
| 41 #include <Xm/Xm.h> | |
| 42 #if XmVersion < 1002 /* 1.1 or ancient */ | |
| 43 #undef XmFONTLIST_DEFAULT_TAG | |
| 44 #define XmFONTLIST_DEFAULT_TAG XmSTRING_DEFAULT_CHARSET | |
| 45 #endif /* XmVersion < 1.2 */ | |
| 46 #endif | |
| 3094 | 47 |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
48 /* #### we may want to turn off HAVE_XFT here if !HAVE_XFT_MENUBARS |
| 3094 | 49 In fact, maybe that's the right interface overall? */ |
| 50 #include "lwlib-fonts.h" | |
| 51 #include "lwlib-colors.h" | |
| 428 | 52 #include "xlwmenuP.h" |
| 53 | |
| 54 #ifdef USE_DEBUG_MALLOC | |
| 55 #include <dmalloc.h> | |
| 56 #endif | |
| 57 | |
| 442 | 58 /* simple, naive integer maximum */ |
| 428 | 59 #ifndef max |
| 60 #define max(a,b) ((a)>(b)?(a):(b)) | |
| 61 #endif | |
| 62 | |
| 63 static char | |
| 64 xlwMenuTranslations [] = | |
| 65 "<BtnDown>: start()\n\ | |
| 66 <BtnMotion>: drag()\n\ | |
| 67 <BtnUp>: select()\n\ | |
| 68 "; | |
| 69 | |
| 70 extern Widget lw_menubar_widget; | |
| 71 | |
| 72 static XtResource | |
| 73 xlwMenuResources[] = | |
| 74 { | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
75 /* The offset macro is a standard trick. The remaining macros are an |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
76 experiment to compress redundancies in resource descriptions, and shut |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
77 up GCC 4.3 (the String casts, which keep G++ from complaining about |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
78 implicit conversions from const char *). */ |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
79 #define offset(field) XtOffset(XlwMenuWidget, menu.field) |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
80 #define fontres(name,_class,repr,type,member,value) \ |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
81 Xt_RESOURCE (name, _class, repr, type, offset(member), XtRString, value) |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
82 #define mflres(name,cls,member,repr,value) \ |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
83 Xt_RESOURCE (name, cls, XmRFontList, XmFontList, offset(member), repr, value) |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
84 #define dimres(name,cls,repr,member,value) \ |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
85 Xt_RESOURCE (name, cls, repr, Dimension, offset(member), XtRImmediate, value) |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
86 #define boolres(nm,cls,member,val) \ |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
87 Xt_RESOURCE (nm, cls, XtRBoolean, Boolean, offset(member), XtRImmediate, val) |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
88 #define cbres(name,member,value) \ |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
89 Xt_RESOURCE (name, XtCCallback, XtRCallback, XtPointer, offset(member), \ |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
90 XtRCallback, value) |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
91 #define pixres(name,_class,member,repr,value) \ |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
92 Xt_RESOURCE (name, _class, XtRPixel, Pixel, offset(member), repr, value) |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
93 #define fgpixres(name,_class,member) \ |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
94 pixres (name, _class, member, XtRString, "XtDefaultForeground") |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
95 #define nullpixres(name,_class,member) \ |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
96 pixres (name, _class, member, XtRImmediate, -1) |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
97 #define pmres(name,cls,member) \ |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
98 Xt_RESOURCE (name, cls, XtRPixmap, Pixmap, offset(member), XtRImmediate, None) |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
99 |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
100 #if defined(NEED_MOTIF) && !defined(HAVE_XFT_MENUBARS) |
| 428 | 101 /* There are three font list resources, so that we can accept either of |
| 102 the resources *fontList: or *font:, and so that we can tell the | |
| 103 difference between them being specified, and being defaulted to a | |
| 104 font from the XtRString specified here. */ | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
105 mflres (XmNfontList, XmCFontList, font_list, XtRImmediate, 0), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
106 mflres (XtNfont, XtCFont, font_list_2, XtRImmediate, 0), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
107 mflres (XmNfontList, XmCFontList, fallback_font_list, |
| 428 | 108 /* We must use an iso8859-1 font here, or people without $LANG set lose. |
| 109 It's fair to assume that those who do have $LANG set also have the | |
| 110 *fontList resource set, or at least know how to deal with this. */ | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
111 XtRString, (XtPointer) "-*-helvetica-bold-r-*-*-*-120-*-*-*-*-iso8859-1"), |
| 428 | 112 #else |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
113 fontres (XtNfont, XtCFont, XtRFontStruct, XFontStruct *, font, |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
114 "XtDefaultFont"), |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
115 #ifdef HAVE_XFT_MENUBARS |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
116 fontres (XtNfcFontName, XtCFcFontName, XtRString, String, fcFontName, |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
117 "sans-serif-12:bold"), |
| 3397 | 118 /* #### This needs to be fixed to give a proper type and converter for |
| 119 XftFonts. See also xlwtabs.c. */ | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
120 fontres (XtNxftFont, XtCXftFont, XtRString, XtPointer, xftFontName, |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
121 "Helvetica-12:bold"), |
| 3094 | 122 #endif |
| 428 | 123 # ifdef USE_XFONTSET |
| 442 | 124 /* #### Consider using the same method as for Motif; see the comment in |
| 125 XlwMenuInitialize(). */ | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
126 fontres (XtNfontSet, XtCFontSet, XtRFontSet, XFontSet, font_set, |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
127 "XtDefaultFontSet"), |
| 428 | 128 # endif |
| 129 #endif | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
130 fgpixres (XtNforeground, XtCForeground, foreground), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
131 fgpixres (XtNbuttonForeground, XtCButtonForeground, button_foreground), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
132 fgpixres (XtNhighlightForeground, XtCHighlightForeground, |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
133 highlight_foreground), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
134 fgpixres (XtNtitleForeground, XtCTitleForeground, title_foreground), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
135 dimres (XtNmargin, XtCMargin, XtRDimension, margin, 2), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
136 dimres (XmNmarginWidth, XmCMarginWidth, XmRHorizontalDimension, |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
137 horizontal_margin, 2), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
138 dimres (XmNmarginHeight, XmCMarginHeight, XmRVerticalDimension, |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
139 vertical_margin, 1), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
140 dimres (XmNspacing, XmCSpacing, XmRHorizontalDimension, column_spacing, 4), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
141 dimres (XmNindicatorSize, XmCIndicatorSize, XtRDimension, indicator_size, 0), |
| 428 | 142 #if 0 |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
143 dimres (XmNshadowThickness, XmCShadowThickness, XmRHorizontalDimension, |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
144 shadow_thickness, 2), |
| 428 | 145 #else |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
146 dimres (XmNshadowThickness, XmCShadowThickness, XtRDimension, |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
147 shadow_thickness, 2), |
| 428 | 148 #endif |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
149 nullpixres (XmNselectColor, XmCSelectColor, select_color), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
150 nullpixres (XmNtopShadowColor, XmCTopShadowColor, top_shadow_color), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
151 nullpixres (XmNbottomShadowColor, XmCBottomShadowColor, bottom_shadow_color), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
152 pmres (XmNtopShadowPixmap, XmCTopShadowPixmap, top_shadow_pixmap), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
153 pmres (XmNbottomShadowPixmap, XmCBottomShadowPixmap, bottom_shadow_pixmap), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
154 |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
155 cbres (XtNopen, open, NULL), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
156 cbres (XtNselect, select, NULL), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
157 Xt_RESOURCE (XtNmenu, XtCMenu, XtRPointer, XtPointer, offset(contents), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
158 XtRImmediate, NULL), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
159 Xt_RESOURCE (XtNcursor, XtCCursor, XtRCursor, Cursor, offset(cursor_shape), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
160 XtRString, "right_ptr"), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
161 Xt_RESOURCE (XtNhorizontal, XtCHorizontal, XtRInt, int, offset(horizontal), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
162 XtRImmediate, True), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
163 boolres (XtNuseBackingStore, XtCUseBackingStore, use_backing_store, False), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
164 boolres (XtNbounceDown, XtCBounceDown, bounce_down, True), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
165 boolres (XtNresourceLabels, XtCResourceLabels, lookup_labels, False), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
166 |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
167 #undef offset |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
168 #undef mflres |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
169 #undef fontres |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
170 #undef dimres |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
171 #undef boolres |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
172 #undef cbres |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
173 #undef pixres |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
174 #undef fgpixres |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
175 #undef nullpixres |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
176 #undef pmres |
|
4522
fc7067b7f407
Backout last patch; forgot to specify file.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4521
diff
changeset
|
177 }; |
| 428 | 178 |
| 1201 | 179 static Boolean XlwMenuSetValues (Widget current, Widget request, Widget new_, |
| 428 | 180 ArgList args, Cardinal *num_args); |
| 181 static void XlwMenuRealize (Widget w, Mask *valueMask, | |
| 182 XSetWindowAttributes *attributes); | |
| 183 static void XlwMenuRedisplay (Widget w, XEvent *ev, Region region); | |
| 184 static void XlwMenuResize (Widget w); | |
| 1201 | 185 static void XlwMenuInitialize (Widget request, Widget new_, ArgList args, |
| 428 | 186 Cardinal *num_args); |
| 187 static void XlwMenuDestroy (Widget w); | |
| 188 static void XlwMenuClassInitialize (void); | |
| 189 static void Start (Widget w, XEvent *ev, String *params, Cardinal *num_params); | |
| 190 static void Drag (Widget w, XEvent *ev, String *params, Cardinal *num_params); | |
| 191 static void Select(Widget w, XEvent *ev, String *params, Cardinal *num_params); | |
| 192 | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
193 #if defined(NEED_MOTIF) && !defined(HAVE_XFT_MENUBARS) |
| 428 | 194 static XFontStruct *default_font_of_font_list (XmFontList); |
| 195 #endif | |
| 196 | |
| 197 static XtActionsRec | |
| 198 xlwMenuActionsList [] = | |
| 199 { | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
200 { (String) "start", Start}, |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
201 { (String) "drag", Drag}, |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
202 { (String) "select", Select}, |
| 428 | 203 }; |
| 204 | |
| 205 #define SuperClass ((CoreWidgetClass)&coreClassRec) | |
| 206 | |
| 207 XlwMenuClassRec xlwMenuClassRec = | |
| 208 { | |
| 209 { /* CoreClass fields initialization */ | |
| 210 (WidgetClass) SuperClass, /* superclass */ | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
211 (String) "XlwMenu", /* class_name */ |
| 428 | 212 sizeof(XlwMenuRec), /* size */ |
| 213 XlwMenuClassInitialize, /* class_initialize */ | |
| 214 NULL, /* class_part_initialize */ | |
| 215 FALSE, /* class_inited */ | |
| 216 XlwMenuInitialize, /* initialize */ | |
| 217 NULL, /* initialize_hook */ | |
| 218 XlwMenuRealize, /* realize */ | |
| 219 xlwMenuActionsList, /* actions */ | |
| 220 XtNumber(xlwMenuActionsList), /* num_actions */ | |
| 221 xlwMenuResources, /* resources */ | |
| 222 XtNumber(xlwMenuResources), /* resource_count */ | |
| 223 NULLQUARK, /* xrm_class */ | |
| 224 TRUE, /* compress_motion */ | |
| 1294 | 225 XtExposeCompressMaximal, /* compress_exposure */ |
| 428 | 226 TRUE, /* compress_enterleave */ |
| 227 FALSE, /* visible_interest */ | |
| 228 XlwMenuDestroy, /* destroy */ | |
| 229 XlwMenuResize, /* resize */ | |
| 230 XlwMenuRedisplay, /* expose */ | |
| 231 XlwMenuSetValues, /* set_values */ | |
| 232 NULL, /* set_values_hook */ | |
| 233 XtInheritSetValuesAlmost, /* set_values_almost */ | |
| 234 NULL, /* get_values_hook */ | |
| 235 NULL, /* #### - should this be set for grabs? accept_focus */ | |
| 236 XtVersion, /* version */ | |
| 237 NULL, /* callback_private */ | |
| 238 xlwMenuTranslations, /* tm_table */ | |
| 239 XtInheritQueryGeometry, /* query_geometry */ | |
| 240 XtInheritDisplayAccelerator, /* display_accelerator */ | |
| 241 NULL /* extension */ | |
| 242 }, /* XlwMenuClass fields initialization */ | |
| 243 { | |
| 244 0 /* dummy */ | |
| 245 }, | |
| 246 }; | |
| 247 | |
| 248 WidgetClass xlwMenuWidgetClass = (WidgetClass) &xlwMenuClassRec; | |
| 249 | |
| 250 extern int lw_menu_accelerate; | |
| 251 | |
| 252 /* Utilities */ | |
| 253 #if 0 /* Apparently not used anywhere */ | |
| 254 | |
| 255 static char * | |
| 256 safe_strdup (char *s) | |
| 257 { | |
| 258 char *result; | |
| 259 if (! s) return 0; | |
| 260 result = (char *) malloc (strlen (s) + 1); | |
| 261 if (! result) | |
| 262 return 0; | |
| 263 strcpy (result, s); | |
| 264 return result; | |
| 265 } | |
| 266 | |
| 267 #endif /* 0 */ | |
| 268 | |
| 269 static void | |
| 270 push_new_stack (XlwMenuWidget mw, widget_value *val) | |
| 271 { | |
| 272 if (!mw->menu.new_stack) | |
| 273 { | |
| 274 mw->menu.new_stack_length = 10; | |
| 275 mw->menu.new_stack = | |
| 276 (widget_value**)XtCalloc (mw->menu.new_stack_length, | |
| 277 sizeof (widget_value*)); | |
| 278 } | |
| 279 else if (mw->menu.new_depth == mw->menu.new_stack_length) | |
| 280 { | |
| 281 mw->menu.new_stack_length *= 2; | |
| 282 mw->menu.new_stack = | |
| 283 (widget_value**)XtRealloc ((char *)mw->menu.new_stack, | |
| 284 mw->menu.new_stack_length * | |
| 285 sizeof (widget_value*)); | |
| 286 } | |
| 287 mw->menu.new_stack [mw->menu.new_depth++] = val; | |
| 288 } | |
| 289 | |
| 290 static void | |
| 291 pop_new_stack_if_no_contents (XlwMenuWidget mw) | |
| 292 { | |
| 293 if (mw->menu.new_depth && | |
| 294 !mw->menu.new_stack [mw->menu.new_depth - 1]->contents) | |
| 295 mw->menu.new_depth -= 1; | |
| 296 } | |
| 297 | |
| 298 static void | |
| 299 make_old_stack_space (XlwMenuWidget mw, int n) | |
| 300 { | |
| 301 if (!mw->menu.old_stack) | |
| 302 { | |
| 303 mw->menu.old_stack_length = max (10, n); | |
| 304 mw->menu.old_stack = | |
| 305 (widget_value**)XtCalloc (mw->menu.old_stack_length, | |
| 306 sizeof (widget_value*)); | |
| 307 } | |
| 308 else if (mw->menu.old_stack_length < n) | |
| 309 { | |
| 310 while (mw->menu.old_stack_length < n) | |
| 311 mw->menu.old_stack_length *= 2; | |
| 312 | |
| 313 mw->menu.old_stack = | |
| 314 (widget_value**)XtRealloc ((char *)mw->menu.old_stack, | |
| 315 mw->menu.old_stack_length * | |
| 316 sizeof (widget_value*)); | |
| 317 } | |
| 318 } | |
| 319 | |
| 320 static Boolean | |
| 321 close_to_reference_time (Widget w, Time reference_time, XEvent *ev) | |
| 322 { | |
| 323 return | |
| 324 reference_time && | |
| 647 | 325 ((int) (ev->xbutton.time - reference_time) < |
| 326 XtGetMultiClickTime (XtDisplay (w))); | |
| 428 | 327 } |
| 328 | |
| 329 /* Size code */ | |
| 330 static int | |
| 331 string_width (XlwMenuWidget mw, | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
332 #if defined(NEED_MOTIF) && !defined(HAVE_XFT_MENUBARS) |
| 428 | 333 XmString s |
| 334 #else | |
| 335 char *s | |
| 336 #endif | |
| 337 ) | |
| 338 { | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
339 #if defined(NEED_MOTIF) && !defined(HAVE_XFT_MENUBARS) |
| 428 | 340 Dimension width, height; |
| 341 XmStringExtent (mw->menu.font_list, s, &width, &height); | |
| 342 return width; | |
| 343 #else | |
| 344 # ifdef USE_XFONTSET | |
| 345 XRectangle ri, rl; | |
| 346 XmbTextExtents (mw->menu.font_set, s, strlen (s), &ri, &rl); | |
| 347 return rl.width; | |
| 348 # else | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
349 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 350 XGlyphInfo glyphinfo; |
| 3374 | 351 XftTextExtents8 (XtDisplay (mw), mw->menu.renderFont, (FcChar8 *) s, |
| 352 strlen (s), &glyphinfo); | |
| 3094 | 353 return glyphinfo.xOff; |
| 354 #else | |
| 428 | 355 XCharStruct xcs; |
| 356 int drop; | |
| 357 XTextExtents (mw->menu.font, s, strlen (s), &drop, &drop, &drop, &xcs); | |
| 358 return xcs.width; | |
| 3094 | 359 #endif |
| 428 | 360 # endif /* USE_XFONTSET */ |
| 361 #endif | |
| 362 } | |
| 363 | |
| 364 static char massaged_resource_char[256]; | |
| 365 | |
| 366 static void | |
| 367 initialize_massaged_resource_char (void) | |
| 368 { | |
| 369 int j; | |
| 370 for (j = 0; j < (int) sizeof (massaged_resource_char); j++) | |
| 371 { | |
| 372 if ((j >= 'a' && j <= 'z') || | |
| 373 (j >= 'A' && j <= 'Z') || | |
| 374 (j >= '0' && j <= '9') || | |
| 375 (j == '_') || | |
| 376 (j >= 0xa0)) | |
| 377 massaged_resource_char[j] = (char) j; | |
| 378 } | |
| 379 massaged_resource_char ['_'] = '_'; | |
| 380 massaged_resource_char ['+'] = 'P'; /* Convert C++ to cPP */ | |
| 381 massaged_resource_char ['.'] = '_'; /* Convert Buffers... to buffers___ */ | |
| 382 } | |
| 383 | |
| 384 static int | |
| 385 string_width_u (XlwMenuWidget mw, | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
386 #if defined(NEED_MOTIF) && !defined(HAVE_XFT_MENUBARS) |
| 428 | 387 XmString string |
| 388 #else | |
| 389 char *string | |
| 390 #endif | |
| 391 ) | |
| 392 { | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
393 #if defined(NEED_MOTIF) && !defined(HAVE_XFT_MENUBARS) |
| 428 | 394 Dimension width, height; |
| 395 XmString newstring; | |
| 396 #else | |
| 397 # ifdef USE_XFONTSET | |
| 398 XRectangle ri, rl; | |
| 399 # else /* ! USE_XFONTSET */ | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
400 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 401 XGlyphInfo glyphinfo; |
| 402 #else | |
| 428 | 403 XCharStruct xcs; |
| 404 int drop; | |
| 3094 | 405 #endif |
| 428 | 406 # endif |
| 407 #endif | |
| 408 char* newchars; | |
| 409 int charslength; | |
| 410 char *chars; | |
| 411 int i, j; | |
| 412 | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
413 #if defined(NEED_MOTIF) && !defined(HAVE_XFT_MENUBARS) |
| 428 | 414 chars = ""; |
| 415 if (!XmStringGetLtoR (string, XmFONTLIST_DEFAULT_TAG, &chars)) | |
| 416 chars = ""; | |
| 417 #else | |
| 418 chars = string; | |
| 419 #endif | |
| 420 charslength = strlen (chars); | |
| 421 newchars = (char *) alloca (charslength + 1); | |
| 422 | |
| 423 for (i = j = 0; chars[i] && (j < charslength); i++) | |
| 424 if (chars[i]=='%'&&chars[i+1]=='_') | |
| 425 i++; | |
| 426 else | |
| 427 newchars[j++] = chars[i]; | |
| 428 newchars[j] = '\0'; | |
| 429 | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
430 #if defined(NEED_MOTIF) && !defined(HAVE_XFT_MENUBARS) |
| 428 | 431 newstring = XmStringLtoRCreate (newchars, XmFONTLIST_DEFAULT_TAG); |
| 432 XmStringExtent (mw->menu.font_list, newstring, &width, &height); | |
| 433 XmStringFree (newstring); | |
| 434 XtFree (chars); | |
| 435 return width; | |
| 436 #else | |
| 437 # ifdef USE_XFONTSET | |
| 438 XmbTextExtents (mw->menu.font_set, newchars, j, &ri, &rl); | |
| 439 return rl.width; | |
| 440 # else /* ! USE_XFONTSET */ | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
441 #ifdef HAVE_XFT_MENUBARS |
| 3374 | 442 XftTextExtents8 (XtDisplay (mw), mw->menu.renderFont, (FcChar8 *) newchars, |
| 443 j, &glyphinfo); | |
| 3094 | 444 return glyphinfo.xOff; |
| 445 #else | |
| 428 | 446 XTextExtents (mw->menu.font, newchars, j, &drop, &drop, &drop, &xcs); |
| 447 return xcs.width; | |
| 3094 | 448 #endif |
| 428 | 449 # endif /* USE_XFONTSET */ |
| 450 #endif | |
| 451 } | |
| 452 | |
| 453 static void | |
| 442 | 454 massage_resource_name (const char *in, char *out) |
| 428 | 455 { |
| 456 /* Turn a random string into something suitable for using as a resource. | |
| 457 For example: | |
| 458 | |
| 459 "Kill Buffer" -> "killBuffer" | |
| 460 "Find File..." -> "findFile___" | |
| 461 "Search and Replace..." -> "searchAndReplace___" | |
| 462 "C++ Mode Commands" -> "cppModeCommands" | |
| 463 | |
| 464 Valid characters in a resource NAME component are: a-zA-Z0-9_ | |
| 465 */ | |
| 466 | |
| 467 #ifdef PRINT_XLWMENU_RESOURCE_CONVERSIONS | |
| 468 /* Compile with -DPRINT_XLWMENU_RESOURCE_CONVERSIONS to generate a | |
| 469 translation file for menu localizations. */ | |
| 470 char *save_in = in, *save_out = out; | |
| 471 #endif | |
| 472 | |
| 473 Boolean firstp = True; | |
| 474 while (*in) | |
| 475 { | |
| 442 | 476 if (*in == '%' && *(in + 1) == '_') |
| 477 in += 2; | |
| 478 else | |
| 428 | 479 { |
| 442 | 480 char ch; |
| 481 | |
| 482 if (*in == '%' && *(in + 1) == '%') | |
| 483 in++; | |
| 484 ch = massaged_resource_char[(unsigned char) *in++]; | |
| 485 if (ch) | |
| 486 { | |
| 487 int int_ch = (int) (unsigned char) ch; | |
| 488 *out++ = firstp ? tolower (int_ch) : toupper (int_ch); | |
| 489 firstp = False; | |
| 490 while ((ch = massaged_resource_char[(unsigned char) *in++]) | |
| 491 != '\0') | |
| 492 *out++ = ch; | |
| 493 if (!*(in-1)) /* Overshot the NULL byte? */ | |
| 494 break; | |
| 495 } | |
| 428 | 496 } |
| 497 } | |
| 498 *out = 0; | |
| 499 | |
| 500 #ifdef PRINT_XLWMENU_RESOURCE_CONVERSIONS | |
| 501 printf ("! Emacs*XlwMenu.%s.labelString:\t%s\n", save_out, save_in); | |
| 502 printf ( "Emacs*XlwMenu.%s.labelString:\n", save_out); | |
| 503 #endif | |
| 504 } | |
| 505 | |
| 506 static XtResource | |
| 507 nameResource[] = | |
| 508 { | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
509 { (String) "labelString", (String) "LabelString", XtRString, sizeof(String), |
| 428 | 510 0, XtRImmediate, 0 } |
| 511 }; | |
| 512 | |
| 442 | 513 /* This function searches STRING for parameter inserts of the form: |
| 514 %[padding]1 | |
| 515 padding is either space (' ') or dash ('-') meaning | |
| 516 padding to the left or right of the inserted parameter. | |
| 517 In essence, all %1 strings are replaced by VALUE in the return value. | |
| 518 The caller is expected to free the return value using XtFree(). | |
| 519 %% means insert one % (like printf). | |
| 520 %1 means insert VALUE. | |
| 521 %-1 means insert VALUE followed by one space. The latter is | |
| 522 not inserted if VALUE is a zero length string. | |
| 523 */ | |
| 428 | 524 static char* |
| 442 | 525 parameterize_string (const char *string, const char *value) |
| 428 | 526 { |
| 442 | 527 const char *percent; |
| 428 | 528 char *result; |
| 529 unsigned int done = 0; | |
| 530 unsigned int ntimes; | |
| 531 | |
| 532 if (!string) | |
| 533 { | |
| 534 result = XtMalloc(1); | |
| 535 result[0] = '\0'; | |
| 442 | 536 return result; |
| 428 | 537 } |
| 538 | |
| 539 if (!value) | |
| 540 value = ""; | |
| 541 | |
| 442 | 542 for (ntimes = 1, percent = string; |
| 543 (percent = strchr (percent, '%')); | |
| 428 | 544 ntimes++) |
| 442 | 545 percent++; |
| 428 | 546 |
| 547 result = XtMalloc ((ntimes * strlen(value)) + strlen(string) + 4); | |
| 548 result[0] = '\0'; | |
| 549 | |
| 442 | 550 while ((percent = strchr (string, '%'))) |
| 428 | 551 { |
| 552 unsigned int left_pad; | |
| 553 unsigned int right_pad; | |
| 442 | 554 const char *p; |
| 428 | 555 |
| 556 if (percent[1] == '%') | |
| 557 { /* it's a real % */ | |
| 558 strncat (result, string, 1 + percent - string); /* incl % */ | |
| 559 string = &percent[2]; /* after the second '%' */ | |
| 560 continue; /* with the while() loop */ | |
| 561 } | |
| 562 | |
| 563 left_pad = 0; | |
| 564 right_pad = 0; | |
| 565 | |
| 566 for (p = &percent[1]; /* test *p inside the loop */ ; p++) | |
| 567 { | |
| 568 if (*p == ' ') | |
| 569 { /* left pad */ | |
| 570 left_pad++; | |
| 571 } | |
| 572 else if (*p == '-') | |
| 573 { /* right pad */ | |
| 574 right_pad++; | |
| 575 } | |
| 576 else if (*p == '1') | |
| 577 { /* param and terminator */ | |
| 578 strncat (result, string, percent - string); | |
| 579 if (value[0] != '\0') | |
| 580 { | |
| 581 unsigned int i; | |
| 582 for (i = 0; i < left_pad; i++) | |
| 583 strcat (result, " "); | |
| 584 strcat (result, value); | |
| 585 for (i = 0; i < right_pad; i++) | |
| 586 strcat (result, " "); | |
| 587 } | |
| 588 string = &p[1]; /* after the '1' */ | |
| 589 done++; /* no need to do old way */ | |
| 590 break; /* out of for() loop */ | |
| 591 } | |
| 592 else | |
| 593 { /* bogus, copy the format as is */ | |
| 594 /* out of for() loop */ | |
| 595 strncat (result, string, 1 + p - string); | |
| 596 string = (*p ? &p[1] : p); | |
| 597 break; | |
| 598 } | |
| 599 } | |
| 600 } | |
| 601 | |
| 602 /* Copy the tail of the string */ | |
| 603 strcat (result, string); | |
| 604 | |
| 605 /* If we have not processed a % string, and we have a value, tail it. */ | |
| 606 if (!done && value[0] != '\0') | |
| 607 { | |
| 608 strcat (result, " "); | |
| 609 strcat (result, value); | |
| 610 } | |
| 611 | |
| 612 return result; | |
| 613 } | |
| 614 | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
615 #if defined(NEED_MOTIF) && !defined(HAVE_XFT_MENUBARS) |
| 428 | 616 |
| 617 static XmString | |
| 618 resource_widget_value (XlwMenuWidget mw, widget_value *val) | |
| 619 { | |
| 620 if (!val->toolkit_data) | |
| 621 { | |
| 622 char *resourced_name = NULL; | |
| 623 char *converted_name, *str; | |
| 624 XmString complete_name; | |
| 625 char massaged_name [1024]; | |
| 626 | |
| 627 if (mw->menu.lookup_labels) | |
| 628 { | |
| 629 /* Convert value style name into resource style name. | |
| 630 eg: "Free Willy" becomes "freeWilly" */ | |
| 631 massage_resource_name (val->name, massaged_name); | |
| 632 | |
| 633 /* If we have a value (parameter) see if we can find a "Named" | |
| 634 resource. */ | |
| 635 if (val->value) | |
| 636 { | |
| 637 char named_name[1024]; | |
| 638 sprintf (named_name, "%sNamed", massaged_name); | |
| 639 XtGetSubresources ((Widget) mw, | |
| 640 (XtPointer) &resourced_name, | |
| 641 named_name, named_name, | |
| 642 nameResource, 1, NULL, 0); | |
| 643 } | |
| 644 | |
| 645 /* If nothing yet, try to load from the massaged name. */ | |
| 646 if (!resourced_name) | |
| 647 { | |
| 648 XtGetSubresources ((Widget) mw, | |
| 649 (XtPointer) &resourced_name, | |
| 650 massaged_name, massaged_name, | |
| 651 nameResource, 1, NULL, 0); | |
| 652 } | |
| 653 } /* if (mw->menu.lookup_labels) */ | |
| 654 | |
| 655 /* Still nothing yet, use the name as the value. */ | |
| 656 if (!resourced_name) | |
| 657 resourced_name = val->name; | |
| 658 | |
| 659 /* Parameterize the string. */ | |
| 660 converted_name = parameterize_string (resourced_name, val->value); | |
| 661 | |
| 662 /* nuke newline characters to prevent menubar screwups */ | |
| 663 for ( str = converted_name ; *str ; str++ ) | |
| 664 { | |
| 665 if (str[0] == '\n') str[0] = ' '; | |
| 666 } | |
| 667 | |
| 668 /* Improve OSF's bottom line. */ | |
| 669 #if (XmVersion >= 1002) | |
| 670 complete_name = XmStringCreateLocalized (converted_name); | |
| 671 #else | |
| 672 complete_name = XmStringCreateLtoR (converted_name, | |
| 673 XmSTRING_DEFAULT_CHARSET); | |
| 674 #endif | |
| 675 XtFree (converted_name); | |
| 676 | |
| 677 val->toolkit_data = complete_name; | |
| 678 val->free_toolkit_data = True; | |
| 679 } | |
| 680 return (XmString) val->toolkit_data; | |
| 681 } | |
| 682 | |
| 683 /* Unused */ | |
| 684 #if 0 | |
| 442 | 685 /* These two routines should be a separate file..djw */ |
| 428 | 686 static char * |
| 687 xlw_create_localized_string (Widget w, | |
| 688 char *name, | |
| 689 char **args, | |
| 690 unsigned int nargs) | |
| 691 { | |
| 692 char *string = NULL; | |
| 693 char *arg = NULL; | |
| 694 | |
| 695 if (nargs > 0) | |
| 696 arg = args[0]; | |
| 697 | |
| 698 XtGetSubresources (w, | |
| 699 (XtPointer)&string, | |
| 700 name, | |
| 701 name, | |
| 702 nameResource, 1, | |
| 703 NULL, 0); | |
| 704 | |
| 705 if (!string) | |
| 706 string = name; | |
| 707 | |
| 708 return parameterize_string (string, arg); | |
| 709 } | |
| 710 | |
| 711 static XmString | |
| 712 xlw_create_localized_xmstring (Widget w, | |
| 713 char *name, | |
| 714 char **args, | |
| 715 unsigned int nargs) | |
| 716 { | |
| 717 char * string = xlw_create_localized_string (w, name, args, nargs); | |
| 718 XmString xm_string = XmStringCreateLtoR (string, XmSTRING_DEFAULT_CHARSET); | |
| 719 XtFree (string); | |
| 720 return xm_string; | |
| 721 } | |
| 722 #endif /* 0 */ | |
| 723 | |
| 724 #else /* !Motif */ | |
| 725 | |
| 726 static char* | |
| 727 resource_widget_value (XlwMenuWidget mw, widget_value *val) | |
| 728 { | |
| 729 if (!val->toolkit_data) | |
| 730 { | |
| 731 char *resourced_name = NULL; | |
| 732 char *complete_name; | |
| 733 char massaged_name [1024]; | |
| 734 | |
| 735 if (mw->menu.lookup_labels) | |
| 736 { | |
| 737 massage_resource_name (val->name, massaged_name); | |
| 738 | |
| 739 XtGetSubresources ((Widget) mw, | |
| 740 (XtPointer) &resourced_name, | |
| 741 massaged_name, massaged_name, | |
| 742 nameResource, 1, NULL, 0); | |
| 743 } | |
| 744 if (!resourced_name) | |
| 745 resourced_name = val->name; | |
| 746 | |
| 747 complete_name = parameterize_string (resourced_name, val->value); | |
| 748 | |
| 749 val->toolkit_data = complete_name; | |
| 750 /* nuke newline characters to prevent menubar screwups */ | |
| 751 for ( ; *complete_name ; complete_name++ ) | |
| 752 { | |
| 753 if (complete_name[0] == '\n') | |
| 754 complete_name[0] = ' '; | |
| 755 } | |
| 756 val->free_toolkit_data = True; | |
| 757 } | |
| 758 return (char *) val->toolkit_data; | |
| 759 } | |
| 760 | |
| 761 #endif /* !Motif */ | |
| 762 | |
| 3094 | 763 #define MINL(x,y) ((((unsigned long) (x)) < ((unsigned long) (y))) \ |
| 764 ? ((unsigned long) (x)) : ((unsigned long) (y))) | |
| 765 | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
766 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 767 static int |
| 768 x_xft_text_width (Display *dpy, XftFont *xft_font, char *run, int len) | |
| 769 { | |
| 770 static XGlyphInfo glyphinfo; | |
| 771 | |
| 772 XftTextExtents8 (dpy, | |
| 773 xft_font, | |
| 3374 | 774 (FcChar8 *) run, len, &glyphinfo); |
| 3094 | 775 return glyphinfo.xOff; |
| 776 } | |
| 777 #endif | |
| 778 | |
| 428 | 779 /* Code for drawing strings. */ |
| 780 static void | |
| 781 string_draw (XlwMenuWidget mw, | |
| 782 Window window, | |
| 783 int x, int y, | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
784 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 785 XftColor *color, |
| 786 XftColor *colorBg, | |
| 787 #else | |
| 428 | 788 GC gc, |
| 3094 | 789 #endif |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
790 #if defined(NEED_MOTIF) && !defined(HAVE_XFT_MENUBARS) |
| 428 | 791 XmString string |
| 792 #else | |
| 793 char *string | |
| 794 #endif | |
| 795 ) | |
| 796 { | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
797 #if defined(NEED_MOTIF) && !defined(HAVE_XFT_MENUBARS) |
| 428 | 798 XmStringDraw (XtDisplay (mw), window, |
| 799 mw->menu.font_list, | |
| 800 string, gc, | |
| 801 x, y, | |
| 802 1000, /* ???? width */ | |
| 803 XmALIGNMENT_BEGINNING, | |
| 804 0, /* ???? layout_direction */ | |
| 805 0); | |
| 806 #else | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
807 # ifdef HAVE_XFT_MENUBARS |
| 3094 | 808 Display *display = XtDisplay (mw); |
| 809 Visual *visual = DefaultVisualOfScreen (XtScreen (mw)); | |
| 810 Colormap cmap = mw->core.colormap; | |
| 811 XftDraw *xftDraw = XftDrawCreate (display, window, visual, cmap); | |
| 812 XftFont *renderFont = mw->menu.renderFont; | |
| 813 /* draw background rect */ | |
| 814 XftDrawRect (xftDraw, colorBg, | |
| 815 x, y, | |
| 816 x_xft_text_width (display, renderFont, string, strlen (string)), | |
| 817 renderFont->ascent + renderFont->descent); /* XXX */ | |
| 818 /* draw text */ | |
| 3374 | 819 XftDrawString8 (xftDraw, color, renderFont, x, y + mw->menu.font_ascent, |
| 820 (FcChar8 *) string, strlen (string)); | |
| 3094 | 821 XftDrawDestroy (xftDraw); |
| 822 # else | |
| 823 # ifdef USE_XFONTSET | |
| 428 | 824 XmbDrawString (XtDisplay (mw), window, mw->menu.font_set, gc, |
| 825 x, y + mw->menu.font_ascent, string, strlen (string)); | |
| 3094 | 826 # else |
| 428 | 827 XDrawString (XtDisplay (mw), window, gc, |
| 828 x, y + mw->menu.font_ascent, string, strlen (string)); | |
| 3094 | 829 # endif /* USE_XFONTSET */ |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
830 # endif /* HAVE_XFT_MENUBARS */ |
| 3094 | 831 #endif /* NEED_MOTIF */ |
| 428 | 832 } |
| 833 | |
| 834 static int | |
| 835 string_draw_range ( | |
| 836 XlwMenuWidget mw, | |
| 837 Window window, | |
| 838 int x, int y, | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
839 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 840 XftColor *color, |
| 841 XftColor *colorBg, | |
| 842 #else | |
| 428 | 843 GC gc, |
| 3094 | 844 #endif |
| 428 | 845 char *string, |
| 846 int start, | |
| 847 int end | |
| 848 ) | |
| 849 { | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
850 #if defined(NEED_MOTIF) && !defined(HAVE_XFT_MENUBARS) |
| 428 | 851 Dimension width, height; |
| 852 XmString newstring; | |
| 853 int c; | |
| 854 | |
| 855 if (end <= start) | |
| 856 return 0; | |
| 857 c = string[end]; | |
| 858 string[end] = '\0'; | |
| 859 newstring = XmStringLtoRCreate (&string[start], XmFONTLIST_DEFAULT_TAG); | |
| 860 XmStringDraw ( | |
| 861 XtDisplay (mw), window, | |
| 862 mw->menu.font_list, | |
| 863 newstring, gc, | |
| 864 x, y, | |
| 865 1000, /* ???? width */ | |
| 866 XmALIGNMENT_BEGINNING, | |
| 867 0, /* ???? layout_direction */ | |
| 868 0 | |
| 869 ); | |
| 870 XmStringExtent (mw->menu.font_list, newstring, &width, &height); | |
| 871 XmStringFree (newstring); | |
| 872 string[end] = c; | |
| 873 return width; | |
| 874 #else | |
| 875 # ifdef USE_XFONTSET | |
| 876 XRectangle ri, rl; | |
| 877 | |
| 878 if (end <= start) | |
| 879 return 0; | |
| 880 XmbDrawString ( | |
| 881 XtDisplay (mw), window, mw->menu.font_set, gc, | |
| 882 x, y + mw->menu.font_ascent, &string[start], end - start); | |
| 883 XmbTextExtents ( | |
| 884 mw->menu.font_set, &string[start], end - start, &ri, &rl); | |
| 885 return rl.width; | |
| 886 # else | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
887 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 888 if (end <= start) |
| 889 return 0; | |
| 890 else | |
| 891 { | |
| 892 XGlyphInfo glyphinfo; | |
| 893 Display *display = XtDisplay (mw); | |
| 894 Visual *visual = DefaultVisualOfScreen (XtScreen (mw)); | |
| 895 Colormap cmap = mw->core.colormap; | |
| 896 XftFont *renderFont = mw->menu.renderFont; | |
| 897 /* #### should use parent frame's .xftDraw? */ | |
| 898 XftDraw *xftDraw = XftDrawCreate (display, window, visual, cmap); | |
| 899 /* draw background rect */ | |
| 900 XftDrawRect (xftDraw, colorBg, | |
| 901 x, y, | |
| 902 x_xft_text_width (display, | |
| 903 renderFont, &string[start], end - start), | |
| 904 renderFont->ascent + renderFont->descent); /* XXX */ | |
| 905 /* draw text */ | |
| 906 XftDrawString8 (xftDraw, color, renderFont, | |
| 907 x, y + mw->menu.font_ascent, | |
| 3374 | 908 (FcChar8 *) &string[start], end - start); |
| 3094 | 909 |
| 3374 | 910 XftTextExtents8 (display, renderFont, (FcChar8 *) &string[start], |
| 911 end - start, &glyphinfo); | |
| 3094 | 912 |
| 913 /* #### should use parent frame's .xftDraw */ | |
| 914 XftDrawDestroy (xftDraw); | |
| 915 return glyphinfo.xOff; | |
| 916 } | |
| 917 #else | |
| 428 | 918 XCharStruct xcs; |
| 919 int drop; | |
| 920 | |
| 921 if (end <= start) | |
| 922 return 0; | |
| 3094 | 923 XDrawString ( /* XXX */ |
| 428 | 924 XtDisplay (mw), window, gc, |
| 925 x, y + mw->menu.font_ascent, &string[start], end - start); | |
| 926 XTextExtents ( | |
| 927 mw->menu.font, &string[start], end - start, | |
| 928 &drop, &drop, &drop, &xcs); | |
| 929 return xcs.width; | |
| 3094 | 930 #endif |
| 428 | 931 # endif |
| 932 #endif | |
| 933 } | |
| 934 | |
| 935 static void | |
| 936 string_draw_u (XlwMenuWidget mw, | |
| 937 Window window, | |
| 938 int x, int y, | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
939 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 940 XftColor *color, XftColor *colorBg, GC gc, |
| 941 #else | |
| 428 | 942 GC gc, |
| 3094 | 943 #endif |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
944 #if defined(NEED_MOTIF) && !defined(HAVE_XFT_MENUBARS) |
| 428 | 945 XmString string |
| 946 #else | |
| 947 char *string | |
| 948 #endif | |
| 949 ) | |
| 950 { | |
| 951 int i, s = 0; | |
| 952 char *chars; | |
| 953 | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
954 #if defined(NEED_MOTIF) && !defined(HAVE_XFT_MENUBARS) |
| 428 | 955 chars = ""; |
| 956 if (!XmStringGetLtoR (string, XmFONTLIST_DEFAULT_TAG, &chars)) | |
| 957 chars = ""; | |
| 958 #else | |
| 959 chars = string; | |
| 960 #endif | |
| 961 for (i=0; chars[i]; ++i) { | |
| 962 if (chars[i] == '%' && chars[i+1] == '_') { | |
| 963 int w; | |
| 964 | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
965 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 966 x += string_draw_range (mw, window, x, y, color, colorBg, chars, s, i); |
| 967 w = string_draw_range (mw, window, x, y, color, colorBg, chars, i+2, i+3); | |
| 968 #else | |
| 428 | 969 x += string_draw_range (mw, window, x, y, gc, chars, s, i); |
| 970 w = string_draw_range (mw, window, x, y, gc, chars, i+2, i+3); | |
| 3094 | 971 #endif |
| 428 | 972 |
| 973 /* underline next character */ | |
| 974 XDrawLine (XtDisplay (mw), window, gc, x - 1, | |
| 975 y + mw->menu.font_ascent + 1, | |
| 976 x + w - 1, y + mw->menu.font_ascent + 1 ); | |
| 977 x += w; | |
| 978 s = i + 3; | |
| 979 i += 2; | |
| 980 } | |
| 981 } | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
982 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 983 x += string_draw_range (mw, window, x, y, color, colorBg, chars, s, i); |
| 984 #else | |
| 428 | 985 x += string_draw_range (mw, window, x, y, gc, chars, s, i); |
| 3094 | 986 #endif |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
987 #if defined(NEED_MOTIF) && !defined(HAVE_XFT_MENUBARS) |
| 428 | 988 XtFree (chars); |
| 989 #endif | |
| 990 } | |
| 991 | |
| 3094 | 992 static void /* XXX */ |
| 993 binding_draw (XlwMenuWidget mw, Window w, int x, int y, | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
994 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 995 XftColor *color, |
| 996 XftColor *colorBg, | |
| 997 #else | |
| 998 GC gc, | |
| 999 #endif | |
| 1000 char *value) | |
| 428 | 1001 { |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
1002 #if defined(NEED_MOTIF) && !defined(HAVE_XFT_MENUBARS) |
| 428 | 1003 XmString xm_value = XmStringCreateLtoR(value, XmSTRING_DEFAULT_CHARSET); |
| 1004 string_draw (mw, w, x, y, gc, xm_value); | |
| 1005 XmStringFree (xm_value); | |
| 1006 #else | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
1007 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 1008 string_draw (mw, w, x, y, color, colorBg, value); |
| 1009 #else | |
| 428 | 1010 string_draw (mw, w, x, y, gc, value); |
| 1011 #endif | |
| 3094 | 1012 #endif |
| 428 | 1013 } |
| 1014 | |
| 1015 /* Low level code for drawing 3-D edges. */ | |
| 1016 static void | |
| 1017 shadow_rectangle_draw (Display *dpy, | |
| 1018 Window window, | |
| 1019 GC top_gc, | |
| 1020 GC bottom_gc, | |
| 1021 int x, int y, | |
| 1022 unsigned int width, | |
| 1023 unsigned int height, | |
| 1024 unsigned int thickness) | |
| 1025 { | |
| 1026 XPoint points [4]; | |
| 1027 | |
| 1028 if (!thickness) | |
| 1029 return; | |
| 1030 | |
| 1031 points [0].x = x; | |
| 1032 points [0].y = y; | |
| 1033 points [1].x = x + width; | |
| 1034 points [1].y = y; | |
| 1035 points [2].x = x + width - thickness; | |
| 1036 points [2].y = y + thickness; | |
| 1037 points [3].x = x; | |
| 1038 points [3].y = y + thickness; | |
| 1039 XFillPolygon (dpy, window, top_gc, points, 4, Convex, CoordModeOrigin); | |
| 1040 points [0].x = x; | |
| 1041 points [0].y = y + thickness; | |
| 1042 points [1].x = x; | |
| 1043 points [1].y = y + height; | |
| 1044 points [2].x = x + thickness; | |
| 1045 points [2].y = y + height - thickness; | |
| 1046 points [3].x = x + thickness; | |
| 1047 points [3].y = y + thickness; | |
| 1048 XFillPolygon (dpy, window, top_gc, points, 4, Convex, CoordModeOrigin); | |
| 1049 points [0].x = x + width; | |
| 1050 points [0].y = y; | |
| 1051 points [1].x = x + width - thickness; | |
| 1052 points [1].y = y + thickness; | |
| 1053 points [2].x = x + width - thickness; | |
| 1054 points [2].y = y + height - thickness; | |
| 1055 points [3].x = x + width; | |
| 1056 points [3].y = y + height - thickness; | |
| 1057 XFillPolygon (dpy, window, bottom_gc, points, 4, Convex, CoordModeOrigin); | |
| 1058 points [0].x = x; | |
| 1059 points [0].y = y + height; | |
| 1060 points [1].x = x + width; | |
| 1061 points [1].y = y + height; | |
| 1062 points [2].x = x + width; | |
| 1063 points [2].y = y + height - thickness; | |
| 1064 points [3].x = x + thickness; | |
| 1065 points [3].y = y + height - thickness; | |
| 1066 XFillPolygon (dpy, window, bottom_gc, points, 4, Convex, CoordModeOrigin); | |
| 1067 } | |
| 1068 | |
| 1069 typedef enum e_shadow_type | |
| 1070 { | |
| 1071 /* these are Motif compliant */ | |
| 1072 SHADOW_BACKGROUND, | |
| 1073 SHADOW_OUT, | |
| 1074 SHADOW_IN, | |
| 1075 SHADOW_ETCHED_OUT, | |
| 1076 SHADOW_ETCHED_IN, | |
| 1077 SHADOW_ETCHED_OUT_DASH, | |
| 1078 SHADOW_ETCHED_IN_DASH, | |
| 1079 SHADOW_SINGLE_LINE, | |
| 1080 SHADOW_DOUBLE_LINE, | |
| 1081 SHADOW_SINGLE_DASHED_LINE, | |
| 1082 SHADOW_DOUBLE_DASHED_LINE, | |
| 1083 SHADOW_NO_LINE, | |
| 1084 /* these are all non-Motif */ | |
| 1085 SHADOW_DOUBLE_ETCHED_OUT, | |
| 1086 SHADOW_DOUBLE_ETCHED_IN, | |
| 1087 SHADOW_DOUBLE_ETCHED_OUT_DASH, | |
| 1088 SHADOW_DOUBLE_ETCHED_IN_DASH | |
| 1089 } shadow_type; | |
| 1090 | |
| 1091 static void | |
| 1092 shadow_draw (XlwMenuWidget mw, | |
| 1093 Window window, | |
| 1094 int x, int y, | |
| 1095 unsigned int width, | |
| 1096 unsigned int height, | |
| 1097 shadow_type type) | |
| 1098 { | |
| 1099 Display *dpy = XtDisplay (mw); | |
| 1100 GC top_gc; | |
| 1101 GC bottom_gc; | |
| 1102 int thickness = mw->menu.shadow_thickness; | |
| 1103 #if 0 | |
| 1104 XPoint points [4]; | |
| 1105 #endif /* 0 */ | |
| 1106 Boolean etched = False; | |
| 1107 | |
| 1108 switch (type) | |
| 1109 { | |
| 1110 case SHADOW_BACKGROUND: | |
| 1111 top_gc = bottom_gc = mw->menu.background_gc; | |
| 1112 break; | |
| 1113 case SHADOW_ETCHED_IN: | |
| 1114 top_gc = mw->menu.shadow_bottom_gc; | |
| 1115 bottom_gc = mw->menu.shadow_top_gc; | |
| 1116 etched = True; | |
| 1117 break; | |
| 1118 case SHADOW_ETCHED_OUT: | |
| 1119 top_gc = mw->menu.shadow_top_gc; | |
| 1120 bottom_gc = mw->menu.shadow_bottom_gc; | |
| 1121 etched = True; | |
| 1122 break; | |
| 1123 case SHADOW_IN: | |
| 1124 top_gc = mw->menu.shadow_bottom_gc; | |
| 1125 bottom_gc = mw->menu.shadow_top_gc; | |
| 1126 break; | |
| 1127 case SHADOW_OUT: | |
| 1128 default: | |
| 1129 top_gc = mw->menu.shadow_top_gc; | |
| 1130 bottom_gc = mw->menu.shadow_bottom_gc; | |
| 1131 break; | |
| 1132 } | |
| 1133 | |
| 1134 if (etched) | |
| 1135 { | |
| 1136 unsigned int half = thickness/2; | |
| 1137 shadow_rectangle_draw (dpy, | |
| 1138 window, | |
| 1139 top_gc, | |
| 1140 top_gc, | |
| 1141 x, y, | |
| 1142 width - half, height - half, | |
| 1143 thickness - half); | |
| 1144 shadow_rectangle_draw (dpy, | |
| 1145 window, | |
| 1146 bottom_gc, | |
| 1147 bottom_gc, | |
| 1148 x + half, y + half, | |
| 1149 width - half , height - half, | |
| 1150 half); | |
| 1151 } | |
| 1152 else | |
| 1153 { | |
| 1154 shadow_rectangle_draw (dpy, | |
| 1155 window, | |
| 1156 top_gc, | |
| 1157 bottom_gc, | |
| 1158 x, y, | |
| 1159 width, height, | |
| 1160 thickness); | |
| 1161 } | |
| 1162 } | |
| 1163 | |
| 1164 static void | |
| 1165 arrow_decoration_draw (XlwMenuWidget mw, | |
| 1166 Window window, | |
| 1167 int x, int y, | |
| 1168 unsigned int width, | |
| 1169 Boolean raised) | |
| 1170 { | |
| 1171 Display *dpy = XtDisplay (mw); | |
| 1172 GC top_gc; | |
| 1173 GC bottom_gc; | |
| 1174 GC select_gc; | |
| 1175 int thickness = mw->menu.shadow_thickness; | |
| 1176 XPoint points [4]; | |
| 1177 int half_width; | |
| 1178 int length = (int)((double)width * 0.87); | |
| 1179 int thick_med = (int)((double)thickness * 1.73); | |
| 1180 | |
| 1181 if (width & 0x1) | |
| 1182 half_width = width/2 + 1; | |
| 1183 else | |
| 1184 half_width = width/2; | |
| 1185 | |
| 1186 select_gc = mw->menu.background_gc; | |
| 1187 | |
| 1188 if (raised) | |
| 1189 { | |
| 1190 top_gc = mw->menu.shadow_bottom_gc; | |
| 1191 bottom_gc = mw->menu.shadow_top_gc; | |
| 1192 } | |
| 1193 else | |
| 1194 { | |
| 1195 top_gc = mw->menu.shadow_top_gc; | |
| 1196 bottom_gc = mw->menu.shadow_bottom_gc; | |
| 1197 } | |
| 1198 | |
| 1199 /* Fill internal area. We do this first so that the borders have a | |
| 1200 nice sharp edge. */ | |
| 1201 points [0].x = x + thickness; | |
| 1202 points [0].y = y + thickness; | |
| 1203 points [1].x = x + length - thickness; | |
| 1204 points [1].y = y + half_width; | |
| 1205 points [2].x = x + length - thickness; | |
| 1206 points [2].y = y + half_width + thickness; | |
| 1207 points [3].x = x + thickness; | |
| 1208 points [3].y = y + width - thickness; | |
| 1209 | |
| 1210 XFillPolygon (dpy, | |
| 1211 window, | |
| 1212 select_gc, | |
| 1213 points, | |
| 1214 4, | |
| 1215 Convex, | |
| 1216 CoordModeOrigin); | |
| 1217 | |
| 1218 /* left border */ | |
| 1219 points [0].x = x; | |
| 1220 points [0].y = y; | |
| 1221 points [1].x = x + thickness; | |
| 1222 points [1].y = y + thick_med; | |
| 1223 points [2].x = x + thickness; | |
| 1224 points [2].y = y + width - thick_med; | |
| 1225 points [3].x = x; | |
| 1226 points [3].y = y + width; | |
| 1227 | |
| 1228 XFillPolygon (dpy, window, top_gc, points, 4, Convex, CoordModeOrigin); | |
| 1229 | |
| 1230 /* top border */ | |
| 1231 points [0].x = x; | |
| 1232 points [0].y = y + width; | |
| 1233 points [1].x = x + length; | |
| 1234 points [1].y = y + half_width; | |
| 1235 points [2].x = x + length - (thickness + thickness); | |
| 1236 points [2].y = y + half_width; | |
| 1237 points [3].x = x + thickness; | |
| 1238 points [3].y = y + width - thick_med; | |
| 1239 | |
| 1240 XFillPolygon (dpy, window, bottom_gc, points, 4, Convex, CoordModeOrigin); | |
| 1241 | |
| 1242 /* bottom shadow */ | |
| 1243 points [0].x = x; | |
| 1244 points [0].y = y; | |
| 1245 points [1].x = x + length; | |
| 1246 points [1].y = y + half_width; | |
| 1247 points [2].x = x + length - (thickness + thickness); | |
| 1248 points [2].y = y + half_width; | |
| 1249 points [3].x = x + thickness; | |
| 1250 points [3].y = y + thick_med; | |
| 1251 | |
| 1252 XFillPolygon (dpy, window, top_gc, points, 4, Convex, CoordModeOrigin); | |
| 1253 } | |
| 1254 | |
| 1255 static void | |
| 1256 toggle_decoration_draw (XlwMenuWidget mw, | |
| 1257 Window window, | |
| 1258 int x, int y, | |
| 1259 unsigned int width, | |
| 1260 Boolean set) | |
| 1261 { | |
| 1262 Display *dpy = XtDisplay (mw); | |
| 1263 int thickness = mw->menu.shadow_thickness; | |
| 1264 shadow_type type; | |
| 1265 GC select_gc = mw->menu.select_gc; | |
| 1266 | |
| 1267 if (set) | |
| 1268 type = SHADOW_IN; | |
| 1269 else | |
| 1270 type = SHADOW_OUT; | |
| 1271 | |
| 1272 /* Fill internal area. */ | |
| 1273 if (set) | |
| 1274 XFillRectangle (dpy, | |
| 1275 window, | |
| 1276 select_gc, | |
| 1277 x + thickness, | |
| 1278 y + thickness, | |
| 1279 width - (2*thickness), | |
| 1280 width - (2*thickness)); | |
| 1281 | |
| 1282 shadow_draw (mw, window, x, y, width, width, type); | |
| 1283 } | |
| 1284 | |
| 1285 static void | |
| 1286 radio_decoration_draw (XlwMenuWidget mw, | |
| 1287 Window window, | |
| 1288 int x, int y, | |
| 1289 unsigned int width, | |
| 1290 Boolean enabled) | |
| 1291 { | |
| 1292 Display *dpy = XtDisplay (mw); | |
| 1293 GC top_gc; | |
| 1294 GC bottom_gc; | |
| 1295 GC select_gc = mw->menu.select_gc; | |
| 1296 int thickness = mw->menu.shadow_thickness; | |
| 1297 XPoint points[6]; | |
| 1298 int half_width; | |
| 1299 #if 0 | |
| 1300 int npoints; | |
| 1301 #endif /* 0 */ | |
| 1302 | |
| 1303 if (width & 0x1) | |
| 1304 width++; | |
| 1305 | |
| 1306 half_width = width/2; | |
| 1307 | |
| 1308 if (enabled) | |
| 1309 { | |
| 1310 top_gc = mw->menu.shadow_bottom_gc; | |
| 1311 bottom_gc = mw->menu.shadow_top_gc; | |
| 1312 } | |
| 1313 else | |
| 1314 { | |
| 1315 top_gc = mw->menu.shadow_top_gc; | |
| 1316 bottom_gc = mw->menu.shadow_bottom_gc; | |
| 1317 } | |
| 1318 | |
| 1319 #if 1 | |
| 1320 /* Draw the bottom first, just in case the regions overlap. | |
| 1321 The top should cast the longer shadow. */ | |
| 1322 points [0].x = x; /* left corner */ | |
| 1323 points [0].y = y + half_width; | |
| 1324 points [1].x = x + half_width; /* bottom corner */ | |
| 1325 points [1].y = y + width; | |
| 1326 points [2].x = x + half_width; /* bottom inside corner */ | |
| 1327 points [2].y = y + width - thickness; | |
| 1328 points [3].x = x + thickness; /* left inside corner */ | |
| 1329 points [3].y = y + half_width; | |
| 1330 | |
| 1331 XFillPolygon (dpy, window, bottom_gc, points, 4, Convex, CoordModeOrigin); | |
| 1332 | |
| 1333 points [0].x = x + half_width; /* bottom corner */ | |
| 1334 points [0].y = y + width; | |
| 1335 points [1].x = x + width; /* right corner */ | |
| 1336 points [1].y = y + half_width; | |
| 1337 points [2].x = x + width - thickness; /* right inside corner */ | |
| 1338 points [2].y = y + half_width; | |
| 1339 points [3].x = x + half_width; /* bottom inside corner */ | |
| 1340 points [3].y = y + width - thickness; | |
| 1341 | |
| 1342 XFillPolygon (dpy, window, bottom_gc, points, 4, Convex, CoordModeOrigin); | |
| 1343 | |
| 1344 points [0].x = x; /* left corner */ | |
| 1345 points [0].y = y + half_width; | |
| 1346 points [1].x = x + half_width; /* top corner */ | |
| 1347 points [1].y = y; | |
| 1348 points [2].x = x + half_width; /* top inside corner */ | |
| 1349 points [2].y = y + thickness; | |
| 1350 points [3].x = x + thickness; /* left inside corner */ | |
| 1351 points [3].y = y + half_width; | |
| 1352 | |
| 1353 XFillPolygon (dpy, window, top_gc, points, 4, Convex, CoordModeOrigin); | |
| 1354 | |
| 1355 points [0].x = x + half_width; /* top corner */ | |
| 1356 points [0].y = y; | |
| 1357 points [1].x = x + width; /* right corner */ | |
| 1358 points [1].y = y + half_width; | |
| 1359 points [2].x = x + width - thickness; /* right inside corner */ | |
| 1360 points [2].y = y + half_width; | |
| 1361 points [3].x = x + half_width; /* top inside corner */ | |
| 1362 points [3].y = y + thickness; | |
| 1363 | |
| 1364 XFillPolygon (dpy, window, top_gc, points, 4, Convex, CoordModeOrigin); | |
| 1365 #else | |
| 1366 /* Draw the bottom first, just in case the regions overlap. | |
| 1367 The top should cast the longer shadow. */ | |
| 1368 npoints = 0; | |
| 1369 points [npoints].x = x; /* left corner */ | |
| 1370 points [npoints++].y = y + half_width; | |
| 1371 points [npoints].x = x + half_width; /* bottom corner */ | |
| 1372 points [npoints++].y = y + width; | |
| 1373 points [npoints].x = x + width; /* right corner */ | |
| 1374 points [npoints++].y = y + half_width; | |
| 1375 points [npoints].x = x + width - thickness; /* right inside corner */ | |
| 1376 points [npoints++].y = y + half_width; | |
| 1377 points [npoints].x = x + half_width; /* bottom inside corner */ | |
| 1378 points [npoints++].y = y + width - thickness; | |
| 1379 points [npoints].x = x + thickness; /* left inside corner */ | |
| 1380 points [npoints++].y = y + half_width; | |
| 1381 | |
| 1382 XFillPolygon (dpy, window, bottom_gc, | |
| 1383 points, npoints, Nonconvex, CoordModeOrigin); | |
| 1384 | |
| 1385 npoints = 0; | |
| 1386 | |
| 1387 points [npoints].x = x; /* left corner */ | |
| 1388 points [npoints++].y = y + half_width; | |
| 1389 points [npoints].x = x + half_width; /* top corner */ | |
| 1390 points [npoints++].y = y; | |
| 1391 points [npoints].x = x + width; /* right corner */ | |
| 1392 points [npoints++].y = y + half_width; | |
| 1393 points [npoints].x = x + width - thickness; /* right inside corner */ | |
| 1394 points [npoints++].y = y + half_width; | |
| 1395 points [npoints].x = x + half_width; /* top inside corner */ | |
| 1396 points [npoints++].y = y + thickness; | |
| 1397 points [npoints].x = x + thickness; /* left inside corner */ | |
| 1398 points [npoints++].y = y + half_width; | |
| 1399 | |
| 1400 XFillPolygon (dpy, window, top_gc, points, npoints, Nonconvex, | |
| 1401 CoordModeOrigin); | |
| 1402 #endif | |
| 1403 | |
| 1404 | |
| 1405 /* Fill internal area. */ | |
| 1406 if (enabled) | |
| 1407 { | |
| 1408 points [0].x = x + thickness; | |
| 1409 points [0].y = y + half_width; | |
| 1410 points [1].x = x + half_width; | |
| 1411 points [1].y = y + thickness; | |
| 1412 points [2].x = x + width - thickness; | |
| 1413 points [2].y = y + half_width; | |
| 1414 points [3].x = x + half_width; | |
| 1415 points [3].y = y + width - thickness; | |
| 1416 XFillPolygon (dpy, | |
| 1417 window, | |
| 1418 select_gc, | |
| 1419 points, | |
| 1420 4, | |
| 1421 Convex, | |
| 1422 CoordModeOrigin); | |
| 1423 } | |
| 1424 } | |
| 1425 | |
| 1426 static void | |
| 1427 separator_decoration_draw (XlwMenuWidget mw, | |
| 1428 Window window, | |
| 1429 int x, int y, | |
| 1430 unsigned int width, | |
| 2286 | 1431 Boolean UNUSED (vertical), |
| 428 | 1432 shadow_type type) |
| 1433 { | |
| 1434 Display *dpy = XtDisplay (mw); | |
| 1435 GC top_gc; | |
| 1436 GC bottom_gc; | |
| 1437 unsigned int offset = 0; | |
| 1438 unsigned int num_separators = 1; | |
| 1439 unsigned int top_line_thickness = 0; | |
| 1440 unsigned int bottom_line_thickness = 0; | |
| 1441 Boolean dashed = False; | |
| 1442 | |
| 1443 switch (type) | |
| 1444 { | |
| 1445 case SHADOW_NO_LINE: /* nothing to do */ | |
| 1446 return; | |
| 1447 case SHADOW_DOUBLE_LINE: | |
| 1448 num_separators = 2; | |
| 1449 case SHADOW_SINGLE_LINE: | |
| 1450 top_gc = bottom_gc = mw->menu.foreground_gc; | |
| 1451 top_line_thickness = 1; | |
| 1452 break; | |
| 1453 case SHADOW_DOUBLE_DASHED_LINE: | |
| 1454 num_separators = 2; | |
| 1455 case SHADOW_SINGLE_DASHED_LINE: | |
| 1456 top_gc = bottom_gc = mw->menu.foreground_gc; | |
| 1457 top_line_thickness = 1; | |
| 1458 dashed = True; | |
| 1459 break; | |
| 1460 case SHADOW_DOUBLE_ETCHED_OUT_DASH: | |
| 1461 num_separators = 2; | |
| 1462 case SHADOW_ETCHED_OUT_DASH: | |
| 1463 top_gc = mw->menu.shadow_top_gc; | |
| 1464 bottom_gc = mw->menu.shadow_bottom_gc; | |
| 1465 top_line_thickness = mw->menu.shadow_thickness/2; | |
| 1466 bottom_line_thickness = mw->menu.shadow_thickness - top_line_thickness; | |
| 1467 dashed = True; | |
| 1468 break; | |
| 1469 case SHADOW_DOUBLE_ETCHED_IN_DASH: | |
| 1470 num_separators = 2; | |
| 1471 case SHADOW_ETCHED_IN_DASH: | |
| 1472 top_gc = mw->menu.shadow_bottom_gc; | |
| 1473 bottom_gc = mw->menu.shadow_top_gc; | |
| 1474 top_line_thickness = mw->menu.shadow_thickness/2; | |
| 1475 bottom_line_thickness = mw->menu.shadow_thickness - top_line_thickness; | |
| 1476 dashed = True; | |
| 1477 break; | |
| 1478 case SHADOW_DOUBLE_ETCHED_OUT: | |
| 1479 num_separators = 2; | |
| 1480 case SHADOW_ETCHED_OUT: | |
| 1481 top_gc = mw->menu.shadow_top_gc; | |
| 1482 bottom_gc = mw->menu.shadow_bottom_gc; | |
| 1483 top_line_thickness = mw->menu.shadow_thickness/2; | |
| 1484 bottom_line_thickness = mw->menu.shadow_thickness - top_line_thickness; | |
| 1485 break; | |
| 1486 case SHADOW_DOUBLE_ETCHED_IN: | |
| 1487 num_separators = 2; | |
| 1488 case SHADOW_ETCHED_IN: | |
| 1489 default: | |
| 1490 top_gc = mw->menu.shadow_bottom_gc; | |
| 1491 bottom_gc = mw->menu.shadow_top_gc; | |
| 1492 top_line_thickness = mw->menu.shadow_thickness/2; | |
| 1493 bottom_line_thickness = mw->menu.shadow_thickness - top_line_thickness; | |
| 1494 break; | |
| 1495 } | |
| 1496 | |
| 1497 if (dashed) | |
| 1498 { | |
| 1499 XGCValues values; | |
| 1500 values.line_style = LineOnOffDash; | |
| 1501 if (top_line_thickness > 0) | |
| 1502 XChangeGC (dpy, top_gc, GCLineStyle, &values); | |
| 1503 if (bottom_line_thickness > 0 && bottom_gc != top_gc) | |
| 1504 XChangeGC (dpy, bottom_gc, GCLineStyle, &values); | |
| 1505 } | |
| 1506 | |
| 1507 while (num_separators--) | |
| 1508 { | |
| 1509 unsigned int i; | |
| 1510 for (i = 0; i < top_line_thickness; i++) | |
| 1511 XDrawLine (dpy, window, top_gc, x, y + i, x + width, y + i); | |
| 1512 | |
| 1513 for (i = 0; i < bottom_line_thickness; i++) | |
| 1514 XDrawLine (dpy, window, bottom_gc, | |
| 1515 x, y + top_line_thickness + offset + i, | |
| 1516 x + width, y + top_line_thickness + offset + i); | |
| 1517 y += (top_line_thickness + offset + bottom_line_thickness + 1); | |
| 1518 } | |
| 1519 | |
| 1520 if (dashed) | |
| 1521 { | |
| 1522 XGCValues values; | |
| 1523 values.line_style = LineSolid; | |
| 1524 if (top_line_thickness > 0) | |
| 1525 XChangeGC (dpy, top_gc, GCLineStyle, &values); | |
| 1526 if (bottom_line_thickness > 0 && bottom_gc != top_gc) | |
| 1527 XChangeGC (dpy, bottom_gc, GCLineStyle, &values); | |
| 1528 } | |
| 1529 } | |
| 1530 | |
| 1531 #define SLOPPY_TYPES 0 /* 0=off, 1=error check, 2=easy to please */ | |
| 1532 #if SLOPPY_TYPES | |
| 1533 #if SLOPPY_TYPES < 2 | |
| 1534 | |
| 1535 static char *wv_types[] = | |
| 1536 { | |
| 1537 "UNSPECIFIED", | |
| 1538 "BUTTON", | |
| 1539 "TOGGLE", | |
| 1540 "RADIO", | |
| 1541 "TEXT", | |
| 1542 "SEPARATOR", | |
| 1543 "CASCADE", | |
| 1544 "PUSHRIGHT", | |
| 1545 "INCREMENTAL" | |
| 1546 }; | |
| 1547 | |
| 1548 static void | |
| 1549 print_widget_value (widget_value *wv, int just_one, int depth) | |
| 1550 { | |
| 1551 char d [200]; | |
| 1552 int i; | |
| 1553 for (i = 0; i < depth; i++) | |
| 1554 d[i] = ' '; | |
| 1555 d[depth]=0; | |
| 1556 if (!wv) | |
| 1557 { | |
| 1558 printf ("%s(null widget value pointer)\n", d); | |
| 1559 return; | |
| 1560 } | |
| 1561 printf ("%stype: %s\n", d, wv_types [wv->type]); | |
| 1562 #if 0 | |
| 1563 printf ("%sname: %s\n", d, (wv->name ? wv->name : "(null)")); | |
| 1564 #else | |
| 1565 if (wv->name) printf ("%sname: %s\n", d, wv->name); | |
| 1566 #endif | |
| 1567 if (wv->value) printf ("%svalue: %s\n", d, wv->value); | |
| 1568 if (wv->key) printf ("%skey: %s\n", d, wv->key); | |
| 1569 printf ("%senabled: %d\n", d, wv->enabled); | |
| 1570 if (wv->contents) | |
| 1571 { | |
| 1572 printf ("\n%scontents: \n", d); | |
| 1573 print_widget_value (wv->contents, 0, depth + 5); | |
| 1574 } | |
| 1575 if (!just_one && wv->next) | |
| 1576 { | |
| 1577 printf ("\n"); | |
| 1578 print_widget_value (wv->next, 0, depth); | |
| 1579 } | |
| 1580 } | |
| 1581 #endif /* SLOPPY_TYPES < 2 */ | |
| 1582 | |
| 1583 static Boolean | |
| 1584 all_dashes_p (char *s) | |
| 1585 { | |
| 1586 char *p; | |
| 1587 if (!s || s[0] == '\0') | |
| 1588 return False; | |
| 1589 for (p = s; *p == '-'; p++); | |
| 1590 | |
| 1591 if (*p == '!' || *p == '\0') | |
| 1592 return True; | |
| 1593 return False; | |
| 1594 } | |
| 1595 #endif /* SLOPPY_TYPES */ | |
| 1596 | |
| 1597 static widget_value_type | |
| 1598 menu_item_type (widget_value *val) | |
| 1599 { | |
| 1600 if (val->type != UNSPECIFIED_TYPE) | |
| 1601 return val->type; | |
| 1602 #if SLOPPY_TYPES | |
| 1603 else if (all_dashes_p (val->name)) | |
| 1604 return SEPARATOR_TYPE; | |
| 1605 else if (val->name && val->name[0] == '\0') /* push right */ | |
| 1606 return PUSHRIGHT_TYPE; | |
| 1607 else if (val->contents) /* cascade */ | |
| 1608 return CASCADE_TYPE; | |
| 1609 else if (val->call_data) /* push button */ | |
| 1610 return BUTTON_TYPE; | |
| 1611 else | |
| 1612 return TEXT_TYPE; | |
| 1613 #else | |
| 442 | 1614 else |
| 428 | 1615 abort(); |
| 1616 return UNSPECIFIED_TYPE; /* Not reached */ | |
| 1617 #endif | |
| 1618 } | |
| 1619 | |
| 1620 static void | |
| 1621 label_button_size (XlwMenuWidget mw, | |
| 1622 widget_value *val, | |
| 2286 | 1623 Boolean UNUSED (in_menubar), |
| 428 | 1624 unsigned int *toggle_width, |
| 1625 unsigned int *label_width, | |
| 1626 unsigned int *bindings_width, | |
| 1627 unsigned int *height) | |
| 1628 { | |
| 1629 *height = (mw->menu.font_ascent + mw->menu.font_descent + | |
| 1630 2 * mw->menu.vertical_margin + | |
| 1631 2 * mw->menu.shadow_thickness); | |
| 1632 /* no left column decoration */ | |
| 430 | 1633 *toggle_width = mw->menu.horizontal_margin + mw->menu.shadow_thickness; |
| 428 | 1634 |
| 1635 *label_width = string_width_u (mw, resource_widget_value (mw, val)); | |
| 1636 *bindings_width = mw->menu.horizontal_margin + mw->menu.shadow_thickness; | |
| 1637 } | |
| 1638 | |
| 1639 static void | |
| 1640 label_button_draw (XlwMenuWidget mw, | |
| 1641 widget_value *val, | |
| 1642 Boolean in_menubar, | |
| 1643 Boolean highlighted, | |
| 1644 Window window, | |
| 1645 int x, int y, | |
| 2286 | 1646 unsigned int UNUSED (width), |
| 1647 unsigned int UNUSED (height), | |
| 428 | 1648 unsigned int label_offset, |
| 2286 | 1649 unsigned int UNUSED (binding_tab)) |
| 428 | 1650 { |
| 1651 int y_offset = mw->menu.shadow_thickness + mw->menu.vertical_margin; | |
| 1652 GC gc; | |
| 1653 | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
1654 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 1655 XftColor color, colorBg; |
| 1656 Display *display = XtDisplay (mw); | |
| 1657 Colormap cmap = mw->core.colormap; | |
| 1658 Visual *visual; | |
| 1659 int ignored, pixel, pixelBg; | |
| 1660 | |
| 1661 visual_info_from_widget ((Widget) mw, &visual, &ignored); | |
| 1662 #endif | |
| 1663 | |
| 428 | 1664 if (!label_offset) |
| 1665 label_offset = mw->menu.shadow_thickness + mw->menu.horizontal_margin; | |
| 1666 | |
| 3094 | 1667 if (highlighted && (in_menubar || val->contents)) |
| 1668 { | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
1669 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 1670 pixel = mw->menu.highlight_foreground; |
| 1671 pixelBg = mw->core.background_pixel; | |
| 1672 #endif | |
| 1673 gc = mw->menu.highlight_gc; | |
| 1674 } | |
| 428 | 1675 else if (in_menubar || val->contents) |
| 3094 | 1676 { |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
1677 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 1678 pixel = mw->menu.foreground; |
| 1679 pixelBg = mw->core.background_pixel; | |
| 1680 #endif | |
| 1681 gc = mw->menu.foreground_gc; | |
| 1682 } | |
| 428 | 1683 else |
| 3094 | 1684 { |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
1685 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 1686 pixel = mw->menu.title_foreground; |
| 1687 pixelBg = mw->core.background_pixel; | |
| 1688 #endif | |
| 1689 gc = mw->menu.title_gc; | |
| 1690 } | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
1691 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 1692 color = xft_convert_color (display, cmap, visual, pixel, 0); |
| 1693 colorBg = xft_convert_color (display, cmap, visual, pixelBg, 0); | |
| 1694 #endif | |
| 428 | 1695 |
| 1696 /* Draw the label string. */ | |
| 3094 | 1697 string_draw_u (mw, /* XXX */ |
| 1698 window, | |
| 1699 x + label_offset, y + y_offset, | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
1700 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 1701 &color, &colorBg, gc, |
| 1702 #else | |
| 428 | 1703 gc, |
| 3094 | 1704 #endif |
| 428 | 1705 resource_widget_value (mw, val)); |
| 1706 } | |
| 1707 | |
| 1708 static void | |
| 1709 push_button_size (XlwMenuWidget mw, | |
| 1710 widget_value *val, | |
| 1711 Boolean in_menubar, | |
| 1712 unsigned int *toggle_width, | |
| 1713 unsigned int *label_width, | |
| 1714 unsigned int *bindings_width, | |
| 1715 unsigned int *height) | |
| 1716 { | |
| 1717 /* inherit */ | |
| 1718 label_button_size (mw, val, in_menubar, | |
| 1719 toggle_width, label_width, bindings_width, | |
| 1720 height); | |
| 1721 | |
| 1722 /* key bindings to display? */ | |
| 1723 if (!in_menubar && val->key) | |
| 1724 { | |
| 1725 int w; | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
1726 #if defined(NEED_MOTIF) && !defined(HAVE_XFT_MENUBARS) |
| 428 | 1727 XmString key = XmStringCreateLtoR (val->key, XmSTRING_DEFAULT_CHARSET); |
| 1728 w = string_width (mw, key); | |
| 1729 XmStringFree (key); | |
| 1730 #else | |
| 1731 char *key = val->key; | |
| 1732 w = string_width (mw, key); | |
| 1733 #endif | |
| 1734 *bindings_width += w + mw->menu.column_spacing; | |
| 1735 } | |
| 1736 } | |
| 1737 | |
| 1738 static void | |
| 1739 push_button_draw (XlwMenuWidget mw, | |
| 1740 widget_value *val, | |
| 1741 Boolean in_menubar, | |
| 1742 Boolean highlighted, | |
| 1743 Window window, | |
| 1744 int x, int y, | |
| 1745 unsigned int width, | |
| 1746 unsigned int height, | |
| 1747 unsigned int label_offset, | |
| 1748 unsigned int binding_offset) | |
| 1749 { | |
| 1750 int y_offset = mw->menu.shadow_thickness + mw->menu.vertical_margin; | |
| 1751 GC gc; | |
| 1752 shadow_type type; | |
| 1753 Boolean menu_pb = in_menubar && (menu_item_type (val) == BUTTON_TYPE); | |
| 1754 | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
1755 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 1756 XftColor color, colorBg; |
| 1757 Display *display = XtDisplay (mw); | |
| 1758 Colormap cmap = mw->core.colormap; | |
| 1759 Visual *visual; | |
| 1760 int ignored, pixel, pixelBg, dim = 0; | |
| 1761 | |
| 1762 visual_info_from_widget ((Widget) mw, &visual, &ignored); | |
| 1763 #endif | |
| 1764 | |
| 428 | 1765 /* Draw the label string. */ |
| 1766 if (!label_offset) | |
| 1767 label_offset = mw->menu.shadow_thickness + mw->menu.horizontal_margin; | |
| 1768 | |
| 1769 if (highlighted) | |
| 1770 { | |
| 1771 if (val->enabled) | |
| 3094 | 1772 { |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
1773 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 1774 pixel = mw->menu.highlight_foreground; |
| 1775 pixelBg = mw->core.background_pixel; | |
| 1776 #endif | |
| 1777 gc = mw->menu.highlight_gc; | |
| 1778 } | |
| 428 | 1779 else |
| 3094 | 1780 { |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
1781 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 1782 dim = 1; |
| 1783 pixel = mw->menu.foreground; | |
| 1784 pixelBg = mw->core.background_pixel; | |
| 1785 #endif | |
| 1786 gc = mw->menu.inactive_gc; | |
| 1787 } | |
| 428 | 1788 } |
| 1789 else if (menu_pb) | |
| 1790 { | |
| 1791 if (val->enabled) | |
| 3094 | 1792 { |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
1793 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 1794 pixel = mw->menu.button_foreground; |
| 1795 pixelBg = mw->core.background_pixel; | |
| 1796 #endif | |
| 1797 gc = mw->menu.button_gc; | |
| 1798 } | |
| 428 | 1799 else |
| 3094 | 1800 { |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
1801 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 1802 dim = 1; |
| 1803 pixel = mw->menu.button_foreground; | |
| 1804 pixelBg = mw->core.background_pixel; | |
| 1805 #endif | |
| 1806 gc = mw->menu.inactive_button_gc; | |
| 1807 } | |
| 428 | 1808 } |
| 1809 else | |
| 1810 { | |
| 1811 if (val->enabled) | |
| 3094 | 1812 { |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
1813 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 1814 pixel = mw->menu.foreground; |
| 1815 pixelBg = mw->core.background_pixel; | |
| 1816 #endif | |
| 1817 gc = mw->menu.foreground_gc; | |
| 1818 } | |
| 428 | 1819 else |
| 3094 | 1820 { |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
1821 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 1822 dim = 1; |
| 1823 pixel = mw->menu.foreground; | |
| 1824 pixelBg = mw->core.background_pixel; | |
| 1825 #endif | |
| 1826 gc = mw->menu.inactive_gc; | |
| 1827 } | |
| 428 | 1828 } |
| 1829 | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
1830 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 1831 color = xft_convert_color (display, cmap, visual, pixel, dim); |
| 1832 colorBg = xft_convert_color (display, cmap, visual, pixelBg, 0); | |
| 1833 #endif | |
| 1834 | |
| 428 | 1835 string_draw_u (mw, |
| 3094 | 1836 window, |
| 1837 x + label_offset, y + y_offset, | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
1838 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 1839 &color, &colorBg, gc, |
| 1840 #else | |
| 1841 gc, | |
| 1842 #endif | |
| 428 | 1843 resource_widget_value (mw, val)); |
| 1844 | |
| 1845 /* Draw the keybindings */ | |
| 1846 if (val->key) | |
| 1847 { | |
| 1848 if (!binding_offset) | |
| 1849 { | |
| 1850 unsigned int s_width = | |
| 1851 string_width (mw, resource_widget_value (mw, val)); | |
| 1852 binding_offset = label_offset + s_width + mw->menu.shadow_thickness; | |
| 1853 } | |
| 1854 binding_draw (mw, window, | |
| 1855 x + binding_offset + mw->menu.column_spacing, | |
| 3094 | 1856 y + y_offset, |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
1857 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 1858 &color, &colorBg, |
| 1859 #else | |
| 1860 gc, | |
| 1861 #endif | |
| 1862 val->key); | |
| 428 | 1863 } |
| 1864 | |
| 1865 /* Draw the shadow */ | |
| 1866 if (menu_pb) | |
| 1867 { | |
| 1868 if (highlighted) | |
| 1869 type = SHADOW_OUT; | |
| 1870 else | |
| 1871 type = (val->selected ? SHADOW_ETCHED_OUT : SHADOW_ETCHED_IN); | |
| 1872 } | |
| 1873 else | |
| 1874 { | |
| 1875 if (highlighted) | |
| 1876 type = SHADOW_OUT; | |
| 1877 else | |
| 1878 type = SHADOW_BACKGROUND; | |
| 1879 } | |
| 1880 | |
| 1881 shadow_draw (mw, window, x, y, width, height, type); | |
| 1882 } | |
| 1883 | |
| 1884 static unsigned int | |
| 1885 arrow_decoration_height (XlwMenuWidget mw) | |
| 1886 { | |
| 1887 int result = (mw->menu.font_ascent + mw->menu.font_descent) / 2; | |
| 1888 | |
| 1889 result += 2 * mw->menu.shadow_thickness; | |
| 1890 | |
| 1891 if (result > (mw->menu.font_ascent + mw->menu.font_descent)) | |
| 1892 result = mw->menu.font_ascent + mw->menu.font_descent; | |
| 1893 | |
| 1894 return result; | |
| 1895 } | |
| 1896 | |
| 1897 static void | |
| 1898 cascade_button_size (XlwMenuWidget mw, | |
| 1899 widget_value *val, | |
| 1900 Boolean in_menubar, | |
| 1901 unsigned int *toggle_width, | |
| 1902 unsigned int *label_width, | |
| 1903 unsigned int *arrow_width, | |
| 1904 unsigned int *height) | |
| 1905 { | |
| 1906 /* inherit */ | |
| 1907 label_button_size (mw, val, in_menubar, | |
| 1908 toggle_width, label_width, arrow_width, | |
| 1909 height); | |
| 1910 /* we have a pull aside arrow */ | |
| 1911 if (!in_menubar) | |
| 1912 { | |
| 1913 *arrow_width += arrow_decoration_height (mw) + mw->menu.column_spacing; | |
| 1914 } | |
| 1915 } | |
| 1916 | |
| 1917 static void | |
| 1918 cascade_button_draw (XlwMenuWidget mw, | |
| 1919 widget_value *val, | |
| 1920 Boolean in_menubar, | |
| 1921 Boolean highlighted, | |
| 1922 Window window, | |
| 1923 int x, int y, | |
| 1924 unsigned int width, | |
| 1925 unsigned int height, | |
| 1926 unsigned int label_offset, | |
| 1927 unsigned int binding_offset) | |
| 1928 { | |
| 1929 shadow_type type; | |
| 1930 | |
| 1931 /* Draw the label string. */ | |
| 1932 label_button_draw (mw, val, in_menubar, highlighted, | |
| 1933 window, x, y, width, height, label_offset, | |
| 1934 binding_offset); | |
| 1935 | |
| 1936 /* Draw the pull aside arrow */ | |
| 1937 if (!in_menubar && val->contents) | |
| 1938 { | |
| 1939 int y_offset; | |
| 1940 unsigned int arrow_height = arrow_decoration_height (mw); | |
| 1941 | |
| 1942 y_offset = mw->menu.shadow_thickness + mw->menu.vertical_margin + | |
| 1943 (mw->menu.font_ascent+mw->menu.font_descent - arrow_height)/2; | |
| 1944 | |
| 1945 if (!binding_offset) | |
| 1946 { | |
| 1947 unsigned int s_width = | |
| 1948 string_width (mw, resource_widget_value (mw, val)); | |
| 1949 | |
| 1950 if (!label_offset) | |
| 1951 label_offset = mw->menu.shadow_thickness + | |
| 1952 mw->menu.horizontal_margin; | |
| 1953 | |
| 1954 binding_offset = label_offset + s_width + mw->menu.shadow_thickness; | |
| 1955 } | |
| 1956 | |
| 1957 arrow_decoration_draw (mw, | |
| 1958 window, | |
| 1959 x + binding_offset + mw->menu.column_spacing, | |
| 1960 y + y_offset, | |
| 1961 arrow_height, | |
| 1962 highlighted); | |
| 1963 } | |
| 1964 | |
| 1965 /* Draw the shadow */ | |
| 1966 if (highlighted) | |
| 1967 type = SHADOW_OUT; | |
| 1968 else | |
| 1969 type = SHADOW_BACKGROUND; | |
| 1970 | |
| 1971 shadow_draw (mw, window, x, y, width, height, type); | |
| 1972 } | |
| 1973 | |
| 1974 static unsigned int | |
| 1975 toggle_decoration_height (XlwMenuWidget mw) | |
| 1976 { | |
| 1977 int rv; | |
| 1978 if (mw->menu.indicator_size > 0) | |
| 1979 rv = mw->menu.indicator_size; | |
| 1980 else | |
| 1981 rv = mw->menu.font_ascent; | |
| 1982 | |
| 1983 if (rv > (mw->menu.font_ascent + mw->menu.font_descent)) | |
| 1984 rv = mw->menu.font_ascent + mw->menu.font_descent; | |
| 1985 | |
| 1986 /* radio button can't be smaller than its border or a filling | |
| 1987 error will occur. */ | |
| 1988 if (rv < 2 * mw->menu.shadow_thickness) | |
| 1989 rv = 2 * mw->menu.shadow_thickness; | |
| 1990 | |
| 1991 return rv; | |
| 1992 } | |
| 1993 | |
| 1994 static void | |
| 1995 toggle_button_size (XlwMenuWidget mw, | |
| 1996 widget_value *val, | |
| 1997 Boolean in_menubar, | |
| 1998 unsigned int *toggle_width, | |
| 1999 unsigned int *label_width, | |
| 2000 unsigned int *bindings_width, | |
| 2001 unsigned int *height) | |
| 2002 { | |
| 2003 /* inherit */ | |
| 2004 push_button_size (mw, val, in_menubar, | |
| 2005 toggle_width, label_width, bindings_width, | |
| 2006 height); | |
| 2007 /* we have a toggle */ | |
| 2008 *toggle_width += toggle_decoration_height (mw) + mw->menu.column_spacing; | |
| 2009 } | |
| 2010 | |
| 2011 static void | |
| 2012 toggle_button_draw (XlwMenuWidget mw, | |
| 2013 widget_value *val, | |
| 2014 Boolean in_menubar, | |
| 2015 Boolean highlighted, | |
| 2016 Window window, | |
| 2017 int x, int y, | |
| 2018 unsigned int width, | |
| 2019 unsigned int height, | |
| 2020 unsigned int label_tab, | |
| 2021 unsigned int binding_tab) | |
| 2022 { | |
| 2023 int x_offset; | |
| 2024 int y_offset; | |
| 2025 unsigned int t_height = toggle_decoration_height (mw); | |
| 2026 | |
| 2027 /* Draw a toggle. */ | |
| 2028 x_offset = mw->menu.shadow_thickness + mw->menu.horizontal_margin; | |
| 2029 y_offset = mw->menu.shadow_thickness + mw->menu.vertical_margin; | |
| 2030 y_offset += (mw->menu.font_ascent + mw->menu.font_descent - t_height)/2; | |
| 2031 | |
| 2032 toggle_decoration_draw (mw, window, x + x_offset, y + y_offset, | |
| 2033 t_height, val->selected); | |
| 2034 | |
| 2035 /* Draw the pushbutton parts. */ | |
| 2036 push_button_draw (mw, val, in_menubar, highlighted, window, x, y, width, | |
| 2037 height, label_tab, binding_tab); | |
| 2038 } | |
| 2039 | |
| 2040 static unsigned int | |
| 2041 radio_decoration_height (XlwMenuWidget mw) | |
| 2042 { | |
| 2043 return toggle_decoration_height (mw); | |
| 2044 } | |
| 2045 | |
| 2046 static void | |
| 2047 radio_button_draw (XlwMenuWidget mw, | |
| 2048 widget_value *val, | |
| 2049 Boolean in_menubar, | |
| 2050 Boolean highlighted, | |
| 2051 Window window, | |
| 2052 int x, int y, | |
| 2053 unsigned int width, | |
| 2054 unsigned int height, | |
| 2055 unsigned int label_tab, | |
| 2056 unsigned int binding_tab) | |
| 2057 { | |
| 2058 int x_offset; | |
| 2059 int y_offset; | |
| 2060 unsigned int r_height = radio_decoration_height (mw); | |
| 2061 | |
| 2062 /* Draw a toggle. */ | |
| 2063 x_offset = mw->menu.shadow_thickness + mw->menu.horizontal_margin; | |
| 2064 y_offset = mw->menu.shadow_thickness + mw->menu.vertical_margin; | |
| 2065 y_offset += (mw->menu.font_ascent + mw->menu.font_descent - r_height)/2; | |
| 2066 | |
| 2067 radio_decoration_draw (mw, window, x + x_offset, y + y_offset, r_height, | |
| 2068 val->selected); | |
| 2069 | |
| 2070 /* Draw the pushbutton parts. */ | |
| 2071 push_button_draw (mw, val, in_menubar, highlighted, window, x, y, width, | |
| 2072 height, label_tab, binding_tab); | |
| 2073 } | |
| 2074 | |
| 2075 static struct _shadow_names | |
| 2076 { | |
| 442 | 2077 const char * name; |
| 428 | 2078 shadow_type type; |
| 2079 } shadow_names[] = | |
| 2080 { | |
| 2081 /* Motif */ | |
| 2082 { "singleLine", SHADOW_SINGLE_LINE }, | |
| 2083 { "doubleLine", SHADOW_DOUBLE_LINE }, | |
| 2084 { "singleDashedLine", SHADOW_SINGLE_DASHED_LINE }, | |
| 2085 { "doubleDashedLine", SHADOW_DOUBLE_DASHED_LINE }, | |
| 2086 { "noLine", SHADOW_NO_LINE }, | |
| 2087 { "shadowEtchedIn", SHADOW_ETCHED_IN }, | |
| 2088 { "shadowEtchedOut", SHADOW_ETCHED_OUT }, | |
| 2089 { "shadowEtchedInDash", SHADOW_ETCHED_IN_DASH }, | |
| 2090 { "shadowEtchedOutDash", SHADOW_ETCHED_OUT_DASH }, | |
| 2091 /* non-Motif */ | |
| 2092 { "shadowDoubleEtchedIn", SHADOW_DOUBLE_ETCHED_IN }, | |
| 2093 { "shadowDoubleEtchedOut", SHADOW_DOUBLE_ETCHED_OUT }, | |
| 2094 { "shadowDoubleEtchedInDash", SHADOW_DOUBLE_ETCHED_IN_DASH }, | |
| 2095 { "shadowDoubleEtchedOutDash", SHADOW_DOUBLE_ETCHED_OUT_DASH } | |
| 2096 }; | |
| 2097 | |
| 2098 static shadow_type | |
| 2099 separator_type (char *name) | |
| 2100 { | |
| 2101 if (name) | |
| 2102 { | |
| 2103 int i; | |
| 2104 for (i = 0; i < (int) (XtNumber (shadow_names)); i++ ) | |
| 2105 { | |
| 2106 if (strcmp (name, shadow_names[i].name) == 0) | |
| 2107 return shadow_names[i].type; | |
| 2108 } | |
| 2109 } | |
| 2110 return SHADOW_BACKGROUND; | |
| 2111 } | |
| 2112 | |
| 2113 static unsigned int | |
| 2114 separator_decoration_height (XlwMenuWidget mw, widget_value *val) | |
| 2115 { | |
| 2116 | |
| 2117 switch (separator_type (val->value)) | |
| 2118 { | |
| 2119 case SHADOW_NO_LINE: | |
| 2120 case SHADOW_SINGLE_LINE: | |
| 2121 case SHADOW_SINGLE_DASHED_LINE: | |
| 2122 return 1; | |
| 2123 case SHADOW_DOUBLE_LINE: | |
| 2124 case SHADOW_DOUBLE_DASHED_LINE: | |
| 2125 return 3; | |
| 2126 case SHADOW_DOUBLE_ETCHED_OUT: | |
| 2127 case SHADOW_DOUBLE_ETCHED_IN: | |
| 2128 case SHADOW_DOUBLE_ETCHED_OUT_DASH: | |
| 2129 case SHADOW_DOUBLE_ETCHED_IN_DASH: | |
| 2130 return (1 + 2 * mw->menu.shadow_thickness); | |
| 2131 case SHADOW_ETCHED_OUT: | |
| 2132 case SHADOW_ETCHED_IN: | |
| 2133 default: | |
| 2134 return mw->menu.shadow_thickness; | |
| 2135 } | |
| 2136 } | |
| 2137 | |
| 2138 static void | |
| 2139 separator_size (XlwMenuWidget mw, | |
| 2140 widget_value *val, | |
| 2286 | 2141 Boolean UNUSED (in_menubar), |
| 428 | 2142 unsigned int *toggle_width, |
| 2143 unsigned int *label_width, | |
| 2144 unsigned int *rest_width, | |
| 2145 unsigned int *height) | |
| 2146 { | |
| 2147 *height = separator_decoration_height (mw, val); | |
| 2148 *label_width = 1; | |
| 2149 *toggle_width = *rest_width = 0; | |
| 2150 } | |
| 2151 | |
| 2152 static void | |
| 2153 separator_draw (XlwMenuWidget mw, | |
| 2154 widget_value *val, | |
| 2155 Boolean in_menubar, | |
| 2286 | 2156 Boolean UNUSED (highlighted), |
| 428 | 2157 Window window, |
| 2158 int x, int y, | |
| 2159 unsigned int width, | |
| 2160 unsigned int height, | |
| 2286 | 2161 unsigned int UNUSED (label_tab), |
| 2162 unsigned int UNUSED (binding_tab)) | |
| 428 | 2163 { |
| 2164 unsigned int sep_width; | |
| 2165 | |
| 2166 if (in_menubar) | |
| 2167 sep_width = height; | |
| 2168 else | |
| 2169 sep_width = width; | |
| 2170 | |
| 2171 separator_decoration_draw (mw, | |
| 2172 window, | |
| 2173 x, | |
| 2174 y, | |
| 2175 sep_width, | |
| 2176 in_menubar, | |
| 2177 separator_type(val->value)); | |
| 2178 } | |
| 2179 | |
| 2180 static void | |
| 2286 | 2181 pushright_size (XlwMenuWidget UNUSED (mw), |
| 2182 widget_value *UNUSED (val), | |
| 2183 Boolean UNUSED (in_menubar), | |
| 428 | 2184 unsigned int *toggle_width, |
| 2185 unsigned int *label_width, | |
| 2186 unsigned int *rest_width, | |
| 2187 unsigned int *height) | |
| 2188 { | |
| 2189 *height = *label_width = *toggle_width = *rest_width = 0; | |
| 2190 } | |
| 2191 | |
| 2192 static void | |
| 2193 size_menu_item (XlwMenuWidget mw, | |
| 2194 widget_value *val, | |
| 2195 int horizontal, | |
| 2196 unsigned int *toggle_width, | |
| 2197 unsigned int *label_width, | |
| 2198 unsigned int *rest_width, | |
| 2199 unsigned int *height) | |
| 2200 { | |
| 2201 void (*function_ptr) (XlwMenuWidget _mw, | |
| 2202 widget_value *_val, | |
| 2203 Boolean _in_menubar, | |
| 2204 unsigned int *_toggle_width, | |
| 2205 unsigned int *_label_width, | |
| 2206 unsigned int *_rest_width, | |
| 2207 unsigned int *_height); | |
| 2208 | |
| 2209 switch (menu_item_type (val)) | |
| 2210 { | |
| 2211 case TOGGLE_TYPE: | |
| 2212 case RADIO_TYPE: | |
| 2213 function_ptr = toggle_button_size; | |
| 2214 break; | |
| 2215 case SEPARATOR_TYPE: | |
| 2216 function_ptr = separator_size; | |
| 2217 break; | |
| 2218 case INCREMENTAL_TYPE: | |
| 2219 case CASCADE_TYPE: | |
| 2220 function_ptr = cascade_button_size; | |
| 2221 break; | |
| 2222 case BUTTON_TYPE: | |
| 2223 function_ptr = push_button_size; | |
| 2224 break; | |
| 2225 case PUSHRIGHT_TYPE: | |
| 2226 function_ptr = pushright_size; | |
| 2227 break; | |
| 2228 case TEXT_TYPE: | |
| 2229 default: | |
| 2230 function_ptr = label_button_size; | |
| 2231 break; | |
| 2232 } | |
| 2233 | |
| 2234 (*function_ptr) (mw, | |
| 2235 val, | |
| 2236 horizontal, | |
| 2237 toggle_width, | |
| 2238 label_width, | |
| 2239 rest_width, | |
| 2240 height); | |
| 2241 } | |
| 2242 | |
| 2243 static void | |
| 2244 display_menu_item (XlwMenuWidget mw, | |
| 2245 widget_value *val, | |
| 2246 window_state *ws, | |
| 2247 XPoint *where, | |
| 2248 Boolean highlighted, | |
| 2249 Boolean horizontal, | |
| 2250 Boolean just_compute) | |
| 2251 { | |
| 2252 | |
| 2253 int x = where->x /* + mw->menu.shadow_thickness */ ; | |
| 2254 int y = where->y /* + mw->menu.shadow_thickness */ ; | |
| 2255 unsigned int toggle_width; | |
| 2256 unsigned int label_width; | |
| 2257 unsigned int binding_width; | |
| 2258 unsigned int width; | |
| 2259 unsigned int height; | |
| 2260 unsigned int label_tab; | |
| 2261 unsigned int binding_tab; | |
| 2262 void (*function_ptr) (XlwMenuWidget _mw, | |
| 2263 widget_value *_val, | |
| 2264 Boolean _in_menubar, | |
| 2265 Boolean _highlighted, | |
| 2266 Window _window, | |
| 2267 int _x, int _y, | |
| 2268 unsigned int _width, | |
| 2269 unsigned int _height, | |
| 2270 unsigned int _label_tab, | |
| 2271 unsigned int _binding_tab); | |
| 2272 | |
| 2273 size_menu_item (mw, val, horizontal, | |
| 2274 &toggle_width, &label_width, &binding_width, &height); | |
| 2275 | |
| 2276 if (horizontal) | |
| 2277 { | |
| 2278 width = toggle_width + label_width + binding_width; | |
| 2279 height = ws->height - 2 * mw->menu.shadow_thickness; | |
| 2280 } | |
| 2281 else | |
| 2282 { | |
| 2283 width = ws->width - 2 * mw->menu.shadow_thickness; | |
| 2284 toggle_width = ws->toggle_width; | |
| 2285 label_width = ws->label_width; | |
| 2286 } | |
| 2287 | |
| 2288 where->x += width; | |
| 2289 where->y += height; | |
| 2290 | |
| 2291 if (just_compute) | |
| 2292 return; | |
| 2293 | |
| 2294 label_tab = toggle_width; | |
| 2295 binding_tab = toggle_width + label_width; | |
| 2296 | |
| 2297 switch (menu_item_type (val)) | |
| 2298 { | |
| 2299 case TOGGLE_TYPE: | |
| 2300 function_ptr = toggle_button_draw; | |
| 2301 break; | |
| 2302 case RADIO_TYPE: | |
| 2303 function_ptr = radio_button_draw; | |
| 2304 break; | |
| 2305 case SEPARATOR_TYPE: | |
| 2306 function_ptr = separator_draw; | |
| 2307 break; | |
| 2308 case INCREMENTAL_TYPE: | |
| 2309 case CASCADE_TYPE: | |
| 2310 function_ptr = cascade_button_draw; | |
| 2311 break; | |
| 2312 case BUTTON_TYPE: | |
| 2313 function_ptr = push_button_draw; | |
| 2314 break; | |
| 2315 case TEXT_TYPE: | |
| 2316 function_ptr = label_button_draw; | |
| 2317 break; | |
| 2318 default: /* do no drawing */ | |
| 2319 return; | |
| 2320 } | |
| 2321 | |
| 2322 (*function_ptr) (mw, | |
| 2323 val, | |
| 2324 horizontal, | |
| 2325 highlighted, | |
| 2326 ws->window, | |
| 2327 x, y, | |
| 2328 width, height, | |
| 2329 label_tab, | |
| 2330 binding_tab); | |
| 2331 } | |
| 2332 | |
| 2333 static void | |
| 2334 size_menu (XlwMenuWidget mw, int level) | |
| 2335 { | |
| 2336 unsigned int toggle_width; | |
| 2337 unsigned int label_width; | |
| 2338 unsigned int rest_width; | |
| 2339 unsigned int height; | |
| 2340 unsigned int max_toggle_width = 0; | |
| 2341 unsigned int max_label_width = 0; | |
| 2342 unsigned int max_rest_width = 0; | |
| 2343 unsigned int max_height = 0; | |
| 2344 int horizontal_p = mw->menu.horizontal && (level == 0); | |
| 2345 widget_value* val; | |
| 2346 window_state* ws; | |
| 2347 | |
| 2348 if (level >= mw->menu.old_depth) | |
| 2349 abort (); | |
| 2350 | |
| 2351 ws = &mw->menu.windows [level]; | |
| 2352 | |
| 2353 for (val = mw->menu.old_stack [level]->contents; val; val = val->next) | |
| 2354 { | |
| 2355 size_menu_item (mw, | |
| 2356 val, | |
| 2357 horizontal_p, | |
| 2358 &toggle_width, | |
| 2359 &label_width, | |
| 2360 &rest_width, | |
| 2361 &height); | |
| 2362 if (horizontal_p) | |
| 2363 { | |
| 2364 max_label_width += toggle_width + label_width + rest_width; | |
| 2365 if (height > max_height) | |
| 2366 max_height = height; | |
| 2367 } | |
| 2368 else | |
| 2369 { | |
| 2370 if (max_toggle_width < toggle_width) | |
| 2371 max_toggle_width = toggle_width; | |
| 2372 if (max_label_width < label_width) | |
| 2373 max_label_width = label_width; | |
| 2374 if (max_rest_width < rest_width) | |
| 2375 max_rest_width = rest_width; | |
| 2376 max_height += height; | |
| 2377 } | |
| 2378 } | |
| 2379 | |
| 2380 ws->height = max_height; | |
| 2381 ws->width = max_label_width + max_rest_width + max_toggle_width; | |
| 2382 ws->toggle_width = max_toggle_width; | |
| 2383 ws->label_width = max_label_width; | |
| 2384 | |
| 2385 ws->width += 2 * mw->menu.shadow_thickness; | |
| 2386 ws->height += 2 * mw->menu.shadow_thickness; | |
| 2387 } | |
| 2388 | |
| 2389 static void | |
| 2390 display_menu (XlwMenuWidget mw, int level, Boolean just_compute_p, | |
| 2391 XPoint *highlighted_pos, XPoint *hit, widget_value **hit_return, | |
| 1201 | 2392 widget_value *this_, widget_value *that) |
| 428 | 2393 { |
| 2394 widget_value *val; | |
| 2395 widget_value *following_item; | |
| 2396 window_state *ws; | |
| 2397 XPoint where; | |
| 2398 int horizontal_p = mw->menu.horizontal && (level == 0); | |
| 2399 int highlighted_p; | |
| 2400 int just_compute_this_one_p; | |
| 2401 | |
| 2402 if (level >= mw->menu.old_depth) | |
| 2403 abort (); | |
| 2404 | |
| 2405 if (level < mw->menu.old_depth - 1) | |
| 2406 following_item = mw->menu.old_stack [level + 1]; | |
| 2407 else | |
| 2408 { | |
| 2409 if (lw_menu_accelerate | |
| 2410 && level == mw->menu.old_depth - 1 | |
| 2411 && mw->menu.old_stack [level]->type == CASCADE_TYPE) | |
| 2412 just_compute_p = True; | |
| 2413 following_item = NULL; | |
| 2414 } | |
| 2415 | |
| 2416 #if SLOPPY_TYPES == 1 | |
| 2417 puts("==================================================================="); | |
| 2418 print_widget_value (following_item, 1, 0); | |
| 2419 #endif | |
| 2420 | |
| 2421 if (hit) | |
| 2422 *hit_return = NULL; | |
| 2423 | |
| 2424 where.x = mw->menu.shadow_thickness; | |
| 2425 where.y = mw->menu.shadow_thickness; | |
| 2426 | |
| 2427 ws = &mw->menu.windows [level]; | |
| 2428 for (val = mw->menu.old_stack [level]->contents; val; val = val->next) | |
| 2429 { | |
| 2430 XPoint start; | |
| 2431 | |
| 2432 highlighted_p = (val == following_item); | |
| 2433 /* If this is the partition (the dummy item which says that menus | |
| 2434 after this should be flushright) then figure out how big the | |
| 2435 following items are. This means we walk down the tail of the | |
| 2436 list twice, but that's no big deal - it's short. | |
| 2437 */ | |
| 2438 if (horizontal_p && (menu_item_type (val) == PUSHRIGHT_TYPE)) | |
| 2439 { | |
| 2440 widget_value *rest; | |
| 2441 XPoint flushright_size; | |
| 2442 int new_x; | |
| 2443 flushright_size.x = 0; | |
| 2444 flushright_size.y = 0; | |
| 2445 for (rest = val; rest; rest = rest->next) | |
| 2446 display_menu_item (mw, rest, ws, &flushright_size, | |
| 2447 highlighted_p, horizontal_p, True); | |
| 2448 new_x = ws->width - (flushright_size.x + mw->menu.shadow_thickness); | |
| 2449 if (new_x > where.x) | |
| 2450 where.x = new_x; | |
| 2451 /* We know what we need; don't draw this item. */ | |
| 2452 continue; | |
| 2453 } | |
| 2454 | |
| 2455 if (highlighted_p && highlighted_pos) | |
| 2456 { | |
| 2457 if (horizontal_p) | |
| 2458 highlighted_pos->x = where.x; | |
| 2459 else | |
| 2460 highlighted_pos->y = where.y; | |
| 2461 } | |
| 2462 | |
| 2463 just_compute_this_one_p = | |
| 1201 | 2464 just_compute_p || ((this_ || that) && val != this_ && val != that); |
| 428 | 2465 |
| 2466 start.x = where.x; | |
| 2467 start.y = where.y; | |
| 2468 display_menu_item (mw, val, ws, &where, highlighted_p, horizontal_p, | |
| 2469 just_compute_this_one_p); | |
| 2470 | |
| 2471 if (highlighted_p && highlighted_pos) | |
| 2472 { | |
| 2473 if (horizontal_p) | |
| 2474 highlighted_pos->y = ws->height; | |
| 2475 else | |
| 2476 highlighted_pos->x = ws->width; | |
| 2477 } | |
| 2478 | |
| 2479 if (hit && !*hit_return) | |
| 2480 { | |
| 2481 if (horizontal_p && hit->x > start.x && hit->x <= where.x) | |
| 2482 *hit_return = val; | |
| 2483 else if (!horizontal_p && hit->y > start.y && hit->y <= where.y) | |
| 2484 *hit_return = val; | |
| 2485 } | |
| 2486 | |
| 2487 if (horizontal_p) | |
| 2488 where.y = mw->menu.shadow_thickness; | |
| 2489 else | |
| 2490 where.x = mw->menu.shadow_thickness; | |
| 2491 } | |
| 2492 | |
| 2493 /* Draw slab edges around menu */ | |
| 2494 if (!just_compute_p) | |
| 2495 shadow_draw(mw, ws->window, 0, 0, ws->width, ws->height, SHADOW_OUT); | |
| 2496 } | |
| 2497 | |
| 2498 /* Motion code */ | |
| 2499 static void | |
| 2500 set_new_state (XlwMenuWidget mw, widget_value *val, int level) | |
| 2501 { | |
| 2502 int i; | |
| 2503 | |
| 2504 mw->menu.new_depth = 0; | |
| 2505 for (i = 0; i < level; i++) | |
| 2506 push_new_stack (mw, mw->menu.old_stack [i]); | |
| 2507 if (val) | |
| 2508 push_new_stack (mw, val); | |
| 2509 } | |
| 2510 | |
| 2511 static void | |
| 2512 make_windows_if_needed (XlwMenuWidget mw, int n) | |
| 2513 { | |
| 2514 int i; | |
| 2515 int start_at; | |
| 2516 XSetWindowAttributes xswa; | |
| 2517 Widget p; | |
| 446 | 2518 unsigned long mask; |
| 428 | 2519 int depth; |
| 2520 Visual *visual; | |
| 2521 window_state *windows; | |
| 2522 Window root; | |
| 2523 | |
| 2524 if (mw->menu.windows_length >= n) | |
| 2525 return; | |
| 2526 | |
| 2527 root = RootWindowOfScreen (XtScreen(mw)); | |
| 3094 | 2528 /* use visual_info_from_widget() from lwlib-colors.c */ |
| 428 | 2529 /* grab the visual and depth from the nearest shell ancestor */ |
| 2530 visual = CopyFromParent; | |
| 2531 depth = CopyFromParent; | |
| 2532 p = XtParent(mw); | |
| 2533 while (visual == CopyFromParent && p) | |
| 2534 { | |
| 2535 if (XtIsShell(p)) | |
| 2536 { | |
| 2537 visual = ((ShellWidget)p)->shell.visual; | |
| 2538 depth = p->core.depth; | |
| 2539 } | |
| 2540 p = XtParent(p); | |
| 2541 } | |
| 2542 | |
| 2543 xswa.save_under = True; | |
| 2544 xswa.override_redirect = True; | |
| 2545 xswa.background_pixel = mw->core.background_pixel; | |
| 2546 xswa.border_pixel = mw->core.border_pixel; | |
| 2547 xswa.event_mask = (ExposureMask | ButtonMotionMask | |
| 2548 | ButtonReleaseMask | ButtonPressMask); | |
| 2549 xswa.cursor = mw->menu.cursor_shape; | |
| 2550 xswa.colormap = mw->core.colormap; | |
| 2551 mask = CWSaveUnder | CWOverrideRedirect | CWBackPixel | CWBorderPixel | |
| 2552 | CWEventMask | CWCursor | CWColormap; | |
| 2553 | |
| 2554 if (mw->menu.use_backing_store) | |
| 2555 { | |
| 2556 xswa.backing_store = Always; | |
| 2557 mask |= CWBackingStore; | |
| 2558 } | |
| 2559 | |
| 2560 if (!mw->menu.windows) | |
| 2561 { | |
| 2562 mw->menu.windows = | |
| 2563 (window_state *) XtMalloc (n * sizeof (window_state)); | |
| 2564 start_at = 0; | |
| 2565 } | |
| 2566 else | |
| 2567 { | |
| 2568 mw->menu.windows = | |
| 2569 (window_state *) XtRealloc ((char *) mw->menu.windows, | |
| 2570 n * sizeof (window_state)); | |
| 2571 start_at = mw->menu.windows_length; | |
| 2572 } | |
| 2573 mw->menu.windows_length = n; | |
| 2574 | |
| 2575 windows = mw->menu.windows; | |
| 2576 | |
| 2577 for (i = start_at; i < n; i++) | |
| 2578 { | |
| 2579 windows [i].x = 0; | |
| 2580 windows [i].y = 0; | |
| 2581 windows [i].width = 1; | |
| 2582 windows [i].height = 1; | |
| 2583 windows [i].window = | |
| 2584 XCreateWindow (XtDisplay (mw), | |
| 2585 root, | |
| 2586 0, 0, 1, 1, | |
| 2587 0, depth, CopyFromParent, visual, mask, &xswa); | |
| 2588 } | |
| 2589 } | |
| 2590 | |
| 2591 /* Make the window fit in the screen */ | |
| 2592 static void | |
| 2593 fit_to_screen (XlwMenuWidget mw, window_state *ws, window_state *previous_ws, | |
| 2594 Boolean horizontal_p) | |
| 2595 { | |
| 2596 int screen_width = WidthOfScreen (XtScreen (mw)); | |
| 2597 int screen_height = HeightOfScreen (XtScreen (mw)); | |
| 2598 | |
| 2599 if (ws->x < 0) | |
| 2600 ws->x = 0; | |
| 2601 else if ((int) (ws->x + ws->width) > screen_width) | |
| 2602 { | |
| 2603 if (!horizontal_p) | |
| 2604 ws->x = previous_ws->x - ws->width; | |
| 2605 else | |
| 2606 { | |
| 2607 ws->x = screen_width - ws->width; | |
| 2608 | |
| 2609 /* This check is to make sure we cut off the right side | |
| 2610 instead of the left side if the menu is wider than the | |
| 2611 screen. */ | |
| 2612 if (ws->x < 0) | |
| 2613 ws->x = 0; | |
| 2614 } | |
| 2615 } | |
| 2616 if (ws->y < 0) | |
| 2617 ws->y = 0; | |
| 2618 else if ((int) (ws->y + ws->height) > screen_height) | |
| 2619 { | |
| 2620 if (horizontal_p) | |
| 2621 { | |
| 2622 /* A pulldown must either be entirely above or below the menubar. | |
| 2623 If we're here, the pulldown doesn't fit below the menubar, so | |
| 2624 let's determine if it will fit above the menubar. | |
| 2625 Only put it above if there is more room above than below. | |
| 2626 Note shadow_thickness offset to allow for slab surround. | |
| 2627 */ | |
| 2628 if (ws->y > (screen_height / 2)) | |
| 2629 ws->y = previous_ws->y - ws->height + mw->menu.shadow_thickness; | |
| 2630 } | |
| 2631 else | |
| 2632 { | |
| 2633 ws->y = screen_height - ws->height; | |
| 2634 /* if it's taller than the screen, display the topmost part | |
| 2635 that will fit, beginning at the top of the screen. */ | |
| 2636 if (ws->y < 0) | |
| 2637 ws->y = 0; | |
| 2638 } | |
| 2639 } | |
| 2640 } | |
| 2641 | |
| 2642 /* Updates old_stack from new_stack and redisplays. */ | |
| 2643 static void | |
| 2644 remap_menubar (XlwMenuWidget mw) | |
| 2645 { | |
| 2646 int i; | |
| 2647 int last_same; | |
| 2648 XPoint selection_position; | |
| 2649 int old_depth = mw->menu.old_depth; | |
| 2650 int new_depth = mw->menu.new_depth; | |
| 2651 widget_value **old_stack; | |
| 2652 widget_value **new_stack; | |
| 2653 window_state *windows; | |
| 2654 widget_value *old_selection; | |
| 2655 widget_value *new_selection; | |
| 2656 | |
| 2657 /* Check that enough windows and old_stack are ready. */ | |
| 2658 make_windows_if_needed (mw, new_depth); | |
| 2659 make_old_stack_space (mw, new_depth); | |
| 2660 windows = mw->menu.windows; | |
| 2661 old_stack = mw->menu.old_stack; | |
| 2662 new_stack = mw->menu.new_stack; | |
| 2663 | |
| 2664 /* compute the last identical different entry */ | |
| 2665 for (i = 1; i < old_depth && i < new_depth; i++) | |
| 2666 if (old_stack [i] != new_stack [i]) | |
| 2667 break; | |
| 2668 last_same = i - 1; | |
| 2669 | |
| 2670 if (lw_menu_accelerate | |
| 2671 && last_same | |
| 2672 && last_same == old_depth - 1 | |
| 2673 && old_stack [last_same]->contents) | |
| 2674 last_same--; | |
| 2675 | |
| 2676 /* Memorize the previously selected item to be able to refresh it */ | |
| 2677 old_selection = last_same + 1 < old_depth ? old_stack [last_same + 1] : NULL; | |
| 2678 new_selection = last_same + 1 < new_depth ? new_stack [last_same + 1] : NULL; | |
| 2679 | |
| 2680 /* updates old_state from new_state. It has to be done now because | |
| 2681 display_menu (called below) uses the old_stack to know what to display. */ | |
| 2682 for (i = last_same + 1; i < new_depth; i++) | |
| 2683 old_stack [i] = new_stack [i]; | |
| 2684 | |
| 2685 mw->menu.old_depth = new_depth; | |
| 2686 | |
| 442 | 2687 /* refresh the last selection */ |
| 428 | 2688 selection_position.x = 0; |
| 2689 selection_position.y = 0; | |
| 2690 display_menu (mw, last_same, new_selection == old_selection, | |
| 2691 &selection_position, NULL, NULL, old_selection, new_selection); | |
| 2692 | |
| 2693 /* Now popup the new menus */ | |
| 2694 for (i = last_same + 1; i < new_depth && new_stack [i]->contents; i++) | |
| 2695 { | |
| 2696 window_state *previous_ws = &windows [i - 1]; | |
| 2697 window_state *ws = &windows [i]; | |
| 2698 | |
| 2699 if (lw_menu_accelerate && i == new_depth - 1) | |
| 2700 break; | |
| 2701 | |
| 2702 ws->x = previous_ws->x + selection_position.x; | |
| 2703 ws->y = previous_ws->y + selection_position.y; | |
| 2704 | |
| 2705 /* take into account the slab around the new menu */ | |
| 2706 ws->y -= mw->menu.shadow_thickness; | |
| 2707 | |
| 2708 { | |
| 2709 widget_value *val = mw->menu.old_stack [i]; | |
| 2710 if (val->contents->type == INCREMENTAL_TYPE) | |
| 2711 { | |
| 2712 /* okay, we're now doing a lisp callback to incrementally generate | |
| 2713 more of the menu. */ | |
| 2714 XtCallCallbackList ((Widget)mw, | |
| 2715 mw->menu.open, | |
| 2716 (XtPointer)val->contents); | |
| 2717 } | |
| 2718 } | |
| 2719 | |
| 2720 size_menu (mw, i); | |
| 2721 | |
| 2722 fit_to_screen (mw, ws, previous_ws, mw->menu.horizontal && i == 1); | |
| 2723 | |
| 2724 XClearWindow (XtDisplay (mw), ws->window); | |
| 2725 XMoveResizeWindow (XtDisplay (mw), ws->window, ws->x, ws->y, | |
| 2726 ws->width, ws->height); | |
| 2727 XMapRaised (XtDisplay (mw), ws->window); | |
| 2728 display_menu (mw, i, False, &selection_position, NULL, NULL, NULL, NULL); | |
| 2729 } | |
| 2730 | |
| 2731 /* unmap the menus that popped down */ | |
| 2732 | |
| 2733 last_same = new_depth; | |
| 2734 if (lw_menu_accelerate | |
| 2735 && last_same > 1 | |
| 2736 && new_stack [last_same - 1]->contents) | |
| 2737 last_same--; | |
| 2738 | |
| 2739 for (i = last_same - 1; i < old_depth; i++) | |
| 2740 if (i >= last_same || !new_stack [i]->contents) | |
| 2741 XUnmapWindow (XtDisplay (mw), windows [i].window); | |
| 2742 } | |
| 2743 | |
| 2744 static Boolean | |
| 2745 motion_event_is_in_menu (XlwMenuWidget mw, XMotionEvent *ev, int level, | |
| 2746 XPoint *relative_pos) | |
| 2747 { | |
| 2748 window_state *ws = &mw->menu.windows [level]; | |
| 2749 int x = level == 0 ? ws->x : ws->x + mw->menu.shadow_thickness; | |
| 2750 int y = level == 0 ? ws->y : ws->y + mw->menu.shadow_thickness; | |
| 2751 relative_pos->x = ev->x_root - x; | |
| 2752 relative_pos->y = ev->y_root - y; | |
| 2753 return (x < ev->x_root && ev->x_root < (int) (x + ws->width) && | |
| 2754 y < ev->y_root && ev->y_root < (int) (y + ws->height)); | |
| 2755 } | |
| 2756 | |
| 2757 static Boolean | |
| 2758 map_event_to_widget_value (XlwMenuWidget mw, XMotionEvent *ev, | |
| 2759 widget_value **val_ptr, int *level, | |
| 2760 Boolean *inside_menu) | |
| 2761 { | |
| 2762 int i; | |
| 2763 XPoint relative_pos; | |
| 2764 window_state* ws; | |
| 2765 | |
| 2766 *val_ptr = NULL; | |
| 2767 *inside_menu = False; | |
| 2768 | |
| 2769 /* Find the window */ | |
| 2770 #if 1 | |
| 2771 for (i = mw->menu.old_depth - 1; i >= 0; i--) | |
| 2772 #else | |
| 2773 for (i = 0; i <= mw->menu.old_depth - 1; i++) | |
| 2774 #endif | |
| 2775 { | |
| 2776 ws = &mw->menu.windows [i]; | |
| 2777 if (ws && motion_event_is_in_menu (mw, ev, i, &relative_pos)) | |
| 2778 { | |
| 2779 *inside_menu = True; /* special logic for menubar below... */ | |
| 2780 if ((ev->type == ButtonPress) || | |
| 2781 (ev->state != 0)) | |
| 2782 { | |
| 2783 display_menu (mw, i, True, NULL, &relative_pos, | |
| 2784 val_ptr, NULL, NULL); | |
| 2785 if (*val_ptr) | |
| 2786 { | |
| 2787 *level = i + 1; | |
| 2788 *inside_menu = True; | |
| 2789 return True; | |
| 2790 } | |
| 2791 else if (mw->menu.horizontal || i == 0) | |
| 2792 { | |
| 2793 /* if we're clicking on empty part of the menubar, then | |
| 2794 unpost the stay-up menu */ | |
| 2795 *inside_menu = False; | |
| 2796 } | |
| 2797 } | |
| 2798 } | |
| 2799 } | |
| 2800 return False; | |
| 2801 } | |
| 2802 | |
| 2803 /* Procedures */ | |
| 2804 static void | |
| 2805 make_drawing_gcs (XlwMenuWidget mw) | |
| 2806 { | |
| 2807 XGCValues xgcv; | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
2808 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 2809 unsigned long flags = (GCForeground | GCBackground); |
| 2810 #else | |
| 428 | 2811 unsigned long flags = (GCFont | GCForeground | GCBackground); |
| 3094 | 2812 #endif |
| 2813 | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
2814 #if defined(NEED_MOTIF) && !defined(HAVE_XFT_MENUBARS) |
| 428 | 2815 xgcv.font = default_font_of_font_list (mw->menu.font_list)->fid; |
| 2816 #else | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
2817 #ifndef HAVE_XFT_MENUBARS |
| 428 | 2818 xgcv.font = mw->menu.font->fid; |
| 2819 #endif | |
| 3094 | 2820 #endif |
| 428 | 2821 |
| 2822 xgcv.foreground = mw->core.background_pixel; | |
| 2823 xgcv.background = mw->menu.foreground; | |
| 2824 mw->menu.background_gc = XtGetGC ((Widget) mw, flags, &xgcv); | |
| 2825 | |
| 2826 xgcv.foreground = mw->menu.foreground; | |
| 2827 xgcv.background = mw->core.background_pixel; | |
| 2828 mw->menu.foreground_gc = XtGetGC ((Widget) mw, flags, &xgcv); | |
| 2829 | |
| 2830 if (mw->menu.select_color != (Pixel)-1) | |
| 2831 { | |
| 2832 xgcv.foreground = mw->menu.select_color; | |
| 2833 } | |
| 2834 else | |
| 2835 { | |
| 2836 Display *dpy = XtDisplay(mw); | |
| 2837 if (CellsOfScreen(DefaultScreenOfDisplay(dpy)) <= 2) | |
| 2838 { /* mono */ | |
| 2839 xgcv.foreground = mw->menu.foreground; | |
| 2840 } | |
| 2841 else | |
| 2842 { /* color */ | |
| 2843 XColor xcolor; | |
| 3094 | 2844 Visual *visual; |
| 2845 int ignore; | |
| 3157 | 2846 Colormap cmap; |
| 3094 | 2847 visual_info_from_widget ((Widget) mw, &visual, &ignore); |
| 3157 | 2848 cmap = mw->core.colormap; |
| 428 | 2849 xcolor.pixel = mw->core.background_pixel; |
| 2850 XQueryColor (dpy, cmap, &xcolor); | |
| 2851 xcolor.red = (xcolor.red * 17) / 20; | |
| 2852 xcolor.green = (xcolor.green * 17) / 20; | |
| 2853 xcolor.blue = (xcolor.blue * 17) / 20; | |
| 3094 | 2854 if (x_allocate_nearest_color (dpy, cmap, visual, &xcolor)) |
| 428 | 2855 xgcv.foreground = xcolor.pixel; |
| 2856 } | |
| 2857 } | |
| 2858 xgcv.background = mw->core.background_pixel; | |
| 3094 | 2859 mw->menu.select_gc = XtGetGC ((Widget) mw, flags, &xgcv); |
| 428 | 2860 |
| 2861 xgcv.foreground = mw->menu.foreground; | |
| 2862 xgcv.background = mw->core.background_pixel; | |
| 2863 xgcv.fill_style = FillStippled; | |
| 2864 xgcv.stipple = mw->menu.gray_pixmap; | |
| 2865 mw->menu.inactive_gc = XtGetGC ((Widget)mw, | |
| 2866 (flags | GCFillStyle | GCStipple), | |
| 2867 &xgcv); | |
| 2868 | |
| 2869 xgcv.foreground = mw->menu.highlight_foreground; | |
| 2870 xgcv.background = mw->core.background_pixel; | |
| 2871 mw->menu.highlight_gc = XtGetGC ((Widget)mw, flags, &xgcv); | |
| 2872 | |
| 2873 xgcv.foreground = mw->menu.title_foreground; | |
| 2874 xgcv.background = mw->core.background_pixel; | |
| 2875 mw->menu.title_gc = XtGetGC ((Widget)mw, flags, &xgcv); | |
| 2876 | |
| 2877 xgcv.foreground = mw->menu.button_foreground; | |
| 2878 xgcv.background = mw->core.background_pixel; | |
| 2879 mw->menu.button_gc = XtGetGC ((Widget)mw, flags, &xgcv); | |
| 2880 | |
| 2881 xgcv.fill_style = FillStippled; | |
| 2882 xgcv.stipple = mw->menu.gray_pixmap; | |
| 2883 mw->menu.inactive_button_gc = XtGetGC ((Widget)mw, | |
| 2884 (flags | GCFillStyle | GCStipple), | |
| 2885 &xgcv); | |
| 2886 } | |
| 2887 | |
| 2888 static void | |
| 2889 release_drawing_gcs (XlwMenuWidget mw) | |
| 2890 { | |
| 3094 | 2891 |
| 428 | 2892 XtReleaseGC ((Widget) mw, mw->menu.foreground_gc); |
| 2893 XtReleaseGC ((Widget) mw, mw->menu.button_gc); | |
| 2894 XtReleaseGC ((Widget) mw, mw->menu.highlight_gc); | |
| 2895 XtReleaseGC ((Widget) mw, mw->menu.title_gc); | |
| 2896 XtReleaseGC ((Widget) mw, mw->menu.inactive_gc); | |
| 2897 XtReleaseGC ((Widget) mw, mw->menu.inactive_button_gc); | |
| 2898 XtReleaseGC ((Widget) mw, mw->menu.background_gc); | |
| 2899 XtReleaseGC ((Widget) mw, mw->menu.select_gc); | |
| 2900 /* let's get some segvs if we try to use these... */ | |
| 2901 mw->menu.foreground_gc = (GC) -1; | |
| 2902 mw->menu.button_gc = (GC) -1; | |
| 2903 mw->menu.highlight_gc = (GC) -1; | |
| 2904 mw->menu.title_gc = (GC) -1; | |
| 2905 mw->menu.inactive_gc = (GC) -1; | |
| 2906 mw->menu.inactive_button_gc = (GC) -1; | |
| 2907 mw->menu.background_gc = (GC) -1; | |
| 2908 mw->menu.select_gc = (GC) -1; | |
| 2909 } | |
| 2910 | |
| 2911 static void | |
| 2912 make_shadow_gcs (XlwMenuWidget mw) | |
| 2913 { | |
| 2914 XGCValues xgcv; | |
| 2915 unsigned long pm = 0; | |
| 2916 Display *dpy = XtDisplay ((Widget) mw); | |
| 2917 Colormap cmap = mw->core.colormap; | |
| 3094 | 2918 Visual *visual; |
| 2919 int ignored; | |
| 428 | 2920 XColor topc, botc; |
| 2921 int top_frobbed = 0, bottom_frobbed = 0; | |
| 2922 | |
| 3094 | 2923 visual_info_from_widget ((Widget) mw, &visual, &ignored); |
| 2924 /* #### Apparently this is called before any shell has a visual? | |
| 2925 or maybe the widget doesn't have a parent yet? */ | |
| 2926 if (visual == CopyFromParent) | |
| 2927 { | |
| 2928 Screen *screen = DefaultScreenOfDisplay (dpy); | |
| 2929 visual = DefaultVisualOfScreen (screen); | |
| 2930 } | |
| 2931 | |
| 428 | 2932 if (mw->menu.top_shadow_color == (Pixel) (-1)) |
| 2933 mw->menu.top_shadow_color = mw->core.background_pixel; | |
| 2934 if (mw->menu.bottom_shadow_color == (Pixel) (-1)) | |
| 2935 mw->menu.bottom_shadow_color = mw->menu.foreground; | |
| 2936 | |
| 2937 if (mw->menu.top_shadow_color == mw->core.background_pixel || | |
| 2938 mw->menu.top_shadow_color == mw->menu.foreground) | |
| 2939 { | |
| 2940 topc.pixel = mw->core.background_pixel; | |
| 2941 XQueryColor (dpy, cmap, &topc); | |
| 2942 /* don't overflow/wrap! */ | |
| 2943 topc.red = MINL (65535, topc.red * 1.2); | |
| 2944 topc.green = MINL (65535, topc.green * 1.2); | |
| 2945 topc.blue = MINL (65535, topc.blue * 1.2); | |
| 3094 | 2946 if (x_allocate_nearest_color (dpy, cmap, visual, &topc)) |
| 428 | 2947 { |
| 2948 if (topc.pixel == mw->core.background_pixel) | |
| 2949 { | |
| 2950 XFreeColors( dpy, cmap, &topc.pixel, 1, 0); | |
| 2951 topc.red = MINL (65535, topc.red + 0x8000); | |
| 2952 topc.green = MINL (65535, topc.green + 0x8000); | |
| 2953 topc.blue = MINL (65535, topc.blue + 0x8000); | |
| 3094 | 2954 if (x_allocate_nearest_color (dpy, cmap, visual, &topc)) |
| 428 | 2955 { |
| 2956 mw->menu.top_shadow_color = topc.pixel; | |
| 2957 } | |
| 2958 } | |
| 2959 else | |
| 2960 { | |
| 2961 mw->menu.top_shadow_color = topc.pixel; | |
| 2962 } | |
| 2963 | |
| 2964 top_frobbed = 1; | |
| 2965 } | |
| 2966 } | |
| 2967 if (mw->menu.bottom_shadow_color == mw->menu.foreground || | |
| 2968 mw->menu.bottom_shadow_color == mw->core.background_pixel) | |
| 2969 { | |
| 2970 botc.pixel = mw->core.background_pixel; | |
| 2971 XQueryColor (dpy, cmap, &botc); | |
| 2972 botc.red = (botc.red * 3) / 5; | |
| 2973 botc.green = (botc.green * 3) / 5; | |
| 2974 botc.blue = (botc.blue * 3) / 5; | |
| 3094 | 2975 if (x_allocate_nearest_color (dpy, cmap, visual, &botc)) |
| 428 | 2976 { |
| 2977 if (botc.pixel == mw->core.background_pixel) | |
| 2978 { | |
| 2979 XFreeColors (dpy, cmap, &botc.pixel, 1, 0); | |
| 2980 botc.red = MINL (65535, botc.red + 0x4000); | |
| 2981 botc.green = MINL (65535, botc.green + 0x4000); | |
| 2982 botc.blue = MINL (65535, botc.blue + 0x4000); | |
| 3094 | 2983 if (x_allocate_nearest_color (dpy, cmap, visual, &botc)) |
| 428 | 2984 { |
| 2985 mw->menu.bottom_shadow_color = botc.pixel; | |
| 2986 } | |
| 2987 } | |
| 2988 else | |
| 2989 { | |
| 2990 mw->menu.bottom_shadow_color = botc.pixel; | |
| 2991 } | |
| 2992 | |
| 2993 bottom_frobbed = 1; | |
| 2994 } | |
| 2995 } | |
| 2996 | |
| 2997 if (top_frobbed && bottom_frobbed) | |
| 2998 { | |
| 2999 int top_avg = ((topc.red / 3) + (topc.green / 3) + (topc.blue / 3)); | |
| 3000 int bot_avg = ((botc.red / 3) + (botc.green / 3) + (botc.blue / 3)); | |
| 3001 if (bot_avg > top_avg) | |
| 3002 { | |
| 3003 Pixel tmp = mw->menu.top_shadow_color; | |
| 3004 mw->menu.top_shadow_color = mw->menu.bottom_shadow_color; | |
| 3005 mw->menu.bottom_shadow_color = tmp; | |
| 3006 } | |
| 3007 else if (topc.pixel == botc.pixel) | |
| 3008 { | |
| 3009 if (botc.pixel == mw->menu.foreground) | |
| 3010 mw->menu.top_shadow_color = mw->core.background_pixel; | |
| 3011 else | |
| 3012 mw->menu.bottom_shadow_color = mw->menu.foreground; | |
| 3013 } | |
| 3014 } | |
| 3015 | |
| 3016 if (!mw->menu.top_shadow_pixmap && | |
| 3017 mw->menu.top_shadow_color == mw->core.background_pixel) | |
| 3018 { | |
| 3019 mw->menu.top_shadow_pixmap = mw->menu.gray_pixmap; | |
| 3020 mw->menu.top_shadow_color = mw->menu.foreground; | |
| 3021 } | |
| 3022 if (!mw->menu.bottom_shadow_pixmap && | |
| 3023 mw->menu.bottom_shadow_color == mw->core.background_pixel) | |
| 3024 { | |
| 3025 mw->menu.bottom_shadow_pixmap = mw->menu.gray_pixmap; | |
| 3026 mw->menu.bottom_shadow_color = mw->menu.foreground; | |
| 3027 } | |
| 3028 | |
| 3029 xgcv.fill_style = FillOpaqueStippled; | |
| 3030 xgcv.foreground = mw->menu.top_shadow_color; | |
| 3031 xgcv.background = mw->core.background_pixel; | |
| 3032 /* xgcv.stipple = mw->menu.top_shadow_pixmap; gtb */ | |
| 3033 if (mw->menu.top_shadow_pixmap && | |
| 3034 mw->menu.top_shadow_pixmap != XmUNSPECIFIED_PIXMAP) | |
| 3035 xgcv.stipple = mw->menu.top_shadow_pixmap; | |
| 3036 else | |
| 3037 xgcv.stipple = 0; | |
| 3038 pm = (xgcv.stipple ? GCStipple|GCFillStyle : 0); | |
| 3039 mw->menu.shadow_top_gc = | |
| 3040 XtGetGC((Widget)mw, GCForeground|GCBackground|pm, &xgcv); | |
| 3041 | |
| 3042 xgcv.foreground = mw->menu.bottom_shadow_color; | |
| 3043 /* xgcv.stipple = mw->menu.bottom_shadow_pixmap; gtb */ | |
| 3044 if (mw->menu.bottom_shadow_pixmap && | |
| 3045 mw->menu.bottom_shadow_pixmap != XmUNSPECIFIED_PIXMAP) | |
| 3046 xgcv.stipple = mw->menu.bottom_shadow_pixmap; | |
| 3047 else | |
| 3048 xgcv.stipple = 0; | |
| 3049 pm = (xgcv.stipple ? GCStipple|GCFillStyle : 0); | |
| 3050 mw->menu.shadow_bottom_gc = | |
| 3051 XtGetGC ((Widget)mw, GCForeground|GCBackground|pm, &xgcv); | |
| 3052 } | |
| 3053 | |
| 3054 | |
| 3055 static void | |
| 3056 release_shadow_gcs (XlwMenuWidget mw) | |
| 3057 { | |
| 3058 XtReleaseGC ((Widget) mw, mw->menu.shadow_top_gc); | |
| 3059 XtReleaseGC ((Widget) mw, mw->menu.shadow_bottom_gc); | |
| 3060 } | |
| 3061 | |
| 3062 | |
| 3063 static void | |
| 3064 extract_font_extents (XlwMenuWidget mw) | |
| 3065 { | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
3066 #if defined(NEED_MOTIF) && !defined(HAVE_XFT_MENUBARS) |
| 428 | 3067 /* Find the maximal ascent/descent of the fonts in the font list |
| 3068 so that all menu items can be the same height... */ | |
| 3069 mw->menu.font_ascent = 0; | |
| 3070 mw->menu.font_descent = 0; | |
| 3071 | |
| 3072 { | |
| 3073 XmFontContext context; | |
| 3074 #if (XmVersion >= 1002) | |
| 3075 XmFontListEntry fontentry; | |
| 3076 #else | |
| 3077 XmStringCharSet charset; | |
| 3078 #endif | |
| 3079 XFontStruct *font; | |
| 3080 | |
| 3081 if (! XmFontListInitFontContext (&context, mw->menu.font_list)) | |
| 3082 abort (); | |
| 3083 #if (XmVersion >= 1002) | |
| 3084 /* There is a BUG in the 1.2 version of XmFontListGetNextFont() (or more | |
| 3085 specifically, in _XmGetFirstFont()) that can cause a null pointer to be | |
| 3086 passed to XFontsOfFontSet. Use XmFontListNextEntry(), which is the | |
| 3087 newer equivalent, instead. Also, it supports font sets, and the | |
| 3088 older function doesn't. */ | |
| 3089 while ((fontentry = XmFontListNextEntry (context))) | |
| 3090 { | |
| 3091 XmFontType rettype; | |
| 3092 | |
| 3093 XtPointer one_of_them = XmFontListEntryGetFont (fontentry, &rettype); | |
| 3094 if (rettype == XmFONT_IS_FONTSET) | |
| 3095 { | |
| 3096 XFontSet fontset = (XFontSet) one_of_them; | |
| 3097 XFontStruct **fontstruct_list; | |
| 3098 char **fontname_list; | |
| 3099 int fontcount = XFontsOfFontSet (fontset, &fontstruct_list, | |
| 3100 &fontname_list); | |
| 3101 while (--fontcount >= 0) | |
| 3102 { | |
| 3103 font = fontstruct_list[fontcount]; | |
| 3104 if (font->ascent > (int) mw->menu.font_ascent) | |
| 3105 mw->menu.font_ascent = font->ascent; | |
| 3106 if (font->descent > (int) mw->menu.font_descent) | |
| 3107 mw->menu.font_descent = font->descent; | |
| 3108 } | |
| 3109 } | |
| 3110 else /* XmFONT_IS_FONT */ | |
| 3111 { | |
| 3112 font = (XFontStruct *) one_of_them; | |
| 3113 if (font->ascent > (int) mw->menu.font_ascent) | |
| 3114 mw->menu.font_ascent = font->ascent; | |
| 3115 if (font->descent > (int) mw->menu.font_descent) | |
| 3116 mw->menu.font_descent = font->descent; | |
| 3117 } | |
| 3118 } | |
| 3119 #else /* motif 1.1 */ | |
| 3120 while (XmFontListGetNextFont (context, &charset, &font)) | |
| 3121 { | |
| 3122 if (font->ascent > (int) mw->menu.font_ascent) | |
| 3123 mw->menu.font_ascent = font->ascent; | |
| 3124 if (font->descent > (int) mw->menu.font_descent) | |
| 3125 mw->menu.font_descent = font->descent; | |
| 3126 XtFree (charset); | |
| 3127 } | |
| 3128 #endif /* Motif version */ | |
| 3129 XmFontListFreeFontContext (context); | |
| 3130 } | |
| 3131 #else /* Not Motif */ | |
| 3132 # ifdef USE_XFONTSET | |
| 3133 XFontStruct **fontstruct_list; | |
| 3134 char **fontname_list; | |
| 3135 XFontStruct *font; | |
| 3136 int fontcount = XFontsOfFontSet(mw->menu.font_set, &fontstruct_list, | |
| 3137 &fontname_list); | |
| 3138 mw->menu.font_ascent = 0; | |
| 3139 mw->menu.font_descent = 0; | |
| 3140 # if 0 /* nasty, personal debug, Kazz */ | |
| 3141 fprintf(stderr, "fontSet count is %d\n", fontcount); | |
| 3142 # endif | |
| 3143 while (--fontcount >= 0) { | |
| 3144 font = fontstruct_list[fontcount]; | |
| 3145 if (font->ascent > (int) mw->menu.font_ascent) | |
| 3146 mw->menu.font_ascent = font->ascent; | |
| 3147 if (font->descent > (int) mw->menu.font_descent) | |
| 3148 mw->menu.font_descent = font->descent; | |
| 3149 } | |
| 3150 # else /* ! USE_XFONTSET */ | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
3151 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 3152 mw->menu.font_ascent = mw->menu.renderFont->ascent; |
| 3153 mw->menu.font_descent = mw->menu.renderFont->descent; | |
| 3154 #else | |
| 428 | 3155 mw->menu.font_ascent = mw->menu.font->ascent; |
| 3156 mw->menu.font_descent = mw->menu.font->descent; | |
| 3094 | 3157 #endif |
| 428 | 3158 # endif |
| 3159 #endif /* NEED_MOTIF */ | |
| 3160 } | |
| 3161 | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
3162 #if defined(NEED_MOTIF) && !defined(HAVE_XFT_MENUBARS) |
| 428 | 3163 static XFontStruct * |
| 3164 default_font_of_font_list (XmFontList font_list) | |
| 3165 { | |
| 3166 XFontStruct *font = 0; | |
| 3167 # if 0 | |
| 3168 /* Xm/Label.c does this: */ | |
| 3169 _XmFontListGetDefaultFont (font_list, &font); | |
| 3170 # else /* !0 */ | |
| 3171 { | |
| 3172 XmFontContext context; | |
| 3173 #if (XmVersion >= 1002) | |
| 3174 XmFontListEntry fontentry; | |
| 3175 XmFontType rettype; | |
| 3176 XtPointer one_of_them; | |
| 3177 #else | |
| 3178 XmStringCharSet charset; | |
| 3179 #endif | |
| 3180 | |
| 3181 if (! XmFontListInitFontContext (&context, font_list)) | |
| 3182 abort (); | |
| 3183 #if (XmVersion >= 1002) | |
| 3184 /* There is a BUG in the 1.2 version of XmFontListGetNextFont() (or more | |
| 3185 specifically, in _XmGetFirstFont()) that can cause a null pointer to be | |
| 3186 passed to XFontsOfFontSet. Use XmFontListNextEntry(), which is the | |
| 3187 newer equivalent, instead. */ | |
| 3188 fontentry = XmFontListNextEntry (context); | |
| 3189 one_of_them = XmFontListEntryGetFont (fontentry, &rettype); | |
| 3190 if (rettype == XmFONT_IS_FONTSET) | |
| 3191 { | |
| 3192 XFontSet fontset = (XFontSet) one_of_them; | |
| 3193 XFontStruct **fontstruct_list; | |
| 3194 char **fontname_list; | |
| 3195 (void) XFontsOfFontSet (fontset, &fontstruct_list, &fontname_list); | |
| 3196 font = fontstruct_list[0]; | |
| 3197 } | |
| 3198 else /* XmFONT_IS_FONT */ | |
| 3199 { | |
| 3200 font = (XFontStruct *) one_of_them; | |
| 3201 } | |
| 3202 #else | |
| 3203 if (! XmFontListGetNextFont (context, &charset, &font)) | |
| 3204 abort (); | |
| 3205 XtFree (charset); | |
| 3206 #endif | |
| 3207 XmFontListFreeFontContext (context); | |
| 3208 } | |
| 3209 # endif /* !0 */ | |
| 3210 | |
| 3211 if (! font) abort (); | |
| 3212 return font; | |
| 3213 } | |
| 3214 #endif /* NEED_MOTIF */ | |
| 3215 | |
| 3216 static void | |
| 2286 | 3217 XlwMenuInitialize (Widget UNUSED (request), Widget new_, ArgList UNUSED (args), |
| 3218 Cardinal *UNUSED (num_args)) | |
| 428 | 3219 { |
| 3220 /* Get the GCs and the widget size */ | |
| 1201 | 3221 XlwMenuWidget mw = (XlwMenuWidget)new_; |
| 428 | 3222 Window window = RootWindowOfScreen (DefaultScreenOfDisplay (XtDisplay (mw))); |
| 3223 Display *display = XtDisplay (mw); | |
| 3224 | |
| 3225 /* mw->menu.cursor = XCreateFontCursor (display, mw->menu.cursor_shape); */ | |
| 3226 mw->menu.cursor = mw->menu.cursor_shape; | |
| 3227 | |
| 3228 mw->menu.gray_pixmap = | |
| 3229 XCreatePixmapFromBitmapData (display, window, (char *) gray_bits, | |
| 3230 gray_width, gray_height, 1, 0, 1); | |
| 3231 | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
3232 #if defined(NEED_MOTIF) && !defined(HAVE_XFT_MENUBARS) |
| 442 | 3233 /* #### Even if it's a kludge!!!, we should consider doing the same for |
| 3234 X Font Sets. */ | |
| 428 | 3235 /* The menu.font_list slot came from the *fontList resource (Motif standard.) |
| 3236 The menu.font_list_2 slot came from the *font resource, for backward | |
| 3237 compatibility with older versions of this code, and consistency with the | |
| 442 | 3238 rest of emacs. If both font and fontList are specified, we use fontList. |
| 428 | 3239 If only one is specified, we use that. If neither are specified, we |
| 3240 use the "fallback" value. What a kludge!!! | |
| 3241 | |
| 3242 Note that this has the bug that a more general wildcard like "*fontList:" | |
| 3243 will override a more specific resource like "Emacs*menubar.font:". But | |
| 3244 I can't think of a way around that. | |
| 3245 */ | |
| 3246 if (mw->menu.font_list) /* if *fontList is specified, use that */ | |
| 3247 ; | |
| 3248 else if (mw->menu.font_list_2) /* else if *font is specified, use that */ | |
| 3249 mw->menu.font_list = mw->menu.font_list_2; | |
| 3250 else /* otherwise use default */ | |
| 3251 mw->menu.font_list = mw->menu.fallback_font_list; | |
| 3252 #endif | |
| 3253 | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
3254 #ifdef HAVE_XFT_MENUBARS |
| 3685 | 3255 /* #### kludge for name change */ |
| 3256 if (!mw->menu.fcFontName) | |
| 3257 mw->menu.fcFontName = mw->menu.xftFontName; | |
| 3094 | 3258 /* to do this right, we should add a new Xt Resource type + |
| 3259 conversion function | |
| 3260 */ | |
| 3261 mw->menu.renderFont = | |
| 3397 | 3262 xft_open_font_by_name (XtDisplay (mw), mw->menu.fcFontName); |
| 3094 | 3263 #endif |
| 3264 | |
| 428 | 3265 make_drawing_gcs (mw); |
| 3266 make_shadow_gcs (mw); | |
| 3267 extract_font_extents (mw); | |
| 3268 | |
| 3269 mw->menu.popped_up = False; | |
| 3270 mw->menu.pointer_grabbed = False; | |
| 3271 mw->menu.next_release_must_exit = False; | |
| 3272 | |
| 3273 mw->menu.old_depth = 1; | |
| 3274 mw->menu.old_stack = XtNew (widget_value*); | |
| 3275 mw->menu.old_stack_length = 1; | |
| 3276 mw->menu.old_stack [0] = mw->menu.contents; | |
| 3277 | |
| 3278 mw->menu.new_depth = 0; | |
| 3279 mw->menu.new_stack = 0; | |
| 3280 mw->menu.new_stack_length = 0; | |
| 3281 push_new_stack (mw, mw->menu.contents); | |
| 3282 | |
| 3283 mw->menu.windows = XtNew (window_state); | |
| 3284 mw->menu.windows_length = 1; | |
| 3285 mw->menu.windows [0].x = 0; | |
| 3286 mw->menu.windows [0].y = 0; | |
| 3287 mw->menu.windows [0].width = 0; | |
| 3288 mw->menu.windows [0].height = 0; | |
| 3289 size_menu (mw, 0); | |
| 3290 | |
| 3291 mw->core.width = mw->menu.windows [0].width; | |
| 3292 mw->core.height = mw->menu.windows [0].height; | |
| 3293 } | |
| 3294 | |
| 3295 static void | |
| 3296 XlwMenuClassInitialize (void) | |
| 3297 { | |
| 3298 initialize_massaged_resource_char(); | |
| 3299 } | |
| 3300 | |
| 3301 static void | |
| 3302 XlwMenuRealize (Widget w, Mask *valueMask, XSetWindowAttributes *attributes) | |
| 3303 { | |
| 3304 XlwMenuWidget mw = (XlwMenuWidget)w; | |
| 3305 XSetWindowAttributes xswa; | |
| 446 | 3306 unsigned long mask; |
| 428 | 3307 |
| 3308 (*xlwMenuWidgetClass->core_class.superclass->core_class.realize) | |
| 3309 (w, valueMask, attributes); | |
| 3310 | |
| 3311 xswa.save_under = True; | |
| 3312 xswa.cursor = mw->menu.cursor_shape; | |
| 3313 mask = CWSaveUnder | CWCursor; | |
| 3314 if (mw->menu.use_backing_store) | |
| 3315 { | |
| 3316 xswa.backing_store = Always; | |
| 3317 mask |= CWBackingStore; | |
| 3318 } | |
| 3319 XChangeWindowAttributes (XtDisplay (w), XtWindow (w), mask, &xswa); | |
| 3320 | |
| 3321 mw->menu.windows [0].window = XtWindow (w); | |
| 3322 mw->menu.windows [0].x = w->core.x; | |
| 3323 mw->menu.windows [0].y = w->core.y; | |
| 3324 mw->menu.windows [0].width = w->core.width; | |
| 3325 mw->menu.windows [0].height = w->core.height; | |
| 3326 } | |
| 3327 | |
| 3328 /* Only the toplevel menubar/popup is a widget so it's the only one that | |
| 3329 receives expose events through Xt. So we repaint all the other panes | |
| 3330 when receiving an Expose event. */ | |
| 3331 static void | |
| 2286 | 3332 XlwMenuRedisplay (Widget w, XEvent *UNUSED (ev), Region UNUSED (region)) |
| 428 | 3333 { |
| 3334 XlwMenuWidget mw = (XlwMenuWidget)w; | |
| 3335 int i; | |
| 3336 | |
| 3337 if (mw->core.being_destroyed) return; | |
| 3338 | |
| 3339 for (i = 0; i < mw->menu.old_depth; i++) | |
| 3340 display_menu (mw, i, False, NULL, NULL, NULL, NULL, NULL); | |
| 3341 set_new_state (mw, NULL, mw->menu.old_depth); /* #### - ??? */ | |
| 3342 remap_menubar (mw); /* #### - do these two lines do anything? */ | |
| 3343 } | |
| 3344 | |
| 3345 static void | |
| 3346 XlwMenuDestroy (Widget w) | |
| 3347 { | |
| 3348 int i; | |
| 3349 XlwMenuWidget mw = (XlwMenuWidget) w; | |
| 3350 | |
| 3351 if (mw->menu.pointer_grabbed) | |
| 3352 { | |
| 3353 XtUngrabPointer (w, CurrentTime); | |
| 3354 mw->menu.pointer_grabbed = False; | |
| 3355 } | |
| 3356 | |
| 3357 release_drawing_gcs (mw); | |
| 3358 release_shadow_gcs (mw); | |
| 3359 | |
| 3360 /* this doesn't come from the resource db but is created explicitly | |
| 3361 so we must free it ourselves. */ | |
| 3362 XFreePixmap (XtDisplay (mw), mw->menu.gray_pixmap); | |
| 3363 mw->menu.gray_pixmap = (Pixmap) -1; | |
| 3364 | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
3365 #ifdef HAVE_XFT_MENUBARS |
| 4173 | 3366 XftFontClose (XtDisplay (mw), mw->menu.renderFont); |
| 3367 #endif | |
| 3368 | |
| 428 | 3369 /* Don't free mw->menu.contents because that comes from our creator. |
| 3370 The `*_stack' elements are just pointers into `contents' so leave | |
| 3371 that alone too. But free the stacks themselves. */ | |
| 3372 if (mw->menu.old_stack) XtFree ((char *) mw->menu.old_stack); | |
| 3373 if (mw->menu.new_stack) XtFree ((char *) mw->menu.new_stack); | |
| 3374 | |
| 3375 /* Remember, you can't free anything that came from the resource | |
| 3376 database. This includes: | |
| 3377 mw->menu.cursor | |
| 3378 mw->menu.top_shadow_pixmap | |
| 3379 mw->menu.bottom_shadow_pixmap | |
| 3380 mw->menu.font | |
| 3381 mw->menu.font_set | |
| 3382 Also the color cells of top_shadow_color, bottom_shadow_color, | |
| 3383 foreground, and button_foreground will never be freed until this | |
| 3384 client exits. Nice, eh? | |
| 3385 */ | |
| 3386 | |
| 3387 /* start from 1 because the one in slot 0 is w->core.window */ | |
| 3388 for (i = 1; i < mw->menu.windows_length; i++) | |
| 3389 XDestroyWindow (XtDisplay (mw), mw->menu.windows [i].window); | |
| 3390 if (mw->menu.windows) | |
| 3391 XtFree ((char *) mw->menu.windows); | |
| 3392 } | |
| 3393 | |
| 3394 static Boolean | |
| 2286 | 3395 XlwMenuSetValues (Widget current, Widget UNUSED (request), Widget new_, |
| 3396 ArgList UNUSED (args), Cardinal *UNUSED (num_args)) | |
| 428 | 3397 { |
| 3398 XlwMenuWidget oldmw = (XlwMenuWidget)current; | |
| 1201 | 3399 XlwMenuWidget newmw = (XlwMenuWidget)new_; |
| 428 | 3400 Boolean redisplay = False; |
| 3401 int i; | |
| 3402 | |
| 3403 if (newmw->menu.contents | |
| 3404 && newmw->menu.contents->contents | |
| 3405 && newmw->menu.contents->contents->change >= VISIBLE_CHANGE) | |
| 3406 redisplay = True; | |
| 3407 | |
| 3408 if (newmw->core.background_pixel != oldmw->core.background_pixel | |
| 3409 || newmw->menu.foreground != oldmw->menu.foreground | |
| 3410 /* For the XEditResource protocol, which may want to change the font. */ | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
3411 #if defined(NEED_MOTIF) && !defined(HAVE_XFT_MENUBARS) |
| 428 | 3412 || newmw->menu.font_list != oldmw->menu.font_list |
| 3413 || newmw->menu.font_list_2 != oldmw->menu.font_list_2 | |
| 3414 || newmw->menu.fallback_font_list != oldmw->menu.fallback_font_list | |
| 3415 #else | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4528
diff
changeset
|
3416 #ifdef HAVE_XFT_MENUBARS |
| 3094 | 3417 || newmw->menu.renderFont != oldmw->menu.renderFont |
| 3418 #else | |
| 428 | 3419 || newmw->menu.font != oldmw->menu.font |
| 3420 #endif | |
| 3094 | 3421 #endif |
| 428 | 3422 ) |
| 3423 { | |
| 3424 release_drawing_gcs (newmw); | |
| 3425 make_drawing_gcs (newmw); | |
| 3426 redisplay = True; | |
| 3427 | |
| 3428 for (i = 0; i < oldmw->menu.windows_length; i++) | |
| 3429 { | |
| 3430 XSetWindowBackground (XtDisplay (oldmw), | |
| 3431 oldmw->menu.windows [i].window, | |
| 3432 newmw->core.background_pixel); | |
| 3433 /* clear windows and generate expose events */ | |
| 3434 XClearArea (XtDisplay (oldmw), oldmw->menu.windows[i].window, | |
| 3435 0, 0, 0, 0, True); | |
| 3436 } | |
| 3437 } | |
| 3438 | |
| 3439 return redisplay; | |
| 3440 } | |
| 3441 | |
| 3442 static void | |
| 3443 XlwMenuResize (Widget w) | |
| 3444 { | |
| 3445 XlwMenuWidget mw = (XlwMenuWidget)w; | |
| 3446 | |
| 3447 mw->menu.windows [0].width = mw->core.width; | |
| 3448 mw->menu.windows [0].height = mw->core.height; | |
| 3449 } | |
| 3450 | |
| 3451 /* Action procedures */ | |
| 3452 static void | |
| 3453 handle_single_motion_event (XlwMenuWidget mw, XMotionEvent *ev, | |
| 3454 Boolean select_p) | |
| 3455 { | |
| 3456 widget_value *val; | |
| 3457 Boolean stay_up; | |
| 3458 int level; | |
| 3459 | |
| 3460 if (!map_event_to_widget_value (mw, ev, &val, &level, &stay_up)) | |
| 3461 { | |
| 3462 /* we wind up here when: (a) the event is in the menubar, (b) the | |
| 3463 event isn't in the menubar or any of the panes, (c) the event is on | |
| 3464 a disabled menu item */ | |
| 3465 pop_new_stack_if_no_contents (mw); | |
| 3466 if (select_p && !stay_up) { | |
| 3467 /* pop down all menus and exit */ | |
| 3468 mw->menu.next_release_must_exit = True; | |
| 3469 set_new_state(mw, (val = NULL), 1); | |
| 3470 } | |
| 3471 } | |
| 3472 else | |
| 3473 { | |
| 3474 /* we wind up here when: (a) the event pops up a pull_right menu, | |
| 3475 (b) a menu item that is not disabled is highlighted */ | |
| 3476 if (select_p && mw->menu.bounce_down | |
| 3477 && close_to_reference_time((Widget)mw, | |
| 3478 mw->menu.menu_bounce_time, | |
| 3479 (XEvent *)ev)) | |
| 3480 { | |
| 3481 /* motion can cause more than one event. Don't bounce right back | |
| 3482 up if we've just bounced down. */ | |
| 3483 val = NULL; | |
| 3484 } | |
| 3485 else if (select_p && mw->menu.bounce_down && | |
| 3486 mw->menu.last_selected_val && | |
| 3487 (mw->menu.last_selected_val == val)) | |
| 3488 { | |
| 3489 val = NULL; /* assigned to mw->last_selected_val below */ | |
| 3490 mw->menu.menu_bounce_time = ev->time; | |
| 3491 /* popdown last menu if we're selecting the same menu item as we did | |
| 3492 last time and the XlwMenu.bounceDown resource is set, if the | |
| 3493 item is on the menubar itself, then exit. */ | |
| 3494 if (level == (mw->menu.popped_up ? 0 : 1)) | |
| 3495 mw->menu.next_release_must_exit = True; | |
| 3496 } | |
| 3497 else | |
| 3498 mw->menu.menu_bounce_time = 0; | |
| 3499 set_new_state (mw, val, level); | |
| 3500 } | |
| 3501 mw->menu.last_selected_val = val; | |
| 3502 remap_menubar (mw); | |
| 3503 | |
| 3504 /* Sync with the display. Makes it feel better on X terms. */ | |
| 3505 XFlush (XtDisplay (mw)); | |
| 3506 } | |
| 3507 | |
| 3508 static void | |
| 3509 handle_motion_event (XlwMenuWidget mw, XMotionEvent *ev, | |
| 3510 Boolean select_p) | |
| 3511 { | |
| 3512 int x = ev->x_root; | |
| 3513 int y = ev->y_root; | |
| 3514 unsigned int state = ev->state; | |
| 3515 XMotionEvent *event= ev, dummy; | |
| 3516 | |
| 3517 /* allow motion events to be generated again */ | |
| 3518 dummy.window = ev->window; | |
| 3519 if (ev->is_hint | |
| 3520 && XQueryPointer (XtDisplay (mw), dummy.window, | |
| 3521 &dummy.root, &dummy.subwindow, | |
| 3522 &dummy.x_root, &dummy.y_root, | |
| 3523 &dummy.x, &dummy.y, | |
| 3524 &dummy.state) | |
| 3525 && dummy.state == state | |
| 3526 && (dummy.x_root != x || dummy.y_root != y)) | |
| 3527 { | |
| 3528 /* don't handle the event twice or that breaks bounce_down. --Stig */ | |
| 3529 dummy.type = ev->type; | |
| 3530 event = &dummy; | |
| 3531 } | |
| 3532 | |
| 3533 lw_menu_accelerate = False; | |
| 3534 handle_single_motion_event (mw, event, select_p); | |
| 3535 } | |
| 3536 | |
| 3537 Time x_focus_timestamp_really_sucks_fix_me_better; | |
| 3538 | |
| 3539 static void | |
| 2286 | 3540 Start (Widget w, XEvent *ev, String *UNUSED (params), |
| 3541 Cardinal *UNUSED (num_params)) | |
| 428 | 3542 { |
| 3543 XlwMenuWidget mw = (XlwMenuWidget)w; | |
| 3544 | |
| 3545 lw_menubar_widget = w; | |
| 3546 | |
| 3547 lw_menu_active = True; | |
| 3548 | |
| 3549 if (!mw->menu.pointer_grabbed) | |
| 3550 { | |
| 3551 mw->menu.menu_post_time = ev->xbutton.time; | |
| 3552 mw->menu.menu_bounce_time = 0; | |
| 3553 mw->menu.next_release_must_exit = True; | |
| 3554 mw->menu.last_selected_val = NULL; | |
| 3555 x_focus_timestamp_really_sucks_fix_me_better = | |
| 3556 ((XButtonPressedEvent*)ev)->time; | |
| 3557 XtCallCallbackList ((Widget)mw, mw->menu.open, NULL); | |
| 3558 | |
| 3559 /* notes the absolute position of the menubar window */ | |
| 3560 mw->menu.windows [0].x = ev->xmotion.x_root - ev->xmotion.x; | |
| 3561 mw->menu.windows [0].y = ev->xmotion.y_root - ev->xmotion.y; | |
| 3562 | |
| 3563 XtGrabPointer ((Widget)mw, False, | |
| 3564 (ButtonMotionMask | ButtonReleaseMask | ButtonPressMask), | |
| 3565 GrabModeAsync, GrabModeAsync, | |
| 3566 None, mw->menu.cursor_shape, | |
| 3567 ((XButtonPressedEvent*)ev)->time); | |
| 3568 mw->menu.pointer_grabbed = True; | |
| 3569 } | |
| 3570 | |
| 3571 /* handles the down like a move, slots are mostly compatible */ | |
| 3572 handle_motion_event (mw, &ev->xmotion, True); | |
| 3573 } | |
| 3574 | |
| 3575 static void | |
| 2286 | 3576 Drag (Widget w, XEvent *ev, String *UNUSED (params), |
| 3577 Cardinal *UNUSED (num_params)) | |
| 428 | 3578 { |
| 3579 XlwMenuWidget mw = (XlwMenuWidget)w; | |
| 3580 handle_motion_event (mw, &ev->xmotion, False); | |
| 3581 } | |
| 3582 | |
| 3583 static void | |
| 2286 | 3584 Select (Widget w, XEvent *ev, String *UNUSED (params), |
| 3585 Cardinal *UNUSED (num_params)) | |
| 428 | 3586 { |
| 3587 XlwMenuWidget mw = (XlwMenuWidget)w; | |
| 3588 widget_value *selected_item = mw->menu.old_stack [mw->menu.old_depth - 1]; | |
| 3589 | |
| 3590 lw_menu_accelerate = False; | |
| 3591 | |
| 3592 /* If user releases the button quickly, without selecting anything, | |
| 3593 after the initial down-click that brought the menu up, | |
| 3594 do nothing. */ | |
| 3595 if ((selected_item == 0 || selected_item->call_data == 0) | |
| 3596 && (!mw->menu.next_release_must_exit | |
| 3597 || close_to_reference_time(w, mw->menu.menu_post_time, ev))) | |
| 3598 { | |
| 3599 mw->menu.next_release_must_exit = False; | |
| 3600 return; | |
| 3601 } | |
| 3602 | |
| 3603 /* pop down everything */ | |
| 3604 mw->menu.new_depth = 1; | |
| 3605 remap_menubar (mw); | |
| 3606 | |
| 3607 /* Destroy() only gets called for popup menus. Menubar widgets aren't | |
| 3608 destroyed when their menu panes get nuked. */ | |
| 3609 if (mw->menu.pointer_grabbed) | |
| 3610 { | |
| 3611 XtUngrabPointer ((Widget)w, ev->xmotion.time); | |
| 3612 mw->menu.pointer_grabbed = False; | |
| 3613 } | |
| 3614 | |
| 3615 if (mw->menu.popped_up) | |
| 3616 { | |
| 3617 mw->menu.popped_up = False; | |
| 3618 XtPopdown (XtParent (mw)); | |
| 3619 } | |
| 3620 | |
| 3621 lw_menu_active = False; | |
| 3622 | |
| 3623 x_focus_timestamp_really_sucks_fix_me_better = | |
| 3624 ((XButtonPressedEvent*)ev)->time; | |
| 3625 | |
| 3626 /* callback */ | |
| 3627 XtCallCallbackList ((Widget) mw, mw->menu.select, (XtPointer) selected_item); | |
| 3628 } | |
| 3629 | |
| 3630 /* Action procedures for keyboard accelerators */ | |
| 3631 | |
| 3632 /* set the menu */ | |
| 3633 void | |
| 3634 xlw_set_menu (Widget w, widget_value *val) | |
| 3635 { | |
| 3636 lw_menubar_widget = w; | |
| 3637 set_new_state ((XlwMenuWidget)w, val, 1); | |
| 3638 } | |
| 3639 | |
| 3640 /* prepare the menu structure via the call-backs */ | |
| 3641 void | |
| 3642 xlw_map_menu (Time t) | |
| 3643 { | |
| 3644 XlwMenuWidget mw = (XlwMenuWidget)lw_menubar_widget; | |
| 3645 | |
| 3646 lw_menu_accelerate = True; | |
| 3647 | |
| 3648 if (!mw->menu.pointer_grabbed) | |
| 3649 { | |
| 3650 XWindowAttributes ret; | |
| 3462 | 3651 Window parent,root = 0UL; |
| 3652 Window *waste = NULL; | |
| 428 | 3653 unsigned int num_waste; |
| 3654 | |
| 3655 lw_menu_active = True; | |
| 3656 | |
| 3657 mw->menu.menu_post_time = t; | |
| 3658 mw->menu.menu_bounce_time = 0; | |
| 3659 | |
| 3660 mw->menu.next_release_must_exit = True; | |
| 3661 mw->menu.last_selected_val = NULL; | |
| 3662 | |
| 3663 XtCallCallbackList ((Widget)mw, mw->menu.open, NULL); | |
| 3664 | |
| 3665 /* do this for keyboards too! */ | |
| 3666 /* notes the absolute position of the menubar window */ | |
| 3667 /* | |
| 3668 mw->menu.windows [0].x = ev->xmotion.x_root - ev->xmotion.x; | |
| 3669 mw->menu.windows [0].y = ev->xmotion.y_root - ev->xmotion.y; | |
| 3670 */ | |
| 3671 | |
| 3672 /* get the geometry of the menubar */ | |
| 3673 | |
| 3674 /* there has to be a better way than this. */ | |
| 3675 | |
| 3676 mw->menu.windows [0].x = 0; | |
| 3677 mw->menu.windows [0].y = 0; | |
| 3678 | |
| 3679 parent = XtWindow (lw_menubar_widget); | |
| 3680 do | |
| 3681 { | |
| 3682 XGetWindowAttributes (XtDisplay (lw_menubar_widget), parent, &ret); | |
| 3683 mw->menu.windows [0].x += ret.x; | |
| 3684 mw->menu.windows [0].y += ret.y; | |
| 3685 | |
| 3686 if (parent) | |
| 3687 XQueryTree (XtDisplay (lw_menubar_widget), parent, &root, &parent, &waste, | |
| 3688 &num_waste); | |
| 3689 if (waste) | |
| 3690 { | |
| 3691 XFree (waste); | |
| 3692 } | |
| 3693 } | |
| 3694 while (parent != root); | |
| 3695 | |
| 3696 XtGrabPointer ((Widget)mw, False, | |
| 3697 (ButtonMotionMask | ButtonReleaseMask | ButtonPressMask), | |
| 3698 GrabModeAsync, GrabModeAsync, | |
| 3699 None, mw->menu.cursor_shape, t); | |
| 3700 mw->menu.pointer_grabbed = True; | |
| 3701 } | |
| 3702 } | |
| 3703 | |
| 3704 /* display the stupid menu already */ | |
| 3705 void | |
| 2286 | 3706 xlw_display_menu (Time UNUSED (t)) |
| 428 | 3707 { |
| 3708 XlwMenuWidget mw = (XlwMenuWidget)lw_menubar_widget; | |
| 3709 | |
| 3710 lw_menu_accelerate = True; | |
| 3711 | |
| 3712 remap_menubar (mw); | |
| 3713 | |
| 3714 /* Sync with the display. Makes it feel better on X terms. */ | |
| 3715 XFlush (XtDisplay (mw)); | |
| 3716 } | |
| 3717 | |
| 3718 /* push a sub menu */ | |
| 3719 void | |
| 3720 xlw_push_menu (widget_value *val) | |
| 3721 { | |
| 3722 push_new_stack ((XlwMenuWidget)lw_menubar_widget, val); | |
| 3723 } | |
| 3724 | |
| 3725 /* pop a sub menu */ | |
| 3726 int | |
| 3727 xlw_pop_menu (void) | |
| 3728 { | |
| 3729 if (((XlwMenuWidget)lw_menubar_widget)->menu.new_depth > 0) | |
| 3730 ((XlwMenuWidget)lw_menubar_widget)->menu.new_depth --; | |
| 3731 else | |
| 3732 return 0; | |
| 3733 return 1; | |
| 3734 } | |
| 3735 | |
| 3736 void | |
| 3737 xlw_kill_menus (widget_value *val) | |
| 3738 { | |
| 3739 XlwMenuWidget mw = (XlwMenuWidget)lw_menubar_widget; | |
| 3740 | |
| 3741 lw_menu_accelerate = False; | |
| 3742 | |
| 3743 mw->menu.new_depth = 1; | |
| 3744 remap_menubar (mw); | |
| 3745 | |
| 3746 if (mw->menu.pointer_grabbed) | |
| 3747 { | |
| 3748 XtUngrabPointer (lw_menubar_widget, CurrentTime); | |
| 3749 mw->menu.pointer_grabbed = False; | |
| 3750 } | |
| 3751 | |
| 3752 lw_menu_active = False; | |
| 3753 XtCallCallbackList (lw_menubar_widget, mw->menu.select, (XtPointer)val); | |
| 3754 } | |
| 3755 | |
| 3756 /* set the menu item */ | |
| 3757 void | |
| 3758 xlw_set_item (widget_value *val) | |
| 3759 { | |
| 3760 if (((XlwMenuWidget)lw_menubar_widget)->menu.new_depth > 0) | |
| 3761 ((XlwMenuWidget) lw_menubar_widget)->menu.new_depth --; | |
| 3762 push_new_stack ((XlwMenuWidget) lw_menubar_widget, val); | |
| 3763 } | |
| 3764 | |
| 3765 /* get either the current entry or a list of all entries in the current submenu */ | |
| 3766 widget_value * | |
| 3767 xlw_get_entries (int allp) | |
| 3768 { | |
| 3769 XlwMenuWidget mw = (XlwMenuWidget)lw_menubar_widget; | |
| 3770 if (allp) | |
| 3771 { | |
| 3772 if (mw->menu.new_depth >= 2) | |
| 3773 return mw->menu.new_stack [mw->menu.new_depth - 2]->contents; | |
| 3774 else | |
| 3775 return mw->menu.new_stack[0]; | |
| 3776 } | |
| 3777 else | |
| 3778 if (mw->menu.new_depth >= 1) | |
| 3779 return mw->menu.new_stack [mw->menu.new_depth - 1]; | |
| 3780 | |
| 3781 return NULL; | |
| 3782 } | |
| 3783 | |
| 3784 int | |
| 3785 xlw_menu_level (void) | |
| 3786 { | |
| 3787 return ((XlwMenuWidget)lw_menubar_widget)->menu.new_depth; | |
| 3788 } | |
| 3789 | |
| 3790 | |
| 3791 /* Special code to pop-up a menu */ | |
| 3792 void | |
| 3793 xlw_pop_up_menu (XlwMenuWidget mw, XButtonPressedEvent *event) | |
| 3794 { | |
| 3795 int x = event->x_root; | |
| 3796 int y = event->y_root; | |
| 3797 int w; | |
| 3798 int h; | |
| 3799 int borderwidth = mw->menu.shadow_thickness; | |
| 3800 Screen* screen = XtScreen (mw); | |
| 3801 | |
| 3802 mw->menu.menu_post_time = event->time; | |
| 3803 mw->menu.menu_bounce_time = 0; | |
| 3804 mw->menu.next_release_must_exit = True; | |
| 3805 mw->menu.last_selected_val = NULL; | |
| 3806 | |
| 3807 XtCallCallbackList ((Widget) mw, mw->menu.open, NULL); | |
| 3808 | |
| 3809 size_menu (mw, 0); | |
| 3810 | |
| 3811 w = mw->menu.windows [0].width; | |
| 3812 h = mw->menu.windows [0].height; | |
| 3813 | |
| 3814 x -= borderwidth; | |
| 3815 y -= borderwidth; | |
| 3816 | |
| 3817 if (x < borderwidth) | |
| 3818 x = borderwidth; | |
| 3819 | |
| 3820 if (x > WidthOfScreen (screen) - w - 2 * borderwidth) | |
| 3821 x = WidthOfScreen (screen) - w - 2 * borderwidth; | |
| 3822 | |
| 3823 if (y < borderwidth) | |
| 3824 y = borderwidth; | |
| 3825 | |
| 3826 if (y > HeightOfScreen (screen) - h - 2 * borderwidth) | |
| 3827 y = HeightOfScreen (screen) - h - 2 * borderwidth; | |
| 3828 | |
| 3829 mw->menu.popped_up = True; | |
| 3830 XtConfigureWidget (XtParent (mw), x, y, w, h, | |
| 3831 XtParent (mw)->core.border_width); | |
| 3832 XtPopup (XtParent (mw), XtGrabExclusive); | |
| 3833 display_menu (mw, 0, False, NULL, NULL, NULL, NULL, NULL); | |
| 3834 if (!mw->menu.pointer_grabbed) | |
| 3835 { | |
| 3836 XtGrabPointer ((Widget)mw, False, | |
| 3837 (ButtonMotionMask | ButtonReleaseMask | ButtonPressMask), | |
| 3838 GrabModeAsync, GrabModeAsync, | |
| 3839 None, mw->menu.cursor_shape, event->time); | |
| 3840 mw->menu.pointer_grabbed = True; | |
| 3841 } | |
| 3842 | |
| 3843 mw->menu.windows [0].x = x + borderwidth; | |
| 3844 mw->menu.windows [0].y = y + borderwidth; | |
| 3845 | |
| 3846 handle_motion_event (mw, (XMotionEvent *) event, True); | |
| 3847 } | |
| 3848 | |
| 3849 /* #### unused */ | |
| 3850 #if 0 | |
| 3851 /* | |
| 3852 * This is a horrible function which should not be needed. | |
| 3853 * use it to put the resize method back the way the XlwMenu | |
| 3854 * class initializer put it. Motif screws with this when | |
| 3855 * the XlwMenu class gets instantiated. | |
| 3856 */ | |
| 3857 void | |
| 3858 xlw_unmunge_class_resize (Widget w) | |
| 3859 { | |
| 3860 if (w->core.widget_class->core_class.resize != XlwMenuResize) | |
| 3861 w->core.widget_class->core_class.resize = XlwMenuResize; | |
| 3862 } | |
| 3863 #endif /* 0 */ | |
| 3864 |