dwindows: gtk3/dw.c comparison

comparison gtk3/dw.c @ 1933:758f49e54566

Enable dw_windows_get_text() to return value of label under GTK. Support for fullscreen display on GTK.

author	mhessling@81767d24-ef19-dc11-ae90-00e081727c95
date	Mon, 11 Sep 2017 05:56:04 +0000
parents	3a5571255ee6
children	eb488c379969

comparison

equal deleted inserted replaced

-:bf34d9f9dabe
+:758f49e54566
 GdkCursor *cursor;
 GdkPixbuf *pixbuf;
 child_box = gtk_event_box_new ();
 child_widget_box = gtk_event_box_new ();
 #if GTK_CHECK_VERSION(3,12,0)
 gtk_widget_set_margin_start(child_widget_box, 2);
 #else
 gtk_widget_set_margin_left(child_widget_box, 2);
 #endif
 top_event_box = gtk_event_box_new ();
 bottom_event_box = gtk_event_box_new ();
 grid = gtk_grid_new ();
 gtk_grid_set_row_spacing(GTK_GRID(grid), 1);
 gtk_grid_set_column_spacing(GTK_GRID(grid), 1);
 for (i = 0; i < 3; i++)
 {
 button[i] = gtk_event_box_new ();
 gtk_widget_set_events (button[i], GDK_BUTTON_PRESS_MASK);
 }
 {
 _dw_override_color (button[j], "background-color", &color);
 }
 gdk_rgba_parse (&color, GTK_MDI_LABEL_FOREGROUND);
 _dw_override_color (label, "color", &color);
 #if GTK_CHECK_VERSION(3,16,0)
 gtk_label_set_xalign(GTK_LABEL(label), 0.0f);
 gtk_label_set_yalign(GTK_LABEL(label), 0.5f);
 #else
 gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
 #endif
 gtk_widget_set_hexpand(top_event_box, TRUE);
 gtk_grid_attach (GTK_GRID (grid), top_event_box, 0, 0, 1, 1);
 gtk_grid_attach (GTK_GRID (grid), button[0], 1, 0, 1, 1);
 gtk_grid_attach (GTK_GRID (grid), button[1], 2, 0, 1, 1);
 gtk_grid_attach (GTK_GRID (grid), button[2], 3, 0, 1, 1);
 /* Window contents */
 gtk_widget_set_hexpand(child_widget_box, TRUE);
 gtk_widget_set_vexpand(child_widget_box, TRUE);
 gtk_grid_attach (GTK_GRID (grid), child_widget_box, 0, 1, 4, 1);
 /* Bottom border */
 gtk_grid_attach (GTK_GRID (grid), bottom_event_box, 4, 2, 1, 1);
 gtk_container_add (GTK_CONTAINER (child_box), grid);
 attributes.visual = gtk_widget_get_visual (widget);
 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
 thiswindow = gdk_window_new (gtk_widget_get_parent_window(widget), &attributes, attributes_mask);
 gtk_widget_set_window(widget, thiswindow);
 gdk_window_set_user_data (gtk_widget_get_window(widget), widget);
 }
 static void gtk_mdi_get_preferred_width (GtkWidget *widget, gint *minimum_width, gint *natural_width)
 {
 FALSE,
 GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK |
 GDK_BUTTON_RELEASE_MASK,
 NULL,
 event->button.time) != GDK_GRAB_SUCCESS)
 #endif
 return FALSE;
 mdi->drag_button = event->button.button;
 mdi->drag_start.x = event->button.x;
 FALSE,
 GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK |
 GDK_BUTTON_RELEASE_MASK,
 NULL,
 event->button.time) != GDK_GRAB_SUCCESS)
 #endif
 return FALSE;
 mdi->drag_button = event->button.button;
 if ((child->state == CHILD_MAXIMIZED) || (child->state == CHILD_ICONIFIED))
 {
 }
 static SignalHandler _get_signal_handler(gpointer data)
 {
 SignalHandler sh = {0};
 if(data)
 {
 void **params = (void **)data;
 int counter = GPOINTER_TO_INT(params[0]);
 GtkWidget *widget = (GtkWidget *)params[2];
 if(work.window)
 {
 int (*keypressfunc)(HWND, char, int, int, void *, char *) = work.func;
 guint32 unichar = gdk_keyval_to_unicode(event->keyval);
 char utf8[7] = { 0 };
 g_unichar_to_utf8(unichar, utf8);
 retval = keypressfunc(work.window, *event->string, event->keyval,
 event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK), work.data, utf8);
 }
 return retval;
 }
 static gint _column_click_event(GtkWidget *widget, gpointer data)
 {
 void **params = data;
 int retval = FALSE;
 if(params && params[2])
 {
 GtkWidget *tree = (GtkWidget *)params[2];
 gint handlerdata = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(tree), "_dw_column_click_id"));
 if(handlerdata)
 {
 SignalHandler work;
 params[0] = GINT_TO_POINTER(handlerdata-1);
 work = _get_signal_handler(params);
 if(work.window)
 {
 static gint _value_changed_event(GtkWidget *widget, gpointer data)
 {
 GtkWidget *slider, *spinbutton, *scrollbar;
 GtkAdjustment *adjustment = (GtkAdjustment *)widget;
 int max, val;
 if(!GTK_IS_ADJUSTMENT(adjustment))
 adjustment = (GtkAdjustment *)g_object_get_data(G_OBJECT(widget), "_dw_adjustment");
 slider = (GtkWidget *)g_object_get_data(G_OBJECT(adjustment), "_dw_slider");
 spinbutton = (GtkWidget *)g_object_get_data(G_OBJECT(adjustment), "_dw_spinbutton");
 scrollbar = (GtkWidget *)g_object_get_data(G_OBJECT(adjustment), "_dw_scrollbar");
 max = _round_value(gtk_adjustment_get_upper(adjustment));
 val = _round_value(gtk_adjustment_get_value(adjustment));
 if(g_object_get_data(G_OBJECT(adjustment), "_dw_suppress_value_changed_event"))
 return FALSE;
 if (slider || spinbutton || scrollbar)
 {
 }
 if(data)
 {
 GdkPixbuf *icon_pixbuf;
 if(data[0] == 'G' && data[1] == 'd' && data[2] == 'k' && data[3] == 'P')
 icon_pixbuf = gdk_pixbuf_new_from_inline(-1, (const guint8 *)data, FALSE, NULL);
 else
 icon_pixbuf = gdk_pixbuf_new_from_xpm_data((const char **)data);
 {
 _resources.resource_max = res->resource_max;
 _resources.resource_id = res->resource_id;
 _resources.resource_data = res->resource_data;
 }
 /* Setup the private data directory */
 if(argc && argv && *argc > 0 && (*argv)[0])
 {
 char *pathcopy = strdup((*argv)[0]);
 char *pos = strrchr(pathcopy, '/');
 char *binname = pathcopy;
 /* If we have a / then...
 * the binary name should be at the end.
 */
 if(pos)
 {
 binname = pos + 1;
 *pos = 0;
 }
 if(*binname)
 {
 char *binpos = strstr(pathcopy, "/bin");
 if(binpos)
 strncpy(_dw_share_path, pathcopy, (size_t)(binpos - pathcopy));
 else
 strcpy(_dw_share_path, "/usr/local");
 strcat(_dw_share_path, "/share/");
 free(pathcopy);
 }
 /* If that failed... just get the current directory */
 if(!_dw_share_path[0] && !getcwd(_dw_share_path, PATH_MAX))
 _dw_share_path[0] = '/';
 #if !GLIB_CHECK_VERSION(2,31,0)
 g_thread_init(NULL);
 #endif
 /* Load these functions via dlsym to avoid deprecation warnings */
 _dw_gdk_threads_init = dlsym(RTLD_DEFAULT, "gdk_threads_init");
 _dw_gdk_threads_enter = dlsym(RTLD_DEFAULT, "gdk_threads_enter");
 _dw_gdk_threads_leave = dlsym(RTLD_DEFAULT, "gdk_threads_leave");
 gettimeofday(&tv, NULL);
 while(((tv.tv_sec - start.tv_sec)*1000) + ((tv.tv_usec - start.tv_usec)/1000) <= milliseconds)
 {
 int _locked_by_me = FALSE;
 if(orig == (pthread_t)-1)
 {
 if(!pthread_getspecific(_dw_mutex_key))
 {
 _dw_gdk_threads_enter();
 void API dw_main_iteration(void)
 {
 pthread_t orig = _dw_thread;
 pthread_t curr = pthread_self();
 int _locked_by_me = FALSE;
 if(_dw_thread == (pthread_t)-1)
 {
 if(!pthread_getspecific(_dw_mutex_key))
 {
 _dw_gdk_threads_enter();
 char outbuf[1025] = {0};
 va_start(args, format);
 vsnprintf(outbuf, 1024, format, args);
 va_end(args);
 fprintf(stderr, "%s", outbuf);
 }
 /*
 * Displays a Message Box with given text and title..
 /* If we had a position request before shown */
 if (g_object_get_data(G_OBJECT(handle), "_dw_pos"))
 {
 int x = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(handle), "_dw_x"));
 int y = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(handle), "_dw_y"));
 /* Call the position function again now that we are realized */
 dw_window_set_pos(handle, x, y);
 /* Clear out the data so we don't do it again */
 g_object_set_data(G_OBJECT(handle), "_dw_pos", NULL);
 }
 /* Handle the invisible event box if it exists */
 if(eventbox && GTK_IS_WIDGET(eventbox))
 handle2 = eventbox;
 /* Check if we are removing a widget from a box */
 if((box = gtk_widget_get_parent(handle2)) && GTK_IS_GRID(box))
 {
 /* Get the number of items in the box... */
 int boxcount = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(box), "_dw_boxcount"));
 #if GTK_CHECK_VERSION(3,10,0)
 int boxtype = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(box), "_dw_boxtype"));
 int z;
 /* Figure out where in the grid this widget is and remove that row/column */
 if(boxtype == DW_VERT)
 {
 for(z=0;z<boxcount;z++)
 {
 /* Decrease the count by 1 */
 boxcount--;
 g_object_set_data(G_OBJECT(box), "_dw_boxcount", GINT_TO_POINTER(boxcount));
 }
 }
 /* Finally destroy the widget */
 gtk_widget_destroy(handle2);
 }
 DW_MUTEX_UNLOCK;
 return 0;
 }
 *           fontname: Font name in Dynamic Windows format.
 */
 void API dw_font_set_default(char *fontname)
 {
 char *oldfont = _DWDefaultFont;
 _DWDefaultFont = strdup(fontname);
 if(oldfont)
 free(oldfont);
 }
 /* Convert DW style font to pango style */
 g_object_set_data(G_OBJECT(handle2), "_dw_fontname", (gpointer)font);
 if(data)
 free(data);
 _dw_override_font(handle2, font);
 DW_MUTEX_UNLOCK;
 return TRUE;
 }
 /* Allows the user to choose a font using the system's font chooser dialog.
 if(font)
 {
 gtk_font_chooser_set_font(fd, font);
 free(font);
 }
 gtk_widget_show(GTK_WIDGET(fd));
 if(gtk_dialog_run(GTK_DIALOG(fd)) == GTK_RESPONSE_OK)
 {
 char *fontname = gtk_font_chooser_get_font(fd);
 if(fontname && (retfont = strdup(fontname)))
 {
 int len = strlen(fontname);
 /* Convert to Dynamic Windows format if we can... */
 if(len > 0 && isdigit(fontname[len-1]))
 {
 int size, x=len-1;
 while(x > 0 && fontname[x] != ' ')
 {
 x--;
 }
 size = atoi(&fontname[x]);
 forecolor.green = (gdouble)DW_GREEN_VALUE(fore) / 255.0;
 forecolor.blue = (gdouble)DW_BLUE_VALUE(fore) / 255.0;
 }
 else if(fore != DW_CLR_DEFAULT)
 forecolor = _colors[fore];
 _dw_override_color(handle, "color", fore != DW_CLR_DEFAULT ? &forecolor : NULL);
 if(back & DW_RGB_COLOR)
 {
 backcolor.alpha = 1.0;
 backcolor.red = (gdouble)DW_RED_VALUE(back) / 255.0;
 backcolor.green = (gdouble)DW_GREEN_VALUE(back) / 255.0;
 backcolor.blue = (gdouble)DW_BLUE_VALUE(back) / 255.0;
 }
 else if(back != DW_CLR_DEFAULT)
 backcolor = _colors[back];
 _dw_override_color(handle, "background-color", back != DW_CLR_DEFAULT ? &backcolor : NULL);
 _save_gdk_colors(handle, forecolor, backcolor);
 return TRUE;
 #else
 _dw_grab_manager = gdk_display_get_device_manager(gtk_widget_get_display(handle));
 gdk_device_grab(gdk_device_manager_get_client_pointer(manager),
 gtk_widget_get_window(handle),
 GDK_OWNERSHIP_WINDOW,
 FALSE,
 GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK,
 NULL,
 GDK_CURRENT_TIME);
 #endif
 DW_MUTEX_UNLOCK;
 }
 DW_MUTEX_LOCK;
 #if GTK_CHECK_VERSION(3,20,0)
 if(_dw_grab_seat)
 gdk_seat_ungrab(_dw_grab_seat);
 _dw_grab_seat = NULL;
 #else
 gdk_device_ungrab(gdk_device_manager_get_client_pointer(manager), GDK_CURRENT_TIME);
 manager = NULL;
 #endif
 DW_MUTEX_UNLOCK;
 }
 /*
 * Create a new Window Frame.
 {
 GtkWidget *box = dw_box_new(DW_VERT, 0);
 GtkWidget *grid = gtk_grid_new();
 gtk_widget_show_all(grid);
 last_window = tmp = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 gtk_window_set_title(GTK_WINDOW(tmp), title);
 gtk_window_set_resizable(GTK_WINDOW(tmp), (flStyle & DW_FCF_SIZEBORDER) ? TRUE : FALSE);
 flags |= GDK_DECOR_RESIZEH | GDK_DECOR_BORDER;
 if(flStyle & (DW_FCF_BORDER | DW_FCF_DLGBORDER))
 flags |= GDK_DECOR_BORDER;
-if(flStyle & DW_FCF_MAXIMIZE)
+if(flStyle & DW_FCF_FULLSCREEN)
-gtk_window_maximize(GTK_WINDOW(tmp));
+gtk_window_fullscreen(GTK_WINDOW(tmp));
+else
-if(flStyle & DW_FCF_MINIMIZE)
+{
-gtk_window_iconify(GTK_WINDOW(tmp));
+if(flStyle & DW_FCF_MAXIMIZE)
+gtk_window_maximize(GTK_WINDOW(tmp));
+if(flStyle & DW_FCF_MINIMIZE)
+gtk_window_iconify(GTK_WINDOW(tmp));
+}
 /* Either the CLOSEBUTTON or SYSMENU flags should make it deletable */
 gtk_window_set_deletable(GTK_WINDOW(tmp), (flStyle & (DW_FCF_CLOSEBUTTON | DW_FCF_SYSMENU)) ? TRUE : FALSE);
 gdk_window_set_decorations(gtk_widget_get_window(tmp), flags);
 if(!flags)
 if(hwndOwner)
 gdk_window_reparent(gtk_widget_get_window(GTK_WIDGET(tmp)), gtk_widget_get_window(GTK_WIDGET(hwndOwner)), 0, 0);
 if(flStyle & DW_FCF_SIZEBORDER)
 g_object_set_data(G_OBJECT(tmp), "_dw_size", GINT_TO_POINTER(1));
 gtk_grid_attach(GTK_GRID(grid), box, 0, 1, 1, 1);
 gtk_container_add(GTK_CONTAINER(tmp), grid);
 g_object_set_data(G_OBJECT(tmp), "_dw_boxhandle", (gpointer)box);
 g_object_set_data(G_OBJECT(tmp), "_dw_grid", (gpointer)grid);
 gtk_widget_add_events(GTK_WIDGET(tmp), GDK_PROPERTY_CHANGE_MASK);
 GtkAccelGroup *accel_group;
 GtkWidget *box;
 HMENUI tmp = 0;
 DW_MUTEX_LOCK;
 if(GTK_IS_WINDOW(location) &&
 (box = (GtkWidget *)g_object_get_data(G_OBJECT(location), "_dw_grid")))
 {
 /* If there is an existing menu bar, remove it */
 GtkWidget *oldmenu = (GtkWidget *)g_object_get_data(G_OBJECT(location), "_dw_menubar");
 if(oldmenu)
 /*
 * Deletes the menu item specified.
 * Parameters:
 *       menu: The handle to the  menu in which the item was appended.
 *       id: Menuitem id.
 * Returns:
 *       DW_ERROR_NONE (0) on success or DW_ERROR_UNKNOWN on failure.
 */
 int API dw_menu_delete_item(HMENUI menu, unsigned long id)
 {
 char numbuf[11];
 GdkDevice *device;
 #if GTK_CHECK_VERSION(3,20,0)
 GdkSeat *seat;
 #else
 GdkDeviceManager *manager;
 #endif
 DW_MUTEX_LOCK;
 #ifdef GDK_WINDOWING_X11
 display = gdk_display_get_default();
 #if GTK_CHECK_VERSION(3,20,0)
 device = gdk_seat_get_pointer(seat);
 #else
 manager = gdk_display_get_device_manager(display);
 device = gdk_device_manager_get_client_pointer(manager);
 #endif
 gdk_window_get_device_position(gdk_x11_window_lookup_for_display(display, GDK_ROOT_WINDOW()),
 device, &gx, &gy, &state);
 #endif
 if(x)
 *x = gx;
 if(y)
 GdkDevice *device;
 #if GTK_CHECK_VERSION(3,20,0)
 GdkSeat *seat;
 #else
 GdkDeviceManager *manager;
 #endif
 DW_MUTEX_LOCK;
 #ifdef GDK_WINDOWING_X11
 display = gdk_display_get_default();
 #if GTK_CHECK_VERSION(3,20,0)
 DW_MUTEX_LOCK;
 tmp = gtk_label_new(text);
 /* Left and centered */
 #if GTK_CHECK_VERSION(3,16,0)
 gtk_label_set_xalign(GTK_LABEL(tmp), 0.0f);
 gtk_label_set_yalign(GTK_LABEL(tmp), 0.5f);
 #else
 gtk_misc_set_alignment(GTK_MISC(tmp), 0.0f, 0.5f);
 #endif
 gtk_container_add(GTK_CONTAINER(frame), tmp);
 gtk_widget_show(tmp);
 gtk_widget_show(frame);
 /* Left and centered */
 #if GTK_CHECK_VERSION(3,16,0)
 gtk_label_set_xalign(GTK_LABEL(tmp), 0.0f);
 gtk_label_set_yalign(GTK_LABEL(tmp), 0.5f);
 #else
 gtk_misc_set_alignment(GTK_MISC(tmp), 0.0f, 0.5f);
 #endif
 DW_MUTEX_LOCK;
 if(GTK_IS_ENTRY(handle))
 possible = gtk_entry_get_text(GTK_ENTRY(handle));
 else if(GTK_IS_COMBO_BOX(handle))
 possible = gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(handle))));
+else if(GTK_IS_LABEL(handle))
+possible = gtk_label_get_text(GTK_LABEL(handle));
 DW_MUTEX_UNLOCK;
 return strdup(possible ? possible : "");
 }
 void dw_mle_thaw(HWND handle)
 {
 }
 /* Internal function to update the progress bar
 * while in an indeterminate state.
 */
 gboolean _dw_update_progress_bar(gpointer data)
 {
 if(g_object_get_data(G_OBJECT(data), "_dw_alive"))
 {
 (store = (GtkTreeModel *)gtk_tree_view_get_model(GTK_TREE_VIEW(tree))))
 {
 GtkTreeIter iter;
 if(gtk_tree_model_iter_parent(store, &iter, (GtkTreeIter *)item))
 gtk_tree_model_get(store, &iter, 3, &parent, -1);
 }
 DW_MUTEX_UNLOCK;
 return parent;
 }
 {
 if(ret)
 {
 int pwidth = gdk_pixbuf_get_width(ret);
 int pheight = gdk_pixbuf_get_height(ret);
 if(pwidth > 24 || pheight > 24)
 {
 GdkPixbuf *orig = ret;
 ret = gdk_pixbuf_scale_simple(ret, pwidth > 24 ? 24 : pwidth, pheight > 24 ? 24 : pheight, GDK_INTERP_BILINEAR);
 g_object_unref(G_OBJECT(orig));
 *                    DW_RGB_TRANSPARENT will disable coloring rows.
 *                    DW_CLR_DEFAULT will use the system default alternating row colors.
 */
 void API dw_container_set_stripe(HWND handle, unsigned long oddcolor, unsigned long evencolor)
 {
 #if !GTK_CHECK_VERSION(3,14,0)
 GtkWidget *cont;
 int _locked_by_me = FALSE;
 DW_MUTEX_LOCK;
 cont = (GtkWidget *)g_object_get_data(G_OBJECT(handle), "_dw_user");
 /* Make sure it is the correct tree type */
 if(cont && GTK_IS_TREE_VIEW(cont) && g_object_get_data(G_OBJECT(cont), "_dw_tree_type") == GINT_TO_POINTER(_DW_TREE_TYPE_CONTAINER))
 {
 if(oddcolor == DW_RGB_TRANSPARENT && evencolor == DW_RGB_TRANSPARENT)
 gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(cont), FALSE);
 else
 gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(cont), TRUE);
 }
 DW_MUTEX_UNLOCK;
 #endif
 }
 /*
 * Sets the width of a column in the container.
 * Parameters:
 GtkWidget *cont;
 int _locked_by_me = FALSE;
 DW_MUTEX_LOCK;
 cont = (GtkWidget *)g_object_get_data(G_OBJECT(handle), "_dw_user");
 /* Make sure it is the correct tree type */
 if(cont && GTK_IS_TREE_VIEW(cont) && g_object_get_data(G_OBJECT(cont), "_dw_tree_type") == GINT_TO_POINTER(_DW_TREE_TYPE_CONTAINER))
 {
 GtkTreeViewColumn *col = gtk_tree_view_get_column(GTK_TREE_VIEW(cont), column);
 static void _status_translate(GtkStatusIcon *status_icon, guint button, guint activate_time, gpointer user_data)
 {
 GdkEventButton event = { 0 };
 long x, y;
 gboolean retval;
 dw_pointer_query_pos(&x, &y);
 event.button = button;
 event.x = x;
 event.y = y;
 g_signal_emit_by_name(G_OBJECT(user_data), "button_press_event", &event, &retval);
 }
 /*
 * Inserts an icon into the taskbar.
 status = gtk_status_icon_new_from_pixbuf(pixbuf);
 if(bubbletext)
 gtk_status_icon_set_tooltip_text(status, bubbletext);
 g_object_set_data(G_OBJECT(handle), "_dw_taskbar", status);
 g_signal_connect(G_OBJECT (status), "popup-menu", G_CALLBACK (_status_translate), handle);
 gtk_status_icon_set_visible(status, TRUE);
 DW_MUTEX_UNLOCK;
 }
 /*
 * Deletes an icon from the taskbar.
 * Parameters:
 }
 *background = color;
 }
 }
 #if GTK_CHECK_VERSION(3,3,11)
 /* Allows the user to choose a color using the system's color chooser dialog.
 * Parameters:
 *       value: current color
 * Returns:
 *       The selected color or the current color if cancelled.
 DW_MUTEX_LOCK;
 cd = (GtkColorChooser *)gtk_color_chooser_dialog_new("Choose color", NULL);
 gtk_color_chooser_set_use_alpha(cd, FALSE);
 gtk_color_chooser_set_rgba(cd, &color);
 gtk_widget_show(GTK_WIDGET(cd));
 if(gtk_dialog_run(GTK_DIALOG(cd)) == GTK_RESPONSE_OK)
 {
 gtk_color_chooser_get_rgba(cd, &color);
 retcolor = DW_RGB((int)(color.red * 255), (int)(color.green * 255), (int)(color.blue * 255));
 }
 gtk_widget_destroy(GTK_WIDGET(cd));
 DW_MUTEX_UNLOCK;
 return retcolor;
 }
 #else
 static int _dw_color_active = 0;
 /* Internal function to handle the color OK press */
 static gint _gtk_color_ok(GtkWidget *widget, DWDialog *dwwait)
 {
 }
 #if GTK_CHECK_VERSION(3,22,0)
 clip = gdk_window_get_clip_region(window);
 dc = gdk_window_begin_draw_frame(window, clip);
 cr = gdk_drawing_context_get_cairo_context(dc);
 #else
 cr = gdk_cairo_create(window);
 #endif
 }
 else if(pixmap)
 cr = cairo_create(pixmap->image);
 if(cr)
 {
 /* If we are using a drawing context...
 * we don't own the cairo context so don't destroy it.
 */
 if(dc)
 gdk_window_end_draw_frame(gtk_widget_get_window(handle), dc);
 else
 #endif
 cairo_destroy(cr);
 }
 DW_MUTEX_UNLOCK;
 }
 }
 #if GTK_CHECK_VERSION(3,22,0)
 clip = gdk_window_get_clip_region(window);
 dc = gdk_window_begin_draw_frame(window, clip);
 cr = gdk_drawing_context_get_cairo_context(dc);
 #else
 cr = gdk_cairo_create(window);
 #endif
 }
 else if(pixmap)
 cr = cairo_create(pixmap->image);
 if(cr)
 {
 /* If we are using a drawing context...
 * we don't own the cairo context so don't destroy it.
 */
 if(dc)
 gdk_window_end_draw_frame(gtk_widget_get_window(handle), dc);
 else
 #endif
 cairo_destroy(cr);
 }
 DW_MUTEX_UNLOCK;
 }
 }
 #if GTK_CHECK_VERSION(3,22,0)
 clip = gdk_window_get_clip_region(window);
 dc = gdk_window_begin_draw_frame(window, clip);
 cr = gdk_drawing_context_get_cairo_context(dc);
 #else
 cr = gdk_cairo_create(window);
 #endif
 }
 else if(pixmap)
 cr = cairo_create(pixmap->image);
 if(cr)
 {
 GdkRGBA *foreground = pthread_getspecific(_dw_fg_color_key);
 if(flags & DW_DRAW_NOAA)
 cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
 gdk_cairo_set_source_rgba(cr, foreground);
 cairo_set_line_width(cr, 1);
 cairo_move_to(cr, x[0], y[0]);
 for(z=1;z<npoints;z++)
 {
 /* If we are using a drawing context...
 * we don't own the cairo context so don't destroy it.
 */
 if(dc)
 gdk_window_end_draw_frame(gtk_widget_get_window(handle), dc);
 else
 #endif
 cairo_destroy(cr);
 }
 DW_MUTEX_UNLOCK;
 }
 }
 #if GTK_CHECK_VERSION(3,22,0)
 clip = gdk_window_get_clip_region(window);
 dc = gdk_window_begin_draw_frame(window, clip);
 cr = gdk_drawing_context_get_cairo_context(dc);
 #else
 cr = gdk_cairo_create(window);
 #endif
 }
 else if(pixmap)
 cr = cairo_create(pixmap->image);
 if(cr)
 {
 GdkRGBA *foreground = pthread_getspecific(_dw_fg_color_key);
 if(flags & DW_DRAW_NOAA)
 cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
 gdk_cairo_set_source_rgba(cr, foreground);
 cairo_set_line_width(cr, 1);
 cairo_move_to(cr, x, y);
 cairo_line_to(cr, x, y + height);
 cairo_line_to(cr, x + width, y + height);
 /* If we are using a drawing context...
 * we don't own the cairo context so don't destroy it.
 */
 if(dc)
 gdk_window_end_draw_frame(gtk_widget_get_window(handle), dc);
 else
 #endif
 cairo_destroy(cr);
 }
 DW_MUTEX_UNLOCK;
 }
 }
 #if GTK_CHECK_VERSION(3,22,0)
 clip = gdk_window_get_clip_region(window);
 dc = gdk_window_begin_draw_frame(window, clip);
 cr = gdk_drawing_context_get_cairo_context(dc);
 #else
 cr = gdk_cairo_create(window);
 #endif
 }
 else if(pixmap)
 cr = cairo_create(pixmap->image);
 if(cr)
 {
 GdkRGBA *foreground = pthread_getspecific(_dw_fg_color_key);
 int width = abs(x2-x1);
 float scale = fabs((float)(y2-y1))/(float)width;
 if(flags & DW_DRAW_NOAA)
 cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
 gdk_cairo_set_source_rgba(cr, foreground);
 cairo_set_line_width(cr, 1);
 if(scale != 1.0)
 cairo_scale(cr, 1.0, scale);
 if(flags & DW_DRAW_FULL)
 /* If we are using a drawing context...
 * we don't own the cairo context so don't destroy it.
 */
 if(dc)
 gdk_window_end_draw_frame(gtk_widget_get_window(handle), dc);
 else
 #endif
 cairo_destroy(cr);
 }
 DW_MUTEX_UNLOCK;
 }
 }
 #if GTK_CHECK_VERSION(3,22,0)
 clip = gdk_window_get_clip_region(window);
 dc = gdk_window_begin_draw_frame(window, clip);
 cr = gdk_drawing_context_get_cairo_context(dc);
 #else
 cr = gdk_cairo_create(window);
 #endif
 if((tmpname = (char *)g_object_get_data(G_OBJECT(handle), "_dw_fontname")))
 fontname = tmpname;
 }
 else if(pixmap)
 {
 /* If we are using a drawing context...
 * we don't own the cairo context so don't destroy it.
 */
 if(dc)
 gdk_window_end_draw_frame(gtk_widget_get_window(handle), dc);
 else
 #endif
 cairo_destroy(cr);
 }
 DW_MUTEX_UNLOCK;
 }
 }
 #if GTK_CHECK_VERSION(3,22,0)
 clip = gdk_window_get_clip_region(window);
 dc = gdk_window_begin_draw_frame(window, clip);
 cr = gdk_drawing_context_get_cairo_context(dc);
 #else
 cr = gdk_cairo_create(window);
 #endif
 }
 else if(destp)
 cr = cairo_create(destp->image);
 if(cr)
 {
 double xscale = 1, yscale = 1;
 if(srcwidth != -1 && srcheight != -1)
 {
 xscale = (double)width / (double)srcwidth;
 yscale = (double)height / (double)srcheight;
 cairo_scale(cr, xscale, yscale);
 }
 if(src)
 gdk_cairo_set_source_window (cr, gtk_widget_get_window(src), (xdest + xsrc) / xscale, (ydest + ysrc) / yscale);
 else if(srcp)
 cairo_set_source_surface (cr, srcp->image, (xdest + xsrc) / xscale, (ydest + ysrc) / yscale);
 cairo_rectangle(cr, xdest / xscale, ydest / yscale, width, height);
 cairo_fill(cr);
 #if GTK_CHECK_VERSION(3,22,0)
 if(clip)
 cairo_region_destroy(clip);
 /* If we are using a drawing context...
 * we don't own the cairo context so don't destroy it.
 */
 if(dc)
 gdk_window_end_draw_frame(gtk_widget_get_window(dest), dc);
 else
 #endif
 cairo_destroy(cr);
 retval = DW_ERROR_NONE;
 }
 DW_MUTEX_UNLOCK;
 return retval;
 if(!eve)
 return DW_ERROR_NON_INIT;
 pthread_mutex_lock (&(eve->mutex));
 if(eve->posted)
 {
 pthread_mutex_unlock (&(eve->mutex));
 return DW_ERROR_NONE;
 }
 if(timeout != -1)
 {
 struct timeval now;
 struct timespec timeo;
 gettimeofday(&now, 0);
 timeo.tv_sec = now.tv_sec + (timeout / 1000);
 timeo.tv_nsec = now.tv_usec * 1000;
 rc = pthread_cond_timedwait(&(eve->event), &(eve->mutex), &timeo);
 }
 else
 rc = pthread_cond_wait(&(eve->event), &(eve->mutex));
 pthread_mutex_unlock (&(eve->mutex));
 if(!rc)
 return DW_ERROR_NONE;
 if(rc == ETIMEDOUT)
 return DW_ERROR_TIMEOUT;
 */
 close(GPOINTER_TO_INT(eve));
 return DW_ERROR_NONE;
 }
 /*
 * Generally an internal function called from a newly created
 * thread to setup the Dynamic Windows environment for the thread.
 * However it is exported so language bindings can call it when
 * they create threads that require access to Dynamic Windows.
 */
 foreground->alpha = foreground->red = foreground->green = foreground->blue = 0.0;
 pthread_setspecific(_dw_fg_color_key, foreground);
 pthread_setspecific(_dw_bg_color_key, NULL);
 }
 /*
 * Generally an internal function called from a terminating
 * thread to cleanup the Dynamic Windows environment for the thread.
 * However it is exported so language bindings can call it when
 * they exit threads that require access to Dynamic Windows.
 */
 void API _dw_deinit_thread(void)
 {
 GdkRGBA *foreground, *background;
 if((foreground = pthread_getspecific(_dw_fg_color_key)))
 free(foreground);
 if((background = pthread_getspecific(_dw_bg_color_key)))
 free(background);
 }
 /* Internal function to get the recommended size of scrolled items */
 void _get_scrolled_size(GtkWidget *item, gint *thiswidth, gint *thisheight)
 {
 GtkWidget *widget = g_object_get_data(G_OBJECT(item), "_dw_user");
 *thisheight = *thiswidth = 0;
 if(widget)
 {
 if(g_object_get_data(G_OBJECT(widget), "_dw_tree_type") == GINT_TO_POINTER(_DW_TREE_TYPE_TREE))
 {
 /* Set to half for tree */
 int height, width;
 char *buf, *ptr;
 int wrap = (gtk_text_view_get_wrap_mode(GTK_TEXT_VIEW(widget)) == GTK_WRAP_WORD);
 static char testtext[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 int hscrolled = FALSE;
 *thiswidth = *thisheight = 0;
 dw_mle_get_size(item, &bytes, NULL);
 ptr = buf = alloca(bytes + 2);
 dw_mle_export(item, buf, 0, (int)bytes);
 buf[bytes] = 0;
 strcat(buf, "\r");
 /* MLE */
 while((ptr = strstr(buf, "\r")))
 {
 ptr[0] = 0;
 width = 0;
 if(strlen(buf))
 dw_font_text_extents_get(item, NULL, buf, &width, &height);
 else
 dw_font_text_extents_get(item, NULL, testtext, NULL, &height);
 if(wrap && width > _DW_SCROLLED_MAX_WIDTH)
 {
 *thiswidth = _DW_SCROLLED_MAX_WIDTH;
 *thisheight += height * (width / _DW_SCROLLED_MAX_WIDTH);
 }
 }
 else
 {
 gtk_widget_get_preferred_height(GTK_WIDGET(widget), NULL, thisheight);
 gtk_widget_get_preferred_width(GTK_WIDGET(widget), NULL, thiswidth);
 *thisheight += 20;
 *thiswidth += 20;
 }
 }
 if(*thiswidth < _DW_SCROLLED_MIN_WIDTH)
 if(pixbuf)
 {
 int pwidth = gdk_pixbuf_get_width(pixbuf);
 int pheight = gdk_pixbuf_get_height(pixbuf);
 if(width == -1)
 width = pwidth;
 if(height == -1)
 height = pheight;
 /* Do some sanity bounds checking */
 if(index < 0)
 index = 0;
 if(index > boxcount)
 index = boxcount;
 #if !GTK_CHECK_VERSION(3,10,0)
 /* Fix the index by taking into account empty cells */
 if(boxtype == DW_VERT)
 {
 int z;
 gtk_widget_set_valign(item, vsize ? GTK_ALIGN_FILL : GTK_ALIGN_START);
 gtk_widget_set_hexpand(item, hsize);
 gtk_widget_set_halign(item, hsize ? GTK_ALIGN_FILL : GTK_ALIGN_START);
 /* Use the margin property as padding */
 g_object_set(G_OBJECT(item), "margin", pad, NULL);
 /* Add to the grid using insert...
 * rows for vertical boxes and columns for horizontal.
 */
 if(boxtype == DW_VERT)
 {
 gtk_grid_insert_row(GTK_GRID(box), index);
 g_object_set_data(G_OBJECT(box), "_dw_boxcount", GINT_TO_POINTER(boxcount + 1));
 /* Special case for scrolled windows */
 if(GTK_IS_SCROLLED_WINDOW(item))
 {
 gint scrolledwidth = 0, scrolledheight = 0;
 /* Pre-run the calculation code for MLE/Container/Tree if needed */
 if((width < 1 && !hsize) || (height < 1 && !vsize))
 _get_scrolled_size(item, &scrolledwidth, &scrolledheight);
 if(width > 0)
 gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(item), width);
 else if(!hsize)
 gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(item), scrolledwidth);
 if(height > 0)
 /* Set the requested size of the widget */
 if(width == -1 && (GTK_IS_COMBO_BOX(item) || GTK_IS_ENTRY(item)))
 gtk_widget_set_size_request(item, 150, height);
 else if(width == -1 && GTK_IS_SPIN_BUTTON(item))
 gtk_widget_set_size_request(item, 50, height);
 else
 gtk_widget_set_size_request(item, width, height);
 }
 if(GTK_IS_RADIO_BUTTON(item))
 {
 GSList *group;
 *       DW_ERROR_NONE on success and DW_ERROR_GENERAL on failure.
 */
 int API dw_box_unpack(HWND handle)
 {
 int _locked_by_me = FALSE, retcode = DW_ERROR_GENERAL;
 DW_MUTEX_LOCK;
 if(GTK_IS_WIDGET(handle))
 {
 GtkWidget *box, *handle2 = handle;
 GtkWidget *eventbox = (GtkWidget *)g_object_get_data(G_OBJECT(handle), "_dw_eventbox");
 /* Handle the invisible event box if it exists */
 if(eventbox && GTK_IS_WIDGET(eventbox))
 handle2 = eventbox;
 /* Check if we are removing a widget from a box */
 if((box = gtk_widget_get_parent(handle2)) && GTK_IS_GRID(box))
 {
 /* Get the number of items in the box... */
 int boxcount = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(box), "_dw_boxcount"));
 #if GTK_CHECK_VERSION(3,10,0)
 int boxtype = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(box), "_dw_boxtype"));
 #endif
 if(boxcount > 0)
 {
 if(!g_object_get_data(G_OBJECT(handle2), "_dw_refed"))
 {
 g_object_ref(G_OBJECT(handle2));
 g_object_set_data(G_OBJECT(handle2), "_dw_refed", GINT_TO_POINTER(1));
 }
 /* Remove the widget from the box */
 #if GTK_CHECK_VERSION(3,10,0)
 /* Figure out where in the grid this widget is and remove that row/column */
 if(boxtype == DW_VERT)
 {
 int z;
 */
 HWND API dw_box_unpack_at_index(HWND box, int index)
 {
 int _locked_by_me = FALSE;
 HWND retval = 0;
 DW_MUTEX_LOCK;
 /* Check if we are removing a widget from a box */
 if(GTK_IS_GRID(box))
 {
 /* Get the number of items in the box... */
 int boxcount = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(box), "_dw_boxcount"));
 int boxtype = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(box), "_dw_boxtype"));
 #if GTK_CHECK_VERSION(3,10,0)
 GtkWidget *item = (boxtype == DW_VERT) ? gtk_grid_get_child_at(GTK_GRID(box), 0, index) : gtk_grid_get_child_at(GTK_GRID(box), index, 0);
 #else
 GtkWidget *item;
 /* Fix the index by taking into account empty cells */
 if(!g_object_get_data(G_OBJECT(item), "_dw_refed"))
 {
 g_object_ref(G_OBJECT(item));
 g_object_set_data(G_OBJECT(item), "_dw_refed", GINT_TO_POINTER(1));
 }
 /* Remove the widget from the box */
 gtk_container_remove(GTK_CONTAINER(box), item);
 #if GTK_CHECK_VERSION(3,10,0)
 if(boxtype == DW_VERT)
 gtk_grid_remove_row(GTK_GRID(box), index);
 else
 gtk_grid_remove_column(GTK_GRID(box), index);
 #endif
 retval = item;
 }
 }
 DW_MUTEX_UNLOCK;
 return retval;
 (SubstructureRedirectMask | SubstructureNotifyMask),
 &xevent);
 /* Connect a signal to look for the property change */
 connid = g_signal_connect(G_OBJECT(window), "property_notify_event", G_CALLBACK(_dw_property_notify), gdkwindow);
 /* Record the request time */
 time(&extents_time);
 /* Look for the property notify event */
 do
 {
 dw_main_iteration();
 time(&currtime);
 }
 while(currtime - extents_time < 2);
 /* Remove the signal handler now that we are done */
 g_signal_handler_disconnect(G_OBJECT(window), connid);
 }
 /* Attempt to retrieve window's frame extents. */
 eu.extents = &extents;
 if(gdk_property_get(gdkwindow,
 extents_atom,
 gdk_atom_intern("CARDINAL", FALSE),
 gint gwidth, gheight;
 /* Calculate the border size */
 gdk_window_get_frame_extents(window, &frame);
 gdk_window_get_geometry(window, NULL, NULL, &gwidth, &gheight);
 cx = frame.width - gwidth;
 if(cx < 0)
 cx = 0;
 cy = frame.height - gheight;
 if(cy < 0)
 DW_MUTEX_LOCK;
 if(GTK_IS_SCROLLED_WINDOW(handle))
 {
 gint scrolledwidth, scrolledheight;
 _get_scrolled_size(handle, &scrolledwidth, &scrolledheight);
 if(width)
 *width = scrolledwidth;
 if(height)
 *height = scrolledheight;
 }
 int _dw_screen_width(void)
 {
 #if GTK_CHECK_VERSION(3,22,0)
 {
 GdkDisplay *display = gdk_display_get_default();
 if(display)
 {
 GdkMonitor *monitor = gdk_display_get_primary_monitor(display);
 if(monitor)
 {
 GdkRectangle rc = { 0, 0, 0 ,0 };
 gdk_monitor_get_geometry(monitor, &rc);
 return rc.width;
 }
 }
 }
 return 0;
 #else
 return gdk_screen_width();
 #endif
 }
 /*
 * Returns the width of the screen.
 */
 int _dw_screen_height(void)
 {
 #if GTK_CHECK_VERSION(3,22,0)
 {
 GdkDisplay *display = gdk_display_get_default();
 if(display)
 {
 GdkMonitor *monitor = gdk_display_get_primary_monitor(display);
 if(monitor)
 {
 GdkRectangle rc = { 0, 0, 0 ,0 };
 gdk_monitor_get_geometry(monitor, &rc);
 return rc.height;
 }
 }
 }
 return 0;
 #else
 return gdk_screen_height();
 #endif
 }
 /*
 * Returns the height of the screen.
 */
 DW_MUTEX_LOCK;
 #if GTK_CHECK_VERSION(3,22,0)
 vis = gdk_screen_get_system_visual(gdk_screen_get_default());
 #else
 vis = gdk_visual_get_system();
 #endif
 retval = gdk_visual_get_depth(vis);
 DW_MUTEX_UNLOCK;
 return retval;
 }
 GtkWidget *mdi;
 #endif
 if(!handle)
 return;
 DW_MUTEX_LOCK;
 #ifdef DW_INCLUDE_DEPRECATED
 if((mdi = (GtkWidget *)g_object_get_data(G_OBJECT(handle), "_dw_mdi")) && GTK_IS_MDI(mdi))
 {
 gtk_mdi_move(GTK_MDI(mdi), handle, x, y);
 }
 else
 #endif
 {
 GdkWindow *window = NULL;
 if(GTK_IS_WINDOW(handle))
 {
 GdkWindow *window = gtk_widget_get_window(handle);
 int horz = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(handle), "_dw_grav_horz"));
 int vert = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(handle), "_dw_grav_vert"));
 int cx = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(handle), "_dw_frame_width"));
 int cy = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(handle), "_dw_frame_height"));
 int newx = x, newy = y, width = 0, height = 0;
 /* If the window is mapped */
 if(window && gtk_widget_get_mapped(handle))
 {
 /* If we need the width or height... */
 if(horz || vert)
 GdkRectangle frame;
 int count = 0;
 /* Get the frame size */
 gdk_window_get_frame_extents(window, &frame);
 /* FIXME: Sometimes we get returned an invalid 200x200
 * result... so if we get this... try the call a second
 * time and hope for a better result.
 */
 while((frame.width == 200 || frame.width == (200 + cx)) &&
 (frame.height == 200 || frame.height == (200 + cy)) && count < 10)
 {
 _dw_msleep(1);
 count++;
 gdk_window_get_frame_extents(window, &frame);
 if((vert & 0xf) == DW_GRAV_CENTER)
 newy += ((_dw_screen_height() / 2) - (height / 2));
 else if((vert & 0xf) == DW_GRAV_BOTTOM)
 newy = _dw_screen_height() - height - y;
 #if GTK_CHECK_VERSION(3,3,8)
 /* Adjust the values to avoid Gnome bar if requested */
 if((horz | vert) & DW_GRAV_OBSTACLES)
 {
 GdkRectangle rect = { 0, 0, 0, 0 };
 #if GTK_CHECK_VERSION(3,22,0)
 GdkDisplay *display = gdk_display_get_default();
 if(display)
 {
 GdkMonitor *monitor = gdk_display_get_primary_monitor(display);
 if(monitor)
 gdk_monitor_get_workarea(monitor, &rect);
 }
 #else
 GdkScreen *screen = gdk_screen_get_default();
 gdk_screen_get_monitor_workarea(screen, 0, &rect);
 #endif
 if(horz & DW_GRAV_OBSTACLES)
 {
 if((horz & 0xf) == DW_GRAV_LEFT)
 newx += rect.x;
 else if((horz & 0xf) == DW_GRAV_RIGHT)
 newy += rect.y;
 else if((vert & 0xf) == DW_GRAV_BOTTOM)
 newy -= _dw_screen_height() - (rect.y + rect.height);
 }
 }
 #endif
 }
 /* Finally move the window into place */
 gtk_window_move(GTK_WINDOW(handle), newx, newy);
 }
 else if((window = gtk_widget_get_window(handle)))
 gdk_window_move(window, x, y);
 }
 else
 #endif
 {
 GdkWindow *window;
 /* Can only query if the window is realized */
 if(handle && (window = gtk_widget_get_window(handle)))
 {
 /* If it is a toplevel window */
 if(GTK_IS_WINDOW(handle))
 y = DW_CENTER;
 if ( style & DW_DT_TOP )
 y = DW_TOP;
 if ( style & DW_DT_BOTTOM )
 y = DW_BOTTOM;
 #if GTK_CHECK_VERSION(3,16,0)
 gtk_label_set_xalign(GTK_LABEL(handle2), x);
 gtk_label_set_yalign(GTK_LABEL(handle2), y);
 #else
 gtk_misc_set_alignment(GTK_MISC(handle2), x, y);
 #endif
 gtk_label_set_line_wrap( GTK_LABEL(handle), TRUE );
 }
 if ( GTK_IS_CHECK_MENU_ITEM(handle2) && (mask & (DW_MIS_CHECKED | DW_MIS_UNCHECKED)) )
 {
 int check = 0;
 if ( style & DW_MIS_CHECKED )
 check = 1;
 _dw_ignore_click = 1;
 if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(handle2)) != check)
 gint rowcount = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(store), NULL);
 gdouble pagesize = gtk_adjustment_get_page_size(adjust);
 gdouble upper = gtk_adjustment_get_upper(adjust) - pagesize;
 gdouble lower = gtk_adjustment_get_lower(adjust);
 gdouble change;
 /* Safety check */
 if(rowcount < 2)
 {
 DW_MUTEX_UNLOCK;
 return;
 }
 /* Verify the range */
 rowcount--;
 if(top > rowcount)
 top = rowcount;
 float *percent = (float *)g_object_get_data(G_OBJECT(widget), "_dw_percent");
 if(percent)
 {
 GtkAllocation alloc;
 gtk_widget_get_allocation(widget, &alloc);
 if(gtk_orientable_get_orientation(GTK_ORIENTABLE(widget)) == GTK_ORIENTATION_HORIZONTAL)
 gtk_paned_set_position(GTK_PANED(widget), (int)(alloc.width * (*percent / 100.0)));
 else
 gtk_paned_set_position(GTK_PANED(widget), (int)(alloc.height * (*percent / 100.0)));
 g_object_set_data(G_OBJECT(widget), "_dw_percent", NULL);
 }
 if ( defpath )
 {
 struct stat buf;
 if ( g_path_is_absolute( defpath ) || !realpath(defpath, mypath))
 {
 strcpy( mypath, defpath );
 }
 /* See if the path exists */
 if(stat(mypath, &buf) == 0)
 {
 /* If the path is a directory... set the current folder */
 if(buf.st_mode & S_IFDIR)
 gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( filew ), mypath );
 else if(flags == DW_FILE_SAVE)
 {
 if(strchr(mypath, '/'))
 {
 unsigned long x = strlen(mypath) - 1;
 /* Trim off the filename */
 while(x > 0 && mypath[x] != '/')
 {
 x--;
 }
 if(mypath[x] == '/')
 {
 char *file = NULL;
 char temp[PATH_MAX+1];
 /* Save the original path in temp */
 strcpy(temp, mypath);
 mypath[x] = 0;
 /* Check to make sure the trimmed piece is a directory */
 if(realpath(mypath, temp) && stat(temp, &buf) == 0)
 {
 if(buf.st_mode & S_IFDIR)
 {
 /* We now have it split */
 file = &mypath[x+1];
 }
 }
 /* Select folder... */
 gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER(filew), temp );
 /* ... and file separately */
 if(file)
 gtk_file_chooser_set_current_name( GTK_FILE_CHOOSER(filew), file );
 */
 HPRINT API dw_print_new(char *jobname, unsigned long flags, unsigned int pages, void *drawfunc, void *drawdata)
 {
 GtkPrintOperation *op;
 int _locked_by_me = FALSE;
 if(!drawfunc)
 return NULL;
 DW_MUTEX_LOCK;
 if((op = gtk_print_operation_new()))
 {
 gtk_print_operation_set_n_pages(op, pages);
 gtk_print_operation_set_job_name(op, jobname ? jobname : "Dynamic Windows Print Job");
 g_object_set_data(G_OBJECT(op), "_dw_drawfunc", drawfunc);
 int API dw_print_run(HPRINT print, unsigned long flags)
 {
 GtkPrintOperationResult res;
 GtkPrintOperation *op = (GtkPrintOperation *)print;
 int _locked_by_me = FALSE;
 DW_MUTEX_LOCK;
 res = gtk_print_operation_run(op, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, NULL, NULL);
 DW_MUTEX_UNLOCK;
 return (res == GTK_PRINT_OPERATION_RESULT_ERROR ? DW_ERROR_UNKNOWN : DW_ERROR_NONE);
 }
 */
 void API dw_print_cancel(HPRINT print)
 {
 int _locked_by_me = FALSE;
 GtkPrintOperation *op = (GtkPrintOperation *)print;
 DW_MUTEX_LOCK;
 gtk_print_operation_cancel(op);
 DW_MUTEX_UNLOCK;
 }
 return _user_dir;
 }
 /*
 * Returns a pointer to a static buffer which containes the
 * private application data directory.
 */
 char * API dw_app_dir(void)
 {
 return _dw_share_path;
 }
 *       sigfunc: The pointer to the function to be used as the callback.
 *       data: User data to be passed to the handler function.
 */
 void dw_signal_connect(HWND window, char *signame, void *sigfunc, void *data)
 {
 dw_signal_connect_data(window, signame, sigfunc, NULL, data);
 }
 /* Internal function to free any allocated signal data..
 * and call any required function to free additional memory.
 */
 void (*discfunc)(HWND, void *) = params[1];
 if(discfunc)
 {
 SignalHandler work = _get_signal_handler(data);
 if(work.window)
 {
 discfunc(work.window, work.data);
 }
 }
 char *thisname = signame;
 HWND thiswindow = window;
 int sigid, _locked_by_me = FALSE;
 void **params = calloc(3, sizeof(void *));
 gint cid;
 /* Save the disconnect function pointer */
 params[1] = discfunc;
 DW_MUTEX_LOCK;
 /*
 sigid = _set_signal_handler(thiswindow, window, sigfunc, data, _container_enter_event, discfunc);
 params[0] = GINT_TO_POINTER(sigid);
 params[2] = (void *)thiswindow;
 cid = g_signal_connect_data(G_OBJECT(thiswindow), "key_press_event", G_CALLBACK(_container_enter_event), params, _dw_signal_disconnect, 0);
 _set_signal_handler_id(thiswindow, sigid, cid);
 params = calloc(sizeof(void *), 3);
 thisname = "button_press_event";
 thisfunc = _findsigfunc(DW_SIGNAL_ITEM_ENTER);
 }
 thisfunc = _findsigfunc(signame);
 for(z=0;z<count;z++)
 {
 SignalHandler sh;
 params[0] = GINT_TO_POINTER(z);
 sh = _get_signal_handler(params);
 if(sh.intfunc == thisfunc)
 _remove_signal_handler((HWND)params[2], z);
 count = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(params[2]), "_dw_sigcounter"));
 for(z=0;z<count;z++)
 {
 SignalHandler sh;
 params[0] = GINT_TO_POINTER(z);
 sh = _get_signal_handler(params);
 if(sh.data == data)
 _remove_signal_handler((HWND)params[2], z);
 *       or NULL on failure.
 */
 wchar_t * API dw_utf8_to_wchar(char *utf8string)
 {
 wchar_t *retval = NULL, *freeme;
 if(sizeof(wchar_t) == sizeof(gunichar))
 freeme = retval = (wchar_t *)g_utf8_to_ucs4(utf8string, -1, NULL, NULL, NULL);
 else if(sizeof(wchar_t) == sizeof(gunichar2))
 freeme = retval = (wchar_t *)g_utf8_to_utf16(utf8string, -1, NULL, NULL, NULL);
 if(retval)
 {
 retval = wcsdup(retval);
 g_free(freeme);
 *       or NULL on failure.
 */
 char * API dw_wchar_to_utf8(wchar_t *wstring)
 {
 char *retval = NULL, *freeme;
 if(sizeof(wchar_t) == sizeof(gunichar))
 freeme = retval = g_ucs4_to_utf8((gunichar *)wstring, -1, NULL, NULL, NULL);
 else if(sizeof(wchar_t) == sizeof(gunichar2))
 freeme = retval = g_utf16_to_utf8((gunichar2 *)wstring, -1, NULL, NULL, NULL);
 if(retval)
 {
 retval = strdup(retval);
 g_free(freeme);
 }
 return retval;
 }

Mercurial > dwindows

comparison gtk3/dw.c @ 1933:758f49e54566