}
GtkWidget *
-shape_create_icon (char *xpm_file,
- gint x,
- gint y,
- gint px,
- gint py,
- gint window_type);
+shape_create_icon (GdkScreen *screen,
+ char *xpm_file,
+ gint x,
+ gint y,
+ gint px,
+ gint py,
+ gint window_type);
static GtkWidget *
-build_option_menu (gchar *items[],
- gint num_items,
- gint history,
- void (*func)(GtkWidget *widget, gpointer data),
- gpointer data);
+build_option_menu (gchar *items[],
+ gint num_items,
+ gint history,
+ void (*func)(GtkWidget *widget, gpointer data),
+ gpointer data);
/* macro, structure and variables used by tree window demos */
#define DEFAULT_NUMBER_OF_ITEM 3
/* end of tree section */
static GtkWidget *
-build_option_menu (gchar *items[],
- gint num_items,
- gint history,
- void (*func)(GtkWidget *widget, gpointer data),
- gpointer data)
+build_option_menu (gchar *items[],
+ gint num_items,
+ gint history,
+ void (*func)(GtkWidget *widget, gpointer data),
+ gpointer data)
{
GtkWidget *omenu;
GtkWidget *menu;
}
static void
-create_big_windows (void)
+create_big_windows (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *darea, *table, *scrollbar;
GtkAdjustment *vadj;
static gint current_x;
static gint current_y;
-
+
if (!window)
{
current_x = 0;
GTK_STOCK_CLOSE,
GTK_RESPONSE_NONE,
NULL);
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_window_set_default_size (GTK_WINDOW (window), 200, 300);
}
static void
-create_buttons (void)
+create_buttons (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
*/
static void
-create_toggle_buttons (void)
+create_toggle_buttons (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
*/
static void
-create_check_buttons (void)
+create_check_buttons (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *button;
GtkWidget *separator;
-
+
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
*/
static void
-create_radio_buttons (void)
+create_radio_buttons (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
}
static void
-create_button_box (void)
+create_button_box (GtkWidget *widget)
{
static GtkWidget* window = NULL;
GtkWidget *main_vbox;
GtkWidget *hbox;
GtkWidget *frame_horz;
GtkWidget *frame_vert;
-
+
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (widget));
gtk_window_set_title (GTK_WINDOW (window), "Button Boxes");
gtk_signal_connect (GTK_OBJECT (window), "destroy",
}
static void
-create_toolbar (void)
+create_toolbar (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *toolbar;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
}
static void
-create_statusbar (void)
+create_statusbar (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
}
static void
-create_tree_sample(guint selection_mode,
+create_tree_sample(GdkScreen *screen, guint selection_mode,
guint draw_line, guint view_line, guint no_root_item,
guint nb_item_max, guint recursion_level_max)
{
/* create top level window */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window), screen);
gtk_window_set_title(GTK_WINDOW(window), "Tree Sample");
gtk_signal_connect(GTK_OBJECT(window), "destroy",
(GtkSignalFunc) cb_tree_destroy_event, NULL);
return;
}
- create_tree_sample(selection_mode, draw_line, view_line, no_root_item, nb_item, recursion_level);
+ create_tree_sample(gtk_widget_get_screen (w),
+ selection_mode, draw_line,
+ view_line, no_root_item, nb_item, recursion_level);
}
void
-create_tree_mode_window(void)
+create_tree_mode_window(GtkWidget *widget)
{
static GtkWidget* window;
GtkWidget* box1;
{
/* create toplevel window */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_window_set_title(GTK_WINDOW(window), "Set Tree Parameters");
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
"Reset", 1,
GTK_STOCK_CLOSE, GTK_RESPONSE_NONE,
NULL);
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (GTK_WIDGET (dialog)));
g_free (title);
g_signal_connect (window, "response",
G_CALLBACK (gridded_geometry_subresponse), geometry_string);
}
static void
-create_gridded_geometry (void)
+create_gridded_geometry (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *entry;
"Create", 1,
GTK_STOCK_CLOSE, GTK_RESPONSE_NONE,
NULL);
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
label = gtk_label_new ("Geometry string:");
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label, FALSE, FALSE, 0);
}
static void
-create_handle_box (void)
+create_handle_box (GtkWidget *widget)
{
static GtkWidget* window = NULL;
GtkWidget *handle_box;
GtkWidget *toolbar;
GtkWidget *label;
GtkWidget *separator;
-
+
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_window_set_title (GTK_WINDOW (window),
"Handle Box Test");
gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
}
static void
-create_get_image (void)
+create_get_image (GtkWidget *widget)
{
static GtkWidget *window = NULL;
gid = g_new (struct GetImageData, 1);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_signal_connect (GTK_OBJECT (window),
"destroy",
return button;
}
-void create_labels (void)
+void create_labels (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *label;
GtkWidget *button;
-
+
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
}
static void
-create_reparent (void)
+create_reparent (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
}
static void
-create_saved_position (void)
+create_saved_position (GtkWidget *widget)
{
static GtkWidget *window = NULL;
"signal::configure_event", uposition_configure, NULL,
NULL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
&window);
*/
static void
-create_pixmap (void)
+create_pixmap (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
}
static void
-create_tooltips (void)
+create_tooltips (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
"GtkWidget::width", 200,
NULL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (destroy_tooltips),
&window);
}
static void
-create_image (void)
+create_image (GtkWidget *widget)
{
static GtkWidget *window = NULL;
-
+
if (window == NULL)
{
GtkWidget *vbox;
GdkBitmap *mask;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
/* this is bogus for testing drawing when allocation < request,
* don't copy into real code
*/
*/
static GtkWidget*
-create_menu (gint depth, gint length, gboolean tearoff)
+create_menu (GdkScreen *screen, gint depth, gint length, gboolean tearoff)
{
GtkWidget *menu;
GtkWidget *menuitem;
return NULL;
menu = gtk_menu_new ();
+ gtk_menu_set_screen (GTK_MENU (menu), screen);
+
group = NULL;
if (tearoff)
TRUE);
if (i < 5)
- gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1, 5, TRUE));
+ gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem),
+ create_menu (screen, depth - 1, 5, TRUE));
}
return menu;
}
static void
-create_menus (void)
+create_menus (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *menuitem;
GtkAccelGroup *accel_group;
GtkWidget *image;
+ GdkScreen *screen = gtk_widget_get_screen (widget);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_window_set_screen (GTK_WINDOW (window), screen);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
gtk_widget_show (menubar);
- menu = create_menu (2, 50, TRUE);
+ menu = create_menu (screen, 2, 50, TRUE);
menuitem = gtk_menu_item_new_with_label ("test\nline2");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("foo");
- gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3, 5, TRUE));
+ gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (screen, 3, 5, TRUE));
gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
gtk_widget_show (menuitem);
gtk_widget_show (image);
menuitem = gtk_image_menu_item_new_with_label ("Help");
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
- gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, 5, TRUE));
+ gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (screen, 4, 5, TRUE));
gtk_menu_item_set_right_justified (GTK_MENU_ITEM (menuitem), TRUE);
gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
gtk_widget_show (menuitem);
gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
gtk_widget_show (menubar);
- menu = create_menu (2, 10, TRUE);
+ menu = create_menu (screen, 2, 10, TRUE);
menuitem = gtk_menu_item_new_with_label ("Second menu bar");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
- menu = create_menu (1, 5, FALSE);
+ menu = create_menu (screen, 1, 5, FALSE);
gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_NEW, accel_group);
static int nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
static void
-create_item_factory (void)
+create_item_factory (GtkWidget *widget)
{
static GtkWidget *window = NULL;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
}
static void
-create_key_lookup (void)
+create_key_lookup (GtkWidget *widget)
{
static GtkWidget *window = NULL;
-
+
if (!window)
{
GtkAccelGroup *accel_group = gtk_accel_group_new ();
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
/* We have to expand it so the accel labels will draw their labels
*/
gtk_window_set_default_size (GTK_WINDOW (window), 300, -1);
csd=gtk_color_selection_dialog_new ("This is a modal color selection dialog");
+ gtk_window_set_screen (GTK_WINDOW (csd), gtk_widget_get_screen (parent));
+
gtk_color_selection_set_has_palette (GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (csd)->colorsel),
TRUE);
fs = gtk_file_selection_new("This is a modal file selection dialog");
+ gtk_window_set_screen (GTK_WINDOW (fs), gtk_widget_get_screen (parent));
+
/* Set as modal */
gtk_window_set_modal (GTK_WINDOW(fs),TRUE);
static void
-create_modal_window (void)
+create_modal_window (GtkWidget *widget)
{
GtkWidget *window = NULL;
GtkWidget *box1,*box2;
GtkWidget *btnColor,*btnFile,*btnClose;
/* Create modal window (Here you can use any window descendent )*/
- window=gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_window_set_title (GTK_WINDOW(window),"This window is modal");
/* Set window as modal */
*/
static void
-make_message_dialog (GtkWidget **dialog,
+make_message_dialog (GdkScreen *screen,
+ GtkWidget **dialog,
GtkMessageType type,
GtkButtonsType buttons,
guint default_response)
*dialog = gtk_message_dialog_new (NULL, 0, type, buttons,
"This is a message dialog; it can wrap long lines. This is a long line. La la la. Look this line is wrapped. Blah blah blah blah blah blah. (Note: testgtk has a nonstandard gtkrc that changes some of the message dialog icons.)");
+ gtk_window_set_screen (GTK_WINDOW (*dialog), screen);
+
gtk_signal_connect_object (GTK_OBJECT (*dialog),
"response",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
}
static void
-create_message_dialog (void)
+create_message_dialog (GtkWidget *widget)
{
static GtkWidget *info = NULL;
static GtkWidget *warning = NULL;
static GtkWidget *error = NULL;
static GtkWidget *question = NULL;
+ GdkScreen *screen = gtk_widget_get_screen (widget);
- make_message_dialog (&info, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, GTK_RESPONSE_OK);
- make_message_dialog (&warning, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, GTK_RESPONSE_OK);
- make_message_dialog (&error, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK_CANCEL, GTK_RESPONSE_OK);
- make_message_dialog (&question, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, GTK_RESPONSE_YES);
+ make_message_dialog (screen, &info, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, GTK_RESPONSE_OK);
+ make_message_dialog (screen, &warning, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, GTK_RESPONSE_OK);
+ make_message_dialog (screen, &error, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK_CANCEL, GTK_RESPONSE_OK);
+ make_message_dialog (screen, &question, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, GTK_RESPONSE_YES);
}
/*
{
sw_parent = scrollwin->parent;
sw_float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (sw_float_parent),
+ gtk_widget_get_screen (widget));
+
gtk_window_set_default_size (GTK_WINDOW (sw_float_parent), 200, 200);
gtk_widget_reparent (scrollwin, sw_float_parent);
}
static void
-create_scrolled_windows (void)
+create_scrolled_windows (GtkWidget *widget)
{
static GtkWidget *window;
GtkWidget *scrolled_window;
{
window = gtk_dialog_new ();
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
}
static void
-create_entry (void)
+create_entry (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
cbitems = g_list_append(cbitems, "item9 item9");
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
}
static GtkWidget *
-create_size_group_window (GtkSizeGroup *master_size_group)
+create_size_group_window (GdkScreen *screen,
+ GtkSizeGroup *master_size_group)
{
GtkWidget *window;
GtkWidget *table;
GTK_RESPONSE_NONE,
NULL);
+ gtk_window_set_screen (GTK_WINDOW (window), screen);
+
gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
gtk_signal_connect (GTK_OBJECT (window), "response",
}
static void
-create_size_groups (void)
+create_size_groups (GtkWidget *widget)
{
static GtkWidget *window1 = NULL;
static GtkWidget *window2 = NULL;
if (!master_size_group)
master_size_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
-
+
if (!window1)
{
- window1 = create_size_group_window (master_size_group);
+ window1 = create_size_group_window (gtk_widget_get_screen (widget),
+ master_size_group);
gtk_signal_connect (GTK_OBJECT (window1), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
if (!window2)
{
- window2 = create_size_group_window (master_size_group);
+ window2 = create_size_group_window (gtk_widget_get_screen (widget),
+ master_size_group);
gtk_signal_connect (GTK_OBJECT (window2), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
}
static void
-create_spins (void)
+create_spins (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *frame;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
else
gtk_label_set_text (GTK_LABEL (label), "<unknown>");
- cursor = gdk_cursor_new (c);
+ cursor = gdk_cursor_new_for_screen (gtk_widget_get_screen (widget), c);
gdk_window_set_cursor (widget->window, cursor);
gdk_cursor_unref (cursor);
}
}
static void
-create_cursors (void)
+create_cursors (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *frame;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
}
static void
-create_list (void)
+create_list (GtkWidget *widget)
{
static GtkWidget *window = NULL;
"Browse",
"Multiple"
};
-
+
if (!window)
{
GtkWidget *cbox;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
}
static void
-create_clist (void)
+create_clist (GtkWidget *widget)
{
gint i;
static GtkWidget *window = NULL;
{
clist_rows = 0;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window);
* GtkCTree
*/
-GdkPixmap *pixmap1;
-GdkPixmap *pixmap2;
-GdkPixmap *pixmap3;
-GdkBitmap *mask1;
-GdkBitmap *mask2;
-GdkBitmap *mask3;
+typedef struct
+{
+ GdkPixmap *pixmap1;
+ GdkPixmap *pixmap2;
+ GdkPixmap *pixmap3;
+ GdkBitmap *mask1;
+ GdkBitmap *mask2;
+ GdkBitmap *mask3;
+} CTreePixmaps;
static gint books = 0;
static gint pages = 0;
static GtkWidget *spin3;
static gint line_style;
+
+static CTreePixmaps *
+get_ctree_pixmaps (GtkCTree *ctree)
+{
+ GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (ctree));
+ CTreePixmaps *pixmaps = g_object_get_data (G_OBJECT (screen), "ctree-pixmaps");
+
+ if (!pixmaps)
+ {
+ GdkColormap *colormap = gdk_screen_get_rgb_colormap (screen);
+ pixmaps = g_new (CTreePixmaps, 1);
+
+ pixmaps->pixmap1 = gdk_pixmap_colormap_create_from_xpm_d (NULL, colormap,
+ &pixmaps->mask1,
+ NULL, book_closed_xpm);
+ pixmaps->pixmap2 = gdk_pixmap_colormap_create_from_xpm_d (NULL, colormap,
+ &pixmaps->mask2,
+ NULL, book_open_xpm);
+ pixmaps->pixmap3 = gdk_pixmap_colormap_create_from_xpm_d (NULL, colormap,
+ &pixmaps->mask3,
+ NULL, mini_page_xpm);
+
+ g_object_set_data (G_OBJECT (screen), "ctree-pixmaps", pixmaps);
+ }
+
+ return pixmaps;
+}
+
void after_press (GtkCTree *ctree, gpointer data)
{
char buf[80];
GdkBitmap *mask_closed;
GdkPixmap *pixmap_opened;
GdkBitmap *mask_opened;
+ CTreePixmaps *pixmaps;
if (!cnode || !gnode || (!(es = gnode->data)))
return FALSE;
+ pixmaps = get_ctree_pixmaps (ctree);
+
if (es->is_leaf)
{
- pixmap_closed = pixmap3;
- mask_closed = mask3;
+ pixmap_closed = pixmaps->pixmap3;
+ mask_closed = pixmaps->mask3;
pixmap_opened = NULL;
mask_opened = NULL;
}
else
{
- pixmap_closed = pixmap1;
- mask_closed = mask1;
- pixmap_opened = pixmap2;
- mask_opened = mask2;
+ pixmap_closed = pixmaps->pixmap1;
+ mask_closed = pixmaps->mask1;
+ pixmap_opened = pixmaps->pixmap2;
+ mask_opened = pixmaps->mask2;
}
gtk_ctree_set_node_info (ctree, cnode, es->tree, 2, pixmap_closed,
if (!export_window)
{
export_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_window_set_screen (GTK_WINDOW (export_window),
+ gtk_widget_get_screen (widget));
gtk_signal_connect (GTK_OBJECT (export_window), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
gchar buf1[60];
gchar buf2[60];
GtkCTreeNode *sibling;
+ CTreePixmaps *pixmaps;
gint i;
text[0] = buf1;
text[1] = buf2;
sibling = NULL;
+ pixmaps = get_ctree_pixmaps (ctree);
+
for (i = num_pages + num_books; i > num_books; i--)
{
pages++;
sprintf (buf1, "Page %02d", (gint) rand() % 100);
sprintf (buf2, "Item %d-%d", cur_depth, i);
sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
- pixmap3, mask3, NULL, NULL,
+ pixmaps->pixmap3, pixmaps->mask3, NULL, NULL,
TRUE, FALSE);
if (parent && ctree->line_style == GTK_CTREE_LINES_TABBED)
sprintf (buf1, "Book %02d", (gint) rand() % 100);
sprintf (buf2, "Item %d-%d", cur_depth, i);
sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
- pixmap1, mask1, pixmap2, mask2,
+ pixmaps->pixmap1, pixmaps->mask1, pixmaps->pixmap2, pixmaps->mask2,
FALSE, FALSE);
style = gtk_style_new ();
GtkCTreeNode *parent;
GtkStyle *style;
guint b, d, p, n;
+ CTreePixmaps *pixmaps;
+
+ pixmaps = get_ctree_pixmaps (ctree);
text[0] = label1;
text[1] = label2;
books = 1;
pages = 0;
- parent = gtk_ctree_insert_node (ctree, NULL, NULL, text, 5, pixmap1,
- mask1, pixmap2, mask2, FALSE, TRUE);
+ parent = gtk_ctree_insert_node (ctree, NULL, NULL, text, 5, pixmaps->pixmap1,
+ pixmaps->mask1, pixmaps->pixmap2, pixmaps->mask2, FALSE, TRUE);
style = gtk_style_new ();
style->base[GTK_STATE_NORMAL].red = 0;
gtk_ctree_sort_recursive (ctree, NULL);
}
-void create_ctree (void)
+void create_ctree (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkTooltips *tooltips;
GtkWidget *check;
GtkAdjustment *adj;
GtkWidget *spinner;
- GdkColor transparent = { 0 };
char *title[] = { "Tree" , "Info" };
char buf[80];
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
NULL);
gtk_widget_realize (window);
-
- if (!pixmap1)
- pixmap1 = gdk_pixmap_create_from_xpm_d (window->window, &mask1,
- &transparent, book_closed_xpm);
- if (!pixmap2)
- pixmap2 = gdk_pixmap_create_from_xpm_d (window->window, &mask2,
- &transparent, book_open_xpm);
- if (!pixmap3)
- pixmap3 = gdk_pixmap_create_from_xpm_d (window->window, &mask3,
- &transparent, mini_page_xpm);
-
+
gtk_widget_set_usize (GTK_WIDGET (ctree), 0, 300);
frame = gtk_frame_new (NULL);
}
void
-create_color_selection (void)
+create_color_selection (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *check_button;
window = gtk_color_selection_dialog_new ("color selection dialog");
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_widget_show (GTK_COLOR_SELECTION_DIALOG (window)->help_button);
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
}
void
-create_file_selection (void)
+create_file_selection (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *button;
if (!window)
{
window = gtk_file_selection_new ("file selection dialog");
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window));
}
void
-create_flipping (void)
+create_flipping (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *check_button, *button;
{
window = gtk_dialog_new ();
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
}
static void
-create_focus (void)
+create_focus (GtkWidget *widget)
{
static GtkWidget *window = NULL;
-
+
if (!window)
{
GtkWidget *table;
GTK_RESPONSE_NONE,
NULL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
&window);
}
void
-create_font_selection (void)
+create_font_selection (GtkWidget *widget)
{
static GtkWidget *window = NULL;
if (!window)
{
window = gtk_font_selection_dialog_new ("Font Selection Dialog");
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
}
static void
-create_dialog (void)
+create_dialog (GtkWidget *widget)
{
static GtkWidget *label;
GtkWidget *button;
*/
dialog_window = gtk_dialog_new ();
+ gtk_window_set_screen (GTK_WINDOW (dialog_window),
+ gtk_widget_get_screen (widget));
gtk_signal_connect (GTK_OBJECT (dialog_window),
"response",
gtk_widget_destroy (dialog_window);
}
+/* Display & Screen test
+ */
+
+typedef struct
+{
+ GtkEntry *entry;
+ GtkWidget *radio_dpy;
+ GtkWidget *toplevel;
+ GtkWidget *dialog_window;
+ GList *valid_display_list;
+} ScreenDisplaySelection;
+
+static gint
+display_name_cmp (gconstpointer a,
+ gconstpointer b)
+{
+ return g_ascii_strcasecmp (a,b);
+}
+
+static void
+screen_display_check (GtkWidget *widget, ScreenDisplaySelection *data)
+{
+ char *display_name;
+ GdkDisplay *display = gtk_widget_get_display (widget);
+ GtkWidget *dialog;
+ GdkScreen *new_screen = NULL;
+ GdkScreen *current_screen = gtk_widget_get_screen (widget);
+
+ if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->radio_dpy)))
+ {
+ display_name = g_strdup (gtk_entry_get_text (data->entry));
+ display = gdk_open_display (display_name);
+
+ if (!display)
+ {
+ dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (widget)),
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_MESSAGE_ERROR,
+ GTK_BUTTONS_OK,
+ "The display :\n%s\ncannot be opened",
+ display_name);
+ gtk_window_set_screen (GTK_WINDOW (dialog), current_screen);
+ gtk_widget_show (dialog);
+ g_signal_connect (G_OBJECT (dialog), "response",
+ G_CALLBACK (gtk_widget_destroy),
+ NULL);
+ }
+ else
+ {
+ if (!g_list_find_custom (data->valid_display_list,
+ display_name,
+ display_name_cmp))
+ data->valid_display_list = g_list_append (data->valid_display_list,
+ display_name);
+
+ new_screen = gdk_display_get_default_screen (display);
+ }
+ }
+ else
+ {
+ gint number_of_screens = gdk_display_get_n_screens (display);
+ gint screen_num = gdk_screen_get_number (current_screen);
+ if ((screen_num +1) < number_of_screens)
+ new_screen = gdk_display_get_screen (display, screen_num + 1);
+ else
+ new_screen = gdk_display_get_screen (display, 0);
+ }
+
+ if (new_screen)
+ {
+ gtk_window_set_screen (GTK_WINDOW (data->toplevel), new_screen);
+ gtk_widget_destroy (data->dialog_window);
+ }
+}
+
+void
+screen_display_destroy_diag (GtkWidget *widget, GtkWidget *data)
+{
+ gtk_widget_destroy (data);
+}
+
+void
+create_display_screen (GtkWidget *widget)
+{
+ GtkWidget *table, *frame, *window, *combo_dpy, *vbox;
+ GtkWidget *radio_dpy, *radio_scr, *applyb, *cancelb;
+ GtkWidget *bbox;
+ ScreenDisplaySelection *scr_dpy_data;
+ GdkScreen *screen = gtk_widget_get_screen (widget);
+ static GList *valid_display_list = NULL;
+
+ GdkDisplay *display = gdk_screen_get_display (screen);
+
+ window = gtk_widget_new (gtk_window_get_type (),
+ "screen", screen,
+ "user_data", NULL,
+ "type", GTK_WINDOW_TOPLEVEL,
+ "title",
+ "Screen or Display selection",
+ "border_width", 10, NULL);
+ g_signal_connect (G_OBJECT (window), "destroy",
+ G_CALLBACK (gtk_widget_destroy), NULL);
+
+ vbox = gtk_vbox_new (FALSE, 3);
+ gtk_container_add (GTK_CONTAINER (window), vbox);
+
+ frame = gtk_frame_new ("Select screen or display");
+ gtk_container_add (GTK_CONTAINER (vbox), frame);
+
+ table = gtk_table_new (2, 2, TRUE);
+ gtk_table_set_row_spacings (GTK_TABLE (table), 3);
+ gtk_table_set_col_spacings (GTK_TABLE (table), 3);
+
+ gtk_container_add (GTK_CONTAINER (frame), table);
+
+ radio_dpy = gtk_radio_button_new_with_label (NULL, "move to another X display");
+ if (gdk_display_get_n_screens(display) > 1)
+ radio_scr = gtk_radio_button_new_with_label
+ (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_dpy)), "move to next screen");
+ else
+ {
+ radio_scr = gtk_radio_button_new_with_label
+ (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_dpy)),
+ "only one screen on the current display");
+ gtk_widget_set_sensitive (radio_scr, FALSE);
+ }
+ combo_dpy = gtk_combo_new ();
+ if (!valid_display_list)
+ valid_display_list = g_list_append (valid_display_list, "diabolo:0.0");
+
+ gtk_combo_set_popdown_strings (GTK_COMBO (combo_dpy), valid_display_list);
+
+ gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (combo_dpy)->entry),
+ "<hostname>:<X Server Num>.<Screen Num>");
+
+ gtk_table_attach_defaults (GTK_TABLE (table), radio_dpy, 0, 1, 0, 1);
+ gtk_table_attach_defaults (GTK_TABLE (table), radio_scr, 0, 1, 1, 2);
+ gtk_table_attach_defaults (GTK_TABLE (table), combo_dpy, 1, 2, 0, 1);
+
+ bbox = gtk_hbutton_box_new ();
+ applyb = gtk_button_new_from_stock (GTK_STOCK_APPLY);
+ cancelb = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
+
+ gtk_container_add (GTK_CONTAINER (vbox), bbox);
+
+ gtk_container_add (GTK_CONTAINER (bbox), applyb);
+ gtk_container_add (GTK_CONTAINER (bbox), cancelb);
+
+ scr_dpy_data = g_new0 (ScreenDisplaySelection, 1);
+
+ scr_dpy_data->entry = GTK_ENTRY (GTK_COMBO (combo_dpy)->entry);
+ scr_dpy_data->radio_dpy = radio_dpy;
+ scr_dpy_data->toplevel = gtk_widget_get_toplevel (widget);
+ scr_dpy_data->dialog_window = window;
+ scr_dpy_data->valid_display_list = valid_display_list;
+
+ g_signal_connect (G_OBJECT (cancelb), "clicked",
+ G_CALLBACK (screen_display_destroy_diag), G_OBJECT (window));
+ g_signal_connect (G_OBJECT (applyb), "clicked",
+ G_CALLBACK (screen_display_check), scr_dpy_data);
+ gtk_widget_show_all (window);
+}
+
/* Event Watcher
*/
static gboolean event_watcher_enter_id = 0;
}
static void
-create_event_watcher (void)
+create_event_watcher (GtkWidget *widget)
{
GtkWidget *button;
if (!dialog_window)
{
dialog_window = gtk_dialog_new ();
+ gtk_window_set_screen (GTK_WINDOW (dialog_window),
+ gtk_widget_get_screen (widget));
gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
}
static void
-create_range_controls (void)
+create_range_controls (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
*/
void
-create_rulers (void)
+create_rulers (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *table;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, FALSE);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
}
void
-create_text (void)
+create_text (GtkWidget *widget)
{
int i, j;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_widget_set_name (window, "text window");
gtk_widget_set_usize (window, 500, 500);
gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
* GtkNotebook
*/
-GdkPixmap *book_open;
-GdkPixmap *book_closed;
-GdkBitmap *book_open_mask;
-GdkBitmap *book_closed_mask;
+GdkPixbuf *book_open;
+GdkPixbuf *book_closed;
GtkWidget *sample_notebook;
static void
-set_page_pixmaps (GtkNotebook *notebook, gint page_num,
- GdkPixmap *pixmap, GdkPixmap *mask)
+set_page_image (GtkNotebook *notebook, gint page_num, GdkPixbuf *pixbuf)
{
GtkWidget *page_widget;
GtkWidget *pixwid;
page_widget = gtk_notebook_get_nth_page (notebook, page_num);
pixwid = gtk_object_get_data (GTK_OBJECT (page_widget), "tab_pixmap");
- gtk_pixmap_set (GTK_PIXMAP (pixwid), pixmap, mask);
+ gtk_image_set_from_pixbuf (GTK_IMAGE (pixwid), pixbuf);
pixwid = gtk_object_get_data (GTK_OBJECT (page_widget), "menu_pixmap");
- gtk_pixmap_set (GTK_PIXMAP (pixwid), pixmap, mask);
+ gtk_image_set_from_pixbuf (GTK_IMAGE (pixwid), pixbuf);
}
static void
if (page_num == old_page_num)
return;
- set_page_pixmaps (notebook, page_num, book_open, book_open_mask);
+ set_page_image (notebook, page_num, book_open);
if (old_page_num != -1)
- set_page_pixmaps (notebook, old_page_num, book_closed, book_closed_mask);
+ set_page_image (notebook, old_page_num, book_closed);
}
static void
gtk_widget_show_all (child);
label_box = gtk_hbox_new (FALSE, 0);
- pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
+ pixwid = gtk_image_new_from_pixbuf (book_closed);
gtk_object_set_data (GTK_OBJECT (child), "tab_pixmap", pixwid);
gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
menu_box = gtk_hbox_new (FALSE, 0);
- pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
+ pixwid = gtk_image_new_from_pixbuf (book_closed);
gtk_object_set_data (GTK_OBJECT (child), "menu_pixmap", pixwid);
gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
}
static void
-create_notebook (void)
+create_notebook (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *button;
GtkWidget *separator;
GtkWidget *omenu;
- GdkColor *transparent = NULL;
GtkWidget *label;
static gchar *items[] =
"Borderless",
"Scrollable"
};
-
+
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
gtk_container_set_border_width (GTK_CONTAINER (sample_notebook), 10);
gtk_widget_realize (sample_notebook);
+
if (!book_open)
- book_open = gdk_pixmap_create_from_xpm_d (sample_notebook->window,
- &book_open_mask,
- transparent,
- book_open_xpm);
+ book_open = gdk_pixbuf_new_from_xpm_data ((const char **)book_open_xpm);
+
if (!book_closed)
- book_closed = gdk_pixmap_create_from_xpm_d (sample_notebook->window,
- &book_closed_mask,
- transparent,
- book_closed_xpm);
+ book_closed = gdk_pixbuf_new_from_xpm_data ((const char **)book_closed_xpm);
create_pages (GTK_NOTEBOOK (sample_notebook), 1, 5);
GObject *paned)
{
GtkWidget *window = create_prop_editor (paned, GTK_TYPE_PANED);
-
+
gtk_window_set_title (GTK_WINDOW (window), "Paned Properties");
}
}
void
-create_panes (void)
+create_panes (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *frame;
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
*/
static GtkWidget*
-paned_keyboard_window1 (void)
+paned_keyboard_window1 (GtkWidget *widget)
{
GtkWidget *window1;
GtkWidget *hpaned1;
window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window1), "Basic paned navigation");
+ gtk_window_set_screen (GTK_WINDOW (window1),
+ gtk_widget_get_screen (widget));
hpaned1 = gtk_hpaned_new ();
gtk_container_add (GTK_CONTAINER (window1), hpaned1);
}
static GtkWidget*
-paned_keyboard_window2 (void)
+paned_keyboard_window2 (GtkWidget *widget)
{
GtkWidget *window2;
GtkWidget *hpaned2;
window2 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window2), "\"button 10\" is not inside the horisontal pane");
+ gtk_window_set_screen (GTK_WINDOW (window2),
+ gtk_widget_get_screen (widget));
+
hpaned2 = gtk_hpaned_new ();
gtk_container_add (GTK_CONTAINER (window2), hpaned2);
}
static GtkWidget*
-paned_keyboard_window3 (void)
+paned_keyboard_window3 (GtkWidget *widget)
{
GtkWidget *window3;
GtkWidget *vbox2;
gtk_object_set_data (GTK_OBJECT (window3), "window3", window3);
gtk_window_set_title (GTK_WINDOW (window3), "Nested panes");
+ gtk_window_set_screen (GTK_WINDOW (window3),
+ gtk_widget_get_screen (widget));
+
+
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window3), vbox2);
}
static GtkWidget*
-paned_keyboard_window4 (void)
+paned_keyboard_window4 (GtkWidget *widget)
{
GtkWidget *window4;
GtkWidget *vbox3;
gtk_object_set_data (GTK_OBJECT (window4), "window4", window4);
gtk_window_set_title (GTK_WINDOW (window4), "window4");
+ gtk_window_set_screen (GTK_WINDOW (window4),
+ gtk_widget_get_screen (widget));
+
vbox3 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window4), vbox3);
}
static void
-create_paned_keyboard_navigation (void)
+create_paned_keyboard_navigation (GtkWidget *widget)
{
static GtkWidget *window1 = NULL;
static GtkWidget *window2 = NULL;
static GtkWidget *window3 = NULL;
static GtkWidget *window4 = NULL;
+ if (window1 &&
+ (gtk_widget_get_screen (window1) != gtk_widget_get_screen (widget)))
+ {
+ gtk_widget_destroy (window1);
+ gtk_widget_destroy (window2);
+ gtk_widget_destroy (window3);
+ gtk_widget_destroy (window4);
+ }
+
if (!window1)
{
- window1 = paned_keyboard_window1 ();
+ window1 = paned_keyboard_window1 (widget);
gtk_signal_connect (GTK_OBJECT (window1), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window1);
if (!window2)
{
- window2 = paned_keyboard_window2 ();
+ window2 = paned_keyboard_window2 (widget);
gtk_signal_connect (GTK_OBJECT (window2), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window2);
if (!window3)
{
- window3 = paned_keyboard_window3 ();
+ window3 = paned_keyboard_window3 (widget);
gtk_signal_connect (GTK_OBJECT (window3), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window3);
if (!window4)
{
- window4 = paned_keyboard_window4 ();
+ window4 = paned_keyboard_window4 (widget);
gtk_signal_connect (GTK_OBJECT (window4), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window4);
shape_released (GtkWidget *widget)
{
gtk_grab_remove (widget);
- gdk_pointer_ungrab (0);
+ gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
+ GDK_CURRENT_TIME);
}
static void
}
GtkWidget *
-shape_create_icon (char *xpm_file,
- gint x,
- gint y,
- gint px,
- gint py,
- gint window_type)
+shape_create_icon (GdkScreen *screen,
+ char *xpm_file,
+ gint x,
+ gint y,
+ gint px,
+ gint py,
+ gint window_type)
{
GtkWidget *window;
GtkWidget *pixmap;
* GDK_WINDOW_TOPLEVEL works also, giving you a title border
*/
window = gtk_window_new (window_type);
+ gtk_window_set_screen (GTK_WINDOW (window), screen);
fixed = gtk_fixed_new ();
gtk_widget_set_usize (fixed, 100,100);
}
void
-create_shapes (void)
+create_shapes (GtkWidget *widget)
{
/* Variables used by the Drag/Drop and Shape Window demos */
static GtkWidget *modeller = NULL;
static GtkWidget *sheets = NULL;
static GtkWidget *rings = NULL;
static GtkWidget *with_region = NULL;
+ GdkScreen *screen = gtk_widget_get_screen (widget);
if (!(file_exists ("Modeller.xpm") &&
file_exists ("FilesQueue.xpm") &&
if (!modeller)
{
- modeller = shape_create_icon ("Modeller.xpm",
+ modeller = shape_create_icon (screen, "Modeller.xpm",
440, 140, 0,0, GTK_WINDOW_POPUP);
gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
if (!sheets)
{
- sheets = shape_create_icon ("FilesQueue.xpm",
+ sheets = shape_create_icon (screen, "FilesQueue.xpm",
580, 170, 0,0, GTK_WINDOW_POPUP);
gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
if (!rings)
{
- rings = shape_create_icon ("3DRings.xpm",
+ rings = shape_create_icon (screen, "3DRings.xpm",
460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
gtk_signal_connect (GTK_OBJECT (rings), "destroy",
GdkRegion *region;
gint x, y;
- with_region = shape_create_icon ("3DRings.xpm",
+ with_region = shape_create_icon (screen, "3DRings.xpm",
460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
gtk_window_set_decorated (GTK_WINDOW (with_region), FALSE);
*/
void
-create_wmhints (void)
+create_wmhints (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *label;
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
}
void
-create_window_states (void)
+create_window_states (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *label;
GtkWidget *iconified;
GtkWidget *normal;
GtkWidget *controls;
-
+
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
gtk_container_add (GTK_CONTAINER (window), box1);
iconified = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_window_set_screen (GTK_WINDOW (iconified),
+ gtk_widget_get_screen (widget));
+
gtk_signal_connect_object (GTK_OBJECT (iconified), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT (window));
gtk_container_add (GTK_CONTAINER (iconified), controls);
normal = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_window_set_screen (GTK_WINDOW (normal),
+ gtk_widget_get_screen (widget));
+
gtk_signal_connect_object (GTK_OBJECT (normal), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT (window));
gint *y)
{
int w, h;
+ GdkScreen * screen = gtk_window_get_screen (window);
gtk_window_get_size (GTK_WINDOW (window), &w, &h);
switch (gtk_window_get_gravity (window))
{
case GDK_GRAVITY_SOUTH_EAST:
- *x = gdk_screen_width () - w;
- *y = gdk_screen_height () - h;
+ *x = gdk_screen_get_width (screen) - w;
+ *y = gdk_screen_get_height (screen) - h;
break;
case GDK_GRAVITY_NORTH_EAST:
- *x = gdk_screen_width () - w;
+ *x = gdk_screen_get_width (screen) - w;
*y = 0;
break;
case GDK_GRAVITY_SOUTH_WEST:
*x = 0;
- *y = gdk_screen_height () - h;
+ *y = gdk_screen_get_height (screen) - h;
break;
case GDK_GRAVITY_NORTH_WEST:
break;
case GDK_GRAVITY_SOUTH:
- *x = (gdk_screen_width () - w) / 2;
- *y = gdk_screen_height () - h;
+ *x = (gdk_screen_get_width (screen) - w) / 2;
+ *y = gdk_screen_get_height (screen) - h;
break;
case GDK_GRAVITY_NORTH:
- *x = (gdk_screen_width () - w) / 2;
+ *x = (gdk_screen_get_width (screen) - w) / 2;
*y = 0;
break;
case GDK_GRAVITY_WEST:
*x = 0;
- *y = (gdk_screen_height () - h) / 2;
+ *y = (gdk_screen_get_height (screen) - h) / 2;
break;
case GDK_GRAVITY_EAST:
- *x = gdk_screen_width () - w;
- *y = (gdk_screen_height () - h) / 2;
+ *x = gdk_screen_get_width (screen) - w;
+ *y = (gdk_screen_get_height (screen) - h) / 2;
break;
case GDK_GRAVITY_CENTER:
- *x = (gdk_screen_width () - w) / 2;
- *y = (gdk_screen_height () - h) / 2;
+ *x = (gdk_screen_get_width (screen) - w) / 2;
+ *y = (gdk_screen_get_height (screen) - h) / 2;
break;
case GDK_GRAVITY_STATIC:
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (destroy_with));
+
vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox);
control_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (control_window),
+ gtk_widget_get_screen (window));
+
gtk_window_set_title (GTK_WINDOW (control_window), "Size controls");
g_object_set_data (G_OBJECT (control_window),
}
void
-create_window_sizing (void)
+create_window_sizing (GtkWidget *widget)
{
static GtkWidget *window = NULL;
static GtkWidget *target_window = NULL;
-
+
if (!target_window)
{
GtkWidget *label;
target_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
-
+ gtk_window_set_screen (GTK_WINDOW (target_window),
+ gtk_widget_get_screen (widget));
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), "<span foreground=\"purple\"><big>Window being resized</big></span>\nBlah blah blah blah\nblah blah blah\nblah blah blah blah blah");
gtk_container_add (GTK_CONTAINER (target_window), label);
}
void
-create_progress_bar (void)
+create_progress_bar (GtkWidget *widget)
{
GtkWidget *button;
GtkWidget *vbox;
"Continuous",
"Discrete"
};
-
+
if (!pdata)
pdata = g_new0 (ProgressData, 1);
{
pdata->window = gtk_dialog_new ();
+ gtk_window_set_screen (GTK_WINDOW (pdata->window),
+ gtk_widget_get_screen (widget));
+
gtk_window_set_policy (GTK_WINDOW (pdata->window), FALSE, FALSE, TRUE);
gtk_signal_connect (GTK_OBJECT (pdata->window), "destroy",
}
static GtkWidget *
-find_widget_at_pointer (void)
+find_widget_at_pointer (GdkScreen *screen)
{
GtkWidget *widget = NULL;
GdkWindow *pointer_window;
gint x, y;
FindWidgetData data;
- pointer_window = gdk_window_at_pointer (NULL, NULL);
+ pointer_window = gdk_screen_get_window_at_pointer (screen, NULL, NULL);
if (pointer_window)
gdk_window_get_user_data (pointer_window, (gpointer*) &widget);
if (event->type == GDK_BUTTON_RELEASE)
{
gtk_grab_remove (widget);
- gdk_pointer_ungrab (GDK_CURRENT_TIME);
+ gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
+ GDK_CURRENT_TIME);
- res_widget = find_widget_at_pointer ();
+ res_widget = find_widget_at_pointer (gtk_widget_get_screen (widget));
if (res_widget)
- create_prop_editor (G_OBJECT (res_widget), 0);
+ {
+ g_object_set_data (G_OBJECT (res_widget), "prop-editor-screen",
+ gtk_widget_get_screen (widget));
+ create_prop_editor (G_OBJECT (res_widget), 0);
+ }
data->in_query = FALSE;
}
if (!data->cursor)
- data->cursor = gdk_cursor_new (GDK_TARGET);
+ data->cursor = gdk_cursor_new_for_screen (gtk_widget_get_screen (GTK_WIDGET (button)),
+ GDK_TARGET);
failure = gdk_pointer_grab (GTK_WIDGET (button)->window,
TRUE,
}
static void
-create_properties (void)
+create_properties (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *button;
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
data->handler = gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(destroy_properties),
data);
}
void
-create_color_preview (void)
+create_color_preview (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *preview;
if (!window)
{
- gtk_widget_push_colormap (gdk_rgb_get_cmap ());
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_widget_pop_colormap ();
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(color_preview_destroy),
}
void
-create_gray_preview (void)
+create_gray_preview (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *preview;
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gray_preview_destroy),
&window);
}
void
-create_selection_test (void)
+create_selection_test (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *button;
if (!window)
{
window = gtk_dialog_new ();
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
*/
void
-create_gamma_curve (void)
+create_gamma_curve (GtkWidget *widget)
{
static GtkWidget *window = NULL, *curve;
static int count = 0;
gfloat vec[256];
gint max;
gint i;
-
+
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_window_set_title (GTK_WINDOW (window), "test");
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
void
-create_scroll_test (void)
+create_scroll_test (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *hbox;
GtkAdjustment *adj;
GdkGeometry geometry;
GdkWindowHints geometry_mask;
-
+
if (!window)
{
window = gtk_dialog_new ();
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
}
void
-create_timeout_test (void)
+create_timeout_test (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *button;
{
window = gtk_dialog_new ();
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(destroy_timeout_test),
&window);
}
static void
-create_idle_test (void)
+create_idle_test (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *button;
window = gtk_dialog_new ();
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(destroy_idle_test),
&window);
}
void
-create_rc_file (void)
+create_rc_file (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *button;
{
window = gtk_dialog_new ();
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(destroy_idle_test),
&window);
}
void
-create_mainloop (void)
+create_mainloop (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *label;
{
window = gtk_dialog_new ();
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
gtk_signal_connect (GTK_OBJECT (window), "destroy",
return FALSE;
}
-void create_layout (void)
+void create_layout (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *layout;
gint i, j;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
}
void
-create_styles (void)
+create_styles (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *label;
if (!window)
{
window = gtk_dialog_new ();
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
{ "ctree", create_ctree },
{ "cursors", create_cursors },
{ "dialog", create_dialog },
+ { "display & screen", create_display_screen },
{ "entry", create_entry },
{ "event watcher", create_event_watcher },
{ "file selection", create_file_selection },
projects / ~andy / gtk / commitdiff