1 /***********************************************************************/
2 /* Open Visualization Data Explorer */
3 /* (C) Copyright IBM Corp. 1989,1999 */
4 /* ALL RIGHTS RESERVED */
5 /* This code licensed under the */
6 /* "IBM PUBLIC LICENSE - Open Visualization Data Explorer" */
7 /***********************************************************************/
8
9 #include <dxconfig.h>
10 #include "../base/defines.h"
11
12
13 #include <string.h>
14 #if defined(HAVE_MALLOC_H)
15 #include <malloc.h>
16 #endif
17
18 #include "dxlP.h"
19 #include "dict.h"
20
21 typedef struct handler_data{
22 DXLValueHandler handler;
23 const void *data;
24 } HandlerData;
25
26 #if 0
27 static HandlerData *NewHandlerData(DXLValueHandler
28 handler, const void *data)
29 {
30 HandlerData *hd = (HandlerData*)MALLOC(sizeof(HandlerData));
31 if (!hd)
32 return NULL;
33
34 hd->handler = handler;
35 hd->data = data;
36
37 return hd;
38 }
39 #endif
40
DeleteHandlerData(HandlerData * hd)41 static void DeleteHandlerData(HandlerData *hd)
42 {
43 if (hd)
44 FREE(hd);
45 }
DictDeleteHandlerData(void * data)46 static void DictDeleteHandlerData(void *data)
47 {
48 DeleteHandlerData((HandlerData*)data);
49 }
50
51
52 /*
53 * The message comming across is in the format
54 * "DXLOutput VALUE <name> <value>"
55 * FIXME: what about values that are longer than a single message buffer.
56 */
57 static char *link_value_token = "LINK: DXLOutput VALUE";
58
59
60 static void
SystemValueHandler(DXLConnection * conn,const char * msg,void * data)61 SystemValueHandler(DXLConnection *conn, const char *msg, void *data)
62 {
63 HandlerData *hd = NULL;
64 char format[1024];
65 char varname[1024];
66 int count;
67
68 /* Parse varname from msg which contains varname" */
69 sprintf(format,"%s %%s %%n",link_value_token);
70 if (sscanf(msg,format,varname,&count) == 1)
71 hd = (HandlerData*)DictFind(conn->valueHandlerDict, varname);
72
73 if (hd) {
74 /* Extract value from the message
75 */
76 char value[8192];
77 strcpy(value, msg + count);
78 (hd->handler)(conn,varname,(const char *)value,(void*)hd->data);
79 }
80
81 }
82
InitializeValueHandler(DXLConnection * conn)83 static DXLError InitializeValueHandler(DXLConnection *conn)
84 {
85 DXLPacketTypeEnum ptype;
86
87 conn->valueHandlerDict = NewDictionary();
88 if (!conn->valueHandlerDict)
89 return ERROR;
90
91 if (conn->majorVersion > 2)
92 ptype = PACK_LINK;
93 else
94 ptype = PACK_INFO;
95
96 if (!_dxl_SetSystemHandlerString(conn, ptype, link_value_token,
97 SystemValueHandler, NULL))
98 return ERROR;
99
100 return OK;
101 }
102 /*
103 * Install a handler for the value that has been given the name 'name'.
104 * One handler is allowed per named value.
105 * Return 0 on error, non-zero on success.
106 */
107 DXLError
DXLSetValueHandler(DXLConnection * conn,const char * varname,DXLValueHandler handler,const void * data)108 DXLSetValueHandler(DXLConnection *conn, const char *varname,
109 DXLValueHandler handler, const void *data)
110 {
111 HandlerData *hd;
112
113 if (!conn->valueHandlerDict && !InitializeValueHandler(conn))
114 return ERROR;
115
116 hd = (HandlerData*)MALLOC(sizeof(HandlerData));
117 if (!hd)
118 return ERROR;
119
120 hd->handler = handler;
121 hd->data = data;
122 if (!DictInsert(conn->valueHandlerDict,varname,hd, DictDeleteHandlerData)) {
123 FREE(hd);
124 return ERROR;
125 }
126
127 return OK;
128
129 }
130 /*
131 * Remove the handler for the value that has been given the name 'name'.
132 * Return 0 on error, non-zero on success.
133 */
134 DXLError
DXLRemoveValueHandler(DXLConnection * conn,const char * name)135 DXLRemoveValueHandler(DXLConnection *conn, const char *name)
136 {
137 if (!conn->valueHandlerDict)
138 return OK;
139
140 if (DictFind(conn->valueHandlerDict,name)) {
141 DictDelete(conn->valueHandlerDict,name);
142 return OK;
143 }
144
145 return ERROR;
146 }
147
148
149 DXLError
DXLSetValue(DXLConnection * conn,const char * var,const char * value)150 DXLSetValue(DXLConnection *conn, const char *var, const char *value)
151 {
152 int sts;
153 if (conn->dxuiConnected) {
154 char *buffer = MALLOC(strlen(var)+ strlen(value) +
155 strlen("set receiver %s = %s"));
156 if (conn->majorVersion <= 2)
157 sprintf(buffer, "set receiver %s = %s",var, value);
158 else
159 sprintf(buffer, "set value %s = %s",var, value);
160 sts = DXLSend(conn, buffer);
161 FREE(buffer);
162 } else {
163 char *name = MALLOC(strlen(var) + 3);
164 sprintf(name, "\"%s\"", var);
165 exDXLExecuteOnceNamedWithArgs(conn, "SetDXLInputNamed", name, value, 0);
166 FREE(name);
167 sts = OK;
168 }
169
170 return sts;
171 }
172
173 #if 0
174 static DXLError
175 DXLSetTabValue(DXLConnection *conn, const char *var, const char *value)
176 {
177 int sts;
178 char *buffer = MALLOC(strlen(var)+ strlen(value) + 16);
179
180 if (conn->dxuiConnected) {
181 if (conn->majorVersion <= 2)
182 sprintf(buffer, "set value %s = %s",var, value);
183 else
184 sprintf(buffer, "set tab %s = %s",var, value);
185 } else {
186 sprintf(buffer, "%s = %s;",var, value);
187 }
188 sts = DXLSend(conn, buffer);
189 FREE(buffer);
190
191 return sts;
192 }
193 #endif
194
195 DXLError
DXLSetInteger(DXLConnection * conn,const char * gvarname,const int value)196 DXLSetInteger(DXLConnection *conn, const char *gvarname, const int value)
197 {
198 char buf[128];
199 sprintf(buf,"%d",value);
200 return DXLSetValue(conn,gvarname,buf);
201 }
202
203 DXLError
DXLSetScalar(DXLConnection * conn,const char * gvarname,const double value)204 DXLSetScalar(DXLConnection *conn, const char *gvarname, const double value)
205 {
206 char buf[128];
207 sprintf(buf,"%.*g",8,value);
208 return DXLSetValue(conn,gvarname,buf);
209 }
210 DXLError
DXLSetString(DXLConnection * conn,const char * gvarname,const char * value)211 DXLSetString(DXLConnection *conn, const char *gvarname, const char *value)
212 {
213 int r, l = strlen(value) + 3;
214 char *buffer = MALLOC(l);
215
216 sprintf(buffer, "\"%s\"",value);
217 r = DXLSetValue(conn,gvarname,buffer);
218 FREE(buffer);
219 return r;
220 }
221
222 DXLError
DXLSetInputValue(DXLConnection * conn,const char * macro,const char * module,const int instance,const int number,const char * value)223 DXLSetInputValue(DXLConnection *conn,
224 const char *macro, const char *module, const int instance, const int number,
225 const char *value)
226 {
227 int l = strlen(macro) + strlen(module);
228 char *varname = MALLOC(l + 32);
229 int sts;
230
231 sprintf(varname, "%s_%s_%d_in_%d", macro, module, instance, number);
232 sts = DXLSetValue(conn, varname, value);
233 FREE(varname);
234 return sts;
235 }
236
237 DXLError
DXLSetInputInteger(DXLConnection * conn,const char * macro,const char * module,const int instance,const int number,const int value)238 DXLSetInputInteger(DXLConnection *conn,
239 const char *macro, const char *module, const int instance, const int number,
240 const int value)
241 {
242 char buf[128];
243 sprintf(buf,"%d",value);
244 return DXLSetInputValue(conn,macro,module,instance,number,buf);
245 }
246
247 DXLError
DXLSetInputScalar(DXLConnection * conn,const char * macro,const char * module,const int instance,const int number,const double value)248 DXLSetInputScalar(DXLConnection *conn,
249 const char *macro, const char *module, const int instance, const int number,
250 const double value)
251 {
252 char buf[128];
253 sprintf(buf,"%f",value);
254 return DXLSetInputValue(conn,macro,module,instance,number,buf);
255 }
256 DXLError
DXLSetInputString(DXLConnection * conn,const char * macro,const char * module,const int instance,const int number,const char * value)257 DXLSetInputString(DXLConnection *conn,
258 const char *macro, const char *module, const int instance, const int number,
259 const char *value)
260 {
261 int r, l = strlen(value) + 3;
262 char *buffer = MALLOC(l);
263
264 sprintf(buffer, "\"%s\"",value);
265 r = DXLSetInputValue(conn,macro,module,instance,number,buffer);
266 FREE(buffer);
267 return r;
268 }
269
270 DXLError
DXLSetOutputValue(DXLConnection * conn,const char * macro,const char * module,const int instance,const int number,const char * value)271 DXLSetOutputValue(DXLConnection *conn,
272 const char *macro, const char *module, const int instance, const int number,
273 const char *value)
274 {
275 int l = strlen(macro) + strlen(module);
276 char *varname = MALLOC(l + 32);
277 int sts;
278
279 sprintf(varname, "%s_%s_%d_out_%d", macro, module, instance, number);
280 sts = DXLSetValue(conn, varname, value);
281 FREE(varname);
282 return sts;
283 }
284
285 DXLError
DXLSetOutputInteger(DXLConnection * conn,const char * macro,const char * module,const int instance,const int number,const int value)286 DXLSetOutputInteger(DXLConnection *conn,
287 const char *macro, const char *module, const int instance, const int number,
288 const int value)
289 {
290 char buf[128];
291 sprintf(buf,"%d",value);
292 return DXLSetOutputValue(conn,macro,module,instance,number,buf);
293 }
294
295 DXLError
DXLSetOutputScalar(DXLConnection * conn,const char * macro,const char * module,const int instance,const int number,const double value)296 DXLSetOutputScalar(DXLConnection *conn,
297 const char *macro, const char *module, const int instance, const int number,
298 const double value)
299 {
300 char buf[128];
301 sprintf(buf,"%.*g",8,value);
302 return DXLSetOutputValue(conn,macro,module,instance,number,buf);
303 }
304 DXLError
DXLSetOutputString(DXLConnection * conn,const char * macro,const char * module,const int instance,const int number,const char * value)305 DXLSetOutputString(DXLConnection *conn,
306 const char *macro, const char *module, const int instance, const int number,
307 const char *value)
308 {
309 int r, l = strlen(value) + 3;
310 char *buffer = MALLOC(l);
311
312 sprintf(buffer, "\"%s\"",value);
313 r = DXLSetOutputValue(conn,macro,module,instance,number,buffer);
314 FREE(buffer);
315 return r;
316 }
317