Mercurial > dwindows
comparison gtk/dw.c @ 622:fb59f9eeeecd
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(>kthread, NULL, (void *)_dwthreadstart, (void *)tmp); | 8438 pthread_create(>kthread, 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 } |