1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
/*
* Copyright 2003, Joe English
*
* Simplified interface to Tcl_TraceVariable.
*
* PROBLEM: Can't distinguish "variable does not exist" (which is OK)
* from other errors (which are not).
*/
#include <tk.h>
#include "ttkTheme.h"
#include "ttkWidget.h"
struct TtkTraceHandle_
{
Tcl_Interp *interp; /* Containing interpreter */
Tcl_Obj *varnameObj; /* Name of variable being traced */
Ttk_TraceProc callback; /* Callback procedure */
void *clientData; /* Data to pass to callback */
};
/*
* Tcl_VarTraceProc for trace handles.
*/
static char *
VarTraceProc(
ClientData clientData, /* Widget record pointer */
Tcl_Interp *interp, /* Interpreter containing variable. */
const char *name1, /* (unused) */
const char *name2, /* (unused) */
int flags) /* Information about what happened. */
{
Ttk_TraceHandle *tracePtr = clientData;
const char *name, *value;
Tcl_Obj *valuePtr;
if (flags & TCL_INTERP_DESTROYED) {
return NULL;
}
name = Tcl_GetString(tracePtr->varnameObj);
/*
* If the variable is being unset, then re-establish the trace:
*/
if (flags & TCL_TRACE_DESTROYED) {
/*
* If a prior call to Ttk_UntraceVariable() left behind an
* indicator that we wanted this handler to be deleted (see below),
* cleanup the ClientData bits and exit.
*/
if (tracePtr->interp == NULL) {
Tcl_DecrRefCount(tracePtr->varnameObj);
ckfree((ClientData)tracePtr);
return NULL;
}
Tcl_TraceVar2(interp, name, NULL,
TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
VarTraceProc, clientData);
tracePtr->callback(tracePtr->clientData, NULL);
return NULL;
}
/*
* Call the callback:
*/
valuePtr = Tcl_GetVar2Ex(interp, name, NULL, TCL_GLOBAL_ONLY);
value = valuePtr ? Tcl_GetString(valuePtr) : NULL;
tracePtr->callback(tracePtr->clientData, value);
return NULL;
}
/* Ttk_TraceVariable(interp, varNameObj, callback, clientdata) --
* Attach a write trace to the specified variable,
* which will pass the variable's value to 'callback'
* whenever the variable is set.
*
* When the variable is unset, passes NULL to the callback
* and reattaches the trace.
*/
Ttk_TraceHandle *Ttk_TraceVariable(
Tcl_Interp *interp,
Tcl_Obj *varnameObj,
Ttk_TraceProc callback,
void *clientData)
{
Ttk_TraceHandle *h = ckalloc(sizeof(*h));
int status;
h->interp = interp;
h->varnameObj = Tcl_DuplicateObj(varnameObj);
Tcl_IncrRefCount(h->varnameObj);
h->clientData = clientData;
h->callback = callback;
status = Tcl_TraceVar2(interp, Tcl_GetString(varnameObj),
NULL, TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
VarTraceProc, (ClientData)h);
if (status != TCL_OK) {
Tcl_DecrRefCount(h->varnameObj);
ckfree(h);
return NULL;
}
return h;
}
/*
* Ttk_UntraceVariable --
* Remove previously-registered trace and free the handle.
*/
void Ttk_UntraceVariable(Ttk_TraceHandle *h)
{
if (h) {
ClientData cd = NULL;
/*
* Workaround for Tcl Bug 3062331. The trace design problem is
* that when variable unset traces fire, Tcl documents that the
* traced variable has already been unset. It's already gone.
* So from within an unset trace, if you try to call
* Tcl_UntraceVar() on that variable, it will do nothing, because
* the variable by that name can no longer be found. It's gone.
* This means callers of Tcl_UntraceVar() that might be running
* in response to an unset trace have to handle the possibility
* that their Tcl_UntraceVar() call will do nothing. In this case,
* we have to support the possibility that Tcl_UntraceVar() will
* leave the trace in place, so we need to leave the ClientData
* untouched so when that trace does fire it will not crash.
*/
/*
* Search the traces on the variable to see if the one we are tasked
* with removing is present.
*/
while ((cd = Tcl_VarTraceInfo(h->interp, Tcl_GetString(h->varnameObj),
TCL_GLOBAL_ONLY, VarTraceProc, cd)) != NULL) {
if (cd == (ClientData) h) {
break;
}
}
/*
* If the trace we wish to delete is not visible, Tcl_UntraceVar
* will do nothing, so don't try to call it. Instead set an
* indicator in the Ttk_TraceHandle that we need to cleanup later.
*/
if (cd == NULL) {
h->interp = NULL;
return;
}
Tcl_UntraceVar2(h->interp, Tcl_GetString(h->varnameObj),
NULL, TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
VarTraceProc, (ClientData)h);
Tcl_DecrRefCount(h->varnameObj);
ckfree(h);
}
}
/*
* Ttk_FireTrace --
* Executes a trace handle as if the variable has been written.
*
* Note: may reenter the interpreter.
*/
int Ttk_FireTrace(Ttk_TraceHandle *tracePtr)
{
Tcl_Interp *interp = tracePtr->interp;
void *clientData = tracePtr->clientData;
const char *name = Tcl_GetString(tracePtr->varnameObj);
Ttk_TraceProc callback = tracePtr->callback;
Tcl_Obj *valuePtr;
const char *value;
/* Read the variable.
* Note that this can reenter the interpreter, and anything can happen --
* including the current trace handle being freed!
*/
valuePtr = Tcl_GetVar2Ex(interp, name, NULL, TCL_GLOBAL_ONLY);
value = valuePtr ? Tcl_GetString(valuePtr) : NULL;
/* Call callback.
*/
callback(clientData, value);
return TCL_OK;
}
/*EOF*/
|
