+2008-08-11 Sven Neumann <sven@gimp.org>
+
+ * demos/gtk-demo/changedisplay.c
+ * demos/gtk-demo/clipboard.c
+ * demos/gtk-demo/drawingarea.c
+ * demos/gtk-demo/iconview.c
+ * demos/gtk-demo/images.c
+ * demos/gtk-demo/pixbufs.c: use canonical signal names in the demos.
+
2008-08-11 Matthias Clasen <mclasen@redhat.com>
Bug 547211 – Duplicated mnemonic
/* Change Display
- *
+ *
* Demonstrates migrating a window between different displays and
* screens. A display is a mouse and keyboard with some number of
* associated monitors. A screen is a set of monitors grouped
* - Changing the screen for a window
*
* - Letting the user choose a window by clicking on it
- *
+ *
* - Using GtkListStore and GtkTreeView
*
* - Using GtkDialog
GtkTreeModel *display_model;
GtkTreeModel *screen_model;
GtkTreeSelection *screen_selection;
-
+
GdkDisplay *current_display;
GdkScreen *current_screen;
};
GtkWidget *popup, *label, *frame;
GdkCursor *cursor;
GtkWidget *toplevel = NULL;
-
+
popup = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_screen (GTK_WINDOW (popup), screen);
gtk_window_set_modal (GTK_WINDOW (popup), TRUE);
gtk_window_set_position (GTK_WINDOW (popup), GTK_WIN_POS_CENTER);
-
+
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
gtk_container_add (GTK_CONTAINER (popup), frame);
-
+
label = gtk_label_new (prompt);
gtk_misc_set_padding (GTK_MISC (label), 10, 10);
gtk_container_add (GTK_CONTAINER (frame), label);
-
+
gtk_widget_show_all (popup);
cursor = gdk_cursor_new_for_display (display, GDK_CROSSHAIR);
-
+
if (gdk_pointer_grab (popup->window, FALSE,
GDK_BUTTON_RELEASE_MASK,
NULL,
GDK_CURRENT_TIME) == GDK_GRAB_SUCCESS)
{
gboolean clicked = FALSE;
-
+
g_signal_connect (popup, "button-release-event",
G_CALLBACK (button_release_event_cb), &clicked);
-
+
/* Process events until clicked is set by button_release_event_cb.
* We pass in may_block=TRUE since we want to wait if there
* are no events currently.
*/
while (!clicked)
g_main_context_iteration (NULL, TRUE);
-
+
toplevel = find_toplevel_at_pointer (gdk_screen_get_display (screen));
if (toplevel == popup)
toplevel = NULL;
}
-
+
gdk_cursor_unref (cursor);
gtk_widget_destroy (popup);
gdk_flush (); /* Really release the grab */
-
+
return toplevel;
}
{
gint n_screens = gdk_display_get_n_screens (info->current_display);
gint i;
-
+
for (i = 0; i < n_screens; i++)
{
GdkScreen *screen = gdk_display_get_screen (info->current_display, i);
GtkTreeIter iter;
-
+
gtk_list_store_append (GTK_LIST_STORE (info->screen_model), &iter);
gtk_list_store_set (GTK_LIST_STORE (info->screen_model), &iter,
SCREEN_COLUMN_NUMBER, i,
GtkWidget *dialog_label;
gchar *new_screen_name = NULL;
GdkDisplay *result = NULL;
-
+
dialog = gtk_dialog_new_with_buttons ("Open Display",
GTK_WINDOW (info->window),
GTK_DIALOG_MODAL,
gtk_widget_grab_focus (display_entry);
gtk_widget_show_all (GTK_BIN (dialog)->child);
-
+
while (!result)
{
gint response_id = gtk_dialog_run (GTK_DIALOG (dialog));
if (response_id != GTK_RESPONSE_OK)
break;
-
+
new_screen_name = gtk_editable_get_chars (GTK_EDITABLE (display_entry),
0, -1);
g_free (new_screen_name);
}
}
-
+
gtk_widget_destroy (dialog);
}
GtkTreeSelection *selection;
GtkWidget *scrollwin;
GtkWidget *hbox;
-
+
*frame = gtk_frame_new (title);
hbox = gtk_hbox_new (FALSE, 8);
if (!info->size_group)
info->size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
-
+
gtk_size_group_add_widget (GTK_SIZE_GROUP (info->size_group), *button_vbox);
}
button = left_align_button_new ("_Open...");
g_signal_connect (button, "clicked", G_CALLBACK (open_display_cb), info);
gtk_box_pack_start (GTK_BOX (button_vbox), button, FALSE, FALSE, 0);
-
+
button = left_align_button_new ("_Close");
g_signal_connect (button, "clicked", G_CALLBACK (close_display_cb), info);
gtk_box_pack_start (GTK_BOX (button_vbox), button, FALSE, FALSE, 0);
valid = gtk_tree_model_iter_next (info->display_model, &iter))
{
GdkDisplay *tmp_display;
-
+
gtk_tree_model_get (info->display_model, &iter,
DISPLAY_COLUMN_DISPLAY, &tmp_display,
-1);
{
const gchar *name = gdk_display_get_name (display);
GtkTreeIter iter;
-
+
gtk_list_store_append (GTK_LIST_STORE (info->display_model), &iter);
gtk_list_store_set (GTK_LIST_STORE (info->display_model), &iter,
DISPLAY_COLUMN_NAME, name,
-1);
g_signal_connect (display, "closed",
- G_CALLBACK (display_closed_cb), info);
+ G_CALLBACK (display_closed_cb), info);
}
/* Called when a new display is opened
g_slist_free (tmp_list);
- g_signal_connect (manager, "display_opened",
+ g_signal_connect (manager, "display-opened",
G_CALLBACK (display_opened_cb), info);
}
g_signal_handlers_disconnect_by_func (tmp_list->data,
display_closed_cb,
info);
-
+
g_slist_free (tmp_list);
g_object_unref (info->size_group);
info = g_new0 (ChangeDisplayInfo, 1);
info->window = gtk_dialog_new_with_buttons ("Change Screen or display",
- GTK_WINDOW (do_widget),
+ GTK_WINDOW (do_widget),
GTK_DIALOG_NO_SEPARATOR,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
"Change", GTK_RESPONSE_OK,
vbox = gtk_vbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
-
+
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (info->window)->vbox), vbox,
TRUE, TRUE, 0);
frame = create_display_frame (info);
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
-
+
frame = create_screen_frame (info);
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
/* Clipboard
*
* GtkClipboard is used for clipboard handling. This demo shows how to
- * copy and paste text to and from the clipboard.
+ * copy and paste text to and from the clipboard.
*
- * It also shows how to transfer images via the clipboard or via
+ * It also shows how to transfer images via the clipboard or via
* drag-and-drop, and how to make clipboard contents persist after
* the application exits. Clipboard persistence requires a clipboard
* manager to run.
GtkClipboard *clipboard;
entry = GTK_WIDGET (user_data);
-
+
/* Get the clipboard object */
clipboard = gtk_widget_get_clipboard (entry,
GDK_SELECTION_CLIPBOARD);
GtkWidget *entry;
entry = GTK_WIDGET (user_data);
-
+
/* Set the entry text */
if(text)
gtk_entry_set_text (GTK_ENTRY (entry), text);
GtkClipboard *clipboard;
entry = GTK_WIDGET (user_data);
-
+
/* Get the clipboard object */
clipboard = gtk_widget_get_clipboard (entry,
GDK_SELECTION_CLIPBOARD);
return gtk_widget_render_icon (GTK_WIDGET (image),
stock_id, size, NULL);
default:
- g_warning ("Image storage type %d not handled",
+ g_warning ("Image storage type %d not handled",
gtk_image_get_storage_type (image));
return NULL;
}
g_object_unref (pixbuf);
}
-void
+void
drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
{
GtkWidget *menu;
GtkWidget *item;
-
+
if (button->button != 3)
return FALSE;
menu = gtk_menu_new ();
-
+
item = gtk_image_menu_item_new_from_stock (GTK_STOCK_COPY, NULL);
g_signal_connect (item, "activate", G_CALLBACK (copy_image), data);
gtk_widget_show (item);
GtkWidget *entry, *button;
GtkWidget *ebox, *image;
GtkClipboard *clipboard;
-
+
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
-
+
gtk_container_add (GTK_CONTAINER (window), vbox);
label = gtk_label_new ("\"Copy\" will copy the text\nin the entry to the clipboard");
-
+
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
hbox = gtk_hbox_new (FALSE, 4);
/* Create the first entry */
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
-
+
/* Create the button */
button = gtk_button_new_from_stock (GTK_STOCK_COPY);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
/* Create the second entry */
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
-
+
/* Create the button */
button = gtk_button_new_from_stock (GTK_STOCK_PASTE);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (paste_button_clicked), entry);
-
+
label = gtk_label_new ("Images can be transferred via the clipboard, too");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
/* Create the first image */
- image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING,
+ image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING,
GTK_ICON_SIZE_BUTTON);
ebox = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (ebox), image);
/* make ebox a drag source */
gtk_drag_source_set (ebox, GDK_BUTTON1_MASK, NULL, 0, GDK_ACTION_COPY);
gtk_drag_source_add_image_targets (ebox);
- g_signal_connect (ebox, "drag_begin",
+ g_signal_connect (ebox, "drag-begin",
G_CALLBACK (drag_begin), image);
- g_signal_connect (ebox, "drag_data_get",
+ g_signal_connect (ebox, "drag-data-get",
G_CALLBACK (drag_data_get), image);
-
+
/* accept drops on ebox */
- gtk_drag_dest_set (ebox, GTK_DEST_DEFAULT_ALL,
+ gtk_drag_dest_set (ebox, GTK_DEST_DEFAULT_ALL,
NULL, 0, GDK_ACTION_COPY);
gtk_drag_dest_add_image_targets (ebox);
- g_signal_connect (ebox, "drag_data_received",
+ g_signal_connect (ebox, "drag-data-received",
G_CALLBACK (drag_data_received), image);
-
+
/* context menu on ebox */
- g_signal_connect (ebox, "button_press_event",
+ g_signal_connect (ebox, "button-press-event",
G_CALLBACK (button_press), image);
/* Create the second image */
- image = gtk_image_new_from_stock (GTK_STOCK_STOP,
+ image = gtk_image_new_from_stock (GTK_STOCK_STOP,
GTK_ICON_SIZE_BUTTON);
ebox = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (ebox), image);
/* make ebox a drag source */
gtk_drag_source_set (ebox, GDK_BUTTON1_MASK, NULL, 0, GDK_ACTION_COPY);
gtk_drag_source_add_image_targets (ebox);
- g_signal_connect (ebox, "drag_begin",
+ g_signal_connect (ebox, "drag-begin",
G_CALLBACK (drag_begin), image);
- g_signal_connect (ebox, "drag_data_get",
+ g_signal_connect (ebox, "drag-data-get",
G_CALLBACK (drag_data_get), image);
-
+
/* accept drops on ebox */
- gtk_drag_dest_set (ebox, GTK_DEST_DEFAULT_ALL,
+ gtk_drag_dest_set (ebox, GTK_DEST_DEFAULT_ALL,
NULL, 0, GDK_ACTION_COPY);
gtk_drag_dest_add_image_targets (ebox);
- g_signal_connect (ebox, "drag_data_received",
+ g_signal_connect (ebox, "drag-data-received",
G_CALLBACK (drag_data_received), image);
-
+
/* context menu on ebox */
- g_signal_connect (ebox, "button_press_event",
+ g_signal_connect (ebox, "button-press-event",
G_CALLBACK (button_press), image);
-
+
/* tell the clipboard manager to make the data persistent */
clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
gtk_clipboard_set_can_store (clipboard, NULL, 0);
* but honestly any GC would work. The only thing to worry about
* is whether the GC has an inappropriate clip region set.
*/
-
+
gdk_draw_drawable (widget->window,
widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
pixmap,
event->area.x, event->area.y,
event->area.x, event->area.y,
event->area.width, event->area.height);
-
+
return FALSE;
}
{
if (pixmap == NULL)
return FALSE; /* paranoia check, in case we haven't gotten a configure event */
-
+
if (event->button == 1)
draw_brush (widget, event->x, event->y);
* we avoid getting a huge number of events faster than we
* can cope.
*/
-
+
gdk_window_get_pointer (event->window, &x, &y, &state);
-
+
if (state & GDK_BUTTON1_MASK)
draw_brush (widget, x, y);
gint i, j, xcount, ycount;
GdkGC *gc1, *gc2;
GdkColor color;
-
+
#define CHECK_SIZE 10
#define SPACING 2
-
+
/* At the start of an expose handler, a clip region of event->area
* is set on the window, and event->area has been cleared to the
* widget's background color. The docs for
color.green = 65535;
color.blue = 65535;
gdk_gc_set_rgb_fg_color (gc2, &color);
-
+
xcount = 0;
i = SPACING;
while (i < da->allocation.width)
while (j < da->allocation.height)
{
GdkGC *gc;
-
+
if (ycount % 2)
gc = gc1;
else
i += CHECK_SIZE + SPACING;
++xcount;
}
-
+
g_object_unref (gc1);
g_object_unref (gc2);
-
+
/* return TRUE because we've handled this event, so no
* further processing is required.
*/
GtkWidget *vbox;
GtkWidget *da;
GtkWidget *label;
-
+
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
/*
* Create the checkerboard area
*/
-
+
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Checkerboard pattern</u>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
-
+
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
-
+
da = gtk_drawing_area_new ();
/* set a minimum size */
gtk_widget_set_size_request (da, 100, 100);
gtk_container_add (GTK_CONTAINER (frame), da);
- g_signal_connect (da, "expose_event",
+ g_signal_connect (da, "expose-event",
G_CALLBACK (checkerboard_expose), NULL);
/*
* Create the scribble area
*/
-
+
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Scribble area</u>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
-
+
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
-
+
da = gtk_drawing_area_new ();
/* set a minimum size */
gtk_widget_set_size_request (da, 100, 100);
gtk_container_add (GTK_CONTAINER (frame), da);
/* Signals used to handle backing pixmap */
-
- g_signal_connect (da, "expose_event",
+
+ g_signal_connect (da, "expose-event",
G_CALLBACK (scribble_expose_event), NULL);
- g_signal_connect (da,"configure_event",
+ g_signal_connect (da,"configure-event",
G_CALLBACK (scribble_configure_event), NULL);
-
+
/* Event signals */
-
- g_signal_connect (da, "motion_notify_event",
+
+ g_signal_connect (da, "motion-notify-event",
G_CALLBACK (scribble_motion_notify_event), NULL);
- g_signal_connect (da, "button_press_event",
+ g_signal_connect (da, "button-press-event",
G_CALLBACK (scribble_button_press_event), NULL);
/* Icon View/Icon View Basics
*
- * The GtkIconView widget is used to display and manipulate icons.
- * It uses a GtkTreeModel for data storage, so the list store
+ * The GtkIconView widget is used to display and manipulate icons.
+ * It uses a GtkTreeModel for data storage, so the list store
* example might be helpful.
*/
file_pixbuf = gdk_pixbuf_new_from_file (filename, error);
g_free (filename);
-
+
if (!file_pixbuf)
return FALSE; /* Note that "error" was filled with a GError */
-
+
filename = demo_find_file (FOLDER_NAME, error);
if (!filename)
return FALSE; /* note that "error" was filled in and returned */
GDir *dir;
const gchar *name;
GtkTreeIter iter;
-
+
/* First clear the store */
gtk_list_store_clear (store);
{
gchar *path, *display_name;
gboolean is_dir;
-
+
/* We ignore hidden files that start with a '.' */
if (name[0] != '.')
{
path = g_build_filename (parent, name, NULL);
is_dir = g_file_test (path, G_FILE_TEST_IS_DIR);
-
+
display_name = g_filename_to_utf8 (name, -1, NULL, NULL, NULL);
gtk_list_store_append (store, &iter);
g_free (display_name);
}
- name = g_dir_read_name (dir);
+ name = g_dir_read_name (dir);
}
}
* folders before files.
*/
-
+
gtk_tree_model_get (model, a,
COL_IS_DIRECTORY, &is_dir_a,
COL_DISPLAY_NAME, &name_a,
GtkListStore *store;
store = gtk_list_store_new (NUM_COLS,
- G_TYPE_STRING,
- G_TYPE_STRING,
+ G_TYPE_STRING,
+ G_TYPE_STRING,
GDK_TYPE_PIXBUF,
G_TYPE_BOOLEAN);
- /* Set sort column and function */
+ /* Set sort column and function */
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (store),
sort_func,
NULL, NULL);
gchar *path;
GtkTreeIter iter;
gboolean is_dir;
-
+
store = GTK_LIST_STORE (user_data);
gtk_tree_model_get_iter (GTK_TREE_MODEL (store),
g_free (path);
return;
}
-
+
/* Replace parent with path and re-fill the model*/
g_free (parent);
parent = path;
dir_name = g_path_get_dirname (parent);
g_free (parent);
-
+
parent = dir_name;
fill_store (store);
if (!window)
{
GError *error;
-
+
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), 650, 400);
-
+
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "GtkIconView demo");
GtkWidget *vbox;
GtkWidget *tool_bar;
GtkToolItem *home_button;
-
+
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
tool_bar = gtk_toolbar_new ();
gtk_box_pack_start (GTK_BOX (vbox), tool_bar, FALSE, FALSE, 0);
-
+
up_button = gtk_tool_button_new_from_stock (GTK_STOCK_GO_UP);
gtk_tool_item_set_is_important (up_button, TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (up_button), FALSE);
home_button = gtk_tool_button_new_from_stock (GTK_STOCK_HOME);
gtk_tool_item_set_is_important (home_button, TRUE);
gtk_toolbar_insert (GTK_TOOLBAR (tool_bar), home_button, -1);
-
-
+
+
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
-
+
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
-
+
/* Create the store and fill it with the contents of '/' */
parent = g_strdup ("/");
store = create_store ();
gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (icon_view),
GTK_SELECTION_MULTIPLE);
g_object_unref (store);
-
+
/* Connect to the "clicked" signal of the "Up" tool button */
g_signal_connect (up_button, "clicked",
G_CALLBACK (up_clicked), store);
/* Connect to the "clicked" signal of the "Home" tool button */
g_signal_connect (home_button, "clicked",
G_CALLBACK (home_clicked), store);
-
+
/* We now set which model columns that correspond to the text
* and pixbuf of each item
*/
gtk_icon_view_set_text_column (GTK_ICON_VIEW (icon_view), COL_DISPLAY_NAME);
gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (icon_view), COL_PIXBUF);
- /* Connect to the "item_activated" signal */
- g_signal_connect (icon_view, "item_activated",
+ /* Connect to the "item-activated" signal */
+ g_signal_connect (icon_view, "item-activated",
G_CALLBACK (item_activated), store);
gtk_container_add (GTK_CONTAINER (sw), icon_view);
gtk_widget_grab_focus (icon_view);
}
}
-
+
if (!GTK_WIDGET_VISIBLE (window))
gtk_widget_show_all (window);
else
GtkWidget *image;
image = GTK_WIDGET (data);
-
+
pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
/* Avoid displaying random memory contents, since the pixbuf
* isn't filled in yet.
*/
gdk_pixbuf_fill (pixbuf, 0xaaaaaaff);
-
+
gtk_image_set_from_pixbuf (GTK_IMAGE (image), pixbuf);
}
gpointer data)
{
GtkWidget *image;
-
+
image = GTK_WIDGET (data);
/* We know the pixbuf inside the GtkImage has changed, but the image
* the pixbuf on the display, then we could queue a draw for only
* the updated area of the image.
*/
-
+
gtk_widget_queue_draw (image);
}
GtkWidget *image;
image = GTK_WIDGET (data);
-
+
/* This shows off fully-paranoid error handling, so looks scary.
* You could factor out the error handling code into a nice separate
* function to make things nicer.
*/
-
+
if (image_stream)
{
size_t bytes_read;
guchar buf[256];
GError *error = NULL;
-
+
bytes_read = fread (buf, 1, 256, image_stream);
if (ferror (image_stream))
{
GtkWidget *dialog;
-
+
dialog = gtk_message_dialog_new (GTK_WINDOW (window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
image_stream = NULL;
gtk_widget_show (dialog);
-
+
load_timeout = 0;
return FALSE; /* uninstall the timeout */
&error))
{
GtkWidget *dialog;
-
+
dialog = gtk_message_dialog_new (GTK_WINDOW (window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
error->message);
g_error_free (error);
-
+
g_signal_connect (dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
fclose (image_stream);
image_stream = NULL;
-
+
gtk_widget_show (dialog);
load_timeout = 0;
&error))
{
GtkWidget *dialog;
-
+
dialog = gtk_message_dialog_new (GTK_WINDOW (window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"Failed to load image: %s",
error->message);
-
+
g_error_free (error);
-
+
g_signal_connect (dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
-
+
gtk_widget_show (dialog);
g_object_unref (pixbuf_loader);
pixbuf_loader = NULL;
-
+
load_timeout = 0;
-
+
return FALSE; /* uninstall the timeout */
}
-
+
g_object_unref (pixbuf_loader);
pixbuf_loader = NULL;
}
{
gchar *filename;
gchar *error_message = NULL;
- GError *error = NULL;
+ GError *error = NULL;
/* demo_find_file() looks in the current directory first,
* so you can run gtk-demo without installing GTK, then looks
if (image_stream == NULL)
{
GtkWidget *dialog;
-
+
dialog = gtk_message_dialog_new (GTK_WINDOW (window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
g_signal_connect (dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
-
+
gtk_widget_show (dialog);
load_timeout = 0;
g_object_unref (pixbuf_loader);
pixbuf_loader = NULL;
}
-
+
pixbuf_loader = gdk_pixbuf_loader_new ();
-
- g_signal_connect (pixbuf_loader, "area_prepared",
+
+ g_signal_connect (pixbuf_loader, "area-prepared",
G_CALLBACK (progressive_prepared_callback), image);
-
- g_signal_connect (pixbuf_loader, "area_updated",
+
+ g_signal_connect (pixbuf_loader, "area-updated",
G_CALLBACK (progressive_updated_callback), image);
}
g_source_remove (load_timeout);
load_timeout = 0;
}
-
+
if (pixbuf_loader)
{
gdk_pixbuf_loader_close (pixbuf_loader, NULL);
GtkContainer *container = user_data;
GList *list;
GList *tmp;
-
+
list = gtk_container_get_children (container);
tmp = list;
if (GTK_WIDGET (tmp->data) != togglebutton)
gtk_widget_set_sensitive (GTK_WIDGET (tmp->data),
!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (togglebutton)));
-
+
tmp = tmp->next;
}
g_list_free (list);
}
-
+
GtkWidget *
do_images (GtkWidget *do_widget)
GdkPixbuf *pixbuf;
GError *error = NULL;
char *filename;
-
+
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Image loaded from a file</u>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
-
+
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
/* The alignment keeps the frame from growing when users resize
* be displayed instead.
*/
GtkWidget *dialog;
-
+
dialog = gtk_message_dialog_new (GTK_WINDOW (window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
"Unable to open image file 'gtk-logo-rgb.gif': %s",
error->message);
g_error_free (error);
-
+
g_signal_connect (dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
-
+
gtk_widget_show (dialog);
}
-
+
image = gtk_image_new_from_pixbuf (pixbuf);
gtk_container_add (GTK_CONTAINER (frame), image);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Animation loaded from a file</u>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
-
+
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
/* The alignment keeps the frame from growing when users resize
g_free (filename);
gtk_container_add (GTK_CONTAINER (frame), image);
-
+
/* Progressive */
-
-
+
+
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Progressive image loading</u>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
-
+
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
/* The alignment keeps the frame from growing when users resize
gtk_window_set_title (GTK_WINDOW (window), "Pixbufs");
gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window);
- g_signal_connect (window, "destroy", G_CALLBACK (cleanup_callback), NULL);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed), &window);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (cleanup_callback), NULL);
error = NULL;
da = gtk_drawing_area_new ();
- g_signal_connect (da, "expose_event",
+ g_signal_connect (da, "expose-event",
G_CALLBACK (expose_cb), NULL);
gtk_container_add (GTK_CONTAINER (window), da);
projects / ~andy / gtk / commitdiff