dwindows: gtk4/dw.c comparison

comparison gtk4/dw.c @ 2266:bb0690c04413

GTK4: First buildable version... although tons still left to do. No thread safety at all, only single threaded apps... no menus. Signal handlers are a complete mess.... but progress.

author	bsmith@81767d24-ef19-dc11-ae90-00e081727c95
date	Sat, 30 Jan 2021 01:53:20 +0000
parents	63bb97e94cd3
children	7ac85e938b71

comparison

equal deleted inserted replaced

-:63bb97e94cd3
+:bb0690c04413
 GtkButtonsType gtkbuttons = GTK_BUTTONS_OK;
 GtkWidget *dialog;
 int response;
 va_list args;
 char outbuf[1025] = {0};
+DWDialog *tmp = dw_dialog_new(NULL);
 va_start(args, format);
 vsnprintf(outbuf, 1024, format, args);
 va_end(args);
 GTK_DIALOG_USE_HEADER_BAR |
 GTK_DIALOG_MODAL, gtkicon, gtkbuttons, "%s", title);
 gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog), "%s", outbuf);
 if(flags & DW_MB_YESNOCANCEL)
 gtk_dialog_add_button(GTK_DIALOG(dialog), "Cancel", GTK_RESPONSE_CANCEL);
-response = gtk_dialog_run(GTK_DIALOG(dialog));
+gtk_widget_show(GTK_WIDGET(dialog));
+/* TODO: Implement signal handlers so this will return */
+response = DW_POINTER_TO_INT(dw_dialog_wait(tmp));
 if(GTK_IS_WINDOW(dialog))
 gtk_window_destroy(GTK_WINDOW(dialog));
 switch(response)
 {
 case GTK_RESPONSE_OK:
 {
 GtkFontChooser *fd;
 char *font = currfont ? strdup(currfont) : NULL;
 char *name = font ? strchr(font, '.') : NULL;
 char *retfont = NULL;
+DWDialog *tmp = dw_dialog_new(NULL);
 /* Detect Dynamic Windows style font name...
 * Format: ##.Fontname
 * and convert to a Pango name
 */
 free(font);
 }
 gtk_widget_show(GTK_WIDGET(fd));
-if(gtk_dialog_run(GTK_DIALOG(fd)) == GTK_RESPONSE_OK)
+/* TODO: Connect signal handlers so this actually returns */
+if(DW_POINTER_TO_INT(dw_dialog_wait(tmp)) == GTK_RESPONSE_OK)
 {
 char *fontname = gtk_font_chooser_get_font(fd);
 if(fontname && (retfont = strdup(fontname)))
 {
 int len = strlen(fontname);
 }
 }
 g_free(fontname);
 }
 }
-g_object_unref(G_OBJECT(fd));
+if(GTK_IS_WINDOW(fd))
+gtk_window_destroy(GTK_WINDOW(fd));
 return retfont;
 }
 /*
 * Gets the font used by a specified window (widget) handle.
 *       id: An ID to be used for getting the resource from the
 *           resource file.
 */
 HMENUI dw_menu_new(unsigned long id)
 {
-HMENUI tmp;
+HMENUI tmp = NULL;
+#if 0 /* TODO: Implement this with GMenuModel and GtkPopoverMenu */
 tmp = gtk_menu_new();
 gtk_widget_show(tmp);
 g_object_set_data(G_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
+#endif
 return tmp;
 }
 /*
 * Create a menubar on a window.
 * If there is no box already packed into the "location", the menu will not appear
 * so tell the user.
 */
 HMENUI dw_menubar_new(HWND location)
 {
+HMENUI tmp = 0;
+#if 0 /* TODO: Implement this with GMenuModel and GtkPopoverMenu */
 GtkWidget *box;
-HMENUI tmp = 0;
 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 */
 /* Save pointers to each other */
 g_object_set_data(G_OBJECT(location), "_dw_menubar", (gpointer)tmp);
 g_object_set_data(G_OBJECT(tmp), "_dw_window", (gpointer)location);
 gtk_grid_attach(GTK_GRID(box), tmp, 0, 0, 1, 1);
 }
+#endif
 return tmp;
 }
 /*
 * Destroys a menu created with dw_menubar_new or dw_menu_new.
 * Parameters:
 *       menu: Handle of a menu.
 */
 void dw_menu_destroy(HMENUI *menu)
 {
+#if 0 /* TODO: Implement this with GMenuModel and GtkPopoverMenu */
 if(menu && *menu)
 {
 GtkWidget *window;
 /* If it is a menu bar, try to delete the reference to it */
 /* Actually destroy the menu */
 if(GTK_IS_WIDGET(*menu))
 g_object_unref(G_OBJECT(*menu));
 *menu = NULL;
 }
-}
+#endif
-char _removetilde(char *dest, const char *src)
-{
-int z, cur=0;
-char accel = '\0';
-for(z=0;z<strlen(src);z++)
-{
-if(src[z] != '~')
-{
-dest[cur] = src[z];
-cur++;
-}
-else
-{
-dest[cur] = '_';
-accel = src[z+1];
-cur++;
-}
-}
-dest[cur] = 0;
-return accel;
 }
 /*
 * Adds a menuitem or submenu to an existing menu.
 * Parameters:
 *       check: If TRUE menu is "check"able.
 *       submenu: Handle to an existing menu to be a submenu or NULL.
 */
 HWND dw_menu_append_item(HMENUI menu, const char *title, unsigned long id, unsigned long flags, int end, int check, HMENUI submenu)
 {
-GtkWidget *tmphandle;
+GtkWidget *tmphandle = NULL;
+#if 0 /* TODO: Implement this with GMenuModel and GtkPopoverMenu */
 char accel, *tempbuf = malloc(strlen(title)+1);
 int submenucount;
-GtkAccelGroup *accel_group;
 if (!menu)
 {
 free(tempbuf);
 return NULL;
 }
 accel = _removetilde(tempbuf, title);
-accel_group = (GtkAccelGroup *)g_object_get_data(G_OBJECT(menu), "_dw_accel");
 submenucount = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menu), "_dw_submenucount"));
 if (strlen(tempbuf) == 0)
 tmphandle=gtk_menu_item_new();
 else
 char numbuf[25] = {0};
 if (check)
 {
 tmphandle = gtk_check_menu_item_new_with_label(tempbuf);
-if (accel && accel_group)
+if (accel)
+gtk_label_set_use_underline(GTK_LABEL(gtk_bin_get_child(GTK_BIN(tmphandle))), TRUE);
+snprintf(numbuf, 24, "%lu", id);
+g_object_set_data(G_OBJECT(menu), numbuf, (gpointer)tmphandle);
+}
+else
+{
+tmphandle=gtk_menu_item_new_with_label(tempbuf);
+if (accel)
 {
 gtk_label_set_use_underline(GTK_LABEL(gtk_bin_get_child(GTK_BIN(tmphandle))), TRUE);
-#if 0 /* TODO: This isn't working right */
-gtk_widget_add_accelerator(tmphandle, "activate", accel_group, tmp_key, GDK_MOD1_MASK, 0);
-#endif
-}
-snprintf(numbuf, 24, "%lu", id);
-g_object_set_data(G_OBJECT(menu), numbuf, (gpointer)tmphandle);
-}
-else
-{
-tmphandle=gtk_menu_item_new_with_label(tempbuf);
-if (accel && accel_group)
-{
-gtk_label_set_use_underline(GTK_LABEL(gtk_bin_get_child(GTK_BIN(tmphandle))), TRUE);
-#if 0 /* TODO: This isn't working right */
-gtk_widget_add_accelerator(tmphandle, "activate", accel_group, tmp_key, GDK_MOD1_MASK, 0);
-#endif
 }
 snprintf(numbuf, 24, "%lu", id);
 g_object_set_data(G_OBJECT(menu), numbuf, (gpointer)tmphandle);
 }
 }
 _dw_ignore_click = 0;
 }
 if ( flags & DW_MIS_DISABLED )
 gtk_widget_set_sensitive( tmphandle, FALSE );
+#endif
 return tmphandle;
 }
 GtkWidget *_find_submenu_id(GtkWidget *start, const char *name)
 {
 *       check: TRUE for checked FALSE for not checked.
 * deprecated: use dw_menu_item_set_state()
 */
 void dw_menu_item_set_check(HMENUI menu, unsigned long id, int check)
 {
+#if 0 /* TODO: Implement this with GMenuModel and GtkPopoverMenu */
 char numbuf[25] = {0};
 GtkWidget *tmphandle;
 if(!menu)
 return;
 _dw_ignore_click = 1;
 if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(tmphandle)) != check)
 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(tmphandle), check);
 _dw_ignore_click = 0;
 }
+#endif
 }
 /*
 * Sets the state of a menu item.
 * Parameters:
 *       id: Menuitem id.
 *       state: TRUE for checked FALSE for not checked.
 */
 void dw_menu_item_set_state(HMENUI menu, unsigned long id, unsigned long state)
 {
+#if 0 /* TODO: Implement this with GMenuModel and GtkPopoverMenu */
 char numbuf[25] = {0};
 GtkWidget *tmphandle;
 int check;
 if(!menu)
 else
 gtk_widget_set_sensitive( tmphandle, FALSE );
 _dw_ignore_click = 0;
 }
 }
+#endif
 }
 /*
 * Deletes the menu item specified.
 * Parameters:
 * Returns:
 *       DW_ERROR_NONE (0) on success or DW_ERROR_UNKNOWN on failure.
 */
 int API dw_menu_delete_item(HMENUI menu, unsigned long id)
 {
+int ret = DW_ERROR_UNKNOWN;
+#if 0 /* TODO: Implement this with GMenuModel and GtkPopoverMenu */
 char numbuf[25] = {0};
 GtkWidget *tmphandle;
-int ret = DW_ERROR_UNKNOWN;
 if(!menu)
 return ret;
 snprintf(numbuf, 24, "%lu", id);
 if(GTK_IS_WIDGET(tmphandle))
 g_object_unref(G_OBJECT(tmphandle));
 g_object_set_data(G_OBJECT(menu), numbuf, NULL);
 ret = DW_ERROR_NONE;
 }
+#endif
 return ret;
 }
 /*
 * Pops up a context menu at given x and y coordinates.
 void dw_menu_popup(HMENUI *menu, HWND parent, int x, int y)
 {
 if(!menu || !*menu)
 return;
+#if 0 /* TODO: Implement this with GMenuModel and GtkPopoverMenu */
 popup = parent;
 gtk_menu_popup_at_pointer(GTK_MENU(*menu), NULL);
+#endif
 *menu = NULL;
 }
 /*
 *       x: Pointer to variable to store X coordinate.
 *       y: Pointer to variable to store Y coordinate.
 */
 void dw_pointer_query_pos(long *x, long *y)
 {
-GdkModifierType state = 0;
+/* TODO: See if this is possible in GTK4 */
-int gx, gy;
-GdkDisplay *display;
-GdkDevice *device;
-GdkSeat *seat;
-#ifdef GDK_WINDOWING_X11
-display = gdk_display_get_default();
-seat = gdk_display_get_default_seat(display);
-device = gdk_seat_get_pointer(seat);
-gdk_window_get_device_position(gdk_x11_window_lookup_for_display(display, GDK_ROOT_WINDOW()),
-device, &gx, &gy, &state);
-#endif
 if(x)
-*x = gx;
+*x = 0;
 if(y)
-*y = gy;
+*y = 0;
 }
 /*
 * Sets the X and Y coordinates of the mouse pointer.
 * Parameters:
 *       x: X coordinate.
 *       y: Y coordinate.
 */
 void dw_pointer_set_pos(long x, long y)
 {
-GdkDisplay *display;
+/* TODO: See if this is possible in GTK4 */
-GdkDevice *device;
-GdkSeat *seat;
-#ifdef GDK_WINDOWING_X11
-display = gdk_display_get_default();
-seat = gdk_display_get_default_seat(display);
-device = gdk_seat_get_pointer(seat);
-gdk_device_warp(device, gdk_screen_get_default(), x, y);
-#endif
 }
 #define _DW_TREE_CONTAINER 1
 #define _DW_TREE_TREE      2
 #define _DW_TREE_LISTBOX   3
 GtkWidget *_tree_create(unsigned long id)
 {
 GtkWidget *tmp;
-tmp = gtk_scrolled_window_new(NULL, NULL);
+tmp = gtk_scrolled_window_new();
 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (tmp),
 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 g_object_set_data(G_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
 gtk_widget_show(tmp);
 GtkWidget *_tree_setup(GtkWidget *tmp, GtkTreeModel *store)
 {
 GtkWidget *tree = gtk_tree_view_new_with_model(store);
 gtk_tree_view_set_enable_search(GTK_TREE_VIEW(tree), FALSE);
-#if GTK_CHECK_VERSION(3,8,0)
+gtk_scrolled_window_set_child(GTK_SCROLLED_WINDOW(tmp), tree);
-gtk_container_add(GTK_CONTAINER(tmp), tree);
-#else
-gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(tmp), tree);
-#endif
 g_object_set_data(G_OBJECT(tmp), "_dw_user", (gpointer)tree);
 return tree;
 }
 /*
 HWND dw_status_text_new(const char *text, ULONG id)
 {
 GtkWidget *tmp, *frame;
 frame = gtk_frame_new(NULL);
-gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
 tmp = gtk_label_new(text);
-gtk_container_add(GTK_CONTAINER(frame), tmp);
+gtk_frame_set_child(GTK_FRAME(frame), tmp);
 gtk_widget_show(tmp);
 gtk_widget_show(frame);
 /* Left and centered */
 gtk_label_set_xalign(GTK_LABEL(tmp), 0.0f);
 */
 HWND dw_mle_new(unsigned long id)
 {
 GtkWidget *tmp, *tmpbox;
-tmpbox = gtk_scrolled_window_new (NULL, NULL);
+tmpbox = gtk_scrolled_window_new();
-gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(tmpbox),
+gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(tmpbox),
 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
-gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(tmpbox), GTK_SHADOW_ETCHED_IN);
 tmp = gtk_text_view_new();
-gtk_container_add (GTK_CONTAINER(tmpbox), tmp);
+gtk_scrolled_window_set_child(GTK_SCROLLED_WINDOW(tmpbox), tmp);
 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(tmp), GTK_WRAP_WORD);
 g_object_set_data(G_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
 g_object_set_data(G_OBJECT(tmpbox), "_dw_user", (gpointer)tmp);
 gtk_widget_show(tmp);
 *       id: An ID to be used with dw_window_from_id() or 0L.
 */
 HWND dw_entryfield_new(const char *text, unsigned long id)
 {
 GtkWidget *tmp;
+GtkEntryBuffer *buffer = gtk_entry_buffer_new(text, -1);
-tmp = gtk_entry_new();
+tmp = gtk_entry_new_with_buffer(buffer);
-gtk_entry_set_text(GTK_ENTRY(tmp), text);
-gtk_entry_set_width_chars(GTK_ENTRY(tmp), 0);
 gtk_widget_show(tmp);
 g_object_set_data(G_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
 if(_DWDefaultFont)
 *       id: An ID to be used with dw_window_from_id() or 0L.
 */
 HWND dw_entryfield_password_new(const char *text, ULONG id)
 {
 GtkWidget *tmp;
+GtkEntryBuffer *buffer = gtk_entry_buffer_new(text, -1);
-tmp = gtk_entry_new();
+tmp = gtk_entry_new_with_buffer(buffer);
 gtk_entry_set_visibility(GTK_ENTRY(tmp), FALSE);
-gtk_entry_set_text(GTK_ENTRY(tmp), text);
-gtk_entry_set_width_chars(GTK_ENTRY(tmp), 0);
 gtk_widget_show(tmp);
 g_object_set_data(G_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
 if(_DWDefaultFont)
 *       id: An ID to be used with dw_window_from_id() or 0L.
 */
 HWND dw_combobox_new(const char *text, unsigned long id)
 {
 GtkWidget *tmp;
+GtkEntryBuffer *buffer;
 GtkListStore *store;
 store = gtk_list_store_new(1, G_TYPE_STRING);
 tmp = gtk_combo_box_new_with_model_and_entry(GTK_TREE_MODEL(store));
 gtk_combo_box_set_entry_text_column(GTK_COMBO_BOX(tmp), 0);
-gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(tmp))), text);
+buffer = gtk_entry_get_buffer(GTK_ENTRY(gtk_combo_box_get_child(GTK_COMBO_BOX(tmp))));
-gtk_entry_set_width_chars(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(tmp))), 0);
+gtk_entry_buffer_set_max_length(buffer, 0);
+gtk_entry_buffer_set_text(buffer, text, -1);
 gtk_widget_show(tmp);
 g_object_set_data(G_OBJECT(tmp), "_dw_tree_type", GINT_TO_POINTER(_DW_TREE_TYPE_COMBOBOX));
 g_object_set_data(G_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
 if(_DWDefaultFont)
 dw_window_set_font(tmp, _DWDefaultFont);
 bitmap = dw_bitmap_new(id);
 if(bitmap)
 {
 dw_window_set_bitmap(bitmap, id, NULL);
-gtk_container_add (GTK_CONTAINER(tmp), bitmap);
+gtk_button_set_child(GTK_BUTTON(tmp), bitmap);
 g_object_set_data(G_OBJECT(tmp), "_dw_bitmap", bitmap);
 }
 gtk_widget_show(tmp);
 if(text)
-{
 gtk_widget_set_tooltip_text(tmp, text);
-}
 g_object_set_data(G_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
 return tmp;
 }
 /*
 tmp = gtk_button_new();
 /* Now on to the image stuff */
 bitmap = dw_bitmap_new(id);
 if(bitmap)
 {
-dw_window_set_bitmap( bitmap, 0, filename );
+dw_window_set_bitmap(bitmap, 0, filename);
-gtk_container_add (GTK_CONTAINER(tmp), bitmap);
+gtk_button_set_child(GTK_BUTTON(tmp), bitmap);
 g_object_set_data(G_OBJECT(tmp), "_dw_bitmap", bitmap);
 }
 gtk_widget_show(tmp);
 if(text)
-{
 gtk_widget_set_tooltip_text(tmp, text);
-}
 g_object_set_data(G_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
 return tmp;
 }
 /*
 bitmap = dw_bitmap_new(id);
 if(bitmap)
 {
 dw_window_set_bitmap_from_data(bitmap, 0, data, len);
-gtk_container_add (GTK_CONTAINER(tmp), bitmap);
+gtk_button_set_child(GTK_BUTTON(tmp), bitmap);
 g_object_set_data(G_OBJECT(tmp), "_dw_bitmap", bitmap);
 }
 gtk_widget_show(tmp);
 if(text)
-{
 gtk_widget_set_tooltip_text(tmp, text);
-}
 g_object_set_data(G_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
 return tmp;
 }
 /*
 HWND dw_spinbutton_new(const char *text, unsigned long id)
 {
 GtkAdjustment *adj;
 GtkWidget *tmp;
-adj = (GtkAdjustment *)gtk_adjustment_new ((float)atoi(text), -65536.0, 65536.0, 1.0, 5.0, 0.0);
+adj = (GtkAdjustment *)gtk_adjustment_new((float)atoi(text), -65536.0, 65536.0, 1.0, 5.0, 0.0);
-tmp = gtk_spin_button_new (adj, 0, 0);
+tmp = gtk_spin_button_new(adj, 0, 0);
 gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(tmp), TRUE);
 gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(tmp), TRUE);
 gtk_widget_show(tmp);
 g_object_set_data(G_OBJECT(tmp), "_dw_adjustment", (gpointer)adj);
 g_object_set_data(G_OBJECT(adj), "_dw_spinbutton", (gpointer)tmp);
 *       text: The text to be display by the static text widget.
 *       id: An ID to be used with dw_window_from_id() or 0L.
 */
 HWND dw_radiobutton_new(const char *text, ULONG id)
 {
-/* This will have to be fixed in the future. */
+GtkWidget *tmp = gtk_toggle_button_new_with_label(text);
-GtkWidget *tmp;
-tmp = gtk_radio_button_new_with_label(NULL, text);
 g_object_set_data(G_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
 gtk_widget_show(tmp);
 if(_DWDefaultFont)
 dw_window_set_font(tmp, _DWDefaultFont);
 *       handle: Handle to the window.
 *       id: An ID to be used to specify the icon.
 */
 void dw_window_set_icon(HWND handle, HICN icon)
 {
+/* TODO: figure out how to do this for GTK4 */
+#if GTK3
 GdkPixbuf *icon_pixbuf;
 icon_pixbuf = _find_pixbuf(icon, NULL, NULL);
-if(gtk_widget_get_window(handle) && icon_pixbuf)
+if(icon_pixbuf)
 {
-GList *list = g_list_append(NULL, icon_pixbuf);
+gtk_window_set_icon_name(
-gdk_window_set_icon_list(gtk_widget_get_window(handle), list);
+}
-g_list_free(list);
+#endif
-}
 }
 /*
 * Sets the bitmap used for a given static window.
 * Parameters:
 *       handle: Handle to the window.
 *       text: The text associated with a given window.
 */
 void dw_window_set_text(HWND handle, const char *text)
 {
-GtkWidget *tmp;
-if((tmp = (GtkWidget *)g_object_get_data(G_OBJECT(handle), "_dw_mdi_title")))
-handle = tmp;
 if(GTK_IS_ENTRY(handle))
-gtk_entry_set_text(GTK_ENTRY(handle), text);
+{
+GtkEntryBuffer *buffer = gtk_entry_get_buffer(GTK_ENTRY(handle));
+if(buffer)
+gtk_entry_buffer_set_text(buffer, text, -1);
+}
 else if(GTK_IS_COMBO_BOX(handle))
-gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(handle))), text);
+{
+GtkWidget *entry = gtk_combo_box_get_child(GTK_COMBO_BOX(handle));
+GtkEntryBuffer *buffer = gtk_entry_get_buffer(GTK_ENTRY(entry));
+if(buffer)
+gtk_entry_buffer_set_text(buffer, text, -1);
+}
 else if(GTK_IS_LABEL(handle))
 gtk_label_set_text(GTK_LABEL(handle), text);
 else if(GTK_IS_BUTTON(handle))
-{
 gtk_button_set_label(GTK_BUTTON(handle), text);
-}
+else if(GTK_IS_WINDOW(handle))
-else if(gtk_widget_is_toplevel(handle))
 gtk_window_set_title(GTK_WINDOW(handle), text);
 else if (GTK_IS_FRAME(handle))
 {
 /*
 * This is a groupbox or status_text
 */
 GtkWidget *tmp = (GtkWidget *)g_object_get_data(G_OBJECT(handle), "_dw_label");
-if ( tmp && GTK_IS_LABEL(tmp) )
+if (tmp && GTK_IS_LABEL(tmp))
 gtk_label_set_text(GTK_LABEL(tmp), text);
 else /* assume groupbox */
 gtk_frame_set_label(GTK_FRAME(handle), text && *text ? text : NULL);
 }
 }
 char *dw_window_get_text(HWND handle)
 {
 const char *possible = NULL;
 if(GTK_IS_ENTRY(handle))
-possible = gtk_entry_get_text(GTK_ENTRY(handle));
+{
+GtkEntryBuffer *buffer = gtk_entry_get_buffer(GTK_ENTRY(handle));
+possible = gtk_entry_buffer_get_text(buffer);
+}
 else if(GTK_IS_COMBO_BOX(handle))
-possible = gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(handle))));
+{
+GtkWidget *entry = gtk_combo_box_get_child(GTK_COMBO_BOX(handle));
+GtkEntryBuffer *buffer = gtk_entry_get_buffer(GTK_ENTRY(entry));
+possible = gtk_entry_buffer_get_text(buffer);
+}
 else if(GTK_IS_LABEL(handle))
 possible = gtk_label_get_text(GTK_LABEL(handle));
 return strdup(possible ? possible : "");
 }
 *       handle: Handle to the parent window.
 *       id: Integer ID of the child.
 */
 HWND API dw_window_from_id(HWND handle, int id)
 {
+/* TODO: Figure out how to do this in GTK4 without GtkContainer */
+#if GTK3
 GList *orig = NULL, *list = NULL;
 if(handle && GTK_IS_CONTAINER(handle))
 {
 orig = list = gtk_container_get_children(GTK_CONTAINER(handle));
 }
 list = list->next;
 }
 if(orig)
 g_list_free(orig);
+#endif
 return 0L;
 }
 /*
 * Adds text to an MLE box and returns the current point.
 /* 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))
 gtk_tree_view_columns_autosize(GTK_TREE_VIEW(cont));
 }
-/* Translate the status message into a message on our buddy window */
-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.
 * Parameters:
 *       handle: Window handle that will handle taskbar icon messages.
 *       icon: Icon handle to display in the taskbar.
 *       bubbletext: Text to show when the mouse is above the icon.
 */
 void dw_taskbar_insert(HWND handle, HICN icon, const char *bubbletext)
 {
-GtkStatusIcon *status;
+/* TODO: Removed in GTK4.... no replacement? */
-GdkPixbuf *pixbuf;
-pixbuf = _find_pixbuf(icon, NULL, NULL);
-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);
 }
 /*
 * Deletes an icon from the taskbar.
 * Parameters:
 *       handle: Window handle that was used with dw_taskbar_insert().
 *       icon: Icon handle that was used with dw_taskbar_insert().
 */
 void dw_taskbar_delete(HWND handle, HICN icon)
 {
-GtkStatusIcon *status;
+/* TODO: Removed in GTK4.... no replacement? */
-status = g_object_get_data(G_OBJECT(handle), "_dw_taskbar");
-g_object_unref(G_OBJECT(status));
 }
 /*
 * Creates a rendering context widget (window) to be packed.
 * Parameters:
 HWND dw_render_new(unsigned long id)
 {
 GtkWidget *tmp;
 tmp = gtk_drawing_area_new();
-gtk_widget_set_events(tmp, GDK_EXPOSURE_MASK
-| GDK_LEAVE_NOTIFY_MASK
-| GDK_BUTTON_PRESS_MASK
-| GDK_BUTTON_RELEASE_MASK
-| GDK_KEY_PRESS_MASK
-| GDK_POINTER_MOTION_MASK
-| GDK_POINTER_MOTION_HINT_MASK);
 g_object_set_data(G_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
 gtk_widget_set_can_focus(tmp, TRUE);
 gtk_widget_show(tmp);
 if(_DWDefaultFont)
 dw_window_set_font(tmp, _DWDefaultFont);
 unsigned long API dw_color_choose(unsigned long value)
 {
 GtkColorChooser *cd;
 GdkRGBA color = _internal_color(value);
 unsigned long retcolor = value;
+DWDialog *tmp = dw_dialog_new(NULL);
 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)
+if(DW_POINTER_TO_INT(dw_dialog_wait(tmp)) == 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));
 }
-if(GTK_IS_WIDGET(cd))
+if(GTK_IS_WINDOW(cd))
-g_object_unref(G_OBJECT(cd));
+gtk_window_destroy(GTK_WINDOW(cd));
 return retcolor;
 }
 /* Draw a point on a window (preferably a render window).
 * Parameters:
 GdkDrawingContext *dc = NULL;
 cairo_region_t *clip = NULL;
 if(handle)
 {
+/* TODO: Figure out how to do this in GTK4 with no GdkWindow */
+#if GTK3
 GdkWindow *window = gtk_widget_get_window(handle);
 /* Safety check for non-existant windows */
 if(!window || !GDK_IS_WINDOW(window))
 return;
 clip = gdk_window_get_clip_region(window);
 dc = gdk_window_begin_draw_frame(window, clip);
 cr = gdk_drawing_context_get_cairo_context(dc);
+#endif
 }
 else if(pixmap)
 cr = cairo_create(pixmap->image);
 if(cr)
 {
 cairo_set_line_width(cr, 1);
 cairo_move_to(cr, x, y);
 cairo_stroke(cr);
 if(clip)
 cairo_region_destroy(clip);
+/* TODO: Figure out how to do this in GTK4 with no GdkWindow */
+#if GTK3
 /* 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
-cairo_destroy(cr);
+#else
+if(!dc)
+#endif
+cairo_destroy(cr);
 }
 }
 /* Draw a line on a window (preferably a render window).
 * Parameters:
 GdkDrawingContext *dc = NULL;
 cairo_region_t *clip = NULL;
 if(handle)
 {
+/* TODO: Figure out how to do this in GTK4 with no GdkWindow */
+#if GTK3
+GdkWindow *window = gtk_widget_get_window(handle);
+/* Safety check for non-existant windows */
+if(!window || !GDK_IS_WINDOW(window))
+return;
+clip = gdk_window_get_clip_region(window);
+dc = gdk_window_begin_draw_frame(window, clip);
+cr = gdk_drawing_context_get_cairo_context(dc);
+#endif
+}
+else if(pixmap)
+cr = cairo_create(pixmap->image);
+if(cr)
+{
+GdkRGBA *foreground = pthread_getspecific(_dw_fg_color_key);
+gdk_cairo_set_source_rgba(cr, foreground);
+cairo_set_line_width(cr, 1);
+cairo_move_to(cr, x1, y1);
+cairo_line_to(cr, x2, y2);
+cairo_stroke(cr);
+if(clip)
+cairo_region_destroy(clip);
+/* TODO: Figure out how to do this in GTK4 with no GdkWindow */
+#if GTK3
+/* 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
+#else
+if(!dc)
+#endif
+cairo_destroy(cr);
+}
+}
+/* Draw a closed polygon on a window (preferably a render window).
+* Parameters:
+*       handle: Handle to the window.
+*       pixmap: Handle to the pixmap. (choose only one of these)
+*       flags: DW_DRAW_FILL (1) to fill the polygon or DW_DRAW_DEFAULT (0).
+*       number of points
+*       x[]: X coordinates.
+*       y[]: Y coordinates.
+*/
+void dw_draw_polygon(HWND handle, HPIXMAP pixmap, int flags, int npoints, int *x, int *y)
+{
+cairo_t *cr = NULL;
+int z;
+GdkDrawingContext *dc = NULL;
+cairo_region_t *clip = NULL;
+if(handle)
+{
+/* TODO: Figure out how to do this in GTK4 with no GdkWindow */
+#if GTK3
 GdkWindow *window = gtk_widget_get_window(handle);
 /* Safety check for non-existant windows */
 if(!window || !GDK_IS_WINDOW(window))
 return;
 clip = gdk_window_get_clip_region(window);
 dc = gdk_window_begin_draw_frame(window, clip);
 cr = gdk_drawing_context_get_cairo_context(dc);
+#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, x1, y1);
+cairo_move_to(cr, x[0], y[0]);
-cairo_line_to(cr, x2, y2);
+for(z=1;z<npoints;z++)
+{
+cairo_line_to(cr, x[z], y[z]);
+}
+if(flags & DW_DRAW_FILL)
+cairo_fill(cr);
 cairo_stroke(cr);
 if(clip)
 cairo_region_destroy(clip);
+/* TODO: Figure out how to do this in GTK4 with no GdkWindow */
+#if GTK3
 /* 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
-cairo_destroy(cr);
+#else
-}
+if(!dc)
-}
+#endif
+cairo_destroy(cr);
-/* Draw a closed polygon on a window (preferably a render window).
+}
+}
+/* Draw a rectangle on a window (preferably a render window).
 * Parameters:
 *       handle: Handle to the window.
 *       pixmap: Handle to the pixmap. (choose only one of these)
-*       flags: DW_DRAW_FILL (1) to fill the polygon or DW_DRAW_DEFAULT (0).
+*       flags: DW_DRAW_FILL (1) to fill the box or DW_DRAW_DEFAULT (0).
-*       number of points
+*       x: X coordinate.
-*       x[]: X coordinates.
+*       y: Y coordinate.
-*       y[]: Y coordinates.
+*       width: Width of rectangle.
-*/
+*       height: Height of rectangle.
-void dw_draw_polygon(HWND handle, HPIXMAP pixmap, int flags, int npoints, int *x, int *y)
+*/
+void dw_draw_rect(HWND handle, HPIXMAP pixmap, int flags, int x, int y, int width, int height)
 {
 cairo_t *cr = NULL;
-int z;
 GdkDrawingContext *dc = NULL;
 cairo_region_t *clip = NULL;
 if(handle)
 {
+/* TODO: Figure out how to do this in GTK4 with no GdkWindow */
+#if GTK3
 GdkWindow *window = gtk_widget_get_window(handle);
 /* Safety check for non-existant windows */
 if(!window || !GDK_IS_WINDOW(window))
 return;
 clip = gdk_window_get_clip_region(window);
 dc = gdk_window_begin_draw_frame(window, clip);
 cr = gdk_drawing_context_get_cairo_context(dc);
-}
+#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++)
-{
-cairo_line_to(cr, x[z], y[z]);
-}
-if(flags & DW_DRAW_FILL)
-cairo_fill(cr);
-cairo_stroke(cr);
-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(handle), dc);
-else
-cairo_destroy(cr);
-}
-}
-/* Draw a rectangle on a window (preferably a render window).
-* Parameters:
-*       handle: Handle to the window.
-*       pixmap: Handle to the pixmap. (choose only one of these)
-*       flags: DW_DRAW_FILL (1) to fill the box or DW_DRAW_DEFAULT (0).
-*       x: X coordinate.
-*       y: Y coordinate.
-*       width: Width of rectangle.
-*       height: Height of rectangle.
-*/
-void dw_draw_rect(HWND handle, HPIXMAP pixmap, int flags, int x, int y, int width, int height)
-{
-cairo_t *cr = NULL;
-GdkDrawingContext *dc = NULL;
-cairo_region_t *clip = NULL;
-if(handle)
-{
-GdkWindow *window = gtk_widget_get_window(handle);
-/* Safety check for non-existant windows */
-if(!window || !GDK_IS_WINDOW(window))
-return;
-clip = gdk_window_get_clip_region(window);
-dc = gdk_window_begin_draw_frame(window, clip);
-cr = gdk_drawing_context_get_cairo_context(dc);
 }
 else if(pixmap)
 cr = cairo_create(pixmap->image);
 if(cr)
 {
 if(flags & DW_DRAW_FILL)
 cairo_fill(cr);
 cairo_stroke(cr);
 if(clip)
 cairo_region_destroy(clip);
+/* TODO: Figure out how to do this in GTK4 with no GdkWindow */
+#if GTK3
 /* 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
-cairo_destroy(cr);
+#else
+if(!dc)
+#endif
+cairo_destroy(cr);
 }
 }
 /* Draw an arc on a window (preferably a render window).
 * Parameters:
 GdkDrawingContext *dc = NULL;
 cairo_region_t *clip = NULL;
 if(handle)
 {
+/* TODO: Figure out how to do this in GTK4 with no GdkWindow */
+#if GTK3
 GdkWindow *window = gtk_widget_get_window(handle);
 /* Safety check for non-existant windows */
 if(!window || !GDK_IS_WINDOW(window))
 return;
 clip = gdk_window_get_clip_region(window);
 dc = gdk_window_begin_draw_frame(window, clip);
 cr = gdk_drawing_context_get_cairo_context(dc);
+#endif
 }
 else if(pixmap)
 cr = cairo_create(pixmap->image);
 if(cr)
 {
 if(flags & DW_DRAW_FILL)
 cairo_fill(cr);
 cairo_stroke(cr);
 if(clip)
 cairo_region_destroy(clip);
+/* TODO: Figure out how to do this in GTK4 with no GdkWindow */
+#if GTK3
 /* 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
-cairo_destroy(cr);
+#else
+if(!dc)
+#endif
+cairo_destroy(cr);
 }
 }
 /* Draw text on a window (preferably a render window).
 * Parameters:
 if(!text)
 return;
 if(handle)
 {
+/* TODO: Figure out how to do this in GTK4 with no GdkWindow */
+#if GTK3
 GdkWindow *window = gtk_widget_get_window(handle);
 /* Safety check for non-existant windows */
 if(!window || !GDK_IS_WINDOW(window))
 return;
 clip = gdk_window_get_clip_region(window);
 dc = gdk_window_begin_draw_frame(window, clip);
 cr = gdk_drawing_context_get_cairo_context(dc);
 if((tmpname = (char *)g_object_get_data(G_OBJECT(handle), "_dw_fontname")))
 fontname = tmpname;
+#endif
 }
 else if(pixmap)
 {
 if(pixmap->font)
 fontname = pixmap->font;
 }
 pango_font_description_free(font);
 }
 if(clip)
 cairo_region_destroy(clip);
+/* TODO: Figure out how to do this in GTK4 with no GdkWindow */
+#if GTK3
 /* 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
-cairo_destroy(cr);
+#else
+if(!dc)
+#endif
+cairo_destroy(cr);
 }
 }
 /* Query the width and height of a text string.
 * Parameters:
 }
 font = pango_font_description_from_string(fontname ? fontname : "monospace 10");
 if(font)
 {
-PangoContext *context = gdk_pango_context_get();
+PangoContext *context = pango_context_new();
 if(context)
 {
 PangoLayout *layout = pango_layout_new(context);
 }
 g_object_unref(context);
 }
 pango_font_description_free(font);
 }
-if ( free_fontname )
+if(free_fontname)
-free( fontname );
+free(fontname);
 }
 /*
 * Creates a pixmap with given parameters.
 * Parameters:
 if((!dest && (!destp || !destp->image)) || (!src && (!srcp || !srcp->image)))
 return retval;
 if(dest)
 {
+/* TODO: Figure out how to do this in GTK4 with no GdkWindow */
+#if GTK3
 GdkWindow *window = gtk_widget_get_window(dest);
 /* Safety check for non-existant windows */
 if(!window || !GDK_IS_WINDOW(window))
 return retval;
 clip = gdk_window_get_clip_region(window);
 dc = gdk_window_begin_draw_frame(window, clip);
 cr = gdk_drawing_context_get_cairo_context(dc);
+#endif
 }
 else if(destp)
 cr = cairo_create(destp->image);
 if(cr)
 yscale = (double)height / (double)srcheight;
 cairo_scale(cr, xscale, yscale);
 }
 if(src)
+;
+#ifdef GTK3
 gdk_cairo_set_source_window (cr, gtk_widget_get_window(src), (xdest + xsrc) / xscale, (ydest + ysrc) / yscale);
+#endif
 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(clip)
 cairo_region_destroy(clip);
+/* TODO: Figure out how to do this in GTK4 with no GdkWindow */
+#if GTK3
 /* 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
+#else
+if(!dc)
+#endif
 cairo_destroy(cr);
 retval = DW_ERROR_NONE;
 }
 return retval;
 }
 if(hscrolled)
 *thisheight += 10;
 }
 else
 {
-gtk_widget_get_preferred_height(GTK_WIDGET(widget), NULL, thisheight);
+gtk_widget_measure(GTK_WIDGET(widget), GTK_ORIENTATION_HORIZONTAL, -1, thiswidth, NULL, NULL, NULL);
-gtk_widget_get_preferred_width(GTK_WIDGET(widget), NULL, thiswidth);
+gtk_widget_measure(GTK_WIDGET(widget), GTK_ORIENTATION_VERTICAL, -1, thisheight, NULL, NULL, NULL);
 *thisheight += 20;
 *thiswidth += 20;
 }
 }
 }
 /* Internal box packing function called by the other 3 functions */
 void _dw_box_pack(HWND box, HWND item, int index, int width, int height, int hsize, int vsize, int pad, char *funcname)
 {
-int warn = FALSE;
 GtkWidget *tmp, *tmpitem, *image = NULL;
 if(!box)
 return;
 /* Can't pack nothing with GTK, so create an empty label */
 if(!item)
 {
 item = gtk_label_new("");
 g_object_set_data(G_OBJECT(item), "_dw_padding", GINT_TO_POINTER(1));
-gtk_widget_show_all(item);
+gtk_widget_show(item);
 }
 /* Due to GTK3 minimum size limitations, if we are packing a widget
 * with an image, we need to scale the image down to fit the packed size.
 */
 else if((image = g_object_get_data(G_OBJECT(item), "_dw_bitmap")))
 {
+/* TODO: Figure out how to do this in GTK4 since gtk_image_get_pixbif() is gone...
+* Might need to save the pixbuf in the window data manually.
+*/
+#if GTK3
 GdkPixbuf *pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(image));
 if(pixbuf)
 {
 int pwidth = gdk_pixbuf_get_width(pixbuf);
 if(pwidth > width || pheight > height)
 pixbuf = gdk_pixbuf_scale_simple(pixbuf, pwidth > width ? width : pwidth, pheight > height ? height : pheight, GDK_INTERP_BILINEAR);
 gtk_image_set_from_pixbuf(GTK_IMAGE(image), pixbuf);
 }
+#endif
 }
 /* Check if the item to be packed is a special box */
 tmpitem = (GtkWidget *)g_object_get_data(G_OBJECT(item), "_dw_boxhandle");
 * due to a bug in the OS/2 and Win32 renderer and a limitation
 * of the GtkTable class.
 */
 if(GTK_IS_GRID(item) || (tmpitem && GTK_IS_GRID(tmpitem)))
 {
-GtkWidget *eventbox = (GtkWidget *)g_object_get_data(G_OBJECT(item), "_dw_eventbox");
 /* NOTE: I left in the ability to pack boxes with a size,
 *       this eliminates that by forcing the size to 0.
 */
 height = width = 0;
+/* TODO: Might need to add "_dw_boxpad" to item here */
-if(eventbox)
-{
-int boxpad = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(item), "_dw_boxpad"));
-gtk_container_add(GTK_CONTAINER(eventbox), item);
-gtk_container_set_border_width(GTK_CONTAINER(eventbox), boxpad);
-item = eventbox;
-}
-}
-else
-{
-/* Only show warning if item is not a box */
-warn = TRUE;
 }
 /* Do some sanity bounds checking */
 if(index < 0)
 index = 0;
 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))
+if(GTK_IS_TOGGLE_BUTTON(item))
 {
-GSList *group;
+GtkToggleButton *groupstart = (GtkToggleButton *)g_object_get_data(G_OBJECT(box), "_dw_group");
-GtkWidget *groupstart = (GtkWidget *)g_object_get_data(G_OBJECT(box), "_dw_group");
 if(groupstart)
-{
+gtk_toggle_button_set_group(GTK_TOGGLE_BUTTON(item), groupstart);
-group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(groupstart));
-gtk_radio_button_set_group(GTK_RADIO_BUTTON(item), group);
-}
 else
 g_object_set_data(G_OBJECT(box), "_dw_group", (gpointer)item);
 }
 /* If we previously incremented the reference count... drop it now that it is packed */
 if(g_object_get_data(G_OBJECT(item), "_dw_refed"))
 {
 g_object_unref(G_OBJECT(item));
 g_object_set_data(G_OBJECT(item), "_dw_refed", NULL);
 }
-}
-if(warn)
-{
-if ( width == 0 && hsize == FALSE )
-dw_messagebox(funcname, DW_MB_OK|DW_MB_ERROR, "Width and expand Horizonal both unset for box: %x item: %x",box,item);
-if ( height == 0 && vsize == FALSE )
-dw_messagebox(funcname, DW_MB_OK|DW_MB_ERROR, "Height and expand Vertical both unset for box: %x item: %x",box,item);
 }
 }
 /*
 * Remove windows (widgets) from the box they are packed into.
 {
 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);
+gtk_grid_remove(GTK_GRID(box), item);
 if(boxtype == DW_VERT)
 gtk_grid_remove_row(GTK_GRID(box), index);
 else
 gtk_grid_remove_column(GTK_GRID(box), index);
 retval = item;
 {
 if(!handle)
 return;
 if(GTK_IS_WINDOW(handle))
-gtk_window_set_default_size(handle, width, height);
+gtk_window_set_default_size(GTK_WINDOW(handle), width, height);
 else
-gtk_widget_set_size_request(handle, width, height);
+gtk_widget_set_size_request(GTK_WIDGET(handle), width, height);
 }
 /*
 * Gets the size the system thinks the widget should be.
 * Parameters:
 if(height)
 *height = scrolledheight;
 }
 else
 {
 if(width)
-gtk_widget_get_preferred_width(handle, NULL, width);
+gtk_widget_measure(GTK_WIDGET(handle), GTK_ORIENTATION_HORIZONTAL, -1, width, NULL, NULL, NULL);
 if(height)
-gtk_widget_get_preferred_height(handle, NULL, height);
+gtk_widget_measure(GTK_WIDGET(handle), GTK_ORIENTATION_VERTICAL, -1, height, NULL, NULL, NULL);
 }
 }
 /* Internal version to simplify the code with multiple versions of GTK */
 int _dw_screen_width(void)
 {
 GdkDisplay *display = gdk_display_get_default();
 if(display)
 {
-GdkMonitor *monitor = gdk_display_get_primary_monitor(display);
+/* TODO: Verify this is the correct way to do this */
+GListModel *monitors = gdk_display_get_monitors(display);
+GdkMonitor *monitor = GDK_MONITOR(g_list_model_get_object(monitors, 0));
 if(monitor)
 {
 GdkRectangle rc = { 0, 0, 0 ,0 };
 gdk_monitor_get_geometry(monitor, &rc);
 {
 GdkDisplay *display = gdk_display_get_default();
 if(display)
 {
-GdkMonitor *monitor = gdk_display_get_primary_monitor(display);
+/* TODO: Verify this is the correct way to do this */
+GListModel *monitors = gdk_display_get_monitors(display);
+GdkMonitor *monitor = GDK_MONITOR(g_list_model_get_object(monitors, 0));
 if(monitor)
 {
 GdkRectangle rc = { 0, 0, 0 ,0 };
 gdk_monitor_get_geometry(monitor, &rc);
 }
 /* This should return the current color depth */
 unsigned long dw_color_depth_get(void)
 {
-GdkVisual *vis = gdk_screen_get_system_visual(gdk_screen_get_default());
+/* TODO: Make this work on GTK4... with no GdkVisual */
-return gdk_visual_get_depth(vis);
+return 32;
 }
 /*
 * Sets the gravity of a given window (widget).
 * Gravity controls which corner of the screen and window the position is relative to.
 *          x: X location from the bottom left.
 *          y: Y location from the bottom left.
 */
 void dw_window_set_pos(HWND handle, long x, long y)
 {
+/* TODO: Figure out how to do this in GTK4 with no GdkWindow */
 if(!handle)
 return;
-{
-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);
-}
-width = frame.width;
-height = frame.height;
-}
-}
-else
-{
-/* Check if we have cached frame size values */
-if(!(cx | cy))
-{
-/* If not try to ask the window manager for the estimated size...
-* and finally if all else fails, guess.
-*/
-_dw_get_frame_extents(handle, &cy, &cx);
-/* Cache values for later use */
-g_object_set_data(G_OBJECT(handle), "_dw_frame_width", GINT_TO_POINTER(cx));
-g_object_set_data(G_OBJECT(handle), "_dw_frame_height", GINT_TO_POINTER(cy));
-}
-/* Save the positions for when it is shown */
-g_object_set_data(G_OBJECT(handle), "_dw_x", GINT_TO_POINTER(x));
-g_object_set_data(G_OBJECT(handle), "_dw_y", GINT_TO_POINTER(y));
-g_object_set_data(G_OBJECT(handle), "_dw_pos", GINT_TO_POINTER(1));
-/* Check to see if there is a pending size request too */
-width = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(handle), "_dw_width"));
-height = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(handle), "_dw_height"));
-if(!width || !height)
-{
-/* Ask what GTK is planning on suggesting for the window size */
-gtk_window_get_size(GTK_WINDOW(handle), !width ? &width : NULL, !height ? &height : NULL);
-}
-/* Add the frame size to it */
-width += cx;
-height += cy;
-}
-/* Do any gravity calculations */
-if(horz || vert)
-{
-/* Handle horizontal center gravity */
-if((horz & 0xf) == DW_GRAV_CENTER)
-newx += ((_dw_screen_width() / 2) - (width / 2));
-/* Handle right gravity */
-else if((horz & 0xf) == DW_GRAV_RIGHT)
-newx = _dw_screen_width() - width - x;
-/* Handle vertical center gravity */
-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;
-/* Adjust the values to avoid Gnome bar if requested */
-if((horz | vert) & DW_GRAV_OBSTACLES)
-{
-GdkRectangle rect = { 0, 0, 0, 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);
-}
-if(horz & DW_GRAV_OBSTACLES)
-{
-if((horz & 0xf) == DW_GRAV_LEFT)
-newx += rect.x;
-else if((horz & 0xf) == DW_GRAV_RIGHT)
-newx -= _dw_screen_width() - (rect.x + rect.width);
-}
-if(vert & DW_GRAV_OBSTACLES)
-{
-if((vert & 0xf) == DW_GRAV_TOP)
-newy += rect.y;
-else if((vert & 0xf) == DW_GRAV_BOTTOM)
-newy -= _dw_screen_height() - (rect.y + rect.height);
-}
-}
-}
-/* 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);
-}
 }
 /*
 * Sets the position and size of a given window (widget).
 * Parameters:
 *          width: Width of the widget.
 *          height: Height of the widget.
 */
 void dw_window_get_pos_size(HWND handle, long *x, long *y, ULONG *width, ULONG *height)
 {
-gint gx = 0, gy = 0, gwidth = 0, gheight = 0;
+/* TODO: Figure out how to do this in GTK4 with no GdkWindow */
+if(!handle || !GTK_IS_WIDGET(handle))
-{
+return;
-GdkWindow *window;
+if(width)
-/* Can only query if the window is realized */
+*width = (ULONG)gtk_widget_get_width(GTK_WIDGET(handle));
-if(handle && (window = gtk_widget_get_window(handle)))
+if(height)
-{
+*height = (ULONG)gtk_widget_get_height(GTK_WIDGET(handle));
-/* If it is a toplevel window */
-if(GTK_IS_WINDOW(handle))
-{
-if(gtk_widget_get_mapped(handle))
-{
-GdkRectangle frame;
-/* Calculate the border rectangle */
-gdk_window_get_frame_extents(window, &frame);
-gx = frame.x;
-gy = frame.y;
-gwidth = frame.width;
-gheight = frame.height;
-}
-}
-else
-{
-/* Get an individual widget coordinates */
-gdk_window_get_geometry(window, &gx, &gy, &gwidth, &gheight);
-gdk_window_get_root_origin(window, &gx, &gy);
-}
-}
-}
-/* Fill in the requested fields */
 if(x)
-*x = gx;
+*x = 0;
 if(y)
-*y = gy;
+*y = 0;
-if(width)
-*width = gwidth;
-if(height)
-*height = gheight;
 }
 /*
 * Sets the style of a given window (widget).
 * Parameters:
 }
 else if(GTK_IS_BUTTON(handle))
 {
 if(mask & DW_BS_NOBORDER)
 {
+/* TODO: Figure out how to do this in GTK4 with no Shadow or Relief */
 if(style & DW_BS_NOBORDER)
-{
+;
-gtk_button_set_relief((GtkButton *)handle, GTK_RELIEF_NONE);
-}
 else
-{
+;
-gtk_button_set_relief((GtkButton *)handle, GTK_RELIEF_NORMAL);
-}
 }
 }
-if ( GTK_IS_LABEL(handle2) )
+if(GTK_IS_LABEL(handle2))
 {
 gfloat x=DW_LEFT, y=DW_CENTER;
 /* horizontal... */
 if ( style & DW_DT_CENTER )
 x = DW_CENTER;
 y = DW_TOP;
 if ( style & DW_DT_BOTTOM )
 y = DW_BOTTOM;
 gtk_label_set_xalign(GTK_LABEL(handle2), x);
 gtk_label_set_yalign(GTK_LABEL(handle2), y);
-if ( style & DW_DT_WORDBREAK )
+if(style & DW_DT_WORDBREAK)
-gtk_label_set_line_wrap( GTK_LABEL(handle), TRUE );
+gtk_label_set_wrap(GTK_LABEL(handle), TRUE);
 }
-if ( GTK_IS_CHECK_MENU_ITEM(handle2) && (mask & (DW_MIS_CHECKED | DW_MIS_UNCHECKED)) )
+/* TODO: Convert to GMenuModel */
+#if GTK3
+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)
 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(handle2), check);
 _dw_ignore_click = 0;
 }
-if ( (GTK_IS_CHECK_MENU_ITEM(handle2) || GTK_IS_MENU_ITEM(handle2)) && (mask & (DW_MIS_ENABLED | DW_MIS_DISABLED) ))
+if((GTK_IS_CHECK_MENU_ITEM(handle2) || GTK_IS_MENU_ITEM(handle2)) && (mask & (DW_MIS_ENABLED | DW_MIS_DISABLED)))
 {
 _dw_ignore_click = 1;
 if ( style & DW_MIS_ENABLED )
-gtk_widget_set_sensitive( handle2, TRUE );
+gtk_widget_set_sensitive(handle2, TRUE);
 else
-gtk_widget_set_sensitive( handle2, FALSE );
+gtk_widget_set_sensitive(handle2, FALSE);
 _dw_ignore_click = 0;
 }
+#endif
 }
 /*
 * Adds a new page to specified notebook.
 * Parameters:
 label = gtk_label_new(text ? text : "");
 if(GTK_IS_GRID(page))
 {
 pad = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(page), "_dw_boxpad"));
-gtk_container_set_border_width(GTK_CONTAINER(page), pad);
+/* TODO: Add padding to page with no GtkContainer in GTK4 */
+pad = pad;
 }
 if(realpage != -1)
 gtk_notebook_insert_page(GTK_NOTEBOOK(handle), page, label, realpage);
 else if(num & ~(0xFF))
 {
 GtkWidget *tmp = NULL;
 float *percent = malloc(sizeof(float));
 tmp = gtk_paned_new(type == DW_HORZ ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL);
-gtk_paned_pack1(GTK_PANED(tmp), topleft, TRUE, FALSE);
+gtk_paned_set_start_child(GTK_PANED(tmp), topleft);
-gtk_paned_pack2(GTK_PANED(tmp), bottomright, TRUE, FALSE);
+gtk_paned_set_resize_start_child(GTK_PANED(tmp), TRUE);
+gtk_paned_set_shrink_start_child(GTK_PANED(tmp), FALSE);
+gtk_paned_set_end_child(GTK_PANED(tmp), bottomright);
+gtk_paned_set_resize_end_child(GTK_PANED(tmp), TRUE);
+gtk_paned_set_shrink_end_child(GTK_PANED(tmp), FALSE);
 g_object_set_data(G_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
 *percent = 50.0;
 g_object_set_data(G_OBJECT(tmp), "_dw_percent", (gpointer)percent);
 g_signal_connect(G_OBJECT(tmp), "size-allocate", G_CALLBACK(_splitbar_size_allocate), NULL);
 gtk_widget_show(tmp);
 * Returns:
 *       A handle to a calendar window or NULL on failure.
 */
 HWND dw_calendar_new(unsigned long id)
 {
-GtkWidget *tmp;
+GtkWidget *tmp = gtk_calendar_new();
-GtkCalendarDisplayOptions flags;
+GTimeZone *tz = g_time_zone_new_local();
-time_t now;
+GDateTime *now = g_date_time_new_now(tz);
-struct tm *tmdata;
-tmp = gtk_calendar_new();
 gtk_widget_show(tmp);
 g_object_set_data(G_OBJECT(tmp), "_dw_id", GINT_TO_POINTER(id));
 /* select today */
-flags = GTK_CALENDAR_SHOW_HEADING|GTK_CALENDAR_SHOW_DAY_NAMES;
+gtk_calendar_set_show_day_names(GTK_CALENDAR(tmp), TRUE);
-gtk_calendar_set_display_options( GTK_CALENDAR(tmp), flags );
+gtk_calendar_set_show_heading(GTK_CALENDAR(tmp), TRUE);
-now = time( NULL );
+gtk_calendar_select_day(GTK_CALENDAR(tmp), now);
-tmdata = localtime( & now );
+g_date_time_unref(now);
-gtk_calendar_select_month( GTK_CALENDAR(tmp), tmdata->tm_mon, 1900+tmdata->tm_year );
+g_time_zone_unref(tz);
-gtk_calendar_select_day( GTK_CALENDAR(tmp), tmdata->tm_mday );
 return tmp;
 }
 /*
 * Sets the current date of a calendar
 */
 void dw_calendar_set_date(HWND handle, unsigned int year, unsigned int month, unsigned int day)
 {
 if(GTK_IS_CALENDAR(handle))
 {
-gtk_calendar_select_month(GTK_CALENDAR(handle),month-1,year);
+GTimeZone *tz = g_time_zone_new_local();
-gtk_calendar_select_day(GTK_CALENDAR(handle), day);
+GDateTime *datetime = g_date_time_new(tz, year, month, day, 0, 0, 0);
+gtk_calendar_select_day(GTK_CALENDAR(handle), datetime);
+g_date_time_unref(datetime);
+g_time_zone_unref(tz);
 }
 }
 /*
 * Gets the position of a splitbar (pecentage).
 */
 void dw_calendar_get_date(HWND handle, unsigned int *year, unsigned int *month, unsigned int *day)
 {
 if(GTK_IS_CALENDAR(handle))
 {
-gtk_calendar_get_date(GTK_CALENDAR(handle),year,month,day);
+GDateTime *datetime = gtk_calendar_get_date(GTK_CALENDAR(handle));
-*month = *month + 1;
+if(year)
+*year = g_date_time_get_year(datetime);
+if(month)
+*month = g_date_time_get_month(datetime);
+if(day)
+*day = g_date_time_get_day_of_month(datetime);
 }
 }
 /*
 * Sets the current focus item for a window/dialog.
 GtkFileFilter *filter1 = NULL;
 GtkFileFilter *filter2 = NULL;
 gchar *button;
 char *filename = NULL;
 char buf[1000];
-char mypath[PATH_MAX+1];
+DWDialog *tmp = dw_dialog_new(NULL);
 switch (flags )
 {
 case DW_DIRECTORY_OPEN:
 action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
 action,
 _("_Cancel"), GTK_RESPONSE_CANCEL,
 button, GTK_RESPONSE_ACCEPT,
 NULL);
-if ( flags == DW_FILE_SAVE )
+if(ext)
-gtk_file_chooser_set_do_overwrite_confirmation( GTK_FILE_CHOOSER( filew ), TRUE );
-if ( ext )
 {
 filter1 = gtk_file_filter_new();
 sprintf( buf, "*.%s", ext );
 gtk_file_filter_add_pattern( filter1, (gchar *)buf );
 sprintf( buf, "\"%s\" files", ext );
 gtk_file_filter_set_name( filter2, (gchar *)"All Files" );
 gtk_file_chooser_add_filter( GTK_FILE_CHOOSER( filew ), filter1 );
 gtk_file_chooser_add_filter( GTK_FILE_CHOOSER( filew ), filter2 );
 }
-if ( defpath )
+if(defpath)
 {
-struct stat buf;
+GFile *path = g_file_new_for_path(defpath);
-if ( g_path_is_absolute( defpath ) || !realpath(defpath, mypath))
-{
-strcpy( mypath, defpath );
-}
 /* See if the path exists */
-if(stat(mypath, &buf) == 0)
+if(path)
 {
 /* 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), path, NULL);
-gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( filew ), mypath );
+gtk_file_chooser_set_file(GTK_FILE_CHOOSER(filew), path, NULL);
-else if(flags == DW_FILE_SAVE) /* Otherwise set the filename */
-gtk_file_chooser_set_filename( GTK_FILE_CHOOSER( filew ), mypath );
+g_object_unref(G_OBJECT(path));
-else if(flags == DW_FILE_OPEN)
+}
-gtk_file_chooser_select_filename( GTK_FILE_CHOOSER( filew), mypath );
+}
-}
-else if(flags == DW_FILE_SAVE)
+/* TODO: Connect signal handlers so this actually returns */
-{
+if(DW_POINTER_TO_INT(dw_dialog_wait(tmp)) == GTK_RESPONSE_ACCEPT)
-if(strchr(mypath, '/'))
+{
-{
+GFile *file = gtk_file_chooser_get_file(GTK_FILE_CHOOSER(filew));
-unsigned long x = strlen(mypath) - 1;
+filename = g_file_get_path(file);
+g_object_unref(G_OBJECT(file));
-/* Trim off the filename */
+}
-while(x > 0 && mypath[x] != '/')
-{
+if(GTK_IS_WINDOW(filew))
-x--;
+gtk_window_destroy(GTK_WINDOW(filew));
-}
-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 );
-}
-}
-}
-}
-if ( gtk_dialog_run( GTK_DIALOG( filew ) ) == GTK_RESPONSE_ACCEPT )
-{
-filename = gtk_file_chooser_get_filename( GTK_FILE_CHOOSER( filew ) );
-/*g_free (filename);*/
-}
-if(GTK_IS_WIDGET(filew))
-g_object_unref(G_OBJECT(filew));
 return filename;
 }
 /*
 *       url: Uniform resource locator.
 */
 int dw_browse(const char *url)
 {
 /* If possible load the URL/URI using gvfs... */
-#if GTK_CHECK_VERSION(3,22,0)
+gtk_show_uri(NULL, url, GDK_CURRENT_TIME);
-if(gtk_show_uri_on_window(NULL, url, GDK_CURRENT_TIME, NULL))
+return DW_ERROR_NONE;
-#else
-if(gtk_show_uri(gdk_screen_get_default(), url, GDK_CURRENT_TIME, NULL))
-#endif
-{
-return DW_ERROR_NONE;
-}
-else
-{
-/* Otherwise just fall back to executing firefox...
-* or the browser defined by the DW_BROWSER variable.
-*/
-char *execargs[3], *browser = "firefox", *tmp;
-tmp = getenv( "DW_BROWSER" );
-if(tmp) browser = tmp;
-execargs[0] = browser;
-execargs[1] = (char *)url;
-execargs[2] = NULL;
-return dw_exec(browser, DW_EXEC_GUI, execargs);
-}
 }
 #ifdef USE_WEBKIT
 /* Helper function to get the web view handle */
 WebKitWebView *_dw_html_web_view(GtkWidget *widget)
 *       Pointer to an allocated string of text or NULL if clipboard empty or contents could not
 *       be converted to text.
 */
 char *dw_clipboard_get_text()
 {
-GtkClipboard *clipboard_object;
+GdkDisplay *display = gdk_display_get_default();
+GdkClipboard *clipboard_object;
 char *ret = NULL;
-if((clipboard_object = gtk_clipboard_get( GDK_SELECTION_CLIPBOARD )))
+if((clipboard_object = gdk_display_get_clipboard(display)))
 {
+/* TODO: Finish conversion to GdkClipboard */
+#if GTK3
 gchar *clipboard_contents;
 if((clipboard_contents = gtk_clipboard_wait_for_text( clipboard_object )))
 {
 ret = strdup((char *)clipboard_contents);
 g_free(clipboard_contents);
 }
+#endif
 }
 return ret;
 }
 /*
 * Parameters:
 *       Text.
 */
 void  dw_clipboard_set_text(const char *str, int len)
 {
-GtkClipboard *clipboard_object;
+GdkDisplay *display = gdk_display_get_default();
+GdkClipboard *clipboard_object;
-if((clipboard_object = gtk_clipboard_get( GDK_SELECTION_CLIPBOARD )))
-{
+if((clipboard_object = gdk_display_get_clipboard(display)))
+{
+/* TODO: Finish conversion to GdkClipboard */
+#if GTK3
 gtk_clipboard_set_text( clipboard_object, str, len );
+#endif
 }
 }
 /* Internal function to create the drawable pixmap and call the function */
 static void _dw_draw_page(GtkPrintOperation *operation, GtkPrintContext *context, int page_nr)
 if (strcmp(signame, DW_SIGNAL_EXPOSE) == 0)
 {
 thisname = "draw";
 }
+/* TODO: Convert to GMenuModel */
+#if GTK3
 else if (GTK_IS_MENU_ITEM(thiswindow) && strcmp(signame, DW_SIGNAL_CLICKED) == 0)
 {
 thisname = "activate";
 thisfunc = _findsigfunc(thisname);
 }
+#endif
 else if (GTK_IS_TREE_VIEW(thiswindow)  && strcmp(signame, DW_SIGNAL_ITEM_CONTEXT) == 0)
 {
 sigid = _set_signal_handler(thiswindow, window, sigfunc, data, thisfunc, discfunc);
 params[0] = GINT_TO_POINTER(sigid);
 params[2] = (void *)thiswindow;
 }
 else if (strcmp(signame, DW_SIGNAL_SET_FOCUS) == 0)
 {
 thisname = "focus-in-event";
 if (GTK_IS_COMBO_BOX(thiswindow))
-thiswindow = gtk_bin_get_child(GTK_BIN(thiswindow));
+thiswindow = gtk_combo_box_get_child(GTK_COMBO_BOX(thiswindow));
 }
 #ifdef USE_WEBKIT
 else if (WEBKIT_IS_WEB_VIEW(thiswindow) && strcmp(signame, DW_SIGNAL_HTML_CHANGED) == 0)
 {
 thisname = "load-changed";

Mercurial > dwindows

comparison gtk4/dw.c @ 2266:bb0690c04413