Mercurial > dwindows

comparison gtk3/dw.c @ 2626:401a3b9f21ba

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Massive continuation of code style standardization. Only tested on Mac and iOS, may require follow up commits to get things building again as I test on various platforms.
author bsmith@81767d24-ef19-dc11-ae90-00e081727c95
date Sun, 01 Aug 2021 12:17:07 +0000
parents 156ad91481eb
children 650f8b062317
comparison
equal deleted inserted replaced
2625:2e804b4db81e 2626:401a3b9f21ba
72 * bb = 187 = 0.7333 72 * bb = 187 = 0.7333
73 * aa = 170 = 0.6667 73 * aa = 170 = 0.6667
74 * 77 = 119 = 0.4667 74 * 77 = 119 = 0.4667
75 * 00 = 0 = 0.0000 75 * 00 = 0 = 0.0000
76 */ 76 */
77 GdkRGBA _colors[] = 77 GdkRGBA _dw_colors[] =
78 { 78 {
79 { 0.0000, 0.0000, 0.0000, 1.0 }, /* 0 black */ 79 { 0.0000, 0.0000, 0.0000, 1.0 }, /* 0 black */
80 { 0.7333, 0.0000, 0.0000, 1.0 }, /* 1 red */ 80 { 0.7333, 0.0000, 0.0000, 1.0 }, /* 1 red */
81 { 0.0000, 0.7333, 0.0000, 1.0 }, /* 2 green */ 81 { 0.0000, 0.7333, 0.0000, 1.0 }, /* 2 green */
82 { 0.6667, 0.6667, 0.0000, 1.0 }, /* 3 yellow */ 82 { 0.6667, 0.6667, 0.0000, 1.0 }, /* 3 yellow */
96 96
97 /* 97 /*
98 * List those icons that have transparency first 98 * List those icons that have transparency first
99 */ 99 */
100 #define NUM_EXTS 9 100 #define NUM_EXTS 9
101 char *image_exts[NUM_EXTS] = 101 char *_dw_image_exts[NUM_EXTS] =
102 { 102 {
103 ".xpm", 103 ".xpm",
104 ".png", 104 ".png",
105 ".ico", 105 ".ico",
106 ".icns", 106 ".icns",
145 #define _DW_TREE_TYPE_TREE 2 145 #define _DW_TREE_TYPE_TREE 2
146 #define _DW_TREE_TYPE_LISTBOX 3 146 #define _DW_TREE_TYPE_LISTBOX 3
147 #define _DW_TREE_TYPE_COMBOBOX 4 147 #define _DW_TREE_TYPE_COMBOBOX 4
148 148
149 /* Signal forwarder prototypes */ 149 /* Signal forwarder prototypes */
150 static gint _button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data); 150 static gint _dw_button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data);
151 static gint _button_release_event(GtkWidget *widget, GdkEventButton *event, gpointer data); 151 static gint _dw_button_release_event(GtkWidget *widget, GdkEventButton *event, gpointer data);
152 static gint _motion_notify_event(GtkWidget *widget, GdkEventMotion *event, gpointer data); 152 static gint _dw_motion_notify_event(GtkWidget *widget, GdkEventMotion *event, gpointer data);
153 static gint _delete_event(GtkWidget *widget, GdkEvent *event, gpointer data); 153 static gint _dw_delete_event(GtkWidget *widget, GdkEvent *event, gpointer data);
154 static gint _key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data); 154 static gint _dw_key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data);
155 static gint _generic_event(GtkWidget *widget, gpointer data); 155 static gint _dw_generic_event(GtkWidget *widget, gpointer data);
156 static gint _configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer data); 156 static gint _dw_configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer data);
157 static gint _activate_event(GtkWidget *widget, gpointer data); 157 static gint _dw_activate_event(GtkWidget *widget, gpointer data);
158 static gint _container_enter_event(GtkWidget *widget, GdkEventAny *event, gpointer data); 158 static gint _dw_container_enter_event(GtkWidget *widget, GdkEventAny *event, gpointer data);
159 static gint _combobox_select_event(GtkWidget *widget, gpointer data); 159 static gint _dw_combobox_select_event(GtkWidget *widget, gpointer data);
160 static gint _expose_event(GtkWidget *widget, cairo_t *cr, gpointer data); 160 static gint _dw_expose_event(GtkWidget *widget, cairo_t *cr, gpointer data);
161 static gint _set_focus_event(GtkWindow *window, GtkWidget *widget, gpointer data); 161 static gint _dw_set_focus_event(GtkWindow *window, GtkWidget *widget, gpointer data);
162 static gint _tree_context_event(GtkWidget *widget, GdkEventButton *event, gpointer data); 162 static gint _dw_tree_context_event(GtkWidget *widget, GdkEventButton *event, gpointer data);
163 static gint _value_changed_event(GtkWidget *widget, gpointer user_data); 163 static gint _dw_value_changed_event(GtkWidget *widget, gpointer user_data);
164 static gint _tree_select_event(GtkTreeSelection *sel, gpointer data); 164 static gint _dw_tree_select_event(GtkTreeSelection *sel, gpointer data);
165 static gint _tree_expand_event(GtkTreeView *treeview, GtkTreeIter *arg1, GtkTreePath *arg2, gpointer data); 165 static gint _dw_tree_expand_event(GtkTreeView *treeview, GtkTreeIter *arg1, GtkTreePath *arg2, gpointer data);
166 static gint _switch_page_event(GtkNotebook *notebook, GtkWidget *page, guint page_num, gpointer data); 166 static gint _dw_switch_page_event(GtkNotebook *notebook, GtkWidget *page, guint page_num, gpointer data);
167 static gint _column_click_event(GtkWidget *widget, gpointer data); 167 static gint _dw_column_click_event(GtkWidget *widget, gpointer data);
168 static void _html_result_event(GObject *object, GAsyncResult *result, gpointer script_data); 168 static void _dw_html_result_event(GObject *object, GAsyncResult *result, gpointer script_data);
169 #ifdef USE_WEBKIT 169 #ifdef USE_WEBKIT
170 #ifdef USE_WEBKIT2 170 #ifdef USE_WEBKIT2
171 static void _html_changed_event(WebKitWebView *web_view, WebKitLoadEvent load_event, gpointer data); 171 static void _dw_html_changed_event(WebKitWebView *web_view, WebKitLoadEvent load_event, gpointer data);
172 #else 172 #else
173 static void _html_changed_event(WebKitWebView *web_view, WebKitWebFrame *frame, gpointer user_data); 173 static void _dw_html_changed_event(WebKitWebView *web_view, WebKitWebFrame *frame, gpointer user_data);
174 #endif 174 #endif
175 #endif 175 #endif
176 static void _dw_signal_disconnect(gpointer data, GClosure *closure); 176 static void _dw_signal_disconnect(gpointer data, GClosure *closure);
177 177
178 GObject *_DWObject = NULL; 178 GObject *_DWObject = NULL;
186 typedef struct 186 typedef struct
187 { 187 {
188 void *func; 188 void *func;
189 char name[30]; 189 char name[30];
190 190
191 } SignalList; 191 } DWSignalList;
192 192
193 typedef struct 193 typedef struct
194 { 194 {
195 HWND window; 195 HWND window;
196 void *func; 196 void *func;
197 gpointer data; 197 gpointer data;
198 gint cid; 198 gint cid;
199 void *intfunc; 199 void *intfunc;
200 200
201 } SignalHandler; 201 } DWSignalHandler;
202 202
203 #define SIGNALMAX 20 203 #define SIGNALMAX 20
204 204
205 /* A list of signal forwarders, to account for paramater differences. */ 205 /* A list of signal forwarders, to account for paramater differences. */
206 static SignalList SignalTranslate[SIGNALMAX] = { 206 static DWSignalList DWSignalTranslate[SIGNALMAX] = {
207 { _configure_event, DW_SIGNAL_CONFIGURE }, 207 { _dw_configure_event, DW_SIGNAL_CONFIGURE },
208 { _key_press_event, DW_SIGNAL_KEY_PRESS }, 208 { _dw_key_press_event, DW_SIGNAL_KEY_PRESS },
209 { _button_press_event, DW_SIGNAL_BUTTON_PRESS }, 209 { _dw_button_press_event, DW_SIGNAL_BUTTON_PRESS },
210 { _button_release_event, DW_SIGNAL_BUTTON_RELEASE }, 210 { _dw_button_release_event, DW_SIGNAL_BUTTON_RELEASE },
211 { _motion_notify_event, DW_SIGNAL_MOTION_NOTIFY }, 211 { _dw_motion_notify_event, DW_SIGNAL_MOTION_NOTIFY },
212 { _delete_event, DW_SIGNAL_DELETE }, 212 { _dw_delete_event, DW_SIGNAL_DELETE },
213 { _expose_event, DW_SIGNAL_EXPOSE }, 213 { _dw_expose_event, DW_SIGNAL_EXPOSE },
214 { _activate_event, "activate" }, 214 { _dw_activate_event, "activate" },
215 { _generic_event, DW_SIGNAL_CLICKED }, 215 { _dw_generic_event, DW_SIGNAL_CLICKED },
216 { _container_enter_event, DW_SIGNAL_ITEM_ENTER }, 216 { _dw_container_enter_event, DW_SIGNAL_ITEM_ENTER },
217 { _tree_context_event, DW_SIGNAL_ITEM_CONTEXT }, 217 { _dw_tree_context_event, DW_SIGNAL_ITEM_CONTEXT },
218 { _combobox_select_event, DW_SIGNAL_LIST_SELECT }, 218 { _dw_combobox_select_event, DW_SIGNAL_LIST_SELECT },
219 { _tree_select_event, DW_SIGNAL_ITEM_SELECT }, 219 { _dw_tree_select_event, DW_SIGNAL_ITEM_SELECT },
220 { _set_focus_event, DW_SIGNAL_SET_FOCUS }, 220 { _dw_set_focus_event, DW_SIGNAL_SET_FOCUS },
221 { _value_changed_event, DW_SIGNAL_VALUE_CHANGED }, 221 { _dw_value_changed_event, DW_SIGNAL_VALUE_CHANGED },
222 { _switch_page_event, DW_SIGNAL_SWITCH_PAGE }, 222 { _dw_switch_page_event, DW_SIGNAL_SWITCH_PAGE },
223 { _column_click_event, DW_SIGNAL_COLUMN_CLICK }, 223 { _dw_column_click_event, DW_SIGNAL_COLUMN_CLICK },
224 { _tree_expand_event, DW_SIGNAL_TREE_EXPAND }, 224 { _dw_tree_expand_event, DW_SIGNAL_TREE_EXPAND },
225 #ifdef USE_WEBKIT 225 #ifdef USE_WEBKIT
226 { _html_changed_event, DW_SIGNAL_HTML_CHANGED }, 226 { _dw_html_changed_event, DW_SIGNAL_HTML_CHANGED },
227 #else 227 #else
228 { _generic_event, DW_SIGNAL_HTML_CHANGED }, 228 { _dw_generic_event, DW_SIGNAL_HTML_CHANGED },
229 #endif 229 #endif
230 { _html_result_event, DW_SIGNAL_HTML_RESULT } 230 { _dw_html_result_event, DW_SIGNAL_HTML_RESULT }
231 }; 231 };
232 232
233 /* Alignment flags */ 233 /* Alignment flags */
234 #define DW_CENTER 0.5f 234 #define DW_CENTER 0.5f
235 #define DW_LEFT 0.0f 235 #define DW_LEFT 0.0f
310 static gboolean gtk_mdi_draw(GtkWidget *widget, cairo_t *cr); 310 static gboolean gtk_mdi_draw(GtkWidget *widget, cairo_t *cr);
311 static void gtk_mdi_get_preferred_width (GtkWidget *widget, gint *minimum_width, gint *natural_width); 311 static void gtk_mdi_get_preferred_width (GtkWidget *widget, gint *minimum_width, gint *natural_width);
312 static void gtk_mdi_get_preferred_height (GtkWidget *widget, gint *minimum_height, gint *natural_height); 312 static void gtk_mdi_get_preferred_height (GtkWidget *widget, gint *minimum_height, gint *natural_height);
313 313
314 /* Callbacks */ 314 /* Callbacks */
315 static gboolean move_child_callback(GtkWidget *widget, GdkEvent *event, gpointer data); 315 static gboolean _dw_mdi_move_child_callback(GtkWidget *widget, GdkEvent *event, gpointer data);
316 static gboolean resize_child_callback(GtkWidget *widget, GdkEvent *event, gpointer data); 316 static gboolean _dw_mdi_resize_child_callback(GtkWidget *widget, GdkEvent *event, gpointer data);
317 static gboolean iconify_child_callback(GtkWidget *widget, GdkEvent *event, gpointer data); 317 static gboolean _dw_mdi_iconify_child_callback(GtkWidget *widget, GdkEvent *event, gpointer data);
318 static gboolean maximize_child_callback(GtkWidget *widget, GdkEvent *event, gpointer data); 318 static gboolean _dw_mdi_maximize_child_callback(GtkWidget *widget, GdkEvent *event, gpointer data);
319 static gboolean kill_child_callback(GtkWidget *widget, GdkEvent *event, gpointer data); 319 static gboolean _dw_mdi_kill_child_callback(GtkWidget *widget, GdkEvent *event, gpointer data);
320 320
321 static void gtk_mdi_add(GtkContainer *container, GtkWidget *widget); 321 static void gtk_mdi_add(GtkContainer *container, GtkWidget *widget);
322 static void gtk_mdi_remove_true(GtkContainer *container, GtkWidget *widget); 322 static void gtk_mdi_remove_true(GtkContainer *container, GtkWidget *widget);
323 static void gtk_mdi_forall(GtkContainer *container, gboolean include_internals, GtkCallback callback, gpointer callback_data); 323 static void gtk_mdi_forall(GtkContainer *container, gboolean include_internals, GtkCallback callback, gpointer callback_data);
324 324
325 static GtkMdiChild *get_child(GtkMdi *mdi, GtkWidget * widget); 325 static GtkMdiChild *_dw_mdi_get_child(GtkMdi *mdi, GtkWidget * widget);
326 326
327 static GType gtk_mdi_get_type(void) 327 static GType gtk_mdi_get_type(void)
328 { 328 {
329 static GType mdi_type = 0; 329 static GType mdi_type = 0;
330 330
512 cursor = gdk_cursor_new_for_display (gdk_display_get_default(), GDK_BOTTOM_RIGHT_CORNER); 512 cursor = gdk_cursor_new_for_display (gdk_display_get_default(), GDK_BOTTOM_RIGHT_CORNER);
513 gtk_widget_realize (bottom_event_box); 513 gtk_widget_realize (bottom_event_box);
514 gdk_window_set_cursor (gtk_widget_get_window(bottom_event_box), cursor); 514 gdk_window_set_cursor (gtk_widget_get_window(bottom_event_box), cursor);
515 515
516 g_signal_connect (G_OBJECT (top_event_box), "event", 516 g_signal_connect (G_OBJECT (top_event_box), "event",
517 G_CALLBACK (move_child_callback), 517 G_CALLBACK (_dw_mdi_move_child_callback),
518 child); 518 child);
519 g_signal_connect (G_OBJECT (bottom_event_box), "event", 519 g_signal_connect (G_OBJECT (bottom_event_box), "event",
520 G_CALLBACK (resize_child_callback), 520 G_CALLBACK (_dw_mdi_resize_child_callback),
521 child); 521 child);
522 g_signal_connect (G_OBJECT (button[0]), "button_press_event", 522 g_signal_connect (G_OBJECT (button[0]), "button_press_event",
523 G_CALLBACK (iconify_child_callback), 523 G_CALLBACK (_dw_mdi_iconify_child_callback),
524 child); 524 child);
525 g_signal_connect (G_OBJECT (button[1]), "button_press_event", 525 g_signal_connect (G_OBJECT (button[1]), "button_press_event",
526 G_CALLBACK (maximize_child_callback), 526 G_CALLBACK (_dw_mdi_maximize_child_callback),
527 child); 527 child);
528 g_signal_connect (G_OBJECT (button[2]), "button_press_event", 528 g_signal_connect (G_OBJECT (button[2]), "button_press_event",
529 G_CALLBACK (kill_child_callback), 529 G_CALLBACK (_dw_mdi_kill_child_callback),
530 child); 530 child);
531 } 531 }
532 532
533 static void gtk_mdi_move(GtkMdi *mdi, GtkWidget *widget, gint x, gint y) 533 static void gtk_mdi_move(GtkMdi *mdi, GtkWidget *widget, gint x, gint y)
534 { 534 {
535 GtkMdiChild *child; 535 GtkMdiChild *child;
536 536
537 g_return_if_fail(GTK_IS_MDI(mdi)); 537 g_return_if_fail(GTK_IS_MDI(mdi));
538 g_return_if_fail(GTK_IS_WIDGET(widget)); 538 g_return_if_fail(GTK_IS_WIDGET(widget));
539 539
540 child = get_child(mdi, widget); 540 child = _dw_mdi_get_child(mdi, widget);
541 g_return_if_fail(child); 541 g_return_if_fail(child);
542 542
543 child->x = x; 543 child->x = x;
544 child->y = y; 544 child->y = y;
545 if (gtk_widget_get_visible(widget) && gtk_widget_get_visible(GTK_WIDGET(mdi))) 545 if (gtk_widget_get_visible(widget) && gtk_widget_get_visible(GTK_WIDGET(mdi)))
551 GtkMdiChild *child; 551 GtkMdiChild *child;
552 552
553 g_return_if_fail(GTK_IS_MDI (mdi)); 553 g_return_if_fail(GTK_IS_MDI (mdi));
554 g_return_if_fail(GTK_IS_WIDGET (widget)); 554 g_return_if_fail(GTK_IS_WIDGET (widget));
555 555
556 child = get_child(mdi, widget); 556 child = _dw_mdi_get_child(mdi, widget);
557 g_return_if_fail(child); 557 g_return_if_fail(child);
558 558
559 *x = child->x; 559 *x = child->x;
560 *y = child->y; 560 *y = child->y;
561 } 561 }
565 GtkMdiChild *child; 565 GtkMdiChild *child;
566 566
567 g_return_if_fail (GTK_IS_MDI (mdi)); 567 g_return_if_fail (GTK_IS_MDI (mdi));
568 g_return_if_fail (GTK_IS_WIDGET (widget)); 568 g_return_if_fail (GTK_IS_WIDGET (widget));
569 569
570 child = get_child (mdi, widget); 570 child = _dw_mdi_get_child (mdi, widget);
571 g_return_if_fail (child); 571 g_return_if_fail (child);
572 572
573 child->state = state; 573 child->state = state;
574 if (gtk_widget_get_visible(child->widget) && gtk_widget_get_visible(GTK_WIDGET(mdi))) 574 if (gtk_widget_get_visible(child->widget) && gtk_widget_get_visible(GTK_WIDGET(mdi)))
575 gtk_widget_queue_resize(GTK_WIDGET(child->widget)); 575 gtk_widget_queue_resize(GTK_WIDGET(child->widget));
578 static void gtk_mdi_remove(GtkMdi *mdi, GtkWidget *widget) 578 static void gtk_mdi_remove(GtkMdi *mdi, GtkWidget *widget)
579 { 579 {
580 GtkMdiChild *child; 580 GtkMdiChild *child;
581 581
582 g_return_if_fail (GTK_IS_MDI (mdi)); 582 g_return_if_fail (GTK_IS_MDI (mdi));
583 child = get_child (mdi, widget); 583 child = _dw_mdi_get_child (mdi, widget);
584 g_return_if_fail (child); 584 g_return_if_fail (child);
585 gtk_mdi_remove_true (GTK_CONTAINER (mdi), child->widget); 585 gtk_mdi_remove_true (GTK_CONTAINER (mdi), child->widget);
586 } 586 }
587 587
588 static void gtk_mdi_realize(GtkWidget *widget) 588 static void gtk_mdi_realize(GtkWidget *widget)
830 830
831 (*callback) (child->widget, callback_data); 831 (*callback) (child->widget, callback_data);
832 } 832 }
833 } 833 }
834 834
835 static gboolean move_child_callback(GtkWidget *widget, GdkEvent *event, gpointer data) 835 static gboolean _dw_mdi_move_child_callback(GtkWidget *widget, GdkEvent *event, gpointer data)
836 { 836 {
837 GtkMdi *mdi; 837 GtkMdi *mdi;
838 GtkMdiChild *child; 838 GtkMdiChild *child;
839 839
840 child = (GtkMdiChild *) data; 840 child = (GtkMdiChild *) data;
924 } 924 }
925 925
926 return FALSE; 926 return FALSE;
927 } 927 }
928 928
929 static gboolean resize_child_callback(GtkWidget *widget, GdkEvent *event, gpointer data) 929 static gboolean _dw_mdi_resize_child_callback(GtkWidget *widget, GdkEvent *event, gpointer data)
930 { 930 {
931 GtkMdi *mdi; 931 GtkMdi *mdi;
932 GtkMdiChild *child; 932 GtkMdiChild *child;
933 933
934 child = (GtkMdiChild *) data; 934 child = (GtkMdiChild *) data;
1031 } 1031 }
1032 1032
1033 return FALSE; 1033 return FALSE;
1034 } 1034 }
1035 1035
1036 static gboolean iconify_child_callback (GtkWidget *widget, GdkEvent *event, gpointer data) 1036 static gboolean _dw_mdi_iconify_child_callback (GtkWidget *widget, GdkEvent *event, gpointer data)
1037 { 1037 {
1038 GtkMdiChild *child; 1038 GtkMdiChild *child;
1039 child = (GtkMdiChild *) data; 1039 child = (GtkMdiChild *) data;
1040 if(child->state == CHILD_ICONIFIED) 1040 if(child->state == CHILD_ICONIFIED)
1041 { 1041 {
1048 if(gtk_widget_get_visible(child->widget)) 1048 if(gtk_widget_get_visible(child->widget))
1049 gtk_widget_queue_resize(GTK_WIDGET (child->widget)); 1049 gtk_widget_queue_resize(GTK_WIDGET (child->widget));
1050 return FALSE; 1050 return FALSE;
1051 } 1051 }
1052 1052
1053 static gboolean maximize_child_callback (GtkWidget *widget, GdkEvent * event, gpointer data) 1053 static gboolean _dw_mdi_maximize_child_callback (GtkWidget *widget, GdkEvent * event, gpointer data)
1054 { 1054 {
1055 GtkMdiChild *child; 1055 GtkMdiChild *child;
1056 child = (GtkMdiChild *) data; 1056 child = (GtkMdiChild *) data;
1057 if (child->state == CHILD_MAXIMIZED) 1057 if (child->state == CHILD_MAXIMIZED)
1058 { 1058 {
1065 if(gtk_widget_get_visible(child->widget)) 1065 if(gtk_widget_get_visible(child->widget))
1066 gtk_widget_queue_resize(GTK_WIDGET (child->widget)); 1066 gtk_widget_queue_resize(GTK_WIDGET (child->widget));
1067 return FALSE; 1067 return FALSE;
1068 } 1068 }
1069 1069
1070 static gboolean kill_child_callback (GtkWidget *widget, GdkEvent *event, gpointer data) 1070 static gboolean _dw_mdi_kill_child_callback (GtkWidget *widget, GdkEvent *event, gpointer data)
1071 { 1071 {
1072 GtkMdiChild *child; 1072 GtkMdiChild *child;
1073 GtkMdi *mdi; 1073 GtkMdi *mdi;
1074 1074
1075 child = (GtkMdiChild *) data; 1075 child = (GtkMdiChild *) data;
1079 1079
1080 gtk_mdi_remove_true (GTK_CONTAINER (mdi), child->widget); 1080 gtk_mdi_remove_true (GTK_CONTAINER (mdi), child->widget);
1081 return FALSE; 1081 return FALSE;
1082 } 1082 }
1083 1083
1084 static GtkMdiChild *get_child (GtkMdi *mdi, GtkWidget *widget) 1084 static GtkMdiChild *_dw_mdi_get_child (GtkMdi *mdi, GtkWidget *widget)
1085 { 1085 {
1086 GList *children; 1086 GList *children;
1087 1087
1088 children = mdi->children; 1088 children = mdi->children;
1089 while (children) 1089 while (children)
1120 usleep(period * 1000); 1120 usleep(period * 1000);
1121 #endif 1121 #endif
1122 } 1122 }
1123 1123
1124 /* Finds the translation function for a given signal name */ 1124 /* Finds the translation function for a given signal name */
1125 static void *_findsigfunc(const char *signame) 1125 static void *_dw_findsigfunc(const char *signame)
1126 { 1126 {
1127 int z; 1127 int z;
1128 1128
1129 for(z=0;z<SIGNALMAX;z++) 1129 for(z=0;z<SIGNALMAX;z++)
1130 { 1130 {
1131 if(strcasecmp(signame, SignalTranslate[z].name) == 0) 1131 if(strcasecmp(signame, DWSignalTranslate[z].name) == 0)
1132 return SignalTranslate[z].func; 1132 return DWSignalTranslate[z].func;
1133 } 1133 }
1134 return NULL; 1134 return NULL;
1135 } 1135 }
1136 1136
1137 static SignalHandler _get_signal_handler(gpointer data) 1137 static DWSignalHandler _dw_get_signal_handler(gpointer data)
1138 { 1138 {
1139 SignalHandler sh = {0}; 1139 DWSignalHandler sh = {0};
1140 1140
1141 if(data) 1141 if(data)
1142 { 1142 {
1143 void **params = (void **)data; 1143 void **params = (void **)data;
1144 int counter = GPOINTER_TO_INT(params[0]); 1144 int counter = GPOINTER_TO_INT(params[0]);
1157 sh.cid = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), text)); 1157 sh.cid = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), text));
1158 } 1158 }
1159 return sh; 1159 return sh;
1160 } 1160 }
1161 1161
1162 static void _remove_signal_handler(GtkWidget *widget, int counter) 1162 static void _dw_remove_signal_handler(GtkWidget *widget, int counter)
1163 { 1163 {
1164 char text[100]; 1164 char text[100];
1165 gint cid; 1165 gint cid;
1166 1166
1167 sprintf(text, "_dw_sigcid%d", counter); 1167 sprintf(text, "_dw_sigcid%d", counter);
1176 g_object_set_data(G_OBJECT(widget), text, NULL); 1176 g_object_set_data(G_OBJECT(widget), text, NULL);
1177 sprintf(text, "_dw_sigdata%d", counter); 1177 sprintf(text, "_dw_sigdata%d", counter);
1178 g_object_set_data(G_OBJECT(widget), text, NULL); 1178 g_object_set_data(G_OBJECT(widget), text, NULL);
1179 } 1179 }
1180 1180
1181 static int _set_signal_handler(GtkWidget *widget, HWND window, void *func, gpointer data, void *intfunc, void *discfunc) 1181 static int _dw_set_signal_handler(GtkWidget *widget, HWND window, void *func, gpointer data, void *intfunc, void *discfunc)
1182 { 1182 {
1183 int counter = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "_dw_sigcounter")); 1183 int counter = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "_dw_sigcounter"));
1184 char text[100]; 1184 char text[100];
1185 1185
1186 sprintf(text, "_dw_sigwindow%d", counter); 1186 sprintf(text, "_dw_sigwindow%d", counter);
1198 g_object_set_data(G_OBJECT(widget), "_dw_sigcounter", GINT_TO_POINTER(counter)); 1198 g_object_set_data(G_OBJECT(widget), "_dw_sigcounter", GINT_TO_POINTER(counter));
1199 1199
1200 return counter - 1; 1200 return counter - 1;
1201 } 1201 }
1202 1202
1203 static void _set_signal_handler_id(GtkWidget *widget, int counter, gint cid) 1203 static void _dw_set_signal_handler_id(GtkWidget *widget, int counter, gint cid)
1204 { 1204 {
1205 char text[100]; 1205 char text[100];
1206 1206
1207 sprintf(text, "_dw_sigcid%d", counter); 1207 sprintf(text, "_dw_sigcid%d", counter);
1208 g_object_set_data(G_OBJECT(widget), text, GINT_TO_POINTER(cid)); 1208 g_object_set_data(G_OBJECT(widget), text, GINT_TO_POINTER(cid));
1209 } 1209 }
1210 1210
1211 static void _html_result_event(GObject *object, GAsyncResult *result, gpointer script_data) 1211 static void _dw_html_result_event(GObject *object, GAsyncResult *result, gpointer script_data)
1212 { 1212 {
1213 #if USE_WEBKIT2 1213 #if USE_WEBKIT2
1214 pthread_t saved_thread = _dw_thread; 1214 pthread_t saved_thread = _dw_thread;
1215 WebKitJavascriptResult *js_result; 1215 WebKitJavascriptResult *js_result;
1216 #if WEBKIT_CHECK_VERSION(2, 22, 0) 1216 #if WEBKIT_CHECK_VERSION(2, 22, 0)
1225 void *user_data = NULL; 1225 void *user_data = NULL;
1226 1226
1227 _dw_thread = (pthread_t)-1; 1227 _dw_thread = (pthread_t)-1;
1228 if(handlerdata) 1228 if(handlerdata)
1229 { 1229 {
1230 SignalHandler work; 1230 DWSignalHandler work;
1231 void *params[3] = { GINT_TO_POINTER(handlerdata-1), 0, object }; 1231 void *params[3] = { GINT_TO_POINTER(handlerdata-1), 0, object };
1232 1232
1233 work = _get_signal_handler(params); 1233 work = _dw_get_signal_handler(params);
1234 1234
1235 if(work.window) 1235 if(work.window)
1236 { 1236 {
1237 htmlresultfunc = work.func; 1237 htmlresultfunc = work.func;
1238 user_data = work.data; 1238 user_data = work.data;
1288 #endif 1288 #endif
1289 } 1289 }
1290 1290
1291 #ifdef USE_WEBKIT 1291 #ifdef USE_WEBKIT
1292 #ifdef USE_WEBKIT2 1292 #ifdef USE_WEBKIT2
1293 static void _html_changed_event(WebKitWebView *web_view, WebKitLoadEvent load_event, gpointer data) 1293 static void _dw_html_changed_event(WebKitWebView *web_view, WebKitLoadEvent load_event, gpointer data)
1294 { 1294 {
1295 SignalHandler work = _get_signal_handler(data); 1295 DWSignalHandler work = _dw_get_signal_handler(data);
1296 char *location = (char *)webkit_web_view_get_uri(web_view); 1296 char *location = (char *)webkit_web_view_get_uri(web_view);
1297 int status = 0; 1297 int status = 0;
1298 1298
1299 switch (load_event) { 1299 switch (load_event) {
1300 case WEBKIT_LOAD_STARTED: 1300 case WEBKIT_LOAD_STARTED:
1316 1316
1317 htmlchangedfunc(work.window, status, location, work.data); 1317 htmlchangedfunc(work.window, status, location, work.data);
1318 } 1318 }
1319 } 1319 }
1320 #else 1320 #else
1321 static void _html_changed_event(WebKitWebView *web_view, WebKitWebFrame *frame, gpointer data) 1321 static void _dw_html_changed_event(WebKitWebView *web_view, WebKitWebFrame *frame, gpointer data)
1322 { 1322 {
1323 SignalHandler work = _get_signal_handler(data); 1323 DWSignalHandler work = _dw_get_signal_handler(data);
1324 char *location = (char *)webkit_web_view_get_uri(web_view); 1324 char *location = (char *)webkit_web_view_get_uri(web_view);
1325 int status = 0; 1325 int status = 0;
1326 void **params = data; 1326 void **params = data;
1327 1327
1328 if(params) 1328 if(params)
1336 } 1336 }
1337 } 1337 }
1338 #endif 1338 #endif
1339 #endif 1339 #endif
1340 1340
1341 static gint _set_focus_event(GtkWindow *window, GtkWidget *widget, gpointer data) 1341 static gint _dw_set_focus_event(GtkWindow *window, GtkWidget *widget, gpointer data)
1342 { 1342 {
1343 SignalHandler work = _get_signal_handler(data); 1343 DWSignalHandler work = _dw_get_signal_handler(data);
1344 int retval = FALSE; 1344 int retval = FALSE;
1345 1345
1346 if(work.window) 1346 if(work.window)
1347 { 1347 {
1348 int (*setfocusfunc)(HWND, void *) = work.func; 1348 int (*setfocusfunc)(HWND, void *) = work.func;
1350 retval = setfocusfunc(work.window, work.data); 1350 retval = setfocusfunc(work.window, work.data);
1351 } 1351 }
1352 return retval; 1352 return retval;
1353 } 1353 }
1354 1354
1355 static gint _button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data) 1355 static gint _dw_button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
1356 { 1356 {
1357 SignalHandler work = _get_signal_handler(data); 1357 DWSignalHandler work = _dw_get_signal_handler(data);
1358 int retval = FALSE; 1358 int retval = FALSE;
1359 1359
1360 if(work.window) 1360 if(work.window)
1361 { 1361 {
1362 int (*buttonfunc)(HWND, int, int, int, void *) = work.func; 1362 int (*buttonfunc)(HWND, int, int, int, void *) = work.func;
1370 retval = buttonfunc(work.window, event->x, event->y, mybutton, work.data); 1370 retval = buttonfunc(work.window, event->x, event->y, mybutton, work.data);
1371 } 1371 }
1372 return retval; 1372 return retval;
1373 } 1373 }
1374 1374
1375 static gint _button_release_event(GtkWidget *widget, GdkEventButton *event, gpointer data) 1375 static gint _dw_button_release_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
1376 { 1376 {
1377 SignalHandler work = _get_signal_handler(data); 1377 DWSignalHandler work = _dw_get_signal_handler(data);
1378 int retval = FALSE; 1378 int retval = FALSE;
1379 1379
1380 if(work.window) 1380 if(work.window)
1381 { 1381 {
1382 int (*buttonfunc)(HWND, int, int, int, void *) = work.func; 1382 int (*buttonfunc)(HWND, int, int, int, void *) = work.func;
1390 retval = buttonfunc(work.window, event->x, event->y, mybutton, work.data); 1390 retval = buttonfunc(work.window, event->x, event->y, mybutton, work.data);
1391 } 1391 }
1392 return retval; 1392 return retval;
1393 } 1393 }
1394 1394
1395 static gint _motion_notify_event(GtkWidget *widget, GdkEventMotion *event, gpointer data) 1395 static gint _dw_motion_notify_event(GtkWidget *widget, GdkEventMotion *event, gpointer data)
1396 { 1396 {
1397 SignalHandler work = _get_signal_handler(data); 1397 DWSignalHandler work = _dw_get_signal_handler(data);
1398 int retval = FALSE; 1398 int retval = FALSE;
1399 1399
1400 if(work.window) 1400 if(work.window)
1401 { 1401 {
1402 int (*motionfunc)(HWND, int, int, int, void *) = work.func; 1402 int (*motionfunc)(HWND, int, int, int, void *) = work.func;
1422 retval = motionfunc(work.window, x, y, keys, work.data); 1422 retval = motionfunc(work.window, x, y, keys, work.data);
1423 } 1423 }
1424 return retval; 1424 return retval;
1425 } 1425 }
1426 1426
1427 static gint _delete_event(GtkWidget *widget, GdkEvent *event, gpointer data) 1427 static gint _dw_delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)
1428 { 1428 {
1429 SignalHandler work = _get_signal_handler(data); 1429 DWSignalHandler work = _dw_get_signal_handler(data);
1430 int retval = FALSE; 1430 int retval = FALSE;
1431 1431
1432 if(work.window) 1432 if(work.window)
1433 { 1433 {
1434 int (*closefunc)(HWND, void *) = work.func; 1434 int (*closefunc)(HWND, void *) = work.func;
1436 retval = closefunc(work.window, work.data); 1436 retval = closefunc(work.window, work.data);
1437 } 1437 }
1438 return retval; 1438 return retval;
1439 } 1439 }
1440 1440
1441 static gint _key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data) 1441 static gint _dw_key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
1442 { 1442 {
1443 SignalHandler work = _get_signal_handler(data); 1443 DWSignalHandler work = _dw_get_signal_handler(data);
1444 int retval = FALSE; 1444 int retval = FALSE;
1445 1445
1446 if(work.window) 1446 if(work.window)
1447 { 1447 {
1448 int (*keypressfunc)(HWND, char, int, int, void *, char *) = work.func; 1448 int (*keypressfunc)(HWND, char, int, int, void *, char *) = work.func;
1455 event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK), work.data, utf8); 1455 event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK), work.data, utf8);
1456 } 1456 }
1457 return retval; 1457 return retval;
1458 } 1458 }
1459 1459
1460 static gint _generic_event(GtkWidget *widget, gpointer data) 1460 static gint _dw_generic_event(GtkWidget *widget, gpointer data)
1461 { 1461 {
1462 SignalHandler work = _get_signal_handler(data); 1462 DWSignalHandler work = _dw_get_signal_handler(data);
1463 int retval = FALSE; 1463 int retval = FALSE;
1464 1464
1465 if(work.window) 1465 if(work.window)
1466 { 1466 {
1467 int (*genericfunc)(HWND, void *) = work.func; 1467 int (*genericfunc)(HWND, void *) = work.func;
1469 retval = genericfunc(work.window, work.data); 1469 retval = genericfunc(work.window, work.data);
1470 } 1470 }
1471 return retval; 1471 return retval;
1472 } 1472 }
1473 1473
1474 static gint _activate_event(GtkWidget *widget, gpointer data) 1474 static gint _dw_activate_event(GtkWidget *widget, gpointer data)
1475 { 1475 {
1476 SignalHandler work = _get_signal_handler(data); 1476 DWSignalHandler work = _dw_get_signal_handler(data);
1477 int retval = FALSE; 1477 int retval = FALSE;
1478 1478
1479 if(work.window && !_dw_ignore_click) 1479 if(work.window && !_dw_ignore_click)
1480 { 1480 {
1481 int (*activatefunc)(HWND, void *) = work.func; 1481 int (*activatefunc)(HWND, void *) = work.func;
1484 _dw_popup = NULL; 1484 _dw_popup = NULL;
1485 } 1485 }
1486 return retval; 1486 return retval;
1487 } 1487 }
1488 1488
1489 static gint _configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer data) 1489 static gint _dw_configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer data)
1490 { 1490 {
1491 SignalHandler work = _get_signal_handler(data); 1491 DWSignalHandler work = _dw_get_signal_handler(data);
1492 int retval = FALSE; 1492 int retval = FALSE;
1493 1493
1494 if(work.window) 1494 if(work.window)
1495 { 1495 {
1496 int (*sizefunc)(HWND, int, int, void *) = work.func; 1496 int (*sizefunc)(HWND, int, int, void *) = work.func;
1498 retval = sizefunc(work.window, event->width, event->height, work.data); 1498 retval = sizefunc(work.window, event->width, event->height, work.data);
1499 } 1499 }
1500 return retval; 1500 return retval;
1501 } 1501 }
1502 1502
1503 static gint _expose_event(GtkWidget *widget, cairo_t *cr, gpointer data) 1503 static gint _dw_expose_event(GtkWidget *widget, cairo_t *cr, gpointer data)
1504 { 1504 {
1505 SignalHandler work = _get_signal_handler(data); 1505 DWSignalHandler work = _dw_get_signal_handler(data);
1506 int retval = FALSE; 1506 int retval = FALSE;
1507 1507
1508 if(work.window) 1508 if(work.window)
1509 { 1509 {
1510 DWExpose exp; 1510 DWExpose exp;
1521 g_object_set_data(G_OBJECT(work.window), "_dw_cr", NULL); 1521 g_object_set_data(G_OBJECT(work.window), "_dw_cr", NULL);
1522 } 1522 }
1523 return retval; 1523 return retval;
1524 } 1524 }
1525 1525
1526 static gint _combobox_select_event(GtkWidget *widget, gpointer data) 1526 static gint _dw_combobox_select_event(GtkWidget *widget, gpointer data)
1527 { 1527 {
1528 SignalHandler work = _get_signal_handler(data); 1528 DWSignalHandler work = _dw_get_signal_handler(data);
1529 int retval = FALSE; 1529 int retval = FALSE;
1530 1530
1531 if(g_object_get_data(G_OBJECT(widget), "_dw_recursing")) 1531 if(g_object_get_data(G_OBJECT(widget), "_dw_recursing"))
1532 return FALSE; 1532 return FALSE;
1533 1533
1567 } 1567 }
1568 1568
1569 #define _DW_DATA_TYPE_STRING 0 1569 #define _DW_DATA_TYPE_STRING 0
1570 #define _DW_DATA_TYPE_POINTER 1 1570 #define _DW_DATA_TYPE_POINTER 1
1571 1571
1572 static gint _tree_context_event(GtkWidget *widget, GdkEventButton *event, gpointer data) 1572 static gint _dw_tree_context_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
1573 { 1573 {
1574 SignalHandler work = _get_signal_handler(data); 1574 DWSignalHandler work = _dw_get_signal_handler(data);
1575 int retval = FALSE; 1575 int retval = FALSE;
1576 1576
1577 if(work.window) 1577 if(work.window)
1578 { 1578 {
1579 if(event->button == 3) 1579 if(event->button == 3)
1631 } 1631 }
1632 } 1632 }
1633 return retval; 1633 return retval;
1634 } 1634 }
1635 1635
1636 static gint _tree_select_event(GtkTreeSelection *sel, gpointer data) 1636 static gint _dw_tree_select_event(GtkTreeSelection *sel, gpointer data)
1637 { 1637 {
1638 GtkWidget *item = NULL, *widget = (GtkWidget *)gtk_tree_selection_get_tree_view(sel); 1638 GtkWidget *item = NULL, *widget = (GtkWidget *)gtk_tree_selection_get_tree_view(sel);
1639 int retval = FALSE; 1639 int retval = FALSE;
1640 1640
1641 if(widget) 1641 if(widget)
1642 { 1642 {
1643 SignalHandler work = _get_signal_handler(data); 1643 DWSignalHandler work = _dw_get_signal_handler(data);
1644 1644
1645 if(work.window) 1645 if(work.window)
1646 { 1646 {
1647 int (*treeselectfunc)(HWND, HTREEITEM, char *, void *, void *) = work.func; 1647 int (*treeselectfunc)(HWND, HTREEITEM, char *, void *, void *) = work.func;
1648 GtkTreeIter iter; 1648 GtkTreeIter iter;
1728 } 1728 }
1729 } 1729 }
1730 return retval; 1730 return retval;
1731 } 1731 }
1732 1732
1733 static gint _tree_expand_event(GtkTreeView *widget, GtkTreeIter *iter, GtkTreePath *path, gpointer data) 1733 static gint _dw_tree_expand_event(GtkTreeView *widget, GtkTreeIter *iter, GtkTreePath *path, gpointer data)
1734 { 1734 {
1735 SignalHandler work = _get_signal_handler(data); 1735 DWSignalHandler work = _dw_get_signal_handler(data);
1736 int retval = FALSE; 1736 int retval = FALSE;
1737 1737
1738 if(!_dw_ignore_expand && work.window) 1738 if(!_dw_ignore_expand && work.window)
1739 { 1739 {
1740 int (*treeexpandfunc)(HWND, HTREEITEM, void *) = work.func; 1740 int (*treeexpandfunc)(HWND, HTREEITEM, void *) = work.func;
1741 retval = treeexpandfunc(work.window, (HTREEITEM)iter, work.data); 1741 retval = treeexpandfunc(work.window, (HTREEITEM)iter, work.data);
1742 } 1742 }
1743 return retval; 1743 return retval;
1744 } 1744 }
1745 1745
1746 static gint _container_enter_event(GtkWidget *widget, GdkEventAny *event, gpointer data) 1746 static gint _dw_container_enter_event(GtkWidget *widget, GdkEventAny *event, gpointer data)
1747 { 1747 {
1748 SignalHandler work = _get_signal_handler(data); 1748 DWSignalHandler work = _dw_get_signal_handler(data);
1749 GdkEventKey *keyevent = (GdkEventKey *)event; 1749 GdkEventKey *keyevent = (GdkEventKey *)event;
1750 GdkEventButton *buttonevent = (GdkEventButton *)event; 1750 GdkEventButton *buttonevent = (GdkEventButton *)event;
1751 int retval = FALSE; 1751 int retval = FALSE;
1752 1752
1753 if(work.window) 1753 if(work.window)
1794 } 1794 }
1795 return retval; 1795 return retval;
1796 } 1796 }
1797 1797
1798 /* Return the logical page id from the physical page id */ 1798 /* Return the logical page id from the physical page id */
1799 int _get_logical_page(HWND handle, unsigned long pageid) 1799 int _dw_get_logical_page(HWND handle, unsigned long pageid)
1800 { 1800 {
1801 int z; 1801 int z;
1802 GtkWidget **pagearray = g_object_get_data(G_OBJECT(handle), "_dw_pagearray"); 1802 GtkWidget **pagearray = g_object_get_data(G_OBJECT(handle), "_dw_pagearray");
1803 GtkWidget *thispage = gtk_notebook_get_nth_page(GTK_NOTEBOOK(handle), pageid); 1803 GtkWidget *thispage = gtk_notebook_get_nth_page(GTK_NOTEBOOK(handle), pageid);
1804 1804
1812 } 1812 }
1813 return 256; 1813 return 256;
1814 } 1814 }
1815 1815
1816 1816
1817 static gint _switch_page_event(GtkNotebook *notebook, GtkWidget *page, guint page_num, gpointer data) 1817 static gint _dw_switch_page_event(GtkNotebook *notebook, GtkWidget *page, guint page_num, gpointer data)
1818 { 1818 {
1819 SignalHandler work = _get_signal_handler(data); 1819 DWSignalHandler work = _dw_get_signal_handler(data);
1820 int retval = FALSE; 1820 int retval = FALSE;
1821 1821
1822 if(work.window) 1822 if(work.window)
1823 { 1823 {
1824 int (*switchpagefunc)(HWND, unsigned long, void *) = work.func; 1824 int (*switchpagefunc)(HWND, unsigned long, void *) = work.func;
1825 retval = switchpagefunc(work.window, _get_logical_page(GTK_WIDGET(notebook), page_num), work.data); 1825 retval = switchpagefunc(work.window, _dw_get_logical_page(GTK_WIDGET(notebook), page_num), work.data);
1826 } 1826 }
1827 return retval; 1827 return retval;
1828 } 1828 }
1829 1829
1830 static gint _column_click_event(GtkWidget *widget, gpointer data) 1830 static gint _dw_column_click_event(GtkWidget *widget, gpointer data)
1831 { 1831 {
1832 void **params = data; 1832 void **params = data;
1833 int retval = FALSE; 1833 int retval = FALSE;
1834 1834
1835 if(params && params[2]) 1835 if(params && params[2])
1837 GtkWidget *tree = (GtkWidget *)params[2]; 1837 GtkWidget *tree = (GtkWidget *)params[2];
1838 gint handlerdata = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(tree), "_dw_column_click_id")); 1838 gint handlerdata = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(tree), "_dw_column_click_id"));
1839 1839
1840 if(handlerdata) 1840 if(handlerdata)
1841 { 1841 {
1842 SignalHandler work; 1842 DWSignalHandler work;
1843 1843
1844 params[0] = GINT_TO_POINTER(handlerdata-1); 1844 params[0] = GINT_TO_POINTER(handlerdata-1);
1845 work = _get_signal_handler(params); 1845 work = _dw_get_signal_handler(params);
1846 1846
1847 if(work.window) 1847 if(work.window)
1848 { 1848 {
1849 int column_num = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "_dw_column")); 1849 int column_num = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "_dw_column"));
1850 int (*clickcolumnfunc)(HWND, int, void *) = work.func; 1850 int (*clickcolumnfunc)(HWND, int, void *) = work.func;
1853 } 1853 }
1854 } 1854 }
1855 return retval; 1855 return retval;
1856 } 1856 }
1857 1857
1858 static int _round_value(gfloat val) 1858 static int _dw_round_value(gfloat val)
1859 { 1859 {
1860 int newval = (int)val; 1860 int newval = (int)val;
1861 1861
1862 if(val >= 0.5 + (gfloat)newval) 1862 if(val >= 0.5 + (gfloat)newval)
1863 newval++; 1863 newval++;
1864 1864
1865 return newval; 1865 return newval;
1866 } 1866 }
1867 1867
1868 static gint _value_changed_event(GtkWidget *widget, gpointer data) 1868 static gint _dw_value_changed_event(GtkWidget *widget, gpointer data)
1869 { 1869 {
1870 GtkWidget *slider, *spinbutton, *scrollbar; 1870 GtkWidget *slider, *spinbutton, *scrollbar;
1871 GtkAdjustment *adjustment = (GtkAdjustment *)widget; 1871 GtkAdjustment *adjustment = (GtkAdjustment *)widget;
1872 int max, val; 1872 int max, val;
1873 1873
1876 1876
1877 slider = (GtkWidget *)g_object_get_data(G_OBJECT(adjustment), "_dw_slider"); 1877 slider = (GtkWidget *)g_object_get_data(G_OBJECT(adjustment), "_dw_slider");
1878 spinbutton = (GtkWidget *)g_object_get_data(G_OBJECT(adjustment), "_dw_spinbutton"); 1878 spinbutton = (GtkWidget *)g_object_get_data(G_OBJECT(adjustment), "_dw_spinbutton");
1879 scrollbar = (GtkWidget *)g_object_get_data(G_OBJECT(adjustment), "_dw_scrollbar"); 1879 scrollbar = (GtkWidget *)g_object_get_data(G_OBJECT(adjustment), "_dw_scrollbar");
1880 1880
1881 max = _round_value(gtk_adjustment_get_upper(adjustment)); 1881 max = _dw_round_value(gtk_adjustment_get_upper(adjustment));
1882 val = _round_value(gtk_adjustment_get_value(adjustment)); 1882 val = _dw_round_value(gtk_adjustment_get_value(adjustment));
1883 1883
1884 if(g_object_get_data(G_OBJECT(adjustment), "_dw_suppress_value_changed_event")) 1884 if(g_object_get_data(G_OBJECT(adjustment), "_dw_suppress_dw_value_changed_event"))
1885 return FALSE; 1885 return FALSE;
1886 1886
1887 if (slider || spinbutton || scrollbar) 1887 if (slider || spinbutton || scrollbar)
1888 { 1888 {
1889 SignalHandler work = _get_signal_handler(data); 1889 DWSignalHandler work = _dw_get_signal_handler(data);
1890 1890
1891 if (work.window) 1891 if (work.window)
1892 { 1892 {
1893 int (*valuechangedfunc)(HWND, int, void *) = work.func; 1893 int (*valuechangedfunc)(HWND, int, void *) = work.func;
1894 1894
1899 } 1899 }
1900 } 1900 }
1901 return FALSE; 1901 return FALSE;
1902 } 1902 }
1903 1903
1904 static gint _default_key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data) 1904 static gint _dw_default_key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
1905 { 1905 {
1906 GtkWidget *next = (GtkWidget *)data; 1906 GtkWidget *next = (GtkWidget *)data;
1907 1907
1908 if(next) 1908 if(next)
1909 { 1909 {
1936 #else 1936 #else
1937 return NULL; 1937 return NULL;
1938 #endif 1938 #endif
1939 } 1939 }
1940 1940
1941 static GdkPixbuf *_find_pixbuf(HICN icon, unsigned long *userwidth, unsigned long *userheight) 1941 static GdkPixbuf *_dw_find_pixbuf(HICN icon, unsigned long *userwidth, unsigned long *userheight)
1942 { 1942 {
1943 unsigned int id = GPOINTER_TO_INT(icon); 1943 unsigned int id = GPOINTER_TO_INT(icon);
1944 GdkPixbuf *icon_pixbuf = NULL; 1944 GdkPixbuf *icon_pixbuf = NULL;
1945 1945
1946 /* Quick dropout for non-handle */ 1946 /* Quick dropout for non-handle */
2698 } 2698 }
2699 2699
2700 /* Convert DW style font to CSS syntax (or Pango for older versions): 2700 /* Convert DW style font to CSS syntax (or Pango for older versions):
2701 * font: font-style font-variant font-weight font-size/line-height font-family 2701 * font: font-style font-variant font-weight font-size/line-height font-family
2702 */ 2702 */
2703 char *_convert_font(const char *font) 2703 char *_dw_convert_font(const char *font)
2704 { 2704 {
2705 char *newfont = NULL; 2705 char *newfont = NULL;
2706 2706
2707 if(font) 2707 if(font)
2708 { 2708 {
2800 * fontname: Name and size of the font in the form "size.fontname" 2800 * fontname: Name and size of the font in the form "size.fontname"
2801 */ 2801 */
2802 int dw_window_set_font(HWND handle, const char *fontname) 2802 int dw_window_set_font(HWND handle, const char *fontname)
2803 { 2803 {
2804 GtkWidget *handle2 = handle; 2804 GtkWidget *handle2 = handle;
2805 char *font = _convert_font(fontname); 2805 char *font = _dw_convert_font(fontname);
2806 int _locked_by_me = FALSE; 2806 int _locked_by_me = FALSE;
2807 gpointer data; 2807 gpointer data;
2808 2808
2809 DW_MUTEX_LOCK; 2809 DW_MUTEX_LOCK;
2810 if(GTK_IS_SCROLLED_WINDOW(handle)) 2810 if(GTK_IS_SCROLLED_WINDOW(handle))
2975 } 2975 }
2976 DW_MUTEX_UNLOCK; 2976 DW_MUTEX_UNLOCK;
2977 return retfont; 2977 return retfont;
2978 } 2978 }
2979 2979
2980 void _free_gdk_colors(HWND handle) 2980 void _dw_free_gdk_colors(HWND handle)
2981 { 2981 {
2982 GdkRGBA *old = (GdkRGBA *)g_object_get_data(G_OBJECT(handle), "_dw_foregdk"); 2982 GdkRGBA *old = (GdkRGBA *)g_object_get_data(G_OBJECT(handle), "_dw_foregdk");
2983 2983
2984 if(old) 2984 if(old)
2985 free(old); 2985 free(old);
2989 if(old) 2989 if(old)
2990 free(old); 2990 free(old);
2991 } 2991 }
2992 2992
2993 /* Free old color pointers and allocate new ones */ 2993 /* Free old color pointers and allocate new ones */
2994 static void _save_gdk_colors(HWND handle, GdkRGBA fore, GdkRGBA back) 2994 static void _dw_save_gdk_colors(HWND handle, GdkRGBA fore, GdkRGBA back)
2995 { 2995 {
2996 GdkRGBA *foregdk = malloc(sizeof(GdkRGBA)); 2996 GdkRGBA *foregdk = malloc(sizeof(GdkRGBA));
2997 GdkRGBA *backgdk = malloc(sizeof(GdkRGBA)); 2997 GdkRGBA *backgdk = malloc(sizeof(GdkRGBA));
2998 2998
2999 _free_gdk_colors(handle); 2999 _dw_free_gdk_colors(handle);
3000 3000
3001 *foregdk = fore; 3001 *foregdk = fore;
3002 *backgdk = back; 3002 *backgdk = back;
3003 3003
3004 g_object_set_data(G_OBJECT(handle), "_dw_foregdk", (gpointer)foregdk); 3004 g_object_set_data(G_OBJECT(handle), "_dw_foregdk", (gpointer)foregdk);
3005 g_object_set_data(G_OBJECT(handle), "_dw_backgdk", (gpointer)backgdk); 3005 g_object_set_data(G_OBJECT(handle), "_dw_backgdk", (gpointer)backgdk);
3006 } 3006 }
3007 3007
3008 static int _set_color(HWND handle, unsigned long fore, unsigned long back) 3008 static int _dw_set_color(HWND handle, unsigned long fore, unsigned long back)
3009 { 3009 {
3010 /* Remember that each color component in X11 use 16 bit no matter 3010 /* Remember that each color component in X11 use 16 bit no matter
3011 * what the destination display supports. (and thus GDK) 3011 * what the destination display supports. (and thus GDK)
3012 */ 3012 */
3013 GdkRGBA forecolor = {0}, backcolor = {0}; 3013 GdkRGBA forecolor = {0}, backcolor = {0};
3018 forecolor.red = (gdouble)DW_RED_VALUE(fore) / 255.0; 3018 forecolor.red = (gdouble)DW_RED_VALUE(fore) / 255.0;
3019 forecolor.green = (gdouble)DW_GREEN_VALUE(fore) / 255.0; 3019 forecolor.green = (gdouble)DW_GREEN_VALUE(fore) / 255.0;
3020 forecolor.blue = (gdouble)DW_BLUE_VALUE(fore) / 255.0; 3020 forecolor.blue = (gdouble)DW_BLUE_VALUE(fore) / 255.0;
3021 } 3021 }
3022 else if(fore != DW_CLR_DEFAULT) 3022 else if(fore != DW_CLR_DEFAULT)
3023 forecolor = _colors[fore]; 3023 forecolor = _dw_colors[fore];
3024 3024
3025 _dw_override_color(handle, "color", fore != DW_CLR_DEFAULT ? &forecolor : NULL); 3025 _dw_override_color(handle, "color", fore != DW_CLR_DEFAULT ? &forecolor : NULL);
3026 3026
3027 if(back & DW_RGB_COLOR) 3027 if(back & DW_RGB_COLOR)
3028 { 3028 {
3030 backcolor.red = (gdouble)DW_RED_VALUE(back) / 255.0; 3030 backcolor.red = (gdouble)DW_RED_VALUE(back) / 255.0;
3031 backcolor.green = (gdouble)DW_GREEN_VALUE(back) / 255.0; 3031 backcolor.green = (gdouble)DW_GREEN_VALUE(back) / 255.0;
3032 backcolor.blue = (gdouble)DW_BLUE_VALUE(back) / 255.0; 3032 backcolor.blue = (gdouble)DW_BLUE_VALUE(back) / 255.0;
3033 } 3033 }
3034 else if(back != DW_CLR_DEFAULT) 3034 else if(back != DW_CLR_DEFAULT)
3035 backcolor = _colors[back]; 3035 backcolor = _dw_colors[back];
3036 3036
3037 _dw_override_color(handle, "background-color", back != DW_CLR_DEFAULT ? &backcolor : NULL); 3037 _dw_override_color(handle, "background-color", back != DW_CLR_DEFAULT ? &backcolor : NULL);
3038 3038
3039 _save_gdk_colors(handle, forecolor, backcolor); 3039 _dw_save_gdk_colors(handle, forecolor, backcolor);
3040 3040
3041 return TRUE; 3041 return TRUE;
3042 } 3042 }
3043 /* 3043 /*
3044 * Sets the colors used by a specified window (widget) handle. 3044 * Sets the colors used by a specified window (widget) handle.
3068 handle2 = tmp; 3068 handle2 = tmp;
3069 fore = DW_CLR_DEFAULT; 3069 fore = DW_CLR_DEFAULT;
3070 } 3070 }
3071 } 3071 }
3072 3072
3073 _set_color(handle2, fore, back); 3073 _dw_set_color(handle2, fore, back);
3074 3074
3075 DW_MUTEX_UNLOCK; 3075 DW_MUTEX_UNLOCK;
3076 return TRUE; 3076 return TRUE;
3077 } 3077 }
3078 3078
3135 GdkCursor *cursor; 3135 GdkCursor *cursor;
3136 3136
3137 DW_MUTEX_LOCK; 3137 DW_MUTEX_LOCK;
3138 if(pointertype > 65535) 3138 if(pointertype > 65535)
3139 { 3139 {
3140 GdkPixbuf *pixbuf = _find_pixbuf(GINT_TO_POINTER(pointertype), NULL, NULL); 3140 GdkPixbuf *pixbuf = _dw_find_pixbuf(GINT_TO_POINTER(pointertype), NULL, NULL);
3141 cursor = gdk_cursor_new_from_pixbuf(gdk_display_get_default(), pixbuf, 8, 8); 3141 cursor = gdk_cursor_new_from_pixbuf(gdk_display_get_default(), pixbuf, 8, 8);
3142 } 3142 }
3143 else if(!pointertype) 3143 else if(!pointertype)
3144 cursor = NULL; 3144 cursor = NULL;
3145 else 3145 else
3340 if ( orient == DW_HORZ ) 3340 if ( orient == DW_HORZ )
3341 adjustment = gtk_scrolled_window_get_hadjustment( GTK_SCROLLED_WINDOW(handle) ); 3341 adjustment = gtk_scrolled_window_get_hadjustment( GTK_SCROLLED_WINDOW(handle) );
3342 else 3342 else
3343 adjustment = gtk_scrolled_window_get_vadjustment( GTK_SCROLLED_WINDOW(handle) ); 3343 adjustment = gtk_scrolled_window_get_vadjustment( GTK_SCROLLED_WINDOW(handle) );
3344 if (adjustment) 3344 if (adjustment)
3345 val = _round_value(gtk_adjustment_get_value(adjustment)); 3345 val = _dw_round_value(gtk_adjustment_get_value(adjustment));
3346 DW_MUTEX_UNLOCK; 3346 DW_MUTEX_UNLOCK;
3347 return val; 3347 return val;
3348 } 3348 }
3349 3349
3350 /* 3350 /*
3366 adjustment = gtk_scrolled_window_get_hadjustment( GTK_SCROLLED_WINDOW(handle) ); 3366 adjustment = gtk_scrolled_window_get_hadjustment( GTK_SCROLLED_WINDOW(handle) );
3367 else 3367 else
3368 adjustment = gtk_scrolled_window_get_vadjustment( GTK_SCROLLED_WINDOW(handle) ); 3368 adjustment = gtk_scrolled_window_get_vadjustment( GTK_SCROLLED_WINDOW(handle) );
3369 if (adjustment) 3369 if (adjustment)
3370 { 3370 {
3371 range = _round_value(gtk_adjustment_get_upper(adjustment)); 3371 range = _dw_round_value(gtk_adjustment_get_upper(adjustment));
3372 } 3372 }
3373 DW_MUTEX_UNLOCK; 3373 DW_MUTEX_UNLOCK;
3374 return range; 3374 return range;
3375 } 3375 }
3376 3376
3547 *menu = NULL; 3547 *menu = NULL;
3548 DW_MUTEX_UNLOCK; 3548 DW_MUTEX_UNLOCK;
3549 } 3549 }
3550 } 3550 }
3551 3551
3552 char _removetilde(char *dest, const char *src) 3552 char _dw_removetilde(char *dest, const char *src)
3553 { 3553 {
3554 int z, cur=0; 3554 int z, cur=0;
3555 char accel = '\0'; 3555 char accel = '\0';
3556 3556
3557 for(z=0;z<strlen(src);z++) 3557 for(z=0;z<strlen(src);z++)
3595 free(tempbuf); 3595 free(tempbuf);
3596 return NULL; 3596 return NULL;
3597 } 3597 }
3598 3598
3599 DW_MUTEX_LOCK; 3599 DW_MUTEX_LOCK;
3600 accel = _removetilde(tempbuf, title); 3600 accel = _dw_removetilde(tempbuf, title);
3601 3601
3602 accel_group = (GtkAccelGroup *)g_object_get_data(G_OBJECT(menu), "_dw_accel"); 3602 accel_group = (GtkAccelGroup *)g_object_get_data(G_OBJECT(menu), "_dw_accel");
3603 submenucount = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menu), "_dw_submenucount")); 3603 submenucount = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menu), "_dw_submenucount"));
3604 3604
3605 if (strlen(tempbuf) == 0) 3605 if (strlen(tempbuf) == 0)
3671 3671
3672 DW_MUTEX_UNLOCK; 3672 DW_MUTEX_UNLOCK;
3673 return tmphandle; 3673 return tmphandle;
3674 } 3674 }
3675 3675
3676 GtkWidget *_find_submenu_id(GtkWidget *start, const char *name) 3676 GtkWidget *_dw_find_submenu_id(GtkWidget *start, const char *name)
3677 { 3677 {
3678 GtkWidget *tmp; 3678 GtkWidget *tmp;
3679 int z, submenucount = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(start), "_dw_submenucount")); 3679 int z, submenucount = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(start), "_dw_submenucount"));
3680 3680
3681 if((tmp = g_object_get_data(G_OBJECT(start), name))) 3681 if((tmp = g_object_get_data(G_OBJECT(start), name)))
3688 3688
3689 snprintf(tempbuf, 100, "_dw_submenu%d", z); 3689 snprintf(tempbuf, 100, "_dw_submenu%d", z);
3690 3690
3691 if((submenu = g_object_get_data(G_OBJECT(start), tempbuf))) 3691 if((submenu = g_object_get_data(G_OBJECT(start), tempbuf)))
3692 { 3692 {
3693 if((menuitem = _find_submenu_id(submenu, name))) 3693 if((menuitem = _dw_find_submenu_id(submenu, name)))
3694 return menuitem; 3694 return menuitem;
3695 } 3695 }
3696 } 3696 }
3697 return NULL; 3697 return NULL;
3698 } 3698 }
3714 if(!menu) 3714 if(!menu)
3715 return; 3715 return;
3716 3716
3717 DW_MUTEX_LOCK; 3717 DW_MUTEX_LOCK;
3718 snprintf(numbuf, 24, "%lu", id); 3718 snprintf(numbuf, 24, "%lu", id);
3719 tmphandle = _find_submenu_id(menu, numbuf); 3719 tmphandle = _dw_find_submenu_id(menu, numbuf);
3720 3720
3721 if(tmphandle) 3721 if(tmphandle)
3722 { 3722 {
3723 _dw_ignore_click = 1; 3723 _dw_ignore_click = 1;
3724 if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(tmphandle)) != check) 3724 if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(tmphandle)) != check)
3745 if(!menu) 3745 if(!menu)
3746 return; 3746 return;
3747 3747
3748 DW_MUTEX_LOCK; 3748 DW_MUTEX_LOCK;
3749 snprintf(numbuf, 24, "%lu", id); 3749 snprintf(numbuf, 24, "%lu", id);
3750 tmphandle = _find_submenu_id(menu, numbuf); 3750 tmphandle = _dw_find_submenu_id(menu, numbuf);
3751 3751
3752 if ( (state & DW_MIS_CHECKED) || (state & DW_MIS_UNCHECKED) ) 3752 if ( (state & DW_MIS_CHECKED) || (state & DW_MIS_UNCHECKED) )
3753 { 3753 {
3754 if ( state & DW_MIS_CHECKED ) 3754 if ( state & DW_MIS_CHECKED )
3755 check = 1; 3755 check = 1;
3797 if(!menu) 3797 if(!menu)
3798 return ret; 3798 return ret;
3799 3799
3800 DW_MUTEX_LOCK; 3800 DW_MUTEX_LOCK;
3801 snprintf(numbuf, 24, "%lu", id); 3801 snprintf(numbuf, 24, "%lu", id);
3802 tmphandle = _find_submenu_id(menu, numbuf); 3802 tmphandle = _dw_find_submenu_id(menu, numbuf);
3803 3803
3804 if(tmphandle) 3804 if(tmphandle)
3805 { 3805 {
3806 gtk_widget_destroy(tmphandle); 3806 gtk_widget_destroy(tmphandle);
3807 g_object_set_data(G_OBJECT(menu), numbuf, NULL); 3807 g_object_set_data(G_OBJECT(menu), numbuf, NULL);
3908 3908
3909 #define _DW_TREE_CONTAINER 1 3909 #define _DW_TREE_CONTAINER 1
3910 #define _DW_TREE_TREE 2 3910 #define _DW_TREE_TREE 2
3911 #define _DW_TREE_LISTBOX 3 3911 #define _DW_TREE_LISTBOX 3
3912 3912
3913 GtkWidget *_tree_create(unsigned long id) 3913 GtkWidget *_dw_tree_create(unsigned long id)
3914 { 3914 {
3915 GtkWidget *tmp; 3915 GtkWidget *tmp;
3916 3916
3917 tmp = gtk_scrolled_window_new(NULL, NULL); 3917 tmp = gtk_scrolled_window_new(NULL, NULL);
3918 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (tmp), 3918 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (tmp),
3921 g_object_set_data(G_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id)); 3921 g_object_set_data(G_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
3922 gtk_widget_show(tmp); 3922 gtk_widget_show(tmp);
3923 return tmp; 3923 return tmp;
3924 } 3924 }
3925 3925
3926 GtkWidget *_tree_setup(GtkWidget *tmp, GtkTreeModel *store) 3926 GtkWidget *_dw_tree_setup(GtkWidget *tmp, GtkTreeModel *store)
3927 { 3927 {
3928 GtkWidget *tree = gtk_tree_view_new_with_model(store); 3928 GtkWidget *tree = gtk_tree_view_new_with_model(store);
3929 gtk_tree_view_set_enable_search(GTK_TREE_VIEW(tree), FALSE); 3929 gtk_tree_view_set_enable_search(GTK_TREE_VIEW(tree), FALSE);
3930 #if GTK_CHECK_VERSION(3,8,0) 3930 #if GTK_CHECK_VERSION(3,8,0)
3931 gtk_container_add(GTK_CONTAINER(tmp), tree); 3931 gtk_container_add(GTK_CONTAINER(tmp), tree);
3946 { 3946 {
3947 GtkWidget *tmp; 3947 GtkWidget *tmp;
3948 int _locked_by_me = FALSE; 3948 int _locked_by_me = FALSE;
3949 3949
3950 DW_MUTEX_LOCK; 3950 DW_MUTEX_LOCK;
3951 if(!(tmp = _tree_create(id))) 3951 if(!(tmp = _dw_tree_create(id)))
3952 { 3952 {
3953 DW_MUTEX_UNLOCK; 3953 DW_MUTEX_UNLOCK;
3954 return 0; 3954 return 0;
3955 } 3955 }
3956 g_object_set_data(G_OBJECT(tmp), "_dw_tree_type", GINT_TO_POINTER(_DW_TREE_TYPE_CONTAINER)); 3956 g_object_set_data(G_OBJECT(tmp), "_dw_tree_type", GINT_TO_POINTER(_DW_TREE_TYPE_CONTAINER));
3973 GtkCellRenderer *rend; 3973 GtkCellRenderer *rend;
3974 GtkTreeSelection *sel; 3974 GtkTreeSelection *sel;
3975 int _locked_by_me = FALSE; 3975 int _locked_by_me = FALSE;
3976 3976
3977 DW_MUTEX_LOCK; 3977 DW_MUTEX_LOCK;
3978 if(!(tmp = _tree_create(id))) 3978 if(!(tmp = _dw_tree_create(id)))
3979 { 3979 {
3980 DW_MUTEX_UNLOCK; 3980 DW_MUTEX_UNLOCK;
3981 return 0; 3981 return 0;
3982 } 3982 }
3983 store = gtk_tree_store_new(4, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_POINTER, G_TYPE_POINTER); 3983 store = gtk_tree_store_new(4, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_POINTER, G_TYPE_POINTER);
3984 tree = _tree_setup(tmp, GTK_TREE_MODEL(store)); 3984 tree = _dw_tree_setup(tmp, GTK_TREE_MODEL(store));
3985 g_object_set_data(G_OBJECT(tmp), "_dw_tree_type", GINT_TO_POINTER(_DW_TREE_TYPE_TREE)); 3985 g_object_set_data(G_OBJECT(tmp), "_dw_tree_type", GINT_TO_POINTER(_DW_TREE_TYPE_TREE));
3986 g_object_set_data(G_OBJECT(tree), "_dw_tree_type", GINT_TO_POINTER(_DW_TREE_TYPE_TREE)); 3986 g_object_set_data(G_OBJECT(tree), "_dw_tree_type", GINT_TO_POINTER(_DW_TREE_TYPE_TREE));
3987 col = gtk_tree_view_column_new(); 3987 col = gtk_tree_view_column_new();
3988 3988
3989 rend = gtk_cell_renderer_pixbuf_new(); 3989 rend = gtk_cell_renderer_pixbuf_new();
4474 GtkCellRenderer *rend; 4474 GtkCellRenderer *rend;
4475 GtkTreeSelection *sel; 4475 GtkTreeSelection *sel;
4476 int _locked_by_me = FALSE; 4476 int _locked_by_me = FALSE;
4477 4477
4478 DW_MUTEX_LOCK; 4478 DW_MUTEX_LOCK;
4479 if(!(tmp = _tree_create(id))) 4479 if(!(tmp = _dw_tree_create(id)))
4480 { 4480 {
4481 DW_MUTEX_UNLOCK; 4481 DW_MUTEX_UNLOCK;
4482 return 0; 4482 return 0;
4483 } 4483 }
4484 store = gtk_list_store_new(1, G_TYPE_STRING); 4484 store = gtk_list_store_new(1, G_TYPE_STRING);
4485 tree = _tree_setup(tmp, GTK_TREE_MODEL(store)); 4485 tree = _dw_tree_setup(tmp, GTK_TREE_MODEL(store));
4486 g_object_set_data(G_OBJECT(tmp), "_dw_tree_type", GINT_TO_POINTER(_DW_TREE_TYPE_LISTBOX)); 4486 g_object_set_data(G_OBJECT(tmp), "_dw_tree_type", GINT_TO_POINTER(_DW_TREE_TYPE_LISTBOX));
4487 g_object_set_data(G_OBJECT(tree), "_dw_tree_type", GINT_TO_POINTER(_DW_TREE_TYPE_LISTBOX)); 4487 g_object_set_data(G_OBJECT(tree), "_dw_tree_type", GINT_TO_POINTER(_DW_TREE_TYPE_LISTBOX));
4488 4488
4489 col = gtk_tree_view_column_new(); 4489 col = gtk_tree_view_column_new();
4490 rend = gtk_cell_renderer_text_new(); 4490 rend = gtk_cell_renderer_text_new();
4521 { 4521 {
4522 GdkPixbuf *icon_pixbuf; 4522 GdkPixbuf *icon_pixbuf;
4523 int _locked_by_me = FALSE; 4523 int _locked_by_me = FALSE;
4524 4524
4525 DW_MUTEX_LOCK; 4525 DW_MUTEX_LOCK;
4526 icon_pixbuf = _find_pixbuf(icon, NULL, NULL); 4526 icon_pixbuf = _dw_find_pixbuf(icon, NULL, NULL);
4527 4527
4528 if(gtk_widget_get_window(handle) && icon_pixbuf) 4528 if(gtk_widget_get_window(handle) && icon_pixbuf)
4529 { 4529 {
4530 GList *list = g_list_append(NULL, icon_pixbuf); 4530 GList *list = g_list_append(NULL, icon_pixbuf);
4531 gdk_window_set_icon_list(gtk_widget_get_window(handle), list); 4531 gdk_window_set_icon_list(gtk_widget_get_window(handle), list);
4554 if(!id && !filename) 4554 if(!id && !filename)
4555 return; 4555 return;
4556 4556
4557 DW_MUTEX_LOCK; 4557 DW_MUTEX_LOCK;
4558 if(id) 4558 if(id)
4559 tmp = _find_pixbuf((HICN)id, NULL, NULL); 4559 tmp = _dw_find_pixbuf((HICN)id, NULL, NULL);
4560 else 4560 else
4561 { 4561 {
4562 char *file = alloca(strlen(filename) + 6); 4562 char *file = alloca(strlen(filename) + 6);
4563 4563
4564 if (!file) 4564 if (!file)
4574 { 4574 {
4575 /* Try with various extentions */ 4575 /* Try with various extentions */
4576 for ( i = 0; i < NUM_EXTS; i++ ) 4576 for ( i = 0; i < NUM_EXTS; i++ )
4577 { 4577 {
4578 strcpy( file, filename ); 4578 strcpy( file, filename );
4579 strcat( file, image_exts[i] ); 4579 strcat( file, _dw_image_exts[i] );
4580 if ( access( file, 04 ) == 0 ) 4580 if ( access( file, 04 ) == 0 )
4581 { 4581 {
4582 found_ext = 1; 4582 found_ext = 1;
4583 break; 4583 break;
4584 } 4584 }
4654 tmp = gdk_pixbuf_new_from_file(template, NULL); 4654 tmp = gdk_pixbuf_new_from_file(template, NULL);
4655 /* remove our temporary file */ 4655 /* remove our temporary file */
4656 unlink(template); 4656 unlink(template);
4657 } 4657 }
4658 else if (id) 4658 else if (id)
4659 tmp = _find_pixbuf((HICN)id, NULL, NULL); 4659 tmp = _dw_find_pixbuf((HICN)id, NULL, NULL);
4660 4660
4661 if(tmp) 4661 if(tmp)
4662 { 4662 {
4663 if(GTK_IS_BUTTON(handle)) 4663 if(GTK_IS_BUTTON(handle))
4664 { 4664 {
5219 5219
5220 DW_MUTEX_LOCK; 5220 DW_MUTEX_LOCK;
5221 adjustment = (GtkAdjustment *)g_object_get_data(G_OBJECT(handle), "_dw_adjustment"); 5221 adjustment = (GtkAdjustment *)g_object_get_data(G_OBJECT(handle), "_dw_adjustment");
5222 if(adjustment) 5222 if(adjustment)
5223 { 5223 {
5224 int max = _round_value(gtk_adjustment_get_upper(adjustment)) - 1; 5224 int max = _dw_round_value(gtk_adjustment_get_upper(adjustment)) - 1;
5225 int thisval = _round_value(gtk_adjustment_get_value(adjustment)); 5225 int thisval = _dw_round_value(gtk_adjustment_get_value(adjustment));
5226 5226
5227 if(gtk_orientable_get_orientation(GTK_ORIENTABLE(handle)) == GTK_ORIENTATION_VERTICAL) 5227 if(gtk_orientable_get_orientation(GTK_ORIENTABLE(handle)) == GTK_ORIENTATION_VERTICAL)
5228 val = max - thisval; 5228 val = max - thisval;
5229 else 5229 else
5230 val = thisval; 5230 val = thisval;
5249 5249
5250 DW_MUTEX_LOCK; 5250 DW_MUTEX_LOCK;
5251 adjustment = (GtkAdjustment *)g_object_get_data(G_OBJECT(handle), "_dw_adjustment"); 5251 adjustment = (GtkAdjustment *)g_object_get_data(G_OBJECT(handle), "_dw_adjustment");
5252 if(adjustment) 5252 if(adjustment)
5253 { 5253 {
5254 int max = _round_value(gtk_adjustment_get_upper(adjustment)) - 1; 5254 int max = _dw_round_value(gtk_adjustment_get_upper(adjustment)) - 1;
5255 5255
5256 if(gtk_orientable_get_orientation(GTK_ORIENTABLE(handle)) == GTK_ORIENTATION_VERTICAL) 5256 if(gtk_orientable_get_orientation(GTK_ORIENTABLE(handle)) == GTK_ORIENTATION_VERTICAL)
5257 gtk_adjustment_set_value(adjustment, (gfloat)(max - position)); 5257 gtk_adjustment_set_value(adjustment, (gfloat)(max - position));
5258 else 5258 else
5259 gtk_adjustment_set_value(adjustment, (gfloat)position); 5259 gtk_adjustment_set_value(adjustment, (gfloat)position);
5275 return 0; 5275 return 0;
5276 5276
5277 DW_MUTEX_LOCK; 5277 DW_MUTEX_LOCK;
5278 adjustment = (GtkAdjustment *)g_object_get_data(G_OBJECT(handle), "_dw_adjustment"); 5278 adjustment = (GtkAdjustment *)g_object_get_data(G_OBJECT(handle), "_dw_adjustment");
5279 if(adjustment) 5279 if(adjustment)
5280 val = _round_value(gtk_adjustment_get_value(adjustment)); 5280 val = _dw_round_value(gtk_adjustment_get_value(adjustment));
5281 DW_MUTEX_UNLOCK; 5281 DW_MUTEX_UNLOCK;
5282 return val; 5282 return val;
5283 } 5283 }
5284 5284
5285 /* 5285 /*
5298 5298
5299 DW_MUTEX_LOCK; 5299 DW_MUTEX_LOCK;
5300 adjustment = (GtkAdjustment *)g_object_get_data(G_OBJECT(handle), "_dw_adjustment"); 5300 adjustment = (GtkAdjustment *)g_object_get_data(G_OBJECT(handle), "_dw_adjustment");
5301 if(adjustment) 5301 if(adjustment)
5302 { 5302 {
5303 g_object_set_data(G_OBJECT(adjustment), "_dw_suppress_value_changed_event", GINT_TO_POINTER(1)); 5303 g_object_set_data(G_OBJECT(adjustment), "_dw_suppress_dw_value_changed_event", GINT_TO_POINTER(1));
5304 gtk_adjustment_set_value(adjustment, (gfloat)position); 5304 gtk_adjustment_set_value(adjustment, (gfloat)position);
5305 g_object_set_data(G_OBJECT(adjustment), "_dw_suppress_value_changed_event", GINT_TO_POINTER(0)); 5305 g_object_set_data(G_OBJECT(adjustment), "_dw_suppress_dw_value_changed_event", GINT_TO_POINTER(0));
5306 } 5306 }
5307 DW_MUTEX_UNLOCK; 5307 DW_MUTEX_UNLOCK;
5308 } 5308 }
5309 5309
5310 /* 5310 /*
5464 && GTK_IS_TREE_VIEW(tree) && 5464 && GTK_IS_TREE_VIEW(tree) &&
5465 (store = (GtkTreeStore *)gtk_tree_view_get_model(GTK_TREE_VIEW(tree)))) 5465 (store = (GtkTreeStore *)gtk_tree_view_get_model(GTK_TREE_VIEW(tree))))
5466 { 5466 {
5467 iter = (GtkTreeIter *)malloc(sizeof(GtkTreeIter)); 5467 iter = (GtkTreeIter *)malloc(sizeof(GtkTreeIter));
5468 5468
5469 pixbuf = _find_pixbuf(icon, NULL, NULL); 5469 pixbuf = _dw_find_pixbuf(icon, NULL, NULL);
5470 5470
5471 gtk_tree_store_insert_after(store, iter, (GtkTreeIter *)parent, (GtkTreeIter *)item); 5471 gtk_tree_store_insert_after(store, iter, (GtkTreeIter *)parent, (GtkTreeIter *)item);
5472 gtk_tree_store_set (store, iter, 0, title, 1, pixbuf, 2, itemdata, 3, iter, -1); 5472 gtk_tree_store_set (store, iter, 0, title, 1, pixbuf, 2, itemdata, 3, iter, -1);
5473 retval = (HTREEITEM)iter; 5473 retval = (HTREEITEM)iter;
5474 } 5474 }
5503 && GTK_IS_TREE_VIEW(tree) && 5503 && GTK_IS_TREE_VIEW(tree) &&
5504 (store = (GtkTreeStore *)gtk_tree_view_get_model(GTK_TREE_VIEW(tree)))) 5504 (store = (GtkTreeStore *)gtk_tree_view_get_model(GTK_TREE_VIEW(tree))))
5505 { 5505 {
5506 iter = (GtkTreeIter *)malloc(sizeof(GtkTreeIter)); 5506 iter = (GtkTreeIter *)malloc(sizeof(GtkTreeIter));
5507 5507
5508 pixbuf = _find_pixbuf(icon, NULL, NULL); 5508 pixbuf = _dw_find_pixbuf(icon, NULL, NULL);
5509 5509
5510 gtk_tree_store_append (store, iter, (GtkTreeIter *)parent); 5510 gtk_tree_store_append (store, iter, (GtkTreeIter *)parent);
5511 gtk_tree_store_set (store, iter, 0, title, 1, pixbuf, 2, itemdata, 3, iter, -1); 5511 gtk_tree_store_set (store, iter, 0, title, 1, pixbuf, 2, itemdata, 3, iter, -1);
5512 retval = (HTREEITEM)iter; 5512 retval = (HTREEITEM)iter;
5513 } 5513 }
5537 DW_MUTEX_LOCK; 5537 DW_MUTEX_LOCK;
5538 if((tree = (GtkWidget *)g_object_get_data(G_OBJECT(handle), "_dw_user")) 5538 if((tree = (GtkWidget *)g_object_get_data(G_OBJECT(handle), "_dw_user"))
5539 && GTK_IS_TREE_VIEW(tree) && 5539 && GTK_IS_TREE_VIEW(tree) &&
5540 (store = (GtkTreeStore *)gtk_tree_view_get_model(GTK_TREE_VIEW(tree)))) 5540 (store = (GtkTreeStore *)gtk_tree_view_get_model(GTK_TREE_VIEW(tree))))
5541 { 5541 {
5542 pixbuf = _find_pixbuf(icon, NULL, NULL); 5542 pixbuf = _dw_find_pixbuf(icon, NULL, NULL);
5543 5543
5544 gtk_tree_store_set(store, (GtkTreeIter *)item, 0, title, 1, pixbuf, -1); 5544 gtk_tree_store_set(store, (GtkTreeIter *)item, 0, title, 1, pixbuf, -1);
5545 } 5545 }
5546 DW_MUTEX_UNLOCK; 5546 DW_MUTEX_UNLOCK;
5547 } 5547 }
5871 array[z+_DW_CONTAINER_STORE_EXTRA+1] = G_TYPE_STRING; 5871 array[z+_DW_CONTAINER_STORE_EXTRA+1] = G_TYPE_STRING;
5872 } 5872 }
5873 } 5873 }
5874 /* Create the store and then the tree */ 5874 /* Create the store and then the tree */
5875 store = gtk_list_store_newv(count + _DW_CONTAINER_STORE_EXTRA + 1, array); 5875 store = gtk_list_store_newv(count + _DW_CONTAINER_STORE_EXTRA + 1, array);
5876 tree = _tree_setup(handle, GTK_TREE_MODEL(store)); 5876 tree = _dw_tree_setup(handle, GTK_TREE_MODEL(store));
5877 g_object_set_data(G_OBJECT(tree), "_dw_tree_type", GINT_TO_POINTER(_DW_TREE_TYPE_CONTAINER)); 5877 g_object_set_data(G_OBJECT(tree), "_dw_tree_type", GINT_TO_POINTER(_DW_TREE_TYPE_CONTAINER));
5878 /* Second loop... create the columns */ 5878 /* Second loop... create the columns */
5879 for(z=0;z<count;z++) 5879 for(z=0;z<count;z++)
5880 { 5880 {
5881 snprintf(numbuf, 24, "_dw_cont_col%d", z); 5881 snprintf(numbuf, 24, "_dw_cont_col%d", z);
5927 gtk_tree_view_column_add_attribute(col, rend, "text", z+_DW_CONTAINER_STORE_EXTRA+1); 5927 gtk_tree_view_column_add_attribute(col, rend, "text", z+_DW_CONTAINER_STORE_EXTRA+1);
5928 gtk_tree_view_column_set_resizable(col, TRUE); 5928 gtk_tree_view_column_set_resizable(col, TRUE);
5929 } 5929 }
5930 g_object_set_data(G_OBJECT(col), "_dw_column", GINT_TO_POINTER(z)); 5930 g_object_set_data(G_OBJECT(col), "_dw_column", GINT_TO_POINTER(z));
5931 params[2] = tree; 5931 params[2] = tree;
5932 g_signal_connect_data(G_OBJECT(col), "clicked", G_CALLBACK(_column_click_event), (gpointer)params, _dw_signal_disconnect, 0); 5932 g_signal_connect_data(G_OBJECT(col), "clicked", G_CALLBACK(_dw_column_click_event), (gpointer)params, _dw_signal_disconnect, 0);
5933 gtk_tree_view_column_set_title(col, titles[z]); 5933 gtk_tree_view_column_set_title(col, titles[z]);
5934 if(flags[z] & DW_CFA_RIGHT) 5934 if(flags[z] & DW_CFA_RIGHT)
5935 { 5935 {
5936 gtk_tree_view_column_set_alignment(col, 1.0); 5936 gtk_tree_view_column_set_alignment(col, 1.0);
5937 if(rend) 5937 if(rend)
6081 { 6081 {
6082 /* Try with various extentions */ 6082 /* Try with various extentions */
6083 for ( i = 0; i < NUM_EXTS; i++ ) 6083 for ( i = 0; i < NUM_EXTS; i++ )
6084 { 6084 {
6085 strcpy( file, filename ); 6085 strcpy( file, filename );
6086 strcat( file, image_exts[i] ); 6086 strcat( file, _dw_image_exts[i] );
6087 if ( access( file, 04 ) == 0 ) 6087 if ( access( file, 04 ) == 0 )
6088 { 6088 {
6089 found_ext = 1; 6089 found_ext = 1;
6090 break; 6090 break;
6091 } 6091 }
6220 if(flag & DW_CFA_STRINGANDICON) 6220 if(flag & DW_CFA_STRINGANDICON)
6221 { 6221 {
6222 void **thisdata = (void **)data; 6222 void **thisdata = (void **)data;
6223 HICN hicon = data ? *((HICN *)thisdata[0]) : 0; 6223 HICN hicon = data ? *((HICN *)thisdata[0]) : 0;
6224 char *tmp = data ? (char *)thisdata[1] : NULL; 6224 char *tmp = data ? (char *)thisdata[1] : NULL;
6225 GdkPixbuf *pixbuf = hicon ? _find_pixbuf(hicon, NULL, NULL) : NULL; 6225 GdkPixbuf *pixbuf = hicon ? _dw_find_pixbuf(hicon, NULL, NULL) : NULL;
6226 6226
6227 gtk_list_store_set(store, &iter, _DW_CONTAINER_STORE_EXTRA, pixbuf, -1); 6227 gtk_list_store_set(store, &iter, _DW_CONTAINER_STORE_EXTRA, pixbuf, -1);
6228 gtk_list_store_set(store, &iter, _DW_CONTAINER_STORE_EXTRA + 1, tmp, -1); 6228 gtk_list_store_set(store, &iter, _DW_CONTAINER_STORE_EXTRA + 1, tmp, -1);
6229 } 6229 }
6230 else if(flag & DW_CFA_BITMAPORICON) 6230 else if(flag & DW_CFA_BITMAPORICON)
6231 { 6231 {
6232 HICN hicon = data ? *((HICN *)data) : 0; 6232 HICN hicon = data ? *((HICN *)data) : 0;
6233 GdkPixbuf *pixbuf = hicon ? _find_pixbuf(hicon, NULL, NULL) : NULL; 6233 GdkPixbuf *pixbuf = hicon ? _dw_find_pixbuf(hicon, NULL, NULL) : NULL;
6234 6234
6235 gtk_list_store_set(store, &iter, column + _DW_CONTAINER_STORE_EXTRA + 1, pixbuf, -1); 6235 gtk_list_store_set(store, &iter, column + _DW_CONTAINER_STORE_EXTRA + 1, pixbuf, -1);
6236 } 6236 }
6237 else if(flag & DW_CFA_STRING) 6237 else if(flag & DW_CFA_STRING)
6238 { 6238 {
6885 } 6885 }
6886 DW_MUTEX_UNLOCK; 6886 DW_MUTEX_UNLOCK;
6887 return retval; 6887 return retval;
6888 } 6888 }
6889 6889
6890 int _find_iter(GtkListStore *store, GtkTreeIter *iter, void *data, int textcomp) 6890 int _dw_find_iter(GtkListStore *store, GtkTreeIter *iter, void *data, int textcomp)
6891 { 6891 {
6892 int z, rows = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(store), NULL); 6892 int z, rows = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(store), NULL);
6893 void *thisdata; 6893 void *thisdata;
6894 int retval = FALSE; 6894 int retval = FALSE;
6895 6895
6926 6926
6927 if(store) 6927 if(store)
6928 { 6928 {
6929 GtkTreeIter iter; 6929 GtkTreeIter iter;
6930 6930
6931 if(_find_iter(store, &iter, data, textcomp)) 6931 if(_dw_find_iter(store, &iter, data, textcomp))
6932 { 6932 {
6933 GtkTreePath *path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter); 6933 GtkTreePath *path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter);
6934 6934
6935 if(path) 6935 if(path)
6936 { 6936 {
6980 if(store) 6980 if(store)
6981 { 6981 {
6982 GtkTreeIter iter; 6982 GtkTreeIter iter;
6983 int rows = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(cont), "_dw_rowcount")); 6983 int rows = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(cont), "_dw_rowcount"));
6984 6984
6985 if(_find_iter(store, &iter, data, textcomp)) 6985 if(_dw_find_iter(store, &iter, data, textcomp))
6986 { 6986 {
6987 gtk_list_store_remove(store, &iter); 6987 gtk_list_store_remove(store, &iter);
6988 rows--; 6988 rows--;
6989 } 6989 }
6990 6990
7033 gtk_tree_view_columns_autosize(GTK_TREE_VIEW(cont)); 7033 gtk_tree_view_columns_autosize(GTK_TREE_VIEW(cont));
7034 DW_MUTEX_UNLOCK; 7034 DW_MUTEX_UNLOCK;
7035 } 7035 }
7036 7036
7037 /* Translate the status message into a message on our buddy window */ 7037 /* Translate the status message into a message on our buddy window */
7038 static void _status_translate(GtkStatusIcon *status_icon, guint button, guint activate_time, gpointer user_data) 7038 static void _dw_status_translate(GtkStatusIcon *status_icon, guint button, guint activate_time, gpointer user_data)
7039 { 7039 {
7040 GdkEventButton event = { 0 }; 7040 GdkEventButton event = { 0 };
7041 long x, y; 7041 long x, y;
7042 gboolean retval; 7042 gboolean retval;
7043 7043
7062 GtkStatusIcon *status; 7062 GtkStatusIcon *status;
7063 GdkPixbuf *pixbuf; 7063 GdkPixbuf *pixbuf;
7064 int _locked_by_me = FALSE; 7064 int _locked_by_me = FALSE;
7065 7065
7066 DW_MUTEX_LOCK; 7066 DW_MUTEX_LOCK;
7067 pixbuf = _find_pixbuf(icon, NULL, NULL); 7067 pixbuf = _dw_find_pixbuf(icon, NULL, NULL);
7068 status = gtk_status_icon_new_from_pixbuf(pixbuf); 7068 status = gtk_status_icon_new_from_pixbuf(pixbuf);
7069 if(bubbletext) 7069 if(bubbletext)
7070 gtk_status_icon_set_tooltip_text(status, bubbletext); 7070 gtk_status_icon_set_tooltip_text(status, bubbletext);
7071 g_object_set_data(G_OBJECT(handle), "_dw_taskbar", status); 7071 g_object_set_data(G_OBJECT(handle), "_dw_taskbar", status);
7072 g_signal_connect(G_OBJECT (status), "popup-menu", G_CALLBACK (_status_translate), handle); 7072 g_signal_connect(G_OBJECT (status), "popup-menu", G_CALLBACK (_dw_status_translate), handle);
7073 gtk_status_icon_set_visible(status, TRUE); 7073 gtk_status_icon_set_visible(status, TRUE);
7074 DW_MUTEX_UNLOCK; 7074 DW_MUTEX_UNLOCK;
7075 } 7075 }
7076 7076
7077 /* 7077 /*
7142 gtk_widget_queue_draw(handle); 7142 gtk_widget_queue_draw(handle);
7143 DW_MUTEX_UNLOCK; 7143 DW_MUTEX_UNLOCK;
7144 } 7144 }
7145 7145
7146 /* Returns a GdkRGBA from a DW color */ 7146 /* Returns a GdkRGBA from a DW color */
7147 static GdkRGBA _internal_color(unsigned long value) 7147 static GdkRGBA _dw_internal_color(unsigned long value)
7148 { 7148 {
7149 if(DW_RGB_COLOR & value) 7149 if(DW_RGB_COLOR & value)
7150 { 7150 {
7151 GdkRGBA color = { (gfloat)DW_RED_VALUE(value) / 255.0, (gfloat)DW_GREEN_VALUE(value) / 255.0, (gfloat)DW_BLUE_VALUE(value) / 255.0, 1.0 }; 7151 GdkRGBA color = { (gfloat)DW_RED_VALUE(value) / 255.0, (gfloat)DW_GREEN_VALUE(value) / 255.0, (gfloat)DW_BLUE_VALUE(value) / 255.0, 1.0 };
7152 return color; 7152 return color;
7153 } 7153 }
7154 if (value < 16) 7154 if (value < 16)
7155 return _colors[value]; 7155 return _dw_colors[value];
7156 return _colors[0]; 7156 return _dw_colors[0];
7157 } 7157 }
7158 7158
7159 /* Sets the current foreground drawing color. 7159 /* Sets the current foreground drawing color.
7160 * Parameters: 7160 * Parameters:
7161 * red: red value. 7161 * red: red value.
7162 * green: green value. 7162 * green: green value.
7163 * blue: blue value. 7163 * blue: blue value.
7164 */ 7164 */
7165 void dw_color_foreground_set(unsigned long value) 7165 void dw_color_foreground_set(unsigned long value)
7166 { 7166 {
7167 GdkRGBA color = _internal_color(value); 7167 GdkRGBA color = _dw_internal_color(value);
7168 GdkRGBA *foreground = pthread_getspecific(_dw_fg_color_key); 7168 GdkRGBA *foreground = pthread_getspecific(_dw_fg_color_key);
7169 7169
7170 *foreground = color; 7170 *foreground = color;
7171 } 7171 }
7172 7172
7188 free(background); 7188 free(background);
7189 } 7189 }
7190 } 7190 }
7191 else 7191 else
7192 { 7192 {
7193 GdkRGBA color = _internal_color(value); 7193 GdkRGBA color = _dw_internal_color(value);
7194 7194
7195 if(!background) 7195 if(!background)
7196 { 7196 {
7197 background = malloc(sizeof(GdkRGBA)); 7197 background = malloc(sizeof(GdkRGBA));
7198 pthread_setspecific(_dw_bg_color_key, background); 7198 pthread_setspecific(_dw_bg_color_key, background);
7209 * The selected color or the current color if cancelled. 7209 * The selected color or the current color if cancelled.
7210 */ 7210 */
7211 unsigned long API dw_color_choose(unsigned long value) 7211 unsigned long API dw_color_choose(unsigned long value)
7212 { 7212 {
7213 GtkColorChooser *cd; 7213 GtkColorChooser *cd;
7214 GdkRGBA color = _internal_color(value); 7214 GdkRGBA color = _dw_internal_color(value);
7215 int _locked_by_me = FALSE; 7215 int _locked_by_me = FALSE;
7216 unsigned long retcolor = value; 7216 unsigned long retcolor = value;
7217 7217
7218 DW_MUTEX_LOCK; 7218 DW_MUTEX_LOCK;
7219 cd = (GtkColorChooser *)gtk_color_chooser_dialog_new("Choose color", NULL); 7219 cd = (GtkColorChooser *)gtk_color_chooser_dialog_new("Choose color", NULL);
7233 } 7233 }
7234 #else 7234 #else
7235 static int _dw_color_active = 0; 7235 static int _dw_color_active = 0;
7236 7236
7237 /* Internal function to handle the color OK press */ 7237 /* Internal function to handle the color OK press */
7238 static gint _gtk_color_ok(GtkWidget *widget, DWDialog *dwwait) 7238 static gint _dw_color_ok(GtkWidget *widget, DWDialog *dwwait)
7239 { 7239 {
7240 GdkRGBA color; 7240 GdkRGBA color;
7241 unsigned long dw_color; 7241 unsigned long dw_color;
7242 GtkColorSelection *colorsel; 7242 GtkColorSelection *colorsel;
7243 7243
7252 dw_dialog_dismiss(dwwait, (void *)dw_color); 7252 dw_dialog_dismiss(dwwait, (void *)dw_color);
7253 return FALSE; 7253 return FALSE;
7254 } 7254 }
7255 7255
7256 /* Internal function to handle the color Cancel press */ 7256 /* Internal function to handle the color Cancel press */
7257 static gint _gtk_color_cancel(GtkWidget *widget, DWDialog *dwwait) 7257 static gint _dw_color_cancel(GtkWidget *widget, DWDialog *dwwait)
7258 { 7258 {
7259 if(!dwwait) 7259 if(!dwwait)
7260 return FALSE; 7260 return FALSE;
7261 7261
7262 gtk_widget_destroy(GTK_WIDGET(dwwait->data)); 7262 gtk_widget_destroy(GTK_WIDGET(dwwait->data));
7275 { 7275 {
7276 GtkWidget *colorw, *ok_button, *cancel_button; 7276 GtkWidget *colorw, *ok_button, *cancel_button;
7277 int _locked_by_me = FALSE; 7277 int _locked_by_me = FALSE;
7278 DWDialog *dwwait; 7278 DWDialog *dwwait;
7279 GtkColorSelection *colorsel; 7279 GtkColorSelection *colorsel;
7280 GdkRGBA color = _internal_color(value); 7280 GdkRGBA color = _dw_internal_color(value);
7281 unsigned long dw_color; 7281 unsigned long dw_color;
7282 7282
7283 DW_MUTEX_LOCK; 7283 DW_MUTEX_LOCK;
7284 7284
7285 /* The DW mutex should be sufficient for 7285 /* The DW mutex should be sufficient for
7297 7297
7298 dwwait = dw_dialog_new((void *)colorw); 7298 dwwait = dw_dialog_new((void *)colorw);
7299 7299
7300 colorsel = (GtkColorSelection *)gtk_color_selection_dialog_get_color_selection(GTK_COLOR_SELECTION_DIALOG(colorw)); 7300 colorsel = (GtkColorSelection *)gtk_color_selection_dialog_get_color_selection(GTK_COLOR_SELECTION_DIALOG(colorw));
7301 g_object_get(G_OBJECT(colorw), "ok-button", &ok_button, "cancel-button", &cancel_button, NULL); 7301 g_object_get(G_OBJECT(colorw), "ok-button", &ok_button, "cancel-button", &cancel_button, NULL);
7302 g_signal_connect(G_OBJECT(ok_button), "clicked", G_CALLBACK(_gtk_color_ok), dwwait); 7302 g_signal_connect(G_OBJECT(ok_button), "clicked", G_CALLBACK(_dw_color_ok), dwwait);
7303 g_signal_connect(G_OBJECT(cancel_button), "clicked", G_CALLBACK(_gtk_color_cancel), dwwait); 7303 g_signal_connect(G_OBJECT(cancel_button), "clicked", G_CALLBACK(_dw_color_cancel), dwwait);
7304 7304
7305 gtk_color_selection_set_previous_rgba(colorsel,&color); 7305 gtk_color_selection_set_previous_rgba(colorsel,&color);
7306 gtk_color_selection_set_current_rgba(colorsel,&color); 7306 gtk_color_selection_set_current_rgba(colorsel,&color);
7307 gtk_color_selection_set_has_palette(colorsel,TRUE); 7307 gtk_color_selection_set_has_palette(colorsel,TRUE);
7308 7308
7996 { 7996 {
7997 /* Try with various extentions */ 7997 /* Try with various extentions */
7998 for ( i = 0; i < NUM_EXTS; i++ ) 7998 for ( i = 0; i < NUM_EXTS; i++ )
7999 { 7999 {
8000 strcpy( file, filename ); 8000 strcpy( file, filename );
8001 strcat( file, image_exts[i] ); 8001 strcat( file, _dw_image_exts[i] );
8002 if ( access( file, 04 ) == 0 ) 8002 if ( access( file, 04 ) == 0 )
8003 { 8003 {
8004 found_ext = 1; 8004 found_ext = 1;
8005 break; 8005 break;
8006 } 8006 }
8097 if (!(pixmap = calloc(1,sizeof(struct _hpixmap)))) 8097 if (!(pixmap = calloc(1,sizeof(struct _hpixmap))))
8098 return NULL; 8098 return NULL;
8099 8099
8100 8100
8101 DW_MUTEX_LOCK; 8101 DW_MUTEX_LOCK;
8102 pixmap->pixbuf = gdk_pixbuf_copy(_find_pixbuf((HICN)id, &pixmap->width, &pixmap->height)); 8102 pixmap->pixbuf = gdk_pixbuf_copy(_dw_find_pixbuf((HICN)id, &pixmap->width, &pixmap->height));
8103 DW_MUTEX_UNLOCK; 8103 DW_MUTEX_UNLOCK;
8104 return pixmap; 8104 return pixmap;
8105 } 8105 }
8106 8106
8107 static void _dw_flush_dirty(gpointer widget, gpointer data) 8107 static void _dw_flush_dirty(gpointer widget, gpointer data)
8139 { 8139 {
8140 if(pixmap) 8140 if(pixmap)
8141 { 8141 {
8142 char *oldfont = pixmap->font; 8142 char *oldfont = pixmap->font;
8143 8143
8144 pixmap->font = _convert_font(fontname); 8144 pixmap->font = _dw_convert_font(fontname);
8145 8145
8146 if(oldfont) 8146 if(oldfont)
8147 free(oldfont); 8147 free(oldfont);
8148 return DW_ERROR_NONE; 8148 return DW_ERROR_NONE;
8149 } 8149 }
9130 { 9130 {
9131 exit(exitcode); 9131 exit(exitcode);
9132 } 9132 }
9133 9133
9134 /* Internal function to get the recommended size of scrolled items */ 9134 /* Internal function to get the recommended size of scrolled items */
9135 void _get_scrolled_size(GtkWidget *item, gint *thiswidth, gint *thisheight) 9135 void _dw_get_scrolled_size(GtkWidget *item, gint *thiswidth, gint *thisheight)
9136 { 9136 {
9137 GtkWidget *widget = g_object_get_data(G_OBJECT(item), "_dw_user"); 9137 GtkWidget *widget = g_object_get_data(G_OBJECT(item), "_dw_user");
9138 9138
9139 *thisheight = *thiswidth = 0; 9139 *thisheight = *thiswidth = 0;
9140 9140
9371 { 9371 {
9372 gint scrolledwidth = 0, scrolledheight = 0; 9372 gint scrolledwidth = 0, scrolledheight = 0;
9373 9373
9374 /* Pre-run the calculation code for MLE/Container/Tree if needed */ 9374 /* Pre-run the calculation code for MLE/Container/Tree if needed */
9375 if((width < 1 && !hsize) || (height < 1 && !vsize)) 9375 if((width < 1 && !hsize) || (height < 1 && !vsize))
9376 _get_scrolled_size(item, &scrolledwidth, &scrolledheight); 9376 _dw_get_scrolled_size(item, &scrolledwidth, &scrolledheight);
9377 9377
9378 if(width > 0) 9378 if(width > 0)
9379 gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(item), width); 9379 gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(item), width);
9380 else if(!hsize) 9380 else if(!hsize)
9381 gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(item), scrolledwidth); 9381 gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(item), scrolledwidth);
9638 { 9638 {
9639 _dw_box_pack(box, item, 0, width, height, hsize, vsize, pad, "dw_box_pack_end()"); 9639 _dw_box_pack(box, item, 0, width, height, hsize, vsize, pad, "dw_box_pack_end()");
9640 } 9640 }
9641 9641
9642 9642
9643 union extents_union { guchar **gu_extents; unsigned long **extents; }; 9643 union _dw_extents_union { guchar **gu_extents; unsigned long **extents; };
9644 static GdkAtom extents_atom = 0; 9644 static GdkAtom _dw_extents_atom = 0;
9645 static time_t extents_time = 0; 9645 static time_t _dw_extents_time = 0;
9646 9646
9647 static gboolean _dw_property_notify(GtkWidget *window, GdkEventProperty* event, GdkWindow *gdkwindow) 9647 static gboolean _dw_property_notify(GtkWidget *window, GdkEventProperty* event, GdkWindow *gdkwindow)
9648 { 9648 {
9649 /* Check to see if we got a property change */ 9649 /* Check to see if we got a property change */
9650 if(event->state == GDK_PROPERTY_NEW_VALUE && event->atom == extents_atom && event->window == gdkwindow) 9650 if(event->state == GDK_PROPERTY_NEW_VALUE && event->atom == _dw_extents_atom && event->window == gdkwindow)
9651 extents_time = 0; 9651 _dw_extents_time = 0;
9652 return FALSE; 9652 return FALSE;
9653 } 9653 }
9654 9654
9655 /* Internal function to figure out the frame extents of an unmapped window */ 9655 /* Internal function to figure out the frame extents of an unmapped window */
9656 void _dw_get_frame_extents(GtkWidget *window, int *vert, int *horz) 9656 void _dw_get_frame_extents(GtkWidget *window, int *vert, int *horz)
9657 { 9657 {
9658 if(gtk_window_get_decorated(GTK_WINDOW(window))) 9658 if(gtk_window_get_decorated(GTK_WINDOW(window)))
9659 { 9659 {
9660 const char *request = "_NET_REQUEST_FRAME_EXTENTS"; 9660 const char *request = "_NET_REQUEST_FRAME_EXTENTS";
9661 unsigned long *extents = NULL; 9661 unsigned long *extents = NULL;
9662 union extents_union eu; 9662 union _dw_extents_union eu;
9663 GdkAtom request_extents = gdk_atom_intern(request, FALSE); 9663 GdkAtom request_extents = gdk_atom_intern(request, FALSE);
9664 GdkWindow *gdkwindow = gtk_widget_get_window(window); 9664 GdkWindow *gdkwindow = gtk_widget_get_window(window);
9665 GdkDisplay *display = gtk_widget_get_display(window); 9665 GdkDisplay *display = gtk_widget_get_display(window);
9666 9666
9667 if(!extents_atom) 9667 if(!_dw_extents_atom)
9668 extents_atom = gdk_atom_intern("_NET_FRAME_EXTENTS", FALSE); 9668 _dw_extents_atom = gdk_atom_intern("_NET_FRAME_EXTENTS", FALSE);
9669 9669
9670 /* Set some rational defaults.. just in case */ 9670 /* Set some rational defaults.. just in case */
9671 *vert = 28; 9671 *vert = 28;
9672 *horz = 12; 9672 *horz = 12;
9673 9673
9696 9696
9697 /* Connect a signal to look for the property change */ 9697 /* Connect a signal to look for the property change */
9698 connid = g_signal_connect(G_OBJECT(window), "property_notify_event", G_CALLBACK(_dw_property_notify), gdkwindow); 9698 connid = g_signal_connect(G_OBJECT(window), "property_notify_event", G_CALLBACK(_dw_property_notify), gdkwindow);
9699 9699
9700 /* Record the request time */ 9700 /* Record the request time */
9701 time(&extents_time); 9701 time(&_dw_extents_time);
9702 9702
9703 /* Look for the property notify event */ 9703 /* Look for the property notify event */
9704 do 9704 do
9705 { 9705 {
9706 dw_main_iteration(); 9706 dw_main_iteration();
9707 time(&currtime); 9707 time(&currtime);
9708 } 9708 }
9709 while(currtime - extents_time < 2); 9709 while(currtime - _dw_extents_time < 2);
9710 9710
9711 /* Remove the signal handler now that we are done */ 9711 /* Remove the signal handler now that we are done */
9712 g_signal_handler_disconnect(G_OBJECT(window), connid); 9712 g_signal_handler_disconnect(G_OBJECT(window), connid);
9713 } 9713 }
9714 9714
9715 /* Attempt to retrieve window's frame extents. */ 9715 /* Attempt to retrieve window's frame extents. */
9716 eu.extents = &extents; 9716 eu.extents = &extents;
9717 if(gdk_property_get(gdkwindow, 9717 if(gdk_property_get(gdkwindow,
9718 extents_atom, 9718 _dw_extents_atom,
9719 gdk_atom_intern("CARDINAL", FALSE), 9719 gdk_atom_intern("CARDINAL", FALSE),
9720 0, sizeof(unsigned long)*4, FALSE, 9720 0, sizeof(unsigned long)*4, FALSE,
9721 NULL, NULL, NULL, eu.gu_extents)) 9721 NULL, NULL, NULL, eu.gu_extents))
9722 { 9722 {
9723 *horz = extents[0] + extents[1]; 9723 *horz = extents[0] + extents[1];
9809 DW_MUTEX_LOCK; 9809 DW_MUTEX_LOCK;
9810 if(GTK_IS_SCROLLED_WINDOW(handle)) 9810 if(GTK_IS_SCROLLED_WINDOW(handle))
9811 { 9811 {
9812 gint scrolledwidth, scrolledheight; 9812 gint scrolledwidth, scrolledheight;
9813 9813
9814 _get_scrolled_size(handle, &scrolledwidth, &scrolledheight); 9814 _dw_get_scrolled_size(handle, &scrolledwidth, &scrolledheight);
9815 9815
9816 if(width) 9816 if(width)
9817 *width = scrolledwidth; 9817 *width = scrolledwidth;
9818 if(height) 9818 if(height)
9819 *height = scrolledheight; 9819 *height = scrolledheight;
10304 /* Hopefully this won't happen. */ 10304 /* Hopefully this won't happen. */
10305 return 256; 10305 return 256;
10306 } 10306 }
10307 10307
10308 /* Return the physical page id from the logical page id */ 10308 /* Return the physical page id from the logical page id */
10309 int _get_physical_page(HWND handle, unsigned long pageid) 10309 int _dw_get_physical_page(HWND handle, unsigned long pageid)
10310 { 10310 {
10311 int z; 10311 int z;
10312 GtkWidget *thispage, **pagearray = g_object_get_data(G_OBJECT(handle), "_dw_pagearray"); 10312 GtkWidget *thispage, **pagearray = g_object_get_data(G_OBJECT(handle), "_dw_pagearray");
10313 10313
10314 if(pagearray) 10314 if(pagearray)
10335 { 10335 {
10336 int realpage, _locked_by_me = FALSE; 10336 int realpage, _locked_by_me = FALSE;
10337 GtkWidget **pagearray; 10337 GtkWidget **pagearray;
10338 10338
10339 DW_MUTEX_LOCK; 10339 DW_MUTEX_LOCK;
10340 realpage = _get_physical_page(handle, pageid); 10340 realpage = _dw_get_physical_page(handle, pageid);
10341 if(realpage > -1 && realpage < 256) 10341 if(realpage > -1 && realpage < 256)
10342 { 10342 {
10343 gtk_notebook_remove_page(GTK_NOTEBOOK(handle), realpage); 10343 gtk_notebook_remove_page(GTK_NOTEBOOK(handle), realpage);
10344 if((pagearray = g_object_get_data(G_OBJECT(handle), "_dw_pagearray"))) 10344 if((pagearray = g_object_get_data(G_OBJECT(handle), "_dw_pagearray")))
10345 pagearray[pageid] = NULL; 10345 pagearray[pageid] = NULL;
10357 int retval, phys; 10357 int retval, phys;
10358 int _locked_by_me = FALSE; 10358 int _locked_by_me = FALSE;
10359 10359
10360 DW_MUTEX_LOCK; 10360 DW_MUTEX_LOCK;
10361 phys = gtk_notebook_get_current_page(GTK_NOTEBOOK(handle)); 10361 phys = gtk_notebook_get_current_page(GTK_NOTEBOOK(handle));
10362 retval = _get_logical_page(handle, phys); 10362 retval = _dw_get_logical_page(handle, phys);
10363 DW_MUTEX_UNLOCK; 10363 DW_MUTEX_UNLOCK;
10364 return retval; 10364 return retval;
10365 } 10365 }
10366 10366
10367 /* 10367 /*
10373 void dw_notebook_page_set(HWND handle, unsigned int pageid) 10373 void dw_notebook_page_set(HWND handle, unsigned int pageid)
10374 { 10374 {
10375 int realpage, _locked_by_me = FALSE; 10375 int realpage, _locked_by_me = FALSE;
10376 10376
10377 DW_MUTEX_LOCK; 10377 DW_MUTEX_LOCK;
10378 realpage = _get_physical_page(handle, pageid); 10378 realpage = _dw_get_physical_page(handle, pageid);
10379 if(realpage > -1 && realpage < 256) 10379 if(realpage > -1 && realpage < 256)
10380 gtk_notebook_set_current_page(GTK_NOTEBOOK(handle), pageid); 10380 gtk_notebook_set_current_page(GTK_NOTEBOOK(handle), pageid);
10381 DW_MUTEX_UNLOCK; 10381 DW_MUTEX_UNLOCK;
10382 } 10382 }
10383 10383
10393 { 10393 {
10394 GtkWidget *child; 10394 GtkWidget *child;
10395 int realpage, _locked_by_me = FALSE; 10395 int realpage, _locked_by_me = FALSE;
10396 10396
10397 DW_MUTEX_LOCK; 10397 DW_MUTEX_LOCK;
10398 realpage = _get_physical_page(handle, pageid); 10398 realpage = _dw_get_physical_page(handle, pageid);
10399 if(realpage < 0 || realpage > 255) 10399 if(realpage < 0 || realpage > 255)
10400 { 10400 {
10401 char ptext[101] = {0}; 10401 char ptext[101] = {0};
10402 int num; 10402 int num;
10403 10403
11056 } 11056 }
11057 DW_MUTEX_UNLOCK; 11057 DW_MUTEX_UNLOCK;
11058 } 11058 }
11059 11059
11060 /* Function to do delayed positioning */ 11060 /* Function to do delayed positioning */
11061 gboolean _splitbar_set_percent(gpointer data) 11061 gboolean _dw_splitbar_set_percent(gpointer data)
11062 { 11062 {
11063 GtkWidget *widget = data; 11063 GtkWidget *widget = data;
11064 float *percent = (float *)g_object_get_data(G_OBJECT(widget), "_dw_percent"); 11064 float *percent = (float *)g_object_get_data(G_OBJECT(widget), "_dw_percent");
11065 11065
11066 if(percent) 11066 if(percent)
11078 } 11078 }
11079 return FALSE; 11079 return FALSE;
11080 } 11080 }
11081 11081
11082 /* Reposition the bar according to the percentage */ 11082 /* Reposition the bar according to the percentage */
11083 static gint _splitbar_size_allocate(GtkWidget *widget, GtkAllocation *event, gpointer data) 11083 static gint _dw_splitbar_size_allocate(GtkWidget *widget, GtkAllocation *event, gpointer data)
11084 { 11084 {
11085 float *percent = (float *)g_object_get_data(G_OBJECT(widget), "_dw_percent"); 11085 float *percent = (float *)g_object_get_data(G_OBJECT(widget), "_dw_percent");
11086 11086
11087 /* Prevent infinite recursion ;) */ 11087 /* Prevent infinite recursion ;) */
11088 if(!percent || event->width < 20 || event->height < 20) 11088 if(!percent || event->width < 20 || event->height < 20)
11089 return FALSE; 11089 return FALSE;
11090 11090
11091 g_idle_add(_splitbar_set_percent, widget); 11091 g_idle_add(_dw_splitbar_set_percent, widget);
11092 return FALSE; 11092 return FALSE;
11093 } 11093 }
11094 11094
11095 /* 11095 /*
11096 * Creates a splitbar window (widget) with given parameters. 11096 * Creates a splitbar window (widget) with given parameters.
11112 gtk_paned_pack1(GTK_PANED(tmp), topleft, TRUE, FALSE); 11112 gtk_paned_pack1(GTK_PANED(tmp), topleft, TRUE, FALSE);
11113 gtk_paned_pack2(GTK_PANED(tmp), bottomright, TRUE, FALSE); 11113 gtk_paned_pack2(GTK_PANED(tmp), bottomright, TRUE, FALSE);
11114 g_object_set_data(G_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id)); 11114 g_object_set_data(G_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
11115 *percent = 50.0; 11115 *percent = 50.0;
11116 g_object_set_data(G_OBJECT(tmp), "_dw_percent", (gpointer)percent); 11116 g_object_set_data(G_OBJECT(tmp), "_dw_percent", (gpointer)percent);
11117 g_signal_connect(G_OBJECT(tmp), "size-allocate", G_CALLBACK(_splitbar_size_allocate), NULL); 11117 g_signal_connect(G_OBJECT(tmp), "size-allocate", G_CALLBACK(_dw_splitbar_size_allocate), NULL);
11118 gtk_widget_show(tmp); 11118 gtk_widget_show(tmp);
11119 DW_MUTEX_UNLOCK; 11119 DW_MUTEX_UNLOCK;
11120 return tmp; 11120 return tmp;
11121 } 11121 }
11122 11122
11281 11281
11282 if(!window) 11282 if(!window)
11283 return; 11283 return;
11284 11284
11285 DW_MUTEX_LOCK; 11285 DW_MUTEX_LOCK;
11286 g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(_default_key_press_event), next); 11286 g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(_dw_default_key_press_event), next);
11287 DW_MUTEX_UNLOCK; 11287 DW_MUTEX_UNLOCK;
11288 } 11288 }
11289 11289
11290 11290
11291 /* 11291 /*
11803 WebKitWebView *web_view; 11803 WebKitWebView *web_view;
11804 11804
11805 DW_MUTEX_LOCK; 11805 DW_MUTEX_LOCK;
11806 if((web_view = _dw_html_web_view(handle))) 11806 if((web_view = _dw_html_web_view(handle)))
11807 #ifdef USE_WEBKIT2 11807 #ifdef USE_WEBKIT2
11808 webkit_web_view_run_javascript(web_view, script, NULL, _html_result_event, scriptdata); 11808 webkit_web_view_run_javascript(web_view, script, NULL, _dw_html_result_event, scriptdata);
11809 #else 11809 #else
11810 webkit_web_view_execute_script(web_view, script); 11810 webkit_web_view_execute_script(web_view, script);
11811 #endif 11811 #endif
11812 DW_MUTEX_UNLOCK; 11812 DW_MUTEX_UNLOCK;
11813 return DW_ERROR_NONE; 11813 return DW_ERROR_NONE;
12244 } 12244 }
12245 12245
12246 /* Get the actual signal window handle not the user window handle 12246 /* Get the actual signal window handle not the user window handle
12247 * Should mimic the code in dw_signal_connect() below. 12247 * Should mimic the code in dw_signal_connect() below.
12248 */ 12248 */
12249 static HWND _find_signal_window(HWND window, const char *signame) 12249 static HWND _dw_find_signal_window(HWND window, const char *signame)
12250 { 12250 {
12251 HWND thiswindow = window; 12251 HWND thiswindow = window;
12252 12252
12253 if(GTK_IS_SCROLLED_WINDOW(thiswindow)) 12253 if(GTK_IS_SCROLLED_WINDOW(thiswindow))
12254 thiswindow = (HWND)g_object_get_data(G_OBJECT(window), "_dw_user"); 12254 thiswindow = (HWND)g_object_get_data(G_OBJECT(window), "_dw_user");
12282 void **params = (void **)data; 12282 void **params = (void **)data;
12283 void (*discfunc)(HWND, void *) = params[1]; 12283 void (*discfunc)(HWND, void *) = params[1];
12284 12284
12285 if(discfunc) 12285 if(discfunc)
12286 { 12286 {
12287 SignalHandler work = _get_signal_handler(data); 12287 DWSignalHandler work = _dw_get_signal_handler(data);
12288 12288
12289 if(work.window) 12289 if(work.window)
12290 { 12290 {
12291 discfunc(work.window, work.data); 12291 discfunc(work.window, work.data);
12292 } 12292 }
12306 * discfunc: The pointer to the function called when this handler is removed. 12306 * discfunc: The pointer to the function called when this handler is removed.
12307 * data: User data to be passed to the handler function. 12307 * data: User data to be passed to the handler function.
12308 */ 12308 */
12309 void dw_signal_connect_data(HWND window, const char *signame, void *sigfunc, void *discfunc, void *data) 12309 void dw_signal_connect_data(HWND window, const char *signame, void *sigfunc, void *discfunc, void *data)
12310 { 12310 {
12311 void *thisfunc = _findsigfunc(signame); 12311 void *thisfunc = _dw_findsigfunc(signame);
12312 char *thisname = (char *)signame; 12312 char *thisname = (char *)signame;
12313 HWND thiswindow = window; 12313 HWND thiswindow = window;
12314 int sigid, _locked_by_me = FALSE; 12314 int sigid, _locked_by_me = FALSE;
12315 void **params = calloc(_DW_INTERNAL_CALLBACK_PARAMS, sizeof(void *)); 12315 void **params = calloc(_DW_INTERNAL_CALLBACK_PARAMS, sizeof(void *));
12316 gint cid; 12316 gint cid;
12350 thisname = "draw"; 12350 thisname = "draw";
12351 } 12351 }
12352 else if (GTK_IS_MENU_ITEM(thiswindow) && strcmp(signame, DW_SIGNAL_CLICKED) == 0) 12352 else if (GTK_IS_MENU_ITEM(thiswindow) && strcmp(signame, DW_SIGNAL_CLICKED) == 0)
12353 { 12353 {
12354 thisname = "activate"; 12354 thisname = "activate";
12355 thisfunc = _findsigfunc(thisname); 12355 thisfunc = _dw_findsigfunc(thisname);
12356 } 12356 }
12357 else if (GTK_IS_TREE_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_CONTEXT) == 0) 12357 else if (GTK_IS_TREE_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_CONTEXT) == 0)
12358 { 12358 {
12359 sigid = _set_signal_handler(thiswindow, window, sigfunc, data, thisfunc, discfunc); 12359 sigid = _dw_set_signal_handler(thiswindow, window, sigfunc, data, thisfunc, discfunc);
12360 params[0] = GINT_TO_POINTER(sigid); 12360 params[0] = GINT_TO_POINTER(sigid);
12361 params[2] = (void *)thiswindow; 12361 params[2] = (void *)thiswindow;
12362 cid = g_signal_connect_data(G_OBJECT(thiswindow), "button_press_event", G_CALLBACK(thisfunc), params, _dw_signal_disconnect, 0); 12362 cid = g_signal_connect_data(G_OBJECT(thiswindow), "button_press_event", G_CALLBACK(thisfunc), params, _dw_signal_disconnect, 0);
12363 _set_signal_handler_id(thiswindow, sigid, cid); 12363 _dw_set_signal_handler_id(thiswindow, sigid, cid);
12364 12364
12365 DW_MUTEX_UNLOCK; 12365 DW_MUTEX_UNLOCK;
12366 return; 12366 return;
12367 } 12367 }
12368 else if ((GTK_IS_TREE_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_SELECT) == 0) || 12368 else if ((GTK_IS_TREE_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_SELECT) == 0) ||
12370 { 12370 {
12371 GtkWidget *widget = thiswindow; 12371 GtkWidget *widget = thiswindow;
12372 12372
12373 thisname = "changed"; 12373 thisname = "changed";
12374 12374
12375 sigid = _set_signal_handler(widget, window, sigfunc, data, thisfunc, discfunc); 12375 sigid = _dw_set_signal_handler(widget, window, sigfunc, data, thisfunc, discfunc);
12376 params[0] = GINT_TO_POINTER(sigid); 12376 params[0] = GINT_TO_POINTER(sigid);
12377 params[2] = (void *)thiswindow; 12377 params[2] = (void *)thiswindow;
12378 if(GTK_IS_TREE_VIEW(thiswindow)) 12378 if(GTK_IS_TREE_VIEW(thiswindow))
12379 { 12379 {
12380 thiswindow = (GtkWidget *)gtk_tree_view_get_selection(GTK_TREE_VIEW(thiswindow)); 12380 thiswindow = (GtkWidget *)gtk_tree_view_get_selection(GTK_TREE_VIEW(thiswindow));
12381 cid = g_signal_connect_data(G_OBJECT(thiswindow), thisname, G_CALLBACK(thisfunc), params, _dw_signal_disconnect, 0); 12381 cid = g_signal_connect_data(G_OBJECT(thiswindow), thisname, G_CALLBACK(thisfunc), params, _dw_signal_disconnect, 0);
12382 } 12382 }
12383 else 12383 else
12384 { 12384 {
12385 cid = g_signal_connect_data(G_OBJECT(thiswindow), thisname, G_CALLBACK(_combobox_select_event), params, _dw_signal_disconnect, 0); 12385 cid = g_signal_connect_data(G_OBJECT(thiswindow), thisname, G_CALLBACK(_dw_combobox_select_event), params, _dw_signal_disconnect, 0);
12386 } 12386 }
12387 _set_signal_handler_id(widget, sigid, cid); 12387 _dw_set_signal_handler_id(widget, sigid, cid);
12388 12388
12389 DW_MUTEX_UNLOCK; 12389 DW_MUTEX_UNLOCK;
12390 return; 12390 return;
12391 } 12391 }
12392 else if (GTK_IS_TREE_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_TREE_EXPAND) == 0) 12392 else if (GTK_IS_TREE_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_TREE_EXPAND) == 0)
12393 { 12393 {
12394 thisname = "row-expanded"; 12394 thisname = "row-expanded";
12395 } 12395 }
12396 else if (GTK_IS_TREE_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_ENTER) == 0) 12396 else if (GTK_IS_TREE_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_ITEM_ENTER) == 0)
12397 { 12397 {
12398 sigid = _set_signal_handler(thiswindow, window, sigfunc, data, _container_enter_event, discfunc); 12398 sigid = _dw_set_signal_handler(thiswindow, window, sigfunc, data, _dw_container_enter_event, discfunc);
12399 params[0] = GINT_TO_POINTER(sigid); 12399 params[0] = GINT_TO_POINTER(sigid);
12400 params[2] = (void *)thiswindow; 12400 params[2] = (void *)thiswindow;
12401 cid = g_signal_connect_data(G_OBJECT(thiswindow), "key_press_event", G_CALLBACK(_container_enter_event), params, _dw_signal_disconnect, 0); 12401 cid = g_signal_connect_data(G_OBJECT(thiswindow), "key_press_event", G_CALLBACK(_dw_container_enter_event), params, _dw_signal_disconnect, 0);
12402 _set_signal_handler_id(thiswindow, sigid, cid); 12402 _dw_set_signal_handler_id(thiswindow, sigid, cid);
12403 12403
12404 params = calloc(sizeof(void *), _DW_INTERNAL_CALLBACK_PARAMS); 12404 params = calloc(sizeof(void *), _DW_INTERNAL_CALLBACK_PARAMS);
12405 12405
12406 thisname = "button_press_event"; 12406 thisname = "button_press_event";
12407 thisfunc = _findsigfunc(DW_SIGNAL_ITEM_ENTER); 12407 thisfunc = _dw_findsigfunc(DW_SIGNAL_ITEM_ENTER);
12408 } 12408 }
12409 else if (GTK_IS_TREE_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_COLUMN_CLICK) == 0) 12409 else if (GTK_IS_TREE_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_COLUMN_CLICK) == 0)
12410 { 12410 {
12411 /* We don't actually need a signal handler here... just need to assign the handler ID 12411 /* We don't actually need a signal handler here... just need to assign the handler ID
12412 * Since the handlers for the columns were already created in _dw_container_setup() 12412 * Since the handlers for the columns were already created in _dw_container_setup()
12413 */ 12413 */
12414 sigid = _set_signal_handler(thiswindow, window, sigfunc, data, _column_click_event, discfunc); 12414 sigid = _dw_set_signal_handler(thiswindow, window, sigfunc, data, _dw_column_click_event, discfunc);
12415 g_object_set_data(G_OBJECT(thiswindow), "_dw_column_click_id", GINT_TO_POINTER(sigid+1)); 12415 g_object_set_data(G_OBJECT(thiswindow), "_dw_column_click_id", GINT_TO_POINTER(sigid+1));
12416 DW_MUTEX_UNLOCK; 12416 DW_MUTEX_UNLOCK;
12417 return; 12417 return;
12418 } 12418 }
12419 else if (strcmp(signame, DW_SIGNAL_SET_FOCUS) == 0) 12419 else if (strcmp(signame, DW_SIGNAL_SET_FOCUS) == 0)
12426 else if (WEBKIT_IS_WEB_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_HTML_CHANGED) == 0) 12426 else if (WEBKIT_IS_WEB_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_HTML_CHANGED) == 0)
12427 { 12427 {
12428 #ifdef USE_WEBKIT2 12428 #ifdef USE_WEBKIT2
12429 thisname = "load-changed"; 12429 thisname = "load-changed";
12430 #else 12430 #else
12431 sigid = _set_signal_handler(thiswindow, window, sigfunc, data, thisfunc, discfunc); 12431 sigid = _dw_set_signal_handler(thiswindow, window, sigfunc, data, thisfunc, discfunc);
12432 params[0] = GINT_TO_POINTER(sigid); 12432 params[0] = GINT_TO_POINTER(sigid);
12433 params[2] = (void *)thiswindow; 12433 params[2] = (void *)thiswindow;
12434 params[3] = GINT_TO_POINTER(DW_HTML_CHANGE_STARTED); 12434 params[3] = GINT_TO_POINTER(DW_HTML_CHANGE_STARTED);
12435 cid = g_signal_connect_data(G_OBJECT(thiswindow), "load-started", G_CALLBACK(thisfunc), params, _dw_signal_disconnect, 0); 12435 cid = g_signal_connect_data(G_OBJECT(thiswindow), "load-started", G_CALLBACK(thisfunc), params, _dw_signal_disconnect, 0);
12436 _set_signal_handler_id(thiswindow, sigid, cid); 12436 _dw_set_signal_handler_id(thiswindow, sigid, cid);
12437 12437
12438 params = calloc(sizeof(void *), _DW_INTERNAL_CALLBACK_PARAMS); 12438 params = calloc(sizeof(void *), _DW_INTERNAL_CALLBACK_PARAMS);
12439 12439
12440 sigid = _set_signal_handler(thiswindow, window, sigfunc, data, thisfunc, discfunc); 12440 sigid = _dw_set_signal_handler(thiswindow, window, sigfunc, data, thisfunc, discfunc);
12441 params[0] = GINT_TO_POINTER(sigid); 12441 params[0] = GINT_TO_POINTER(sigid);
12442 params[2] = (void *)thiswindow; 12442 params[2] = (void *)thiswindow;
12443 params[3] = GINT_TO_POINTER(DW_HTML_CHANGE_LOADING); 12443 params[3] = GINT_TO_POINTER(DW_HTML_CHANGE_LOADING);
12444 cid = g_signal_connect_data(G_OBJECT(thiswindow), "load-committed", G_CALLBACK(thisfunc), params, _dw_signal_disconnect, 0); 12444 cid = g_signal_connect_data(G_OBJECT(thiswindow), "load-committed", G_CALLBACK(thisfunc), params, _dw_signal_disconnect, 0);
12445 _set_signal_handler_id(thiswindow, sigid, cid); 12445 _dw_set_signal_handler_id(thiswindow, sigid, cid);
12446 12446
12447 params = calloc(sizeof(void *), _DW_INTERNAL_CALLBACK_PARAMS); 12447 params = calloc(sizeof(void *), _DW_INTERNAL_CALLBACK_PARAMS);
12448 params[3] = GINT_TO_POINTER(DW_HTML_CHANGE_COMPLETE); 12448 params[3] = GINT_TO_POINTER(DW_HTML_CHANGE_COMPLETE);
12449 12449
12450 thisname = "load-finished"; 12450 thisname = "load-finished";
12453 else if (WEBKIT_IS_WEB_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_HTML_RESULT) == 0) 12453 else if (WEBKIT_IS_WEB_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_HTML_RESULT) == 0)
12454 { 12454 {
12455 /* We don't actually need a signal handler here... just need to assign the handler ID 12455 /* We don't actually need a signal handler here... just need to assign the handler ID
12456 * Since the handler is created in dw_html_javasript_run() 12456 * Since the handler is created in dw_html_javasript_run()
12457 */ 12457 */
12458 sigid = _set_signal_handler(thiswindow, window, sigfunc, data, _html_result_event, discfunc); 12458 sigid = _dw_set_signal_handler(thiswindow, window, sigfunc, data, _dw_html_result_event, discfunc);
12459 g_object_set_data(G_OBJECT(thiswindow), "_dw_html_result_id", GINT_TO_POINTER(sigid+1)); 12459 g_object_set_data(G_OBJECT(thiswindow), "_dw_html_result_id", GINT_TO_POINTER(sigid+1));
12460 #ifndef USE_WEBKIT2 12460 #ifndef USE_WEBKIT2
12461 dw_debug("WARNING: DW_SIGNAL_HTML_RESULT will not be generated unless using webkit2gtk!\n"); 12461 dw_debug("WARNING: DW_SIGNAL_HTML_RESULT will not be generated unless using webkit2gtk!\n");
12462 #endif 12462 #endif
12463 DW_MUTEX_UNLOCK; 12463 DW_MUTEX_UNLOCK;
12486 free(params); 12486 free(params);
12487 DW_MUTEX_UNLOCK; 12487 DW_MUTEX_UNLOCK;
12488 return; 12488 return;
12489 } 12489 }
12490 12490
12491 sigid = _set_signal_handler(thiswindow, window, sigfunc, data, thisfunc, discfunc); 12491 sigid = _dw_set_signal_handler(thiswindow, window, sigfunc, data, thisfunc, discfunc);
12492 params[0] = GINT_TO_POINTER(sigid); 12492 params[0] = GINT_TO_POINTER(sigid);
12493 params[2] = (void *)thiswindow; 12493 params[2] = (void *)thiswindow;
12494 cid = g_signal_connect_data(G_OBJECT(thiswindow), thisname, G_CALLBACK(thisfunc), params, _dw_signal_disconnect, 0); 12494 cid = g_signal_connect_data(G_OBJECT(thiswindow), thisname, G_CALLBACK(thisfunc), params, _dw_signal_disconnect, 0);
12495 _set_signal_handler_id(thiswindow, sigid, cid); 12495 _dw_set_signal_handler_id(thiswindow, sigid, cid);
12496 DW_MUTEX_UNLOCK; 12496 DW_MUTEX_UNLOCK;
12497 } 12497 }
12498 12498
12499 /* 12499 /*
12500 * Removes callbacks for a given window with given name. 12500 * Removes callbacks for a given window with given name.
12507 void *thisfunc; 12507 void *thisfunc;
12508 int _locked_by_me = FALSE; 12508 int _locked_by_me = FALSE;
12509 void **params = alloca(sizeof(void *) * 3); 12509 void **params = alloca(sizeof(void *) * 3);
12510 12510
12511 DW_MUTEX_LOCK; 12511 DW_MUTEX_LOCK;
12512 params[2] = _find_signal_window(window, signame); 12512 params[2] = _dw_find_signal_window(window, signame);
12513 count = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(params[2]), "_dw_sigcounter")); 12513 count = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(params[2]), "_dw_sigcounter"));
12514 thisfunc = _findsigfunc(signame); 12514 thisfunc = _dw_findsigfunc(signame);
12515 12515
12516 for(z=0;z<count;z++) 12516 for(z=0;z<count;z++)
12517 { 12517 {
12518 SignalHandler sh; 12518 DWSignalHandler sh;
12519 12519
12520 params[0] = GINT_TO_POINTER(z); 12520 params[0] = GINT_TO_POINTER(z);
12521 sh = _get_signal_handler(params); 12521 sh = _dw_get_signal_handler(params);
12522 12522
12523 if(sh.intfunc == thisfunc) 12523 if(sh.intfunc == thisfunc)
12524 _remove_signal_handler((HWND)params[2], z); 12524 _dw_remove_signal_handler((HWND)params[2], z);
12525 } 12525 }
12526 DW_MUTEX_UNLOCK; 12526 DW_MUTEX_UNLOCK;
12527 } 12527 }
12528 12528
12529 /* 12529 /*
12536 HWND thiswindow; 12536 HWND thiswindow;
12537 int z, count; 12537 int z, count;
12538 int _locked_by_me = FALSE; 12538 int _locked_by_me = FALSE;
12539 12539
12540 DW_MUTEX_LOCK; 12540 DW_MUTEX_LOCK;
12541 thiswindow = _find_signal_window(window, NULL); 12541 thiswindow = _dw_find_signal_window(window, NULL);
12542 count = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(thiswindow), "_dw_sigcounter")); 12542 count = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(thiswindow), "_dw_sigcounter"));
12543 12543
12544 for(z=0;z<count;z++) 12544 for(z=0;z<count;z++)
12545 _remove_signal_handler(thiswindow, z); 12545 _dw_remove_signal_handler(thiswindow, z);
12546 g_object_set_data(G_OBJECT(thiswindow), "_dw_sigcounter", NULL); 12546 g_object_set_data(G_OBJECT(thiswindow), "_dw_sigcounter", NULL);
12547 DW_MUTEX_UNLOCK; 12547 DW_MUTEX_UNLOCK;
12548 } 12548 }
12549 12549
12550 /* 12550 /*
12558 int z, count; 12558 int z, count;
12559 int _locked_by_me = FALSE; 12559 int _locked_by_me = FALSE;
12560 void **params = alloca(sizeof(void *) * 3); 12560 void **params = alloca(sizeof(void *) * 3);
12561 12561
12562 DW_MUTEX_LOCK; 12562 DW_MUTEX_LOCK;
12563 params[2] = _find_signal_window(window, NULL); 12563 params[2] = _dw_find_signal_window(window, NULL);
12564 count = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(params[2]), "_dw_sigcounter")); 12564 count = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(params[2]), "_dw_sigcounter"));
12565 12565
12566 for(z=0;z<count;z++) 12566 for(z=0;z<count;z++)
12567 { 12567 {
12568 SignalHandler sh; 12568 DWSignalHandler sh;
12569 12569
12570 params[0] = GINT_TO_POINTER(z); 12570 params[0] = GINT_TO_POINTER(z);
12571 sh = _get_signal_handler(params); 12571 sh = _dw_get_signal_handler(params);
12572 12572
12573 if(sh.data == data) 12573 if(sh.data == data)
12574 _remove_signal_handler((HWND)params[2], z); 12574 _dw_remove_signal_handler((HWND)params[2], z);
12575 } 12575 }
12576 DW_MUTEX_UNLOCK; 12576 DW_MUTEX_UNLOCK;
12577 } 12577 }
12578 12578
12579 /* 12579 /*