Mercurial > dwindows

comparison gtk/dw.c @ 622:fb59f9eeeecd

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
SUpport for embedded mozilla/firefox widget
author mhessling@81767d24-ef19-dc11-ae90-00e081727c95
date Mon, 07 Apr 2008 06:59:45 +0000
parents c5e5671dec8f
children ad7a4335f1f1
comparison
equal deleted inserted replaced
621:46c261153aa4 622:fb59f9eeeecd
41 #include "gtk/messagebox_error.xpm" 41 #include "gtk/messagebox_error.xpm"
42 #include "gtk/messagebox_warning.xpm" 42 #include "gtk/messagebox_warning.xpm"
43 #include "gtk/messagebox_information.xpm" 43 #include "gtk/messagebox_information.xpm"
44 #include "gtk/messagebox_question.xpm" 44 #include "gtk/messagebox_question.xpm"
45 45
46 #ifdef USE_GTKMOZEMBED
47 extern gint mozilla_get_mouse_event_button(gpointer event);
48 extern gint mozilla_get_mouse_location( gpointer event, glong *x, glong *y);
49 #endif
50
46 /* These are used for resource management */ 51 /* These are used for resource management */
47 #if defined(DW_RESOURCES) && !defined(BUILD_DLL) 52 #if defined(DW_RESOURCES) && !defined(BUILD_DLL)
48 extern DWResources _resources; 53 extern DWResources _resources;
49 #endif 54 #endif
50 55
51 GdkColor _colors[] = 56 GdkColor _colors[] =
52 { 57 {
53 { 0, 0x0000, 0x0000, 0x0000 }, /* 0 black */ 58 { 0, 0x0000, 0x0000, 0x0000 }, /* 0 black */
54 { 0, 0xbbbb, 0x0000, 0x0000 }, /* 1 red */ 59 { 0, 0xbbbb, 0x0000, 0x0000 }, /* 1 red */
55 { 0, 0x0000, 0xbbbb, 0x0000 }, /* 2 green */ 60 { 0, 0x0000, 0xbbbb, 0x0000 }, /* 2 green */
56 { 0, 0xaaaa, 0xaaaa, 0x0000 }, /* 3 yellow */ 61 { 0, 0xaaaa, 0xaaaa, 0x0000 }, /* 3 yellow */
57 { 0, 0x0000, 0x0000, 0xcccc }, /* 4 blue */ 62 { 0, 0x0000, 0x0000, 0xcccc }, /* 4 blue */
58 { 0, 0xbbbb, 0x0000, 0xbbbb }, /* 5 magenta */ 63 { 0, 0xbbbb, 0x0000, 0xbbbb }, /* 5 magenta */
59 { 0, 0x0000, 0xbbbb, 0xbbbb }, /* 6 cyan */ 64 { 0, 0x0000, 0xbbbb, 0xbbbb }, /* 6 cyan */
60 { 0, 0xbbbb, 0xbbbb, 0xbbbb }, /* 7 white */ 65 { 0, 0xbbbb, 0xbbbb, 0xbbbb }, /* 7 white */
61 { 0, 0x7777, 0x7777, 0x7777 }, /* 8 grey */ 66 { 0, 0x7777, 0x7777, 0x7777 }, /* 8 grey */
62 { 0, 0xffff, 0x0000, 0x0000 }, /* 9 bright red */ 67 { 0, 0xffff, 0x0000, 0x0000 }, /* 9 bright red */
63 { 0, 0x0000, 0xffff, 0x0000 }, /* 10 bright green */ 68 { 0, 0x0000, 0xffff, 0x0000 }, /* 10 bright green */
64 { 0, 0xeeee, 0xeeee, 0x0000 }, /* 11 bright yellow */ 69 { 0, 0xeeee, 0xeeee, 0x0000 }, /* 11 bright yellow */
65 { 0, 0x0000, 0x0000, 0xffff }, /* 12 bright blue */ 70 { 0, 0x0000, 0x0000, 0xffff }, /* 12 bright blue */
66 { 0, 0xffff, 0x0000, 0xffff }, /* 13 bright magenta */ 71 { 0, 0xffff, 0x0000, 0xffff }, /* 13 bright magenta */
67 { 0, 0x0000, 0xeeee, 0xeeee }, /* 14 bright cyan */ 72 { 0, 0x0000, 0xeeee, 0xeeee }, /* 14 bright cyan */
68 { 0, 0xffff, 0xffff, 0xffff }, /* 15 bright white */ 73 { 0, 0xffff, 0xffff, 0xffff }, /* 15 bright white */
69 }; 74 };
70 75
71 #define NUM_EXTS 5 76 #define NUM_EXTS 5
72 char *image_exts[NUM_EXTS] = 77 char *image_exts[NUM_EXTS] =
73 { 78 {
146 void (*_gtk_moz_embed_reload)(GtkMozEmbed *, guint32) = NULL; 151 void (*_gtk_moz_embed_reload)(GtkMozEmbed *, guint32) = NULL;
147 void (*_gtk_moz_embed_stop_load)(GtkMozEmbed *) = NULL; 152 void (*_gtk_moz_embed_stop_load)(GtkMozEmbed *) = NULL;
148 void (*_gtk_moz_embed_render_data)(GtkMozEmbed *, const char *, guint32, const char *, const char *) = NULL; 153 void (*_gtk_moz_embed_render_data)(GtkMozEmbed *, const char *, guint32, const char *, const char *) = NULL;
149 GtkWidget *(*_gtk_moz_embed_new)(void) = NULL; 154 GtkWidget *(*_gtk_moz_embed_new)(void) = NULL;
150 GtkType (*_dw_moz_embed_get_type)(void) = NULL; 155 GtkType (*_dw_moz_embed_get_type)(void) = NULL;
156 gboolean (*_gtk_moz_embed_can_go_back)(GtkMozEmbed *) = NULL;
157 gboolean (*_gtk_moz_embed_can_go_forward)(GtkMozEmbed *) = NULL;
151 #endif 158 #endif
152 159
153 typedef struct 160 typedef struct
154 { 161 {
155 GdkPixmap *pixmap; 162 GdkPixmap *pixmap;
156 GdkBitmap *mask; 163 GdkBitmap *mask;
157 int used; 164 int used;
158 unsigned long width, height; 165 unsigned long width, height;
159 #if GTK_MAJOR_VERSION > 1 166 #if GTK_MAJOR_VERSION > 1
160 GdkPixbuf *pixbuf; 167 GdkPixbuf *pixbuf;
161 #endif 168 #endif
162 } DWPrivatePixmap; 169 } DWPrivatePixmap;
163 170
164 static DWPrivatePixmap *_PixmapArray = NULL; 171 static DWPrivatePixmap *_PixmapArray = NULL;
165 static int _PixmapCount = 0; 172 static int _PixmapCount = 0;
166 173
167 typedef struct 174 typedef struct
168 { 175 {
169 void *func; 176 void *func;
170 char name[30]; 177 char name[30];
171 178
172 } SignalList; 179 } SignalList;
173 180
174 typedef struct 181 typedef struct
175 { 182 {
176 HWND window; 183 HWND window;
177 void *func; 184 void *func;
178 gpointer data; 185 gpointer data;
179 gint cid; 186 gint cid;
180 void *intfunc; 187 void *intfunc;
181 188
182 } SignalHandler; 189 } SignalHandler;
183 190
184 #define SIGNALMAX 19 191 #define SIGNALMAX 19
185 192
186 /* A list of signal forwarders, to account for paramater differences. */ 193 /* A list of signal forwarders, to account for paramater differences. */
187 static SignalList SignalTranslate[SIGNALMAX] = { 194 static SignalList SignalTranslate[SIGNALMAX] = {
188 { _configure_event, DW_SIGNAL_CONFIGURE }, 195 { _configure_event, DW_SIGNAL_CONFIGURE },
189 { _key_press_event, DW_SIGNAL_KEY_PRESS }, 196 { _key_press_event, DW_SIGNAL_KEY_PRESS },
190 { _button_press_event, DW_SIGNAL_BUTTON_PRESS }, 197 { _button_press_event, DW_SIGNAL_BUTTON_PRESS },
191 { _button_release_event, DW_SIGNAL_BUTTON_RELEASE }, 198 { _button_release_event, DW_SIGNAL_BUTTON_RELEASE },
192 { _motion_notify_event, DW_SIGNAL_MOTION_NOTIFY }, 199 { _motion_notify_event, DW_SIGNAL_MOTION_NOTIFY },
193 { _delete_event, DW_SIGNAL_DELETE }, 200 { _delete_event, DW_SIGNAL_DELETE },
194 { _expose_event, DW_SIGNAL_EXPOSE }, 201 { _expose_event, DW_SIGNAL_EXPOSE },
195 { _activate_event, "activate" }, 202 { _activate_event, "activate" },
196 { _generic_event, DW_SIGNAL_CLICKED }, 203 { _generic_event, DW_SIGNAL_CLICKED },
197 { _container_select_event, DW_SIGNAL_ITEM_ENTER }, 204 { _container_select_event, DW_SIGNAL_ITEM_ENTER },
198 { _container_context_event, DW_SIGNAL_ITEM_CONTEXT }, 205 { _container_context_event, DW_SIGNAL_ITEM_CONTEXT },
199 { _tree_context_event, "tree-context" }, 206 { _tree_context_event, "tree-context" },
200 { _item_select_event, DW_SIGNAL_LIST_SELECT }, 207 { _item_select_event, DW_SIGNAL_LIST_SELECT },
201 { _tree_select_event, DW_SIGNAL_ITEM_SELECT }, 208 { _tree_select_event, DW_SIGNAL_ITEM_SELECT },
202 { _set_focus_event, DW_SIGNAL_SET_FOCUS }, 209 { _set_focus_event, DW_SIGNAL_SET_FOCUS },
203 { _value_changed_event, DW_SIGNAL_VALUE_CHANGED }, 210 { _value_changed_event, DW_SIGNAL_VALUE_CHANGED },
204 { _switch_page_event, DW_SIGNAL_SWITCH_PAGE }, 211 { _switch_page_event, DW_SIGNAL_SWITCH_PAGE },
205 { _column_click_event, DW_SIGNAL_COLUMN_CLICK }, 212 { _column_click_event, DW_SIGNAL_COLUMN_CLICK },
206 { _tree_expand_event, DW_SIGNAL_TREE_EXPAND } 213 { _tree_expand_event, DW_SIGNAL_TREE_EXPAND }
207 }; 214 };
208 215
209 /* Alignment flags */ 216 /* Alignment flags */
210 #define DW_CENTER 0.5f 217 #define DW_CENTER 0.5f
211 #define DW_LEFT 0.0f 218 #define DW_LEFT 0.0f
222 typedef struct _GtkMdiDragInfo GtkMdiDragInfo; 229 typedef struct _GtkMdiDragInfo GtkMdiDragInfo;
223 typedef enum _GtkMdiChildState GtkMdiChildState; 230 typedef enum _GtkMdiChildState GtkMdiChildState;
224 231
225 enum _GtkMdiChildState 232 enum _GtkMdiChildState
226 { 233 {
227 CHILD_NORMAL, 234 CHILD_NORMAL,
228 CHILD_MAXIMIZED, 235 CHILD_MAXIMIZED,
229 CHILD_ICONIFIED 236 CHILD_ICONIFIED
230 }; 237 };
231 238
232 struct _GtkMdi 239 struct _GtkMdi
233 { 240 {
234 GtkContainer container; 241 GtkContainer container;
235 GList *children; 242 GList *children;
236 243
237 GdkPoint drag_start; 244 GdkPoint drag_start;
238 gint drag_button; 245 gint drag_button;
239 }; 246 };
240 247
241 struct _GtkMdiClass 248 struct _GtkMdiClass
242 { 249 {
243 GtkContainerClass parent_class; 250 GtkContainerClass parent_class;
244 251
245 void (*mdi) (GtkMdi * mdi); 252 void (*mdi) (GtkMdi * mdi);
246 }; 253 };
247 254
248 #include "gtk/maximize.xpm" 255 #include "gtk/maximize.xpm"
249 #include "gtk/minimize.xpm" 256 #include "gtk/minimize.xpm"
250 #include "gtk/kill.xpm" 257 #include "gtk/kill.xpm"
259 266
260 typedef struct _GtkMdiChild GtkMdiChild; 267 typedef struct _GtkMdiChild GtkMdiChild;
261 268
262 struct _GtkMdiChild 269 struct _GtkMdiChild
263 { 270 {
264 GtkWidget *widget; 271 GtkWidget *widget;
265 272
266 GtkWidget *child; 273 GtkWidget *child;
267 GtkMdi *mdi; 274 GtkMdi *mdi;
268 275
269 gint x; 276 gint x;
270 gint y; 277 gint y;
271 gint width; 278 gint width;
272 gint height; 279 gint height;
273 280
274 GtkMdiChildState state; 281 GtkMdiChildState state;
275 }; 282 };
276 283
277 static void gtk_mdi_class_init(GtkMdiClass *klass); 284 static void gtk_mdi_class_init(GtkMdiClass *klass);
278 static void gtk_mdi_init(GtkMdi *mdi); 285 static void gtk_mdi_init(GtkMdi *mdi);
279 286
295 302
296 static GtkMdiChild *get_child(GtkMdi *mdi, GtkWidget * widget); 303 static GtkMdiChild *get_child(GtkMdi *mdi, GtkWidget * widget);
297 304
298 static GtkType gtk_mdi_get_type(void) 305 static GtkType gtk_mdi_get_type(void)
299 { 306 {
300 static GType mdi_type = 0; 307 static GType mdi_type = 0;
301 308
302 if (!mdi_type) 309 if (!mdi_type)
303 { 310 {
304 311
305 static const GTypeInfo mdi_info = 312 static const GTypeInfo mdi_info =
306 { 313 {
307 sizeof (GtkMdiClass), 314 sizeof (GtkMdiClass),
308 NULL, 315 NULL,
309 NULL, 316 NULL,
310 (GClassInitFunc) gtk_mdi_class_init, 317 (GClassInitFunc) gtk_mdi_class_init,
311 NULL, 318 NULL,
312 NULL, 319 NULL,
313 sizeof (GtkMdi), 320 sizeof (GtkMdi),
314 0, 321 0,
315 (GInstanceInitFunc) gtk_mdi_init, 322 (GInstanceInitFunc) gtk_mdi_init,
316 }; 323 };
317 324
318 mdi_type = g_type_register_static (GTK_TYPE_CONTAINER, "GtkMdi", &mdi_info, 0); 325 mdi_type = g_type_register_static (GTK_TYPE_CONTAINER, "GtkMdi", &mdi_info, 0);
319 } 326 }
320 327
321 return mdi_type; 328 return mdi_type;
322 } 329 }
323 330
324 /* Local data */ 331 /* Local data */
325 static GtkWidgetClass *parent_class = NULL; 332 static GtkWidgetClass *parent_class = NULL;
326 333
327 static void gtk_mdi_class_init(GtkMdiClass *class) 334 static void gtk_mdi_class_init(GtkMdiClass *class)
328 { 335 {
329 GObjectClass *object_class; 336 GObjectClass *object_class;
330 GtkWidgetClass *widget_class; 337 GtkWidgetClass *widget_class;
331 GtkContainerClass *container_class; 338 GtkContainerClass *container_class;
332 339
333 object_class = (GObjectClass *) class; 340 object_class = (GObjectClass *) class;
334 widget_class = (GtkWidgetClass *) class; 341 widget_class = (GtkWidgetClass *) class;
335 container_class = (GtkContainerClass *) class; 342 container_class = (GtkContainerClass *) class;
336 343
337 parent_class = gtk_type_class (GTK_TYPE_CONTAINER); 344 parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
338 345
339 widget_class->realize = gtk_mdi_realize; 346 widget_class->realize = gtk_mdi_realize;
340 widget_class->expose_event = gtk_mdi_expose; 347 widget_class->expose_event = gtk_mdi_expose;
341 widget_class->size_request = gtk_mdi_size_request; 348 widget_class->size_request = gtk_mdi_size_request;
342 widget_class->size_allocate = gtk_mdi_size_allocate; 349 widget_class->size_allocate = gtk_mdi_size_allocate;
343 350
344 container_class->add = gtk_mdi_add; 351 container_class->add = gtk_mdi_add;
345 container_class->remove = gtk_mdi_remove_true; 352 container_class->remove = gtk_mdi_remove_true;
346 container_class->forall = gtk_mdi_forall; 353 container_class->forall = gtk_mdi_forall;
347 class->mdi = NULL; 354 class->mdi = NULL;
348 } 355 }
349 356
350 static void gtk_mdi_init(GtkMdi *mdi) 357 static void gtk_mdi_init(GtkMdi *mdi)
351 { 358 {
352 mdi->drag_button = -1; 359 mdi->drag_button = -1;
353 mdi->children = NULL; 360 mdi->children = NULL;
354 } 361 }
355 362
356 static GtkWidget *gtk_mdi_new(void) 363 static GtkWidget *gtk_mdi_new(void)
357 { 364 {
358 GtkWidget *mdi; 365 GtkWidget *mdi;
359 GdkColor background; 366 GdkColor background;
360 367
361 mdi = GTK_WIDGET (g_object_new (gtk_mdi_get_type (), NULL)); 368 mdi = GTK_WIDGET (g_object_new (gtk_mdi_get_type (), NULL));
362 gdk_color_parse (GTK_MDI_BACKGROUND, &background); 369 gdk_color_parse (GTK_MDI_BACKGROUND, &background);
363 gtk_widget_modify_bg (mdi, GTK_STATE_NORMAL, &background); 370 gtk_widget_modify_bg (mdi, GTK_STATE_NORMAL, &background);
364 371
365 return mdi; 372 return mdi;
366 } 373 }
367 374
368 static void gtk_mdi_put(GtkMdi *mdi, GtkWidget *child_widget, gint x, gint y, GtkWidget *label) 375 static void gtk_mdi_put(GtkMdi *mdi, GtkWidget *child_widget, gint x, gint y, GtkWidget *label)
369 { 376 {
370 GtkMdiChild *child; 377 GtkMdiChild *child;
371 378
372 GtkWidget *table; 379 GtkWidget *table;
373 GtkWidget *button[3]; 380 GtkWidget *button[3];
374 381
375 GtkWidget *child_box; 382 GtkWidget *child_box;
376 GtkWidget *top_event_box; 383 GtkWidget *top_event_box;
377 GtkWidget *bottom_event_box; 384 GtkWidget *bottom_event_box;
378 GtkWidget *child_widget_box; 385 GtkWidget *child_widget_box;
379 GtkWidget *image; 386 GtkWidget *image;
380 387
381 GdkColor color; 388 GdkColor color;
382 gint i, j; 389 gint i, j;
383 GdkCursor *cursor; 390 GdkCursor *cursor;
384 GdkColormap *colormap; 391 GdkColormap *colormap;
385 GdkPixmap *pixmap; 392 GdkPixmap *pixmap;
386 GdkBitmap *mask; 393 GdkBitmap *mask;
387 GtkStyle *style; 394 GtkStyle *style;
388 395
389 child_box = gtk_event_box_new (); 396 child_box = gtk_event_box_new ();
390 child_widget_box = gtk_event_box_new (); 397 child_widget_box = gtk_event_box_new ();
391 top_event_box = gtk_event_box_new (); 398 top_event_box = gtk_event_box_new ();
392 bottom_event_box = gtk_event_box_new (); 399 bottom_event_box = gtk_event_box_new ();
393 table = gtk_table_new (4, 7, FALSE); 400 table = gtk_table_new (4, 7, FALSE);
394 gtk_table_set_row_spacings (GTK_TABLE (table), 1); 401 gtk_table_set_row_spacings (GTK_TABLE (table), 1);
395 gtk_table_set_col_spacings (GTK_TABLE (table), 1); 402 gtk_table_set_col_spacings (GTK_TABLE (table), 1);
396 gtk_table_set_row_spacing (GTK_TABLE (table), 3, 0); 403 gtk_table_set_row_spacing (GTK_TABLE (table), 3, 0);
397 gtk_table_set_col_spacing (GTK_TABLE (table), 6, 0); 404 gtk_table_set_col_spacing (GTK_TABLE (table), 6, 0);
398 gtk_table_set_row_spacing (GTK_TABLE (table), 2, 0); 405 gtk_table_set_row_spacing (GTK_TABLE (table), 2, 0);
399 gtk_table_set_col_spacing (GTK_TABLE (table), 5, 0); 406 gtk_table_set_col_spacing (GTK_TABLE (table), 5, 0);
400 407
401 for (i = 0; i < 3; i++) 408 for (i = 0; i < 3; i++)
402 { 409 {
403 button[i] = gtk_event_box_new (); 410 button[i] = gtk_event_box_new ();
404 gtk_widget_set_events (button[0], GDK_BUTTON_PRESS_MASK); 411 gtk_widget_set_events (button[0], GDK_BUTTON_PRESS_MASK);
405 } 412 }
406 413
407 gdk_color_parse (GTK_MDI_LABEL_BACKGROUND, &color); 414 gdk_color_parse (GTK_MDI_LABEL_BACKGROUND, &color);
408 415
409 gtk_widget_modify_bg (top_event_box, GTK_STATE_NORMAL, &color); 416 gtk_widget_modify_bg (top_event_box, GTK_STATE_NORMAL, &color);
410 gtk_widget_modify_bg (bottom_event_box, GTK_STATE_NORMAL, &color); 417 gtk_widget_modify_bg (bottom_event_box, GTK_STATE_NORMAL, &color);
411 gtk_widget_modify_bg (child_box, GTK_STATE_NORMAL, &color); 418 gtk_widget_modify_bg (child_box, GTK_STATE_NORMAL, &color);
412 for (i = GTK_STATE_NORMAL; i < GTK_STATE_ACTIVE; i++) 419 for (i = GTK_STATE_NORMAL; i < GTK_STATE_ACTIVE; i++)
413 { 420 {
414 for (j = 0; j < 3; j++) 421 for (j = 0; j < 3; j++)
415 { 422 {
416 gtk_widget_modify_bg (button[j], i, &color); 423 gtk_widget_modify_bg (button[j], i, &color);
417 } 424 }
418 } 425 }
419 gdk_color_parse (GTK_MDI_LABEL_FOREGROUND, &color); 426 gdk_color_parse (GTK_MDI_LABEL_FOREGROUND, &color);
420 gtk_widget_modify_fg (label, GTK_STATE_NORMAL, &color); 427 gtk_widget_modify_fg (label, GTK_STATE_NORMAL, &color);
421 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); 428 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
422 429
423 gtk_container_add (GTK_CONTAINER (top_event_box), label); 430 gtk_container_add (GTK_CONTAINER (top_event_box), label);
424 gtk_container_add (GTK_CONTAINER (child_widget_box), child_widget); 431 gtk_container_add (GTK_CONTAINER (child_widget_box), child_widget);
425 gtk_widget_set_size_request (bottom_event_box, 2, 2); 432 gtk_widget_set_size_request (bottom_event_box, 2, 2);
426 433
427 434
428 style = gtk_widget_get_default_style (); 435 style = gtk_widget_get_default_style ();
429 colormap = gdk_colormap_get_system (); 436 colormap = gdk_colormap_get_system ();
430 pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL, colormap, &mask, 437 pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL, colormap, &mask,
431 &style->bg[GTK_STATE_NORMAL], 438 &style->bg[GTK_STATE_NORMAL],
432 (gchar **) minimize_xpm); 439 (gchar **) minimize_xpm);
433 image = gtk_image_new_from_pixmap (pixmap, mask); 440 image = gtk_image_new_from_pixmap (pixmap, mask);
434 gtk_widget_show(image); 441 gtk_widget_show(image);
435 gtk_container_add (GTK_CONTAINER (button[0]), image); 442 gtk_container_add (GTK_CONTAINER (button[0]), image);
436 pixmap = gdk_pixmap_colormap_create_from_xpm_d (GTK_WIDGET (mdi)->window, colormap, &mask, 443 pixmap = gdk_pixmap_colormap_create_from_xpm_d (GTK_WIDGET (mdi)->window, colormap, &mask,
437 &style->bg[GTK_STATE_NORMAL], 444 &style->bg[GTK_STATE_NORMAL],
438 (gchar **) maximize_xpm); 445 (gchar **) maximize_xpm);
439 image = gtk_image_new_from_pixmap (pixmap, mask); 446 image = gtk_image_new_from_pixmap (pixmap, mask);
440 gtk_widget_show(image); 447 gtk_widget_show(image);
441 gtk_container_add (GTK_CONTAINER (button[1]), image); 448 gtk_container_add (GTK_CONTAINER (button[1]), image);
442 pixmap = gdk_pixmap_colormap_create_from_xpm_d (GTK_WIDGET (mdi)->window, colormap, &mask, 449 pixmap = gdk_pixmap_colormap_create_from_xpm_d (GTK_WIDGET (mdi)->window, colormap, &mask,
443 &style->bg[GTK_STATE_NORMAL], 450 &style->bg[GTK_STATE_NORMAL],
444 (gchar **) kill_xpm); 451 (gchar **) kill_xpm);
445 image = gtk_image_new_from_pixmap (pixmap, mask); 452 image = gtk_image_new_from_pixmap (pixmap, mask);
446 gtk_widget_show(image); 453 gtk_widget_show(image);
447 gtk_container_add (GTK_CONTAINER (button[2]), image); 454 gtk_container_add (GTK_CONTAINER (button[2]), image);
448 455
449 gtk_table_attach (GTK_TABLE (table), child_widget_box, 1, 6, 2, 3, 456 gtk_table_attach (GTK_TABLE (table), child_widget_box, 1, 6, 2, 3,
450 GTK_EXPAND | GTK_SHRINK | GTK_FILL, 457 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
451 GTK_EXPAND | GTK_SHRINK | GTK_FILL, 458 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
452 0, 0); 459 0, 0);
453 gtk_table_attach (GTK_TABLE (table), top_event_box, 1, 2, 1, 2, 460 gtk_table_attach (GTK_TABLE (table), top_event_box, 1, 2, 1, 2,
454 GTK_FILL | GTK_EXPAND | GTK_SHRINK, 461 GTK_FILL | GTK_EXPAND | GTK_SHRINK,
455 0, 462 0,
456 0, 0); 463 0, 0);
457 gtk_table_attach (GTK_TABLE (table), bottom_event_box, 6, 7, 3, 4, 464 gtk_table_attach (GTK_TABLE (table), bottom_event_box, 6, 7, 3, 4,
458 0, 465 0,
459 0, 466 0,
460 0, 0); 467 0, 0);
461 gtk_table_attach (GTK_TABLE (table), button[0], 2, 3, 1, 2, 468 gtk_table_attach (GTK_TABLE (table), button[0], 2, 3, 1, 2,
462 0, 469 0,
463 0, 470 0,
464 0, 0); 471 0, 0);
465 gtk_table_attach (GTK_TABLE (table), button[1], 3, 4, 1, 2, 472 gtk_table_attach (GTK_TABLE (table), button[1], 3, 4, 1, 2,
466 0, 473 0,
467 0, 474 0,
468 0, 0); 475 0, 0);
469 gtk_table_attach (GTK_TABLE (table), button[2], 4, 5, 1, 2, 476 gtk_table_attach (GTK_TABLE (table), button[2], 4, 5, 1, 2,
470 0, 477 0,
471 0, 478 0,
472 0, 0); 479 0, 0);
473 480
474 gtk_container_add (GTK_CONTAINER (child_box), table); 481 gtk_container_add (GTK_CONTAINER (child_box), table);
475 482
476 child = g_new (GtkMdiChild, 1); 483 child = g_new (GtkMdiChild, 1);
477 child->widget = child_box; 484 child->widget = child_box;
478 child->x = x; 485 child->x = x;
479 child->y = y; 486 child->y = y;
480 child->width = -1; 487 child->width = -1;
481 child->height = -1; 488 child->height = -1;
482 child->child = child_widget; 489 child->child = child_widget;
483 child->mdi = mdi; 490 child->mdi = mdi;
484 child->state = CHILD_NORMAL; 491 child->state = CHILD_NORMAL;
485 492
486 gtk_widget_set_parent (child_box, GTK_WIDGET (mdi)); 493 gtk_widget_set_parent (child_box, GTK_WIDGET (mdi));
487 mdi->children = g_list_append (mdi->children, child); 494 mdi->children = g_list_append (mdi->children, child);
488 495
489 gtk_widget_show (child_box); 496 gtk_widget_show (child_box);
490 gtk_widget_show (table); 497 gtk_widget_show (table);
491 gtk_widget_show (top_event_box); 498 gtk_widget_show (top_event_box);
492 gtk_widget_show (bottom_event_box); 499 gtk_widget_show (bottom_event_box);
493 gtk_widget_show (child_widget_box); 500 gtk_widget_show (child_widget_box);
494 for (i = 0; i < 3; i++) 501 for (i = 0; i < 3; i++)
495 { 502 {
496 gtk_widget_show (button[i]); 503 gtk_widget_show (button[i]);
497 } 504 }
498 505
499 cursor = gdk_cursor_new (GDK_HAND1); 506 cursor = gdk_cursor_new (GDK_HAND1);
500 gtk_widget_realize (top_event_box); 507 gtk_widget_realize (top_event_box);
501 gdk_window_set_cursor (top_event_box->window, cursor); 508 gdk_window_set_cursor (top_event_box->window, cursor);
502 cursor = gdk_cursor_new (GDK_BOTTOM_RIGHT_CORNER); 509 cursor = gdk_cursor_new (GDK_BOTTOM_RIGHT_CORNER);
503 gtk_widget_realize (bottom_event_box); 510 gtk_widget_realize (bottom_event_box);
504 gdk_window_set_cursor (bottom_event_box->window, cursor); 511 gdk_window_set_cursor (bottom_event_box->window, cursor);
505 512
506 g_signal_connect (G_OBJECT (top_event_box), "event", 513 g_signal_connect (G_OBJECT (top_event_box), "event",
507 G_CALLBACK (move_child_callback), 514 G_CALLBACK (move_child_callback),
508 child); 515 child);
509 g_signal_connect (G_OBJECT (bottom_event_box), "event", 516 g_signal_connect (G_OBJECT (bottom_event_box), "event",
510 G_CALLBACK (resize_child_callback), 517 G_CALLBACK (resize_child_callback),
511 child); 518 child);
512 g_signal_connect (G_OBJECT (button[0]), "button_press_event", 519 g_signal_connect (G_OBJECT (button[0]), "button_press_event",
513 G_CALLBACK (iconify_child_callback), 520 G_CALLBACK (iconify_child_callback),
514 child); 521 child);
515 g_signal_connect (G_OBJECT (button[1]), "button_press_event", 522 g_signal_connect (G_OBJECT (button[1]), "button_press_event",
516 G_CALLBACK (maximize_child_callback), 523 G_CALLBACK (maximize_child_callback),
517 child); 524 child);
518 g_signal_connect (G_OBJECT (button[2]), "button_press_event", 525 g_signal_connect (G_OBJECT (button[2]), "button_press_event",
519 G_CALLBACK (kill_child_callback), 526 G_CALLBACK (kill_child_callback),
520 child); 527 child);
521 } 528 }
522 529
523 static void gtk_mdi_move(GtkMdi *mdi, GtkWidget *widget, gint x, gint y) 530 static void gtk_mdi_move(GtkMdi *mdi, GtkWidget *widget, gint x, gint y)
524 { 531 {
525 GtkMdiChild *child; 532 GtkMdiChild *child;
526 533
527 g_return_if_fail (GTK_IS_MDI (mdi)); 534 g_return_if_fail (GTK_IS_MDI (mdi));
528 g_return_if_fail (GTK_IS_WIDGET (widget)); 535 g_return_if_fail (GTK_IS_WIDGET (widget));
529 536
530 child = get_child (mdi, widget); 537 child = get_child (mdi, widget);
531 g_return_if_fail (child); 538 g_return_if_fail (child);
532 539
533 child->x = x; 540 child->x = x;
534 child->y = y; 541 child->y = y;
535 if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (mdi)) 542 if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (mdi))
536 gtk_widget_queue_resize (GTK_WIDGET (widget)); 543 gtk_widget_queue_resize (GTK_WIDGET (widget));
537 } 544 }
538 545
539 static void gtk_mdi_get_pos(GtkMdi *mdi, GtkWidget *widget, gint *x, gint *y) 546 static void gtk_mdi_get_pos(GtkMdi *mdi, GtkWidget *widget, gint *x, gint *y)
540 { 547 {
541 GtkMdiChild *child; 548 GtkMdiChild *child;
542 549
543 g_return_if_fail (GTK_IS_MDI (mdi)); 550 g_return_if_fail (GTK_IS_MDI (mdi));
544 g_return_if_fail (GTK_IS_WIDGET (widget)); 551 g_return_if_fail (GTK_IS_WIDGET (widget));
545 552
546 child = get_child (mdi, widget); 553 child = get_child (mdi, widget);
547 g_return_if_fail (child); 554 g_return_if_fail (child);
548 555
549 *x = child->x; 556 *x = child->x;
550 *y = child->y; 557 *y = child->y;
551 } 558 }
552 559
553 static void gtk_mdi_tile(GtkMdi *mdi) 560 static void gtk_mdi_tile(GtkMdi *mdi)
554 { 561 {
555 int i, n; 562 int i, n;
556 int width, height; 563 int width, height;
557 GList *children; 564 GList *children;
558 GtkMdiChild *child; 565 GtkMdiChild *child;
559 566
560 g_return_if_fail (GTK_IS_MDI (mdi)); 567 g_return_if_fail (GTK_IS_MDI (mdi));
561 568
562 children = mdi->children; 569 children = mdi->children;
563 n = g_list_length (children); 570 n = g_list_length (children);
564 width = GTK_WIDGET (mdi)->allocation.width; 571 width = GTK_WIDGET (mdi)->allocation.width;
565 height = GTK_WIDGET (mdi)->allocation.height / n; 572 height = GTK_WIDGET (mdi)->allocation.height / n;
566 for (i = 0; i < n; i++) 573 for (i = 0; i < n; i++)
567 { 574 {
568 child = (GtkMdiChild *) children->data; 575 child = (GtkMdiChild *) children->data;
569 children = children->next; 576 children = children->next;
570 child->x = 0; 577 child->x = 0;
571 child->y = i * height; 578 child->y = i * height;
572 gtk_widget_set_size_request (child->widget, width, height); 579 gtk_widget_set_size_request (child->widget, width, height);
573 child->state = CHILD_NORMAL; 580 child->state = CHILD_NORMAL;
574 child->width = -1; 581 child->width = -1;
575 child->height = -1; 582 child->height = -1;
576 } 583 }
577 if (GTK_WIDGET_VISIBLE (GTK_WIDGET (mdi))) 584 if (GTK_WIDGET_VISIBLE (GTK_WIDGET (mdi)))
578 gtk_widget_queue_resize (GTK_WIDGET (mdi)); 585 gtk_widget_queue_resize (GTK_WIDGET (mdi));
579 return; 586 return;
580 } 587 }
581 static void gtk_mdi_cascade(GtkMdi *mdi) 588 static void gtk_mdi_cascade(GtkMdi *mdi)
582 { 589 {
583 int i, n; 590 int i, n;
584 int width, height; 591 int width, height;
585 GList *children; 592 GList *children;
586 GtkMdiChild *child; 593 GtkMdiChild *child;
587 594
588 g_return_if_fail (GTK_IS_MDI (mdi)); 595 g_return_if_fail (GTK_IS_MDI (mdi));
589 if (!GTK_WIDGET_VISIBLE (GTK_WIDGET (mdi))) 596 if (!GTK_WIDGET_VISIBLE (GTK_WIDGET (mdi)))
590 return; 597 return;
591 598
592 children = mdi->children; 599 children = mdi->children;
593 n = g_list_length (children); 600 n = g_list_length (children);
594 width = GTK_WIDGET (mdi)->allocation.width / (2 * n - 1); 601 width = GTK_WIDGET (mdi)->allocation.width / (2 * n - 1);
595 height = GTK_WIDGET (mdi)->allocation.height / (2 * n - 1); 602 height = GTK_WIDGET (mdi)->allocation.height / (2 * n - 1);
596 for (i = 0; i < n; i++) 603 for (i = 0; i < n; i++)
597 { 604 {
598 child = (GtkMdiChild *) children->data; 605 child = (GtkMdiChild *) children->data;
599 children = children->next; 606 children = children->next;
600 child->x = i * width; 607 child->x = i * width;
601 child->y = i * height; 608 child->y = i * height;
602 gtk_widget_set_size_request (child->widget, width * n, height * n); 609 gtk_widget_set_size_request (child->widget, width * n, height * n);
603 child->state = CHILD_NORMAL; 610 child->state = CHILD_NORMAL;
604 child->width = -1; 611 child->width = -1;
605 child->height = -1; 612 child->height = -1;
606 } 613 }
607 if (GTK_WIDGET_VISIBLE (GTK_WIDGET (mdi))) 614 if (GTK_WIDGET_VISIBLE (GTK_WIDGET (mdi)))
608 gtk_widget_queue_resize (GTK_WIDGET (mdi)); 615 gtk_widget_queue_resize (GTK_WIDGET (mdi));
609 return; 616 return;
610 } 617 }
611 618
612 static GtkMdiChildState gtk_mdi_get_state(GtkMdi *mdi, GtkWidget *widget) 619 static GtkMdiChildState gtk_mdi_get_state(GtkMdi *mdi, GtkWidget *widget)
613 { 620 {
614 GtkMdiChild *child; 621 GtkMdiChild *child;
615 622
616 g_return_val_if_fail (GTK_IS_MDI (mdi), CHILD_NORMAL); 623 g_return_val_if_fail (GTK_IS_MDI (mdi), CHILD_NORMAL);
617 g_return_val_if_fail (GTK_IS_WIDGET (widget), CHILD_NORMAL); 624 g_return_val_if_fail (GTK_IS_WIDGET (widget), CHILD_NORMAL);
618 625
619 child = get_child (mdi, widget); 626 child = get_child (mdi, widget);
620 g_return_val_if_fail (child, CHILD_NORMAL); 627 g_return_val_if_fail (child, CHILD_NORMAL);
621 628
622 return child->state; 629 return child->state;
623 } 630 }
624 631
625 static void gtk_mdi_set_state(GtkMdi *mdi, GtkWidget *widget, GtkMdiChildState state) 632 static void gtk_mdi_set_state(GtkMdi *mdi, GtkWidget *widget, GtkMdiChildState state)
626 { 633 {
627 GtkMdiChild *child; 634 GtkMdiChild *child;
628 635
629 g_return_if_fail (GTK_IS_MDI (mdi)); 636 g_return_if_fail (GTK_IS_MDI (mdi));
630 g_return_if_fail (GTK_IS_WIDGET (widget)); 637 g_return_if_fail (GTK_IS_WIDGET (widget));
631 638
632 child = get_child (mdi, widget); 639 child = get_child (mdi, widget);
633 g_return_if_fail (child); 640 g_return_if_fail (child);
634 641
635 child->state = state; 642 child->state = state;
636 if (GTK_WIDGET_VISIBLE (child->widget) && GTK_WIDGET_VISIBLE (mdi)) 643 if (GTK_WIDGET_VISIBLE (child->widget) && GTK_WIDGET_VISIBLE (mdi))
637 gtk_widget_queue_resize (GTK_WIDGET (child->widget)); 644 gtk_widget_queue_resize (GTK_WIDGET (child->widget));
638 } 645 }
639 646
640 static void gtk_mdi_remove(GtkMdi *mdi, GtkWidget *widget) 647 static void gtk_mdi_remove(GtkMdi *mdi, GtkWidget *widget)
641 { 648 {
642 GtkMdiChild *child; 649 GtkMdiChild *child;
643 650
644 g_return_if_fail (GTK_IS_MDI (mdi)); 651 g_return_if_fail (GTK_IS_MDI (mdi));
645 child = get_child (mdi, widget); 652 child = get_child (mdi, widget);
646 g_return_if_fail (child); 653 g_return_if_fail (child);
647 gtk_mdi_remove_true (GTK_CONTAINER (mdi), child->widget); 654 gtk_mdi_remove_true (GTK_CONTAINER (mdi), child->widget);
648 } 655 }
649 656
650 static void gtk_mdi_realize(GtkWidget *widget) 657 static void gtk_mdi_realize(GtkWidget *widget)
651 { 658 {
652 GtkMdi *mdi; 659 GtkMdi *mdi;
653 GdkWindowAttr attributes; 660 GdkWindowAttr attributes;
654 gint attributes_mask; 661 gint attributes_mask;
655 662
656 mdi = GTK_MDI (widget); 663 mdi = GTK_MDI (widget);
657 664
658 g_return_if_fail (widget != NULL); 665 g_return_if_fail (widget != NULL);
659 g_return_if_fail (GTK_IS_MDI (mdi)); 666 g_return_if_fail (GTK_IS_MDI (mdi));
660 667
661 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED); 668 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
662 669
663 attributes.x = widget->allocation.x; 670 attributes.x = widget->allocation.x;
664 attributes.y = widget->allocation.y; 671 attributes.y = widget->allocation.y;
665 attributes.width = widget->allocation.width; 672 attributes.width = widget->allocation.width;
666 attributes.height = widget->allocation.height; 673 attributes.height = widget->allocation.height;
667 attributes.wclass = GDK_INPUT_OUTPUT; 674 attributes.wclass = GDK_INPUT_OUTPUT;
668 attributes.window_type = GDK_WINDOW_CHILD; 675 attributes.window_type = GDK_WINDOW_CHILD;
669 attributes.event_mask = gtk_widget_get_events (widget) | 676 attributes.event_mask = gtk_widget_get_events (widget) |
670 GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | 677 GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK |
671 GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | 678 GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK |
672 GDK_POINTER_MOTION_HINT_MASK; 679 GDK_POINTER_MOTION_HINT_MASK;
673 attributes.visual = gtk_widget_get_visual (widget); 680 attributes.visual = gtk_widget_get_visual (widget);
674 attributes.colormap = gtk_widget_get_colormap (widget); 681 attributes.colormap = gtk_widget_get_colormap (widget);
675 682
676 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP; 683 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
677 widget->window = gdk_window_new (widget->parent->window, &attributes, attributes_mask); 684 widget->window = gdk_window_new (widget->parent->window, &attributes, attributes_mask);
678 685
679 widget->style = gtk_style_attach (widget->style, widget->window); 686 widget->style = gtk_style_attach (widget->style, widget->window);
680 687
681 gdk_window_set_user_data (widget->window, widget); 688 gdk_window_set_user_data (widget->window, widget);
682 689
683 gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL); 690 gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
684 } 691 }
685 692
686 static void gtk_mdi_size_request (GtkWidget *widget, GtkRequisition *requisition) 693 static void gtk_mdi_size_request (GtkWidget *widget, GtkRequisition *requisition)
687 { 694 {
688 GtkMdi *mdi; 695 GtkMdi *mdi;
689 GtkMdiChild *child; 696 GtkMdiChild *child;
690 GList *children; 697 GList *children;
691 GtkRequisition child_requisition; 698 GtkRequisition child_requisition;
692 699
693 mdi = GTK_MDI (widget); 700 mdi = GTK_MDI (widget);
694 requisition->width = GTK_MDI_DEFAULT_WIDTH; 701 requisition->width = GTK_MDI_DEFAULT_WIDTH;
695 requisition->height = GTK_MDI_DEFAULT_HEIGHT; 702 requisition->height = GTK_MDI_DEFAULT_HEIGHT;
696 703
697 children = mdi->children; 704 children = mdi->children;
698 while (children) 705 while (children)
699 { 706 {
700 child = children->data; 707 child = children->data;
701 children = children->next; 708 children = children->next;
702 709
703 if (GTK_WIDGET_VISIBLE (child->widget)) 710 if (GTK_WIDGET_VISIBLE (child->widget))
704 { 711 {
705 gtk_widget_size_request (child->widget, &child_requisition); 712 gtk_widget_size_request (child->widget, &child_requisition);
706 } 713 }
707 } 714 }
708 } 715 }
709 716
710 static void gtk_mdi_size_allocate(GtkWidget *widget, GtkAllocation *allocation) 717 static void gtk_mdi_size_allocate(GtkWidget *widget, GtkAllocation *allocation)
711 { 718 {
712 GtkMdi *mdi; 719 GtkMdi *mdi;
713 GtkMdiChild *child; 720 GtkMdiChild *child;
714 GtkAllocation child_allocation; 721 GtkAllocation child_allocation;
715 GtkRequisition child_requisition; 722 GtkRequisition child_requisition;
716 GList *children; 723 GList *children;
717 724
718 mdi = GTK_MDI (widget); 725 mdi = GTK_MDI (widget);
719 726
720 widget->allocation = *allocation; 727 widget->allocation = *allocation;
721 728
722 if (GTK_WIDGET_REALIZED (widget)) 729 if (GTK_WIDGET_REALIZED (widget))
723 gdk_window_move_resize (widget->window, 730 gdk_window_move_resize (widget->window,
724 allocation->x, 731 allocation->x,
725 allocation->y, 732 allocation->y,
726 allocation->width, 733 allocation->width,
727 allocation->height); 734 allocation->height);
728 735
729 736
730 children = mdi->children; 737 children = mdi->children;
731 while (children) 738 while (children)
732 { 739 {
733 child = children->data; 740 child = children->data;
734 children = children->next; 741 children = children->next;
735 742
736 if (GTK_WIDGET_VISIBLE (child->widget)) 743 if (GTK_WIDGET_VISIBLE (child->widget))
737 { 744 {
738 gtk_widget_get_child_requisition (child->widget, &child_requisition); 745 gtk_widget_get_child_requisition (child->widget, &child_requisition);
739 child_allocation.x = 0; 746 child_allocation.x = 0;
740 child_allocation.y = 0; 747 child_allocation.y = 0;
741 switch (child->state) 748 switch (child->state)
742 { 749 {
743 case CHILD_NORMAL: 750 case CHILD_NORMAL:
744 { 751 {
745 if ((child->width < 0) && (child->height < 0)) 752 if ((child->width < 0) && (child->height < 0))
746 { 753 {
747 child_allocation.width = child_requisition.width; 754 child_allocation.width = child_requisition.width;
748 child_allocation.height = child_requisition.height; 755 child_allocation.height = child_requisition.height;
749 } 756 }
750 else 757 else
751 { 758 {
752 child_allocation.width = child->width; 759 child_allocation.width = child->width;
753 child_allocation.height = child->height; 760 child_allocation.height = child->height;
754 child->width = -1; 761 child->width = -1;
755 child->height = -1; 762 child->height = -1;
756 } 763 }
757 child_allocation.x += child->x; 764 child_allocation.x += child->x;
758 child_allocation.y += child->y; 765 child_allocation.y += child->y;
759 break; 766 break;
760 } 767 }
761 case CHILD_MAXIMIZED: 768 case CHILD_MAXIMIZED:
762 { 769 {
763 if ((child->width < 0) && (child->height < 0)) 770 if ((child->width < 0) && (child->height < 0))
764 { 771 {
765 child->width = child_requisition.width; 772 child->width = child_requisition.width;
766 child->height = child_requisition.height; 773 child->height = child_requisition.height;
767 } 774 }
768 child_allocation.width = allocation->width; 775 child_allocation.width = allocation->width;
769 child_allocation.height = allocation->height; 776 child_allocation.height = allocation->height;
770 } 777 }
771 break; 778 break;
772 case CHILD_ICONIFIED: 779 case CHILD_ICONIFIED:
773 { 780 {
774 if ((child->width < 0) && (child->height < 0)) 781 if ((child->width < 0) && (child->height < 0))
775 { 782 {
776 child->width = child_requisition.width; 783 child->width = child_requisition.width;
777 child->height = child_requisition.height; 784 child->height = child_requisition.height;
778 } 785 }
779 child_allocation.x += child->x; 786 child_allocation.x += child->x;
780 child_allocation.y += child->y; 787 child_allocation.y += child->y;
781 child_allocation.width = child_requisition.width; 788 child_allocation.width = child_requisition.width;
782 child_allocation.height = GTK_MDI_MIN_HEIGHT; 789 child_allocation.height = GTK_MDI_MIN_HEIGHT;
783 break; 790 break;
784 } 791 }
785 } 792 }
786 gtk_widget_size_allocate (child->widget, &child_allocation); 793 gtk_widget_size_allocate (child->widget, &child_allocation);
787 } 794 }
788 } 795 }
789 } 796 }
790 797
791 static gint gtk_mdi_expose(GtkWidget *widget, GdkEventExpose *event) 798 static gint gtk_mdi_expose(GtkWidget *widget, GdkEventExpose *event)
792 { 799 {
793 GtkMdiChild *child; 800 GtkMdiChild *child;
794 GList *children; 801 GList *children;
795 GtkMdi *mdi; 802 GtkMdi *mdi;
796 803
797 g_return_val_if_fail (widget != NULL, FALSE); 804 g_return_val_if_fail (widget != NULL, FALSE);
798 g_return_val_if_fail (GTK_IS_MDI (widget), FALSE); 805 g_return_val_if_fail (GTK_IS_MDI (widget), FALSE);
799 g_return_val_if_fail (event != NULL, FALSE); 806 g_return_val_if_fail (event != NULL, FALSE);
800 807
801 mdi = GTK_MDI (widget); 808 mdi = GTK_MDI (widget);
802 for (children = mdi->children; children; children = children->next) 809 for (children = mdi->children; children; children = children->next)
803 { 810 {
804 child = (GtkMdiChild *) children->data; 811 child = (GtkMdiChild *) children->data;
805 gtk_container_propagate_expose (GTK_CONTAINER (mdi), 812 gtk_container_propagate_expose (GTK_CONTAINER (mdi),
806 child->widget, 813 child->widget,
807 event); 814 event);
808 } 815 }
809 return FALSE; 816 return FALSE;
810 } 817 }
811 818
812 static void gtk_mdi_add(GtkContainer *container, GtkWidget *widget) 819 static void gtk_mdi_add(GtkContainer *container, GtkWidget *widget)
813 { 820 {
814 GtkWidget *label; 821 GtkWidget *label;
815 label = gtk_label_new (""); 822 label = gtk_label_new ("");
816 gtk_mdi_put (GTK_MDI (container), widget, 0, 0, label); 823 gtk_mdi_put (GTK_MDI (container), widget, 0, 0, label);
817 } 824 }
818 825
819 static void gtk_mdi_remove_true(GtkContainer *container, GtkWidget *widget) 826 static void gtk_mdi_remove_true(GtkContainer *container, GtkWidget *widget)
820 { 827 {
821 GtkMdi *mdi; 828 GtkMdi *mdi;
822 GtkMdiChild *child = NULL; 829 GtkMdiChild *child = NULL;
823 GList *children; 830 GList *children;
824 831
825 mdi = GTK_MDI (container); 832 mdi = GTK_MDI (container);
826 833
827 children = mdi->children; 834 children = mdi->children;
828 while (children) 835 while (children)
829 { 836 {
830 child = children->data; 837 child = children->data;
831 if (child->widget == widget) 838 if (child->widget == widget)
832 break; 839 break;
833 840
834 children = children->next; 841 children = children->next;
835 } 842 }
836 843
837 if(child) 844 if(child)
838 { 845 {
839 gtk_widget_unparent (child->widget); 846 gtk_widget_unparent (child->widget);
840 g_free (child); 847 g_free (child);
841 } 848 }
842 mdi->children = g_list_remove_link (mdi->children, children); 849 mdi->children = g_list_remove_link (mdi->children, children);
843 g_list_free (children); 850 g_list_free (children);
844 } 851 }
845 852
846 static void gtk_mdi_forall(GtkContainer *container, gboolean include_internals, GtkCallback callback, gpointer callback_data) 853 static void gtk_mdi_forall(GtkContainer *container, gboolean include_internals, GtkCallback callback, gpointer callback_data)
847 { 854 {
848 GtkMdi *mdi; 855 GtkMdi *mdi;
849 GtkMdiChild *child; 856 GtkMdiChild *child;
850 GList *children; 857 GList *children;
851 858
852 g_return_if_fail (callback != NULL); 859 g_return_if_fail (callback != NULL);
853 860
854 mdi = GTK_MDI (container); 861 mdi = GTK_MDI (container);
855 862
856 children = mdi->children; 863 children = mdi->children;
857 while (children) 864 while (children)
858 { 865 {
859 child = children->data; 866 child = children->data;
860 children = children->next; 867 children = children->next;
861 868
862 (*callback) (child->widget, callback_data); 869 (*callback) (child->widget, callback_data);
863 } 870 }
864 } 871 }
865 872
866 static gboolean move_child_callback(GtkWidget *widget, GdkEvent *event, gpointer data) 873 static gboolean move_child_callback(GtkWidget *widget, GdkEvent *event, gpointer data)
867 { 874 {
868 GtkMdi *mdi; 875 GtkMdi *mdi;
869 GtkMdiChild *child; 876 GtkMdiChild *child;
870 877
871 child = (GtkMdiChild *) data; 878 child = (GtkMdiChild *) data;
872 mdi = child->mdi; 879 mdi = child->mdi;
873 880
874 g_return_val_if_fail (GTK_IS_MDI (mdi), FALSE); 881 g_return_val_if_fail (GTK_IS_MDI (mdi), FALSE);
875 g_return_val_if_fail (GTK_IS_EVENT_BOX (widget), FALSE); 882 g_return_val_if_fail (GTK_IS_EVENT_BOX (widget), FALSE);
876 883
877 884
878 switch (event->type) 885 switch (event->type)
879 { 886 {
880 case GDK_2BUTTON_PRESS: 887 case GDK_2BUTTON_PRESS:
881 { 888 {
882 gdk_window_raise (child->widget->window); 889 gdk_window_raise (child->widget->window);
883 } 890 }
884 case GDK_BUTTON_PRESS: 891 case GDK_BUTTON_PRESS:
885 if (child->state == CHILD_MAXIMIZED) 892 if (child->state == CHILD_MAXIMIZED)
886 return FALSE; 893 return FALSE;
887 if (mdi->drag_button < 0) 894 if (mdi->drag_button < 0)
888 { 895 {
889 if (gdk_pointer_grab (event->button.window, 896 if (gdk_pointer_grab (event->button.window,
890 FALSE, 897 FALSE,
891 GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | 898 GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK |
892 GDK_BUTTON_RELEASE_MASK, 899 GDK_BUTTON_RELEASE_MASK,
893 NULL, 900 NULL,
894 NULL, 901 NULL,
895 event->button.time) != GDK_GRAB_SUCCESS) 902 event->button.time) != GDK_GRAB_SUCCESS)
896 return FALSE; 903 return FALSE;
897 904
898 mdi->drag_button = event->button.button; 905 mdi->drag_button = event->button.button;
899 906
900 mdi->drag_start.x = event->button.x; 907 mdi->drag_start.x = event->button.x;
901 mdi->drag_start.y = event->button.y; 908 mdi->drag_start.y = event->button.y;
902 } 909 }
903 break; 910 break;
904 911
905 case GDK_BUTTON_RELEASE: 912 case GDK_BUTTON_RELEASE:
906 if (mdi->drag_button < 0) 913 if (mdi->drag_button < 0)
907 return FALSE; 914 return FALSE;
908 915
909 if (mdi->drag_button == event->button.button) 916 if (mdi->drag_button == event->button.button)
910 { 917 {
911 int x, y; 918 int x, y;
912 919
913 gdk_pointer_ungrab (event->button.time); 920 gdk_pointer_ungrab (event->button.time);
914 mdi->drag_button = -1; 921 mdi->drag_button = -1;
915 922
916 x = event->button.x + child->x - mdi->drag_start.x; 923 x = event->button.x + child->x - mdi->drag_start.x;
917 y = event->button.y + child->y - mdi->drag_start.y; 924 y = event->button.y + child->y - mdi->drag_start.y;
918 925
919 gtk_mdi_move (mdi, child->child, x, y); 926 gtk_mdi_move (mdi, child->child, x, y);
920 } 927 }
921 break; 928 break;
922 929
923 case GDK_MOTION_NOTIFY: 930 case GDK_MOTION_NOTIFY:
924 { 931 {
925 int x, y; 932 int x, y;
926 933
927 if (mdi->drag_button < 0) 934 if (mdi->drag_button < 0)
928 return FALSE; 935 return FALSE;
929 936
930 gdk_window_get_pointer (widget->window, &x, &y, NULL); 937 gdk_window_get_pointer (widget->window, &x, &y, NULL);
931 938
932 939
933 x = x - mdi->drag_start.x + child->x; 940 x = x - mdi->drag_start.x + child->x;
934 y = y - mdi->drag_start.y + child->y; 941 y = y - mdi->drag_start.y + child->y;
935 942
936 943
937 gtk_mdi_move (mdi, child->child, x, y); 944 gtk_mdi_move (mdi, child->child, x, y);
938 } 945 }
939 break; 946 break;
940 947
941 default: 948 default:
942 break; 949 break;
943 } 950 }
944 951
945 return FALSE; 952 return FALSE;
946 } 953 }
947 954
948 static gboolean resize_child_callback(GtkWidget *widget, GdkEvent *event, gpointer data) 955 static gboolean resize_child_callback(GtkWidget *widget, GdkEvent *event, gpointer data)
949 { 956 {
950 GtkMdi *mdi; 957 GtkMdi *mdi;
951 GtkMdiChild *child; 958 GtkMdiChild *child;
952 959
953 child = (GtkMdiChild *) data; 960 child = (GtkMdiChild *) data;
954 mdi = child->mdi; 961 mdi = child->mdi;
955 962
956 g_return_val_if_fail (GTK_IS_MDI (mdi), FALSE); 963 g_return_val_if_fail (GTK_IS_MDI (mdi), FALSE);
957 g_return_val_if_fail (GTK_IS_EVENT_BOX (widget), FALSE); 964 g_return_val_if_fail (GTK_IS_EVENT_BOX (widget), FALSE);
958 965
959 switch (event->type) 966 switch (event->type)
960 { 967 {
961 case GDK_BUTTON_PRESS: 968 case GDK_BUTTON_PRESS:
962 if (mdi->drag_button < 0) 969 if (mdi->drag_button < 0)
963 { 970 {
964 if (gdk_pointer_grab (event->button.window, 971 if (gdk_pointer_grab (event->button.window,
965 FALSE, 972 FALSE,
966 GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | 973 GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK |
967 GDK_BUTTON_RELEASE_MASK, 974 GDK_BUTTON_RELEASE_MASK,
968 NULL, 975 NULL,
969 NULL, 976 NULL,
970 event->button.time) != GDK_GRAB_SUCCESS) 977 event->button.time) != GDK_GRAB_SUCCESS)
971 return FALSE; 978 return FALSE;
972 979
973 mdi->drag_button = event->button.button; 980 mdi->drag_button = event->button.button;
974 if ((child->state == CHILD_MAXIMIZED) || (child->state == CHILD_ICONIFIED)) 981 if ((child->state == CHILD_MAXIMIZED) || (child->state == CHILD_ICONIFIED))
975 { 982 {
976 child->state = CHILD_NORMAL; 983 child->state = CHILD_NORMAL;
977 child->x = child->widget->allocation.x; 984 child->x = child->widget->allocation.x;
978 child->y = child->widget->allocation.y; 985 child->y = child->widget->allocation.y;
979 child->width = child->widget->allocation.width; 986 child->width = child->widget->allocation.width;
980 child->height = child->widget->allocation.height; 987 child->height = child->widget->allocation.height;
981 } 988 }
982 989
983 } 990 }
984 break; 991 break;
985 992
986 case GDK_BUTTON_RELEASE: 993 case GDK_BUTTON_RELEASE:
987 if (mdi->drag_button < 0) 994 if (mdi->drag_button < 0)
988 return FALSE; 995 return FALSE;
989 996
990 if (mdi->drag_button == event->button.button) 997 if (mdi->drag_button == event->button.button)
991 { 998 {
992 int width, height; 999 int width, height;
993 1000
994 gdk_pointer_ungrab (event->button.time); 1001 gdk_pointer_ungrab (event->button.time);
995 mdi->drag_button = -1; 1002 mdi->drag_button = -1;
996 1003
997 width = event->button.x + widget->allocation.x; 1004 width = event->button.x + widget->allocation.x;
998 height = event->button.y + widget->allocation.y; 1005 height = event->button.y + widget->allocation.y;
999 1006
1000 width = MAX (width, GTK_MDI_MIN_WIDTH); 1007 width = MAX (width, GTK_MDI_MIN_WIDTH);
1001 height = MAX (height, GTK_MDI_MIN_HEIGHT); 1008 height = MAX (height, GTK_MDI_MIN_HEIGHT);
1002 1009
1003 gtk_widget_set_size_request (child->widget, width, height); 1010 gtk_widget_set_size_request (child->widget, width, height);
1004 gtk_widget_queue_resize (child->widget); 1011 gtk_widget_queue_resize (child->widget);
1005 } 1012 }
1006 break; 1013 break;
1007 1014
1008 case GDK_MOTION_NOTIFY: 1015 case GDK_MOTION_NOTIFY:
1009 { 1016 {
1010 int x, y; 1017 int x, y;
1011 int width, height; 1018 int width, height;
1012 1019
1013 if (mdi->drag_button < 0) 1020 if (mdi->drag_button < 0)
1014 return FALSE; 1021 return FALSE;
1015 1022
1016 gdk_window_get_pointer (widget->window, &x, &y, NULL); 1023 gdk_window_get_pointer (widget->window, &x, &y, NULL);
1017 1024
1018 width = x + widget->allocation.x; 1025 width = x + widget->allocation.x;
1019 height = y + widget->allocation.y; 1026 height = y + widget->allocation.y;
1020 1027
1021 width = MAX (width, GTK_MDI_MIN_WIDTH); 1028 width = MAX (width, GTK_MDI_MIN_WIDTH);
1022 height = MAX (height, GTK_MDI_MIN_HEIGHT); 1029 height = MAX (height, GTK_MDI_MIN_HEIGHT);
1023 1030
1024 gtk_widget_set_size_request (child->widget, width, height); 1031 gtk_widget_set_size_request (child->widget, width, height);
1025 gtk_widget_queue_resize (child->widget); 1032 gtk_widget_queue_resize (child->widget);
1026 } 1033 }
1027 break; 1034 break;
1028 1035
1029 default: 1036 default:
1030 break; 1037 break;
1031 } 1038 }
1032 1039
1033 return FALSE; 1040 return FALSE;
1034 } 1041 }
1035 1042
1036 static gboolean iconify_child_callback (GtkWidget *widget, GdkEvent *event, gpointer data) 1043 static gboolean iconify_child_callback (GtkWidget *widget, GdkEvent *event, gpointer data)
1037 { 1044 {
1038 GtkMdiChild *child; 1045 GtkMdiChild *child;
1039 child = (GtkMdiChild *) data; 1046 child = (GtkMdiChild *) data;
1040 if (child->state == CHILD_ICONIFIED) 1047 if (child->state == CHILD_ICONIFIED)
1041 { 1048 {
1042 child->state = CHILD_NORMAL; 1049 child->state = CHILD_NORMAL;
1043 } 1050 }
1044 else 1051 else
1045 { 1052 {
1046 child->state = CHILD_ICONIFIED; 1053 child->state = CHILD_ICONIFIED;
1047 } 1054 }
1048 if (GTK_WIDGET_VISIBLE (child->widget)) 1055 if (GTK_WIDGET_VISIBLE (child->widget))
1049 gtk_widget_queue_resize (GTK_WIDGET (child->widget)); 1056 gtk_widget_queue_resize (GTK_WIDGET (child->widget));
1050 return FALSE; 1057 return FALSE;
1051 } 1058 }
1052 1059
1053 static gboolean maximize_child_callback (GtkWidget *widget, GdkEvent * event, gpointer data) 1060 static gboolean maximize_child_callback (GtkWidget *widget, GdkEvent * event, gpointer data)
1054 { 1061 {
1055 GtkMdiChild *child; 1062 GtkMdiChild *child;
1056 child = (GtkMdiChild *) data; 1063 child = (GtkMdiChild *) data;
1057 if (child->state == CHILD_MAXIMIZED) 1064 if (child->state == CHILD_MAXIMIZED)
1058 { 1065 {
1059 child->state = CHILD_NORMAL; 1066 child->state = CHILD_NORMAL;
1060 } 1067 }
1061 else 1068 else
1062 { 1069 {
1063 child->state = CHILD_MAXIMIZED; 1070 child->state = CHILD_MAXIMIZED;
1064 } 1071 }
1065 if (GTK_WIDGET_VISIBLE (child->widget)) 1072 if (GTK_WIDGET_VISIBLE (child->widget))
1066 gtk_widget_queue_resize (GTK_WIDGET (child->widget)); 1073 gtk_widget_queue_resize (GTK_WIDGET (child->widget));
1067 return FALSE; 1074 return FALSE;
1068 } 1075 }
1069 1076
1070 static gboolean kill_child_callback (GtkWidget *widget, GdkEvent *event, gpointer data) 1077 static gboolean kill_child_callback (GtkWidget *widget, GdkEvent *event, gpointer data)
1071 { 1078 {
1072 GtkMdiChild *child; 1079 GtkMdiChild *child;
1073 GtkMdi *mdi; 1080 GtkMdi *mdi;
1074 1081
1075 child = (GtkMdiChild *) data; 1082 child = (GtkMdiChild *) data;
1076 mdi = child->mdi; 1083 mdi = child->mdi;
1077 1084
1078 g_return_val_if_fail (GTK_IS_MDI (mdi), FALSE); 1085 g_return_val_if_fail (GTK_IS_MDI (mdi), FALSE);
1079 1086
1080 gtk_mdi_remove_true (GTK_CONTAINER (mdi), child->widget); 1087 gtk_mdi_remove_true (GTK_CONTAINER (mdi), child->widget);
1081 return FALSE; 1088 return FALSE;
1082 } 1089 }
1083 1090
1084 static GtkMdiChild *get_child (GtkMdi *mdi, GtkWidget *widget) 1091 static GtkMdiChild *get_child (GtkMdi *mdi, GtkWidget *widget)
1085 { 1092 {
1086 GList *children; 1093 GList *children;
1087 1094
1088 children = mdi->children; 1095 children = mdi->children;
1089 while (children) 1096 while (children)
1090 { 1097 {
1091 GtkMdiChild *child; 1098 GtkMdiChild *child;
1092 1099
1093 child = children->data; 1100 child = children->data;
1094 children = children->next; 1101 children = children->next;
1095 1102
1096 if (child->child == widget) 1103 if (child->child == widget)
1097 return child; 1104 return child;
1098 } 1105 }
1099 1106
1100 return NULL; 1107 return NULL;
1101 } 1108 }
1102 #endif 1109 #endif
1103 1110
1104 static void _dw_msleep(long period) 1111 static void _dw_msleep(long period)
1105 { 1112 {
1106 #ifdef __sun__ 1113 #ifdef __sun__
1107 /* usleep() isn't threadsafe on Solaris */ 1114 /* usleep() isn't threadsafe on Solaris */
1108 struct timespec req; 1115 struct timespec req;
1109 1116
1110 req.tv_sec = 0; 1117 req.tv_sec = 0;
1111 req.tv_nsec = period * 10000000; 1118 req.tv_nsec = period * 10000000;
1112 1119
1113 nanosleep(&req, NULL); 1120 nanosleep(&req, NULL);
1114 #else 1121 #else
1115 usleep(period * 1000); 1122 usleep(period * 1000);
1116 #endif 1123 #endif
1117 } 1124 }
1118 1125
1119 /* Finds the translation function for a given signal name */ 1126 /* Finds the translation function for a given signal name */
1120 static void *_findsigfunc(char *signame) 1127 static void *_findsigfunc(char *signame)
1121 { 1128 {
1122 int z; 1129 int z;
1123 1130
1124 for(z=0;z<SIGNALMAX;z++) 1131 for(z=0;z<SIGNALMAX;z++)
1125 { 1132 {
1126 if(strcasecmp(signame, SignalTranslate[z].name) == 0) 1133 if(strcasecmp(signame, SignalTranslate[z].name) == 0)
1127 return SignalTranslate[z].func; 1134 return SignalTranslate[z].func;
1128 } 1135 }
1129 return NULL; 1136 return NULL;
1130 } 1137 }
1131 1138
1132 static SignalHandler _get_signal_handler(GtkWidget *widget, gpointer data) 1139 static SignalHandler _get_signal_handler(GtkWidget *widget, gpointer data)
1133 { 1140 {
1134 int counter = (int)data; 1141 int counter = (int)data;
1135 SignalHandler sh; 1142 SignalHandler sh;
1136 char text[100]; 1143 char text[100];
1137 1144
1138 sprintf(text, "_dw_sigwindow%d", counter); 1145 sprintf(text, "_dw_sigwindow%d", counter);
1139 sh.window = (HWND)gtk_object_get_data(GTK_OBJECT(widget), text); 1146 sh.window = (HWND)gtk_object_get_data(GTK_OBJECT(widget), text);
1140 sprintf(text, "_dw_sigfunc%d", counter); 1147 sprintf(text, "_dw_sigfunc%d", counter);
1141 sh.func = (void *)gtk_object_get_data(GTK_OBJECT(widget), text); 1148 sh.func = (void *)gtk_object_get_data(GTK_OBJECT(widget), text);
1142 sprintf(text, "_dw_intfunc%d", counter); 1149 sprintf(text, "_dw_intfunc%d", counter);
1143 sh.intfunc = (void *)gtk_object_get_data(GTK_OBJECT(widget), text); 1150 sh.intfunc = (void *)gtk_object_get_data(GTK_OBJECT(widget), text);
1144 sprintf(text, "_dw_sigdata%d", counter); 1151 sprintf(text, "_dw_sigdata%d", counter);
1145 sh.data = gtk_object_get_data(GTK_OBJECT(widget), text); 1152 sh.data = gtk_object_get_data(GTK_OBJECT(widget), text);
1146 sprintf(text, "_dw_sigcid%d", counter); 1153 sprintf(text, "_dw_sigcid%d", counter);
1147 sh.cid = (gint)gtk_object_get_data(GTK_OBJECT(widget), text); 1154 sh.cid = (gint)gtk_object_get_data(GTK_OBJECT(widget), text);
1148 1155
1149 return sh; 1156 return sh;
1150 } 1157 }
1151 1158
1152 static void _remove_signal_handler(GtkWidget *widget, int counter) 1159 static void _remove_signal_handler(GtkWidget *widget, int counter)
1153 { 1160 {
1154 char text[100]; 1161 char text[100];
1155 gint cid; 1162 gint cid;
1156 1163
1157 sprintf(text, "_dw_sigcid%d", counter); 1164 sprintf(text, "_dw_sigcid%d", counter);
1158 cid = (gint)gtk_object_get_data(GTK_OBJECT(widget), text); 1165 cid = (gint)gtk_object_get_data(GTK_OBJECT(widget), text);
1159 gtk_signal_disconnect(GTK_OBJECT(widget), cid); 1166 gtk_signal_disconnect(GTK_OBJECT(widget), cid);
1160 gtk_object_set_data(GTK_OBJECT(widget), text, NULL); 1167 gtk_object_set_data(GTK_OBJECT(widget), text, NULL);
1161 sprintf(text, "_dw_sigwindow%d", counter); 1168 sprintf(text, "_dw_sigwindow%d", counter);
1162 gtk_object_set_data(GTK_OBJECT(widget), text, NULL); 1169 gtk_object_set_data(GTK_OBJECT(widget), text, NULL);
1163 sprintf(text, "_dw_sigfunc%d", counter); 1170 sprintf(text, "_dw_sigfunc%d", counter);
1164 gtk_object_set_data(GTK_OBJECT(widget), text, NULL); 1171 gtk_object_set_data(GTK_OBJECT(widget), text, NULL);
1165 sprintf(text, "_dw_intfunc%d", counter); 1172 sprintf(text, "_dw_intfunc%d", counter);
1166 gtk_object_set_data(GTK_OBJECT(widget), text, NULL); 1173 gtk_object_set_data(GTK_OBJECT(widget), text, NULL);
1167 sprintf(text, "_dw_sigdata%d", counter); 1174 sprintf(text, "_dw_sigdata%d", counter);
1168 gtk_object_set_data(GTK_OBJECT(widget), text, NULL); 1175 gtk_object_set_data(GTK_OBJECT(widget), text, NULL);
1169 } 1176 }
1170 1177
1171 static int _set_signal_handler(GtkWidget *widget, HWND window, void *func, gpointer data, void *intfunc) 1178 static int _set_signal_handler(GtkWidget *widget, HWND window, void *func, gpointer data, void *intfunc)
1172 { 1179 {
1173 int counter = (int)gtk_object_get_data(GTK_OBJECT(widget), "_dw_sigcounter"); 1180 int counter = (int)gtk_object_get_data(GTK_OBJECT(widget), "_dw_sigcounter");
1174 char text[100]; 1181 char text[100];
1175 1182
1176 sprintf(text, "_dw_sigwindow%d", counter); 1183 sprintf(text, "_dw_sigwindow%d", counter);
1177 gtk_object_set_data(GTK_OBJECT(widget), text, (gpointer)window); 1184 gtk_object_set_data(GTK_OBJECT(widget), text, (gpointer)window);
1178 sprintf(text, "_dw_sigfunc%d", counter); 1185 sprintf(text, "_dw_sigfunc%d", counter);
1179 gtk_object_set_data(GTK_OBJECT(widget), text, (gpointer)func); 1186 gtk_object_set_data(GTK_OBJECT(widget), text, (gpointer)func);
1180 sprintf(text, "_dw_intfunc%d", counter); 1187 sprintf(text, "_dw_intfunc%d", counter);
1181 gtk_object_set_data(GTK_OBJECT(widget), text, (gpointer)intfunc); 1188 gtk_object_set_data(GTK_OBJECT(widget), text, (gpointer)intfunc);
1182 sprintf(text, "_dw_sigdata%d", counter); 1189 sprintf(text, "_dw_sigdata%d", counter);
1183 gtk_object_set_data(GTK_OBJECT(widget), text, (gpointer)data); 1190 gtk_object_set_data(GTK_OBJECT(widget), text, (gpointer)data);
1184 1191
1185 counter++; 1192 counter++;
1186 gtk_object_set_data(GTK_OBJECT(widget), "_dw_sigcounter", (gpointer)counter); 1193 gtk_object_set_data(GTK_OBJECT(widget), "_dw_sigcounter", GINT_TO_POINTER(counter));
1187 1194
1188 return counter - 1; 1195 return counter - 1;
1189 } 1196 }
1190 1197
1191 static void _set_signal_handler_id(GtkWidget *widget, int counter, gint cid) 1198 static void _set_signal_handler_id(GtkWidget *widget, int counter, gint cid)
1192 { 1199 {
1193 char text[100]; 1200 char text[100];
1194 1201
1195 sprintf(text, "_dw_sigcid%d", counter); 1202 sprintf(text, "_dw_sigcid%d", counter);
1196 gtk_object_set_data(GTK_OBJECT(widget), text, (gpointer)cid); 1203 gtk_object_set_data(GTK_OBJECT(widget), text, GINT_TO_POINTER(cid));
1197 } 1204 }
1198 1205
1199 static gint _set_focus_event(GtkWindow *window, GtkWidget *widget, gpointer data) 1206 static gint _set_focus_event(GtkWindow *window, GtkWidget *widget, gpointer data)
1200 { 1207 {
1201 SignalHandler work = _get_signal_handler((GtkWidget *)window, data); 1208 SignalHandler work = _get_signal_handler((GtkWidget *)window, data);
1202 int retval = FALSE; 1209 int retval = FALSE;
1203 1210
1204 if(work.window) 1211 if(work.window)
1205 { 1212 {
1206 int (*setfocusfunc)(HWND, void *) = work.func; 1213 int (*setfocusfunc)(HWND, void *) = work.func;
1207 1214
1208 retval = setfocusfunc(work.window, work.data); 1215 retval = setfocusfunc(work.window, work.data);
1209 } 1216 }
1210 return retval; 1217 return retval;
1211 } 1218 }
1212 1219
1213 static gint _button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data) 1220 static gint _button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
1214 { 1221 {
1215 SignalHandler work = _get_signal_handler(widget, data); 1222 SignalHandler work = _get_signal_handler(widget, data);
1216 int retval = FALSE; 1223 int retval = FALSE;
1217 1224
1218 if(work.window) 1225 if(work.window)
1219 { 1226 {
1220 int (*buttonfunc)(HWND, int, int, int, void *) = work.func; 1227 int (*buttonfunc)(HWND, int, int, int, void *) = work.func;
1221 int mybutton = event->button; 1228 int mybutton = event->button;
1222 1229
1223 if(event->button == 3) 1230 if(event->button == 3)
1224 mybutton = 2; 1231 mybutton = 2;
1225 else if(event->button == 2) 1232 else if(event->button == 2)
1226 mybutton = 3; 1233 mybutton = 3;
1227 1234
1228 retval = buttonfunc(work.window, event->x, event->y, mybutton, work.data); 1235 retval = buttonfunc(work.window, event->x, event->y, mybutton, work.data);
1229 } 1236 }
1230 return retval; 1237 return retval;
1231 } 1238 }
1232 1239
1233 static gint _button_release_event(GtkWidget *widget, GdkEventButton *event, gpointer data) 1240 static gint _button_release_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
1234 { 1241 {
1235 SignalHandler work = _get_signal_handler(widget, data); 1242 SignalHandler work = _get_signal_handler(widget, data);
1236 int retval = FALSE; 1243 int retval = FALSE;
1237 1244
1238 if(work.window) 1245 if(work.window)
1239 { 1246 {
1240 int (*buttonfunc)(HWND, int, int, int, void *) = work.func; 1247 int (*buttonfunc)(HWND, int, int, int, void *) = work.func;
1241 int mybutton = event->button; 1248 int mybutton = event->button;
1242 1249
1243 if(event->button == 3) 1250 if(event->button == 3)
1244 mybutton = 2; 1251 mybutton = 2;
1245 else if(event->button == 2) 1252 else if(event->button == 2)
1246 mybutton = 3; 1253 mybutton = 3;
1247 1254
1248 retval = buttonfunc(work.window, event->x, event->y, mybutton, work.data); 1255 retval = buttonfunc(work.window, event->x, event->y, mybutton, work.data);
1249 } 1256 }
1250 return retval; 1257 return retval;
1251 } 1258 }
1252 1259
1253 static gint _motion_notify_event(GtkWidget *widget, GdkEventMotion *event, gpointer data) 1260 static gint _motion_notify_event(GtkWidget *widget, GdkEventMotion *event, gpointer data)
1254 { 1261 {
1255 SignalHandler work = _get_signal_handler(widget, data); 1262 SignalHandler work = _get_signal_handler(widget, data);
1256 int retval = FALSE; 1263 int retval = FALSE;
1257 1264
1258 if(work.window) 1265 if(work.window)
1259 { 1266 {
1260 int (*motionfunc)(HWND, int, int, int, void *) = work.func; 1267 int (*motionfunc)(HWND, int, int, int, void *) = work.func;
1261 int keys = 0, x, y; 1268 int keys = 0, x, y;
1262 GdkModifierType state; 1269 GdkModifierType state;
1263 1270
1264 if (event->is_hint) 1271 if (event->is_hint)
1265 gdk_window_get_pointer (event->window, &x, &y, &state); 1272 gdk_window_get_pointer (event->window, &x, &y, &state);
1266 else 1273 else
1267 { 1274 {
1268 x = event->x; 1275 x = event->x;
1269 y = event->y; 1276 y = event->y;
1270 state = event->state; 1277 state = event->state;
1271 } 1278 }
1272 1279
1273 if (state & GDK_BUTTON1_MASK) 1280 if (state & GDK_BUTTON1_MASK)
1274 keys = DW_BUTTON1_MASK; 1281 keys = DW_BUTTON1_MASK;
1275 if (state & GDK_BUTTON3_MASK) 1282 if (state & GDK_BUTTON3_MASK)
1276 keys |= DW_BUTTON2_MASK; 1283 keys |= DW_BUTTON2_MASK;
1277 if (state & GDK_BUTTON2_MASK) 1284 if (state & GDK_BUTTON2_MASK)
1278 keys |= DW_BUTTON3_MASK; 1285 keys |= DW_BUTTON3_MASK;
1279 1286
1280 retval = motionfunc(work.window, x, y, keys, work.data); 1287 retval = motionfunc(work.window, x, y, keys, work.data);
1281 } 1288 }
1282 return retval; 1289 return retval;
1283 } 1290 }
1284 1291
1285 static gint _delete_event(GtkWidget *widget, GdkEvent *event, gpointer data) 1292 static gint _delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)
1286 { 1293 {
1287 SignalHandler work = _get_signal_handler(widget, data); 1294 SignalHandler work = _get_signal_handler(widget, data);
1288 int retval = FALSE; 1295 int retval = FALSE;
1289 1296
1290 if(work.window) 1297 if(work.window)
1291 { 1298 {
1292 int (*closefunc)(HWND, void *) = work.func; 1299 int (*closefunc)(HWND, void *) = work.func;
1293 1300
1294 retval = closefunc(work.window, work.data); 1301 retval = closefunc(work.window, work.data);
1295 } 1302 }
1296 return retval; 1303 return retval;
1297 } 1304 }
1298 1305
1299 static gint _key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data) 1306 static gint _key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
1300 { 1307 {
1301 SignalHandler work = _get_signal_handler(widget, data); 1308 SignalHandler work = _get_signal_handler(widget, data);
1302 int retval = FALSE; 1309 int retval = FALSE;
1303 1310
1304 if(work.window) 1311 if(work.window)
1305 { 1312 {
1306 int (*keypressfunc)(HWND, char, int, int, void *) = work.func; 1313 int (*keypressfunc)(HWND, char, int, int, void *) = work.func;
1307 1314
1308 retval = keypressfunc(work.window, *event->string, event->keyval, 1315 retval = keypressfunc(work.window, *event->string, event->keyval,
1309 event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK), work.data); 1316 event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK), work.data);
1310 } 1317 }
1311 return retval; 1318 return retval;
1312 } 1319 }
1313 1320
1314 static gint _generic_event(GtkWidget *widget, gpointer data) 1321 static gint _generic_event(GtkWidget *widget, gpointer data)
1315 { 1322 {
1316 SignalHandler work = _get_signal_handler(widget, data); 1323 SignalHandler work = _get_signal_handler(widget, data);
1317 int retval = FALSE; 1324 int retval = FALSE;
1318 1325
1319 if(work.window) 1326 if(work.window)
1320 { 1327 {
1321 int (*genericfunc)(HWND, void *) = work.func; 1328 int (*genericfunc)(HWND, void *) = work.func;
1322 1329
1323 retval = genericfunc(work.window, work.data); 1330 retval = genericfunc(work.window, work.data);
1324 } 1331 }
1325 return retval; 1332 return retval;
1326 } 1333 }
1327 1334
1328 static gint _activate_event(GtkWidget *widget, gpointer data) 1335 static gint _activate_event(GtkWidget *widget, gpointer data)
1329 { 1336 {
1330 SignalHandler work = _get_signal_handler(widget, data); 1337 SignalHandler work = _get_signal_handler(widget, data);
1331 int retval = FALSE; 1338 int retval = FALSE;
1332 1339
1333 if(work.window && !_dw_ignore_click) 1340 if(work.window && !_dw_ignore_click)
1334 { 1341 {
1335 int (*activatefunc)(HWND, void *) = work.func; 1342 int (*activatefunc)(HWND, void *) = work.func;
1336 1343
1337 retval = activatefunc(popup ? popup : work.window, work.data); 1344 retval = activatefunc(popup ? popup : work.window, work.data);
1338 } 1345 }
1339 return retval; 1346 return retval;
1340 } 1347 }
1341 1348
1342 static gint _configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer data) 1349 static gint _configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer data)
1343 { 1350 {
1344 SignalHandler work = _get_signal_handler(widget, data); 1351 SignalHandler work = _get_signal_handler(widget, data);
1345 int retval = FALSE; 1352 int retval = FALSE;
1346 1353
1347 if(work.window) 1354 if(work.window)
1348 { 1355 {
1349 int (*sizefunc)(HWND, int, int, void *) = work.func; 1356 int (*sizefunc)(HWND, int, int, void *) = work.func;
1350 1357
1351 retval = sizefunc(work.window, event->width, event->height, work.data); 1358 retval = sizefunc(work.window, event->width, event->height, work.data);
1352 } 1359 }
1353 return retval; 1360 return retval;
1354 } 1361 }
1355 1362
1356 static gint _expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer data) 1363 static gint _expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer data)
1357 { 1364 {
1358 SignalHandler work = _get_signal_handler(widget, data); 1365 SignalHandler work = _get_signal_handler(widget, data);
1359 int retval = FALSE; 1366 int retval = FALSE;
1360 1367
1361 if(work.window) 1368 if(work.window)
1362 { 1369 {
1363 DWExpose exp; 1370 DWExpose exp;
1364 int (*exposefunc)(HWND, DWExpose *, void *) = work.func; 1371 int (*exposefunc)(HWND, DWExpose *, void *) = work.func;
1365 1372
1366 exp.x = event->area.x; 1373 exp.x = event->area.x;
1367 exp.y = event->area.y; 1374 exp.y = event->area.y;
1368 exp.width = event->area.width; 1375 exp.width = event->area.width;
1369 exp.height = event->area.height; 1376 exp.height = event->area.height;
1370 retval = exposefunc(work.window, &exp, work.data); 1377 retval = exposefunc(work.window, &exp, work.data);
1371 } 1378 }
1372 return retval; 1379 return retval;
1373 } 1380 }
1374 1381
1375 static gint _item_select_event(GtkWidget *widget, GtkWidget *child, gpointer data) 1382 static gint _item_select_event(GtkWidget *widget, GtkWidget *child, gpointer data)
1376 { 1383 {
1377 SignalHandler work = _get_signal_handler(widget, data); 1384 SignalHandler work = _get_signal_handler(widget, data);
1378 static int _dw_recursing = 0; 1385 static int _dw_recursing = 0;
1379 int retval = FALSE; 1386 int retval = FALSE;
1380 1387
1381 if(_dw_recursing) 1388 if(_dw_recursing)
1382 return FALSE; 1389 return FALSE;
1383 1390
1384 if(work.window) 1391 if(work.window)
1385 { 1392 {
1386 int (*selectfunc)(HWND, int, void *) = work.func; 1393 int (*selectfunc)(HWND, int, void *) = work.func;
1387 GList *list; 1394 GList *list;
1388 int item = 0; 1395 int item = 0;
1389 1396
1390 _dw_recursing = 1; 1397 _dw_recursing = 1;
1391 1398
1392 if(GTK_IS_COMBO(work.window)) 1399 if(GTK_IS_COMBO(work.window))
1393 list = GTK_LIST(GTK_COMBO(work.window)->list)->children; 1400 list = GTK_LIST(GTK_COMBO(work.window)->list)->children;
1394 else if(GTK_IS_LIST(widget)) 1401 else if(GTK_IS_LIST(widget))
1395 list = GTK_LIST(widget)->children; 1402 list = GTK_LIST(widget)->children;
1396 else 1403 else
1397 return FALSE; 1404 return FALSE;
1398 1405
1399 while(list) 1406 while(list)
1400 { 1407 {
1401 if(list->data == (gpointer)child) 1408 if(list->data == (gpointer)child)
1402 { 1409 {
1403 if(!gtk_object_get_data(GTK_OBJECT(work.window), "_dw_appending")) 1410 if(!gtk_object_get_data(GTK_OBJECT(work.window), "_dw_appending"))
1404 { 1411 {
1405 gtk_object_set_data(GTK_OBJECT(work.window), "_dw_item", (gpointer)item); 1412 gtk_object_set_data(GTK_OBJECT(work.window), "_dw_item", GINT_TO_POINTER(item));
1406 if(selectfunc) 1413 if(selectfunc)
1407 retval = selectfunc(work.window, item, work.data); 1414 retval = selectfunc(work.window, item, work.data);
1408 } 1415 }
1409 break; 1416 break;
1410 } 1417 }
1411 item++; 1418 item++;
1412 list = list->next; 1419 list = list->next;
1413 } 1420 }
1414 _dw_recursing = 0; 1421 _dw_recursing = 0;
1415 } 1422 }
1416 return retval; 1423 return retval;
1417 } 1424 }
1418 1425
1419 static gint _container_context_event(GtkWidget *widget, GdkEventButton *event, gpointer data) 1426 static gint _container_context_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
1420 { 1427 {
1421 SignalHandler work = _get_signal_handler(widget, data); 1428 SignalHandler work = _get_signal_handler(widget, data);
1422 int retval = FALSE; 1429 int retval = FALSE;
1423 1430
1424 if(work.window) 1431 if(work.window)
1425 { 1432 {
1426 if(event->button == 3) 1433 if(event->button == 3)
1427 { 1434 {
1428 int (*contextfunc)(HWND, char *, int, int, void *, void *) = work.func; 1435 int (*contextfunc)(HWND, char *, int, int, void *, void *) = work.func;
1429 char *text; 1436 char *text;
1430 int row, col; 1437 int row, col;
1431 1438
1432 gtk_clist_get_selection_info(GTK_CLIST(widget), event->x, event->y, &row, &col); 1439 gtk_clist_get_selection_info(GTK_CLIST(widget), event->x, event->y, &row, &col);
1433 1440
1434 text = (char *)gtk_clist_get_row_data(GTK_CLIST(widget), row); 1441 text = (char *)gtk_clist_get_row_data(GTK_CLIST(widget), row);
1435 retval = contextfunc(work.window, text, event->x, event->y, work.data, NULL); 1442 retval = contextfunc(work.window, text, event->x, event->y, work.data, NULL);
1436 } 1443 }
1437 } 1444 }
1438 return retval; 1445 return retval;
1439 } 1446 }
1440 1447
1441 static gint _tree_context_event(GtkWidget *widget, GdkEventButton *event, gpointer data) 1448 static gint _tree_context_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
1442 { 1449 {
1443 SignalHandler work = _get_signal_handler(widget, data); 1450 SignalHandler work = _get_signal_handler(widget, data);
1444 int retval = FALSE; 1451 int retval = FALSE;
1445 1452
1446 if(work.window) 1453 if(work.window)
1447 { 1454 {
1448 if(event->button == 3) 1455 if(event->button == 3)
1449 { 1456 {
1450 #if GTK_MAJOR_VERSION > 1 1457 #if GTK_MAJOR_VERSION > 1
1451 int (*contextfunc)(HWND, char *, int, int, void *, void *) = work.func; 1458 int (*contextfunc)(HWND, char *, int, int, void *, void *) = work.func;
1452 char *text = NULL; 1459 char *text = NULL;
1453 void *itemdata = NULL; 1460 void *itemdata = NULL;
1454 1461
1455 if(widget && GTK_IS_TREE_VIEW(widget)) 1462 if(widget && GTK_IS_TREE_VIEW(widget))
1456 { 1463 {
1457 GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget)); 1464 GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
1458 GtkTreeIter iter; 1465 GtkTreeIter iter;
1459 1466
1460 if(sel && gtk_tree_selection_get_selected(sel, NULL, &iter)) 1467 if(sel && gtk_tree_selection_get_selected(sel, NULL, &iter))
1461 { 1468 {
1462 GtkTreeModel *store = (GtkTreeModel *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_tree_store"); 1469 GtkTreeModel *store = (GtkTreeModel *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_tree_store");
1463 gtk_tree_model_get(store, &iter, 0, &text, 2, &itemdata, -1); 1470 gtk_tree_model_get(store, &iter, 0, &text, 2, &itemdata, -1);
1464 } 1471 }
1465 } 1472 }
1466 1473
1467 retval = contextfunc(work.window, text, event->x, event->y, work.data, itemdata); 1474 retval = contextfunc(work.window, text, event->x, event->y, work.data, itemdata);
1468 #else 1475 #else
1469 int (*contextfunc)(HWND, char *, int, int, void *, void *) = work.func; 1476 int (*contextfunc)(HWND, char *, int, int, void *, void *) = work.func;
1470 char *text = (char *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_text"); 1477 char *text = (char *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_text");
1471 void *itemdata = (void *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_itemdata"); 1478 void *itemdata = (void *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_itemdata");
1472 1479
1473 if(widget != work.window) 1480 if(widget != work.window)
1474 { 1481 {
1475 GtkWidget *tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(work.window)); 1482 GtkWidget *tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(work.window));
1476 1483
1477 if(tree && GTK_IS_TREE(tree)) 1484 if(tree && GTK_IS_TREE(tree))
1478 { 1485 {
1479 GtkWidget *lastselect = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_lastselect"); 1486 GtkWidget *lastselect = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_lastselect");
1480 1487
1481 if(lastselect && GTK_IS_TREE_ITEM(lastselect)) 1488 if(lastselect && GTK_IS_TREE_ITEM(lastselect))
1482 { 1489 {
1483 text = (char *)gtk_object_get_data(GTK_OBJECT(lastselect), "_dw_text"); 1490 text = (char *)gtk_object_get_data(GTK_OBJECT(lastselect), "_dw_text");
1484 itemdata = (void *)gtk_object_get_data(GTK_OBJECT(lastselect), "_dw_itemdata"); 1491 itemdata = (void *)gtk_object_get_data(GTK_OBJECT(lastselect), "_dw_itemdata");
1485 } 1492 }
1486 } 1493 }
1487 } 1494 }
1488 1495
1489 retval = contextfunc(work.window, text, event->x, event->y, work.data, itemdata); 1496 retval = contextfunc(work.window, text, event->x, event->y, work.data, itemdata);
1490 #endif 1497 #endif
1491 } 1498 }
1492 } 1499 }
1493 return retval; 1500 return retval;
1494 } 1501 }
1495 1502
1496 #if GTK_MAJOR_VERSION > 1 1503 #if GTK_MAJOR_VERSION > 1
1497 static gint _tree_select_event(GtkTreeSelection *sel, gpointer data) 1504 static gint _tree_select_event(GtkTreeSelection *sel, gpointer data)
1498 { 1505 {
1499 GtkWidget *item, *widget = (GtkWidget *)gtk_tree_selection_get_tree_view(sel); 1506 GtkWidget *item, *widget = (GtkWidget *)gtk_tree_selection_get_tree_view(sel);
1500 int retval = FALSE; 1507 int retval = FALSE;
1501 1508
1502 if(widget) 1509 if(widget)
1503 { 1510 {
1504 SignalHandler work = _get_signal_handler(widget, data); 1511 SignalHandler work = _get_signal_handler(widget, data);
1505 1512
1506 if(work.window) 1513 if(work.window)
1507 { 1514 {
1508 int (*treeselectfunc)(HWND, HTREEITEM, char *, void *, void *) = work.func; 1515 int (*treeselectfunc)(HWND, HTREEITEM, char *, void *, void *) = work.func;
1509 GtkTreeIter iter; 1516 GtkTreeIter iter;
1510 char *text = NULL; 1517 char *text = NULL;
1511 void *itemdata = NULL; 1518 void *itemdata = NULL;
1512 1519
1513 if(gtk_tree_selection_get_selected(sel, NULL, &iter)) 1520 if(gtk_tree_selection_get_selected(sel, NULL, &iter))
1514 { 1521 {
1515 GtkTreeModel *store = (GtkTreeModel *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_tree_store"); 1522 GtkTreeModel *store = (GtkTreeModel *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_tree_store");
1516 gtk_tree_model_get(store, &iter, 0, &text, 2, &itemdata, 3, &item, -1); 1523 gtk_tree_model_get(store, &iter, 0, &text, 2, &itemdata, 3, &item, -1);
1517 retval = treeselectfunc(work.window, (HTREEITEM)item, text, work.data, itemdata); 1524 retval = treeselectfunc(work.window, (HTREEITEM)item, text, work.data, itemdata);
1518 } 1525 }
1519 } 1526 }
1520 } 1527 }
1521 return retval; 1528 return retval;
1522 } 1529 }
1523 1530
1524 static gint _tree_expand_event(GtkTreeView *widget, GtkTreeIter *iter, GtkTreePath *path, gpointer data) 1531 static gint _tree_expand_event(GtkTreeView *widget, GtkTreeIter *iter, GtkTreePath *path, gpointer data)
1525 { 1532 {
1526 SignalHandler work = _get_signal_handler((GtkWidget *)widget, data); 1533 SignalHandler work = _get_signal_handler((GtkWidget *)widget, data);
1527 int retval = FALSE; 1534 int retval = FALSE;
1528 1535
1529 if(!_dw_ignore_expand && work.window) 1536 if(!_dw_ignore_expand && work.window)
1530 { 1537 {
1531 int (*treeexpandfunc)(HWND, HTREEITEM, void *) = work.func; 1538 int (*treeexpandfunc)(HWND, HTREEITEM, void *) = work.func;
1532 retval = treeexpandfunc(work.window, (HTREEITEM)iter, work.data); 1539 retval = treeexpandfunc(work.window, (HTREEITEM)iter, work.data);
1533 } 1540 }
1534 return retval; 1541 return retval;
1535 } 1542 }
1536 #else 1543 #else
1537 static gint _tree_select_event(GtkTree *tree, GtkWidget *child, gpointer data) 1544 static gint _tree_select_event(GtkTree *tree, GtkWidget *child, gpointer data)
1538 { 1545 {
1539 SignalHandler work = _get_signal_handler((GtkWidget *)tree, data); 1546 SignalHandler work = _get_signal_handler((GtkWidget *)tree, data);
1540 GtkWidget *treeroot = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(child), "_dw_tree"); 1547 GtkWidget *treeroot = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(child), "_dw_tree");
1541 int retval = FALSE; 1548 int retval = FALSE;
1542 1549
1543 if(treeroot && GTK_IS_TREE(treeroot)) 1550 if(treeroot && GTK_IS_TREE(treeroot))
1544 { 1551 {
1545 GtkWidget *lastselect = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(treeroot), "_dw_lastselect"); 1552 GtkWidget *lastselect = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(treeroot), "_dw_lastselect");
1546 if(lastselect && GTK_IS_TREE_ITEM(lastselect)) 1553 if(lastselect && GTK_IS_TREE_ITEM(lastselect))
1547 gtk_tree_item_deselect(GTK_TREE_ITEM(lastselect)); 1554 gtk_tree_item_deselect(GTK_TREE_ITEM(lastselect));
1548 gtk_object_set_data(GTK_OBJECT(treeroot), "_dw_lastselect", (gpointer)child); 1555 gtk_object_set_data(GTK_OBJECT(treeroot), "_dw_lastselect", (gpointer)child);
1549 } 1556 }
1550 1557
1551 if(work.window) 1558 if(work.window)
1552 { 1559 {
1553 int (*treeselectfunc)(HWND, HTREEITEM, char *, void *, void *) = work.func; 1560 int (*treeselectfunc)(HWND, HTREEITEM, char *, void *, void *) = work.func;
1554 char *text = (char *)gtk_object_get_data(GTK_OBJECT(child), "_dw_text"); 1561 char *text = (char *)gtk_object_get_data(GTK_OBJECT(child), "_dw_text");
1555 void *itemdata = (void *)gtk_object_get_data(GTK_OBJECT(child), "_dw_itemdata"); 1562 void *itemdata = (void *)gtk_object_get_data(GTK_OBJECT(child), "_dw_itemdata");
1556 retval = treeselectfunc(work.window, (HTREEITEM)child, text, work.data, itemdata); 1563 retval = treeselectfunc(work.window, (HTREEITEM)child, text, work.data, itemdata);
1557 } 1564 }
1558 return retval; 1565 return retval;
1559 } 1566 }
1560 1567
1561 static gint _tree_expand_event(GtkTreeItem *treeitem, gpointer data) 1568 static gint _tree_expand_event(GtkTreeItem *treeitem, gpointer data)
1562 { 1569 {
1563 SignalHandler work = _get_signal_handler((GtkWidget *)treeitem, data); 1570 SignalHandler work = _get_signal_handler((GtkWidget *)treeitem, data);
1564 int retval = FALSE; 1571 int retval = FALSE;
1565 1572
1566 if(!_dw_ignore_expand && work.window) 1573 if(!_dw_ignore_expand && work.window)
1567 { 1574 {
1568 int (*treeexpandfunc)(HWND, HTREEITEM, void *) = work.func; 1575 int (*treeexpandfunc)(HWND, HTREEITEM, void *) = work.func;
1569 retval = treeexpandfunc(work.window, (HTREEITEM)treeitem, work.data); 1576 retval = treeexpandfunc(work.window, (HTREEITEM)treeitem, work.data);
1570 } 1577 }
1571 return retval; 1578 return retval;
1572 } 1579 }
1573 #endif 1580 #endif
1574 1581
1575 static gint _container_select_event(GtkWidget *widget, GdkEventButton *event, gpointer data) 1582 static gint _container_select_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
1576 { 1583 {
1577 SignalHandler work = _get_signal_handler(widget, data); 1584 SignalHandler work = _get_signal_handler(widget, data);
1578 int retval = FALSE; 1585 int retval = FALSE;
1579 1586
1580 if(work.window) 1587 if(work.window)
1581 { 1588 {
1582 if(event->button == 1 && event->type == GDK_2BUTTON_PRESS) 1589 if(event->button == 1 && event->type == GDK_2BUTTON_PRESS)
1583 { 1590 {
1584 int (*contextfunc)(HWND, char *, void *) = work.func; 1591 int (*contextfunc)(HWND, char *, void *) = work.func;
1585 char *text; 1592 char *text;
1586 int row, col; 1593 int row, col;
1587 1594
1588 gtk_clist_get_selection_info(GTK_CLIST(widget), event->x, event->y, &row, &col); 1595 gtk_clist_get_selection_info(GTK_CLIST(widget), event->x, event->y, &row, &col);
1589 1596
1590 text = (char *)gtk_clist_get_row_data(GTK_CLIST(widget), row); 1597 text = (char *)gtk_clist_get_row_data(GTK_CLIST(widget), row);
1591 retval = contextfunc(work.window, text, work.data); 1598 retval = contextfunc(work.window, text, work.data);
1592 gtk_object_set_data(GTK_OBJECT(widget), "_dw_double_click", (gpointer)1); 1599 gtk_object_set_data(GTK_OBJECT(widget), "_dw_double_click", GINT_TO_POINTER(1));
1593 } 1600 }
1594 } 1601 }
1595 return retval; 1602 return retval;
1596 } 1603 }
1597 1604
1598 static gint _container_enter_event(GtkWidget *widget, GdkEventKey *event, gpointer data) 1605 static gint _container_enter_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
1599 { 1606 {
1600 SignalHandler work = _get_signal_handler(widget, data); 1607 SignalHandler work = _get_signal_handler(widget, data);
1601 int retval = FALSE; 1608 int retval = FALSE;
1602 1609
1603 if(work.window && event->keyval == VK_RETURN) 1610 if(work.window && event->keyval == VK_RETURN)
1604 { 1611 {
1605 int (*contextfunc)(HWND, char *, void *) = work.func; 1612 int (*contextfunc)(HWND, char *, void *) = work.func;
1606 char *text; 1613 char *text;
1607 1614
1608 text = (char *)gtk_clist_get_row_data(GTK_CLIST(widget), GTK_CLIST(widget)->focus_row); 1615 text = (char *)gtk_clist_get_row_data(GTK_CLIST(widget), GTK_CLIST(widget)->focus_row);
1609 retval = contextfunc(work.window, text, work.data); 1616 retval = contextfunc(work.window, text, work.data);
1610 } 1617 }
1611 return retval; 1618 return retval;
1612 } 1619 }
1613 1620
1614 /* Return the logical page id from the physical page id */ 1621 /* Return the logical page id from the physical page id */
1615 int _get_logical_page(HWND handle, unsigned long pageid) 1622 int _get_logical_page(HWND handle, unsigned long pageid)
1616 { 1623 {
1617 int z; 1624 int z;
1618 GtkWidget **pagearray = gtk_object_get_data(GTK_OBJECT(handle), "_dw_pagearray"); 1625 GtkWidget **pagearray = gtk_object_get_data(GTK_OBJECT(handle), "_dw_pagearray");
1619 GtkWidget *thispage = gtk_notebook_get_nth_page(GTK_NOTEBOOK(handle), pageid); 1626 GtkWidget *thispage = gtk_notebook_get_nth_page(GTK_NOTEBOOK(handle), pageid);
1620 1627
1621 if(pagearray && thispage) 1628 if(pagearray && thispage)
1622 { 1629 {
1623 for(z=0;z<256;z++) 1630 for(z=0;z<256;z++)
1624 { 1631 {
1625 if(thispage == pagearray[z]) 1632 if(thispage == pagearray[z])
1626 return z; 1633 return z;
1627 } 1634 }
1628 } 1635 }
1629 return 256; 1636 return 256;
1630 } 1637 }
1631 1638
1632 1639
1633 static gint _switch_page_event(GtkNotebook *notebook, GtkNotebookPage *page, guint page_num, gpointer data) 1640 static gint _switch_page_event(GtkNotebook *notebook, GtkNotebookPage *page, guint page_num, gpointer data)
1634 { 1641 {
1635 SignalHandler work = _get_signal_handler((GtkWidget *)notebook, data); 1642 SignalHandler work = _get_signal_handler((GtkWidget *)notebook, data);
1636 int retval = FALSE; 1643 int retval = FALSE;
1637 1644
1638 if(work.window) 1645 if(work.window)
1639 { 1646 {
1640 int (*switchpagefunc)(HWND, unsigned long, void *) = work.func; 1647 int (*switchpagefunc)(HWND, unsigned long, void *) = work.func;
1641 retval = switchpagefunc(work.window, _get_logical_page(GTK_WIDGET(notebook), page_num), work.data); 1648 retval = switchpagefunc(work.window, _get_logical_page(GTK_WIDGET(notebook), page_num), work.data);
1642 } 1649 }
1643 return retval; 1650 return retval;
1644 } 1651 }
1645 1652
1646 static gint _column_click_event(GtkWidget *widget, gint column_num, gpointer data) 1653 static gint _column_click_event(GtkWidget *widget, gint column_num, gpointer data)
1647 { 1654 {
1648 SignalHandler work = _get_signal_handler(widget, data); 1655 SignalHandler work = _get_signal_handler(widget, data);
1649 int retval = FALSE; 1656 int retval = FALSE;
1650 1657
1651 if(work.window) 1658 if(work.window)
1652 { 1659 {
1653 int (*clickcolumnfunc)(HWND, int, void *) = work.func; 1660 int (*clickcolumnfunc)(HWND, int, void *) = work.func;
1654 retval = clickcolumnfunc(work.window, column_num, work.data); 1661 retval = clickcolumnfunc(work.window, column_num, work.data);
1655 } 1662 }
1656 return retval; 1663 return retval;
1657 } 1664 }
1658 1665
1659 static gint _container_select_row(GtkWidget *widget, gint row, gint column, GdkEventButton *event, gpointer data) 1666 static gint _container_select_row(GtkWidget *widget, gint row, gint column, GdkEventButton *event, gpointer data)
1660 { 1667 {
1661 SignalHandler work = _get_signal_handler(widget, data); 1668 SignalHandler work = _get_signal_handler(widget, data);
1662 char *rowdata = gtk_clist_get_row_data(GTK_CLIST(widget), row); 1669 char *rowdata = gtk_clist_get_row_data(GTK_CLIST(widget), row);
1663 int (*contextfunc)(HWND, HWND, char *, void *, void *) = work.func; 1670 int (*contextfunc)(HWND, HWND, char *, void *, void *) = work.func;
1664 1671
1665 if(!work.window) 1672 if(!work.window)
1666 return TRUE; 1673 return TRUE;
1667 1674
1668 if(gtk_object_get_data(GTK_OBJECT(widget), "_dw_double_click")) 1675 if(gtk_object_get_data(GTK_OBJECT(widget), "_dw_double_click"))
1669 { 1676 {
1670 gtk_object_set_data(GTK_OBJECT(widget), "_dw_double_click", (gpointer)0); 1677 gtk_object_set_data(GTK_OBJECT(widget), "_dw_double_click", GINT_TO_POINTER(0));
1671 return TRUE; 1678 return TRUE;
1672 } 1679 }
1673 return contextfunc(work.window, 0, rowdata, work.data, 0);; 1680 return contextfunc(work.window, 0, rowdata, work.data, 0);;
1674 } 1681 }
1675 1682
1676 static int _round_value(gfloat val) 1683 static int _round_value(gfloat val)
1677 { 1684 {
1678 int newval = (int)val; 1685 int newval = (int)val;
1679 1686
1680 if(val >= 0.5 + (gfloat)newval) 1687 if(val >= 0.5 + (gfloat)newval)
1681 newval++; 1688 newval++;
1682 1689
1683 return newval; 1690 return newval;
1684 } 1691 }
1685 1692
1686 static gint _value_changed_event(GtkAdjustment *adjustment, gpointer data) 1693 static gint _value_changed_event(GtkAdjustment *adjustment, gpointer data)
1687 { 1694 {
1688 int max = _round_value(adjustment->upper); 1695 int max = _round_value(adjustment->upper);
1689 int val = _round_value(adjustment->value); 1696 int val = _round_value(adjustment->value);
1690 GtkWidget *slider = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(adjustment), "_dw_slider"); 1697 GtkWidget *slider = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(adjustment), "_dw_slider");
1691 GtkWidget *spinbutton = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(adjustment), "_dw_spinbutton"); 1698 GtkWidget *spinbutton = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(adjustment), "_dw_spinbutton");
1692 GtkWidget *scrollbar = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(adjustment), "_dw_scrollbar"); 1699 GtkWidget *scrollbar = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(adjustment), "_dw_scrollbar");
1693 1700
1694 if(slider) 1701 if(slider)
1695 { 1702 {
1696 SignalHandler work = _get_signal_handler((GtkWidget *)adjustment, data); 1703 SignalHandler work = _get_signal_handler((GtkWidget *)adjustment, data);
1697 1704
1698 if(work.window) 1705 if(work.window)
1699 { 1706 {
1700 int (*valuechangedfunc)(HWND, int, void *) = work.func; 1707 int (*valuechangedfunc)(HWND, int, void *) = work.func;
1701 1708
1702 if(GTK_IS_VSCALE(slider)) 1709 if(GTK_IS_VSCALE(slider))
1703 valuechangedfunc(work.window, (max - val) - 1, work.data); 1710 valuechangedfunc(work.window, (max - val) - 1, work.data);
1704 else 1711 else
1705 valuechangedfunc(work.window, val, work.data); 1712 valuechangedfunc(work.window, val, work.data);
1706 } 1713 }
1707 } 1714 }
1708 else if(scrollbar || spinbutton) 1715 else if(scrollbar || spinbutton)
1709 { 1716 {
1710 SignalHandler work = _get_signal_handler((GtkWidget *)adjustment, data); 1717 SignalHandler work = _get_signal_handler((GtkWidget *)adjustment, data);
1711 1718
1712 if(work.window) 1719 if(work.window)
1713 { 1720 {
1714 int (*valuechangedfunc)(HWND, int, void *) = work.func; 1721 int (*valuechangedfunc)(HWND, int, void *) = work.func;
1715 1722
1716 valuechangedfunc(work.window, val, work.data); 1723 valuechangedfunc(work.window, val, work.data);
1717 } 1724 }
1718 } 1725 }
1719 return FALSE; 1726 return FALSE;
1720 } 1727 }
1721 1728
1722 static gint _default_key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data) 1729 static gint _default_key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
1723 { 1730 {
1724 GtkWidget *next = (GtkWidget *)data; 1731 GtkWidget *next = (GtkWidget *)data;
1725 1732
1726 if(next) 1733 if(next)
1727 { 1734 {
1728 if(event->keyval == GDK_Return) 1735 if(event->keyval == GDK_Return)
1729 { 1736 {
1730 if(GTK_IS_BUTTON(next)) 1737 if(GTK_IS_BUTTON(next))
1731 gtk_signal_emit_by_name(GTK_OBJECT(next), "clicked"); 1738 gtk_signal_emit_by_name(GTK_OBJECT(next), "clicked");
1732 else 1739 else
1733 gtk_widget_grab_focus(next); 1740 gtk_widget_grab_focus(next);
1734 } 1741 }
1735 } 1742 }
1736 return FALSE; 1743 return FALSE;
1737 } 1744 }
1738 1745
1739 static GdkPixmap *_find_private_pixmap(GdkBitmap **bitmap, long id, unsigned long *userwidth, unsigned long *userheight) 1746 static GdkPixmap *_find_private_pixmap(GdkBitmap **bitmap, long id, unsigned long *userwidth, unsigned long *userheight)
1740 { 1747 {
1741 if(id < _PixmapCount && _PixmapArray[id].used) 1748 if(id < _PixmapCount && _PixmapArray[id].used)
1742 { 1749 {
1743 *bitmap = _PixmapArray[id].mask; 1750 *bitmap = _PixmapArray[id].mask;
1744 if(userwidth) 1751 if(userwidth)
1745 *userwidth = _PixmapArray[id].width; 1752 *userwidth = _PixmapArray[id].width;
1746 if(userheight) 1753 if(userheight)
1747 *userheight = _PixmapArray[id].height; 1754 *userheight = _PixmapArray[id].height;
1748 return _PixmapArray[id].pixmap; 1755 return _PixmapArray[id].pixmap;
1749 } 1756 }
1750 return NULL; 1757 return NULL;
1751 } 1758 }
1752 1759
1753 static GdkPixmap *_find_pixmap(GdkBitmap **bitmap, long id, HWND handle, unsigned long *userwidth, unsigned long *userheight) 1760 static GdkPixmap *_find_pixmap(GdkBitmap **bitmap, long id, HWND handle, unsigned long *userwidth, unsigned long *userheight)
1754 { 1761 {
1755 char *data = NULL; 1762 char *data = NULL;
1756 int z; 1763 int z;
1757 1764
1758 if(id & (1 << 31)) 1765 if(id & (1 << 31))
1759 return _find_private_pixmap(bitmap, (id & 0xFFFFFF), userwidth, userheight); 1766 return _find_private_pixmap(bitmap, (id & 0xFFFFFF), userwidth, userheight);
1760 1767
1761 for(z=0;z<_resources.resource_max;z++) 1768 for(z=0;z<_resources.resource_max;z++)
1762 { 1769 {
1763 if(_resources.resource_id[z] == id) 1770 if(_resources.resource_id[z] == id)
1764 { 1771 {
1765 data = _resources.resource_data[z]; 1772 data = _resources.resource_data[z];
1766 break; 1773 break;
1767 } 1774 }
1768 } 1775 }
1769 1776
1770 if(data) 1777 if(data)
1771 { 1778 {
1772 GdkPixmap *icon_pixmap = NULL; 1779 GdkPixmap *icon_pixmap = NULL;
1773 #if GTK_MAJOR_VERSION > 1 1780 #if GTK_MAJOR_VERSION > 1
1774 GdkPixbuf *icon_pixbuf = gdk_pixbuf_new_from_xpm_data((const char **)data); 1781 GdkPixbuf *icon_pixbuf = gdk_pixbuf_new_from_xpm_data((const char **)data);
1775 1782
1776 if(userwidth) 1783 if(userwidth)
1777 *userwidth = gdk_pixbuf_get_width(icon_pixbuf); 1784 *userwidth = gdk_pixbuf_get_width(icon_pixbuf);
1778 if(userheight) 1785 if(userheight)
1779 *userheight = gdk_pixbuf_get_height(icon_pixbuf); 1786 *userheight = gdk_pixbuf_get_height(icon_pixbuf);
1780 1787
1781 gdk_pixbuf_render_pixmap_and_mask(icon_pixbuf, &icon_pixmap, bitmap, 1); 1788 gdk_pixbuf_render_pixmap_and_mask(icon_pixbuf, &icon_pixmap, bitmap, 1);
1782 g_object_unref(icon_pixbuf); 1789 g_object_unref(icon_pixbuf);
1783 #elif defined(USE_IMLIB) 1790 #elif defined(USE_IMLIB)
1784 gdk_imlib_data_to_pixmap((char **)data, &icon_pixmap, bitmap); 1791 gdk_imlib_data_to_pixmap((char **)data, &icon_pixmap, bitmap);
1785 #else 1792 #else
1786 icon_pixmap = gdk_pixmap_create_from_xpm_d(handle->window, bitmap, &_colors[DW_CLR_PALEGRAY], (char **)data); 1793 icon_pixmap = gdk_pixmap_create_from_xpm_d(handle->window, bitmap, &_colors[DW_CLR_PALEGRAY], (char **)data);
1787 #endif 1794 #endif
1788 return icon_pixmap; 1795 return icon_pixmap;
1789 } 1796 }
1790 return NULL; 1797 return NULL;
1791 } 1798 }
1792 1799
1793 #if GTK_MAJOR_VERSION > 1 1800 #if GTK_MAJOR_VERSION > 1
1794 static GdkPixbuf *_find_private_pixbuf(long id) 1801 static GdkPixbuf *_find_private_pixbuf(long id)
1795 { 1802 {
1796 if(id < _PixmapCount && _PixmapArray[id].used) 1803 if(id < _PixmapCount && _PixmapArray[id].used)
1797 return _PixmapArray[id].pixbuf; 1804 return _PixmapArray[id].pixbuf;
1798 return NULL; 1805 return NULL;
1799 } 1806 }
1800 1807
1801 static GdkPixbuf *_find_pixbuf(long id) 1808 static GdkPixbuf *_find_pixbuf(long id)
1802 { 1809 {
1803 char *data = NULL; 1810 char *data = NULL;
1804 int z; 1811 int z;
1805 1812
1806 if(id & (1 << 31)) 1813 if(id & (1 << 31))
1807 return _find_private_pixbuf((id & 0xFFFFFF)); 1814 return _find_private_pixbuf((id & 0xFFFFFF));
1808 1815
1809 for(z=0;z<_resources.resource_max;z++) 1816 for(z=0;z<_resources.resource_max;z++)
1810 { 1817 {
1811 if(_resources.resource_id[z] == id) 1818 if(_resources.resource_id[z] == id)
1812 { 1819 {
1813 data = _resources.resource_data[z]; 1820 data = _resources.resource_data[z];
1814 break; 1821 break;
1815 } 1822 }
1816 } 1823 }
1817 1824
1818 if(data) 1825 if(data)
1819 return gdk_pixbuf_new_from_xpm_data((const char **)data); 1826 return gdk_pixbuf_new_from_xpm_data((const char **)data);
1820 return NULL; 1827 return NULL;
1821 } 1828 }
1822 #endif 1829 #endif
1823 1830
1824 static void _size_allocate(GtkWindow *window) 1831 static void _size_allocate(GtkWindow *window)
1825 { 1832 {
1833 sizehints.min_height = 8; 1840 sizehints.min_height = 8;
1834 1841
1835 sizehints.flags = (PBaseSize|PMinSize|PResizeInc); 1842 sizehints.flags = (PBaseSize|PMinSize|PResizeInc);
1836 1843
1837 XSetWMNormalHints (GDK_DISPLAY(), 1844 XSetWMNormalHints (GDK_DISPLAY(),
1838 GDK_WINDOW_XWINDOW (GTK_WIDGET (window)->window), 1845 GDK_WINDOW_XWINDOW (GTK_WIDGET (window)->window),
1839 &sizehints); 1846 &sizehints);
1840 gdk_flush (); 1847 gdk_flush ();
1841 } 1848 }
1842 1849
1843 /* Find the index of a given thread */ 1850 /* Find the index of a given thread */
1844 static int _find_thread_index(DWTID tid) 1851 static int _find_thread_index(DWTID tid)
1845 { 1852 {
1846 int z; 1853 int z;
1847 1854
1848 for(z=0;z<DW_THREAD_LIMIT;z++) 1855 for(z=0;z<DW_THREAD_LIMIT;z++)
1849 { 1856 {
1850 if(_dw_thread_list[z] == tid) 1857 if(_dw_thread_list[z] == tid)
1851 return z; 1858 return z;
1852 } 1859 }
1853 return 0; 1860 return 0;
1854 } 1861 }
1855 1862
1856 /* Add a thread id to the thread list */ 1863 /* Add a thread id to the thread list */
1857 static void _dw_thread_add(DWTID tid) 1864 static void _dw_thread_add(DWTID tid)
1858 { 1865 {
1859 int z; 1866 int z;
1860 1867
1861 for(z=0;z<DW_THREAD_LIMIT;z++) 1868 for(z=0;z<DW_THREAD_LIMIT;z++)
1862 { 1869 {
1863 if(_dw_thread_list[z] == tid) 1870 if(_dw_thread_list[z] == tid)
1864 return; 1871 return;
1865 1872
1866 if(_dw_thread_list[z] == (DWTID)-1) 1873 if(_dw_thread_list[z] == (DWTID)-1)
1867 { 1874 {
1868 _dw_thread_list[z] = tid; 1875 _dw_thread_list[z] = tid;
1869 _foreground[z].pixel = _foreground[z].red =_foreground[z].green = _foreground[z].blue = 0; 1876 _foreground[z].pixel = _foreground[z].red =_foreground[z].green = _foreground[z].blue = 0;
1870 _background[z].pixel = 1; 1877 _background[z].pixel = 1;
1871 _background[z].red = _background[z].green = _background[z].blue = 0; 1878 _background[z].red = _background[z].green = _background[z].blue = 0;
1872 _transparent[z] = 1; 1879 _transparent[z] = 1;
1873 _clipboard_contents[z] = NULL; 1880 _clipboard_contents[z] = NULL;
1874 _clipboard_object[z] = NULL; 1881 _clipboard_object[z] = NULL;
1875 return; 1882 return;
1876 } 1883 }
1877 } 1884 }
1878 } 1885 }
1879 1886
1880 /* Remove a thread id to the thread list */ 1887 /* Remove a thread id to the thread list */
1881 static void _dw_thread_remove(DWTID tid) 1888 static void _dw_thread_remove(DWTID tid)
1882 { 1889 {
1883 int z; 1890 int z;
1884 1891
1885 for(z=0;z<DW_THREAD_LIMIT;z++) 1892 for(z=0;z<DW_THREAD_LIMIT;z++)
1886 { 1893 {
1887 if(_dw_thread_list[z] == (DWTID)tid) 1894 if(_dw_thread_list[z] == (DWTID)tid)
1888 { 1895 {
1889 _dw_thread_list[z] = (DWTID)-1; 1896 _dw_thread_list[z] = (DWTID)-1;
1890 if ( _clipboard_contents[z] != NULL ) 1897 if ( _clipboard_contents[z] != NULL )
1891 { 1898 {
1892 g_free( _clipboard_contents[z] ); 1899 g_free( _clipboard_contents[z] );
1893 _clipboard_contents[z] = NULL;; 1900 _clipboard_contents[z] = NULL;;
1894 } 1901 }
1895 _clipboard_object[z] = NULL;; 1902 _clipboard_object[z] = NULL;;
1896 } 1903 }
1897 } 1904 }
1898 } 1905 }
1899 1906
1900 /* Try to load the mozilla embed shared libary */ 1907 /* Try to load the mozilla embed shared libary */
1901 #ifdef USE_GTKMOZEMBED 1908 #ifdef USE_GTKMOZEMBED
1902 #include <ctype.h> 1909 #include <ctype.h>
1903 1910
1904 static char _dw_mozdir[1024];
1905
1906 void init_mozembed(void) 1911 void init_mozembed(void)
1907 { 1912 {
1908 void *handle = NULL; 1913 void *handle = NULL;
1909 FILE *fp = popen("pkg-config --libs-only-L mozilla-gtkmozembed", "r"); 1914 gchar *profile;
1910 1915 handle = dlopen( "libgtkembedmoz.so", RTLD_LAZY );
1911 /* First we try to get the correct location 1916
1912 * from pkg-config. 1917 /* If we loaded it, grab the symbols we want */
1913 */ 1918 if ( handle )
1914 if(fp) 1919 {
1915 { 1920 _gtk_moz_embed_go_back = dlsym(handle, "gtk_moz_embed_go_back");
1916 fgets(_dw_mozdir, 1024, fp); 1921 _gtk_moz_embed_go_forward = dlsym(handle, "gtk_moz_embed_go_forward");
1917 1922 _gtk_moz_embed_load_url = dlsym(handle, "gtk_moz_embed_load_url");
1918 if(_dw_mozdir[0] == '-' && _dw_mozdir[1] == 'L') 1923 _gtk_moz_embed_reload = dlsym(handle, "gtk_moz_embed_reload");
1919 { 1924 _gtk_moz_embed_stop_load = dlsym(handle, "gtk_moz_embed_stop_load");
1920 int x, len = strlen(_dw_mozdir); 1925 _gtk_moz_embed_render_data = dlsym(handle, "gtk_moz_embed_render_data");
1921 1926 _dw_moz_embed_get_type = dlsym(handle, "gtk_moz_embed_get_type");
1922 for(x=len;x>0;x--) 1927 _gtk_moz_embed_new = dlsym(handle, "gtk_moz_embed_new");
1923 { 1928 _gtk_moz_embed_can_go_back = dlsym(handle, "gtk_moz_embed_can_go_back");
1924 if(!isalpha(_dw_mozdir[x]) && !isdigit(_dw_mozdir[x]) && _dw_mozdir[x] != '/') 1929 _gtk_moz_embed_can_go_forward = dlsym(handle, "gtk_moz_embed_can_go_forward");
1925 _dw_mozdir[x] = 0; 1930 gtk_moz_embed_set_comp_path( "/usr/lib/mozilla");
1926 } 1931 gtk_moz_embed_set_comp_path( "/usr/lib/firefox");
1927 strncat(_dw_mozdir, "/libgtkembedmoz.so", 1024); 1932 profile = g_build_filename(g_get_home_dir(), ".dwindows/mozilla", NULL);
1928 handle = dlopen(&_dw_mozdir[2], RTLD_NOW); 1933
1929 } 1934 /* initialize profile */
1930 fclose(fp); 1935 gtk_moz_embed_set_profile_path(profile, "dwindows");
1931 } 1936 g_free(profile);
1932 /* Try the default path */ 1937
1933 if(!handle) 1938 /* startup done */
1934 { 1939 gtk_moz_embed_push_startup();
1935 strncpy(_dw_mozdir, "libgtkembedmoz.so", 1024); 1940 }
1936 handle = dlopen(_dw_mozdir, RTLD_NOW);
1937 }
1938 /* Finally try some common locations */
1939 if(!handle)
1940 {
1941 strncpy(_dw_mozdir, "/usr/X11R6/lib/mozilla/libgtkembedmoz.so", 1024);
1942 handle = dlopen(_dw_mozdir, RTLD_NOW);
1943 }
1944 if(!handle)
1945 {
1946 strncpy(_dw_mozdir, "/usr/lib/mozilla/libgtkembedmoz.so", 1024);
1947 handle = dlopen(_dw_mozdir, RTLD_NOW);
1948 }
1949 if(!handle)
1950 {
1951 strncpy(_dw_mozdir, "/usr/local/lib/mozilla/libgtkembedmoz.so", 1024);
1952 handle = dlopen(_dw_mozdir, RTLD_NOW);
1953 }
1954
1955 /* If we loaded it, grab the symbols we want */
1956 if(handle)
1957 {
1958 _gtk_moz_embed_go_back = dlsym(handle, "gtk_moz_embed_go_back");
1959 _gtk_moz_embed_go_forward = dlsym(handle, "gtk_moz_embed_go_forward");
1960 _gtk_moz_embed_load_url = dlsym(handle, "gtk_moz_embed_load_url");
1961 _gtk_moz_embed_reload = dlsym(handle, "gtk_moz_embed_reload");
1962 _gtk_moz_embed_stop_load = dlsym(handle, "gtk_moz_embed_stop_load");
1963 _gtk_moz_embed_render_data = dlsym(handle, "gtk_moz_embed_render_data");
1964 _dw_moz_embed_get_type = dlsym(handle, "gtk_moz_embed_get_type");
1965 _gtk_moz_embed_new = dlsym(handle, "gtk_moz_embed_new");
1966 }
1967 else
1968 _dw_mozdir[0] = 0;
1969 } 1941 }
1970 #endif 1942 #endif
1971 1943
1972 /* 1944 /*
1973 * Initializes the Dynamic Windows engine. 1945 * Initializes the Dynamic Windows engine.
1975 * newthread: True if this is the only thread. 1947 * newthread: True if this is the only thread.
1976 * False if there is already a message loop running. 1948 * False if there is already a message loop running.
1977 */ 1949 */
1978 int dw_int_init(DWResources *res, int newthread, int *argc, char **argv[]) 1950 int dw_int_init(DWResources *res, int newthread, int *argc, char **argv[])
1979 { 1951 {
1980 int z; 1952 int z;
1981 char *tmp; 1953 char *tmp;
1982 1954
1983 if(res) 1955 if(res)
1984 { 1956 {
1985 _resources.resource_max = res->resource_max; 1957 _resources.resource_max = res->resource_max;
1986 _resources.resource_id = res->resource_id; 1958 _resources.resource_id = res->resource_id;
1987 _resources.resource_data = res->resource_data; 1959 _resources.resource_data = res->resource_data;
1988 } 1960 }
1989 gtk_set_locale(); 1961 gtk_set_locale();
1990 g_thread_init(NULL); 1962 g_thread_init(NULL);
1991 #if GTK_MAJOR_VERSION > 1 1963 #if GTK_MAJOR_VERSION > 1
1992 gdk_threads_init(); 1964 gdk_threads_init();
1993 #endif 1965 #endif
1994 1966
1995 gtk_init(argc, argv); 1967 gtk_init(argc, argv);
1996 #ifdef USE_IMLIB 1968 #ifdef USE_IMLIB
1997 gdk_imlib_init(); 1969 gdk_imlib_init();
1998 #endif 1970 #endif
1999 /* Add colors to the system colormap */ 1971 /* Add colors to the system colormap */
2000 _dw_cmap = gdk_colormap_get_system(); 1972 _dw_cmap = gdk_colormap_get_system();
2001 for(z=0;z<16;z++) 1973 for(z=0;z<16;z++)
2002 gdk_color_alloc(_dw_cmap, &_colors[z]); 1974 gdk_color_alloc(_dw_cmap, &_colors[z]);
2003 1975
2004 tmp = getenv("DW_BORDER_WIDTH"); 1976 tmp = getenv("DW_BORDER_WIDTH");
2005 if(tmp) 1977 if(tmp)
2006 _dw_border_width = atoi(tmp); 1978 _dw_border_width = atoi(tmp);
2007 tmp = getenv("DW_BORDER_HEIGHT"); 1979 tmp = getenv("DW_BORDER_HEIGHT");
2008 if(tmp) 1980 if(tmp)
2009 _dw_border_height = atoi(tmp); 1981 _dw_border_height = atoi(tmp);
2010 1982
2011 for(z=0;z<DW_THREAD_LIMIT;z++) 1983 for(z=0;z<DW_THREAD_LIMIT;z++)
2012 _dw_thread_list[z] = (DWTID)-1; 1984 _dw_thread_list[z] = (DWTID)-1;
2013 1985
2014 gtk_rc_parse_string("style \"gtk-tooltips-style\" { bg[NORMAL] = \"#eeee00\" } widget \"gtk-tooltips\" style \"gtk-tooltips-style\""); 1986 gtk_rc_parse_string("style \"gtk-tooltips-style\" { bg[NORMAL] = \"#eeee00\" } widget \"gtk-tooltips\" style \"gtk-tooltips-style\"");
2015 1987
2016 #ifdef USE_GTKMOZEMBED 1988 #ifdef USE_GTKMOZEMBED
2017 init_mozembed(); 1989 init_mozembed();
2018 #endif 1990 #endif
2019 1991
2020 return TRUE; 1992 return TRUE;
2021 } 1993 }
2022 1994
2023 /* 1995 /*
2024 * Runs a message loop for Dynamic Windows. 1996 * Runs a message loop for Dynamic Windows.
2025 */ 1997 */
2026 void dw_main(void) 1998 void dw_main(void)
2027 { 1999 {
2028 gdk_threads_enter(); 2000 gdk_threads_enter();
2029 _dw_thread = pthread_self(); 2001 _dw_thread = pthread_self();
2030 _dw_thread_add(_dw_thread); 2002 _dw_thread_add(_dw_thread);
2031 gtk_main(); 2003 gtk_main();
2032 _dw_thread = (pthread_t)-1; 2004 _dw_thread = (pthread_t)-1;
2033 gdk_threads_leave(); 2005 gdk_threads_leave();
2034 } 2006 }
2035 2007
2036 /* 2008 /*
2037 * Runs a message loop for Dynamic Windows, for a period of milliseconds. 2009 * Runs a message loop for Dynamic Windows, for a period of milliseconds.
2038 * Parameters: 2010 * Parameters:
2039 * milliseconds: Number of milliseconds to run the loop for. 2011 * milliseconds: Number of milliseconds to run the loop for.
2040 */ 2012 */
2041 void dw_main_sleep(int milliseconds) 2013 void dw_main_sleep(int milliseconds)
2042 { 2014 {
2043 struct timeval tv, start; 2015 struct timeval tv, start;
2044 pthread_t curr = pthread_self(); 2016 pthread_t curr = pthread_self();
2045 2017
2046 gettimeofday(&start, NULL); 2018 gettimeofday(&start, NULL);
2047 2019
2048 if(_dw_thread == (pthread_t)-1 || _dw_thread == curr) 2020 if(_dw_thread == (pthread_t)-1 || _dw_thread == curr)
2049 { 2021 {
2050 pthread_t orig = _dw_thread; 2022 pthread_t orig = _dw_thread;
2051 2023
2052 gettimeofday(&tv, NULL); 2024 gettimeofday(&tv, NULL);
2053 2025
2054 while(((tv.tv_sec - start.tv_sec)*1000) + ((tv.tv_usec - start.tv_usec)/1000) <= milliseconds) 2026 while(((tv.tv_sec - start.tv_sec)*1000) + ((tv.tv_usec - start.tv_usec)/1000) <= milliseconds)
2055 { 2027 {
2056 if(orig == (pthread_t)-1) 2028 if(orig == (pthread_t)-1)
2057 { 2029 {
2058 gdk_threads_enter(); 2030 gdk_threads_enter();
2059 _dw_thread = curr; 2031 _dw_thread = curr;
2060 } 2032 }
2061 if(gtk_events_pending()) 2033 if(gtk_events_pending())
2062 gtk_main_iteration(); 2034 gtk_main_iteration();
2063 else 2035 else
2064 _dw_msleep(1); 2036 _dw_msleep(1);
2065 if(orig == (pthread_t)-1) 2037 if(orig == (pthread_t)-1)
2066 { 2038 {
2067 _dw_thread = orig; 2039 _dw_thread = orig;
2068 gdk_threads_leave(); 2040 gdk_threads_leave();
2069 } 2041 }
2070 gettimeofday(&tv, NULL); 2042 gettimeofday(&tv, NULL);
2071 } 2043 }
2072 } 2044 }
2073 else 2045 else
2074 _dw_msleep(milliseconds); 2046 _dw_msleep(milliseconds);
2075 } 2047 }
2076 2048
2077 /* 2049 /*
2078 * Processes a single message iteration and returns. 2050 * Processes a single message iteration and returns.
2079 */ 2051 */
2080 void dw_main_iteration(void) 2052 void dw_main_iteration(void)
2081 { 2053 {
2082 gdk_threads_enter(); 2054 gdk_threads_enter();
2083 _dw_thread = pthread_self(); 2055 _dw_thread = pthread_self();
2084 _dw_thread_add(_dw_thread); 2056 _dw_thread_add(_dw_thread);
2085 gtk_main_iteration(); 2057 gtk_main_iteration();
2086 _dw_thread = (pthread_t)-1; 2058 _dw_thread = (pthread_t)-1;
2087 gdk_threads_leave(); 2059 gdk_threads_leave();
2088 } 2060 }
2089 2061
2090 /* 2062 /*
2091 * Free's memory allocated by dynamic windows. 2063 * Free's memory allocated by dynamic windows.
2092 * Parameters: 2064 * Parameters:
2093 * ptr: Pointer to dynamic windows allocated 2065 * ptr: Pointer to dynamic windows allocated
2094 * memory to be free()'d. 2066 * memory to be free()'d.
2095 */ 2067 */
2096 void dw_free(void *ptr) 2068 void dw_free(void *ptr)
2097 { 2069 {
2098 free(ptr); 2070 free(ptr);
2099 } 2071 }
2100 2072
2101 /* 2073 /*
2102 * Allocates and initializes a dialog struct. 2074 * Allocates and initializes a dialog struct.
2103 * Parameters: 2075 * Parameters:
2104 * data: User defined data to be passed to functions. 2076 * data: User defined data to be passed to functions.
2105 */ 2077 */
2106 DWDialog *dw_dialog_new(void *data) 2078 DWDialog *dw_dialog_new(void *data)
2107 { 2079 {
2108 DWDialog *tmp = malloc(sizeof(DWDialog)); 2080 DWDialog *tmp = malloc(sizeof(DWDialog));
2109 2081
2110 tmp->eve = dw_event_new(); 2082 tmp->eve = dw_event_new();
2111 dw_event_reset(tmp->eve); 2083 dw_event_reset(tmp->eve);
2112 tmp->data = data; 2084 tmp->data = data;
2113 tmp->done = FALSE; 2085 tmp->done = FALSE;
2114 tmp->method = FALSE; 2086 tmp->method = FALSE;
2115 tmp->result = NULL; 2087 tmp->result = NULL;
2116 2088
2117 return tmp; 2089 return tmp;
2118 } 2090 }
2119 2091
2120 /* 2092 /*
2124 * dialog: Pointer to a dialog struct aquired by dw_dialog_new). 2096 * dialog: Pointer to a dialog struct aquired by dw_dialog_new).
2125 * result: Data to be returned by dw_dialog_wait(). 2097 * result: Data to be returned by dw_dialog_wait().
2126 */ 2098 */
2127 int dw_dialog_dismiss(DWDialog *dialog, void *result) 2099 int dw_dialog_dismiss(DWDialog *dialog, void *result)
2128 { 2100 {
2129 dialog->result = result; 2101 dialog->result = result;
2130 if(dialog->method) 2102 if(dialog->method)
2131 gtk_main_quit(); 2103 gtk_main_quit();
2132 else 2104 else
2133 dw_event_post(dialog->eve); 2105 dw_event_post(dialog->eve);
2134 dialog->done = TRUE; 2106 dialog->done = TRUE;
2135 return 0; 2107 return 0;
2136 } 2108 }
2137 2109
2138 /* 2110 /*
2139 * Accepts a dialog struct waits for dw_dialog_dismiss() to be 2111 * Accepts a dialog struct waits for dw_dialog_dismiss() to be
2140 * called by a signal handler with the given dialog struct. 2112 * called by a signal handler with the given dialog struct.
2141 * Parameters: 2113 * Parameters:
2142 * dialog: Pointer to a dialog struct aquired by dw_dialog_new). 2114 * dialog: Pointer to a dialog struct aquired by dw_dialog_new).
2143 */ 2115 */
2144 void *dw_dialog_wait(DWDialog *dialog) 2116 void *dw_dialog_wait(DWDialog *dialog)
2145 { 2117 {
2146 void *tmp; 2118 void *tmp;
2147 int newprocess = 0; 2119 int newprocess = 0;
2148 2120
2149 /* _dw_thread will be -1 if dw_main hasn't been run yet. */ 2121 /* _dw_thread will be -1 if dw_main hasn't been run yet. */
2150 if(_dw_thread == (pthread_t)-1) 2122 if(_dw_thread == (pthread_t)-1)
2151 { 2123 {
2152 _dw_thread = pthread_self(); 2124 _dw_thread = pthread_self();
2153 newprocess = 1; 2125 newprocess = 1;
2154 gdk_threads_enter(); 2126 gdk_threads_enter();
2155 } 2127 }
2156 2128
2157 if(pthread_self() == _dw_thread) 2129 if(pthread_self() == _dw_thread)
2158 { 2130 {
2159 dialog->method = TRUE; 2131 dialog->method = TRUE;
2160 gtk_main(); 2132 gtk_main();
2161 } 2133 }
2162 else 2134 else
2163 { 2135 {
2164 dialog->method = FALSE; 2136 dialog->method = FALSE;
2165 dw_event_wait(dialog->eve, -1); 2137 dw_event_wait(dialog->eve, -1);
2166 } 2138 }
2167 2139
2168 if(newprocess) 2140 if(newprocess)
2169 { 2141 {
2170 _dw_thread = (pthread_t)-1; 2142 _dw_thread = (pthread_t)-1;
2171 gdk_threads_leave(); 2143 gdk_threads_leave();
2172 } 2144 }
2173 2145
2174 dw_event_close(&dialog->eve); 2146 dw_event_close(&dialog->eve);
2175 tmp = dialog->result; 2147 tmp = dialog->result;
2176 free(dialog); 2148 free(dialog);
2177 return tmp; 2149 return tmp;
2178 } 2150 }
2179 2151
2180 static int _dw_ok_func(HWND window, void *data) 2152 static int _dw_ok_func(HWND window, void *data)
2181 { 2153 {
2182 DWDialog *dwwait = (DWDialog *)data; 2154 DWDialog *dwwait = (DWDialog *)data;
2183 2155
2184 if(!dwwait) 2156 if(!dwwait)
2185 return FALSE; 2157 return FALSE;
2186 2158
2187 dw_window_destroy((HWND)dwwait->data); 2159 dw_window_destroy((HWND)dwwait->data);
2188 dw_dialog_dismiss((DWDialog *)data, (void *)DW_MB_RETURN_OK); 2160 dw_dialog_dismiss((DWDialog *)data, (void *)DW_MB_RETURN_OK);
2189 return FALSE; 2161 return FALSE;
2190 } 2162 }
2191 2163
2192 int _dw_yes_func(HWND window, void *data) 2164 int _dw_yes_func(HWND window, void *data)
2193 { 2165 {
2194 DWDialog *dwwait = (DWDialog *)data; 2166 DWDialog *dwwait = (DWDialog *)data;
2195 2167
2196 if(!dwwait) 2168 if(!dwwait)
2197 return FALSE; 2169 return FALSE;
2198 2170
2199 dw_window_destroy((HWND)dwwait->data); 2171 dw_window_destroy((HWND)dwwait->data);
2200 dw_dialog_dismiss((DWDialog *)data, (void *)DW_MB_RETURN_YES); 2172 dw_dialog_dismiss((DWDialog *)data, (void *)DW_MB_RETURN_YES);
2201 return FALSE; 2173 return FALSE;
2202 } 2174 }
2203 2175
2204 int _dw_no_func(HWND window, void *data) 2176 int _dw_no_func(HWND window, void *data)
2205 { 2177 {
2206 DWDialog *dwwait = (DWDialog *)data; 2178 DWDialog *dwwait = (DWDialog *)data;
2207 2179
2208 if(!dwwait) 2180 if(!dwwait)
2209 return FALSE; 2181 return FALSE;
2210 2182
2211 dw_window_destroy((HWND)dwwait->data); 2183 dw_window_destroy((HWND)dwwait->data);
2212 dw_dialog_dismiss((DWDialog *)data, (void *)DW_MB_RETURN_NO); 2184 dw_dialog_dismiss((DWDialog *)data, (void *)DW_MB_RETURN_NO);
2213 return FALSE; 2185 return FALSE;
2214 } 2186 }
2215 2187
2216 int _dw_cancel_func(HWND window, void *data) 2188 int _dw_cancel_func(HWND window, void *data)
2217 { 2189 {
2218 DWDialog *dwwait = (DWDialog *)data; 2190 DWDialog *dwwait = (DWDialog *)data;
2219 2191
2220 if(!dwwait) 2192 if(!dwwait)
2221 return FALSE; 2193 return FALSE;
2222 2194
2223 dw_window_destroy((HWND)dwwait->data); 2195 dw_window_destroy((HWND)dwwait->data);
2224 dw_dialog_dismiss((DWDialog *)data, (void *)DW_MB_RETURN_CANCEL); 2196 dw_dialog_dismiss((DWDialog *)data, (void *)DW_MB_RETURN_CANCEL);
2225 return FALSE; 2197 return FALSE;
2226 } 2198 }
2227 2199
2228 /* 2200 /*
2229 * Displays a Message Box with given text and title.. 2201 * Displays a Message Box with given text and title..
2230 * Parameters: 2202 * Parameters:
2233 * format: printf style format string. 2205 * format: printf style format string.
2234 * ...: Additional variables for use in the format. 2206 * ...: Additional variables for use in the format.
2235 */ 2207 */
2236 int dw_messagebox(char *title, int flags, char *format, ...) 2208 int dw_messagebox(char *title, int flags, char *format, ...)
2237 { 2209 {
2238 HWND entrywindow, texttargetbox, imagetextbox, mainbox, okbutton, nobutton, yesbutton, cancelbutton, buttonbox, stext; 2210 HWND entrywindow, texttargetbox, imagetextbox, mainbox, okbutton, nobutton, yesbutton, cancelbutton, buttonbox, stext;
2239 ULONG flStyle = DW_FCF_TITLEBAR | DW_FCF_SHELLPOSITION | DW_FCF_DLGBORDER; 2211 ULONG flStyle = DW_FCF_TITLEBAR | DW_FCF_SHELLPOSITION | DW_FCF_DLGBORDER;
2240 DWDialog *dwwait; 2212 DWDialog *dwwait;
2241 va_list args; 2213 va_list args;
2242 char outbuf[1000]; 2214 char outbuf[1000];
2243 char **xpm_data = NULL; 2215 char **xpm_data = NULL;
2244 int x, y, extra_width=0,text_width,text_height; 2216 int x, y, extra_width=0,text_width,text_height;
2245 int width,height; 2217 int width,height;
2246 2218
2247 va_start(args, format); 2219 va_start(args, format);
2248 vsprintf(outbuf, format, args); 2220 vsprintf(outbuf, format, args);
2249 va_end(args); 2221 va_end(args);
2250 2222
2251 entrywindow = dw_window_new(HWND_DESKTOP, title, flStyle); 2223 entrywindow = dw_window_new(HWND_DESKTOP, title, flStyle);
2252 mainbox = dw_box_new(DW_VERT, 10); 2224 mainbox = dw_box_new(DW_VERT, 10);
2253 dw_box_pack_start(entrywindow, mainbox, 0, 0, TRUE, TRUE, 0); 2225 dw_box_pack_start(entrywindow, mainbox, 0, 0, TRUE, TRUE, 0);
2254 2226
2255 /* determine if an icon is to be used - if so we need another HORZ box */ 2227 /* determine if an icon is to be used - if so we need another HORZ box */
2256 if((flags & DW_MB_ERROR) | (flags & DW_MB_WARNING) | (flags & DW_MB_INFORMATION) | (flags & DW_MB_QUESTION)) 2228 if((flags & DW_MB_ERROR) | (flags & DW_MB_WARNING) | (flags & DW_MB_INFORMATION) | (flags & DW_MB_QUESTION))
2257 { 2229 {
2258 imagetextbox = dw_box_new(DW_HORZ, 0); 2230 imagetextbox = dw_box_new(DW_HORZ, 0);
2259 dw_box_pack_start(mainbox, imagetextbox, 0, 0, TRUE, TRUE, 2); 2231 dw_box_pack_start(mainbox, imagetextbox, 0, 0, TRUE, TRUE, 2);
2260 texttargetbox = imagetextbox; 2232 texttargetbox = imagetextbox;
2261 } 2233 }
2262 else 2234 else
2263 { 2235 {
2264 imagetextbox = NULL; 2236 imagetextbox = NULL;
2265 texttargetbox = mainbox; 2237 texttargetbox = mainbox;
2266 } 2238 }
2267 2239
2268 if(flags & DW_MB_ERROR) 2240 if(flags & DW_MB_ERROR)
2269 xpm_data = (char **)_dw_messagebox_error; 2241 xpm_data = (char **)_dw_messagebox_error;
2270 else if(flags & DW_MB_WARNING) 2242 else if(flags & DW_MB_WARNING)
2271 xpm_data = (char **)_dw_messagebox_warning; 2243 xpm_data = (char **)_dw_messagebox_warning;
2272 else if(flags & DW_MB_INFORMATION) 2244 else if(flags & DW_MB_INFORMATION)
2273 xpm_data = (char **)_dw_messagebox_information; 2245 xpm_data = (char **)_dw_messagebox_information;
2274 else if(flags & DW_MB_QUESTION) 2246 else if(flags & DW_MB_QUESTION)
2275 xpm_data = (char **)_dw_messagebox_question; 2247 xpm_data = (char **)_dw_messagebox_question;
2276 2248
2277 if(xpm_data) 2249 if(xpm_data)
2278 extra_width = 32; 2250 extra_width = 32;
2279 2251
2280 if(texttargetbox == imagetextbox) 2252 if(texttargetbox == imagetextbox)
2281 { 2253 {
2282 GdkPixmap *icon_pixmap = NULL; 2254 GdkPixmap *icon_pixmap = NULL;
2283 GdkBitmap *bitmap = NULL; 2255 GdkBitmap *bitmap = NULL;
2284 HWND handle = dw_bitmap_new( 100 ); 2256 HWND handle = dw_bitmap_new( 100 );
2285 #if GTK_MAJOR_VERSION > 1 2257 #if GTK_MAJOR_VERSION > 1
2286 GdkPixbuf *icon_pixbuf = gdk_pixbuf_new_from_xpm_data((const char **)xpm_data); 2258 GdkPixbuf *icon_pixbuf = gdk_pixbuf_new_from_xpm_data((const char **)xpm_data);
2287 2259
2288 gdk_pixbuf_render_pixmap_and_mask(icon_pixbuf, &icon_pixmap, &bitmap, 1); 2260 gdk_pixbuf_render_pixmap_and_mask(icon_pixbuf, &icon_pixmap, &bitmap, 1);
2289 g_object_unref(icon_pixbuf); 2261 g_object_unref(icon_pixbuf);
2290 #elif defined(USE_IMLIB) 2262 #elif defined(USE_IMLIB)
2291 gdk_imlib_data_to_pixmap((char **)xpm_data, &icon_pixmap, &bitmap); 2263 gdk_imlib_data_to_pixmap((char **)xpm_data, &icon_pixmap, &bitmap);
2292 #else 2264 #else
2293 icon_pixmap = gdk_pixmap_create_from_xpm_d(handle->window, &bitmap, &_colors[DW_CLR_PALEGRAY], (char **)xpm_data); 2265 icon_pixmap = gdk_pixmap_create_from_xpm_d(handle->window, &bitmap, &_colors[DW_CLR_PALEGRAY], (char **)xpm_data);
2294 #endif 2266 #endif
2295 2267
2296 #if GTK_MAJOR_VERSION > 1 2268 #if GTK_MAJOR_VERSION > 1
2297 gtk_image_set_from_pixmap(GTK_IMAGE(handle), icon_pixmap, bitmap); 2269 gtk_image_set_from_pixmap(GTK_IMAGE(handle), icon_pixmap, bitmap);
2298 #else 2270 #else
2299 gtk_pixmap_set(GTK_PIXMAP(handle), icon_pixmap, bitmap); 2271 gtk_pixmap_set(GTK_PIXMAP(handle), icon_pixmap, bitmap);
2300 #endif 2272 #endif
2301 2273
2302 dw_box_pack_start( texttargetbox, handle, 32, 32, FALSE, FALSE, 2); 2274 dw_box_pack_start( texttargetbox, handle, 32, 32, FALSE, FALSE, 2);
2303 } 2275 }
2304 2276
2305 /* Create text */ 2277 /* Create text */
2306 text_width = 240; 2278 text_width = 240;
2307 text_height = 0; 2279 text_height = 0;
2308 stext = dw_text_new(outbuf, 0); 2280 stext = dw_text_new(outbuf, 0);
2309 dw_window_set_style(stext, DW_DT_WORDBREAK, DW_DT_WORDBREAK); 2281 dw_window_set_style(stext, DW_DT_WORDBREAK, DW_DT_WORDBREAK);
2310 dw_font_text_extents_get(stext, NULL, outbuf, &width, &height); 2282 dw_font_text_extents_get(stext, NULL, outbuf, &width, &height);
2311 height = height+3; 2283 height = height+3;
2312 if(width < text_width) 2284 if(width < text_width)
2313 text_height = height*2; 2285 text_height = height*2;
2314 else if(width < text_width*2) 2286 else if(width < text_width*2)
2315 text_height = height*3; 2287 text_height = height*3;
2316 else if(width < text_width*3) 2288 else if(width < text_width*3)
2317 text_height = height*4; 2289 text_height = height*4;
2318 else /* width > (3*text_width) */ 2290 else /* width > (3*text_width) */
2319 { 2291 {
2320 text_width = (width / 3) + 60; 2292 text_width = (width / 3) + 60;
2321 text_height = height*4; 2293 text_height = height*4;
2322 } 2294 }
2323 dw_box_pack_start(texttargetbox, stext, text_width, text_height, TRUE, TRUE, 2); 2295 dw_box_pack_start(texttargetbox, stext, text_width, text_height, TRUE, TRUE, 2);
2324 2296
2325 /* Buttons */ 2297 /* Buttons */
2326 buttonbox = dw_box_new(DW_HORZ, 10); 2298 buttonbox = dw_box_new(DW_HORZ, 10);
2327 2299
2328 dw_box_pack_start(mainbox, buttonbox, 0, 0, TRUE, FALSE, 0); 2300 dw_box_pack_start(mainbox, buttonbox, 0, 0, TRUE, FALSE, 0);
2329 2301
2330 dwwait = dw_dialog_new((void *)entrywindow); 2302 dwwait = dw_dialog_new((void *)entrywindow);
2331 2303
2332 /* which buttons ? */ 2304 /* which buttons ? */
2333 if(flags & DW_MB_OK) 2305 if(flags & DW_MB_OK)
2334 { 2306 {
2335 okbutton = dw_button_new("Ok", 1001L); 2307 okbutton = dw_button_new("Ok", 1001L);
2336 dw_box_pack_start(buttonbox, okbutton, 50, 30, TRUE, FALSE, 2); 2308 dw_box_pack_start(buttonbox, okbutton, 50, 30, TRUE, FALSE, 2);
2337 dw_signal_connect(okbutton, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_ok_func), (void *)dwwait); 2309 dw_signal_connect(okbutton, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_ok_func), (void *)dwwait);
2338 } 2310 }
2339 else if(flags & DW_MB_OKCANCEL) 2311 else if(flags & DW_MB_OKCANCEL)
2340 { 2312 {
2341 okbutton = dw_button_new("Ok", 1001L); 2313 okbutton = dw_button_new("Ok", 1001L);
2342 dw_box_pack_start(buttonbox, okbutton, 50, 30, TRUE, FALSE, 2); 2314 dw_box_pack_start(buttonbox, okbutton, 50, 30, TRUE, FALSE, 2);
2343 dw_signal_connect(okbutton, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_ok_func), (void *)dwwait); 2315 dw_signal_connect(okbutton, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_ok_func), (void *)dwwait);
2344 cancelbutton = dw_button_new("Cancel", 1002L); 2316 cancelbutton = dw_button_new("Cancel", 1002L);
2345 dw_box_pack_start(buttonbox, cancelbutton, 50, 30, TRUE, FALSE, 2); 2317 dw_box_pack_start(buttonbox, cancelbutton, 50, 30, TRUE, FALSE, 2);
2346 dw_signal_connect(cancelbutton, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_cancel_func), (void *)dwwait); 2318 dw_signal_connect(cancelbutton, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_cancel_func), (void *)dwwait);
2347 } 2319 }
2348 else if(flags & DW_MB_YESNO) 2320 else if(flags & DW_MB_YESNO)
2349 { 2321 {
2350 yesbutton = dw_button_new("Yes", 1001L); 2322 yesbutton = dw_button_new("Yes", 1001L);
2351 dw_box_pack_start(buttonbox, yesbutton, 50, 30, TRUE, FALSE, 2); 2323 dw_box_pack_start(buttonbox, yesbutton, 50, 30, TRUE, FALSE, 2);
2352 dw_signal_connect(yesbutton, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_yes_func), (void *)dwwait); 2324 dw_signal_connect(yesbutton, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_yes_func), (void *)dwwait);
2353 nobutton = dw_button_new("No", 1002L); 2325 nobutton = dw_button_new("No", 1002L);
2354 dw_box_pack_start(buttonbox, nobutton, 50, 30, TRUE, FALSE, 2); 2326 dw_box_pack_start(buttonbox, nobutton, 50, 30, TRUE, FALSE, 2);
2355 dw_signal_connect(nobutton, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_no_func), (void *)dwwait); 2327 dw_signal_connect(nobutton, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_no_func), (void *)dwwait);
2356 } 2328 }
2357 else if(flags & DW_MB_YESNOCANCEL) 2329 else if(flags & DW_MB_YESNOCANCEL)
2358 { 2330 {
2359 yesbutton = dw_button_new("Yes", 1001L); 2331 yesbutton = dw_button_new("Yes", 1001L);
2360 dw_box_pack_start(buttonbox, yesbutton, 50, 30, TRUE, FALSE, 2); 2332 dw_box_pack_start(buttonbox, yesbutton, 50, 30, TRUE, FALSE, 2);
2361 dw_signal_connect(yesbutton, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_yes_func), (void *)dwwait); 2333 dw_signal_connect(yesbutton, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_yes_func), (void *)dwwait);
2362 nobutton = dw_button_new("No", 1002L); 2334 nobutton = dw_button_new("No", 1002L);
2363 dw_box_pack_start(buttonbox, nobutton, 50, 30, TRUE, FALSE, 2); 2335 dw_box_pack_start(buttonbox, nobutton, 50, 30, TRUE, FALSE, 2);
2364 dw_signal_connect(nobutton, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_no_func), (void *)dwwait); 2336 dw_signal_connect(nobutton, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_no_func), (void *)dwwait);
2365 cancelbutton = dw_button_new("Cancel", 1003L); 2337 cancelbutton = dw_button_new("Cancel", 1003L);
2366 dw_box_pack_start(buttonbox, cancelbutton, 50, 30, TRUE, FALSE, 2); 2338 dw_box_pack_start(buttonbox, cancelbutton, 50, 30, TRUE, FALSE, 2);
2367 dw_signal_connect(cancelbutton, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_cancel_func), (void *)dwwait); 2339 dw_signal_connect(cancelbutton, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_cancel_func), (void *)dwwait);
2368 } 2340 }
2369 2341
2370 height = max(50,text_height)+100; 2342 height = max(50,text_height)+100;
2371 x = (dw_screen_width() - (text_width+60+extra_width))/2; 2343 x = (dw_screen_width() - (text_width+60+extra_width))/2;
2372 y = (dw_screen_height() - height)/2; 2344 y = (dw_screen_height() - height)/2;
2373 2345
2374 dw_window_set_pos_size(entrywindow, x, y, (text_width+60+extra_width), height); 2346 dw_window_set_pos_size(entrywindow, x, y, (text_width+60+extra_width), height);
2375 2347
2376 dw_window_show(entrywindow); 2348 dw_window_show(entrywindow);
2377 2349
2378 return (int)dw_dialog_wait(dwwait); 2350 return (int)dw_dialog_wait(dwwait);
2379 } 2351 }
2380 2352
2381 /* 2353 /*
2382 * Minimizes or Iconifies a top-level window. 2354 * Minimizes or Iconifies a top-level window.
2383 * Parameters: 2355 * Parameters:
2384 * handle: The window handle to minimize. 2356 * handle: The window handle to minimize.
2385 */ 2357 */
2386 int dw_window_minimize(HWND handle) 2358 int dw_window_minimize(HWND handle)
2387 { 2359 {
2388 int _locked_by_me = FALSE; 2360 int _locked_by_me = FALSE;
2389 #if GTK_MAJOR_VERSION > 1 2361 #if GTK_MAJOR_VERSION > 1
2390 GtkWidget *mdi = NULL; 2362 GtkWidget *mdi = NULL;
2391 #endif 2363 #endif
2392 2364
2393 if(!handle) 2365 if(!handle)
2394 return 0; 2366 return 0;
2395 2367
2396 DW_MUTEX_LOCK; 2368 DW_MUTEX_LOCK;
2397 #if GTK_MAJOR_VERSION > 1 2369 #if GTK_MAJOR_VERSION > 1
2398 if((mdi = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_mdi")) && GTK_IS_MDI(mdi)) 2370 if((mdi = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_mdi")) && GTK_IS_MDI(mdi))
2399 { 2371 {
2400 gtk_mdi_set_state(GTK_MDI(mdi), handle, CHILD_ICONIFIED); 2372 gtk_mdi_set_state(GTK_MDI(mdi), handle, CHILD_ICONIFIED);
2401 } 2373 }
2402 else 2374 else
2403 #endif 2375 #endif
2404 { 2376 {
2405 XIconifyWindow(GDK_WINDOW_XDISPLAY(GTK_WIDGET(handle)->window), 2377 XIconifyWindow(GDK_WINDOW_XDISPLAY(GTK_WIDGET(handle)->window),
2406 GDK_WINDOW_XWINDOW(GTK_WIDGET(handle)->window), 2378 GDK_WINDOW_XWINDOW(GTK_WIDGET(handle)->window),
2407 DefaultScreen (GDK_DISPLAY ())); 2379 DefaultScreen (GDK_DISPLAY ()));
2408 } 2380 }
2409 DW_MUTEX_UNLOCK; 2381 DW_MUTEX_UNLOCK;
2410 return 0; 2382 return 0;
2411 } 2383 }
2412 2384
2413 /* 2385 /*
2414 * Makes the window topmost. 2386 * Makes the window topmost.
2415 * Parameters: 2387 * Parameters:
2416 * handle: The window handle to make topmost. 2388 * handle: The window handle to make topmost.
2417 */ 2389 */
2418 int dw_window_raise(HWND handle) 2390 int dw_window_raise(HWND handle)
2419 { 2391 {
2420 int _locked_by_me = FALSE; 2392 int _locked_by_me = FALSE;
2421 2393
2422 if(!handle) 2394 if(!handle)
2423 return 0; 2395 return 0;
2424 2396
2425 DW_MUTEX_LOCK; 2397 DW_MUTEX_LOCK;
2426 gdk_window_raise(GTK_WIDGET(handle)->window); 2398 gdk_window_raise(GTK_WIDGET(handle)->window);
2427 DW_MUTEX_UNLOCK; 2399 DW_MUTEX_UNLOCK;
2428 return 0; 2400 return 0;
2429 } 2401 }
2430 2402
2431 /* 2403 /*
2432 * Makes the window bottommost. 2404 * Makes the window bottommost.
2433 * Parameters: 2405 * Parameters:
2434 * handle: The window handle to make bottommost. 2406 * handle: The window handle to make bottommost.
2435 */ 2407 */
2436 int dw_window_lower(HWND handle) 2408 int dw_window_lower(HWND handle)
2437 { 2409 {
2438 int _locked_by_me = FALSE; 2410 int _locked_by_me = FALSE;
2439 2411
2440 if(!handle) 2412 if(!handle)
2441 return 0; 2413 return 0;
2442 2414
2443 DW_MUTEX_LOCK; 2415 DW_MUTEX_LOCK;
2444 gdk_window_lower(GTK_WIDGET(handle)->window); 2416 gdk_window_lower(GTK_WIDGET(handle)->window);
2445 DW_MUTEX_UNLOCK; 2417 DW_MUTEX_UNLOCK;
2446 return 0; 2418 return 0;
2447 } 2419 }
2448 2420
2449 /* 2421 /*
2450 * Makes the window visible. 2422 * Makes the window visible.
2451 * Parameters: 2423 * Parameters:
2452 * handle: The window handle to make visible. 2424 * handle: The window handle to make visible.
2453 */ 2425 */
2454 int dw_window_show(HWND handle) 2426 int dw_window_show(HWND handle)
2455 { 2427 {
2456 int _locked_by_me = FALSE; 2428 int _locked_by_me = FALSE;
2457 GtkWidget *defaultitem; 2429 GtkWidget *defaultitem;
2458 #if GTK_MAJOR_VERSION > 1 2430 #if GTK_MAJOR_VERSION > 1
2459 GtkWidget *mdi; 2431 GtkWidget *mdi;
2460 #endif 2432 #endif
2461 2433
2462 if(!handle) 2434 if (!handle)
2463 return 0; 2435 return 0;
2464 2436
2465 DW_MUTEX_LOCK; 2437 DW_MUTEX_LOCK;
2466 gtk_widget_show(handle); 2438 gtk_widget_show(handle);
2467 #if GTK_MAJOR_VERSION > 1 2439 #if GTK_MAJOR_VERSION > 1
2468 if((mdi = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_mdi")) && GTK_IS_MDI(mdi)) 2440 if ((mdi = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_mdi")) && GTK_IS_MDI(mdi))
2469 { 2441 {
2470 gtk_mdi_set_state(GTK_MDI(mdi), handle, CHILD_NORMAL); 2442 gtk_mdi_set_state(GTK_MDI(mdi), handle, CHILD_NORMAL);
2471 } 2443 }
2472 else 2444 else
2473 #endif 2445 #endif
2474 { 2446 {
2475 if(GTK_WIDGET(handle)->window) 2447 if (GTK_WIDGET(handle)->window)
2476 { 2448 {
2477 int width = (int)gtk_object_get_data(GTK_OBJECT(handle), "_dw_width"); 2449 int width = (int)gtk_object_get_data(GTK_OBJECT(handle), "_dw_width");
2478 int height = (int)gtk_object_get_data(GTK_OBJECT(handle), "_dw_height"); 2450 int height = (int)gtk_object_get_data(GTK_OBJECT(handle), "_dw_height");
2479 2451
2480 if(width && height) 2452 if (width && height)
2481 { 2453 {
2482 gtk_widget_set_usize(handle, width, height); 2454 gtk_widget_set_usize(handle, width, height);
2483 gtk_object_set_data(GTK_OBJECT(handle), "_dw_width", 0); 2455 gtk_object_set_data(GTK_OBJECT(handle), "_dw_width", GINT_TO_POINTER(0));
2484 gtk_object_set_data(GTK_OBJECT(handle), "_dw_height", 0); 2456 gtk_object_set_data(GTK_OBJECT(handle), "_dw_height", GINT_TO_POINTER(0));
2485 } 2457 }
2486 2458
2487 gdk_window_raise(GTK_WIDGET(handle)->window); 2459 gdk_window_raise(GTK_WIDGET(handle)->window);
2488 gdk_flush(); 2460 gdk_flush();
2489 gdk_window_show(GTK_WIDGET(handle)->window); 2461 gdk_window_show(GTK_WIDGET(handle)->window);
2490 gdk_flush(); 2462 gdk_flush();
2491 } 2463 }
2492 defaultitem = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_defaultitem"); 2464 defaultitem = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_defaultitem");
2493 if(defaultitem) 2465 if (defaultitem)
2494 gtk_widget_grab_focus(defaultitem); 2466 gtk_widget_grab_focus(defaultitem);
2495 } 2467 }
2496 DW_MUTEX_UNLOCK; 2468 DW_MUTEX_UNLOCK;
2497 return 0; 2469 return 0;
2498 } 2470 }
2499 2471
2500 /* 2472 /*
2501 * Makes the window invisible. 2473 * Makes the window invisible.
2502 * Parameters: 2474 * Parameters:
2503 * handle: The window handle to make visible. 2475 * handle: The window handle to make visible.
2504 */ 2476 */
2505 int dw_window_hide(HWND handle) 2477 int dw_window_hide(HWND handle)
2506 { 2478 {
2507 int _locked_by_me = FALSE; 2479 int _locked_by_me = FALSE;
2508 #if GTK_MAJOR_VERSION > 1 2480 #if GTK_MAJOR_VERSION > 1
2509 GtkWidget *mdi = NULL; 2481 GtkWidget *mdi = NULL;
2510 #endif 2482 #endif
2511 2483
2512 if(!handle) 2484 if(!handle)
2513 return 0; 2485 return 0;
2514 2486
2515 DW_MUTEX_LOCK; 2487 DW_MUTEX_LOCK;
2516 #if GTK_MAJOR_VERSION > 1 2488 #if GTK_MAJOR_VERSION > 1
2517 if((mdi = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_mdi")) && GTK_IS_MDI(mdi)) 2489 if((mdi = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_mdi")) && GTK_IS_MDI(mdi))
2518 { 2490 {
2519 gtk_mdi_set_state(GTK_MDI(mdi), handle, CHILD_ICONIFIED); 2491 gtk_mdi_set_state(GTK_MDI(mdi), handle, CHILD_ICONIFIED);
2520 } 2492 }
2521 else 2493 else
2522 #endif 2494 #endif
2523 gtk_widget_hide(handle); 2495 gtk_widget_hide(handle);
2524 DW_MUTEX_UNLOCK; 2496 DW_MUTEX_UNLOCK;
2525 return 0; 2497 return 0;
2526 } 2498 }
2527 2499
2528 /* 2500 /*
2529 * Destroys a window and all of it's children. 2501 * Destroys a window and all of it's children.
2530 * Parameters: 2502 * Parameters:
2531 * handle: The window handle to destroy. 2503 * handle: The window handle to destroy.
2532 */ 2504 */
2533 int dw_window_destroy(HWND handle) 2505 int dw_window_destroy(HWND handle)
2534 { 2506 {
2535 int _locked_by_me = FALSE; 2507 int _locked_by_me = FALSE;
2536 #if GTK_MAJOR_VERSION > 1 2508 #if GTK_MAJOR_VERSION > 1
2537 GtkWidget *mdi = NULL; 2509 GtkWidget *mdi = NULL;
2538 #endif 2510 #endif
2539 2511
2540 if(!handle) 2512 if(!handle)
2541 return 0; 2513 return 0;
2542 2514
2543 DW_MUTEX_LOCK; 2515 DW_MUTEX_LOCK;
2544 #if GTK_MAJOR_VERSION > 1 2516 #if GTK_MAJOR_VERSION > 1
2545 if((mdi = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_mdi")) && GTK_IS_MDI(mdi)) 2517 if((mdi = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_mdi")) && GTK_IS_MDI(mdi))
2546 { 2518 {
2547 gtk_mdi_remove(GTK_MDI(mdi), handle); 2519 gtk_mdi_remove(GTK_MDI(mdi), handle);
2548 } 2520 }
2549 #endif 2521 #endif
2550 if(GTK_IS_WIDGET(handle)) 2522 if(GTK_IS_WIDGET(handle))
2551 { 2523 {
2552 GtkWidget *eventbox = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_eventbox"); 2524 GtkWidget *eventbox = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_eventbox");
2553 2525
2554 if(eventbox && GTK_IS_WIDGET(eventbox)) 2526 if(eventbox && GTK_IS_WIDGET(eventbox))
2555 gtk_widget_destroy(eventbox); 2527 gtk_widget_destroy(eventbox);
2556 else 2528 else
2557 gtk_widget_destroy(handle); 2529 gtk_widget_destroy(handle);
2558 } 2530 }
2559 DW_MUTEX_UNLOCK; 2531 DW_MUTEX_UNLOCK;
2560 return 0; 2532 return 0;
2561 } 2533 }
2562 2534
2563 /* Causes entire window to be invalidated and redrawn. 2535 /* Causes entire window to be invalidated and redrawn.
2564 * Parameters: 2536 * Parameters:
2565 * handle: Toplevel window handle to be redrawn. 2537 * handle: Toplevel window handle to be redrawn.
2574 * handle: The window handle to destroy. 2546 * handle: The window handle to destroy.
2575 * newparent: The window's new parent window. 2547 * newparent: The window's new parent window.
2576 */ 2548 */
2577 void dw_window_reparent(HWND handle, HWND newparent) 2549 void dw_window_reparent(HWND handle, HWND newparent)
2578 { 2550 {
2579 int _locked_by_me = FALSE; 2551 int _locked_by_me = FALSE;
2580 2552
2581 DW_MUTEX_LOCK; 2553 DW_MUTEX_LOCK;
2582 gdk_window_reparent(GTK_WIDGET(handle)->window, newparent ? GTK_WIDGET(newparent)->window : GDK_ROOT_PARENT(), 0, 0); 2554 gdk_window_reparent(GTK_WIDGET(handle)->window, newparent ? GTK_WIDGET(newparent)->window : GDK_ROOT_PARENT(), 0, 0);
2583 DW_MUTEX_UNLOCK; 2555 DW_MUTEX_UNLOCK;
2584 } 2556 }
2585 2557
2586 static int _set_font(HWND handle, char *fontname) 2558 static int _set_font(HWND handle, char *fontname)
2587 { 2559 {
2588 int retval = FALSE; 2560 int retval = FALSE;
2589 #if GTK_MAJOR_VERSION < 2 2561 #if GTK_MAJOR_VERSION < 2
2590 GtkStyle *style; 2562 GtkStyle *style;
2591 GdkFont *font = NULL; 2563 GdkFont *font = NULL;
2592 2564
2593 font = gdk_font_load(fontname); 2565 font = gdk_font_load(fontname);
2594 2566
2595 if(font) 2567 if(font)
2596 { 2568 {
2597 style = gtk_widget_get_style(handle); 2569 style = gtk_widget_get_style(handle);
2598 style->font = font; 2570 style->font = font;
2599 gtk_widget_set_style(handle, style); 2571 gtk_widget_set_style(handle, style);
2600 retval = TRUE; 2572 retval = TRUE;
2601 } 2573 }
2602 #else 2574 #else
2603 PangoFontDescription *font = pango_font_description_from_string(fontname); 2575 PangoFontDescription *font = pango_font_description_from_string(fontname);
2604 2576
2605 if(font) 2577 if(font)
2606 { 2578 {
2607 gtk_widget_modify_font(handle, font); 2579 gtk_widget_modify_font(handle, font);
2608 pango_font_description_free(font); 2580 pango_font_description_free(font);
2609 } 2581 }
2610 #endif 2582 #endif
2611 return retval; 2583 return retval;
2612 } 2584 }
2613 2585
2614 /* 2586 /*
2615 * Sets the font used by a specified window (widget) handle. 2587 * Sets the font used by a specified window (widget) handle.
2616 * Parameters: 2588 * Parameters:
2618 * fontname: Name and size of the font in the form "size.fontname" 2590 * fontname: Name and size of the font in the form "size.fontname"
2619 */ 2591 */
2620 int dw_window_set_font(HWND handle, char *fontname) 2592 int dw_window_set_font(HWND handle, char *fontname)
2621 { 2593 {
2622 #if GTK_MAJOR_VERSION > 1 2594 #if GTK_MAJOR_VERSION > 1
2623 PangoFontDescription *pfont; 2595 PangoFontDescription *pfont;
2624 #else 2596 #else
2625 GdkFont *gdkfont; 2597 GdkFont *gdkfont;
2626 #endif 2598 #endif
2627 GtkWidget *handle2 = handle; 2599 GtkWidget *handle2 = handle;
2628 char *font; 2600 char *font;
2629 int _locked_by_me = FALSE; 2601 int _locked_by_me = FALSE;
2630 gpointer data; 2602 gpointer data;
2631 2603
2632 DW_MUTEX_LOCK; 2604 DW_MUTEX_LOCK;
2633 if(GTK_IS_SCROLLED_WINDOW(handle)) 2605 if(GTK_IS_SCROLLED_WINDOW(handle))
2634 { 2606 {
2635 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 2607 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
2636 if(tmp) 2608 if(tmp)
2637 handle2 = tmp; 2609 handle2 = tmp;
2638 } 2610 }
2639 font = strdup(fontname); 2611 font = strdup(fontname);
2640 2612
2641 #if GTK_MAJOR_VERSION < 2 2613 #if GTK_MAJOR_VERSION < 2
2642 /* Free old font if it exists */ 2614 /* Free old font if it exists */
2643 gdkfont = (GdkFont *)gtk_object_get_data(GTK_OBJECT(handle2), "_dw_gdkfont"); 2615 gdkfont = (GdkFont *)gtk_object_get_data(GTK_OBJECT(handle2), "_dw_gdkfont");
2644 if(gdkfont) 2616 if(gdkfont)
2645 gdk_font_unref(gdkfont); 2617 gdk_font_unref(gdkfont);
2646 gdkfont = gdk_font_load(fontname); 2618 gdkfont = gdk_font_load(fontname);
2647 if(!gdkfont) 2619 if(!gdkfont)
2648 gdkfont = gdk_font_load("fixed"); 2620 gdkfont = gdk_font_load("fixed");
2649 gtk_object_set_data(GTK_OBJECT(handle2), "_dw_gdkfont", (gpointer)gdkfont); 2621 gtk_object_set_data(GTK_OBJECT(handle2), "_dw_gdkfont", (gpointer)gdkfont);
2650 #endif 2622 #endif
2651 2623
2652 /* Free old font name if one is allocated */ 2624 /* Free old font name if one is allocated */
2653 data = gtk_object_get_data(GTK_OBJECT(handle2), "_dw_fontname"); 2625 data = gtk_object_get_data(GTK_OBJECT(handle2), "_dw_fontname");
2654 if(data) 2626 if(data)
2655 free(data); 2627 free(data);
2656 2628
2657 gtk_object_set_data(GTK_OBJECT(handle2), "_dw_fontname", (gpointer)font); 2629 gtk_object_set_data(GTK_OBJECT(handle2), "_dw_fontname", (gpointer)font);
2658 #if GTK_MAJOR_VERSION > 1 2630 #if GTK_MAJOR_VERSION > 1
2659 pfont = pango_font_description_from_string(fontname); 2631 pfont = pango_font_description_from_string(fontname);
2660 2632
2661 if(pfont) 2633 if(pfont)
2662 { 2634 {
2663 gtk_widget_modify_font(handle2, pfont); 2635 gtk_widget_modify_font(handle2, pfont);
2664 pango_font_description_free(pfont); 2636 pango_font_description_free(pfont);
2665 } 2637 }
2666 #endif 2638 #endif
2667 DW_MUTEX_UNLOCK; 2639 DW_MUTEX_UNLOCK;
2668 return TRUE; 2640 return TRUE;
2669 } 2641 }
2670 2642
2671 void _free_gdk_colors(HWND handle) 2643 void _free_gdk_colors(HWND handle)
2672 { 2644 {
2673 GdkColor *old = (GdkColor *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_foregdk"); 2645 GdkColor *old = (GdkColor *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_foregdk");
2674 2646
2675 if(old) 2647 if(old)
2676 free(old); 2648 free(old);
2677 2649
2678 old = (GdkColor *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_backgdk"); 2650 old = (GdkColor *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_backgdk");
2679 2651
2680 if(old) 2652 if(old)
2681 free(old); 2653 free(old);
2682 } 2654 }
2683 2655
2684 /* Free old color pointers and allocate new ones */ 2656 /* Free old color pointers and allocate new ones */
2685 static void _save_gdk_colors(HWND handle, GdkColor fore, GdkColor back) 2657 static void _save_gdk_colors(HWND handle, GdkColor fore, GdkColor back)
2686 { 2658 {
2687 GdkColor *foregdk = malloc(sizeof(GdkColor)); 2659 GdkColor *foregdk = malloc(sizeof(GdkColor));
2688 GdkColor *backgdk = malloc(sizeof(GdkColor)); 2660 GdkColor *backgdk = malloc(sizeof(GdkColor));
2689 2661
2690 _free_gdk_colors(handle); 2662 _free_gdk_colors(handle);
2691 2663
2692 *foregdk = fore; 2664 *foregdk = fore;
2693 *backgdk = back; 2665 *backgdk = back;
2694 2666
2695 gtk_object_set_data(GTK_OBJECT(handle), "_dw_foregdk", (gpointer)foregdk); 2667 gtk_object_set_data(GTK_OBJECT(handle), "_dw_foregdk", (gpointer)foregdk);
2696 gtk_object_set_data(GTK_OBJECT(handle), "_dw_backgdk", (gpointer)backgdk); 2668 gtk_object_set_data(GTK_OBJECT(handle), "_dw_backgdk", (gpointer)backgdk);
2697 } 2669 }
2698 2670
2699 static int _set_color(HWND handle, unsigned long fore, unsigned long back) 2671 static int _set_color(HWND handle, unsigned long fore, unsigned long back)
2700 { 2672 {
2701 /* Remember that each color component in X11 use 16 bit no matter 2673 /* Remember that each color component in X11 use 16 bit no matter
2702 * what the destination display supports. (and thus GDK) 2674 * what the destination display supports. (and thus GDK)
2703 */ 2675 */
2704 GdkColor forecolor, backcolor; 2676 GdkColor forecolor, backcolor;
2705 #if GTK_MAJOR_VERSION < 2 2677 #if GTK_MAJOR_VERSION < 2
2706 GtkStyle *style = gtk_style_copy(gtk_widget_get_style(handle)); 2678 GtkStyle *style = gtk_style_copy(gtk_widget_get_style(handle));
2707 #endif 2679 #endif
2708 2680
2709 if(fore & DW_RGB_COLOR) 2681 if(fore & DW_RGB_COLOR)
2710 { 2682 {
2711 forecolor.pixel = 0; 2683 forecolor.pixel = 0;
2712 forecolor.red = DW_RED_VALUE(fore) << 8; 2684 forecolor.red = DW_RED_VALUE(fore) << 8;
2713 forecolor.green = DW_GREEN_VALUE(fore) << 8; 2685 forecolor.green = DW_GREEN_VALUE(fore) << 8;
2714 forecolor.blue = DW_BLUE_VALUE(fore) << 8; 2686 forecolor.blue = DW_BLUE_VALUE(fore) << 8;
2715 2687
2716 gdk_color_alloc(_dw_cmap, &forecolor); 2688 gdk_color_alloc(_dw_cmap, &forecolor);
2717 2689
2718 #if GTK_MAJOR_VERSION > 1 2690 #if GTK_MAJOR_VERSION > 1
2719 gtk_widget_modify_text(handle, 0, &forecolor); 2691 gtk_widget_modify_text(handle, 0, &forecolor);
2720 gtk_widget_modify_text(handle, 1, &forecolor); 2692 gtk_widget_modify_text(handle, 1, &forecolor);
2721 gtk_widget_modify_fg(handle, 0, &forecolor); 2693 gtk_widget_modify_fg(handle, 0, &forecolor);
2722 gtk_widget_modify_fg(handle, 1, &forecolor); 2694 gtk_widget_modify_fg(handle, 1, &forecolor);
2723 #else 2695 #else
2724 if(style) 2696 if(style)
2725 style->text[0] = style->text[1] = style->fg[0] = style->fg[1] = forecolor; 2697 style->text[0] = style->text[1] = style->fg[0] = style->fg[1] = forecolor;
2726 #endif 2698 #endif
2727 } 2699 }
2728 else if(fore != DW_CLR_DEFAULT) 2700 else if(fore != DW_CLR_DEFAULT)
2729 { 2701 {
2730 forecolor = _colors[fore]; 2702 forecolor = _colors[fore];
2731 2703
2732 #if GTK_MAJOR_VERSION > 1 2704 #if GTK_MAJOR_VERSION > 1
2733 gtk_widget_modify_text(handle, 0, &_colors[fore]); 2705 gtk_widget_modify_text(handle, 0, &_colors[fore]);
2734 gtk_widget_modify_text(handle, 1, &_colors[fore]); 2706 gtk_widget_modify_text(handle, 1, &_colors[fore]);
2735 gtk_widget_modify_fg(handle, 0, &_colors[fore]); 2707 gtk_widget_modify_fg(handle, 0, &_colors[fore]);
2736 gtk_widget_modify_fg(handle, 1, &_colors[fore]); 2708 gtk_widget_modify_fg(handle, 1, &_colors[fore]);
2737 #else 2709 #else
2738 if(style) 2710 if(style)
2739 style->text[0] = style->text[1] = style->fg[0] = style->fg[1] = _colors[fore]; 2711 style->text[0] = style->text[1] = style->fg[0] = style->fg[1] = _colors[fore];
2740 #endif 2712 #endif
2741 } 2713 }
2742 if(back & DW_RGB_COLOR) 2714 if(back & DW_RGB_COLOR)
2743 { 2715 {
2744 backcolor.pixel = 0; 2716 backcolor.pixel = 0;
2745 backcolor.red = DW_RED_VALUE(back) << 8; 2717 backcolor.red = DW_RED_VALUE(back) << 8;
2746 backcolor.green = DW_GREEN_VALUE(back) << 8; 2718 backcolor.green = DW_GREEN_VALUE(back) << 8;
2747 backcolor.blue = DW_BLUE_VALUE(back) << 8; 2719 backcolor.blue = DW_BLUE_VALUE(back) << 8;
2748 2720
2749 gdk_color_alloc(_dw_cmap, &backcolor); 2721 gdk_color_alloc(_dw_cmap, &backcolor);
2750 2722
2751 #if GTK_MAJOR_VERSION > 1 2723 #if GTK_MAJOR_VERSION > 1
2752 gtk_widget_modify_base(handle, 0, &backcolor); 2724 gtk_widget_modify_base(handle, 0, &backcolor);
2753 gtk_widget_modify_base(handle, 1, &backcolor); 2725 gtk_widget_modify_base(handle, 1, &backcolor);
2754 gtk_widget_modify_bg(handle, 0, &backcolor); 2726 gtk_widget_modify_bg(handle, 0, &backcolor);
2755 gtk_widget_modify_bg(handle, 1, &backcolor); 2727 gtk_widget_modify_bg(handle, 1, &backcolor);
2756 #else 2728 #else
2757 if(style) 2729 if(style)
2758 style->base[0] = style->base[1] = style->bg[0] = style->bg[1] = backcolor; 2730 style->base[0] = style->base[1] = style->bg[0] = style->bg[1] = backcolor;
2759 #endif 2731 #endif
2760 } 2732 }
2761 else if(back != DW_CLR_DEFAULT) 2733 else if(back != DW_CLR_DEFAULT)
2762 { 2734 {
2763 backcolor = _colors[back]; 2735 backcolor = _colors[back];
2764 2736
2765 #if GTK_MAJOR_VERSION > 1 2737 #if GTK_MAJOR_VERSION > 1
2766 gtk_widget_modify_base(handle, 0, &_colors[back]); 2738 gtk_widget_modify_base(handle, 0, &_colors[back]);
2767 gtk_widget_modify_base(handle, 1, &_colors[back]); 2739 gtk_widget_modify_base(handle, 1, &_colors[back]);
2768 gtk_widget_modify_bg(handle, 0, &_colors[back]); 2740 gtk_widget_modify_bg(handle, 0, &_colors[back]);
2769 gtk_widget_modify_bg(handle, 1, &_colors[back]); 2741 gtk_widget_modify_bg(handle, 1, &_colors[back]);
2770 #else 2742 #else
2771 if(style) 2743 if(style)
2772 style->base[0] = style->base[1] = style->bg[0] = style->bg[1] = _colors[back]; 2744 style->base[0] = style->base[1] = style->bg[0] = style->bg[1] = _colors[back];
2773 #endif 2745 #endif
2774 } 2746 }
2775 2747
2776 _save_gdk_colors(handle, forecolor, backcolor); 2748 _save_gdk_colors(handle, forecolor, backcolor);
2777 2749
2778 if(GTK_IS_CLIST(handle)) 2750 if(GTK_IS_CLIST(handle))
2779 { 2751 {
2780 int z, rowcount = (int)gtk_object_get_data(GTK_OBJECT(handle), "_dw_rowcount"); 2752 int z, rowcount = (int)gtk_object_get_data(GTK_OBJECT(handle), "_dw_rowcount");
2781 2753
2782 for(z=0;z<rowcount;z++) 2754 for(z=0;z<rowcount;z++)
2783 { 2755 {
2784 gtk_clist_set_foreground(GTK_CLIST(handle), z, &forecolor); 2756 gtk_clist_set_foreground(GTK_CLIST(handle), z, &forecolor);
2785 gtk_clist_set_background(GTK_CLIST(handle), z, &backcolor); 2757 gtk_clist_set_background(GTK_CLIST(handle), z, &backcolor);
2786 } 2758 }
2787 } 2759 }
2788 2760
2789 #if GTK_MAJOR_VERSION < 2 2761 #if GTK_MAJOR_VERSION < 2
2790 if(style) 2762 if(style)
2791 { 2763 {
2792 gtk_widget_set_style(handle, style); 2764 gtk_widget_set_style(handle, style);
2793 gtk_style_unref(style); 2765 gtk_style_unref(style);
2794 } 2766 }
2795 #endif 2767 #endif
2796 return TRUE; 2768 return TRUE;
2797 } 2769 }
2798 /* 2770 /*
2799 * Sets the colors used by a specified window (widget) handle. 2771 * Sets the colors used by a specified window (widget) handle.
2800 * Parameters: 2772 * Parameters:
2801 * handle: The window (widget) handle. 2773 * handle: The window (widget) handle.
2802 * fore: Foreground color in RGB format. 2774 * fore: Foreground color in RGB format.
2803 * back: Background color in RGB format. 2775 * back: Background color in RGB format.
2804 */ 2776 */
2805 int dw_window_set_color(HWND handle, unsigned long fore, unsigned long back) 2777 int dw_window_set_color(HWND handle, unsigned long fore, unsigned long back)
2806 { 2778 {
2807 GtkWidget *handle2 = handle; 2779 GtkWidget *handle2 = handle;
2808 int _locked_by_me = FALSE; 2780 int _locked_by_me = FALSE;
2809 2781
2810 DW_MUTEX_LOCK; 2782 DW_MUTEX_LOCK;
2811 2783
2812 if(GTK_IS_SCROLLED_WINDOW(handle) || GTK_IS_BOX(handle)) 2784 if(GTK_IS_SCROLLED_WINDOW(handle) || GTK_IS_BOX(handle))
2813 { 2785 {
2814 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 2786 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
2815 if(tmp) 2787 if(tmp)
2816 handle2 = tmp; 2788 handle2 = tmp;
2817 } 2789 }
2818 else if(GTK_IS_TABLE(handle)) 2790 else if(GTK_IS_TABLE(handle))
2819 { 2791 {
2820 GtkWidget *tmp = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_eventbox"); 2792 GtkWidget *tmp = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_eventbox");
2821 if(tmp) 2793 if(tmp)
2822 handle2 = tmp; 2794 handle2 = tmp;
2823 } 2795 }
2824 2796
2825 _set_color(handle2, fore, back); 2797 _set_color(handle2, fore, back);
2826 2798
2827 DW_MUTEX_UNLOCK; 2799 DW_MUTEX_UNLOCK;
2828 return TRUE; 2800 return TRUE;
2829 } 2801 }
2830 2802
2831 /* 2803 /*
2832 * Sets the font used by a specified window (widget) handle. 2804 * Sets the font used by a specified window (widget) handle.
2833 * Parameters: 2805 * Parameters:
2834 * handle: The window (widget) handle. 2806 * handle: The window (widget) handle.
2835 * border: Size of the window border in pixels. 2807 * border: Size of the window border in pixels.
2836 */ 2808 */
2837 int dw_window_set_border(HWND handle, int border) 2809 int dw_window_set_border(HWND handle, int border)
2838 { 2810 {
2839 /* TODO */ 2811 /* TODO */
2840 return 0; 2812 return 0;
2841 } 2813 }
2842 2814
2843 /* 2815 /*
2844 * Captures the mouse input to this window. 2816 * Captures the mouse input to this window.
2845 * Parameters: 2817 * Parameters:
2846 * handle: Handle to receive mouse input. 2818 * handle: Handle to receive mouse input.
2847 */ 2819 */
2848 void dw_window_capture(HWND handle) 2820 void dw_window_capture(HWND handle)
2849 { 2821 {
2850 int _locked_by_me = FALSE; 2822 int _locked_by_me = FALSE;
2851 2823
2852 DW_MUTEX_LOCK; 2824 DW_MUTEX_LOCK;
2853 gdk_pointer_grab(handle->window, TRUE, GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK, NULL, NULL, GDK_CURRENT_TIME); 2825 gdk_pointer_grab(handle->window, TRUE, GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK, NULL, NULL, GDK_CURRENT_TIME);
2854 DW_MUTEX_UNLOCK; 2826 DW_MUTEX_UNLOCK;
2855 } 2827 }
2856 2828
2857 /* 2829 /*
2858 * Changes the appearance of the mouse pointer. 2830 * Changes the appearance of the mouse pointer.
2859 * Parameters: 2831 * Parameters:
2860 * handle: Handle to widget for which to change. 2832 * handle: Handle to widget for which to change.
2861 * cursortype: ID of the pointer you want. 2833 * cursortype: ID of the pointer you want.
2862 */ 2834 */
2863 void dw_window_set_pointer(HWND handle, int pointertype) 2835 void dw_window_set_pointer(HWND handle, int pointertype)
2864 { 2836 {
2865 int _locked_by_me = FALSE; 2837 int _locked_by_me = FALSE;
2866 GdkCursor *cursor; 2838 GdkCursor *cursor;
2867 2839
2868 DW_MUTEX_LOCK; 2840 DW_MUTEX_LOCK;
2869 if(pointertype & (1 << 31)) 2841 if(pointertype & (1 << 31))
2870 { 2842 {
2871 GdkBitmap *bitmap = NULL; 2843 GdkBitmap *bitmap = NULL;
2872 GdkPixmap *pixmap = _find_private_pixmap(&bitmap, (pointertype & 0xFFFFFF), NULL, NULL); 2844 GdkPixmap *pixmap = _find_private_pixmap(&bitmap, (pointertype & 0xFFFFFF), NULL, NULL);
2873 cursor = gdk_cursor_new_from_pixmap(pixmap, (GdkPixmap *)bitmap, &_colors[DW_CLR_WHITE], &_colors[DW_CLR_BLACK], 8, 8); 2845 cursor = gdk_cursor_new_from_pixmap(pixmap, (GdkPixmap *)bitmap, &_colors[DW_CLR_WHITE], &_colors[DW_CLR_BLACK], 8, 8);
2874 } 2846 }
2875 else if(!pointertype) 2847 else if(!pointertype)
2876 cursor = NULL; 2848 cursor = NULL;
2877 else 2849 else
2878 cursor = gdk_cursor_new(pointertype); 2850 cursor = gdk_cursor_new(pointertype);
2879 if(handle && handle->window) 2851 if(handle && handle->window)
2880 gdk_window_set_cursor(handle->window, cursor); 2852 gdk_window_set_cursor(handle->window, cursor);
2881 if(cursor) 2853 if(cursor)
2882 gdk_cursor_destroy(cursor); 2854 gdk_cursor_destroy(cursor);
2883 DW_MUTEX_UNLOCK; 2855 DW_MUTEX_UNLOCK;
2884 } 2856 }
2885 2857
2886 /* 2858 /*
2887 * Releases previous mouse capture. 2859 * Releases previous mouse capture.
2888 */ 2860 */
2889 void dw_window_release(void) 2861 void dw_window_release(void)
2890 { 2862 {
2891 int _locked_by_me = FALSE; 2863 int _locked_by_me = FALSE;
2892 2864
2893 DW_MUTEX_LOCK; 2865 DW_MUTEX_LOCK;
2894 gdk_pointer_ungrab(GDK_CURRENT_TIME); 2866 gdk_pointer_ungrab(GDK_CURRENT_TIME);
2895 DW_MUTEX_UNLOCK; 2867 DW_MUTEX_UNLOCK;
2896 } 2868 }
2897 2869
2898 /* 2870 /*
2899 * Create a new Window Frame. 2871 * Create a new Window Frame.
2900 * Parameters: 2872 * Parameters:
2902 * title: The Window title. 2874 * title: The Window title.
2903 * flStyle: Style flags, see the PM reference. 2875 * flStyle: Style flags, see the PM reference.
2904 */ 2876 */
2905 HWND dw_window_new(HWND hwndOwner, char *title, unsigned long flStyle) 2877 HWND dw_window_new(HWND hwndOwner, char *title, unsigned long flStyle)
2906 { 2878 {
2907 GtkWidget *tmp; 2879 GtkWidget *tmp;
2908 int _locked_by_me = FALSE; 2880 int _locked_by_me = FALSE;
2909 int flags = 0; 2881 int flags = 0;
2910 2882
2911 DW_MUTEX_LOCK; 2883 DW_MUTEX_LOCK;
2912 #if GTK_MAJOR_VERSION > 1 2884 #if GTK_MAJOR_VERSION > 1
2913 if(hwndOwner && GTK_IS_MDI(hwndOwner)) 2885 if(hwndOwner && GTK_IS_MDI(hwndOwner))
2914 { 2886 {
2915 GtkWidget *label; 2887 GtkWidget *label;
2916 2888
2917 tmp = dw_box_new(DW_VERT, 0); 2889 tmp = dw_box_new(DW_VERT, 0);
2918 2890
2919 label = gtk_label_new(title); 2891 label = gtk_label_new(title);
2920 gtk_widget_show(label); 2892 gtk_widget_show(label);
2921 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_mdi_child", (gpointer)1); 2893 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_mdi_child", GINT_TO_POINTER(1));
2922 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_mdi_title", (gpointer)label); 2894 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_mdi_title", (gpointer)label);
2923 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_mdi", (gpointer)hwndOwner); 2895 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_mdi", (gpointer)hwndOwner);
2924 2896
2925 gtk_mdi_put(GTK_MDI(hwndOwner), tmp, 100, 75, label); 2897 gtk_mdi_put(GTK_MDI(hwndOwner), tmp, 100, 75, label);
2926 } 2898 }
2927 else 2899 else
2928 #endif 2900 #endif
2929 { 2901 {
2930 last_window = tmp = gtk_window_new(GTK_WINDOW_TOPLEVEL); 2902 last_window = tmp = gtk_window_new(GTK_WINDOW_TOPLEVEL);
2931 2903
2932 gtk_window_set_title(GTK_WINDOW(tmp), title); 2904 gtk_window_set_title(GTK_WINDOW(tmp), title);
2933 if(!(flStyle & DW_FCF_SIZEBORDER)) 2905 if(!(flStyle & DW_FCF_SIZEBORDER))
2934 gtk_window_set_policy(GTK_WINDOW(tmp), FALSE, FALSE, TRUE); 2906 gtk_window_set_policy(GTK_WINDOW(tmp), FALSE, FALSE, TRUE);
2935 2907
2936 gtk_widget_realize(tmp); 2908 gtk_widget_realize(tmp);
2937 2909
2938 if(flStyle & DW_FCF_TITLEBAR) 2910 if(flStyle & DW_FCF_TITLEBAR)
2939 flags |= GDK_DECOR_TITLE; 2911 flags |= GDK_DECOR_TITLE;
2940 2912
2941 if(flStyle & DW_FCF_MINMAX) 2913 if(flStyle & DW_FCF_MINMAX)
2942 flags |= GDK_DECOR_MINIMIZE | GDK_DECOR_MAXIMIZE; 2914 flags |= GDK_DECOR_MINIMIZE | GDK_DECOR_MAXIMIZE;
2943 2915
2944 if(flStyle & DW_FCF_SIZEBORDER) 2916 if(flStyle & DW_FCF_SIZEBORDER)
2945 flags |= GDK_DECOR_RESIZEH | GDK_DECOR_BORDER; 2917 flags |= GDK_DECOR_RESIZEH | GDK_DECOR_BORDER;
2946 2918
2947 if(flStyle & DW_FCF_BORDER || flStyle & DW_FCF_DLGBORDER) 2919 if(flStyle & DW_FCF_BORDER || flStyle & DW_FCF_DLGBORDER)
2948 flags |= GDK_DECOR_BORDER; 2920 flags |= GDK_DECOR_BORDER;
2949 2921
2950 if(flStyle & DW_FCF_MAXIMIZE) 2922 if(flStyle & DW_FCF_MAXIMIZE)
2951 { 2923 {
2952 flags &= ~DW_FCF_MAXIMIZE; 2924 flags &= ~DW_FCF_MAXIMIZE;
2953 #if GTK_MAJOR_VERSION > 1 2925 #if GTK_MAJOR_VERSION > 1
2954 gtk_window_maximize(GTK_WINDOW(tmp)); 2926 gtk_window_maximize(GTK_WINDOW(tmp));
2955 #endif 2927 #endif
2956 } 2928 }
2957 if(flStyle & DW_FCF_MINIMIZE) 2929 if(flStyle & DW_FCF_MINIMIZE)
2958 { 2930 {
2959 flags &= ~DW_FCF_MINIMIZE; 2931 flags &= ~DW_FCF_MINIMIZE;
2960 #if GTK_MAJOR_VERSION > 1 2932 #if GTK_MAJOR_VERSION > 1
2961 gtk_window_iconify(GTK_WINDOW(tmp)); 2933 gtk_window_iconify(GTK_WINDOW(tmp));
2962 #endif 2934 #endif
2963 } 2935 }
2964 2936
2965 gdk_window_set_decorations(tmp->window, flags); 2937 gdk_window_set_decorations(tmp->window, flags);
2966 2938
2967 if(hwndOwner) 2939 if(hwndOwner)
2968 gdk_window_reparent(GTK_WIDGET(tmp)->window, GTK_WIDGET(hwndOwner)->window, 0, 0); 2940 gdk_window_reparent(GTK_WIDGET(tmp)->window, GTK_WIDGET(hwndOwner)->window, 0, 0);
2969 2941
2970 if(flStyle & DW_FCF_SIZEBORDER) 2942 if(flStyle & DW_FCF_SIZEBORDER)
2971 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_size", (gpointer)1); 2943 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_size", GINT_TO_POINTER(1));
2972 } 2944 }
2973 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_style", (gpointer)flStyle); 2945 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_style", GINT_TO_POINTER(flStyle));
2974 DW_MUTEX_UNLOCK; 2946 DW_MUTEX_UNLOCK;
2975 return tmp; 2947 return tmp;
2976 } 2948 }
2977 2949
2978 /* 2950 /*
2979 * Create a new Box to be packed. 2951 * Create a new Box to be packed.
2980 * Parameters: 2952 * Parameters:
2981 * type: Either DW_VERT (vertical) or DW_HORZ (horizontal). 2953 * type: Either DW_VERT (vertical) or DW_HORZ (horizontal).
2982 * pad: Number of pixels to pad around the box. 2954 * pad: Number of pixels to pad around the box.
2983 */ 2955 */
2984 HWND dw_box_new(int type, int pad) 2956 HWND dw_box_new(int type, int pad)
2985 { 2957 {
2986 GtkWidget *tmp, *eventbox; 2958 GtkWidget *tmp, *eventbox;
2987 int _locked_by_me = FALSE; 2959 int _locked_by_me = FALSE;
2988 2960
2989 DW_MUTEX_LOCK; 2961 DW_MUTEX_LOCK;
2990 tmp = gtk_table_new(1, 1, FALSE); 2962 tmp = gtk_table_new(1, 1, FALSE);
2991 eventbox = gtk_event_box_new(); 2963 eventbox = gtk_event_box_new();
2992 2964
2993 gtk_widget_show(eventbox); 2965 gtk_widget_show(eventbox);
2994 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_eventbox", (gpointer)eventbox); 2966 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_eventbox", (gpointer)eventbox);
2995 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_boxtype", (gpointer)type); 2967 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_boxtype", GINT_TO_POINTER(type));
2996 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_boxpad", (gpointer)pad); 2968 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_boxpad", GINT_TO_POINTER(pad));
2997 gtk_widget_show(tmp); 2969 gtk_widget_show(tmp);
2998 DW_MUTEX_UNLOCK; 2970 DW_MUTEX_UNLOCK;
2999 return tmp; 2971 return tmp;
3000 } 2972 }
3001 2973
3002 /* 2974 /*
3003 * Create a new Group Box to be packed. 2975 * Create a new Group Box to be packed.
3004 * Parameters: 2976 * Parameters:
3006 * pad: Number of pixels to pad around the box. 2978 * pad: Number of pixels to pad around the box.
3007 * title: Text to be displayined in the group outline. 2979 * title: Text to be displayined in the group outline.
3008 */ 2980 */
3009 HWND dw_groupbox_new(int type, int pad, char *title) 2981 HWND dw_groupbox_new(int type, int pad, char *title)
3010 { 2982 {
3011 GtkWidget *tmp, *frame; 2983 GtkWidget *tmp, *frame;
3012 int _locked_by_me = FALSE; 2984 int _locked_by_me = FALSE;
3013 2985
3014 DW_MUTEX_LOCK; 2986 DW_MUTEX_LOCK;
3015 frame = gtk_frame_new(NULL); 2987 frame = gtk_frame_new(NULL);
3016 gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN); 2988 gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
3017 gtk_frame_set_label(GTK_FRAME(frame), title && *title ? title : NULL); 2989 gtk_frame_set_label(GTK_FRAME(frame), title && *title ? title : NULL);
3018 tmp = gtk_table_new(1, 1, FALSE); 2990 tmp = gtk_table_new(1, 1, FALSE);
3019 gtk_container_border_width(GTK_CONTAINER(tmp), pad); 2991 gtk_container_border_width(GTK_CONTAINER(tmp), pad);
3020 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_boxtype", (gpointer)type); 2992 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_boxtype", GINT_TO_POINTER(type));
3021 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_boxpad", (gpointer)pad); 2993 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_boxpad", GINT_TO_POINTER(pad));
3022 gtk_object_set_data(GTK_OBJECT(frame), "_dw_boxhandle", (gpointer)tmp); 2994 gtk_object_set_data(GTK_OBJECT(frame), "_dw_boxhandle", (gpointer)tmp);
3023 gtk_container_add(GTK_CONTAINER(frame), tmp); 2995 gtk_container_add(GTK_CONTAINER(frame), tmp);
3024 gtk_widget_show(tmp); 2996 gtk_widget_show(tmp);
3025 gtk_widget_show(frame); 2997 gtk_widget_show(frame);
3026 DW_MUTEX_UNLOCK; 2998 DW_MUTEX_UNLOCK;
3027 return frame; 2999 return frame;
3028 } 3000 }
3029 3001
3030 /* 3002 /*
3031 * Create a new MDI Frame to be packed. 3003 * Create a new MDI Frame to be packed.
3032 * Parameters: 3004 * Parameters:
3033 * id: An ID to be used with dw_window_from_id or 0L. 3005 * id: An ID to be used with dw_window_from_id or 0L.
3034 */ 3006 */
3035 HWND dw_mdi_new(unsigned long id) 3007 HWND dw_mdi_new(unsigned long id)
3036 { 3008 {
3037 GtkWidget *tmp; 3009 GtkWidget *tmp;
3038 int _locked_by_me = FALSE; 3010 int _locked_by_me = FALSE;
3039 3011
3040 DW_MUTEX_LOCK; 3012 DW_MUTEX_LOCK;
3041 #if GTK_MAJOR_VERSION > 1 3013 #if GTK_MAJOR_VERSION > 1
3042 tmp = gtk_mdi_new(); 3014 tmp = gtk_mdi_new();
3043 #else 3015 #else
3044 tmp = gtk_vbox_new(FALSE, 0); 3016 tmp = gtk_vbox_new(FALSE, 0);
3045 #endif 3017 #endif
3046 gtk_widget_show(tmp); 3018 gtk_widget_show(tmp);
3047 DW_MUTEX_UNLOCK; 3019 DW_MUTEX_UNLOCK;
3048 return tmp; 3020 return tmp;
3049 } 3021 }
3050 3022
3051 /* 3023 /*
3052 * Create a bitmap object to be packed. 3024 * Create a bitmap object to be packed.
3053 * Parameters: 3025 * Parameters:
3054 * id: An ID to be used with dw_window_from_id() or 0L. 3026 * id: An ID to be used with dw_window_from_id() or 0L.
3055 */ 3027 */
3056 HWND dw_bitmap_new(unsigned long id) 3028 HWND dw_bitmap_new(unsigned long id)
3057 { 3029 {
3058 #if GTK_MAJOR_VERSION < 2 3030 #if GTK_MAJOR_VERSION < 2
3059 GdkPixmap *pixmap = NULL; 3031 GdkPixmap *pixmap = NULL;
3060 GdkBitmap *bitmap = NULL; 3032 GdkBitmap *bitmap = NULL;
3061 static char * test_xpm[] = { 3033 static char * test_xpm[] = {
3062 "1 1 2 1", 3034 "1 1 2 1",
3063 " c None", 3035 " c None",
3064 ". c #FFFFFF", 3036 ". c #FFFFFF",
3065 "."}; 3037 "."};
3066 #endif 3038 #endif
3067 GtkWidget *tmp; 3039 GtkWidget *tmp;
3068 int _locked_by_me = FALSE; 3040 int _locked_by_me = FALSE;
3069 3041
3070 DW_MUTEX_LOCK; 3042 DW_MUTEX_LOCK;
3071 #if GTK_MAJOR_VERSION > 1 3043 #if GTK_MAJOR_VERSION > 1
3072 tmp = gtk_image_new(); 3044 tmp = gtk_image_new();
3073 #elif defined(USE_IMLIB) 3045 #elif defined(USE_IMLIB)
3074 gdk_imlib_data_to_pixmap(test_xpm, &pixmap, &bitmap); 3046 gdk_imlib_data_to_pixmap(test_xpm, &pixmap, &bitmap);
3075 #else 3047 #else
3076 gtk_widget_realize(last_window); 3048 gtk_widget_realize(last_window);
3077 3049
3078 if(last_window) 3050 if(last_window)
3079 pixmap = gdk_pixmap_create_from_xpm_d(last_window->window, &bitmap, &_colors[DW_CLR_PALEGRAY], test_xpm); 3051 pixmap = gdk_pixmap_create_from_xpm_d(last_window->window, &bitmap, &_colors[DW_CLR_PALEGRAY], test_xpm);
3080 #endif 3052 #endif
3081 #if GTK_MAJOR_VERSION < 2 3053 #if GTK_MAJOR_VERSION < 2
3082 tmp = gtk_pixmap_new(pixmap, bitmap); 3054 tmp = gtk_pixmap_new(pixmap, bitmap);
3083 #endif 3055 #endif
3084 gtk_widget_show(tmp); 3056 gtk_widget_show(tmp);
3085 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 3057 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
3086 DW_MUTEX_UNLOCK; 3058 DW_MUTEX_UNLOCK;
3087 return tmp; 3059 return tmp;
3088 } 3060 }
3089 3061
3090 /* 3062 /*
3091 * Create a notebook object to be packed. 3063 * Create a notebook object to be packed.
3092 * Parameters: 3064 * Parameters:
3093 * id: An ID to be used for getting the resource from the 3065 * id: An ID to be used for getting the resource from the
3094 * resource file. 3066 * resource file.
3095 */ 3067 */
3096 HWND dw_notebook_new(unsigned long id, int top) 3068 HWND dw_notebook_new(unsigned long id, int top)
3097 { 3069 {
3098 GtkWidget *tmp, **pagearray = calloc(sizeof(GtkWidget *), 256); 3070 GtkWidget *tmp, **pagearray = calloc(sizeof(GtkWidget *), 256);
3099 int _locked_by_me = FALSE; 3071 int _locked_by_me = FALSE;
3100 3072
3101 DW_MUTEX_LOCK; 3073 DW_MUTEX_LOCK;
3102 tmp = gtk_notebook_new(); 3074 tmp = gtk_notebook_new();
3103 if(top) 3075 if(top)
3104 gtk_notebook_set_tab_pos(GTK_NOTEBOOK(tmp), GTK_POS_TOP); 3076 gtk_notebook_set_tab_pos(GTK_NOTEBOOK(tmp), GTK_POS_TOP);
3105 else 3077 else
3106 gtk_notebook_set_tab_pos(GTK_NOTEBOOK(tmp), GTK_POS_BOTTOM); 3078 gtk_notebook_set_tab_pos(GTK_NOTEBOOK(tmp), GTK_POS_BOTTOM);
3107 gtk_notebook_set_scrollable(GTK_NOTEBOOK(tmp), TRUE); 3079 gtk_notebook_set_scrollable(GTK_NOTEBOOK(tmp), TRUE);
3108 #if 0 3080 #if 0
3109 gtk_notebook_popup_enable(GTK_NOTEBOOK(tmp)); 3081 gtk_notebook_popup_enable(GTK_NOTEBOOK(tmp));
3110 #endif 3082 #endif
3111 gtk_widget_show(tmp); 3083 gtk_widget_show(tmp);
3112 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 3084 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
3113 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_pagearray", (gpointer)pagearray); 3085 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_pagearray", (gpointer)pagearray);
3114 DW_MUTEX_UNLOCK; 3086 DW_MUTEX_UNLOCK;
3115 return tmp; 3087 return tmp;
3116 } 3088 }
3117 3089
3118 /* 3090 /*
3119 * Create a menu object to be popped up. 3091 * Create a menu object to be popped up.
3120 * Parameters: 3092 * Parameters:
3121 * id: An ID to be used for getting the resource from the 3093 * id: An ID to be used for getting the resource from the
3122 * resource file. 3094 * resource file.
3123 */ 3095 */
3124 HMENUI dw_menu_new(unsigned long id) 3096 HMENUI dw_menu_new(unsigned long id)
3125 { 3097 {
3126 int _locked_by_me = FALSE; 3098 int _locked_by_me = FALSE;
3127 GtkAccelGroup *accel_group; 3099 GtkAccelGroup *accel_group;
3128 HMENUI tmp; 3100 HMENUI tmp;
3129 3101
3130 DW_MUTEX_LOCK; 3102 DW_MUTEX_LOCK;
3131 tmp = gtk_menu_new(); 3103 tmp = gtk_menu_new();
3132 gtk_widget_show(tmp); 3104 gtk_widget_show(tmp);
3133 accel_group = gtk_accel_group_new(); 3105 accel_group = gtk_accel_group_new();
3134 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 3106 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
3135 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_accel", (gpointer)accel_group); 3107 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_accel", (gpointer)accel_group);
3136 DW_MUTEX_UNLOCK; 3108 DW_MUTEX_UNLOCK;
3137 return tmp; 3109 return tmp;
3138 } 3110 }
3139 3111
3140 /* 3112 /*
3141 * Create a menubar on a window. 3113 * Create a menubar on a window.
3142 * Parameters: 3114 * Parameters:
3143 * location: Handle of a window frame to be attached to. 3115 * location: Handle of a window frame to be attached to.
3116 * If there is no box already packed into the "location", the menu will not appear
3117 * so tell the user.
3144 */ 3118 */
3145 HMENUI dw_menubar_new(HWND location) 3119 HMENUI dw_menubar_new(HWND location)
3146 { 3120 {
3147 GtkWidget *box; 3121 GtkWidget *box;
3148 int _locked_by_me = FALSE; 3122 int _locked_by_me = FALSE;
3149 GtkAccelGroup *accel_group; 3123 GtkAccelGroup *accel_group;
3150 HMENUI tmp; 3124 HMENUI tmp;
3151 3125
3152 DW_MUTEX_LOCK; 3126 DW_MUTEX_LOCK;
3153 tmp = gtk_menu_bar_new(); 3127 tmp = gtk_menu_bar_new();
3154 box = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(location)); 3128 box = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(location));
3155 gtk_widget_show(tmp); 3129 gtk_widget_show(tmp);
3156 accel_group = gtk_accel_group_new(); 3130 accel_group = gtk_accel_group_new();
3157 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_accel", (gpointer)accel_group); 3131 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_accel", (gpointer)accel_group);
3158 3132
3159 if(box) 3133 if (box)
3160 gtk_box_pack_end(GTK_BOX(box), tmp, FALSE, FALSE, 0); 3134 gtk_box_pack_end(GTK_BOX(box), tmp, FALSE, FALSE, 0);
3161 3135 else
3162 DW_MUTEX_UNLOCK; 3136 fprintf(stderr,"dw_menubar_new(): Coding error: You MUST pack a box into the window in which this menubar is to be added BEFORE calling this function.\n");
3163 return tmp; 3137
3138 DW_MUTEX_UNLOCK;
3139 return tmp;
3164 } 3140 }
3165 3141
3166 /* 3142 /*
3167 * Destroys a menu created with dw_menubar_new or dw_menu_new. 3143 * Destroys a menu created with dw_menubar_new or dw_menu_new.
3168 * Parameters: 3144 * Parameters:
3169 * menu: Handle of a menu. 3145 * menu: Handle of a menu.
3170 */ 3146 */
3171 void dw_menu_destroy(HMENUI *menu) 3147 void dw_menu_destroy(HMENUI *menu)
3172 { 3148 {
3173 if(menu && *menu) 3149 if(menu && *menu)
3174 { 3150 {
3175 int _locked_by_me = FALSE; 3151 int _locked_by_me = FALSE;
3176 3152
3177 DW_MUTEX_LOCK; 3153 DW_MUTEX_LOCK;
3178 gtk_widget_destroy(*menu); 3154 gtk_widget_destroy(*menu);
3179 *menu = NULL; 3155 *menu = NULL;
3180 DW_MUTEX_UNLOCK; 3156 DW_MUTEX_UNLOCK;
3181 } 3157 }
3182 } 3158 }
3183 3159
3184 char _removetilde(char *dest, char *src) 3160 char _removetilde(char *dest, char *src)
3185 { 3161 {
3186 int z, cur=0; 3162 int z, cur=0;
3187 char accel = '\0'; 3163 char accel = '\0';
3188 3164
3189 for(z=0;z<strlen(src);z++) 3165 for(z=0;z<strlen(src);z++)
3190 { 3166 {
3191 if(src[z] != '~') 3167 if(src[z] != '~')
3192 { 3168 {
3193 dest[cur] = src[z]; 3169 dest[cur] = src[z];
3194 cur++; 3170 cur++;
3195 } 3171 }
3196 else 3172 else
3197 { 3173 {
3198 dest[cur] = '_'; 3174 dest[cur] = '_';
3199 accel = src[z+1]; 3175 accel = src[z+1];
3200 cur++; 3176 cur++;
3201 } 3177 }
3202 } 3178 }
3203 dest[cur] = 0; 3179 dest[cur] = 0;
3204 return accel; 3180 return accel;
3205 } 3181 }
3206 3182
3207 /* 3183 /*
3208 * Adds a menuitem or submenu to an existing menu. 3184 * Adds a menuitem or submenu to an existing menu.
3209 * Parameters: 3185 * Parameters:
3215 * check: If TRUE menu is "check"able. 3191 * check: If TRUE menu is "check"able.
3216 * submenu: Handle to an existing menu to be a submenu or NULL. 3192 * submenu: Handle to an existing menu to be a submenu or NULL.
3217 */ 3193 */
3218 HWND dw_menu_append_item(HMENUI menu, char *title, unsigned long id, unsigned long flags, int end, int check, HMENUI submenu) 3194 HWND dw_menu_append_item(HMENUI menu, char *title, unsigned long id, unsigned long flags, int end, int check, HMENUI submenu)
3219 { 3195 {
3220 GtkWidget *tmphandle; 3196 GtkWidget *tmphandle;
3221 char accel, *tempbuf = malloc(strlen(title)+1); 3197 char accel, *tempbuf = malloc(strlen(title)+1);
3222 int _locked_by_me = FALSE, submenucount; 3198 int _locked_by_me = FALSE, submenucount;
3223 guint tmp_key; 3199 guint tmp_key;
3224 GtkAccelGroup *accel_group; 3200 GtkAccelGroup *accel_group;
3225 3201
3226 if(!menu) 3202 if (!menu)
3227 { 3203 {
3228 free(tempbuf); 3204 free(tempbuf);
3229 return NULL; 3205 return NULL;
3230 } 3206 }
3231 3207
3232 DW_MUTEX_LOCK; 3208 DW_MUTEX_LOCK;
3233 accel = _removetilde(tempbuf, title); 3209 accel = _removetilde(tempbuf, title);
3234 3210
3235 accel_group = (GtkAccelGroup *)gtk_object_get_data(GTK_OBJECT(menu), "_dw_accel"); 3211 accel_group = (GtkAccelGroup *)gtk_object_get_data(GTK_OBJECT(menu), "_dw_accel");
3236 submenucount = (int)gtk_object_get_data(GTK_OBJECT(menu), "_dw_submenucount"); 3212 submenucount = (int)gtk_object_get_data(GTK_OBJECT(menu), "_dw_submenucount");
3237 3213
3238 if(strlen(tempbuf) == 0) 3214 if (strlen(tempbuf) == 0)
3239 tmphandle=gtk_menu_item_new(); 3215 tmphandle=gtk_menu_item_new();
3240 else 3216 else
3241 { 3217 {
3242 if(check) 3218 if (check)
3243 { 3219 {
3244 char numbuf[10]; 3220 char numbuf[10];
3245 if(accel && accel_group) 3221 if (accel && accel_group)
3246 { 3222 {
3247 tmphandle=gtk_check_menu_item_new_with_label(""); 3223 tmphandle = gtk_check_menu_item_new_with_label("");
3248 tmp_key = gtk_label_parse_uline(GTK_LABEL(GTK_BIN(tmphandle)->child), tempbuf); 3224 tmp_key = gtk_label_parse_uline(GTK_LABEL(GTK_BIN(tmphandle)->child), tempbuf);
3249 #if 0 /* This isn't working right */ 3225 #if 0 /* This isn't working right */
3250 gtk_widget_add_accelerator(tmphandle, "activate", accel_group, tmp_key, GDK_MOD1_MASK, 0); 3226 gtk_widget_add_accelerator(tmphandle, "activate", accel_group, tmp_key, GDK_MOD1_MASK, 0);
3251 #endif 3227 #endif
3252 } 3228 }
3253 else 3229 else
3254 tmphandle=gtk_check_menu_item_new_with_label(tempbuf); 3230 tmphandle = gtk_check_menu_item_new_with_label(tempbuf);
3255 gtk_check_menu_item_set_show_toggle(GTK_CHECK_MENU_ITEM(tmphandle), TRUE); 3231 gtk_check_menu_item_set_show_toggle(GTK_CHECK_MENU_ITEM(tmphandle), TRUE);
3256 sprintf(numbuf, "%lu", id); 3232 sprintf(numbuf, "%lu", id);
3257 gtk_object_set_data(GTK_OBJECT(menu), numbuf, (gpointer)tmphandle); 3233 gtk_object_set_data(GTK_OBJECT(menu), numbuf, (gpointer)tmphandle);
3258 } 3234 }
3259 else 3235 else
3260 { 3236 {
3261 if(accel && accel_group) 3237 char numbuf[10];
3262 { 3238 if (accel && accel_group)
3263 tmphandle=gtk_menu_item_new_with_label(""); 3239 {
3264 tmp_key = gtk_label_parse_uline(GTK_LABEL(GTK_BIN(tmphandle)->child), tempbuf); 3240 tmphandle=gtk_menu_item_new_with_label("");
3241 tmp_key = gtk_label_parse_uline(GTK_LABEL(GTK_BIN(tmphandle)->child), tempbuf);
3265 #if 0 /* This isn't working right */ 3242 #if 0 /* This isn't working right */
3266 gtk_widget_add_accelerator(tmphandle, "activate", accel_group, tmp_key, GDK_MOD1_MASK, 0); 3243 gtk_widget_add_accelerator(tmphandle, "activate", accel_group, tmp_key, GDK_MOD1_MASK, 0);
3267 #endif 3244 #endif
3268 } 3245 }
3269 else 3246 else
3270 tmphandle=gtk_menu_item_new_with_label(tempbuf); 3247 tmphandle=gtk_menu_item_new_with_label(tempbuf);
3271 } 3248 sprintf(numbuf, "%lu", id);
3272 } 3249 gtk_object_set_data(GTK_OBJECT(menu), numbuf, (gpointer)tmphandle);
3273 3250 }
3274 gtk_widget_show(tmphandle); 3251 }
3275 3252
3276 if(submenu) 3253 gtk_widget_show(tmphandle);
3277 { 3254
3278 char tempbuf[100]; 3255 if (submenu)
3279 3256 {
3280 sprintf(tempbuf, "_dw_submenu%d", submenucount); 3257 char tempbuf[100];
3281 submenucount++; 3258
3282 gtk_menu_item_set_submenu(GTK_MENU_ITEM(tmphandle), submenu); 3259 sprintf(tempbuf, "_dw_submenu%d", submenucount);
3283 gtk_object_set_data(GTK_OBJECT(menu), tempbuf, (gpointer)submenu); 3260 submenucount++;
3284 gtk_object_set_data(GTK_OBJECT(menu), "_dw_submenucount", (gpointer)submenucount); 3261 gtk_menu_item_set_submenu(GTK_MENU_ITEM(tmphandle), submenu);
3285 } 3262 gtk_object_set_data(GTK_OBJECT(menu), tempbuf, (gpointer)submenu);
3286 3263 gtk_object_set_data(GTK_OBJECT(menu), "_dw_submenucount", (gpointer)submenucount);
3287 if(GTK_IS_MENU_BAR(menu)) 3264 }
3288 gtk_menu_bar_append(GTK_MENU_BAR(menu), tmphandle); 3265
3289 else 3266 if (GTK_IS_MENU_BAR(menu))
3290 gtk_menu_append(GTK_MENU(menu), tmphandle); 3267 gtk_menu_bar_append(GTK_MENU_BAR(menu), tmphandle);
3291 3268 else
3292 gtk_object_set_data(GTK_OBJECT(tmphandle), "_dw_id", (gpointer)id); 3269 gtk_menu_append(GTK_MENU(menu), tmphandle);
3293 free(tempbuf); 3270
3294 DW_MUTEX_UNLOCK; 3271 gtk_object_set_data(GTK_OBJECT(tmphandle), "_dw_id", GINT_TO_POINTER(id));
3295 return tmphandle; 3272 free(tempbuf);
3273 /*
3274 * Set flags
3275 */
3276 if ( check && (flags & DW_MIS_CHECKED) )
3277 {
3278 _dw_ignore_click = 1;
3279 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(tmphandle), 1);
3280 _dw_ignore_click = 0;
3281 }
3282
3283 if ( flags & DW_MIS_DISABLED )
3284 gtk_widget_set_sensitive( tmphandle, FALSE );
3285
3286 DW_MUTEX_UNLOCK;
3287 return tmphandle;
3296 } 3288 }
3297 3289
3298 GtkWidget *_find_submenu_id(GtkWidget *start, char *name) 3290 GtkWidget *_find_submenu_id(GtkWidget *start, char *name)
3299 { 3291 {
3300 GtkWidget *tmp; 3292 GtkWidget *tmp;
3301 int z, submenucount = (int)gtk_object_get_data(GTK_OBJECT(start), "_dw_submenucount"); 3293 int z, submenucount = (int)gtk_object_get_data(GTK_OBJECT(start), "_dw_submenucount");
3302 3294
3303 if((tmp = gtk_object_get_data(GTK_OBJECT(start), name))) 3295 if((tmp = gtk_object_get_data(GTK_OBJECT(start), name)))
3304 return tmp; 3296 return tmp;
3305 3297
3306 for(z=0;z<submenucount;z++) 3298 for(z=0;z<submenucount;z++)
3307 { 3299 {
3308 char tempbuf[100]; 3300 char tempbuf[100];
3309 GtkWidget *submenu, *menuitem; 3301 GtkWidget *submenu, *menuitem;
3310 3302
3311 sprintf(tempbuf, "_dw_submenu%d", z); 3303 sprintf(tempbuf, "_dw_submenu%d", z);
3312 3304
3313 if((submenu = gtk_object_get_data(GTK_OBJECT(start), tempbuf))) 3305 if((submenu = gtk_object_get_data(GTK_OBJECT(start), tempbuf)))
3314 { 3306 {
3315 if((menuitem = _find_submenu_id(submenu, name))) 3307 if((menuitem = _find_submenu_id(submenu, name)))
3316 return menuitem; 3308 return menuitem;
3317 } 3309 }
3318 } 3310 }
3319 return NULL; 3311 return NULL;
3320 } 3312 }
3321 3313
3322 /* 3314 /*
3323 * Sets the state of a menu item check. 3315 * Sets the state of a menu item check.
3324 * Parameters: 3316 * Parameters:
3326 * id: Menuitem id. 3318 * id: Menuitem id.
3327 * check: TRUE for checked FALSE for not checked. 3319 * check: TRUE for checked FALSE for not checked.
3328 */ 3320 */
3329 void dw_menu_item_set_check(HMENUI menu, unsigned long id, int check) 3321 void dw_menu_item_set_check(HMENUI menu, unsigned long id, int check)
3330 { 3322 {
3331 char numbuf[10]; 3323 char numbuf[10];
3332 GtkWidget *tmphandle; 3324 GtkWidget *tmphandle;
3333 int _locked_by_me = FALSE; 3325 int _locked_by_me = FALSE;
3334 3326
3335 if(!menu) 3327 if(!menu)
3336 return; 3328 return;
3337 3329
3338 DW_MUTEX_LOCK; 3330 DW_MUTEX_LOCK;
3339 sprintf(numbuf, "%lu", id); 3331 sprintf(numbuf, "%lu", id);
3340 tmphandle = _find_submenu_id(menu, numbuf); 3332 tmphandle = _find_submenu_id(menu, numbuf);
3341 3333
3342 if(tmphandle) 3334 if(tmphandle)
3343 { 3335 {
3344 _dw_ignore_click = 1; 3336 _dw_ignore_click = 1;
3345 if(GTK_CHECK_MENU_ITEM(tmphandle)->active != check) 3337 if(GTK_CHECK_MENU_ITEM(tmphandle)->active != check)
3346 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(tmphandle), check); 3338 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(tmphandle), check);
3347 _dw_ignore_click = 0; 3339 _dw_ignore_click = 0;
3348 } 3340 }
3349 DW_MUTEX_UNLOCK; 3341 DW_MUTEX_UNLOCK;
3342 }
3343
3344 /*
3345 * Sets the state of a menu item.
3346 * Parameters:
3347 * menu: The handle the the existing menu.
3348 * id: Menuitem id.
3349 * state: TRUE for checked FALSE for not checked.
3350 */
3351 void dw_menu_item_set_state(HMENUI menu, unsigned long id, unsigned long state)
3352 {
3353 char numbuf[10];
3354 GtkWidget *tmphandle;
3355 int check;
3356 int _locked_by_me = FALSE;
3357
3358 if(!menu)
3359 return;
3360
3361 DW_MUTEX_LOCK;
3362 sprintf(numbuf, "%lu", id);
3363 tmphandle = _find_submenu_id(menu, numbuf);
3364
3365 if ( (state & DW_MIS_CHECKED) || (state & DW_MIS_UNCHECKED) )
3366 {
3367 if ( state & DW_MIS_CHECKED )
3368 check = 1;
3369 else
3370 check = 0;
3371
3372 if (tmphandle)
3373 {
3374 _dw_ignore_click = 1;
3375 if(GTK_CHECK_MENU_ITEM(tmphandle)->active != check)
3376 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(tmphandle), check);
3377 _dw_ignore_click = 0;
3378 }
3379 }
3380 if ( (state & DW_MIS_ENABLED) || (state & DW_MIS_DISABLED) )
3381 {
3382 if (tmphandle )
3383 {
3384 _dw_ignore_click = 1;
3385 if ( state & DW_MIS_ENABLED )
3386 gtk_widget_set_sensitive( tmphandle, TRUE );
3387 else
3388 gtk_widget_set_sensitive( tmphandle, FALSE );
3389 _dw_ignore_click = 0;
3390 }
3391 }
3392 DW_MUTEX_UNLOCK;
3350 } 3393 }
3351 3394
3352 /* 3395 /*
3353 * Pops up a context menu at given x and y coordinates. 3396 * Pops up a context menu at given x and y coordinates.
3354 * Parameters: 3397 * Parameters:
3357 * x: X coordinate. 3400 * x: X coordinate.
3358 * y: Y coordinate. 3401 * y: Y coordinate.
3359 */ 3402 */
3360 void dw_menu_popup(HMENUI *menu, HWND parent, int x, int y) 3403 void dw_menu_popup(HMENUI *menu, HWND parent, int x, int y)
3361 { 3404 {
3362 int _locked_by_me = FALSE; 3405 int _locked_by_me = FALSE;
3363 3406
3364 if(!menu || !*menu) 3407 if(!menu || !*menu)
3365 return; 3408 return;
3366 3409
3367 popup = parent; 3410 popup = parent;
3368 3411
3369 DW_MUTEX_LOCK; 3412 DW_MUTEX_LOCK;
3370 gtk_menu_popup(GTK_MENU(*menu), NULL, NULL, NULL, NULL, 1, GDK_CURRENT_TIME); 3413 gtk_menu_popup(GTK_MENU(*menu), NULL, NULL, NULL, NULL, 1, GDK_CURRENT_TIME);
3371 *menu = NULL; 3414 *menu = NULL;
3372 DW_MUTEX_UNLOCK; 3415 DW_MUTEX_UNLOCK;
3373 } 3416 }
3374 3417
3375 3418
3376 /* 3419 /*
3377 * Returns the current X and Y coordinates of the mouse pointer. 3420 * Returns the current X and Y coordinates of the mouse pointer.
3379 * x: Pointer to variable to store X coordinate. 3422 * x: Pointer to variable to store X coordinate.
3380 * y: Pointer to variable to store Y coordinate. 3423 * y: Pointer to variable to store Y coordinate.
3381 */ 3424 */
3382 void dw_pointer_query_pos(long *x, long *y) 3425 void dw_pointer_query_pos(long *x, long *y)
3383 { 3426 {
3384 GdkModifierType state; 3427 GdkModifierType state;
3385 int gx, gy; 3428 int gx, gy;
3386 int _locked_by_me = FALSE; 3429 int _locked_by_me = FALSE;
3387 3430
3388 DW_MUTEX_LOCK; 3431 DW_MUTEX_LOCK;
3389 gdk_window_get_pointer (GDK_ROOT_PARENT(), &gx, &gy, &state); 3432 gdk_window_get_pointer (GDK_ROOT_PARENT(), &gx, &gy, &state);
3390 *x = gx; 3433 *x = gx;
3391 *y = gy; 3434 *y = gy;
3392 DW_MUTEX_UNLOCK; 3435 DW_MUTEX_UNLOCK;
3393 } 3436 }
3394 3437
3395 /* 3438 /*
3396 * Sets the X and Y coordinates of the mouse pointer. 3439 * Sets the X and Y coordinates of the mouse pointer.
3397 * Parameters: 3440 * Parameters:
3398 * x: X coordinate. 3441 * x: X coordinate.
3399 * y: Y coordinate. 3442 * y: Y coordinate.
3400 */ 3443 */
3401 void dw_pointer_set_pos(long x, long y) 3444 void dw_pointer_set_pos(long x, long y)
3402 { 3445 {
3403 int _locked_by_me = FALSE; 3446 int _locked_by_me = FALSE;
3404 3447
3405 DW_MUTEX_LOCK; 3448 DW_MUTEX_LOCK;
3406 XWarpPointer(GDK_DISPLAY(), None, GDK_ROOT_WINDOW(), 0,0,0,0, x, y); 3449 XWarpPointer(GDK_DISPLAY(), None, GDK_ROOT_WINDOW(), 0,0,0,0, x, y);
3407 DW_MUTEX_UNLOCK; 3450 DW_MUTEX_UNLOCK;
3408 } 3451 }
3409 3452
3410 /* 3453 /*
3411 * Create a container object to be packed. 3454 * Create a container object to be packed.
3412 * Parameters: 3455 * Parameters:
3413 * id: An ID to be used for getting the resource from the 3456 * id: An ID to be used for getting the resource from the
3414 * resource file. 3457 * resource file.
3415 */ 3458 */
3416 HWND dw_container_new(unsigned long id, int multi) 3459 HWND dw_container_new(unsigned long id, int multi)
3417 { 3460 {
3418 GtkWidget *tmp; 3461 GtkWidget *tmp;
3419 int _locked_by_me = FALSE; 3462 int _locked_by_me = FALSE;
3420 3463
3421 DW_MUTEX_LOCK; 3464 DW_MUTEX_LOCK;
3422 tmp = gtk_scrolled_window_new (NULL, NULL); 3465 tmp = gtk_scrolled_window_new (NULL, NULL);
3423 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (tmp), 3466 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (tmp),
3424 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); 3467 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
3425 3468
3426 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_multi", (gpointer)multi); 3469 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_multi", GINT_TO_POINTER(multi));
3427 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 3470 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
3428 gtk_widget_show(tmp); 3471 gtk_widget_show(tmp);
3429 3472
3430 DW_MUTEX_UNLOCK; 3473 DW_MUTEX_UNLOCK;
3431 return tmp; 3474 return tmp;
3432 } 3475 }
3433 3476
3434 /* 3477 /*
3435 * Create a tree object to be packed. 3478 * Create a tree object to be packed.
3436 * Parameters: 3479 * Parameters:
3437 * id: An ID to be used for getting the resource from the 3480 * id: An ID to be used for getting the resource from the
3438 * resource file. 3481 * resource file.
3439 */ 3482 */
3440 HWND dw_tree_new(ULONG id) 3483 HWND dw_tree_new(ULONG id)
3441 { 3484 {
3442 GtkWidget *tmp, *tree; 3485 GtkWidget *tmp, *tree;
3443 #if GTK_MAJOR_VERSION > 1 3486 #if GTK_MAJOR_VERSION > 1
3444 GtkTreeStore *store; 3487 GtkTreeStore *store;
3445 GtkTreeViewColumn *col; 3488 GtkTreeViewColumn *col;
3446 GtkCellRenderer *rend; 3489 GtkCellRenderer *rend;
3447 GtkTreeSelection *sel; 3490 GtkTreeSelection *sel;
3448 #endif 3491 #endif
3449 int _locked_by_me = FALSE; 3492 int _locked_by_me = FALSE;
3450 3493
3451 DW_MUTEX_LOCK; 3494 DW_MUTEX_LOCK;
3452 tmp = gtk_scrolled_window_new(NULL, NULL); 3495 tmp = gtk_scrolled_window_new(NULL, NULL);
3453 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (tmp), 3496 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (tmp),
3454 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); 3497 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
3455 3498
3456 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 3499 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
3457 gtk_widget_show(tmp); 3500 gtk_widget_show(tmp);
3458 #if GTK_MAJOR_VERSION > 1 3501 #if GTK_MAJOR_VERSION > 1
3459 store = gtk_tree_store_new(4, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_POINTER, G_TYPE_POINTER); 3502 store = gtk_tree_store_new(4, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_POINTER, G_TYPE_POINTER);
3460 tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); 3503 tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
3461 gtk_object_set_data(GTK_OBJECT(tree), "_dw_tree_store", (gpointer)store); 3504 gtk_object_set_data(GTK_OBJECT(tree), "_dw_tree_store", (gpointer)store);
3462 col = gtk_tree_view_column_new(); 3505 col = gtk_tree_view_column_new();
3463 3506
3464 rend = gtk_cell_renderer_pixbuf_new(); 3507 rend = gtk_cell_renderer_pixbuf_new();
3465 gtk_tree_view_column_pack_start(col, rend, FALSE); 3508 gtk_tree_view_column_pack_start(col, rend, FALSE);
3466 gtk_tree_view_column_add_attribute(col, rend, "pixbuf", 1); 3509 gtk_tree_view_column_add_attribute(col, rend, "pixbuf", 1);
3467 rend = gtk_cell_renderer_text_new(); 3510 rend = gtk_cell_renderer_text_new();
3468 gtk_tree_view_column_pack_start(col, rend, TRUE); 3511 gtk_tree_view_column_pack_start(col, rend, TRUE);
3469 gtk_tree_view_column_add_attribute(col, rend, "text", 0); 3512 gtk_tree_view_column_add_attribute(col, rend, "text", 0);
3470 3513
3471 gtk_tree_view_append_column(GTK_TREE_VIEW (tree), col); 3514 gtk_tree_view_append_column(GTK_TREE_VIEW (tree), col);
3472 gtk_tree_view_set_expander_column(GTK_TREE_VIEW(tree), col); 3515 gtk_tree_view_set_expander_column(GTK_TREE_VIEW(tree), col);
3473 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE); 3516 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE);
3474 3517
3475 sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); 3518 sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
3476 gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE); 3519 gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
3477 #else 3520 #else
3478 tree = gtk_tree_new(); 3521 tree = gtk_tree_new();
3479 #endif 3522 #endif
3480 if(!tree) 3523 if(!tree)
3481 { 3524 {
3482 gtk_widget_destroy(tmp); 3525 gtk_widget_destroy(tmp);
3483 DW_MUTEX_UNLOCK; 3526 DW_MUTEX_UNLOCK;
3484 return FALSE; 3527 return FALSE;
3485 } 3528 }
3486 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(tmp), tree); 3529 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(tmp), tree);
3487 #if GTK_MAJOR_VERSION < 2 3530 #if GTK_MAJOR_VERSION < 2
3488 /* Set the selection mode */ 3531 /* Set the selection mode */
3489 gtk_tree_set_selection_mode (GTK_TREE(tree), GTK_SELECTION_SINGLE); 3532 gtk_tree_set_selection_mode (GTK_TREE(tree), GTK_SELECTION_SINGLE);
3490 gtk_tree_set_view_mode(GTK_TREE(tree), GTK_TREE_VIEW_ITEM); 3533 gtk_tree_set_view_mode(GTK_TREE(tree), GTK_TREE_VIEW_ITEM);
3491 #endif 3534 #endif
3492 3535
3493 gtk_object_set_user_data(GTK_OBJECT(tmp), (gpointer)tree); 3536 gtk_object_set_user_data(GTK_OBJECT(tmp), (gpointer)tree);
3494 gtk_widget_show(tree); 3537 gtk_widget_show(tree);
3495 3538
3496 DW_MUTEX_UNLOCK; 3539 DW_MUTEX_UNLOCK;
3497 return tmp; 3540 return tmp;
3498 } 3541 }
3499 3542
3500 3543
3501 /* 3544 /*
3502 * Create a new static text window (widget) to be packed. 3545 * Create a new static text window (widget) to be packed.
3504 * text: The text to be display by the static text widget. 3547 * text: The text to be display by the static text widget.
3505 * id: An ID to be used with dw_window_from_id() or 0L. 3548 * id: An ID to be used with dw_window_from_id() or 0L.
3506 */ 3549 */
3507 HWND dw_text_new(char *text, unsigned long id) 3550 HWND dw_text_new(char *text, unsigned long id)
3508 { 3551 {
3509 GtkWidget *tmp; 3552 GtkWidget *tmp;
3510 int _locked_by_me = FALSE; 3553 int _locked_by_me = FALSE;
3511 3554
3512 DW_MUTEX_LOCK; 3555 DW_MUTEX_LOCK;
3513 tmp = gtk_label_new(text); 3556 tmp = gtk_label_new(text);
3514 3557
3515 /* Left and centered */ 3558 /* Left and centered */
3516 gtk_misc_set_alignment(GTK_MISC(tmp), 0.0f, 0.5f); 3559 gtk_misc_set_alignment(GTK_MISC(tmp), 0.0f, 0.5f);
3517 gtk_widget_show(tmp); 3560 gtk_widget_show(tmp);
3518 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 3561 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
3519 gtk_misc_set_alignment(GTK_MISC(tmp), DW_LEFT, DW_LEFT); 3562 gtk_misc_set_alignment(GTK_MISC(tmp), DW_LEFT, DW_LEFT);
3520 DW_MUTEX_UNLOCK; 3563 DW_MUTEX_UNLOCK;
3521 return tmp; 3564 return tmp;
3522 } 3565 }
3523 3566
3524 /* 3567 /*
3525 * Create a new status text window (widget) to be packed. 3568 * Create a new status text window (widget) to be packed.
3526 * Parameters: 3569 * Parameters:
3527 * text: The text to be display by the static text widget. 3570 * text: The text to be display by the static text widget.
3528 * id: An ID to be used with dw_window_from_id() or 0L. 3571 * id: An ID to be used with dw_window_from_id() or 0L.
3529 */ 3572 */
3530 HWND dw_status_text_new(char *text, ULONG id) 3573 HWND dw_status_text_new(char *text, ULONG id)
3531 { 3574 {
3532 GtkWidget *tmp, *frame; 3575 GtkWidget *tmp, *frame;
3533 int _locked_by_me = FALSE; 3576 int _locked_by_me = FALSE;
3534 3577
3535 DW_MUTEX_LOCK; 3578 DW_MUTEX_LOCK;
3536 frame = gtk_frame_new(NULL); 3579 frame = gtk_frame_new(NULL);
3537 gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN); 3580 gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
3538 tmp = gtk_label_new(text); 3581 tmp = gtk_label_new(text);
3539 gtk_container_add(GTK_CONTAINER(frame), tmp); 3582 gtk_container_add(GTK_CONTAINER(frame), tmp);
3540 gtk_widget_show(tmp); 3583 gtk_widget_show(tmp);
3541 gtk_widget_show(frame); 3584 gtk_widget_show(frame);
3542 3585
3543 /* Left and centered */ 3586 /* Left and centered */
3544 gtk_misc_set_alignment(GTK_MISC(tmp), 0.0f, 0.5f); 3587 gtk_misc_set_alignment(GTK_MISC(tmp), 0.0f, 0.5f);
3545 gtk_object_set_data(GTK_OBJECT(frame), "_dw_id", (gpointer)id); 3588 gtk_object_set_data(GTK_OBJECT(frame), "_dw_id", GINT_TO_POINTER(id));
3546 gtk_object_set_data(GTK_OBJECT(frame), "_dw_label", (gpointer)tmp); 3589 gtk_object_set_data(GTK_OBJECT(frame), "_dw_label", (gpointer)tmp);
3547 DW_MUTEX_UNLOCK; 3590 DW_MUTEX_UNLOCK;
3548 return frame; 3591 return frame;
3549 } 3592 }
3550 3593
3551 /* 3594 /*
3552 * Create a new Multiline Editbox window (widget) to be packed. 3595 * Create a new Multiline Editbox window (widget) to be packed.
3553 * Parameters: 3596 * Parameters:
3554 * id: An ID to be used with dw_window_from_id() or 0L. 3597 * id: An ID to be used with dw_window_from_id() or 0L.
3555 */ 3598 */
3556 HWND dw_mle_new(unsigned long id) 3599 HWND dw_mle_new(unsigned long id)
3557 { 3600 {
3558 GtkWidget *tmp, *tmpbox, *scroller; 3601 GtkWidget *tmp, *tmpbox, *scroller;
3559 int _locked_by_me = FALSE; 3602 int _locked_by_me = FALSE;
3560 3603
3561 DW_MUTEX_LOCK; 3604 DW_MUTEX_LOCK;
3562 #if GTK_MAJOR_VERSION > 1 3605 #if GTK_MAJOR_VERSION > 1
3563 tmpbox = gtk_scrolled_window_new (NULL, NULL); 3606 tmpbox = gtk_scrolled_window_new (NULL, NULL);
3564 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(tmpbox), 3607 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(tmpbox),
3565 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); 3608 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
3566 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(tmpbox), GTK_SHADOW_ETCHED_IN); 3609 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(tmpbox), GTK_SHADOW_ETCHED_IN);
3567 tmp = gtk_text_view_new(); 3610 tmp = gtk_text_view_new();
3568 gtk_container_add (GTK_CONTAINER(tmpbox), tmp); 3611 gtk_container_add (GTK_CONTAINER(tmpbox), tmp);
3569 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(tmp), GTK_WRAP_NONE); 3612 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(tmp), GTK_WRAP_NONE);
3570 3613
3571 scroller = NULL; 3614 scroller = NULL;
3572 #else 3615 #else
3573 tmpbox = gtk_hbox_new(FALSE, 0); 3616 tmpbox = gtk_hbox_new(FALSE, 0);
3574 tmp = gtk_text_new(NULL, NULL); 3617 tmp = gtk_text_new(NULL, NULL);
3575 gtk_text_set_word_wrap(GTK_TEXT(tmp), FALSE); 3618 gtk_text_set_word_wrap(GTK_TEXT(tmp), FALSE);
3576 gtk_text_set_line_wrap(GTK_TEXT(tmp), FALSE); 3619 gtk_text_set_line_wrap(GTK_TEXT(tmp), FALSE);
3577 scroller = gtk_vscrollbar_new(GTK_TEXT(tmp)->vadj); 3620 scroller = gtk_vscrollbar_new(GTK_TEXT(tmp)->vadj);
3578 GTK_WIDGET_UNSET_FLAGS(scroller, GTK_CAN_FOCUS); 3621 GTK_WIDGET_UNSET_FLAGS(scroller, GTK_CAN_FOCUS);
3579 gtk_box_pack_start(GTK_BOX(tmpbox), tmp, TRUE, TRUE, 0); 3622 gtk_box_pack_start(GTK_BOX(tmpbox), tmp, TRUE, TRUE, 0);
3580 gtk_box_pack_start(GTK_BOX(tmpbox), scroller, FALSE, TRUE, 0); 3623 gtk_box_pack_start(GTK_BOX(tmpbox), scroller, FALSE, TRUE, 0);
3581 gtk_widget_show(scroller); 3624 gtk_widget_show(scroller);
3582 #endif 3625 #endif
3583 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 3626 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
3584 gtk_object_set_user_data(GTK_OBJECT(tmpbox), (gpointer)tmp); 3627 gtk_object_set_user_data(GTK_OBJECT(tmpbox), (gpointer)tmp);
3585 gtk_widget_show(tmp); 3628 gtk_widget_show(tmp);
3586 gtk_widget_show(tmpbox); 3629 gtk_widget_show(tmpbox);
3587 DW_MUTEX_UNLOCK; 3630 DW_MUTEX_UNLOCK;
3588 return tmpbox; 3631 return tmpbox;
3589 } 3632 }
3590 3633
3591 /* 3634 /*
3592 * Create a new Entryfield window (widget) to be packed. 3635 * Create a new Entryfield window (widget) to be packed.
3593 * Parameters: 3636 * Parameters:
3594 * text: The default text to be in the entryfield widget. 3637 * text: The default text to be in the entryfield widget.
3595 * id: An ID to be used with dw_window_from_id() or 0L. 3638 * id: An ID to be used with dw_window_from_id() or 0L.
3596 */ 3639 */
3597 HWND dw_entryfield_new(char *text, unsigned long id) 3640 HWND dw_entryfield_new(char *text, unsigned long id)
3598 { 3641 {
3599 GtkWidget *tmp; 3642 GtkWidget *tmp;
3600 int _locked_by_me = FALSE; 3643 int _locked_by_me = FALSE;
3601 3644
3602 DW_MUTEX_LOCK; 3645 DW_MUTEX_LOCK;
3603 tmp = gtk_entry_new(); 3646 tmp = gtk_entry_new();
3604 3647
3605 gtk_entry_set_text(GTK_ENTRY(tmp), text); 3648 gtk_entry_set_text(GTK_ENTRY(tmp), text);
3606 3649
3607 gtk_widget_show(tmp); 3650 gtk_widget_show(tmp);
3608 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 3651 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
3609 3652
3610 DW_MUTEX_UNLOCK; 3653 DW_MUTEX_UNLOCK;
3611 return tmp; 3654 return tmp;
3612 } 3655 }
3613 3656
3614 /* 3657 /*
3615 * Create a new Entryfield (password) window (widget) to be packed. 3658 * Create a new Entryfield (password) window (widget) to be packed.
3616 * Parameters: 3659 * Parameters:
3617 * text: The default text to be in the entryfield widget. 3660 * text: The default text to be in the entryfield widget.
3618 * id: An ID to be used with dw_window_from_id() or 0L. 3661 * id: An ID to be used with dw_window_from_id() or 0L.
3619 */ 3662 */
3620 HWND dw_entryfield_password_new(char *text, ULONG id) 3663 HWND dw_entryfield_password_new(char *text, ULONG id)
3621 { 3664 {
3622 GtkWidget *tmp; 3665 GtkWidget *tmp;
3623 int _locked_by_me = FALSE; 3666 int _locked_by_me = FALSE;
3624 3667
3625 DW_MUTEX_LOCK; 3668 DW_MUTEX_LOCK;
3626 tmp = gtk_entry_new(); 3669 tmp = gtk_entry_new();
3627 3670
3628 gtk_entry_set_visibility(GTK_ENTRY(tmp), FALSE); 3671 gtk_entry_set_visibility(GTK_ENTRY(tmp), FALSE);
3629 gtk_entry_set_text(GTK_ENTRY(tmp), text); 3672 gtk_entry_set_text(GTK_ENTRY(tmp), text);
3630 3673
3631 gtk_widget_show(tmp); 3674 gtk_widget_show(tmp);
3632 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 3675 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
3633 3676
3634 DW_MUTEX_UNLOCK; 3677 DW_MUTEX_UNLOCK;
3635 return tmp; 3678 return tmp;
3636 } 3679 }
3637 3680
3638 /* 3681 /*
3639 * Create a new Combobox window (widget) to be packed. 3682 * Create a new Combobox window (widget) to be packed.
3640 * Parameters: 3683 * Parameters:
3641 * text: The default text to be in the combpbox widget. 3684 * text: The default text to be in the combpbox widget.
3642 * id: An ID to be used with dw_window_from_id() or 0L. 3685 * id: An ID to be used with dw_window_from_id() or 0L.
3643 */ 3686 */
3644 HWND dw_combobox_new(char *text, unsigned long id) 3687 HWND dw_combobox_new(char *text, unsigned long id)
3645 { 3688 {
3646 GtkWidget *tmp; 3689 GtkWidget *tmp;
3647 int sigid, _locked_by_me = FALSE; 3690 int sigid, _locked_by_me = FALSE;
3648 gint cid; 3691 gint cid;
3649 3692
3650 DW_MUTEX_LOCK; 3693 DW_MUTEX_LOCK;
3651 tmp = gtk_combo_new(); 3694 tmp = gtk_combo_new();
3652 gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(tmp)->entry), text); 3695 gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(tmp)->entry), text);
3653 gtk_combo_set_use_arrows(GTK_COMBO(tmp), TRUE); 3696 gtk_combo_set_use_arrows(GTK_COMBO(tmp), TRUE);
3654 gtk_object_set_user_data(GTK_OBJECT(tmp), NULL); 3697 gtk_object_set_user_data(GTK_OBJECT(tmp), NULL);
3655 gtk_widget_show(tmp); 3698 gtk_widget_show(tmp);
3656 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 3699 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
3657 3700
3658 sigid = _set_signal_handler(GTK_COMBO(tmp)->list, tmp, NULL, NULL, NULL); 3701 sigid = _set_signal_handler(GTK_COMBO(tmp)->list, tmp, NULL, NULL, NULL);
3659 cid = gtk_signal_connect(GTK_OBJECT(GTK_COMBO(tmp)->list), "select_child", GTK_SIGNAL_FUNC(_item_select_event), (gpointer)sigid); 3702 cid = gtk_signal_connect(GTK_OBJECT(GTK_COMBO(tmp)->list), "select_child", GTK_SIGNAL_FUNC(_item_select_event), (gpointer)sigid);
3660 _set_signal_handler_id(GTK_COMBO(tmp)->list, sigid, cid); 3703 _set_signal_handler_id(GTK_COMBO(tmp)->list, sigid, cid);
3661 DW_MUTEX_UNLOCK; 3704 DW_MUTEX_UNLOCK;
3662 return tmp; 3705 return tmp;
3663 } 3706 }
3664 3707
3665 /* 3708 /*
3666 * Create a new button window (widget) to be packed. 3709 * Create a new button window (widget) to be packed.
3667 * Parameters: 3710 * Parameters:
3668 * text: The text to be display by the static text widget. 3711 * text: The text to be display by the static text widget.
3669 * id: An ID to be used with dw_window_from_id() or 0L. 3712 * id: An ID to be used with dw_window_from_id() or 0L.
3670 */ 3713 */
3671 HWND dw_button_new(char *text, unsigned long id) 3714 HWND dw_button_new(char *text, unsigned long id)
3672 { 3715 {
3673 GtkWidget *tmp; 3716 GtkWidget *tmp;
3674 int _locked_by_me = FALSE; 3717 int _locked_by_me = FALSE;
3675 3718
3676 DW_MUTEX_LOCK; 3719 DW_MUTEX_LOCK;
3677 tmp = gtk_button_new_with_label(text); 3720 tmp = gtk_button_new_with_label(text);
3678 gtk_widget_show(tmp); 3721 gtk_widget_show(tmp);
3679 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 3722 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
3680 DW_MUTEX_UNLOCK; 3723 DW_MUTEX_UNLOCK;
3681 return tmp; 3724 return tmp;
3682 } 3725 }
3683 3726
3684 /* 3727 /*
3685 * Create a new bitmap button window (widget) to be packed. 3728 * Create a new bitmap button window (widget) to be packed.
3686 * Parameters: 3729 * Parameters:
3687 * text: Bubble help text to be displayed. 3730 * text: Bubble help text to be displayed.
3688 * id: An ID of a bitmap in the resource file. 3731 * id: An ID of a bitmap in the resource file.
3689 */ 3732 */
3690 HWND dw_bitmapbutton_new(char *text, unsigned long id) 3733 HWND dw_bitmapbutton_new(char *text, unsigned long id)
3691 { 3734 {
3692 GtkWidget *tmp; 3735 GtkWidget *tmp;
3693 GtkWidget *bitmap; 3736 GtkWidget *bitmap;
3694 GtkTooltips *tooltips; 3737 GtkTooltips *tooltips;
3695 int _locked_by_me = FALSE; 3738 int _locked_by_me = FALSE;
3696 3739
3697 DW_MUTEX_LOCK; 3740 DW_MUTEX_LOCK;
3698 tmp = gtk_button_new(); 3741 tmp = gtk_button_new();
3699 bitmap = dw_bitmap_new(id); 3742 bitmap = dw_bitmap_new(id);
3700 3743
3701 if(bitmap) 3744 if(bitmap)
3702 { 3745 {
3703 dw_window_set_bitmap(bitmap, id, NULL); 3746 dw_window_set_bitmap(bitmap, id, NULL);
3704 gtk_container_add (GTK_CONTAINER(tmp), bitmap); 3747 gtk_container_add (GTK_CONTAINER(tmp), bitmap);
3705 } 3748 }
3706 gtk_widget_show(tmp); 3749 gtk_widget_show(tmp);
3707 if(text) 3750 if(text)
3708 { 3751 {
3709 tooltips = gtk_tooltips_new(); 3752 tooltips = gtk_tooltips_new();
3710 gtk_tooltips_set_tip(tooltips, tmp, text, NULL); 3753 gtk_tooltips_set_tip(tooltips, tmp, text, NULL);
3711 gtk_object_set_data(GTK_OBJECT(tmp), "tooltip", (gpointer)tooltips); 3754 gtk_object_set_data(GTK_OBJECT(tmp), "tooltip", (gpointer)tooltips);
3712 } 3755 }
3713 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 3756 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
3714 DW_MUTEX_UNLOCK; 3757 DW_MUTEX_UNLOCK;
3715 return tmp; 3758 return tmp;
3716 } 3759 }
3717 3760
3718 /* 3761 /*
3719 * Create a new bitmap button window (widget) to be packed from a file. 3762 * Create a new bitmap button window (widget) to be packed from a file.
3720 * Parameters: 3763 * Parameters:
3735 char *label_text=NULL; 3778 char *label_text=NULL;
3736 int _locked_by_me = FALSE; 3779 int _locked_by_me = FALSE;
3737 3780
3738 DW_MUTEX_LOCK; 3781 DW_MUTEX_LOCK;
3739 3782
3740 /* Create box for image and label */ 3783 /* Create box for image and label */
3741 box = gtk_hbox_new (FALSE, 0); 3784 box = gtk_hbox_new (FALSE, 0);
3742 gtk_container_set_border_width (GTK_CONTAINER (box), 2); 3785 gtk_container_set_border_width (GTK_CONTAINER (box), 2);
3743 3786
3744 /* Now on to the image stuff */ 3787 /* Now on to the image stuff */
3745 bitmap = dw_bitmap_new(id); 3788 bitmap = dw_bitmap_new(id);
3746 if ( bitmap ) 3789 if ( bitmap )
3747 { 3790 {
3769 { 3812 {
3770 tooltips = gtk_tooltips_new(); 3813 tooltips = gtk_tooltips_new();
3771 gtk_tooltips_set_tip( tooltips, button, text, NULL ); 3814 gtk_tooltips_set_tip( tooltips, button, text, NULL );
3772 gtk_object_set_data( GTK_OBJECT(button), "tooltip", (gpointer)tooltips ); 3815 gtk_object_set_data( GTK_OBJECT(button), "tooltip", (gpointer)tooltips );
3773 } 3816 }
3774 gtk_object_set_data( GTK_OBJECT(button), "_dw_id", (gpointer)id ); 3817 gtk_object_set_data( GTK_OBJECT(button), "_dw_id", GINT_TO_POINTER(id) );
3775 DW_MUTEX_UNLOCK; 3818 DW_MUTEX_UNLOCK;
3776 return button; 3819 return button;
3777 } 3820 }
3778 3821
3779 /* 3822 /*
3806 { 3849 {
3807 tooltips = gtk_tooltips_new(); 3850 tooltips = gtk_tooltips_new();
3808 gtk_tooltips_set_tip(tooltips, tmp, text, NULL); 3851 gtk_tooltips_set_tip(tooltips, tmp, text, NULL);
3809 gtk_object_set_data(GTK_OBJECT(tmp), "tooltip", (gpointer)tooltips); 3852 gtk_object_set_data(GTK_OBJECT(tmp), "tooltip", (gpointer)tooltips);
3810 } 3853 }
3811 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 3854 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
3812 DW_MUTEX_UNLOCK; 3855 DW_MUTEX_UNLOCK;
3813 return tmp; 3856 return tmp;
3814 } 3857 }
3815 3858
3816 /* 3859 /*
3819 * text: The text to be display by the static text widget. 3862 * text: The text to be display by the static text widget.
3820 * id: An ID to be used with dw_window_from_id() or 0L. 3863 * id: An ID to be used with dw_window_from_id() or 0L.
3821 */ 3864 */
3822 HWND dw_spinbutton_new(char *text, unsigned long id) 3865 HWND dw_spinbutton_new(char *text, unsigned long id)
3823 { 3866 {
3824 GtkAdjustment *adj; 3867 GtkAdjustment *adj;
3825 GtkWidget *tmp; 3868 GtkWidget *tmp;
3826 int _locked_by_me = FALSE; 3869 int _locked_by_me = FALSE;
3827 3870
3828 DW_MUTEX_LOCK; 3871 DW_MUTEX_LOCK;
3829 adj = (GtkAdjustment *)gtk_adjustment_new (1.0, 0.0, 100.0, 1.0, 5.0, 0.0); 3872 adj = (GtkAdjustment *)gtk_adjustment_new (1.0, 0.0, 100.0, 1.0, 5.0, 0.0);
3830 tmp = gtk_spin_button_new (adj, 0, 0); 3873 tmp = gtk_spin_button_new (adj, 0, 0);
3831 gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(tmp), TRUE); 3874 gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(tmp), TRUE);
3832 gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(tmp), TRUE); 3875 gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(tmp), TRUE);
3833 gtk_widget_show(tmp); 3876 gtk_widget_show(tmp);
3834 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_adjustment", (gpointer)adj); 3877 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_adjustment", (gpointer)adj);
3835 gtk_object_set_data(GTK_OBJECT(adj), "_dw_spinbutton", (gpointer)tmp); 3878 gtk_object_set_data(GTK_OBJECT(adj), "_dw_spinbutton", (gpointer)tmp);
3836 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 3879 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
3837 DW_MUTEX_UNLOCK; 3880 DW_MUTEX_UNLOCK;
3838 return tmp; 3881 return tmp;
3839 } 3882 }
3840 3883
3841 /* 3884 /*
3842 * Create a new radiobutton window (widget) to be packed. 3885 * Create a new radiobutton window (widget) to be packed.
3843 * Parameters: 3886 * Parameters:
3844 * text: The text to be display by the static text widget. 3887 * text: The text to be display by the static text widget.
3845 * id: An ID to be used with dw_window_from_id() or 0L. 3888 * id: An ID to be used with dw_window_from_id() or 0L.
3846 */ 3889 */
3847 HWND dw_radiobutton_new(char *text, ULONG id) 3890 HWND dw_radiobutton_new(char *text, ULONG id)
3848 { 3891 {
3849 /* This will have to be fixed in the future. */ 3892 /* This will have to be fixed in the future. */
3850 GtkWidget *tmp; 3893 GtkWidget *tmp;
3851 int _locked_by_me = FALSE; 3894 int _locked_by_me = FALSE;
3852 3895
3853 DW_MUTEX_LOCK; 3896 DW_MUTEX_LOCK;
3854 tmp = gtk_radio_button_new_with_label(NULL, text); 3897 tmp = gtk_radio_button_new_with_label(NULL, text);
3855 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 3898 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
3856 gtk_widget_show(tmp); 3899 gtk_widget_show(tmp);
3857 3900
3858 DW_MUTEX_UNLOCK; 3901 DW_MUTEX_UNLOCK;
3859 return tmp; 3902 return tmp;
3860 } 3903 }
3861 3904
3862 /* 3905 /*
3863 * Create a new slider window (widget) to be packed. 3906 * Create a new slider window (widget) to be packed.
3864 * Parameters: 3907 * Parameters:
3866 * increments: Number of increments available. 3909 * increments: Number of increments available.
3867 * id: An ID to be used with dw_window_from_id() or 0L. 3910 * id: An ID to be used with dw_window_from_id() or 0L.
3868 */ 3911 */
3869 HWND dw_slider_new(int vertical, int increments, ULONG id) 3912 HWND dw_slider_new(int vertical, int increments, ULONG id)
3870 { 3913 {
3871 GtkWidget *tmp; 3914 GtkWidget *tmp;
3872 GtkAdjustment *adjustment; 3915 GtkAdjustment *adjustment;
3873 int _locked_by_me = FALSE; 3916 int _locked_by_me = FALSE;
3874 3917
3875 DW_MUTEX_LOCK; 3918 DW_MUTEX_LOCK;
3876 adjustment = (GtkAdjustment *)gtk_adjustment_new(0, 0, (gfloat)increments, 1, 1, 1); 3919 adjustment = (GtkAdjustment *)gtk_adjustment_new(0, 0, (gfloat)increments, 1, 1, 1);
3877 if(vertical) 3920 if(vertical)
3878 tmp = gtk_vscale_new(adjustment); 3921 tmp = gtk_vscale_new(adjustment);
3879 else 3922 else
3880 tmp = gtk_hscale_new(adjustment); 3923 tmp = gtk_hscale_new(adjustment);
3881 gtk_widget_show(tmp); 3924 gtk_widget_show(tmp);
3882 gtk_scale_set_draw_value(GTK_SCALE(tmp), 0); 3925 gtk_scale_set_draw_value(GTK_SCALE(tmp), 0);
3883 gtk_scale_set_digits(GTK_SCALE(tmp), 0); 3926 gtk_scale_set_digits(GTK_SCALE(tmp), 0);
3884 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_adjustment", (gpointer)adjustment); 3927 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_adjustment", (gpointer)adjustment);
3885 gtk_object_set_data(GTK_OBJECT(adjustment), "_dw_slider", (gpointer)tmp); 3928 gtk_object_set_data(GTK_OBJECT(adjustment), "_dw_slider", (gpointer)tmp);
3886 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 3929 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
3887 DW_MUTEX_UNLOCK; 3930 DW_MUTEX_UNLOCK;
3888 return tmp; 3931 return tmp;
3889 } 3932 }
3890 3933
3891 /* 3934 /*
3892 * Create a new scrollbar window (widget) to be packed. 3935 * Create a new scrollbar window (widget) to be packed.
3893 * Parameters: 3936 * Parameters:
3895 * increments: Number of increments available. 3938 * increments: Number of increments available.
3896 * id: An ID to be used with dw_window_from_id() or 0L. 3939 * id: An ID to be used with dw_window_from_id() or 0L.
3897 */ 3940 */
3898 HWND dw_scrollbar_new(int vertical, ULONG id) 3941 HWND dw_scrollbar_new(int vertical, ULONG id)
3899 { 3942 {
3900 GtkWidget *tmp; 3943 GtkWidget *tmp;
3901 GtkAdjustment *adjustment; 3944 GtkAdjustment *adjustment;
3902 int _locked_by_me = FALSE; 3945 int _locked_by_me = FALSE;
3903 3946
3904 DW_MUTEX_LOCK; 3947 DW_MUTEX_LOCK;
3905 adjustment = (GtkAdjustment *)gtk_adjustment_new(0, 0, 0, 1, 1, 1); 3948 adjustment = (GtkAdjustment *)gtk_adjustment_new(0, 0, 0, 1, 1, 1);
3906 if(vertical) 3949 if(vertical)
3907 tmp = gtk_vscrollbar_new(adjustment); 3950 tmp = gtk_vscrollbar_new(adjustment);
3908 else 3951 else
3909 tmp = gtk_hscrollbar_new(adjustment); 3952 tmp = gtk_hscrollbar_new(adjustment);
3910 GTK_WIDGET_UNSET_FLAGS(tmp, GTK_CAN_FOCUS); 3953 GTK_WIDGET_UNSET_FLAGS(tmp, GTK_CAN_FOCUS);
3911 gtk_widget_show(tmp); 3954 gtk_widget_show(tmp);
3912 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_adjustment", (gpointer)adjustment); 3955 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_adjustment", (gpointer)adjustment);
3913 gtk_object_set_data(GTK_OBJECT(adjustment), "_dw_scrollbar", (gpointer)tmp); 3956 gtk_object_set_data(GTK_OBJECT(adjustment), "_dw_scrollbar", (gpointer)tmp);
3914 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 3957 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
3915 DW_MUTEX_UNLOCK; 3958 DW_MUTEX_UNLOCK;
3916 return tmp; 3959 return tmp;
3917 } 3960 }
3918 3961
3919 /* 3962 /*
3920 * Create a new percent bar window (widget) to be packed. 3963 * Create a new percent bar window (widget) to be packed.
3921 * Parameters: 3964 * Parameters:
3922 * id: An ID to be used with dw_window_from_id() or 0L. 3965 * id: An ID to be used with dw_window_from_id() or 0L.
3923 */ 3966 */
3924 HWND dw_percent_new(unsigned long id) 3967 HWND dw_percent_new(unsigned long id)
3925 { 3968 {
3926 GtkWidget *tmp; 3969 GtkWidget *tmp;
3927 int _locked_by_me = FALSE; 3970 int _locked_by_me = FALSE;
3928 3971
3929 DW_MUTEX_LOCK; 3972 DW_MUTEX_LOCK;
3930 tmp = gtk_progress_bar_new(); 3973 tmp = gtk_progress_bar_new();
3931 gtk_widget_show(tmp); 3974 gtk_widget_show(tmp);
3932 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 3975 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
3933 DW_MUTEX_UNLOCK; 3976 DW_MUTEX_UNLOCK;
3934 return tmp; 3977 return tmp;
3935 } 3978 }
3936 3979
3937 /* 3980 /*
3938 * Create a new checkbox window (widget) to be packed. 3981 * Create a new checkbox window (widget) to be packed.
3939 * Parameters: 3982 * Parameters:
3940 * text: The text to be display by the static text widget. 3983 * text: The text to be display by the static text widget.
3941 * id: An ID to be used with dw_window_from_id() or 0L. 3984 * id: An ID to be used with dw_window_from_id() or 0L.
3942 */ 3985 */
3943 HWND dw_checkbox_new(char *text, unsigned long id) 3986 HWND dw_checkbox_new(char *text, unsigned long id)
3944 { 3987 {
3945 GtkWidget *tmp; 3988 GtkWidget *tmp;
3946 int _locked_by_me = FALSE; 3989 int _locked_by_me = FALSE;
3947 3990
3948 DW_MUTEX_LOCK; 3991 DW_MUTEX_LOCK;
3949 tmp = gtk_check_button_new_with_label(text); 3992 tmp = gtk_check_button_new_with_label(text);
3950 gtk_widget_show(tmp); 3993 gtk_widget_show(tmp);
3951 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 3994 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
3952 DW_MUTEX_UNLOCK; 3995 DW_MUTEX_UNLOCK;
3953 return tmp; 3996 return tmp;
3954 } 3997 }
3955 3998
3956 /* 3999 /*
3957 * Create a new listbox window (widget) to be packed. 4000 * Create a new listbox window (widget) to be packed.
3958 * Parameters: 4001 * Parameters:
3959 * id: An ID to be used with dw_window_from_id() or 0L. 4002 * id: An ID to be used with dw_window_from_id() or 0L.
3960 * multi: Multiple select TRUE or FALSE. 4003 * multi: Multiple select TRUE or FALSE.
3961 */ 4004 */
3962 HWND dw_listbox_new(unsigned long id, int multi) 4005 HWND dw_listbox_new(unsigned long id, int multi)
3963 { 4006 {
3964 GtkWidget *tmp, *list; 4007 GtkWidget *tmp, *list;
3965 int _locked_by_me = FALSE; 4008 int _locked_by_me = FALSE;
3966 4009
3967 DW_MUTEX_LOCK; 4010 DW_MUTEX_LOCK;
3968 tmp = gtk_scrolled_window_new(NULL, NULL); 4011 tmp = gtk_scrolled_window_new(NULL, NULL);
3969 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (tmp), 4012 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (tmp),
3970 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); 4013 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
3971 4014
3972 list = gtk_list_new(); 4015 list = gtk_list_new();
3973 gtk_list_set_selection_mode(GTK_LIST(list), multi ? GTK_SELECTION_MULTIPLE : GTK_SELECTION_SINGLE); 4016 gtk_list_set_selection_mode(GTK_LIST(list), multi ? GTK_SELECTION_MULTIPLE : GTK_SELECTION_SINGLE);
3974 4017
3975 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(tmp), 4018 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(tmp),
3976 list); 4019 list);
3977 gtk_object_set_user_data(GTK_OBJECT(tmp), list); 4020 gtk_object_set_user_data(GTK_OBJECT(tmp), list);
3978 gtk_widget_show(list); 4021 gtk_widget_show(list);
3979 gtk_widget_show(tmp); 4022 gtk_widget_show(tmp);
3980 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 4023 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
3981 4024
3982 DW_MUTEX_UNLOCK; 4025 DW_MUTEX_UNLOCK;
3983 return tmp; 4026 return tmp;
3984 } 4027 }
3985 4028
3986 /* 4029 /*
3987 * Sets the icon used for a given window. 4030 * Sets the icon used for a given window.
3988 * Parameters: 4031 * Parameters:
3989 * handle: Handle to the window. 4032 * handle: Handle to the window.
3990 * id: An ID to be used to specify the icon. 4033 * id: An ID to be used to specify the icon.
3991 */ 4034 */
3992 void dw_window_set_icon(HWND handle, unsigned long id) 4035 void dw_window_set_icon(HWND handle, unsigned long id)
3993 { 4036 {
3994 GdkBitmap *bitmap = NULL; 4037 GdkBitmap *bitmap = NULL;
3995 GdkPixmap *icon_pixmap; 4038 GdkPixmap *icon_pixmap;
3996 int _locked_by_me = FALSE; 4039 int _locked_by_me = FALSE;
3997 4040
3998 DW_MUTEX_LOCK; 4041 DW_MUTEX_LOCK;
3999 icon_pixmap = _find_pixmap(&bitmap, id, handle, NULL, NULL); 4042 icon_pixmap = _find_pixmap(&bitmap, id, handle, NULL, NULL);
4000 4043
4001 if(handle->window && icon_pixmap) 4044 if(handle->window && icon_pixmap)
4002 gdk_window_set_icon(handle->window, NULL, icon_pixmap, bitmap); 4045 gdk_window_set_icon(handle->window, NULL, icon_pixmap, bitmap);
4003 4046
4004 DW_MUTEX_UNLOCK; 4047 DW_MUTEX_UNLOCK;
4005 } 4048 }
4006 4049
4007 /* 4050 /*
4008 * Sets the bitmap used for a given static window. 4051 * Sets the bitmap used for a given static window.
4009 * Parameters: 4052 * Parameters:
4178 * handle: Handle to the window. 4221 * handle: Handle to the window.
4179 * text: The text associated with a given window. 4222 * text: The text associated with a given window.
4180 */ 4223 */
4181 void dw_window_set_text(HWND handle, char *text) 4224 void dw_window_set_text(HWND handle, char *text)
4182 { 4225 {
4183 int _locked_by_me = FALSE; 4226 int _locked_by_me = FALSE;
4184 GtkWidget *tmp; 4227 GtkWidget *tmp;
4185 4228
4186 DW_MUTEX_LOCK; 4229 DW_MUTEX_LOCK;
4187 if((tmp = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_mdi_title"))) 4230 if((tmp = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_mdi_title")))
4188 handle = tmp; 4231 handle = tmp;
4189 if(GTK_IS_ENTRY(handle)) 4232 if(GTK_IS_ENTRY(handle))
4190 gtk_entry_set_text(GTK_ENTRY(handle), text); 4233 gtk_entry_set_text(GTK_ENTRY(handle), text);
4191 else if(GTK_IS_COMBO(handle)) 4234 else if(GTK_IS_COMBO(handle))
4192 gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(handle)->entry), text); 4235 gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(handle)->entry), text);
4193 else if(GTK_IS_LABEL(handle)) 4236 else if(GTK_IS_LABEL(handle))
4194 gtk_label_set_text(GTK_LABEL(handle), text); 4237 gtk_label_set_text(GTK_LABEL(handle), text);
4195 else if(GTK_IS_BUTTON(handle)) 4238 else if(GTK_IS_BUTTON(handle))
4196 { 4239 {
4197 #if GTK_MAJOR_VERSION < 2 4240 #if GTK_MAJOR_VERSION < 2
4198 GtkWidget *label = GTK_BUTTON(handle)->child; 4241 GtkWidget *label = GTK_BUTTON(handle)->child;
4199 4242
4200 if(GTK_IS_LABEL(label)) 4243 if(GTK_IS_LABEL(label))
4201 gtk_label_set_text(GTK_LABEL(label), text); 4244 gtk_label_set_text(GTK_LABEL(label), text);
4202 #else 4245 #else
4203 gtk_button_set_label(GTK_BUTTON(handle), text); 4246 gtk_button_set_label(GTK_BUTTON(handle), text);
4204 #endif 4247 #endif
4205 } 4248 }
4206 else if(GTK_WIDGET_TOPLEVEL(handle)) 4249 else if(GTK_WIDGET_TOPLEVEL(handle))
4207 gtk_window_set_title(GTK_WINDOW(handle), text); 4250 gtk_window_set_title(GTK_WINDOW(handle), text);
4208 else if(GTK_IS_FRAME(handle)) 4251 else if(GTK_IS_FRAME(handle))
4209 { 4252 {
4210 GtkWidget *tmp = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_label"); 4253 GtkWidget *tmp = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_label");
4211 if(tmp && GTK_IS_LABEL(tmp)) 4254 if(tmp && GTK_IS_LABEL(tmp))
4212 gtk_label_set_text(GTK_LABEL(tmp), text); 4255 gtk_label_set_text(GTK_LABEL(tmp), text);
4213 } 4256 }
4214 DW_MUTEX_UNLOCK; 4257 DW_MUTEX_UNLOCK;
4215 } 4258 }
4216 4259
4217 /* 4260 /*
4218 * Gets the text used for a given window. 4261 * Gets the text used for a given window.
4219 * Parameters: 4262 * Parameters:
4222 * text: The text associsated with a given window. 4265 * text: The text associsated with a given window.
4223 */ 4266 */
4224 char *dw_window_get_text(HWND handle) 4267 char *dw_window_get_text(HWND handle)
4225 { 4268 {
4226 #if GTK_MAJOR_VERSION > 1 4269 #if GTK_MAJOR_VERSION > 1
4227 const char *possible = ""; 4270 const char *possible = "";
4228 #else 4271 #else
4229 char *possible = ""; 4272 char *possible = "";
4230 #endif 4273 #endif
4231 int _locked_by_me = FALSE; 4274 int _locked_by_me = FALSE;
4232 4275
4233 DW_MUTEX_LOCK; 4276 DW_MUTEX_LOCK;
4234 if(GTK_IS_ENTRY(handle)) 4277 if(GTK_IS_ENTRY(handle))
4235 possible = gtk_entry_get_text(GTK_ENTRY(handle)); 4278 possible = gtk_entry_get_text(GTK_ENTRY(handle));
4236 else if(GTK_IS_COMBO(handle)) 4279 else if(GTK_IS_COMBO(handle))
4237 possible = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(handle)->entry)); 4280 possible = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(handle)->entry));
4238 4281
4239 DW_MUTEX_UNLOCK; 4282 DW_MUTEX_UNLOCK;
4240 return strdup(possible); 4283 return strdup(possible);
4241 } 4284 }
4242 4285
4243 /* 4286 /*
4244 * Disables given window (widget). 4287 * Disables given window (widget).
4245 * Parameters: 4288 * Parameters:
4246 * handle: Handle to the window. 4289 * handle: Handle to the window.
4247 */ 4290 */
4248 void dw_window_disable(HWND handle) 4291 void dw_window_disable(HWND handle)
4249 { 4292 {
4250 int _locked_by_me = FALSE; 4293 int _locked_by_me = FALSE;
4251 4294
4252 DW_MUTEX_LOCK; 4295 DW_MUTEX_LOCK;
4253 gtk_widget_set_sensitive(handle, FALSE); 4296 gtk_widget_set_sensitive(handle, FALSE);
4254 DW_MUTEX_UNLOCK; 4297 DW_MUTEX_UNLOCK;
4255 } 4298 }
4256 4299
4257 /* 4300 /*
4258 * Enables given window (widget). 4301 * Enables given window (widget).
4259 * Parameters: 4302 * Parameters:
4260 * handle: Handle to the window. 4303 * handle: Handle to the window.
4261 */ 4304 */
4262 void dw_window_enable(HWND handle) 4305 void dw_window_enable(HWND handle)
4263 { 4306 {
4264 int _locked_by_me = FALSE; 4307 int _locked_by_me = FALSE;
4265 4308
4266 DW_MUTEX_LOCK; 4309 DW_MUTEX_LOCK;
4267 gtk_widget_set_sensitive(handle, TRUE); 4310 gtk_widget_set_sensitive(handle, TRUE);
4268 DW_MUTEX_UNLOCK; 4311 DW_MUTEX_UNLOCK;
4269 } 4312 }
4270 4313
4271 /* 4314 /*
4272 * Gets the child window handle with specified ID. 4315 * Gets the child window handle with specified ID.
4273 * Parameters: 4316 * Parameters:
4274 * handle: Handle to the parent window. 4317 * handle: Handle to the parent window.
4275 * id: Integer ID of the child. 4318 * id: Integer ID of the child.
4276 */ 4319 */
4277 HWND API dw_window_from_id(HWND handle, int id) 4320 HWND API dw_window_from_id(HWND handle, int id)
4278 { 4321 {
4279 GList *orig = NULL, *list = NULL; 4322 GList *orig = NULL, *list = NULL;
4280 int _locked_by_me = FALSE; 4323 int _locked_by_me = FALSE;
4281 4324
4282 DW_MUTEX_LOCK; 4325 DW_MUTEX_LOCK;
4283 if(handle && GTK_IS_CONTAINER(handle)) 4326 if(handle && GTK_IS_CONTAINER(handle))
4284 { 4327 {
4285 #if GTK_MAJOR_VERSION > 1 4328 #if GTK_MAJOR_VERSION > 1
4286 orig = list = gtk_container_get_children(GTK_CONTAINER(handle)); 4329 orig = list = gtk_container_get_children(GTK_CONTAINER(handle));
4287 #else 4330 #else
4288 orig = list = gtk_container_children(GTK_CONTAINER(handle)); 4331 orig = list = gtk_container_children(GTK_CONTAINER(handle));
4289 #endif 4332 #endif
4290 } 4333 }
4291 while(list) 4334 while(list)
4292 { 4335 {
4293 if(GTK_IS_WIDGET(list->data)) 4336 if(GTK_IS_WIDGET(list->data))
4294 { 4337 {
4295 if(id == (int)gtk_object_get_data(GTK_OBJECT(list->data), "_dw_id")) 4338 if(id == (int)gtk_object_get_data(GTK_OBJECT(list->data), "_dw_id"))
4296 { 4339 {
4297 HWND ret = (HWND)list->data; 4340 HWND ret = (HWND)list->data;
4298 g_list_free(orig); 4341 g_list_free(orig);
4299 DW_MUTEX_UNLOCK; 4342 DW_MUTEX_UNLOCK;
4300 return ret; 4343 return ret;
4301 } 4344 }
4302 } 4345 }
4303 list = list->next; 4346 list = list->next;
4304 } 4347 }
4305 if(orig) 4348 if(orig)
4306 g_list_free(orig); 4349 g_list_free(orig);
4307 DW_MUTEX_UNLOCK; 4350 DW_MUTEX_UNLOCK;
4308 return 0L; 4351 return 0L;
4309 } 4352 }
4310 4353
4311 void _strip_cr(char *dest, char *src) 4354 void _strip_cr(char *dest, char *src)
4312 { 4355 {
4313 int z, x = 0; 4356 int z, x = 0;
4314 4357
4315 for(z=0;z<strlen(src);z++) 4358 for(z=0;z<strlen(src);z++)
4316 { 4359 {
4317 if(src[z] != '\r') 4360 if(src[z] != '\r')
4318 { 4361 {
4319 dest[x] = src[z]; 4362 dest[x] = src[z];
4320 x++; 4363 x++;
4321 } 4364 }
4322 } 4365 }
4323 dest[x] = 0; 4366 dest[x] = 0;
4324 } 4367 }
4325 4368
4326 /* 4369 /*
4327 * Adds text to an MLE box and returns the current point. 4370 * Adds text to an MLE box and returns the current point.
4328 * Parameters: 4371 * Parameters:
4330 * buffer: Text buffer to be imported. 4373 * buffer: Text buffer to be imported.
4331 * startpoint: Point to start entering text. 4374 * startpoint: Point to start entering text.
4332 */ 4375 */
4333 unsigned int dw_mle_import(HWND handle, char *buffer, int startpoint) 4376 unsigned int dw_mle_import(HWND handle, char *buffer, int startpoint)
4334 { 4377 {
4335 unsigned int tmppoint = startpoint; 4378 unsigned int tmppoint = startpoint;
4336 int _locked_by_me = FALSE; 4379 int _locked_by_me = FALSE;
4337 4380
4338 DW_MUTEX_LOCK; 4381 DW_MUTEX_LOCK;
4339 #if GTK_MAJOR_VERSION > 1 4382 #if GTK_MAJOR_VERSION > 1
4340 if(GTK_IS_SCROLLED_WINDOW(handle)) 4383 if(GTK_IS_SCROLLED_WINDOW(handle))
4341 #else 4384 #else
4342 if(GTK_IS_BOX(handle)) 4385 if(GTK_IS_BOX(handle))
4343 #endif 4386 #endif
4344 { 4387 {
4345 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 4388 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
4346 4389
4347 #if GTK_MAJOR_VERSION > 1 4390 #if GTK_MAJOR_VERSION > 1
4348 if(tmp && GTK_IS_TEXT_VIEW(tmp)) 4391 if(tmp && GTK_IS_TEXT_VIEW(tmp))
4349 { 4392 {
4350 char *impbuf = malloc(strlen(buffer)+1); 4393 char *impbuf = malloc(strlen(buffer)+1);
4351 GtkTextBuffer *tbuffer; 4394 GtkTextBuffer *tbuffer;
4352 GtkTextIter iter; 4395 GtkTextIter iter;
4353 4396
4354 _strip_cr(impbuf, buffer); 4397 _strip_cr(impbuf, buffer);
4355 4398
4356 tbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tmp)); 4399 tbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tmp));
4357 gtk_text_buffer_get_iter_at_offset(tbuffer, &iter, startpoint); 4400 gtk_text_buffer_get_iter_at_offset(tbuffer, &iter, startpoint);
4358 gtk_text_buffer_place_cursor(tbuffer, &iter); 4401 gtk_text_buffer_place_cursor(tbuffer, &iter);
4359 gtk_text_buffer_insert_at_cursor(tbuffer, impbuf, -1); 4402 gtk_text_buffer_insert_at_cursor(tbuffer, impbuf, -1);
4360 tmppoint = (startpoint > -1 ? startpoint : 0) + strlen(impbuf); 4403 tmppoint = (startpoint > -1 ? startpoint : 0) + strlen(impbuf);
4361 free(impbuf); 4404 free(impbuf);
4362 } 4405 }
4363 #else 4406 #else
4364 GdkFont *font = (GdkFont *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_gdkfont"); 4407 GdkFont *font = (GdkFont *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_gdkfont");
4365 4408
4366 if(tmp && GTK_IS_TEXT(tmp)) 4409 if(tmp && GTK_IS_TEXT(tmp))
4367 { 4410 {
4368 GdkColor *fore = (GdkColor *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_foregdk"); 4411 GdkColor *fore = (GdkColor *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_foregdk");
4369 GdkColor *back = (GdkColor *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_backgdk"); 4412 GdkColor *back = (GdkColor *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_backgdk");
4370 char *impbuf = malloc(strlen(buffer)+1); 4413 char *impbuf = malloc(strlen(buffer)+1);
4371 4414
4372 _strip_cr(impbuf, buffer); 4415 _strip_cr(impbuf, buffer);
4373 4416
4374 gtk_text_set_point(GTK_TEXT(tmp), startpoint < 0 ? 0 : startpoint); 4417 gtk_text_set_point(GTK_TEXT(tmp), startpoint < 0 ? 0 : startpoint);
4375 gtk_text_insert(GTK_TEXT(tmp), font, fore, back, impbuf, -1); 4418 gtk_text_insert(GTK_TEXT(tmp), font, fore, back, impbuf, -1);
4376 tmppoint = gtk_text_get_point(GTK_TEXT(tmp)); 4419 tmppoint = gtk_text_get_point(GTK_TEXT(tmp));
4377 free(impbuf); 4420 free(impbuf);
4378 } 4421 }
4379 #endif 4422 #endif
4380 } 4423 }
4381 DW_MUTEX_UNLOCK; 4424 DW_MUTEX_UNLOCK;
4382 return tmppoint; 4425 return tmppoint;
4383 } 4426 }
4384 4427
4385 /* 4428 /*
4386 * Grabs text from an MLE box. 4429 * Grabs text from an MLE box.
4387 * Parameters: 4430 * Parameters:
4390 * startpoint: Point to start grabbing text. 4433 * startpoint: Point to start grabbing text.
4391 * length: Amount of text to be grabbed. 4434 * length: Amount of text to be grabbed.
4392 */ 4435 */
4393 void dw_mle_export(HWND handle, char *buffer, int startpoint, int length) 4436 void dw_mle_export(HWND handle, char *buffer, int startpoint, int length)
4394 { 4437 {
4395 int _locked_by_me = FALSE; 4438 int _locked_by_me = FALSE;
4396 gchar *text; 4439 gchar *text;
4397 4440
4398 DW_MUTEX_LOCK; 4441 DW_MUTEX_LOCK;
4399 /* force the return value to nul in case the following tests fail */ 4442 /* force the return value to nul in case the following tests fail */
4400 if(buffer) 4443 if(buffer)
4401 buffer[0] = '\0'; 4444 buffer[0] = '\0';
4402 #if GTK_MAJOR_VERSION > 1 4445 #if GTK_MAJOR_VERSION > 1
4403 if(GTK_IS_SCROLLED_WINDOW(handle)) 4446 if(GTK_IS_SCROLLED_WINDOW(handle))
4404 #else 4447 #else
4405 if(GTK_IS_BOX(handle)) 4448 if(GTK_IS_BOX(handle))
4406 #endif 4449 #endif
4407 { 4450 {
4408 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 4451 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
4409 4452
4410 #if GTK_MAJOR_VERSION > 1 4453 #if GTK_MAJOR_VERSION > 1
4411 if(tmp && GTK_IS_TEXT_VIEW(tmp)) 4454 if(tmp && GTK_IS_TEXT_VIEW(tmp))
4412 { 4455 {
4413 GtkTextBuffer *tbuffer; 4456 GtkTextBuffer *tbuffer;
4414 GtkTextIter start, end; 4457 GtkTextIter start, end;
4415 4458
4416 tbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tmp)); 4459 tbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tmp));
4417 gtk_text_buffer_get_iter_at_offset(tbuffer, &start, startpoint); 4460 gtk_text_buffer_get_iter_at_offset(tbuffer, &start, startpoint);
4418 gtk_text_buffer_get_iter_at_offset(tbuffer, &end, startpoint + length); 4461 gtk_text_buffer_get_iter_at_offset(tbuffer, &end, startpoint + length);
4419 text = gtk_text_iter_get_text(&start, &end); 4462 text = gtk_text_iter_get_text(&start, &end);
4420 if(text) /* Should this get freed? */ 4463 if(text) /* Should this get freed? */
4421 { 4464 {
4422 if(buffer) 4465 if(buffer)
4423 strcpy(buffer, text); 4466 strcpy(buffer, text);
4424 } 4467 }
4425 } 4468 }
4426 #else 4469 #else
4427 if(tmp && GTK_IS_TEXT(tmp)) 4470 if(tmp && GTK_IS_TEXT(tmp))
4428 { 4471 {
4429 text = gtk_editable_get_chars(GTK_EDITABLE(&(GTK_TEXT(tmp)->editable)), 0, -1); /* get the complete contents */ 4472 text = gtk_editable_get_chars(GTK_EDITABLE(&(GTK_TEXT(tmp)->editable)), 0, -1); /* get the complete contents */
4430 if(text) 4473 if(text)
4431 { 4474 {
4432 if(buffer) 4475 if(buffer)
4433 { 4476 {
4434 len = strlen(text); 4477 len = strlen(text);
4435 if(startpoint < len) 4478 if(startpoint < len)
4436 { 4479 {
4437 max = min(length, len - startpoint); 4480 max = min(length, len - startpoint);
4438 memcpy(buffer, &text[startpoint], max); 4481 memcpy(buffer, &text[startpoint], max);
4439 buffer[max] = '\0'; 4482 buffer[max] = '\0';
4440 } 4483 }
4441 } 4484 }
4442 g_free(text); 4485 g_free(text);
4443 } 4486 }
4444 } 4487 }
4445 #endif 4488 #endif
4446 } 4489 }
4447 DW_MUTEX_UNLOCK; 4490 DW_MUTEX_UNLOCK;
4448 } 4491 }
4449 4492
4450 /* 4493 /*
4451 * Obtains information about an MLE box. 4494 * Obtains information about an MLE box.
4452 * Parameters: 4495 * Parameters:
4454 * bytes: A pointer to a variable to return the total bytes. 4497 * bytes: A pointer to a variable to return the total bytes.
4455 * lines: A pointer to a variable to return the number of lines. 4498 * lines: A pointer to a variable to return the number of lines.
4456 */ 4499 */
4457 void dw_mle_get_size(HWND handle, unsigned long *bytes, unsigned long *lines) 4500 void dw_mle_get_size(HWND handle, unsigned long *bytes, unsigned long *lines)
4458 { 4501 {
4459 int _locked_by_me = FALSE; 4502 int _locked_by_me = FALSE;
4460 4503
4461 if(bytes) 4504 if(bytes)
4462 *bytes = 0; 4505 *bytes = 0;
4463 if(lines) 4506 if(lines)
4464 *lines = 0; 4507 *lines = 0;
4465 4508
4466 DW_MUTEX_LOCK; 4509 DW_MUTEX_LOCK;
4467 #if GTK_MAJOR_VERSION > 1 4510 #if GTK_MAJOR_VERSION > 1
4468 if(GTK_IS_SCROLLED_WINDOW(handle)) 4511 if(GTK_IS_SCROLLED_WINDOW(handle))
4469 { 4512 {
4470 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 4513 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
4471 4514
4472 if(tmp && GTK_IS_TEXT_VIEW(tmp)) 4515 if(tmp && GTK_IS_TEXT_VIEW(tmp))
4473 { 4516 {
4474 GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(tmp)); 4517 GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(tmp));
4475 4518
4476 if(bytes) 4519 if(bytes)
4477 *bytes = gtk_text_buffer_get_char_count(buffer) + 1; 4520 *bytes = gtk_text_buffer_get_char_count(buffer) + 1;
4478 if(lines) 4521 if(lines)
4479 *lines = gtk_text_buffer_get_line_count(buffer) + 1; 4522 *lines = gtk_text_buffer_get_line_count(buffer) + 1;
4480 } 4523 }
4481 } 4524 }
4482 #else 4525 #else
4483 if(GTK_IS_BOX(handle)) 4526 if(GTK_IS_BOX(handle))
4484 { 4527 {
4485 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 4528 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
4486 4529
4487 if(tmp && GTK_IS_TEXT(tmp)) 4530 if(tmp && GTK_IS_TEXT(tmp))
4488 { 4531 {
4489 if(bytes) 4532 if(bytes)
4490 *bytes = gtk_text_get_length(GTK_TEXT(tmp)) + 1; 4533 *bytes = gtk_text_get_length(GTK_TEXT(tmp)) + 1;
4491 if(lines) 4534 if(lines)
4492 { 4535 {
4493 gchar *text; 4536 gchar *text;
4494 4537
4495 *lines = 0; 4538 *lines = 0;
4496 text = gtk_editable_get_chars(GTK_EDITABLE(&(GTK_TEXT(tmp)->editable)), 0, gtk_text_get_length(GTK_TEXT(tmp))); 4539 text = gtk_editable_get_chars(GTK_EDITABLE(&(GTK_TEXT(tmp)->editable)), 0, gtk_text_get_length(GTK_TEXT(tmp)));
4497 4540
4498 if(text) 4541 if(text)
4499 { 4542 {
4500 int z, len = strlen(text); 4543 int z, len = strlen(text);
4501 4544
4502 for(z=0;z<len;z++) 4545 for(z=0;z<len;z++)
4503 { 4546 {
4504 if(text[z] == '\n') 4547 if(text[z] == '\n')
4505 (*lines)++; 4548 (*lines)++;
4506 } 4549 }
4507 g_free(text); 4550 g_free(text);
4508 } 4551 }
4509 } 4552 }
4510 } 4553 }
4511 } 4554 }
4512 #endif 4555 #endif
4513 DW_MUTEX_UNLOCK; 4556 DW_MUTEX_UNLOCK;
4514 } 4557 }
4515 4558
4516 /* 4559 /*
4517 * Deletes text from an MLE box. 4560 * Deletes text from an MLE box.
4518 * Parameters: 4561 * Parameters:
4520 * startpoint: Point to start deleting text. 4563 * startpoint: Point to start deleting text.
4521 * length: Amount of text to be deleted. 4564 * length: Amount of text to be deleted.
4522 */ 4565 */
4523 void dw_mle_delete(HWND handle, int startpoint, int length) 4566 void dw_mle_delete(HWND handle, int startpoint, int length)
4524 { 4567 {
4525 int _locked_by_me = FALSE; 4568 int _locked_by_me = FALSE;
4526 4569
4527 DW_MUTEX_LOCK; 4570 DW_MUTEX_LOCK;
4528 #if GTK_MAJOR_VERSION > 1 4571 #if GTK_MAJOR_VERSION > 1
4529 if(GTK_IS_SCROLLED_WINDOW(handle)) 4572 if(GTK_IS_SCROLLED_WINDOW(handle))
4530 #else 4573 #else
4531 if(GTK_IS_BOX(handle)) 4574 if(GTK_IS_BOX(handle))
4532 #endif 4575 #endif
4533 { 4576 {
4534 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 4577 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
4535 4578
4536 #if GTK_MAJOR_VERSION > 1 4579 #if GTK_MAJOR_VERSION > 1
4537 if(tmp && GTK_IS_TEXT_VIEW(tmp)) 4580 if(tmp && GTK_IS_TEXT_VIEW(tmp))
4538 { 4581 {
4539 GtkTextBuffer *tbuffer; 4582 GtkTextBuffer *tbuffer;
4540 GtkTextIter start, end; 4583 GtkTextIter start, end;
4541 4584
4542 tbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tmp)); 4585 tbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tmp));
4543 gtk_text_buffer_get_iter_at_offset(tbuffer, &start, startpoint); 4586 gtk_text_buffer_get_iter_at_offset(tbuffer, &start, startpoint);
4544 gtk_text_buffer_get_iter_at_offset(tbuffer, &end, startpoint + length); 4587 gtk_text_buffer_get_iter_at_offset(tbuffer, &end, startpoint + length);
4545 gtk_text_buffer_delete(tbuffer, &start, &end); 4588 gtk_text_buffer_delete(tbuffer, &start, &end);
4546 } 4589 }
4547 #else 4590 #else
4548 if(tmp && GTK_IS_TEXT(tmp)) 4591 if(tmp && GTK_IS_TEXT(tmp))
4549 { 4592 {
4550 gtk_text_set_point(GTK_TEXT(tmp), startpoint); 4593 gtk_text_set_point(GTK_TEXT(tmp), startpoint);
4551 gtk_text_forward_delete(GTK_TEXT(tmp), length); 4594 gtk_text_forward_delete(GTK_TEXT(tmp), length);
4552 } 4595 }
4553 #endif 4596 #endif
4554 } 4597 }
4555 DW_MUTEX_UNLOCK; 4598 DW_MUTEX_UNLOCK;
4556 } 4599 }
4557 4600
4558 /* 4601 /*
4559 * Clears all text from an MLE box. 4602 * Clears all text from an MLE box.
4560 * Parameters: 4603 * Parameters:
4561 * handle: Handle to the MLE to be cleared. 4604 * handle: Handle to the MLE to be cleared.
4562 */ 4605 */
4563 void dw_mle_clear(HWND handle) 4606 void dw_mle_clear(HWND handle)
4564 { 4607 {
4565 int length, _locked_by_me = FALSE; 4608 int length, _locked_by_me = FALSE;
4566 4609
4567 DW_MUTEX_LOCK; 4610 DW_MUTEX_LOCK;
4568 #if GTK_MAJOR_VERSION > 1 4611 #if GTK_MAJOR_VERSION > 1
4569 if(GTK_IS_SCROLLED_WINDOW(handle)) 4612 if(GTK_IS_SCROLLED_WINDOW(handle))
4570 { 4613 {
4571 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 4614 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
4572 4615
4573 if(tmp && GTK_IS_TEXT_VIEW(tmp)) 4616 if(tmp && GTK_IS_TEXT_VIEW(tmp))
4574 { 4617 {
4575 GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(tmp)); 4618 GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(tmp));
4576 4619
4577 length = -1; 4620 length = -1;
4578 gtk_text_buffer_set_text(buffer, "", length); 4621 gtk_text_buffer_set_text(buffer, "", length);
4579 } 4622 }
4580 } 4623 }
4581 #else 4624 #else
4582 if(GTK_IS_BOX(handle)) 4625 if(GTK_IS_BOX(handle))
4583 { 4626 {
4584 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 4627 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
4585 4628
4586 if(tmp && GTK_IS_TEXT(tmp)) 4629 if(tmp && GTK_IS_TEXT(tmp))
4587 { 4630 {
4588 length = gtk_text_get_length(GTK_TEXT(tmp)); 4631 length = gtk_text_get_length(GTK_TEXT(tmp));
4589 gtk_text_set_point(GTK_TEXT(tmp), 0); 4632 gtk_text_set_point(GTK_TEXT(tmp), 0);
4590 gtk_text_forward_delete(GTK_TEXT(tmp), length); 4633 gtk_text_forward_delete(GTK_TEXT(tmp), length);
4591 } 4634 }
4592 } 4635 }
4593 #endif 4636 #endif
4594 DW_MUTEX_UNLOCK; 4637 DW_MUTEX_UNLOCK;
4595 } 4638 }
4596 4639
4597 /* 4640 /*
4598 * Sets the visible line of an MLE box. 4641 * Sets the visible line of an MLE box.
4599 * Parameters: 4642 * Parameters:
4600 * handle: Handle to the MLE. 4643 * handle: Handle to the MLE.
4601 * line: Line to be visible. 4644 * line: Line to be visible.
4602 */ 4645 */
4603 void dw_mle_set_visible(HWND handle, int line) 4646 void dw_mle_set_visible(HWND handle, int line)
4604 { 4647 {
4605 int _locked_by_me = FALSE; 4648 int _locked_by_me = FALSE;
4606 4649
4607 DW_MUTEX_LOCK; 4650 DW_MUTEX_LOCK;
4608 #if GTK_MAJOR_VERSION > 1 4651 #if GTK_MAJOR_VERSION > 1
4609 if(GTK_IS_SCROLLED_WINDOW(handle)) 4652 if(GTK_IS_SCROLLED_WINDOW(handle))
4610 { 4653 {
4611 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 4654 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
4612 4655
4613 if(tmp && GTK_IS_TEXT_VIEW(tmp)) 4656 if(tmp && GTK_IS_TEXT_VIEW(tmp))
4614 { 4657 {
4615 GtkTextBuffer *tbuffer; 4658 GtkTextBuffer *tbuffer;
4616 GtkTextIter iter; 4659 GtkTextIter iter;
4617 GtkTextMark *mark = (GtkTextMark *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_mark"); 4660 GtkTextMark *mark = (GtkTextMark *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_mark");
4618 4661
4619 tbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tmp)); 4662 tbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tmp));
4620 gtk_text_buffer_get_iter_at_offset(tbuffer, &iter, 0); 4663 gtk_text_buffer_get_iter_at_offset(tbuffer, &iter, 0);
4621 gtk_text_iter_set_line(&iter, line); 4664 gtk_text_iter_set_line(&iter, line);
4622 if(!mark) 4665 if(!mark)
4623 { 4666 {
4624 mark = gtk_text_buffer_create_mark(tbuffer, NULL, &iter, FALSE); 4667 mark = gtk_text_buffer_create_mark(tbuffer, NULL, &iter, FALSE);
4625 gtk_object_set_data(GTK_OBJECT(handle), "_dw_mark", (gpointer)mark); 4668 gtk_object_set_data(GTK_OBJECT(handle), "_dw_mark", (gpointer)mark);
4626 } 4669 }
4627 else 4670 else
4628 gtk_text_buffer_move_mark(tbuffer, mark, &iter); 4671 gtk_text_buffer_move_mark(tbuffer, mark, &iter);
4629 gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(tmp), mark, 4672 gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(tmp), mark,
4630 0, FALSE, 0, 0); 4673 0, FALSE, 0, 0);
4631 } 4674 }
4632 } 4675 }
4633 #else 4676 #else
4634 if(GTK_IS_BOX(handle)) 4677 if(GTK_IS_BOX(handle))
4635 { 4678 {
4636 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 4679 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
4637 4680
4638 if(tmp && GTK_IS_TEXT(tmp)) 4681 if(tmp && GTK_IS_TEXT(tmp))
4639 { 4682 {
4640 unsigned long lines; 4683 unsigned long lines;
4641 float pos, ratio; 4684 float pos, ratio;
4642 4685
4643 dw_mle_get_size(handle, NULL, &lines); 4686 dw_mle_get_size(handle, NULL, &lines);
4644 4687
4645 if(lines) 4688 if(lines)
4646 { 4689 {
4647 ratio = (float)line/(float)lines; 4690 ratio = (float)line/(float)lines;
4648 4691
4649 pos = (ratio * (float)(GTK_TEXT(tmp)->vadj->upper - GTK_TEXT(tmp)->vadj->lower)) + GTK_TEXT(tmp)->vadj->lower; 4692 pos = (ratio * (float)(GTK_TEXT(tmp)->vadj->upper - GTK_TEXT(tmp)->vadj->lower)) + GTK_TEXT(tmp)->vadj->lower;
4650 4693
4651 gtk_adjustment_set_value(GTK_TEXT(tmp)->vadj, pos); 4694 gtk_adjustment_set_value(GTK_TEXT(tmp)->vadj, pos);
4652 } 4695 }
4653 } 4696 }
4654 } 4697 }
4655 #endif 4698 #endif
4656 DW_MUTEX_UNLOCK; 4699 DW_MUTEX_UNLOCK;
4657 } 4700 }
4658 4701
4659 /* 4702 /*
4660 * Sets the editablity of an MLE box. 4703 * Sets the editablity of an MLE box.
4661 * Parameters: 4704 * Parameters:
4662 * handle: Handle to the MLE. 4705 * handle: Handle to the MLE.
4663 * state: TRUE if it can be edited, FALSE for readonly. 4706 * state: TRUE if it can be edited, FALSE for readonly.
4664 */ 4707 */
4665 void dw_mle_set_editable(HWND handle, int state) 4708 void dw_mle_set_editable(HWND handle, int state)
4666 { 4709 {
4667 int _locked_by_me = FALSE; 4710 int _locked_by_me = FALSE;
4668 4711
4669 DW_MUTEX_LOCK; 4712 DW_MUTEX_LOCK;
4670 #if GTK_MAJOR_VERSION > 1 4713 #if GTK_MAJOR_VERSION > 1
4671 if(GTK_IS_SCROLLED_WINDOW(handle)) 4714 if(GTK_IS_SCROLLED_WINDOW(handle))
4672 { 4715 {
4673 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 4716 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
4674 4717
4675 if(tmp && GTK_IS_TEXT_VIEW(tmp)) 4718 if(tmp && GTK_IS_TEXT_VIEW(tmp))
4676 gtk_text_view_set_editable(GTK_TEXT_VIEW(tmp), state); 4719 gtk_text_view_set_editable(GTK_TEXT_VIEW(tmp), state);
4677 } 4720 }
4678 #else 4721 #else
4679 if(GTK_IS_BOX(handle)) 4722 if(GTK_IS_BOX(handle))
4680 { 4723 {
4681 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 4724 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
4682 4725
4683 if(tmp && GTK_IS_TEXT(tmp)) 4726 if(tmp && GTK_IS_TEXT(tmp))
4684 gtk_text_set_editable(GTK_TEXT(tmp), state); 4727 gtk_text_set_editable(GTK_TEXT(tmp), state);
4685 } 4728 }
4686 #endif 4729 #endif
4687 DW_MUTEX_UNLOCK; 4730 DW_MUTEX_UNLOCK;
4688 } 4731 }
4689 4732
4690 /* 4733 /*
4691 * Sets the word wrap state of an MLE box. 4734 * Sets the word wrap state of an MLE box.
4692 * Parameters: 4735 * Parameters:
4693 * handle: Handle to the MLE. 4736 * handle: Handle to the MLE.
4694 * state: TRUE if it wraps, FALSE if it doesn't. 4737 * state: TRUE if it wraps, FALSE if it doesn't.
4695 */ 4738 */
4696 void dw_mle_set_word_wrap(HWND handle, int state) 4739 void dw_mle_set_word_wrap(HWND handle, int state)
4697 { 4740 {
4698 int _locked_by_me = FALSE; 4741 int _locked_by_me = FALSE;
4699 4742
4700 DW_MUTEX_LOCK; 4743 DW_MUTEX_LOCK;
4701 #if GTK_MAJOR_VERSION > 1 4744 #if GTK_MAJOR_VERSION > 1
4702 if(GTK_IS_SCROLLED_WINDOW(handle)) 4745 if(GTK_IS_SCROLLED_WINDOW(handle))
4703 { 4746 {
4704 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 4747 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
4705 4748
4706 if(tmp && GTK_IS_TEXT_VIEW(tmp)) 4749 if(tmp && GTK_IS_TEXT_VIEW(tmp))
4707 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(tmp), GTK_WRAP_WORD); 4750 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(tmp), GTK_WRAP_WORD);
4708 } 4751 }
4709 #else 4752 #else
4710 if(GTK_IS_BOX(handle)) 4753 if(GTK_IS_BOX(handle))
4711 { 4754 {
4712 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 4755 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
4713 4756
4714 if(tmp && GTK_IS_TEXT(tmp)) 4757 if(tmp && GTK_IS_TEXT(tmp))
4715 { 4758 {
4716 gtk_text_set_word_wrap(GTK_TEXT(tmp), state); 4759 gtk_text_set_word_wrap(GTK_TEXT(tmp), state);
4717 gtk_text_set_line_wrap(GTK_TEXT(tmp), state); 4760 gtk_text_set_line_wrap(GTK_TEXT(tmp), state);
4718 } 4761 }
4719 } 4762 }
4720 #endif 4763 #endif
4721 DW_MUTEX_UNLOCK; 4764 DW_MUTEX_UNLOCK;
4722 } 4765 }
4723 4766
4724 /* 4767 /*
4725 * Sets the current cursor position of an MLE box. 4768 * Sets the current cursor position of an MLE box.
4726 * Parameters: 4769 * Parameters:
4727 * handle: Handle to the MLE to be positioned. 4770 * handle: Handle to the MLE to be positioned.
4728 * point: Point to position cursor. 4771 * point: Point to position cursor.
4729 */ 4772 */
4730 void dw_mle_set_cursor(HWND handle, int point) 4773 void dw_mle_set_cursor(HWND handle, int point)
4731 { 4774 {
4732 int _locked_by_me = FALSE; 4775 int _locked_by_me = FALSE;
4733 4776
4734 DW_MUTEX_LOCK; 4777 DW_MUTEX_LOCK;
4735 #if GTK_MAJOR_VERSION > 1 4778 #if GTK_MAJOR_VERSION > 1
4736 if(GTK_IS_SCROLLED_WINDOW(handle)) 4779 if(GTK_IS_SCROLLED_WINDOW(handle))
4737 #else 4780 #else
4738 if(GTK_IS_BOX(handle)) 4781 if(GTK_IS_BOX(handle))
4739 #endif 4782 #endif
4740 { 4783 {
4741 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 4784 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
4742 4785
4743 #if GTK_MAJOR_VERSION > 1 4786 #if GTK_MAJOR_VERSION > 1
4744 if(tmp && GTK_IS_TEXT_VIEW(tmp)) 4787 if(tmp && GTK_IS_TEXT_VIEW(tmp))
4745 { 4788 {
4746 GtkTextBuffer *tbuffer; 4789 GtkTextBuffer *tbuffer;
4747 GtkTextIter iter; 4790 GtkTextIter iter;
4748 GtkTextMark *mark = (GtkTextMark *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_mark"); 4791 GtkTextMark *mark = (GtkTextMark *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_mark");
4749 4792
4750 tbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tmp)); 4793 tbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tmp));
4751 gtk_text_buffer_get_iter_at_offset(tbuffer, &iter, point); 4794 gtk_text_buffer_get_iter_at_offset(tbuffer, &iter, point);
4752 if(!mark) 4795 if(!mark)
4753 { 4796 {
4754 mark = gtk_text_buffer_create_mark(tbuffer, NULL, &iter, FALSE); 4797 mark = gtk_text_buffer_create_mark(tbuffer, NULL, &iter, FALSE);
4755 gtk_object_set_data(GTK_OBJECT(handle), "_dw_mark", (gpointer)mark); 4798 gtk_object_set_data(GTK_OBJECT(handle), "_dw_mark", (gpointer)mark);
4756 } 4799 }
4757 else 4800 else
4758 gtk_text_buffer_move_mark(tbuffer, mark, &iter); 4801 gtk_text_buffer_move_mark(tbuffer, mark, &iter);
4759 gtk_text_buffer_place_cursor(tbuffer, &iter); 4802 gtk_text_buffer_place_cursor(tbuffer, &iter);
4760 gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(tmp), mark, 4803 gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(tmp), mark,
4761 0, FALSE, 0, 0); 4804 0, FALSE, 0, 0);
4762 } 4805 }
4763 #else 4806 #else
4764 if(tmp && GTK_IS_TEXT(tmp)) 4807 if(tmp && GTK_IS_TEXT(tmp))
4765 { 4808 {
4766 unsigned long chars; 4809 unsigned long chars;
4767 float pos, ratio; 4810 float pos, ratio;
4768 4811
4769 dw_mle_get_size(handle, &chars, NULL); 4812 dw_mle_get_size(handle, &chars, NULL);
4770 4813
4771 if(chars) 4814 if(chars)
4772 { 4815 {
4773 ratio = (float)point/(float)chars; 4816 ratio = (float)point/(float)chars;
4774 4817
4775 pos = (ratio * (float)(GTK_TEXT(tmp)->vadj->upper - GTK_TEXT(tmp)->vadj->lower)) + GTK_TEXT(tmp)->vadj->lower; 4818 pos = (ratio * (float)(GTK_TEXT(tmp)->vadj->upper - GTK_TEXT(tmp)->vadj->lower)) + GTK_TEXT(tmp)->vadj->lower;
4776 4819
4777 gtk_adjustment_set_value(GTK_TEXT(tmp)->vadj, pos); 4820 gtk_adjustment_set_value(GTK_TEXT(tmp)->vadj, pos);
4778 } 4821 }
4779 gtk_text_set_point(GTK_TEXT(tmp), point); 4822 gtk_text_set_point(GTK_TEXT(tmp), point);
4780 } 4823 }
4781 #endif 4824 #endif
4782 } 4825 }
4783 DW_MUTEX_UNLOCK; 4826 DW_MUTEX_UNLOCK;
4784 } 4827 }
4785 4828
4786 /* 4829 /*
4787 * Finds text in an MLE box. 4830 * Finds text in an MLE box.
4788 * Parameters: 4831 * Parameters:
4791 * point: Start point of search. 4834 * point: Start point of search.
4792 * flags: Search specific flags. 4835 * flags: Search specific flags.
4793 */ 4836 */
4794 int dw_mle_search(HWND handle, char *text, int point, unsigned long flags) 4837 int dw_mle_search(HWND handle, char *text, int point, unsigned long flags)
4795 { 4838 {
4796 int _locked_by_me = FALSE, retval = 0; 4839 int _locked_by_me = FALSE, retval = 0;
4797 4840
4798 DW_MUTEX_LOCK; 4841 DW_MUTEX_LOCK;
4799 #if GTK_MAJOR_VERSION > 1 4842 #if GTK_MAJOR_VERSION > 1
4800 if(GTK_IS_SCROLLED_WINDOW(handle)) 4843 if(GTK_IS_SCROLLED_WINDOW(handle))
4801 #else 4844 #else
4802 if(GTK_IS_BOX(handle)) 4845 if(GTK_IS_BOX(handle))
4803 #endif 4846 #endif
4804 { 4847 {
4805 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 4848 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
4806 4849
4807 #if GTK_MAJOR_VERSION > 1 4850 #if GTK_MAJOR_VERSION > 1
4808 if(tmp && GTK_IS_TEXT_VIEW(tmp)) 4851 if(tmp && GTK_IS_TEXT_VIEW(tmp))
4809 { 4852 {
4810 GtkTextBuffer *tbuffer; 4853 GtkTextBuffer *tbuffer;
4811 GtkTextIter iter, found; 4854 GtkTextIter iter, found;
4812 4855
4813 tbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tmp)); 4856 tbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tmp));
4814 gtk_text_buffer_get_iter_at_offset(tbuffer, &iter, point); 4857 gtk_text_buffer_get_iter_at_offset(tbuffer, &iter, point);
4815 gtk_text_iter_forward_search(&iter, text, GTK_TEXT_SEARCH_TEXT_ONLY, &found, NULL, NULL); 4858 gtk_text_iter_forward_search(&iter, text, GTK_TEXT_SEARCH_TEXT_ONLY, &found, NULL, NULL);
4816 retval = gtk_text_iter_get_offset(&found); 4859 retval = gtk_text_iter_get_offset(&found);
4817 } 4860 }
4818 #else 4861 #else
4819 if(tmp && GTK_IS_TEXT(tmp)) 4862 if(tmp && GTK_IS_TEXT(tmp))
4820 { 4863 {
4821 int len = gtk_text_get_length(GTK_TEXT(tmp)); 4864 int len = gtk_text_get_length(GTK_TEXT(tmp));
4822 gchar *tmpbuf; 4865 gchar *tmpbuf;
4823 4866
4824 tmpbuf = gtk_editable_get_chars(GTK_EDITABLE(&(GTK_TEXT(tmp)->editable)), 0, len); 4867 tmpbuf = gtk_editable_get_chars(GTK_EDITABLE(&(GTK_TEXT(tmp)->editable)), 0, len);
4825 if(tmpbuf) 4868 if(tmpbuf)
4826 { 4869 {
4827 int z, textlen; 4870 int z, textlen;
4828 4871
4829 textlen = strlen(text); 4872 textlen = strlen(text);
4830 4873
4831 if(flags & DW_MLE_CASESENSITIVE) 4874 if(flags & DW_MLE_CASESENSITIVE)
4832 { 4875 {
4833 for(z=point;z<(len-textlen) && !retval;z++) 4876 for(z=point;z<(len-textlen) && !retval;z++)
4834 { 4877 {
4835 if(strncmp(&tmpbuf[z], text, textlen) == 0) 4878 if(strncmp(&tmpbuf[z], text, textlen) == 0)
4836 retval = z + textlen; 4879 retval = z + textlen;
4837 } 4880 }
4838 } 4881 }
4839 else 4882 else
4840 { 4883 {
4841 for(z=point;z<(len-textlen) && !retval;z++) 4884 for(z=point;z<(len-textlen) && !retval;z++)
4842 { 4885 {
4843 if(strncasecmp(&tmpbuf[z], text, textlen) == 0) 4886 if(strncasecmp(&tmpbuf[z], text, textlen) == 0)
4844 retval = z + textlen; 4887 retval = z + textlen;
4845 } 4888 }
4846 } 4889 }
4847 4890
4848 if(retval) 4891 if(retval)
4849 { 4892 {
4850 gtk_text_set_point(GTK_TEXT(tmp), retval - textlen); 4893 gtk_text_set_point(GTK_TEXT(tmp), retval - textlen);
4851 gtk_editable_select_region(&(GTK_TEXT(tmp)->editable), retval - textlen, retval); 4894 gtk_editable_select_region(&(GTK_TEXT(tmp)->editable), retval - textlen, retval);
4852 } 4895 }
4853 4896
4854 g_free(tmpbuf); 4897 g_free(tmpbuf);
4855 } 4898 }
4856 } 4899 }
4857 #endif 4900 #endif
4858 } 4901 }
4859 DW_MUTEX_UNLOCK; 4902 DW_MUTEX_UNLOCK;
4860 return retval; 4903 return retval;
4861 } 4904 }
4862 4905
4863 /* 4906 /*
4864 * Stops redrawing of an MLE box. 4907 * Stops redrawing of an MLE box.
4865 * Parameters: 4908 * Parameters:
4866 * handle: Handle to the MLE to freeze. 4909 * handle: Handle to the MLE to freeze.
4867 */ 4910 */
4868 void dw_mle_freeze(HWND handle) 4911 void dw_mle_freeze(HWND handle)
4869 { 4912 {
4870 #if GTK_MAJOR_VERSION < 2 4913 #if GTK_MAJOR_VERSION < 2
4871 int _locked_by_me = FALSE; 4914 int _locked_by_me = FALSE;
4872 4915
4873 DW_MUTEX_LOCK; 4916 DW_MUTEX_LOCK;
4874 if(GTK_IS_BOX(handle)) 4917 if(GTK_IS_BOX(handle))
4875 { 4918 {
4876 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 4919 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
4877 4920
4878 if(tmp && GTK_IS_TEXT(tmp)) 4921 if(tmp && GTK_IS_TEXT(tmp))
4879 { 4922 {
4880 gtk_text_freeze(GTK_TEXT(tmp)); 4923 gtk_text_freeze(GTK_TEXT(tmp));
4881 } 4924 }
4882 } 4925 }
4883 DW_MUTEX_UNLOCK; 4926 DW_MUTEX_UNLOCK;
4884 #endif 4927 #endif
4885 } 4928 }
4886 4929
4887 /* 4930 /*
4888 * Resumes redrawing of an MLE box. 4931 * Resumes redrawing of an MLE box.
4890 * handle: Handle to the MLE to thaw. 4933 * handle: Handle to the MLE to thaw.
4891 */ 4934 */
4892 void dw_mle_thaw(HWND handle) 4935 void dw_mle_thaw(HWND handle)
4893 { 4936 {
4894 #if GTK_MAJOR_VERSION < 2 4937 #if GTK_MAJOR_VERSION < 2
4895 int _locked_by_me = FALSE; 4938 int _locked_by_me = FALSE;
4896 4939
4897 DW_MUTEX_LOCK; 4940 DW_MUTEX_LOCK;
4898 if(GTK_IS_BOX(handle)) 4941 if(GTK_IS_BOX(handle))
4899 { 4942 {
4900 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 4943 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
4901 4944
4902 if(tmp && GTK_IS_TEXT(tmp)) 4945 if(tmp && GTK_IS_TEXT(tmp))
4903 { 4946 {
4904 gtk_text_thaw(GTK_TEXT(tmp)); 4947 gtk_text_thaw(GTK_TEXT(tmp));
4905 } 4948 }
4906 } 4949 }
4907 DW_MUTEX_UNLOCK; 4950 DW_MUTEX_UNLOCK;
4908 #endif 4951 #endif
4909 } 4952 }
4910 4953
4911 /* 4954 /*
4912 * Sets the percent bar position. 4955 * Sets the percent bar position.
4914 * handle: Handle to the percent bar to be set. 4957 * handle: Handle to the percent bar to be set.
4915 * position: Position of the percent bar withing the range. 4958 * position: Position of the percent bar withing the range.
4916 */ 4959 */
4917 void dw_percent_set_pos(HWND handle, unsigned int position) 4960 void dw_percent_set_pos(HWND handle, unsigned int position)
4918 { 4961 {
4919 int _locked_by_me = FALSE; 4962 int _locked_by_me = FALSE;
4920 4963
4921 DW_MUTEX_LOCK; 4964 DW_MUTEX_LOCK;
4922 gtk_progress_bar_update(GTK_PROGRESS_BAR(handle), (gfloat)position/100); 4965 gtk_progress_bar_update(GTK_PROGRESS_BAR(handle), (gfloat)position/100);
4923 DW_MUTEX_UNLOCK; 4966 DW_MUTEX_UNLOCK;
4924 } 4967 }
4925 4968
4926 /* 4969 /*
4927 * Returns the position of the slider. 4970 * Returns the position of the slider.
4928 * Parameters: 4971 * Parameters:
4929 * handle: Handle to the slider to be queried. 4972 * handle: Handle to the slider to be queried.
4930 */ 4973 */
4931 unsigned int dw_slider_get_pos(HWND handle) 4974 unsigned int dw_slider_get_pos(HWND handle)
4932 { 4975 {
4933 int val = 0, _locked_by_me = FALSE; 4976 int val = 0, _locked_by_me = FALSE;
4934 GtkAdjustment *adjustment; 4977 GtkAdjustment *adjustment;
4935 4978
4936 if(!handle) 4979 if(!handle)
4937 return 0; 4980 return 0;
4938 4981
4939 DW_MUTEX_LOCK; 4982 DW_MUTEX_LOCK;
4940 adjustment = (GtkAdjustment *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_adjustment"); 4983 adjustment = (GtkAdjustment *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_adjustment");
4941 if(adjustment) 4984 if(adjustment)
4942 { 4985 {
4943 int max = _round_value(adjustment->upper) - 1; 4986 int max = _round_value(adjustment->upper) - 1;
4944 int thisval = _round_value(adjustment->value); 4987 int thisval = _round_value(adjustment->value);
4945 4988
4946 if(GTK_IS_VSCALE(handle)) 4989 if(GTK_IS_VSCALE(handle))
4947 val = max - thisval; 4990 val = max - thisval;
4948 else 4991 else
4949 val = thisval; 4992 val = thisval;
4950 } 4993 }
4951 DW_MUTEX_UNLOCK; 4994 DW_MUTEX_UNLOCK;
4952 return val; 4995 return val;
4953 } 4996 }
4954 4997
4955 /* 4998 /*
4956 * Sets the slider position. 4999 * Sets the slider position.
4957 * Parameters: 5000 * Parameters:
4958 * handle: Handle to the slider to be set. 5001 * handle: Handle to the slider to be set.
4959 * position: Position of the slider withing the range. 5002 * position: Position of the slider withing the range.
4960 */ 5003 */
4961 void dw_slider_set_pos(HWND handle, unsigned int position) 5004 void dw_slider_set_pos(HWND handle, unsigned int position)
4962 { 5005 {
4963 int _locked_by_me = FALSE; 5006 int _locked_by_me = FALSE;
4964 GtkAdjustment *adjustment; 5007 GtkAdjustment *adjustment;
4965 5008
4966 if(!handle) 5009 if(!handle)
4967 return; 5010 return;
4968 5011
4969 DW_MUTEX_LOCK; 5012 DW_MUTEX_LOCK;
4970 adjustment = (GtkAdjustment *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_adjustment"); 5013 adjustment = (GtkAdjustment *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_adjustment");
4971 if(adjustment) 5014 if(adjustment)
4972 { 5015 {
4973 int max = _round_value(adjustment->upper) - 1; 5016 int max = _round_value(adjustment->upper) - 1;
4974 5017
4975 if(GTK_IS_VSCALE(handle)) 5018 if(GTK_IS_VSCALE(handle))
4976 gtk_adjustment_set_value(adjustment, (gfloat)(max - position)); 5019 gtk_adjustment_set_value(adjustment, (gfloat)(max - position));
4977 else 5020 else
4978 gtk_adjustment_set_value(adjustment, (gfloat)position); 5021 gtk_adjustment_set_value(adjustment, (gfloat)position);
4979 } 5022 }
4980 DW_MUTEX_UNLOCK; 5023 DW_MUTEX_UNLOCK;
4981 } 5024 }
4982 5025
4983 /* 5026 /*
4984 * Returns the position of the scrollbar. 5027 * Returns the position of the scrollbar.
4985 * Parameters: 5028 * Parameters:
4986 * handle: Handle to the scrollbar to be queried. 5029 * handle: Handle to the scrollbar to be queried.
4987 */ 5030 */
4988 unsigned int dw_scrollbar_get_pos(HWND handle) 5031 unsigned int dw_scrollbar_get_pos(HWND handle)
4989 { 5032 {
4990 int val = 0, _locked_by_me = FALSE; 5033 int val = 0, _locked_by_me = FALSE;
4991 GtkAdjustment *adjustment; 5034 GtkAdjustment *adjustment;
4992 5035
4993 if(!handle) 5036 if(!handle)
4994 return 0; 5037 return 0;
4995 5038
4996 DW_MUTEX_LOCK; 5039 DW_MUTEX_LOCK;
4997 adjustment = (GtkAdjustment *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_adjustment"); 5040 adjustment = (GtkAdjustment *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_adjustment");
4998 if(adjustment) 5041 if(adjustment)
4999 val = _round_value(adjustment->value); 5042 val = _round_value(adjustment->value);
5000 DW_MUTEX_UNLOCK; 5043 DW_MUTEX_UNLOCK;
5001 return val; 5044 return val;
5002 } 5045 }
5003 5046
5004 /* 5047 /*
5005 * Sets the scrollbar position. 5048 * Sets the scrollbar position.
5006 * Parameters: 5049 * Parameters:
5007 * handle: Handle to the scrollbar to be set. 5050 * handle: Handle to the scrollbar to be set.
5008 * position: Position of the scrollbar withing the range. 5051 * position: Position of the scrollbar withing the range.
5009 */ 5052 */
5010 void dw_scrollbar_set_pos(HWND handle, unsigned int position) 5053 void dw_scrollbar_set_pos(HWND handle, unsigned int position)
5011 { 5054 {
5012 int _locked_by_me = FALSE; 5055 int _locked_by_me = FALSE;
5013 GtkAdjustment *adjustment; 5056 GtkAdjustment *adjustment;
5014 5057
5015 if(!handle) 5058 if(!handle)
5016 return; 5059 return;
5017 5060
5018 DW_MUTEX_LOCK; 5061 DW_MUTEX_LOCK;
5019 adjustment = (GtkAdjustment *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_adjustment"); 5062 adjustment = (GtkAdjustment *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_adjustment");
5020 if(adjustment) 5063 if(adjustment)
5021 gtk_adjustment_set_value(adjustment, (gfloat)position); 5064 gtk_adjustment_set_value(adjustment, (gfloat)position);
5022 DW_MUTEX_UNLOCK; 5065 DW_MUTEX_UNLOCK;
5023 } 5066 }
5024 5067
5025 /* 5068 /*
5026 * Sets the scrollbar range. 5069 * Sets the scrollbar range.
5027 * Parameters: 5070 * Parameters:
5029 * range: Maximum range value. 5072 * range: Maximum range value.
5030 * visible: Visible area relative to the range. 5073 * visible: Visible area relative to the range.
5031 */ 5074 */
5032 void API dw_scrollbar_set_range(HWND handle, unsigned int range, unsigned int visible) 5075 void API dw_scrollbar_set_range(HWND handle, unsigned int range, unsigned int visible)
5033 { 5076 {
5034 int _locked_by_me = FALSE; 5077 int _locked_by_me = FALSE;
5035 GtkAdjustment *adjustment; 5078 GtkAdjustment *adjustment;
5036 5079
5037 if(!handle) 5080 if(!handle)
5038 return; 5081 return;
5039 5082
5040 DW_MUTEX_LOCK; 5083 DW_MUTEX_LOCK;
5041 adjustment = (GtkAdjustment *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_adjustment"); 5084 adjustment = (GtkAdjustment *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_adjustment");
5042 if(adjustment) 5085 if(adjustment)
5043 { 5086 {
5044 adjustment->upper = (gdouble)range; 5087 adjustment->upper = (gdouble)range;
5045 adjustment->page_increment = adjustment->page_size = (gdouble)visible; 5088 adjustment->page_increment = adjustment->page_size = (gdouble)visible;
5046 } 5089 }
5047 DW_MUTEX_UNLOCK; 5090 DW_MUTEX_UNLOCK;
5048 } 5091 }
5049 5092
5050 /* 5093 /*
5051 * Sets the spinbutton value. 5094 * Sets the spinbutton value.
5052 * Parameters: 5095 * Parameters:
5053 * handle: Handle to the spinbutton to be set. 5096 * handle: Handle to the spinbutton to be set.
5054 * position: Current value of the spinbutton. 5097 * position: Current value of the spinbutton.
5055 */ 5098 */
5056 void dw_spinbutton_set_pos(HWND handle, long position) 5099 void dw_spinbutton_set_pos(HWND handle, long position)
5057 { 5100 {
5058 int _locked_by_me = FALSE; 5101 int _locked_by_me = FALSE;
5059 5102
5060 DW_MUTEX_LOCK; 5103 DW_MUTEX_LOCK;
5061 gtk_spin_button_set_value(GTK_SPIN_BUTTON(handle), (gfloat)position); 5104 gtk_spin_button_set_value(GTK_SPIN_BUTTON(handle), (gfloat)position);
5062 DW_MUTEX_UNLOCK; 5105 DW_MUTEX_UNLOCK;
5063 } 5106 }
5064 5107
5065 /* 5108 /*
5066 * Sets the spinbutton limits. 5109 * Sets the spinbutton limits.
5067 * Parameters: 5110 * Parameters:
5069 * position: Current value of the spinbutton. 5112 * position: Current value of the spinbutton.
5070 * position: Current value of the spinbutton. 5113 * position: Current value of the spinbutton.
5071 */ 5114 */
5072 void dw_spinbutton_set_limits(HWND handle, long upper, long lower) 5115 void dw_spinbutton_set_limits(HWND handle, long upper, long lower)
5073 { 5116 {
5074 long curval; 5117 long curval;
5075 GtkAdjustment *adj; 5118 GtkAdjustment *adj;
5076 int _locked_by_me = FALSE; 5119 int _locked_by_me = FALSE;
5077 5120
5078 curval = dw_spinbutton_get_pos(handle); 5121 curval = dw_spinbutton_get_pos(handle);
5079 DW_MUTEX_LOCK; 5122 DW_MUTEX_LOCK;
5080 adj = (GtkAdjustment *)gtk_adjustment_new((gfloat)curval, (gfloat)lower, (gfloat)upper, 1.0, 5.0, 0.0); 5123 adj = (GtkAdjustment *)gtk_adjustment_new((gfloat)curval, (gfloat)lower, (gfloat)upper, 1.0, 5.0, 0.0);
5081 gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON(handle), adj); 5124 gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON(handle), adj);
5082 DW_MUTEX_UNLOCK; 5125 DW_MUTEX_UNLOCK;
5083 } 5126 }
5084 5127
5085 /* 5128 /*
5086 * Sets the entryfield character limit. 5129 * Sets the entryfield character limit.
5087 * Parameters: 5130 * Parameters:
5088 * handle: Handle to the spinbutton to be set. 5131 * handle: Handle to the spinbutton to be set.
5089 * limit: Number of characters the entryfield will take. 5132 * limit: Number of characters the entryfield will take.
5090 */ 5133 */
5091 void dw_entryfield_set_limit(HWND handle, ULONG limit) 5134 void dw_entryfield_set_limit(HWND handle, ULONG limit)
5092 { 5135 {
5093 int _locked_by_me = FALSE; 5136 int _locked_by_me = FALSE;
5094 5137
5095 DW_MUTEX_LOCK; 5138 DW_MUTEX_LOCK;
5096 gtk_entry_set_max_length(GTK_ENTRY(handle), limit); 5139 gtk_entry_set_max_length(GTK_ENTRY(handle), limit);
5097 DW_MUTEX_UNLOCK; 5140 DW_MUTEX_UNLOCK;
5098 } 5141 }
5099 5142
5100 /* 5143 /*
5101 * Returns the current value of the spinbutton. 5144 * Returns the current value of the spinbutton.
5102 * Parameters: 5145 * Parameters:
5103 * handle: Handle to the spinbutton to be queried. 5146 * handle: Handle to the spinbutton to be queried.
5104 */ 5147 */
5105 long dw_spinbutton_get_pos(HWND handle) 5148 long dw_spinbutton_get_pos(HWND handle)
5106 { 5149 {
5107 long retval; 5150 long retval;
5108 int _locked_by_me = FALSE; 5151 int _locked_by_me = FALSE;
5109 5152
5110 DW_MUTEX_LOCK; 5153 DW_MUTEX_LOCK;
5111 retval = (long)gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(handle)); 5154 retval = (long)gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(handle));
5112 DW_MUTEX_UNLOCK; 5155 DW_MUTEX_UNLOCK;
5113 5156
5114 return retval; 5157 return retval;
5115 } 5158 }
5116 5159
5117 /* 5160 /*
5118 * Returns the state of the checkbox. 5161 * Returns the state of the checkbox.
5119 * Parameters: 5162 * Parameters:
5120 * handle: Handle to the checkbox to be queried. 5163 * handle: Handle to the checkbox to be queried.
5121 */ 5164 */
5122 int dw_checkbox_get(HWND handle) 5165 int dw_checkbox_get(HWND handle)
5123 { 5166 {
5124 int retval; 5167 int retval;
5125 int _locked_by_me = FALSE; 5168 int _locked_by_me = FALSE;
5126 5169
5127 DW_MUTEX_LOCK; 5170 DW_MUTEX_LOCK;
5128 retval = GTK_TOGGLE_BUTTON(handle)->active; 5171 retval = GTK_TOGGLE_BUTTON(handle)->active;
5129 DW_MUTEX_UNLOCK; 5172 DW_MUTEX_UNLOCK;
5130 5173
5131 return retval; 5174 return retval;
5132 } 5175 }
5133 5176
5134 /* 5177 /*
5135 * Sets the state of the checkbox. 5178 * Sets the state of the checkbox.
5136 * Parameters: 5179 * Parameters:
5137 * handle: Handle to the checkbox to be queried. 5180 * handle: Handle to the checkbox to be queried.
5138 * value: TRUE for checked, FALSE for unchecked. 5181 * value: TRUE for checked, FALSE for unchecked.
5139 */ 5182 */
5140 void dw_checkbox_set(HWND handle, int value) 5183 void dw_checkbox_set(HWND handle, int value)
5141 { 5184 {
5142 int _locked_by_me = FALSE; 5185 int _locked_by_me = FALSE;
5143 5186
5144 DW_MUTEX_LOCK; 5187 DW_MUTEX_LOCK;
5145 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(handle), value); 5188 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(handle), value);
5146 DW_MUTEX_UNLOCK; 5189 DW_MUTEX_UNLOCK;
5147 } 5190 }
5148 5191
5149 /* 5192 /*
5150 * Inserts an item into a tree window (widget) after another item. 5193 * Inserts an item into a tree window (widget) after another item.
5151 * Parameters: 5194 * Parameters:
5157 * itemdata: Item specific data. 5200 * itemdata: Item specific data.
5158 */ 5201 */
5159 HTREEITEM dw_tree_insert_after(HWND handle, HTREEITEM item, char *title, unsigned long icon, HTREEITEM parent, void *itemdata) 5202 HTREEITEM dw_tree_insert_after(HWND handle, HTREEITEM item, char *title, unsigned long icon, HTREEITEM parent, void *itemdata)
5160 { 5203 {
5161 #if GTK_MAJOR_VERSION > 1 5204 #if GTK_MAJOR_VERSION > 1
5162 GtkWidget *tree; 5205 GtkWidget *tree;
5163 GtkTreeIter *iter; 5206 GtkTreeIter *iter;
5164 GtkTreeStore *store; 5207 GtkTreeStore *store;
5165 GdkPixbuf *pixbuf; 5208 GdkPixbuf *pixbuf;
5166 HTREEITEM retval = 0; 5209 HTREEITEM retval = 0;
5167 int _locked_by_me = FALSE; 5210 int _locked_by_me = FALSE;
5168 5211
5169 if(!handle) 5212 if(!handle)
5170 return NULL; 5213 return NULL;
5171 5214
5172 DW_MUTEX_LOCK; 5215 DW_MUTEX_LOCK;
5173 if((tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle))) 5216 if((tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)))
5174 && GTK_IS_TREE_VIEW(tree) && 5217 && GTK_IS_TREE_VIEW(tree) &&
5175 (store = (GtkTreeStore *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store"))) 5218 (store = (GtkTreeStore *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store")))
5176 { 5219 {
5177 iter = (GtkTreeIter *)malloc(sizeof(GtkTreeIter)); 5220 iter = (GtkTreeIter *)malloc(sizeof(GtkTreeIter));
5178 5221
5179 pixbuf = _find_pixbuf(icon); 5222 pixbuf = _find_pixbuf(icon);
5180 5223
5181 gtk_tree_store_insert_after(store, iter, (GtkTreeIter *)parent, (GtkTreeIter *)item); 5224 gtk_tree_store_insert_after(store, iter, (GtkTreeIter *)parent, (GtkTreeIter *)item);
5182 gtk_tree_store_set (store, iter, 0, title, 1, pixbuf, 2, itemdata, 3, iter, -1); 5225 gtk_tree_store_set (store, iter, 0, title, 1, pixbuf, 2, itemdata, 3, iter, -1);
5183 if(pixbuf && !(icon & (1 << 31))) 5226 if(pixbuf && !(icon & (1 << 31)))
5184 g_object_unref(pixbuf); 5227 g_object_unref(pixbuf);
5185 retval = (HTREEITEM)iter; 5228 retval = (HTREEITEM)iter;
5186 } 5229 }
5187 DW_MUTEX_UNLOCK; 5230 DW_MUTEX_UNLOCK;
5188 5231
5189 return retval; 5232 return retval;
5190 #else 5233 #else
5191 GtkWidget *newitem, *tree, *subtree, *label, *hbox, *pixmap; 5234 GtkWidget *newitem, *tree, *subtree, *label, *hbox, *pixmap;
5192 GdkPixmap *gdkpix; 5235 GdkPixmap *gdkpix;
5193 GdkBitmap *gdkbmp = NULL; 5236 GdkBitmap *gdkbmp = NULL;
5194 int position = -1; 5237 int position = -1;
5195 int _locked_by_me = FALSE; 5238 int _locked_by_me = FALSE;
5196 5239
5197 if(!handle) 5240 if(!handle)
5198 return NULL; 5241 return NULL;
5199 5242
5200 DW_MUTEX_LOCK; 5243 DW_MUTEX_LOCK;
5201 tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 5244 tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
5202 if(!tree || !GTK_IS_TREE(tree)) 5245 if(!tree || !GTK_IS_TREE(tree))
5203 { 5246 {
5204 DW_MUTEX_UNLOCK; 5247 DW_MUTEX_UNLOCK;
5205 return NULL; 5248 return NULL;
5206 } 5249 }
5207 5250
5208 if(item && GTK_IS_TREE_ITEM(item)) 5251 if(item && GTK_IS_TREE_ITEM(item))
5209 position = gtk_tree_child_position(GTK_TREE(tree), item); 5252 position = gtk_tree_child_position(GTK_TREE(tree), item);
5210 5253
5211 position++; 5254 position++;
5212 5255
5213 newitem = gtk_tree_item_new(); 5256 newitem = gtk_tree_item_new();
5214 label = gtk_label_new(title); 5257 label = gtk_label_new(title);
5215 gtk_object_set_data(GTK_OBJECT(newitem), "_dw_text", (gpointer)strdup(title)); 5258 gtk_object_set_data(GTK_OBJECT(newitem), "_dw_text", (gpointer)strdup(title));
5216 gtk_object_set_data(GTK_OBJECT(newitem), "_dw_itemdata", (gpointer)itemdata); 5259 gtk_object_set_data(GTK_OBJECT(newitem), "_dw_itemdata", (gpointer)itemdata);
5217 gtk_object_set_data(GTK_OBJECT(newitem), "_dw_tree", (gpointer)tree); 5260 gtk_object_set_data(GTK_OBJECT(newitem), "_dw_tree", (gpointer)tree);
5218 gtk_object_set_data(GTK_OBJECT(newitem), "_dw_parent", (gpointer)parent); 5261 gtk_object_set_data(GTK_OBJECT(newitem), "_dw_parent", (gpointer)parent);
5219 hbox = gtk_hbox_new(FALSE, 2); 5262 hbox = gtk_hbox_new(FALSE, 2);
5220 gtk_object_set_data(GTK_OBJECT(newitem), "_dw_hbox", (gpointer)hbox); 5263 gtk_object_set_data(GTK_OBJECT(newitem), "_dw_hbox", (gpointer)hbox);
5221 gdkpix = _find_pixmap(&gdkbmp, icon, hbox, NULL, NULL); 5264 gdkpix = _find_pixmap(&gdkbmp, icon, hbox, NULL, NULL);
5222 gtk_container_add(GTK_CONTAINER(newitem), hbox); 5265 gtk_container_add(GTK_CONTAINER(newitem), hbox);
5223 if(gdkpix) 5266 if(gdkpix)
5224 { 5267 {
5225 pixmap = gtk_pixmap_new(gdkpix, gdkbmp); 5268 pixmap = gtk_pixmap_new(gdkpix, gdkbmp);
5226 gtk_box_pack_start(GTK_BOX(hbox), pixmap, FALSE, TRUE, 0); 5269 gtk_box_pack_start(GTK_BOX(hbox), pixmap, FALSE, TRUE, 0);
5227 gtk_widget_show(pixmap); 5270 gtk_widget_show(pixmap);
5228 } 5271 }
5229 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0); 5272 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
5230 gtk_widget_show(label); 5273 gtk_widget_show(label);
5231 gtk_widget_show(hbox); 5274 gtk_widget_show(hbox);
5232 5275
5233 { 5276 {
5234 void *thisfunc = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_item_expand_func"); 5277 void *thisfunc = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_item_expand_func");
5235 void *mydata = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_item_expand_data"); 5278 void *mydata = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_item_expand_data");
5236 SignalHandler work = _get_signal_handler(tree, mydata); 5279 SignalHandler work = _get_signal_handler(tree, mydata);
5237 5280
5238 if(thisfunc && work.window) 5281 if(thisfunc && work.window)
5239 { 5282 {
5240 int sigid = _set_signal_handler(newitem, work.window, work.func, work.data, thisfunc); 5283 int sigid = _set_signal_handler(newitem, work.window, work.func, work.data, thisfunc);
5241 gint cid =gtk_signal_connect(GTK_OBJECT(newitem), "expand", GTK_SIGNAL_FUNC(thisfunc),(gpointer)sigid); 5284 gint cid =gtk_signal_connect(GTK_OBJECT(newitem), "expand", GTK_SIGNAL_FUNC(thisfunc),(gpointer)sigid);
5242 _set_signal_handler_id(newitem, sigid, cid); 5285 _set_signal_handler_id(newitem, sigid, cid);
5243 } 5286 }
5244 } 5287 }
5245 5288
5246 _dw_ignore_expand = 1; 5289 _dw_ignore_expand = 1;
5247 if(parent) 5290 if(parent)
5248 { 5291 {
5249 subtree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(parent)); 5292 subtree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(parent));
5250 if(!subtree || !GTK_IS_TREE(subtree)) 5293 if(!subtree || !GTK_IS_TREE(subtree))
5251 { 5294 {
5252 void *thisfunc = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_select_child_func"); 5295 void *thisfunc = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_select_child_func");
5253 void *mydata = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_select_child_data"); 5296 void *mydata = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_select_child_data");
5254 SignalHandler work = _get_signal_handler(tree, mydata); 5297 SignalHandler work = _get_signal_handler(tree, mydata);
5255 5298
5256 subtree = gtk_tree_new(); 5299 subtree = gtk_tree_new();
5257 5300
5258 if(thisfunc && work.window) 5301 if(thisfunc && work.window)
5259 { 5302 {
5260 int sigid = _set_signal_handler(subtree, work.window, work.func, work.data, thisfunc); 5303 int sigid = _set_signal_handler(subtree, work.window, work.func, work.data, thisfunc);
5261 gint cid =gtk_signal_connect(GTK_OBJECT(subtree), "select-child", GTK_SIGNAL_FUNC(thisfunc),(gpointer)sigid); 5304 gint cid =gtk_signal_connect(GTK_OBJECT(subtree), "select-child", GTK_SIGNAL_FUNC(thisfunc),(gpointer)sigid);
5262 _set_signal_handler_id(subtree, sigid, cid); 5305 _set_signal_handler_id(subtree, sigid, cid);
5263 } 5306 }
5264 5307
5265 thisfunc = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_container_context_func"); 5308 thisfunc = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_container_context_func");
5266 mydata = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_container_context_data"); 5309 mydata = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_container_context_data");
5267 work = _get_signal_handler(tree, mydata); 5310 work = _get_signal_handler(tree, mydata);
5268 5311
5269 if(thisfunc && work.window) 5312 if(thisfunc && work.window)
5270 { 5313 {
5271 int sigid = _set_signal_handler(subtree, work.window, work.func, work.data, thisfunc); 5314 int sigid = _set_signal_handler(subtree, work.window, work.func, work.data, thisfunc);
5272 gint cid =gtk_signal_connect(GTK_OBJECT(subtree), "button_press_event", GTK_SIGNAL_FUNC(thisfunc),(gpointer)sigid); 5315 gint cid =gtk_signal_connect(GTK_OBJECT(subtree), "button_press_event", GTK_SIGNAL_FUNC(thisfunc),(gpointer)sigid);
5273 _set_signal_handler_id(subtree, sigid, cid); 5316 _set_signal_handler_id(subtree, sigid, cid);
5274 } 5317 }
5275 5318
5276 gtk_object_set_user_data(GTK_OBJECT(parent), subtree); 5319 gtk_object_set_user_data(GTK_OBJECT(parent), subtree);
5277 gtk_tree_set_selection_mode(GTK_TREE(subtree), GTK_SELECTION_SINGLE); 5320 gtk_tree_set_selection_mode(GTK_TREE(subtree), GTK_SELECTION_SINGLE);
5278 gtk_tree_set_view_mode(GTK_TREE(subtree), GTK_TREE_VIEW_ITEM); 5321 gtk_tree_set_view_mode(GTK_TREE(subtree), GTK_TREE_VIEW_ITEM);
5279 gtk_tree_item_set_subtree(GTK_TREE_ITEM(parent), subtree); 5322 gtk_tree_item_set_subtree(GTK_TREE_ITEM(parent), subtree);
5280 gtk_object_set_data(GTK_OBJECT(subtree), "_dw_parentitem", (gpointer)parent); 5323 gtk_object_set_data(GTK_OBJECT(subtree), "_dw_parentitem", (gpointer)parent);
5281 gtk_tree_item_collapse(GTK_TREE_ITEM(parent)); 5324 gtk_tree_item_collapse(GTK_TREE_ITEM(parent));
5282 gtk_widget_show(subtree); 5325 gtk_widget_show(subtree);
5283 gtk_tree_item_expand(GTK_TREE_ITEM(parent)); 5326 gtk_tree_item_expand(GTK_TREE_ITEM(parent));
5284 gtk_tree_item_collapse(GTK_TREE_ITEM(parent)); 5327 gtk_tree_item_collapse(GTK_TREE_ITEM(parent));
5285 } 5328 }
5286 gtk_object_set_data(GTK_OBJECT(newitem), "_dw_parenttree", (gpointer)subtree); 5329 gtk_object_set_data(GTK_OBJECT(newitem), "_dw_parenttree", (gpointer)subtree);
5287 gtk_tree_insert(GTK_TREE(subtree), newitem, position); 5330 gtk_tree_insert(GTK_TREE(subtree), newitem, position);
5288 } 5331 }
5289 else 5332 else
5290 { 5333 {
5291 gtk_object_set_data(GTK_OBJECT(newitem), "_dw_parenttree", (gpointer)tree); 5334 gtk_object_set_data(GTK_OBJECT(newitem), "_dw_parenttree", (gpointer)tree);
5292 gtk_tree_insert(GTK_TREE(tree), newitem, position); 5335 gtk_tree_insert(GTK_TREE(tree), newitem, position);
5293 } 5336 }
5294 gtk_tree_item_expand(GTK_TREE_ITEM(newitem)); 5337 gtk_tree_item_expand(GTK_TREE_ITEM(newitem));
5295 gtk_tree_item_collapse(GTK_TREE_ITEM(newitem)); 5338 gtk_tree_item_collapse(GTK_TREE_ITEM(newitem));
5296 gtk_widget_show(newitem); 5339 gtk_widget_show(newitem);
5297 _dw_ignore_expand = 0; 5340 _dw_ignore_expand = 0;
5298 DW_MUTEX_UNLOCK; 5341 DW_MUTEX_UNLOCK;
5299 return (HTREEITEM)newitem; 5342 return (HTREEITEM)newitem;
5300 #endif 5343 #endif
5301 } 5344 }
5302 5345
5303 /* 5346 /*
5304 * Inserts an item into a tree window (widget). 5347 * Inserts an item into a tree window (widget).
5310 * itemdata: Item specific data. 5353 * itemdata: Item specific data.
5311 */ 5354 */
5312 HTREEITEM dw_tree_insert(HWND handle, char *title, unsigned long icon, HTREEITEM parent, void *itemdata) 5355 HTREEITEM dw_tree_insert(HWND handle, char *title, unsigned long icon, HTREEITEM parent, void *itemdata)
5313 { 5356 {
5314 #if GTK_MAJOR_VERSION > 1 5357 #if GTK_MAJOR_VERSION > 1
5315 GtkWidget *tree; 5358 GtkWidget *tree;
5316 GtkTreeIter *iter; 5359 GtkTreeIter *iter;
5317 GtkTreeStore *store; 5360 GtkTreeStore *store;
5318 GdkPixbuf *pixbuf; 5361 GdkPixbuf *pixbuf;
5319 HTREEITEM retval = 0; 5362 HTREEITEM retval = 0;
5320 int _locked_by_me = FALSE; 5363 int _locked_by_me = FALSE;
5321 5364
5322 if(!handle) 5365 if(!handle)
5323 return NULL; 5366 return NULL;
5324 5367
5325 DW_MUTEX_LOCK; 5368 DW_MUTEX_LOCK;
5326 if((tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle))) 5369 if((tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)))
5327 && GTK_IS_TREE_VIEW(tree) && 5370 && GTK_IS_TREE_VIEW(tree) &&
5328 (store = (GtkTreeStore *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store"))) 5371 (store = (GtkTreeStore *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store")))
5329 { 5372 {
5330 iter = (GtkTreeIter *)malloc(sizeof(GtkTreeIter)); 5373 iter = (GtkTreeIter *)malloc(sizeof(GtkTreeIter));
5331 5374
5332 pixbuf = _find_pixbuf(icon); 5375 pixbuf = _find_pixbuf(icon);
5333 5376
5334 gtk_tree_store_append (store, iter, (GtkTreeIter *)parent); 5377 gtk_tree_store_append (store, iter, (GtkTreeIter *)parent);
5335 gtk_tree_store_set (store, iter, 0, title, 1, pixbuf, 2, itemdata, 3, iter, -1); 5378 gtk_tree_store_set (store, iter, 0, title, 1, pixbuf, 2, itemdata, 3, iter, -1);
5336 if(pixbuf && !(icon & (1 << 31))) 5379 if(pixbuf && !(icon & (1 << 31)))
5337 g_object_unref(pixbuf); 5380 g_object_unref(pixbuf);
5338 retval = (HTREEITEM)iter; 5381 retval = (HTREEITEM)iter;
5339 } 5382 }
5340 DW_MUTEX_UNLOCK; 5383 DW_MUTEX_UNLOCK;
5341 5384
5342 return retval; 5385 return retval;
5343 #else 5386 #else
5344 GtkWidget *item, *tree, *subtree, *label, *hbox, *pixmap; 5387 GtkWidget *item, *tree, *subtree, *label, *hbox, *pixmap;
5345 GdkPixmap *gdkpix; 5388 GdkPixmap *gdkpix;
5346 GdkBitmap *gdkbmp = NULL; 5389 GdkBitmap *gdkbmp = NULL;
5347 int _locked_by_me = FALSE; 5390 int _locked_by_me = FALSE;
5348 5391
5349 if(!handle) 5392 if(!handle)
5350 return NULL; 5393 return NULL;
5351 5394
5352 DW_MUTEX_LOCK; 5395 DW_MUTEX_LOCK;
5353 tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 5396 tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
5354 if(!tree || !GTK_IS_TREE(tree)) 5397 if(!tree || !GTK_IS_TREE(tree))
5355 { 5398 {
5356 DW_MUTEX_UNLOCK; 5399 DW_MUTEX_UNLOCK;
5357 return NULL; 5400 return NULL;
5358 } 5401 }
5359 item = gtk_tree_item_new(); 5402 item = gtk_tree_item_new();
5360 label = gtk_label_new(title); 5403 label = gtk_label_new(title);
5361 gtk_object_set_data(GTK_OBJECT(item), "_dw_text", (gpointer)strdup(title)); 5404 gtk_object_set_data(GTK_OBJECT(item), "_dw_text", (gpointer)strdup(title));
5362 gtk_object_set_data(GTK_OBJECT(item), "_dw_itemdata", (gpointer)itemdata); 5405 gtk_object_set_data(GTK_OBJECT(item), "_dw_itemdata", (gpointer)itemdata);
5363 gtk_object_set_data(GTK_OBJECT(item), "_dw_tree", (gpointer)tree); 5406 gtk_object_set_data(GTK_OBJECT(item), "_dw_tree", (gpointer)tree);
5364 gtk_object_set_data(GTK_OBJECT(item), "_dw_parent", (gpointer)parent); 5407 gtk_object_set_data(GTK_OBJECT(item), "_dw_parent", (gpointer)parent);
5365 hbox = gtk_hbox_new(FALSE, 2); 5408 hbox = gtk_hbox_new(FALSE, 2);
5366 gtk_object_set_data(GTK_OBJECT(item), "_dw_hbox", (gpointer)hbox); 5409 gtk_object_set_data(GTK_OBJECT(item), "_dw_hbox", (gpointer)hbox);
5367 gdkpix = _find_pixmap(&gdkbmp, icon, hbox, NULL, NULL); 5410 gdkpix = _find_pixmap(&gdkbmp, icon, hbox, NULL, NULL);
5368 gtk_container_add(GTK_CONTAINER(item), hbox); 5411 gtk_container_add(GTK_CONTAINER(item), hbox);
5369 if(gdkpix) 5412 if(gdkpix)
5370 { 5413 {
5371 pixmap = gtk_pixmap_new(gdkpix, gdkbmp); 5414 pixmap = gtk_pixmap_new(gdkpix, gdkbmp);
5372 gtk_box_pack_start(GTK_BOX(hbox), pixmap, FALSE, TRUE, 0); 5415 gtk_box_pack_start(GTK_BOX(hbox), pixmap, FALSE, TRUE, 0);
5373 gtk_widget_show(pixmap); 5416 gtk_widget_show(pixmap);
5374 } 5417 }
5375 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0); 5418 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
5376 gtk_widget_show(label); 5419 gtk_widget_show(label);
5377 gtk_widget_show(hbox); 5420 gtk_widget_show(hbox);
5378 5421
5379 { 5422 {
5380 void *thisfunc = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_item_expand_func"); 5423 void *thisfunc = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_item_expand_func");
5381 void *mydata = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_item_expand_data"); 5424 void *mydata = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_item_expand_data");
5382 SignalHandler work = _get_signal_handler(tree, mydata); 5425 SignalHandler work = _get_signal_handler(tree, mydata);
5383 5426
5384 if(thisfunc && work.window) 5427 if(thisfunc && work.window)
5385 { 5428 {
5386 int sigid = _set_signal_handler(item, work.window, work.func, work.data, thisfunc); 5429 int sigid = _set_signal_handler(item, work.window, work.func, work.data, thisfunc);
5387 gint cid =gtk_signal_connect(GTK_OBJECT(item), "expand", GTK_SIGNAL_FUNC(thisfunc),(gpointer)sigid); 5430 gint cid =gtk_signal_connect(GTK_OBJECT(item), "expand", GTK_SIGNAL_FUNC(thisfunc),(gpointer)sigid);
5388 _set_signal_handler_id(item, sigid, cid); 5431 _set_signal_handler_id(item, sigid, cid);
5389 } 5432 }
5390 } 5433 }
5391 5434
5392 _dw_ignore_expand = 1; 5435 _dw_ignore_expand = 1;
5393 if(parent) 5436 if(parent)
5394 { 5437 {
5395 subtree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(parent)); 5438 subtree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(parent));
5396 if(!subtree || !GTK_IS_TREE(subtree)) 5439 if(!subtree || !GTK_IS_TREE(subtree))
5397 { 5440 {
5398 void *thisfunc = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_select_child_func"); 5441 void *thisfunc = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_select_child_func");
5399 void *mydata = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_select_child_data"); 5442 void *mydata = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_select_child_data");
5400 SignalHandler work = _get_signal_handler(tree, mydata); 5443 SignalHandler work = _get_signal_handler(tree, mydata);
5401 5444
5402 subtree = gtk_tree_new(); 5445 subtree = gtk_tree_new();
5403 5446
5404 if(thisfunc && work.window) 5447 if(thisfunc && work.window)
5405 { 5448 {
5406 int sigid = _set_signal_handler(subtree, work.window, work.func, work.data, thisfunc); 5449 int sigid = _set_signal_handler(subtree, work.window, work.func, work.data, thisfunc);
5407 gint cid =gtk_signal_connect(GTK_OBJECT(subtree), "select-child", GTK_SIGNAL_FUNC(thisfunc),(gpointer)sigid); 5450 gint cid =gtk_signal_connect(GTK_OBJECT(subtree), "select-child", GTK_SIGNAL_FUNC(thisfunc),(gpointer)sigid);
5408 _set_signal_handler_id(subtree, sigid, cid); 5451 _set_signal_handler_id(subtree, sigid, cid);
5409 } 5452 }
5410 5453
5411 thisfunc = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_container_context_func"); 5454 thisfunc = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_container_context_func");
5412 mydata = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_container_context_data"); 5455 mydata = (void *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_container_context_data");
5413 work = _get_signal_handler(tree, mydata); 5456 work = _get_signal_handler(tree, mydata);
5414 5457
5415 if(thisfunc && work.window) 5458 if(thisfunc && work.window)
5416 { 5459 {
5417 int sigid = _set_signal_handler(subtree, work.window, work.func, work.data, thisfunc); 5460 int sigid = _set_signal_handler(subtree, work.window, work.func, work.data, thisfunc);
5418 gint cid =gtk_signal_connect(GTK_OBJECT(subtree), "button_press_event", GTK_SIGNAL_FUNC(thisfunc),(gpointer)sigid); 5461 gint cid =gtk_signal_connect(GTK_OBJECT(subtree), "button_press_event", GTK_SIGNAL_FUNC(thisfunc),(gpointer)sigid);
5419 _set_signal_handler_id(subtree, sigid, cid); 5462 _set_signal_handler_id(subtree, sigid, cid);
5420 } 5463 }
5421 5464
5422 gtk_object_set_user_data(GTK_OBJECT(parent), subtree); 5465 gtk_object_set_user_data(GTK_OBJECT(parent), subtree);
5423 gtk_tree_set_selection_mode(GTK_TREE(subtree), GTK_SELECTION_SINGLE); 5466 gtk_tree_set_selection_mode(GTK_TREE(subtree), GTK_SELECTION_SINGLE);
5424 gtk_tree_set_view_mode(GTK_TREE(subtree), GTK_TREE_VIEW_ITEM); 5467 gtk_tree_set_view_mode(GTK_TREE(subtree), GTK_TREE_VIEW_ITEM);
5425 gtk_tree_item_set_subtree(GTK_TREE_ITEM(parent), subtree); 5468 gtk_tree_item_set_subtree(GTK_TREE_ITEM(parent), subtree);
5426 gtk_object_set_data(GTK_OBJECT(subtree), "_dw_parentitem", (gpointer)parent); 5469 gtk_object_set_data(GTK_OBJECT(subtree), "_dw_parentitem", (gpointer)parent);
5427 gtk_tree_item_collapse(GTK_TREE_ITEM(parent)); 5470 gtk_tree_item_collapse(GTK_TREE_ITEM(parent));
5428 gtk_widget_show(subtree); 5471 gtk_widget_show(subtree);
5429 gtk_tree_item_expand(GTK_TREE_ITEM(parent)); 5472 gtk_tree_item_expand(GTK_TREE_ITEM(parent));
5430 gtk_tree_item_collapse(GTK_TREE_ITEM(parent)); 5473 gtk_tree_item_collapse(GTK_TREE_ITEM(parent));
5431 } 5474 }
5432 gtk_object_set_data(GTK_OBJECT(item), "_dw_parenttree", (gpointer)subtree); 5475 gtk_object_set_data(GTK_OBJECT(item), "_dw_parenttree", (gpointer)subtree);
5433 gtk_tree_append(GTK_TREE(subtree), item); 5476 gtk_tree_append(GTK_TREE(subtree), item);
5434 } 5477 }
5435 else 5478 else
5436 { 5479 {
5437 gtk_object_set_data(GTK_OBJECT(item), "_dw_parenttree", (gpointer)tree); 5480 gtk_object_set_data(GTK_OBJECT(item), "_dw_parenttree", (gpointer)tree);
5438 gtk_tree_append(GTK_TREE(tree), item); 5481 gtk_tree_append(GTK_TREE(tree), item);
5439 } 5482 }
5440 gtk_tree_item_expand(GTK_TREE_ITEM(item)); 5483 gtk_tree_item_expand(GTK_TREE_ITEM(item));
5441 gtk_tree_item_collapse(GTK_TREE_ITEM(item)); 5484 gtk_tree_item_collapse(GTK_TREE_ITEM(item));
5442 gtk_widget_show(item); 5485 gtk_widget_show(item);
5443 _dw_ignore_expand = 0; 5486 _dw_ignore_expand = 0;
5444 DW_MUTEX_UNLOCK; 5487 DW_MUTEX_UNLOCK;
5445 return (HTREEITEM)item; 5488 return (HTREEITEM)item;
5446 #endif 5489 #endif
5447 } 5490 }
5448 5491
5449 /* 5492 /*
5450 * Sets the text and icon of an item in a tree window (widget). 5493 * Sets the text and icon of an item in a tree window (widget).
5455 * icon: Handle to coresponding icon. 5498 * icon: Handle to coresponding icon.
5456 */ 5499 */
5457 void dw_tree_item_change(HWND handle, HTREEITEM item, char *title, unsigned long icon) 5500 void dw_tree_item_change(HWND handle, HTREEITEM item, char *title, unsigned long icon)
5458 { 5501 {
5459 #if GTK_MAJOR_VERSION > 1 5502 #if GTK_MAJOR_VERSION > 1
5460 GtkWidget *tree; 5503 GtkWidget *tree;
5461 GtkTreeStore *store; 5504 GtkTreeStore *store;
5462 GdkPixbuf *pixbuf; 5505 GdkPixbuf *pixbuf;
5463 int _locked_by_me = FALSE; 5506 int _locked_by_me = FALSE;
5464 5507
5465 if(!handle) 5508 if(!handle)
5466 return; 5509 return;
5467 5510
5468 DW_MUTEX_LOCK; 5511 DW_MUTEX_LOCK;
5469 if((tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle))) 5512 if((tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)))
5470 && GTK_IS_TREE_VIEW(tree) && 5513 && GTK_IS_TREE_VIEW(tree) &&
5471 (store = (GtkTreeStore *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store"))) 5514 (store = (GtkTreeStore *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store")))
5472 { 5515 {
5473 pixbuf = _find_pixbuf(icon); 5516 pixbuf = _find_pixbuf(icon);
5474 5517
5475 gtk_tree_store_set(store, (GtkTreeIter *)item, 0, title, 1, pixbuf, -1); 5518 gtk_tree_store_set(store, (GtkTreeIter *)item, 0, title, 1, pixbuf, -1);
5476 if(pixbuf && !(icon & (1 << 31))) 5519 if(pixbuf && !(icon & (1 << 31)))
5477 g_object_unref(pixbuf); 5520 g_object_unref(pixbuf);
5478 } 5521 }
5479 DW_MUTEX_UNLOCK; 5522 DW_MUTEX_UNLOCK;
5480 #else 5523 #else
5481 GtkWidget *label, *hbox, *pixmap; 5524 GtkWidget *label, *hbox, *pixmap;
5482 GdkPixmap *gdkpix; 5525 GdkPixmap *gdkpix;
5483 GdkBitmap *gdkbmp = NULL; 5526 GdkBitmap *gdkbmp = NULL;
5484 char *oldtext; 5527 char *oldtext;
5485 int _locked_by_me = FALSE; 5528 int _locked_by_me = FALSE;
5486 5529
5487 if(!handle || !item) 5530 if(!handle || !item)
5488 return; 5531 return;
5489 5532
5490 DW_MUTEX_LOCK; 5533 DW_MUTEX_LOCK;
5491 oldtext = (char *)gtk_object_get_data(GTK_OBJECT(item), "_dw_text"); 5534 oldtext = (char *)gtk_object_get_data(GTK_OBJECT(item), "_dw_text");
5492 if(oldtext) 5535 if(oldtext)
5493 free(oldtext); 5536 free(oldtext);
5494 label = gtk_label_new(title); 5537 label = gtk_label_new(title);
5495 gtk_object_set_data(GTK_OBJECT(item), "_dw_text", (gpointer)strdup(title)); 5538 gtk_object_set_data(GTK_OBJECT(item), "_dw_text", (gpointer)strdup(title));
5496 hbox = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(item), "_dw_hbox"); 5539 hbox = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(item), "_dw_hbox");
5497 gtk_widget_destroy(hbox); 5540 gtk_widget_destroy(hbox);
5498 hbox = gtk_hbox_new(FALSE, 2); 5541 hbox = gtk_hbox_new(FALSE, 2);
5499 gtk_object_set_data(GTK_OBJECT(item), "_dw_hbox", (gpointer)hbox); 5542 gtk_object_set_data(GTK_OBJECT(item), "_dw_hbox", (gpointer)hbox);
5500 gdkpix = _find_pixmap(&gdkbmp, icon, hbox, NULL, NULL); 5543 gdkpix = _find_pixmap(&gdkbmp, icon, hbox, NULL, NULL);
5501 gtk_container_add(GTK_CONTAINER(item), hbox); 5544 gtk_container_add(GTK_CONTAINER(item), hbox);
5502 if(gdkpix) 5545 if(gdkpix)
5503 { 5546 {
5504 pixmap = gtk_pixmap_new(gdkpix, gdkbmp); 5547 pixmap = gtk_pixmap_new(gdkpix, gdkbmp);
5505 gtk_box_pack_start(GTK_BOX(hbox), pixmap, FALSE, TRUE, 0); 5548 gtk_box_pack_start(GTK_BOX(hbox), pixmap, FALSE, TRUE, 0);
5506 gtk_widget_show(pixmap); 5549 gtk_widget_show(pixmap);
5507 } 5550 }
5508 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0); 5551 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
5509 gtk_widget_show(label); 5552 gtk_widget_show(label);
5510 gtk_widget_show(hbox); 5553 gtk_widget_show(hbox);
5511 DW_MUTEX_UNLOCK; 5554 DW_MUTEX_UNLOCK;
5512 #endif 5555 #endif
5513 } 5556 }
5514 5557
5515 /* 5558 /*
5516 * Sets the item data of a tree item. 5559 * Sets the item data of a tree item.
5520 * itemdata: User defined data to be associated with item. 5563 * itemdata: User defined data to be associated with item.
5521 */ 5564 */
5522 void dw_tree_item_set_data(HWND handle, HTREEITEM item, void *itemdata) 5565 void dw_tree_item_set_data(HWND handle, HTREEITEM item, void *itemdata)
5523 { 5566 {
5524 #if GTK_MAJOR_VERSION > 1 5567 #if GTK_MAJOR_VERSION > 1
5525 GtkWidget *tree; 5568 GtkWidget *tree;
5526 GtkTreeStore *store; 5569 GtkTreeStore *store;
5527 int _locked_by_me = FALSE; 5570 int _locked_by_me = FALSE;
5528 5571
5529 if(!handle || !item) 5572 if(!handle || !item)
5530 return; 5573 return;
5531 5574
5532 DW_MUTEX_LOCK; 5575 DW_MUTEX_LOCK;
5533 if((tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle))) 5576 if((tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)))
5534 && GTK_IS_TREE_VIEW(tree) && 5577 && GTK_IS_TREE_VIEW(tree) &&
5535 (store = (GtkTreeStore *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store"))) 5578 (store = (GtkTreeStore *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store")))
5536 gtk_tree_store_set(store, (GtkTreeIter *)item, 2, itemdata, -1); 5579 gtk_tree_store_set(store, (GtkTreeIter *)item, 2, itemdata, -1);
5537 DW_MUTEX_UNLOCK; 5580 DW_MUTEX_UNLOCK;
5538 #else 5581 #else
5539 int _locked_by_me = FALSE; 5582 int _locked_by_me = FALSE;
5540 5583
5541 if(!handle || !item) 5584 if(!handle || !item)
5542 return; 5585 return;
5543 5586
5544 DW_MUTEX_LOCK; 5587 DW_MUTEX_LOCK;
5545 gtk_object_set_data(GTK_OBJECT(item), "_dw_itemdata", (gpointer)itemdata); 5588 gtk_object_set_data(GTK_OBJECT(item), "_dw_itemdata", (gpointer)itemdata);
5546 DW_MUTEX_UNLOCK; 5589 DW_MUTEX_UNLOCK;
5547 #endif 5590 #endif
5548 } 5591 }
5549 5592
5550 /* 5593 /*
5551 * Gets the text an item in a tree window (widget). 5594 * Gets the text an item in a tree window (widget).
5553 * handle: Handle to the tree containing the item. 5596 * handle: Handle to the tree containing the item.
5554 * item: Handle of the item to be modified. 5597 * item: Handle of the item to be modified.
5555 */ 5598 */
5556 char * API dw_tree_get_title(HWND handle, HTREEITEM item) 5599 char * API dw_tree_get_title(HWND handle, HTREEITEM item)
5557 { 5600 {
5558 int _locked_by_me = FALSE; 5601 int _locked_by_me = FALSE;
5559 char *text = NULL; 5602 char *text = NULL;
5560 #if GTK_MAJOR_VERSION > 1 5603 #if GTK_MAJOR_VERSION > 1
5561 GtkWidget *tree; 5604 GtkWidget *tree;
5562 GtkTreeModel *store; 5605 GtkTreeModel *store;
5563 #endif 5606 #endif
5564 5607
5565 if(!handle || !item) 5608 if(!handle || !item)
5566 return text; 5609 return text;
5567 5610
5568 DW_MUTEX_LOCK; 5611 DW_MUTEX_LOCK;
5569 #if GTK_MAJOR_VERSION > 1 5612 #if GTK_MAJOR_VERSION > 1
5570 tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 5613 tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
5571 5614
5572 if(tree && GTK_IS_TREE_VIEW(tree) && 5615 if(tree && GTK_IS_TREE_VIEW(tree) &&
5573 (store = (GtkTreeModel *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store"))) 5616 (store = (GtkTreeModel *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store")))
5574 gtk_tree_model_get(store, (GtkTreeIter *)item, 0, &text, -1); 5617 gtk_tree_model_get(store, (GtkTreeIter *)item, 0, &text, -1);
5575 #else 5618 #else
5576 text = (char *)gtk_object_get_data(GTK_OBJECT(item), "_dw_text"); 5619 text = (char *)gtk_object_get_data(GTK_OBJECT(item), "_dw_text");
5577 #endif 5620 #endif
5578 DW_MUTEX_UNLOCK; 5621 DW_MUTEX_UNLOCK;
5579 return text; 5622 return text;
5580 } 5623 }
5581 5624
5582 /* 5625 /*
5583 * Gets the text an item in a tree window (widget). 5626 * Gets the text an item in a tree window (widget).
5584 * Parameters: 5627 * Parameters:
5585 * handle: Handle to the tree containing the item. 5628 * handle: Handle to the tree containing the item.
5586 * item: Handle of the item to be modified. 5629 * item: Handle of the item to be modified.
5587 */ 5630 */
5588 HTREEITEM API dw_tree_get_parent(HWND handle, HTREEITEM item) 5631 HTREEITEM API dw_tree_get_parent(HWND handle, HTREEITEM item)
5589 { 5632 {
5590 int _locked_by_me = FALSE; 5633 int _locked_by_me = FALSE;
5591 HTREEITEM parent = (HTREEITEM)0; 5634 HTREEITEM parent = (HTREEITEM)0;
5592 #if GTK_MAJOR_VERSION > 1 5635 #if GTK_MAJOR_VERSION > 1
5593 GtkWidget *tree; 5636 GtkWidget *tree;
5594 GtkTreeModel *store; 5637 GtkTreeModel *store;
5595 #endif 5638 #endif
5596 5639
5597 if(!handle || !item) 5640 if(!handle || !item)
5598 return parent; 5641 return parent;
5599 5642
5600 DW_MUTEX_LOCK; 5643 DW_MUTEX_LOCK;
5601 #if GTK_MAJOR_VERSION > 1 5644 #if GTK_MAJOR_VERSION > 1
5602 tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 5645 tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
5603 5646
5604 if(tree && GTK_IS_TREE_VIEW(tree) && 5647 if(tree && GTK_IS_TREE_VIEW(tree) &&
5605 (store = (GtkTreeModel *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store"))) 5648 (store = (GtkTreeModel *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store")))
5606 { 5649 {
5607 GtkTreeIter *p = malloc(sizeof(GtkTreeIter)); 5650 GtkTreeIter *p = malloc(sizeof(GtkTreeIter));
5608 5651
5609 if(gtk_tree_model_iter_parent(store, p, (GtkTreeIter *)item)) 5652 if(gtk_tree_model_iter_parent(store, p, (GtkTreeIter *)item))
5610 parent = p; 5653 parent = p;
5611 else 5654 else
5612 free(p); 5655 free(p);
5613 } 5656 }
5614 #else 5657 #else
5615 parent = (HTREEITEM)gtk_object_get_data(GTK_OBJECT(item), "_dw_parent"); 5658 parent = (HTREEITEM)gtk_object_get_data(GTK_OBJECT(item), "_dw_parent");
5616 #endif 5659 #endif
5617 DW_MUTEX_UNLOCK; 5660 DW_MUTEX_UNLOCK;
5618 return parent; 5661 return parent;
5619 } 5662 }
5620 5663
5621 /* 5664 /*
5622 * Gets the item data of a tree item. 5665 * Gets the item data of a tree item.
5623 * Parameters: 5666 * Parameters:
5624 * handle: Handle to the tree containing the item. 5667 * handle: Handle to the tree containing the item.
5625 * item: Handle of the item to be modified. 5668 * item: Handle of the item to be modified.
5626 */ 5669 */
5627 void *dw_tree_item_get_data(HWND handle, HTREEITEM item) 5670 void *dw_tree_item_get_data(HWND handle, HTREEITEM item)
5628 { 5671 {
5629 void *ret = NULL; 5672 void *ret = NULL;
5630 #if GTK_MAJOR_VERSION > 1 5673 #if GTK_MAJOR_VERSION > 1
5631 GtkWidget *tree; 5674 GtkWidget *tree;
5632 GtkTreeModel *store; 5675 GtkTreeModel *store;
5633 int _locked_by_me = FALSE; 5676 int _locked_by_me = FALSE;
5634 5677
5635 if(!handle || !item) 5678 if(!handle || !item)
5636 return NULL; 5679 return NULL;
5637 5680
5638 DW_MUTEX_LOCK; 5681 DW_MUTEX_LOCK;
5639 if((tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle))) 5682 if((tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)))
5640 && GTK_IS_TREE_VIEW(tree) && 5683 && GTK_IS_TREE_VIEW(tree) &&
5641 (store = (GtkTreeModel *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store"))) 5684 (store = (GtkTreeModel *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store")))
5642 gtk_tree_model_get(store, (GtkTreeIter *)item, 2, &ret, -1); 5685 gtk_tree_model_get(store, (GtkTreeIter *)item, 2, &ret, -1);
5643 DW_MUTEX_UNLOCK; 5686 DW_MUTEX_UNLOCK;
5644 #else 5687 #else
5645 int _locked_by_me = FALSE; 5688 int _locked_by_me = FALSE;
5646 5689
5647 if(!handle || !item) 5690 if(!handle || !item)
5648 return NULL; 5691 return NULL;
5649 5692
5650 DW_MUTEX_LOCK; 5693 DW_MUTEX_LOCK;
5651 ret = (void *)gtk_object_get_data(GTK_OBJECT(item), "_dw_itemdata"); 5694 ret = (void *)gtk_object_get_data(GTK_OBJECT(item), "_dw_itemdata");
5652 DW_MUTEX_UNLOCK; 5695 DW_MUTEX_UNLOCK;
5653 #endif 5696 #endif
5654 return ret; 5697 return ret;
5655 } 5698 }
5656 5699
5657 /* 5700 /*
5658 * Sets this item as the active selection. 5701 * Sets this item as the active selection.
5659 * Parameters: 5702 * Parameters:
5661 * item: Handle to the item to be selected. 5704 * item: Handle to the item to be selected.
5662 */ 5705 */
5663 void dw_tree_item_select(HWND handle, HTREEITEM item) 5706 void dw_tree_item_select(HWND handle, HTREEITEM item)
5664 { 5707 {
5665 #if GTK_MAJOR_VERSION > 1 5708 #if GTK_MAJOR_VERSION > 1
5666 GtkWidget *tree; 5709 GtkWidget *tree;
5667 GtkTreeStore *store; 5710 GtkTreeStore *store;
5668 int _locked_by_me = FALSE; 5711 int _locked_by_me = FALSE;
5669 5712
5670 if(!handle || !item) 5713 if(!handle || !item)
5671 return; 5714 return;
5672 5715
5673 DW_MUTEX_LOCK; 5716 DW_MUTEX_LOCK;
5674 if((tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle))) 5717 if((tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)))
5675 && GTK_IS_TREE_VIEW(tree) && 5718 && GTK_IS_TREE_VIEW(tree) &&
5676 (store = (GtkTreeStore *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store"))) 5719 (store = (GtkTreeStore *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store")))
5677 { 5720 {
5678 GtkTreePath *path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), (GtkTreeIter *)item); 5721 GtkTreePath *path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), (GtkTreeIter *)item);
5679 GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); 5722 GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
5680 5723
5681 gtk_tree_view_set_cursor(GTK_TREE_VIEW(tree), path, NULL, FALSE); 5724 gtk_tree_view_set_cursor(GTK_TREE_VIEW(tree), path, NULL, FALSE);
5682 gtk_tree_selection_select_iter(sel, (GtkTreeIter *)item); 5725 gtk_tree_selection_select_iter(sel, (GtkTreeIter *)item);
5683 gtk_tree_path_free(path); 5726 gtk_tree_path_free(path);
5684 } 5727 }
5685 DW_MUTEX_UNLOCK; 5728 DW_MUTEX_UNLOCK;
5686 #else 5729 #else
5687 GtkWidget *lastselect, *tree; 5730 GtkWidget *lastselect, *tree;
5688 int _locked_by_me = FALSE; 5731 int _locked_by_me = FALSE;
5689 5732
5690 if(!handle || !item) 5733 if(!handle || !item)
5691 return; 5734 return;
5692 5735
5693 DW_MUTEX_LOCK; 5736 DW_MUTEX_LOCK;
5694 tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 5737 tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
5695 lastselect = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_lastselect"); 5738 lastselect = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_lastselect");
5696 if(lastselect && GTK_IS_TREE_ITEM(lastselect)) 5739 if(lastselect && GTK_IS_TREE_ITEM(lastselect))
5697 gtk_tree_item_deselect(GTK_TREE_ITEM(lastselect)); 5740 gtk_tree_item_deselect(GTK_TREE_ITEM(lastselect));
5698 gtk_tree_item_select(GTK_TREE_ITEM(item)); 5741 gtk_tree_item_select(GTK_TREE_ITEM(item));
5699 gtk_object_set_data(GTK_OBJECT(tree), "_dw_lastselect", (gpointer)item); 5742 gtk_object_set_data(GTK_OBJECT(tree), "_dw_lastselect", (gpointer)item);
5700 DW_MUTEX_UNLOCK; 5743 DW_MUTEX_UNLOCK;
5701 #endif 5744 #endif
5702 } 5745 }
5703 5746
5704 #if GTK_MAJOR_VERSION > 1 5747 #if GTK_MAJOR_VERSION > 1
5705 static void _dw_recursive_free(GtkTreeModel *store, GtkTreeIter parent) 5748 static void _dw_recursive_free(GtkTreeModel *store, GtkTreeIter parent)
5706 { 5749 {
5707 void *data; 5750 void *data;
5708 GtkTreeIter iter; 5751 GtkTreeIter iter;
5709 5752
5710 gtk_tree_model_get(store, &parent, 3, &data, -1); 5753 gtk_tree_model_get(store, &parent, 3, &data, -1);
5711 if(data) 5754 if(data)
5712 free(data); 5755 free(data);
5713 gtk_tree_store_set(GTK_TREE_STORE(store), &parent, 3, NULL, -1); 5756 gtk_tree_store_set(GTK_TREE_STORE(store), &parent, 3, NULL, -1);
5714 5757
5715 if(gtk_tree_model_iter_children(store, &iter, &parent)) 5758 if(gtk_tree_model_iter_children(store, &iter, &parent))
5716 { 5759 {
5717 do { 5760 do {
5718 _dw_recursive_free(GTK_TREE_MODEL(store), iter); 5761 _dw_recursive_free(GTK_TREE_MODEL(store), iter);
5719 } while(gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter)); 5762 } while(gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter));
5720 } 5763 }
5721 } 5764 }
5722 #endif 5765 #endif
5723 5766
5724 /* 5767 /*
5725 * Removes all nodes from a tree. 5768 * Removes all nodes from a tree.
5727 * handle: Handle to the window (widget) to be cleared. 5770 * handle: Handle to the window (widget) to be cleared.
5728 */ 5771 */
5729 void dw_tree_clear(HWND handle) 5772 void dw_tree_clear(HWND handle)
5730 { 5773 {
5731 #if GTK_MAJOR_VERSION > 1 5774 #if GTK_MAJOR_VERSION > 1
5732 GtkWidget *tree; 5775 GtkWidget *tree;
5733 GtkTreeStore *store; 5776 GtkTreeStore *store;
5734 int _locked_by_me = FALSE; 5777 int _locked_by_me = FALSE;
5735 5778
5736 if(!handle) 5779 if(!handle)
5737 return; 5780 return;
5738 5781
5739 DW_MUTEX_LOCK; 5782 DW_MUTEX_LOCK;
5740 if((tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle))) 5783 if((tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)))
5741 && GTK_IS_TREE_VIEW(tree) && 5784 && GTK_IS_TREE_VIEW(tree) &&
5742 (store = (GtkTreeStore *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store"))) 5785 (store = (GtkTreeStore *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store")))
5743 { 5786 {
5744 GtkTreeIter iter; 5787 GtkTreeIter iter;
5745 5788
5746 if(gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter)) 5789 if(gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter))
5747 { 5790 {
5748 do { 5791 do {
5749 _dw_recursive_free(GTK_TREE_MODEL(store), iter); 5792 _dw_recursive_free(GTK_TREE_MODEL(store), iter);
5750 } while(gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter)); 5793 } while(gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter));
5751 } 5794 }
5752 gtk_tree_store_clear(store); 5795 gtk_tree_store_clear(store);
5753 } 5796 }
5754 DW_MUTEX_UNLOCK; 5797 DW_MUTEX_UNLOCK;
5755 #else 5798 #else
5756 GtkWidget *tree; 5799 GtkWidget *tree;
5757 int _locked_by_me = FALSE; 5800 int _locked_by_me = FALSE;
5758 5801
5759 if(!handle) 5802 if(!handle)
5760 return; 5803 return;
5761 5804
5762 DW_MUTEX_LOCK; 5805 DW_MUTEX_LOCK;
5763 tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 5806 tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
5764 if(!tree || !GTK_IS_TREE(tree)) 5807 if(!tree || !GTK_IS_TREE(tree))
5765 { 5808 {
5766 DW_MUTEX_UNLOCK; 5809 DW_MUTEX_UNLOCK;
5767 return; 5810 return;
5768 } 5811 }
5769 gtk_object_set_data(GTK_OBJECT(tree), "_dw_lastselect", NULL); 5812 gtk_object_set_data(GTK_OBJECT(tree), "_dw_lastselect", NULL);
5770 gtk_tree_clear_items(GTK_TREE(tree), 0, 1000000); 5813 gtk_tree_clear_items(GTK_TREE(tree), 0, 1000000);
5771 DW_MUTEX_UNLOCK; 5814 DW_MUTEX_UNLOCK;
5772 #endif 5815 #endif
5773 } 5816 }
5774 5817
5775 /* 5818 /*
5776 * Expands a node on a tree. 5819 * Expands a node on a tree.
5779 * item: Handle to node to be expanded. 5822 * item: Handle to node to be expanded.
5780 */ 5823 */
5781 void dw_tree_item_expand(HWND handle, HTREEITEM item) 5824 void dw_tree_item_expand(HWND handle, HTREEITEM item)
5782 { 5825 {
5783 #if GTK_MAJOR_VERSION > 1 5826 #if GTK_MAJOR_VERSION > 1
5784 GtkWidget *tree; 5827 GtkWidget *tree;
5785 GtkTreeStore *store; 5828 GtkTreeStore *store;
5786 int _locked_by_me = FALSE; 5829 int _locked_by_me = FALSE;
5787 5830
5788 if(!handle) 5831 if(!handle)
5789 return; 5832 return;
5790 5833
5791 DW_MUTEX_LOCK; 5834 DW_MUTEX_LOCK;
5792 if((tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle))) 5835 if((tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)))
5793 && GTK_IS_TREE_VIEW(tree) && 5836 && GTK_IS_TREE_VIEW(tree) &&
5794 (store = (GtkTreeStore *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store"))) 5837 (store = (GtkTreeStore *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store")))
5795 { 5838 {
5796 GtkTreePath *path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), (GtkTreeIter *)item); 5839 GtkTreePath *path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), (GtkTreeIter *)item);
5797 gtk_tree_view_expand_row(GTK_TREE_VIEW(tree), path, FALSE); 5840 gtk_tree_view_expand_row(GTK_TREE_VIEW(tree), path, FALSE);
5798 gtk_tree_path_free(path); 5841 gtk_tree_path_free(path);
5799 } 5842 }
5800 DW_MUTEX_UNLOCK; 5843 DW_MUTEX_UNLOCK;
5801 #else 5844 #else
5802 int _locked_by_me = FALSE; 5845 int _locked_by_me = FALSE;
5803 5846
5804 if(!handle || !item) 5847 if(!handle || !item)
5805 return; 5848 return;
5806 5849
5807 DW_MUTEX_LOCK; 5850 DW_MUTEX_LOCK;
5808 _dw_ignore_expand = 1; 5851 _dw_ignore_expand = 1;
5809 if(GTK_IS_TREE_ITEM(item)) 5852 if(GTK_IS_TREE_ITEM(item))
5810 gtk_tree_item_expand(GTK_TREE_ITEM(item)); 5853 gtk_tree_item_expand(GTK_TREE_ITEM(item));
5811 _dw_ignore_expand = 0; 5854 _dw_ignore_expand = 0;
5812 DW_MUTEX_UNLOCK; 5855 DW_MUTEX_UNLOCK;
5813 #endif 5856 #endif
5814 } 5857 }
5815 5858
5816 /* 5859 /*
5817 * Collapses a node on a tree. 5860 * Collapses a node on a tree.
5820 * item: Handle to node to be collapsed. 5863 * item: Handle to node to be collapsed.
5821 */ 5864 */
5822 void dw_tree_item_collapse(HWND handle, HTREEITEM item) 5865 void dw_tree_item_collapse(HWND handle, HTREEITEM item)
5823 { 5866 {
5824 #if GTK_MAJOR_VERSION > 1 5867 #if GTK_MAJOR_VERSION > 1
5825 GtkWidget *tree; 5868 GtkWidget *tree;
5826 GtkTreeStore *store; 5869 GtkTreeStore *store;
5827 int _locked_by_me = FALSE; 5870 int _locked_by_me = FALSE;
5828 5871
5829 if(!handle) 5872 if(!handle)
5830 return; 5873 return;
5831 5874
5832 DW_MUTEX_LOCK; 5875 DW_MUTEX_LOCK;
5833 if((tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle))) 5876 if((tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)))
5834 && GTK_IS_TREE_VIEW(tree) && 5877 && GTK_IS_TREE_VIEW(tree) &&
5835 (store = (GtkTreeStore *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store"))) 5878 (store = (GtkTreeStore *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store")))
5836 { 5879 {
5837 GtkTreePath *path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), (GtkTreeIter *)item); 5880 GtkTreePath *path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), (GtkTreeIter *)item);
5838 gtk_tree_view_collapse_row(GTK_TREE_VIEW(tree), path); 5881 gtk_tree_view_collapse_row(GTK_TREE_VIEW(tree), path);
5839 gtk_tree_path_free(path); 5882 gtk_tree_path_free(path);
5840 } 5883 }
5841 DW_MUTEX_UNLOCK; 5884 DW_MUTEX_UNLOCK;
5842 #else 5885 #else
5843 int _locked_by_me = FALSE; 5886 int _locked_by_me = FALSE;
5844 5887
5845 if(!handle || !item) 5888 if(!handle || !item)
5846 return; 5889 return;
5847 5890
5848 DW_MUTEX_LOCK; 5891 DW_MUTEX_LOCK;
5849 if(GTK_IS_TREE_ITEM(item)) 5892 if(GTK_IS_TREE_ITEM(item))
5850 gtk_tree_item_collapse(GTK_TREE_ITEM(item)); 5893 gtk_tree_item_collapse(GTK_TREE_ITEM(item));
5851 DW_MUTEX_UNLOCK; 5894 DW_MUTEX_UNLOCK;
5852 #endif 5895 #endif
5853 } 5896 }
5854 5897
5855 /* 5898 /*
5856 * Removes a node from a tree. 5899 * Removes a node from a tree.
5859 * item: Handle to node to be deleted. 5902 * item: Handle to node to be deleted.
5860 */ 5903 */
5861 void dw_tree_item_delete(HWND handle, HTREEITEM item) 5904 void dw_tree_item_delete(HWND handle, HTREEITEM item)
5862 { 5905 {
5863 #if GTK_MAJOR_VERSION > 1 5906 #if GTK_MAJOR_VERSION > 1
5864 GtkWidget *tree; 5907 GtkWidget *tree;
5865 GtkTreeStore *store; 5908 GtkTreeStore *store;
5866 int _locked_by_me = FALSE; 5909 int _locked_by_me = FALSE;
5867 5910
5868 if(!handle) 5911 if(!handle)
5869 return; 5912 return;
5870 5913
5871 DW_MUTEX_LOCK; 5914 DW_MUTEX_LOCK;
5872 if((tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle))) 5915 if((tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)))
5873 && GTK_IS_TREE_VIEW(tree) && 5916 && GTK_IS_TREE_VIEW(tree) &&
5874 (store = (GtkTreeStore *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store"))) 5917 (store = (GtkTreeStore *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_tree_store")))
5875 { 5918 {
5876 gtk_tree_store_remove(store, (GtkTreeIter *)item); 5919 gtk_tree_store_remove(store, (GtkTreeIter *)item);
5877 free(item); 5920 free(item);
5878 } 5921 }
5879 DW_MUTEX_UNLOCK; 5922 DW_MUTEX_UNLOCK;
5880 #else 5923 #else
5881 GtkWidget *tree, *lastselect, *parenttree; 5924 GtkWidget *tree, *lastselect, *parenttree;
5882 int _locked_by_me = FALSE; 5925 int _locked_by_me = FALSE;
5883 5926
5884 if(!handle || !item || !GTK_IS_WIDGET(handle) || !GTK_IS_WIDGET(item)) 5927 if(!handle || !item || !GTK_IS_WIDGET(handle) || !GTK_IS_WIDGET(item))
5885 return; 5928 return;
5886 5929
5887 DW_MUTEX_LOCK; 5930 DW_MUTEX_LOCK;
5888 tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 5931 tree = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
5889 if(!tree || !GTK_IS_TREE(tree)) 5932 if(!tree || !GTK_IS_TREE(tree))
5890 { 5933 {
5891 DW_MUTEX_UNLOCK; 5934 DW_MUTEX_UNLOCK;
5892 return; 5935 return;
5893 } 5936 }
5894 5937
5895 lastselect = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_lastselect"); 5938 lastselect = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(tree), "_dw_lastselect");
5896 5939
5897 parenttree = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(item), "_dw_parenttree"); 5940 parenttree = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(item), "_dw_parenttree");
5898 5941
5899 if(lastselect == item) 5942 if(lastselect == item)
5900 { 5943 {
5901 gtk_tree_item_deselect(GTK_TREE_ITEM(lastselect)); 5944 gtk_tree_item_deselect(GTK_TREE_ITEM(lastselect));
5902 gtk_object_set_data(GTK_OBJECT(tree), "_dw_lastselect", NULL); 5945 gtk_object_set_data(GTK_OBJECT(tree), "_dw_lastselect", NULL);
5903 } 5946 }
5904 5947
5905 if(parenttree && GTK_IS_WIDGET(parenttree)) 5948 if(parenttree && GTK_IS_WIDGET(parenttree))
5906 gtk_container_remove(GTK_CONTAINER(parenttree), item); 5949 gtk_container_remove(GTK_CONTAINER(parenttree), item);
5907 DW_MUTEX_UNLOCK; 5950 DW_MUTEX_UNLOCK;
5908 #endif 5951 #endif
5909 } 5952 }
5910 5953
5911 static int _dw_container_setup(HWND handle, unsigned long *flags, char **titles, int count, int separator, int extra) 5954 static int _dw_container_setup(HWND handle, unsigned long *flags, char **titles, int count, int separator, int extra)
5912 { 5955 {
5913 GtkWidget *clist; 5956 GtkWidget *clist;
5914 char numbuf[10]; 5957 char numbuf[10];
5915 int z, multi; 5958 int z, multi;
5916 int _locked_by_me = FALSE; 5959 int _locked_by_me = FALSE;
5917 GtkJustification justification; 5960 GtkJustification justification;
5918 5961
5919 DW_MUTEX_LOCK; 5962 DW_MUTEX_LOCK;
5920 clist = gtk_clist_new_with_titles(count, (gchar **)titles); 5963 clist = gtk_clist_new_with_titles(count, (gchar **)titles);
5921 if(!clist) 5964 if(!clist)
5922 { 5965 {
5923 DW_MUTEX_UNLOCK; 5966 DW_MUTEX_UNLOCK;
5924 return FALSE; 5967 return FALSE;
5925 } 5968 }
5926 multi = (int)gtk_object_get_data(GTK_OBJECT(handle), "_dw_multi"); 5969 multi = (int)gtk_object_get_data(GTK_OBJECT(handle), "_dw_multi");
5927 gtk_object_set_data(GTK_OBJECT(handle), "_dw_multi", (gpointer)multi); 5970 gtk_object_set_data(GTK_OBJECT(handle), "_dw_multi", GINT_TO_POINTER(multi));
5928 5971
5929 gtk_clist_set_column_auto_resize(GTK_CLIST(clist), 0, TRUE); 5972 gtk_clist_set_column_auto_resize(GTK_CLIST(clist), 0, TRUE);
5930 if(multi) 5973 if(multi)
5931 gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_EXTENDED); 5974 gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_EXTENDED);
5932 else 5975 else
5933 gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_SINGLE); 5976 gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_SINGLE);
5934 gtk_container_add(GTK_CONTAINER(handle), clist); 5977 gtk_container_add(GTK_CONTAINER(handle), clist);
5935 gtk_object_set_user_data(GTK_OBJECT(handle), (gpointer)clist); 5978 gtk_object_set_user_data(GTK_OBJECT(handle), (gpointer)clist);
5936 gtk_widget_show(clist); 5979 gtk_widget_show(clist);
5937 gtk_object_set_data(GTK_OBJECT(clist), "_dw_colcount", (gpointer)count); 5980 gtk_object_set_data(GTK_OBJECT(clist), "_dw_colcount", GINT_TO_POINTER(count));
5938 5981
5939 if(extra) 5982 if(extra)
5940 gtk_clist_set_column_width(GTK_CLIST(clist), 1, 120); 5983 gtk_clist_set_column_width(GTK_CLIST(clist), 1, 120);
5941 5984
5942 for(z=0;z<count;z++) 5985 for(z=0;z<count;z++)
5943 { 5986 {
5944 if(!extra || z > 1) 5987 if(!extra || z > 1)
5945 gtk_clist_set_column_width(GTK_CLIST(clist), z, 50); 5988 gtk_clist_set_column_width(GTK_CLIST(clist), z, 50);
5946 sprintf(numbuf, "%d", z); 5989 sprintf(numbuf, "%d", z);
5947 gtk_object_set_data(GTK_OBJECT(clist), numbuf, (gpointer)flags[z]); 5990 gtk_object_set_data(GTK_OBJECT(clist), numbuf, GINT_TO_POINTER(flags[z]));
5948 if(flags[z]&DW_CFA_RIGHT) 5991 if(flags[z]&DW_CFA_RIGHT)
5949 justification = GTK_JUSTIFY_RIGHT; 5992 justification = GTK_JUSTIFY_RIGHT;
5950 else if(flags[z]&DW_CFA_CENTER) 5993 else if(flags[z]&DW_CFA_CENTER)
5951 justification = GTK_JUSTIFY_CENTER; 5994 justification = GTK_JUSTIFY_CENTER;
5952 else 5995 else
5953 justification = GTK_JUSTIFY_LEFT; 5996 justification = GTK_JUSTIFY_LEFT;
5954 gtk_clist_set_column_justification(GTK_CLIST(clist),z,justification); 5997 gtk_clist_set_column_justification(GTK_CLIST(clist),z,justification);
5955 } 5998 }
5956 5999
5957 DW_MUTEX_UNLOCK; 6000 DW_MUTEX_UNLOCK;
5958 return TRUE; 6001 return TRUE;
5959 } 6002 }
5960 6003
5961 /* 6004 /*
5962 * Sets up the container columns. 6005 * Sets up the container columns.
5963 * Parameters: 6006 * Parameters:
5968 * separator: The column number that contains the main separator. 6011 * separator: The column number that contains the main separator.
5969 * (this item may only be used in OS/2) 6012 * (this item may only be used in OS/2)
5970 */ 6013 */
5971 int dw_container_setup(HWND handle, unsigned long *flags, char **titles, int count, int separator) 6014 int dw_container_setup(HWND handle, unsigned long *flags, char **titles, int count, int separator)
5972 { 6015 {
5973 return _dw_container_setup(handle, flags, titles, count, separator, 0); 6016 return _dw_container_setup(handle, flags, titles, count, separator, 0);
5974 } 6017 }
5975 6018
5976 /* 6019 /*
5977 * Sets up the filesystem columns, note: filesystem always has an icon/filename field. 6020 * Sets up the filesystem columns, note: filesystem always has an icon/filename field.
5978 * Parameters: 6021 * Parameters:
5981 * titles: An array of strings with column text titles. 6024 * titles: An array of strings with column text titles.
5982 * count: The number of columns (this should match the arrays). 6025 * count: The number of columns (this should match the arrays).
5983 */ 6026 */
5984 int dw_filesystem_setup(HWND handle, unsigned long *flags, char **titles, int count) 6027 int dw_filesystem_setup(HWND handle, unsigned long *flags, char **titles, int count)
5985 { 6028 {
5986 char **newtitles = malloc(sizeof(char *) * (count + 1)); 6029 char **newtitles = malloc(sizeof(char *) * (count + 1));
5987 unsigned long *newflags = malloc(sizeof(unsigned long) * (count + 1)); 6030 unsigned long *newflags = malloc(sizeof(unsigned long) * (count + 1));
5988 6031
5989 newtitles[0] = "Filename"; 6032 newtitles[0] = "Filename";
5990 6033
5991 newflags[0] = DW_CFA_STRINGANDICON | DW_CFA_LEFT | DW_CFA_HORZSEPARATOR; 6034 newflags[0] = DW_CFA_STRINGANDICON | DW_CFA_LEFT | DW_CFA_HORZSEPARATOR;
5992 6035
5993 memcpy(&newtitles[1], titles, sizeof(char *) * count); 6036 memcpy(&newtitles[1], titles, sizeof(char *) * count);
5994 memcpy(&newflags[1], flags, sizeof(unsigned long) * count); 6037 memcpy(&newflags[1], flags, sizeof(unsigned long) * count);
5995 6038
5996 _dw_container_setup(handle, newflags, newtitles, count + 1, 1, 1); 6039 _dw_container_setup(handle, newflags, newtitles, count + 1, 1, 1);
5997 6040
5998 free(newtitles); 6041 free(newtitles);
5999 free(newflags); 6042 free(newflags);
6000 return TRUE; 6043 return TRUE;
6001 } 6044 }
6002 6045
6003 /* 6046 /*
6004 * Obtains an icon from a module (or header in GTK). 6047 * Obtains an icon from a module (or header in GTK).
6005 * Parameters: 6048 * Parameters:
6008 * Windows, on GTK this is converted to a pointer 6051 * Windows, on GTK this is converted to a pointer
6009 * to an embedded XPM. 6052 * to an embedded XPM.
6010 */ 6053 */
6011 unsigned long dw_icon_load(unsigned long module, unsigned long id) 6054 unsigned long dw_icon_load(unsigned long module, unsigned long id)
6012 { 6055 {
6013 return id; 6056 return id;
6014 } 6057 }
6015 6058
6016 /* 6059 /*
6017 * Obtains an icon from a file. 6060 * Obtains an icon from a file.
6018 * Parameters: 6061 * Parameters:
6221 * Parameters: 6264 * Parameters:
6222 * handle: Handle to icon returned by dw_icon_load(). 6265 * handle: Handle to icon returned by dw_icon_load().
6223 */ 6266 */
6224 void dw_icon_free(unsigned long handle) 6267 void dw_icon_free(unsigned long handle)
6225 { 6268 {
6226 /* If it is a private icon, find the item 6269 /* If it is a private icon, find the item
6227 * free the associated structures and set 6270 * free the associated structures and set
6228 * the entry to unused. 6271 * the entry to unused.
6229 */ 6272 */
6230 if(handle & (1 << 31)) 6273 if(handle & (1 << 31))
6231 { 6274 {
6232 unsigned long id = handle & 0xFFFFFF; 6275 unsigned long id = handle & 0xFFFFFF;
6233 6276
6234 if(id < _PixmapCount && _PixmapArray[id].used) 6277 if(id < _PixmapCount && _PixmapArray[id].used)
6235 { 6278 {
6236 #if GTK_MAJOR_VERSION > 1 6279 #if GTK_MAJOR_VERSION > 1
6237 if(_PixmapArray[id].pixbuf) 6280 if(_PixmapArray[id].pixbuf)
6238 { 6281 {
6239 g_object_unref(_PixmapArray[id].pixbuf); 6282 g_object_unref(_PixmapArray[id].pixbuf);
6240 _PixmapArray[id].pixbuf = NULL; 6283 _PixmapArray[id].pixbuf = NULL;
6241 } 6284 }
6242 #endif 6285 #endif
6243 if(_PixmapArray[id].mask) 6286 if(_PixmapArray[id].mask)
6244 { 6287 {
6245 gdk_bitmap_unref(_PixmapArray[id].mask); 6288 gdk_bitmap_unref(_PixmapArray[id].mask);
6246 _PixmapArray[id].mask = NULL; 6289 _PixmapArray[id].mask = NULL;
6247 } 6290 }
6248 if(_PixmapArray[id].pixmap) 6291 if(_PixmapArray[id].pixmap)
6249 { 6292 {
6250 gdk_pixmap_unref(_PixmapArray[id].pixmap); 6293 gdk_pixmap_unref(_PixmapArray[id].pixmap);
6251 _PixmapArray[id].pixmap = NULL; 6294 _PixmapArray[id].pixmap = NULL;
6252 } 6295 }
6253 _PixmapArray[id].used = 0; 6296 _PixmapArray[id].used = 0;
6254 } 6297 }
6255 } 6298 }
6256 } 6299 }
6257 6300
6258 /* Clears a CList selection and associated selection list */ 6301 /* Clears a CList selection and associated selection list */
6259 void _dw_unselect(GtkWidget *clist) 6302 void _dw_unselect(GtkWidget *clist)
6260 { 6303 {
6261 gtk_clist_unselect_all(GTK_CLIST(clist)); 6304 gtk_clist_unselect_all(GTK_CLIST(clist));
6262 } 6305 }
6263 6306
6264 /* 6307 /*
6265 * Allocates memory used to populate a container. 6308 * Allocates memory used to populate a container.
6266 * Parameters: 6309 * Parameters:
6267 * handle: Handle to the container window (widget). 6310 * handle: Handle to the container window (widget).
6268 * rowcount: The number of items to be populated. 6311 * rowcount: The number of items to be populated.
6269 */ 6312 */
6270 void *dw_container_alloc(HWND handle, int rowcount) 6313 void *dw_container_alloc(HWND handle, int rowcount)
6271 { 6314 {
6272 int z, count = 0, prevrowcount = 0; 6315 int z, count = 0, prevrowcount = 0;
6273 GtkWidget *clist; 6316 GtkWidget *clist;
6274 GdkColor *fore, *back; 6317 GdkColor *fore, *back;
6275 char **blah; 6318 char **blah;
6276 int _locked_by_me = FALSE; 6319 int _locked_by_me = FALSE;
6277 6320
6278 DW_MUTEX_LOCK; 6321 DW_MUTEX_LOCK;
6279 clist = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 6322 clist = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
6280 if(!clist) 6323 if(!clist)
6281 { 6324 {
6282 DW_MUTEX_UNLOCK; 6325 DW_MUTEX_UNLOCK;
6283 return NULL; 6326 return NULL;
6284 } 6327 }
6285 6328
6286 count = (int)gtk_object_get_data(GTK_OBJECT(clist), "_dw_colcount"); 6329 count = (int)gtk_object_get_data(GTK_OBJECT(clist), "_dw_colcount");
6287 prevrowcount = (int)gtk_object_get_data(GTK_OBJECT(clist), "_dw_rowcount"); 6330 prevrowcount = (int)gtk_object_get_data(GTK_OBJECT(clist), "_dw_rowcount");
6288 6331
6289 if(!count) 6332 if(!count)
6290 { 6333 {
6291 DW_MUTEX_UNLOCK; 6334 DW_MUTEX_UNLOCK;
6292 return NULL; 6335 return NULL;
6293 } 6336 }
6294 6337
6295 blah = malloc(sizeof(char *) * count); 6338 blah = malloc(sizeof(char *) * count);
6296 memset(blah, 0, sizeof(char *) * count); 6339 memset(blah, 0, sizeof(char *) * count);
6297 6340
6298 fore = (GdkColor *)gtk_object_get_data(GTK_OBJECT(clist), "_dw_foregdk"); 6341 fore = (GdkColor *)gtk_object_get_data(GTK_OBJECT(clist), "_dw_foregdk");
6299 back = (GdkColor *)gtk_object_get_data(GTK_OBJECT(clist), "_dw_backgdk"); 6342 back = (GdkColor *)gtk_object_get_data(GTK_OBJECT(clist), "_dw_backgdk");
6300 gtk_clist_freeze(GTK_CLIST(clist)); 6343 gtk_clist_freeze(GTK_CLIST(clist));
6301 for(z=0;z<rowcount;z++) 6344 for(z=0;z<rowcount;z++)
6302 { 6345 {
6303 gtk_clist_append(GTK_CLIST(clist), blah); 6346 gtk_clist_append(GTK_CLIST(clist), blah);
6304 if(fore) 6347 if(fore)
6305 gtk_clist_set_foreground(GTK_CLIST(clist), z + prevrowcount, fore); 6348 gtk_clist_set_foreground(GTK_CLIST(clist), z + prevrowcount, fore);
6306 if(back) 6349 if(back)
6307 gtk_clist_set_background(GTK_CLIST(clist), z + prevrowcount, back); 6350 gtk_clist_set_background(GTK_CLIST(clist), z + prevrowcount, back);
6308 } 6351 }
6309 gtk_object_set_data(GTK_OBJECT(clist), "_dw_insertpos", (gpointer)prevrowcount); 6352 gtk_object_set_data(GTK_OBJECT(clist), "_dw_insertpos", GINT_TO_POINTER(prevrowcount));
6310 gtk_object_set_data(GTK_OBJECT(clist), "_dw_rowcount", (gpointer)(rowcount + prevrowcount)); 6353 gtk_object_set_data(GTK_OBJECT(clist), "_dw_rowcount", GINT_TO_POINTER(rowcount + prevrowcount));
6311 free(blah); 6354 free(blah);
6312 DW_MUTEX_UNLOCK; 6355 DW_MUTEX_UNLOCK;
6313 return (void *)handle; 6356 return (void *)handle;
6314 } 6357 }
6315 6358
6316 /* 6359 /*
6317 * Internal representation of dw_container_set_item() extracted so we can pass 6360 * Internal representation of dw_container_set_item() extracted so we can pass
6318 * two data pointers; icon and text for dw_filesystem_set_item(). 6361 * two data pointers; icon and text for dw_filesystem_set_item().
6319 */ 6362 */
6320 void _dw_container_set_item(HWND handle, void *pointer, int column, int row, void *data, char *text) 6363 void _dw_container_set_item(HWND handle, void *pointer, int column, int row, void *data, char *text)
6321 { 6364 {
6322 char numbuf[10], textbuffer[100]; 6365 char numbuf[10], textbuffer[100];
6323 int flag = 0; 6366 int flag = 0;
6324 GtkWidget *clist; 6367 GtkWidget *clist;
6325 int _locked_by_me = FALSE; 6368 int _locked_by_me = FALSE;
6326 6369
6327 DW_MUTEX_LOCK; 6370 DW_MUTEX_LOCK;
6328 clist = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 6371 clist = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
6329 if(!clist) 6372 if(!clist)
6330 { 6373 {
6331 DW_MUTEX_UNLOCK; 6374 DW_MUTEX_UNLOCK;
6332 return; 6375 return;
6333 } 6376 }
6334 6377
6335 sprintf(numbuf, "%d", column); 6378 sprintf(numbuf, "%d", column);
6336 flag = (int)gtk_object_get_data(GTK_OBJECT(clist), numbuf); 6379 flag = (int)gtk_object_get_data(GTK_OBJECT(clist), numbuf);
6337 row += (int)gtk_object_get_data(GTK_OBJECT(clist), "_dw_insertpos"); 6380 row += (int)gtk_object_get_data(GTK_OBJECT(clist), "_dw_insertpos");
6338 6381
6339 if(flag & DW_CFA_BITMAPORICON) 6382 if(flag & DW_CFA_BITMAPORICON)
6340 { 6383 {
6341 long hicon = *((long *)data); 6384 long hicon = *((long *)data);
6342 GdkBitmap *bitmap = NULL; 6385 GdkBitmap *bitmap = NULL;
6343 GdkPixmap *pixmap = _find_pixmap(&bitmap, hicon, clist, NULL, NULL); 6386 GdkPixmap *pixmap = _find_pixmap(&bitmap, hicon, clist, NULL, NULL);
6344 6387
6345 if(pixmap) 6388 if(pixmap)
6346 gtk_clist_set_pixmap(GTK_CLIST(clist), row, column, pixmap, bitmap); 6389 gtk_clist_set_pixmap(GTK_CLIST(clist), row, column, pixmap, bitmap);
6347 } 6390 }
6348 else if(flag & DW_CFA_STRINGANDICON) 6391 else if(flag & DW_CFA_STRINGANDICON)
6349 { 6392 {
6350 long hicon = *((long *)data); 6393 long hicon = *((long *)data);
6351 GdkBitmap *bitmap = NULL; 6394 GdkBitmap *bitmap = NULL;
6352 GdkPixmap *pixmap = _find_pixmap(&bitmap, hicon, clist, NULL, NULL); 6395 GdkPixmap *pixmap = _find_pixmap(&bitmap, hicon, clist, NULL, NULL);
6353 6396
6354 if(pixmap) 6397 if(pixmap)
6355 gtk_clist_set_pixtext(GTK_CLIST(clist), row, column, text, 2, pixmap, bitmap); 6398 gtk_clist_set_pixtext(GTK_CLIST(clist), row, column, text, 2, pixmap, bitmap);
6356 } 6399 }
6357 else if(flag & DW_CFA_STRING) 6400 else if(flag & DW_CFA_STRING)
6358 { 6401 {
6359 char *tmp = *((char **)data); 6402 char *tmp = *((char **)data);
6360 gtk_clist_set_text(GTK_CLIST(clist), row, column, tmp); 6403 gtk_clist_set_text(GTK_CLIST(clist), row, column, tmp);
6361 } 6404 }
6362 else if(flag & DW_CFA_ULONG) 6405 else if(flag & DW_CFA_ULONG)
6363 { 6406 {
6364 ULONG tmp = *((ULONG *)data); 6407 ULONG tmp = *((ULONG *)data);
6365 6408
6366 sprintf(textbuffer, "%lu", tmp); 6409 sprintf(textbuffer, "%lu", tmp);
6367 6410
6368 gtk_clist_set_text(GTK_CLIST(clist), row, column, textbuffer); 6411 gtk_clist_set_text(GTK_CLIST(clist), row, column, textbuffer);
6369 } 6412 }
6370 else if(flag & DW_CFA_DATE) 6413 else if(flag & DW_CFA_DATE)
6371 { 6414 {
6372 struct tm curtm; 6415 struct tm curtm;
6373 CDATE cdate = *((CDATE *)data); 6416 CDATE cdate = *((CDATE *)data);
6374 6417
6375 curtm.tm_mday = cdate.day; 6418 curtm.tm_mday = cdate.day;
6376 curtm.tm_mon = cdate.month - 1; 6419 curtm.tm_mon = cdate.month - 1;
6377 curtm.tm_year = cdate.year - 1900; 6420 curtm.tm_year = cdate.year - 1900;
6378 6421
6379 strftime(textbuffer, 100, "%x", &curtm); 6422 strftime(textbuffer, 100, "%x", &curtm);
6380 6423
6381 gtk_clist_set_text(GTK_CLIST(clist), row, column, textbuffer); 6424 gtk_clist_set_text(GTK_CLIST(clist), row, column, textbuffer);
6382 } 6425 }
6383 else if(flag & DW_CFA_TIME) 6426 else if(flag & DW_CFA_TIME)
6384 { 6427 {
6385 struct tm curtm; 6428 struct tm curtm;
6386 CTIME ctime = *((CTIME *)data); 6429 CTIME ctime = *((CTIME *)data);
6387 6430
6388 curtm.tm_hour = ctime.hours; 6431 curtm.tm_hour = ctime.hours;
6389 curtm.tm_min = ctime.minutes; 6432 curtm.tm_min = ctime.minutes;
6390 curtm.tm_sec = ctime.seconds; 6433 curtm.tm_sec = ctime.seconds;
6391 6434
6392 strftime(textbuffer, 100, "%X", &curtm); 6435 strftime(textbuffer, 100, "%X", &curtm);
6393 6436
6394 gtk_clist_set_text(GTK_CLIST(clist), row, column, textbuffer); 6437 gtk_clist_set_text(GTK_CLIST(clist), row, column, textbuffer);
6395 } 6438 }
6396 DW_MUTEX_UNLOCK; 6439 DW_MUTEX_UNLOCK;
6397 } 6440 }
6398 6441
6399 /* 6442 /*
6400 * Sets an item in specified row and column to the given data. 6443 * Sets an item in specified row and column to the given data.
6401 * Parameters: 6444 * Parameters:
6405 * row: Zero based row of data being set. 6448 * row: Zero based row of data being set.
6406 * data: Pointer to the data to be added. 6449 * data: Pointer to the data to be added.
6407 */ 6450 */
6408 void dw_container_set_item(HWND handle, void *pointer, int column, int row, void *data) 6451 void dw_container_set_item(HWND handle, void *pointer, int column, int row, void *data)
6409 { 6452 {
6410 _dw_container_set_item(handle, NULL, column, row, data, NULL); 6453 _dw_container_set_item(handle, NULL, column, row, data, NULL);
6411 } 6454 }
6412 6455
6413 /* 6456 /*
6414 * Changes an existing item in specified row and column to the given data. 6457 * Changes an existing item in specified row and column to the given data.
6415 * Parameters: 6458 * Parameters:
6418 * row: Zero based row of data being set. 6461 * row: Zero based row of data being set.
6419 * data: Pointer to the data to be added. 6462 * data: Pointer to the data to be added.
6420 */ 6463 */
6421 void dw_container_change_item(HWND handle, int column, int row, void *data) 6464 void dw_container_change_item(HWND handle, int column, int row, void *data)
6422 { 6465 {
6423 _dw_container_set_item(handle, NULL, column, row, data, NULL); 6466 _dw_container_set_item(handle, NULL, column, row, data, NULL);
6424 } 6467 }
6425 6468
6426 /* 6469 /*
6427 * Changes an existing item in specified row and column to the given data. 6470 * Changes an existing item in specified row and column to the given data.
6428 * Parameters: 6471 * Parameters:
6431 * row: Zero based row of data being set. 6474 * row: Zero based row of data being set.
6432 * data: Pointer to the data to be added. 6475 * data: Pointer to the data to be added.
6433 */ 6476 */
6434 void API dw_filesystem_change_item(HWND handle, int column, int row, void *data) 6477 void API dw_filesystem_change_item(HWND handle, int column, int row, void *data)
6435 { 6478 {
6436 dw_filesystem_set_item(handle, NULL, column, row, data); 6479 dw_filesystem_set_item(handle, NULL, column, row, data);
6437 } 6480 }
6438 6481
6439 /* 6482 /*
6440 * Changes an item in specified row and column to the given data. 6483 * Changes an item in specified row and column to the given data.
6441 * Parameters: 6484 * Parameters:
6445 * row: Zero based row of data being set. 6488 * row: Zero based row of data being set.
6446 * data: Pointer to the data to be added. 6489 * data: Pointer to the data to be added.
6447 */ 6490 */
6448 void API dw_filesystem_change_file(HWND handle, int row, char *filename, unsigned long icon) 6491 void API dw_filesystem_change_file(HWND handle, int row, char *filename, unsigned long icon)
6449 { 6492 {
6450 dw_filesystem_set_file(handle, NULL, row, filename, icon); 6493 dw_filesystem_set_file(handle, NULL, row, filename, icon);
6451 } 6494 }
6452 6495
6453 /* 6496 /*
6454 * Sets an item in specified row and column to the given data. 6497 * Sets an item in specified row and column to the given data.
6455 * Parameters: 6498 * Parameters:
6459 * row: Zero based row of data being set. 6502 * row: Zero based row of data being set.
6460 * data: Pointer to the data to be added. 6503 * data: Pointer to the data to be added.
6461 */ 6504 */
6462 void dw_filesystem_set_file(HWND handle, void *pointer, int row, char *filename, unsigned long icon) 6505 void dw_filesystem_set_file(HWND handle, void *pointer, int row, char *filename, unsigned long icon)
6463 { 6506 {
6464 _dw_container_set_item(handle, pointer, 0, row, (void *)&icon, filename); 6507 _dw_container_set_item(handle, pointer, 0, row, (void *)&icon, filename);
6465 } 6508 }
6466 6509
6467 /* 6510 /*
6468 * Sets an item in specified row and column to the given data. 6511 * Sets an item in specified row and column to the given data.
6469 * Parameters: 6512 * Parameters:
6473 * row: Zero based row of data being set. 6516 * row: Zero based row of data being set.
6474 * data: Pointer to the data to be added. 6517 * data: Pointer to the data to be added.
6475 */ 6518 */
6476 void dw_filesystem_set_item(HWND handle, void *pointer, int column, int row, void *data) 6519 void dw_filesystem_set_item(HWND handle, void *pointer, int column, int row, void *data)
6477 { 6520 {
6478 _dw_container_set_item(handle, pointer, column + 1, row, data, NULL); 6521 _dw_container_set_item(handle, pointer, column + 1, row, data, NULL);
6479 } 6522 }
6480 6523
6481 /* 6524 /*
6482 * Gets column type for a container column 6525 * Gets column type for a container column
6483 * Parameters: 6526 * Parameters:
6484 * handle: Handle to the container window (widget). 6527 * handle: Handle to the container window (widget).
6485 * column: Zero based column. 6528 * column: Zero based column.
6486 */ 6529 */
6487 int dw_container_get_column_type(HWND handle, int column) 6530 int dw_container_get_column_type(HWND handle, int column)
6488 { 6531 {
6489 char numbuf[10]; 6532 char numbuf[10];
6490 int flag, rc; 6533 int flag, rc;
6491 GtkWidget *clist; 6534 GtkWidget *clist;
6492 int _locked_by_me = FALSE; 6535 int _locked_by_me = FALSE;
6493 6536
6494 DW_MUTEX_LOCK; 6537 DW_MUTEX_LOCK;
6495 clist = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 6538 clist = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
6496 if(!clist) 6539 if(!clist)
6497 { 6540 {
6498 DW_MUTEX_UNLOCK; 6541 DW_MUTEX_UNLOCK;
6499 return 0; 6542 return 0;
6500 } 6543 }
6501 6544
6502 sprintf(numbuf, "%d", column); 6545 sprintf(numbuf, "%d", column);
6503 flag = (int)gtk_object_get_data(GTK_OBJECT(clist), numbuf); 6546 flag = (int)gtk_object_get_data(GTK_OBJECT(clist), numbuf);
6504 6547
6505 if(flag & DW_CFA_BITMAPORICON) 6548 if(flag & DW_CFA_BITMAPORICON)
6506 rc = DW_CFA_BITMAPORICON; 6549 rc = DW_CFA_BITMAPORICON;
6507 else if(flag & DW_CFA_STRING) 6550 else if(flag & DW_CFA_STRING)
6508 rc = DW_CFA_STRING; 6551 rc = DW_CFA_STRING;
6509 else if(flag & DW_CFA_ULONG) 6552 else if(flag & DW_CFA_ULONG)
6510 rc = DW_CFA_ULONG; 6553 rc = DW_CFA_ULONG;
6511 else if(flag & DW_CFA_DATE) 6554 else if(flag & DW_CFA_DATE)
6512 rc = DW_CFA_DATE; 6555 rc = DW_CFA_DATE;
6513 else if(flag & DW_CFA_TIME) 6556 else if(flag & DW_CFA_TIME)
6514 rc = DW_CFA_TIME; 6557 rc = DW_CFA_TIME;
6515 else 6558 else
6516 rc = 0; 6559 rc = 0;
6517 DW_MUTEX_UNLOCK; 6560 DW_MUTEX_UNLOCK;
6518 return rc; 6561 return rc;
6519 } 6562 }
6520 6563
6521 /* 6564 /*
6522 * Gets column type for a filesystem container column 6565 * Gets column type for a filesystem container column
6523 * Parameters: 6566 * Parameters:
6524 * handle: Handle to the container window (widget). 6567 * handle: Handle to the container window (widget).
6525 * column: Zero based column. 6568 * column: Zero based column.
6526 */ 6569 */
6527 int API dw_filesystem_get_column_type(HWND handle, int column) 6570 int API dw_filesystem_get_column_type(HWND handle, int column)
6528 { 6571 {
6529 return dw_container_get_column_type( handle, column + 1 ); 6572 return dw_container_get_column_type( handle, column + 1 );
6530 } 6573 }
6531 6574
6532 /* 6575 /*
6533 * Sets the width of a column in the container. 6576 * Sets the width of a column in the container.
6534 * Parameters: 6577 * Parameters:
6536 * column: Zero based column of width being set. 6579 * column: Zero based column of width being set.
6537 * width: Width of column in pixels. 6580 * width: Width of column in pixels.
6538 */ 6581 */
6539 void dw_container_set_column_width(HWND handle, int column, int width) 6582 void dw_container_set_column_width(HWND handle, int column, int width)
6540 { 6583 {
6541 GtkWidget *clist; 6584 GtkWidget *clist;
6542 int _locked_by_me = FALSE; 6585 int _locked_by_me = FALSE;
6543 6586
6544 DW_MUTEX_LOCK; 6587 DW_MUTEX_LOCK;
6545 clist = gtk_object_get_user_data(GTK_OBJECT(handle)); 6588 clist = gtk_object_get_user_data(GTK_OBJECT(handle));
6546 6589
6547 if(clist && GTK_IS_CLIST(clist)) 6590 if(clist && GTK_IS_CLIST(clist))
6548 gtk_clist_set_column_width(GTK_CLIST(clist), column, width); 6591 gtk_clist_set_column_width(GTK_CLIST(clist), column, width);
6549 DW_MUTEX_UNLOCK; 6592 DW_MUTEX_UNLOCK;
6550 } 6593 }
6551 6594
6552 /* 6595 /*
6553 * Sets the title of a row in the container. 6596 * Sets the title of a row in the container.
6554 * Parameters: 6597 * Parameters:
6556 * row: Zero based row of data being set. 6599 * row: Zero based row of data being set.
6557 * title: String title of the item. 6600 * title: String title of the item.
6558 */ 6601 */
6559 void dw_container_set_row_title(void *pointer, int row, char *title) 6602 void dw_container_set_row_title(void *pointer, int row, char *title)
6560 { 6603 {
6561 GtkWidget *clist; 6604 GtkWidget *clist;
6562 int _locked_by_me = FALSE; 6605 int _locked_by_me = FALSE;
6563 6606
6564 DW_MUTEX_LOCK; 6607 DW_MUTEX_LOCK;
6565 clist = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(pointer)); 6608 clist = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(pointer));
6566 row += (int)gtk_object_get_data(GTK_OBJECT(clist), "_dw_insertpos"); 6609 row += (int)gtk_object_get_data(GTK_OBJECT(clist), "_dw_insertpos");
6567 6610
6568 if(clist) 6611 if(clist)
6569 gtk_clist_set_row_data(GTK_CLIST(clist), row, (gpointer)title); 6612 gtk_clist_set_row_data(GTK_CLIST(clist), row, (gpointer)title);
6570 DW_MUTEX_UNLOCK; 6613 DW_MUTEX_UNLOCK;
6571 } 6614 }
6572 6615
6573 /* 6616 /*
6574 * Sets the title of a row in the container. 6617 * Sets the title of a row in the container.
6575 * Parameters: 6618 * Parameters:
6577 * pointer: Pointer to the allocated memory in dw_container_alloc(). 6620 * pointer: Pointer to the allocated memory in dw_container_alloc().
6578 * rowcount: The number of rows to be inserted. 6621 * rowcount: The number of rows to be inserted.
6579 */ 6622 */
6580 void dw_container_insert(HWND handle, void *pointer, int rowcount) 6623 void dw_container_insert(HWND handle, void *pointer, int rowcount)
6581 { 6624 {
6582 GtkWidget *clist; 6625 GtkWidget *clist;
6583 int _locked_by_me = FALSE; 6626 int _locked_by_me = FALSE;
6584 6627
6585 DW_MUTEX_LOCK; 6628 DW_MUTEX_LOCK;
6586 clist = gtk_object_get_user_data(GTK_OBJECT(handle)); 6629 clist = gtk_object_get_user_data(GTK_OBJECT(handle));
6587 6630
6588 if(clist && GTK_IS_CLIST(clist)) 6631 if(clist && GTK_IS_CLIST(clist))
6589 gtk_clist_thaw(GTK_CLIST(clist)); 6632 gtk_clist_thaw(GTK_CLIST(clist));
6590 DW_MUTEX_UNLOCK; 6633 DW_MUTEX_UNLOCK;
6591 } 6634 }
6592 6635
6593 /* 6636 /*
6594 * Removes the first x rows from a container. 6637 * Removes the first x rows from a container.
6595 * Parameters: 6638 * Parameters:
6596 * handle: Handle to the window (widget) to be deleted from. 6639 * handle: Handle to the window (widget) to be deleted from.
6597 * rowcount: The number of rows to be deleted. 6640 * rowcount: The number of rows to be deleted.
6598 */ 6641 */
6599 void dw_container_delete(HWND handle, int rowcount) 6642 void dw_container_delete(HWND handle, int rowcount)
6600 { 6643 {
6601 GtkWidget *clist; 6644 GtkWidget *clist;
6602 int _locked_by_me = FALSE; 6645 int _locked_by_me = FALSE;
6603 6646
6604 DW_MUTEX_LOCK; 6647 DW_MUTEX_LOCK;
6605 clist = (GtkWidget*)gtk_object_get_user_data(GTK_OBJECT(handle)); 6648 clist = (GtkWidget*)gtk_object_get_user_data(GTK_OBJECT(handle));
6606 if(clist && GTK_IS_CLIST(clist)) 6649 if(clist && GTK_IS_CLIST(clist))
6607 { 6650 {
6608 int rows, z; 6651 int rows, z;
6609 6652
6610 rows = (int)gtk_object_get_data(GTK_OBJECT(clist), "_dw_rowcount"); 6653 rows = (int)gtk_object_get_data(GTK_OBJECT(clist), "_dw_rowcount");
6611 6654
6612 _dw_unselect(clist); 6655 _dw_unselect(clist);
6613 6656
6614 for(z=0;z<rowcount;z++) 6657 for(z=0;z<rowcount;z++)
6615 gtk_clist_remove(GTK_CLIST(clist), 0); 6658 gtk_clist_remove(GTK_CLIST(clist), 0);
6616 6659
6617 if(rows - rowcount < 0) 6660 if(rows - rowcount < 0)
6618 rows = 0; 6661 rows = 0;
6619 else 6662 else
6620 rows -= rowcount; 6663 rows -= rowcount;
6621 6664
6622 gtk_object_set_data(GTK_OBJECT(clist), "_dw_rowcount", (gpointer)rows); 6665 gtk_object_set_data(GTK_OBJECT(clist), "_dw_rowcount", GINT_TO_POINTER(rows));
6623 } 6666 }
6624 DW_MUTEX_UNLOCK; 6667 DW_MUTEX_UNLOCK;
6625 } 6668 }
6626 6669
6627 /* 6670 /*
6628 * Removes all rows from a container. 6671 * Removes all rows from a container.
6629 * Parameters: 6672 * Parameters:
6630 * handle: Handle to the window (widget) to be cleared. 6673 * handle: Handle to the window (widget) to be cleared.
6631 * redraw: TRUE to cause the container to redraw immediately. 6674 * redraw: TRUE to cause the container to redraw immediately.
6632 */ 6675 */
6633 void dw_container_clear(HWND handle, int redraw) 6676 void dw_container_clear(HWND handle, int redraw)
6634 { 6677 {
6635 GtkWidget *clist; 6678 GtkWidget *clist;
6636 int _locked_by_me = FALSE; 6679 int _locked_by_me = FALSE;
6637 6680
6638 DW_MUTEX_LOCK; 6681 DW_MUTEX_LOCK;
6639 clist = (GtkWidget*)gtk_object_get_user_data(GTK_OBJECT(handle)); 6682 clist = (GtkWidget*)gtk_object_get_user_data(GTK_OBJECT(handle));
6640 if(clist && GTK_IS_CLIST(clist)) 6683 if(clist && GTK_IS_CLIST(clist))
6641 { 6684 {
6642 _dw_unselect(clist); 6685 _dw_unselect(clist);
6643 gtk_clist_clear(GTK_CLIST(clist)); 6686 gtk_clist_clear(GTK_CLIST(clist));
6644 gtk_object_set_data(GTK_OBJECT(clist), "_dw_rowcount", (gpointer)0); 6687 gtk_object_set_data(GTK_OBJECT(clist), "_dw_rowcount", GINT_TO_POINTER(0));
6645 } 6688 }
6646 DW_MUTEX_UNLOCK; 6689 DW_MUTEX_UNLOCK;
6647 } 6690 }
6648 6691
6649 /* 6692 /*
6650 * Scrolls container up or down. 6693 * Scrolls container up or down.
6651 * Parameters: 6694 * Parameters:
6654 * DW_SCROLL_BOTTOM. (rows is ignored for last two) 6697 * DW_SCROLL_BOTTOM. (rows is ignored for last two)
6655 * rows: The number of rows to be scrolled. 6698 * rows: The number of rows to be scrolled.
6656 */ 6699 */
6657 void dw_container_scroll(HWND handle, int direction, long rows) 6700 void dw_container_scroll(HWND handle, int direction, long rows)
6658 { 6701 {
6659 GtkAdjustment *adj; 6702 GtkAdjustment *adj;
6660 GtkWidget *clist; 6703 GtkWidget *clist;
6661 int _locked_by_me = FALSE; 6704 int _locked_by_me = FALSE;
6662 6705
6663 DW_MUTEX_LOCK; 6706 DW_MUTEX_LOCK;
6664 clist = (GtkWidget*)gtk_object_get_user_data(GTK_OBJECT(handle)); 6707 clist = (GtkWidget*)gtk_object_get_user_data(GTK_OBJECT(handle));
6665 if(clist && GTK_IS_CLIST(clist)) 6708 if(clist && GTK_IS_CLIST(clist))
6666 { 6709 {
6667 adj = gtk_clist_get_vadjustment(GTK_CLIST(clist)); 6710 adj = gtk_clist_get_vadjustment(GTK_CLIST(clist));
6668 if(adj) 6711 if(adj)
6669 { 6712 {
6670 switch(direction) 6713 switch(direction)
6671 { 6714 {
6672 case DW_SCROLL_TOP: 6715 case DW_SCROLL_TOP:
6673 adj->value = adj->lower; 6716 adj->value = adj->lower;
6674 break; 6717 break;
6675 case DW_SCROLL_BOTTOM: 6718 case DW_SCROLL_BOTTOM:
6676 adj->value = adj->upper; 6719 adj->value = adj->upper;
6677 break; 6720 break;
6678 } 6721 }
6679 gtk_clist_set_vadjustment(GTK_CLIST(clist), adj); 6722 gtk_clist_set_vadjustment(GTK_CLIST(clist), adj);
6680 } 6723 }
6681 } 6724 }
6682 DW_MUTEX_UNLOCK; 6725 DW_MUTEX_UNLOCK;
6683 } 6726 }
6684 6727
6685 /* 6728 /*
6686 * Starts a new query of a container. 6729 * Starts a new query of a container.
6687 * Parameters: 6730 * Parameters:
6690 * return items that are currently selected. Otherwise 6733 * return items that are currently selected. Otherwise
6691 * it will return all records in the container. 6734 * it will return all records in the container.
6692 */ 6735 */
6693 char *dw_container_query_start(HWND handle, unsigned long flags) 6736 char *dw_container_query_start(HWND handle, unsigned long flags)
6694 { 6737 {
6695 GtkWidget *clist; 6738 GtkWidget *clist;
6696 GList *list; 6739 GList *list;
6697 char *retval = NULL; 6740 char *retval = NULL;
6698 int _locked_by_me = FALSE; 6741 int _locked_by_me = FALSE;
6699 6742
6700 DW_MUTEX_LOCK; 6743 DW_MUTEX_LOCK;
6701 clist = (GtkWidget*)gtk_object_get_user_data(GTK_OBJECT(handle)); 6744 clist = (GtkWidget*)gtk_object_get_user_data(GTK_OBJECT(handle));
6702 6745
6703 if(!clist) 6746 if(!clist)
6704 { 6747 {
6705 DW_MUTEX_UNLOCK; 6748 DW_MUTEX_UNLOCK;
6706 return NULL; 6749 return NULL;
6707 } 6750 }
6708 6751
6709 /* These should be separate but right now this will work */ 6752 /* These should be separate but right now this will work */
6710 if(flags & DW_CRA_SELECTED) 6753 if(flags & DW_CRA_SELECTED)
6711 { 6754 {
6712 list = GTK_CLIST(clist)->selection; 6755 list = GTK_CLIST(clist)->selection;
6713 6756
6714 if(list) 6757 if(list)
6715 { 6758 {
6716 gtk_object_set_data(GTK_OBJECT(clist), "_dw_querypos", (gpointer)1); 6759 gtk_object_set_data(GTK_OBJECT(clist), "_dw_querypos", GINT_TO_POINTER(1));
6717 retval = (char *)gtk_clist_get_row_data(GTK_CLIST(clist), GPOINTER_TO_UINT(list->data)); 6760 retval = (char *)gtk_clist_get_row_data(GTK_CLIST(clist), GPOINTER_TO_UINT(list->data));
6718 } 6761 }
6719 } 6762 }
6720 else if(flags & DW_CRA_CURSORED) 6763 else if(flags & DW_CRA_CURSORED)
6721 { 6764 {
6722 retval = (char *)gtk_clist_get_row_data(GTK_CLIST(clist), GTK_CLIST(clist)->focus_row); 6765 retval = (char *)gtk_clist_get_row_data(GTK_CLIST(clist), GTK_CLIST(clist)->focus_row);
6723 } 6766 }
6724 else 6767 else
6725 { 6768 {
6726 retval = (char *)gtk_clist_get_row_data(GTK_CLIST(clist), 0); 6769 retval = (char *)gtk_clist_get_row_data(GTK_CLIST(clist), 0);
6727 gtk_object_set_data(GTK_OBJECT(clist), "_dw_querypos", (gpointer)1); 6770 gtk_object_set_data(GTK_OBJECT(clist), "_dw_querypos", GINT_TO_POINTER(1));
6728 } 6771 }
6729 DW_MUTEX_UNLOCK; 6772 DW_MUTEX_UNLOCK;
6730 return retval; 6773 return retval;
6731 } 6774 }
6732 6775
6733 /* 6776 /*
6734 * Continues an existing query of a container. 6777 * Continues an existing query of a container.
6735 * Parameters: 6778 * Parameters:
6738 * return items that are currently selected. Otherwise 6781 * return items that are currently selected. Otherwise
6739 * it will return all records in the container. 6782 * it will return all records in the container.
6740 */ 6783 */
6741 char *dw_container_query_next(HWND handle, unsigned long flags) 6784 char *dw_container_query_next(HWND handle, unsigned long flags)
6742 { 6785 {
6743 GtkWidget *clist; 6786 GtkWidget *clist;
6744 GList *list; 6787 GList *list;
6745 char *retval = NULL; 6788 char *retval = NULL;
6746 int _locked_by_me = FALSE; 6789 int _locked_by_me = FALSE;
6747 6790
6748 DW_MUTEX_LOCK; 6791 DW_MUTEX_LOCK;
6749 clist = (GtkWidget*)gtk_object_get_user_data(GTK_OBJECT(handle)); 6792 clist = (GtkWidget*)gtk_object_get_user_data(GTK_OBJECT(handle));
6750 6793
6751 if(!clist) 6794 if(!clist)
6752 { 6795 {
6753 DW_MUTEX_UNLOCK; 6796 DW_MUTEX_UNLOCK;
6754 return NULL; 6797 return NULL;
6755 } 6798 }
6756 6799
6757 /* These should be separate but right now this will work */ 6800 /* These should be separate but right now this will work */
6758 if(flags & DW_CRA_SELECTED) 6801 if(flags & DW_CRA_SELECTED)
6759 { 6802 {
6760 list = GTK_CLIST(clist)->selection; 6803 list = GTK_CLIST(clist)->selection;
6761 6804
6762 if(list) 6805 if(list)
6763 { 6806 {
6764 int counter = 0, pos = (int)gtk_object_get_data(GTK_OBJECT(clist), "_dw_querypos"); 6807 int counter = 0, pos = (int)gtk_object_get_data(GTK_OBJECT(clist), "_dw_querypos");
6765 gtk_object_set_data(GTK_OBJECT(clist), "_dw_querypos", (gpointer)pos+1); 6808 gtk_object_set_data(GTK_OBJECT(clist), "_dw_querypos", GINT_TO_POINTER(pos+1));
6766 6809
6767 while(list && counter < pos) 6810 while(list && counter < pos)
6768 { 6811 {
6769 list = list->next; 6812 list = list->next;
6770 counter++; 6813 counter++;
6771 } 6814 }
6772 6815
6773 if(list) 6816 if(list)
6774 retval = (char *)gtk_clist_get_row_data(GTK_CLIST(clist), GPOINTER_TO_UINT(list->data)); 6817 retval = (char *)gtk_clist_get_row_data(GTK_CLIST(clist), GPOINTER_TO_UINT(list->data));
6775 } 6818 }
6776 } 6819 }
6777 else if(flags & DW_CRA_CURSORED) 6820 else if(flags & DW_CRA_CURSORED)
6778 { 6821 {
6779 /* There will only be one item cursored, 6822 /* There will only be one item cursored,
6780 * retrieve it with dw_container_query_start() 6823 * retrieve it with dw_container_query_start()
6781 */ 6824 */
6782 retval = NULL; 6825 retval = NULL;
6783 } 6826 }
6784 else 6827 else
6785 { 6828 {
6786 int pos = (int)gtk_object_get_data(GTK_OBJECT(clist), "_dw_querypos"); 6829 int pos = (int)gtk_object_get_data(GTK_OBJECT(clist), "_dw_querypos");
6787 6830
6788 retval = (char *)gtk_clist_get_row_data(GTK_CLIST(clist), pos); 6831 retval = (char *)gtk_clist_get_row_data(GTK_CLIST(clist), pos);
6789 gtk_object_set_data(GTK_OBJECT(clist), "_dw_querypos", (gpointer)pos+1); 6832 gtk_object_set_data(GTK_OBJECT(clist), "_dw_querypos", GINT_TO_POINTER(pos+1));
6790 } 6833 }
6791 DW_MUTEX_UNLOCK; 6834 DW_MUTEX_UNLOCK;
6792 return retval; 6835 return retval;
6793 } 6836 }
6794 6837
6795 /* 6838 /*
6796 * Cursors the item with the text speficied, and scrolls to that item. 6839 * Cursors the item with the text speficied, and scrolls to that item.
6797 * Parameters: 6840 * Parameters:
6798 * handle: Handle to the window (widget) to be queried. 6841 * handle: Handle to the window (widget) to be queried.
6799 * text: Text usually returned by dw_container_query(). 6842 * text: Text usually returned by dw_container_query().
6800 */ 6843 */
6801 void dw_container_cursor(HWND handle, char *text) 6844 void dw_container_cursor(HWND handle, char *text)
6802 { 6845 {
6803 int _locked_by_me = FALSE; 6846 int _locked_by_me = FALSE;
6804 GtkWidget *clist; 6847 GtkWidget *clist;
6805 int rowcount, z; 6848 int rowcount, z;
6806 char *rowdata; 6849 char *rowdata;
6807 6850
6808 DW_MUTEX_LOCK; 6851 DW_MUTEX_LOCK;
6809 clist = (GtkWidget*)gtk_object_get_user_data(GTK_OBJECT(handle)); 6852 clist = (GtkWidget*)gtk_object_get_user_data(GTK_OBJECT(handle));
6810 6853
6811 if(!clist) 6854 if(!clist)
6812 { 6855 {
6813 DW_MUTEX_UNLOCK; 6856 DW_MUTEX_UNLOCK;
6814 return; 6857 return;
6815 } 6858 }
6816 rowcount = (int)gtk_object_get_data(GTK_OBJECT(clist), "_dw_rowcount"); 6859 rowcount = (int)gtk_object_get_data(GTK_OBJECT(clist), "_dw_rowcount");
6817 6860
6818 for(z=0;z<rowcount;z++) 6861 for(z=0;z<rowcount;z++)
6819 { 6862 {
6820 rowdata = gtk_clist_get_row_data(GTK_CLIST(clist), z); 6863 rowdata = gtk_clist_get_row_data(GTK_CLIST(clist), z);
6821 if(rowdata == text) 6864 if(rowdata == text)
6822 { 6865 {
6823 gfloat pos; 6866 gfloat pos;
6824 GtkAdjustment *adj = gtk_clist_get_vadjustment(GTK_CLIST(clist)); 6867 GtkAdjustment *adj = gtk_clist_get_vadjustment(GTK_CLIST(clist));
6825 6868
6826 _dw_unselect(clist); 6869 _dw_unselect(clist);
6827 6870
6828 gtk_clist_select_row(GTK_CLIST(clist), z, 0); 6871 gtk_clist_select_row(GTK_CLIST(clist), z, 0);
6829 6872
6830 pos = ((adj->upper - adj->lower) * ((gfloat)z/(gfloat)rowcount)) + adj->lower; 6873 pos = ((adj->upper - adj->lower) * ((gfloat)z/(gfloat)rowcount)) + adj->lower;
6831 gtk_adjustment_set_value(adj, pos); 6874 gtk_adjustment_set_value(adj, pos);
6832 DW_MUTEX_UNLOCK; 6875 DW_MUTEX_UNLOCK;
6833 return; 6876 return;
6834 } 6877 }
6835 } 6878 }
6836 6879
6837 DW_MUTEX_UNLOCK; 6880 DW_MUTEX_UNLOCK;
6838 } 6881 }
6839 6882
6840 /* 6883 /*
6841 * Deletes the item with the text speficied. 6884 * Deletes the item with the text speficied.
6842 * Parameters: 6885 * Parameters:
6843 * handle: Handle to the window (widget). 6886 * handle: Handle to the window (widget).
6844 * text: Text usually returned by dw_container_query(). 6887 * text: Text usually returned by dw_container_query().
6845 */ 6888 */
6846 void dw_container_delete_row(HWND handle, char *text) 6889 void dw_container_delete_row(HWND handle, char *text)
6847 { 6890 {
6848 int _locked_by_me = FALSE; 6891 int _locked_by_me = FALSE;
6849 GtkWidget *clist; 6892 GtkWidget *clist;
6850 int rowcount, z; 6893 int rowcount, z;
6851 char *rowdata; 6894 char *rowdata;
6852 6895
6853 DW_MUTEX_LOCK; 6896 DW_MUTEX_LOCK;
6854 clist = (GtkWidget*)gtk_object_get_user_data(GTK_OBJECT(handle)); 6897 clist = (GtkWidget*)gtk_object_get_user_data(GTK_OBJECT(handle));
6855 6898
6856 if(!clist) 6899 if(!clist)
6857 { 6900 {
6858 DW_MUTEX_UNLOCK; 6901 DW_MUTEX_UNLOCK;
6859 return; 6902 return;
6860 } 6903 }
6861 rowcount = (int)gtk_object_get_data(GTK_OBJECT(clist), "_dw_rowcount"); 6904 rowcount = (int)gtk_object_get_data(GTK_OBJECT(clist), "_dw_rowcount");
6862 6905
6863 for(z=0;z<rowcount;z++) 6906 for(z=0;z<rowcount;z++)
6864 { 6907 {
6865 rowdata = gtk_clist_get_row_data(GTK_CLIST(clist), z); 6908 rowdata = gtk_clist_get_row_data(GTK_CLIST(clist), z);
6866 if(rowdata == text) 6909 if(rowdata == text)
6867 { 6910 {
6868 _dw_unselect(clist); 6911 _dw_unselect(clist);
6869 6912
6870 gtk_clist_remove(GTK_CLIST(clist), z); 6913 gtk_clist_remove(GTK_CLIST(clist), z);
6871 6914
6872 rowcount--; 6915 rowcount--;
6873 6916
6874 gtk_object_set_data(GTK_OBJECT(clist), "_dw_rowcount", (gpointer)rowcount); 6917 gtk_object_set_data(GTK_OBJECT(clist), "_dw_rowcount", GINT_TO_POINTER(rowcount));
6875 DW_MUTEX_UNLOCK; 6918 DW_MUTEX_UNLOCK;
6876 return; 6919 return;
6877 } 6920 }
6878 } 6921 }
6879 6922
6880 DW_MUTEX_UNLOCK; 6923 DW_MUTEX_UNLOCK;
6881 } 6924 }
6882 6925
6883 /* 6926 /*
6884 * Optimizes the column widths so that all data is visible. 6927 * Optimizes the column widths so that all data is visible.
6885 * Parameters: 6928 * Parameters:
6886 * handle: Handle to the window (widget) to be optimized. 6929 * handle: Handle to the window (widget) to be optimized.
6887 */ 6930 */
6888 void dw_container_optimize(HWND handle) 6931 void dw_container_optimize(HWND handle)
6889 { 6932 {
6890 int _locked_by_me = FALSE; 6933 int _locked_by_me = FALSE;
6891 GtkWidget *clist; 6934 GtkWidget *clist;
6892 int colcount, z; 6935 int colcount, z;
6893 6936
6894 DW_MUTEX_LOCK; 6937 DW_MUTEX_LOCK;
6895 clist = (GtkWidget*)gtk_object_get_user_data(GTK_OBJECT(handle)); 6938 clist = (GtkWidget*)gtk_object_get_user_data(GTK_OBJECT(handle));
6896 6939
6897 if(!clist) 6940 if(!clist)
6898 { 6941 {
6899 DW_MUTEX_UNLOCK; 6942 DW_MUTEX_UNLOCK;
6900 return; 6943 return;
6901 } 6944 }
6902 colcount = (int)gtk_object_get_data(GTK_OBJECT(clist), "_dw_colcount"); 6945 colcount = (int)gtk_object_get_data(GTK_OBJECT(clist), "_dw_colcount");
6903 for(z=0;z<colcount;z++) 6946 for(z=0;z<colcount;z++)
6904 { 6947 {
6905 int width = gtk_clist_optimal_column_width(GTK_CLIST(clist), z); 6948 int width = gtk_clist_optimal_column_width(GTK_CLIST(clist), z);
6906 gtk_clist_set_column_width(GTK_CLIST(clist), z, width); 6949 gtk_clist_set_column_width(GTK_CLIST(clist), z, width);
6907 } 6950 }
6908 DW_MUTEX_UNLOCK; 6951 DW_MUTEX_UNLOCK;
6909 } 6952 }
6910 6953
6911 /* 6954 /*
6912 * Inserts an icon into the taskbar. 6955 * Inserts an icon into the taskbar.
6913 * Parameters: 6956 * Parameters:
6915 * icon: Icon handle to display in the taskbar. 6958 * icon: Icon handle to display in the taskbar.
6916 * bubbletext: Text to show when the mouse is above the icon. 6959 * bubbletext: Text to show when the mouse is above the icon.
6917 */ 6960 */
6918 void dw_taskbar_insert(HWND handle, unsigned long icon, char *bubbletext) 6961 void dw_taskbar_insert(HWND handle, unsigned long icon, char *bubbletext)
6919 { 6962 {
6920 /* TODO */ 6963 /* TODO */
6921 } 6964 }
6922 6965
6923 /* 6966 /*
6924 * Deletes an icon from the taskbar. 6967 * Deletes an icon from the taskbar.
6925 * Parameters: 6968 * Parameters:
6926 * handle: Window handle that was used with dw_taskbar_insert(). 6969 * handle: Window handle that was used with dw_taskbar_insert().
6927 * icon: Icon handle that was used with dw_taskbar_insert(). 6970 * icon: Icon handle that was used with dw_taskbar_insert().
6928 */ 6971 */
6929 void dw_taskbar_delete(HWND handle, unsigned long icon) 6972 void dw_taskbar_delete(HWND handle, unsigned long icon)
6930 { 6973 {
6931 /* TODO */ 6974 /* TODO */
6932 } 6975 }
6933 6976
6934 /* 6977 /*
6935 * Creates a rendering context widget (window) to be packed. 6978 * Creates a rendering context widget (window) to be packed.
6936 * Parameters: 6979 * Parameters:
6938 * Returns: 6981 * Returns:
6939 * A handle to the widget or NULL on failure. 6982 * A handle to the widget or NULL on failure.
6940 */ 6983 */
6941 HWND dw_render_new(unsigned long id) 6984 HWND dw_render_new(unsigned long id)
6942 { 6985 {
6943 int _locked_by_me = FALSE; 6986 int _locked_by_me = FALSE;
6944 GtkWidget *tmp; 6987 GtkWidget *tmp;
6945 6988
6946 DW_MUTEX_LOCK; 6989 DW_MUTEX_LOCK;
6947 tmp = gtk_drawing_area_new(); 6990 tmp = gtk_drawing_area_new();
6948 gtk_widget_set_events(tmp, GDK_EXPOSURE_MASK 6991 gtk_widget_set_events(tmp, GDK_EXPOSURE_MASK
6949 | GDK_LEAVE_NOTIFY_MASK 6992 | GDK_LEAVE_NOTIFY_MASK
6950 | GDK_BUTTON_PRESS_MASK 6993 | GDK_BUTTON_PRESS_MASK
6951 | GDK_KEY_PRESS_MASK 6994 | GDK_KEY_PRESS_MASK
6952 | GDK_POINTER_MOTION_MASK 6995 | GDK_POINTER_MOTION_MASK
6953 | GDK_POINTER_MOTION_HINT_MASK); 6996 | GDK_POINTER_MOTION_HINT_MASK);
6954 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 6997 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
6955 GTK_WIDGET_SET_FLAGS(tmp, GTK_CAN_FOCUS); 6998 GTK_WIDGET_SET_FLAGS(tmp, GTK_CAN_FOCUS);
6956 gtk_widget_show(tmp); 6999 gtk_widget_show(tmp);
6957 DW_MUTEX_UNLOCK; 7000 DW_MUTEX_UNLOCK;
6958 return tmp; 7001 return tmp;
6959 } 7002 }
6960 7003
6961 /* Returns a GdkColor from a DW color */ 7004 /* Returns a GdkColor from a DW color */
6962 static GdkColor _internal_color(unsigned long value) 7005 static GdkColor _internal_color(unsigned long value)
6963 { 7006 {
6964 if(DW_RGB_COLOR & value) 7007 if(DW_RGB_COLOR & value)
6965 { 7008 {
6966 GdkColor color = { 0, DW_RED_VALUE(value) << 8, DW_GREEN_VALUE(value) << 8, DW_BLUE_VALUE(value) << 8 }; 7009 GdkColor color = { 0, DW_RED_VALUE(value) << 8, DW_GREEN_VALUE(value) << 8, DW_BLUE_VALUE(value) << 8 };
6967 return color; 7010 return color;
6968 } 7011 }
6969 if (value < 16) 7012 if (value < 16)
6970 return _colors[value]; 7013 return _colors[value];
6971 return _colors[0]; 7014 return _colors[0];
6972 } 7015 }
6973 7016
6974 /* Sets the current foreground drawing color. 7017 /* Sets the current foreground drawing color.
6975 * Parameters: 7018 * Parameters:
6976 * red: red value. 7019 * red: red value.
6977 * green: green value. 7020 * green: green value.
6978 * blue: blue value. 7021 * blue: blue value.
6979 */ 7022 */
6980 void dw_color_foreground_set(unsigned long value) 7023 void dw_color_foreground_set(unsigned long value)
6981 { 7024 {
6982 int _locked_by_me = FALSE, index = _find_thread_index(dw_thread_id()); 7025 int _locked_by_me = FALSE, index = _find_thread_index(dw_thread_id());
6983 GdkColor color = _internal_color(value); 7026 GdkColor color = _internal_color(value);
6984 7027
6985 DW_MUTEX_LOCK; 7028 DW_MUTEX_LOCK;
6986 gdk_color_alloc(_dw_cmap, &color); 7029 gdk_color_alloc(_dw_cmap, &color);
6987 _foreground[index] = color; 7030 _foreground[index] = color;
6988 DW_MUTEX_UNLOCK; 7031 DW_MUTEX_UNLOCK;
6989 } 7032 }
6990 7033
6991 /* Sets the current background drawing color. 7034 /* Sets the current background drawing color.
6992 * Parameters: 7035 * Parameters:
6993 * red: red value. 7036 * red: red value.
6994 * green: green value. 7037 * green: green value.
6995 * blue: blue value. 7038 * blue: blue value.
6996 */ 7039 */
6997 void dw_color_background_set(unsigned long value) 7040 void dw_color_background_set(unsigned long value)
6998 { 7041 {
6999 int _locked_by_me = FALSE, index = _find_thread_index(dw_thread_id()); 7042 int _locked_by_me = FALSE, index = _find_thread_index(dw_thread_id());
7000 GdkColor color = _internal_color(value); 7043 GdkColor color = _internal_color(value);
7001 7044
7002 DW_MUTEX_LOCK; 7045 DW_MUTEX_LOCK;
7003 gdk_color_alloc(_dw_cmap, &color); 7046 gdk_color_alloc(_dw_cmap, &color);
7004 if(value == DW_CLR_DEFAULT) 7047 if(value == DW_CLR_DEFAULT)
7005 _transparent[index] = 1; 7048 _transparent[index] = 1;
7006 else 7049 else
7007 _transparent[index] = 0; 7050 _transparent[index] = 0;
7008 7051
7009 _background[index] = color; 7052 _background[index] = color;
7010 DW_MUTEX_UNLOCK; 7053 DW_MUTEX_UNLOCK;
7011 } 7054 }
7012 7055
7013 /* Internal function to handle the color OK press */ 7056 /* Internal function to handle the color OK press */
7014 static gint _gtk_color_ok(GtkWidget *widget, DWDialog *dwwait) 7057 static gint _gtk_color_ok(GtkWidget *widget, DWDialog *dwwait)
7015 { 7058 {
7016 #if GTK_MAJOR_VERSION > 1 7059 #if GTK_MAJOR_VERSION > 1
7017 GdkColor color; 7060 GdkColor color;
7018 #else 7061 #else
7019 gdouble colors[4]; 7062 gdouble colors[4];
7020 #endif 7063 #endif
7021 unsigned long dw_color; 7064 unsigned long dw_color;
7022 GtkColorSelection *colorsel; 7065 GtkColorSelection *colorsel;
7023 7066
7024 if(!dwwait) 7067 if(!dwwait)
7025 return FALSE; 7068 return FALSE;
7026 7069
7027 colorsel = GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(dwwait->data)->colorsel); 7070 colorsel = GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(dwwait->data)->colorsel);
7028 #if GTK_MAJOR_VERSION > 1 7071 #if GTK_MAJOR_VERSION > 1
7029 gtk_color_selection_get_current_color(colorsel, &color); 7072 gtk_color_selection_get_current_color(colorsel, &color);
7030 #else 7073 #else
7031 gtk_color_selection_get_color(colorsel, colors); 7074 gtk_color_selection_get_color(colorsel, colors);
7032 #endif 7075 #endif
7033 gtk_widget_destroy(GTK_WIDGET(dwwait->data)); 7076 gtk_widget_destroy(GTK_WIDGET(dwwait->data));
7034 _dw_color_active = 0; 7077 _dw_color_active = 0;
7035 #if GTK_MAJOR_VERSION > 1 7078 #if GTK_MAJOR_VERSION > 1
7036 dw_color = DW_RGB( (color.red & 0xFF), (color.green & 0xFF), (color.blue & 0xFF)); 7079 dw_color = DW_RGB( (color.red & 0xFF), (color.green & 0xFF), (color.blue & 0xFF));
7037 #else 7080 #else
7038 dw_color = DW_RGB( (int)(colors[0] * 255), (int)(colors[1] * 255), (int)(colors[2] * 255)); 7081 dw_color = DW_RGB( (int)(colors[0] * 255), (int)(colors[1] * 255), (int)(colors[2] * 255));
7039 #endif 7082 #endif
7040 dw_dialog_dismiss(dwwait, (void *)dw_color); 7083 dw_dialog_dismiss(dwwait, (void *)dw_color);
7041 return FALSE; 7084 return FALSE;
7042 } 7085 }
7043 7086
7044 /* Internal function to handle the color Cancel press */ 7087 /* Internal function to handle the color Cancel press */
7045 static gint _gtk_color_cancel(GtkWidget *widget, DWDialog *dwwait) 7088 static gint _gtk_color_cancel(GtkWidget *widget, DWDialog *dwwait)
7046 { 7089 {
7047 if(!dwwait) 7090 if(!dwwait)
7048 return FALSE; 7091 return FALSE;
7049 7092
7050 gtk_widget_destroy(GTK_WIDGET(dwwait->data)); 7093 gtk_widget_destroy(GTK_WIDGET(dwwait->data));
7051 _dw_color_active = 0; 7094 _dw_color_active = 0;
7052 dw_dialog_dismiss(dwwait, (void *)-1); 7095 dw_dialog_dismiss(dwwait, (void *)-1);
7053 return FALSE; 7096 return FALSE;
7054 } 7097 }
7055 7098
7056 /* Allows the user to choose a color using the system's color chooser dialog. 7099 /* Allows the user to choose a color using the system's color chooser dialog.
7057 * Parameters: 7100 * Parameters:
7058 * value: current color 7101 * value: current color
7059 * Returns: 7102 * Returns:
7060 * The selected color or the current color if cancelled. 7103 * The selected color or the current color if cancelled.
7061 */ 7104 */
7062 unsigned long API dw_color_choose(unsigned long value) 7105 unsigned long API dw_color_choose(unsigned long value)
7063 { 7106 {
7064 GtkWidget *colorw; 7107 GtkWidget *colorw;
7065 int _locked_by_me = FALSE; 7108 int _locked_by_me = FALSE;
7066 DWDialog *dwwait; 7109 DWDialog *dwwait;
7067 GtkColorSelection *colorsel; 7110 GtkColorSelection *colorsel;
7068 #if GTK_MAJOR_VERSION > 1 7111 #if GTK_MAJOR_VERSION > 1
7069 GdkColor color = _internal_color(value); 7112 GdkColor color = _internal_color(value);
7070 #else 7113 #else
7071 gdouble colors[4]; 7114 gdouble colors[4];
7072 #endif 7115 #endif
7073 unsigned long dw_color; 7116 unsigned long dw_color;
7074 7117
7075 DW_MUTEX_LOCK; 7118 DW_MUTEX_LOCK;
7076 7119
7077 /* The DW mutex should be sufficient for 7120 /* The DW mutex should be sufficient for
7078 * insuring no thread changes this unknowingly. 7121 * insuring no thread changes this unknowingly.
7079 */ 7122 */
7080 if(_dw_color_active) 7123 if(_dw_color_active)
7081 { 7124 {
7082 DW_MUTEX_UNLOCK; 7125 DW_MUTEX_UNLOCK;
7083 return value; 7126 return value;
7084 } 7127 }
7085 7128
7086 _dw_color_active = 1; 7129 _dw_color_active = 1;
7087 7130
7088 colorw = gtk_color_selection_dialog_new("Select Color"); 7131 colorw = gtk_color_selection_dialog_new("Select Color");
7089 7132
7090 dwwait = dw_dialog_new((void *)colorw); 7133 dwwait = dw_dialog_new((void *)colorw);
7091 7134
7092 gtk_signal_connect(GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(colorw)->ok_button), "clicked", (GtkSignalFunc) _gtk_color_ok, dwwait); 7135 gtk_signal_connect(GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(colorw)->ok_button), "clicked", (GtkSignalFunc) _gtk_color_ok, dwwait);
7093 gtk_signal_connect(GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(colorw)->cancel_button), "clicked", (GtkSignalFunc) _gtk_color_cancel, dwwait); 7136 gtk_signal_connect(GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(colorw)->cancel_button), "clicked", (GtkSignalFunc) _gtk_color_cancel, dwwait);
7094 7137
7095 colorsel = GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(colorw)->colorsel); 7138 colorsel = GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(colorw)->colorsel);
7096 #if GTK_MAJOR_VERSION > 1 7139 #if GTK_MAJOR_VERSION > 1
7097 gtk_color_selection_set_previous_color(colorsel,&color); 7140 gtk_color_selection_set_previous_color(colorsel,&color);
7098 gtk_color_selection_set_current_color(colorsel,&color); 7141 gtk_color_selection_set_current_color(colorsel,&color);
7099 gtk_color_selection_set_has_palette(colorsel,TRUE); 7142 gtk_color_selection_set_has_palette(colorsel,TRUE);
7100 #else 7143 #else
7101 colors[0] = ((gdouble)DW_RED_VALUE(value) / (gdouble)255); 7144 colors[0] = ((gdouble)DW_RED_VALUE(value) / (gdouble)255);
7102 colors[1] = ((gdouble)DW_GREEN_VALUE(value) / (gdouble)255); 7145 colors[1] = ((gdouble)DW_GREEN_VALUE(value) / (gdouble)255);
7103 colors[2] = ((gdouble)DW_BLUE_VALUE(value) / (gdouble)255); 7146 colors[2] = ((gdouble)DW_BLUE_VALUE(value) / (gdouble)255);
7104 gtk_color_selection_set_color(colorsel, colors); 7147 gtk_color_selection_set_color(colorsel, colors);
7105 #endif 7148 #endif
7106 7149
7107 gtk_widget_show(colorw); 7150 gtk_widget_show(colorw);
7108 7151
7109 dw_color = (unsigned long)dw_dialog_wait(dwwait); 7152 dw_color = (unsigned long)dw_dialog_wait(dwwait);
7110 if ((unsigned long)dw_color == -1) 7153 if ((unsigned long)dw_color == -1)
7111 dw_color = value; 7154 dw_color = value;
7112 DW_MUTEX_UNLOCK; 7155 DW_MUTEX_UNLOCK;
7113 return (unsigned long)dw_color; 7156 return (unsigned long)dw_color;
7114 /* 7157 /*
7115 dw_messagebox("Not implemented", DW_MB_OK|DW_MB_INFORMATION, "This feature not yet supported."); 7158 dw_messagebox("Not implemented", DW_MB_OK|DW_MB_INFORMATION, "This feature not yet supported.");
7116 return value; 7159 return value;
7117 */ 7160 */
7118 } 7161 }
7119 7162
7120 GdkGC *_set_colors(GdkWindow *window) 7163 GdkGC *_set_colors(GdkWindow *window)
7121 { 7164 {
7122 GdkGC *gc = NULL; 7165 GdkGC *gc = NULL;
7123 int index = _find_thread_index(dw_thread_id()); 7166 int index = _find_thread_index(dw_thread_id());
7124 7167
7125 if(!window) 7168 if(!window)
7126 return NULL; 7169 return NULL;
7127 gc = gdk_gc_new(window); 7170 gc = gdk_gc_new(window);
7128 if(gc) 7171 if(gc)
7129 { 7172 {
7130 gdk_gc_set_foreground(gc, &_foreground[index]); 7173 gdk_gc_set_foreground(gc, &_foreground[index]);
7131 gdk_gc_set_background(gc, &_background[index]); 7174 gdk_gc_set_background(gc, &_background[index]);
7132 } 7175 }
7133 return gc; 7176 return gc;
7134 } 7177 }
7135 7178
7136 /* Draw a point on a window (preferably a render window). 7179 /* Draw a point on a window (preferably a render window).
7137 * Parameters: 7180 * Parameters:
7138 * handle: Handle to the window. 7181 * handle: Handle to the window.
7140 * x: X coordinate. 7183 * x: X coordinate.
7141 * y: Y coordinate. 7184 * y: Y coordinate.
7142 */ 7185 */
7143 void dw_draw_point(HWND handle, HPIXMAP pixmap, int x, int y) 7186 void dw_draw_point(HWND handle, HPIXMAP pixmap, int x, int y)
7144 { 7187 {
7145 int _locked_by_me = FALSE; 7188 int _locked_by_me = FALSE;
7146 GdkGC *gc = NULL; 7189 GdkGC *gc = NULL;
7147 7190
7148 DW_MUTEX_LOCK; 7191 DW_MUTEX_LOCK;
7149 if(handle) 7192 if(handle)
7150 gc = _set_colors(handle->window); 7193 gc = _set_colors(handle->window);
7151 else if(pixmap) 7194 else if(pixmap)
7152 gc = _set_colors(pixmap->pixmap); 7195 gc = _set_colors(pixmap->pixmap);
7153 if(gc) 7196 if(gc)
7154 { 7197 {
7155 gdk_draw_point(handle ? handle->window : pixmap->pixmap, gc, x, y); 7198 gdk_draw_point(handle ? handle->window : pixmap->pixmap, gc, x, y);
7156 gdk_gc_unref(gc); 7199 gdk_gc_unref(gc);
7157 } 7200 }
7158 DW_MUTEX_UNLOCK; 7201 DW_MUTEX_UNLOCK;
7159 } 7202 }
7160 7203
7161 /* Draw a line on a window (preferably a render window). 7204 /* Draw a line on a window (preferably a render window).
7162 * Parameters: 7205 * Parameters:
7163 * handle: Handle to the window. 7206 * handle: Handle to the window.
7167 * x2: Second X coordinate. 7210 * x2: Second X coordinate.
7168 * y2: Second Y coordinate. 7211 * y2: Second Y coordinate.
7169 */ 7212 */
7170 void dw_draw_line(HWND handle, HPIXMAP pixmap, int x1, int y1, int x2, int y2) 7213 void dw_draw_line(HWND handle, HPIXMAP pixmap, int x1, int y1, int x2, int y2)
7171 { 7214 {
7172 int _locked_by_me = FALSE; 7215 int _locked_by_me = FALSE;
7173 GdkGC *gc = NULL; 7216 GdkGC *gc = NULL;
7174 7217
7175 DW_MUTEX_LOCK; 7218 DW_MUTEX_LOCK;
7176 if(handle) 7219 if(handle)
7177 gc = _set_colors(handle->window); 7220 gc = _set_colors(handle->window);
7178 else if(pixmap) 7221 else if(pixmap)
7179 gc = _set_colors(pixmap->pixmap); 7222 gc = _set_colors(pixmap->pixmap);
7180 if(gc) 7223 if(gc)
7181 { 7224 {
7182 gdk_draw_line(handle ? handle->window : pixmap->pixmap, gc, x1, y1, x2, y2); 7225 gdk_draw_line(handle ? handle->window : pixmap->pixmap, gc, x1, y1, x2, y2);
7183 gdk_gc_unref(gc); 7226 gdk_gc_unref(gc);
7184 } 7227 }
7185 DW_MUTEX_UNLOCK; 7228 DW_MUTEX_UNLOCK;
7186 } 7229 }
7187 7230
7188 /* Draw a rectangle on a window (preferably a render window). 7231 /* Draw a rectangle on a window (preferably a render window).
7189 * Parameters: 7232 * Parameters:
7190 * handle: Handle to the window. 7233 * handle: Handle to the window.
7194 * width: Width of rectangle. 7237 * width: Width of rectangle.
7195 * height: Height of rectangle. 7238 * height: Height of rectangle.
7196 */ 7239 */
7197 void dw_draw_rect(HWND handle, HPIXMAP pixmap, int fill, int x, int y, int width, int height) 7240 void dw_draw_rect(HWND handle, HPIXMAP pixmap, int fill, int x, int y, int width, int height)
7198 { 7241 {
7199 int _locked_by_me = FALSE; 7242 int _locked_by_me = FALSE;
7200 GdkGC *gc = NULL; 7243 GdkGC *gc = NULL;
7201 7244
7202 DW_MUTEX_LOCK; 7245 DW_MUTEX_LOCK;
7203 if(handle) 7246 if(handle)
7204 gc = _set_colors(handle->window); 7247 gc = _set_colors(handle->window);
7205 else if(pixmap) 7248 else if(pixmap)
7206 gc = _set_colors(pixmap->pixmap); 7249 gc = _set_colors(pixmap->pixmap);
7207 if(gc) 7250 if(gc)
7208 { 7251 {
7209 gdk_draw_rectangle(handle ? handle->window : pixmap->pixmap, gc, fill, x, y, width, height); 7252 gdk_draw_rectangle(handle ? handle->window : pixmap->pixmap, gc, fill, x, y, width, height);
7210 gdk_gc_unref(gc); 7253 gdk_gc_unref(gc);
7211 } 7254 }
7212 DW_MUTEX_UNLOCK; 7255 DW_MUTEX_UNLOCK;
7213 } 7256 }
7214 7257
7215 /* Draw text on a window (preferably a render window). 7258 /* Draw text on a window (preferably a render window).
7216 * Parameters: 7259 * Parameters:
7217 * handle: Handle to the window. 7260 * handle: Handle to the window.
7220 * y: Y coordinate. 7263 * y: Y coordinate.
7221 * text: Text to be displayed. 7264 * text: Text to be displayed.
7222 */ 7265 */
7223 void dw_draw_text(HWND handle, HPIXMAP pixmap, int x, int y, char *text) 7266 void dw_draw_text(HWND handle, HPIXMAP pixmap, int x, int y, char *text)
7224 { 7267 {
7225 int _locked_by_me = FALSE; 7268 int _locked_by_me = FALSE;
7226 GdkGC *gc = NULL; 7269 GdkGC *gc = NULL;
7227 #if GTK_MAJOR_VERSION > 1 7270 #if GTK_MAJOR_VERSION > 1
7228 PangoFontDescription *font; 7271 PangoFontDescription *font;
7229 #else 7272 #else
7230 GdkFont *font; 7273 GdkFont *font;
7231 #endif 7274 #endif
7232 char *fontname = "fixed"; 7275 char *fontname = "fixed";
7233 7276
7234 if(!text) 7277 if(!text)
7235 return; 7278 return;
7236 7279
7237 DW_MUTEX_LOCK; 7280 DW_MUTEX_LOCK;
7238 if(handle) 7281 if(handle)
7239 { 7282 {
7240 fontname = (char *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_fontname"); 7283 fontname = (char *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_fontname");
7241 gc = _set_colors(handle->window); 7284 gc = _set_colors(handle->window);
7242 } 7285 }
7243 else if(pixmap) 7286 else if(pixmap)
7244 { 7287 {
7245 fontname = (char *)gtk_object_get_data(GTK_OBJECT(pixmap->handle), "_dw_fontname"); 7288 fontname = (char *)gtk_object_get_data(GTK_OBJECT(pixmap->handle), "_dw_fontname");
7246 gc = _set_colors(pixmap->pixmap); 7289 gc = _set_colors(pixmap->pixmap);
7247 } 7290 }
7248 if(gc) 7291 if(gc)
7249 { 7292 {
7250 #if GTK_MAJOR_VERSION > 1 7293 #if GTK_MAJOR_VERSION > 1
7251 font = pango_font_description_from_string(fontname); 7294 font = pango_font_description_from_string(fontname);
7252 if(font) 7295 if(font)
7253 { 7296 {
7254 PangoContext *context = gdk_pango_context_get(); 7297 PangoContext *context = gdk_pango_context_get();
7255 7298
7256 if(context) 7299 if(context)
7257 { 7300 {
7258 PangoLayout *layout = pango_layout_new(context); 7301 PangoLayout *layout = pango_layout_new(context);
7259 7302
7260 if(layout) 7303 if(layout)
7261 { 7304 {
7262 int index = _find_thread_index(dw_thread_id()); 7305 int index = _find_thread_index(dw_thread_id());
7263 7306
7264 gdk_pango_context_set_colormap(context, _dw_cmap); 7307 gdk_pango_context_set_colormap(context, _dw_cmap);
7265 pango_layout_set_font_description(layout, font); 7308 pango_layout_set_font_description(layout, font);
7266 pango_layout_set_text(layout, text, strlen(text)); 7309 pango_layout_set_text(layout, text, strlen(text));
7267 7310
7268 if(_transparent[index]) 7311 if(_transparent[index])
7269 gdk_draw_layout(handle ? handle->window : pixmap->pixmap, gc, x, y, layout); 7312 gdk_draw_layout(handle ? handle->window : pixmap->pixmap, gc, x, y, layout);
7270 else 7313 else
7271 gdk_draw_layout_with_colors(handle ? handle->window : pixmap->pixmap, gc, x, y, layout, &_foreground[index], &_background[index]); 7314 gdk_draw_layout_with_colors(handle ? handle->window : pixmap->pixmap, gc, x, y, layout, &_foreground[index], &_background[index]);
7272 7315
7273 g_object_unref(layout); 7316 g_object_unref(layout);
7274 } 7317 }
7275 g_object_unref(context); 7318 g_object_unref(context);
7276 } 7319 }
7277 pango_font_description_free(font); 7320 pango_font_description_free(font);
7278 } 7321 }
7279 #else 7322 #else
7280 font = gdk_font_load(fontname); 7323 font = gdk_font_load(fontname);
7281 if(!font) 7324 if(!font)
7282 font = gdk_font_load("fixed"); 7325 font = gdk_font_load("fixed");
7283 if(font) 7326 if(font)
7284 { 7327 {
7285 gint ascent, descent, width, junk_ascent, junk_descent, junk_width; 7328 gint ascent, descent, width, junk_ascent, junk_descent, junk_width;
7286 int index = _find_thread_index(dw_thread_id()); 7329 int index = _find_thread_index(dw_thread_id());
7287 7330
7288 /* gdk_text_extents() calculates ascent and descent based on the string, so 7331 /* gdk_text_extents() calculates ascent and descent based on the string, so
7289 * a string without a character with a descent or without an ascent will have 7332 * a string without a character with a descent or without an ascent will have
7290 * incorrect ascent/descent values 7333 * incorrect ascent/descent values
7291 */ 7334 */
7292 gdk_text_extents(font, text, strlen(text), NULL, NULL, &width, &junk_ascent, &junk_descent); 7335 gdk_text_extents(font, text, strlen(text), NULL, NULL, &width, &junk_ascent, &junk_descent);
7293 /* force ascent/descent to be maximum values */ 7336 /* force ascent/descent to be maximum values */
7294 gdk_text_extents(font, "(g", 2, NULL, NULL, &junk_width, &ascent, &descent); 7337 gdk_text_extents(font, "(g", 2, NULL, NULL, &junk_width, &ascent, &descent);
7295 if(!_transparent[index]) 7338 if(!_transparent[index])
7296 { 7339 {
7297 GdkGC *gc2 = NULL; 7340 GdkGC *gc2 = NULL;
7298 7341
7299 gc2 = gdk_gc_new(handle ? handle->window : pixmap->pixmap); 7342 gc2 = gdk_gc_new(handle ? handle->window : pixmap->pixmap);
7300 if(gc2) 7343 if(gc2)
7301 { 7344 {
7302 gdk_gc_set_foreground(gc2, &_background[index]); 7345 gdk_gc_set_foreground(gc2, &_background[index]);
7303 gdk_gc_set_background(gc2, &_background[index]); 7346 gdk_gc_set_background(gc2, &_background[index]);
7304 } 7347 }
7305 gdk_draw_rectangle(handle ? handle->window : pixmap->pixmap, gc2, TRUE, x, y, width, ascent + descent + 1); 7348 gdk_draw_rectangle(handle ? handle->window : pixmap->pixmap, gc2, TRUE, x, y, width, ascent + descent + 1);
7306 gdk_gc_unref(gc2); 7349 gdk_gc_unref(gc2);
7307 } 7350 }
7308 gdk_draw_text(handle ? handle->window : pixmap->pixmap, font, gc, x, y + ascent + 1, text, strlen(text)); 7351 gdk_draw_text(handle ? handle->window : pixmap->pixmap, font, gc, x, y + ascent + 1, text, strlen(text));
7309 gdk_font_unref(font); 7352 gdk_font_unref(font);
7310 } 7353 }
7311 #endif 7354 #endif
7312 gdk_gc_unref(gc); 7355 gdk_gc_unref(gc);
7313 } 7356 }
7314 DW_MUTEX_UNLOCK; 7357 DW_MUTEX_UNLOCK;
7315 } 7358 }
7316 7359
7317 /* Query the width and height of a text string. 7360 /* Query the width and height of a text string.
7318 * Parameters: 7361 * Parameters:
7319 * handle: Handle to the window. 7362 * handle: Handle to the window.
7322 * width: Pointer to a variable to be filled in with the width. 7365 * width: Pointer to a variable to be filled in with the width.
7323 * height Pointer to a variable to be filled in with the height. 7366 * height Pointer to a variable to be filled in with the height.
7324 */ 7367 */
7325 void dw_font_text_extents_get(HWND handle, HPIXMAP pixmap, char *text, int *width, int *height) 7368 void dw_font_text_extents_get(HWND handle, HPIXMAP pixmap, char *text, int *width, int *height)
7326 { 7369 {
7327 int _locked_by_me = FALSE; 7370 int _locked_by_me = FALSE;
7328 #if GTK_MAJOR_VERSION > 1 7371 #if GTK_MAJOR_VERSION > 1
7329 PangoFontDescription *font; 7372 PangoFontDescription *font;
7330 #else 7373 #else
7331 GdkFont *font; 7374 GdkFont *font;
7332 #endif 7375 #endif
7333 char *fontname = NULL; 7376 char *fontname = NULL;
7334 7377
7335 if(!text) 7378 if(!text)
7336 return; 7379 return;
7337 7380
7338 DW_MUTEX_LOCK; 7381 DW_MUTEX_LOCK;
7339 if(handle) 7382 if(handle)
7340 fontname = (char *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_fontname"); 7383 fontname = (char *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_fontname");
7341 else if(pixmap) 7384 else if(pixmap)
7342 fontname = (char *)gtk_object_get_data(GTK_OBJECT(pixmap->handle), "_dw_fontname"); 7385 fontname = (char *)gtk_object_get_data(GTK_OBJECT(pixmap->handle), "_dw_fontname");
7343 7386
7344 #if GTK_MAJOR_VERSION > 1 7387 #if GTK_MAJOR_VERSION > 1
7345 font = pango_font_description_from_string(fontname ? fontname : "monospace 10"); 7388 font = pango_font_description_from_string(fontname ? fontname : "monospace 10");
7346 if(font) 7389 if(font)
7347 { 7390 {
7348 PangoContext *context = gdk_pango_context_get(); 7391 PangoContext *context = gdk_pango_context_get();
7349 7392
7350 if(context) 7393 if(context)
7351 { 7394 {
7352 PangoLayout *layout = pango_layout_new(context); 7395 PangoLayout *layout = pango_layout_new(context);
7353 7396
7354 if(layout) 7397 if(layout)
7355 { 7398 {
7356 PangoRectangle rect; 7399 PangoRectangle rect;
7357 7400
7358 pango_layout_set_font_description(layout, font); 7401 pango_layout_set_font_description(layout, font);
7359 pango_layout_set_text(layout, text, -1); 7402 pango_layout_set_text(layout, text, -1);
7360 pango_layout_get_pixel_extents(layout, NULL, &rect); 7403 pango_layout_get_pixel_extents(layout, NULL, &rect);
7361 7404
7362 if(width) 7405 if(width)
7363 *width = rect.width; 7406 *width = rect.width;
7364 if(height) 7407 if(height)
7365 *height = rect.height; 7408 *height = rect.height;
7366 7409
7367 g_object_unref(layout); 7410 g_object_unref(layout);
7368 } 7411 }
7369 g_object_unref(context); 7412 g_object_unref(context);
7370 } 7413 }
7371 pango_font_description_free(font); 7414 pango_font_description_free(font);
7372 } 7415 }
7373 #else 7416 #else
7374 7417
7375 font = gdk_font_load(fontname ? fontname : "fixed"); 7418 font = gdk_font_load(fontname ? fontname : "fixed");
7376 if(!font) 7419 if(!font)
7377 font = gdk_font_load("fixed"); 7420 font = gdk_font_load("fixed");
7378 if(font) 7421 if(font)
7379 { 7422 {
7380 if(width) 7423 if(width)
7381 *width = gdk_string_width(font, text); 7424 *width = gdk_string_width(font, text);
7382 if(height) 7425 if(height)
7383 *height = gdk_string_height(font, text); 7426 *height = gdk_string_height(font, text);
7384 gdk_font_unref(font); 7427 gdk_font_unref(font);
7385 } 7428 }
7386 #endif 7429 #endif
7387 DW_MUTEX_UNLOCK; 7430 DW_MUTEX_UNLOCK;
7388 } 7431 }
7389 7432
7390 /* 7433 /*
7391 * Creates a pixmap with given parameters. 7434 * Creates a pixmap with given parameters.
7392 * Parameters: 7435 * Parameters:
7397 * Returns: 7440 * Returns:
7398 * A handle to a pixmap or NULL on failure. 7441 * A handle to a pixmap or NULL on failure.
7399 */ 7442 */
7400 HPIXMAP dw_pixmap_new(HWND handle, unsigned long width, unsigned long height, int depth) 7443 HPIXMAP dw_pixmap_new(HWND handle, unsigned long width, unsigned long height, int depth)
7401 { 7444 {
7402 int _locked_by_me = FALSE; 7445 int _locked_by_me = FALSE;
7403 HPIXMAP pixmap; 7446 HPIXMAP pixmap;
7404 7447
7405 if (!(pixmap = calloc(1,sizeof(struct _hpixmap)))) 7448 if (!(pixmap = calloc(1,sizeof(struct _hpixmap))))
7406 return NULL; 7449 return NULL;
7407 7450
7408 if (!depth) 7451 if (!depth)
7409 depth = -1; 7452 depth = -1;
7410 7453
7411 pixmap->width = width; pixmap->height = height; 7454 pixmap->width = width; pixmap->height = height;
7412 7455
7413 7456
7414 DW_MUTEX_LOCK; 7457 DW_MUTEX_LOCK;
7415 pixmap->handle = handle; 7458 pixmap->handle = handle;
7416 pixmap->pixmap = gdk_pixmap_new(handle->window, width, height, depth); 7459 pixmap->pixmap = gdk_pixmap_new(handle->window, width, height, depth);
7417 DW_MUTEX_UNLOCK; 7460 DW_MUTEX_UNLOCK;
7418 return pixmap; 7461 return pixmap;
7419 } 7462 }
7420 7463
7421 /* 7464 /*
7422 * Creates a pixmap from a file. 7465 * Creates a pixmap from a file.
7423 * Parameters: 7466 * Parameters:
7561 * Returns: 7604 * Returns:
7562 * A handle to a pixmap or NULL on failure. 7605 * A handle to a pixmap or NULL on failure.
7563 */ 7606 */
7564 HPIXMAP dw_pixmap_grab(HWND handle, ULONG id) 7607 HPIXMAP dw_pixmap_grab(HWND handle, ULONG id)
7565 { 7608 {
7566 GdkBitmap *bitmap = NULL; 7609 GdkBitmap *bitmap = NULL;
7567 HPIXMAP pixmap; 7610 HPIXMAP pixmap;
7568 int _locked_by_me = FALSE; 7611 int _locked_by_me = FALSE;
7569 7612
7570 if (!(pixmap = calloc(1,sizeof(struct _hpixmap)))) 7613 if (!(pixmap = calloc(1,sizeof(struct _hpixmap))))
7571 return NULL; 7614 return NULL;
7572 7615
7573 7616
7574 DW_MUTEX_LOCK; 7617 DW_MUTEX_LOCK;
7575 pixmap->pixmap = _find_pixmap(&bitmap, id, handle, &pixmap->width, &pixmap->height); 7618 pixmap->pixmap = _find_pixmap(&bitmap, id, handle, &pixmap->width, &pixmap->height);
7576 if(pixmap->pixmap) 7619 if(pixmap->pixmap)
7577 { 7620 {
7578 #if GTK_MAJOR_VERSION < 2 7621 #if GTK_MAJOR_VERSION < 2
7579 GdkPixmapPrivate *pvt = (GdkPixmapPrivate *)pixmap->pixmap; 7622 GdkPixmapPrivate *pvt = (GdkPixmapPrivate *)pixmap->pixmap;
7580 pixmap->width = pvt->width; pixmap->height = pvt->height; 7623 pixmap->width = pvt->width; pixmap->height = pvt->height;
7581 #endif 7624 #endif
7582 } 7625 }
7583 DW_MUTEX_UNLOCK; 7626 DW_MUTEX_UNLOCK;
7584 return pixmap; 7627 return pixmap;
7585 } 7628 }
7586 7629
7587 /* Call this after drawing to the screen to make sure 7630 /* Call this after drawing to the screen to make sure
7588 * anything you have drawn is visible. 7631 * anything you have drawn is visible.
7589 */ 7632 */
7590 void dw_flush(void) 7633 void dw_flush(void)
7591 { 7634 {
7592 #if GTK_MAJOR_VERSION < 2 7635 #if GTK_MAJOR_VERSION < 2
7593 int _locked_by_me = FALSE; 7636 int _locked_by_me = FALSE;
7594 7637
7595 DW_MUTEX_LOCK; 7638 DW_MUTEX_LOCK;
7596 gdk_flush(); 7639 gdk_flush();
7597 DW_MUTEX_UNLOCK; 7640 DW_MUTEX_UNLOCK;
7598 #endif 7641 #endif
7599 } 7642 }
7600 7643
7601 /* 7644 /*
7602 * Destroys an allocated pixmap. 7645 * Destroys an allocated pixmap.
7604 * pixmap: Handle to a pixmap returned by 7647 * pixmap: Handle to a pixmap returned by
7605 * dw_pixmap_new.. 7648 * dw_pixmap_new..
7606 */ 7649 */
7607 void dw_pixmap_destroy(HPIXMAP pixmap) 7650 void dw_pixmap_destroy(HPIXMAP pixmap)
7608 { 7651 {
7609 int _locked_by_me = FALSE; 7652 int _locked_by_me = FALSE;
7610 7653
7611 DW_MUTEX_LOCK; 7654 DW_MUTEX_LOCK;
7612 gdk_pixmap_unref(pixmap->pixmap); 7655 gdk_pixmap_unref(pixmap->pixmap);
7613 free(pixmap); 7656 free(pixmap);
7614 DW_MUTEX_UNLOCK; 7657 DW_MUTEX_UNLOCK;
7615 } 7658 }
7616 7659
7617 /* 7660 /*
7618 * Copies from one item to another. 7661 * Copies from one item to another.
7619 * Parameters: 7662 * Parameters:
7628 * xsrc: X coordinate of source. 7671 * xsrc: X coordinate of source.
7629 * ysrc: Y coordinate of source. 7672 * ysrc: Y coordinate of source.
7630 */ 7673 */
7631 void dw_pixmap_bitblt(HWND dest, HPIXMAP destp, int xdest, int ydest, int width, int height, HWND src, HPIXMAP srcp, int xsrc, int ysrc) 7674 void dw_pixmap_bitblt(HWND dest, HPIXMAP destp, int xdest, int ydest, int width, int height, HWND src, HPIXMAP srcp, int xsrc, int ysrc)
7632 { 7675 {
7633 /* Ok, these #ifdefs are going to get a bit confusing because 7676 /* Ok, these #ifdefs are going to get a bit confusing because
7634 * when using gdk-pixbuf, pixmaps are really pixbufs, so we 7677 * when using gdk-pixbuf, pixmaps are really pixbufs, so we
7635 * have to use the pixbuf functions on them, and thus convoluting 7678 * have to use the pixbuf functions on them, and thus convoluting
7636 * the code here a bit. -Brian 7679 * the code here a bit. -Brian
7637 */ 7680 */
7638 int _locked_by_me = FALSE; 7681 int _locked_by_me = FALSE;
7639 GdkGC *gc = NULL; 7682 GdkGC *gc = NULL;
7640 7683
7641 if((!dest && (!destp || !destp->pixmap)) || (!src && (!srcp || !srcp->pixmap))) 7684 if((!dest && (!destp || !destp->pixmap)) || (!src && (!srcp || !srcp->pixmap)))
7642 return; 7685 return;
7643 7686
7644 DW_MUTEX_LOCK; 7687 DW_MUTEX_LOCK;
7645 if(dest) 7688 if(dest)
7646 gc = _set_colors(dest->window); 7689 gc = _set_colors(dest->window);
7647 else if(src) 7690 else if(src)
7648 gc = _set_colors(src->window); 7691 gc = _set_colors(src->window);
7649 else if(destp) 7692 else if(destp)
7650 gc = gdk_gc_new(destp->pixmap); 7693 gc = gdk_gc_new(destp->pixmap);
7651 else if(srcp) 7694 else if(srcp)
7652 gc = gdk_gc_new(srcp->pixmap); 7695 gc = gdk_gc_new(srcp->pixmap);
7653 7696
7654 if(gc) 7697 if(gc)
7655 { 7698 {
7656 gdk_draw_pixmap(dest ? dest->window : destp->pixmap, gc, src ? src->window : srcp->pixmap, xsrc, ysrc, xdest, ydest, width, height); 7699 gdk_draw_pixmap(dest ? dest->window : destp->pixmap, gc, src ? src->window : srcp->pixmap, xsrc, ysrc, xdest, ydest, width, height);
7657 gdk_gc_unref(gc); 7700 gdk_gc_unref(gc);
7658 } 7701 }
7659 DW_MUTEX_UNLOCK; 7702 DW_MUTEX_UNLOCK;
7660 } 7703 }
7661 7704
7662 /* 7705 /*
7663 * Emits a beep. 7706 * Emits a beep.
7664 * Parameters: 7707 * Parameters:
7665 * freq: Frequency. 7708 * freq: Frequency.
7666 * dur: Duration. 7709 * dur: Duration.
7667 */ 7710 */
7668 void dw_beep(int freq, int dur) 7711 void dw_beep(int freq, int dur)
7669 { 7712 {
7670 int _locked_by_me = FALSE; 7713 int _locked_by_me = FALSE;
7671 7714
7672 DW_MUTEX_LOCK; 7715 DW_MUTEX_LOCK;
7673 gdk_beep(); 7716 gdk_beep();
7674 DW_MUTEX_UNLOCK; 7717 DW_MUTEX_UNLOCK;
7675 } 7718 }
7676 7719
7677 void _my_strlwr(char *buf) 7720 void _my_strlwr(char *buf)
7678 { 7721 {
7679 int z, len = strlen(buf); 7722 int z, len = strlen(buf);
7680 7723
7681 for(z=0;z<len;z++) 7724 for(z=0;z<len;z++)
7682 { 7725 {
7683 if(buf[z] >= 'A' && buf[z] <= 'Z') 7726 if(buf[z] >= 'A' && buf[z] <= 'Z')
7684 buf[z] -= 'A' - 'a'; 7727 buf[z] -= 'A' - 'a';
7685 } 7728 }
7686 } 7729 }
7687 7730
7688 /* Open a shared library and return a handle. 7731 /* Open a shared library and return a handle.
7689 * Parameters: 7732 * Parameters:
7690 * name: Base name of the shared library. 7733 * name: Base name of the shared library.
7691 * handle: Pointer to a module handle, 7734 * handle: Pointer to a module handle,
7692 * will be filled in with the handle. 7735 * will be filled in with the handle.
7693 */ 7736 */
7694 int dw_module_load(char *name, HMOD *handle) 7737 int dw_module_load(char *name, HMOD *handle)
7695 { 7738 {
7696 int len; 7739 int len;
7697 char *newname; 7740 char *newname;
7698 char errorbuf[1024]; 7741 char errorbuf[1024];
7699 7742
7700 7743
7701 if(!handle) 7744 if(!handle)
7702 return -1; 7745 return -1;
7703 7746
7704 if((len = strlen(name)) == 0) 7747 if((len = strlen(name)) == 0)
7705 return -1; 7748 return -1;
7706 7749
7707 /* Lenth + "lib" + ".so" + NULL */ 7750 /* Lenth + "lib" + ".so" + NULL */
7708 newname = malloc(len + 7); 7751 newname = malloc(len + 7);
7709 7752
7710 if(!newname) 7753 if(!newname)
7711 return -1; 7754 return -1;
7712 7755
7713 sprintf(newname, "lib%s.so", name); 7756 sprintf(newname, "lib%s.so", name);
7714 _my_strlwr(newname); 7757 _my_strlwr(newname);
7715 7758
7716 *handle = dlopen(newname, RTLD_NOW); 7759 *handle = dlopen(newname, RTLD_NOW);
7717 if(*handle == NULL) 7760 if(*handle == NULL)
7718 { 7761 {
7719 strncpy(errorbuf, dlerror(), 1024); 7762 strncpy(errorbuf, dlerror(), 1024);
7720 printf("%s\n", errorbuf); 7763 printf("%s\n", errorbuf);
7721 sprintf(newname, "lib%s.so", name); 7764 sprintf(newname, "lib%s.so", name);
7722 *handle = dlopen(newname, RTLD_NOW); 7765 *handle = dlopen(newname, RTLD_NOW);
7723 } 7766 }
7724 7767
7725 free(newname); 7768 free(newname);
7726 7769
7727 return (NULL == *handle) ? -1 : 0; 7770 return (NULL == *handle) ? -1 : 0;
7728 } 7771 }
7729 7772
7730 /* Queries the address of a symbol within open handle. 7773 /* Queries the address of a symbol within open handle.
7731 * Parameters: 7774 * Parameters:
7732 * handle: Module handle returned by dw_module_load() 7775 * handle: Module handle returned by dw_module_load()
7734 * func: A pointer to a function pointer, to obtain 7777 * func: A pointer to a function pointer, to obtain
7735 * the address. 7778 * the address.
7736 */ 7779 */
7737 int dw_module_symbol(HMOD handle, char *name, void**func) 7780 int dw_module_symbol(HMOD handle, char *name, void**func)
7738 { 7781 {
7739 if(!func || !name) 7782 if(!func || !name)
7740 return -1; 7783 return -1;
7741 7784
7742 if(strlen(name) == 0) 7785 if(strlen(name) == 0)
7743 return -1; 7786 return -1;
7744 7787
7745 *func = (void*)dlsym(handle, name); 7788 *func = (void*)dlsym(handle, name);
7746 return (NULL == *func); 7789 return (NULL == *func);
7747 } 7790 }
7748 7791
7749 /* Frees the shared library previously opened. 7792 /* Frees the shared library previously opened.
7750 * Parameters: 7793 * Parameters:
7751 * handle: Module handle returned by dw_module_load() 7794 * handle: Module handle returned by dw_module_load()
7752 */ 7795 */
7753 int dw_module_close(HMOD handle) 7796 int dw_module_close(HMOD handle)
7754 { 7797 {
7755 if(handle) 7798 if(handle)
7756 return dlclose(handle); 7799 return dlclose(handle);
7757 return 0; 7800 return 0;
7758 } 7801 }
7759 7802
7760 /* 7803 /*
7761 * Returns the handle to an unnamed mutex semaphore. 7804 * Returns the handle to an unnamed mutex semaphore.
7762 */ 7805 */
7763 HMTX dw_mutex_new(void) 7806 HMTX dw_mutex_new(void)
7764 { 7807 {
7765 HMTX mutex = malloc(sizeof(pthread_mutex_t)); 7808 HMTX mutex = malloc(sizeof(pthread_mutex_t));
7766 7809
7767 pthread_mutex_init(mutex, NULL); 7810 pthread_mutex_init(mutex, NULL);
7768 return mutex; 7811 return mutex;
7769 } 7812 }
7770 7813
7771 /* 7814 /*
7772 * Closes a semaphore created by dw_mutex_new(). 7815 * Closes a semaphore created by dw_mutex_new().
7773 * Parameters: 7816 * Parameters:
7774 * mutex: The handle to the mutex returned by dw_mutex_new(). 7817 * mutex: The handle to the mutex returned by dw_mutex_new().
7775 */ 7818 */
7776 void dw_mutex_close(HMTX mutex) 7819 void dw_mutex_close(HMTX mutex)
7777 { 7820 {
7778 if(mutex) 7821 if(mutex)
7779 { 7822 {
7780 pthread_mutex_destroy(mutex); 7823 pthread_mutex_destroy(mutex);
7781 free(mutex); 7824 free(mutex);
7782 } 7825 }
7783 } 7826 }
7784 7827
7785 /* 7828 /*
7786 * Tries to gain access to the semaphore, if it can't it blocks. 7829 * Tries to gain access to the semaphore, if it can't it blocks.
7787 * Parameters: 7830 * Parameters:
7788 * mutex: The handle to the mutex returned by dw_mutex_new(). 7831 * mutex: The handle to the mutex returned by dw_mutex_new().
7789 */ 7832 */
7790 void dw_mutex_lock(HMTX mutex) 7833 void dw_mutex_lock(HMTX mutex)
7791 { 7834 {
7792 /* If we are being called from an event handler we must release 7835 /* If we are being called from an event handler we must release
7793 * the GTK mutex so we don't deadlock. 7836 * the GTK mutex so we don't deadlock.
7794 */ 7837 */
7795 if(pthread_self() == _dw_thread) 7838 if(pthread_self() == _dw_thread)
7796 gdk_threads_leave(); 7839 gdk_threads_leave();
7797 7840
7798 pthread_mutex_lock(mutex); 7841 pthread_mutex_lock(mutex);
7799 7842
7800 /* And of course relock it when we have acquired the mutext */ 7843 /* And of course relock it when we have acquired the mutext */
7801 if(pthread_self() == _dw_thread) 7844 if(pthread_self() == _dw_thread)
7802 gdk_threads_enter(); 7845 gdk_threads_enter();
7803 } 7846 }
7804 7847
7805 /* 7848 /*
7806 * Reliquishes the access to the semaphore. 7849 * Reliquishes the access to the semaphore.
7807 * Parameters: 7850 * Parameters:
7808 * mutex: The handle to the mutex returned by dw_mutex_new(). 7851 * mutex: The handle to the mutex returned by dw_mutex_new().
7809 */ 7852 */
7810 void dw_mutex_unlock(HMTX mutex) 7853 void dw_mutex_unlock(HMTX mutex)
7811 { 7854 {
7812 pthread_mutex_unlock(mutex); 7855 pthread_mutex_unlock(mutex);
7813 } 7856 }
7814 7857
7815 /* 7858 /*
7816 * Returns the handle to an unnamed event semaphore. 7859 * Returns the handle to an unnamed event semaphore.
7817 */ 7860 */
7818 HEV dw_event_new(void) 7861 HEV dw_event_new(void)
7819 { 7862 {
7820 HEV eve = (HEV)malloc(sizeof(struct _dw_unix_event)); 7863 HEV eve = (HEV)malloc(sizeof(struct _dw_unix_event));
7821 7864
7822 if(!eve) 7865 if(!eve)
7823 return NULL; 7866 return NULL;
7824 7867
7825 /* We need to be careful here, mutexes on Linux are 7868 /* We need to be careful here, mutexes on Linux are
7826 * FAST by default but are error checking on other 7869 * FAST by default but are error checking on other
7827 * systems such as FreeBSD and OS/2, perhaps others. 7870 * systems such as FreeBSD and OS/2, perhaps others.
7828 */ 7871 */
7829 pthread_mutex_init (&(eve->mutex), NULL); 7872 pthread_mutex_init (&(eve->mutex), NULL);
7830 pthread_mutex_lock (&(eve->mutex)); 7873 pthread_mutex_lock (&(eve->mutex));
7831 pthread_cond_init (&(eve->event), NULL); 7874 pthread_cond_init (&(eve->event), NULL);
7832 7875
7833 pthread_mutex_unlock (&(eve->mutex)); 7876 pthread_mutex_unlock (&(eve->mutex));
7834 eve->alive = 1; 7877 eve->alive = 1;
7835 eve->posted = 0; 7878 eve->posted = 0;
7836 7879
7837 return eve; 7880 return eve;
7838 } 7881 }
7839 7882
7840 /* 7883 /*
7841 * Resets a semaphore created by dw_event_new(). 7884 * Resets a semaphore created by dw_event_new().
7842 * Parameters: 7885 * Parameters:
7843 * eve: The handle to the event returned by dw_event_new(). 7886 * eve: The handle to the event returned by dw_event_new().
7844 */ 7887 */
7845 int dw_event_reset (HEV eve) 7888 int dw_event_reset (HEV eve)
7846 { 7889 {
7847 if(!eve) 7890 if(!eve)
7848 return FALSE; 7891 return FALSE;
7849 7892
7850 pthread_mutex_lock (&(eve->mutex)); 7893 pthread_mutex_lock (&(eve->mutex));
7851 pthread_cond_broadcast (&(eve->event)); 7894 pthread_cond_broadcast (&(eve->event));
7852 pthread_cond_init (&(eve->event), NULL); 7895 pthread_cond_init (&(eve->event), NULL);
7853 eve->posted = 0; 7896 eve->posted = 0;
7854 pthread_mutex_unlock (&(eve->mutex)); 7897 pthread_mutex_unlock (&(eve->mutex));
7855 return 0; 7898 return 0;
7856 } 7899 }
7857 7900
7858 /* 7901 /*
7859 * Posts a semaphore created by dw_event_new(). Causing all threads 7902 * Posts a semaphore created by dw_event_new(). Causing all threads
7860 * waiting on this event in dw_event_wait to continue. 7903 * waiting on this event in dw_event_wait to continue.
7861 * Parameters: 7904 * Parameters:
7862 * eve: The handle to the event returned by dw_event_new(). 7905 * eve: The handle to the event returned by dw_event_new().
7863 */ 7906 */
7864 int dw_event_post (HEV eve) 7907 int dw_event_post (HEV eve)
7865 { 7908 {
7866 if(!eve) 7909 if(!eve)
7867 return FALSE; 7910 return FALSE;
7868 7911
7869 pthread_mutex_lock (&(eve->mutex)); 7912 pthread_mutex_lock (&(eve->mutex));
7870 pthread_cond_broadcast (&(eve->event)); 7913 pthread_cond_broadcast (&(eve->event));
7871 eve->posted = 1; 7914 eve->posted = 1;
7872 pthread_mutex_unlock (&(eve->mutex)); 7915 pthread_mutex_unlock (&(eve->mutex));
7873 return 0; 7916 return 0;
7874 } 7917 }
7875 7918
7876 /* 7919 /*
7877 * Waits on a semaphore created by dw_event_new(), until the 7920 * Waits on a semaphore created by dw_event_new(), until the
7878 * event gets posted or until the timeout expires. 7921 * event gets posted or until the timeout expires.
7879 * Parameters: 7922 * Parameters:
7880 * eve: The handle to the event returned by dw_event_new(). 7923 * eve: The handle to the event returned by dw_event_new().
7881 */ 7924 */
7882 int dw_event_wait(HEV eve, unsigned long timeout) 7925 int dw_event_wait(HEV eve, unsigned long timeout)
7883 { 7926 {
7884 int rc; 7927 int rc;
7885 struct timeval now; 7928 struct timeval now;
7886 struct timespec timeo; 7929 struct timespec timeo;
7887 7930
7888 if(!eve) 7931 if(!eve)
7889 return FALSE; 7932 return FALSE;
7890 7933
7891 if(eve->posted) 7934 if(eve->posted)
7892 return 0; 7935 return 0;
7893 7936
7894 pthread_mutex_lock (&(eve->mutex)); 7937 pthread_mutex_lock (&(eve->mutex));
7895 gettimeofday(&now, 0); 7938 gettimeofday(&now, 0);
7896 timeo.tv_sec = now.tv_sec + (timeout / 1000); 7939 timeo.tv_sec = now.tv_sec + (timeout / 1000);
7897 timeo.tv_nsec = now.tv_usec * 1000; 7940 timeo.tv_nsec = now.tv_usec * 1000;
7898 rc = pthread_cond_timedwait (&(eve->event), &(eve->mutex), &timeo); 7941 rc = pthread_cond_timedwait (&(eve->event), &(eve->mutex), &timeo);
7899 pthread_mutex_unlock (&(eve->mutex)); 7942 pthread_mutex_unlock (&(eve->mutex));
7900 if(!rc) 7943 if(!rc)
7901 return 1; 7944 return 1;
7902 if(rc == ETIMEDOUT) 7945 if(rc == ETIMEDOUT)
7903 return -1; 7946 return -1;
7904 return 0; 7947 return 0;
7905 } 7948 }
7906 7949
7907 /* 7950 /*
7908 * Closes a semaphore created by dw_event_new(). 7951 * Closes a semaphore created by dw_event_new().
7909 * Parameters: 7952 * Parameters:
7910 * eve: The handle to the event returned by dw_event_new(). 7953 * eve: The handle to the event returned by dw_event_new().
7911 */ 7954 */
7912 int dw_event_close(HEV *eve) 7955 int dw_event_close(HEV *eve)
7913 { 7956 {
7914 if(!eve || !(*eve)) 7957 if(!eve || !(*eve))
7915 return FALSE; 7958 return FALSE;
7916 7959
7917 pthread_mutex_lock (&((*eve)->mutex)); 7960 pthread_mutex_lock (&((*eve)->mutex));
7918 pthread_cond_destroy (&((*eve)->event)); 7961 pthread_cond_destroy (&((*eve)->event));
7919 pthread_mutex_unlock (&((*eve)->mutex)); 7962 pthread_mutex_unlock (&((*eve)->mutex));
7920 pthread_mutex_destroy (&((*eve)->mutex)); 7963 pthread_mutex_destroy (&((*eve)->mutex));
7921 free(*eve); 7964 free(*eve);
7922 *eve = NULL; 7965 *eve = NULL;
7923 7966
7924 return TRUE; 7967 return TRUE;
7925 } 7968 }
7926 7969
7927 struct _seminfo { 7970 struct _seminfo {
7928 int fd; 7971 int fd;
7929 int waiting; 7972 int waiting;
7930 }; 7973 };
7931 7974
7932 static void _handle_sem(int *tmpsock) 7975 static void _handle_sem(int *tmpsock)
7933 { 7976 {
7934 fd_set rd; 7977 fd_set rd;
7935 struct _seminfo *array = (struct _seminfo *)malloc(sizeof(struct _seminfo)); 7978 struct _seminfo *array = (struct _seminfo *)malloc(sizeof(struct _seminfo));
7936 int listenfd = tmpsock[0]; 7979 int listenfd = tmpsock[0];
7937 int bytesread, connectcount = 1, maxfd, z, posted = 0; 7980 int bytesread, connectcount = 1, maxfd, z, posted = 0;
7938 char command; 7981 char command;
7939 sigset_t mask; 7982 sigset_t mask;
7940 7983
7941 sigfillset(&mask); /* Mask all allowed signals */ 7984 sigfillset(&mask); /* Mask all allowed signals */
7942 pthread_sigmask(SIG_BLOCK, &mask, NULL); 7985 pthread_sigmask(SIG_BLOCK, &mask, NULL);
7943 7986
7944 /* problems */ 7987 /* problems */
7945 if(tmpsock[1] == -1) 7988 if(tmpsock[1] == -1)
7946 { 7989 {
7947 free(array); 7990 free(array);
7948 return; 7991 return;
7949 } 7992 }
7950 7993
7951 array[0].fd = tmpsock[1]; 7994 array[0].fd = tmpsock[1];
7952 array[0].waiting = 0; 7995 array[0].waiting = 0;
7953 7996
7954 /* Free the memory allocated in dw_named_event_new. */ 7997 /* Free the memory allocated in dw_named_event_new. */
7955 free(tmpsock); 7998 free(tmpsock);
7956 7999
7957 while(1) 8000 while(1)
7958 { 8001 {
7959 FD_ZERO(&rd); 8002 FD_ZERO(&rd);
7960 FD_SET(listenfd, &rd); 8003 FD_SET(listenfd, &rd);
7961 8004
7962 maxfd = listenfd; 8005 maxfd = listenfd;
7963 8006
7964 /* Added any connections to the named event semaphore */ 8007 /* Added any connections to the named event semaphore */
7965 for(z=0;z<connectcount;z++) 8008 for(z=0;z<connectcount;z++)
7966 { 8009 {
7967 if(array[z].fd > maxfd) 8010 if(array[z].fd > maxfd)
7968 maxfd = array[z].fd; 8011 maxfd = array[z].fd;
7969 8012
7970 FD_SET(array[z].fd, &rd); 8013 FD_SET(array[z].fd, &rd);
7971 } 8014 }
7972 8015
7973 if(select(maxfd+1, &rd, NULL, NULL, NULL) == -1) 8016 if(select(maxfd+1, &rd, NULL, NULL, NULL) == -1)
7974 return; 8017 return;
7975 8018
7976 if(FD_ISSET(listenfd, &rd)) 8019 if(FD_ISSET(listenfd, &rd))
7977 { 8020 {
7978 struct _seminfo *newarray; 8021 struct _seminfo *newarray;
7979 int newfd = accept(listenfd, 0, 0); 8022 int newfd = accept(listenfd, 0, 0);
7980 8023
7981 if(newfd > -1) 8024 if(newfd > -1)
7982 { 8025 {
7983 /* Add new connections to the set */ 8026 /* Add new connections to the set */
7984 newarray = (struct _seminfo *)malloc(sizeof(struct _seminfo)*(connectcount+1)); 8027 newarray = (struct _seminfo *)malloc(sizeof(struct _seminfo)*(connectcount+1));
7985 memcpy(newarray, array, sizeof(struct _seminfo)*(connectcount)); 8028 memcpy(newarray, array, sizeof(struct _seminfo)*(connectcount));
7986 8029
7987 newarray[connectcount].fd = newfd; 8030 newarray[connectcount].fd = newfd;
7988 newarray[connectcount].waiting = 0; 8031 newarray[connectcount].waiting = 0;
7989 8032
7990 connectcount++; 8033 connectcount++;
7991 8034
7992 /* Replace old array with new one */ 8035 /* Replace old array with new one */
7993 free(array); 8036 free(array);
7994 array = newarray; 8037 array = newarray;
7995 } 8038 }
7996 } 8039 }
7997 8040
7998 /* Handle any events posted to the semaphore */ 8041 /* Handle any events posted to the semaphore */
7999 for(z=0;z<connectcount;z++) 8042 for(z=0;z<connectcount;z++)
8000 { 8043 {
8001 if(FD_ISSET(array[z].fd, &rd)) 8044 if(FD_ISSET(array[z].fd, &rd))
8002 { 8045 {
8003 if((bytesread = read(array[z].fd, &command, 1)) < 1) 8046 if((bytesread = read(array[z].fd, &command, 1)) < 1)
8004 { 8047 {
8005 struct _seminfo *newarray; 8048 struct _seminfo *newarray;
8006 8049
8007 /* Remove this connection from the set */ 8050 /* Remove this connection from the set */
8008 newarray = (struct _seminfo *)malloc(sizeof(struct _seminfo)*(connectcount-1)); 8051 newarray = (struct _seminfo *)malloc(sizeof(struct _seminfo)*(connectcount-1));
8009 if(!z) 8052 if(!z)
8010 memcpy(newarray, &array[1], sizeof(struct _seminfo)*(connectcount-1)); 8053 memcpy(newarray, &array[1], sizeof(struct _seminfo)*(connectcount-1));
8011 else 8054 else
8012 { 8055 {
8013 memcpy(newarray, array, sizeof(struct _seminfo)*z); 8056 memcpy(newarray, array, sizeof(struct _seminfo)*z);
8014 if(z!=(connectcount-1)) 8057 if(z!=(connectcount-1))
8015 memcpy(&newarray[z], &array[z+1], sizeof(struct _seminfo)*(z-connectcount-1)); 8058 memcpy(&newarray[z], &array[z+1], sizeof(struct _seminfo)*(z-connectcount-1));
8016 } 8059 }
8017 connectcount--; 8060 connectcount--;
8018 8061
8019 /* Replace old array with new one */ 8062 /* Replace old array with new one */
8020 free(array); 8063 free(array);
8021 array = newarray; 8064 array = newarray;
8022 } 8065 }
8023 else if(bytesread == 1) 8066 else if(bytesread == 1)
8024 { 8067 {
8025 switch(command) 8068 switch(command)
8026 { 8069 {
8027 case 0: 8070 case 0:
8028 { 8071 {
8029 /* Reset */ 8072 /* Reset */
8030 posted = 0; 8073 posted = 0;
8031 } 8074 }
8032 break; 8075 break;
8033 case 1: 8076 case 1:
8034 /* Post */ 8077 /* Post */
8035 { 8078 {
8036 int s; 8079 int s;
8037 char tmp = (char)0; 8080 char tmp = (char)0;
8038 8081
8039 posted = 1; 8082 posted = 1;
8040 8083
8041 for(s=0;s<connectcount;s++) 8084 for(s=0;s<connectcount;s++)
8042 { 8085 {
8043 /* The semaphore has been posted so 8086 /* The semaphore has been posted so
8044 * we tell all the waiting threads to 8087 * we tell all the waiting threads to
8045 * continue. 8088 * continue.
8046 */ 8089 */
8047 if(array[s].waiting) 8090 if(array[s].waiting)
8048 write(array[s].fd, &tmp, 1); 8091 write(array[s].fd, &tmp, 1);
8049 } 8092 }
8050 } 8093 }
8051 break; 8094 break;
8052 case 2: 8095 case 2:
8053 /* Wait */ 8096 /* Wait */
8054 { 8097 {
8055 char tmp = (char)0; 8098 char tmp = (char)0;
8056 8099
8057 array[z].waiting = 1; 8100 array[z].waiting = 1;
8058 8101
8059 /* If we are posted exit immeditately */ 8102 /* If we are posted exit immeditately */
8060 if(posted) 8103 if(posted)
8061 write(array[z].fd, &tmp, 1); 8104 write(array[z].fd, &tmp, 1);
8062 } 8105 }
8063 break; 8106 break;
8064 case 3: 8107 case 3:
8065 { 8108 {
8066 /* Done Waiting */ 8109 /* Done Waiting */
8067 array[z].waiting = 0; 8110 array[z].waiting = 0;
8068 } 8111 }
8069 break; 8112 break;
8070 } 8113 }
8071 } 8114 }
8072 } 8115 }
8073 } 8116 }
8074 8117
8075 } 8118 }
8076 8119
8077 } 8120 }
8078 8121
8079 /* Using domain sockets on unix for IPC */ 8122 /* Using domain sockets on unix for IPC */
8080 /* Create a named event semaphore which can be 8123 /* Create a named event semaphore which can be
8084 * name: Name given to semaphore which can be opened 8127 * name: Name given to semaphore which can be opened
8085 * by other processes. 8128 * by other processes.
8086 */ 8129 */
8087 HEV dw_named_event_new(char *name) 8130 HEV dw_named_event_new(char *name)
8088 { 8131 {
8089 struct sockaddr_un un; 8132 struct sockaddr_un un;
8090 int ev, *tmpsock = (int *)malloc(sizeof(int)*2); 8133 int ev, *tmpsock = (int *)malloc(sizeof(int)*2);
8091 DWTID dwthread; 8134 DWTID dwthread;
8092 8135
8093 if(!tmpsock) 8136 if(!tmpsock)
8094 return NULL; 8137 return NULL;
8095 8138
8096 tmpsock[0] = socket(AF_UNIX, SOCK_STREAM, 0); 8139 tmpsock[0] = socket(AF_UNIX, SOCK_STREAM, 0);
8097 ev = socket(AF_UNIX, SOCK_STREAM, 0); 8140 ev = socket(AF_UNIX, SOCK_STREAM, 0);
8098 memset(&un, 0, sizeof(un)); 8141 memset(&un, 0, sizeof(un));
8099 un.sun_family=AF_UNIX; 8142 un.sun_family=AF_UNIX;
8100 mkdir("/tmp/.dw", S_IWGRP|S_IWOTH); 8143 mkdir("/tmp/.dw", S_IWGRP|S_IWOTH);
8101 strcpy(un.sun_path, "/tmp/.dw/"); 8144 strcpy(un.sun_path, "/tmp/.dw/");
8102 strcat(un.sun_path, name); 8145 strcat(un.sun_path, name);
8103 8146
8104 /* just to be safe, this should be changed 8147 /* just to be safe, this should be changed
8105 * to support multiple instances. 8148 * to support multiple instances.
8106 */ 8149 */
8107 remove(un.sun_path); 8150 remove(un.sun_path);
8108 8151
8109 bind(tmpsock[0], (struct sockaddr *)&un, sizeof(un)); 8152 bind(tmpsock[0], (struct sockaddr *)&un, sizeof(un));
8110 listen(tmpsock[0], 0); 8153 listen(tmpsock[0], 0);
8111 connect(ev, (struct sockaddr *)&un, sizeof(un)); 8154 connect(ev, (struct sockaddr *)&un, sizeof(un));
8112 tmpsock[1] = accept(tmpsock[0], 0, 0); 8155 tmpsock[1] = accept(tmpsock[0], 0, 0);
8113 8156
8114 if(tmpsock[0] < 0 || tmpsock[1] < 0 || ev < 0) 8157 if(tmpsock[0] < 0 || tmpsock[1] < 0 || ev < 0)
8115 { 8158 {
8116 if(tmpsock[0] > -1) 8159 if(tmpsock[0] > -1)
8117 close(tmpsock[0]); 8160 close(tmpsock[0]);
8118 if(tmpsock[1] > -1) 8161 if(tmpsock[1] > -1)
8119 close(tmpsock[1]); 8162 close(tmpsock[1]);
8120 if(ev > -1) 8163 if(ev > -1)
8121 close(ev); 8164 close(ev);
8122 free(tmpsock); 8165 free(tmpsock);
8123 return NULL; 8166 return NULL;
8124 } 8167 }
8125 8168
8126 /* Create a thread to handle this event semaphore */ 8169 /* Create a thread to handle this event semaphore */
8127 pthread_create(&dwthread, NULL, (void *)_handle_sem, (void *)tmpsock); 8170 pthread_create(&dwthread, NULL, (void *)_handle_sem, (void *)tmpsock);
8128 return (HEV)ev; 8171 return (HEV)ev;
8129 } 8172 }
8130 8173
8131 /* Open an already existing named event semaphore. 8174 /* Open an already existing named event semaphore.
8132 * Parameters: 8175 * Parameters:
8133 * eve: Pointer to an event handle to receive handle. 8176 * eve: Pointer to an event handle to receive handle.
8134 * name: Name given to semaphore which can be opened 8177 * name: Name given to semaphore which can be opened
8135 * by other processes. 8178 * by other processes.
8136 */ 8179 */
8137 HEV dw_named_event_get(char *name) 8180 HEV dw_named_event_get(char *name)
8138 { 8181 {
8139 struct sockaddr_un un; 8182 struct sockaddr_un un;
8140 int ev = socket(AF_UNIX, SOCK_STREAM, 0); 8183 int ev = socket(AF_UNIX, SOCK_STREAM, 0);
8141 if(ev < 0) 8184 if(ev < 0)
8142 return NULL; 8185 return NULL;
8143 8186
8144 un.sun_family=AF_UNIX; 8187 un.sun_family=AF_UNIX;
8145 mkdir("/tmp/.dw", S_IWGRP|S_IWOTH); 8188 mkdir("/tmp/.dw", S_IWGRP|S_IWOTH);
8146 strcpy(un.sun_path, "/tmp/.dw/"); 8189 strcpy(un.sun_path, "/tmp/.dw/");
8147 strcat(un.sun_path, name); 8190 strcat(un.sun_path, name);
8148 connect(ev, (struct sockaddr *)&un, sizeof(un)); 8191 connect(ev, (struct sockaddr *)&un, sizeof(un));
8149 return (HEV)ev; 8192 return (HEV)ev;
8150 } 8193 }
8151 8194
8152 /* Resets the event semaphore so threads who call wait 8195 /* Resets the event semaphore so threads who call wait
8153 * on this semaphore will block. 8196 * on this semaphore will block.
8154 * Parameters: 8197 * Parameters:
8155 * eve: Handle to the semaphore obtained by 8198 * eve: Handle to the semaphore obtained by
8156 * an open or create call. 8199 * an open or create call.
8157 */ 8200 */
8158 int dw_named_event_reset(HEV eve) 8201 int dw_named_event_reset(HEV eve)
8159 { 8202 {
8160 /* signal reset */ 8203 /* signal reset */
8161 char tmp = (char)0; 8204 char tmp = (char)0;
8162 8205
8163 if((int)eve < 0) 8206 if((int)eve < 0)
8164 return 0; 8207 return 0;
8165 8208
8166 if(write((int)eve, &tmp, 1) == 1) 8209 if(write((int)eve, &tmp, 1) == 1)
8167 return 0; 8210 return 0;
8168 return 1; 8211 return 1;
8169 } 8212 }
8170 8213
8171 /* Sets the posted state of an event semaphore, any threads 8214 /* Sets the posted state of an event semaphore, any threads
8172 * waiting on the semaphore will no longer block. 8215 * waiting on the semaphore will no longer block.
8173 * Parameters: 8216 * Parameters:
8175 * an open or create call. 8218 * an open or create call.
8176 */ 8219 */
8177 int dw_named_event_post(HEV eve) 8220 int dw_named_event_post(HEV eve)
8178 { 8221 {
8179 8222
8180 /* signal post */ 8223 /* signal post */
8181 char tmp = (char)1; 8224 char tmp = (char)1;
8182 8225
8183 if((int)eve < 0) 8226 if((int)eve < 0)
8184 return 0; 8227 return 0;
8185 8228
8186 if(write((int)eve, &tmp, 1) == 1) 8229 if(write((int)eve, &tmp, 1) == 1)
8187 return 0; 8230 return 0;
8188 return 1; 8231 return 1;
8189 } 8232 }
8190 8233
8191 /* Waits on the specified semaphore until it becomes 8234 /* Waits on the specified semaphore until it becomes
8192 * posted, or returns immediately if it already is posted. 8235 * posted, or returns immediately if it already is posted.
8193 * Parameters: 8236 * Parameters:
8196 * timeout: Number of milliseconds before timing out 8239 * timeout: Number of milliseconds before timing out
8197 * or -1 if indefinite. 8240 * or -1 if indefinite.
8198 */ 8241 */
8199 int dw_named_event_wait(HEV eve, unsigned long timeout) 8242 int dw_named_event_wait(HEV eve, unsigned long timeout)
8200 { 8243 {
8201 fd_set rd; 8244 fd_set rd;
8202 struct timeval tv, *useme; 8245 struct timeval tv, *useme;
8203 int retval = 0; 8246 int retval = 0;
8204 char tmp; 8247 char tmp;
8205 8248
8206 if((int)eve < 0) 8249 if((int)eve < 0)
8207 return DW_ERROR_NON_INIT; 8250 return DW_ERROR_NON_INIT;
8208 8251
8209 /* Set the timout or infinite */ 8252 /* Set the timout or infinite */
8210 if(timeout == -1) 8253 if(timeout == -1)
8211 useme = NULL; 8254 useme = NULL;
8212 else 8255 else
8213 { 8256 {
8214 tv.tv_sec = timeout / 1000; 8257 tv.tv_sec = timeout / 1000;
8215 tv.tv_usec = timeout % 1000; 8258 tv.tv_usec = timeout % 1000;
8216 8259
8217 useme = &tv; 8260 useme = &tv;
8218 } 8261 }
8219 8262
8220 FD_ZERO(&rd); 8263 FD_ZERO(&rd);
8221 FD_SET((int)eve, &rd); 8264 FD_SET((int)eve, &rd);
8222 8265
8223 /* Signal wait */ 8266 /* Signal wait */
8224 tmp = (char)2; 8267 tmp = (char)2;
8225 write((int)eve, &tmp, 1); 8268 write((int)eve, &tmp, 1);
8226 8269
8227 retval = select((int)eve+1, &rd, NULL, NULL, useme); 8270 retval = select((int)eve+1, &rd, NULL, NULL, useme);
8228 8271
8229 /* Signal done waiting. */ 8272 /* Signal done waiting. */
8230 tmp = (char)3; 8273 tmp = (char)3;
8231 write((int)eve, &tmp, 1); 8274 write((int)eve, &tmp, 1);
8232 8275
8233 if(retval == 0) 8276 if(retval == 0)
8234 return DW_ERROR_TIMEOUT; 8277 return DW_ERROR_TIMEOUT;
8235 else if(retval == -1) 8278 else if(retval == -1)
8236 return DW_ERROR_INTERRUPT; 8279 return DW_ERROR_INTERRUPT;
8237 8280
8238 /* Clear the entry from the pipe so 8281 /* Clear the entry from the pipe so
8239 * we don't loop endlessly. :) 8282 * we don't loop endlessly. :)
8240 */ 8283 */
8241 read((int)eve, &tmp, 1); 8284 read((int)eve, &tmp, 1);
8242 return 0; 8285 return 0;
8243 } 8286 }
8244 8287
8245 /* Release this semaphore, if there are no more open 8288 /* Release this semaphore, if there are no more open
8246 * handles on this semaphore the semaphore will be destroyed. 8289 * handles on this semaphore the semaphore will be destroyed.
8247 * Parameters: 8290 * Parameters:
8248 * eve: Handle to the semaphore obtained by 8291 * eve: Handle to the semaphore obtained by
8249 * an open or create call. 8292 * an open or create call.
8250 */ 8293 */
8251 int dw_named_event_close(HEV eve) 8294 int dw_named_event_close(HEV eve)
8252 { 8295 {
8253 /* Finally close the domain socket, 8296 /* Finally close the domain socket,
8254 * cleanup will continue in _handle_sem. 8297 * cleanup will continue in _handle_sem.
8255 */ 8298 */
8256 close((int)eve); 8299 close((int)eve);
8257 return 0; 8300 return 0;
8258 } 8301 }
8259 8302
8260 /* 8303 /*
8261 * Setup thread independent color sets. 8304 * Setup thread independent color sets.
8262 */ 8305 */
8263 void _dwthreadstart(void *data) 8306 void _dwthreadstart(void *data)
8264 { 8307 {
8265 void (*threadfunc)(void *) = NULL; 8308 void (*threadfunc)(void *) = NULL;
8266 void **tmp = (void **)data; 8309 void **tmp = (void **)data;
8267 8310
8268 threadfunc = (void (*)(void *))tmp[0]; 8311 threadfunc = (void (*)(void *))tmp[0];
8269 8312
8270 _dw_thread_add(dw_thread_id()); 8313 _dw_thread_add(dw_thread_id());
8271 threadfunc(tmp[1]); 8314 threadfunc(tmp[1]);
8272 _dw_thread_remove(dw_thread_id()); 8315 _dw_thread_remove(dw_thread_id());
8273 free(tmp); 8316 free(tmp);
8274 } 8317 }
8275 8318
8276 /* 8319 /*
8277 * Allocates a shared memory region with a name. 8320 * Allocates a shared memory region with a name.
8278 * Parameters: 8321 * Parameters:
8281 * size: Size in bytes of the shared memory region to allocate. 8324 * size: Size in bytes of the shared memory region to allocate.
8282 * name: A string pointer to a unique memory name. 8325 * name: A string pointer to a unique memory name.
8283 */ 8326 */
8284 HSHM dw_named_memory_new(void **dest, int size, char *name) 8327 HSHM dw_named_memory_new(void **dest, int size, char *name)
8285 { 8328 {
8286 char namebuf[1024]; 8329 char namebuf[1024];
8287 struct _dw_unix_shm *handle = malloc(sizeof(struct _dw_unix_shm)); 8330 struct _dw_unix_shm *handle = malloc(sizeof(struct _dw_unix_shm));
8288 8331
8289 mkdir("/tmp/.dw", S_IWGRP|S_IWOTH); 8332 mkdir("/tmp/.dw", S_IWGRP|S_IWOTH);
8290 sprintf(namebuf, "/tmp/.dw/%s", name); 8333 sprintf(namebuf, "/tmp/.dw/%s", name);
8291 8334
8292 if((handle->fd = open(namebuf, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR)) < 0) 8335 if((handle->fd = open(namebuf, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR)) < 0)
8293 { 8336 {
8294 free(handle); 8337 free(handle);
8295 return NULL; 8338 return NULL;
8296 } 8339 }
8297 8340
8298 ftruncate(handle->fd, size); 8341 ftruncate(handle->fd, size);
8299 8342
8300 /* attach the shared memory segment to our process's address space. */ 8343 /* attach the shared memory segment to our process's address space. */
8301 *dest = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, handle->fd, 0); 8344 *dest = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, handle->fd, 0);
8302 8345
8303 if(*dest == MAP_FAILED) 8346 if(*dest == MAP_FAILED)
8304 { 8347 {
8305 close(handle->fd); 8348 close(handle->fd);
8306 *dest = NULL; 8349 *dest = NULL;
8307 free(handle); 8350 free(handle);
8308 return NULL; 8351 return NULL;
8309 } 8352 }
8310 8353
8311 handle->size = size; 8354 handle->size = size;
8312 handle->sid = getsid(0); 8355 handle->sid = getsid(0);
8313 handle->path = strdup(namebuf); 8356 handle->path = strdup(namebuf);
8314 8357
8315 return handle; 8358 return handle;
8316 } 8359 }
8317 8360
8318 /* 8361 /*
8319 * Aquires shared memory region with a name. 8362 * Aquires shared memory region with a name.
8320 * Parameters: 8363 * Parameters:
8322 * size: Size in bytes of the shared memory region to requested. 8365 * size: Size in bytes of the shared memory region to requested.
8323 * name: A string pointer to a unique memory name. 8366 * name: A string pointer to a unique memory name.
8324 */ 8367 */
8325 HSHM dw_named_memory_get(void **dest, int size, char *name) 8368 HSHM dw_named_memory_get(void **dest, int size, char *name)
8326 { 8369 {
8327 char namebuf[1024]; 8370 char namebuf[1024];
8328 struct _dw_unix_shm *handle = malloc(sizeof(struct _dw_unix_shm)); 8371 struct _dw_unix_shm *handle = malloc(sizeof(struct _dw_unix_shm));
8329 8372
8330 mkdir("/tmp/.dw", S_IWGRP|S_IWOTH); 8373 mkdir("/tmp/.dw", S_IWGRP|S_IWOTH);
8331 sprintf(namebuf, "/tmp/.dw/%s", name); 8374 sprintf(namebuf, "/tmp/.dw/%s", name);
8332 8375
8333 if((handle->fd = open(namebuf, O_RDWR)) < 0) 8376 if((handle->fd = open(namebuf, O_RDWR)) < 0)
8334 { 8377 {
8335 free(handle); 8378 free(handle);
8336 return NULL; 8379 return NULL;
8337 } 8380 }
8338 8381
8339 /* attach the shared memory segment to our process's address space. */ 8382 /* attach the shared memory segment to our process's address space. */
8340 *dest = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, handle->fd, 0); 8383 *dest = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, handle->fd, 0);
8341 8384
8342 if(*dest == MAP_FAILED) 8385 if(*dest == MAP_FAILED)
8343 { 8386 {
8344 close(handle->fd); 8387 close(handle->fd);
8345 *dest = NULL; 8388 *dest = NULL;
8346 free(handle); 8389 free(handle);
8347 return NULL; 8390 return NULL;
8348 } 8391 }
8349 8392
8350 handle->size = size; 8393 handle->size = size;
8351 handle->sid = -1; 8394 handle->sid = -1;
8352 handle->path = NULL; 8395 handle->path = NULL;
8353 8396
8354 return handle; 8397 return handle;
8355 } 8398 }
8356 8399
8357 /* 8400 /*
8358 * Frees a shared memory region previously allocated. 8401 * Frees a shared memory region previously allocated.
8359 * Parameters: 8402 * Parameters:
8360 * handle: Handle obtained from DB_named_memory_allocate. 8403 * handle: Handle obtained from DB_named_memory_allocate.
8361 * ptr: The memory address aquired with DB_named_memory_allocate. 8404 * ptr: The memory address aquired with DB_named_memory_allocate.
8362 */ 8405 */
8363 int dw_named_memory_free(HSHM handle, void *ptr) 8406 int dw_named_memory_free(HSHM handle, void *ptr)
8364 { 8407 {
8365 struct _dw_unix_shm *h = handle; 8408 struct _dw_unix_shm *h = handle;
8366 int rc = munmap(ptr, h->size); 8409 int rc = munmap(ptr, h->size);
8367 8410
8368 close(h->fd); 8411 close(h->fd);
8369 if(h->path) 8412 if(h->path)
8370 { 8413 {
8371 /* Only remove the actual file if we are the 8414 /* Only remove the actual file if we are the
8372 * creator of the file. 8415 * creator of the file.
8373 */ 8416 */
8374 if(h->sid != -1 && h->sid == getsid(0)) 8417 if(h->sid != -1 && h->sid == getsid(0))
8375 remove(h->path); 8418 remove(h->path);
8376 free(h->path); 8419 free(h->path);
8377 } 8420 }
8378 return rc; 8421 return rc;
8379 } 8422 }
8380 /* 8423 /*
8381 * Creates a new thread with a starting point of func. 8424 * Creates a new thread with a starting point of func.
8382 * Parameters: 8425 * Parameters:
8383 * func: Function which will be run in the new thread. 8426 * func: Function which will be run in the new thread.
8384 * data: Parameter(s) passed to the function. 8427 * data: Parameter(s) passed to the function.
8385 * stack: Stack size of new thread (OS/2 and Windows only). 8428 * stack: Stack size of new thread (OS/2 and Windows only).
8386 */ 8429 */
8387 DWTID dw_thread_new(void *func, void *data, int stack) 8430 DWTID dw_thread_new(void *func, void *data, int stack)
8388 { 8431 {
8389 DWTID gtkthread; 8432 DWTID gtkthread;
8390 void **tmp = malloc(sizeof(void *) * 2); 8433 void **tmp = malloc(sizeof(void *) * 2);
8391 8434
8392 tmp[0] = func; 8435 tmp[0] = func;
8393 tmp[1] = data; 8436 tmp[1] = data;
8394 8437
8395 pthread_create(&gtkthread, NULL, (void *)_dwthreadstart, (void *)tmp); 8438 pthread_create(&gtkthread, NULL, (void *)_dwthreadstart, (void *)tmp);
8396 return gtkthread; 8439 return gtkthread;
8397 } 8440 }
8398 8441
8399 /* 8442 /*
8400 * Ends execution of current thread immediately. 8443 * Ends execution of current thread immediately.
8401 */ 8444 */
8402 void dw_thread_end(void) 8445 void dw_thread_end(void)
8403 { 8446 {
8404 pthread_exit(NULL); 8447 pthread_exit(NULL);
8405 } 8448 }
8406 8449
8407 /* 8450 /*
8408 * Returns the current thread's ID. 8451 * Returns the current thread's ID.
8409 */ 8452 */
8410 DWTID dw_thread_id(void) 8453 DWTID dw_thread_id(void)
8411 { 8454 {
8412 return (DWTID)pthread_self(); 8455 return (DWTID)pthread_self();
8413 } 8456 }
8414 8457
8415 /* 8458 /*
8416 * Cleanly terminates a DW session, should be signal handler safe. 8459 * Cleanly terminates a DW session, should be signal handler safe.
8417 * Parameters: 8460 * Parameters:
8418 * exitcode: Exit code reported to the operating system. 8461 * exitcode: Exit code reported to the operating system.
8419 */ 8462 */
8420 void dw_exit(int exitcode) 8463 void dw_exit(int exitcode)
8421 { 8464 {
8422 exit(exitcode); 8465 exit(exitcode);
8423 } 8466 }
8424 8467
8425 #define DW_EXPAND (GTK_EXPAND | GTK_SHRINK | GTK_FILL) 8468 #define DW_EXPAND (GTK_EXPAND | GTK_SHRINK | GTK_FILL)
8426 8469
8427 /* 8470 /*
8435 * vsize: TRUE if the window (widget) should expand vertically to fill space given. 8478 * vsize: TRUE if the window (widget) should expand vertically to fill space given.
8436 * pad: Number of pixels of padding around the item. 8479 * pad: Number of pixels of padding around the item.
8437 */ 8480 */
8438 void dw_box_pack_end(HWND box, HWND item, int width, int height, int hsize, int vsize, int pad) 8481 void dw_box_pack_end(HWND box, HWND item, int width, int height, int hsize, int vsize, int pad)
8439 { 8482 {
8440 int warn = FALSE, _locked_by_me = FALSE; 8483 int warn = FALSE, _locked_by_me = FALSE;
8441 GtkWidget *tmp, *tmpitem; 8484 GtkWidget *tmp, *tmpitem;
8442 8485
8443 if(!box) 8486 if(!box)
8444 return; 8487 return;
8445 8488
8446 /* 8489 /*
8447 * If you try and pack an item into itself VERY bad things can happen; like at least an 8490 * If you try and pack an item into itself VERY bad things can happen; like at least an
8448 * infinite loop on GTK! Lets be safe! 8491 * infinite loop on GTK! Lets be safe!
8449 */ 8492 */
8450 if(box == item) 8493 if(box == item)
8451 { 8494 {
8452 dw_messagebox("dw_box_pack_end()", DW_MB_OK|DW_MB_ERROR, "Danger! Danger! Will Robinson; box and item are the same!"); 8495 dw_messagebox("dw_box_pack_end()", DW_MB_OK|DW_MB_ERROR, "Danger! Danger! Will Robinson; box and item are the same!");
8453 return; 8496 return;
8454 } 8497 }
8455 8498
8456 DW_MUTEX_LOCK; 8499 DW_MUTEX_LOCK;
8457 8500
8458 if((tmp = gtk_object_get_data(GTK_OBJECT(box), "_dw_boxhandle"))) 8501 if((tmp = gtk_object_get_data(GTK_OBJECT(box), "_dw_boxhandle")))
8459 box = tmp; 8502 box = tmp;
8460 8503
8461 if(!item) 8504 if(!item)
8462 { 8505 {
8463 item = gtk_label_new(""); 8506 item = gtk_label_new("");
8464 gtk_widget_show_all(item); 8507 gtk_widget_show_all(item);
8465 } 8508 }
8466 8509
8467 tmpitem = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(item), "_dw_boxhandle"); 8510 tmpitem = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(item), "_dw_boxhandle");
8468 8511
8469 if(GTK_IS_TABLE(box)) 8512 if(GTK_IS_TABLE(box))
8470 { 8513 {
8471 int boxcount = (int)gtk_object_get_data(GTK_OBJECT(box), "_dw_boxcount"); 8514 int boxcount = (int)gtk_object_get_data(GTK_OBJECT(box), "_dw_boxcount");
8472 int boxtype = (int)gtk_object_get_data(GTK_OBJECT(box), "_dw_boxtype"); 8515 int boxtype = (int)gtk_object_get_data(GTK_OBJECT(box), "_dw_boxtype");
8473 8516
8474 /* If the item being packed is a box, then we use it's padding 8517 /* If the item being packed is a box, then we use it's padding
8475 * instead of the padding specified on the pack line, this is 8518 * instead of the padding specified on the pack line, this is
8476 * due to a bug in the OS/2 and Win32 renderer and a limitation 8519 * due to a bug in the OS/2 and Win32 renderer and a limitation
8477 * of the GtkTable class. 8520 * of the GtkTable class.
8478 */ 8521 */
8479 if(GTK_IS_TABLE(item) || (tmpitem && GTK_IS_TABLE(tmpitem))) 8522 if(GTK_IS_TABLE(item) || (tmpitem && GTK_IS_TABLE(tmpitem)))
8480 { 8523 {
8481 GtkWidget *eventbox = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(item), "_dw_eventbox"); 8524 GtkWidget *eventbox = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(item), "_dw_eventbox");
8482 8525
8483 /* NOTE: I left in the ability to pack boxes with a size, 8526 /* NOTE: I left in the ability to pack boxes with a size,
8484 * this eliminates that by forcing the size to 0. 8527 * this eliminates that by forcing the size to 0.
8485 */ 8528 */
8486 height = width = 0; 8529 height = width = 0;
8487 8530
8488 if(eventbox) 8531 if(eventbox)
8489 { 8532 {
8490 int boxpad = (int)gtk_object_get_data(GTK_OBJECT(item), "_dw_boxpad"); 8533 int boxpad = (int)gtk_object_get_data(GTK_OBJECT(item), "_dw_boxpad");
8491 gtk_container_add(GTK_CONTAINER(eventbox), item); 8534 gtk_container_add(GTK_CONTAINER(eventbox), item);
8492 gtk_container_border_width(GTK_CONTAINER(eventbox), boxpad); 8535 gtk_container_border_width(GTK_CONTAINER(eventbox), boxpad);
8493 item = eventbox; 8536 item = eventbox;
8494 } 8537 }
8495 } 8538 }
8496 else 8539 else
8497 { 8540 {
8498 /* Only show warning if item is not a box */ 8541 /* Only show warning if item is not a box */
8499 warn = TRUE; 8542 warn = TRUE;
8500 } 8543 }
8501 8544
8502 if(boxtype == DW_VERT) 8545 if(boxtype == DW_VERT)
8503 gtk_table_resize(GTK_TABLE(box), boxcount + 1, 1); 8546 gtk_table_resize(GTK_TABLE(box), boxcount + 1, 1);
8504 else 8547 else
8505 gtk_table_resize(GTK_TABLE(box), 1, boxcount + 1); 8548 gtk_table_resize(GTK_TABLE(box), 1, boxcount + 1);
8506 8549
8507 gtk_table_attach(GTK_TABLE(box), item, 0, 1, 0, 1, hsize ? DW_EXPAND : 0, vsize ? DW_EXPAND : 0, pad, pad); 8550 gtk_table_attach(GTK_TABLE(box), item, 0, 1, 0, 1, hsize ? DW_EXPAND : 0, vsize ? DW_EXPAND : 0, pad, pad);
8508 gtk_object_set_data(GTK_OBJECT(box), "_dw_boxcount", (gpointer)boxcount + 1); 8551 gtk_object_set_data(GTK_OBJECT(box), "_dw_boxcount", GINT_TO_POINTER(boxcount + 1));
8509 gtk_widget_set_usize(item, width, height); 8552 gtk_widget_set_usize(item, width, height);
8510 if(GTK_IS_RADIO_BUTTON(item)) 8553 if(GTK_IS_RADIO_BUTTON(item))
8511 { 8554 {
8512 GSList *group; 8555 GSList *group;
8513 GtkWidget *groupstart = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(box), "_dw_group"); 8556 GtkWidget *groupstart = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(box), "_dw_group");
8514 8557
8515 if(groupstart) 8558 if(groupstart)
8516 { 8559 {
8517 group = gtk_radio_button_group(GTK_RADIO_BUTTON(groupstart)); 8560 group = gtk_radio_button_group(GTK_RADIO_BUTTON(groupstart));
8518 gtk_radio_button_set_group(GTK_RADIO_BUTTON(item), group); 8561 gtk_radio_button_set_group(GTK_RADIO_BUTTON(item), group);
8519 } 8562 }
8520 else 8563 else
8521 gtk_object_set_data(GTK_OBJECT(box), "_dw_group", (gpointer)item); 8564 gtk_object_set_data(GTK_OBJECT(box), "_dw_group", (gpointer)item);
8522 } 8565 }
8523 } 8566 }
8524 else 8567 else
8525 { 8568 {
8526 GtkWidget *vbox = gtk_vbox_new(FALSE, 0); 8569 GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
8527 8570
8528 if(GTK_IS_TABLE(item) || (tmpitem && GTK_IS_TABLE(tmpitem))) 8571 if(GTK_IS_TABLE(item) || (tmpitem && GTK_IS_TABLE(tmpitem)))
8529 { 8572 {
8530 GtkWidget *eventbox = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(item), "_dw_eventbox"); 8573 GtkWidget *eventbox = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(item), "_dw_eventbox");
8531 8574
8532 /* NOTE: I left in the ability to pack boxes with a size, 8575 /* NOTE: I left in the ability to pack boxes with a size,
8533 * this eliminates that by forcing the size to 0. 8576 * this eliminates that by forcing the size to 0.
8534 */ 8577 */
8535 height = width = 0; 8578 height = width = 0;
8536 8579
8537 if(eventbox) 8580 if(eventbox)
8538 { 8581 {
8539 int boxpad = (int)gtk_object_get_data(GTK_OBJECT(item), "_dw_boxpad"); 8582 int boxpad = (int)gtk_object_get_data(GTK_OBJECT(item), "_dw_boxpad");
8540 gtk_container_add(GTK_CONTAINER(eventbox), item); 8583 gtk_container_add(GTK_CONTAINER(eventbox), item);
8541 gtk_container_border_width(GTK_CONTAINER(eventbox), boxpad); 8584 gtk_container_border_width(GTK_CONTAINER(eventbox), boxpad);
8542 item = eventbox; 8585 item = eventbox;
8543 } 8586 }
8544 } 8587 }
8545 else 8588 else
8546 { 8589 {
8547 /* Only show warning if item is not a box */ 8590 /* Only show warning if item is not a box */
8548 warn = TRUE; 8591 warn = TRUE;
8549 } 8592 }
8550 8593
8551 gtk_container_border_width(GTK_CONTAINER(box), pad); 8594 gtk_container_border_width(GTK_CONTAINER(box), pad);
8552 gtk_container_add(GTK_CONTAINER(box), vbox); 8595 gtk_container_add(GTK_CONTAINER(box), vbox);
8553 gtk_box_pack_end(GTK_BOX(vbox), item, TRUE, TRUE, 0); 8596 gtk_box_pack_end(GTK_BOX(vbox), item, TRUE, TRUE, 0);
8554 gtk_widget_show(vbox); 8597 gtk_widget_show(vbox);
8555 8598
8556 gtk_widget_set_usize(item, width, height); 8599 gtk_widget_set_usize(item, width, height);
8557 gtk_object_set_user_data(GTK_OBJECT(box), vbox); 8600 gtk_object_set_user_data(GTK_OBJECT(box), vbox);
8558 } 8601 }
8559 DW_MUTEX_UNLOCK; 8602 DW_MUTEX_UNLOCK;
8560 8603
8561 if(warn) 8604 if(warn)
8562 { 8605 {
8563 if ( width == 0 && hsize == FALSE ) 8606 if ( width == 0 && hsize == FALSE )
8564 dw_messagebox("dw_box_pack_end()", DW_MB_OK|DW_MB_ERROR, "Width and expand Horizonal both unset for box: %x item: %x",box,item); 8607 dw_messagebox("dw_box_pack_end()", DW_MB_OK|DW_MB_ERROR, "Width and expand Horizonal both unset for box: %x item: %x",box,item);
8565 if ( height == 0 && vsize == FALSE ) 8608 if ( height == 0 && vsize == FALSE )
8566 dw_messagebox("dw_box_pack_end()", DW_MB_OK|DW_MB_ERROR, "Height and expand Vertical both unset for box: %x item: %x",box,item); 8609 dw_messagebox("dw_box_pack_end()", DW_MB_OK|DW_MB_ERROR, "Height and expand Vertical both unset for box: %x item: %x",box,item);
8567 } 8610 }
8568 } 8611 }
8569 8612
8570 /* 8613 /*
8571 * Sets the size of a given window (widget). 8614 * Sets the size of a given window (widget).
8572 * Parameters: 8615 * Parameters:
8594 if(handle->window) 8637 if(handle->window)
8595 gdk_window_resize(handle->window, default_width , default_height ); 8638 gdk_window_resize(handle->window, default_width , default_height );
8596 gtk_window_set_default_size(GTK_WINDOW(handle), default_width , default_height ); 8639 gtk_window_set_default_size(GTK_WINDOW(handle), default_width , default_height );
8597 if(!gtk_object_get_data(GTK_OBJECT(handle), "_dw_size")) 8640 if(!gtk_object_get_data(GTK_OBJECT(handle), "_dw_size"))
8598 { 8641 {
8599 gtk_object_set_data(GTK_OBJECT(handle), "_dw_width", (gpointer)default_width ); 8642 gtk_object_set_data(GTK_OBJECT(handle), "_dw_width", GINT_TO_POINTER(default_width) );
8600 gtk_object_set_data(GTK_OBJECT(handle), "_dw_height", (gpointer)default_height ); 8643 gtk_object_set_data(GTK_OBJECT(handle), "_dw_height", GINT_TO_POINTER(default_height) );
8601 } 8644 }
8602 } 8645 }
8603 else 8646 else
8604 gtk_widget_set_usize(handle, width, height); 8647 gtk_widget_set_usize(handle, width, height);
8605 DW_MUTEX_UNLOCK; 8648 DW_MUTEX_UNLOCK;
8608 /* 8651 /*
8609 * Returns the width of the screen. 8652 * Returns the width of the screen.
8610 */ 8653 */
8611 int dw_screen_width(void) 8654 int dw_screen_width(void)
8612 { 8655 {
8613 int retval; 8656 int retval;
8614 int _locked_by_me = FALSE; 8657 int _locked_by_me = FALSE;
8615 8658
8616 DW_MUTEX_LOCK; 8659 DW_MUTEX_LOCK;
8617 retval = gdk_screen_width(); 8660 retval = gdk_screen_width();
8618 DW_MUTEX_UNLOCK; 8661 DW_MUTEX_UNLOCK;
8619 return retval; 8662 return retval;
8620 } 8663 }
8621 8664
8622 /* 8665 /*
8623 * Returns the height of the screen. 8666 * Returns the height of the screen.
8624 */ 8667 */
8625 int dw_screen_height(void) 8668 int dw_screen_height(void)
8626 { 8669 {
8627 int retval; 8670 int retval;
8628 int _locked_by_me = FALSE; 8671 int _locked_by_me = FALSE;
8629 8672
8630 DW_MUTEX_UNLOCK; 8673 DW_MUTEX_UNLOCK;
8631 retval = gdk_screen_height(); 8674 retval = gdk_screen_height();
8632 DW_MUTEX_UNLOCK; 8675 DW_MUTEX_UNLOCK;
8633 return retval; 8676 return retval;
8634 } 8677 }
8635 8678
8636 /* This should return the current color depth */ 8679 /* This should return the current color depth */
8637 unsigned long dw_color_depth_get(void) 8680 unsigned long dw_color_depth_get(void)
8638 { 8681 {
8639 int retval; 8682 int retval;
8640 GdkVisual *vis; 8683 GdkVisual *vis;
8641 int _locked_by_me = FALSE; 8684 int _locked_by_me = FALSE;
8642 8685
8643 DW_MUTEX_UNLOCK; 8686 DW_MUTEX_UNLOCK;
8644 vis = gdk_visual_get_system(); 8687 vis = gdk_visual_get_system();
8645 retval = vis->depth; 8688 retval = vis->depth;
8646 DW_MUTEX_UNLOCK; 8689 DW_MUTEX_UNLOCK;
8647 return retval; 8690 return retval;
8648 } 8691 }
8649 8692
8650 /* 8693 /*
8651 * Sets the position of a given window (widget). 8694 * Sets the position of a given window (widget).
8652 * Parameters: 8695 * Parameters:
8654 * x: X location from the bottom left. 8697 * x: X location from the bottom left.
8655 * y: Y location from the bottom left. 8698 * y: Y location from the bottom left.
8656 */ 8699 */
8657 void dw_window_set_pos(HWND handle, unsigned long x, unsigned long y) 8700 void dw_window_set_pos(HWND handle, unsigned long x, unsigned long y)
8658 { 8701 {
8659 int _locked_by_me = FALSE; 8702 int _locked_by_me = FALSE;
8660 #if GTK_MAJOR_VERSION > 1 8703 #if GTK_MAJOR_VERSION > 1
8661 GtkWidget *mdi; 8704 GtkWidget *mdi;
8662 #endif 8705 #endif
8663 8706
8664 DW_MUTEX_LOCK; 8707 DW_MUTEX_LOCK;
8665 #if GTK_MAJOR_VERSION > 1 8708 #if GTK_MAJOR_VERSION > 1
8666 if((mdi = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_mdi")) && GTK_IS_MDI(mdi)) 8709 if((mdi = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_mdi")) && GTK_IS_MDI(mdi))
8667 { 8710 {
8668 gtk_mdi_move(GTK_MDI(mdi), handle, x, y); 8711 gtk_mdi_move(GTK_MDI(mdi), handle, x, y);
8669 } 8712 }
8670 else 8713 else
8671 #endif 8714 #endif
8672 { 8715 {
8673 if(handle && handle->window) 8716 if(handle && handle->window)
8674 gdk_window_move(handle->window, x, y); 8717 gdk_window_move(handle->window, x, y);
8675 } 8718 }
8676 DW_MUTEX_UNLOCK; 8719 DW_MUTEX_UNLOCK;
8677 } 8720 }
8678 8721
8679 /* 8722 /*
8680 * Sets the position and size of a given window (widget). 8723 * Sets the position and size of a given window (widget).
8681 * Parameters: 8724 * Parameters:
8685 * width: Width of the widget. 8728 * width: Width of the widget.
8686 * height: Height of the widget. 8729 * height: Height of the widget.
8687 */ 8730 */
8688 void dw_window_set_pos_size(HWND handle, unsigned long x, unsigned long y, unsigned long width, unsigned long height) 8731 void dw_window_set_pos_size(HWND handle, unsigned long x, unsigned long y, unsigned long width, unsigned long height)
8689 { 8732 {
8690 int _locked_by_me = FALSE; 8733 int _locked_by_me = FALSE;
8691 #if GTK_MAJOR_VERSION > 1 8734 #if GTK_MAJOR_VERSION > 1
8692 GtkWidget *mdi; 8735 GtkWidget *mdi;
8693 #endif 8736 #endif
8694 8737
8695 if(!handle) 8738 if(!handle)
8696 return; 8739 return;
8697 8740
8698 DW_MUTEX_LOCK; 8741 DW_MUTEX_LOCK;
8699 #if GTK_MAJOR_VERSION > 1 8742 #if GTK_MAJOR_VERSION > 1
8700 if((mdi = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_mdi")) && GTK_IS_MDI(mdi)) 8743 if((mdi = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_mdi")) && GTK_IS_MDI(mdi))
8701 { 8744 {
8702 gtk_mdi_move(GTK_MDI(mdi), handle, x, y); 8745 gtk_mdi_move(GTK_MDI(mdi), handle, x, y);
8703 } 8746 }
8704 else 8747 else
8705 #endif 8748 #endif
8706 { 8749 {
8707 if(GTK_IS_WINDOW(handle)) 8750 if(GTK_IS_WINDOW(handle))
8708 { 8751 {
8709 dw_window_set_size(handle, width, height); 8752 dw_window_set_size(handle, width, height);
8710 gtk_widget_set_uposition(handle, x, y); 8753 gtk_widget_set_uposition(handle, x, y);
8711 } 8754 }
8712 else if(handle->window) 8755 else if(handle->window)
8713 { 8756 {
8714 gdk_window_resize(handle->window, width, height); 8757 gdk_window_resize(handle->window, width, height);
8715 gdk_window_move(handle->window, x, y); 8758 gdk_window_move(handle->window, x, y);
8716 } 8759 }
8717 } 8760 }
8718 DW_MUTEX_UNLOCK; 8761 DW_MUTEX_UNLOCK;
8719 } 8762 }
8720 8763
8721 /* 8764 /*
8722 * Gets the position and size of a given window (widget). 8765 * Gets the position and size of a given window (widget).
8723 * Parameters: 8766 * Parameters:
8727 * width: Width of the widget. 8770 * width: Width of the widget.
8728 * height: Height of the widget. 8771 * height: Height of the widget.
8729 */ 8772 */
8730 void dw_window_get_pos_size(HWND handle, ULONG *x, ULONG *y, ULONG *width, ULONG *height) 8773 void dw_window_get_pos_size(HWND handle, ULONG *x, ULONG *y, ULONG *width, ULONG *height)
8731 { 8774 {
8732 int _locked_by_me = FALSE; 8775 int _locked_by_me = FALSE;
8733 gint gx, gy, gwidth, gheight, gdepth; 8776 gint gx, gy, gwidth, gheight, gdepth;
8734 #if GTK_MAJOR_VERSION > 1 8777 #if GTK_MAJOR_VERSION > 1
8735 GtkWidget *mdi; 8778 GtkWidget *mdi;
8736 #endif 8779 #endif
8737 8780
8738 DW_MUTEX_LOCK; 8781 DW_MUTEX_LOCK;
8739 #if GTK_MAJOR_VERSION > 1 8782 #if GTK_MAJOR_VERSION > 1
8740 if((mdi = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_mdi")) && GTK_IS_MDI(mdi)) 8783 if((mdi = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_mdi")) && GTK_IS_MDI(mdi))
8741 { 8784 {
8742 gint myx=0, myy=0; 8785 gint myx=0, myy=0;
8743 8786
8744 gtk_mdi_get_pos(GTK_MDI(mdi), handle, &myx, &myy); 8787 gtk_mdi_get_pos(GTK_MDI(mdi), handle, &myx, &myy);
8745 *x = myx; 8788 *x = myx;
8746 *y = myy; 8789 *y = myy;
8747 } 8790 }
8748 else 8791 else
8749 #endif 8792 #endif
8750 { 8793 {
8751 if(handle && handle->window) 8794 if(handle && handle->window)
8752 { 8795 {
8753 8796
8754 gdk_window_get_geometry(handle->window, &gx, &gy, &gwidth, &gheight, &gdepth); 8797 gdk_window_get_geometry(handle->window, &gx, &gy, &gwidth, &gheight, &gdepth);
8755 gdk_window_get_root_origin(handle->window, &gx, &gy); 8798 gdk_window_get_root_origin(handle->window, &gx, &gy);
8756 if(x) 8799 if(x)
8757 *x = gx; 8800 *x = gx;
8758 if(y) 8801 if(y)
8759 *y = gy; 8802 *y = gy;
8760 if(GTK_IS_WINDOW(handle)) 8803 if(GTK_IS_WINDOW(handle))
8761 { 8804 {
8762 if(width) 8805 if(width)
8763 *width = gwidth + _dw_border_width; 8806 *width = gwidth + _dw_border_width;
8764 if(height) 8807 if(height)
8765 *height = gheight + _dw_border_height; 8808 *height = gheight + _dw_border_height;
8766 } 8809 }
8767 else 8810 else
8768 { 8811 {
8769 if(width) 8812 if(width)
8770 *width = gwidth; 8813 *width = gwidth;
8771 if(height) 8814 if(height)
8772 *height = gheight; 8815 *height = gheight;
8773 } 8816 }
8774 } 8817 }
8775 } 8818 }
8776 DW_MUTEX_UNLOCK; 8819 DW_MUTEX_UNLOCK;
8777 } 8820 }
8778 8821
8779 /* 8822 /*
8780 * Sets the style of a given window (widget). 8823 * Sets the style of a given window (widget).
8781 * Parameters: 8824 * Parameters:
8783 * width: New width in pixels. 8826 * width: New width in pixels.
8784 * height: New height in pixels. 8827 * height: New height in pixels.
8785 */ 8828 */
8786 void dw_window_set_style(HWND handle, unsigned long style, unsigned long mask) 8829 void dw_window_set_style(HWND handle, unsigned long style, unsigned long mask)
8787 { 8830 {
8788 GtkWidget *handle2 = handle; 8831 GtkWidget *handle2 = handle;
8789 int _locked_by_me = FALSE; 8832 int _locked_by_me = FALSE;
8790 8833
8791 DW_MUTEX_LOCK; 8834 DW_MUTEX_LOCK;
8792 if(GTK_IS_SCROLLED_WINDOW(handle)) 8835 if(GTK_IS_SCROLLED_WINDOW(handle))
8793 { 8836 {
8794 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 8837 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
8795 if(tmp) 8838 if(tmp)
8796 handle2 = tmp; 8839 handle2 = tmp;
8797 } 8840 }
8798 else if(GTK_IS_FRAME(handle)) 8841 else if(GTK_IS_FRAME(handle))
8799 { 8842 {
8800 GtkWidget *tmp = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_label"); 8843 GtkWidget *tmp = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_label");
8801 if(tmp && GTK_IS_LABEL(tmp)) 8844 if(tmp && GTK_IS_LABEL(tmp))
8802 handle2 = tmp; 8845 handle2 = tmp;
8803 } 8846 }
8804 if(GTK_IS_LABEL(handle2)) 8847 if(GTK_IS_LABEL(handle2))
8805 { 8848 {
8806 if(style & DW_DT_CENTER || style & DW_DT_VCENTER) 8849 if(style & DW_DT_CENTER || style & DW_DT_VCENTER)
8807 { 8850 {
8808 gfloat x, y; 8851 gfloat x, y;
8809 8852
8810 x = y = DW_LEFT; 8853 x = y = DW_LEFT;
8811 8854
8812 if(style & DW_DT_CENTER) 8855 if(style & DW_DT_CENTER)
8813 x = DW_CENTER; 8856 x = DW_CENTER;
8814 8857
8815 if(style & DW_DT_VCENTER) 8858 if(style & DW_DT_VCENTER)
8816 y = DW_CENTER; 8859 y = DW_CENTER;
8817 8860
8818 gtk_misc_set_alignment(GTK_MISC(handle2), x, y); 8861 gtk_misc_set_alignment(GTK_MISC(handle2), x, y);
8819 } 8862 }
8820 if(style & DW_DT_WORDBREAK) 8863 if(style & DW_DT_WORDBREAK)
8821 gtk_label_set_line_wrap(GTK_LABEL(handle), TRUE); 8864 gtk_label_set_line_wrap(GTK_LABEL(handle), TRUE);
8822 } 8865 }
8823 DW_MUTEX_UNLOCK; 8866 DW_MUTEX_UNLOCK;
8824 } 8867 }
8825 8868
8826 /* 8869 /*
8827 * Adds a new page to specified notebook. 8870 * Adds a new page to specified notebook.
8828 * Parameters: 8871 * Parameters:
8830 * flags: Any additional page creation flags. 8873 * flags: Any additional page creation flags.
8831 * front: If TRUE page is added at the beginning. 8874 * front: If TRUE page is added at the beginning.
8832 */ 8875 */
8833 unsigned long dw_notebook_page_new(HWND handle, unsigned long flags, int front) 8876 unsigned long dw_notebook_page_new(HWND handle, unsigned long flags, int front)
8834 { 8877 {
8835 int z; 8878 int z;
8836 int _locked_by_me = FALSE; 8879 int _locked_by_me = FALSE;
8837 GtkWidget **pagearray; 8880 GtkWidget **pagearray;
8838 8881
8839 DW_MUTEX_LOCK; 8882 DW_MUTEX_LOCK;
8840 pagearray = (GtkWidget **)gtk_object_get_data(GTK_OBJECT(handle), "_dw_pagearray"); 8883 pagearray = (GtkWidget **)gtk_object_get_data(GTK_OBJECT(handle), "_dw_pagearray");
8841 8884
8842 if(pagearray) 8885 if(pagearray)
8843 { 8886 {
8844 for(z=0;z<256;z++) 8887 for(z=0;z<256;z++)
8845 { 8888 {
8846 if(!pagearray[z]) 8889 if(!pagearray[z])
8847 { 8890 {
8848 char text[100]; 8891 char text[100];
8849 int num = z; 8892 int num = z;
8850 8893
8851 if(front) 8894 if(front)
8852 num |= 1 << 16; 8895 num |= 1 << 16;
8853 8896
8854 sprintf(text, "_dw_page%d", z); 8897 sprintf(text, "_dw_page%d", z);
8855 /* Save the real id and the creation flags */ 8898 /* Save the real id and the creation flags */
8856 gtk_object_set_data(GTK_OBJECT(handle), text, (gpointer)num); 8899 gtk_object_set_data(GTK_OBJECT(handle), text, GINT_TO_POINTER(num));
8857 DW_MUTEX_UNLOCK; 8900 DW_MUTEX_UNLOCK;
8858 return z; 8901 return z;
8859 } 8902 }
8860 } 8903 }
8861 } 8904 }
8862 DW_MUTEX_UNLOCK; 8905 DW_MUTEX_UNLOCK;
8863 8906
8864 /* Hopefully this won't happen. */ 8907 /* Hopefully this won't happen. */
8865 return 256; 8908 return 256;
8866 } 8909 }
8867 8910
8868 /* Return the physical page id from the logical page id */ 8911 /* Return the physical page id from the logical page id */
8869 int _get_physical_page(HWND handle, unsigned long pageid) 8912 int _get_physical_page(HWND handle, unsigned long pageid)
8870 { 8913 {
8871 int z; 8914 int z;
8872 GtkWidget *thispage, **pagearray = gtk_object_get_data(GTK_OBJECT(handle), "_dw_pagearray"); 8915 GtkWidget *thispage, **pagearray = gtk_object_get_data(GTK_OBJECT(handle), "_dw_pagearray");
8873 8916
8874 if(pagearray) 8917 if(pagearray)
8875 { 8918 {
8876 for(z=0;z<256;z++) 8919 for(z=0;z<256;z++)
8877 { 8920 {
8878 if((thispage = gtk_notebook_get_nth_page(GTK_NOTEBOOK(handle), z))) 8921 if((thispage = gtk_notebook_get_nth_page(GTK_NOTEBOOK(handle), z)))
8879 { 8922 {
8880 if(thispage == pagearray[pageid]) 8923 if(thispage == pagearray[pageid])
8881 return z; 8924 return z;
8882 } 8925 }
8883 } 8926 }
8884 } 8927 }
8885 return 256; 8928 return 256;
8886 } 8929 }
8887 8930
8888 /* 8931 /*
8889 * Remove a page from a notebook. 8932 * Remove a page from a notebook.
8890 * Parameters: 8933 * Parameters:
8891 * handle: Handle to the notebook widget. 8934 * handle: Handle to the notebook widget.
8892 * pageid: ID of the page to be destroyed. 8935 * pageid: ID of the page to be destroyed.
8893 */ 8936 */
8894 void dw_notebook_page_destroy(HWND handle, unsigned int pageid) 8937 void dw_notebook_page_destroy(HWND handle, unsigned int pageid)
8895 { 8938 {
8896 int realpage, _locked_by_me = FALSE; 8939 int realpage, _locked_by_me = FALSE;
8897 GtkWidget **pagearray; 8940 GtkWidget **pagearray;
8898 8941
8899 DW_MUTEX_LOCK; 8942 DW_MUTEX_LOCK;
8900 realpage = _get_physical_page(handle, pageid); 8943 realpage = _get_physical_page(handle, pageid);
8901 if(realpage > -1 && realpage < 256) 8944 if(realpage > -1 && realpage < 256)
8902 { 8945 {
8903 gtk_notebook_remove_page(GTK_NOTEBOOK(handle), realpage); 8946 gtk_notebook_remove_page(GTK_NOTEBOOK(handle), realpage);
8904 if((pagearray = gtk_object_get_data(GTK_OBJECT(handle), "_dw_pagearray"))) 8947 if((pagearray = gtk_object_get_data(GTK_OBJECT(handle), "_dw_pagearray")))
8905 pagearray[pageid] = NULL; 8948 pagearray[pageid] = NULL;
8906 } 8949 }
8907 DW_MUTEX_UNLOCK; 8950 DW_MUTEX_UNLOCK;
8908 } 8951 }
8909 8952
8910 /* 8953 /*
8911 * Queries the currently visible page ID. 8954 * Queries the currently visible page ID.
8912 * Parameters: 8955 * Parameters:
8913 * handle: Handle to the notebook widget. 8956 * handle: Handle to the notebook widget.
8914 */ 8957 */
8915 unsigned long dw_notebook_page_get(HWND handle) 8958 unsigned long dw_notebook_page_get(HWND handle)
8916 { 8959 {
8917 int retval, phys; 8960 int retval, phys;
8918 int _locked_by_me = FALSE; 8961 int _locked_by_me = FALSE;
8919 8962
8920 DW_MUTEX_LOCK; 8963 DW_MUTEX_LOCK;
8921 phys = gtk_notebook_get_current_page(GTK_NOTEBOOK(handle)); 8964 phys = gtk_notebook_get_current_page(GTK_NOTEBOOK(handle));
8922 retval = _get_logical_page(handle, phys); 8965 retval = _get_logical_page(handle, phys);
8923 DW_MUTEX_UNLOCK; 8966 DW_MUTEX_UNLOCK;
8924 return retval; 8967 return retval;
8925 } 8968 }
8926 8969
8927 /* 8970 /*
8928 * Sets the currently visibale page ID. 8971 * Sets the currently visibale page ID.
8929 * Parameters: 8972 * Parameters:
8930 * handle: Handle to the notebook widget. 8973 * handle: Handle to the notebook widget.
8931 * pageid: ID of the page to be made visible. 8974 * pageid: ID of the page to be made visible.
8932 */ 8975 */
8933 void dw_notebook_page_set(HWND handle, unsigned int pageid) 8976 void dw_notebook_page_set(HWND handle, unsigned int pageid)
8934 { 8977 {
8935 int realpage, _locked_by_me = FALSE; 8978 int realpage, _locked_by_me = FALSE;
8936 8979
8937 DW_MUTEX_LOCK; 8980 DW_MUTEX_LOCK;
8938 realpage = _get_physical_page(handle, pageid); 8981 realpage = _get_physical_page(handle, pageid);
8939 if(realpage > -1 && realpage < 256) 8982 if(realpage > -1 && realpage < 256)
8940 gtk_notebook_set_page(GTK_NOTEBOOK(handle), pageid); 8983 gtk_notebook_set_page(GTK_NOTEBOOK(handle), pageid);
8941 DW_MUTEX_UNLOCK; 8984 DW_MUTEX_UNLOCK;
8942 } 8985 }
8943 8986
8944 8987
8945 /* 8988 /*
8946 * Sets the text on the specified notebook tab. 8989 * Sets the text on the specified notebook tab.
8949 * pageid: Page ID of the tab to set. 8992 * pageid: Page ID of the tab to set.
8950 * text: Pointer to the text to set. 8993 * text: Pointer to the text to set.
8951 */ 8994 */
8952 void dw_notebook_page_set_text(HWND handle, unsigned long pageid, char *text) 8995 void dw_notebook_page_set_text(HWND handle, unsigned long pageid, char *text)
8953 { 8996 {
8954 GtkWidget *child; 8997 GtkWidget *child;
8955 int realpage, _locked_by_me = FALSE; 8998 int realpage, _locked_by_me = FALSE;
8956 8999
8957 DW_MUTEX_LOCK; 9000 DW_MUTEX_LOCK;
8958 realpage = _get_physical_page(handle, pageid); 9001 realpage = _get_physical_page(handle, pageid);
8959 if(realpage < 0 || realpage > 255) 9002 if(realpage < 0 || realpage > 255)
8960 { 9003 {
8961 char ptext[100]; 9004 char ptext[100];
8962 int num; 9005 int num;
8963 9006
8964 sprintf(ptext, "_dw_page%d", (int)pageid); 9007 sprintf(ptext, "_dw_page%d", (int)pageid);
8965 num = (int)gtk_object_get_data(GTK_OBJECT(handle), ptext); 9008 num = (int)gtk_object_get_data(GTK_OBJECT(handle), ptext);
8966 realpage = 0xFF & num; 9009 realpage = 0xFF & num;
8967 } 9010 }
8968 9011
8969 if(realpage > -1 && realpage < 256) 9012 if(realpage > -1 && realpage < 256)
8970 { 9013 {
8971 child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(handle), realpage); 9014 child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(handle), realpage);
8972 if(child) 9015 if(child)
8973 gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(handle), child, text); 9016 gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(handle), child, text);
8974 } 9017 }
8975 DW_MUTEX_UNLOCK; 9018 DW_MUTEX_UNLOCK;
8976 } 9019 }
8977 9020
8978 /* 9021 /*
8979 * Sets the text on the specified notebook tab status area. 9022 * Sets the text on the specified notebook tab status area.
8980 * Parameters: 9023 * Parameters:
8982 * pageid: Page ID of the tab to set. 9025 * pageid: Page ID of the tab to set.
8983 * text: Pointer to the text to set. 9026 * text: Pointer to the text to set.
8984 */ 9027 */
8985 void dw_notebook_page_set_status_text(HWND handle, unsigned long pageid, char *text) 9028 void dw_notebook_page_set_status_text(HWND handle, unsigned long pageid, char *text)
8986 { 9029 {
8987 /* TODO (if possible) */ 9030 /* TODO (if possible) */
8988 } 9031 }
8989 9032
8990 /* 9033 /*
8991 * Packs the specified box into the notebook page. 9034 * Packs the specified box into the notebook page.
8992 * Parameters: 9035 * Parameters:
8994 * pageid: Page ID in the notebook which is being packed. 9037 * pageid: Page ID in the notebook which is being packed.
8995 * page: Box handle to be packed. 9038 * page: Box handle to be packed.
8996 */ 9039 */
8997 void dw_notebook_pack(HWND handle, unsigned long pageid, HWND page) 9040 void dw_notebook_pack(HWND handle, unsigned long pageid, HWND page)
8998 { 9041 {
8999 GtkWidget *label, *child, *oldlabel, **pagearray; 9042 GtkWidget *label, *child, *oldlabel, **pagearray;
9000 gchar *text = NULL; 9043 gchar *text = NULL;
9001 int num, z, realpage = -1, pad, _locked_by_me = FALSE; 9044 int num, z, realpage = -1, pad, _locked_by_me = FALSE;
9002 char ptext[100]; 9045 char ptext[100];
9003 9046
9004 DW_MUTEX_LOCK; 9047 DW_MUTEX_LOCK;
9005 sprintf(ptext, "_dw_page%d", (int)pageid); 9048 sprintf(ptext, "_dw_page%d", (int)pageid);
9006 num = (int)gtk_object_get_data(GTK_OBJECT(handle), ptext); 9049 num = (int)gtk_object_get_data(GTK_OBJECT(handle), ptext);
9007 gtk_object_set_data(GTK_OBJECT(handle), ptext, NULL); 9050 gtk_object_set_data(GTK_OBJECT(handle), ptext, NULL);
9008 pagearray = (GtkWidget **)gtk_object_get_data(GTK_OBJECT(handle), "_dw_pagearray"); 9051 pagearray = (GtkWidget **)gtk_object_get_data(GTK_OBJECT(handle), "_dw_pagearray");
9009 9052
9010 if(!pagearray) 9053 if(!pagearray)
9011 { 9054 {
9012 DW_MUTEX_UNLOCK; 9055 DW_MUTEX_UNLOCK;
9013 return; 9056 return;
9014 } 9057 }
9015 9058
9016 /* The page already exists... so get it's current page */ 9059 /* The page already exists... so get it's current page */
9017 if(pagearray[pageid]) 9060 if(pagearray[pageid])
9018 { 9061 {
9019 for(z=0;z<256;z++) 9062 for(z=0;z<256;z++)
9020 { 9063 {
9021 child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(handle), z); 9064 child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(handle), z);
9022 if(child == pagearray[pageid]) 9065 if(child == pagearray[pageid])
9023 { 9066 {
9024 oldlabel = gtk_notebook_get_tab_label(GTK_NOTEBOOK(handle), child); 9067 oldlabel = gtk_notebook_get_tab_label(GTK_NOTEBOOK(handle), child);
9025 if(oldlabel) 9068 if(oldlabel)
9026 gtk_label_get(GTK_LABEL(oldlabel), &text); 9069 gtk_label_get(GTK_LABEL(oldlabel), &text);
9027 gtk_notebook_remove_page(GTK_NOTEBOOK(handle), z); 9070 gtk_notebook_remove_page(GTK_NOTEBOOK(handle), z);
9028 realpage = z; 9071 realpage = z;
9029 break; 9072 break;
9030 } 9073 }
9031 } 9074 }
9032 } 9075 }
9033 9076
9034 pagearray[pageid] = page; 9077 pagearray[pageid] = page;
9035 9078
9036 label = gtk_label_new(text ? text : ""); 9079 label = gtk_label_new(text ? text : "");
9037 9080
9038 if(GTK_IS_TABLE(page)) 9081 if(GTK_IS_TABLE(page))
9039 { 9082 {
9040 pad = (int)gtk_object_get_data(GTK_OBJECT(page), "_dw_boxpad"); 9083 pad = (int)gtk_object_get_data(GTK_OBJECT(page), "_dw_boxpad");
9041 gtk_container_border_width(GTK_CONTAINER(page), pad); 9084 gtk_container_border_width(GTK_CONTAINER(page), pad);
9042 } 9085 }
9043 9086
9044 if(realpage != -1) 9087 if(realpage != -1)
9045 gtk_notebook_insert_page(GTK_NOTEBOOK(handle), page, label, realpage); 9088 gtk_notebook_insert_page(GTK_NOTEBOOK(handle), page, label, realpage);
9046 else if(num & ~(0xFF)) 9089 else if(num & ~(0xFF))
9047 gtk_notebook_insert_page(GTK_NOTEBOOK(handle), page, label, 0); 9090 gtk_notebook_insert_page(GTK_NOTEBOOK(handle), page, label, 0);
9048 else 9091 else
9049 gtk_notebook_insert_page(GTK_NOTEBOOK(handle), page, label, 256); 9092 gtk_notebook_insert_page(GTK_NOTEBOOK(handle), page, label, 256);
9050 DW_MUTEX_UNLOCK; 9093 DW_MUTEX_UNLOCK;
9051 } 9094 }
9052 9095
9053 /* 9096 /*
9054 * Appends the specified text to the listbox's (or combobox) entry list. 9097 * Appends the specified text to the listbox's (or combobox) entry list.
9055 * Parameters: 9098 * Parameters:
9056 * handle: Handle to the listbox to be appended to. 9099 * handle: Handle to the listbox to be appended to.
9057 * text: Text to append into listbox. 9100 * text: Text to append into listbox.
9058 */ 9101 */
9059 void dw_listbox_append(HWND handle, char *text) 9102 void dw_listbox_append(HWND handle, char *text)
9060 { 9103 {
9061 GtkWidget *handle2 = handle; 9104 GtkWidget *handle2 = handle;
9062 int _locked_by_me = FALSE; 9105 int _locked_by_me = FALSE;
9063 9106
9064 DW_MUTEX_LOCK; 9107 DW_MUTEX_LOCK;
9065 if(GTK_IS_SCROLLED_WINDOW(handle)) 9108 if(GTK_IS_SCROLLED_WINDOW(handle))
9066 { 9109 {
9067 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 9110 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
9068 if(tmp) 9111 if(tmp)
9069 handle2 = tmp; 9112 handle2 = tmp;
9070 } 9113 }
9071 gtk_object_set_data(GTK_OBJECT(handle), "_dw_appending", (gpointer)1); 9114 gtk_object_set_data(GTK_OBJECT(handle), "_dw_appending", GINT_TO_POINTER(1));
9072 if(GTK_IS_LIST(handle2)) 9115 if(GTK_IS_LIST(handle2))
9073 { 9116 {
9074 GtkWidget *list_item; 9117 GtkWidget *list_item;
9075 GList *tmp; 9118 GList *tmp;
9076 char *font = (char *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_font"); 9119 char *font = (char *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_font");
9077 GdkColor *fore = (GdkColor *)gtk_object_get_data(GTK_OBJECT(handle2), "_dw_foregdk"); 9120 GdkColor *fore = (GdkColor *)gtk_object_get_data(GTK_OBJECT(handle2), "_dw_foregdk");
9078 GdkColor *back = (GdkColor *)gtk_object_get_data(GTK_OBJECT(handle2), "_dw_backgdk"); 9121 GdkColor *back = (GdkColor *)gtk_object_get_data(GTK_OBJECT(handle2), "_dw_backgdk");
9079 9122
9080 list_item=gtk_list_item_new_with_label(text); 9123 list_item=gtk_list_item_new_with_label(text);
9081 9124
9082 if(font) 9125 if(font)
9083 _set_font(GTK_LIST_ITEM(list_item)->item.bin.child, font); 9126 _set_font(GTK_LIST_ITEM(list_item)->item.bin.child, font);
9084 if(fore && back) 9127 if(fore && back)
9085 _set_color(GTK_LIST_ITEM(list_item)->item.bin.child, 9128 _set_color(GTK_LIST_ITEM(list_item)->item.bin.child,
9086 DW_RGB(fore->red, fore->green, fore->blue), 9129 DW_RGB(fore->red, fore->green, fore->blue),
9087 DW_RGB(back->red, back->green, back->blue)); 9130 DW_RGB(back->red, back->green, back->blue));
9088 9131
9089 tmp = g_list_append(NULL, list_item); 9132 tmp = g_list_append(NULL, list_item);
9090 gtk_widget_show(list_item); 9133 gtk_widget_show(list_item);
9091 gtk_list_append_items(GTK_LIST(handle2),tmp); 9134 gtk_list_append_items(GTK_LIST(handle2),tmp);
9092 } 9135 }
9093 else if(GTK_IS_COMBO(handle2)) 9136 else if(GTK_IS_COMBO(handle2))
9094 { 9137 {
9095 GList *tmp = (GList *)gtk_object_get_user_data(GTK_OBJECT(handle2)); 9138 GList *tmp = (GList *)gtk_object_get_user_data(GTK_OBJECT(handle2));
9096 char *addtext = strdup(text); 9139 char *addtext = strdup(text);
9097 9140
9098 if(addtext) 9141 if(addtext)
9099 { 9142 {
9100 tmp = g_list_append(tmp, addtext); 9143 tmp = g_list_append(tmp, addtext);
9101 gtk_object_set_user_data(GTK_OBJECT(handle2), tmp); 9144 gtk_object_set_user_data(GTK_OBJECT(handle2), tmp);
9102 gtk_combo_set_popdown_strings(GTK_COMBO(handle2), tmp); 9145 gtk_combo_set_popdown_strings(GTK_COMBO(handle2), tmp);
9103 } 9146 }
9104 } 9147 }
9105 gtk_object_set_data(GTK_OBJECT(handle), "_dw_appending", NULL); 9148 gtk_object_set_data(GTK_OBJECT(handle), "_dw_appending", NULL);
9106 DW_MUTEX_UNLOCK; 9149 DW_MUTEX_UNLOCK;
9107 } 9150 }
9108 9151
9109 /* 9152 /*
9110 * Appends the specified text items to the listbox's (or combobox) entry list. 9153 * Appends the specified text items to the listbox's (or combobox) entry list.
9111 * Parameters: 9154 * Parameters:
9113 * text: Text strings to append into listbox. 9156 * text: Text strings to append into listbox.
9114 * count: Number of text strings to append 9157 * count: Number of text strings to append
9115 */ 9158 */
9116 void dw_listbox_list_append(HWND handle, char **text, int count) 9159 void dw_listbox_list_append(HWND handle, char **text, int count)
9117 { 9160 {
9118 GtkWidget *handle2 = handle; 9161 GtkWidget *handle2 = handle;
9119 int _locked_by_me = FALSE; 9162 int _locked_by_me = FALSE;
9120 9163
9121 DW_MUTEX_LOCK; 9164 DW_MUTEX_LOCK;
9122 if(GTK_IS_SCROLLED_WINDOW(handle)) 9165 if(GTK_IS_SCROLLED_WINDOW(handle))
9123 { 9166 {
9124 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 9167 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
9125 if(tmp) 9168 if(tmp)
9126 handle2 = tmp; 9169 handle2 = tmp;
9127 } 9170 }
9128 gtk_object_set_data(GTK_OBJECT(handle), "_dw_appending", (gpointer)1); 9171 gtk_object_set_data(GTK_OBJECT(handle), "_dw_appending", GINT_TO_POINTER(1));
9129 if(GTK_IS_LIST(handle2)) 9172 if(GTK_IS_LIST(handle2))
9130 { 9173 {
9131 GtkWidget *list_item; 9174 GtkWidget *list_item;
9132 GList *tmp; 9175 GList *tmp;
9133 char *font = (char *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_font"); 9176 char *font = (char *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_font");
9134 GdkColor *fore = (GdkColor *)gtk_object_get_data(GTK_OBJECT(handle2), "_dw_foregdk"); 9177 GdkColor *fore = (GdkColor *)gtk_object_get_data(GTK_OBJECT(handle2), "_dw_foregdk");
9135 GdkColor *back = (GdkColor *)gtk_object_get_data(GTK_OBJECT(handle2), "_dw_backgdk"); 9178 GdkColor *back = (GdkColor *)gtk_object_get_data(GTK_OBJECT(handle2), "_dw_backgdk");
9136 9179
9137 list_item=gtk_list_item_new_with_label(*text); 9180 list_item=gtk_list_item_new_with_label(*text);
9138 9181
9139 if(font) 9182 if(font)
9140 _set_font(GTK_LIST_ITEM(list_item)->item.bin.child, font); 9183 _set_font(GTK_LIST_ITEM(list_item)->item.bin.child, font);
9141 if(fore && back) 9184 if(fore && back)
9142 _set_color(GTK_LIST_ITEM(list_item)->item.bin.child, 9185 _set_color(GTK_LIST_ITEM(list_item)->item.bin.child,
9143 DW_RGB(fore->red, fore->green, fore->blue), 9186 DW_RGB(fore->red, fore->green, fore->blue),
9144 DW_RGB(back->red, back->green, back->blue)); 9187 DW_RGB(back->red, back->green, back->blue));
9145 9188
9146 tmp = g_list_append(NULL, list_item); 9189 tmp = g_list_append(NULL, list_item);
9147 gtk_widget_show(list_item); 9190 gtk_widget_show(list_item);
9148 gtk_list_append_items(GTK_LIST(handle2),tmp); 9191 gtk_list_append_items(GTK_LIST(handle2),tmp);
9149 } 9192 }
9150 else if(GTK_IS_COMBO(handle2)) 9193 else if(GTK_IS_COMBO(handle2))
9151 { 9194 {
9152 GList *tmp = (GList *)gtk_object_get_user_data(GTK_OBJECT(handle2)); 9195 GList *tmp = (GList *)gtk_object_get_user_data(GTK_OBJECT(handle2));
9153 char *addtext; 9196 char *addtext;
9154 int i; 9197 int i;
9155 9198
9156 for (i=0;i<count;i++) 9199 for (i=0;i<count;i++)
9157 { 9200 {
9158 addtext = strdup(text[i]); 9201 addtext = strdup(text[i]);
9159 tmp = g_list_append(tmp, addtext); 9202 tmp = g_list_append(tmp, addtext);
9160 } 9203 }
9161 gtk_object_set_user_data(GTK_OBJECT(handle2), tmp); 9204 gtk_object_set_user_data(GTK_OBJECT(handle2), tmp);
9162 gtk_combo_set_popdown_strings(GTK_COMBO(handle2), tmp); 9205 gtk_combo_set_popdown_strings(GTK_COMBO(handle2), tmp);
9163 } 9206 }
9164 gtk_object_set_data(GTK_OBJECT(handle), "_dw_appending", NULL); 9207 gtk_object_set_data(GTK_OBJECT(handle), "_dw_appending", NULL);
9165 DW_MUTEX_UNLOCK; 9208 DW_MUTEX_UNLOCK;
9166 } 9209 }
9167 9210
9168 /* 9211 /*
9169 * Clears the listbox's (or combobox) list of all entries. 9212 * Clears the listbox's (or combobox) list of all entries.
9170 * Parameters: 9213 * Parameters:
9171 * handle: Handle to the listbox to be cleared. 9214 * handle: Handle to the listbox to be cleared.
9172 */ 9215 */
9173 void dw_listbox_clear(HWND handle) 9216 void dw_listbox_clear(HWND handle)
9174 { 9217 {
9175 GtkWidget *handle2 = handle; 9218 GtkWidget *handle2 = handle;
9176 int _locked_by_me = FALSE; 9219 int _locked_by_me = FALSE;
9177 9220
9178 DW_MUTEX_LOCK; 9221 DW_MUTEX_LOCK;
9179 if(GTK_IS_SCROLLED_WINDOW(handle)) 9222 if(GTK_IS_SCROLLED_WINDOW(handle))
9180 { 9223 {
9181 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 9224 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
9182 if(tmp) 9225 if(tmp)
9183 handle2 = tmp; 9226 handle2 = tmp;
9184 } 9227 }
9185 if(GTK_IS_COMBO(handle2)) 9228 if(GTK_IS_COMBO(handle2))
9186 { 9229 {
9187 GList *list, *tmp = (GList *)gtk_object_get_user_data(GTK_OBJECT(handle2)); 9230 GList *list, *tmp = (GList *)gtk_object_get_user_data(GTK_OBJECT(handle2));
9188 9231
9189 if(tmp) 9232 if(tmp)
9190 { 9233 {
9191 list = tmp; 9234 list = tmp;
9192 while(list) 9235 while(list)
9193 { 9236 {
9194 if(list->data) 9237 if(list->data)
9195 free(list->data); 9238 free(list->data);
9196 list=list->next; 9239 list=list->next;
9197 } 9240 }
9198 g_list_free(tmp); 9241 g_list_free(tmp);
9199 } 9242 }
9200 gtk_object_set_user_data(GTK_OBJECT(handle2), NULL); 9243 gtk_object_set_user_data(GTK_OBJECT(handle2), NULL);
9201 } 9244 }
9202 else if(GTK_IS_LIST(handle2)) 9245 else if(GTK_IS_LIST(handle2))
9203 { 9246 {
9204 int count = dw_listbox_count(handle); 9247 int count = dw_listbox_count(handle);
9205 9248
9206 gtk_list_clear_items(GTK_LIST(handle2), 0, count - 1); 9249 gtk_list_clear_items(GTK_LIST(handle2), 0, count - 1);
9207 } 9250 }
9208 DW_MUTEX_UNLOCK; 9251 DW_MUTEX_UNLOCK;
9209 } 9252 }
9210 9253
9211 /* 9254 /*
9212 * Returns the listbox's item count. 9255 * Returns the listbox's item count.
9213 * Parameters: 9256 * Parameters:
9214 * handle: Handle to the listbox to be counted 9257 * handle: Handle to the listbox to be counted
9215 */ 9258 */
9216 int dw_listbox_count(HWND handle) 9259 int dw_listbox_count(HWND handle)
9217 { 9260 {
9218 GtkWidget *handle2 = handle; 9261 GtkWidget *handle2 = handle;
9219 int retval = 0; 9262 int retval = 0;
9220 int _locked_by_me = FALSE; 9263 int _locked_by_me = FALSE;
9221 9264
9222 DW_MUTEX_LOCK; 9265 DW_MUTEX_LOCK;
9223 if(GTK_IS_SCROLLED_WINDOW(handle)) 9266 if(GTK_IS_SCROLLED_WINDOW(handle))
9224 { 9267 {
9225 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 9268 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
9226 if(tmp) 9269 if(tmp)
9227 handle2 = tmp; 9270 handle2 = tmp;
9228 } 9271 }
9229 else if(GTK_IS_COMBO(handle)) 9272 else if(GTK_IS_COMBO(handle))
9230 { 9273 {
9231 handle2 = GTK_COMBO(handle)->list; 9274 handle2 = GTK_COMBO(handle)->list;
9232 } 9275 }
9233 if(GTK_IS_LIST(handle2)) 9276 if(GTK_IS_LIST(handle2))
9234 { 9277 {
9235 GList *list = GTK_LIST(handle2)->children; 9278 GList *list = GTK_LIST(handle2)->children;
9236 while(list) 9279 while(list)
9237 { 9280 {
9238 list = list->next; 9281 list = list->next;
9239 retval++; 9282 retval++;
9240 } 9283 }
9241 } 9284 }
9242 DW_MUTEX_UNLOCK; 9285 DW_MUTEX_UNLOCK;
9243 return retval; 9286 return retval;
9244 } 9287 }
9245 9288
9246 /* 9289 /*
9247 * Sets the topmost item in the viewport. 9290 * Sets the topmost item in the viewport.
9248 * Parameters: 9291 * Parameters:
9249 * handle: Handle to the listbox to be cleared. 9292 * handle: Handle to the listbox to be cleared.
9250 * top: Index to the top item. 9293 * top: Index to the top item.
9251 */ 9294 */
9252 void dw_listbox_set_top(HWND handle, int top) 9295 void dw_listbox_set_top(HWND handle, int top)
9253 { 9296 {
9254 GtkWidget *handle2 = handle; 9297 GtkWidget *handle2 = handle;
9255 int _locked_by_me = FALSE; 9298 int _locked_by_me = FALSE;
9256 9299
9257 DW_MUTEX_LOCK; 9300 DW_MUTEX_LOCK;
9258 if(GTK_IS_SCROLLED_WINDOW(handle)) 9301 if(GTK_IS_SCROLLED_WINDOW(handle))
9259 { 9302 {
9260 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 9303 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
9261 if(tmp) 9304 if(tmp)
9262 handle2 = tmp; 9305 handle2 = tmp;
9263 } 9306 }
9264 if(GTK_IS_LIST(handle2)) 9307 if(GTK_IS_LIST(handle2))
9265 { 9308 {
9266 int count = dw_listbox_count(handle); 9309 int count = dw_listbox_count(handle);
9267 GtkAdjustment *adj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(handle)); 9310 GtkAdjustment *adj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(handle));
9268 float pos, ratio; 9311 float pos, ratio;
9269 9312
9270 if(count) 9313 if(count)
9271 { 9314 {
9272 ratio = (float)top/(float)count; 9315 ratio = (float)top/(float)count;
9273 9316
9274 pos = (ratio * (float)(adj->upper - adj->lower)) + adj->lower; 9317 pos = (ratio * (float)(adj->upper - adj->lower)) + adj->lower;
9275 9318
9276 gtk_adjustment_set_value(adj, pos); 9319 gtk_adjustment_set_value(adj, pos);
9277 } 9320 }
9278 } 9321 }
9279 DW_MUTEX_UNLOCK; 9322 DW_MUTEX_UNLOCK;
9280 } 9323 }
9281 9324
9282 /* 9325 /*
9283 * Copies the given index item's text into buffer. 9326 * Copies the given index item's text into buffer.
9284 * Parameters: 9327 * Parameters:
9287 * buffer: Buffer where text will be copied. 9330 * buffer: Buffer where text will be copied.
9288 * length: Length of the buffer (including NULL). 9331 * length: Length of the buffer (including NULL).
9289 */ 9332 */
9290 void dw_listbox_get_text(HWND handle, unsigned int index, char *buffer, unsigned int length) 9333 void dw_listbox_get_text(HWND handle, unsigned int index, char *buffer, unsigned int length)
9291 { 9334 {
9292 GtkWidget *handle2 = handle; 9335 GtkWidget *handle2 = handle;
9293 int _locked_by_me = FALSE; 9336 int _locked_by_me = FALSE;
9294 9337
9295 DW_MUTEX_LOCK; 9338 DW_MUTEX_LOCK;
9296 if(GTK_IS_SCROLLED_WINDOW(handle)) 9339 if(GTK_IS_SCROLLED_WINDOW(handle))
9297 { 9340 {
9298 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 9341 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
9299 if(tmp) 9342 if(tmp)
9300 handle2 = tmp; 9343 handle2 = tmp;
9301 } 9344 }
9302 else if(GTK_IS_COMBO(handle)) 9345 else if(GTK_IS_COMBO(handle))
9303 { 9346 {
9304 handle2 = GTK_COMBO(handle)->list; 9347 handle2 = GTK_COMBO(handle)->list;
9305 } 9348 }
9306 if(GTK_IS_LIST(handle2)) 9349 if(GTK_IS_LIST(handle2))
9307 { 9350 {
9308 int counter = 0; 9351 int counter = 0;
9309 GList *list = GTK_LIST(handle2)->children; 9352 GList *list = GTK_LIST(handle2)->children;
9310 9353
9311 while(list) 9354 while(list)
9312 { 9355 {
9313 if(counter == index) 9356 if(counter == index)
9314 { 9357 {
9315 gchar *text = ""; 9358 gchar *text = "";
9316 9359
9317 if(GTK_IS_LIST_ITEM(list->data)) 9360 if(GTK_IS_LIST_ITEM(list->data))
9318 { 9361 {
9319 GtkListItem *li = GTK_LIST_ITEM(list->data); 9362 GtkListItem *li = GTK_LIST_ITEM(list->data);
9320 9363
9321 if(GTK_IS_ITEM(&(li->item))) 9364 if(GTK_IS_ITEM(&(li->item)))
9322 { 9365 {
9323 GtkItem *i = &(li->item); 9366 GtkItem *i = &(li->item);
9324 9367
9325 if(GTK_IS_BIN(&(i->bin))) 9368 if(GTK_IS_BIN(&(i->bin)))
9326 { 9369 {
9327 GtkBin *b = &(i->bin); 9370 GtkBin *b = &(i->bin);
9328 9371
9329 if(GTK_IS_LABEL(b->child)) 9372 if(GTK_IS_LABEL(b->child))
9330 gtk_label_get(GTK_LABEL(b->child), &text); 9373 gtk_label_get(GTK_LABEL(b->child), &text);
9331 } 9374 }
9332 } 9375 }
9333 } 9376 }
9334 else if(GTK_IS_COMBO(handle) && list->data) 9377 else if(GTK_IS_COMBO(handle) && list->data)
9335 text = (gchar *)list->data; 9378 text = (gchar *)list->data;
9336 9379
9337 strncpy(buffer, (char *)text, length); 9380 strncpy(buffer, (char *)text, length);
9338 break; 9381 break;
9339 } 9382 }
9340 list = list->next; 9383 list = list->next;
9341 counter++; 9384 counter++;
9342 } 9385 }
9343 } 9386 }
9344 DW_MUTEX_UNLOCK; 9387 DW_MUTEX_UNLOCK;
9345 } 9388 }
9346 9389
9347 /* 9390 /*
9348 * Sets the text of a given listbox entry. 9391 * Sets the text of a given listbox entry.
9349 * Parameters: 9392 * Parameters:
9351 * index: Index into the list to be queried. 9394 * index: Index into the list to be queried.
9352 * buffer: Buffer where text will be copied. 9395 * buffer: Buffer where text will be copied.
9353 */ 9396 */
9354 void dw_listbox_set_text(HWND handle, unsigned int index, char *buffer) 9397 void dw_listbox_set_text(HWND handle, unsigned int index, char *buffer)
9355 { 9398 {
9356 GtkWidget *handle2 = handle; 9399 GtkWidget *handle2 = handle;
9357 int _locked_by_me = FALSE; 9400 int _locked_by_me = FALSE;
9358 9401
9359 DW_MUTEX_LOCK; 9402 DW_MUTEX_LOCK;
9360 if(GTK_IS_SCROLLED_WINDOW(handle)) 9403 if(GTK_IS_SCROLLED_WINDOW(handle))
9361 { 9404 {
9362 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 9405 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
9363 if(tmp) 9406 if(tmp)
9364 handle2 = tmp; 9407 handle2 = tmp;
9365 } 9408 }
9366 else if(GTK_IS_COMBO(handle)) 9409 else if(GTK_IS_COMBO(handle))
9367 { 9410 {
9368 handle2 = GTK_COMBO(handle)->list; 9411 handle2 = GTK_COMBO(handle)->list;
9369 } 9412 }
9370 if(GTK_IS_LIST(handle2)) 9413 if(GTK_IS_LIST(handle2))
9371 { 9414 {
9372 int counter = 0; 9415 int counter = 0;
9373 GList *list = GTK_LIST(handle2)->children; 9416 GList *list = GTK_LIST(handle2)->children;
9374 9417
9375 while(list) 9418 while(list)
9376 { 9419 {
9377 if(counter == index) 9420 if(counter == index)
9378 { 9421 {
9379 9422
9380 if(GTK_IS_LIST_ITEM(list->data)) 9423 if(GTK_IS_LIST_ITEM(list->data))
9381 { 9424 {
9382 GtkListItem *li = GTK_LIST_ITEM(list->data); 9425 GtkListItem *li = GTK_LIST_ITEM(list->data);
9383 9426
9384 if(GTK_IS_ITEM(&(li->item))) 9427 if(GTK_IS_ITEM(&(li->item)))
9385 { 9428 {
9386 GtkItem *i = &(li->item); 9429 GtkItem *i = &(li->item);
9387 9430
9388 if(GTK_IS_BIN(&(i->bin))) 9431 if(GTK_IS_BIN(&(i->bin)))
9389 { 9432 {
9390 GtkBin *b = &(i->bin); 9433 GtkBin *b = &(i->bin);
9391 9434
9392 if(GTK_IS_LABEL(b->child)) 9435 if(GTK_IS_LABEL(b->child))
9393 gtk_label_set_text(GTK_LABEL(b->child), buffer); 9436 gtk_label_set_text(GTK_LABEL(b->child), buffer);
9394 } 9437 }
9395 } 9438 }
9396 } 9439 }
9397 else if(GTK_IS_COMBO(handle)) 9440 else if(GTK_IS_COMBO(handle))
9398 { 9441 {
9399 if(list->data) 9442 if(list->data)
9400 g_free(list->data); 9443 g_free(list->data);
9401 list->data = g_strdup(buffer); 9444 list->data = g_strdup(buffer);
9402 } 9445 }
9403 break; 9446 break;
9404 } 9447 }
9405 list = list->next; 9448 list = list->next;
9406 counter++; 9449 counter++;
9407 } 9450 }
9408 } 9451 }
9409 DW_MUTEX_UNLOCK; 9452 DW_MUTEX_UNLOCK;
9410 } 9453 }
9411 9454
9412 #if GTK_MAJOR_VERSION < 2 9455 #if GTK_MAJOR_VERSION < 2
9413 /* Check if a GList item is in another GList */ 9456 /* Check if a GList item is in another GList */
9414 static int _dw_in_list(GList *item, GList *list) 9457 static int _dw_in_list(GList *item, GList *list)
9415 { 9458 {
9416 while(list) 9459 while(list)
9417 { 9460 {
9418 if(list->data == item->data) 9461 if(list->data == item->data)
9419 return TRUE; 9462 return TRUE;
9420 9463
9421 list = list->next; 9464 list = list->next;
9422 } 9465 }
9423 return FALSE; 9466 return FALSE;
9424 } 9467 }
9425 #endif 9468 #endif
9426 9469
9427 /* 9470 /*
9428 * Returns the index to the current selected item or -1 when done. 9471 * Returns the index to the current selected item or -1 when done.
9430 * handle: Handle to the listbox to be queried. 9473 * handle: Handle to the listbox to be queried.
9431 * where: Either the previous return or -1 to restart. 9474 * where: Either the previous return or -1 to restart.
9432 */ 9475 */
9433 int dw_listbox_selected_multi(HWND handle, int where) 9476 int dw_listbox_selected_multi(HWND handle, int where)
9434 { 9477 {
9435 GtkWidget *handle2 = handle; 9478 GtkWidget *handle2 = handle;
9436 int retval = DW_LIT_NONE; 9479 int retval = DW_LIT_NONE;
9437 int _locked_by_me = FALSE; 9480 int _locked_by_me = FALSE;
9438 9481
9439 DW_MUTEX_LOCK; 9482 DW_MUTEX_LOCK;
9440 if(GTK_IS_SCROLLED_WINDOW(handle)) 9483 if(GTK_IS_SCROLLED_WINDOW(handle))
9441 { 9484 {
9442 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 9485 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
9443 if(tmp) 9486 if(tmp)
9444 handle2 = tmp; 9487 handle2 = tmp;
9445 } 9488 }
9446 if(GTK_IS_LIST(handle2)) 9489 if(GTK_IS_LIST(handle2))
9447 { 9490 {
9448 #if GTK_MAJOR_VERSION > 1 9491 #if GTK_MAJOR_VERSION > 1
9449 int counter = 0; 9492 int counter = 0;
9450 GList *list = GTK_LIST(handle2)->children; 9493 GList *list = GTK_LIST(handle2)->children;
9451 9494
9452 while(list) 9495 while(list)
9453 { 9496 {
9454 GtkItem *item = (GtkItem *)list->data; 9497 GtkItem *item = (GtkItem *)list->data;
9455 9498
9456 if(item && 9499 if(item &&
9457 item->bin.container.widget.state == GTK_STATE_SELECTED 9500 item->bin.container.widget.state == GTK_STATE_SELECTED
9458 && counter > where) 9501 && counter > where)
9459 { 9502 {
9460 retval = counter; 9503 retval = counter;
9461 break; 9504 break;
9462 } 9505 }
9463 9506
9464 9507
9465 list = list->next; 9508 list = list->next;
9466 counter++; 9509 counter++;
9467 } 9510 }
9468 #else 9511 #else
9469 int counter = 0; 9512 int counter = 0;
9470 GList *list = GTK_LIST(handle2)->children; 9513 GList *list = GTK_LIST(handle2)->children;
9471 9514
9472 while(list) 9515 while(list)
9473 { 9516 {
9474 if(counter > where && _dw_in_list(list, GTK_LIST(handle2)->selection)) 9517 if(counter > where && _dw_in_list(list, GTK_LIST(handle2)->selection))
9475 { 9518 {
9476 retval = counter; 9519 retval = counter;
9477 break; 9520 break;
9478 } 9521 }
9479 9522
9480 list = list->next; 9523 list = list->next;
9481 counter++; 9524 counter++;
9482 } 9525 }
9483 #endif 9526 #endif
9484 } 9527 }
9485 DW_MUTEX_UNLOCK; 9528 DW_MUTEX_UNLOCK;
9486 return retval; 9529 return retval;
9487 } 9530 }
9488 9531
9489 /* 9532 /*
9490 * Returns the index to the item in the list currently selected. 9533 * Returns the index to the item in the list currently selected.
9491 * Parameters: 9534 * Parameters:
9492 * handle: Handle to the listbox to be queried. 9535 * handle: Handle to the listbox to be queried.
9493 */ 9536 */
9494 unsigned int dw_listbox_selected(HWND handle) 9537 unsigned int dw_listbox_selected(HWND handle)
9495 { 9538 {
9496 GtkWidget *handle2 = handle; 9539 GtkWidget *handle2 = handle;
9497 int retval = DW_LIT_NONE; 9540 int retval = DW_LIT_NONE;
9498 int _locked_by_me = FALSE; 9541 int _locked_by_me = FALSE;
9499 9542
9500 DW_MUTEX_LOCK; 9543 DW_MUTEX_LOCK;
9501 if(GTK_IS_SCROLLED_WINDOW(handle)) 9544 if(GTK_IS_SCROLLED_WINDOW(handle))
9502 { 9545 {
9503 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 9546 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
9504 if(tmp) 9547 if(tmp)
9505 handle2 = tmp; 9548 handle2 = tmp;
9506 } 9549 }
9507 else if(GTK_IS_COMBO(handle)) 9550 else if(GTK_IS_COMBO(handle))
9508 { 9551 {
9509 retval = (unsigned int)gtk_object_get_data(GTK_OBJECT(handle), "_dw_item"); 9552 retval = (unsigned int)gtk_object_get_data(GTK_OBJECT(handle), "_dw_item");
9510 DW_MUTEX_UNLOCK; 9553 DW_MUTEX_UNLOCK;
9511 return retval; 9554 return retval;
9512 } 9555 }
9513 if(GTK_IS_LIST(handle2)) 9556 if(GTK_IS_LIST(handle2))
9514 { 9557 {
9515 int counter = 0; 9558 int counter = 0;
9516 GList *list = GTK_LIST(handle2)->children; 9559 GList *list = GTK_LIST(handle2)->children;
9517 #if GTK_MAJOR_VERSION > 1 9560 #if GTK_MAJOR_VERSION > 1
9518 9561
9519 while(list) 9562 while(list)
9520 { 9563 {
9521 GtkItem *item = (GtkItem *)list->data; 9564 GtkItem *item = (GtkItem *)list->data;
9522 9565
9523 if(item && item->bin.container.widget.state == GTK_STATE_SELECTED) 9566 if(item && item->bin.container.widget.state == GTK_STATE_SELECTED)
9524 { 9567 {
9525 retval = counter; 9568 retval = counter;
9526 break; 9569 break;
9527 } 9570 }
9528 9571
9529 list = list->next; 9572 list = list->next;
9530 counter++; 9573 counter++;
9531 } 9574 }
9532 #else 9575 #else
9533 GList *selection = GTK_LIST(handle2)->selection; 9576 GList *selection = GTK_LIST(handle2)->selection;
9534 9577
9535 if(selection) 9578 if(selection)
9536 { 9579 {
9537 while(list) 9580 while(list)
9538 { 9581 {
9539 if(list->data == selection->data) 9582 if(list->data == selection->data)
9540 { 9583 {
9541 retval = counter; 9584 retval = counter;
9542 break; 9585 break;
9543 } 9586 }
9544 9587
9545 list = list->next; 9588 list = list->next;
9546 counter++; 9589 counter++;
9547 } 9590 }
9548 } 9591 }
9549 #endif 9592 #endif
9550 } 9593 }
9551 DW_MUTEX_UNLOCK; 9594 DW_MUTEX_UNLOCK;
9552 return retval; 9595 return retval;
9553 } 9596 }
9554 9597
9555 /* 9598 /*
9556 * Sets the selection state of a given index. 9599 * Sets the selection state of a given index.
9557 * Parameters: 9600 * Parameters:
9559 * index: Item index. 9602 * index: Item index.
9560 * state: TRUE if selected FALSE if unselected. 9603 * state: TRUE if selected FALSE if unselected.
9561 */ 9604 */
9562 void dw_listbox_select(HWND handle, int index, int state) 9605 void dw_listbox_select(HWND handle, int index, int state)
9563 { 9606 {
9564 GtkWidget *handle2 = handle; 9607 GtkWidget *handle2 = handle;
9565 int _locked_by_me = FALSE; 9608 int _locked_by_me = FALSE;
9566 9609
9567 DW_MUTEX_LOCK; 9610 DW_MUTEX_LOCK;
9568 if(GTK_IS_SCROLLED_WINDOW(handle)) 9611 if(GTK_IS_SCROLLED_WINDOW(handle))
9569 { 9612 {
9570 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 9613 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
9571 if(tmp) 9614 if(tmp)
9572 handle2 = tmp; 9615 handle2 = tmp;
9573 } 9616 }
9574 else if(GTK_IS_COMBO(handle)) 9617 else if(GTK_IS_COMBO(handle))
9575 { 9618 {
9576 handle2 = GTK_COMBO(handle)->list; 9619 handle2 = GTK_COMBO(handle)->list;
9577 } 9620 }
9578 if(GTK_IS_LIST(handle2)) 9621 if(GTK_IS_LIST(handle2))
9579 { 9622 {
9580 if(state) 9623 if(state)
9581 gtk_list_select_item(GTK_LIST(handle2), index); 9624 gtk_list_select_item(GTK_LIST(handle2), index);
9582 else 9625 else
9583 gtk_list_unselect_item(GTK_LIST(handle2), index); 9626 gtk_list_unselect_item(GTK_LIST(handle2), index);
9584 } 9627 }
9585 DW_MUTEX_UNLOCK; 9628 DW_MUTEX_UNLOCK;
9586 } 9629 }
9587 9630
9588 /* 9631 /*
9589 * Deletes the item with given index from the list. 9632 * Deletes the item with given index from the list.
9590 * Parameters: 9633 * Parameters:
9591 * handle: Handle to the listbox to be set. 9634 * handle: Handle to the listbox to be set.
9592 * index: Item index. 9635 * index: Item index.
9593 */ 9636 */
9594 void dw_listbox_delete(HWND handle, int index) 9637 void dw_listbox_delete(HWND handle, int index)
9595 { 9638 {
9596 GtkWidget *handle2 = handle; 9639 GtkWidget *handle2 = handle;
9597 int _locked_by_me = FALSE; 9640 int _locked_by_me = FALSE;
9598 9641
9599 DW_MUTEX_LOCK; 9642 DW_MUTEX_LOCK;
9600 if(GTK_IS_SCROLLED_WINDOW(handle)) 9643 if(GTK_IS_SCROLLED_WINDOW(handle))
9601 { 9644 {
9602 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 9645 GtkWidget *tmp = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
9603 if(tmp) 9646 if(tmp)
9604 handle2 = tmp; 9647 handle2 = tmp;
9605 } 9648 }
9606 else if(GTK_IS_COMBO(handle)) 9649 else if(GTK_IS_COMBO(handle))
9607 { 9650 {
9608 handle2 = GTK_COMBO(handle)->list; 9651 handle2 = GTK_COMBO(handle)->list;
9609 } 9652 }
9610 if(GTK_IS_LIST(handle2)) 9653 if(GTK_IS_LIST(handle2))
9611 { 9654 {
9612 gtk_list_clear_items(GTK_LIST(handle2), index, index+1); 9655 gtk_list_clear_items(GTK_LIST(handle2), index, index+1);
9613 } 9656 }
9614 DW_MUTEX_UNLOCK; 9657 DW_MUTEX_UNLOCK;
9615 } 9658 }
9616 9659
9617 /* Reposition the bar according to the percentage */ 9660 /* Reposition the bar according to the percentage */
9618 static gint _splitbar_size_allocate(GtkWidget *widget, GtkAllocation *event, gpointer data) 9661 static gint _splitbar_size_allocate(GtkWidget *widget, GtkAllocation *event, gpointer data)
9619 { 9662 {
9620 float *percent = (float *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_percent"); 9663 float *percent = (float *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_percent");
9621 int lastwidth = (int)gtk_object_get_data(GTK_OBJECT(widget), "_dw_lastwidth"); 9664 int lastwidth = (int)gtk_object_get_data(GTK_OBJECT(widget), "_dw_lastwidth");
9622 int lastheight = (int)gtk_object_get_data(GTK_OBJECT(widget), "_dw_lastheight"); 9665 int lastheight = (int)gtk_object_get_data(GTK_OBJECT(widget), "_dw_lastheight");
9623 9666
9624 /* Prevent infinite recursion ;) */ 9667 /* Prevent infinite recursion ;) */
9625 if(!percent || (lastwidth == event->width && lastheight == event->height)) 9668 if(!percent || (lastwidth == event->width && lastheight == event->height))
9626 return FALSE; 9669 return FALSE;
9627 9670
9628 lastwidth = event->width; lastheight = event->height; 9671 lastwidth = event->width; lastheight = event->height;
9629 9672
9630 gtk_object_set_data(GTK_OBJECT(widget), "_dw_lastwidth", (gpointer)lastwidth); 9673 gtk_object_set_data(GTK_OBJECT(widget), "_dw_lastwidth", GINT_TO_POINTER(lastwidth));
9631 gtk_object_set_data(GTK_OBJECT(widget), "_dw_lastheight", (gpointer)lastheight); 9674 gtk_object_set_data(GTK_OBJECT(widget), "_dw_lastheight", GINT_TO_POINTER(lastheight));
9632 9675
9633 if(GTK_IS_HPANED(widget)) 9676 if(GTK_IS_HPANED(widget))
9634 gtk_paned_set_position(GTK_PANED(widget), (int)(event->width * (*percent / 100.0))); 9677 gtk_paned_set_position(GTK_PANED(widget), (int)(event->width * (*percent / 100.0)));
9635 if(GTK_IS_VPANED(widget)) 9678 if(GTK_IS_VPANED(widget))
9636 gtk_paned_set_position(GTK_PANED(widget), (int)(event->height * (*percent / 100.0))); 9679 gtk_paned_set_position(GTK_PANED(widget), (int)(event->height * (*percent / 100.0)));
9637 gtk_object_set_data(GTK_OBJECT(widget), "_dw_waiting", NULL); 9680 gtk_object_set_data(GTK_OBJECT(widget), "_dw_waiting", NULL);
9638 return FALSE; 9681 return FALSE;
9639 } 9682 }
9640 9683
9641 #if GTK_MAJOR_VERSION > 1 9684 #if GTK_MAJOR_VERSION > 1
9642 /* Figure out the new percentage */ 9685 /* Figure out the new percentage */
9643 static void _splitbar_accept_position(GObject *object, GParamSpec *pspec, gpointer data) 9686 static void _splitbar_accept_position(GObject *object, GParamSpec *pspec, gpointer data)
9644 { 9687 {
9645 GtkWidget *widget = (GtkWidget *)data; 9688 GtkWidget *widget = (GtkWidget *)data;
9646 float *percent = (float *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_percent"); 9689 float *percent = (float *)gtk_object_get_data(GTK_OBJECT(widget), "_dw_percent");
9647 int size = 0, position = gtk_paned_get_position(GTK_PANED(widget)); 9690 int size = 0, position = gtk_paned_get_position(GTK_PANED(widget));
9648 9691
9649 if(!percent || gtk_object_get_data(GTK_OBJECT(widget), "_dw_waiting")) 9692 if(!percent || gtk_object_get_data(GTK_OBJECT(widget), "_dw_waiting"))
9650 return; 9693 return;
9651 9694
9652 if(GTK_IS_VPANED(widget)) 9695 if(GTK_IS_VPANED(widget))
9653 size = widget->allocation.height; 9696 size = widget->allocation.height;
9654 else if(GTK_IS_HPANED(widget)) 9697 else if(GTK_IS_HPANED(widget))
9655 size = widget->allocation.width; 9698 size = widget->allocation.width;
9656 9699
9657 if(size > 0) 9700 if(size > 0)
9658 *percent = ((float)(position * 100) / (float)size); 9701 *percent = ((float)(position * 100) / (float)size);
9659 } 9702 }
9660 #endif 9703 #endif
9661 9704
9662 /* 9705 /*
9663 * Creates a splitbar window (widget) with given parameters. 9706 * Creates a splitbar window (widget) with given parameters.
9668 * Returns: 9711 * Returns:
9669 * A handle to a splitbar window or NULL on failure. 9712 * A handle to a splitbar window or NULL on failure.
9670 */ 9713 */
9671 HWND dw_splitbar_new(int type, HWND topleft, HWND bottomright, unsigned long id) 9714 HWND dw_splitbar_new(int type, HWND topleft, HWND bottomright, unsigned long id)
9672 { 9715 {
9673 GtkWidget *tmp = NULL; 9716 GtkWidget *tmp = NULL;
9674 int _locked_by_me = FALSE; 9717 int _locked_by_me = FALSE;
9675 float *percent = malloc(sizeof(float)); 9718 float *percent = malloc(sizeof(float));
9676 9719
9677 DW_MUTEX_LOCK; 9720 DW_MUTEX_LOCK;
9678 if(type == DW_HORZ) 9721 if(type == DW_HORZ)
9679 tmp = gtk_hpaned_new(); 9722 tmp = gtk_hpaned_new();
9680 else 9723 else
9681 tmp = gtk_vpaned_new(); 9724 tmp = gtk_vpaned_new();
9682 gtk_paned_add1(GTK_PANED(tmp), topleft); 9725 gtk_paned_add1(GTK_PANED(tmp), topleft);
9683 gtk_paned_add2(GTK_PANED(tmp), bottomright); 9726 gtk_paned_add2(GTK_PANED(tmp), bottomright);
9684 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 9727 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
9685 *percent = 50.0; 9728 *percent = 50.0;
9686 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_percent", (gpointer)percent); 9729 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_percent", (gpointer)percent);
9687 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_waiting", (gpointer)1); 9730 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_waiting", GINT_TO_POINTER(1));
9688 gtk_signal_connect(GTK_OBJECT(tmp), "size-allocate", GTK_SIGNAL_FUNC(_splitbar_size_allocate), NULL); 9731 gtk_signal_connect(GTK_OBJECT(tmp), "size-allocate", GTK_SIGNAL_FUNC(_splitbar_size_allocate), NULL);
9689 #if GTK_MAJOR_VERSION > 1 9732 #if GTK_MAJOR_VERSION > 1
9690 g_signal_connect(G_OBJECT(tmp), "notify::position", (GCallback)_splitbar_accept_position, (gpointer)tmp); 9733 g_signal_connect(G_OBJECT(tmp), "notify::position", (GCallback)_splitbar_accept_position, (gpointer)tmp);
9691 #else 9734 #else
9692 gtk_paned_set_handle_size(GTK_PANED(tmp), 3); 9735 gtk_paned_set_handle_size(GTK_PANED(tmp), 3);
9693 #endif 9736 #endif
9694 gtk_widget_show(tmp); 9737 gtk_widget_show(tmp);
9695 DW_MUTEX_UNLOCK; 9738 DW_MUTEX_UNLOCK;
9696 return tmp; 9739 return tmp;
9697 } 9740 }
9698 9741
9699 /* 9742 /*
9700 * Sets the position of a splitbar (pecentage). 9743 * Sets the position of a splitbar (pecentage).
9701 * Parameters: 9744 * Parameters:
9702 * handle: The handle to the splitbar returned by dw_splitbar_new(). 9745 * handle: The handle to the splitbar returned by dw_splitbar_new().
9703 */ 9746 */
9704 void dw_splitbar_set(HWND handle, float percent) 9747 void dw_splitbar_set(HWND handle, float percent)
9705 { 9748 {
9706 float *mypercent = (float *)dw_window_get_data(handle, "_dw_percent"); 9749 float *mypercent = (float *)dw_window_get_data(handle, "_dw_percent");
9707 int size = 0, position; 9750 int size = 0, position;
9708 9751
9709 if(GTK_IS_VPANED(handle)) 9752 if(GTK_IS_VPANED(handle))
9710 size = handle->allocation.height; 9753 size = handle->allocation.height;
9711 else if(GTK_IS_HPANED(handle)) 9754 else if(GTK_IS_HPANED(handle))
9712 size = handle->allocation.width; 9755 size = handle->allocation.width;
9713 9756
9714 if(mypercent) 9757 if(mypercent)
9715 *mypercent = percent; 9758 *mypercent = percent;
9716 9759
9717 if(size > 10) 9760 if(size > 10)
9718 { 9761 {
9719 position = (int)((float)size * (percent / 100.0)); 9762 position = (int)((float)size * (percent / 100.0));
9720 9763
9721 gtk_paned_set_position(GTK_PANED(handle), position); 9764 gtk_paned_set_position(GTK_PANED(handle), position);
9722 } 9765 }
9723 } 9766 }
9724 9767
9725 /* 9768 /*
9726 * Gets the position of a splitbar (pecentage). 9769 * Gets the position of a splitbar (pecentage).
9727 * Parameters: 9770 * Parameters:
9728 * handle: The handle to the splitbar returned by dw_splitbar_new(). 9771 * handle: The handle to the splitbar returned by dw_splitbar_new().
9729 */ 9772 */
9730 float dw_splitbar_get(HWND handle) 9773 float dw_splitbar_get(HWND handle)
9731 { 9774 {
9732 float *percent = (float *)dw_window_get_data(handle, "_dw_percent"); 9775 float *percent = (float *)dw_window_get_data(handle, "_dw_percent");
9733 9776
9734 if(percent) 9777 if(percent)
9735 return *percent; 9778 return *percent;
9736 return 0.0; 9779 return 0.0;
9737 } 9780 }
9738 9781
9739 /* 9782 /*
9740 * Creates a calendar window (widget) with given parameters. 9783 * Creates a calendar window (widget) with given parameters.
9741 * Parameters: 9784 * Parameters:
9743 * Returns: 9786 * Returns:
9744 * A handle to a calendar window or NULL on failure. 9787 * A handle to a calendar window or NULL on failure.
9745 */ 9788 */
9746 HWND dw_calendar_new(unsigned long id) 9789 HWND dw_calendar_new(unsigned long id)
9747 { 9790 {
9748 GtkWidget *tmp; 9791 GtkWidget *tmp;
9749 int _locked_by_me = FALSE; 9792 int _locked_by_me = FALSE;
9750 GtkCalendarDisplayOptions flags; 9793 GtkCalendarDisplayOptions flags;
9751 time_t now; 9794 time_t now;
9752 struct tm *tmdata; 9795 struct tm *tmdata;
9753 9796
9754 DW_MUTEX_LOCK; 9797 DW_MUTEX_LOCK;
9755 tmp = gtk_calendar_new(); 9798 tmp = gtk_calendar_new();
9756 gtk_widget_show(tmp); 9799 gtk_widget_show(tmp);
9757 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", (gpointer)id); 9800 gtk_object_set_data(GTK_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
9758 /* select today */ 9801 /* select today */
9759 flags = GTK_CALENDAR_WEEK_START_MONDAY|GTK_CALENDAR_SHOW_HEADING|GTK_CALENDAR_SHOW_DAY_NAMES; 9802 flags = GTK_CALENDAR_WEEK_START_MONDAY|GTK_CALENDAR_SHOW_HEADING|GTK_CALENDAR_SHOW_DAY_NAMES;
9760 gtk_calendar_display_options( GTK_CALENDAR(tmp), flags ); 9803 gtk_calendar_display_options( GTK_CALENDAR(tmp), flags );
9761 now = time( NULL ); 9804 now = time( NULL );
9762 tmdata = localtime( & now ); 9805 tmdata = localtime( & now );
9763 gtk_calendar_select_month( GTK_CALENDAR(tmp), tmdata->tm_mon, 1900+tmdata->tm_year ); 9806 gtk_calendar_select_month( GTK_CALENDAR(tmp), tmdata->tm_mon, 1900+tmdata->tm_year );
9764 gtk_calendar_select_day( GTK_CALENDAR(tmp), tmdata->tm_mday ); 9807 gtk_calendar_select_day( GTK_CALENDAR(tmp), tmdata->tm_mday );
9765 9808
9766 DW_MUTEX_UNLOCK; 9809 DW_MUTEX_UNLOCK;
9767 return tmp; 9810 return tmp;
9768 } 9811 }
9769 9812
9770 /* 9813 /*
9771 * Sets the current date of a calendar 9814 * Sets the current date of a calendar
9772 * Parameters: 9815 * Parameters:
9773 * handle: The handle to the calendar returned by dw_calendar_new(). 9816 * handle: The handle to the calendar returned by dw_calendar_new().
9774 * year... 9817 * year...
9775 */ 9818 */
9776 void dw_calendar_set_date(HWND handle, unsigned int year, unsigned int month, unsigned int day) 9819 void dw_calendar_set_date(HWND handle, unsigned int year, unsigned int month, unsigned int day)
9777 { 9820 {
9778 int _locked_by_me = FALSE; 9821 int _locked_by_me = FALSE;
9779 9822
9780 DW_MUTEX_LOCK; 9823 DW_MUTEX_LOCK;
9781 if(GTK_IS_CALENDAR(handle)) 9824 if(GTK_IS_CALENDAR(handle))
9782 { 9825 {
9783 gtk_calendar_select_month(GTK_CALENDAR(handle),month-1,year); 9826 gtk_calendar_select_month(GTK_CALENDAR(handle),month-1,year);
9784 gtk_calendar_select_day(GTK_CALENDAR(handle), day); 9827 gtk_calendar_select_day(GTK_CALENDAR(handle), day);
9785 } 9828 }
9786 DW_MUTEX_UNLOCK; 9829 DW_MUTEX_UNLOCK;
9787 return; 9830 return;
9788 } 9831 }
9789 9832
9790 /* 9833 /*
9791 * Gets the position of a splitbar (pecentage). 9834 * Gets the position of a splitbar (pecentage).
9792 * Parameters: 9835 * Parameters:
9793 * handle: The handle to the splitbar returned by dw_splitbar_new(). 9836 * handle: The handle to the splitbar returned by dw_splitbar_new().
9794 */ 9837 */
9795 void dw_calendar_get_date(HWND handle, unsigned int *year, unsigned int *month, unsigned int *day) 9838 void dw_calendar_get_date(HWND handle, unsigned int *year, unsigned int *month, unsigned int *day)
9796 { 9839 {
9797 int _locked_by_me = FALSE; 9840 int _locked_by_me = FALSE;
9798 9841
9799 DW_MUTEX_LOCK; 9842 DW_MUTEX_LOCK;
9800 if(GTK_IS_CALENDAR(handle)) 9843 if(GTK_IS_CALENDAR(handle))
9801 { 9844 {
9802 gtk_calendar_get_date(GTK_CALENDAR(handle),year,month,day); 9845 gtk_calendar_get_date(GTK_CALENDAR(handle),year,month,day);
9803 *month = *month + 1; 9846 *month = *month + 1;
9804 } 9847 }
9805 DW_MUTEX_UNLOCK; 9848 DW_MUTEX_UNLOCK;
9806 return; 9849 return;
9807 } 9850 }
9808 9851
9809 /* 9852 /*
9810 * Pack windows (widgets) into a box from the start (or top). 9853 * Pack windows (widgets) into a box from the start (or top).
9811 * Parameters: 9854 * Parameters:
9817 * vsize: TRUE if the window (widget) should expand vertically to fill space given. 9860 * vsize: TRUE if the window (widget) should expand vertically to fill space given.
9818 * pad: Number of pixels of padding around the item. 9861 * pad: Number of pixels of padding around the item.
9819 */ 9862 */
9820 void dw_box_pack_start(HWND box, HWND item, int width, int height, int hsize, int vsize, int pad) 9863 void dw_box_pack_start(HWND box, HWND item, int width, int height, int hsize, int vsize, int pad)
9821 { 9864 {
9822 int warn = FALSE, _locked_by_me = FALSE; 9865 int warn = FALSE, _locked_by_me = FALSE;
9823 GtkWidget *tmp, *tmpitem; 9866 GtkWidget *tmp, *tmpitem;
9824 9867
9825 if(!box) 9868 if ( !box )
9826 return; 9869 return;
9827 9870
9828 /* 9871 /*
9829 * If you try and pack an item into itself VERY bad things can happen; like at least an 9872 * If you try and pack an item into itself VERY bad things can happen; like at least an
9830 * infinite loop on GTK! Lets be safe! 9873 * infinite loop on GTK! Lets be safe!
9831 */ 9874 */
9832 if(box == item) 9875 if ( box == item )
9833 { 9876 {
9834 dw_messagebox("dw_box_pack_start()", DW_MB_OK|DW_MB_ERROR, "Danger! Danger! Will Robinson; box and item are the same!"); 9877 dw_messagebox( "dw_box_pack_start()", DW_MB_OK|DW_MB_ERROR, "Danger! Danger! Will Robinson; box and item are the same!" );
9835 return; 9878 return;
9836 } 9879 }
9837 9880
9838 DW_MUTEX_LOCK; 9881 DW_MUTEX_LOCK;
9839 9882
9840 if((tmp = gtk_object_get_data(GTK_OBJECT(box), "_dw_boxhandle"))) 9883 if ((tmp = gtk_object_get_data(GTK_OBJECT(box), "_dw_boxhandle")))
9841 box = tmp; 9884 box = tmp;
9842 9885
9843 if(!item) 9886 if (!item)
9844 { 9887 {
9845 item = gtk_label_new(""); 9888 item = gtk_label_new("");
9846 gtk_widget_show_all(item); 9889 gtk_widget_show_all(item);
9847 } 9890 }
9848 9891
9849 tmpitem = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(item), "_dw_boxhandle"); 9892 tmpitem = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(item), "_dw_boxhandle");
9850 9893
9851 if(GTK_IS_TABLE(box)) 9894 if (GTK_IS_TABLE(box))
9852 { 9895 {
9853 int boxcount = (int)gtk_object_get_data(GTK_OBJECT(box), "_dw_boxcount"); 9896 int boxcount = (int)gtk_object_get_data(GTK_OBJECT(box), "_dw_boxcount");
9854 int boxtype = (int)gtk_object_get_data(GTK_OBJECT(box), "_dw_boxtype"); 9897 int boxtype = (int)gtk_object_get_data(GTK_OBJECT(box), "_dw_boxtype");
9855 int x, y; 9898 int x, y;
9856 9899
9857 /* If the item being packed is a box, then we use it's padding 9900 /* If the item being packed is a box, then we use it's padding
9858 * instead of the padding specified on the pack line, this is 9901 * instead of the padding specified on the pack line, this is
9859 * due to a bug in the OS/2 and Win32 renderer and a limitation 9902 * due to a bug in the OS/2 and Win32 renderer and a limitation
9860 * of the GtkTable class. 9903 * of the GtkTable class.
9861 */ 9904 */
9862 if(GTK_IS_TABLE(item) || (tmpitem && GTK_IS_TABLE(tmpitem))) 9905 if (GTK_IS_TABLE(item) || (tmpitem && GTK_IS_TABLE(tmpitem)))
9863 { 9906 {
9864 GtkWidget *eventbox = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(item), "_dw_eventbox"); 9907 GtkWidget *eventbox = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(item), "_dw_eventbox");
9865 9908
9866 /* NOTE: I left in the ability to pack boxes with a size, 9909 /* NOTE: I left in the ability to pack boxes with a size,
9867 * this eliminates that by forcing the size to 0. 9910 * this eliminates that by forcing the size to 0.
9868 */ 9911 */
9869 height = width = 0; 9912 height = width = 0;
9870 9913
9871 if(eventbox) 9914 if (eventbox)
9872 { 9915 {
9873 int boxpad = (int)gtk_object_get_data(GTK_OBJECT(item), "_dw_boxpad"); 9916 int boxpad = (int)gtk_object_get_data(GTK_OBJECT(item), "_dw_boxpad");
9874 gtk_container_add(GTK_CONTAINER(eventbox), item); 9917 gtk_container_add(GTK_CONTAINER(eventbox), item);
9875 gtk_container_border_width(GTK_CONTAINER(eventbox), boxpad); 9918 gtk_container_border_width(GTK_CONTAINER(eventbox), boxpad);
9876 item = eventbox; 9919 item = eventbox;
9877 } 9920 }
9878 } 9921 }
9879 else 9922 else
9880 { 9923 {
9881 /* Only show warning if item is not a box */ 9924 /* Only show warning if item is not a box */
9882 warn = TRUE; 9925 warn = TRUE;
9883 } 9926 }
9884 9927
9885 if(boxtype == DW_VERT) 9928 if (boxtype == DW_VERT)
9886 { 9929 {
9887 x = 0; 9930 x = 0;
9888 y = boxcount; 9931 y = boxcount;
9889 gtk_table_resize(GTK_TABLE(box), boxcount + 1, 1); 9932 gtk_table_resize(GTK_TABLE(box), boxcount + 1, 1);
9890 } 9933 }
9891 else 9934 else
9892 { 9935 {
9893 x = boxcount; 9936 x = boxcount;
9894 y = 0; 9937 y = 0;
9895 gtk_table_resize(GTK_TABLE(box), 1, boxcount + 1); 9938 gtk_table_resize(GTK_TABLE(box), 1, boxcount + 1);
9896 } 9939 }
9897 9940
9898 gtk_table_attach(GTK_TABLE(box), item, x, x + 1, y, y + 1, hsize ? DW_EXPAND : 0, vsize ? DW_EXPAND : 0, pad, pad); 9941 gtk_table_attach(GTK_TABLE(box), item, x, x + 1, y, y + 1, hsize ? DW_EXPAND : 0, vsize ? DW_EXPAND : 0, pad, pad);
9899 gtk_object_set_data(GTK_OBJECT(box), "_dw_boxcount", (gpointer)boxcount + 1); 9942 gtk_object_set_data(GTK_OBJECT(box), "_dw_boxcount", GINT_TO_POINTER(boxcount + 1));
9900 gtk_widget_set_usize(item, width, height); 9943 gtk_widget_set_usize(item, width, height);
9901 if(GTK_IS_RADIO_BUTTON(item)) 9944 if (GTK_IS_RADIO_BUTTON(item))
9902 { 9945 {
9903 GSList *group; 9946 GSList *group;
9904 GtkWidget *groupstart = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(box), "_dw_group"); 9947 GtkWidget *groupstart = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(box), "_dw_group");
9905 9948
9906 if(groupstart) 9949 if (groupstart)
9907 { 9950 {
9908 group = gtk_radio_button_group(GTK_RADIO_BUTTON(groupstart)); 9951 group = gtk_radio_button_group(GTK_RADIO_BUTTON(groupstart));
9909 gtk_radio_button_set_group(GTK_RADIO_BUTTON(item), group); 9952 gtk_radio_button_set_group(GTK_RADIO_BUTTON(item), group);
9910 } 9953 }
9911 else 9954 else
9912 gtk_object_set_data(GTK_OBJECT(box), "_dw_group", (gpointer)item); 9955 {
9913 } 9956 gtk_object_set_data(GTK_OBJECT(box), "_dw_group", (gpointer)item);
9914 } 9957 }
9915 else 9958 }
9916 { 9959 }
9917 GtkWidget *vbox = gtk_vbox_new(FALSE, 0); 9960 else
9918 9961 {
9919 if(GTK_IS_TABLE(item) || (tmpitem && GTK_IS_TABLE(tmpitem))) 9962 GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
9920 { 9963
9921 GtkWidget *eventbox = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(item), "_dw_eventbox"); 9964 if (GTK_IS_TABLE(item) || (tmpitem && GTK_IS_TABLE(tmpitem)))
9922 9965 {
9923 /* NOTE: I left in the ability to pack boxes with a size, 9966 GtkWidget *eventbox = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(item), "_dw_eventbox");
9924 * this eliminates that by forcing the size to 0. 9967
9925 */ 9968 /* NOTE: I left in the ability to pack boxes with a size,
9926 height = width = 0; 9969 * this eliminates that by forcing the size to 0.
9927 9970 */
9928 if(eventbox) 9971 height = width = 0;
9929 { 9972
9930 int boxpad = (int)gtk_object_get_data(GTK_OBJECT(item), "_dw_boxpad"); 9973 if (eventbox)
9931 gtk_container_add(GTK_CONTAINER(eventbox), item); 9974 {
9932 gtk_container_border_width(GTK_CONTAINER(eventbox), boxpad); 9975 int boxpad = (int)gtk_object_get_data(GTK_OBJECT(item), "_dw_boxpad");
9933 item = eventbox; 9976 gtk_container_add(GTK_CONTAINER(eventbox), item);
9934 } 9977 gtk_container_border_width(GTK_CONTAINER(eventbox), boxpad);
9935 } 9978 item = eventbox;
9936 else 9979 }
9937 { 9980 }
9938 /* Only show warning if item is not a box */ 9981 else
9939 warn = TRUE; 9982 {
9940 } 9983 /* Only show warning if item is not a box */
9941 9984 warn = TRUE;
9942 gtk_container_border_width(GTK_CONTAINER(box), pad); 9985 }
9943 gtk_container_add(GTK_CONTAINER(box), vbox); 9986
9944 gtk_box_pack_end(GTK_BOX(vbox), item, TRUE, TRUE, 0); 9987 gtk_container_border_width(GTK_CONTAINER(box), pad);
9945 gtk_widget_show(vbox); 9988 gtk_container_add(GTK_CONTAINER(box), vbox);
9946 9989 gtk_box_pack_end(GTK_BOX(vbox), item, TRUE, TRUE, 0);
9947 gtk_widget_set_usize(item, width, height); 9990 gtk_widget_show(vbox);
9948 gtk_object_set_user_data(GTK_OBJECT(box), vbox); 9991
9949 } 9992 gtk_widget_set_usize(item, width, height);
9950 DW_MUTEX_UNLOCK; 9993 gtk_object_set_user_data(GTK_OBJECT(box), vbox);
9951 9994 }
9952 if(warn) 9995 DW_MUTEX_UNLOCK;
9953 { 9996
9954 if ( width == 0 && hsize == FALSE ) 9997 if (warn)
9955 dw_messagebox("dw_box_pack_start()", DW_MB_OK|DW_MB_ERROR, "Width and expand Horizonal both unset for box: %x item: %x",box,item); 9998 {
9956 if ( height == 0 && vsize == FALSE ) 9999 if ( width == 0 && hsize == FALSE )
9957 dw_messagebox("dw_box_pack_start()", DW_MB_OK|DW_MB_ERROR, "Height and expand Vertical both unset for box: %x item: %x",box,item); 10000 dw_messagebox("dw_box_pack_start()", DW_MB_OK|DW_MB_ERROR, "Width and expand Horizonal both unset for box: %x item: %x",box,item);
9958 } 10001 if ( height == 0 && vsize == FALSE )
10002 dw_messagebox("dw_box_pack_start()", DW_MB_OK|DW_MB_ERROR, "Height and expand Vertical both unset for box: %x item: %x",box,item);
10003 }
9959 } 10004 }
9960 10005
9961 /* 10006 /*
9962 * Sets the default focus item for a window/dialog. 10007 * Sets the default focus item for a window/dialog.
9963 * Parameters: 10008 * Parameters:
9964 * window: Toplevel window or dialog. 10009 * window: Toplevel window or dialog.
9965 * defaultitem: Handle to the dialog item to be default. 10010 * defaultitem: Handle to the dialog item to be default.
9966 */ 10011 */
9967 void dw_window_default(HWND window, HWND defaultitem) 10012 void dw_window_default(HWND window, HWND defaultitem)
9968 { 10013 {
9969 int _locked_by_me = FALSE; 10014 int _locked_by_me = FALSE;
9970 10015
9971 if(!window) 10016 if(!window)
9972 return; 10017 return;
9973 10018
9974 DW_MUTEX_LOCK; 10019 DW_MUTEX_LOCK;
9975 gtk_object_set_data(GTK_OBJECT(window), "_dw_defaultitem", (gpointer)defaultitem); 10020 gtk_object_set_data(GTK_OBJECT(window), "_dw_defaultitem", (gpointer)defaultitem);
9976 DW_MUTEX_UNLOCK; 10021 DW_MUTEX_UNLOCK;
9977 } 10022 }
9978 10023
9979 /* 10024 /*
9980 * Sets window to click the default dialog item when an ENTER is pressed. 10025 * Sets window to click the default dialog item when an ENTER is pressed.
9981 * Parameters: 10026 * Parameters:
9982 * window: Window (widget) to look for the ENTER press. 10027 * window: Window (widget) to look for the ENTER press.
9983 * next: Window (widget) to move to next (or click) 10028 * next: Window (widget) to move to next (or click)
9984 */ 10029 */
9985 void dw_window_click_default(HWND window, HWND next) 10030 void dw_window_click_default(HWND window, HWND next)
9986 { 10031 {
9987 int _locked_by_me = FALSE; 10032 int _locked_by_me = FALSE;
9988 10033
9989 if(!window) 10034 if(!window)
9990 return; 10035 return;
9991 10036
9992 DW_MUTEX_LOCK; 10037 DW_MUTEX_LOCK;
9993 gtk_signal_connect(GTK_OBJECT(window), "key_press_event", GTK_SIGNAL_FUNC(_default_key_press_event), next); 10038 gtk_signal_connect(GTK_OBJECT(window), "key_press_event", GTK_SIGNAL_FUNC(_default_key_press_event), next);
9994 DW_MUTEX_UNLOCK; 10039 DW_MUTEX_UNLOCK;
9995 } 10040 }
9996 10041
9997 /* 10042 /*
9998 * Returns some information about the current operating environment. 10043 * Returns some information about the current operating environment.
9999 * Parameters: 10044 * Parameters:
10000 * env: Pointer to a DWEnv struct. 10045 * env: Pointer to a DWEnv struct.
10001 */ 10046 */
10002 void dw_environment_query(DWEnv *env) 10047 void dw_environment_query(DWEnv *env)
10003 { 10048 {
10004 struct utsname name; 10049 struct utsname name;
10005 char tempbuf[100]; 10050 char tempbuf[100];
10006 int len, z; 10051 int len, z;
10007 10052
10008 uname(&name); 10053 uname(&name);
10009 strcpy(env->osName, name.sysname); 10054 strcpy(env->osName, name.sysname);
10010 strcpy(tempbuf, name.release); 10055 strcpy(tempbuf, name.release);
10011 10056
10012 env->MajorBuild = env->MinorBuild = 0; 10057 env->MajorBuild = env->MinorBuild = 0;
10013 10058
10014 len = strlen(tempbuf); 10059 len = strlen(tempbuf);
10015 10060
10016 strcpy(env->buildDate, __DATE__); 10061 strcpy(env->buildDate, __DATE__);
10017 strcpy(env->buildTime, __TIME__); 10062 strcpy(env->buildTime, __TIME__);
10018 env->DWMajorVersion = DW_MAJOR_VERSION; 10063 env->DWMajorVersion = DW_MAJOR_VERSION;
10019 env->DWMinorVersion = DW_MINOR_VERSION; 10064 env->DWMinorVersion = DW_MINOR_VERSION;
10020 env->DWSubVersion = DW_SUB_VERSION; 10065 env->DWSubVersion = DW_SUB_VERSION;
10021 10066
10022 for(z=1;z<len;z++) 10067 for(z=1;z<len;z++)
10023 { 10068 {
10024 if(tempbuf[z] == '.') 10069 if(tempbuf[z] == '.')
10025 { 10070 {
10026 tempbuf[z] = '\0'; 10071 tempbuf[z] = '\0';
10027 env->MajorVersion = atoi(&tempbuf[z-1]); 10072 env->MajorVersion = atoi(&tempbuf[z-1]);
10028 env->MinorVersion = atoi(&tempbuf[z+1]); 10073 env->MinorVersion = atoi(&tempbuf[z+1]);
10029 return; 10074 return;
10030 } 10075 }
10031 } 10076 }
10032 env->MajorVersion = atoi(tempbuf); 10077 env->MajorVersion = atoi(tempbuf);
10033 env->MinorVersion = 0; 10078 env->MinorVersion = 0;
10034 } 10079 }
10035 10080
10036 /* Internal function to handle the file OK press */ 10081 /* Internal function to handle the file OK press */
10037 static gint _gtk_file_ok(GtkWidget *widget, DWDialog *dwwait) 10082 static gint _gtk_file_ok(GtkWidget *widget, DWDialog *dwwait)
10038 { 10083 {
10039 #if GTK_MAJOR_VERSION > 1 10084 #if GTK_MAJOR_VERSION > 1
10040 const char *tmp; 10085 const char *tmp;
10041 #else 10086 #else
10042 char *tmp; 10087 char *tmp;
10043 #endif 10088 #endif
10044 char *tmpdup=NULL; 10089 char *tmpdup=NULL;
10045 10090
10046 if(!dwwait) 10091 if(!dwwait)
10047 return FALSE; 10092 return FALSE;
10048 10093
10049 if((tmp = gtk_file_selection_get_filename(GTK_FILE_SELECTION(dwwait->data)))) 10094 if((tmp = gtk_file_selection_get_filename(GTK_FILE_SELECTION(dwwait->data))))
10050 tmpdup = strdup(tmp); 10095 tmpdup = strdup(tmp);
10051 gtk_widget_destroy(GTK_WIDGET(dwwait->data)); 10096 gtk_widget_destroy(GTK_WIDGET(dwwait->data));
10052 _dw_file_active = 0; 10097 _dw_file_active = 0;
10053 dw_dialog_dismiss(dwwait, (void *)tmpdup); 10098 dw_dialog_dismiss(dwwait, (void *)tmpdup);
10054 return FALSE; 10099 return FALSE;
10055 } 10100 }
10056 10101
10057 /* Internal function to handle the file Cancel press */ 10102 /* Internal function to handle the file Cancel press */
10058 static gint _gtk_file_cancel(GtkWidget *widget, DWDialog *dwwait) 10103 static gint _gtk_file_cancel(GtkWidget *widget, DWDialog *dwwait)
10059 { 10104 {
10060 if(!dwwait) 10105 if(!dwwait)
10061 return FALSE; 10106 return FALSE;
10062 10107
10063 gtk_widget_destroy(GTK_WIDGET(dwwait->data)); 10108 gtk_widget_destroy(GTK_WIDGET(dwwait->data));
10064 _dw_file_active = 0; 10109 _dw_file_active = 0;
10065 dw_dialog_dismiss(dwwait, NULL); 10110 dw_dialog_dismiss(dwwait, NULL);
10066 return FALSE; 10111 return FALSE;
10067 } 10112 }
10068 10113
10069 /* The next few functions are support functions for the UNIX folder browser */ 10114 /* The next few functions are support functions for the UNIX folder browser */
10070 static void _populate_directory(HWND tree, HTREEITEM parent, char *path) 10115 static void _populate_directory(HWND tree, HTREEITEM parent, char *path)
10071 { 10116 {
10072 struct dirent *dent; 10117 struct dirent *dent;
10073 HTREEITEM item; 10118 HTREEITEM item;
10074 DIR *hdir; 10119 DIR *hdir;
10075 10120
10076 if((hdir = opendir(path))) 10121 if((hdir = opendir(path)))
10077 { 10122 {
10078 while((dent = readdir(hdir))) 10123 while((dent = readdir(hdir)))
10079 { 10124 {
10080 if(strcmp(dent->d_name, ".") && strcmp(dent->d_name, "..")) 10125 if(strcmp(dent->d_name, ".") && strcmp(dent->d_name, ".."))
10081 { 10126 {
10082 int len = strlen(path); 10127 int len = strlen(path);
10083 char *folder = malloc(len + strlen(dent->d_name) + 2); 10128 char *folder = malloc(len + strlen(dent->d_name) + 2);
10084 struct stat bleah; 10129 struct stat bleah;
10085 HTREEITEM tempitem; 10130 HTREEITEM tempitem;
10086 10131
10087 strcpy(folder, path); 10132 strcpy(folder, path);
10088 strcpy(&folder[len], dent->d_name); 10133 strcpy(&folder[len], dent->d_name);
10089 10134
10090 stat(folder, &bleah); 10135 stat(folder, &bleah);
10091 10136
10092 if(S_IFDIR & bleah.st_mode) 10137 if(S_IFDIR & bleah.st_mode)
10093 { 10138 {
10094 item = dw_tree_insert(tree, dent->d_name, 0, parent, (void *)parent); 10139 item = dw_tree_insert(tree, dent->d_name, 0, parent, (void *)parent);
10095 tempitem = dw_tree_insert(tree, "", 0, item, 0); 10140 tempitem = dw_tree_insert(tree, "", 0, item, 0);
10096 dw_tree_item_set_data(tree, item, (void *)tempitem); 10141 dw_tree_item_set_data(tree, item, (void *)tempitem);
10097 } 10142 }
10098 10143
10099 free(folder); 10144 free(folder);
10100 } 10145 }
10101 } 10146 }
10102 closedir(hdir); 10147 closedir(hdir);
10103 } 10148 }
10104 } 10149 }
10105 10150
10106 static int DWSIGNAL _dw_folder_ok_func(HWND window, void *data) 10151 static int DWSIGNAL _dw_folder_ok_func(HWND window, void *data)
10107 { 10152 {
10108 DWDialog *dwwait = (DWDialog *)data; 10153 DWDialog *dwwait = (DWDialog *)data;
10109 void *treedata; 10154 void *treedata;
10110 10155
10111 if(!dwwait) 10156 if(!dwwait)
10112 return FALSE; 10157 return FALSE;
10113 10158
10114 treedata = dw_window_get_data((HWND)dwwait->data, "_dw_tree_selected"); 10159 treedata = dw_window_get_data((HWND)dwwait->data, "_dw_tree_selected");
10115 dw_window_destroy((HWND)dwwait->data); 10160 dw_window_destroy((HWND)dwwait->data);
10116 dw_dialog_dismiss(dwwait, treedata); 10161 dw_dialog_dismiss(dwwait, treedata);
10117 return FALSE; 10162 return FALSE;
10118 } 10163 }
10119 10164
10120 static int DWSIGNAL _dw_folder_cancel_func(HWND window, void *data) 10165 static int DWSIGNAL _dw_folder_cancel_func(HWND window, void *data)
10121 { 10166 {
10122 DWDialog *dwwait = (DWDialog *)data; 10167 DWDialog *dwwait = (DWDialog *)data;
10123 10168
10124 if(!dwwait) 10169 if(!dwwait)
10125 return FALSE; 10170 return FALSE;
10126 10171
10127 dw_window_destroy((HWND)dwwait->data); 10172 dw_window_destroy((HWND)dwwait->data);
10128 dw_dialog_dismiss(dwwait, NULL); 10173 dw_dialog_dismiss(dwwait, NULL);
10129 return FALSE; 10174 return FALSE;
10130 } 10175 }
10131 10176
10132 static char *_tree_folder(HWND tree, HTREEITEM item) 10177 static char *_tree_folder(HWND tree, HTREEITEM item)
10133 { 10178 {
10134 char *folder=strdup(""); 10179 char *folder=strdup("");
10135 HTREEITEM parent = item; 10180 HTREEITEM parent = item;
10136 10181
10137 while(parent) 10182 while(parent)
10138 { 10183 {
10139 char *temp, *text = dw_tree_get_title(tree, parent); 10184 char *temp, *text = dw_tree_get_title(tree, parent);
10140 10185
10141 if(text) 10186 if(text)
10142 { 10187 {
10143 temp = malloc(strlen(text) + strlen(folder) + 3); 10188 temp = malloc(strlen(text) + strlen(folder) + 3);
10144 strcpy(temp, text); 10189 strcpy(temp, text);
10145 if(strcmp(text, "/")) 10190 if(strcmp(text, "/"))
10146 strcat(temp, "/"); 10191 strcat(temp, "/");
10147 strcat(temp, folder); 10192 strcat(temp, folder);
10148 free(folder); 10193 free(folder);
10149 folder = temp; 10194 folder = temp;
10150 } 10195 }
10151 parent = dw_tree_get_parent(tree, parent); 10196 parent = dw_tree_get_parent(tree, parent);
10152 } 10197 }
10153 return folder; 10198 return folder;
10154 } 10199 }
10155 10200
10156 static int DWSIGNAL _item_select(HWND window, HTREEITEM item, char *text, void *data, void *itemdata) 10201 static int DWSIGNAL _item_select(HWND window, HTREEITEM item, char *text, void *data, void *itemdata)
10157 { 10202 {
10158 DWDialog *dwwait = (DWDialog *)data; 10203 DWDialog *dwwait = (DWDialog *)data;
10159 char *treedata = (char *)dw_window_get_data((HWND)dwwait->data, "_dw_tree_selected"); 10204 char *treedata = (char *)dw_window_get_data((HWND)dwwait->data, "_dw_tree_selected");
10160 10205
10161 text = text; itemdata = itemdata; 10206 text = text; itemdata = itemdata;
10162 if(treedata) 10207 if(treedata)
10163 free(treedata); 10208 free(treedata);
10164 10209
10165 treedata = _tree_folder(window, item); 10210 treedata = _tree_folder(window, item);
10166 dw_window_set_data((HWND)dwwait->data, "_dw_tree_selected", (void *)treedata); 10211 dw_window_set_data((HWND)dwwait->data, "_dw_tree_selected", (void *)treedata);
10167 10212
10168 return FALSE; 10213 return FALSE;
10169 } 10214 }
10170 10215
10171 static int DWSIGNAL _tree_expand(HWND window, HTREEITEM item, void *data) 10216 static int DWSIGNAL _tree_expand(HWND window, HTREEITEM item, void *data)
10172 { 10217 {
10173 DWDialog *dwwait = (DWDialog *)data; 10218 DWDialog *dwwait = (DWDialog *)data;
10174 HWND tree = (HWND)dw_window_get_data((HWND)dwwait->data, "_dw_tree"); 10219 HWND tree = (HWND)dw_window_get_data((HWND)dwwait->data, "_dw_tree");
10175 HTREEITEM tempitem = (HTREEITEM)dw_tree_item_get_data(tree, item); 10220 HTREEITEM tempitem = (HTREEITEM)dw_tree_item_get_data(tree, item);
10176 10221
10177 if(tempitem) 10222 if(tempitem)
10178 { 10223 {
10179 char *folder = _tree_folder(tree, item); 10224 char *folder = _tree_folder(tree, item);
10180 10225
10181 dw_tree_item_set_data(tree, item, 0); 10226 dw_tree_item_set_data(tree, item, 0);
10182 10227
10183 if(*folder) 10228 if(*folder)
10184 _populate_directory(tree, item, folder); 10229 _populate_directory(tree, item, folder);
10185 10230
10186 #if GTK_MAJOR_VERSION > 1 10231 #if GTK_MAJOR_VERSION > 1
10187 /* FIXME: GTK 1.x tree control goes crazy when 10232 /* FIXME: GTK 1.x tree control goes crazy when
10188 * I delete the temporary item. The subtree 10233 * I delete the temporary item. The subtree
10189 * it sits on ceases to be valid and attempts 10234 * it sits on ceases to be valid and attempts
10190 * to delete or recreate it fail horribly. 10235 * to delete or recreate it fail horribly.
10191 */ 10236 */
10192 dw_tree_item_delete(tree, tempitem); 10237 dw_tree_item_delete(tree, tempitem);
10193 #endif 10238 #endif
10194 free(folder); 10239 free(folder);
10195 } 10240 }
10196 10241
10197 return FALSE; 10242 return FALSE;
10198 } 10243 }
10199 10244
10200 /* 10245 /*
10201 * Opens a file dialog and queries user selection. 10246 * Opens a file dialog and queries user selection.
10202 * Parameters: 10247 * Parameters:
10209 * the file path on success. 10254 * the file path on success.
10210 * 10255 *
10211 */ 10256 */
10212 char *dw_file_browse(char *title, char *defpath, char *ext, int flags) 10257 char *dw_file_browse(char *title, char *defpath, char *ext, int flags)
10213 { 10258 {
10214 GtkWidget *filew; 10259 GtkWidget *filew;
10215 int _locked_by_me = FALSE; 10260 int _locked_by_me = FALSE;
10216 DWDialog *dwwait; 10261 DWDialog *dwwait;
10217 10262
10218 if(flags == DW_DIRECTORY_OPEN) 10263 if(flags == DW_DIRECTORY_OPEN)
10219 { 10264 {
10220 HWND window, hbox, vbox, tree, button; 10265 HWND window, hbox, vbox, tree, button;
10221 HTREEITEM item, tempitem; 10266 HTREEITEM item, tempitem;
10222 10267
10223 window = dw_window_new( HWND_DESKTOP, title, DW_FCF_SHELLPOSITION | DW_FCF_TITLEBAR | DW_FCF_SIZEBORDER | DW_FCF_MINMAX); 10268 window = dw_window_new( HWND_DESKTOP, title, DW_FCF_SHELLPOSITION | DW_FCF_TITLEBAR | DW_FCF_SIZEBORDER | DW_FCF_MINMAX);
10224 10269
10225 vbox = dw_box_new(DW_VERT, 5); 10270 vbox = dw_box_new(DW_VERT, 5);
10226 10271
10227 dw_box_pack_start(window, vbox, 0, 0, TRUE, TRUE, 0); 10272 dw_box_pack_start(window, vbox, 0, 0, TRUE, TRUE, 0);
10228 10273
10229 tree = dw_tree_new(60); 10274 tree = dw_tree_new(60);
10230 10275
10231 dw_box_pack_start(vbox, tree, 1, 1, TRUE, TRUE, 0); 10276 dw_box_pack_start(vbox, tree, 1, 1, TRUE, TRUE, 0);
10232 dw_window_set_data(window, "_dw_tree", (void *)tree); 10277 dw_window_set_data(window, "_dw_tree", (void *)tree);
10233 10278
10234 hbox = dw_box_new(DW_HORZ, 0); 10279 hbox = dw_box_new(DW_HORZ, 0);
10235 10280
10236 dw_box_pack_start(vbox, hbox, 0, 0, TRUE, FALSE, 0); 10281 dw_box_pack_start(vbox, hbox, 0, 0, TRUE, FALSE, 0);
10237 10282
10238 dwwait = dw_dialog_new((void *)window); 10283 dwwait = dw_dialog_new((void *)window);
10239 10284
10240 dw_signal_connect(tree, DW_SIGNAL_ITEM_SELECT, DW_SIGNAL_FUNC(_item_select), (void *)dwwait); 10285 dw_signal_connect(tree, DW_SIGNAL_ITEM_SELECT, DW_SIGNAL_FUNC(_item_select), (void *)dwwait);
10241 dw_signal_connect(tree, DW_SIGNAL_TREE_EXPAND, DW_SIGNAL_FUNC(_tree_expand), (void *)dwwait); 10286 dw_signal_connect(tree, DW_SIGNAL_TREE_EXPAND, DW_SIGNAL_FUNC(_tree_expand), (void *)dwwait);
10242 10287
10243 button = dw_button_new("Ok", 1001L); 10288 button = dw_button_new("Ok", 1001L);
10244 dw_box_pack_start(hbox, button, 50, 30, TRUE, FALSE, 3); 10289 dw_box_pack_start(hbox, button, 50, 30, TRUE, FALSE, 3);
10245 dw_signal_connect(button, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_folder_ok_func), (void *)dwwait); 10290 dw_signal_connect(button, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_folder_ok_func), (void *)dwwait);
10246 10291
10247 button = dw_button_new("Cancel", 1002L); 10292 button = dw_button_new("Cancel", 1002L);
10248 dw_box_pack_start(hbox, button, 50, 30, TRUE, FALSE, 3); 10293 dw_box_pack_start(hbox, button, 50, 30, TRUE, FALSE, 3);
10249 dw_signal_connect(button, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_folder_cancel_func), (void *)dwwait); 10294 dw_signal_connect(button, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_folder_cancel_func), (void *)dwwait);
10250 10295
10251 item = dw_tree_insert(tree, "/", 0, NULL, 0); 10296 item = dw_tree_insert(tree, "/", 0, NULL, 0);
10252 tempitem = dw_tree_insert(tree, "", 0, item, 0); 10297 tempitem = dw_tree_insert(tree, "", 0, item, 0);
10253 dw_tree_item_set_data(tree, item, (void *)tempitem); 10298 dw_tree_item_set_data(tree, item, (void *)tempitem);
10254 10299
10255 dw_window_set_size(window, 225, 300); 10300 dw_window_set_size(window, 225, 300);
10256 dw_window_show(window); 10301 dw_window_show(window);
10257 } 10302 }
10258 else 10303 else
10259 { 10304 {
10260 DW_MUTEX_LOCK; 10305 DW_MUTEX_LOCK;
10261 10306
10262 /* The DW mutex should be sufficient for 10307 /* The DW mutex should be sufficient for
10263 * insuring no thread changes this unknowingly. 10308 * insuring no thread changes this unknowingly.
10264 */ 10309 */
10265 if(_dw_file_active) 10310 if(_dw_file_active)
10266 { 10311 {
10267 DW_MUTEX_UNLOCK; 10312 DW_MUTEX_UNLOCK;
10268 return NULL; 10313 return NULL;
10269 } 10314 }
10270 10315
10271 _dw_file_active = 1; 10316 _dw_file_active = 1;
10272 10317
10273 filew = gtk_file_selection_new(title); 10318 filew = gtk_file_selection_new(title);
10274 10319
10275 dwwait = dw_dialog_new((void *)filew); 10320 dwwait = dw_dialog_new((void *)filew);
10276 10321
10277 gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(filew)->ok_button), "clicked", (GtkSignalFunc) _gtk_file_ok, dwwait); 10322 gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(filew)->ok_button), "clicked", (GtkSignalFunc) _gtk_file_ok, dwwait);
10278 gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(filew)->cancel_button), "clicked", (GtkSignalFunc) _gtk_file_cancel, dwwait); 10323 gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(filew)->cancel_button), "clicked", (GtkSignalFunc) _gtk_file_cancel, dwwait);
10279 10324
10280 if(defpath) 10325 if(defpath)
10281 gtk_file_selection_set_filename(GTK_FILE_SELECTION(filew), defpath); 10326 gtk_file_selection_set_filename(GTK_FILE_SELECTION(filew), defpath);
10282 10327
10283 gtk_widget_show(filew); 10328 gtk_widget_show(filew);
10284 10329
10285 DW_MUTEX_UNLOCK; 10330 DW_MUTEX_UNLOCK;
10286 } 10331 }
10287 return (char *)dw_dialog_wait(dwwait); 10332 return (char *)dw_dialog_wait(dwwait);
10288 } 10333 }
10289 10334
10290 10335
10291 /* 10336 /*
10292 * Execute and external program in a seperate session. 10337 * Execute and external program in a seperate session.
10297 * Returns: 10342 * Returns:
10298 * -1 on error. 10343 * -1 on error.
10299 */ 10344 */
10300 int dw_exec(char *program, int type, char **params) 10345 int dw_exec(char *program, int type, char **params)
10301 { 10346 {
10302 int ret = -1; 10347 int ret = -1;
10303 10348
10304 if((ret = fork()) == 0) 10349 if((ret = fork()) == 0)
10305 { 10350 {
10306 int i; 10351 int i;
10307 10352
10308 for (i = 3; i < 256; i++) 10353 for (i = 3; i < 256; i++)
10309 close(i); 10354 close(i);
10310 setsid(); 10355 setsid();
10311 if(type == DW_EXEC_GUI) 10356 if(type == DW_EXEC_GUI)
10312 { 10357 {
10313 execvp(program, params); 10358 execvp(program, params);
10314 } 10359 }
10315 else if(type == DW_EXEC_CON) 10360 else if(type == DW_EXEC_CON)
10316 { 10361 {
10317 char **tmpargs; 10362 char **tmpargs;
10318 10363
10319 if(!params) 10364 if(!params)
10320 { 10365 {
10321 tmpargs = malloc(sizeof(char *)); 10366 tmpargs = malloc(sizeof(char *));
10322 tmpargs[0] = NULL; 10367 tmpargs[0] = NULL;
10323 } 10368 }
10324 else 10369 else
10325 { 10370 {
10326 int z = 0; 10371 int z = 0;
10327 10372
10328 while(params[z]) 10373 while(params[z])
10329 { 10374 {
10330 z++; 10375 z++;
10331 } 10376 }
10332 tmpargs = malloc(sizeof(char *)*(z+3)); 10377 tmpargs = malloc(sizeof(char *)*(z+3));
10333 z=0; 10378 z=0;
10334 tmpargs[0] = "xterm"; 10379 tmpargs[0] = "xterm";
10335 tmpargs[1] = "-e"; 10380 tmpargs[1] = "-e";
10336 while(params[z]) 10381 while(params[z])
10337 { 10382 {
10338 tmpargs[z+2] = params[z]; 10383 tmpargs[z+2] = params[z];
10339 z++; 10384 z++;
10340 } 10385 }
10341 tmpargs[z+2] = NULL; 10386 tmpargs[z+2] = NULL;
10342 } 10387 }
10343 execvp("xterm", tmpargs); 10388 execvp("xterm", tmpargs);
10344 free(tmpargs); 10389 free(tmpargs);
10345 } 10390 }
10346 /* If we got here exec failed */ 10391 /* If we got here exec failed */
10347 _exit(-1); 10392 _exit(-1);
10348 } 10393 }
10349 return ret; 10394 return ret;
10350 } 10395 }
10351 10396
10352 /* 10397 /*
10353 * Loads a web browser pointed at the given URL. 10398 * Loads a web browser pointed at the given URL.
10354 * Parameters: 10399 * Parameters:
10355 * url: Uniform resource locator. 10400 * url: Uniform resource locator.
10356 */ 10401 */
10357 int dw_browse(char *url) 10402 int dw_browse(char *url)
10358 { 10403 {
10359 /* Is there a way to find the webbrowser in Unix? */ 10404 /* Is there a way to find the webbrowser in Unix? */
10360 char *execargs[3], *browser = "netscape", *tmp; 10405 char *execargs[3], *browser = "netscape", *tmp;
10361 10406
10362 tmp = getenv( "DW_BROWSER" ); 10407 tmp = getenv( "DW_BROWSER" );
10363 if(tmp) browser = tmp; 10408 if(tmp) browser = tmp;
10364 execargs[0] = browser; 10409 execargs[0] = browser;
10365 execargs[1] = url; 10410 execargs[1] = url;
10366 execargs[2] = NULL; 10411 execargs[2] = NULL;
10367 10412
10368 return dw_exec(browser, DW_EXEC_GUI, execargs); 10413 return dw_exec(browser, DW_EXEC_GUI, execargs);
10369 } 10414 }
10370 10415
10371 /* 10416 /*
10372 * Causes the embedded HTML widget to take action. 10417 * Causes the embedded HTML widget to take action.
10373 * Parameters: 10418 * Parameters:
10375 * action: One of the DW_HTML_* constants. 10420 * action: One of the DW_HTML_* constants.
10376 */ 10421 */
10377 void dw_html_action(HWND handle, int action) 10422 void dw_html_action(HWND handle, int action)
10378 { 10423 {
10379 #ifdef USE_GTKMOZEMBED 10424 #ifdef USE_GTKMOZEMBED
10380 int _locked_by_me = FALSE; 10425 int _locked_by_me = FALSE;
10381 10426
10382 if(!_gtk_moz_embed_new) 10427 if(!_gtk_moz_embed_new)
10383 return; 10428 return;
10384 10429
10385 DW_MUTEX_LOCK; 10430 DW_MUTEX_LOCK;
10386 switch(action) 10431 switch(action)
10387 { 10432 {
10388 case DW_HTML_GOBACK: 10433 case DW_HTML_GOBACK:
10389 _gtk_moz_embed_go_back(GTK_MOZ_EMBED(handle)); 10434 _gtk_moz_embed_go_back(GTK_MOZ_EMBED(handle));
10390 break; 10435 break;
10391 case DW_HTML_GOFORWARD: 10436 case DW_HTML_GOFORWARD:
10392 _gtk_moz_embed_go_forward(GTK_MOZ_EMBED(handle)); 10437 _gtk_moz_embed_go_forward(GTK_MOZ_EMBED(handle));
10393 break; 10438 break;
10394 case DW_HTML_GOHOME: 10439 case DW_HTML_GOHOME:
10395 _gtk_moz_embed_load_url(GTK_MOZ_EMBED(handle), "http://dwindows.netlabs.org"); 10440 _gtk_moz_embed_load_url(GTK_MOZ_EMBED(handle), "http://dwindows.netlabs.org");
10396 break; 10441 break;
10397 case DW_HTML_RELOAD: 10442 case DW_HTML_RELOAD:
10398 _gtk_moz_embed_reload(GTK_MOZ_EMBED(handle), 0); 10443 _gtk_moz_embed_reload(GTK_MOZ_EMBED(handle), 0);
10399 break; 10444 break;
10400 case DW_HTML_STOP: 10445 case DW_HTML_STOP:
10401 _gtk_moz_embed_stop_load(GTK_MOZ_EMBED(handle)); 10446 _gtk_moz_embed_stop_load(GTK_MOZ_EMBED(handle));
10402 break; 10447 break;
10403 } 10448 }
10404 DW_MUTEX_UNLOCK; 10449 DW_MUTEX_UNLOCK;
10405 #endif 10450 #endif
10406 } 10451 }
10407 10452
10408 /* 10453 /*
10409 * Render raw HTML code in the embedded HTML widget.. 10454 * Render raw HTML code in the embedded HTML widget..
10415 * 0 on success. 10460 * 0 on success.
10416 */ 10461 */
10417 int dw_html_raw(HWND handle, char *string) 10462 int dw_html_raw(HWND handle, char *string)
10418 { 10463 {
10419 #ifdef USE_GTKMOZEMBED 10464 #ifdef USE_GTKMOZEMBED
10420 int _locked_by_me = FALSE; 10465 int _locked_by_me = FALSE;
10421 10466
10422 if(!_gtk_moz_embed_new) 10467 if(!_gtk_moz_embed_new)
10423 return -1; 10468 return -1;
10424 10469
10425 DW_MUTEX_LOCK; 10470 DW_MUTEX_LOCK;
10426 _gtk_moz_embed_render_data(GTK_MOZ_EMBED(handle), string, strlen(string), "", ""); 10471 _gtk_moz_embed_render_data(GTK_MOZ_EMBED(handle), string, strlen(string), "", "");
10427 DW_MUTEX_UNLOCK; 10472 DW_MUTEX_UNLOCK;
10428 return 0; 10473 return 0;
10429 #endif 10474 #endif
10430 return -1; 10475 return -1;
10431 } 10476 }
10432 10477
10433 /* 10478 /*
10434 * Render file or web page in the embedded HTML widget.. 10479 * Render file or web page in the embedded HTML widget..
10435 * Parameters: 10480 * Parameters:
10440 * 0 on success. 10485 * 0 on success.
10441 */ 10486 */
10442 int dw_html_url(HWND handle, char *url) 10487 int dw_html_url(HWND handle, char *url)
10443 { 10488 {
10444 #ifdef USE_GTKMOZEMBED 10489 #ifdef USE_GTKMOZEMBED
10445 int _locked_by_me = FALSE; 10490 int _locked_by_me = FALSE;
10446 10491
10447 if(!_gtk_moz_embed_new) 10492 if (!_gtk_moz_embed_new)
10448 return -1; 10493 return -1;
10449 10494
10450 DW_MUTEX_LOCK; 10495 DW_MUTEX_LOCK;
10451 _gtk_moz_embed_load_url(GTK_MOZ_EMBED(handle), url); 10496 _gtk_moz_embed_load_url( GTK_MOZ_EMBED(handle), url );
10452 DW_MUTEX_UNLOCK; 10497 DW_MUTEX_UNLOCK;
10453 return 0; 10498 return 0;
10454 #endif 10499 #endif
10455 return -1; 10500 return -1;
10456 } 10501 }
10502
10503 #ifdef USE_GTKMOZEMBED
10504 /*
10505 * Callback for a HTML widget when the "Forward" menu item is selected
10506 */
10507 static int _dw_html_forward_callback(HWND window, void *data)
10508 {
10509 HWND handle=(HWND)data;
10510 dw_html_action( handle, DW_HTML_GOFORWARD );
10511 return TRUE;
10512 }
10513
10514 /*
10515 * Callback for a HTML widget when the "Back" menu item is selected
10516 */
10517 static int _dw_html_backward_callback(HWND window, void *data)
10518 {
10519 HWND handle=(HWND)data;
10520 dw_html_action( handle, DW_HTML_GOBACK );
10521 return TRUE;
10522 }
10523
10524 /*
10525 * Callback for a HTML widget when the "Reload" menu item is selected
10526 */
10527 static int _dw_html_reload_callback(HWND window, void *data)
10528 {
10529 HWND handle=(HWND)data;
10530 dw_html_action( handle, DW_HTML_RELOAD );
10531 return TRUE;
10532 }
10533
10534 /*
10535 * Callback for a HTML widget when a page has completed loading
10536 * Once the page has finished loading, show the widget.
10537 */
10538 void _dw_html_net_stop_cb( GtkMozEmbed *embed, gpointer data )
10539 {
10540 gtk_widget_show(GTK_WIDGET(data));
10541 }
10542
10543 /*
10544 * Callback for a HTML widget when a mouse button is clicked inside the widget
10545 * If the right mouse button is clicked, popup a context menu
10546 */
10547 static gint _dw_dom_mouse_click_cb (GtkMozEmbed *dummy, gpointer dom_event, gpointer embed)
10548 {
10549 gint button,rc;
10550 glong x,y;
10551 int flags;
10552
10553 button = mozilla_get_mouse_event_button( dom_event );
10554 if ( button == 2 )
10555 {
10556 HWND menuitem;
10557 HMENUI popup;
10558 /*
10559 * Right mouse button; display context menu
10560 */
10561 rc = mozilla_get_mouse_location( dom_event, &x, &y);
10562 popup = dw_menu_new( 0 );
10563 if ( _gtk_moz_embed_can_go_forward(GTK_MOZ_EMBED(embed) ) )
10564 flags = DW_MIS_ENABLED;
10565 else
10566 flags = DW_MIS_DISABLED;
10567 menuitem = dw_menu_append_item( popup, "Forward", 1, flags, TRUE, FALSE, 0 );
10568 dw_signal_connect( menuitem, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_html_forward_callback), embed );
10569
10570 if ( _gtk_moz_embed_can_go_back(GTK_MOZ_EMBED(embed) ) )
10571 flags = DW_MIS_ENABLED;
10572 else
10573 flags = DW_MIS_DISABLED;
10574 menuitem = dw_menu_append_item( popup, "Back", 2, flags, TRUE, FALSE, 0 );
10575 dw_signal_connect( menuitem, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_html_backward_callback), embed );
10576
10577 dw_menu_append_item( popup, DW_MENU_SEPARATOR, 99, 0, TRUE, FALSE, 0 );
10578
10579 menuitem = dw_menu_append_item( popup, "Reload", 3, 0, TRUE, FALSE, 0 );
10580 dw_signal_connect( menuitem, DW_SIGNAL_CLICKED, DW_SIGNAL_FUNC(_dw_html_reload_callback), embed );
10581
10582 dw_menu_popup( &popup, embed, x, y );
10583 rc = TRUE;
10584 }
10585 else
10586 {
10587 rc = FALSE;
10588 }
10589 return rc;
10590 }
10591 #endif
10457 10592
10458 /* 10593 /*
10459 * Create a new Entryfield window (widget) to be packed. 10594 * Create a new Entryfield window (widget) to be packed.
10460 * Parameters: 10595 * Parameters:
10461 * text: The default text to be in the entryfield widget. 10596 * text: The default text to be in the entryfield widget.
10462 * id: An ID to be used with dw_window_from_id() or 0L. 10597 * id: An ID to be used with dw_window_from_id() or 0L.
10463 */ 10598 */
10464 HWND dw_html_new(unsigned long id) 10599 HWND dw_html_new(unsigned long id)
10465 { 10600 {
10601 GtkWidget *widget,*stext;
10602 int _locked_by_me = FALSE;
10603
10604 DW_MUTEX_LOCK;
10466 #ifdef USE_GTKMOZEMBED 10605 #ifdef USE_GTKMOZEMBED
10467 GtkWidget *widget; 10606 if (!_gtk_moz_embed_new)
10468 int _locked_by_me = FALSE; 10607 {
10469 10608 widget = dw_box_new(DW_HORZ, 0);
10470 if(!_gtk_moz_embed_new) 10609 stext = dw_text_new( "HTML widget not available; you do not have access to gtkmozembed.", 0);
10471 return NULL; 10610 dw_box_pack_start(widget, stext, 0, 0, TRUE, TRUE, 10);
10472 10611 }
10473 DW_MUTEX_LOCK; 10612 else
10474 widget = _gtk_moz_embed_new(); 10613 {
10475 DW_MUTEX_UNLOCK; 10614 widget = _gtk_moz_embed_new();
10476 return widget; 10615 /*
10616 * Connect some signals
10617 */
10618 gtk_signal_connect( GTK_OBJECT(widget), "net-stop", GTK_SIGNAL_FUNC(_dw_html_net_stop_cb), widget );
10619 gtk_signal_connect( GTK_OBJECT(widget), "dom_mouse_click", GTK_SIGNAL_FUNC(_dw_dom_mouse_click_cb), widget );
10620 }
10477 #else 10621 #else
10478 return dw_box_new(DW_HORZ, 0); 10622 widget = dw_box_new(DW_HORZ, 0);
10479 #endif 10623 stext = dw_text_new( "HTML widget not available; you do not have access to gtkmozembed.", 0);
10624 dw_box_pack_start(widget, stext, 0, 0, TRUE, TRUE, 10);
10625 #endif
10626 DW_MUTEX_UNLOCK;
10627 return widget;
10480 } 10628 }
10481 10629
10482 /* 10630 /*
10483 * Gets the contents of the default clipboard as text. 10631 * Gets the contents of the default clipboard as text.
10484 * Parameters: 10632 * Parameters:
10528 * current user directory. Or the root directory (C:\ on 10676 * current user directory. Or the root directory (C:\ on
10529 * OS/2 and Windows). 10677 * OS/2 and Windows).
10530 */ 10678 */
10531 char *dw_user_dir(void) 10679 char *dw_user_dir(void)
10532 { 10680 {
10533 static char _user_dir[1024] = ""; 10681 static char _user_dir[1024] = "";
10534 10682
10535 if(!_user_dir[0]) 10683 if(!_user_dir[0])
10536 { 10684 {
10537 char *home = getenv("HOME"); 10685 char *home = getenv("HOME");
10538 10686
10539 if(home) 10687 if(home)
10540 strcpy(_user_dir, home); 10688 strcpy(_user_dir, home);
10541 else 10689 else
10542 strcpy(_user_dir, "/"); 10690 strcpy(_user_dir, "/");
10543 } 10691 }
10544 return _user_dir; 10692 return _user_dir;
10545 } 10693 }
10546 10694
10547 /* 10695 /*
10548 * Call a function from the window (widget)'s context. 10696 * Call a function from the window (widget)'s context.
10549 * Parameters: 10697 * Parameters:
10551 * function: Function pointer to be called. 10699 * function: Function pointer to be called.
10552 * data: Pointer to the data to be passed to the function. 10700 * data: Pointer to the data to be passed to the function.
10553 */ 10701 */
10554 void dw_window_function(HWND handle, void *function, void *data) 10702 void dw_window_function(HWND handle, void *function, void *data)
10555 { 10703 {
10556 void (* windowfunc)(void *); 10704 void (* windowfunc)(void *);
10557 10705
10558 windowfunc = function; 10706 windowfunc = function;
10559 10707
10560 if(windowfunc) 10708 if(windowfunc)
10561 windowfunc(data); 10709 windowfunc(data);
10562 } 10710 }
10563 10711
10564 /* 10712 /*
10565 * Add a named user data item to a window handle. 10713 * Add a named user data item to a window handle.
10566 * Parameters: 10714 * Parameters:
10568 * dataname: A string pointer identifying which signal to be hooked. 10716 * dataname: A string pointer identifying which signal to be hooked.
10569 * data: User data to be passed to the handler function. 10717 * data: User data to be passed to the handler function.
10570 */ 10718 */
10571 void dw_window_set_data(HWND window, char *dataname, void *data) 10719 void dw_window_set_data(HWND window, char *dataname, void *data)
10572 { 10720 {
10573 int _locked_by_me = FALSE; 10721 int _locked_by_me = FALSE;
10574 10722
10575 if(!window) 10723 if(!window)
10576 return; 10724 return;
10577 10725
10578 DW_MUTEX_LOCK; 10726 DW_MUTEX_LOCK;
10579 if(GTK_IS_OBJECT(window)) 10727 if(GTK_IS_OBJECT(window))
10580 { 10728 {
10581 if(GTK_IS_SCROLLED_WINDOW(window)) 10729 if(GTK_IS_SCROLLED_WINDOW(window))
10582 { 10730 {
10583 HWND thiswindow = (HWND)gtk_object_get_user_data(GTK_OBJECT(window)); 10731 HWND thiswindow = (HWND)gtk_object_get_user_data(GTK_OBJECT(window));
10584 10732
10585 if(thiswindow && GTK_IS_OBJECT(thiswindow)) 10733 if(thiswindow && GTK_IS_OBJECT(thiswindow))
10586 gtk_object_set_data(GTK_OBJECT(thiswindow), dataname, (gpointer)data); 10734 gtk_object_set_data(GTK_OBJECT(thiswindow), dataname, (gpointer)data);
10587 } 10735 }
10588 if(GTK_IS_COMBO(window)) 10736 if(GTK_IS_COMBO(window))
10589 gtk_object_set_data(GTK_OBJECT(GTK_COMBO(window)->entry), dataname, (gpointer)data); 10737 gtk_object_set_data(GTK_OBJECT(GTK_COMBO(window)->entry), dataname, (gpointer)data);
10590 gtk_object_set_data(GTK_OBJECT(window), dataname, (gpointer)data); 10738 gtk_object_set_data(GTK_OBJECT(window), dataname, (gpointer)data);
10591 } 10739 }
10592 DW_MUTEX_UNLOCK; 10740 DW_MUTEX_UNLOCK;
10593 } 10741 }
10594 10742
10595 /* 10743 /*
10596 * Gets a named user data item to a window handle. 10744 * Gets a named user data item to a window handle.
10597 * Parameters: 10745 * Parameters:
10599 * dataname: A string pointer identifying which signal to be hooked. 10747 * dataname: A string pointer identifying which signal to be hooked.
10600 * data: User data to be passed to the handler function. 10748 * data: User data to be passed to the handler function.
10601 */ 10749 */
10602 void *dw_window_get_data(HWND window, char *dataname) 10750 void *dw_window_get_data(HWND window, char *dataname)
10603 { 10751 {
10604 int _locked_by_me = FALSE; 10752 int _locked_by_me = FALSE;
10605 void *ret = NULL; 10753 void *ret = NULL;
10606 10754
10607 if(!window) 10755 if(!window)
10608 return NULL; 10756 return NULL;
10609 10757
10610 DW_MUTEX_LOCK; 10758 DW_MUTEX_LOCK;
10611 if(GTK_IS_OBJECT(window)) 10759 if(GTK_IS_OBJECT(window))
10612 ret = (void *)gtk_object_get_data(GTK_OBJECT(window), dataname); 10760 ret = (void *)gtk_object_get_data(GTK_OBJECT(window), dataname);
10613 DW_MUTEX_UNLOCK; 10761 DW_MUTEX_UNLOCK;
10614 return ret; 10762 return ret;
10615 } 10763 }
10616 10764
10617 /* 10765 /*
10618 * Add a callback to a timer event. 10766 * Add a callback to a timer event.
10619 * Parameters: 10767 * Parameters:
10623 * Returns: 10771 * Returns:
10624 * Timer ID for use with dw_timer_disconnect(), 0 on error. 10772 * Timer ID for use with dw_timer_disconnect(), 0 on error.
10625 */ 10773 */
10626 int API dw_timer_connect(int interval, void *sigfunc, void *data) 10774 int API dw_timer_connect(int interval, void *sigfunc, void *data)
10627 { 10775 {
10628 int tag, _locked_by_me = FALSE; 10776 int tag, _locked_by_me = FALSE;
10629 10777
10630 DW_MUTEX_LOCK; 10778 DW_MUTEX_LOCK;
10631 tag = gtk_timeout_add(interval, (GtkFunction)sigfunc, data); 10779 tag = gtk_timeout_add(interval, (GtkFunction)sigfunc, data);
10632 DW_MUTEX_UNLOCK; 10780 DW_MUTEX_UNLOCK;
10633 return tag; 10781 return tag;
10634 } 10782 }
10635 10783
10636 /* 10784 /*
10637 * Removes timer callback. 10785 * Removes timer callback.
10638 * Parameters: 10786 * Parameters:
10639 * id: Timer ID returned by dw_timer_connect(). 10787 * id: Timer ID returned by dw_timer_connect().
10640 */ 10788 */
10641 void API dw_timer_disconnect(int id) 10789 void API dw_timer_disconnect(int id)
10642 { 10790 {
10643 int _locked_by_me = FALSE; 10791 int _locked_by_me = FALSE;
10644 10792
10645 DW_MUTEX_LOCK; 10793 DW_MUTEX_LOCK;
10646 gtk_timeout_remove(id); 10794 gtk_timeout_remove(id);
10647 DW_MUTEX_UNLOCK; 10795 DW_MUTEX_UNLOCK;
10648 } 10796 }
10649 10797
10650 /* Get the actual signal window handle not the user window handle 10798 /* Get the actual signal window handle not the user window handle
10651 * Should mimic the code in dw_signal_connect() below. 10799 * Should mimic the code in dw_signal_connect() below.
10652 */ 10800 */
10653 static HWND _find_signal_window(HWND window, char *signame) 10801 static HWND _find_signal_window(HWND window, char *signame)
10654 { 10802 {
10655 HWND thiswindow = window; 10803 HWND thiswindow = window;
10656 10804
10657 if(GTK_IS_SCROLLED_WINDOW(thiswindow)) 10805 if(GTK_IS_SCROLLED_WINDOW(thiswindow))
10658 thiswindow = (HWND)gtk_object_get_user_data(GTK_OBJECT(window)); 10806 thiswindow = (HWND)gtk_object_get_user_data(GTK_OBJECT(window));
10659 else if(GTK_IS_COMBO(thiswindow) && signame && strcmp(signame, DW_SIGNAL_LIST_SELECT) == 0) 10807 else if(GTK_IS_COMBO(thiswindow) && signame && strcmp(signame, DW_SIGNAL_LIST_SELECT) == 0)
10660 thiswindow = GTK_COMBO(thiswindow)->list; 10808 thiswindow = GTK_COMBO(thiswindow)->list;
10661 else if(GTK_IS_COMBO(thiswindow) && signame && strcmp(signame, DW_SIGNAL_SET_FOCUS) == 0) 10809 else if(GTK_IS_COMBO(thiswindow) && signame && strcmp(signame, DW_SIGNAL_SET_FOCUS) == 0)
10662 thiswindow = GTK_COMBO(thiswindow)->entry; 10810 thiswindow = GTK_COMBO(thiswindow)->entry;
10663 else if(GTK_IS_VSCALE(thiswindow) || GTK_IS_HSCALE(thiswindow) || 10811 else if(GTK_IS_VSCALE(thiswindow) || GTK_IS_HSCALE(thiswindow) ||
10664 GTK_IS_VSCROLLBAR(thiswindow) || GTK_IS_HSCROLLBAR(thiswindow)) 10812 GTK_IS_VSCROLLBAR(thiswindow) || GTK_IS_HSCROLLBAR(thiswindow))
10665 thiswindow = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(thiswindow), "_dw_adjustment"); 10813 thiswindow = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(thiswindow), "_dw_adjustment");
10666 #if GTK_MAJOR_VERSION > 1 10814 #if GTK_MAJOR_VERSION > 1
10667 else if(GTK_IS_TREE_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_SELECT) == 0) 10815 else if(GTK_IS_TREE_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_SELECT) == 0)
10668 thiswindow = (GtkWidget *)gtk_tree_view_get_selection(GTK_TREE_VIEW(thiswindow)); 10816 thiswindow = (GtkWidget *)gtk_tree_view_get_selection(GTK_TREE_VIEW(thiswindow));
10669 #endif 10817 #endif
10670 return thiswindow; 10818 return thiswindow;
10671 } 10819 }
10672 10820
10673 /* 10821 /*
10674 * Add a callback to a window event. 10822 * Add a callback to a window event.
10675 * Parameters: 10823 * Parameters:
10678 * sigfunc: The pointer to the function to be used as the callback. 10826 * sigfunc: The pointer to the function to be used as the callback.
10679 * data: User data to be passed to the handler function. 10827 * data: User data to be passed to the handler function.
10680 */ 10828 */
10681 void dw_signal_connect(HWND window, char *signame, void *sigfunc, void *data) 10829 void dw_signal_connect(HWND window, char *signame, void *sigfunc, void *data)
10682 { 10830 {
10683 void *thisfunc = _findsigfunc(signame); 10831 void *thisfunc = _findsigfunc(signame);
10684 char *thisname = signame; 10832 char *thisname = signame;
10685 HWND thiswindow = window; 10833 HWND thiswindow = window;
10686 int sigid, _locked_by_me = FALSE; 10834 int sigid, _locked_by_me = FALSE;
10687 gint cid; 10835 gint cid;
10688 10836
10689 DW_MUTEX_LOCK; 10837 DW_MUTEX_LOCK;
10690 /* 10838 /*
10691 * If the window we are setting the signal on is a scrolled window we need to get 10839 * If the window we are setting the signal on is a scrolled window we need to get
10692 * the "real" widget type. thiswindow is the "real" widget type 10840 * the "real" widget type. thiswindow is the "real" widget type
10693 */ 10841 */
10694 if(GTK_IS_SCROLLED_WINDOW(thiswindow)) 10842 if (GTK_IS_SCROLLED_WINDOW(thiswindow))
10695 { 10843 {
10696 thiswindow = (HWND)gtk_object_get_user_data(GTK_OBJECT(window)); 10844 thiswindow = (HWND)gtk_object_get_user_data(GTK_OBJECT(window));
10697 } 10845 }
10698 10846
10699 if(GTK_IS_MENU_ITEM(thiswindow) && strcmp(signame, DW_SIGNAL_CLICKED) == 0) 10847 if (GTK_IS_MENU_ITEM(thiswindow) && strcmp(signame, DW_SIGNAL_CLICKED) == 0)
10700 { 10848 {
10701 thisname = "activate"; 10849 thisname = "activate";
10702 thisfunc = _findsigfunc(thisname); 10850 thisfunc = _findsigfunc(thisname);
10703 } 10851 }
10704 else if(GTK_IS_CLIST(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_CONTEXT) == 0) 10852 else if (GTK_IS_CLIST(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_CONTEXT) == 0)
10705 { 10853 {
10706 thisname = "button_press_event"; 10854 thisname = "button_press_event";
10707 thisfunc = _findsigfunc(DW_SIGNAL_ITEM_CONTEXT); 10855 thisfunc = _findsigfunc(DW_SIGNAL_ITEM_CONTEXT);
10708 } 10856 }
10709 #if GTK_MAJOR_VERSION > 1 10857 #if GTK_MAJOR_VERSION > 1
10710 else if(GTK_IS_TREE_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_CONTEXT) == 0) 10858 else if (GTK_IS_TREE_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_CONTEXT) == 0)
10711 { 10859 {
10712 thisfunc = _findsigfunc("tree-context"); 10860 thisfunc = _findsigfunc("tree-context");
10713 10861
10714 sigid = _set_signal_handler(thiswindow, window, sigfunc, data, thisfunc); 10862 sigid = _set_signal_handler(thiswindow, window, sigfunc, data, thisfunc);
10715 cid = gtk_signal_connect(GTK_OBJECT(thiswindow), "button_press_event", GTK_SIGNAL_FUNC(thisfunc), (gpointer)sigid); 10863 cid = gtk_signal_connect(GTK_OBJECT(thiswindow), "button_press_event", GTK_SIGNAL_FUNC(thisfunc), (gpointer)sigid);
10716 _set_signal_handler_id(thiswindow, sigid, cid); 10864 _set_signal_handler_id(thiswindow, sigid, cid);
10717 10865
10718 #if 0 10866 #if 0
10719 sigid = _set_signal_handler(window, window, sigfunc, data, thisfunc); 10867 sigid = _set_signal_handler(window, window, sigfunc, data, thisfunc);
10720 cid = gtk_signal_connect(GTK_OBJECT(window), "button_press_event", GTK_SIGNAL_FUNC(thisfunc), (gpointer)sigid); 10868 cid = gtk_signal_connect(GTK_OBJECT(window), "button_press_event", GTK_SIGNAL_FUNC(thisfunc), (gpointer)sigid);
10721 _set_signal_handler_id(window, sigid, cid); 10869 _set_signal_handler_id(window, sigid, cid);
10722 #endif 10870 #endif
10723 10871
10724 DW_MUTEX_UNLOCK; 10872 DW_MUTEX_UNLOCK;
10725 return; 10873 return;
10726 } 10874 }
10727 else if(GTK_IS_TREE_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_SELECT) == 0) 10875 else if (GTK_IS_TREE_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_SELECT) == 0)
10728 { 10876 {
10729 GtkWidget *treeview = thiswindow; 10877 GtkWidget *treeview = thiswindow;
10730 10878
10731 thiswindow = (GtkWidget *)gtk_tree_view_get_selection(GTK_TREE_VIEW(thiswindow)); 10879 thiswindow = (GtkWidget *)gtk_tree_view_get_selection(GTK_TREE_VIEW(thiswindow));
10732 thisname = "changed"; 10880 thisname = "changed";
10733 10881
10734 sigid = _set_signal_handler(treeview, window, sigfunc, data, thisfunc); 10882 sigid = _set_signal_handler(treeview, window, sigfunc, data, thisfunc);
10735 cid = g_signal_connect(G_OBJECT(thiswindow), thisname, (GCallback)thisfunc, (gpointer)sigid); 10883 cid = g_signal_connect(G_OBJECT(thiswindow), thisname, (GCallback)thisfunc, (gpointer)sigid);
10736 _set_signal_handler_id(treeview, sigid, cid); 10884 _set_signal_handler_id(treeview, sigid, cid);
10737 DW_MUTEX_UNLOCK; 10885 DW_MUTEX_UNLOCK;
10738 return; 10886 return;
10739 } 10887 }
10740 else if(GTK_IS_TREE_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_TREE_EXPAND) == 0) 10888 else if (GTK_IS_TREE_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_TREE_EXPAND) == 0)
10741 { 10889 {
10742 thisname = "row-expanded"; 10890 thisname = "row-expanded";
10743 } 10891 }
10744 #else 10892 #else
10745 else if(GTK_IS_TREE(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_CONTEXT) == 0) 10893 else if (GTK_IS_TREE(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_CONTEXT) == 0)
10746 { 10894 {
10747 thisfunc = _findsigfunc("tree-context"); 10895 thisfunc = _findsigfunc("tree-context");
10748 sigid = _set_signal_handler(thiswindow, window, sigfunc, data, thisfunc); 10896 sigid = _set_signal_handler(thiswindow, window, sigfunc, data, thisfunc);
10749 10897
10750 gtk_object_set_data(GTK_OBJECT(thiswindow), "_dw_container_context_func", (gpointer)thisfunc); 10898 gtk_object_set_data(GTK_OBJECT(thiswindow), "_dw_container_context_func", (gpointer)thisfunc);
10751 gtk_object_set_data(GTK_OBJECT(thiswindow), "_dw_container_context_data", (gpointer)sigid); 10899 gtk_object_set_data(GTK_OBJECT(thiswindow), "_dw_container_context_data", GINT_TO_POINTER(sigid));
10752 cid = gtk_signal_connect(GTK_OBJECT(thiswindow), "button_press_event", GTK_SIGNAL_FUNC(thisfunc), (gpointer)sigid); 10900 cid = gtk_signal_connect(GTK_OBJECT(thiswindow), "button_press_event", GTK_SIGNAL_FUNC(thisfunc), (gpointer)sigid);
10753 _set_signal_handler_id(thiswindow, sigid, cid); 10901 _set_signal_handler_id(thiswindow, sigid, cid);
10754 sigid = _set_signal_handler(window, window, sigfunc, data, thisfunc); 10902 sigid = _set_signal_handler(window, window, sigfunc, data, thisfunc);
10755 cid = gtk_signal_connect(GTK_OBJECT(window), "button_press_event", GTK_SIGNAL_FUNC(thisfunc), (gpointer)sigid); 10903 cid = gtk_signal_connect(GTK_OBJECT(window), "button_press_event", GTK_SIGNAL_FUNC(thisfunc), (gpointer)sigid);
10756 _set_signal_handler_id(window, sigid, cid); 10904 _set_signal_handler_id(window, sigid, cid);
10757 DW_MUTEX_UNLOCK; 10905 DW_MUTEX_UNLOCK;
10758 return; 10906 return;
10759 } 10907 }
10760 else if(GTK_IS_TREE(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_SELECT) == 0) 10908 else if (GTK_IS_TREE(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_SELECT) == 0)
10761 { 10909 {
10762 if(thisfunc) 10910 if(thisfunc)
10763 { 10911 {
10764 sigid = _set_signal_handler(thiswindow, window, sigfunc, data, thisfunc); 10912 sigid = _set_signal_handler(thiswindow, window, sigfunc, data, thisfunc);
10765 gtk_object_set_data(GTK_OBJECT(thiswindow), "_dw_select_child_func", (gpointer)thisfunc); 10913 gtk_object_set_data(GTK_OBJECT(thiswindow), "_dw_select_child_func", (gpointer)thisfunc);
10766 gtk_object_set_data(GTK_OBJECT(thiswindow), "_dw_select_child_data", (gpointer)sigid); 10914 gtk_object_set_data(GTK_OBJECT(thiswindow), "_dw_select_child_data", GINT_TO_POINTER(sigid));
10767 } 10915 }
10768 thisname = "select-child"; 10916 thisname = "select-child";
10769 } 10917 }
10770 else if(GTK_IS_TREE(thiswindow) && strcmp(signame, DW_SIGNAL_TREE_EXPAND) == 0) 10918 else if (GTK_IS_TREE(thiswindow) && strcmp(signame, DW_SIGNAL_TREE_EXPAND) == 0)
10771 { 10919 {
10772 if(thisfunc) 10920 if(thisfunc)
10773 { 10921 {
10774 sigid = _set_signal_handler(thiswindow, window, sigfunc, data, thisfunc); 10922 sigid = _set_signal_handler(thiswindow, window, sigfunc, data, thisfunc);
10775 gtk_object_set_data(GTK_OBJECT(thiswindow), "_dw_tree_item_expand_func", (gpointer)thisfunc); 10923 gtk_object_set_data(GTK_OBJECT(thiswindow), "_dw_tree_item_expand_func", (gpointer)thisfunc);
10776 gtk_object_set_data(GTK_OBJECT(thiswindow), "_dw_tree_item_expand_data", (gpointer)sigid); 10924 gtk_object_set_data(GTK_OBJECT(thiswindow), "_dw_tree_item_expand_data", GINT_TO_POINTER(sigid));
10777 } 10925 }
10778 DW_MUTEX_UNLOCK; 10926 DW_MUTEX_UNLOCK;
10779 return; 10927 return;
10780 } 10928 }
10781 #endif 10929 #endif
10782 else if(GTK_IS_CLIST(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_ENTER) == 0) 10930 else if (GTK_IS_CLIST(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_ENTER) == 0)
10783 { 10931 {
10784 sigid = _set_signal_handler(thiswindow, window, sigfunc, data, _container_enter_event); 10932 sigid = _set_signal_handler(thiswindow, window, sigfunc, data, _container_enter_event);
10785 cid = gtk_signal_connect(GTK_OBJECT(thiswindow), "key_press_event", GTK_SIGNAL_FUNC(_container_enter_event), (gpointer)sigid); 10933 cid = gtk_signal_connect(GTK_OBJECT(thiswindow), "key_press_event", GTK_SIGNAL_FUNC(_container_enter_event), (gpointer)sigid);
10786 _set_signal_handler_id(thiswindow, sigid, cid); 10934 _set_signal_handler_id(thiswindow, sigid, cid);
10787 10935
10788 thisname = "button_press_event"; 10936 thisname = "button_press_event";
10789 thisfunc = _findsigfunc(DW_SIGNAL_ITEM_ENTER); 10937 thisfunc = _findsigfunc(DW_SIGNAL_ITEM_ENTER);
10790 } 10938 }
10791 else if(GTK_IS_CLIST(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_SELECT) == 0) 10939 else if (GTK_IS_CLIST(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_SELECT) == 0)
10792 { 10940 {
10793 thisname = "select_row"; 10941 thisname = "select_row";
10794 thisfunc = (void *)_container_select_row; 10942 thisfunc = (void *)_container_select_row;
10795 } 10943 }
10796 else if(GTK_IS_COMBO(thiswindow) && strcmp(signame, DW_SIGNAL_LIST_SELECT) == 0) 10944 else if (GTK_IS_COMBO(thiswindow) && strcmp(signame, DW_SIGNAL_LIST_SELECT) == 0)
10797 { 10945 {
10798 thisname = "select_child"; 10946 thisname = "select_child";
10799 thiswindow = GTK_COMBO(thiswindow)->list; 10947 thiswindow = GTK_COMBO(thiswindow)->list;
10800 } 10948 }
10801 else if(GTK_IS_LIST(thiswindow) && strcmp(signame, DW_SIGNAL_LIST_SELECT) == 0) 10949 else if (GTK_IS_LIST(thiswindow) && strcmp(signame, DW_SIGNAL_LIST_SELECT) == 0)
10802 { 10950 {
10803 thisname = "select_child"; 10951 thisname = "select_child";
10804 } 10952 }
10805 else if(strcmp(signame, DW_SIGNAL_SET_FOCUS) == 0) 10953 else if (strcmp(signame, DW_SIGNAL_SET_FOCUS) == 0)
10806 { 10954 {
10807 thisname = "focus-in-event"; 10955 thisname = "focus-in-event";
10808 if(GTK_IS_COMBO(thiswindow)) 10956 if (GTK_IS_COMBO(thiswindow))
10809 thiswindow = GTK_COMBO(thiswindow)->entry; 10957 thiswindow = GTK_COMBO(thiswindow)->entry;
10810 } 10958 }
10811 #if 0 10959 #if 0
10812 else if(strcmp(signame, DW_SIGNAL_LOSE_FOCUS) == 0) 10960 else if (strcmp(signame, DW_SIGNAL_LOSE_FOCUS) == 0)
10813 { 10961 {
10814 thisname = "focus-out-event"; 10962 thisname = "focus-out-event";
10815 if(GTK_IS_COMBO(thiswindow)) 10963 if(GTK_IS_COMBO(thiswindow))
10816 thiswindow = GTK_COMBO(thiswindow)->entry; 10964 thiswindow = GTK_COMBO(thiswindow)->entry;
10817 } 10965 }
10818 #endif 10966 #endif
10819 else if(GTK_IS_VSCALE(thiswindow) || GTK_IS_HSCALE(thiswindow) || 10967 else if (GTK_IS_VSCALE(thiswindow) || GTK_IS_HSCALE(thiswindow) ||
10820 GTK_IS_VSCROLLBAR(thiswindow) || GTK_IS_HSCROLLBAR(thiswindow)) 10968 GTK_IS_VSCROLLBAR(thiswindow) || GTK_IS_HSCROLLBAR(thiswindow))
10821 { 10969 {
10822 thiswindow = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(thiswindow), "_dw_adjustment"); 10970 thiswindow = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(thiswindow), "_dw_adjustment");
10823 } 10971 }
10824 else if(GTK_IS_NOTEBOOK(thiswindow) && strcmp(signame, DW_SIGNAL_SWITCH_PAGE) == 0) 10972 else if (GTK_IS_NOTEBOOK(thiswindow) && strcmp(signame, DW_SIGNAL_SWITCH_PAGE) == 0)
10825 { 10973 {
10826 thisname = "switch-page"; 10974 thisname = "switch-page";
10827 } 10975 }
10828 else if(GTK_IS_CLIST(thiswindow) && strcmp(signame, DW_SIGNAL_COLUMN_CLICK) == 0) 10976 else if (GTK_IS_CLIST(thiswindow) && strcmp(signame, DW_SIGNAL_COLUMN_CLICK) == 0)
10829 { 10977 {
10830 thisname = "click-column"; 10978 thisname = "click-column";
10831 } 10979 }
10832 10980
10833 if(!thisfunc || !thiswindow) 10981 if (!thisfunc || !thiswindow)
10834 { 10982 {
10835 DW_MUTEX_UNLOCK; 10983 DW_MUTEX_UNLOCK;
10836 return; 10984 return;
10837 } 10985 }
10838 10986
10839 sigid = _set_signal_handler(thiswindow, window, sigfunc, data, thisfunc); 10987 sigid = _set_signal_handler(thiswindow, window, sigfunc, data, thisfunc);
10840 cid = gtk_signal_connect(GTK_OBJECT(thiswindow), thisname, GTK_SIGNAL_FUNC(thisfunc),(gpointer)sigid); 10988 cid = gtk_signal_connect(GTK_OBJECT(thiswindow), thisname, GTK_SIGNAL_FUNC(thisfunc),(gpointer)sigid);
10841 _set_signal_handler_id(thiswindow, sigid, cid); 10989 _set_signal_handler_id(thiswindow, sigid, cid);
10842 DW_MUTEX_UNLOCK; 10990 DW_MUTEX_UNLOCK;
10843 } 10991 }
10844 10992
10845 /* 10993 /*
10846 * Removes callbacks for a given window with given name. 10994 * Removes callbacks for a given window with given name.
10847 * Parameters: 10995 * Parameters:
10848 * window: Window handle of callback to be removed. 10996 * window: Window handle of callback to be removed.
10849 */ 10997 */
10850 void dw_signal_disconnect_by_name(HWND window, char *signame) 10998 void dw_signal_disconnect_by_name(HWND window, char *signame)
10851 { 10999 {
10852 HWND thiswindow; 11000 HWND thiswindow;
10853 int z, count; 11001 int z, count;
10854 void *thisfunc; 11002 void *thisfunc;
10855 int _locked_by_me = FALSE; 11003 int _locked_by_me = FALSE;
10856 11004
10857 DW_MUTEX_LOCK; 11005 DW_MUTEX_LOCK;
10858 thiswindow = _find_signal_window(window, signame); 11006 thiswindow = _find_signal_window(window, signame);
10859 count = (int)gtk_object_get_data(GTK_OBJECT(thiswindow), "_dw_sigcounter"); 11007 count = (int)gtk_object_get_data(GTK_OBJECT(thiswindow), "_dw_sigcounter");
10860 thisfunc = _findsigfunc(signame); 11008 thisfunc = _findsigfunc(signame);
10861 11009
10862 for(z=0;z<count;z++) 11010 for(z=0;z<count;z++)
10863 { 11011 {
10864 SignalHandler sh = _get_signal_handler(thiswindow, (gpointer)z); 11012 SignalHandler sh = _get_signal_handler(thiswindow, (gpointer)z);
10865 11013
10866 if(sh.intfunc == thisfunc) 11014 if(sh.intfunc == thisfunc)
10867 _remove_signal_handler(thiswindow, z); 11015 _remove_signal_handler(thiswindow, z);
10868 } 11016 }
10869 DW_MUTEX_UNLOCK; 11017 DW_MUTEX_UNLOCK;
10870 } 11018 }
10871 11019
10872 /* 11020 /*
10873 * Removes all callbacks for a given window. 11021 * Removes all callbacks for a given window.
10874 * Parameters: 11022 * Parameters:
10875 * window: Window handle of callback to be removed. 11023 * window: Window handle of callback to be removed.
10876 */ 11024 */
10877 void dw_signal_disconnect_by_window(HWND window) 11025 void dw_signal_disconnect_by_window(HWND window)
10878 { 11026 {
10879 HWND thiswindow; 11027 HWND thiswindow;
10880 int z, count; 11028 int z, count;
10881 int _locked_by_me = FALSE; 11029 int _locked_by_me = FALSE;
10882 11030
10883 DW_MUTEX_LOCK; 11031 DW_MUTEX_LOCK;
10884 thiswindow = _find_signal_window(window, NULL); 11032 thiswindow = _find_signal_window(window, NULL);
10885 count = (int)gtk_object_get_data(GTK_OBJECT(thiswindow), "_dw_sigcounter"); 11033 count = (int)gtk_object_get_data(GTK_OBJECT(thiswindow), "_dw_sigcounter");
10886 11034
10887 for(z=0;z<count;z++) 11035 for(z=0;z<count;z++)
10888 _remove_signal_handler(thiswindow, z); 11036 _remove_signal_handler(thiswindow, z);
10889 gtk_object_set_data(GTK_OBJECT(thiswindow), "_dw_sigcounter", NULL); 11037 gtk_object_set_data(GTK_OBJECT(thiswindow), "_dw_sigcounter", NULL);
10890 DW_MUTEX_UNLOCK; 11038 DW_MUTEX_UNLOCK;
10891 } 11039 }
10892 11040
10893 /* 11041 /*
10894 * Removes all callbacks for a given window with specified data. 11042 * Removes all callbacks for a given window with specified data.
10895 * Parameters: 11043 * Parameters:
10896 * window: Window handle of callback to be removed. 11044 * window: Window handle of callback to be removed.
10897 * data: Pointer to the data to be compared against. 11045 * data: Pointer to the data to be compared against.
10898 */ 11046 */
10899 void dw_signal_disconnect_by_data(HWND window, void *data) 11047 void dw_signal_disconnect_by_data(HWND window, void *data)
10900 { 11048 {
10901 HWND thiswindow; 11049 HWND thiswindow;
10902 int z, count; 11050 int z, count;
10903 int _locked_by_me = FALSE; 11051 int _locked_by_me = FALSE;
10904 11052
10905 DW_MUTEX_LOCK; 11053 DW_MUTEX_LOCK;
10906 thiswindow = _find_signal_window(window, NULL); 11054 thiswindow = _find_signal_window(window, NULL);
10907 count = (int)gtk_object_get_data(GTK_OBJECT(thiswindow), "_dw_sigcounter"); 11055 count = (int)gtk_object_get_data(GTK_OBJECT(thiswindow), "_dw_sigcounter");
10908 11056
10909 for(z=0;z<count;z++) 11057 for(z=0;z<count;z++)
10910 { 11058 {
10911 SignalHandler sh = _get_signal_handler(thiswindow, (gpointer)z); 11059 SignalHandler sh = _get_signal_handler(thiswindow, (gpointer)z);
10912 11060
10913 if(sh.data == data) 11061 if(sh.data == data)
10914 _remove_signal_handler(thiswindow, z); 11062 _remove_signal_handler(thiswindow, z);
10915 } 11063 }
10916 DW_MUTEX_UNLOCK; 11064 DW_MUTEX_UNLOCK;
10917 } 11065 }