Mercurial > dwindows

comparison gtk/dw.c @ 258:b2c436c84e5d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added code to create a lookup table for icon data loaded in dw_icon_load_from_file() on Unix.
author bsmith@81767d24-ef19-dc11-ae90-00e081727c95
date Thu, 20 Feb 2003 23:33:08 +0000
parents 9ea4ac9a097f
children 22a215209887
comparison
equal deleted inserted replaced
257:9ea4ac9a097f 258:b2c436c84e5d
55 GdkColor _foreground[DW_THREAD_LIMIT]; 55 GdkColor _foreground[DW_THREAD_LIMIT];
56 GdkColor _background[DW_THREAD_LIMIT]; 56 GdkColor _background[DW_THREAD_LIMIT];
57 57
58 GtkWidget *last_window = NULL, *popup = NULL; 58 GtkWidget *last_window = NULL, *popup = NULL;
59 59
60 int _dw_file_active = 0, _dw_ignore_click = 0, _dw_unselecting = 0; 60 static int _dw_file_active = 0, _dw_ignore_click = 0, _dw_unselecting = 0;
61 pthread_t _dw_thread = (pthread_t)-1; 61 static pthread_t _dw_thread = (pthread_t)-1;
62 int _dw_mutex_locked[DW_THREAD_LIMIT]; 62 static int _dw_mutex_locked[DW_THREAD_LIMIT];
63 /* Use default border size for the default enlightenment theme */ 63 /* Use default border size for the default enlightenment theme */
64 int _dw_border_width = 12, _dw_border_height = 28; 64 static int _dw_border_width = 12, _dw_border_height = 28;
65 65
66 #define DW_MUTEX_LOCK { int index = _find_thread_index(dw_thread_id()); if(pthread_self() != _dw_thread && _dw_mutex_locked[index] == FALSE) { gdk_threads_enter(); _dw_mutex_locked[index] = TRUE; _locked_by_me = TRUE; } } 66 #define DW_MUTEX_LOCK { int index = _find_thread_index(dw_thread_id()); if(pthread_self() != _dw_thread && _dw_mutex_locked[index] == FALSE) { gdk_threads_enter(); _dw_mutex_locked[index] = TRUE; _locked_by_me = TRUE; } }
67 #define DW_MUTEX_UNLOCK { if(pthread_self() != _dw_thread && _locked_by_me == TRUE) { gdk_threads_leave(); _dw_mutex_locked[_find_thread_index(dw_thread_id())] = FALSE; _locked_by_me = FALSE; } } 67 #define DW_MUTEX_UNLOCK { if(pthread_self() != _dw_thread && _locked_by_me == TRUE) { gdk_threads_leave(); _dw_mutex_locked[_find_thread_index(dw_thread_id())] = FALSE; _locked_by_me = FALSE; } }
68 68
69 #define DEFAULT_SIZE_WIDTH 12 69 #define DEFAULT_SIZE_WIDTH 12
70 #define DEFAULT_SIZE_HEIGHT 6 70 #define DEFAULT_SIZE_HEIGHT 6
71 #define DEFAULT_TITLEBAR_HEIGHT 22 71 #define DEFAULT_TITLEBAR_HEIGHT 22
72 72
73 GdkColormap *_dw_cmap = NULL; 73 static GdkColormap *_dw_cmap = NULL;
74 74
75 /* Signal forwarder prototypes */ 75 /* Signal forwarder prototypes */
76 gint _button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data); 76 static gint _button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data);
77 gint _button_release_event(GtkWidget *widget, GdkEventButton *event, gpointer data); 77 static gint _button_release_event(GtkWidget *widget, GdkEventButton *event, gpointer data);
78 gint _motion_notify_event(GtkWidget *widget, GdkEventMotion *event, gpointer data); 78 static gint _motion_notify_event(GtkWidget *widget, GdkEventMotion *event, gpointer data);
79 gint _delete_event(GtkWidget *widget, GdkEvent *event, gpointer data); 79 static gint _delete_event(GtkWidget *widget, GdkEvent *event, gpointer data);
80 gint _key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data); 80 static gint _key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data);
81 gint _generic_event(GtkWidget *widget, gpointer data); 81 static gint _generic_event(GtkWidget *widget, gpointer data);
82 gint _configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer data); 82 static gint _configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer data);
83 gint _activate_event(GtkWidget *widget, gpointer data); 83 static gint _activate_event(GtkWidget *widget, gpointer data);
84 gint _container_select_event(GtkWidget *widget, GdkEventButton *event, gpointer data); 84 static gint _container_select_event(GtkWidget *widget, GdkEventButton *event, gpointer data);
85 gint _container_context_event(GtkWidget *widget, GdkEventButton *event, gpointer data); 85 static gint _container_context_event(GtkWidget *widget, GdkEventButton *event, gpointer data);
86 gint _item_select_event(GtkWidget *widget, GtkWidget *child, gpointer data); 86 static gint _item_select_event(GtkWidget *widget, GtkWidget *child, gpointer data);
87 gint _expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer data); 87 static gint _expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer data);
88 gint _set_focus_event(GtkWindow *window, GtkWidget *widget, gpointer data); 88 static gint _set_focus_event(GtkWindow *window, GtkWidget *widget, gpointer data);
89 gint _tree_context_event(GtkWidget *widget, GdkEventButton *event, gpointer data); 89 static gint _tree_context_event(GtkWidget *widget, GdkEventButton *event, gpointer data);
90 gint _value_changed_event(GtkAdjustment *adjustment, gpointer user_data); 90 static gint _value_changed_event(GtkAdjustment *adjustment, gpointer user_data);
91 #if GTK_MAJOR_VERSION > 1 91 #if GTK_MAJOR_VERSION > 1
92 gint _tree_select_event(GtkTreeSelection *sel, gpointer data); 92 static gint _tree_select_event(GtkTreeSelection *sel, gpointer data);
93 #else 93 #else
94 gint _tree_select_event(GtkTree *tree, GtkWidget *child, gpointer data); 94 static gint _tree_select_event(GtkTree *tree, GtkWidget *child, gpointer data);
95 #endif 95 #endif
96 96
97 typedef struct
98 {
99 GdkPixmap *pixmap;
100 GdkBitmap *mask;
101 int used;
102 unsigned long width, height;
103 } DWPrivatePixmap;
104
105 static DWPrivatePixmap *_PixmapArray = NULL;
106 static int _PixmapCount = 0;
97 107
98 typedef struct 108 typedef struct
99 { 109 {
100 void *func; 110 void *func;
101 char name[30]; 111 char name[30];
111 } SignalHandler; 121 } SignalHandler;
112 122
113 #define SIGNALMAX 16 123 #define SIGNALMAX 16
114 124
115 /* A list of signal forwarders, to account for paramater differences. */ 125 /* A list of signal forwarders, to account for paramater differences. */
116 SignalList SignalTranslate[SIGNALMAX] = { 126 static SignalList SignalTranslate[SIGNALMAX] = {
117 { _configure_event, "configure_event" }, 127 { _configure_event, "configure_event" },
118 { _key_press_event, "key_press_event" }, 128 { _key_press_event, "key_press_event" },
119 { _button_press_event, "button_press_event" }, 129 { _button_press_event, "button_press_event" },
120 { _button_release_event, "button_release_event" }, 130 { _button_release_event, "button_release_event" },
121 { _motion_notify_event, "motion_notify_event" }, 131 { _motion_notify_event, "motion_notify_event" },
135 /* Alignment flags */ 145 /* Alignment flags */
136 #define DW_CENTER 0.5f 146 #define DW_CENTER 0.5f
137 #define DW_LEFT 0.0f 147 #define DW_LEFT 0.0f
138 #define DW_RIGHT 1.0f 148 #define DW_RIGHT 1.0f
139 149
140 void _dw_msleep(long period) 150 static void _dw_msleep(long period)
141 { 151 {
142 #ifdef __sun__ 152 #ifdef __sun__
143 /* usleep() isn't threadsafe on Solaris */ 153 /* usleep() isn't threadsafe on Solaris */
144 struct timespec req; 154 struct timespec req;
145 155
151 usleep(period * 1000); 161 usleep(period * 1000);
152 #endif 162 #endif
153 } 163 }
154 164
155 /* Finds the translation function for a given signal name */ 165 /* Finds the translation function for a given signal name */
156 void *_findsigfunc(char *signame) 166 static void *_findsigfunc(char *signame)
157 { 167 {
158 int z; 168 int z;
159 169
160 for(z=0;z<SIGNALMAX;z++) 170 for(z=0;z<SIGNALMAX;z++)
161 { 171 {
163 return SignalTranslate[z].func; 173 return SignalTranslate[z].func;
164 } 174 }
165 return NULL; 175 return NULL;
166 } 176 }
167 177
168 gint _set_focus_event(GtkWindow *window, GtkWidget *widget, gpointer data) 178 static gint _set_focus_event(GtkWindow *window, GtkWidget *widget, gpointer data)
169 { 179 {
170 SignalHandler *work = (SignalHandler *)data; 180 SignalHandler *work = (SignalHandler *)data;
171 int retval = FALSE; 181 int retval = FALSE;
172 182
173 if(work) 183 if(work)
177 retval = setfocusfunc((HWND)window, work->data); 187 retval = setfocusfunc((HWND)window, work->data);
178 } 188 }
179 return retval; 189 return retval;
180 } 190 }
181 191
182 gint _button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data) 192 static gint _button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
183 { 193 {
184 SignalHandler *work = (SignalHandler *)data; 194 SignalHandler *work = (SignalHandler *)data;
185 int retval = FALSE; 195 int retval = FALSE;
186 196
187 if(work) 197 if(work)
197 retval = buttonfunc(widget, event->x, event->y, mybutton, work->data); 207 retval = buttonfunc(widget, event->x, event->y, mybutton, work->data);
198 } 208 }
199 return retval; 209 return retval;
200 } 210 }
201 211
202 gint _button_release_event(GtkWidget *widget, GdkEventButton *event, gpointer data) 212 static gint _button_release_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
203 { 213 {
204 SignalHandler *work = (SignalHandler *)data; 214 SignalHandler *work = (SignalHandler *)data;
205 int retval = FALSE; 215 int retval = FALSE;
206 216
207 if(work) 217 if(work)
217 retval = buttonfunc(widget, event->x, event->y, mybutton, work->data); 227 retval = buttonfunc(widget, event->x, event->y, mybutton, work->data);
218 } 228 }
219 return retval; 229 return retval;
220 } 230 }
221 231
222 gint _motion_notify_event(GtkWidget *widget, GdkEventMotion *event, gpointer data) 232 static gint _motion_notify_event(GtkWidget *widget, GdkEventMotion *event, gpointer data)
223 { 233 {
224 SignalHandler *work = (SignalHandler *)data; 234 SignalHandler *work = (SignalHandler *)data;
225 int retval = FALSE; 235 int retval = FALSE;
226 236
227 if(work) 237 if(work)
249 retval = motionfunc(widget, x, y, keys, work->data); 259 retval = motionfunc(widget, x, y, keys, work->data);
250 } 260 }
251 return retval; 261 return retval;
252 } 262 }
253 263
254 gint _delete_event(GtkWidget *widget, GdkEvent *event, gpointer data) 264 static gint _delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)
255 { 265 {
256 SignalHandler *work = (SignalHandler *)data; 266 SignalHandler *work = (SignalHandler *)data;
257 int retval = FALSE; 267 int retval = FALSE;
258 268
259 if(work) 269 if(work)
263 retval = closefunc(widget, work->data); 273 retval = closefunc(widget, work->data);
264 } 274 }
265 return retval; 275 return retval;
266 } 276 }
267 277
268 gint _key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data) 278 static gint _key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
269 { 279 {
270 SignalHandler *work = (SignalHandler *)data; 280 SignalHandler *work = (SignalHandler *)data;
271 int retval = FALSE; 281 int retval = FALSE;
272 282
273 if(work) 283 if(work)
277 retval = keypressfunc(widget, *event->string, work->data); 287 retval = keypressfunc(widget, *event->string, work->data);
278 } 288 }
279 return retval; 289 return retval;
280 } 290 }
281 291
282 gint _generic_event(GtkWidget *widget, gpointer data) 292 static gint _generic_event(GtkWidget *widget, gpointer data)
283 { 293 {
284 SignalHandler *work = (SignalHandler *)data; 294 SignalHandler *work = (SignalHandler *)data;
285 int retval = FALSE; 295 int retval = FALSE;
286 296
287 if(work) 297 if(work)
291 retval = genericfunc(widget, work->data); 301 retval = genericfunc(widget, work->data);
292 } 302 }
293 return retval; 303 return retval;
294 } 304 }
295 305
296 gint _activate_event(GtkWidget *widget, gpointer data) 306 static gint _activate_event(GtkWidget *widget, gpointer data)
297 { 307 {
298 SignalHandler *work = (SignalHandler *)data; 308 SignalHandler *work = (SignalHandler *)data;
299 int retval = FALSE; 309 int retval = FALSE;
300 310
301 if(work && !_dw_ignore_click) 311 if(work && !_dw_ignore_click)
305 retval = activatefunc(popup ? popup : work->window, work->data); 315 retval = activatefunc(popup ? popup : work->window, work->data);
306 } 316 }
307 return retval; 317 return retval;
308 } 318 }
309 319
310 gint _configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer data) 320 static gint _configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer data)
311 { 321 {
312 SignalHandler *work = (SignalHandler *)data; 322 SignalHandler *work = (SignalHandler *)data;
313 int retval = FALSE; 323 int retval = FALSE;
314 324
315 if(work) 325 if(work)
319 retval = sizefunc(widget, event->width, event->height, work->data); 329 retval = sizefunc(widget, event->width, event->height, work->data);
320 } 330 }
321 return retval; 331 return retval;
322 } 332 }
323 333
324 gint _expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer data) 334 static gint _expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer data)
325 { 335 {
326 SignalHandler *work = (SignalHandler *)data; 336 SignalHandler *work = (SignalHandler *)data;
327 int retval = FALSE; 337 int retval = FALSE;
328 338
329 if(work) 339 if(work)
338 retval = exposefunc(widget, &exp, work->data); 348 retval = exposefunc(widget, &exp, work->data);
339 } 349 }
340 return retval; 350 return retval;
341 } 351 }
342 352
343 gint _item_select_event(GtkWidget *widget, GtkWidget *child, gpointer data) 353 static gint _item_select_event(GtkWidget *widget, GtkWidget *child, gpointer data)
344 { 354 {
345 SignalHandler *work = (SignalHandler *)data; 355 SignalHandler *work = (SignalHandler *)data;
346 static int _dw_recursing = 0; 356 static int _dw_recursing = 0;
347 int retval = FALSE; 357 int retval = FALSE;
348 358
382 _dw_recursing = 0; 392 _dw_recursing = 0;
383 } 393 }
384 return retval; 394 return retval;
385 } 395 }
386 396
387 gint _container_context_event(GtkWidget *widget, GdkEventButton *event, gpointer data) 397 static gint _container_context_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
388 { 398 {
389 SignalHandler *work = (SignalHandler *)data; 399 SignalHandler *work = (SignalHandler *)data;
390 int retval = FALSE; 400 int retval = FALSE;
391 401
392 if(work) 402 if(work)
404 } 414 }
405 } 415 }
406 return retval; 416 return retval;
407 } 417 }
408 418
409 gint _tree_context_event(GtkWidget *widget, GdkEventButton *event, gpointer data) 419 static gint _tree_context_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
410 { 420 {
411 SignalHandler *work = (SignalHandler *)data; 421 SignalHandler *work = (SignalHandler *)data;
412 int retval = FALSE; 422 int retval = FALSE;
413 423
414 if(work) 424 if(work)
460 } 470 }
461 return retval; 471 return retval;
462 } 472 }
463 473
464 #if GTK_MAJOR_VERSION > 1 474 #if GTK_MAJOR_VERSION > 1
465 gint _tree_select_event(GtkTreeSelection *sel, gpointer data) 475 static gint _tree_select_event(GtkTreeSelection *sel, gpointer data)
466 { 476 {
467 SignalHandler *work = (SignalHandler *)data; 477 SignalHandler *work = (SignalHandler *)data;
468 int retval = FALSE; 478 int retval = FALSE;
469 479
470 if(work) 480 if(work)
483 } 493 }
484 } 494 }
485 return retval; 495 return retval;
486 } 496 }
487 #else 497 #else
488 gint _tree_select_event(GtkTree *tree, GtkWidget *child, gpointer data) 498 static gint _tree_select_event(GtkTree *tree, GtkWidget *child, gpointer data)
489 { 499 {
490 SignalHandler *work = (SignalHandler *)data; 500 SignalHandler *work = (SignalHandler *)data;
491 GtkWidget *treeroot = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(child), "tree"); 501 GtkWidget *treeroot = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(child), "tree");
492 int retval = FALSE; 502 int retval = FALSE;
493 503
508 } 518 }
509 return retval; 519 return retval;
510 } 520 }
511 #endif 521 #endif
512 522
513 gint _container_select_event(GtkWidget *widget, GdkEventButton *event, gpointer data) 523 static gint _container_select_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
514 { 524 {
515 SignalHandler *work = (SignalHandler *)data; 525 SignalHandler *work = (SignalHandler *)data;
516 int retval = FALSE; 526 int retval = FALSE;
517 527
518 if(work) 528 if(work)
530 } 540 }
531 } 541 }
532 return retval; 542 return retval;
533 } 543 }
534 544
535 gint _select_row(GtkWidget *widget, gint row, gint column, GdkEventButton *event, gpointer data) 545 static gint _select_row(GtkWidget *widget, gint row, gint column, GdkEventButton *event, gpointer data)
536 { 546 {
537 GList *tmp = (GList *)gtk_object_get_data(GTK_OBJECT(widget), "selectlist"); 547 GList *tmp = (GList *)gtk_object_get_data(GTK_OBJECT(widget), "selectlist");
538 char *rowdata = gtk_clist_get_row_data(GTK_CLIST(widget), row); 548 char *rowdata = gtk_clist_get_row_data(GTK_CLIST(widget), row);
539 int multi = (int)gtk_object_get_data(GTK_OBJECT(widget), "multi"); 549 int multi = (int)gtk_object_get_data(GTK_OBJECT(widget), "multi");
540 550
550 gtk_object_set_data(GTK_OBJECT(widget), "selectlist", tmp); 560 gtk_object_set_data(GTK_OBJECT(widget), "selectlist", tmp);
551 } 561 }
552 return FALSE; 562 return FALSE;
553 } 563 }
554 564
555 gint _container_select_row(GtkWidget *widget, gint row, gint column, GdkEventButton *event, gpointer data) 565 static gint _container_select_row(GtkWidget *widget, gint row, gint column, GdkEventButton *event, gpointer data)
556 { 566 {
557 SignalHandler *work = (SignalHandler *)data; 567 SignalHandler *work = (SignalHandler *)data;
558 char *rowdata = gtk_clist_get_row_data(GTK_CLIST(widget), row); 568 char *rowdata = gtk_clist_get_row_data(GTK_CLIST(widget), row);
559 int (*contextfunc)(HWND, char *, void *) = work->func; 569 int (*contextfunc)(HWND, char *, void *) = work->func;
560 570
561 return contextfunc(work->window, rowdata, work->data);; 571 return contextfunc(work->window, rowdata, work->data);;
562 } 572 }
563 573
564 gint _unselect_row(GtkWidget *widget, gint row, gint column, GdkEventButton *event, gpointer data) 574 static gint _unselect_row(GtkWidget *widget, gint row, gint column, GdkEventButton *event, gpointer data)
565 { 575 {
566 GList *tmp; 576 GList *tmp;
567 char *rowdata; 577 char *rowdata;
568 578
569 if(_dw_unselecting) 579 if(_dw_unselecting)
578 gtk_object_set_data(GTK_OBJECT(widget), "selectlist", tmp); 588 gtk_object_set_data(GTK_OBJECT(widget), "selectlist", tmp);
579 } 589 }
580 return FALSE; 590 return FALSE;
581 } 591 }
582 592
583 int _round_value(gfloat val) 593 static int _round_value(gfloat val)
584 { 594 {
585 int newval = (int)val; 595 int newval = (int)val;
586 596
587 if(val >= 0.5 + (gfloat)newval) 597 if(val >= 0.5 + (gfloat)newval)
588 newval++; 598 newval++;
589 599
590 return newval; 600 return newval;
591 } 601 }
592 602
593 gint _value_changed_event(GtkAdjustment *adjustment, gpointer data) 603 static gint _value_changed_event(GtkAdjustment *adjustment, gpointer data)
594 { 604 {
595 SignalHandler *work = (SignalHandler *)data; 605 SignalHandler *work = (SignalHandler *)data;
596 606
597 if(work) 607 if(work)
598 { 608 {
615 } 625 }
616 } 626 }
617 return FALSE; 627 return FALSE;
618 } 628 }
619 629
620 gint _default_key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data) 630 static gint _default_key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
621 { 631 {
622 GtkWidget *next = (GtkWidget *)data; 632 GtkWidget *next = (GtkWidget *)data;
623 633
624 if(next) 634 if(next)
625 { 635 {
632 } 642 }
633 } 643 }
634 return FALSE; 644 return FALSE;
635 } 645 }
636 646
637 GdkPixmap *_find_pixmap(GdkBitmap **bitmap, long id, HWND handle, unsigned long *userwidth, unsigned long *userheight) 647 static GdkPixmap *_find_private_pixmap(GdkBitmap **bitmap, long id, unsigned long *userwidth, unsigned long *userheight)
648 {
649 if(id < _PixmapCount && _PixmapArray[id].used)
650 {
651 *bitmap = _PixmapArray[id].mask;
652 if(userwidth)
653 *userwidth = _PixmapArray[id].width;
654 if(userheight)
655 *userheight = _PixmapArray[id].height;
656 return _PixmapArray[id].pixmap;
657 }
658 return NULL;
659 }
660
661 static GdkPixmap *_find_pixmap(GdkBitmap **bitmap, long id, HWND handle, unsigned long *userwidth, unsigned long *userheight)
638 { 662 {
639 char *data = NULL; 663 char *data = NULL;
640 int z; 664 int z;
665
666 if(id & (1 << 31))
667 return _find_private_pixmap(bitmap, (id & 0xFFFFFF), userwidth, userheight);
641 668
642 for(z=0;z<_resources.resource_max;z++) 669 for(z=0;z<_resources.resource_max;z++)
643 { 670 {
644 if(_resources.resource_id[z] == id) 671 if(_resources.resource_id[z] == id)
645 { 672 {
670 } 697 }
671 return NULL; 698 return NULL;
672 } 699 }
673 700
674 #if GTK_MAJOR_VERSION > 1 701 #if GTK_MAJOR_VERSION > 1
675 GdkPixbuf *_find_pixbuf(long id) 702 static GdkPixbuf *_find_pixbuf(long id)
676 { 703 {
677 char *data = NULL; 704 char *data = NULL;
678 int z; 705 int z;
679 706
680 for(z=0;z<_resources.resource_max;z++) 707 for(z=0;z<_resources.resource_max;z++)
690 return gdk_pixbuf_new_from_xpm_data((const char **)data); 717 return gdk_pixbuf_new_from_xpm_data((const char **)data);
691 return NULL; 718 return NULL;
692 } 719 }
693 #endif 720 #endif
694 721
695 void _size_allocate(GtkWindow *window) 722 static void _size_allocate(GtkWindow *window)
696 { 723 {
697 XSizeHints sizehints; 724 XSizeHints sizehints;
698 725
699 sizehints.base_width = 1; 726 sizehints.base_width = 1;
700 sizehints.base_height = 1; 727 sizehints.base_height = 1;
710 &sizehints); 737 &sizehints);
711 gdk_flush (); 738 gdk_flush ();
712 } 739 }
713 740
714 /* Find the index of a given thread */ 741 /* Find the index of a given thread */
715 int _find_thread_index(DWTID tid) 742 static int _find_thread_index(DWTID tid)
716 { 743 {
717 int z; 744 int z;
718 745
719 for(z=0;z<DW_THREAD_LIMIT;z++) 746 for(z=0;z<DW_THREAD_LIMIT;z++)
720 { 747 {
723 } 750 }
724 return 0; 751 return 0;
725 } 752 }
726 753
727 /* Add a thread id to the thread list */ 754 /* Add a thread id to the thread list */
728 void _dw_thread_add(DWTID tid) 755 static void _dw_thread_add(DWTID tid)
729 { 756 {
730 int z; 757 int z;
731 758
732 for(z=0;z<DW_THREAD_LIMIT;z++) 759 for(z=0;z<DW_THREAD_LIMIT;z++)
733 { 760 {
743 } 770 }
744 } 771 }
745 } 772 }
746 773
747 /* Remove a thread id to the thread list */ 774 /* Remove a thread id to the thread list */
748 void _dw_thread_remove(DWTID tid) 775 static void _dw_thread_remove(DWTID tid)
749 { 776 {
750 int z; 777 int z;
751 778
752 for(z=0;z<DW_THREAD_LIMIT;z++) 779 for(z=0;z<DW_THREAD_LIMIT;z++)
753 { 780 {
938 tmp = dialog->result; 965 tmp = dialog->result;
939 free(dialog); 966 free(dialog);
940 return tmp; 967 return tmp;
941 } 968 }
942 969
943 int _delete(GtkWidget *widget, GtkWidget *event, gpointer param) 970 static int _dw_ok_func(HWND window, void *data)
944 {
945 gtk_widget_destroy(GTK_WIDGET(param));
946 return FALSE;
947 }
948
949 int _delete2(GtkWidget *widget, gpointer param)
950 {
951 gtk_widget_destroy(GTK_WIDGET(param));
952 return FALSE;
953 }
954
955
956 int _dw_ok_func(HWND window, void *data)
957 { 971 {
958 DWDialog *dwwait = (DWDialog *)data; 972 DWDialog *dwwait = (DWDialog *)data;
959 973
960 if(!dwwait) 974 if(!dwwait)
961 return FALSE; 975 return FALSE;
1242 DW_MUTEX_LOCK; 1256 DW_MUTEX_LOCK;
1243 gdk_window_reparent(GTK_WIDGET(handle)->window, newparent ? GTK_WIDGET(newparent)->window : GDK_ROOT_PARENT(), 0, 0); 1257 gdk_window_reparent(GTK_WIDGET(handle)->window, newparent ? GTK_WIDGET(newparent)->window : GDK_ROOT_PARENT(), 0, 0);
1244 DW_MUTEX_UNLOCK; 1258 DW_MUTEX_UNLOCK;
1245 } 1259 }
1246 1260
1247 int _set_font(HWND handle, char *fontname) 1261 static int _set_font(HWND handle, char *fontname)
1248 { 1262 {
1249 int retval = FALSE; 1263 int retval = FALSE;
1250 #if GTK_MAJOR_VERSION < 2 1264 #if GTK_MAJOR_VERSION < 2
1251 GtkStyle *style; 1265 GtkStyle *style;
1252 GdkFont *font = NULL; 1266 GdkFont *font = NULL;
1341 if(old) 1355 if(old)
1342 free(old); 1356 free(old);
1343 } 1357 }
1344 1358
1345 /* Free old color pointers and allocate new ones */ 1359 /* Free old color pointers and allocate new ones */
1346 void _save_gdk_colors(HWND handle, GdkColor fore, GdkColor back) 1360 static void _save_gdk_colors(HWND handle, GdkColor fore, GdkColor back)
1347 { 1361 {
1348 GdkColor *foregdk = malloc(sizeof(GdkColor)); 1362 GdkColor *foregdk = malloc(sizeof(GdkColor));
1349 GdkColor *backgdk = malloc(sizeof(GdkColor)); 1363 GdkColor *backgdk = malloc(sizeof(GdkColor));
1350 1364
1351 _free_gdk_colors(handle); 1365 _free_gdk_colors(handle);
1355 1369
1356 gtk_object_set_data(GTK_OBJECT(handle), "foregdk", (gpointer)foregdk); 1370 gtk_object_set_data(GTK_OBJECT(handle), "foregdk", (gpointer)foregdk);
1357 gtk_object_set_data(GTK_OBJECT(handle), "backgdk", (gpointer)backgdk); 1371 gtk_object_set_data(GTK_OBJECT(handle), "backgdk", (gpointer)backgdk);
1358 } 1372 }
1359 1373
1360 int _set_color(HWND handle, unsigned long fore, unsigned long back) 1374 static int _set_color(HWND handle, unsigned long fore, unsigned long back)
1361 { 1375 {
1362 /* Remember that each color component in X11 use 16 bit no matter 1376 /* Remember that each color component in X11 use 16 bit no matter
1363 * what the destination display supports. (and thus GDK) 1377 * what the destination display supports. (and thus GDK)
1364 */ 1378 */
1365 GdkColor forecolor, backcolor; 1379 GdkColor forecolor, backcolor;
3822 DW_MUTEX_UNLOCK; 3836 DW_MUTEX_UNLOCK;
3823 #endif 3837 #endif
3824 } 3838 }
3825 3839
3826 #if GTK_MAJOR_VERSION > 1 3840 #if GTK_MAJOR_VERSION > 1
3827 void _dw_recursive_free(GtkTreeModel *store, GtkTreeIter parent) 3841 static void _dw_recursive_free(GtkTreeModel *store, GtkTreeIter parent)
3828 { 3842 {
3829 void *data; 3843 void *data;
3830 GtkTreeIter iter; 3844 GtkTreeIter iter;
3831 3845
3832 gtk_tree_model_get(store, &parent, 3, &data, -1); 3846 gtk_tree_model_get(store, &parent, 3, &data, -1);
4026 gtk_container_remove(GTK_CONTAINER(parenttree), item); 4040 gtk_container_remove(GTK_CONTAINER(parenttree), item);
4027 DW_MUTEX_UNLOCK; 4041 DW_MUTEX_UNLOCK;
4028 #endif 4042 #endif
4029 } 4043 }
4030 4044
4031 int _dw_container_setup(HWND handle, unsigned long *flags, char **titles, int count, int separator, int extra) 4045 static int _dw_container_setup(HWND handle, unsigned long *flags, char **titles, int count, int separator, int extra)
4032 { 4046 {
4033 GtkWidget *clist; 4047 GtkWidget *clist;
4034 char numbuf[10]; 4048 char numbuf[10];
4035 int z; 4049 int z;
4036 int _locked_by_me = FALSE; 4050 int _locked_by_me = FALSE;
4133 * DW pick the appropriate file extension. 4147 * DW pick the appropriate file extension.
4134 * (ICO on OS/2 or Windows, XPM on Unix) 4148 * (ICO on OS/2 or Windows, XPM on Unix)
4135 */ 4149 */
4136 unsigned long API dw_icon_load_from_file(char *filename) 4150 unsigned long API dw_icon_load_from_file(char *filename)
4137 { 4151 {
4152 int z, found = -1, _locked_by_me = FALSE;
4153 #if GTK_MAJOR_VERSION > 1
4154 GdkPixbuf *pixbuf;
4155 #elif defined(USE_IMLIB)
4156 GdkImlibImage *image;
4157 #endif
4138 char *file = alloca(strlen(filename) + 5); 4158 char *file = alloca(strlen(filename) + 5);
4139 4159
4140 if(!file) 4160 if (!file)
4141 return 0; 4161 return 0;
4142 4162
4143 strcpy(file, filename); 4163 strcpy(file, filename);
4144 4164
4145 /* check if we can read from this file (it exists and read permission) */ 4165 /* check if we can read from this file (it exists and read permission) */
4146 if(access(file, 04) != 0) 4166 if(access(file, 04) != 0)
4147 { 4167 {
4148 /* Try with .bmp extention */ 4168 /* Try with .xpm extention */
4149 strcat(file, ".xpm"); 4169 strcat(file, ".xpm");
4150 if(access(file, 04) != 0) 4170 if(access(file, 04) != 0)
4151 return 0; 4171 return 0;
4152 } 4172 }
4153 /* Need to add code to add to the internal pixmap lists */ 4173
4154 return 0; 4174 DW_MUTEX_LOCK;
4175 /* Find a free entry in the array */
4176 for(z=0;z<_PixmapCount;z++)
4177 {
4178 if(!_PixmapArray[z].used)
4179 {
4180 found = z;
4181 break;
4182 }
4183 }
4184
4185 /* If there are no free entries, expand the
4186 * array.
4187 */
4188 if(found == -1)
4189 {
4190 DWPrivatePixmap *old = _PixmapArray;
4191
4192 found = _PixmapCount;
4193 _PixmapCount++;
4194
4195 _PixmapArray = malloc(sizeof(DWPrivatePixmap) * _PixmapCount);
4196
4197 if(found)
4198 memcpy(_PixmapArray, old, sizeof(DWPrivatePixmap) * found);
4199 if(old)
4200 free(old);
4201 _PixmapArray[found].used = 1;
4202 _PixmapArray[found].pixmap = _PixmapArray[found].mask = NULL;
4203 }
4204
4205 #if GTK_MAJOR_VERSION > 1
4206 pixbuf = gdk_pixbuf_new_from_file(file, NULL);
4207
4208 _PixmapArray[found].width = gdk_pixbuf_get_width(pixbuf);
4209 _PixmapArray[found].height = gdk_pixbuf_get_height(pixbuf);
4210
4211 gdk_pixbuf_render_pixmap_and_mask(pixbuf, &_PixmapArray[found].pixmap, &_PixmapArray[found].mask, 1);
4212 g_object_unref(pixbuf);
4213 #elif defined(USE_IMLIB)
4214 image = gdk_imlib_load_image(file);
4215
4216 _PixmapArray[found].width = image->rgb_width;
4217 _PixmapArray[found].height = image->rgb_height;
4218
4219 gdk_imlib_render(image, image->rgb_width, image->rgb_height);
4220 _PixmapArray[found].pixmap = gdk_imlib_copy_image(image);
4221 gdk_imlib_destroy_image(image);
4222 #else
4223 _PixmapArray[found].pixmap = gdk_pixmap_create_from_xpm(handle->window, &_PixmapArray[found].mask, &_colors[DW_CLR_PALEGRAY], file);
4224 #endif
4225 DW_MUTEX_UNLOCK;
4226 return found | (1 << 31);
4155 } 4227 }
4156 4228
4157 /* 4229 /*
4158 * Frees a loaded resource in OS/2 and Windows. 4230 * Frees a loaded resource in OS/2 and Windows.
4159 * Parameters: 4231 * Parameters:
4160 * handle: Handle to icon returned by dw_icon_load(). 4232 * handle: Handle to icon returned by dw_icon_load().
4161 */ 4233 */
4162 void dw_icon_free(unsigned long handle) 4234 void dw_icon_free(unsigned long handle)
4163 { 4235 {
4236 /* If it is a private icon, find the item
4237 * free the associated structures and set
4238 * the entry to unused.
4239 */
4240 if(handle & (1 << 31))
4241 {
4242 unsigned long id = handle & 0xFFFFFF;
4243
4244 if(id < _PixmapCount && _PixmapArray[id].used)
4245 {
4246 if(_PixmapArray[id].mask)
4247 {
4248 gdk_bitmap_unref(_PixmapArray[id].mask);
4249 _PixmapArray[id].mask = NULL;
4250 }
4251 if(_PixmapArray[id].pixmap)
4252 {
4253 gdk_pixmap_unref(_PixmapArray[id].pixmap);
4254 _PixmapArray[id].pixmap = NULL;
4255 }
4256 _PixmapArray[id].used = 0;
4257 }
4258 }
4164 } 4259 }
4165 4260
4166 /* Clears a CList selection and associated selection list */ 4261 /* Clears a CList selection and associated selection list */
4167 void _dw_unselect(GtkWidget *clist) 4262 void _dw_unselect(GtkWidget *clist)
4168 { 4263 {
4764 DW_MUTEX_UNLOCK; 4859 DW_MUTEX_UNLOCK;
4765 return tmp; 4860 return tmp;
4766 } 4861 }
4767 4862
4768 /* Returns a GdkColor from a DW color */ 4863 /* Returns a GdkColor from a DW color */
4769 GdkColor _internal_color(unsigned long value) 4864 static GdkColor _internal_color(unsigned long value)
4770 { 4865 {
4771 if(DW_RGB_COLOR & value) 4866 if(DW_RGB_COLOR & value)
4772 { 4867 {
4773 GdkColor color = { 0, DW_RED_VALUE(value) << 8, DW_GREEN_VALUE(value) << 8, DW_BLUE_VALUE(value) << 8 }; 4868 GdkColor color = { 0, DW_RED_VALUE(value) << 8, DW_GREEN_VALUE(value) << 8, DW_BLUE_VALUE(value) << 8 };
4774 return color; 4869 return color;
6447 DW_MUTEX_UNLOCK; 6542 DW_MUTEX_UNLOCK;
6448 } 6543 }
6449 6544
6450 #if GTK_MAJOR_VERSION < 2 6545 #if GTK_MAJOR_VERSION < 2
6451 /* Check if a GList item is in another GList */ 6546 /* Check if a GList item is in another GList */
6452 int _dw_in_list(GList *item, GList *list) 6547 static int _dw_in_list(GList *item, GList *list)
6453 { 6548 {
6454 while(list) 6549 while(list)
6455 { 6550 {
6456 if(list->data == item->data) 6551 if(list->data == item->data)
6457 return TRUE; 6552 return TRUE;
6635 gtk_list_clear_items(GTK_LIST(handle2), index, index); 6730 gtk_list_clear_items(GTK_LIST(handle2), index, index);
6636 DW_MUTEX_UNLOCK; 6731 DW_MUTEX_UNLOCK;
6637 } 6732 }
6638 6733
6639 /* Reposition the bar according to the percentage */ 6734 /* Reposition the bar according to the percentage */
6640 gint _splitbar_size_allocate(GtkWidget *widget, GtkAllocation *event, gpointer data) 6735 static gint _splitbar_size_allocate(GtkWidget *widget, GtkAllocation *event, gpointer data)
6641 { 6736 {
6642 float *percent = (float *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_percent"); 6737 float *percent = (float *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_percent");
6643 int lastwidth = (int)gtk_object_get_data(GTK_OBJECT(widget), "_dw_lastwidth"); 6738 int lastwidth = (int)gtk_object_get_data(GTK_OBJECT(widget), "_dw_lastwidth");
6644 int lastheight = (int)gtk_object_get_data(GTK_OBJECT(widget), "_dw_lastheight"); 6739 int lastheight = (int)gtk_object_get_data(GTK_OBJECT(widget), "_dw_lastheight");
6645 6740
6660 return FALSE; 6755 return FALSE;
6661 } 6756 }
6662 6757
6663 #if GTK_MAJOR_VERSION > 1 6758 #if GTK_MAJOR_VERSION > 1
6664 /* Figure out the new percentage */ 6759 /* Figure out the new percentage */
6665 void _splitbar_accept_position(GObject *object, GParamSpec *pspec, gpointer data) 6760 static void _splitbar_accept_position(GObject *object, GParamSpec *pspec, gpointer data)
6666 { 6761 {
6667 GtkWidget *widget = (GtkWidget *)data; 6762 GtkWidget *widget = (GtkWidget *)data;
6668 float *percent = (float *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_percent"); 6763 float *percent = (float *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_percent");
6669 int size = 0, position = gtk_paned_get_position(GTK_PANED(widget)); 6764 int size = 0, position = gtk_paned_get_position(GTK_PANED(widget));
6670 6765
6942 env->MajorVersion = atoi(tempbuf); 7037 env->MajorVersion = atoi(tempbuf);
6943 env->MinorVersion = 0; 7038 env->MinorVersion = 0;
6944 } 7039 }
6945 7040
6946 /* Internal function to handle the file OK press */ 7041 /* Internal function to handle the file OK press */
6947 gint _gtk_file_ok(GtkWidget *widget, DWDialog *dwwait) 7042 static gint _gtk_file_ok(GtkWidget *widget, DWDialog *dwwait)
6948 { 7043 {
6949 #if GTK_MAJOR_VERSION > 1 7044 #if GTK_MAJOR_VERSION > 1
6950 const char *tmp; 7045 const char *tmp;
6951 #else 7046 #else
6952 char *tmp; 7047 char *tmp;
6963 dw_dialog_dismiss(dwwait, (void *)tmpdup); 7058 dw_dialog_dismiss(dwwait, (void *)tmpdup);
6964 return FALSE; 7059 return FALSE;
6965 } 7060 }
6966 7061
6967 /* Internal function to handle the file Cancel press */ 7062 /* Internal function to handle the file Cancel press */
6968 gint _gtk_file_cancel(GtkWidget *widget, DWDialog *dwwait) 7063 static gint _gtk_file_cancel(GtkWidget *widget, DWDialog *dwwait)
6969 { 7064 {
6970 if(!dwwait) 7065 if(!dwwait)
6971 return FALSE; 7066 return FALSE;
6972 7067
6973 gtk_widget_destroy(GTK_WIDGET(dwwait->data)); 7068 gtk_widget_destroy(GTK_WIDGET(dwwait->data));