File: | src/TMstate.c |
Location: | line 2319, column 32 |
Description: | Dereference of null pointer |
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 | } |