File: | SimpleMenu.c |
Location: | line 1687, column 21 |
Description: | Division by zero |
1 | /* | |||
2 | Copyright 1989, 1994, 1998 The Open Group | |||
3 | ||||
4 | Permission to use, copy, modify, distribute, and sell this software and its | |||
5 | documentation for any purpose is hereby granted without fee, provided that | |||
6 | the above copyright notice appear in all copies and that both that | |||
7 | copyright notice and this permission notice appear in supporting | |||
8 | documentation. | |||
9 | ||||
10 | The above copyright notice and this permission notice shall be included in | |||
11 | all copies or substantial portions of the Software. | |||
12 | ||||
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |||
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |||
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |||
16 | OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN | |||
17 | AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | |||
18 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |||
19 | ||||
20 | Except as contained in this notice, the name of The Open Group shall not be | |||
21 | used in advertising or otherwise to promote the sale, use or other dealings | |||
22 | in this Software without prior written authorization from The Open Group. | |||
23 | */ | |||
24 | ||||
25 | /* | |||
26 | * SimpleMenu.c - Source code file for SimpleMenu widget. | |||
27 | * | |||
28 | * Date: April 3, 1989 | |||
29 | * | |||
30 | * By: Chris D. Peterson | |||
31 | * MIT X Consortium | |||
32 | * kit@expo.lcs.mit.edu | |||
33 | */ | |||
34 | ||||
35 | #ifdef HAVE_CONFIG_H1 | |||
36 | #include <config.h> | |||
37 | #endif | |||
38 | #include <stdio.h> | |||
39 | #include <X11/IntrinsicP.h> | |||
40 | #include <X11/StringDefs.h> | |||
41 | #include <X11/Xmu/Initer.h> | |||
42 | #include <X11/Xaw/Cardinals.h> | |||
43 | #include <X11/Xaw/SimpleMenP.h> | |||
44 | #include <X11/Xaw/SmeBSBP.h> | |||
45 | #include <X11/Xaw/XawInit.h> | |||
46 | #include "Private.h" | |||
47 | ||||
48 | #define streq(a, b)(strcmp((a), (b)) == 0) (strcmp((a), (b)) == 0) | |||
49 | ||||
50 | #define ForAllChildren(smw, childP)for ((childP) = (SmeObject *)(smw)->composite.children; (childP ) < (SmeObject *)((smw)->composite.children + (smw)-> composite.num_children); (childP)++) \ | |||
51 | for ((childP) = (SmeObject *)(smw)->composite.children; \ | |||
52 | (childP) < (SmeObject *)((smw)->composite.children \ | |||
53 | + (smw)->composite.num_children); \ | |||
54 | (childP)++) | |||
55 | ||||
56 | #ifndef OLDXAW | |||
57 | #define SMW_UNMAPPING0x01 0x01 | |||
58 | #define SMW_POPLEFT0x02 0x02 | |||
59 | #endif | |||
60 | ||||
61 | /* | |||
62 | * Class Methods | |||
63 | */ | |||
64 | static void XawSimpleMenuChangeManaged(Widget); | |||
65 | static void XawSimpleMenuClassInitialize(void); | |||
66 | static void XawSimpleMenuClassPartInitialize(WidgetClass); | |||
67 | static XtGeometryResult XawSimpleMenuGeometryManager(Widget, XtWidgetGeometry*, | |||
68 | XtWidgetGeometry*); | |||
69 | static void XawSimpleMenuInitialize(Widget, Widget, ArgList, Cardinal*); | |||
70 | static void XawSimpleMenuRealize(Widget, XtValueMask*, XSetWindowAttributes*); | |||
71 | static void XawSimpleMenuRedisplay(Widget, XEvent*, Region); | |||
72 | static void XawSimpleMenuResize(Widget); | |||
73 | static Boolean XawSimpleMenuSetValues(Widget, Widget, Widget, | |||
74 | ArgList, Cardinal*); | |||
75 | static Boolean XawSimpleMenuSetValuesHook(Widget, ArgList, Cardinal*); | |||
76 | #ifndef OLDXAW | |||
77 | static void PopupSubMenu(SimpleMenuWidget); | |||
78 | static void PopdownSubMenu(SimpleMenuWidget); | |||
79 | static void PopupCB(Widget, XtPointer, XtPointer); | |||
80 | #endif | |||
81 | ||||
82 | /* | |||
83 | * Prototypes | |||
84 | */ | |||
85 | static void AddPositionAction(XtAppContext, XPointer); | |||
86 | static void CalculateNewSize(Widget, Dimension*, Dimension*); | |||
87 | static void ChangeCursorOnGrab(Widget, XtPointer, XtPointer); | |||
88 | static void CreateLabel(Widget); | |||
89 | static SmeObject DoGetEventEntry(Widget, int, int); | |||
90 | static Widget FindMenu(Widget, String); | |||
91 | static SmeObject GetEventEntry(Widget, XEvent*); | |||
92 | static void Layout(Widget, Dimension*, Dimension*); | |||
93 | static void MakeResizeRequest(Widget); | |||
94 | static void MakeSetValuesRequest(Widget, unsigned int, unsigned int); | |||
95 | static void MoveMenu(Widget, int, int); | |||
96 | static void PositionMenu(Widget, XPoint*); | |||
97 | ||||
98 | /* | |||
99 | * Actions | |||
100 | */ | |||
101 | static void Highlight(Widget, XEvent*, String*, Cardinal*); | |||
102 | static void Notify(Widget, XEvent*, String*, Cardinal*); | |||
103 | #ifndef OLDXAW | |||
104 | static void Popdown(Widget, XEvent*, String*, Cardinal*); | |||
105 | #endif | |||
106 | static void PositionMenuAction(Widget, XEvent*, String*, Cardinal*); | |||
107 | static void Unhighlight(Widget, XEvent*, String*, Cardinal*); | |||
108 | ||||
109 | /* | |||
110 | * Initialization | |||
111 | */ | |||
112 | #define offset(field) XtOffsetOf(SimpleMenuRec, simple_menu.field)__builtin_offsetof(SimpleMenuRec, simple_menu.field) | |||
113 | ||||
114 | static XtResource resources[] = { | |||
115 | /* label */ | |||
116 | { | |||
117 | XtNlabel((char*)&XtStrings[429]), | |||
118 | XtCLabel((char*)&XtStrings[1151]), | |||
119 | XtRString((char*)&XtStrings[1797]), | |||
120 | sizeof(String), | |||
121 | offset(label_string), | |||
122 | XtRString((char*)&XtStrings[1797]), | |||
123 | NULL((void*)0) | |||
124 | }, | |||
125 | { | |||
126 | XtNlabelClass"labelClass", | |||
127 | XtCLabelClass"LabelClass", | |||
128 | XtRPointer((char*)&XtStrings[1767]), | |||
129 | sizeof(WidgetClass), | |||
130 | offset(label_class), | |||
131 | XtRImmediate((char*)&XtStrings[1695]), | |||
132 | NULL((void*)0) | |||
133 | }, | |||
134 | ||||
135 | /* layout */ | |||
136 | { | |||
137 | XtNrowHeight"rowHeight", | |||
138 | XtCRowHeight"RowHeight", | |||
139 | XtRDimension((char*)&XtStrings[1618]), | |||
140 | sizeof(Dimension), | |||
141 | offset(row_height), | |||
142 | XtRImmediate((char*)&XtStrings[1695]), | |||
143 | (XtPointer)0 | |||
144 | }, | |||
145 | { | |||
146 | XtNtopMargin"topMargin", | |||
147 | XtCVerticalMargins"VerticalMargins", | |||
148 | XtRDimension((char*)&XtStrings[1618]), | |||
149 | sizeof(Dimension), | |||
150 | offset(top_margin), | |||
151 | XtRImmediate((char*)&XtStrings[1695]), | |||
152 | (XtPointer)0 | |||
153 | }, | |||
154 | { | |||
155 | XtNbottomMargin"bottomMargin", | |||
156 | XtCVerticalMargins"VerticalMargins", | |||
157 | XtRDimension((char*)&XtStrings[1618]), | |||
158 | sizeof(Dimension), | |||
159 | offset(bottom_margin), | |||
160 | XtRImmediate((char*)&XtStrings[1695]), | |||
161 | (XtPointer)0 | |||
162 | }, | |||
163 | #ifndef OLDXAW | |||
164 | { | |||
165 | XtNleftMargin"leftMargin", | |||
166 | XtCHorizontalMargins"HorizontalMargins", | |||
167 | XtRDimension((char*)&XtStrings[1618]), | |||
168 | sizeof(Dimension), | |||
169 | offset(left_margin), | |||
170 | XtRImmediate((char*)&XtStrings[1695]), | |||
171 | (XtPointer)0 | |||
172 | }, | |||
173 | { | |||
174 | XtNrightMargin"rightMargin", | |||
175 | XtCHorizontalMargins"HorizontalMargins", | |||
176 | XtRDimension((char*)&XtStrings[1618]), | |||
177 | sizeof(Dimension), | |||
178 | offset(right_margin), | |||
179 | XtRImmediate((char*)&XtStrings[1695]), | |||
180 | (XtPointer)0 | |||
181 | }, | |||
182 | #endif | |||
183 | ||||
184 | /* misc */ | |||
185 | { | |||
186 | XtNallowShellResize((char*)&XtShellStrings[280]), | |||
187 | XtCAllowShellResize((char*)&XtShellStrings[297]), | |||
188 | XtRBoolean((char*)&XtStrings[1561]), | |||
189 | sizeof(Boolean), | |||
190 | XtOffsetOf(SimpleMenuRec, shell.allow_shell_resize)__builtin_offsetof(SimpleMenuRec, shell.allow_shell_resize), | |||
191 | XtRImmediate((char*)&XtStrings[1695]), | |||
192 | (XtPointer)True1 | |||
193 | }, | |||
194 | { | |||
195 | XtNcursor"cursor", | |||
196 | XtCCursor((char*)&XtStrings[976]), | |||
197 | XtRCursor((char*)&XtStrings[1611]), | |||
198 | sizeof(Cursor), | |||
199 | offset(cursor), | |||
200 | XtRImmediate((char*)&XtStrings[1695]), | |||
201 | (XtPointer)None0L | |||
202 | }, | |||
203 | { | |||
204 | XtNmenuOnScreen"menuOnScreen", | |||
205 | XtCMenuOnScreen"MenuOnScreen", | |||
206 | XtRBoolean((char*)&XtStrings[1561]), | |||
207 | sizeof(Boolean), | |||
208 | offset(menu_on_screen), | |||
209 | XtRImmediate((char*)&XtStrings[1695]), | |||
210 | (XtPointer)True1 | |||
211 | }, | |||
212 | { | |||
213 | XtNpopupOnEntry"popupOnEntry", | |||
214 | XtCPopupOnEntry"PopupOnEntry", | |||
215 | XtRWidget((char*)&XtStrings[1865]), | |||
216 | sizeof(Widget), | |||
217 | offset(popup_entry), | |||
218 | XtRWidget((char*)&XtStrings[1865]), | |||
219 | NULL((void*)0) | |||
220 | }, | |||
221 | { | |||
222 | XtNbackingStore"backingStore", | |||
223 | XtCBackingStore"BackingStore", | |||
224 | XtRBackingStore"BackingStore", | |||
225 | sizeof(int), | |||
226 | offset(backing_store), | |||
227 | XtRImmediate((char*)&XtStrings[1695]), | |||
228 | (XtPointer)(Always2 + WhenMapped1 + NotUseful0) | |||
229 | }, | |||
230 | #ifndef OLDXAW | |||
231 | { | |||
232 | XawNdisplayList"displayList", | |||
233 | XawCDisplayList"DisplayList", | |||
234 | XawRDisplayList"XawDisplayList", | |||
235 | sizeof(XawDisplayList*), | |||
236 | offset(display_list), | |||
237 | XtRImmediate((char*)&XtStrings[1695]), | |||
238 | NULL((void*)0) | |||
239 | }, | |||
240 | #endif | |||
241 | }; | |||
242 | #undef offset | |||
243 | ||||
244 | static char defaultTranslations[] = | |||
245 | "<Enter>:" "highlight()\n" | |||
246 | "<Leave>:" "unhighlight()\n" | |||
247 | "<BtnMotion>:" "highlight()\n" | |||
248 | #ifndef OLDXAW | |||
249 | "<BtnUp>:" "popdown() notify() unhighlight()\n" | |||
250 | #else | |||
251 | "<BtnUp>:" "MenuPopdown() notify() unhighlight()\n" | |||
252 | #endif | |||
253 | ; | |||
254 | ||||
255 | static XtActionsRec actionsList[] = | |||
256 | { | |||
257 | {"notify", Notify}, | |||
258 | {"highlight", Highlight}, | |||
259 | {"unhighlight", Unhighlight}, | |||
260 | #ifndef OLDXAW | |||
261 | {"popdown", Popdown}, | |||
262 | {"set-values", XawSetValuesAction}, | |||
263 | {"get-values", XawGetValuesAction}, | |||
264 | {"declare", XawDeclareAction}, | |||
265 | {"call-proc", XawCallProcAction}, | |||
266 | #endif | |||
267 | }; | |||
268 | ||||
269 | static CompositeClassExtensionRec extension_rec = { | |||
270 | NULL((void*)0), /* next_extension */ | |||
271 | NULLQUARK((XrmQuark) 0), /* record_type */ | |||
272 | XtCompositeExtensionVersion2L, /* version */ | |||
273 | sizeof(CompositeClassExtensionRec), /* record_size */ | |||
274 | True1, /* accepts_objects */ | |||
275 | }; | |||
276 | ||||
277 | #define Superclass(&overrideShellClassRec) (&overrideShellClassRec) | |||
278 | SimpleMenuClassRec simpleMenuClassRec = { | |||
279 | /* core */ | |||
280 | { | |||
281 | (WidgetClass)Superclass(&overrideShellClassRec), /* superclass */ | |||
282 | "SimpleMenu", /* class_name */ | |||
283 | sizeof(SimpleMenuRec), /* size */ | |||
284 | XawSimpleMenuClassInitialize, /* class_initialize */ | |||
285 | XawSimpleMenuClassPartInitialize, /* class_part_initialize */ | |||
286 | False0, /* class_inited */ | |||
287 | XawSimpleMenuInitialize, /* initialize */ | |||
288 | NULL((void*)0), /* initialize_hook */ | |||
289 | XawSimpleMenuRealize, /* realize */ | |||
290 | actionsList, /* actions */ | |||
291 | XtNumber(actionsList)((Cardinal) (sizeof(actionsList) / sizeof(actionsList[0]))), /* num_actions */ | |||
292 | resources, /* resources */ | |||
293 | XtNumber(resources)((Cardinal) (sizeof(resources) / sizeof(resources[0]))), /* num_resources */ | |||
294 | NULLQUARK((XrmQuark) 0), /* xrm_class */ | |||
295 | True1, /* compress_motion */ | |||
296 | True1, /* compress_exposure */ | |||
297 | True1, /* compress_enterleave */ | |||
298 | False0, /* visible_interest */ | |||
299 | NULL((void*)0), /* destroy */ | |||
300 | XawSimpleMenuResize, /* resize */ | |||
301 | XawSimpleMenuRedisplay, /* expose */ | |||
302 | XawSimpleMenuSetValues, /* set_values */ | |||
303 | XawSimpleMenuSetValuesHook, /* set_values_hook */ | |||
304 | XtInheritSetValuesAlmost((XtAlmostProc) _XtInherit), /* set_values_almost */ | |||
305 | NULL((void*)0), /* get_values_hook */ | |||
306 | NULL((void*)0), /* accept_focus */ | |||
307 | XtVersion(11 * 1000 + 6), /* intrinsics version */ | |||
308 | NULL((void*)0), /* callback offsets */ | |||
309 | defaultTranslations, /* tm_table */ | |||
310 | NULL((void*)0), /* query_geometry */ | |||
311 | NULL((void*)0), /* display_accelerator */ | |||
312 | NULL((void*)0), /* extension */ | |||
313 | }, | |||
314 | /* composite */ | |||
315 | { | |||
316 | XawSimpleMenuGeometryManager, /* geometry_manager */ | |||
317 | XawSimpleMenuChangeManaged, /* change_managed */ | |||
318 | XtInheritInsertChild((XtWidgetProc) _XtInherit), /* insert_child */ | |||
319 | XtInheritDeleteChild((XtWidgetProc) _XtInherit), /* delete_child */ | |||
320 | NULL((void*)0), /* extension */ | |||
321 | }, | |||
322 | /* shell */ | |||
323 | { | |||
324 | NULL((void*)0), /* extension */ | |||
325 | }, | |||
326 | /* override */ | |||
327 | { | |||
328 | NULL((void*)0), /* extension */ | |||
329 | }, | |||
330 | /* simple_menu */ | |||
331 | { | |||
332 | NULL((void*)0), /* extension */ | |||
333 | }, | |||
334 | }; | |||
335 | ||||
336 | WidgetClass simpleMenuWidgetClass = (WidgetClass)&simpleMenuClassRec; | |||
337 | ||||
338 | /* | |||
339 | * Implementation | |||
340 | */ | |||
341 | /* | |||
342 | * Function: | |||
343 | * XawSimpleMenuClassInitialize | |||
344 | * | |||
345 | * Description: | |||
346 | * Class Initialize routine, called only once. | |||
347 | */ | |||
348 | static void | |||
349 | XawSimpleMenuClassInitialize(void) | |||
350 | { | |||
351 | XawInitializeWidgetSet(); | |||
352 | XtAddConverter(XtRString((char*)&XtStrings[1797]), XtRBackingStore"BackingStore", XmuCvtStringToBackingStore, | |||
353 | NULL((void*)0), 0); | |||
354 | XtSetTypeConverter(XtRBackingStore"BackingStore", XtRString((char*)&XtStrings[1797]), XmuCvtBackingStoreToString, | |||
355 | NULL((void*)0), 0, XtCacheNone0x001, NULL((void*)0)); | |||
356 | XmuAddInitializer(AddPositionAction, NULL((void*)0)); | |||
357 | } | |||
358 | ||||
359 | /* | |||
360 | * Function: | |||
361 | * XawSimpleMenuClassPartInitialize | |||
362 | * Arguments: wc - the widget class of the subclass. | |||
363 | * | |||
364 | * Description: | |||
365 | * Class Part Initialize routine, called for every subclass. Makes | |||
366 | * sure that the subclasses pick up the extension record. | |||
367 | */ | |||
368 | static void | |||
369 | XawSimpleMenuClassPartInitialize(WidgetClass wc) | |||
370 | { | |||
371 | SimpleMenuWidgetClass smwc = (SimpleMenuWidgetClass)wc; | |||
372 | ||||
373 | /* | |||
374 | * Make sure that our subclass gets the extension rec too | |||
375 | */ | |||
376 | extension_rec.next_extension = smwc->composite_class.extension; | |||
377 | smwc->composite_class.extension = (XtPointer) &extension_rec; | |||
378 | } | |||
379 | ||||
380 | /* | |||
381 | * Function: | |||
382 | * XawSimpleMenuInitialize | |||
383 | * | |||
384 | * Parameters: | |||
385 | * request - widget requested by the argument list | |||
386 | * cnew - new widget with both resource and non resource values | |||
387 | * | |||
388 | * Description: | |||
389 | * Initializes the simple menu widget. | |||
390 | */ | |||
391 | /*ARGSUSED*/ | |||
392 | static void | |||
393 | XawSimpleMenuInitialize(Widget request, Widget cnew, | |||
394 | ArgList args, Cardinal *num_args) | |||
395 | { | |||
396 | SimpleMenuWidget smw = (SimpleMenuWidget)cnew; | |||
397 | Dimension width, height; | |||
398 | ||||
399 | XmuCallInitializers(XtWidgetToApplicationContext(cnew)); | |||
400 | ||||
401 | if (smw->simple_menu.label_class == NULL((void*)0)) | |||
| ||||
402 | smw->simple_menu.label_class = smeBSBObjectClass; | |||
403 | ||||
404 | smw->simple_menu.label = NULL((void*)0); | |||
405 | smw->simple_menu.entry_set = NULL((void*)0); | |||
406 | smw->simple_menu.recursive_set_values = False0; | |||
407 | #ifndef OLDXAW | |||
408 | smw->simple_menu.sub_menu = NULL((void*)0); | |||
409 | smw->simple_menu.state = 0; | |||
410 | ||||
411 | XtAddCallback(cnew, XtNpopupCallback((char*)&XtStrings[534]), PopupCB, NULL((void*)0)); | |||
412 | #endif | |||
413 | ||||
414 | if (smw->simple_menu.label_string != NULL((void*)0)) | |||
415 | CreateLabel(cnew); | |||
416 | ||||
417 | width = height = 0; | |||
418 | CalculateNewSize(cnew, &width, &height); | |||
419 | ||||
420 | smw->simple_menu.menu_width = True1; | |||
421 | ||||
422 | if (XtWidth(smw)(((RectObj)smw)->rectangle.width) == 0) { | |||
423 | smw->simple_menu.menu_width = False0; | |||
424 | XtWidth(smw)(((RectObj)smw)->rectangle.width) = width; | |||
425 | } | |||
426 | ||||
427 | smw->simple_menu.menu_height = True1; | |||
428 | ||||
429 | if (XtHeight(smw)(((RectObj)smw)->rectangle.height) == 0) { | |||
430 | smw->simple_menu.menu_height = False0; | |||
431 | XtHeight(smw)(((RectObj)smw)->rectangle.height) = height; | |||
432 | } | |||
433 | ||||
434 | /* | |||
435 | * Add a popup_callback routine for changing the cursor | |||
436 | */ | |||
437 | XtAddCallback(cnew, XtNpopupCallback((char*)&XtStrings[534]), ChangeCursorOnGrab, NULL((void*)0)); | |||
438 | } | |||
439 | ||||
440 | /* | |||
441 | * Function: | |||
442 | * XawSimpleMenuRedisplay | |||
443 | * | |||
444 | * Parameters: | |||
445 | * w - simple menu widget | |||
446 | * event - X event that caused this redisplay | |||
447 | * region - region the needs to be repainted | |||
448 | * | |||
449 | * Description: | |||
450 | * Redisplays the contents of the widget. | |||
451 | */ | |||
452 | /*ARGSUSED*/ | |||
453 | static void | |||
454 | XawSimpleMenuRedisplay(Widget w, XEvent *event, Region region) | |||
455 | { | |||
456 | SimpleMenuWidget smw = (SimpleMenuWidget)w; | |||
457 | SmeObject *entry; | |||
458 | SmeObjectClass cclass; | |||
459 | ||||
460 | if (region == NULL((void*)0)) | |||
461 | XClearWindow(XtDisplay(w)(((w)->core.screen)->display), XtWindow(w)((w)->core.window)); | |||
462 | ||||
463 | #ifndef OLDXAW | |||
464 | if (smw->simple_menu.display_list) | |||
465 | XawRunDisplayList(w, smw->simple_menu.display_list, event, region); | |||
466 | #endif | |||
467 | ||||
468 | /* | |||
469 | * Check and Paint each of the entries - including the label | |||
470 | */ | |||
471 | ForAllChildren(smw, entry)for ((entry) = (SmeObject *)(smw)->composite.children; (entry ) < (SmeObject *)((smw)->composite.children + (smw)-> composite.num_children); (entry)++) { | |||
472 | if (!XtIsManaged((Widget)*entry)) | |||
473 | continue; | |||
474 | ||||
475 | if (region != NULL((void*)0)) | |||
476 | switch(XRectInRegion(region, XtX(*entry)(((RectObj)*entry)->rectangle.x),XtY(*entry)(((RectObj)*entry)->rectangle.y), | |||
477 | XtWidth(*entry)(((RectObj)*entry)->rectangle.width), XtHeight(*entry)(((RectObj)*entry)->rectangle.height))) { | |||
478 | case RectangleIn1: | |||
479 | case RectanglePart2: | |||
480 | break; | |||
481 | default: | |||
482 | continue; | |||
483 | } | |||
484 | ||||
485 | cclass = (SmeObjectClass)(*entry)->object.widget_class; | |||
486 | ||||
487 | if (cclass->rect_class.expose != NULL((void*)0)) | |||
488 | (cclass->rect_class.expose)((Widget)*entry, NULL((void*)0), NULL((void*)0)); | |||
489 | } | |||
490 | } | |||
491 | ||||
492 | /* | |||
493 | * Function: | |||
494 | * XawSimpleMenuRealize | |||
495 | * | |||
496 | * Parameters: | |||
497 | * w - simple menu widget | |||
498 | * mask - value mask for the window to create | |||
499 | * attrs - attributes for the window to create | |||
500 | * | |||
501 | * Description: | |||
502 | * Realizes the widget. | |||
503 | */ | |||
504 | static void | |||
505 | XawSimpleMenuRealize(Widget w, XtValueMask *mask, XSetWindowAttributes *attrs) | |||
506 | { | |||
507 | SimpleMenuWidget smw = (SimpleMenuWidget)w; | |||
508 | #ifndef OLDXAW | |||
509 | XawPixmap *pixmap; | |||
510 | #endif | |||
511 | ||||
512 | attrs->cursor = smw->simple_menu.cursor; | |||
513 | *mask |= CWCursor(1L<<14); | |||
514 | if (smw->simple_menu.backing_store == Always2 || | |||
515 | smw->simple_menu.backing_store == NotUseful0 || | |||
516 | smw->simple_menu.backing_store == WhenMapped1) { | |||
517 | *mask |= CWBackingStore(1L<<6); | |||
518 | attrs->backing_store = smw->simple_menu.backing_store; | |||
519 | } | |||
520 | else | |||
521 | *mask &= ~CWBackingStore(1L<<6); | |||
522 | ||||
523 | (*Superclass(&overrideShellClassRec)->core_class.realize)(w, mask, attrs); | |||
524 | ||||
525 | #ifndef OLDXAW | |||
526 | if (w->core.background_pixmap > XtUnspecifiedPixmap((Pixmap)2)) { | |||
527 | pixmap = XawPixmapFromXPixmap(w->core.background_pixmap, XtScreen(w)((w)->core.screen), | |||
528 | w->core.colormap, w->core.depth); | |||
529 | if (pixmap && pixmap->mask) | |||
530 | XawReshapeWidget(w, pixmap); | |||
531 | } | |||
532 | #endif | |||
533 | } | |||
534 | ||||
535 | /* | |||
536 | * Function: | |||
537 | * XawSimpleMenuResize | |||
538 | * | |||
539 | * Parameters: | |||
540 | * w - simple menu widget | |||
541 | * | |||
542 | * Description: | |||
543 | * Handle the menu being resized. | |||
544 | */ | |||
545 | static void | |||
546 | XawSimpleMenuResize(Widget w) | |||
547 | { | |||
548 | if (!XtIsRealized(w)(XtWindowOfObject(w) != 0L)) | |||
549 | return; | |||
550 | ||||
551 | Layout(w, NULL((void*)0), NULL((void*)0)); | |||
552 | ||||
553 | XawSimpleMenuRedisplay(w, NULL((void*)0), NULL((void*)0)); | |||
554 | } | |||
555 | ||||
556 | /* | |||
557 | * Function: | |||
558 | * XawSimpleMenuSetValues | |||
559 | * | |||
560 | * Parameters: | |||
561 | * current - current state of the widget | |||
562 | * request - what was requested | |||
563 | * cnew - what the widget will become | |||
564 | * | |||
565 | * Description: | |||
566 | * Relayout the menu when one of the resources is changed. | |||
567 | */ | |||
568 | /*ARGSUSED*/ | |||
569 | static Boolean | |||
570 | XawSimpleMenuSetValues(Widget current, Widget request, Widget cnew, | |||
571 | ArgList args, Cardinal *num_args) | |||
572 | { | |||
573 | SimpleMenuWidget smw_old = (SimpleMenuWidget)current; | |||
574 | SimpleMenuWidget smw_new = (SimpleMenuWidget)cnew; | |||
575 | Boolean ret_val = False0, layout = False0; | |||
576 | ||||
577 | if (!XtIsRealized(current)(XtWindowOfObject(current) != 0L)) | |||
578 | return (False0); | |||
579 | ||||
580 | if (!smw_new->simple_menu.recursive_set_values) { | |||
581 | if (XtWidth(smw_new)(((RectObj)smw_new)->rectangle.width) != XtWidth(smw_old)(((RectObj)smw_old)->rectangle.width)) { | |||
582 | smw_new->simple_menu.menu_width = XtWidth(smw_new)(((RectObj)smw_new)->rectangle.width) != 0; | |||
583 | layout = True1; | |||
584 | } | |||
585 | if (XtHeight(smw_new)(((RectObj)smw_new)->rectangle.height) != XtHeight(smw_old)(((RectObj)smw_old)->rectangle.height)) { | |||
586 | smw_new->simple_menu.menu_height = XtHeight(smw_new)(((RectObj)smw_new)->rectangle.height) != 0; | |||
587 | layout = True1; | |||
588 | } | |||
589 | } | |||
590 | ||||
591 | if (smw_old->simple_menu.cursor != smw_new->simple_menu.cursor) | |||
592 | XDefineCursor(XtDisplay(cnew)(((cnew)->core.screen)->display), XtWindow(cnew)((cnew)->core.window), | |||
593 | smw_new->simple_menu.cursor); | |||
594 | ||||
595 | if (smw_old->simple_menu.label_string !=smw_new->simple_menu.label_string) { | |||
596 | if (smw_new->simple_menu.label_string == NULL((void*)0)) /* Destroy */ | |||
597 | XtDestroyWidget((Widget)smw_old->simple_menu.label); | |||
598 | else if (smw_old->simple_menu.label_string == NULL((void*)0)) /* Create */ | |||
599 | CreateLabel(cnew); | |||
600 | else { /* Change */ | |||
601 | Arg arglist[1]; | |||
602 | ||||
603 | XtSetArg(arglist[0], XtNlabel, smw_new->simple_menu.label_string)((void)( (arglist[0]).name = (((char*)&XtStrings[429])), ( arglist[0]).value = (XtArgVal)(smw_new->simple_menu.label_string ) )); | |||
604 | XtSetValues((Widget)smw_new->simple_menu.label, arglist, ONE((Cardinal)1)); | |||
605 | } | |||
606 | } | |||
607 | ||||
608 | if (smw_old->simple_menu.label_class != smw_new->simple_menu.label_class) | |||
609 | XtAppWarning(XtWidgetToApplicationContext(cnew), | |||
610 | "No Dynamic class change of the SimpleMenu Label."); | |||
611 | ||||
612 | if (smw_old->simple_menu.top_margin != smw_new->simple_menu.top_margin | |||
613 | || smw_old->simple_menu.bottom_margin | |||
614 | != smw_new->simple_menu.bottom_margin) { | |||
615 | layout = True1; | |||
616 | ret_val = True1; | |||
617 | } | |||
618 | ||||
619 | #ifndef OLDXAW | |||
620 | if (smw_old->core.background_pixmap != smw_new->core.background_pixmap) { | |||
621 | XawPixmap *opix, *npix; | |||
622 | ||||
623 | opix = XawPixmapFromXPixmap(smw_old->core.background_pixmap, | |||
624 | XtScreen(smw_old)((smw_old)->core.screen), smw_old->core.colormap, | |||
625 | smw_old->core.depth); | |||
626 | npix = XawPixmapFromXPixmap(smw_new->core.background_pixmap, | |||
627 | XtScreen(smw_new)((smw_new)->core.screen), smw_new->core.colormap, | |||
628 | smw_new->core.depth); | |||
629 | if ((npix && npix->mask) || (opix && opix->mask)) | |||
630 | XawReshapeWidget(cnew, npix); | |||
631 | } | |||
632 | #endif | |||
633 | ||||
634 | if (layout) | |||
635 | Layout(cnew, NULL((void*)0), NULL((void*)0)); | |||
636 | ||||
637 | return (ret_val); | |||
638 | } | |||
639 | ||||
640 | /* | |||
641 | * Function: | |||
642 | * XawSimpleMenuSetValuesHook | |||
643 | * | |||
644 | * Parameters: | |||
645 | * w - menu widget | |||
646 | * arglist - argument list passed to XtSetValues | |||
647 | * num_args - number of args | |||
648 | * | |||
649 | * Description: | |||
650 | * To handle a special case, this is passed the actual arguments. | |||
651 | */ | |||
652 | static Boolean | |||
653 | XawSimpleMenuSetValuesHook(Widget w, ArgList arglist, Cardinal *num_args) | |||
654 | { | |||
655 | Cardinal i; | |||
656 | Dimension width, height; | |||
657 | ||||
658 | width = XtWidth(w)(((RectObj)w)->rectangle.width); | |||
659 | height = XtHeight(w)(((RectObj)w)->rectangle.height); | |||
660 | ||||
661 | for (i = 0 ; i < *num_args ; i++) { | |||
662 | if (streq(arglist[i].name, XtNwidth)(strcmp((arglist[i].name), (((char*)&XtStrings[872]))) == 0)) | |||
663 | width = (Dimension)arglist[i].value; | |||
664 | if (streq(arglist[i].name, XtNheight)(strcmp((arglist[i].name), (((char*)&XtStrings[234]))) == 0)) | |||
665 | height = (Dimension) arglist[i].value; | |||
666 | } | |||
667 | ||||
668 | if (width != XtWidth(w)(((RectObj)w)->rectangle.width) || height != XtHeight(w)(((RectObj)w)->rectangle.height)) | |||
669 | MakeSetValuesRequest(w, width, height); | |||
670 | ||||
671 | return (False0); | |||
672 | } | |||
673 | ||||
674 | /* | |||
675 | * Geometry Management routines | |||
676 | */ | |||
677 | /* | |||
678 | * Function: | |||
679 | * XawSimpleMenuGeometryManager | |||
680 | * | |||
681 | * Parameters: | |||
682 | * w - Menu Entry making the request | |||
683 | * request - requested new geometry | |||
684 | * reply - the allowed geometry. | |||
685 | * | |||
686 | * Description: | |||
687 | * This is the SimpleMenu Widget's Geometry Manager. | |||
688 | * | |||
689 | * Returns: | |||
690 | * XtGeometry{Yes, No, Almost} | |||
691 | */ | |||
692 | static XtGeometryResult | |||
693 | XawSimpleMenuGeometryManager(Widget w, XtWidgetGeometry *request, | |||
694 | XtWidgetGeometry *reply) | |||
695 | { | |||
696 | SimpleMenuWidget smw = (SimpleMenuWidget)XtParent(w)((w)->core.parent); | |||
697 | SmeObject entry = (SmeObject)w; | |||
698 | XtGeometryMask mode = request->request_mode; | |||
699 | XtGeometryResult answer; | |||
700 | Dimension old_height, old_width; | |||
701 | ||||
702 | if (!(mode & CWWidth(1<<2)) && !(mode & CWHeight(1<<3))) | |||
703 | return (XtGeometryNo); | |||
704 | ||||
705 | reply->width = request->width; | |||
706 | reply->height = request->height; | |||
707 | ||||
708 | old_width = XtWidth(entry)(((RectObj)entry)->rectangle.width); | |||
709 | old_height = XtHeight(entry)(((RectObj)entry)->rectangle.height); | |||
710 | ||||
711 | Layout(w, &reply->width, &reply->height); | |||
712 | ||||
713 | /* | |||
714 | * Since we are an override shell and have no parent there is no one to | |||
715 | * ask to see if this geom change is okay, so I am just going to assume | |||
716 | * we can do whatever we want. If you subclass be very careful with this | |||
717 | * assumption, it could bite you. | |||
718 | * | |||
719 | * Chris D. Peterson - Sept. 1989. | |||
720 | */ | |||
721 | if ((!(mode & CWWidth(1<<2)) || reply->width == request->width) | |||
722 | && (!(mode & CWHeight(1<<3)) || reply->height == request->height)) { | |||
723 | if (mode & XtCWQueryOnly(1 << 7)) { /* Actually perform the layout */ | |||
724 | XtWidth(entry)(((RectObj)entry)->rectangle.width) = old_width; | |||
725 | XtHeight(entry)(((RectObj)entry)->rectangle.height) = old_height; | |||
726 | } | |||
727 | else | |||
728 | Layout((Widget)smw, NULL((void*)0), NULL((void*)0)); | |||
729 | answer = XtGeometryDone; | |||
730 | } | |||
731 | else { | |||
732 | XtWidth(entry)(((RectObj)entry)->rectangle.width) = old_width; | |||
733 | XtHeight(entry)(((RectObj)entry)->rectangle.height) = old_height; | |||
734 | ||||
735 | if ((reply->width == request->width && !(mode & CWHeight(1<<3))) | |||
736 | || (reply->height == request->height && !(mode & CWWidth(1<<2))) | |||
737 | || (reply->width == request->width | |||
738 | && reply->height == request->height)) | |||
739 | answer = XtGeometryNo; | |||
740 | else { | |||
741 | answer = XtGeometryAlmost; | |||
742 | reply->request_mode = 0; | |||
743 | if (reply->width != request->width) | |||
744 | reply->request_mode |= CWWidth(1<<2); | |||
745 | if (reply->height != request->height) | |||
746 | reply->request_mode |= CWHeight(1<<3); | |||
747 | } | |||
748 | } | |||
749 | ||||
750 | return (answer); | |||
751 | } | |||
752 | ||||
753 | /* | |||
754 | * Function: | |||
755 | * XawSimpleMenuChangeManaged | |||
756 | * | |||
757 | * Parameters: | |||
758 | * w - simple menu widget | |||
759 | * | |||
760 | * Description: | |||
761 | * Called whenever a new child is managed. | |||
762 | */ | |||
763 | static void | |||
764 | XawSimpleMenuChangeManaged(Widget w) | |||
765 | { | |||
766 | Layout(w, NULL((void*)0), NULL((void*)0)); | |||
767 | } | |||
768 | ||||
769 | /* | |||
770 | * Global Action Routines | |||
771 | * | |||
772 | * These actions routines will be added to the application's | |||
773 | * global action list | |||
774 | */ | |||
775 | /* | |||
776 | * Function: | |||
777 | * PositionMenuAction | |||
778 | * | |||
779 | * Parameters: | |||
780 | * w - a widget (no the simple menu widget) | |||
781 | * event - the event that caused this action | |||
782 | * params - parameters passed to the routine. | |||
783 | * we expect the name of the menu here. | |||
784 | * num_params - "" | |||
785 | * | |||
786 | * Description: | |||
787 | * Positions the simple menu widget. | |||
788 | */ | |||
789 | /*ARGSUSED*/ | |||
790 | static void | |||
791 | PositionMenuAction(Widget w, XEvent *event, | |||
792 | String *params, Cardinal *num_params) | |||
793 | { | |||
794 | Widget menu; | |||
795 | XPoint loc; | |||
796 | ||||
797 | if (*num_params != 1) { | |||
798 | XtAppWarning(XtWidgetToApplicationContext(w), | |||
799 | "SimpleMenuWidget: position menu action expects " | |||
800 | "only one parameter which is the name of the menu."); | |||
801 | return; | |||
802 | } | |||
803 | ||||
804 | if ((menu = FindMenu(w, params[0])) == NULL((void*)0)) { | |||
805 | char error_buf[BUFSIZ1024]; | |||
806 | ||||
807 | snprintf(error_buf, sizeof(error_buf),__builtin___snprintf_chk (error_buf, sizeof(error_buf), 0, __builtin_object_size (error_buf, 2 > 1 ? 1 : 0), "SimpleMenuWidget: could not find menu named %s." , params[0]) | |||
808 | "SimpleMenuWidget: could not find menu named %s.",__builtin___snprintf_chk (error_buf, sizeof(error_buf), 0, __builtin_object_size (error_buf, 2 > 1 ? 1 : 0), "SimpleMenuWidget: could not find menu named %s." , params[0]) | |||
809 | params[0])__builtin___snprintf_chk (error_buf, sizeof(error_buf), 0, __builtin_object_size (error_buf, 2 > 1 ? 1 : 0), "SimpleMenuWidget: could not find menu named %s." , params[0]); | |||
810 | XtAppWarning(XtWidgetToApplicationContext(w), error_buf); | |||
811 | return; | |||
812 | } | |||
813 | ||||
814 | switch (event->type) { | |||
815 | case ButtonPress4: | |||
816 | case ButtonRelease5: | |||
817 | loc.x = event->xbutton.x_root; | |||
818 | loc.y = event->xbutton.y_root; | |||
819 | PositionMenu(menu, &loc); | |||
820 | break; | |||
821 | case EnterNotify7: | |||
822 | case LeaveNotify8: | |||
823 | loc.x = event->xcrossing.x_root; | |||
824 | loc.y = event->xcrossing.y_root; | |||
825 | PositionMenu(menu, &loc); | |||
826 | break; | |||
827 | case MotionNotify6: | |||
828 | loc.x = event->xmotion.x_root; | |||
829 | loc.y = event->xmotion.y_root; | |||
830 | PositionMenu(menu, &loc); | |||
831 | break; | |||
832 | default: | |||
833 | PositionMenu(menu, NULL((void*)0)); | |||
834 | break; | |||
835 | } | |||
836 | } | |||
837 | ||||
838 | /* | |||
839 | * Widget Action Routines | |||
840 | */ | |||
841 | /* | |||
842 | * Function: | |||
843 | * Unhighlight | |||
844 | * | |||
845 | * Parameters: | |||
846 | * w - simple menu widget | |||
847 | * event - event that caused this action | |||
848 | * params - not used | |||
849 | * num_params - "" | |||
850 | * | |||
851 | * Description: | |||
852 | * Unhighlights current entry. | |||
853 | */ | |||
854 | /*ARGSUSED*/ | |||
855 | static void | |||
856 | Unhighlight(Widget w, XEvent *event, String *params, Cardinal *num_params) | |||
857 | { | |||
858 | SimpleMenuWidget smw = (SimpleMenuWidget)w; | |||
859 | SmeObject entry = smw->simple_menu.entry_set; | |||
860 | ||||
861 | if (entry == NULL((void*)0)) | |||
862 | return; | |||
863 | ||||
864 | #ifndef OLDXAW | |||
865 | if (!smw->simple_menu.sub_menu) | |||
866 | #endif | |||
867 | { | |||
868 | SmeObjectClass cclass; | |||
869 | ||||
870 | smw->simple_menu.entry_set = NULL((void*)0); | |||
871 | cclass = (SmeObjectClass)entry->object.widget_class; | |||
872 | (cclass->sme_class.unhighlight)((Widget)entry); | |||
873 | } | |||
874 | } | |||
875 | ||||
876 | /* | |||
877 | * Function: | |||
878 | * Highlight | |||
879 | * | |||
880 | * Parameters: | |||
881 | * w - simple menu widget | |||
882 | * event - event that caused this action | |||
883 | * params - not used | |||
884 | * num_params - "" | |||
885 | * | |||
886 | * Description: | |||
887 | * Highlights current entry. | |||
888 | */ | |||
889 | /*ARGSUSED*/ | |||
890 | static void | |||
891 | Highlight(Widget w, XEvent *event, String *params, Cardinal *num_params) | |||
892 | { | |||
893 | SimpleMenuWidget smw = (SimpleMenuWidget)w; | |||
894 | SmeObject entry; | |||
895 | ||||
896 | if (!XtIsSensitive(w)) | |||
897 | return; | |||
898 | ||||
899 | entry = GetEventEntry(w, event); | |||
900 | ||||
901 | if (entry == smw->simple_menu.entry_set) | |||
902 | return; | |||
903 | ||||
904 | #ifndef OLDXAW | |||
905 | if (!smw->simple_menu.sub_menu) | |||
906 | #endif | |||
907 | Unhighlight(w, event, params, num_params); | |||
908 | ||||
909 | if (entry == NULL((void*)0)) | |||
910 | return; | |||
911 | ||||
912 | if (!XtIsSensitive((Widget)entry)) | |||
913 | return; | |||
914 | ||||
915 | #ifndef OLDXAW | |||
916 | if (smw->simple_menu.sub_menu) | |||
917 | PopdownSubMenu(smw); | |||
918 | #endif | |||
919 | ||||
920 | Unhighlight(w, event, params, num_params); | |||
921 | ||||
922 | #ifndef OLDXAW | |||
923 | if (!(smw->simple_menu.state & SMW_UNMAPPING0x01)) | |||
924 | #endif | |||
925 | { | |||
926 | SmeObjectClass cclass; | |||
927 | ||||
928 | smw->simple_menu.entry_set = entry; | |||
929 | cclass = (SmeObjectClass)entry->object.widget_class; | |||
930 | ||||
931 | (cclass->sme_class.highlight)((Widget)entry); | |||
932 | ||||
933 | #ifndef OLDXAW | |||
934 | if (XtIsSubclass((Widget)entry, smeBSBObjectClass)) | |||
935 | PopupSubMenu(smw); | |||
936 | #endif | |||
937 | } | |||
938 | } | |||
939 | ||||
940 | /* | |||
941 | * Function: | |||
942 | * Notify | |||
943 | * | |||
944 | * Parameters: | |||
945 | * w - simple menu widget | |||
946 | * event - event that caused this action | |||
947 | * params - not used | |||
948 | * num_params - "" | |||
949 | * | |||
950 | * Description: | |||
951 | * Notify user of current entry. | |||
952 | */ | |||
953 | /*ARGSUSED*/ | |||
954 | static void | |||
955 | Notify(Widget w, XEvent *event, String *params, Cardinal *num_params) | |||
956 | { | |||
957 | SmeObject entry; | |||
958 | SmeObjectClass cclass; | |||
959 | ||||
960 | /* may be a propagated event from a sub menu, need to check it */ | |||
961 | if (XtWindow(w)((w)->core.window) != event->xany.window) | |||
962 | return; | |||
963 | entry = GetEventEntry(w, event); | |||
964 | if (entry == NULL((void*)0) || !XtIsSensitive((Widget)entry)) | |||
965 | return; | |||
966 | ||||
967 | cclass = (SmeObjectClass) entry->object.widget_class; | |||
968 | (cclass->sme_class.notify)((Widget)entry); | |||
969 | } | |||
970 | ||||
971 | /* | |||
972 | * Public Functions | |||
973 | */ | |||
974 | /* | |||
975 | * Function: | |||
976 | * XawSimpleMenuAddGlobalActions | |||
977 | * | |||
978 | * Arguments: | |||
979 | * app_con - appcontext | |||
980 | * | |||
981 | * Description: | |||
982 | * Adds the global actions to the simple menu widget. | |||
983 | */ | |||
984 | void | |||
985 | XawSimpleMenuAddGlobalActions(XtAppContext app_con) | |||
986 | { | |||
987 | XtInitializeWidgetClass(simpleMenuWidgetClass); | |||
988 | XmuCallInitializers(app_con); | |||
989 | } | |||
990 | ||||
991 | /* | |||
992 | * Function: | |||
993 | * XawSimpleMenuGetActiveEntry | |||
994 | * | |||
995 | * Parameters: | |||
996 | * w - smw widget | |||
997 | * | |||
998 | * Description: | |||
999 | * Gets the currently active (set) entry. | |||
1000 | * | |||
1001 | * Returns: | |||
1002 | * The currently set entry or NULL if none is set | |||
1003 | */ | |||
1004 | Widget | |||
1005 | XawSimpleMenuGetActiveEntry(Widget w) | |||
1006 | { | |||
1007 | SimpleMenuWidget smw = (SimpleMenuWidget)w; | |||
1008 | ||||
1009 | return ((Widget)smw->simple_menu.entry_set); | |||
1010 | } | |||
1011 | ||||
1012 | /* | |||
1013 | * Function: | |||
1014 | * XawSimpleMenuClearActiveEntry | |||
1015 | * | |||
1016 | * Parameters: | |||
1017 | * w - smw widget | |||
1018 | * | |||
1019 | * Description: | |||
1020 | * Unsets the currently active (set) entry. | |||
1021 | */ | |||
1022 | void | |||
1023 | XawSimpleMenuClearActiveEntry(Widget w) | |||
1024 | { | |||
1025 | SimpleMenuWidget smw = (SimpleMenuWidget)w; | |||
1026 | ||||
1027 | smw->simple_menu.entry_set = NULL((void*)0); | |||
1028 | } | |||
1029 | ||||
1030 | /* | |||
1031 | * Private Functions | |||
1032 | */ | |||
1033 | /* | |||
1034 | * Function: | |||
1035 | * CreateLabel | |||
1036 | * | |||
1037 | * Parameters: | |||
1038 | * w - smw widget | |||
1039 | * | |||
1040 | * Description: | |||
1041 | * Creates the label object and makes sure it is the first child in | |||
1042 | * in the list. | |||
1043 | */ | |||
1044 | static void | |||
1045 | CreateLabel(Widget w) | |||
1046 | { | |||
1047 | SimpleMenuWidget smw = (SimpleMenuWidget)w; | |||
1048 | Widget *child, *next_child; | |||
1049 | int i; | |||
1050 | Arg args[2]; | |||
1051 | ||||
1052 | if (smw->simple_menu.label_string == NULL((void*)0) || | |||
1053 | smw->simple_menu.label != NULL((void*)0)) { | |||
1054 | XtAppWarning(XtWidgetToApplicationContext(w), | |||
1055 | "Xaw Simple Menu Widget: label string is NULL or " | |||
1056 | "label already exists, no label is being created."); | |||
1057 | return; | |||
1058 | } | |||
1059 | ||||
1060 | XtSetArg(args[0], XtNlabel, smw->simple_menu.label_string)((void)( (args[0]).name = (((char*)&XtStrings[429])), (args [0]).value = (XtArgVal)(smw->simple_menu.label_string) )); | |||
1061 | XtSetArg(args[1], XtNjustify, XtJustifyCenter)((void)( (args[1]).name = (((char*)&XtStrings[379])), (args [1]).value = (XtArgVal)(XtJustifyCenter) )); | |||
1062 | smw->simple_menu.label = (SmeObject) | |||
1063 | XtCreateManagedWidget("menuLabel", | |||
1064 | smw->simple_menu.label_class, w, args, TWO((Cardinal)2)); | |||
1065 | ||||
1066 | next_child = NULL((void*)0); | |||
1067 | for (child = smw->composite.children + smw->composite.num_children, | |||
1068 | i = smw->composite.num_children; i > 0; i--, child--) { | |||
1069 | if (next_child != NULL((void*)0)) | |||
1070 | *next_child = *child; | |||
1071 | next_child = child; | |||
1072 | } | |||
1073 | *child = (Widget)smw->simple_menu.label; | |||
1074 | } | |||
1075 | ||||
1076 | /* | |||
1077 | * Function: | |||
1078 | * Layout | |||
1079 | * | |||
1080 | * Arguments: | |||
1081 | * w - See below | |||
1082 | * width_ret - returned width | |||
1083 | * height_ret - returned height | |||
1084 | * | |||
1085 | * Note: | |||
1086 | * if width == NULL || height == NULL then it assumes the you do not care | |||
1087 | * about the return values, and just want a relayout. | |||
1088 | * | |||
1089 | * if this is not the case then it will set width_ret and height_ret | |||
1090 | * to be width and height that the child would get if it were layed out | |||
1091 | * at this time. | |||
1092 | * | |||
1093 | * "w" can be the simple menu widget or any of its object children. | |||
1094 | */ | |||
1095 | static void | |||
1096 | Layout(Widget w, Dimension *width_ret, Dimension *height_ret) | |||
1097 | { | |||
1098 | SmeObject current_entry; | |||
1099 | SimpleMenuWidget smw; | |||
1100 | Dimension width, height; | |||
1101 | Boolean allow_change_size; | |||
1102 | Widget kid; | |||
1103 | Cardinal i, count, n; | |||
1104 | int width_kid, height_kid, tmp_w, tmp_h; | |||
1105 | short vadd, hadd, x_ins, y_ins; | |||
1106 | Dimension *widths; | |||
1107 | ||||
1108 | height = 0; | |||
1109 | ||||
1110 | if (XtIsSubclass(w, simpleMenuWidgetClass)) { | |||
1111 | smw = (SimpleMenuWidget)w; | |||
1112 | current_entry = NULL((void*)0); | |||
1113 | } | |||
1114 | else { | |||
1115 | smw = (SimpleMenuWidget)XtParent(w)((w)->core.parent); | |||
1116 | current_entry = (SmeObject)w; | |||
1117 | } | |||
1118 | ||||
1119 | allow_change_size = (!XtIsRealized((Widget)smw)(XtWindowOfObject((Widget)smw) != 0L) | |||
1120 | || smw->shell.allow_shell_resize); | |||
1121 | ||||
1122 | for (i = smw->simple_menu.label ? 1 : 0; | |||
1123 | i < smw->composite.num_children; | |||
1124 | i++) { | |||
1125 | XtWidgetGeometry preferred; | |||
1126 | ||||
1127 | kid = smw->composite.children[i]; | |||
1128 | if (!XtIsManaged(kid)) | |||
1129 | continue; | |||
1130 | if (smw->simple_menu.row_height != 0) | |||
1131 | XtHeight(kid)(((RectObj)kid)->rectangle.height) = smw->simple_menu.row_height; | |||
1132 | XtQueryGeometry(kid, NULL((void*)0), &preferred); | |||
1133 | if (preferred.request_mode & CWWidth(1<<2)) | |||
1134 | XtWidth(kid)(((RectObj)kid)->rectangle.width) = preferred.width; | |||
1135 | } | |||
1136 | ||||
1137 | if (smw->simple_menu.label | |||
1138 | && XtIsManaged((Widget)smw->simple_menu.label)) { | |||
1139 | XtWidgetGeometry preferred; | |||
1140 | ||||
1141 | kid = (Widget)smw->simple_menu.label; | |||
1142 | XtQueryGeometry(kid, NULL((void*)0), &preferred); | |||
1143 | if (preferred.request_mode & CWWidth(1<<2)) | |||
1144 | XtWidth(kid)(((RectObj)kid)->rectangle.width) = preferred.width; | |||
1145 | if (preferred.request_mode & CWHeight(1<<3)) | |||
1146 | XtHeight(kid)(((RectObj)kid)->rectangle.height) = preferred.height; | |||
1147 | } | |||
1148 | ||||
1149 | /* reset */ | |||
1150 | if (!smw->simple_menu.menu_width) | |||
1151 | XtWidth(smw)(((RectObj)smw)->rectangle.width) = 0; | |||
1152 | if (!smw->simple_menu.menu_height) | |||
1153 | XtHeight(smw)(((RectObj)smw)->rectangle.height) = 0; | |||
1154 | if (!XtWidth(smw)(((RectObj)smw)->rectangle.width) || !XtHeight(smw)(((RectObj)smw)->rectangle.height)) | |||
1155 | MakeResizeRequest((Widget)smw); | |||
1156 | ||||
1157 | widths = (Dimension *)XtMalloc(sizeof(Dimension)); | |||
1158 | #ifndef OLDXAW | |||
1159 | hadd = smw->simple_menu.left_margin; | |||
1160 | #else | |||
1161 | hadd = 0; | |||
1162 | #endif | |||
1163 | vadd = smw->simple_menu.top_margin; | |||
1164 | if (smw->simple_menu.label) | |||
1165 | vadd += XtHeight(smw->simple_menu.label)(((RectObj)smw->simple_menu.label)->rectangle.height); | |||
1166 | ||||
1167 | count = 1; | |||
1168 | width = tmp_w = tmp_h = n = 0; | |||
1169 | height = vadd; | |||
1170 | ||||
1171 | for (i = smw->simple_menu.label ? 1 : 0; | |||
1172 | i < smw->composite.num_children; | |||
1173 | i++) { | |||
1174 | kid = smw->composite.children[i]; | |||
1175 | if (!XtIsManaged(kid)) | |||
1176 | continue; | |||
1177 | width_kid = XtWidth(kid)(((RectObj)kid)->rectangle.width); | |||
1178 | height_kid = XtHeight(kid)(((RectObj)kid)->rectangle.height); | |||
1179 | ||||
1180 | if (n && (height + height_kid + smw->simple_menu.bottom_margin | |||
1181 | > XtHeight(smw)(((RectObj)smw)->rectangle.height))) { | |||
1182 | ++count; | |||
1183 | widths = (Dimension *)XtRealloc((char *)widths, | |||
1184 | sizeof(Dimension) * count); | |||
1185 | widths[count - 1] = width_kid; | |||
1186 | width += tmp_w; | |||
1187 | tmp_w = width_kid; | |||
1188 | height = height_kid + vadd; | |||
1189 | } | |||
1190 | else | |||
1191 | height += height_kid; | |||
1192 | if (height > tmp_h) | |||
1193 | tmp_h = height; | |||
1194 | if (width_kid > tmp_w) | |||
1195 | widths[count - 1] = tmp_w = width_kid; | |||
1196 | ++n; | |||
1197 | } | |||
1198 | ||||
1199 | height = tmp_h + smw->simple_menu.bottom_margin; | |||
1200 | width += tmp_w; | |||
1201 | ||||
1202 | if (smw->simple_menu.label && width < XtWidth(smw->simple_menu.label)(((RectObj)smw->simple_menu.label)->rectangle.width)) { | |||
1203 | float inc; | |||
1204 | ||||
1205 | inc = (XtWidth(smw->simple_menu.label)(((RectObj)smw->simple_menu.label)->rectangle.width) - width) / (float)count; | |||
1206 | width = XtWidth(smw->simple_menu.label)(((RectObj)smw->simple_menu.label)->rectangle.width); | |||
1207 | for (n = 0; n < count; n++) | |||
1208 | widths[n] += inc; | |||
1209 | } | |||
1210 | ||||
1211 | #ifndef OLDXAW | |||
1212 | width += hadd + smw->simple_menu.right_margin; | |||
1213 | #endif | |||
1214 | ||||
1215 | x_ins = n = count = 0; | |||
1216 | tmp_w = widths[0]; | |||
1217 | tmp_h = vadd; | |||
1218 | ||||
1219 | for (i = smw->simple_menu.label ? 1 : 0; | |||
1220 | i < smw->composite.num_children; | |||
1221 | i++) { | |||
1222 | kid = smw->composite.children[i]; | |||
1223 | if (!XtIsManaged(kid)) | |||
1224 | continue; | |||
1225 | ||||
1226 | height_kid = XtHeight(kid)(((RectObj)kid)->rectangle.height); | |||
1227 | ||||
1228 | if (n && (tmp_h + height_kid + smw->simple_menu.bottom_margin | |||
1229 | > XtHeight(smw)(((RectObj)smw)->rectangle.height))) { | |||
1230 | x_ins = tmp_w; | |||
1231 | y_ins = vadd; | |||
1232 | ++count; | |||
1233 | tmp_w += widths[count]; | |||
1234 | tmp_h = height_kid + vadd; | |||
1235 | } | |||
1236 | else { | |||
1237 | y_ins = tmp_h; | |||
1238 | tmp_h += height_kid; | |||
1239 | } | |||
1240 | ++n; | |||
1241 | ||||
1242 | XtX(kid)(((RectObj)kid)->rectangle.x) = x_ins + hadd; | |||
1243 | XtY(kid)(((RectObj)kid)->rectangle.y) = y_ins; | |||
1244 | XtWidth(kid)(((RectObj)kid)->rectangle.width) = widths[count]; | |||
1245 | } | |||
1246 | ||||
1247 | XtFree((char *)widths); | |||
1248 | ||||
1249 | if (allow_change_size) | |||
1250 | MakeSetValuesRequest((Widget) smw, width, height); | |||
1251 | ||||
1252 | if (smw->simple_menu.label) { | |||
1253 | XtX(smw->simple_menu.label)(((RectObj)smw->simple_menu.label)->rectangle.x) = 0; | |||
1254 | XtY(smw->simple_menu.label)(((RectObj)smw->simple_menu.label)->rectangle.y) = smw->simple_menu.top_margin; | |||
1255 | XtWidth(smw->simple_menu.label)(((RectObj)smw->simple_menu.label)->rectangle.width) = XtWidth(smw)(((RectObj)smw)->rectangle.width) | |||
1256 | #ifndef OLDXAW | |||
1257 | - (smw->simple_menu.left_margin + smw->simple_menu.right_margin) | |||
1258 | #endif | |||
1259 | ; | |||
1260 | } | |||
1261 | if (current_entry) { | |||
1262 | if (width_ret) | |||
1263 | *width_ret = XtWidth(current_entry)(((RectObj)current_entry)->rectangle.width); | |||
1264 | if (height_ret) | |||
1265 | *height_ret = XtHeight(current_entry)(((RectObj)current_entry)->rectangle.height); | |||
1266 | } | |||
1267 | } | |||
1268 | ||||
1269 | /* | |||
1270 | * Function: | |||
1271 | * AddPositionAction | |||
1272 | * | |||
1273 | * Parameters: | |||
1274 | * app_con - application context | |||
1275 | * data - (not used) | |||
1276 | * | |||
1277 | * Description: | |||
1278 | * Adds the XawPositionSimpleMenu action to the global | |||
1279 | * action list for this appcon. | |||
1280 | */ | |||
1281 | /*ARGSUSED*/ | |||
1282 | static void | |||
1283 | AddPositionAction(XtAppContext app_con, XPointer data) | |||
1284 | { | |||
1285 | static XtActionsRec pos_action[] = { | |||
1286 | {"XawPositionSimpleMenu", PositionMenuAction}, | |||
1287 | }; | |||
1288 | ||||
1289 | XtAppAddActions(app_con, pos_action, XtNumber(pos_action)((Cardinal) (sizeof(pos_action) / sizeof(pos_action[0])))); | |||
1290 | } | |||
1291 | ||||
1292 | /* | |||
1293 | * Function: | |||
1294 | * FindMenu | |||
1295 | * | |||
1296 | * Parameters: | |||
1297 | * widget - reference widget | |||
1298 | * name - menu widget's name | |||
1299 | * | |||
1300 | * Description: | |||
1301 | * Find the menu give a name and reference widget | |||
1302 | * | |||
1303 | * Returns: | |||
1304 | * The menu widget or NULL. | |||
1305 | */ | |||
1306 | static Widget | |||
1307 | FindMenu(Widget widget, String name) | |||
1308 | { | |||
1309 | Widget w, menu; | |||
1310 | ||||
1311 | for (w = widget; w != NULL((void*)0); w = XtParent(w)((w)->core.parent)) | |||
1312 | if ((menu = XtNameToWidget(w, name)) != NULL((void*)0)) | |||
1313 | return (menu); | |||
1314 | ||||
1315 | return (NULL((void*)0)); | |||
1316 | } | |||
1317 | ||||
1318 | /* | |||
1319 | * Function: | |||
1320 | * PositionMenu | |||
1321 | * | |||
1322 | * Parameters: | |||
1323 | * w - simple menu widget | |||
1324 | * location - pointer the the position or NULL | |||
1325 | * | |||
1326 | * Description: | |||
1327 | * Places the menu | |||
1328 | */ | |||
1329 | static void | |||
1330 | PositionMenu(Widget w, XPoint *location) | |||
1331 | { | |||
1332 | SimpleMenuWidget smw = (SimpleMenuWidget)w; | |||
1333 | SmeObject entry; | |||
1334 | XPoint t_point; | |||
1335 | ||||
1336 | if (location == NULL((void*)0)) { | |||
1337 | Window temp1, temp2; | |||
1338 | int root_x, root_y, tempX, tempY; | |||
1339 | unsigned int tempM; | |||
1340 | ||||
1341 | location = &t_point; | |||
1342 | if (XQueryPointer(XtDisplay(w)(((w)->core.screen)->display), XtWindow(w)((w)->core.window), &temp1, &temp2, | |||
1343 | &root_x, &root_y, &tempX, &tempY, &tempM) == False0) { | |||
1344 | XtAppWarning(XtWidgetToApplicationContext(w), | |||
1345 | "Xaw Simple Menu Widget: " | |||
1346 | "Could not find location of mouse pointer"); | |||
1347 | return; | |||
1348 | } | |||
1349 | location->x = (short) root_x; | |||
1350 | location->y = (short) root_y; | |||
1351 | } | |||
1352 | ||||
1353 | /* | |||
1354 | * The width will not be correct unless it is realized | |||
1355 | */ | |||
1356 | XtRealizeWidget(w); | |||
1357 | ||||
1358 | location->x -= XtWidth(w)(((RectObj)w)->rectangle.width) >> 1; | |||
1359 | ||||
1360 | if (smw->simple_menu.popup_entry == NULL((void*)0)) | |||
1361 | entry = smw->simple_menu.label; | |||
1362 | else | |||
1363 | entry = smw->simple_menu.popup_entry; | |||
1364 | ||||
1365 | if (entry != NULL((void*)0)) | |||
1366 | location->y -= XtY(entry)(((RectObj)entry)->rectangle.y) + (XtHeight(entry)(((RectObj)entry)->rectangle.height) >> 1); | |||
1367 | ||||
1368 | MoveMenu(w, location->x, location->y); | |||
1369 | } | |||
1370 | ||||
1371 | /* | |||
1372 | * Function: | |||
1373 | * MoveMenu | |||
1374 | * | |||
1375 | * Parameters: | |||
1376 | * w - simple menu widget | |||
1377 | * x - current location of the widget | |||
1378 | * y - "" | |||
1379 | * | |||
1380 | * Description: | |||
1381 | * Actually moves the menu, may force it to | |||
1382 | * to be fully visable if menu_on_screen is True. | |||
1383 | */ | |||
1384 | static void | |||
1385 | MoveMenu(Widget w, int x, int y) | |||
1386 | { | |||
1387 | Arg arglist[2]; | |||
1388 | Cardinal num_args = 0; | |||
1389 | SimpleMenuWidget smw = (SimpleMenuWidget)w; | |||
1390 | ||||
1391 | if (smw->simple_menu.menu_on_screen) { | |||
1392 | int width = XtWidth(w)(((RectObj)w)->rectangle.width) + (XtBorderWidth(w)(((RectObj)w)->rectangle.border_width) << 1); | |||
1393 | int height = XtHeight(w)(((RectObj)w)->rectangle.height) + (XtBorderWidth(w)(((RectObj)w)->rectangle.border_width) << 1); | |||
1394 | ||||
1395 | if (x >= 0) { | |||
1396 | int scr_width = WidthOfScreen(XtScreen(w))((((w)->core.screen))->width); | |||
1397 | ||||
1398 | if (x + width > scr_width) | |||
1399 | x = scr_width - width; | |||
1400 | } | |||
1401 | if (x < 0) | |||
1402 | x = 0; | |||
1403 | ||||
1404 | if (y >= 0) { | |||
1405 | int scr_height = HeightOfScreen(XtScreen(w))((((w)->core.screen))->height); | |||
1406 | ||||
1407 | if (y + height > scr_height) | |||
1408 | y = scr_height - height; | |||
1409 | } | |||
1410 | if (y < 0) | |||
1411 | y = 0; | |||
1412 | } | |||
1413 | ||||
1414 | XtSetArg(arglist[num_args], XtNx, x)((void)( (arglist[num_args]).name = (((char*)&XtStrings[885 ])), (arglist[num_args]).value = (XtArgVal)(x) )); num_args++; | |||
1415 | XtSetArg(arglist[num_args], XtNy, y)((void)( (arglist[num_args]).name = (((char*)&XtStrings[887 ])), (arglist[num_args]).value = (XtArgVal)(y) )); num_args++; | |||
1416 | XtSetValues(w, arglist, num_args); | |||
1417 | } | |||
1418 | ||||
1419 | /* | |||
1420 | * Function: | |||
1421 | * ChangeCursorOnGrab | |||
1422 | * | |||
1423 | * Parameters: | |||
1424 | * w - menu widget | |||
1425 | * temp1 - not used | |||
1426 | * temp2 - "" | |||
1427 | * | |||
1428 | * Description: | |||
1429 | * Changes the cursor on the active grab to the one | |||
1430 | * specified in out resource list. | |||
1431 | */ | |||
1432 | /*ARGSUSED*/ | |||
1433 | static void | |||
1434 | ChangeCursorOnGrab(Widget w, XtPointer temp1, XtPointer temp2) | |||
1435 | { | |||
1436 | SimpleMenuWidget smw = (SimpleMenuWidget)w; | |||
1437 | ||||
1438 | /* | |||
1439 | * The event mask here is what is currently in the MIT implementation. | |||
1440 | * There really needs to be a way to get the value of the mask out | |||
1441 | * of the toolkit (CDP 5/26/89). | |||
1442 | */ | |||
1443 | XChangeActivePointerGrab(XtDisplay(w)(((w)->core.screen)->display), ButtonPressMask(1L<<2) | ButtonReleaseMask(1L<<3), | |||
1444 | smw->simple_menu.cursor, | |||
1445 | XtLastTimestampProcessed(XtDisplay(w)(((w)->core.screen)->display))); | |||
1446 | } | |||
1447 | ||||
1448 | /* | |||
1449 | * Function: | |||
1450 | * MakeSetValuesRequest | |||
1451 | * | |||
1452 | * Parameters: | |||
1453 | * w - simple menu widget | |||
1454 | * width - size requested | |||
1455 | * height - "" | |||
1456 | */ | |||
1457 | static void | |||
1458 | MakeSetValuesRequest(Widget w, unsigned int width, unsigned int height) | |||
1459 | { | |||
1460 | SimpleMenuWidget smw = (SimpleMenuWidget)w; | |||
1461 | Arg arglist[2]; | |||
1462 | Cardinal num_args = 0; | |||
1463 | ||||
1464 | if (!smw->simple_menu.recursive_set_values) { | |||
1465 | if (XtWidth(smw)(((RectObj)smw)->rectangle.width) != width || XtHeight(smw)(((RectObj)smw)->rectangle.height) != height) { | |||
1466 | smw->simple_menu.recursive_set_values = True1; | |||
1467 | XtSetArg(arglist[num_args], XtNwidth, width)((void)( (arglist[num_args]).name = (((char*)&XtStrings[872 ])), (arglist[num_args]).value = (XtArgVal)(width) )); num_args++; | |||
1468 | XtSetArg(arglist[num_args], XtNheight, height)((void)( (arglist[num_args]).name = (((char*)&XtStrings[234 ])), (arglist[num_args]).value = (XtArgVal)(height) )); num_args++; | |||
1469 | XtSetValues(w, arglist, num_args); | |||
1470 | } | |||
1471 | else if (XtIsRealized((Widget)smw)(XtWindowOfObject((Widget)smw) != 0L)) | |||
1472 | XawSimpleMenuRedisplay((Widget)smw, NULL((void*)0), NULL((void*)0)); | |||
1473 | } | |||
1474 | smw->simple_menu.recursive_set_values = False0; | |||
1475 | } | |||
1476 | ||||
1477 | static SmeObject | |||
1478 | DoGetEventEntry(Widget w, int x_loc, int y_loc) | |||
1479 | { | |||
1480 | SimpleMenuWidget smw = (SimpleMenuWidget)w; | |||
1481 | SmeObject *entry; | |||
1482 | ||||
1483 | ForAllChildren(smw, entry)for ((entry) = (SmeObject *)(smw)->composite.children; (entry ) < (SmeObject *)((smw)->composite.children + (smw)-> composite.num_children); (entry)++) { | |||
1484 | if (!XtIsManaged((Widget)*entry)) | |||
1485 | continue; | |||
1486 | ||||
1487 | if (x_loc > XtX(*entry)(((RectObj)*entry)->rectangle.x) | |||
1488 | && x_loc <= XtX(*entry)(((RectObj)*entry)->rectangle.x) + XtWidth(*entry)(((RectObj)*entry)->rectangle.width) | |||
1489 | && y_loc > XtY(*entry)(((RectObj)*entry)->rectangle.y) | |||
1490 | && y_loc <= XtY(*entry)(((RectObj)*entry)->rectangle.y) + XtHeight(*entry)(((RectObj)*entry)->rectangle.height)) { | |||
1491 | if (*entry == smw->simple_menu.label) | |||
1492 | return (NULL((void*)0)); /* cannot select the label */ | |||
1493 | else | |||
1494 | return (*entry); | |||
1495 | } | |||
1496 | } | |||
1497 | ||||
1498 | return (NULL((void*)0)); | |||
1499 | } | |||
1500 | ||||
1501 | /* | |||
1502 | * Function: | |||
1503 | * GetEventEntry | |||
1504 | * | |||
1505 | * Parameters: | |||
1506 | * w - simple menu widget | |||
1507 | * event - X event | |||
1508 | * | |||
1509 | * Description: | |||
1510 | * Gets an entry given an event that has X and Y coords. | |||
1511 | * | |||
1512 | * Returns: | |||
1513 | * The entry that this point is in | |||
1514 | */ | |||
1515 | static SmeObject | |||
1516 | GetEventEntry(Widget w, XEvent *event) | |||
1517 | { | |||
1518 | int x_loc, y_loc, x_root; | |||
1519 | SimpleMenuWidget smw = (SimpleMenuWidget)w; | |||
1520 | SmeObject entry; | |||
1521 | int warp, move; | |||
1522 | ||||
1523 | switch (event->type) { | |||
1524 | case MotionNotify6: | |||
1525 | x_loc = event->xmotion.x; | |||
1526 | y_loc = event->xmotion.y; | |||
1527 | x_root = event->xmotion.x_root; | |||
1528 | break; | |||
1529 | case EnterNotify7: | |||
1530 | case LeaveNotify8: | |||
1531 | x_loc = event->xcrossing.x; | |||
1532 | y_loc = event->xcrossing.y; | |||
1533 | x_root = event->xcrossing.x_root; | |||
1534 | break; | |||
1535 | case ButtonPress4: | |||
1536 | case ButtonRelease5: | |||
1537 | x_loc = event->xbutton.x; | |||
1538 | y_loc = event->xbutton.y; | |||
1539 | x_root = event->xbutton.x_root; | |||
1540 | break; | |||
1541 | default: | |||
1542 | XtAppError(XtWidgetToApplicationContext(w), | |||
1543 | "Unknown event type in GetEventEntry()."); | |||
1544 | return (NULL((void*)0)); | |||
1545 | } | |||
1546 | ||||
1547 | if (x_loc < 0 || x_loc >= XtWidth(smw)(((RectObj)smw)->rectangle.width) || | |||
1548 | y_loc < 0 || y_loc >= XtHeight(smw)(((RectObj)smw)->rectangle.height)) | |||
1549 | return (NULL((void*)0)); | |||
1550 | ||||
1551 | /* Move the menu if it's outside the screen, does not check | |||
1552 | * smw->simple_menu.menu_on_screen because menus is bigger than screen | |||
1553 | */ | |||
1554 | if (x_root == WidthOfScreen(XtScreen(w))((((w)->core.screen))->width) - 1 && | |||
1555 | XtX(w)(((RectObj)w)->rectangle.x) + XtWidth(w)(((RectObj)w)->rectangle.width) + (XtBorderWidth(w)(((RectObj)w)->rectangle.border_width)) > x_root) { | |||
1556 | warp = -8; | |||
1557 | if (smw->simple_menu.entry_set) { | |||
1558 | entry = DoGetEventEntry(w, | |||
1559 | XtX(smw->simple_menu.entry_set)(((RectObj)smw->simple_menu.entry_set)->rectangle.x) | |||
1560 | + XtWidth(smw->simple_menu.entry_set)(((RectObj)smw->simple_menu.entry_set)->rectangle.width ) + 1, | |||
1561 | y_loc); | |||
1562 | Unhighlight(w, event, NULL((void*)0), NULL((void*)0)); | |||
1563 | if (entry) { | |||
1564 | warp = -(int)XtWidth(entry)(((RectObj)entry)->rectangle.width) >> 1; | |||
1565 | move = x_loc - XtWidth(entry)(((RectObj)entry)->rectangle.width) - XtX(entry)(((RectObj)entry)->rectangle.x) + XtBorderWidth(w)(((RectObj)w)->rectangle.border_width); | |||
1566 | } | |||
1567 | else { | |||
1568 | warp = 0; | |||
1569 | move = WidthOfScreen(XtScreen(w))((((w)->core.screen))->width) - | |||
1570 | (XtX(w)(((RectObj)w)->rectangle.x) + XtWidth(w)(((RectObj)w)->rectangle.width) + (XtBorderWidth(w)(((RectObj)w)->rectangle.border_width) << 1)); | |||
1571 | } | |||
1572 | } | |||
1573 | else { | |||
1574 | warp = 0; | |||
1575 | move = WidthOfScreen(XtScreen(w))((((w)->core.screen))->width) - | |||
1576 | (XtX(w)(((RectObj)w)->rectangle.x) + XtWidth(w)(((RectObj)w)->rectangle.width) + (XtBorderWidth(w)(((RectObj)w)->rectangle.border_width) << 1)); | |||
1577 | } | |||
1578 | } | |||
1579 | else if (x_root == 0 && XtX(w)(((RectObj)w)->rectangle.x) < 0) { | |||
1580 | warp = 8; | |||
1581 | if (smw->simple_menu.entry_set) { | |||
1582 | entry = DoGetEventEntry(w, XtX(smw->simple_menu.entry_set)(((RectObj)smw->simple_menu.entry_set)->rectangle.x) - 1, | |||
1583 | y_loc); | |||
1584 | Unhighlight(w, event, NULL((void*)0), NULL((void*)0)); | |||
1585 | if (entry) { | |||
1586 | warp = XtWidth(entry)(((RectObj)entry)->rectangle.width) >> 1; | |||
1587 | move = x_loc - XtX(entry)(((RectObj)entry)->rectangle.x); | |||
1588 | } | |||
1589 | else | |||
1590 | move = x_loc + XtBorderWidth(w)(((RectObj)w)->rectangle.border_width); | |||
1591 | } | |||
1592 | else | |||
1593 | move = x_loc + XtBorderWidth(w)(((RectObj)w)->rectangle.border_width); | |||
1594 | } | |||
1595 | else | |||
1596 | move = warp = 0; | |||
1597 | ||||
1598 | if (move) | |||
1599 | XtMoveWidget(w, XtX(w)(((RectObj)w)->rectangle.x) + move, XtY(w)(((RectObj)w)->rectangle.y)); | |||
1600 | if (warp) | |||
1601 | XWarpPointer(XtDisplay(w)(((w)->core.screen)->display), None0L, None0L, 0, 0, 0, 0, warp, 0); | |||
1602 | ||||
1603 | return (DoGetEventEntry(w, x_loc, y_loc)); | |||
1604 | } | |||
1605 | ||||
1606 | static void | |||
1607 | CalculateNewSize(Widget w, Dimension *width_return, Dimension *height_return) | |||
1608 | { | |||
1609 | SimpleMenuWidget xaw = (SimpleMenuWidget)w; | |||
1610 | Widget kid; | |||
1611 | Cardinal i; | |||
1612 | int width_kid, height_kid; | |||
1613 | int width, height, tmp_w, tmp_h, max_dim; | |||
1614 | short vadd, hadd; | |||
1615 | int n, columns, test_h, num_children = 0; | |||
1616 | Boolean try_layout = False0; | |||
1617 | ||||
1618 | #ifndef OLDXAW | |||
1619 | hadd = xaw->simple_menu.left_margin + xaw->simple_menu.right_margin; | |||
1620 | #else | |||
1621 | hadd = 0; | |||
1622 | #endif | |||
1623 | vadd = xaw->simple_menu.top_margin + xaw->simple_menu.bottom_margin; | |||
1624 | if (xaw->simple_menu.label) | |||
1625 | vadd += XtHeight(xaw->simple_menu.label)(((RectObj)xaw->simple_menu.label)->rectangle.height); | |||
1626 | ||||
1627 | if (*height_return) | |||
1628 | max_dim = *height_return; | |||
1629 | else if (!XtHeight(w)(((RectObj)w)->rectangle.height)) { | |||
1630 | max_dim = HeightOfScreen(XtScreen(w))((((w)->core.screen))->height); | |||
1631 | try_layout = True1; | |||
1632 | } | |||
1633 | else | |||
1634 | max_dim = XtHeight(w)(((RectObj)w)->rectangle.height); | |||
1635 | max_dim -= vadd; | |||
1636 | ||||
1637 | width = height = tmp_w = tmp_h = n = test_h = 0; | |||
1638 | columns = 1; | |||
1639 | for (i = xaw->simple_menu.label ? 1 : 0; | |||
1640 | i < xaw->composite.num_children; | |||
1641 | i++) { | |||
1642 | kid = xaw->composite.children[i]; | |||
1643 | if (!XtIsManaged(kid)) | |||
1644 | continue; | |||
1645 | ++num_children; | |||
1646 | width_kid = XtWidth(kid)(((RectObj)kid)->rectangle.width); | |||
1647 | height_kid = XtHeight(kid)(((RectObj)kid)->rectangle.height); | |||
1648 | ||||
1649 | if (try_layout) { | |||
1650 | if (!test_h) | |||
1651 | test_h = height_kid; | |||
1652 | else if (test_h != height_kid) | |||
1653 | try_layout = False0; | |||
1654 | } | |||
1655 | ||||
1656 | if (n && (height + height_kid > max_dim)) { | |||
1657 | ++columns; | |||
1658 | width += tmp_w; | |||
1659 | tmp_w = width_kid; | |||
1660 | height = height_kid; | |||
1661 | } | |||
1662 | else | |||
1663 | height += height_kid; | |||
1664 | if (height > tmp_h) | |||
1665 | tmp_h = height; | |||
1666 | if (width_kid > tmp_w) | |||
1667 | tmp_w = width_kid; | |||
1668 | ++n; | |||
1669 | } | |||
1670 | ||||
1671 | height = tmp_h + vadd; | |||
1672 | width += tmp_w + hadd; | |||
1673 | ||||
1674 | if (xaw->simple_menu.label) | |||
1675 | width = XawMax(width, XtWidth(xaw->simple_menu.label) + hadd)((width) > ((((RectObj)xaw->simple_menu.label)->rectangle .width) + hadd) ? (width) : ((((RectObj)xaw->simple_menu.label )->rectangle.width) + hadd)); | |||
1676 | ||||
1677 | *width_return = width; | |||
1678 | *height_return = height; | |||
1679 | ||||
1680 | if (try_layout && columns > 1 && num_children > 2) { | |||
1681 | int space; | |||
1682 | ||||
1683 | height = test_h * (xaw->simple_menu.label ? | |||
1684 | num_children - 1 : | |||
1685 | num_children); | |||
1686 | ||||
1687 | max_dim -= max_dim % test_h; | |||
| ||||
1688 | space = max_dim - (height % max_dim); | |||
1689 | if (space >= test_h * columns) { | |||
1690 | height = max_dim - space / columns; | |||
1691 | if (height % test_h) | |||
1692 | height += test_h - (height % test_h); | |||
1693 | *height_return = height + vadd; | |||
1694 | CalculateNewSize(w, width_return, height_return); | |||
1695 | } | |||
1696 | } | |||
1697 | } | |||
1698 | ||||
1699 | static void | |||
1700 | MakeResizeRequest(Widget w) | |||
1701 | { | |||
1702 | int tries; | |||
1703 | Dimension width, height; | |||
1704 | ||||
1705 | width = XtWidth(w)(((RectObj)w)->rectangle.width); | |||
1706 | height = XtHeight(w)(((RectObj)w)->rectangle.height); | |||
1707 | ||||
1708 | for (tries = 0; tries < 100; tries++) { | |||
1709 | CalculateNewSize(w, &width, &height); | |||
1710 | if (width == XtWidth(w)(((RectObj)w)->rectangle.width) && height == XtHeight(w)(((RectObj)w)->rectangle.height)) | |||
1711 | break; | |||
1712 | if (XtMakeResizeRequest(w, width, height, &width, &height) == | |||
1713 | XtGeometryNo) | |||
1714 | break; | |||
1715 | } | |||
1716 | } | |||
1717 | ||||
1718 | #ifndef OLDXAW | |||
1719 | static void | |||
1720 | Popdown(Widget w, XEvent *event, String *params, Cardinal *num_params) | |||
1721 | { | |||
1722 | SimpleMenuWidget smw = (SimpleMenuWidget)w; | |||
1723 | ||||
1724 | while (XtParent(w)((w)->core.parent) && | |||
1725 | XtIsSubclass(XtParent(w)((w)->core.parent), simpleMenuWidgetClass)) { | |||
1726 | if (((SimpleMenuWidget)XtParent(w)((w)->core.parent))->simple_menu.sub_menu == (Widget)w) { | |||
1727 | w = XtParent(w)((w)->core.parent); | |||
1728 | smw = (SimpleMenuWidget)w; | |||
1729 | smw->simple_menu.entry_set = NULL((void*)0); | |||
1730 | } | |||
1731 | else | |||
1732 | break; | |||
1733 | } | |||
1734 | ||||
1735 | smw->simple_menu.state |= SMW_UNMAPPING0x01; | |||
1736 | if (smw->simple_menu.sub_menu) | |||
1737 | PopdownSubMenu(smw); | |||
1738 | XtCallActionProc(w, "XtMenuPopdown", event, params, *num_params); | |||
1739 | } | |||
1740 | ||||
1741 | static void | |||
1742 | PopupSubMenu(SimpleMenuWidget smw) | |||
1743 | { | |||
1744 | Arg args[2]; | |||
1745 | Cardinal num_args; | |||
1746 | Widget menu; | |||
1747 | SmeBSBObject entry = (SmeBSBObject)smw->simple_menu.entry_set; | |||
1748 | Position menu_x, menu_y; | |||
1749 | Boolint popleft; | |||
1750 | ||||
1751 | if (entry->sme_bsb.menu_name == NULL((void*)0)) | |||
1752 | return; | |||
1753 | ||||
1754 | if ((menu = FindMenu((Widget)smw, entry->sme_bsb.menu_name)) == NULL((void*)0)) | |||
1755 | return; | |||
1756 | ||||
1757 | smw->simple_menu.sub_menu = menu; | |||
1758 | ||||
1759 | if (!XtIsRealized(menu)(XtWindowOfObject(menu) != 0L)) | |||
1760 | XtRealizeWidget(menu); | |||
1761 | ||||
1762 | popleft = (smw->simple_menu.state & SMW_POPLEFT0x02) != 0; | |||
1763 | ||||
1764 | if (popleft) | |||
1765 | XtTranslateCoords((Widget)smw, -(int)XtWidth(menu)(((RectObj)menu)->rectangle.width), | |||
1766 | XtY(entry)(((RectObj)entry)->rectangle.y) - XtBorderWidth(menu)(((RectObj)menu)->rectangle.border_width), &menu_x, &menu_y); | |||
1767 | else | |||
1768 | XtTranslateCoords((Widget)smw, XtWidth(smw)(((RectObj)smw)->rectangle.width), XtY(entry)(((RectObj)entry)->rectangle.y) | |||
1769 | - XtBorderWidth(menu)(((RectObj)menu)->rectangle.border_width), &menu_x, &menu_y); | |||
1770 | ||||
1771 | if (!popleft && menu_x >= 0) { | |||
1772 | int scr_width = WidthOfScreen(XtScreen(menu))((((menu)->core.screen))->width); | |||
1773 | ||||
1774 | if (menu_x + XtWidth(menu)(((RectObj)menu)->rectangle.width) > scr_width) { | |||
1775 | menu_x -= XtWidth(menu)(((RectObj)menu)->rectangle.width) + XtWidth(smw)(((RectObj)smw)->rectangle.width); | |||
1776 | popleft = True1; | |||
1777 | } | |||
1778 | } | |||
1779 | else if (popleft && menu_x < 0) { | |||
1780 | menu_x = 0; | |||
1781 | popleft = False0; | |||
1782 | } | |||
1783 | if (menu_y >= 0) { | |||
1784 | int scr_height = HeightOfScreen(XtScreen(menu))((((menu)->core.screen))->height); | |||
1785 | ||||
1786 | if (menu_y + XtHeight(menu)(((RectObj)menu)->rectangle.height) > scr_height) | |||
1787 | menu_y = scr_height - XtHeight(menu)(((RectObj)menu)->rectangle.height) - XtBorderWidth(menu)(((RectObj)menu)->rectangle.border_width); | |||
1788 | } | |||
1789 | if (menu_y < 0) | |||
1790 | menu_y = 0; | |||
1791 | ||||
1792 | num_args = 0; | |||
1793 | XtSetArg(args[num_args], XtNx, menu_x)((void)( (args[num_args]).name = (((char*)&XtStrings[885] )), (args[num_args]).value = (XtArgVal)(menu_x) )); num_args++; | |||
1794 | XtSetArg(args[num_args], XtNy, menu_y)((void)( (args[num_args]).name = (((char*)&XtStrings[887] )), (args[num_args]).value = (XtArgVal)(menu_y) )); num_args++; | |||
1795 | XtSetValues(menu, args, num_args); | |||
1796 | ||||
1797 | if (popleft) | |||
1798 | ((SimpleMenuWidget)menu)->simple_menu.state |= SMW_POPLEFT0x02; | |||
1799 | else | |||
1800 | ((SimpleMenuWidget)menu)->simple_menu.state &= ~SMW_POPLEFT0x02; | |||
1801 | ||||
1802 | XtPopup(menu, XtGrabNone); | |||
1803 | } | |||
1804 | ||||
1805 | static void | |||
1806 | PopdownSubMenu(SimpleMenuWidget smw) | |||
1807 | { | |||
1808 | SimpleMenuWidget menu = (SimpleMenuWidget)smw->simple_menu.sub_menu; | |||
1809 | ||||
1810 | if (!menu) | |||
1811 | return; | |||
1812 | ||||
1813 | menu->simple_menu.state |= SMW_UNMAPPING0x01; | |||
1814 | PopdownSubMenu(menu); | |||
1815 | ||||
1816 | XtPopdown((Widget)menu); | |||
1817 | ||||
1818 | smw->simple_menu.sub_menu = NULL((void*)0); | |||
1819 | } | |||
1820 | ||||
1821 | /*ARGSUSED*/ | |||
1822 | static void | |||
1823 | PopupCB(Widget w, XtPointer client_data, XtPointer call_data) | |||
1824 | { | |||
1825 | SimpleMenuWidget smw = (SimpleMenuWidget)w; | |||
1826 | ||||
1827 | smw->simple_menu.state &= ~(SMW_UNMAPPING0x01 | SMW_POPLEFT0x02); | |||
1828 | } | |||
1829 | #endif /* OLDXAW */ |