File: | src/TMstate.c |
Location: | line 1871, column 18 |
Description: | Function call argument is an uninitialized value |
1 | /*********************************************************** | |||
2 | Copyright (c) 1993, Oracle and/or its affiliates. All rights reserved. | |||
3 | ||||
4 | Permission is hereby granted, free of charge, to any person obtaining a | |||
5 | copy of this software and associated documentation files (the "Software"), | |||
6 | to deal in the Software without restriction, including without limitation | |||
7 | the rights to use, copy, modify, merge, publish, distribute, sublicense, | |||
8 | and/or sell copies of the Software, and to permit persons to whom the | |||
9 | Software is furnished to do so, subject to the following conditions: | |||
10 | ||||
11 | The above copyright notice and this permission notice (including the next | |||
12 | paragraph) shall be included in all copies or substantial portions of the | |||
13 | Software. | |||
14 | ||||
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |||
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |||
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |||
18 | THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |||
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING | |||
20 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER | |||
21 | DEALINGS IN THE SOFTWARE. | |||
22 | ||||
23 | Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts. | |||
24 | ||||
25 | All Rights Reserved | |||
26 | ||||
27 | Permission to use, copy, modify, and distribute this software and its | |||
28 | documentation for any purpose and without fee is hereby granted, | |||
29 | provided that the above copyright notice appear in all copies and that | |||
30 | both that copyright notice and this permission notice appear in | |||
31 | supporting documentation, and that the name of Digital not be | |||
32 | used in advertising or publicity pertaining to distribution of the | |||
33 | software without specific, written prior permission. | |||
34 | ||||
35 | DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING | |||
36 | ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL | |||
37 | DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR | |||
38 | ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, | |||
39 | WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, | |||
40 | ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS | |||
41 | SOFTWARE. | |||
42 | ||||
43 | ******************************************************************/ | |||
44 | ||||
45 | /* | |||
46 | ||||
47 | Copyright 1987, 1988, 1994, 1998 The Open Group | |||
48 | ||||
49 | Permission to use, copy, modify, distribute, and sell this software and its | |||
50 | documentation for any purpose is hereby granted without fee, provided that | |||
51 | the above copyright notice appear in all copies and that both that | |||
52 | copyright notice and this permission notice appear in supporting | |||
53 | documentation. | |||
54 | ||||
55 | The above copyright notice and this permission notice shall be included in | |||
56 | all copies or substantial portions of the Software. | |||
57 | ||||
58 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |||
59 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |||
60 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |||
61 | OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN | |||
62 | AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | |||
63 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |||
64 | ||||
65 | Except as contained in this notice, the name of The Open Group shall not be | |||
66 | used in advertising or otherwise to promote the sale, use or other dealings | |||
67 | in this Software without prior written authorization from The Open Group. | |||
68 | ||||
69 | */ | |||
70 | ||||
71 | /* TMstate.c -- maintains the state table of actions for the translation | |||
72 | * manager. | |||
73 | */ | |||
74 | /*LINTLIBRARY*/ | |||
75 | ||||
76 | #ifdef HAVE_CONFIG_H1 | |||
77 | #include <config.h> | |||
78 | #endif | |||
79 | #include "IntrinsicI.h" | |||
80 | ||||
81 | #ifndef TM_NO_MATCH(-2) | |||
82 | #define TM_NO_MATCH(-2) (-2) | |||
83 | #endif /* TM_NO_MATCH */ | |||
84 | ||||
85 | /* forward definitions */ | |||
86 | static StatePtr NewState(TMParseStateTree, TMShortCard, TMShortCard); | |||
87 | ||||
88 | ||||
89 | static String XtNtranslationError = "translationError"; | |||
90 | ||||
91 | #ifndef __EMX__ | |||
92 | TMGlobalRec _XtGlobalTM; /* initialized to zero K&R */ | |||
93 | #else | |||
94 | TMGlobalRec _XtGlobalTM = {0}; | |||
95 | #endif | |||
96 | ||||
97 | #define MatchIncomingEvent(tmEvent, typeMatch, modMatch)(typeMatch->eventType == tmEvent->event.eventType && (typeMatch->matchEvent != ((void*)0)) && (*typeMatch ->matchEvent)(typeMatch, modMatch, tmEvent)) \ | |||
98 | (typeMatch->eventType == tmEvent->event.eventType && \ | |||
99 | (typeMatch->matchEvent != NULL((void*)0)) && \ | |||
100 | (*typeMatch->matchEvent)(typeMatch, modMatch, tmEvent)) | |||
101 | ||||
102 | ||||
103 | #define NumStateTrees(xlations)((translateData->isSimple) ? 1 : (TMComplexXlations(xlations ))->numTrees) \ | |||
104 | ((translateData->isSimple) ? 1 : (TMComplexXlations(xlations))->numTrees) | |||
105 | ||||
106 | static TMShortCard GetBranchHead( | |||
107 | TMParseStateTree parseTree, | |||
108 | TMShortCard typeIndex, | |||
109 | TMShortCard modIndex, | |||
110 | Boolean isDummy) | |||
111 | { | |||
112 | #define TM_BRANCH_HEAD_TBL_ALLOC8 8 | |||
113 | #define TM_BRANCH_HEAD_TBL_REALLOC8 8 | |||
114 | ||||
115 | TMBranchHead branchHead = parseTree->branchHeadTbl; | |||
116 | TMShortCard newSize, i; | |||
117 | ||||
118 | /* | |||
119 | * dummy is used as a place holder for later matching in old-style | |||
120 | * matching behavior. If there's already an entry we don't need | |||
121 | * another dummy. | |||
122 | */ | |||
123 | if (isDummy) { | |||
124 | for (i = 0; i < parseTree->numBranchHeads; i++, branchHead++) { | |||
125 | if ((branchHead->typeIndex == typeIndex) && | |||
126 | (branchHead->modIndex == modIndex)) | |||
127 | return i; | |||
128 | } | |||
129 | } | |||
130 | if (parseTree->numBranchHeads == parseTree->branchHeadTblSize) | |||
131 | { | |||
132 | if (parseTree->branchHeadTblSize == 0) | |||
133 | parseTree->branchHeadTblSize += TM_BRANCH_HEAD_TBL_ALLOC8; | |||
134 | else | |||
135 | parseTree->branchHeadTblSize += | |||
136 | TM_BRANCH_HEAD_TBL_REALLOC8; | |||
137 | newSize = (parseTree->branchHeadTblSize * sizeof(TMBranchHeadRec)); | |||
138 | if (parseTree->isStackBranchHeads) { | |||
139 | TMBranchHead oldBranchHeadTbl = parseTree->branchHeadTbl; | |||
140 | parseTree->branchHeadTbl = (TMBranchHead) __XtMalloc(newSize); | |||
141 | XtMemmove(parseTree->branchHeadTbl, oldBranchHeadTbl, newSize)if ((char *)(parseTree->branchHeadTbl) != (char *)(oldBranchHeadTbl )) { (void) __builtin___memcpy_chk ((char *) (parseTree->branchHeadTbl ), (char *) (oldBranchHeadTbl), (int) (newSize), __builtin_object_size ((char *) (parseTree->branchHeadTbl), 0)); }; | |||
142 | parseTree->isStackBranchHeads = False0; | |||
143 | } | |||
144 | else { | |||
145 | parseTree->branchHeadTbl = (TMBranchHead) | |||
146 | XtRealloc((char *)parseTree->branchHeadTbl, | |||
147 | (parseTree->branchHeadTblSize * | |||
148 | sizeof(TMBranchHeadRec))); | |||
149 | } | |||
150 | } | |||
151 | #ifdef TRACE_TM | |||
152 | LOCK_PROCESSif(_XtProcessLock)(*_XtProcessLock)(); | |||
153 | _XtGlobalTM.numBranchHeads++; | |||
154 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
155 | #endif /* TRACE_TM */ | |||
156 | branchHead = | |||
157 | &parseTree->branchHeadTbl[parseTree->numBranchHeads++]; | |||
158 | branchHead->typeIndex = typeIndex; | |||
159 | branchHead->modIndex = modIndex; | |||
160 | branchHead->more = 0; | |||
161 | branchHead->isSimple = True1; | |||
162 | branchHead->hasActions = False0; | |||
163 | branchHead->hasCycles = False0; | |||
164 | return parseTree->numBranchHeads-1; | |||
165 | } | |||
166 | ||||
167 | TMShortCard _XtGetQuarkIndex( | |||
168 | TMParseStateTree parseTree, | |||
169 | XrmQuark quark) | |||
170 | { | |||
171 | #define TM_QUARK_TBL_ALLOC16 16 | |||
172 | #define TM_QUARK_TBL_REALLOC16 16 | |||
173 | TMShortCard i = parseTree->numQuarks; | |||
174 | ||||
175 | for (i=0; i < parseTree->numQuarks; i++) | |||
176 | if (parseTree->quarkTbl[i] == quark) | |||
177 | break; | |||
178 | ||||
179 | if (i == parseTree->numQuarks) | |||
180 | { | |||
181 | if (parseTree->numQuarks == parseTree->quarkTblSize) | |||
182 | { | |||
183 | TMShortCard newSize; | |||
184 | ||||
185 | if (parseTree->quarkTblSize == 0) | |||
186 | parseTree->quarkTblSize += TM_QUARK_TBL_ALLOC16; | |||
187 | else | |||
188 | parseTree->quarkTblSize += TM_QUARK_TBL_REALLOC16; | |||
189 | newSize = (parseTree->quarkTblSize * sizeof(XrmQuark)); | |||
190 | ||||
191 | if (parseTree->isStackQuarks) { | |||
192 | XrmQuark *oldquarkTbl = parseTree->quarkTbl; | |||
193 | parseTree->quarkTbl = (XrmQuark *) __XtMalloc(newSize); | |||
194 | XtMemmove(parseTree->quarkTbl, oldquarkTbl, newSize)if ((char *)(parseTree->quarkTbl) != (char *)(oldquarkTbl) ) { (void) __builtin___memcpy_chk ((char *) (parseTree->quarkTbl ), (char *) (oldquarkTbl), (int) (newSize), __builtin_object_size ((char *) (parseTree->quarkTbl), 0)); }; | |||
195 | parseTree->isStackQuarks = False0; | |||
196 | } | |||
197 | else { | |||
198 | parseTree->quarkTbl = (XrmQuark *) | |||
199 | XtRealloc((char *)parseTree->quarkTbl, | |||
200 | (parseTree->quarkTblSize * | |||
201 | sizeof(XrmQuark))); | |||
202 | } | |||
203 | } | |||
204 | parseTree->quarkTbl[parseTree->numQuarks++] = quark; | |||
205 | } | |||
206 | return i; | |||
207 | } | |||
208 | ||||
209 | /* | |||
210 | * Get an entry from the parseTrees complex branchHead tbl. If there's none | |||
211 | * there then allocate one | |||
212 | */ | |||
213 | /*ARGSUSED*/ | |||
214 | static TMShortCard GetComplexBranchIndex( | |||
215 | TMParseStateTree parseTree, | |||
216 | TMShortCard typeIndex, | |||
217 | TMShortCard modIndex) | |||
218 | { | |||
219 | #define TM_COMPLEXBRANCH_HEAD_TBL_ALLOC8 8 | |||
220 | #define TM_COMPLEXBRANCH_HEAD_TBL_REALLOC4 4 | |||
221 | ||||
222 | if (parseTree->numComplexBranchHeads == parseTree->complexBranchHeadTblSize) { | |||
223 | TMShortCard newSize; | |||
224 | ||||
225 | if (parseTree->complexBranchHeadTblSize == 0) | |||
226 | parseTree->complexBranchHeadTblSize += TM_COMPLEXBRANCH_HEAD_TBL_ALLOC8; | |||
227 | else | |||
228 | parseTree->complexBranchHeadTblSize += TM_COMPLEXBRANCH_HEAD_TBL_REALLOC4; | |||
229 | ||||
230 | newSize = (parseTree->complexBranchHeadTblSize * sizeof(StatePtr)); | |||
231 | ||||
232 | if (parseTree->isStackComplexBranchHeads) { | |||
233 | StatePtr *oldcomplexBranchHeadTbl | |||
234 | = parseTree->complexBranchHeadTbl; | |||
235 | parseTree->complexBranchHeadTbl = (StatePtr *) __XtMalloc(newSize); | |||
236 | XtMemmove(parseTree->complexBranchHeadTbl,if ((char *)(parseTree->complexBranchHeadTbl) != (char *)( oldcomplexBranchHeadTbl)) { (void) __builtin___memcpy_chk ((char *) (parseTree->complexBranchHeadTbl), (char *) (oldcomplexBranchHeadTbl ), (int) (newSize), __builtin_object_size ((char *) (parseTree ->complexBranchHeadTbl), 0)); } | |||
237 | oldcomplexBranchHeadTbl, newSize)if ((char *)(parseTree->complexBranchHeadTbl) != (char *)( oldcomplexBranchHeadTbl)) { (void) __builtin___memcpy_chk ((char *) (parseTree->complexBranchHeadTbl), (char *) (oldcomplexBranchHeadTbl ), (int) (newSize), __builtin_object_size ((char *) (parseTree ->complexBranchHeadTbl), 0)); }; | |||
238 | parseTree->isStackComplexBranchHeads = False0; | |||
239 | } | |||
240 | else { | |||
241 | parseTree->complexBranchHeadTbl = (StatePtr *) | |||
242 | XtRealloc((char *)parseTree->complexBranchHeadTbl, | |||
243 | (parseTree->complexBranchHeadTblSize * | |||
244 | sizeof(StatePtr))); | |||
245 | } | |||
246 | } | |||
247 | parseTree->complexBranchHeadTbl[parseTree->numComplexBranchHeads++] = NULL((void*)0); | |||
248 | return parseTree->numComplexBranchHeads-1; | |||
249 | } | |||
250 | ||||
251 | TMShortCard _XtGetTypeIndex( | |||
252 | Event *event) | |||
253 | { | |||
254 | TMShortCard i, j = TM_TYPE_SEGMENT_SIZE16; | |||
255 | TMShortCard typeIndex = 0; | |||
256 | TMTypeMatch typeMatch; | |||
257 | TMTypeMatch segment = NULL((void*)0); | |||
258 | ||||
259 | LOCK_PROCESSif(_XtProcessLock)(*_XtProcessLock)(); | |||
260 | for (i = 0; i < _XtGlobalTM.numTypeMatchSegments; i++) { | |||
261 | segment = _XtGlobalTM.typeMatchSegmentTbl[i]; | |||
262 | for (j = 0; | |||
263 | typeIndex < _XtGlobalTM.numTypeMatches && j < TM_TYPE_SEGMENT_SIZE16; | |||
264 | j++, typeIndex++) | |||
265 | { | |||
266 | typeMatch = &(segment[j]); | |||
267 | if (event->eventType == typeMatch->eventType && | |||
268 | event->eventCode == typeMatch->eventCode && | |||
269 | event->eventCodeMask == typeMatch->eventCodeMask && | |||
270 | event->matchEvent == typeMatch->matchEvent) { | |||
271 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
272 | return typeIndex; | |||
273 | } | |||
274 | } | |||
275 | } | |||
276 | ||||
277 | if (j == TM_TYPE_SEGMENT_SIZE16) { | |||
278 | if (_XtGlobalTM.numTypeMatchSegments == _XtGlobalTM.typeMatchSegmentTblSize) { | |||
279 | _XtGlobalTM.typeMatchSegmentTblSize += 4; | |||
280 | _XtGlobalTM.typeMatchSegmentTbl = (TMTypeMatch *) | |||
281 | XtRealloc((char *)_XtGlobalTM.typeMatchSegmentTbl, | |||
282 | (_XtGlobalTM.typeMatchSegmentTblSize * sizeof(TMTypeMatch))); | |||
283 | } | |||
284 | _XtGlobalTM.typeMatchSegmentTbl[_XtGlobalTM.numTypeMatchSegments++] = | |||
285 | segment = (TMTypeMatch) | |||
286 | __XtMalloc(TM_TYPE_SEGMENT_SIZE16 * sizeof(TMTypeMatchRec)); | |||
287 | j = 0; | |||
288 | } | |||
289 | typeMatch = &segment[j]; | |||
290 | typeMatch->eventType = event->eventType; | |||
291 | typeMatch->eventCode = event->eventCode; | |||
292 | typeMatch->eventCodeMask = event->eventCodeMask; | |||
293 | typeMatch->matchEvent = event->matchEvent; | |||
294 | _XtGlobalTM.numTypeMatches++; | |||
295 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
296 | return typeIndex; | |||
297 | } | |||
298 | ||||
299 | static Boolean CompareLateModifiers( | |||
300 | LateBindingsPtr lateBind1P, | |||
301 | LateBindingsPtr lateBind2P) | |||
302 | { | |||
303 | LateBindingsPtr late1P = lateBind1P; | |||
304 | LateBindingsPtr late2P = lateBind2P; | |||
305 | ||||
306 | if (late1P != NULL((void*)0) || late2P != NULL((void*)0)) { | |||
307 | int i = 0; | |||
308 | int j = 0; | |||
309 | if (late1P != NULL((void*)0)) | |||
310 | for (; late1P->keysym != NoSymbol0L; i++) late1P++; | |||
311 | if (late2P != NULL((void*)0)) | |||
312 | for (; late2P->keysym != NoSymbol0L; j++) late2P++; | |||
313 | if (i != j) return FALSE0; | |||
314 | late1P--; | |||
315 | while (late1P >= lateBind1P) { | |||
316 | Boolean last = True1; | |||
317 | for (late2P = lateBind2P + i - 1; | |||
318 | late2P >= lateBind2P; | |||
319 | late2P--) { | |||
320 | if (late1P->keysym == late2P->keysym | |||
321 | && late1P->knot == late2P->knot) { | |||
322 | j--; | |||
323 | if (last) i--; | |||
324 | break; | |||
325 | } | |||
326 | last = False0; | |||
327 | } | |||
328 | late1P--; | |||
329 | } | |||
330 | if (j != 0) return FALSE0; | |||
331 | } | |||
332 | return TRUE1; | |||
333 | } | |||
334 | ||||
335 | TMShortCard _XtGetModifierIndex( | |||
336 | Event *event) | |||
337 | { | |||
338 | TMShortCard i, j = TM_MOD_SEGMENT_SIZE16; | |||
339 | TMShortCard modIndex = 0; | |||
340 | TMModifierMatch modMatch; | |||
341 | TMModifierMatch segment = NULL((void*)0); | |||
342 | ||||
343 | LOCK_PROCESSif(_XtProcessLock)(*_XtProcessLock)(); | |||
344 | for (i = 0; i < _XtGlobalTM.numModMatchSegments; i++) { | |||
345 | segment = _XtGlobalTM.modMatchSegmentTbl[i]; | |||
346 | for (j = 0; | |||
347 | modIndex < _XtGlobalTM.numModMatches && j < TM_MOD_SEGMENT_SIZE16; | |||
348 | j++, modIndex++) { | |||
349 | modMatch = &(segment[j]); | |||
350 | if (event->modifiers == modMatch->modifiers && | |||
351 | event->modifierMask == modMatch->modifierMask && | |||
352 | event->standard == modMatch->standard && | |||
353 | ((!event->lateModifiers && !modMatch->lateModifiers) || | |||
354 | CompareLateModifiers(event->lateModifiers, | |||
355 | modMatch->lateModifiers))) { | |||
356 | /* | |||
357 | * if we found a match then we can free the parser's | |||
358 | * late modifiers. If there isn't a match we use the | |||
359 | * parser's copy | |||
360 | */ | |||
361 | if (event->lateModifiers && | |||
362 | --event->lateModifiers->ref_count == 0) { | |||
363 | XtFree((char *)event->lateModifiers); | |||
364 | event->lateModifiers = NULL((void*)0); | |||
365 | } | |||
366 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
367 | return modIndex; | |||
368 | } | |||
369 | } | |||
370 | } | |||
371 | ||||
372 | if (j == TM_MOD_SEGMENT_SIZE16) { | |||
373 | if (_XtGlobalTM.numModMatchSegments == _XtGlobalTM.modMatchSegmentTblSize) { | |||
374 | _XtGlobalTM.modMatchSegmentTblSize += 4; | |||
375 | _XtGlobalTM.modMatchSegmentTbl = (TMModifierMatch *) | |||
376 | XtRealloc((char *)_XtGlobalTM.modMatchSegmentTbl, | |||
377 | (_XtGlobalTM.modMatchSegmentTblSize * sizeof(TMModifierMatch))); | |||
378 | } | |||
379 | _XtGlobalTM.modMatchSegmentTbl[_XtGlobalTM.numModMatchSegments++] = | |||
380 | segment = (TMModifierMatch) | |||
381 | __XtMalloc(TM_MOD_SEGMENT_SIZE16 * sizeof(TMModifierMatchRec)); | |||
382 | j = 0; | |||
383 | } | |||
384 | modMatch = &segment[j]; | |||
385 | modMatch->modifiers = event->modifiers; | |||
386 | modMatch->modifierMask = event->modifierMask; | |||
387 | modMatch->standard = event->standard; | |||
388 | /* | |||
389 | * We use the parser's copy of the late binding array | |||
390 | */ | |||
391 | #ifdef TRACE_TM | |||
392 | if (event->lateModifiers) | |||
393 | _XtGlobalTM.numLateBindings++; | |||
394 | #endif /* TRACE_TM */ | |||
395 | modMatch->lateModifiers = event->lateModifiers; | |||
396 | _XtGlobalTM.numModMatches++; | |||
397 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
398 | return modIndex; | |||
399 | } | |||
400 | ||||
401 | ||||
402 | /* | |||
403 | * This is called from the SimpleStateHandler to match a stateTree | |||
404 | * entry to the event coming in | |||
405 | */ | |||
406 | static int MatchBranchHead( | |||
407 | TMSimpleStateTree stateTree, | |||
408 | int startIndex, | |||
409 | TMEventPtr event) | |||
410 | { | |||
411 | TMBranchHead branchHead = &stateTree->branchHeadTbl[startIndex]; | |||
412 | int i; | |||
413 | ||||
414 | LOCK_PROCESSif(_XtProcessLock)(*_XtProcessLock)(); | |||
415 | for (i = startIndex; | |||
416 | i < (int)stateTree->numBranchHeads; | |||
417 | i++, branchHead++) | |||
418 | { | |||
419 | TMTypeMatch typeMatch; | |||
420 | TMModifierMatch modMatch; | |||
421 | ||||
422 | typeMatch = TMGetTypeMatch(branchHead->typeIndex)((TMTypeMatch) &((_XtGlobalTM.typeMatchSegmentTbl[((branchHead ->typeIndex) >> 4)])[(branchHead->typeIndex) & 15])); | |||
423 | modMatch = TMGetModifierMatch(branchHead->modIndex)((TMModifierMatch) &((_XtGlobalTM.modMatchSegmentTbl[(branchHead ->modIndex) >> 4])[(branchHead->modIndex) & 15 ])); | |||
424 | ||||
425 | if (MatchIncomingEvent(event, typeMatch, modMatch)(typeMatch->eventType == event->event.eventType && (typeMatch->matchEvent != ((void*)0)) && (*typeMatch ->matchEvent)(typeMatch, modMatch, event))) { | |||
426 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
427 | return i; | |||
428 | } | |||
429 | } | |||
430 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
431 | return (TM_NO_MATCH(-2)); | |||
432 | } | |||
433 | ||||
434 | Boolean _XtRegularMatch( | |||
435 | TMTypeMatch typeMatch, | |||
436 | TMModifierMatch modMatch, | |||
437 | TMEventPtr eventSeq) | |||
438 | { | |||
439 | Modifiers computed =0; | |||
440 | Modifiers computedMask =0; | |||
441 | Boolean resolved = TRUE1; | |||
442 | if (typeMatch->eventCode != (eventSeq->event.eventCode & | |||
443 | typeMatch->eventCodeMask)) return FALSE0; | |||
444 | if (modMatch->lateModifiers != NULL((void*)0)) | |||
445 | resolved = _XtComputeLateBindings(eventSeq->xev->xany.display, | |||
446 | modMatch->lateModifiers, | |||
447 | &computed, &computedMask); | |||
448 | if (!resolved) return FALSE0; | |||
449 | computed |= modMatch->modifiers; | |||
450 | computedMask |= modMatch->modifierMask; | |||
451 | ||||
452 | return ( (computed & computedMask) == | |||
453 | (eventSeq->event.modifiers & computedMask)); | |||
454 | } | |||
455 | ||||
456 | /*ARGSUSED*/ | |||
457 | Boolean _XtMatchAtom( | |||
458 | TMTypeMatch typeMatch, | |||
459 | TMModifierMatch modMatch, | |||
460 | TMEventPtr eventSeq) | |||
461 | { | |||
462 | Atom atom; | |||
463 | ||||
464 | atom = XInternAtom(eventSeq->xev->xany.display, | |||
465 | XrmQuarkToString(typeMatch->eventCode), | |||
466 | False0); | |||
467 | return (atom == eventSeq->event.eventCode); | |||
468 | } | |||
469 | ||||
470 | #define IsOn(vec,idx)((vec)[(idx)>>3] & (1 << ((idx) & 7))) ((vec)[(idx)>>3] & (1 << ((idx) & 7))) | |||
471 | ||||
472 | /* | |||
473 | * there are certain cases where you want to ignore the event and stay | |||
474 | * in the same state. | |||
475 | */ | |||
476 | static Boolean Ignore( | |||
477 | TMEventPtr event) | |||
478 | { | |||
479 | Display *dpy; | |||
480 | XtPerDisplay pd; | |||
481 | ||||
482 | if (event->event.eventType == MotionNotify6) | |||
483 | return TRUE1; | |||
484 | if (!(event->event.eventType == KeyPress2 || | |||
485 | event->event.eventType == KeyRelease3)) | |||
486 | return FALSE0; | |||
487 | dpy = event->xev->xany.display; | |||
488 | pd = _XtGetPerDisplay(dpy); | |||
489 | _InitializeKeysymTables(dpy, pd)if (pd->keysyms == ((void*)0)) _XtBuildKeysymTables(dpy, pd ); | |||
490 | return IsOn(pd->isModifier, event->event.eventCode)((pd->isModifier)[(event->event.eventCode)>>3] & (1 << ((event->event.eventCode) & 7))) ? TRUE1 : FALSE0; | |||
491 | } | |||
492 | ||||
493 | ||||
494 | static void XEventToTMEvent( | |||
495 | XEvent *event, | |||
496 | TMEventPtr tmEvent) | |||
497 | { | |||
498 | tmEvent->xev = event; | |||
499 | tmEvent->event.eventCodeMask = 0; | |||
500 | tmEvent->event.modifierMask = 0; | |||
501 | tmEvent->event.eventType = event->type; | |||
502 | tmEvent->event.lateModifiers = NULL((void*)0); | |||
503 | tmEvent->event.matchEvent = NULL((void*)0); | |||
504 | tmEvent->event.standard = FALSE0; | |||
505 | ||||
506 | switch (event->type) { | |||
507 | ||||
508 | case KeyPress2: | |||
509 | case KeyRelease3: | |||
510 | tmEvent->event.eventCode = event->xkey.keycode; | |||
511 | tmEvent->event.modifiers = event->xkey.state; | |||
512 | break; | |||
513 | ||||
514 | case ButtonPress4: | |||
515 | case ButtonRelease5: | |||
516 | tmEvent->event.eventCode = event->xbutton.button; | |||
517 | tmEvent->event.modifiers = event->xbutton.state; | |||
518 | break; | |||
519 | ||||
520 | case MotionNotify6: | |||
521 | tmEvent->event.eventCode = event->xmotion.is_hint; | |||
522 | tmEvent->event.modifiers = event->xmotion.state; | |||
523 | break; | |||
524 | ||||
525 | case EnterNotify7: | |||
526 | case LeaveNotify8: | |||
527 | tmEvent->event.eventCode = event->xcrossing.mode; | |||
528 | tmEvent->event.modifiers = event->xcrossing.state; | |||
529 | break; | |||
530 | ||||
531 | case PropertyNotify28: | |||
532 | tmEvent->event.eventCode = event->xproperty.atom; | |||
533 | tmEvent->event.modifiers = 0; | |||
534 | break; | |||
535 | ||||
536 | case SelectionClear29: | |||
537 | tmEvent->event.eventCode = event->xselectionclear.selection; | |||
538 | tmEvent->event.modifiers = 0; | |||
539 | break; | |||
540 | ||||
541 | case SelectionRequest30: | |||
542 | tmEvent->event.eventCode = event->xselectionrequest.selection; | |||
543 | tmEvent->event.modifiers = 0; | |||
544 | break; | |||
545 | ||||
546 | case SelectionNotify31: | |||
547 | tmEvent->event.eventCode = event->xselection.selection; | |||
548 | tmEvent->event.modifiers = 0; | |||
549 | break; | |||
550 | ||||
551 | case ClientMessage33: | |||
552 | tmEvent->event.eventCode = event->xclient.message_type; | |||
553 | tmEvent->event.modifiers = 0; | |||
554 | break; | |||
555 | ||||
556 | case MappingNotify34: | |||
557 | tmEvent->event.eventCode = event->xmapping.request; | |||
558 | tmEvent->event.modifiers = 0; | |||
559 | break; | |||
560 | ||||
561 | case FocusIn9: | |||
562 | case FocusOut10: | |||
563 | tmEvent->event.eventCode = event->xfocus.mode; | |||
564 | tmEvent->event.modifiers = 0; | |||
565 | break; | |||
566 | ||||
567 | default: | |||
568 | tmEvent->event.eventCode = 0; | |||
569 | tmEvent->event.modifiers = 0; | |||
570 | break; | |||
571 | } | |||
572 | } | |||
573 | ||||
574 | ||||
575 | static unsigned long GetTime( | |||
576 | XtTM tm, | |||
577 | XEvent *event) | |||
578 | { | |||
579 | switch (event->type) { | |||
580 | ||||
581 | case KeyPress2: | |||
582 | case KeyRelease3: | |||
583 | return event->xkey.time; | |||
584 | ||||
585 | case ButtonPress4: | |||
586 | case ButtonRelease5: | |||
587 | return event->xbutton.time; | |||
588 | ||||
589 | default: | |||
590 | return tm->lastEventTime; | |||
591 | ||||
592 | } | |||
593 | ||||
594 | } | |||
595 | ||||
596 | static void HandleActions( | |||
597 | Widget w, | |||
598 | XEvent *event, | |||
599 | TMSimpleStateTree stateTree, | |||
600 | Widget accelWidget, | |||
601 | XtActionProc *procs, | |||
602 | ActionRec *actions) | |||
603 | { | |||
604 | ActionHook actionHookList; | |||
605 | Widget bindWidget; | |||
606 | ||||
607 | bindWidget = accelWidget ? accelWidget : w; | |||
608 | if (accelWidget && !XtIsSensitive(accelWidget)((((Object)(accelWidget))->object.widget_class->core_class .class_inited & 0x02) ? ((accelWidget)->core.sensitive && (accelWidget)->core.ancestor_sensitive) : 0) && | |||
609 | (event->type == KeyPress2 || event->type == KeyRelease3 || | |||
610 | event->type == ButtonPress4 || event->type == ButtonRelease5 || | |||
611 | event->type == MotionNotify6 || event->type == EnterNotify7 || | |||
612 | event->type == LeaveNotify8 || event->type == FocusIn9 || | |||
613 | event->type == FocusOut10)) | |||
614 | return; | |||
615 | ||||
616 | actionHookList = XtWidgetToApplicationContext(w)->action_hook_list; | |||
617 | ||||
618 | while (actions != NULL((void*)0)) { | |||
619 | /* perform any actions */ | |||
620 | if (procs[actions->idx] != NULL((void*)0)) { | |||
621 | if (actionHookList) { | |||
622 | ActionHook hook; | |||
623 | ActionHook next_hook; | |||
624 | String procName = | |||
625 | XrmQuarkToString(stateTree->quarkTbl[actions->idx] ); | |||
626 | ||||
627 | for (hook = actionHookList; hook != NULL((void*)0); ) { | |||
628 | /* | |||
629 | * Need to cache hook->next because the following action | |||
630 | * proc may free hook via XtRemoveActionHook making | |||
631 | * hook->next invalid upon return from the action proc. | |||
632 | */ | |||
633 | next_hook = hook->next; | |||
634 | (*hook->proc)(bindWidget, | |||
635 | hook->closure, | |||
636 | procName, | |||
637 | event, | |||
638 | actions->params, | |||
639 | &actions->num_params | |||
640 | ); | |||
641 | hook = next_hook; | |||
642 | } | |||
643 | } | |||
644 | (*(procs[actions->idx])) | |||
645 | (bindWidget, event, | |||
646 | actions->params, &actions->num_params ); | |||
647 | } | |||
648 | actions = actions->next; | |||
649 | } | |||
650 | } | |||
651 | ||||
652 | typedef struct { | |||
653 | unsigned int isCycleStart:1; | |||
654 | unsigned int isCycleEnd:1; | |||
655 | TMShortCard typeIndex; | |||
656 | TMShortCard modIndex; | |||
657 | }MatchPairRec, *MatchPair; | |||
658 | ||||
659 | typedef struct TMContextRec{ | |||
660 | TMShortCard numMatches; | |||
661 | TMShortCard maxMatches; | |||
662 | MatchPair matches; | |||
663 | }TMContextRec, *TMContext; | |||
664 | ||||
665 | static TMContextRec contextCache[2]; | |||
666 | ||||
667 | #define GetContextPtr(tm)((TMContext *)&(tm->current_state)) ((TMContext *)&(tm->current_state)) | |||
668 | ||||
669 | #define TM_CONTEXT_MATCHES_ALLOC4 4 | |||
670 | #define TM_CONTEXT_MATCHES_REALLOC2 2 | |||
671 | ||||
672 | static void PushContext( | |||
673 | TMContext *contextPtr, | |||
674 | StatePtr newState) | |||
675 | { | |||
676 | TMContext context = *contextPtr; | |||
677 | ||||
678 | LOCK_PROCESSif(_XtProcessLock)(*_XtProcessLock)(); | |||
679 | if (context == NULL((void*)0)) | |||
680 | { | |||
681 | if (contextCache[0].numMatches == 0) | |||
682 | context = &contextCache[0]; | |||
683 | else if (contextCache[1].numMatches == 0) | |||
684 | context = &contextCache[1]; | |||
685 | if (!context) | |||
686 | { | |||
687 | context = XtNew(TMContextRec)((TMContextRec *) XtMalloc((unsigned) sizeof(TMContextRec))); | |||
688 | context->matches = NULL((void*)0); | |||
689 | context->numMatches = | |||
690 | context->maxMatches = 0; | |||
691 | } | |||
692 | } | |||
693 | if (context->numMatches && | |||
694 | context->matches[context->numMatches-1].isCycleEnd) | |||
695 | { | |||
696 | TMShortCard i; | |||
697 | for (i = 0; | |||
698 | i < context->numMatches && | |||
699 | !(context->matches[i].isCycleStart); | |||
700 | i++){}; | |||
701 | if (i < context->numMatches) | |||
702 | context->numMatches = i+1; | |||
703 | #ifdef DEBUG | |||
704 | else | |||
705 | XtWarning("pushing cycle end with no cycle start"); | |||
706 | #endif /* DEBUG */ | |||
707 | } | |||
708 | else | |||
709 | { | |||
710 | if (context->numMatches == context->maxMatches) | |||
711 | { | |||
712 | if (context->maxMatches == 0) | |||
713 | context->maxMatches += TM_CONTEXT_MATCHES_ALLOC4; | |||
714 | else | |||
715 | context->maxMatches += TM_CONTEXT_MATCHES_REALLOC2; | |||
716 | context->matches = (MatchPairRec *) | |||
717 | XtRealloc((char *)context->matches, | |||
718 | context->maxMatches * sizeof(MatchPairRec)); | |||
719 | } | |||
720 | context->matches[context->numMatches].isCycleStart = newState->isCycleStart; | |||
721 | context->matches[context->numMatches].isCycleEnd = newState->isCycleEnd; | |||
722 | context->matches[context->numMatches].typeIndex = newState->typeIndex; | |||
723 | context->matches[context->numMatches++].modIndex = newState->modIndex; | |||
724 | *contextPtr = context; | |||
725 | } | |||
726 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
727 | } | |||
728 | ||||
729 | static void FreeContext( | |||
730 | TMContext *contextPtr) | |||
731 | { | |||
732 | TMContext context = NULL((void*)0); | |||
733 | ||||
734 | LOCK_PROCESSif(_XtProcessLock)(*_XtProcessLock)(); | |||
735 | ||||
736 | if (&contextCache[0] == *contextPtr) | |||
737 | context = &contextCache[0]; | |||
738 | else if (&contextCache[1] == *contextPtr) | |||
739 | context = &contextCache[1]; | |||
740 | ||||
741 | if (context) | |||
742 | context->numMatches = 0; | |||
743 | else if (*contextPtr) | |||
744 | { | |||
745 | if ((*contextPtr)->matches) | |||
746 | XtFree ((char *) ((*contextPtr)->matches)); | |||
747 | XtFree((char *)*contextPtr); | |||
748 | } | |||
749 | ||||
750 | *contextPtr = NULL((void*)0); | |||
751 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
752 | } | |||
753 | ||||
754 | static int MatchExact( | |||
755 | TMSimpleStateTree stateTree, | |||
756 | int startIndex, | |||
757 | TMShortCard typeIndex, | |||
758 | TMShortCard modIndex) | |||
759 | { | |||
760 | TMBranchHead branchHead = &(stateTree->branchHeadTbl[startIndex]); | |||
761 | int i; | |||
762 | ||||
763 | for (i = startIndex; | |||
764 | i < (int)stateTree->numBranchHeads; | |||
765 | i++, branchHead++) | |||
766 | { | |||
767 | if ((branchHead->typeIndex == typeIndex) && | |||
768 | (branchHead->modIndex == modIndex)) | |||
769 | return i; | |||
770 | } | |||
771 | return (TM_NO_MATCH(-2)); | |||
772 | } | |||
773 | ||||
774 | ||||
775 | ||||
776 | static void HandleSimpleState( | |||
777 | Widget w, | |||
778 | XtTM tmRecPtr, | |||
779 | TMEventRec *curEventPtr) | |||
780 | { | |||
781 | XtTranslations xlations = tmRecPtr->translations; | |||
782 | TMSimpleStateTree stateTree; | |||
783 | TMContext *contextPtr = GetContextPtr(tmRecPtr)((TMContext *)&(tmRecPtr->current_state)); | |||
784 | TMShortCard i; | |||
785 | ActionRec *actions = NULL((void*)0); | |||
786 | Boolean matchExact = False0; | |||
787 | Boolean match = False0; | |||
788 | StatePtr complexMatchState = NULL((void*)0); | |||
789 | int currIndex; | |||
790 | TMShortCard typeIndex = 0, modIndex = 0; | |||
791 | int matchTreeIndex = TM_NO_MATCH(-2); | |||
792 | ||||
793 | LOCK_PROCESSif(_XtProcessLock)(*_XtProcessLock)(); | |||
794 | stateTree = (TMSimpleStateTree)xlations->stateTreeTbl[0]; | |||
795 | ||||
796 | for (i = 0; | |||
797 | ((!match || !complexMatchState) && (i < xlations->numStateTrees)); | |||
798 | i++){ | |||
799 | stateTree = (TMSimpleStateTree)xlations->stateTreeTbl[i]; | |||
800 | currIndex = -1; | |||
801 | /* | |||
802 | * don't process this tree if we're only looking for a | |||
803 | * complexMatchState and there are no complex states | |||
804 | */ | |||
805 | while (!(match && stateTree->isSimple) && | |||
806 | ((!match || !complexMatchState) && (currIndex != TM_NO_MATCH(-2)))) { | |||
807 | currIndex++; | |||
808 | if (matchExact) | |||
809 | currIndex = MatchExact(stateTree,currIndex,typeIndex,modIndex); | |||
810 | else | |||
811 | currIndex = MatchBranchHead(stateTree,currIndex,curEventPtr); | |||
812 | if (currIndex != TM_NO_MATCH(-2)) { | |||
813 | TMBranchHead branchHead; | |||
814 | StatePtr currState; | |||
815 | ||||
816 | branchHead = &stateTree->branchHeadTbl[currIndex]; | |||
817 | if (branchHead->isSimple) | |||
818 | currState = NULL((void*)0); | |||
819 | else | |||
820 | currState = ((TMComplexStateTree)stateTree) | |||
821 | ->complexBranchHeadTbl[TMBranchMore(branchHead)(branchHead->more)]; | |||
822 | ||||
823 | /* | |||
824 | * first check for a complete match | |||
825 | */ | |||
826 | if (!match) { | |||
827 | if (branchHead->hasActions) { | |||
828 | if (branchHead->isSimple) { | |||
829 | static ActionRec dummyAction; | |||
830 | ||||
831 | dummyAction.idx = TMBranchMore(branchHead)(branchHead->more); | |||
832 | actions = &dummyAction; | |||
833 | } | |||
834 | else | |||
835 | actions = currState->actions; | |||
836 | tmRecPtr->lastEventTime = | |||
837 | GetTime(tmRecPtr, curEventPtr->xev); | |||
838 | FreeContext((TMContext | |||
839 | *)&tmRecPtr->current_state); | |||
840 | match = True1; | |||
841 | matchTreeIndex = i; | |||
842 | } | |||
843 | /* | |||
844 | * if it doesn't have actions and | |||
845 | * it's bc mode then it's a potential match node that is | |||
846 | * used to match later sequences. | |||
847 | */ | |||
848 | if (!TMNewMatchSemantics()(_XtGlobalTM.newMatchSemantics) && !matchExact) { | |||
849 | matchExact = True1; | |||
850 | typeIndex = branchHead->typeIndex; | |||
851 | modIndex = branchHead->modIndex; | |||
852 | } | |||
853 | } | |||
854 | /* | |||
855 | * check for it being an event sequence which can be | |||
856 | * a future match | |||
857 | */ | |||
858 | if (!branchHead->isSimple && | |||
859 | !branchHead->hasActions && | |||
860 | !complexMatchState) | |||
861 | complexMatchState = currState; | |||
862 | } | |||
863 | } | |||
864 | } | |||
865 | if (match) | |||
866 | { | |||
867 | TMBindData bindData = (TMBindData) tmRecPtr->proc_table; | |||
868 | XtActionProc *procs; | |||
869 | Widget accelWidget; | |||
870 | ||||
871 | if (bindData->simple.isComplex) { | |||
872 | TMComplexBindProcs bindProcs = | |||
873 | TMGetComplexBindEntry(bindData, matchTreeIndex)((TMComplexBindProcs)&(((TMComplexBindData)bindData)-> bindTbl[matchTreeIndex])); | |||
874 | procs = bindProcs->procs; | |||
875 | accelWidget = bindProcs->widget; | |||
876 | } | |||
877 | else { | |||
878 | TMSimpleBindProcs bindProcs = | |||
879 | TMGetSimpleBindEntry(bindData, matchTreeIndex)((TMSimpleBindProcs)&(((TMSimpleBindData)bindData)->bindTbl [matchTreeIndex])); | |||
880 | procs = bindProcs->procs; | |||
881 | accelWidget = NULL((void*)0); | |||
882 | } | |||
883 | HandleActions | |||
884 | (w, | |||
885 | curEventPtr->xev, | |||
886 | (TMSimpleStateTree)xlations->stateTreeTbl[matchTreeIndex], | |||
887 | accelWidget, | |||
888 | procs, | |||
889 | actions); | |||
890 | } | |||
891 | if (complexMatchState) | |||
892 | PushContext(contextPtr, complexMatchState); | |||
893 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
894 | } | |||
895 | ||||
896 | static int MatchComplexBranch( | |||
897 | TMComplexStateTree stateTree, | |||
898 | int startIndex, | |||
899 | TMContext context, | |||
900 | StatePtr *leafStateRtn) | |||
901 | { | |||
902 | TMShortCard i; | |||
903 | ||||
904 | LOCK_PROCESSif(_XtProcessLock)(*_XtProcessLock)(); | |||
905 | for (i = startIndex; i < stateTree->numComplexBranchHeads; i++) | |||
906 | { | |||
907 | StatePtr candState; | |||
908 | TMShortCard numMatches = context->numMatches; | |||
909 | MatchPair statMatch = context->matches; | |||
910 | ||||
911 | for (candState = stateTree->complexBranchHeadTbl[i]; | |||
912 | numMatches && candState; | |||
913 | numMatches--, statMatch++, candState = candState->nextLevel) | |||
914 | { | |||
915 | if ((statMatch->typeIndex != candState->typeIndex) || | |||
916 | (statMatch->modIndex != candState->modIndex)) | |||
917 | break; | |||
918 | } | |||
919 | if (numMatches == 0) { | |||
920 | *leafStateRtn = candState; | |||
921 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
922 | return i; | |||
923 | } | |||
924 | } | |||
925 | *leafStateRtn = NULL((void*)0); | |||
926 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
927 | return (TM_NO_MATCH(-2)); | |||
928 | } | |||
929 | ||||
930 | static StatePtr TryCurrentTree( | |||
931 | TMComplexStateTree *stateTreePtr, | |||
932 | XtTM tmRecPtr, | |||
933 | TMEventRec *curEventPtr) | |||
934 | { | |||
935 | StatePtr candState = NULL((void*)0), matchState = NULL((void*)0); | |||
936 | TMContext *contextPtr = GetContextPtr(tmRecPtr)((TMContext *)&(tmRecPtr->current_state)); | |||
937 | TMTypeMatch typeMatch; | |||
938 | TMModifierMatch modMatch; | |||
939 | int currIndex = -1; | |||
940 | ||||
941 | /* | |||
942 | * we want the first sequence that both matches and has actions. | |||
943 | * we keep on looking till we find both | |||
944 | */ | |||
945 | LOCK_PROCESSif(_XtProcessLock)(*_XtProcessLock)(); | |||
946 | while ((currIndex = | |||
947 | MatchComplexBranch(*stateTreePtr, | |||
948 | ++currIndex, | |||
949 | (*contextPtr), | |||
950 | &candState)) | |||
951 | != TM_NO_MATCH(-2)) { | |||
952 | if (candState != NULL((void*)0)) { | |||
953 | typeMatch = TMGetTypeMatch(candState->typeIndex)((TMTypeMatch) &((_XtGlobalTM.typeMatchSegmentTbl[((candState ->typeIndex) >> 4)])[(candState->typeIndex) & 15])); | |||
954 | modMatch = TMGetModifierMatch(candState->modIndex)((TMModifierMatch) &((_XtGlobalTM.modMatchSegmentTbl[(candState ->modIndex) >> 4])[(candState->modIndex) & 15 ])); | |||
955 | ||||
956 | /* does this state's index match? --> done */ | |||
957 | if (MatchIncomingEvent(curEventPtr, typeMatch, modMatch)(typeMatch->eventType == curEventPtr->event.eventType && (typeMatch->matchEvent != ((void*)0)) && (*typeMatch ->matchEvent)(typeMatch, modMatch, curEventPtr))) | |||
958 | { | |||
959 | if (candState->actions) { | |||
960 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
961 | return candState; | |||
962 | } | |||
963 | else | |||
964 | matchState = candState; | |||
965 | } | |||
966 | /* is this an event timer? */ | |||
967 | if (typeMatch->eventType == _XtEventTimerEventType((TMLongCard)~0L)) { | |||
968 | StatePtr nextState = candState->nextLevel; | |||
969 | ||||
970 | /* does the succeeding state match? */ | |||
971 | if (nextState != NULL((void*)0)) { | |||
972 | TMTypeMatch nextTypeMatch; | |||
973 | TMModifierMatch nextModMatch; | |||
974 | ||||
975 | nextTypeMatch = TMGetTypeMatch(nextState->typeIndex)((TMTypeMatch) &((_XtGlobalTM.typeMatchSegmentTbl[((nextState ->typeIndex) >> 4)])[(nextState->typeIndex) & 15])); | |||
976 | nextModMatch = TMGetModifierMatch(nextState->modIndex)((TMModifierMatch) &((_XtGlobalTM.modMatchSegmentTbl[(nextState ->modIndex) >> 4])[(nextState->modIndex) & 15 ])); | |||
977 | ||||
978 | /* is it within the timeout? */ | |||
979 | if (MatchIncomingEvent(curEventPtr,(nextTypeMatch->eventType == curEventPtr->event.eventType && (nextTypeMatch->matchEvent != ((void*)0)) && (*nextTypeMatch->matchEvent)(nextTypeMatch, nextModMatch, curEventPtr)) | |||
980 | nextTypeMatch,(nextTypeMatch->eventType == curEventPtr->event.eventType && (nextTypeMatch->matchEvent != ((void*)0)) && (*nextTypeMatch->matchEvent)(nextTypeMatch, nextModMatch, curEventPtr)) | |||
981 | nextModMatch)(nextTypeMatch->eventType == curEventPtr->event.eventType && (nextTypeMatch->matchEvent != ((void*)0)) && (*nextTypeMatch->matchEvent)(nextTypeMatch, nextModMatch, curEventPtr))) { | |||
982 | XEvent *xev = curEventPtr->xev; | |||
983 | unsigned long time = GetTime(tmRecPtr, xev); | |||
984 | XtPerDisplay pd = _XtGetPerDisplay(xev->xany.display); | |||
985 | unsigned long delta = pd->multi_click_time; | |||
986 | ||||
987 | if ((tmRecPtr->lastEventTime + delta) >= time) { | |||
988 | if (nextState->actions) { | |||
989 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
990 | return candState; | |||
991 | } | |||
992 | else | |||
993 | matchState = candState; | |||
994 | } | |||
995 | } | |||
996 | } | |||
997 | } | |||
998 | } | |||
999 | } | |||
1000 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
1001 | return matchState; | |||
1002 | } | |||
1003 | ||||
1004 | static void HandleComplexState( | |||
1005 | Widget w, | |||
1006 | XtTM tmRecPtr, | |||
1007 | TMEventRec *curEventPtr) | |||
1008 | { | |||
1009 | XtTranslations xlations = tmRecPtr->translations; | |||
1010 | TMContext *contextPtr = GetContextPtr(tmRecPtr)((TMContext *)&(tmRecPtr->current_state)); | |||
1011 | TMShortCard i, matchTreeIndex = 0; | |||
1012 | StatePtr matchState = NULL((void*)0), candState; | |||
1013 | TMComplexStateTree *stateTreePtr = | |||
1014 | (TMComplexStateTree *)&xlations->stateTreeTbl[0]; | |||
1015 | ||||
1016 | LOCK_PROCESSif(_XtProcessLock)(*_XtProcessLock)(); | |||
1017 | for (i = 0; | |||
1018 | i < xlations->numStateTrees; | |||
1019 | i++, stateTreePtr++) { | |||
1020 | /* | |||
1021 | * some compilers sign extend Boolean bit fields so test for | |||
1022 | * false ||| | |||
1023 | */ | |||
1024 | if (((*stateTreePtr)->isSimple == False0) && | |||
1025 | (candState = TryCurrentTree(stateTreePtr, | |||
1026 | tmRecPtr, | |||
1027 | curEventPtr))) { | |||
1028 | if (!matchState || candState->actions) { | |||
1029 | matchTreeIndex = i; | |||
1030 | matchState = candState; | |||
1031 | if (candState->actions) | |||
1032 | break; | |||
1033 | } | |||
1034 | } | |||
1035 | } | |||
1036 | if (matchState == NULL((void*)0)){ | |||
1037 | /* couldn't find it... */ | |||
1038 | if (!Ignore(curEventPtr)) | |||
1039 | { | |||
1040 | FreeContext(contextPtr); | |||
1041 | HandleSimpleState(w, tmRecPtr, curEventPtr); | |||
1042 | } | |||
1043 | } | |||
1044 | else { | |||
1045 | TMBindData bindData = (TMBindData) tmRecPtr->proc_table; | |||
1046 | XtActionProc *procs; | |||
1047 | Widget accelWidget; | |||
1048 | TMTypeMatch typeMatch; | |||
1049 | ||||
1050 | typeMatch = TMGetTypeMatch(matchState->typeIndex)((TMTypeMatch) &((_XtGlobalTM.typeMatchSegmentTbl[((matchState ->typeIndex) >> 4)])[(matchState->typeIndex) & 15])); | |||
1051 | ||||
1052 | PushContext(contextPtr, matchState); | |||
1053 | if (typeMatch->eventType == _XtEventTimerEventType((TMLongCard)~0L)) { | |||
1054 | matchState = matchState->nextLevel; | |||
1055 | PushContext(contextPtr, matchState); | |||
1056 | } | |||
1057 | tmRecPtr->lastEventTime = GetTime (tmRecPtr, curEventPtr->xev); | |||
1058 | ||||
1059 | if (bindData->simple.isComplex) { | |||
1060 | TMComplexBindProcs bindProcs = | |||
1061 | TMGetComplexBindEntry(bindData, matchTreeIndex)((TMComplexBindProcs)&(((TMComplexBindData)bindData)-> bindTbl[matchTreeIndex])); | |||
1062 | procs = bindProcs->procs; | |||
1063 | accelWidget = bindProcs->widget; | |||
1064 | } | |||
1065 | else { | |||
1066 | TMSimpleBindProcs bindProcs = | |||
1067 | TMGetSimpleBindEntry(bindData, matchTreeIndex)((TMSimpleBindProcs)&(((TMSimpleBindData)bindData)->bindTbl [matchTreeIndex])); | |||
1068 | procs = bindProcs->procs; | |||
1069 | accelWidget = NULL((void*)0); | |||
1070 | } | |||
1071 | HandleActions(w, | |||
1072 | curEventPtr->xev, | |||
1073 | (TMSimpleStateTree) | |||
1074 | xlations->stateTreeTbl[matchTreeIndex], | |||
1075 | accelWidget, | |||
1076 | procs, | |||
1077 | matchState->actions); | |||
1078 | } | |||
1079 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
1080 | } | |||
1081 | ||||
1082 | ||||
1083 | void _XtTranslateEvent ( | |||
1084 | Widget w, | |||
1085 | XEvent * event) | |||
1086 | { | |||
1087 | XtTM tmRecPtr = &w->core.tm; | |||
1088 | TMEventRec curEvent; | |||
1089 | StatePtr current_state = tmRecPtr->current_state; | |||
1090 | ||||
1091 | XEventToTMEvent (event, &curEvent); | |||
1092 | ||||
1093 | if (! tmRecPtr->translations) { | |||
1094 | XtAppWarningMsg(XtWidgetToApplicationContext(w), | |||
1095 | XtNtranslationError,"nullTable",XtCXtToolkitError, | |||
1096 | "Can't translate event through NULL table", | |||
1097 | (String *)NULL((void*)0), (Cardinal *)NULL((void*)0)); | |||
1098 | return ; | |||
1099 | } | |||
1100 | if (current_state == NULL((void*)0)) | |||
1101 | HandleSimpleState(w, tmRecPtr, &curEvent); | |||
1102 | else | |||
1103 | HandleComplexState(w, tmRecPtr, &curEvent); | |||
1104 | } | |||
1105 | ||||
1106 | ||||
1107 | /*ARGSUSED*/ | |||
1108 | static StatePtr NewState( | |||
1109 | TMParseStateTree stateTree, | |||
1110 | TMShortCard typeIndex, | |||
1111 | TMShortCard modIndex) | |||
1112 | { | |||
1113 | StatePtr state = XtNew(StateRec)((StateRec *) XtMalloc((unsigned) sizeof(StateRec))); | |||
1114 | ||||
1115 | #ifdef TRACE_TM | |||
1116 | LOCK_PROCESSif(_XtProcessLock)(*_XtProcessLock)(); | |||
1117 | _XtGlobalTM.numComplexStates++; | |||
1118 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
1119 | #endif /* TRACE_TM */ | |||
1120 | state->typeIndex = typeIndex; | |||
1121 | state->modIndex = modIndex; | |||
1122 | state->nextLevel = NULL((void*)0); | |||
1123 | state->actions = NULL((void*)0); | |||
1124 | state->isCycleStart = state->isCycleEnd = False0; | |||
1125 | return state; | |||
1126 | } | |||
1127 | ||||
1128 | /* | |||
1129 | * This routine is an iterator for state trees. If the func returns | |||
1130 | * true then iteration is over. | |||
1131 | */ | |||
1132 | void _XtTraverseStateTree( | |||
1133 | TMStateTree tree, | |||
1134 | _XtTraversalProc func, | |||
1135 | XtPointer data) | |||
1136 | { | |||
1137 | TMComplexStateTree stateTree = (TMComplexStateTree)tree; | |||
1138 | TMBranchHead currBH; | |||
1139 | TMShortCard i; | |||
1140 | StateRec dummyStateRec, *dummyState = &dummyStateRec; | |||
1141 | ActionRec dummyActionRec, *dummyAction = &dummyActionRec; | |||
1142 | Boolean firstSimple = True1; | |||
1143 | StatePtr currState; | |||
1144 | ||||
1145 | /* first traverse the complex states */ | |||
1146 | if (stateTree->isSimple == False0) | |||
1147 | for (i = 0; i < stateTree->numComplexBranchHeads; i++) { | |||
1148 | currState = stateTree->complexBranchHeadTbl[i]; | |||
1149 | for (; currState; currState = currState->nextLevel) { | |||
1150 | if (func(currState, data)) | |||
1151 | return; | |||
1152 | if (currState->isCycleEnd) | |||
1153 | break; | |||
1154 | } | |||
1155 | } | |||
1156 | ||||
1157 | /* now traverse the simple ones */ | |||
1158 | for (i = 0, currBH = stateTree->branchHeadTbl; | |||
1159 | i < stateTree->numBranchHeads; | |||
1160 | i++, currBH++) | |||
1161 | { | |||
1162 | if (currBH->isSimple && currBH->hasActions) | |||
1163 | { | |||
1164 | if (firstSimple) | |||
1165 | { | |||
1166 | XtBZero((char *) dummyState, sizeof(StateRec))__builtin___memset_chk ((char *) ((char *) dummyState), 0, (int ) (sizeof(StateRec)), __builtin_object_size ((char *) ((char * ) dummyState), 0)); | |||
1167 | XtBZero((char *) dummyAction, sizeof(ActionRec))__builtin___memset_chk ((char *) ((char *) dummyAction), 0, ( int) (sizeof(ActionRec)), __builtin_object_size ((char *) ((char *) dummyAction), 0)); | |||
1168 | dummyState->actions = dummyAction; | |||
1169 | firstSimple = False0; | |||
1170 | } | |||
1171 | dummyState->typeIndex = currBH->typeIndex; | |||
1172 | dummyState->modIndex = currBH->modIndex; | |||
1173 | dummyAction->idx = currBH->more; | |||
1174 | if (func(dummyState, data)) | |||
1175 | return; | |||
1176 | } | |||
1177 | } | |||
1178 | } | |||
1179 | ||||
1180 | static EventMask EventToMask( | |||
1181 | TMTypeMatch typeMatch, | |||
1182 | TMModifierMatch modMatch) | |||
1183 | { | |||
1184 | EventMask returnMask; | |||
1185 | unsigned long eventType = typeMatch->eventType; | |||
1186 | ||||
1187 | if (eventType == MotionNotify6) { | |||
1188 | Modifiers modifierMask = modMatch->modifierMask; | |||
1189 | Modifiers tempMask; | |||
1190 | ||||
1191 | returnMask = 0; | |||
1192 | if (modifierMask == 0) { | |||
1193 | if (modMatch->modifiers == AnyButtonMask(1L<<28)) | |||
1194 | return ButtonMotionMask(1L<<13); | |||
1195 | else | |||
1196 | return PointerMotionMask(1L<<6); | |||
1197 | } | |||
1198 | tempMask = modifierMask & | |||
1199 | (Button1Mask(1<<8) | Button2Mask(1<<9) | Button3Mask(1<<10) | |||
1200 | | Button4Mask(1<<11) | Button5Mask(1<<12)); | |||
1201 | if (tempMask == 0) | |||
1202 | return PointerMotionMask(1L<<6); | |||
1203 | if (tempMask & Button1Mask(1<<8)) | |||
1204 | returnMask |= Button1MotionMask(1L<<8); | |||
1205 | if (tempMask & Button2Mask(1<<9)) | |||
1206 | returnMask |= Button2MotionMask(1L<<9); | |||
1207 | if (tempMask & Button3Mask(1<<10)) | |||
1208 | returnMask |= Button3MotionMask(1L<<10); | |||
1209 | if (tempMask & Button4Mask(1<<11)) | |||
1210 | returnMask |= Button4MotionMask(1L<<11); | |||
1211 | if (tempMask & Button5Mask(1<<12)) | |||
1212 | returnMask |= Button5MotionMask(1L<<12); | |||
1213 | return returnMask; | |||
1214 | } | |||
1215 | returnMask = _XtConvertTypeToMask(eventType); | |||
1216 | if (returnMask == (StructureNotifyMask(1L<<17)|SubstructureNotifyMask(1L<<19))) | |||
1217 | returnMask = StructureNotifyMask(1L<<17); | |||
1218 | return returnMask; | |||
1219 | } | |||
1220 | ||||
1221 | /*ARGSUSED*/ | |||
1222 | static void DispatchMappingNotify( | |||
1223 | Widget widget, /* will be NULL from _RefreshMapping */ | |||
1224 | XtPointer closure, /* real Widget */ | |||
1225 | XtPointer call_data) /* XEvent* */ | |||
1226 | { | |||
1227 | _XtTranslateEvent( (Widget)closure, (XEvent*)call_data); | |||
1228 | } | |||
1229 | ||||
1230 | ||||
1231 | /*ARGSUSED*/ | |||
1232 | static void RemoveFromMappingCallbacks( | |||
1233 | Widget widget, | |||
1234 | XtPointer closure, /* target widget */ | |||
1235 | XtPointer call_data) | |||
1236 | { | |||
1237 | _XtRemoveCallback( &_XtGetPerDisplay(XtDisplay(widget)(((widget)->core.screen)->display))->mapping_callbacks, | |||
1238 | DispatchMappingNotify, | |||
1239 | closure | |||
1240 | ); | |||
1241 | } | |||
1242 | ||||
1243 | static Boolean AggregateEventMask( | |||
1244 | StatePtr state, | |||
1245 | XtPointer data) | |||
1246 | { | |||
1247 | LOCK_PROCESSif(_XtProcessLock)(*_XtProcessLock)(); | |||
1248 | *((EventMask *)data) |= EventToMask(TMGetTypeMatch(state->typeIndex)((TMTypeMatch) &((_XtGlobalTM.typeMatchSegmentTbl[((state ->typeIndex) >> 4)])[(state->typeIndex) & 15] )), | |||
1249 | TMGetModifierMatch(state->modIndex)((TMModifierMatch) &((_XtGlobalTM.modMatchSegmentTbl[(state ->modIndex) >> 4])[(state->modIndex) & 15]))); | |||
1250 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
1251 | return False0; | |||
1252 | } | |||
1253 | ||||
1254 | void _XtInstallTranslations( | |||
1255 | Widget widget) | |||
1256 | { | |||
1257 | XtTranslations xlations; | |||
1258 | Cardinal i; | |||
1259 | TMStateTree stateTree; | |||
1260 | Boolean mappingNotifyInterest = False0; | |||
1261 | ||||
1262 | xlations = widget->core.tm.translations; | |||
1263 | if (xlations == NULL((void*)0)) return; | |||
1264 | ||||
1265 | /* | |||
1266 | * check for somebody stuffing the translations directly into the | |||
1267 | * instance structure. We will end up being called again out of | |||
1268 | * ComposeTranslations but we *should* have bindings by then | |||
1269 | */ | |||
1270 | if (widget->core.tm.proc_table == NULL((void*)0)) { | |||
1271 | _XtMergeTranslations(widget, NULL((void*)0), XtTableReplace0); | |||
1272 | /* | |||
1273 | * if we're realized then we'll be called out of | |||
1274 | * ComposeTranslations | |||
1275 | */ | |||
1276 | if (XtIsRealized(widget)((((((Object)(widget))->object.widget_class->core_class .class_inited & 0x04) ? (widget) : _XtWindowedAncestor(widget )) ->core.window) != 0L)) | |||
1277 | return; | |||
1278 | } | |||
1279 | ||||
1280 | xlations->eventMask = 0; | |||
1281 | for (i = 0; | |||
1282 | i < xlations->numStateTrees; | |||
1283 | i++) | |||
1284 | { | |||
1285 | stateTree = xlations->stateTreeTbl[i]; | |||
1286 | _XtTraverseStateTree(stateTree, | |||
1287 | AggregateEventMask, | |||
1288 | (XtPointer)&xlations->eventMask); | |||
1289 | mappingNotifyInterest |= stateTree->simple.mappingNotifyInterest; | |||
1290 | } | |||
1291 | /* double click needs to make sure that you have selected on both | |||
1292 | button down and up. */ | |||
1293 | ||||
1294 | if (xlations->eventMask & ButtonPressMask(1L<<2)) | |||
1295 | xlations->eventMask |= ButtonReleaseMask(1L<<3); | |||
1296 | if (xlations->eventMask & ButtonReleaseMask(1L<<3)) | |||
1297 | xlations->eventMask |= ButtonPressMask(1L<<2); | |||
1298 | ||||
1299 | if (mappingNotifyInterest) { | |||
1300 | XtPerDisplay pd = _XtGetPerDisplay(XtDisplay(widget)(((widget)->core.screen)->display)); | |||
1301 | if (pd->mapping_callbacks) | |||
1302 | _XtAddCallbackOnce(&(pd->mapping_callbacks), | |||
1303 | DispatchMappingNotify, | |||
1304 | (XtPointer)widget); | |||
1305 | else | |||
1306 | _XtAddCallback(&(pd->mapping_callbacks), | |||
1307 | DispatchMappingNotify, | |||
1308 | (XtPointer)widget); | |||
1309 | ||||
1310 | if (widget->core.destroy_callbacks != NULL((void*)0)) | |||
1311 | _XtAddCallbackOnce( (InternalCallbackList *) | |||
1312 | &widget->core.destroy_callbacks, | |||
1313 | RemoveFromMappingCallbacks, | |||
1314 | (XtPointer)widget | |||
1315 | ); | |||
1316 | else | |||
1317 | _XtAddCallback((InternalCallbackList *) | |||
1318 | &widget->core.destroy_callbacks, | |||
1319 | RemoveFromMappingCallbacks, | |||
1320 | (XtPointer)widget | |||
1321 | ); | |||
1322 | } | |||
1323 | _XtBindActions(widget, (XtTM)&widget->core.tm); | |||
1324 | _XtRegisterGrabs(widget); | |||
1325 | } | |||
1326 | ||||
1327 | void _XtRemoveTranslations( | |||
1328 | Widget widget) | |||
1329 | { | |||
1330 | Cardinal i; | |||
1331 | TMSimpleStateTree stateTree; | |||
1332 | Boolean mappingNotifyInterest = False0; | |||
1333 | XtTranslations xlations = widget->core.tm.translations; | |||
1334 | ||||
1335 | if (xlations == NULL((void*)0)) | |||
1336 | return; | |||
1337 | ||||
1338 | for (i = 0; | |||
1339 | i < xlations->numStateTrees; | |||
1340 | i++) | |||
1341 | { | |||
1342 | stateTree = (TMSimpleStateTree)xlations->stateTreeTbl[i]; | |||
1343 | mappingNotifyInterest |= stateTree->mappingNotifyInterest; | |||
1344 | } | |||
1345 | if (mappingNotifyInterest) | |||
1346 | RemoveFromMappingCallbacks(widget, (XtPointer)widget, NULL((void*)0)); | |||
1347 | } | |||
1348 | ||||
1349 | static void _XtUninstallTranslations( | |||
1350 | Widget widget) | |||
1351 | { | |||
1352 | XtTranslations xlations = widget->core.tm.translations; | |||
1353 | ||||
1354 | _XtUnbindActions(widget, | |||
1355 | xlations, | |||
1356 | (TMBindData)widget->core.tm.proc_table); | |||
1357 | _XtRemoveTranslations(widget); | |||
1358 | widget->core.tm.translations = NULL((void*)0); | |||
1359 | FreeContext((TMContext *)&widget->core.tm.current_state); | |||
1360 | } | |||
1361 | ||||
1362 | void _XtDestroyTMData( | |||
1363 | Widget widget) | |||
1364 | { | |||
1365 | TMComplexBindData cBindData; | |||
1366 | ||||
1367 | _XtUninstallTranslations(widget); | |||
1368 | ||||
1369 | if ((cBindData = (TMComplexBindData)widget->core.tm.proc_table)) { | |||
1370 | if (cBindData->isComplex) { | |||
1371 | ATranslations aXlations, nXlations; | |||
1372 | ||||
1373 | nXlations = (ATranslations) cBindData->accel_context; | |||
1374 | while (nXlations){ | |||
1375 | aXlations = nXlations; | |||
1376 | nXlations = nXlations->next; | |||
1377 | XtFree((char *)aXlations); | |||
1378 | } | |||
1379 | } | |||
1380 | XtFree((char *)cBindData); | |||
1381 | } | |||
1382 | } | |||
1383 | ||||
1384 | /*** Public procedures ***/ | |||
1385 | ||||
1386 | ||||
1387 | void XtUninstallTranslations( | |||
1388 | Widget widget) | |||
1389 | { | |||
1390 | EventMask oldMask; | |||
1391 | Widget hookobj; | |||
1392 | WIDGET_TO_APPCON(widget)XtAppContext app = (widget && _XtProcessLock ? XtWidgetToApplicationContext (widget) : ((void*)0)); | |||
1393 | ||||
1394 | LOCK_APP(app)if(app && app->lock)(*app->lock)(app); | |||
1395 | if (! widget->core.tm.translations) { | |||
1396 | UNLOCK_APP(app)if(app && app->unlock)(*app->unlock)(app); | |||
1397 | return; | |||
1398 | } | |||
1399 | oldMask = widget->core.tm.translations->eventMask; | |||
1400 | _XtUninstallTranslations(widget); | |||
1401 | if (XtIsRealized(widget)((((((Object)(widget))->object.widget_class->core_class .class_inited & 0x04) ? (widget) : _XtWindowedAncestor(widget )) ->core.window) != 0L) && oldMask) | |||
1402 | XSelectInput(XtDisplay(widget)(((widget)->core.screen)->display), XtWindow(widget)((widget)->core.window), | |||
1403 | XtBuildEventMask(widget)); | |||
1404 | hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget)((((Object)(widget))->object.widget_class->core_class.class_inited & 0x04) ? (widget)->core.screen->display : _XtIsHookObject (widget) ? ((HookObject)(widget))->hooks.screen->display : _XtWindowedAncestor(widget)->core.screen->display)); | |||
1405 | if (XtHasCallbacks(hookobj, XtNchangeHook((char*)&XtStrings[2061])) == XtCallbackHasSome) { | |||
1406 | XtChangeHookDataRec call_data; | |||
1407 | ||||
1408 | call_data.type = XtHuninstallTranslations((char*)&XtStrings[2445]); | |||
1409 | call_data.widget = widget; | |||
1410 | XtCallCallbackList(hookobj, | |||
1411 | ((HookObject)hookobj)->hooks.changehook_callbacks, | |||
1412 | (XtPointer)&call_data); | |||
1413 | } | |||
1414 | UNLOCK_APP(app)if(app && app->unlock)(*app->unlock)(app); | |||
1415 | } | |||
1416 | ||||
1417 | XtTranslations _XtCreateXlations( | |||
1418 | TMStateTree *stateTrees, | |||
1419 | TMShortCard numStateTrees, | |||
1420 | XtTranslations first, | |||
1421 | XtTranslations second) | |||
1422 | { | |||
1423 | XtTranslations xlations; | |||
1424 | TMShortCard i; | |||
1425 | ||||
1426 | xlations = (XtTranslations) | |||
1427 | __XtMalloc(sizeof(TranslationData) + | |||
1428 | (numStateTrees-1) * sizeof(TMStateTree)); | |||
1429 | #ifdef TRACE_TM | |||
1430 | LOCK_PROCESSif(_XtProcessLock)(*_XtProcessLock)(); | |||
1431 | if (_XtGlobalTM.numTms == _XtGlobalTM.tmTblSize) { | |||
1432 | _XtGlobalTM.tmTblSize += 16; | |||
1433 | _XtGlobalTM.tmTbl = (XtTranslations *) | |||
1434 | XtRealloc((char *)_XtGlobalTM.tmTbl, | |||
1435 | _XtGlobalTM.tmTblSize * sizeof(XtTranslations)); | |||
1436 | } | |||
1437 | _XtGlobalTM.tmTbl[_XtGlobalTM.numTms++] = xlations; | |||
1438 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
1439 | #endif /* TRACE_TM */ | |||
1440 | ||||
1441 | xlations->composers[0] = first; | |||
1442 | xlations->composers[1] = second; | |||
1443 | xlations->hasBindings = False0; | |||
1444 | xlations->operation = XtTableReplace0; | |||
1445 | ||||
1446 | for (i = 0;i < numStateTrees; i++) | |||
1447 | { | |||
1448 | xlations->stateTreeTbl[i] = (TMStateTree) stateTrees[i]; | |||
1449 | stateTrees[i]->simple.refCount++; | |||
1450 | } | |||
1451 | xlations->numStateTrees = numStateTrees; | |||
1452 | xlations->eventMask = 0; | |||
1453 | return xlations; | |||
1454 | } | |||
1455 | ||||
1456 | TMStateTree _XtParseTreeToStateTree( | |||
1457 | TMParseStateTree parseTree) | |||
1458 | { | |||
1459 | TMSimpleStateTree simpleTree; | |||
1460 | unsigned int tableSize; | |||
1461 | ||||
1462 | if (parseTree->numComplexBranchHeads) { | |||
1463 | TMComplexStateTree complexTree; | |||
1464 | ||||
1465 | complexTree = XtNew(TMComplexStateTreeRec)((TMComplexStateTreeRec *) XtMalloc((unsigned) sizeof(TMComplexStateTreeRec ))); | |||
1466 | complexTree->isSimple = False0; | |||
1467 | tableSize = parseTree->numComplexBranchHeads * sizeof(StatePtr); | |||
1468 | complexTree->complexBranchHeadTbl = (StatePtr *) | |||
1469 | __XtMalloc(tableSize); | |||
1470 | XtMemmove(complexTree->complexBranchHeadTbl,if ((char *)(complexTree->complexBranchHeadTbl) != (char * )(parseTree->complexBranchHeadTbl)) { (void) __builtin___memcpy_chk ((char *) (complexTree->complexBranchHeadTbl), (char *) ( parseTree->complexBranchHeadTbl), (int) (tableSize), __builtin_object_size ((char *) (complexTree->complexBranchHeadTbl), 0)); } | |||
1471 | parseTree->complexBranchHeadTbl, tableSize)if ((char *)(complexTree->complexBranchHeadTbl) != (char * )(parseTree->complexBranchHeadTbl)) { (void) __builtin___memcpy_chk ((char *) (complexTree->complexBranchHeadTbl), (char *) ( parseTree->complexBranchHeadTbl), (int) (tableSize), __builtin_object_size ((char *) (complexTree->complexBranchHeadTbl), 0)); }; | |||
1472 | complexTree->numComplexBranchHeads = | |||
1473 | parseTree->numComplexBranchHeads; | |||
1474 | simpleTree = (TMSimpleStateTree)complexTree; | |||
1475 | } | |||
1476 | else { | |||
1477 | simpleTree = XtNew(TMSimpleStateTreeRec)((TMSimpleStateTreeRec *) XtMalloc((unsigned) sizeof(TMSimpleStateTreeRec ))); | |||
1478 | simpleTree->isSimple = True1; | |||
1479 | } | |||
1480 | simpleTree->isAccelerator = parseTree->isAccelerator; | |||
1481 | simpleTree->refCount = 0; | |||
1482 | simpleTree->mappingNotifyInterest = parseTree->mappingNotifyInterest; | |||
1483 | ||||
1484 | tableSize = parseTree->numBranchHeads * sizeof(TMBranchHeadRec); | |||
1485 | simpleTree->branchHeadTbl = (TMBranchHead) | |||
1486 | __XtMalloc(tableSize); | |||
1487 | XtMemmove(simpleTree->branchHeadTbl, parseTree->branchHeadTbl, tableSize)if ((char *)(simpleTree->branchHeadTbl) != (char *)(parseTree ->branchHeadTbl)) { (void) __builtin___memcpy_chk ((char * ) (simpleTree->branchHeadTbl), (char *) (parseTree->branchHeadTbl ), (int) (tableSize), __builtin_object_size ((char *) (simpleTree ->branchHeadTbl), 0)); }; | |||
1488 | simpleTree->numBranchHeads = parseTree->numBranchHeads; | |||
1489 | ||||
1490 | tableSize = parseTree->numQuarks * sizeof(XrmQuark); | |||
1491 | simpleTree->quarkTbl = (XrmQuark *) __XtMalloc(tableSize); | |||
1492 | XtMemmove(simpleTree->quarkTbl, parseTree->quarkTbl, tableSize)if ((char *)(simpleTree->quarkTbl) != (char *)(parseTree-> quarkTbl)) { (void) __builtin___memcpy_chk ((char *) (simpleTree ->quarkTbl), (char *) (parseTree->quarkTbl), (int) (tableSize ), __builtin_object_size ((char *) (simpleTree->quarkTbl), 0)); }; | |||
1493 | simpleTree->numQuarks = parseTree->numQuarks; | |||
1494 | ||||
1495 | return (TMStateTree)simpleTree; | |||
1496 | } | |||
1497 | ||||
1498 | static void FreeActions( | |||
1499 | ActionPtr actions) | |||
1500 | { | |||
1501 | ActionPtr action; | |||
1502 | TMShortCard i; | |||
1503 | for (action = actions; action;) { | |||
1504 | ActionPtr nextAction = action->next; | |||
1505 | for (i = action->num_params; i;) { | |||
1506 | XtFree( action->params[--i] ); | |||
1507 | } | |||
1508 | XtFree( (char*)action->params ); | |||
1509 | XtFree((char*) action); | |||
1510 | action = nextAction; | |||
1511 | } | |||
1512 | } | |||
1513 | ||||
1514 | /*ARGSUSED*/ | |||
1515 | static void AmbigActions( | |||
1516 | EventSeqPtr initialEvent, | |||
1517 | StatePtr *state, | |||
1518 | TMParseStateTree stateTree) | |||
1519 | { | |||
1520 | String params[3]; | |||
1521 | Cardinal numParams = 0; | |||
1522 | ||||
1523 | params[numParams++] = _XtPrintEventSeq(initialEvent, NULL((void*)0)); | |||
1524 | params[numParams++] = _XtPrintActions((*state)->actions, | |||
1525 | stateTree->quarkTbl); | |||
1526 | XtWarningMsg (XtNtranslationError,"oldActions",XtCXtToolkitError, | |||
1527 | "Previous entry was: %s %s", params, &numParams); | |||
1528 | XtFree((char *)params[0]); | |||
1529 | XtFree((char *)params[1]); | |||
1530 | numParams = 0; | |||
1531 | params[numParams++] = _XtPrintActions(initialEvent->actions, | |||
1532 | stateTree->quarkTbl); | |||
1533 | XtWarningMsg (XtNtranslationError,"newActions",XtCXtToolkitError, | |||
1534 | "New actions are:%s", params, &numParams); | |||
1535 | XtFree((char *)params[0]); | |||
1536 | XtWarningMsg (XtNtranslationError,"ambiguousActions", | |||
1537 | XtCXtToolkitError, | |||
1538 | "Overriding earlier translation manager actions.", | |||
1539 | (String *)NULL((void*)0), (Cardinal *)NULL((void*)0)); | |||
1540 | ||||
1541 | FreeActions((*state)->actions); | |||
1542 | (*state)->actions = NULL((void*)0); | |||
1543 | } | |||
1544 | ||||
1545 | ||||
1546 | void _XtAddEventSeqToStateTree( | |||
1547 | EventSeqPtr eventSeq, | |||
1548 | TMParseStateTree stateTree) | |||
1549 | { | |||
1550 | StatePtr *state; | |||
1551 | EventSeqPtr initialEvent = eventSeq; | |||
1552 | TMBranchHead branchHead; | |||
1553 | TMShortCard idx, modIndex, typeIndex; | |||
1554 | ||||
1555 | if (eventSeq == NULL((void*)0)) return; | |||
1556 | ||||
1557 | /* note that all states in the event seq passed in start out null */ | |||
1558 | /* we fill them in with the matching state as we traverse the list */ | |||
1559 | ||||
1560 | /* | |||
1561 | * We need to free the parser data structures !!! | |||
1562 | */ | |||
1563 | ||||
1564 | typeIndex = _XtGetTypeIndex(&eventSeq->event); | |||
1565 | modIndex = _XtGetModifierIndex(&eventSeq->event); | |||
1566 | idx = GetBranchHead(stateTree, typeIndex, modIndex, False0); | |||
1567 | branchHead = &stateTree->branchHeadTbl[idx]; | |||
1568 | ||||
1569 | /* | |||
1570 | * Need to check for pre-existing actions with same lhs ||| | |||
1571 | */ | |||
1572 | ||||
1573 | /* | |||
1574 | * Check for optimized case. Don't assume that the eventSeq has actions. | |||
1575 | */ | |||
1576 | if (!eventSeq->next && | |||
1577 | eventSeq->actions && | |||
1578 | !eventSeq->actions->next && | |||
1579 | !eventSeq->actions->num_params) | |||
1580 | { | |||
1581 | if (eventSeq->event.eventType == MappingNotify34) | |||
1582 | stateTree->mappingNotifyInterest = True1; | |||
1583 | branchHead->hasActions = True1; | |||
1584 | branchHead->more = eventSeq->actions->idx; | |||
1585 | FreeActions(eventSeq->actions); | |||
1586 | eventSeq->actions = NULL((void*)0); | |||
1587 | return; | |||
1588 | } | |||
1589 | ||||
1590 | branchHead->isSimple = False0; | |||
1591 | if (!eventSeq->next) | |||
1592 | branchHead->hasActions = True1; | |||
1593 | branchHead->more = GetComplexBranchIndex(stateTree, typeIndex, modIndex); | |||
1594 | state = &stateTree->complexBranchHeadTbl[TMBranchMore(branchHead)(branchHead->more)]; | |||
1595 | ||||
1596 | for (;;) { | |||
1597 | *state = NewState(stateTree, typeIndex, modIndex); | |||
1598 | ||||
1599 | if (eventSeq->event.eventType == MappingNotify34) | |||
1600 | stateTree->mappingNotifyInterest = True1; | |||
1601 | ||||
1602 | /* *state now points at state record matching event */ | |||
1603 | eventSeq->state = *state; | |||
1604 | ||||
1605 | if (eventSeq->actions != NULL((void*)0)) { | |||
1606 | if ((*state)->actions != NULL((void*)0)) | |||
1607 | AmbigActions(initialEvent, state, stateTree); | |||
1608 | (*state)->actions = eventSeq->actions; | |||
1609 | #ifdef TRACE_TM | |||
1610 | LOCK_PROCESSif(_XtProcessLock)(*_XtProcessLock)() | |||
1611 | _XtGlobalTM.numComplexActions++; | |||
1612 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
1613 | #endif /* TRACE_TM */ | |||
1614 | } | |||
1615 | ||||
1616 | if (((eventSeq = eventSeq->next) == NULL((void*)0)) || (eventSeq->state)) | |||
1617 | break; | |||
1618 | ||||
1619 | state = &(*state)->nextLevel; | |||
1620 | typeIndex = _XtGetTypeIndex(&eventSeq->event); | |||
1621 | modIndex = _XtGetModifierIndex(&eventSeq->event); | |||
1622 | LOCK_PROCESSif(_XtProcessLock)(*_XtProcessLock)(); | |||
1623 | if (!TMNewMatchSemantics()(_XtGlobalTM.newMatchSemantics)) { | |||
1624 | /* | |||
1625 | * force a potential empty entry into the branch head | |||
1626 | * table in order to emulate old matching behavior | |||
1627 | */ | |||
1628 | (void) GetBranchHead(stateTree, typeIndex, modIndex, True1); | |||
1629 | } | |||
1630 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
1631 | } | |||
1632 | ||||
1633 | if (eventSeq && eventSeq->state) { | |||
1634 | /* we've been here before... must be a cycle in the event seq. */ | |||
1635 | branchHead->hasCycles = True1; | |||
1636 | (*state)->nextLevel = eventSeq->state; | |||
1637 | eventSeq->state->isCycleStart = True1; | |||
1638 | (*state)->isCycleEnd = TRUE1; | |||
1639 | } | |||
1640 | } | |||
1641 | ||||
1642 | ||||
1643 | /* | |||
1644 | * Internal Converter for merging. Old and New must both be valid xlations | |||
1645 | */ | |||
1646 | ||||
1647 | /*ARGSUSED*/ | |||
1648 | Boolean _XtCvtMergeTranslations( | |||
1649 | Display *dpy, | |||
1650 | XrmValuePtr args, | |||
1651 | Cardinal *num_args, | |||
1652 | XrmValuePtr from, | |||
1653 | XrmValuePtr to, | |||
1654 | XtPointer *closure_ret) | |||
1655 | { | |||
1656 | XtTranslations first, second, xlations; | |||
1657 | TMStateTree *stateTrees, stackStateTrees[16]; | |||
1658 | TMShortCard numStateTrees, i; | |||
1659 | ||||
1660 | if (*num_args != 0) | |||
1661 | XtWarningMsg("invalidParameters","mergeTranslations",XtCXtToolkitError, | |||
1662 | "MergeTM to TranslationTable needs no extra arguments", | |||
1663 | (String *)NULL((void*)0), (Cardinal *)NULL((void*)0)); | |||
1664 | ||||
1665 | if (to->addr != NULL((void*)0) && to->size < sizeof(XtTranslations)) { | |||
1666 | to->size = sizeof(XtTranslations); | |||
1667 | return False0; | |||
1668 | } | |||
1669 | ||||
1670 | first = ((TMConvertRec*)from->addr)->old; | |||
1671 | second = ((TMConvertRec*)from->addr)->new; | |||
1672 | ||||
1673 | numStateTrees = first->numStateTrees + second->numStateTrees; | |||
1674 | ||||
1675 | stateTrees = (TMStateTree *) | |||
1676 | XtStackAlloc(numStateTrees * sizeof(TMStateTree), stackStateTrees)((numStateTrees * sizeof(TMStateTree)) <= sizeof(stackStateTrees ) ? (XtPointer)(stackStateTrees) : XtMalloc((unsigned)(numStateTrees * sizeof(TMStateTree)))); | |||
1677 | ||||
1678 | for (i = 0; i < first->numStateTrees; i++) | |||
1679 | stateTrees[i] = first->stateTreeTbl[i]; | |||
1680 | for (i = 0; i < second->numStateTrees; i++) | |||
1681 | stateTrees[i + first->numStateTrees] = second->stateTreeTbl[i]; | |||
1682 | ||||
1683 | xlations = _XtCreateXlations(stateTrees, numStateTrees, first, second); | |||
1684 | ||||
1685 | if (to->addr != NULL((void*)0)) { | |||
1686 | *(XtTranslations*)to->addr = xlations; | |||
1687 | } | |||
1688 | else { | |||
1689 | static XtTranslations staticStateTable; | |||
1690 | staticStateTable = xlations; | |||
1691 | to->addr= (XPointer)&staticStateTable; | |||
1692 | to->size = sizeof(XtTranslations); | |||
1693 | } | |||
1694 | ||||
1695 | XtStackFree((XtPointer)stateTrees, (XtPointer)stackStateTrees){ if (((XtPointer)stateTrees) != ((XtPointer)((XtPointer)stackStateTrees ))) XtFree((XtPointer)stateTrees); }; | |||
1696 | return True1; | |||
1697 | } | |||
1698 | ||||
1699 | ||||
1700 | static XtTranslations MergeThem( | |||
1701 | Widget dest, | |||
1702 | XtTranslations first, | |||
1703 | XtTranslations second) | |||
1704 | { | |||
1705 | XtCacheRef cache_ref; | |||
1706 | static XrmQuark from_type = NULLQUARK((XrmQuark) 0), to_type; | |||
1707 | XrmValue from, to; | |||
1708 | TMConvertRec convert_rec; | |||
1709 | XtTranslations newTable; | |||
1710 | ||||
1711 | LOCK_PROCESSif(_XtProcessLock)(*_XtProcessLock)(); | |||
1712 | if (from_type == NULLQUARK((XrmQuark) 0)) { | |||
1713 | from_type = XrmPermStringToQuark(_XtRStateTablePair"_XtStateTablePair"); | |||
1714 | to_type = XrmPermStringToQuark(XtRTranslationTable((char*)&XtStrings[1841])); | |||
1715 | } | |||
1716 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
1717 | from.addr = (XPointer)&convert_rec; | |||
1718 | from.size = sizeof(TMConvertRec); | |||
1719 | to.addr = (XPointer)&newTable; | |||
1720 | to.size = sizeof(XtTranslations); | |||
1721 | convert_rec.old = first; | |||
1722 | convert_rec.new = second; | |||
1723 | ||||
1724 | LOCK_PROCESSif(_XtProcessLock)(*_XtProcessLock)(); | |||
1725 | if (! _XtConvert(dest, from_type, &from, to_type, &to, &cache_ref)) { | |||
1726 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
1727 | return NULL((void*)0); | |||
1728 | } | |||
1729 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
1730 | ||||
1731 | #ifndef REFCNT_TRANSLATIONS | |||
1732 | ||||
1733 | if (cache_ref) | |||
1734 | XtAddCallback(dest, XtNdestroyCallback((char*)&XtStrings[169]), | |||
1735 | XtCallbackReleaseCacheRef, (XtPointer)cache_ref); | |||
1736 | ||||
1737 | #endif | |||
1738 | ||||
1739 | return newTable; | |||
1740 | } | |||
1741 | ||||
1742 | /* | |||
1743 | * Unmerge will recursively traverse the xlation compose tree and | |||
1744 | * generate a new xlation that is the result of all instances of | |||
1745 | * xlations being removed. It currently doesn't differentiate between | |||
1746 | * the potential that an xlation will be both an accelerator and | |||
1747 | * normal. This is not supported by the spec anyway. | |||
1748 | */ | |||
1749 | static XtTranslations UnmergeTranslations( | |||
1750 | Widget widget, | |||
1751 | XtTranslations xlations, | |||
1752 | XtTranslations unmergeXlations, | |||
1753 | TMShortCard currIndex, | |||
1754 | TMComplexBindProcs oldBindings, | |||
1755 | TMShortCard numOldBindings, | |||
1756 | TMComplexBindProcs newBindings, | |||
1757 | TMShortCard *numNewBindingsRtn) | |||
1758 | ||||
1759 | { | |||
1760 | XtTranslations first, second, result; | |||
1761 | ||||
1762 | if (!xlations || (xlations == unmergeXlations)) | |||
1763 | return NULL((void*)0); | |||
1764 | ||||
1765 | if (xlations->composers[0]) { | |||
1766 | first = UnmergeTranslations(widget, xlations->composers[0], | |||
1767 | unmergeXlations, currIndex, | |||
1768 | oldBindings, numOldBindings, | |||
1769 | newBindings, numNewBindingsRtn); | |||
1770 | } | |||
1771 | else | |||
1772 | first = NULL((void*)0); | |||
1773 | ||||
1774 | if (xlations->composers[1]) { | |||
1775 | second = UnmergeTranslations(widget, xlations->composers[1], | |||
1776 | unmergeXlations, | |||
1777 | currIndex + | |||
1778 | xlations->composers[0]->numStateTrees, | |||
1779 | oldBindings, numOldBindings, | |||
1780 | newBindings, numNewBindingsRtn); | |||
1781 | } | |||
1782 | else | |||
1783 | second = NULL((void*)0); | |||
1784 | ||||
1785 | if (first || second) { | |||
1786 | if (first && second) { | |||
1787 | if ((first != xlations->composers[0]) || | |||
1788 | (second != xlations->composers[1])) | |||
1789 | result = MergeThem(widget, first, second); | |||
1790 | else result = xlations; | |||
1791 | } | |||
1792 | else { | |||
1793 | if (first) | |||
1794 | result = first; | |||
1795 | else | |||
1796 | result = second; | |||
1797 | } | |||
1798 | } else { /* only update for leaf nodes */ | |||
1799 | if (numOldBindings) { | |||
1800 | Cardinal i; | |||
1801 | for (i = 0; i < xlations->numStateTrees; i++) { | |||
1802 | if (xlations->stateTreeTbl[i]->simple.isAccelerator) | |||
1803 | newBindings[*numNewBindingsRtn] = | |||
1804 | oldBindings[currIndex + i]; | |||
1805 | (*numNewBindingsRtn)++; | |||
1806 | } | |||
1807 | } | |||
1808 | result = xlations; | |||
1809 | } | |||
1810 | return result; | |||
1811 | } | |||
1812 | ||||
1813 | typedef struct { | |||
1814 | XtTranslations xlations; | |||
1815 | TMComplexBindProcs bindings; | |||
1816 | }MergeBindRec, *MergeBind; | |||
1817 | ||||
1818 | static XtTranslations MergeTranslations( | |||
1819 | Widget widget, | |||
1820 | XtTranslations oldXlations, | |||
1821 | XtTranslations newXlations, | |||
1822 | _XtTranslateOp operation, | |||
1823 | Widget source, | |||
1824 | TMComplexBindProcs oldBindings, | |||
1825 | TMComplexBindProcs newBindings, | |||
1826 | TMShortCard *numNewRtn) | |||
1827 | { | |||
1828 | XtTranslations newTable = NULL((void*)0), xlations; | |||
1829 | TMComplexBindProcs bindings; | |||
1830 | TMShortCard i, j; | |||
1831 | TMStateTree *treePtr; | |||
1832 | TMShortCard numNew = *numNewRtn; | |||
1833 | MergeBindRec bindPair[2]; | |||
1834 | ||||
1835 | /* If the new translation has an accelerator context then pull it | |||
1836 | * off and pass it and the real xlations in to the caching merge | |||
1837 | * routine. | |||
1838 | */ | |||
1839 | if (newXlations->hasBindings) { | |||
1840 | xlations = ((ATranslations) newXlations)->xlations; | |||
1841 | bindings = (TMComplexBindProcs) | |||
1842 | &((ATranslations) newXlations)->bindTbl[0]; | |||
1843 | } | |||
1844 | else { | |||
1845 | xlations = newXlations; | |||
1846 | bindings = NULL((void*)0); | |||
1847 | } | |||
1848 | switch(operation) { | |||
1849 | case XtTableReplace0: | |||
1850 | newTable = bindPair[0].xlations = xlations; | |||
1851 | bindPair[0].bindings = bindings; | |||
1852 | bindPair[1].xlations = NULL((void*)0); | |||
1853 | bindPair[1].bindings = NULL((void*)0); | |||
1854 | break; | |||
1855 | case XtTableAugment1: | |||
1856 | bindPair[0].xlations = oldXlations; | |||
1857 | bindPair[0].bindings = oldBindings; | |||
1858 | bindPair[1].xlations = xlations; | |||
1859 | bindPair[1].bindings = bindings; | |||
1860 | newTable = NULL((void*)0); | |||
1861 | break; | |||
1862 | case XtTableOverride2: | |||
1863 | bindPair[0].xlations = xlations; | |||
1864 | bindPair[0].bindings = bindings; | |||
1865 | bindPair[1].xlations = oldXlations; | |||
1866 | bindPair[1].bindings = oldBindings; | |||
1867 | newTable = NULL((void*)0); | |||
1868 | break; | |||
1869 | } | |||
1870 | if (!newTable) | |||
1871 | newTable = MergeThem(widget, bindPair[0].xlations, bindPair[1].xlations); | |||
| ||||
1872 | ||||
1873 | for (i = 0, numNew = 0; i < 2; i++) { | |||
1874 | if (bindPair[i].xlations) | |||
1875 | for (j = 0; j < bindPair[i].xlations->numStateTrees; j++, numNew++) { | |||
1876 | if (bindPair[i].xlations->stateTreeTbl[j]->simple.isAccelerator) { | |||
1877 | if (bindPair[i].bindings) | |||
1878 | newBindings[numNew] = bindPair[i].bindings[j]; | |||
1879 | else { | |||
1880 | newBindings[numNew].widget = source; | |||
1881 | newBindings[numNew].aXlations = | |||
1882 | bindPair[i].xlations; | |||
1883 | } | |||
1884 | } | |||
1885 | } | |||
1886 | } | |||
1887 | *numNewRtn = numNew; | |||
1888 | treePtr = &newTable->stateTreeTbl[0]; | |||
1889 | for (i = 0; i < newTable->numStateTrees; i++, treePtr++) | |||
1890 | (*treePtr)->simple.refCount++; | |||
1891 | return newTable; | |||
1892 | } | |||
1893 | ||||
1894 | static TMBindData MakeBindData( | |||
1895 | TMComplexBindProcs bindings, | |||
1896 | TMShortCard numBindings, | |||
1897 | TMBindData oldBindData) | |||
1898 | { | |||
1899 | TMLongCard bytes; | |||
1900 | TMShortCard i; | |||
1901 | Boolean isComplex; | |||
1902 | TMBindData bindData; | |||
1903 | ||||
1904 | if (numBindings == 0) | |||
1905 | return NULL((void*)0); | |||
1906 | for (i = 0; i < numBindings; i++) | |||
1907 | if (bindings[i].widget) | |||
1908 | break; | |||
1909 | isComplex = (i < numBindings); | |||
1910 | if (isComplex) | |||
1911 | bytes = (sizeof(TMComplexBindDataRec) + | |||
1912 | ((numBindings - 1) * | |||
1913 | sizeof(TMComplexBindProcsRec))); | |||
1914 | else | |||
1915 | bytes = (sizeof(TMSimpleBindDataRec) + | |||
1916 | ((numBindings - 1) * | |||
1917 | sizeof(TMSimpleBindProcsRec))); | |||
1918 | ||||
1919 | bindData = (TMBindData) __XtCalloc(sizeof(char), bytes); | |||
1920 | bindData->simple.isComplex = isComplex; | |||
1921 | if (isComplex) { | |||
1922 | TMComplexBindData cBindData = (TMComplexBindData)bindData; | |||
1923 | /* | |||
1924 | * If there were any accelerator contexts in the old bindData | |||
1925 | * then propagate them to the new one. | |||
1926 | */ | |||
1927 | if (oldBindData && oldBindData->simple.isComplex) | |||
1928 | cBindData->accel_context = | |||
1929 | ((TMComplexBindData) oldBindData)->accel_context; | |||
1930 | XtMemmove((char *)&cBindData->bindTbl[0], (char *)bindings,if ((char *)((char *)&cBindData->bindTbl[0]) != (char * )((char *)bindings)) { (void) __builtin___memcpy_chk ((char * ) ((char *)&cBindData->bindTbl[0]), (char *) ((char *) bindings), (int) (numBindings * sizeof(TMComplexBindProcsRec) ), __builtin_object_size ((char *) ((char *)&cBindData-> bindTbl[0]), 0)); } | |||
1931 | numBindings * sizeof(TMComplexBindProcsRec))if ((char *)((char *)&cBindData->bindTbl[0]) != (char * )((char *)bindings)) { (void) __builtin___memcpy_chk ((char * ) ((char *)&cBindData->bindTbl[0]), (char *) ((char *) bindings), (int) (numBindings * sizeof(TMComplexBindProcsRec) ), __builtin_object_size ((char *) ((char *)&cBindData-> bindTbl[0]), 0)); }; | |||
1932 | } | |||
1933 | return bindData; | |||
1934 | } | |||
1935 | ||||
1936 | /* | |||
1937 | * This routine is the central clearinghouse for merging translations | |||
1938 | * into a widget. It takes care of preping the action bindings for | |||
1939 | * realize time and calling the converter or doing a straight merge if | |||
1940 | * the destination is empty. | |||
1941 | */ | |||
1942 | static Boolean ComposeTranslations( | |||
1943 | Widget dest, | |||
1944 | _XtTranslateOp operation, | |||
1945 | Widget source, | |||
1946 | XtTranslations newXlations) | |||
1947 | { | |||
1948 | XtTranslations newTable, oldXlations; | |||
1949 | XtTranslations accNewXlations; | |||
1950 | EventMask oldMask = 0; | |||
1951 | TMBindData bindData; | |||
1952 | TMComplexBindProcs oldBindings = NULL((void*)0); | |||
1953 | TMShortCard numOldBindings = 0, numNewBindings = 0, numBytes; | |||
1954 | TMComplexBindProcsRec stackBindings[16], *newBindings; | |||
1955 | ||||
1956 | /* | |||
1957 | * how should we be handling the refcount decrement for the | |||
1958 | * replaced translation table ??? | |||
1959 | */ | |||
1960 | if (!newXlations) | |||
| ||||
1961 | { | |||
1962 | XtAppWarningMsg(XtWidgetToApplicationContext(dest), | |||
1963 | XtNtranslationError,"nullTable",XtCXtToolkitError, | |||
1964 | "table to (un)merge must not be null", | |||
1965 | (String *)NULL((void*)0), (Cardinal *)NULL((void*)0)); | |||
1966 | return False0; | |||
1967 | } | |||
1968 | ||||
1969 | accNewXlations = newXlations; | |||
1970 | newXlations = ((newXlations->hasBindings) | |||
1971 | ? ((ATranslations)newXlations)->xlations | |||
1972 | : newXlations); | |||
1973 | ||||
1974 | if (!(oldXlations = dest->core.tm.translations)) | |||
1975 | operation = XtTableReplace0; | |||
1976 | ||||
1977 | /* | |||
1978 | * try to avoid generation of duplicate state trees. If the source | |||
1979 | * isn't simple (1 state Tree) then it's too much hassle | |||
1980 | */ | |||
1981 | if (((operation == XtTableAugment1) || | |||
1982 | (operation == XtTableOverride2)) && | |||
1983 | (newXlations->numStateTrees == 1)) { | |||
1984 | Cardinal i; | |||
1985 | for (i = 0; i < oldXlations->numStateTrees; i++) | |||
1986 | if (oldXlations->stateTreeTbl[i] == | |||
1987 | newXlations->stateTreeTbl[0]) | |||
1988 | break; | |||
1989 | if (i < oldXlations->numStateTrees) { | |||
1990 | if (operation == XtTableAugment1) { | |||
1991 | /* | |||
1992 | * we don't need to do anything since it's already | |||
1993 | * there | |||
1994 | */ | |||
1995 | return True1; | |||
1996 | } | |||
1997 | else {/* operation == XtTableOverride */ | |||
1998 | /* | |||
1999 | * We'll get rid of the duplicate trees throughout the | |||
2000 | * and leave it with a pruned translation table. This | |||
2001 | * will only work if the same table has been merged | |||
2002 | * into this table (or one of it's composers | |||
2003 | */ | |||
2004 | _XtUnmergeTranslations(dest, newXlations); | |||
2005 | /* | |||
2006 | * reset oldXlations so we're back in sync | |||
2007 | */ | |||
2008 | if (!(oldXlations = dest->core.tm.translations)) | |||
2009 | operation = XtTableReplace0; | |||
2010 | } | |||
2011 | } | |||
2012 | } | |||
2013 | ||||
2014 | bindData = (TMBindData) dest->core.tm.proc_table; | |||
2015 | if (bindData) { | |||
2016 | numOldBindings = (oldXlations ? oldXlations->numStateTrees : 0); | |||
2017 | if (bindData->simple.isComplex) | |||
2018 | oldBindings = &((TMComplexBindData)bindData)->bindTbl[0]; | |||
2019 | else | |||
2020 | oldBindings = (TMComplexBindProcs) | |||
2021 | (&((TMSimpleBindData)bindData)->bindTbl[0]); | |||
2022 | } | |||
2023 | ||||
2024 | numBytes =(((oldXlations ? oldXlations->numStateTrees : 0) | |||
2025 | + newXlations->numStateTrees) * sizeof(TMComplexBindProcsRec)); | |||
2026 | newBindings = (TMComplexBindProcs) XtStackAlloc(numBytes, stackBindings)((numBytes) <= sizeof(stackBindings) ? (XtPointer)(stackBindings ) : XtMalloc((unsigned)(numBytes))); | |||
2027 | XtBZero((char *)newBindings, numBytes)__builtin___memset_chk ((char *) ((char *)newBindings), 0, (int ) (numBytes), __builtin_object_size ((char *) ((char *)newBindings ), 0)); | |||
2028 | ||||
2029 | if (operation == XtTableUnmerge3) { | |||
2030 | newTable = UnmergeTranslations(dest, | |||
2031 | oldXlations, | |||
2032 | newXlations, | |||
2033 | 0, | |||
2034 | oldBindings, numOldBindings, | |||
2035 | newBindings, &numNewBindings); | |||
2036 | #ifdef DEBUG | |||
2037 | /* check for no match for unmerge */ | |||
2038 | if (newTable == oldXlations) { | |||
2039 | XtWarning("attempt to unmerge invalid table"); | |||
2040 | XtStackFree((char *)newBindings, (char *)stackBindings){ if (((char *)newBindings) != ((XtPointer)((char *)stackBindings ))) XtFree((char *)newBindings); }; | |||
2041 | return(newTable != NULL((void*)0)); | |||
2042 | } | |||
2043 | #endif /* DEBUG */ | |||
2044 | } | |||
2045 | else { | |||
2046 | newTable = MergeTranslations(dest, | |||
2047 | oldXlations, | |||
2048 | accNewXlations, | |||
2049 | operation, | |||
2050 | source, | |||
2051 | oldBindings, | |||
2052 | newBindings, | |||
2053 | &numNewBindings); | |||
2054 | } | |||
2055 | if (XtIsRealized(dest)((((((Object)(dest))->object.widget_class->core_class.class_inited & 0x04) ? (dest) : _XtWindowedAncestor(dest)) ->core. window) != 0L)) { | |||
2056 | oldMask = 0; | |||
2057 | if (oldXlations) | |||
2058 | oldMask = oldXlations->eventMask; | |||
2059 | _XtUninstallTranslations(dest); | |||
2060 | } | |||
2061 | ||||
2062 | dest->core.tm.proc_table = | |||
2063 | (XtActionProc *) MakeBindData(newBindings, numNewBindings, bindData); | |||
2064 | ||||
2065 | if (bindData) XtFree((char *)bindData); | |||
2066 | ||||
2067 | dest->core.tm.translations = newTable; | |||
2068 | ||||
2069 | if (XtIsRealized(dest)((((((Object)(dest))->object.widget_class->core_class.class_inited & 0x04) ? (dest) : _XtWindowedAncestor(dest)) ->core. window) != 0L)) { | |||
2070 | EventMask mask = 0; | |||
2071 | _XtInstallTranslations(dest); | |||
2072 | if (newTable) | |||
2073 | mask = newTable->eventMask; | |||
2074 | if (mask != oldMask) | |||
2075 | XSelectInput(XtDisplay(dest)(((dest)->core.screen)->display), XtWindow(dest)((dest)->core.window), | |||
2076 | XtBuildEventMask(dest)); | |||
2077 | } | |||
2078 | XtStackFree((XtPointer)newBindings, (XtPointer)stackBindings){ if (((XtPointer)newBindings) != ((XtPointer)((XtPointer)stackBindings ))) XtFree((XtPointer)newBindings); }; | |||
2079 | return(newTable != NULL((void*)0)); | |||
2080 | } | |||
2081 | ||||
2082 | /* | |||
2083 | * If a GetValues is done on a translation resource that contains | |||
2084 | * accelerators we need to return the accelerator context in addition | |||
2085 | * to the pure translations. Since this means returning memory that | |||
2086 | * the client controlls but we still own, we will track the "headers" | |||
2087 | * that we return (via a linked list pointed to from the bindData) and | |||
2088 | * free it at destroy time. | |||
2089 | */ | |||
2090 | XtTranslations _XtGetTranslationValue( | |||
2091 | Widget w) | |||
2092 | { | |||
2093 | XtTM tmRecPtr = (XtTM) &w->core.tm; | |||
2094 | ATranslations *aXlationsPtr; | |||
2095 | TMComplexBindData cBindData = (TMComplexBindData) tmRecPtr->proc_table; | |||
2096 | XtTranslations xlations = tmRecPtr->translations; | |||
2097 | ||||
2098 | if (!xlations || !cBindData || !cBindData->isComplex) | |||
2099 | return xlations; | |||
2100 | ||||
2101 | /* Walk the list looking to see if we already have generated a | |||
2102 | * header for the currently installed translations. If we have, | |||
2103 | * just return that header. Otherwise create a new header. | |||
2104 | */ | |||
2105 | for (aXlationsPtr = (ATranslations *) &cBindData->accel_context; | |||
2106 | *aXlationsPtr && (*aXlationsPtr)->xlations != xlations; | |||
2107 | aXlationsPtr = &(*aXlationsPtr)->next) | |||
2108 | ; | |||
2109 | if (*aXlationsPtr) | |||
2110 | return (XtTranslations) *aXlationsPtr; | |||
2111 | else { | |||
2112 | /* create a new aXlations context */ | |||
2113 | ATranslations aXlations; | |||
2114 | Cardinal numBindings = xlations->numStateTrees; | |||
2115 | ||||
2116 | (*aXlationsPtr) = aXlations = (ATranslations) | |||
2117 | __XtMalloc(sizeof(ATranslationData) + | |||
2118 | (numBindings - 1) * sizeof(TMComplexBindProcsRec)); | |||
2119 | ||||
2120 | aXlations->hasBindings = True1; | |||
2121 | aXlations->xlations = xlations; | |||
2122 | aXlations->next = NULL((void*)0); | |||
2123 | XtMemmove((char *) &aXlations->bindTbl[0],if ((char *)((char *) &aXlations->bindTbl[0]) != (char *)((char *) &cBindData->bindTbl[0])) { (void) __builtin___memcpy_chk ((char *) ((char *) &aXlations->bindTbl[0]), (char *) ((char *) &cBindData->bindTbl[0]), (int) (numBindings * sizeof(TMComplexBindProcsRec)), __builtin_object_size ((char *) ((char *) &aXlations->bindTbl[0]), 0)); } | |||
2124 | (char *) &cBindData->bindTbl[0],if ((char *)((char *) &aXlations->bindTbl[0]) != (char *)((char *) &cBindData->bindTbl[0])) { (void) __builtin___memcpy_chk ((char *) ((char *) &aXlations->bindTbl[0]), (char *) ((char *) &cBindData->bindTbl[0]), (int) (numBindings * sizeof(TMComplexBindProcsRec)), __builtin_object_size ((char *) ((char *) &aXlations->bindTbl[0]), 0)); } | |||
2125 | numBindings * sizeof(TMComplexBindProcsRec))if ((char *)((char *) &aXlations->bindTbl[0]) != (char *)((char *) &cBindData->bindTbl[0])) { (void) __builtin___memcpy_chk ((char *) ((char *) &aXlations->bindTbl[0]), (char *) ((char *) &cBindData->bindTbl[0]), (int) (numBindings * sizeof(TMComplexBindProcsRec)), __builtin_object_size ((char *) ((char *) &aXlations->bindTbl[0]), 0)); }; | |||
2126 | return (XtTranslations) aXlations; | |||
2127 | } | |||
2128 | } | |||
2129 | ||||
2130 | ||||
2131 | /*ARGSUSED*/ | |||
2132 | static void RemoveStateTree( | |||
2133 | TMStateTree tree) | |||
2134 | { | |||
2135 | #ifdef REFCNT_TRANSLATIONS | |||
2136 | TMComplexStateTree stateTree = (TMComplexStateTree)tree; | |||
2137 | ||||
2138 | if (--stateTree->refCount == 0) { | |||
2139 | /* | |||
2140 | * should we free/refcount the match recs ? | |||
2141 | */ | |||
2142 | if (!stateTree->isSimple) { | |||
2143 | StatePtr currState, nextState; | |||
2144 | TMShortCard i; | |||
2145 | for (i = 0; i < stateTree->numComplexBranchHeads; i++) { | |||
2146 | currState = | |||
2147 | nextState = | |||
2148 | stateTree->complexBranchHeadTbl[i]; | |||
2149 | for (; nextState;){ | |||
2150 | FreeActions(currState->actions); | |||
2151 | currState->actions = NULL((void*)0); | |||
2152 | if (!currState->isCycleEnd) | |||
2153 | nextState = currState->nextLevel; | |||
2154 | else | |||
2155 | nextState = NULL((void*)0); | |||
2156 | XtFree( (char*)currState ); | |||
2157 | } | |||
2158 | } | |||
2159 | XtFree((char*)stateTree->complexBranchHeadTbl); | |||
2160 | } | |||
2161 | XtFree((char*)stateTree->branchHeadTbl); | |||
2162 | XtFree((char*)stateTree); | |||
2163 | } | |||
2164 | #endif /* REFCNT_TRANSLATIONS */ | |||
2165 | } | |||
2166 | ||||
2167 | void _XtRemoveStateTreeByIndex( | |||
2168 | XtTranslations xlations, | |||
2169 | TMShortCard i) | |||
2170 | { | |||
2171 | TMStateTree *stateTrees = xlations->stateTreeTbl; | |||
2172 | ||||
2173 | RemoveStateTree(stateTrees[i]); | |||
2174 | xlations->numStateTrees--; | |||
2175 | ||||
2176 | for (; i < xlations->numStateTrees; i++) | |||
2177 | { | |||
2178 | stateTrees[i] = stateTrees[i+1]; | |||
2179 | } | |||
2180 | } | |||
2181 | ||||
2182 | /* ARGSUSED */ | |||
2183 | void _XtFreeTranslations( | |||
2184 | XtAppContext app, | |||
2185 | XrmValuePtr toVal, | |||
2186 | XtPointer closure, | |||
2187 | XrmValuePtr args, | |||
2188 | Cardinal *num_args) | |||
2189 | { | |||
2190 | XtTranslations xlations; | |||
2191 | int i; | |||
2192 | ||||
2193 | if (*num_args != 0) | |||
2194 | XtAppWarningMsg(app, | |||
2195 | "invalidParameters","freeTranslations",XtCXtToolkitError, | |||
2196 | "Freeing XtTranslations requires no extra arguments", | |||
2197 | (String *)NULL((void*)0), (Cardinal *)NULL((void*)0)); | |||
2198 | ||||
2199 | xlations = *(XtTranslations*)toVal->addr; | |||
2200 | for (i = 0; i < (int)xlations->numStateTrees; i++) | |||
2201 | RemoveStateTree(xlations->stateTreeTbl[i]); | |||
2202 | XtFree((char *)xlations); | |||
2203 | } | |||
2204 | ||||
2205 | /* The spec is not clear on when actions specified in accelerators are bound; | |||
2206 | * Bind them at Realize the same as translations | |||
2207 | */ | |||
2208 | void XtInstallAccelerators( | |||
2209 | Widget destination, Widget source) | |||
2210 | { | |||
2211 | XtTranslations aXlations; | |||
2212 | _XtTranslateOp op; | |||
2213 | String buf; | |||
2214 | WIDGET_TO_APPCON(destination)XtAppContext app = (destination && _XtProcessLock ? XtWidgetToApplicationContext (destination) : ((void*)0)); | |||
2215 | ||||
2216 | /* | |||
2217 | * test that it was parsed as an accelarator table. Even though | |||
2218 | * there doesn't need to be a distinction it makes life easier if | |||
2219 | * we honor the spec implication that aXlations is an accelerator | |||
2220 | */ | |||
2221 | LOCK_APP(app)if(app && app->lock)(*app->lock)(app); | |||
2222 | LOCK_PROCESSif(_XtProcessLock)(*_XtProcessLock)(); | |||
2223 | if ((!XtIsWidget(source)(((Object)(source))->object.widget_class->core_class.class_inited & 0x04)) || | |||
2224 | ((aXlations = source->core.accelerators) == NULL((void*)0)) || | |||
2225 | (aXlations->stateTreeTbl[0]->simple.isAccelerator == False0)) { | |||
2226 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
2227 | UNLOCK_APP(app)if(app && app->unlock)(*app->unlock)(app); | |||
2228 | return; | |||
2229 | } | |||
2230 | ||||
2231 | aXlations = source->core.accelerators; | |||
2232 | op = aXlations->operation; | |||
2233 | ||||
2234 | if (ComposeTranslations(destination, op, source, aXlations) && | |||
2235 | (XtClass(source)((source)->core.widget_class)->core_class.display_accelerator != NULL((void*)0))) { | |||
2236 | ||||
2237 | buf = _XtPrintXlations(destination, aXlations, source, False0); | |||
2238 | (*(XtClass(source)((source)->core.widget_class)->core_class.display_accelerator))(source,buf); | |||
2239 | XtFree(buf); | |||
2240 | } | |||
2241 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
2242 | UNLOCK_APP(app)if(app && app->unlock)(*app->unlock)(app); | |||
2243 | } | |||
2244 | ||||
2245 | void XtInstallAllAccelerators( | |||
2246 | Widget destination, | |||
2247 | Widget source) | |||
2248 | { | |||
2249 | Cardinal i; | |||
2250 | CompositeWidget cw; | |||
2251 | WIDGET_TO_APPCON(destination)XtAppContext app = (destination && _XtProcessLock ? XtWidgetToApplicationContext (destination) : ((void*)0)); | |||
2252 | ||||
2253 | /* Recurse down normal children */ | |||
2254 | LOCK_APP(app)if(app && app->lock)(*app->lock)(app); | |||
2255 | LOCK_PROCESSif(_XtProcessLock)(*_XtProcessLock)(); | |||
2256 | if (XtIsComposite(source)(((Object)(source))->object.widget_class->core_class.class_inited & 0x08)) { | |||
2257 | cw = (CompositeWidget) source; | |||
2258 | for (i = 0; i < cw->composite.num_children; i++) { | |||
2259 | XtInstallAllAccelerators(destination,cw->composite.children[i]); | |||
2260 | } | |||
2261 | } | |||
2262 | ||||
2263 | /* Recurse down popup children */ | |||
2264 | if (XtIsWidget(source)(((Object)(source))->object.widget_class->core_class.class_inited & 0x04)) { | |||
2265 | for (i = 0; i < source->core.num_popups; i++) { | |||
2266 | XtInstallAllAccelerators(destination,source->core.popup_list[i]); | |||
2267 | } | |||
2268 | } | |||
2269 | /* Finally, apply procedure to this widget */ | |||
2270 | XtInstallAccelerators(destination,source); | |||
2271 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
2272 | UNLOCK_APP(app)if(app && app->unlock)(*app->unlock)(app); | |||
2273 | } | |||
2274 | ||||
2275 | #if 0 /* dead code */ | |||
2276 | static _XtTranslateOp _XtGetTMOperation( | |||
2277 | XtTranslations xlations) | |||
2278 | { | |||
2279 | return ((xlations->hasBindings) | |||
2280 | ? ((ATranslations)xlations)->xlations->operation | |||
2281 | : xlations->operation); | |||
2282 | } | |||
2283 | #endif | |||
2284 | ||||
2285 | void XtAugmentTranslations( | |||
2286 | Widget widget, | |||
2287 | XtTranslations new) | |||
2288 | { | |||
2289 | Widget hookobj; | |||
2290 | WIDGET_TO_APPCON(widget)XtAppContext app = (widget && _XtProcessLock ? XtWidgetToApplicationContext (widget) : ((void*)0)); | |||
2291 | ||||
2292 | LOCK_APP(app)if(app && app->lock)(*app->lock)(app); | |||
2293 | LOCK_PROCESSif(_XtProcessLock)(*_XtProcessLock)(); | |||
2294 | (void)ComposeTranslations(widget, XtTableAugment1, (Widget)NULL((void*)0), new); | |||
2295 | hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget)((((Object)(widget))->object.widget_class->core_class.class_inited & 0x04) ? (widget)->core.screen->display : _XtIsHookObject (widget) ? ((HookObject)(widget))->hooks.screen->display : _XtWindowedAncestor(widget)->core.screen->display)); | |||
2296 | if (XtHasCallbacks(hookobj, XtNchangeHook((char*)&XtStrings[2061])) == XtCallbackHasSome) { | |||
2297 | XtChangeHookDataRec call_data; | |||
2298 | ||||
2299 | call_data.type = XtHaugmentTranslations((char*)&XtStrings[2400]); | |||
2300 | call_data.widget = widget; | |||
2301 | XtCallCallbackList(hookobj, | |||
2302 | ((HookObject)hookobj)->hooks.changehook_callbacks, | |||
2303 | (XtPointer)&call_data); | |||
2304 | } | |||
2305 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
2306 | UNLOCK_APP(app)if(app && app->unlock)(*app->unlock)(app); | |||
2307 | } | |||
2308 | ||||
2309 | void XtOverrideTranslations( | |||
2310 | Widget widget, | |||
2311 | XtTranslations new) | |||
2312 | { | |||
2313 | Widget hookobj; | |||
2314 | WIDGET_TO_APPCON(widget)XtAppContext app = (widget && _XtProcessLock ? XtWidgetToApplicationContext (widget) : ((void*)0)); | |||
2315 | ||||
2316 | LOCK_APP(app)if(app && app->lock)(*app->lock)(app); | |||
2317 | LOCK_PROCESSif(_XtProcessLock)(*_XtProcessLock)(); | |||
2318 | (void) ComposeTranslations(widget, XtTableOverride2, (Widget)NULL((void*)0), new); | |||
2319 | hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget)((((Object)(widget))->object.widget_class->core_class.class_inited & 0x04) ? (widget)->core.screen->display : _XtIsHookObject (widget) ? ((HookObject)(widget))->hooks.screen->display : _XtWindowedAncestor(widget)->core.screen->display)); | |||
2320 | if (XtHasCallbacks(hookobj, XtNchangeHook((char*)&XtStrings[2061])) == XtCallbackHasSome) { | |||
2321 | XtChangeHookDataRec call_data; | |||
2322 | ||||
2323 | call_data.type = XtHoverrideTranslations((char*)&XtStrings[2422]); | |||
2324 | call_data.widget = widget; | |||
2325 | XtCallCallbackList(hookobj, | |||
2326 | ((HookObject)hookobj)->hooks.changehook_callbacks, | |||
2327 | (XtPointer)&call_data); | |||
2328 | } | |||
2329 | UNLOCK_PROCESSif(_XtProcessUnlock)(*_XtProcessUnlock)(); | |||
2330 | UNLOCK_APP(app)if(app && app->unlock)(*app->unlock)(app); | |||
2331 | } | |||
2332 | ||||
2333 | void _XtMergeTranslations( | |||
2334 | Widget widget, | |||
2335 | XtTranslations newXlations, | |||
2336 | _XtTranslateOp op) | |||
2337 | { | |||
2338 | if (!newXlations){ | |||
2339 | if (!widget->core.tm.translations) | |||
2340 | return; | |||
2341 | else { | |||
2342 | newXlations = widget->core.tm.translations; | |||
2343 | widget->core.tm.translations = NULL((void*)0); | |||
2344 | } | |||
2345 | } | |||
2346 | (void) ComposeTranslations(widget, | |||
2347 | op, | |||
2348 | (Widget)NULL((void*)0), | |||
2349 | newXlations); | |||
2350 | } | |||
2351 | ||||
2352 | void _XtUnmergeTranslations( | |||
2353 | Widget widget, | |||
2354 | XtTranslations xlations) | |||
2355 | { | |||
2356 | ComposeTranslations(widget, XtTableUnmerge3, (Widget)NULL((void*)0), xlations); | |||
2357 | } |