Mercurial > dwindows

comparison gtk/dw.c @ 361:8c0212f70914

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Signal handler changes to avoid a memory leak.
author bsmith@81767d24-ef19-dc11-ae90-00e081727c95
date Wed, 23 Apr 2003 05:16:23 +0000
parents 9ddcbbaebd50
children eb61b854fd58
comparison
equal deleted inserted replaced
360:cf66410d03b4 361:8c0212f70914
178 return SignalTranslate[z].func; 178 return SignalTranslate[z].func;
179 } 179 }
180 return NULL; 180 return NULL;
181 } 181 }
182 182
183 static SignalHandler _get_signal_handler(GtkWidget *widget, gpointer data)
184 {
185 int counter = (int)data;
186 SignalHandler sh;
187 char text[100];
188
189 sprintf(text, "_dw_sigwindow%d", counter);
190 sh.window = (HWND)gtk_object_get_data(GTK_OBJECT(widget), text);
191 sprintf(text, "_dw_sigfunc%d", counter);
192 sh.func = (void *)gtk_object_get_data(GTK_OBJECT(widget), text);
193 sprintf(text, "_dw_sigdata%d", counter);
194 sh.data = gtk_object_get_data(GTK_OBJECT(widget), text);
195
196 return sh;
197 }
198
199 static int _set_signal_handler(GtkWidget *widget, HWND window, void *func, gpointer data)
200 {
201 int counter = (int)gtk_object_get_data(GTK_OBJECT(widget), "_dw_sigcounter");
202 char text[100];
203
204 sprintf(text, "_dw_sigwindow%d", counter);
205 gtk_object_set_data(GTK_OBJECT(widget), text, (gpointer)window);
206 sprintf(text, "_dw_sigfunc%d", counter);
207 gtk_object_set_data(GTK_OBJECT(widget), text, (gpointer)func);
208 sprintf(text, "_dw_sigdata%d", counter);
209 gtk_object_set_data(GTK_OBJECT(widget), text, (gpointer)data);
210
211 counter++;
212 gtk_object_set_data(GTK_OBJECT(widget), "_dw_sigcounter", (gpointer)counter);
213
214 return counter - 1;
215 }
216
183 static gint _set_focus_event(GtkWindow *window, GtkWidget *widget, gpointer data) 217 static gint _set_focus_event(GtkWindow *window, GtkWidget *widget, gpointer data)
184 { 218 {
185 SignalHandler *work = (SignalHandler *)data; 219 SignalHandler work = _get_signal_handler((GtkWidget *)window, data);
186 int retval = FALSE; 220 int retval = FALSE;
187 221
188 if(work) 222 if(work.window)
189 { 223 {
190 int (*setfocusfunc)(HWND, void *) = work->func; 224 int (*setfocusfunc)(HWND, void *) = work.func;
191 225
192 retval = setfocusfunc((HWND)window, work->data); 226 retval = setfocusfunc(work.window, work.data);
193 } 227 }
194 return retval; 228 return retval;
195 } 229 }
196 230
197 static gint _button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data) 231 static gint _button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
198 { 232 {
199 SignalHandler *work = (SignalHandler *)data; 233 SignalHandler work = _get_signal_handler(widget, data);
200 int retval = FALSE; 234 int retval = FALSE;
201 235
202 if(work) 236 if(work.window)
203 { 237 {
204 int (*buttonfunc)(HWND, int, int, int, void *) = work->func; 238 int (*buttonfunc)(HWND, int, int, int, void *) = work.func;
205 int mybutton = event->button; 239 int mybutton = event->button;
206 240
207 if(event->button == 3) 241 if(event->button == 3)
208 mybutton = 2; 242 mybutton = 2;
209 else if(event->button == 2) 243 else if(event->button == 2)
210 mybutton = 3; 244 mybutton = 3;
211 245
212 retval = buttonfunc(widget, event->x, event->y, mybutton, work->data); 246 retval = buttonfunc(work.window, event->x, event->y, mybutton, work.data);
213 } 247 }
214 return retval; 248 return retval;
215 } 249 }
216 250
217 static gint _button_release_event(GtkWidget *widget, GdkEventButton *event, gpointer data) 251 static gint _button_release_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
218 { 252 {
219 SignalHandler *work = (SignalHandler *)data; 253 SignalHandler work = _get_signal_handler(widget, data);
220 int retval = FALSE; 254 int retval = FALSE;
221 255
222 if(work) 256 if(work.window)
223 { 257 {
224 int (*buttonfunc)(HWND, int, int, int, void *) = work->func; 258 int (*buttonfunc)(HWND, int, int, int, void *) = work.func;
225 int mybutton = event->button; 259 int mybutton = event->button;
226 260
227 if(event->button == 3) 261 if(event->button == 3)
228 mybutton = 2; 262 mybutton = 2;
229 else if(event->button == 2) 263 else if(event->button == 2)
230 mybutton = 3; 264 mybutton = 3;
231 265
232 retval = buttonfunc(widget, event->x, event->y, mybutton, work->data); 266 retval = buttonfunc(work.window, event->x, event->y, mybutton, work.data);
233 } 267 }
234 return retval; 268 return retval;
235 } 269 }
236 270
237 static gint _motion_notify_event(GtkWidget *widget, GdkEventMotion *event, gpointer data) 271 static gint _motion_notify_event(GtkWidget *widget, GdkEventMotion *event, gpointer data)
238 { 272 {
239 SignalHandler *work = (SignalHandler *)data; 273 SignalHandler work = _get_signal_handler(widget, data);
240 int retval = FALSE; 274 int retval = FALSE;
241 275
242 if(work) 276 if(work.window)
243 { 277 {
244 int (*motionfunc)(HWND, int, int, int, void *) = work->func; 278 int (*motionfunc)(HWND, int, int, int, void *) = work.func;
245 int keys = 0, x, y; 279 int keys = 0, x, y;
246 GdkModifierType state; 280 GdkModifierType state;
247 281
248 if (event->is_hint) 282 if (event->is_hint)
249 gdk_window_get_pointer (event->window, &x, &y, &state); 283 gdk_window_get_pointer (event->window, &x, &y, &state);
259 if (state & GDK_BUTTON3_MASK) 293 if (state & GDK_BUTTON3_MASK)
260 keys |= DW_BUTTON2_MASK; 294 keys |= DW_BUTTON2_MASK;
261 if (state & GDK_BUTTON2_MASK) 295 if (state & GDK_BUTTON2_MASK)
262 keys |= DW_BUTTON3_MASK; 296 keys |= DW_BUTTON3_MASK;
263 297
264 retval = motionfunc(widget, x, y, keys, work->data); 298 retval = motionfunc(work.window, x, y, keys, work.data);
265 } 299 }
266 return retval; 300 return retval;
267 } 301 }
268 302
269 static gint _delete_event(GtkWidget *widget, GdkEvent *event, gpointer data) 303 static gint _delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)
270 { 304 {
271 SignalHandler *work = (SignalHandler *)data; 305 SignalHandler work = _get_signal_handler(widget, data);
272 int retval = FALSE; 306 int retval = FALSE;
273 307
274 if(work) 308 if(work.window)
275 { 309 {
276 int (*closefunc)(HWND, void *) = work->func; 310 int (*closefunc)(HWND, void *) = work.func;
277 311
278 retval = closefunc(widget, work->data); 312 retval = closefunc(work.window, work.data);
279 } 313 }
280 return retval; 314 return retval;
281 } 315 }
282 316
283 static gint _key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data) 317 static gint _key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
284 { 318 {
285 SignalHandler *work = (SignalHandler *)data; 319 SignalHandler work = _get_signal_handler(widget, data);
286 int retval = FALSE; 320 int retval = FALSE;
287 321
288 if(work) 322 if(work.window)
289 { 323 {
290 int (*keypressfunc)(HWND, char, int, int, void *) = work->func; 324 int (*keypressfunc)(HWND, char, int, int, void *) = work.func;
291 325
292 retval = keypressfunc(widget, *event->string, event->keyval, 326 retval = keypressfunc(work.window, *event->string, event->keyval,
293 event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK), work->data); 327 event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK), work.data);
294 } 328 }
295 return retval; 329 return retval;
296 } 330 }
297 331
298 static gint _generic_event(GtkWidget *widget, gpointer data) 332 static gint _generic_event(GtkWidget *widget, gpointer data)
299 { 333 {
300 SignalHandler *work = (SignalHandler *)data; 334 SignalHandler work = _get_signal_handler(widget, data);
301 int retval = FALSE; 335 int retval = FALSE;
302 336
303 if(work) 337 if(work.window)
304 { 338 {
305 int (*genericfunc)(HWND, void *) = work->func; 339 int (*genericfunc)(HWND, void *) = work.func;
306 340
307 retval = genericfunc(widget, work->data); 341 retval = genericfunc(work.window, work.data);
308 } 342 }
309 return retval; 343 return retval;
310 } 344 }
311 345
312 static gint _activate_event(GtkWidget *widget, gpointer data) 346 static gint _activate_event(GtkWidget *widget, gpointer data)
313 { 347 {
314 SignalHandler *work = (SignalHandler *)data; 348 SignalHandler work = _get_signal_handler(widget, data);
315 int retval = FALSE; 349 int retval = FALSE;
316 350
317 if(work && !_dw_ignore_click) 351 if(work.window && !_dw_ignore_click)
318 { 352 {
319 int (*activatefunc)(HWND, void *) = work->func; 353 int (*activatefunc)(HWND, void *) = work.func;
320 354
321 retval = activatefunc(popup ? popup : work->window, work->data); 355 retval = activatefunc(popup ? popup : work.window, work.data);
322 } 356 }
323 return retval; 357 return retval;
324 } 358 }
325 359
326 static gint _configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer data) 360 static gint _configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer data)
327 { 361 {
328 SignalHandler *work = (SignalHandler *)data; 362 SignalHandler work = _get_signal_handler(widget, data);
329 int retval = FALSE; 363 int retval = FALSE;
330 364
331 if(work) 365 if(work.window)
332 { 366 {
333 int (*sizefunc)(HWND, int, int, void *) = work->func; 367 int (*sizefunc)(HWND, int, int, void *) = work.func;
334 368
335 retval = sizefunc(widget, event->width, event->height, work->data); 369 retval = sizefunc(work.window, event->width, event->height, work.data);
336 } 370 }
337 return retval; 371 return retval;
338 } 372 }
339 373
340 static gint _expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer data) 374 static gint _expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer data)
341 { 375 {
342 SignalHandler *work = (SignalHandler *)data; 376 SignalHandler work = _get_signal_handler(widget, data);
343 int retval = FALSE; 377 int retval = FALSE;
344 378
345 if(work) 379 if(work.window)
346 { 380 {
347 DWExpose exp; 381 DWExpose exp;
348 int (*exposefunc)(HWND, DWExpose *, void *) = work->func; 382 int (*exposefunc)(HWND, DWExpose *, void *) = work.func;
349 383
350 exp.x = event->area.x; 384 exp.x = event->area.x;
351 exp.y = event->area.y; 385 exp.y = event->area.y;
352 exp.width = event->area.width; 386 exp.width = event->area.width;
353 exp.height = event->area.height; 387 exp.height = event->area.height;
354 retval = exposefunc(widget, &exp, work->data); 388 retval = exposefunc(work.window, &exp, work.data);
355 } 389 }
356 return retval; 390 return retval;
357 } 391 }
358 392
359 static gint _item_select_event(GtkWidget *widget, GtkWidget *child, gpointer data) 393 static gint _item_select_event(GtkWidget *widget, GtkWidget *child, gpointer data)
360 { 394 {
361 SignalHandler *work = (SignalHandler *)data; 395 SignalHandler work = _get_signal_handler(widget, data);
362 static int _dw_recursing = 0; 396 static int _dw_recursing = 0;
363 int retval = FALSE; 397 int retval = FALSE;
364 398
365 if(_dw_recursing) 399 if(_dw_recursing)
366 return FALSE; 400 return FALSE;
367 401
368 if(work) 402 if(work.window)
369 { 403 {
370 int (*selectfunc)(HWND, int, void *) = work->func; 404 int (*selectfunc)(HWND, int, void *) = work.func;
371 GList *list; 405 GList *list;
372 int item = 0; 406 int item = 0;
373 407
374 _dw_recursing = 1; 408 _dw_recursing = 1;
375 409
376 if(GTK_IS_COMBO(work->window)) 410 if(GTK_IS_COMBO(work.window))
377 list = GTK_LIST(GTK_COMBO(work->window)->list)->children; 411 list = GTK_LIST(GTK_COMBO(work.window)->list)->children;
378 else if(GTK_IS_LIST(widget)) 412 else if(GTK_IS_LIST(widget))
379 list = GTK_LIST(widget)->children; 413 list = GTK_LIST(widget)->children;
380 else 414 else
381 return FALSE; 415 return FALSE;
382 416
383 while(list) 417 while(list)
384 { 418 {
385 if(list->data == (gpointer)child) 419 if(list->data == (gpointer)child)
386 { 420 {
387 if(!gtk_object_get_data(GTK_OBJECT(work->window), "_dw_appending")) 421 if(!gtk_object_get_data(GTK_OBJECT(work.window), "_dw_appending"))
388 { 422 {
389 gtk_object_set_data(GTK_OBJECT(work->window), "_dw_item", (gpointer)item); 423 gtk_object_set_data(GTK_OBJECT(work.window), "_dw_item", (gpointer)item);
390 if(selectfunc) 424 if(selectfunc)
391 retval = selectfunc(work->window, item, work->data); 425 retval = selectfunc(work.window, item, work.data);
392 } 426 }
393 break; 427 break;
394 } 428 }
395 item++; 429 item++;
396 list = list->next; 430 list = list->next;
400 return retval; 434 return retval;
401 } 435 }
402 436
403 static gint _container_context_event(GtkWidget *widget, GdkEventButton *event, gpointer data) 437 static gint _container_context_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
404 { 438 {
405 SignalHandler *work = (SignalHandler *)data; 439 SignalHandler work = _get_signal_handler(widget, data);
406 int retval = FALSE; 440 int retval = FALSE;
407 441
408 if(work) 442 if(work.window)
409 { 443 {
410 if(event->button == 3) 444 if(event->button == 3)
411 { 445 {
412 int (*contextfunc)(HWND, char *, int, int, void *, void *) = work->func; 446 int (*contextfunc)(HWND, char *, int, int, void *, void *) = work.func;
413 char *text; 447 char *text;
414 int row, col; 448 int row, col;
415 449
416 gtk_clist_get_selection_info(GTK_CLIST(widget), event->x, event->y, &row, &col); 450 gtk_clist_get_selection_info(GTK_CLIST(widget), event->x, event->y, &row, &col);
417 451
418 text = (char *)gtk_clist_get_row_data(GTK_CLIST(widget), row); 452 text = (char *)gtk_clist_get_row_data(GTK_CLIST(widget), row);
419 retval = contextfunc(work->window, text, event->x, event->y, work->data, NULL); 453 retval = contextfunc(work.window, text, event->x, event->y, work.data, NULL);
420 } 454 }
421 } 455 }
422 return retval; 456 return retval;
423 } 457 }
424 458
425 static gint _tree_context_event(GtkWidget *widget, GdkEventButton *event, gpointer data) 459 static gint _tree_context_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
426 { 460 {
427 SignalHandler *work = (SignalHandler *)data; 461 SignalHandler work = _get_signal_handler(widget, data);
428 int retval = FALSE; 462 int retval = FALSE;
429 463
430 if(work) 464 if(work.window)
431 { 465 {
432 if(event->button == 3) 466 if(event->button == 3)
433 { 467 {
434 #if GTK_MAJOR_VERSION > 1 468 #if GTK_MAJOR_VERSION > 1
435 int (*contextfunc)(HWND, char *, int, int, void *, void *) = work->func; 469 int (*contextfunc)(HWND, char *, int, int, void *, void *) = work.func;
436 char *text = NULL; 470 char *text = NULL;
437 void *itemdata = NULL; 471 void *itemdata = NULL;
438 472
439 if(widget && GTK_IS_TREE_VIEW(widget)) 473 if(widget && GTK_IS_TREE_VIEW(widget))
440 { 474 {
446 GtkTreeModel *store = (GtkTreeModel *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_tree_store"); 480 GtkTreeModel *store = (GtkTreeModel *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_tree_store");
447 gtk_tree_model_get(store, &iter, 0, &text, 2, &itemdata, -1); 481 gtk_tree_model_get(store, &iter, 0, &text, 2, &itemdata, -1);
448 } 482 }
449 } 483 }
450 484
451 retval = contextfunc(work->window, text, event->x, event->y, work->data, itemdata); 485 retval = contextfunc(work.window, text, event->x, event->y, work.data, itemdata);
452 #else 486 #else
453 int (*contextfunc)(HWND, char *, int, int, void *, void *) = work->func; 487 int (*contextfunc)(HWND, char *, int, int, void *, void *) = work.func;
454 char *text = (char *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_text"); 488 char *text = (char *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_text");
455 void *itemdata = (void *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_itemdata"); 489 void *itemdata = (void *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_itemdata");
456 490
457 if(widget != work->window) 491 if(widget != work.window)
458 { 492 {
459 GtkWidget *tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(work->window)); 493 GtkWidget *tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(work.window));
460 494
461 if(tree && GTK_IS_TREE(tree)) 495 if(tree && GTK_IS_TREE(tree))
462 { 496 {
463 GtkWidget *lastselect = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_lastselect"); 497 GtkWidget *lastselect = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_lastselect");
464 498
468 itemdata = (void *)gtk_object_get_data(GTK_OBJECT(lastselect), "_dw_itemdata"); 502 itemdata = (void *)gtk_object_get_data(GTK_OBJECT(lastselect), "_dw_itemdata");
469 } 503 }
470 } 504 }
471 } 505 }
472 506
473 retval = contextfunc(work->window, text, event->x, event->y, work->data, itemdata); 507 retval = contextfunc(work.window, text, event->x, event->y, work.data, itemdata);
474 #endif 508 #endif
475 } 509 }
476 } 510 }
477 return retval; 511 return retval;
478 } 512 }
479 513
480 #if GTK_MAJOR_VERSION > 1 514 #if GTK_MAJOR_VERSION > 1
481 static gint _tree_select_event(GtkTreeSelection *sel, gpointer data) 515 static gint _tree_select_event(GtkTreeSelection *sel, gpointer data)
482 { 516 {
483 SignalHandler *work = (SignalHandler *)data; 517 GtkWidget *item, *widget = (GtkWidget *)gtk_tree_selection_get_tree_view(sel);
518 SignalHandler work = _get_signal_handler(widget, data);
484 int retval = FALSE; 519 int retval = FALSE;
485 520
486 if(work) 521 if(widget && work.window)
487 { 522 {
488 int (*treeselectfunc)(HWND, HTREEITEM, char *, void *, void *) = work->func; 523 int (*treeselectfunc)(HWND, HTREEITEM, char *, void *, void *) = work.func;
489 GtkTreeIter iter; 524 GtkTreeIter iter;
490 char *text = NULL; 525 char *text = NULL;
491 void *itemdata = NULL; 526 void *itemdata = NULL;
492 GtkWidget *item, *widget = (GtkWidget *)gtk_tree_selection_get_tree_view(sel);
493 527
494 if(widget && gtk_tree_selection_get_selected(sel, NULL, &iter)) 528 if(gtk_tree_selection_get_selected(sel, NULL, &iter))
495 { 529 {
496 GtkTreeModel *store = (GtkTreeModel *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_tree_store"); 530 GtkTreeModel *store = (GtkTreeModel *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_tree_store");
497 gtk_tree_model_get(store, &iter, 0, &text, 2, &itemdata, 3, &item, -1); 531 gtk_tree_model_get(store, &iter, 0, &text, 2, &itemdata, 3, &item, -1);
498 retval = treeselectfunc(work->window, (HTREEITEM)item, text, work->data, itemdata); 532 retval = treeselectfunc(work.window, (HTREEITEM)item, text, work.data, itemdata);
499 } 533 }
500 } 534 }
501 return retval; 535 return retval;
502 } 536 }
503 #else 537 #else
504 static gint _tree_select_event(GtkTree *tree, GtkWidget *child, gpointer data) 538 static gint _tree_select_event(GtkTree *tree, GtkWidget *child, gpointer data)
505 { 539 {
506 SignalHandler *work = (SignalHandler *)data; 540 SignalHandler work = _get_signal_handler((GtkWidget *)tree, data);
507 GtkWidget *treeroot = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(child), "_dw_tree"); 541 GtkWidget *treeroot = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(child), "_dw_tree");
508 int retval = FALSE; 542 int retval = FALSE;
509 543
510 if(treeroot && GTK_IS_TREE(treeroot)) 544 if(treeroot && GTK_IS_TREE(treeroot))
511 { 545 {
513 if(lastselect && GTK_IS_TREE_ITEM(lastselect)) 547 if(lastselect && GTK_IS_TREE_ITEM(lastselect))
514 gtk_tree_item_deselect(GTK_TREE_ITEM(lastselect)); 548 gtk_tree_item_deselect(GTK_TREE_ITEM(lastselect));
515 gtk_object_set_data(GTK_OBJECT(treeroot), "_dw_lastselect", (gpointer)child); 549 gtk_object_set_data(GTK_OBJECT(treeroot), "_dw_lastselect", (gpointer)child);
516 } 550 }
517 551
518 if(work) 552 if(work.window)
519 { 553 {
520 int (*treeselectfunc)(HWND, HTREEITEM, char *, void *, void *) = work->func; 554 int (*treeselectfunc)(HWND, HTREEITEM, char *, void *, void *) = work.func;
521 char *text = (char *)gtk_object_get_data(GTK_OBJECT(child), "_dw_text"); 555 char *text = (char *)gtk_object_get_data(GTK_OBJECT(child), "_dw_text");
522 void *itemdata = (void *)gtk_object_get_data(GTK_OBJECT(child), "_dw_itemdata"); 556 void *itemdata = (void *)gtk_object_get_data(GTK_OBJECT(child), "_dw_itemdata");
523 retval = treeselectfunc(work->window, (HTREEITEM)child, text, work->data, itemdata); 557 retval = treeselectfunc(work.window, (HTREEITEM)child, text, work.data, itemdata);
524 } 558 }
525 return retval; 559 return retval;
526 } 560 }
527 #endif 561 #endif
528 562
529 static gint _container_select_event(GtkWidget *widget, GdkEventButton *event, gpointer data) 563 static gint _container_select_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
530 { 564 {
531 SignalHandler *work = (SignalHandler *)data; 565 SignalHandler work = _get_signal_handler(widget, data);
532 int retval = FALSE; 566 int retval = FALSE;
533 567
534 if(work) 568 if(work.window)
535 { 569 {
536 if(event->button == 1 && event->type == GDK_2BUTTON_PRESS) 570 if(event->button == 1 && event->type == GDK_2BUTTON_PRESS)
537 { 571 {
538 int (*contextfunc)(HWND, char *, void *) = work->func; 572 int (*contextfunc)(HWND, char *, void *) = work.func;
539 char *text; 573 char *text;
540 int row, col; 574 int row, col;
541 575
542 gtk_clist_get_selection_info(GTK_CLIST(widget), event->x, event->y, &row, &col); 576 gtk_clist_get_selection_info(GTK_CLIST(widget), event->x, event->y, &row, &col);
543 577
544 text = (char *)gtk_clist_get_row_data(GTK_CLIST(widget), row); 578 text = (char *)gtk_clist_get_row_data(GTK_CLIST(widget), row);
545 retval = contextfunc(work->window, text, work->data); 579 retval = contextfunc(work.window, text, work.data);
546 gtk_object_set_data(GTK_OBJECT(widget), "_dw_double_click", (gpointer)1); 580 gtk_object_set_data(GTK_OBJECT(widget), "_dw_double_click", (gpointer)1);
547 } 581 }
548 } 582 }
549 return retval; 583 return retval;
550 } 584 }
568 } 602 }
569 603
570 604
571 static gint _switch_page_event(GtkNotebook *notebook, GtkNotebookPage *page, guint page_num, gpointer data) 605 static gint _switch_page_event(GtkNotebook *notebook, GtkNotebookPage *page, guint page_num, gpointer data)
572 { 606 {
573 SignalHandler *work = (SignalHandler *)data; 607 SignalHandler work = _get_signal_handler((GtkWidget *)notebook, data);
574 int retval = FALSE; 608 int retval = FALSE;
575 609
576 if(work) 610 if(work.window)
577 { 611 {
578 int (*switchpagefunc)(HWND, unsigned long, void *) = work->func; 612 int (*switchpagefunc)(HWND, unsigned long, void *) = work.func;
579 retval = switchpagefunc(work->window, _get_logical_page(GTK_WIDGET(notebook), page_num), work->data); 613 retval = switchpagefunc(work.window, _get_logical_page(GTK_WIDGET(notebook), page_num), work.data);
580 } 614 }
581 return retval; 615 return retval;
582 } 616 }
583 617
584 static gint _container_select_row(GtkWidget *widget, gint row, gint column, GdkEventButton *event, gpointer data) 618 static gint _container_select_row(GtkWidget *widget, gint row, gint column, GdkEventButton *event, gpointer data)
585 { 619 {
586 SignalHandler *work = (SignalHandler *)data; 620 SignalHandler work = _get_signal_handler(widget, data);
587 char *rowdata = gtk_clist_get_row_data(GTK_CLIST(widget), row); 621 char *rowdata = gtk_clist_get_row_data(GTK_CLIST(widget), row);
588 int (*contextfunc)(HWND, HWND, char *, void *, void *) = work->func; 622 int (*contextfunc)(HWND, HWND, char *, void *, void *) = work.func;
623
624 if(!work.window)
625 return TRUE;
589 626
590 if(gtk_object_get_data(GTK_OBJECT(widget), "_dw_double_click")) 627 if(gtk_object_get_data(GTK_OBJECT(widget), "_dw_double_click"))
591 { 628 {
592 gtk_object_set_data(GTK_OBJECT(widget), "_dw_double_click", (gpointer)0); 629 gtk_object_set_data(GTK_OBJECT(widget), "_dw_double_click", (gpointer)0);
593 return TRUE; 630 return TRUE;
594 } 631 }
595 return contextfunc(work->window, 0, rowdata, work->data, 0);; 632 return contextfunc(work.window, 0, rowdata, work.data, 0);;
596 } 633 }
597 634
598 static int _round_value(gfloat val) 635 static int _round_value(gfloat val)
599 { 636 {
600 int newval = (int)val; 637 int newval = (int)val;
605 return newval; 642 return newval;
606 } 643 }
607 644
608 static gint _value_changed_event(GtkAdjustment *adjustment, gpointer data) 645 static gint _value_changed_event(GtkAdjustment *adjustment, gpointer data)
609 { 646 {
610 SignalHandler *work = (SignalHandler *)data; 647 int max = _round_value(adjustment->upper);
611 648 int val = _round_value(adjustment->value);
612 if(work) 649 GtkWidget *slider = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(adjustment), "_dw_slider");
613 { 650 GtkWidget *scrollbar = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(adjustment), "_dw_scrollbar");
614 int (*valuechangedfunc)(HWND, int, void *) = work->func; 651
615 int max = _round_value(adjustment->upper); 652 if(slider)
616 int val = _round_value(adjustment->value); 653 {
617 GtkWidget *slider = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(adjustment), "_dw_slider"); 654 SignalHandler work = _get_signal_handler((GtkWidget *)adjustment, data);
618 GtkWidget *scrollbar = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(adjustment), "_dw_scrollbar"); 655
619 656 if(work.window)
620 if(slider) 657 {
621 { 658 int (*valuechangedfunc)(HWND, int, void *) = work.func;
659
622 if(GTK_IS_VSCALE(slider)) 660 if(GTK_IS_VSCALE(slider))
623 valuechangedfunc(work->window, (max - val) - 1, work->data); 661 valuechangedfunc(work.window, (max - val) - 1, work.data);
624 else 662 else
625 valuechangedfunc(work->window, val, work->data); 663 valuechangedfunc(work.window, val, work.data);
626 } 664 }
627 else if(scrollbar) 665 }
628 { 666 else if(scrollbar)
629 valuechangedfunc(work->window, val, work->data); 667 {
668 SignalHandler work = _get_signal_handler((GtkWidget *)adjustment, data);
669
670 if(work.window)
671 {
672 int (*valuechangedfunc)(HWND, int, void *) = work.func;
673
674 valuechangedfunc(work.window, val, work.data);
630 } 675 }
631 } 676 }
632 return FALSE; 677 return FALSE;
633 } 678 }
634 679
3747 { 3792 {
3748 subtree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(parent)); 3793 subtree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(parent));
3749 if(!subtree) 3794 if(!subtree)
3750 { 3795 {
3751 void *thisfunc = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_select_child_func"); 3796 void *thisfunc = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_select_child_func");
3752 void *work = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_select_child_data"); 3797 void *mydata = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_select_child_data");
3798 SignalHandler work = _get_signal_handler(tree, mydata);
3753 3799
3754 subtree = gtk_tree_new(); 3800 subtree = gtk_tree_new();
3755 3801
3756 if(thisfunc && work) 3802 if(thisfunc && work.window)
3757 gtk_signal_connect(GTK_OBJECT(subtree), "select-child", GTK_SIGNAL_FUNC(thisfunc), work); 3803 {
3804 gtk_signal_connect(GTK_OBJECT(subtree), "select-child", GTK_SIGNAL_FUNC(thisfunc),
3805 (gpointer)_set_signal_handler(subtree, work.window, work.func, work.data));
3806 }
3758 3807
3759 thisfunc = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_container_context_func"); 3808 thisfunc = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_container_context_func");
3760 work = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_container_context_data"); 3809 mydata = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_container_context_data");
3761 3810 work = _get_signal_handler(tree, mydata);
3762 if(thisfunc && work) 3811
3763 gtk_signal_connect(GTK_OBJECT(subtree), "button_press_event", GTK_SIGNAL_FUNC(thisfunc), work); 3812 if(thisfunc && work.window)
3813 {
3814 gtk_signal_connect(GTK_OBJECT(subtree), "button_press_event", GTK_SIGNAL_FUNC(thisfunc),
3815 (gpointer)_set_signal_handler(subtree, work.window, work.func, work.data));
3816 }
3764 3817
3765 gtk_object_set_user_data(GTK_OBJECT(parent), subtree); 3818 gtk_object_set_user_data(GTK_OBJECT(parent), subtree);
3766 gtk_tree_set_selection_mode(GTK_TREE(subtree), GTK_SELECTION_SINGLE); 3819 gtk_tree_set_selection_mode(GTK_TREE(subtree), GTK_SELECTION_SINGLE);
3767 gtk_tree_set_view_mode(GTK_TREE(subtree), GTK_TREE_VIEW_ITEM); 3820 gtk_tree_set_view_mode(GTK_TREE(subtree), GTK_TREE_VIEW_ITEM);
3768 gtk_tree_item_set_subtree(GTK_TREE_ITEM(parent), subtree); 3821 gtk_tree_item_set_subtree(GTK_TREE_ITEM(parent), subtree);
3866 { 3919 {
3867 subtree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(parent)); 3920 subtree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(parent));
3868 if(!subtree) 3921 if(!subtree)
3869 { 3922 {
3870 void *thisfunc = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_select_child_func"); 3923 void *thisfunc = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_select_child_func");
3871 void *work = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_select_child_data"); 3924 void *mydata = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_select_child_data");
3925 SignalHandler work = _get_signal_handler(tree, mydata);
3872 3926
3873 subtree = gtk_tree_new(); 3927 subtree = gtk_tree_new();
3874 3928
3875 if(thisfunc && work) 3929 if(thisfunc && work.window)
3876 gtk_signal_connect(GTK_OBJECT(subtree), "select-child", GTK_SIGNAL_FUNC(thisfunc), work); 3930 {
3931 gtk_signal_connect(GTK_OBJECT(subtree), "select-child", GTK_SIGNAL_FUNC(thisfunc),
3932 (gpointer)_set_signal_handler(subtree, work.window, work.func, work.data));
3933 }
3877 3934
3878 thisfunc = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_container_context_func"); 3935 thisfunc = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_container_context_func");
3879 work = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_container_context_data"); 3936 mydata = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_container_context_data");
3880 3937 work = _get_signal_handler(tree, mydata);
3881 if(thisfunc && work) 3938
3882 gtk_signal_connect(GTK_OBJECT(subtree), "button_press_event", GTK_SIGNAL_FUNC(thisfunc), work); 3939 if(thisfunc && work.window)
3940 {
3941 gtk_signal_connect(GTK_OBJECT(subtree), "button_press_event", GTK_SIGNAL_FUNC(thisfunc),
3942 (gpointer)_set_signal_handler(subtree, work.window, work.func, work.data));
3943 }
3883 3944
3884 gtk_object_set_user_data(GTK_OBJECT(parent), subtree); 3945 gtk_object_set_user_data(GTK_OBJECT(parent), subtree);
3885 gtk_tree_set_selection_mode(GTK_TREE(subtree), GTK_SELECTION_SINGLE); 3946 gtk_tree_set_selection_mode(GTK_TREE(subtree), GTK_SELECTION_SINGLE);
3886 gtk_tree_set_view_mode(GTK_TREE(subtree), GTK_TREE_VIEW_ITEM); 3947 gtk_tree_set_view_mode(GTK_TREE(subtree), GTK_TREE_VIEW_ITEM);
3887 gtk_tree_item_set_subtree(GTK_TREE_ITEM(parent), subtree); 3948 gtk_tree_item_set_subtree(GTK_TREE_ITEM(parent), subtree);
7556 * sigfunc: The pointer to the function to be used as the callback. 7617 * sigfunc: The pointer to the function to be used as the callback.
7557 * data: User data to be passed to the handler function. 7618 * data: User data to be passed to the handler function.
7558 */ 7619 */
7559 void dw_signal_connect(HWND window, char *signame, void *sigfunc, void *data) 7620 void dw_signal_connect(HWND window, char *signame, void *sigfunc, void *data)
7560 { 7621 {
7561 SignalHandler *work = malloc(sizeof(SignalHandler));
7562 void *thisfunc = _findsigfunc(signame); 7622 void *thisfunc = _findsigfunc(signame);
7563 char *thisname = signame; 7623 char *thisname = signame;
7564 HWND thiswindow = window; 7624 HWND thiswindow = window;
7565 int _locked_by_me = FALSE; 7625 int _locked_by_me = FALSE;
7566 7626
7583 #if GTK_MAJOR_VERSION > 1 7643 #if GTK_MAJOR_VERSION > 1
7584 else if(GTK_IS_TREE_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_CONTEXT) == 0) 7644 else if(GTK_IS_TREE_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_CONTEXT) == 0)
7585 { 7645 {
7586 thisfunc = _findsigfunc("tree-context"); 7646 thisfunc = _findsigfunc("tree-context");
7587 7647
7588 work->window = window; 7648 gtk_signal_connect(GTK_OBJECT(thiswindow), "button_press_event", GTK_SIGNAL_FUNC(thisfunc),
7589 work->data = data; 7649 (gpointer)_set_signal_handler(thiswindow, window, sigfunc, data));
7590 work->func = sigfunc; 7650 gtk_signal_connect(GTK_OBJECT(window), "button_press_event", GTK_SIGNAL_FUNC(thisfunc),
7591 7651 (gpointer)_set_signal_handler(window, window, sigfunc, data));
7592 gtk_signal_connect(GTK_OBJECT(thiswindow), "button_press_event", GTK_SIGNAL_FUNC(thisfunc), work);
7593 gtk_signal_connect(GTK_OBJECT(window), "button_press_event", GTK_SIGNAL_FUNC(thisfunc), work);
7594 DW_MUTEX_UNLOCK; 7652 DW_MUTEX_UNLOCK;
7595 return; 7653 return;
7596 } 7654 }
7597 else if(GTK_IS_TREE_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_SELECT) == 0) 7655 else if(GTK_IS_TREE_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_SELECT) == 0)
7598 { 7656 {
7599 work->window = window;
7600 work->data = data;
7601 work->func = sigfunc;
7602
7603 thiswindow = (GtkWidget *)gtk_tree_view_get_selection(GTK_TREE_VIEW(thiswindow)); 7657 thiswindow = (GtkWidget *)gtk_tree_view_get_selection(GTK_TREE_VIEW(thiswindow));
7604 thisname = "changed"; 7658 thisname = "changed";
7605 7659
7606 g_signal_connect(G_OBJECT(thiswindow), thisname, (GCallback)thisfunc, work); 7660 g_signal_connect(G_OBJECT(thiswindow), thisname, (GCallback)thisfunc,
7661 (gpointer)_set_signal_handler(thiswindow, window, sigfunc, data));
7607 DW_MUTEX_UNLOCK; 7662 DW_MUTEX_UNLOCK;
7608 return; 7663 return;
7609 } 7664 }
7610 #else 7665 #else
7611 else if(GTK_IS_TREE(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_CONTEXT) == 0) 7666 else if(GTK_IS_TREE(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_CONTEXT) == 0)
7612 { 7667 {
7668 int counter = (int)_set_signal_handler(thiswindow, window, sigfunc, data);
7669
7613 thisfunc = _findsigfunc("tree-context"); 7670 thisfunc = _findsigfunc("tree-context");
7614 7671
7615 work->window = window;
7616 work->data = data;
7617 work->func = sigfunc;
7618
7619 gtk_object_set_data(GTK_OBJECT(thiswindow), "_dw_container_context_func", (gpointer)thisfunc); 7672 gtk_object_set_data(GTK_OBJECT(thiswindow), "_dw_container_context_func", (gpointer)thisfunc);
7620 gtk_object_set_data(GTK_OBJECT(thiswindow), "_dw_container_context_data", (gpointer)work); 7673 gtk_object_set_data(GTK_OBJECT(thiswindow), "_dw_container_context_data", (gpointer)counter);
7621 gtk_signal_connect(GTK_OBJECT(thiswindow), "button_press_event", GTK_SIGNAL_FUNC(thisfunc), work); 7674 gtk_signal_connect(GTK_OBJECT(thiswindow), "button_press_event", GTK_SIGNAL_FUNC(thisfunc), (gpointer)counter);
7622 gtk_signal_connect(GTK_OBJECT(window), "button_press_event", GTK_SIGNAL_FUNC(thisfunc), work); 7675 gtk_signal_connect(GTK_OBJECT(window), "button_press_event", GTK_SIGNAL_FUNC(thisfunc),
7676 (gpointer)_set_signal_handler(window, window, sigfunc, data));
7623 DW_MUTEX_UNLOCK; 7677 DW_MUTEX_UNLOCK;
7624 return; 7678 return;
7625 } 7679 }
7626 else if(GTK_IS_TREE(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_SELECT) == 0) 7680 else if(GTK_IS_TREE(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_SELECT) == 0)
7627 { 7681 {
7628 if(thisfunc) 7682 if(thisfunc)
7629 { 7683 {
7630 gtk_object_set_data(GTK_OBJECT(thiswindow), "_dw_select_child_func", (gpointer)thisfunc); 7684 gtk_object_set_data(GTK_OBJECT(thiswindow), "_dw_select_child_func", (gpointer)thisfunc);
7631 gtk_object_set_data(GTK_OBJECT(thiswindow), "_dw_select_child_data", (gpointer)work); 7685 gtk_object_set_data(GTK_OBJECT(thiswindow), "_dw_select_child_data",
7686 (gpointer)_set_signal_handler(thiswindow, window, sigfunc, data));
7632 } 7687 }
7633 thisname = "select-child"; 7688 thisname = "select-child";
7634 } 7689 }
7635 #endif 7690 #endif
7636 else if(GTK_IS_CLIST(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_ENTER) == 0) 7691 else if(GTK_IS_CLIST(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_ENTER) == 0)
7676 thisname = "switch-page"; 7731 thisname = "switch-page";
7677 } 7732 }
7678 7733
7679 if(!thisfunc || !thiswindow) 7734 if(!thisfunc || !thiswindow)
7680 { 7735 {
7681 free(work);
7682 DW_MUTEX_UNLOCK; 7736 DW_MUTEX_UNLOCK;
7683 return; 7737 return;
7684 } 7738 }
7685 7739
7686 work->window = window; 7740 gtk_signal_connect(GTK_OBJECT(thiswindow), thisname, GTK_SIGNAL_FUNC(thisfunc),
7687 work->data = data; 7741 (gpointer)_set_signal_handler(thiswindow, window, sigfunc, data));
7688 work->func = sigfunc;
7689
7690 gtk_signal_connect(GTK_OBJECT(thiswindow), thisname, GTK_SIGNAL_FUNC(thisfunc), work);
7691 DW_MUTEX_UNLOCK; 7742 DW_MUTEX_UNLOCK;
7692 } 7743 }
7693 7744
7694 /* 7745 /*
7695 * Removes callbacks for a given window with given name. 7746 * Removes callbacks for a given window with given name.