gtk2/tests/testgtk.c

10024 lines
299 KiB
C

/* GTK - The GIMP Toolkit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#include "config.h"
#undef G_LOG_DOMAIN
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <math.h>
#include <time.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include "gtk/gtk.h"
#include "gdk/gdk.h"
#include "gdk/gdkkeysyms.h"
#ifdef G_OS_WIN32
#define sleep(n) _sleep(n)
#endif
#include "prop-editor.h"
#include "test.xpm"
gboolean
file_exists (const char *filename)
{
struct stat statbuf;
return stat (filename, &statbuf) == 0;
}
GtkWidget *
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);
/* macro, structure and variables used by tree window demos */
#define DEFAULT_NUMBER_OF_ITEM 3
#define DEFAULT_RECURSION_LEVEL 3
struct {
GSList* selection_mode_group;
GtkWidget* single_button;
GtkWidget* browse_button;
GtkWidget* multiple_button;
GtkWidget* draw_line_button;
GtkWidget* view_line_button;
GtkWidget* no_root_item_button;
GtkWidget* nb_item_spinner;
GtkWidget* recursion_spinner;
} sTreeSampleSelection;
typedef struct sTreeButtons {
guint nb_item_add;
GtkWidget* add_button;
GtkWidget* remove_button;
GtkWidget* subtree_button;
} sTreeButtons;
/* end of tree section */
static GtkWidget *
build_option_menu (gchar *items[],
gint num_items,
gint history,
void (*func)(GtkWidget *widget, gpointer data),
gpointer data)
{
GtkWidget *omenu;
gint i;
omenu = gtk_combo_box_text_new ();
g_signal_connect (omenu, "changed",
G_CALLBACK (func), data);
for (i = 0; i < num_items; i++)
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (omenu), items[i]);
gtk_combo_box_set_active (GTK_COMBO_BOX (omenu), history);
return omenu;
}
/*
* Windows with an alpha channel
*/
static gboolean
on_alpha_window_draw (GtkWidget *widget,
cairo_t *cr)
{
cairo_pattern_t *pattern;
int radius, width, height;
width = gtk_widget_get_allocated_width (widget);
height = gtk_widget_get_allocated_height (widget);
radius = MIN (width, height) / 2;
pattern = cairo_pattern_create_radial (width / 2,
height / 2,
0.0,
width / 2,
height / 2,
radius * 1.33);
if (gdk_screen_get_rgba_visual (gtk_widget_get_screen (widget)) &&
gtk_widget_is_composited (widget))
cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.0); /* transparent */
else
cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); /* opaque white */
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_paint (cr);
cairo_pattern_add_color_stop_rgba (pattern, 0.0,
1.0, 0.75, 0.0, 1.0); /* solid orange */
cairo_pattern_add_color_stop_rgba (pattern, 1.0,
1.0, 0.75, 0.0, 0.0); /* transparent orange */
cairo_set_source (cr, pattern);
cairo_pattern_destroy (pattern);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
cairo_paint (cr);
return FALSE;
}
static GtkWidget *
build_alpha_widgets (void)
{
GtkWidget *grid;
GtkWidget *radio_button;
GtkWidget *check_button;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *entry;
grid = gtk_grid_new ();
radio_button = gtk_radio_button_new_with_label (NULL, "Red");
gtk_widget_set_hexpand (radio_button, TRUE);
gtk_grid_attach (GTK_GRID (grid), radio_button, 0, 0, 1, 1);
radio_button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_button), "Green");
gtk_widget_set_hexpand (radio_button, TRUE);
gtk_grid_attach (GTK_GRID (grid), radio_button, 0, 1, 1, 1);
radio_button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_button), "Blue"),
gtk_widget_set_hexpand (radio_button, TRUE);
gtk_grid_attach (GTK_GRID (grid), radio_button, 0, 2, 1, 1);
check_button = gtk_check_button_new_with_label ("Sedentary"),
gtk_widget_set_hexpand (check_button, TRUE);
gtk_grid_attach (GTK_GRID (grid), check_button, 1, 0, 1, 1);
check_button = gtk_check_button_new_with_label ("Nocturnal"),
gtk_widget_set_hexpand (check_button, TRUE);
gtk_grid_attach (GTK_GRID (grid), check_button, 1, 1, 1, 1);
check_button = gtk_check_button_new_with_label ("Compulsive"),
gtk_widget_set_hexpand (check_button, TRUE);
gtk_grid_attach (GTK_GRID (grid), check_button, 1, 2, 1, 1);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), "<i>Entry: </i>");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
gtk_widget_set_hexpand (hbox, TRUE);
gtk_grid_attach (GTK_GRID (grid), hbox, 0, 3, 2, 1);
return grid;
}
static void
on_alpha_screen_changed (GtkWindow *window,
GdkScreen *old_screen,
GtkWidget *label)
{
GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (window));
GdkVisual *visual = gdk_screen_get_rgba_visual (screen);
if (!visual)
{
visual = gdk_screen_get_system_visual (screen);
gtk_label_set_markup (GTK_LABEL (label), "<b>Screen doesn't support alpha</b>");
}
else
{
gtk_label_set_markup (GTK_LABEL (label), "<b>Screen supports alpha</b>");
}
gtk_widget_set_visual (GTK_WIDGET (window), visual);
}
static void
on_composited_changed (GtkWidget *window,
GtkLabel *label)
{
gboolean is_composited = gtk_widget_is_composited (window);
if (is_composited)
gtk_label_set_text (label, "Composited");
else
gtk_label_set_text (label, "Not composited");
}
void
create_alpha_window (GtkWidget *widget)
{
static GtkWidget *window;
if (!window)
{
GtkWidget *content_area;
GtkWidget *vbox;
GtkWidget *label;
window = gtk_dialog_new_with_buttons ("Alpha Window",
GTK_WINDOW (gtk_widget_get_toplevel (widget)), 0,
GTK_STOCK_CLOSE, 0,
NULL);
gtk_widget_set_app_paintable (window, TRUE);
g_signal_connect (window, "draw",
G_CALLBACK (on_alpha_window_draw), NULL);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_pack_start (GTK_BOX (content_area), vbox,
TRUE, TRUE, 0);
label = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
on_alpha_screen_changed (GTK_WINDOW (window), NULL, label);
g_signal_connect (window, "screen-changed",
G_CALLBACK (on_alpha_screen_changed), label);
label = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
on_composited_changed (window, GTK_LABEL (label));
g_signal_connect (window, "composited_changed", G_CALLBACK (on_composited_changed), label);
gtk_box_pack_start (GTK_BOX (vbox), build_alpha_widgets (), TRUE, TRUE, 0);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
g_signal_connect (window, "response",
G_CALLBACK (gtk_widget_destroy),
NULL);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/*
* Composited non-toplevel window
*/
/* The draw event handler for the event box.
*
* This function simply draws a transparency onto a widget on the area
* for which it receives expose events. This is intended to give the
* event box a "transparent" background.
*
* In order for this to work properly, the widget must have an RGBA
* colourmap. The widget should also be set as app-paintable since it
* doesn't make sense for GTK to draw a background if we are drawing it
* (and because GTK might actually replace our transparency with its
* default background colour).
*/
static gboolean
transparent_draw (GtkWidget *widget,
cairo_t *cr)
{
cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
cairo_paint (cr);
return FALSE;
}
/* The expose event handler for the window.
*
* This function performs the actual compositing of the event box onto
* the already-existing background of the window at 50% normal opacity.
*
* In this case we do not want app-paintable to be set on the widget
* since we want it to draw its own (red) background. Because of this,
* however, we must ensure that we use g_signal_register_after so that
* this handler is called after the red has been drawn. If it was
* called before then GTK would just blindly paint over our work.
*/
static gboolean
window_draw (GtkWidget *widget,
cairo_t *cr)
{
GtkAllocation allocation;
GtkWidget *child;
/* get our child (in this case, the event box) */
child = gtk_bin_get_child (GTK_BIN (widget));
gtk_widget_get_allocation (child, &allocation);
/* the source data is the (composited) event box */
gdk_cairo_set_source_window (cr, gtk_widget_get_window (child),
allocation.x,
allocation.y);
/* composite, with a 50% opacity */
cairo_paint_with_alpha (cr, 0.5);
return FALSE;
}
void
create_composited_window (GtkWidget *widget)
{
static GtkWidget *window;
if (!window)
{
GtkWidget *event, *button;
GdkRGBA red;
/* make the widgets */
button = gtk_button_new_with_label ("A Button");
event = gtk_event_box_new ();
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
/* put a red background on the window */
gdk_rgba_parse (&red, "red");
gtk_widget_override_background_color (window, 0, &red);
/* set our event box to have a fully-transparent background
* drawn on it. currently there is no way to simply tell gtk
* that "transparency" is the background colour for a widget.
*/
gtk_widget_set_app_paintable (GTK_WIDGET (event), TRUE);
g_signal_connect (event, "draw",
G_CALLBACK (transparent_draw), NULL);
/* put them inside one another */
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
gtk_container_add (GTK_CONTAINER (window), event);
gtk_container_add (GTK_CONTAINER (event), button);
/* realise and show everything */
gtk_widget_realize (button);
/* set the event box GdkWindow to be composited.
* obviously must be performed after event box is realised.
*/
gdk_window_set_composited (gtk_widget_get_window (event),
TRUE);
/* set up the compositing handler.
* note that we do _after so that the normal (red) background is drawn
* by gtk before our compositing occurs.
*/
g_signal_connect_after (window, "draw",
G_CALLBACK (window_draw), NULL);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/*
* Big windows and guffaw scrolling
*/
static void
pattern_set_bg (GtkWidget *widget,
GdkWindow *child,
gint level)
{
static GdkRGBA colors[] = {
{ 0.27, 0.27, 1.0, 1.0 },
{ 0.53, 0.53, 1.0, 1.0},
{ 0.67, 0.67, 1.0, 1.0 }
};
gdk_window_set_user_data (child, widget);
gdk_window_set_background_rgba (child, &colors[level]);
}
static void
create_pattern (GtkWidget *widget,
GdkWindow *parent,
gint level,
gint width,
gint height)
{
gint h = 1;
gint i = 0;
GdkWindow *child;
while (2 * h <= height)
{
gint w = 1;
gint j = 0;
while (2 * w <= width)
{
if ((i + j) % 2 == 0)
{
gint x = w - 1;
gint y = h - 1;
GdkWindowAttr attributes;
attributes.window_type = GDK_WINDOW_CHILD;
attributes.x = x;
attributes.y = y;
attributes.width = w;
attributes.height = h;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.event_mask = GDK_EXPOSURE_MASK;
attributes.visual = gtk_widget_get_visual (widget);
child = gdk_window_new (parent, &attributes,
GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL);
pattern_set_bg (widget, child, level);
if (level < 2)
create_pattern (widget, child, level + 1, w, h);
gdk_window_show (child);
}
j++;
w *= 2;
}
i++;
h *= 2;
}
}
#define PATTERN_SIZE (1 << 18)
static void
pattern_hadj_changed (GtkAdjustment *adjustment,
GtkWidget *darea)
{
gint *old_value = g_object_get_data (G_OBJECT (adjustment), "old-value");
gint new_value = gtk_adjustment_get_value (adjustment);
if (gtk_widget_get_realized (darea))
{
gdk_window_scroll (gtk_widget_get_window (darea),
*old_value - new_value, 0);
*old_value = new_value;
}
}
static void
pattern_vadj_changed (GtkAdjustment *adjustment,
GtkWidget *darea)
{
gint *old_value = g_object_get_data (G_OBJECT (adjustment), "old-value");
gint new_value = gtk_adjustment_get_value (adjustment);
if (gtk_widget_get_realized (darea))
{
gdk_window_scroll (gtk_widget_get_window (darea),
0, *old_value - new_value);
*old_value = new_value;
}
}
static void
pattern_realize (GtkWidget *widget,
gpointer data)
{
GdkWindow *window;
window = gtk_widget_get_window (widget);
pattern_set_bg (widget, window, 0);
create_pattern (widget, window, 1, PATTERN_SIZE, PATTERN_SIZE);
}
static void
create_big_windows (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *content_area;
GtkWidget *darea, *grid, *scrollbar;
GtkWidget *eventbox;
GtkAdjustment *hadjustment;
GtkAdjustment *vadjustment;
static gint current_x;
static gint current_y;
if (!window)
{
current_x = 0;
current_y = 0;
window = gtk_dialog_new_with_buttons ("Big Windows",
NULL, 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);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
g_signal_connect (window, "response",
G_CALLBACK (gtk_widget_destroy),
NULL);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
grid = gtk_grid_new ();
gtk_box_pack_start (GTK_BOX (content_area), grid, TRUE, TRUE, 0);
darea = gtk_drawing_area_new ();
hadjustment = gtk_adjustment_new (0, 0, PATTERN_SIZE, 10, 100, 100);
g_signal_connect (hadjustment, "value_changed",
G_CALLBACK (pattern_hadj_changed), darea);
g_object_set_data (G_OBJECT (hadjustment), "old-value", &current_x);
vadjustment = gtk_adjustment_new (0, 0, PATTERN_SIZE, 10, 100, 100);
g_signal_connect (vadjustment, "value_changed",
G_CALLBACK (pattern_vadj_changed), darea);
g_object_set_data (G_OBJECT (vadjustment), "old-value", &current_y);
g_signal_connect (darea, "realize",
G_CALLBACK (pattern_realize),
NULL);
eventbox = gtk_event_box_new ();
gtk_widget_set_hexpand (eventbox, TRUE);
gtk_widget_set_vexpand (eventbox, TRUE);
gtk_grid_attach (GTK_GRID (grid), eventbox, 0, 0, 1, 1);
gtk_container_add (GTK_CONTAINER (eventbox), darea);
scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, hadjustment);
gtk_widget_set_hexpand (scrollbar, TRUE);
gtk_grid_attach (GTK_GRID (grid), scrollbar, 0, 1, 1, 1);
scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, vadjustment);
gtk_widget_set_vexpand (scrollbar, TRUE);
gtk_grid_attach (GTK_GRID (grid), scrollbar, 1, 0, 1, 1);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_hide (window);
}
/*
* GtkButton
*/
static void
button_window (GtkWidget *widget,
GtkWidget *button)
{
if (!gtk_widget_get_visible (button))
gtk_widget_show (button);
else
gtk_widget_hide (button);
}
static void
create_buttons (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *grid;
GtkWidget *separator;
GtkWidget *button[10];
int button_x[9] = { 0, 1, 2, 0, 2, 1, 1, 2, 0 };
int button_y[9] = { 0, 1, 2, 2, 0, 2, 0, 1, 1 };
guint i;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_window_set_title (GTK_WINDOW (window), "GtkButton");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 5);
gtk_grid_set_column_spacing (GTK_GRID (grid), 5);
gtk_container_set_border_width (GTK_CONTAINER (grid), 10);
gtk_box_pack_start (GTK_BOX (box1), grid, TRUE, TRUE, 0);
button[0] = gtk_button_new_with_label ("button1");
button[1] = gtk_button_new_with_mnemonic ("_button2");
button[2] = gtk_button_new_with_mnemonic ("_button3");
button[3] = gtk_button_new_from_stock (GTK_STOCK_OK);
button[4] = gtk_button_new_with_label ("button5");
button[5] = gtk_button_new_with_label ("button6");
button[6] = gtk_button_new_with_label ("button7");
button[7] = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
button[8] = gtk_button_new_with_label ("button9");
for (i = 0; i < 9; i++)
{
g_signal_connect (button[i], "clicked",
G_CALLBACK (button_window),
button[(i + 1) % 9]);
gtk_widget_set_hexpand (button[i], TRUE);
gtk_widget_set_vexpand (button[i], TRUE);
gtk_grid_attach (GTK_GRID (grid), button[i],
button_x[i], button_y[i] + 1, 1, 1);
}
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
button[9] = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button[9], "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_box_pack_start (GTK_BOX (box2), button[9], TRUE, TRUE, 0);
gtk_widget_set_can_default (button[9], TRUE);
gtk_widget_grab_default (button[9]);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/*
* GtkToggleButton
*/
static void
create_toggle_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));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_window_set_title (GTK_WINDOW (window), "GtkToggleButton");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
button = gtk_toggle_button_new_with_label ("button1");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
button = gtk_toggle_button_new_with_label ("button2");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
button = gtk_toggle_button_new_with_label ("button3");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
button = gtk_toggle_button_new_with_label ("inconsistent");
gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
static GtkWidget *
create_widget_grid (GType widget_type)
{
GtkWidget *grid;
GtkWidget *group_widget = NULL;
gint i, j;
grid = gtk_grid_new ();
for (i = 0; i < 5; i++)
{
for (j = 0; j < 5; j++)
{
GtkWidget *widget;
char *tmp;
if (i == 0 && j == 0)
{
widget = NULL;
}
else if (i == 0)
{
tmp = g_strdup_printf ("%d", j);
widget = gtk_label_new (tmp);
g_free (tmp);
}
else if (j == 0)
{
tmp = g_strdup_printf ("%c", 'A' + i - 1);
widget = gtk_label_new (tmp);
g_free (tmp);
}
else
{
widget = g_object_new (widget_type, NULL);
if (g_type_is_a (widget_type, GTK_TYPE_RADIO_BUTTON))
{
if (!group_widget)
group_widget = widget;
else
g_object_set (widget, "group", group_widget, NULL);
}
}
if (widget)
gtk_grid_attach (GTK_GRID (grid), widget, i, j, 1, 1);
}
}
return grid;
}
/*
* GtkCheckButton
*/
static void
create_check_buttons (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *button;
GtkWidget *separator;
GtkWidget *table;
if (!window)
{
window = gtk_dialog_new_with_buttons ("Check Buttons",
NULL, 0,
GTK_STOCK_CLOSE,
GTK_RESPONSE_NONE,
NULL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
g_signal_connect (window, "response",
G_CALLBACK (gtk_widget_destroy),
NULL);
box1 = gtk_dialog_get_content_area (GTK_DIALOG (window));
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
button = gtk_check_button_new_with_mnemonic ("_button1");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
button = gtk_check_button_new_with_label ("button2");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
button = gtk_check_button_new_with_label ("button3");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
button = gtk_check_button_new_with_label ("inconsistent");
gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
table = create_widget_grid (GTK_TYPE_CHECK_BUTTON);
gtk_container_set_border_width (GTK_CONTAINER (table), 10);
gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/*
* GtkRadioButton
*/
static void
create_radio_buttons (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *button;
GtkWidget *separator;
GtkWidget *table;
if (!window)
{
window = gtk_dialog_new_with_buttons ("Radio Buttons",
NULL, 0,
GTK_STOCK_CLOSE,
GTK_RESPONSE_NONE,
NULL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
g_signal_connect (window, "response",
G_CALLBACK (gtk_widget_destroy),
NULL);
box1 = gtk_dialog_get_content_area (GTK_DIALOG (window));
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
button = gtk_radio_button_new_with_label (NULL, "button1");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
button = gtk_radio_button_new_with_label (
gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
"button2");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
button = gtk_radio_button_new_with_label (
gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
"button3");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
button = gtk_radio_button_new_with_label (
gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
"inconsistent");
gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
button = gtk_radio_button_new_with_label (NULL, "button4");
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
button = gtk_radio_button_new_with_label (
gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
"button5");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
button = gtk_radio_button_new_with_label (
gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
"button6");
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
table = create_widget_grid (GTK_TYPE_RADIO_BUTTON);
gtk_container_set_border_width (GTK_CONTAINER (table), 10);
gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/*
* GtkButtonBox
*/
static GtkWidget *
create_bbox (gint horizontal,
char* title,
gint spacing,
gint child_w,
gint child_h,
gint layout)
{
GtkWidget *frame;
GtkWidget *bbox;
GtkWidget *button;
frame = gtk_frame_new (title);
if (horizontal)
bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
else
bbox = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
gtk_container_add (GTK_CONTAINER (frame), bbox);
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), layout);
gtk_box_set_spacing (GTK_BOX (bbox), spacing);
button = gtk_button_new_with_label ("OK");
gtk_container_add (GTK_CONTAINER (bbox), button);
button = gtk_button_new_with_label ("Cancel");
gtk_container_add (GTK_CONTAINER (bbox), button);
button = gtk_button_new_with_label ("Help");
gtk_container_add (GTK_CONTAINER (bbox), button);
return frame;
}
static void
create_button_box (GtkWidget *widget)
{
static GtkWidget* window = NULL;
GtkWidget *main_vbox;
GtkWidget *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");
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), main_vbox);
frame_horz = gtk_frame_new ("Horizontal Button Boxes");
gtk_box_pack_start (GTK_BOX (main_vbox), frame_horz, TRUE, TRUE, 10);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
gtk_container_add (GTK_CONTAINER (frame_horz), vbox);
gtk_box_pack_start (GTK_BOX (vbox),
create_bbox (TRUE, "Spread", 40, 85, 20, GTK_BUTTONBOX_SPREAD),
TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox),
create_bbox (TRUE, "Edge", 40, 85, 20, GTK_BUTTONBOX_EDGE),
TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (vbox),
create_bbox (TRUE, "Start", 40, 85, 20, GTK_BUTTONBOX_START),
TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (vbox),
create_bbox (TRUE, "End", 40, 85, 20, GTK_BUTTONBOX_END),
TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (vbox),
create_bbox (TRUE, "Center", 40, 85, 20, GTK_BUTTONBOX_CENTER),
TRUE, TRUE, 5);
frame_vert = gtk_frame_new ("Vertical Button Boxes");
gtk_box_pack_start (GTK_BOX (main_vbox), frame_vert, TRUE, TRUE, 10);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_container_add (GTK_CONTAINER (frame_vert), hbox);
gtk_box_pack_start (GTK_BOX (hbox),
create_bbox (FALSE, "Spread", 30, 85, 20, GTK_BUTTONBOX_SPREAD),
TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox),
create_bbox (FALSE, "Edge", 30, 85, 20, GTK_BUTTONBOX_EDGE),
TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (hbox),
create_bbox (FALSE, "Start", 30, 85, 20, GTK_BUTTONBOX_START),
TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (hbox),
create_bbox (FALSE, "End", 30, 85, 20, GTK_BUTTONBOX_END),
TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (hbox),
create_bbox (FALSE, "Center", 30, 85, 20, GTK_BUTTONBOX_CENTER),
TRUE, TRUE, 5);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/*
* GtkToolBar
*/
static GtkWidget*
new_pixbuf (char *filename,
GdkWindow *window)
{
GtkWidget *widget;
GdkPixbuf *pixbuf;
if (strcmp (filename, "test.xpm") == 0)
pixbuf = NULL;
else
pixbuf = gdk_pixbuf_new_from_file (filename, NULL);
if (pixbuf == NULL)
pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) openfile);
widget = gtk_image_new_from_pixbuf (pixbuf);
g_object_unref (pixbuf);
return widget;
}
static void
set_toolbar_small_stock (GtkWidget *widget,
gpointer data)
{
gtk_toolbar_set_icon_size (GTK_TOOLBAR (data), GTK_ICON_SIZE_SMALL_TOOLBAR);
}
static void
set_toolbar_large_stock (GtkWidget *widget,
gpointer data)
{
gtk_toolbar_set_icon_size (GTK_TOOLBAR (data), GTK_ICON_SIZE_LARGE_TOOLBAR);
}
static void
set_toolbar_horizontal (GtkWidget *widget,
gpointer data)
{
gtk_orientable_set_orientation (GTK_ORIENTABLE (data), GTK_ORIENTATION_HORIZONTAL);
}
static void
set_toolbar_vertical (GtkWidget *widget,
gpointer data)
{
gtk_orientable_set_orientation (GTK_ORIENTABLE (data), GTK_ORIENTATION_VERTICAL);
}
static void
set_toolbar_icons (GtkWidget *widget,
gpointer data)
{
gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_ICONS);
}
static void
set_toolbar_text (GtkWidget *widget,
gpointer data)
{
gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_TEXT);
}
static void
set_toolbar_both (GtkWidget *widget,
gpointer data)
{
gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH);
}
static void
set_toolbar_both_horiz (GtkWidget *widget,
gpointer data)
{
gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH_HORIZ);
}
static void
set_toolbar_enable (GtkWidget *widget,
gpointer data)
{
GtkSettings *settings = gtk_widget_get_settings (widget);
g_object_set (settings, "gtk-enable-tooltips", TRUE, NULL);
}
static void
set_toolbar_disable (GtkWidget *widget,
gpointer data)
{
GtkSettings *settings = gtk_widget_get_settings (widget);
g_object_set (settings, "gtk-enable-tooltips", FALSE, NULL);
}
static GtkActionEntry create_toolbar_items[] = {
{ NULL, GTK_STOCK_NEW, NULL, NULL, "Stock icon: New",
G_CALLBACK (set_toolbar_small_stock) },
{ NULL, GTK_STOCK_OPEN, NULL, NULL, "Stock icon: Open",
G_CALLBACK (set_toolbar_large_stock) },
{ NULL, NULL, "Horizontal", NULL, "Horizontal toolbar layout",
G_CALLBACK (set_toolbar_horizontal) },
{ NULL, NULL, "Vertical", NULL, "Vertical toolbar layout",
G_CALLBACK (set_toolbar_vertical) },
{ NULL },
{ NULL, NULL, "Icons", NULL, "Only show toolbar icons",
G_CALLBACK (set_toolbar_icons) },
{ NULL, NULL, "Text", NULL, "Only show toolbar text",
G_CALLBACK (set_toolbar_text) },
{ NULL, NULL, "Both", NULL, "Show toolbar icons and text",
G_CALLBACK (set_toolbar_both) },
{ NULL, NULL, "Both (horizontal)", NULL, "Show toolbar icons and text in a horizontal fashion",
G_CALLBACK (set_toolbar_both_horiz) },
{ NULL },
{ "entry", NULL, NULL, "This is an unusable GtkEntry ;)",
NULL },
{ NULL },
{ NULL },
{ NULL, NULL, "Enable", NULL, "Enable tooltips",
G_CALLBACK (set_toolbar_enable) },
{ NULL, NULL, "Disable", NULL, "Disable tooltips",
G_CALLBACK (set_toolbar_disable) },
{ NULL },
{ NULL, NULL, "Frobate", NULL, "Frobate tooltip",
NULL },
{ NULL, NULL, "Baz", NULL, "Baz tooltip",
NULL },
{ NULL },
{ NULL, NULL, "Blah", NULL, "Blash tooltip",
NULL },
{ NULL, NULL, "Bar", NULL, "Bar tooltip",
NULL },
};
static void
create_toolbar (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *toolbar;
if (!window)
{
guint i;
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");
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_widget_realize (window);
toolbar = gtk_toolbar_new ();
for (i = 0; i < G_N_ELEMENTS (create_toolbar_items); i++)
{
GtkToolItem *toolitem;
if (create_toolbar_items[i].tooltip == NULL)
toolitem = gtk_separator_tool_item_new ();
else if (g_strcmp0 (create_toolbar_items[i].name, "entry") == 0)
{
GtkWidget *entry;
toolitem = gtk_tool_item_new ();
entry = gtk_entry_new ();
gtk_container_add (GTK_CONTAINER (toolitem), entry);
}
else if (create_toolbar_items[i].stock_id)
toolitem = gtk_tool_button_new_from_stock (create_toolbar_items[i].stock_id);
else
{
GtkWidget *icon;
icon = new_pixbuf ("test.xpm", gtk_widget_get_window (window));
toolitem = gtk_tool_button_new (icon, create_toolbar_items[i].label);
}
if (create_toolbar_items[i].callback)
g_signal_connect (toolitem, "clicked",
create_toolbar_items[i].callback, toolbar);
gtk_tool_item_set_tooltip_text (toolitem, create_toolbar_items[i].tooltip);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
}
gtk_container_add (GTK_CONTAINER (window), toolbar);
gtk_widget_set_size_request (toolbar, 200, -1);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/*
* GtkStatusBar
*/
static guint statusbar_counter = 1;
static void
statusbar_push (GtkWidget *button,
GtkStatusbar *statusbar)
{
gchar text[1024];
sprintf (text, "something %d", statusbar_counter++);
gtk_statusbar_push (statusbar, 1, text);
}
static void
statusbar_push_long (GtkWidget *button,
GtkStatusbar *statusbar)
{
gchar text[1024];
sprintf (text, "Just because a system has menu choices written with English words, phrases or sentences, that is no guarantee, that it is comprehensible. Individual words may not be familiar to some users (for example, \"repaginate\"), and two menu items may appear to satisfy the users's needs, whereas only one does (for example, \"put away\" or \"eject\").");
gtk_statusbar_push (statusbar, 1, text);
}
static void
statusbar_pop (GtkWidget *button,
GtkStatusbar *statusbar)
{
gtk_statusbar_pop (statusbar, 1);
}
static void
statusbar_steal (GtkWidget *button,
GtkStatusbar *statusbar)
{
gtk_statusbar_remove (statusbar, 1, 4);
}
static void
statusbar_popped (GtkStatusbar *statusbar,
guint context_id,
const gchar *text)
{
if (!text)
statusbar_counter = 1;
}
static void
statusbar_contexts (GtkStatusbar *statusbar)
{
gchar *string;
string = "any context";
g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
string,
gtk_statusbar_get_context_id (statusbar, string));
string = "idle messages";
g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
string,
gtk_statusbar_get_context_id (statusbar, string));
string = "some text";
g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
string,
gtk_statusbar_get_context_id (statusbar, string));
string = "hit the mouse";
g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
string,
gtk_statusbar_get_context_id (statusbar, string));
string = "hit the mouse2";
g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
string,
gtk_statusbar_get_context_id (statusbar, string));
}
static void
create_statusbar (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *button;
GtkWidget *separator;
GtkWidget *statusbar;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_window_set_title (GTK_WINDOW (window), "statusbar");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
statusbar = gtk_statusbar_new ();
gtk_box_pack_end (GTK_BOX (box1), statusbar, TRUE, TRUE, 0);
g_signal_connect (statusbar,
"text_popped",
G_CALLBACK (statusbar_popped),
NULL);
button = g_object_new (gtk_button_get_type (),
"label", "push something",
"visible", TRUE,
"parent", box2,
NULL);
g_object_connect (button,
"signal::clicked", statusbar_push, statusbar,
NULL);
button = g_object_connect (g_object_new (gtk_button_get_type (),
"label", "pop",
"visible", TRUE,
"parent", box2,
NULL),
"signal_after::clicked", statusbar_pop, statusbar,
NULL);
button = g_object_connect (g_object_new (gtk_button_get_type (),
"label", "steal #4",
"visible", TRUE,
"parent", box2,
NULL),
"signal_after::clicked", statusbar_steal, statusbar,
NULL);
button = g_object_connect (g_object_new (gtk_button_get_type (),
"label", "test contexts",
"visible", TRUE,
"parent", box2,
NULL),
"swapped_signal_after::clicked", statusbar_contexts, statusbar,
NULL);
button = g_object_connect (g_object_new (gtk_button_get_type (),
"label", "push something long",
"visible", TRUE,
"parent", box2,
NULL),
"signal_after::clicked", statusbar_push_long, statusbar,
NULL);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/*
* Label Demo
*/
static void
sensitivity_toggled (GtkWidget *toggle,
GtkWidget *widget)
{
gtk_widget_set_sensitive (widget,
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle)));
}
static GtkWidget*
create_sensitivity_control (GtkWidget *widget)
{
GtkWidget *button;
button = gtk_toggle_button_new_with_label ("Sensitive");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
gtk_widget_is_sensitive (widget));
g_signal_connect (button,
"toggled",
G_CALLBACK (sensitivity_toggled),
widget);
gtk_widget_show_all (button);
return button;
}
static void
set_selectable_recursive (GtkWidget *widget,
gboolean setting)
{
if (GTK_IS_CONTAINER (widget))
{
GList *children;
GList *tmp;
children = gtk_container_get_children (GTK_CONTAINER (widget));
tmp = children;
while (tmp)
{
set_selectable_recursive (tmp->data, setting);
tmp = tmp->next;
}
g_list_free (children);
}
else if (GTK_IS_LABEL (widget))
{
gtk_label_set_selectable (GTK_LABEL (widget), setting);
}
}
static void
selectable_toggled (GtkWidget *toggle,
GtkWidget *widget)
{
set_selectable_recursive (widget,
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle)));
}
static GtkWidget*
create_selectable_control (GtkWidget *widget)
{
GtkWidget *button;
button = gtk_toggle_button_new_with_label ("Selectable");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
FALSE);
g_signal_connect (button,
"toggled",
G_CALLBACK (selectable_toggled),
widget);
gtk_widget_show_all (button);
return button;
}
static void
dialog_response (GtkWidget *dialog, gint response_id, GtkLabel *label)
{
const gchar *text;
gtk_widget_destroy (dialog);
text = "Some <a href=\"http://en.wikipedia.org/wiki/Text\" title=\"plain text\">text</a> may be marked up\n"
"as hyperlinks, which can be clicked\n"
"or activated via <a href=\"keynav\">keynav</a>.\n"
"The links remain the same.";
gtk_label_set_markup (label, text);
}
static gboolean
activate_link (GtkWidget *label, const gchar *uri, gpointer data)
{
if (g_strcmp0 (uri, "keynav") == 0)
{
GtkWidget *dialog;
dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW (gtk_widget_get_toplevel (label)),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
"The term <i>keynav</i> is a shorthand for "
"keyboard navigation and refers to the process of using a program "
"(exclusively) via keyboard input.");
gtk_window_present (GTK_WINDOW (dialog));
g_signal_connect (dialog, "response", G_CALLBACK (dialog_response), label);
return TRUE;
}
return FALSE;
}
void create_labels (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *hbox;
GtkWidget *vbox;
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));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_window_set_title (GTK_WINDOW (window), "Label");
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
button = create_sensitivity_control (hbox);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = create_selectable_control (hbox);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (window), 5);
frame = gtk_frame_new ("Normal Label");
label = gtk_label_new ("This is a Normal label");
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_START);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Multi-line Label");
label = gtk_label_new ("This is a Multi-line label.\nSecond line\nThird line");
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Left Justified Label");
label = gtk_label_new ("This is a Left-Justified\nMulti-line label.\nThird line");
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_MIDDLE);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Right Justified Label");
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_START);
label = gtk_label_new ("This is a Right-Justified\nMulti-line label.\nFourth line, (j/k)");
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Internationalized Label");
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"French (Fran\303\247ais) Bonjour, Salut\n"
"Korean (\355\225\234\352\270\200) \354\225\210\353\205\225\355\225\230\354\204\270\354\232\224, \354\225\210\353\205\225\355\225\230\354\213\255\353\213\210\352\271\214\n"
"Russian (\320\240\321\203\321\201\321\201\320\272\320\270\320\271) \320\227\320\264\321\200\320\260\320\262\321\201\321\202\320\262\321\203\320\271\321\202\320\265!\n"
"Chinese (Simplified) <span lang=\"zh-cn\">\345\205\203\346\260\224 \345\274\200\345\217\221</span>\n"
"Chinese (Traditional) <span lang=\"zh-tw\">\345\205\203\346\260\243 \351\226\213\347\231\274</span>\n"
"Japanese <span lang=\"ja\">\345\205\203\346\260\227 \351\226\213\347\231\272</span>");
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Bidirection Label");
label = gtk_label_new ("\342\200\217Arabic \330\247\331\204\330\263\331\204\330\247\331\205 \330\271\331\204\331\212\331\203\331\205\n"
"\342\200\217Hebrew \327\251\327\234\327\225\327\235");
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Links in a label");
label = gtk_label_new ("Some <a href=\"http://en.wikipedia.org/wiki/Text\" title=\"plain text\">text</a> may be marked up\n"
"as hyperlinks, which can be clicked\n"
"or activated via <a href=\"keynav\">keynav</a>");
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
g_signal_connect (label, "activate-link", G_CALLBACK (activate_link), NULL);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
frame = gtk_frame_new ("Line wrapped label");
label = gtk_label_new ("This is an example of a line-wrapped label. It should not be taking "\
"up the entire "/* big space to test spacing */\
"width allocated to it, but automatically wraps the words to fit. "\
"The time has come, for all good men, to come to the aid of their party. "\
"The sixth sheik's six sheep's sick.\n"\
" It supports multiple paragraphs correctly, and correctly adds "\
"many extra spaces. ");
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Filled, wrapped label");
label = gtk_label_new ("This is an example of a line-wrapped, filled label. It should be taking "\
"up the entire width allocated to it. Here is a seneance to prove "\
"my point. Here is another sentence. "\
"Here comes the sun, do de do de do.\n"\
" This is a new paragraph.\n"\
" This is another newer, longer, better paragraph. It is coming to an end, "\
"unfortunately.");
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_FILL);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Underlined label");
label = gtk_label_new ("This label is underlined!\n"
"This one is underlined (\343\201\223\343\202\223\343\201\253\343\201\241\343\201\257) in quite a funky fashion");
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_label_set_pattern (GTK_LABEL (label), "_________________________ _ _________ _ _____ _ __ __ ___ ____ _____");
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Markup label");
label = gtk_label_new (NULL);
/* There's also a gtk_label_set_markup() without accel if you
* don't have an accelerator key
*/
gtk_label_set_markup_with_mnemonic (GTK_LABEL (label),
"This <span foreground=\"blue\" background=\"orange\">label</span> has "
"<b>markup</b> _such as "
"<big><i>Big Italics</i></big>\n"
"<tt>Monospace font</tt>\n"
"<u>Underline!</u>\n"
"foo\n"
"<span foreground=\"green\" background=\"red\">Ugly colors</span>\n"
"and nothing on this line,\n"
"or this.\n"
"or this either\n"
"or even on this one\n"
"la <big>la <big>la <big>la <big>la</big></big></big></big>\n"
"but this _word is <span foreground=\"purple\"><big>purple</big></span>\n"
"<span underline=\"double\">We like <sup>superscript</sup> and <sub>subscript</sub> too</span>");
g_assert (gtk_label_get_mnemonic_keyval (GTK_LABEL (label)) == GDK_KEY_s);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
static void
on_angle_scale_changed (GtkRange *range,
GtkLabel *label)
{
gtk_label_set_angle (GTK_LABEL (label), gtk_range_get_value (range));
}
static void
create_rotated_label (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *content_area;
GtkWidget *vbox;
GtkWidget *hscale;
GtkWidget *label;
GtkWidget *scale_label;
GtkWidget *scale_hbox;
if (!window)
{
window = gtk_dialog_new_with_buttons ("Rotated Label",
GTK_WINDOW (gtk_widget_get_toplevel (widget)), 0,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL);
gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_pack_start (GTK_BOX (content_area), vbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), "Hello World\n<i>Rotate</i> <span underline='single' foreground='blue'>me</span>");
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
scale_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), scale_hbox, FALSE, FALSE, 0);
scale_label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (scale_label), "<i>Angle: </i>");
gtk_box_pack_start (GTK_BOX (scale_hbox), scale_label, FALSE, FALSE, 0);
hscale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
0, 360, 5);
g_signal_connect (hscale, "value-changed",
G_CALLBACK (on_angle_scale_changed), label);
gtk_range_set_value (GTK_RANGE (hscale), 45);
gtk_widget_set_size_request (hscale, 200, -1);
gtk_box_pack_start (GTK_BOX (scale_hbox), hscale, TRUE, TRUE, 0);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
#define DEFAULT_TEXT_RADIUS 200
static void
on_rotated_text_unrealize (GtkWidget *widget)
{
g_object_set_data (G_OBJECT (widget), "text-gc", NULL);
}
static gboolean
on_rotated_text_draw (GtkWidget *widget,
cairo_t *cr,
GdkPixbuf *tile_pixbuf)
{
static const gchar *words[] = { "The", "grand", "old", "Duke", "of", "York",
"had", "10,000", "men" };
int n_words;
int i;
int width, height;
double radius;
PangoLayout *layout;
PangoContext *context;
PangoFontDescription *desc;
if (tile_pixbuf)
{
gdk_cairo_set_source_pixbuf (cr, tile_pixbuf, 0, 0);
cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);
}
else
cairo_set_source_rgb (cr, 0, 0, 0);
width = gtk_widget_get_allocated_width (widget);
height = gtk_widget_get_allocated_height (widget);
radius = MIN (width, height) / 2.;
cairo_translate (cr,
radius + (width - 2 * radius) / 2,
radius + (height - 2 * radius) / 2);
cairo_scale (cr, radius / DEFAULT_TEXT_RADIUS, radius / DEFAULT_TEXT_RADIUS);
context = gtk_widget_get_pango_context (widget);
layout = pango_layout_new (context);
desc = pango_font_description_from_string ("Sans Bold 30");
pango_layout_set_font_description (layout, desc);
pango_font_description_free (desc);
n_words = G_N_ELEMENTS (words);
for (i = 0; i < n_words; i++)
{
int width, height;
cairo_save (cr);
cairo_rotate (cr, 2 * G_PI * i / n_words);
pango_cairo_update_layout (cr, layout);
pango_layout_set_text (layout, words[i], -1);
pango_layout_get_size (layout, &width, &height);
cairo_move_to (cr, - width / 2 / PANGO_SCALE, - DEFAULT_TEXT_RADIUS);
pango_cairo_show_layout (cr, layout);
cairo_restore (cr);
}
g_object_unref (layout);
return FALSE;
}
static void
create_rotated_text (GtkWidget *widget)
{
static GtkWidget *window = NULL;
if (!window)
{
const GdkRGBA white = { 1.0, 1.0, 1.0, 1.0 };
GtkRequisition requisition;
GtkWidget *content_area;
GtkWidget *drawing_area;
GdkPixbuf *tile_pixbuf;
window = gtk_dialog_new_with_buttons ("Rotated Text",
GTK_WINDOW (gtk_widget_get_toplevel (widget)), 0,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL);
gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
drawing_area = gtk_drawing_area_new ();
gtk_box_pack_start (GTK_BOX (content_area), drawing_area, TRUE, TRUE, 0);
gtk_widget_override_background_color (drawing_area, 0, &white);
tile_pixbuf = gdk_pixbuf_new_from_file ("marble.xpm", NULL);
g_signal_connect (drawing_area, "draw",
G_CALLBACK (on_rotated_text_draw), tile_pixbuf);
g_signal_connect (drawing_area, "unrealize",
G_CALLBACK (on_rotated_text_unrealize), NULL);
gtk_widget_show_all (gtk_bin_get_child (GTK_BIN (window)));
gtk_widget_set_size_request (drawing_area, DEFAULT_TEXT_RADIUS * 2, DEFAULT_TEXT_RADIUS * 2);
gtk_widget_get_preferred_size ( (window),
&requisition, NULL);
gtk_widget_set_size_request (drawing_area, -1, -1);
gtk_window_resize (GTK_WINDOW (window), requisition.width, requisition.height);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
}
/*
* Reparent demo
*/
static void
reparent_label (GtkWidget *widget,
GtkWidget *new_parent)
{
GtkWidget *label;
label = g_object_get_data (G_OBJECT (widget), "user_data");
gtk_widget_reparent (label, new_parent);
}
static void
set_parent_signal (GtkWidget *child,
GtkWidget *old_parent,
gpointer func_data)
{
GtkWidget *parent;
parent = gtk_widget_get_parent (child);
g_message ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n",
g_type_name (G_OBJECT_TYPE (child)),
parent ? g_type_name (G_OBJECT_TYPE (parent)) : "NULL",
old_parent ? g_type_name (G_OBJECT_TYPE (old_parent)) : "NULL",
GPOINTER_TO_INT (func_data));
}
static void
create_reparent (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *box3;
GtkWidget *frame;
GtkWidget *button;
GtkWidget *label;
GtkWidget *separator;
GtkWidget *event_box;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_window_set_title (GTK_WINDOW (window), "reparent");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
label = gtk_label_new ("Hello World");
frame = gtk_frame_new ("Frame 1");
gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
box3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
gtk_container_add (GTK_CONTAINER (frame), box3);
button = gtk_button_new_with_label ("switch");
g_object_set_data (G_OBJECT (button), "user_data", label);
gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
event_box = gtk_event_box_new ();
gtk_box_pack_start (GTK_BOX (box3), event_box, FALSE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (event_box), label);
g_signal_connect (button, "clicked",
G_CALLBACK (reparent_label),
event_box);
g_signal_connect (label, "parent_set",
G_CALLBACK (set_parent_signal),
GINT_TO_POINTER (42));
frame = gtk_frame_new ("Frame 2");
gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
box3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
gtk_container_add (GTK_CONTAINER (frame), box3);
button = gtk_button_new_with_label ("switch");
g_object_set_data (G_OBJECT (button), "user_data", label);
gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
event_box = gtk_event_box_new ();
gtk_box_pack_start (GTK_BOX (box3), event_box, FALSE, TRUE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (reparent_label),
event_box);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy), window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/*
* Resize Grips
*/
static gboolean
grippy_button_press (GtkWidget *area, GdkEventButton *event, GdkWindowEdge edge)
{
if (event->type == GDK_BUTTON_PRESS)
{
if (event->button == GDK_BUTTON_PRIMARY)
gtk_window_begin_resize_drag (GTK_WINDOW (gtk_widget_get_toplevel (area)), edge,
event->button, event->x_root, event->y_root,
event->time);
else if (event->button == GDK_BUTTON_MIDDLE)
gtk_window_begin_move_drag (GTK_WINDOW (gtk_widget_get_toplevel (area)),
event->button, event->x_root, event->y_root,
event->time);
}
return TRUE;
}
static gboolean
grippy_draw (GtkWidget *area, cairo_t *cr, GdkWindowEdge edge)
{
GtkStyleContext *context;
GtkJunctionSides sides;
switch (edge)
{
case GDK_WINDOW_EDGE_NORTH_WEST:
sides = GTK_JUNCTION_CORNER_TOPLEFT;
break;
case GDK_WINDOW_EDGE_NORTH:
sides = GTK_JUNCTION_TOP;
break;
case GDK_WINDOW_EDGE_NORTH_EAST:
sides = GTK_JUNCTION_CORNER_TOPRIGHT;
break;
case GDK_WINDOW_EDGE_WEST:
sides = GTK_JUNCTION_LEFT;
break;
case GDK_WINDOW_EDGE_EAST:
sides = GTK_JUNCTION_RIGHT;
break;
case GDK_WINDOW_EDGE_SOUTH_WEST:
sides = GTK_JUNCTION_CORNER_BOTTOMLEFT;
break;
case GDK_WINDOW_EDGE_SOUTH:
sides = GTK_JUNCTION_BOTTOM;
break;
case GDK_WINDOW_EDGE_SOUTH_EAST:
sides = GTK_JUNCTION_CORNER_BOTTOMRIGHT;
break;
default:
g_assert_not_reached();
}
context = gtk_widget_get_style_context (area);
gtk_style_context_save (context);
gtk_style_context_add_class (context, "grip");
gtk_style_context_set_junction_sides (context, sides);
gtk_render_handle (context, cr,
0, 0,
gtk_widget_get_allocated_width (area),
gtk_widget_get_allocated_height (area));
gtk_style_context_restore (context);
return TRUE;
}
static void
create_resize_grips (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *area;
GtkWidget *hbox, *vbox;
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), "resize grips");
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
/* North west */
area = gtk_drawing_area_new ();
gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_WEST));
g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_WEST));
/* North */
area = gtk_drawing_area_new ();
gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH));
g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH));
/* North east */
area = gtk_drawing_area_new ();
gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_EAST));
g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_EAST));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
/* West */
area = gtk_drawing_area_new ();
gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
GINT_TO_POINTER (GDK_WINDOW_EDGE_WEST));
g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
GINT_TO_POINTER (GDK_WINDOW_EDGE_WEST));
/* Middle */
area = gtk_drawing_area_new ();
gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
/* East */
area = gtk_drawing_area_new ();
gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
GINT_TO_POINTER (GDK_WINDOW_EDGE_EAST));
g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
GINT_TO_POINTER (GDK_WINDOW_EDGE_EAST));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
/* South west */
area = gtk_drawing_area_new ();
gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_WEST));
g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_WEST));
/* South */
area = gtk_drawing_area_new ();
gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH));
g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH));
/* South east */
area = gtk_drawing_area_new ();
gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_EAST));
g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_EAST));
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/*
* Saved Position
*/
gint upositionx = 0;
gint upositiony = 0;
static gint
uposition_configure (GtkWidget *window)
{
GtkLabel *lx;
GtkLabel *ly;
gchar buffer[64];
lx = g_object_get_data (G_OBJECT (window), "x");
ly = g_object_get_data (G_OBJECT (window), "y");
gdk_window_get_root_origin (gtk_widget_get_window (window),
&upositionx, &upositiony);
sprintf (buffer, "%d", upositionx);
gtk_label_set_text (lx, buffer);
sprintf (buffer, "%d", upositiony);
gtk_label_set_text (ly, buffer);
return FALSE;
}
static void
uposition_stop_configure (GtkToggleButton *toggle,
GObject *window)
{
if (gtk_toggle_button_get_active (toggle))
g_signal_handlers_block_by_func (window, G_CALLBACK (uposition_configure), NULL);
else
g_signal_handlers_unblock_by_func (window, G_CALLBACK (uposition_configure), NULL);
}
static void
create_saved_position (GtkWidget *widget)
{
static GtkWidget *window = NULL;
if (!window)
{
GtkWidget *hbox;
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkWidget *x_label;
GtkWidget *y_label;
GtkWidget *button;
GtkWidget *label;
GtkWidget *any;
window = g_object_connect (g_object_new (GTK_TYPE_WINDOW,
"type", GTK_WINDOW_TOPLEVEL,
"title", "Saved Position",
NULL),
"signal::configure_event", uposition_configure, NULL,
NULL);
gtk_window_move (GTK_WINDOW (window), upositionx, upositiony);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
gtk_container_add (GTK_CONTAINER (window), main_vbox);
vbox =
g_object_new (GTK_TYPE_BOX,
"orientation", GTK_ORIENTATION_VERTICAL,
"GtkBox::homogeneous", FALSE,
"GtkBox::spacing", 5,
"GtkContainer::border_width", 10,
"GtkWidget::parent", main_vbox,
"GtkWidget::visible", TRUE,
"child", g_object_connect (g_object_new (GTK_TYPE_TOGGLE_BUTTON,
"label", "Stop Events",
"active", FALSE,
"visible", TRUE,
NULL),
"signal::clicked", uposition_stop_configure, window,
NULL),
NULL);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
label = gtk_label_new ("X Origin : ");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
x_label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), x_label, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (window), "x", x_label);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
label = gtk_label_new ("Y Origin : ");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
y_label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), y_label, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (window), "y", y_label);
any =
g_object_new (gtk_separator_get_type (),
"GtkWidget::visible", TRUE,
NULL);
gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("Close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
gtk_widget_show_all (window);
}
else
gtk_widget_destroy (window);
}
/*
* GtkPixmap
*/
static void
create_pixbuf (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *box3;
GtkWidget *button;
GtkWidget *label;
GtkWidget *separator;
GtkWidget *pixbufwid;
GdkWindow *gdk_window;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_window_set_title (GTK_WINDOW (window), "GtkPixmap");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_widget_realize(window);
box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
button = gtk_button_new ();
gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
gdk_window = gtk_widget_get_window (window);
pixbufwid = new_pixbuf ("test.xpm", gdk_window);
label = gtk_label_new ("Pixbuf\ntest");
box3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
gtk_container_add (GTK_CONTAINER (box3), pixbufwid);
gtk_container_add (GTK_CONTAINER (box3), label);
gtk_container_add (GTK_CONTAINER (button), box3);
button = gtk_button_new ();
gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
pixbufwid = new_pixbuf ("test.xpm", gdk_window);
label = gtk_label_new ("Pixbuf\ntest");
box3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
gtk_container_add (GTK_CONTAINER (box3), pixbufwid);
gtk_container_add (GTK_CONTAINER (box3), label);
gtk_container_add (GTK_CONTAINER (button), box3);
gtk_widget_set_sensitive (button, FALSE);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
static void
create_tooltips (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *box3;
GtkWidget *button;
GtkWidget *toggle;
GtkWidget *frame;
GtkWidget *separator;
if (!window)
{
window =
g_object_new (gtk_window_get_type (),
"GtkWindow::type", GTK_WINDOW_TOPLEVEL,
"GtkContainer::border_width", 0,
"GtkWindow::title", "Tooltips",
"GtkWindow::resizable", FALSE,
NULL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
button = gtk_toggle_button_new_with_label ("button1");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text (button, "This is button 1");
button = gtk_toggle_button_new_with_label ("button2");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text (button,
"This is button 2. This is also a really long tooltip which probably "
"won't fit on a single line and will therefore need to be wrapped. "
"Hopefully the wrapping will work correctly.");
toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text (toggle, "Toggle TipsQuery view.");
box3 =
g_object_new (GTK_TYPE_BOX,
"orientation", GTK_ORIENTATION_VERTICAL,
"homogeneous", FALSE,
"spacing", 5,
"border_width", 5,
"visible", TRUE,
NULL);
button =
g_object_new (gtk_button_get_type (),
"label", "[?]",
"visible", TRUE,
"parent", box3,
NULL);
gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
gtk_widget_set_tooltip_text (button, "Start the Tooltips Inspector");
frame = g_object_new (gtk_frame_get_type (),
"label", "ToolTips Inspector",
"label_xalign", (double) 0.5,
"border_width", 0,
"visible", TRUE,
"parent", box2,
"child", box3,
NULL);
gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
gtk_widget_set_tooltip_text (button, "Push this button to close window");
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/*
* GtkImage
*/
static void
pack_image (GtkWidget *box,
const gchar *text,
GtkWidget *image)
{
gtk_box_pack_start (GTK_BOX (box),
gtk_label_new (text),
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box),
image,
TRUE, TRUE, 0);
}
static void
create_image (GtkWidget *widget)
{
static GtkWidget *window = NULL;
if (window == NULL)
{
GtkWidget *vbox;
GdkPixbuf *pixbuf;
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
*/
gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add (GTK_CONTAINER (window), vbox);
pack_image (vbox, "Stock Warning Dialog",
gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING,
GTK_ICON_SIZE_DIALOG));
pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) openfile);
pack_image (vbox, "Pixbuf",
gtk_image_new_from_pixbuf (pixbuf));
g_object_unref (pixbuf);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/*
* Menu demo
*/
static GtkWidget*
create_menu (GdkScreen *screen, gint depth, gint length)
{
GtkWidget *menu;
GtkWidget *menuitem;
GtkWidget *image;
GSList *group;
char buf[32];
int i, j;
if (depth < 1)
return NULL;
menu = gtk_menu_new ();
gtk_menu_set_screen (GTK_MENU (menu), screen);
group = NULL;
image = gtk_image_new_from_stock (GTK_STOCK_OPEN,
GTK_ICON_SIZE_MENU);
gtk_widget_show (image);
menuitem = gtk_image_menu_item_new_with_label ("Image item");
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
for (i = 0, j = 1; i < length; i++, j++)
{
sprintf (buf, "item %2d - %d", depth, j);
menuitem = gtk_radio_menu_item_new_with_label (group, buf);
group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
if (i == 3)
gtk_widget_set_sensitive (menuitem, FALSE);
if (i == 5)
gtk_check_menu_item_set_inconsistent (GTK_CHECK_MENU_ITEM (menuitem),
TRUE);
if (i < 5)
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem),
create_menu (screen, depth - 1, 5));
}
return menu;
}
static GtkWidget*
create_table_menu (GdkScreen *screen, gint cols, gint rows)
{
GtkWidget *menu;
GtkWidget *menuitem;
GtkWidget *submenu;
GtkWidget *image;
char buf[32];
int i, j;
menu = gtk_menu_new ();
gtk_menu_set_screen (GTK_MENU (menu), screen);
j = 0;
menuitem = gtk_menu_item_new_with_label ("items");
gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
submenu = gtk_menu_new ();
gtk_menu_set_screen (GTK_MENU (submenu), screen);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
gtk_widget_show (menuitem);
j++;
/* now fill the items submenu */
image = gtk_image_new_from_stock (GTK_STOCK_HELP,
GTK_ICON_SIZE_MENU);
gtk_widget_show (image);
menuitem = gtk_image_menu_item_new_with_label ("Image");
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("x");
gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 0, 1);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("x");
gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 1, 2);
gtk_widget_show (menuitem);
image = gtk_image_new_from_stock (GTK_STOCK_HELP,
GTK_ICON_SIZE_MENU);
gtk_widget_show (image);
menuitem = gtk_image_menu_item_new_with_label ("Image");
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 1, 2);
gtk_widget_show (menuitem);
menuitem = gtk_radio_menu_item_new_with_label (NULL, "Radio");
gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 2, 3);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("x");
gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 2, 3);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("x");
gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 3, 4);
gtk_widget_show (menuitem);
menuitem = gtk_radio_menu_item_new_with_label (NULL, "Radio");
gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 3, 4);
gtk_widget_show (menuitem);
menuitem = gtk_check_menu_item_new_with_label ("Check");
gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 4, 5);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("x");
gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 4, 5);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("x");
gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 5, 6);
gtk_widget_show (menuitem);
menuitem = gtk_check_menu_item_new_with_label ("Check");
gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 5, 6);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("1. Inserted normally (8)");
gtk_widget_show (menuitem);
gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 8);
menuitem = gtk_menu_item_new_with_label ("2. Inserted normally (2)");
gtk_widget_show (menuitem);
gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 2);
menuitem = gtk_menu_item_new_with_label ("3. Inserted normally (0)");
gtk_widget_show (menuitem);
gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 0);
menuitem = gtk_menu_item_new_with_label ("4. Inserted normally (-1)");
gtk_widget_show (menuitem);
gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, -1);
/* end of items submenu */
menuitem = gtk_menu_item_new_with_label ("spanning");
gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
submenu = gtk_menu_new ();
gtk_menu_set_screen (GTK_MENU (submenu), screen);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
gtk_widget_show (menuitem);
j++;
/* now fill the spanning submenu */
menuitem = gtk_menu_item_new_with_label ("a");
gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 2, 0, 1);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("b");
gtk_menu_attach (GTK_MENU (submenu), menuitem, 2, 3, 0, 2);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("c");
gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 1, 3);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("d");
gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 1, 2);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("e");
gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 3, 2, 3);
gtk_widget_show (menuitem);
/* end of spanning submenu */
menuitem = gtk_menu_item_new_with_label ("left");
gtk_menu_attach (GTK_MENU (menu), menuitem, 0, 1, j, j + 1);
submenu = gtk_menu_new ();
gtk_menu_set_screen (GTK_MENU (submenu), screen);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("Empty");
gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
submenu = gtk_menu_new ();
gtk_menu_set_screen (GTK_MENU (submenu), screen);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("right");
gtk_menu_attach (GTK_MENU (menu), menuitem, 1, 2, j, j + 1);
submenu = gtk_menu_new ();
gtk_menu_set_screen (GTK_MENU (submenu), screen);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("Empty");
gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
gtk_widget_show (menuitem);
j++;
for (; j < rows; j++)
for (i = 0; i < cols; i++)
{
sprintf (buf, "(%d %d)", i, j);
menuitem = gtk_menu_item_new_with_label (buf);
gtk_menu_attach (GTK_MENU (menu), menuitem, i, i + 1, j, j + 1);
gtk_widget_show (menuitem);
}
menuitem = gtk_menu_item_new_with_label ("1. Inserted normally (8)");
gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 8);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("2. Inserted normally (2)");
gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 2);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("3. Inserted normally (0)");
gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 0);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("4. Inserted normally (-1)");
gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, -1);
gtk_widget_show (menuitem);
return menu;
}
static void
create_menus (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *button;
GtkWidget *optionmenu;
GtkWidget *separator;
if (!window)
{
GtkWidget *menubar;
GtkWidget *menu;
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);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
g_signal_connect (window, "delete-event",
G_CALLBACK (gtk_true),
NULL);
accel_group = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
gtk_window_set_title (GTK_WINDOW (window), "menus");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show (box1);
menubar = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
gtk_widget_show (menubar);
menu = create_menu (screen, 2, 50);
menuitem = gtk_menu_item_new_with_label ("test\nline2");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
menu = create_table_menu (screen, 2, 50);
menuitem = gtk_menu_item_new_with_label ("table");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("foo");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (screen, 3, 5));
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
image = gtk_image_new_from_stock (GTK_STOCK_HELP,
GTK_ICON_SIZE_MENU);
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 (screen, 4, 5));
gtk_widget_set_hexpand (menuitem, TRUE);
gtk_widget_set_halign (menuitem, GTK_ALIGN_END);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
menubar = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
gtk_widget_show (menubar);
menu = create_menu (screen, 2, 10);
menuitem = gtk_menu_item_new_with_label ("Second menu bar");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
menu = create_menu (screen, 1, 5);
gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_NEW, accel_group);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_add_accelerator (menuitem,
"activate",
accel_group,
GDK_KEY_F1,
0,
GTK_ACCEL_VISIBLE);
menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_add_accelerator (menuitem,
"activate",
accel_group,
GDK_KEY_F2,
0,
GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_add_accelerator (menuitem,
"activate",
accel_group,
GDK_KEY_F2,
0,
GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator (menuitem,
"activate",
accel_group,
GDK_KEY_F3,
0,
GTK_ACCEL_VISIBLE);
optionmenu = gtk_combo_box_text_new ();
gtk_combo_box_set_active (GTK_COMBO_BOX (optionmenu), 3);
gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
gtk_widget_show (optionmenu);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_widget_show (box2);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
gtk_widget_show (button);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
}
/* GdkPixbuf RGBA C-Source image dump */
static const guint8 apple[] =
{ ""
/* Pixbuf magic (0x47646b50) */
"GdkP"
/* length: header (24) + pixel_data (2304) */
"\0\0\11\30"
/* pixdata_type (0x1010002) */
"\1\1\0\2"
/* rowstride (96) */
"\0\0\0`"
/* width (24) */
"\0\0\0\30"
/* height (24) */
"\0\0\0\30"
/* pixel_data: */
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\26\24"
"\17\11\0\0\0\2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`m"
"[pn{a\344hv_\345_k[`\0\0\0\0\0\0\0\0\0\0\0\0D>/\305\0\0\0_\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`l[Blza\373s\202d\354w\206g\372p~c"
"\374`l[y\0\0\0\0[S\77/\27\25\17\335\0\0\0\20\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0`l\\\20iw_\356y\211h\373x\207g\364~\216i\364u\204e\366gt"
"_\374^jX\241A;-_\0\0\0~\0\0\0\0SM4)SM21B9&\22\320\270\204\1\320\270\204"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0eq"
"]\212r\200c\366v\205f\371jx_\323_kY\232_kZH^jY\26]iW\211@G9\272:6%j\220"
"\211]\320\221\211`\377\212\203Z\377~xP\377mkE\331]^;|/0\37\21\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0ly`\40p~b\360lz`\353^kY\246["
"eT<\216\200Z\203\227\211_\354\234\217c\377\232\217b\362\232\220c\337"
"\243\233k\377\252\241p\377\250\236p\377\241\225h\377\231\214_\377\210"
"\202U\377srI\377[]:\355KO0U\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0i"
"v^\200`lY\211^jY\"\0\0\0\0\221\204\\\273\250\233r\377\302\267\224\377"
"\311\300\237\377\272\256\204\377\271\256\177\377\271\257\200\377\267"
"\260\177\377\260\251x\377\250\236l\377\242\225e\377\226\213]\377~zP\377"
"ff@\377QT5\377LR2d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0]iW(\0\0\0\0\0\0\0"
"\0\213\203[v\253\240t\377\334\326\301\377\344\340\317\377\321\312\253"
"\377\303\271\217\377\300\270\213\377\277\267\210\377\272\264\203\377"
"\261\255z\377\250\242n\377\243\232h\377\232\220`\377\210\202V\377nnE"
"\377SW6\377RX6\364Za<\34\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0b]@\20"
"\234\222e\362\304\274\232\377\337\333\306\377\332\325\273\377\311\302"
"\232\377\312\303\236\377\301\273\216\377\300\271\212\377\270\264\200"
"\377\256\253v\377\246\243n\377\236\232h\377\230\220`\377\213\203V\377"
"wvL\377X]:\377KR0\377NU5v\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\212"
"\203Zl\242\234l\377\321\315\260\377\331\324\271\377\320\313\251\377\307"
"\301\232\377\303\276\224\377\300\272\214\377\274\267\206\377\264\260"
"|\377\253\251s\377\244\243n\377\232\230e\377\223\216^\377\207\200U\377"
"ttJ\377[_<\377HO/\377GN0\200\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\210\204Y\240\245\237o\377\316\310\253\377\310\303\237\377\304\300\230"
"\377\303\277\225\377\277\272\216\377\274\270\210\377\266\263\200\377"
"\256\254v\377\247\246p\377\237\236j\377\227\226d\377\215\212[\377\203"
"\177T\377qsH\377X]8\377FN.\377DK-\200\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\207\204X\257\244\240o\377\300\275\231\377\301\275\226\377\274"
"\270\213\377\274\270\214\377\267\264\205\377\264\262\200\377\260\256"
"z\377\251\251s\377\243\244n\377\231\232g\377\220\222`\377\210\211Y\377"
"|}Q\377hlC\377PU3\377CK,\377DL/Y\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\205\204X\220\232\230h\377\261\260\204\377\266\264\212\377\261\260"
"\201\377\263\260\200\377\260\257}\377\256\256x\377\253\254t\377\244\246"
"o\377\233\236i\377\221\224b\377\211\214\\\377\202\204V\377txM\377]b>"
"\377HP0\377@H+\373CJ-\25\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0xxO>"
"\215\215_\377\237\237r\377\247\247x\377\247\247t\377\252\252w\377\252"
"\252u\377\252\253t\377\243\246o\377\235\240j\377\223\230c\377\213\217"
"]\377\201\206V\377x}P\377gkD\377RY5\377BI,\377AI,\262\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\202\205W\312\216\220`\377\230"
"\232g\377\234\236i\377\236\241l\377\241\244n\377\240\244m\377\232\237"
"i\377\223\230c\377\212\221]\377\200\210W\377v|P\377jnG\377Za>\377HP2"
"\377=D)\377HQ1:\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0wzQ6\177\201U\371\206\211Z\377\216\222`\377\220\225a\377\220\225b\377"
"\220\226a\377\213\221_\377\204\213Z\377{\203R\377ryN\377iqH\377^fA\377"
"R[;\377BJ-\3778@'\317\0\0\0>\0\0\0\36\0\0\0\7\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0ptJTw|Q\371z\177R\377}\202T\377|\203T\377z\200"
"R\377v|O\377pwL\377jpF\377dlB\377`hB\377Yb@\377LT6\377<C*\377\11\12\6"
"\376\0\0\0\347\0\0\0\262\0\0\0Y\0\0\0\32\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\\`=UgnE\370hnG\377gmE\377djB\377]d>\377[c<\377Y"
"b<\377Zc>\377V_>\377OW8\377BK/\377\16\20\12\377\0\0\0\377\0\0\0\377\0"
"\0\0\374\0\0\0\320\0\0\0I\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\1\0\0\0\40\22\24\15\260@D+\377W`;\377OV5\377.3\36\377.3\37\377IP0"
"\377RZ7\377PZ8\3776=&\377\14\15\10\377\0\0\0\377\0\0\0\377\0\0\0\377"
"\0\0\0\347\0\0\0\217\0\0\0""4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\20\0\0\0P\0\0\0\252\7\10\5\346\7\7\5\375\0\0\0\377\0\0"
"\0\377\0\0\0\377\0\0\0\377\0\0\0\377\0\0\0\377\0\0\0\377\0\0\0\374\0"
"\0\0\336\0\0\0\254\0\0\0i\0\0\0""2\0\0\0\10\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\11\0\0\0\40\0\0\0D\0\0\0m\0\0\0"
"\226\0\0\0\234\0\0\0\234\0\0\0\244\0\0\0\246\0\0\0\232\0\0\0\202\0\0"
"\0i\0\0\0T\0\0\0,\0\0\0\15\0\0\0\2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\2\0\0\0\6\0\0\0"
"\16\0\0\0\22\0\0\0\24\0\0\0\23\0\0\0\17\0\0\0\14\0\0\0\13\0\0\0\10\0"
"\0\0\5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"};
static GtkWidget *
accel_button_new (GtkAccelGroup *accel_group,
const gchar *text,
const gchar *accel)
{
guint keyval;
GdkModifierType modifiers;
GtkWidget *button;
GtkWidget *label;
gtk_accelerator_parse (accel, &keyval, &modifiers);
g_assert (keyval);
button = gtk_button_new ();
gtk_widget_add_accelerator (button, "activate", accel_group,
keyval, modifiers, GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
label = gtk_accel_label_new (text);
gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (label), button);
gtk_widget_show (label);
gtk_container_add (GTK_CONTAINER (button), label);
return button;
}
static void
create_key_lookup (GtkWidget *widget)
{
static GtkWidget *window = NULL;
gpointer window_ptr;
if (!window)
{
GtkAccelGroup *accel_group = gtk_accel_group_new ();
GtkWidget *button;
GtkWidget *content_area;
window = gtk_dialog_new_with_buttons ("Key Lookup", NULL, 0,
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);
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
button = gtk_button_new_with_mnemonic ("Button 1 (_a)");
gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
button = gtk_button_new_with_mnemonic ("Button 2 (_A)");
gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
button = gtk_button_new_with_mnemonic ("Button 3 (_\321\204)");
gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
button = gtk_button_new_with_mnemonic ("Button 4 (_\320\244)");
gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
button = gtk_button_new_with_mnemonic ("Button 6 (_b)");
gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
button = accel_button_new (accel_group, "Button 7", "<Alt><Shift>b");
gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
button = accel_button_new (accel_group, "Button 8", "<Alt>d");
gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
button = accel_button_new (accel_group, "Button 9", "<Alt>Cyrillic_ve");
gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
button = gtk_button_new_with_mnemonic ("Button 10 (_1)");
gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
button = gtk_button_new_with_mnemonic ("Button 11 (_!)");
gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
button = accel_button_new (accel_group, "Button 12", "<Super>a");
gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
button = accel_button_new (accel_group, "Button 13", "<Hyper>a");
gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
button = accel_button_new (accel_group, "Button 14", "<Meta>a");
gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
button = accel_button_new (accel_group, "Button 15", "<Shift><Mod4>b");
gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
window_ptr = &window;
g_object_add_weak_pointer (G_OBJECT (window), window_ptr);
g_signal_connect (window, "response", G_CALLBACK (gtk_widget_destroy), NULL);
gtk_widget_show_all (window);
}
else
gtk_widget_destroy (window);
}
/*
create_modal_window
*/
static gboolean
cmw_destroy_cb(GtkWidget *widget)
{
/* This is needed to get out of gtk_main */
gtk_main_quit ();
return FALSE;
}
static void
cmw_color (GtkWidget *widget, GtkWidget *parent)
{
GtkWidget *csd;
csd = gtk_color_chooser_dialog_new ("This is a modal color selection dialog", GTK_WINDOW (parent));
/* Set as modal */
gtk_window_set_modal (GTK_WINDOW(csd),TRUE);
g_signal_connect (csd, "destroy",
G_CALLBACK (cmw_destroy_cb), NULL);
g_signal_connect (csd, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
/* wait until destroy calls gtk_main_quit */
gtk_widget_show (csd);
gtk_main ();
}
static void
cmw_file (GtkWidget *widget, GtkWidget *parent)
{
GtkWidget *fs;
fs = gtk_file_chooser_dialog_new ("This is a modal file selection dialog",
GTK_WINDOW (parent), GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
gtk_window_set_screen (GTK_WINDOW (fs), gtk_widget_get_screen (parent));
gtk_window_set_modal (GTK_WINDOW (fs), TRUE);
g_signal_connect (fs, "destroy",
G_CALLBACK (cmw_destroy_cb), NULL);
g_signal_connect_swapped (fs, "response",
G_CALLBACK (gtk_widget_destroy), fs);
/* wait until destroy calls gtk_main_quit */
gtk_widget_show (fs);
gtk_main();
}
static void
create_modal_window (GtkWidget *widget)
{
GtkWidget *window = NULL;
GtkWidget *box1,*box2;
GtkWidget *frame1;
GtkWidget *btnColor,*btnFile,*btnClose;
/* Create modal window (Here you can use any window descendent )*/
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 */
gtk_window_set_modal (GTK_WINDOW(window),TRUE);
/* Create widgets */
box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
frame1 = gtk_frame_new ("Standard dialogs in modal form");
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_set_homogeneous (GTK_BOX (box2), TRUE);
btnColor = gtk_button_new_with_label ("Color");
btnFile = gtk_button_new_with_label ("File Selection");
btnClose = gtk_button_new_with_label ("Close");
/* Init widgets */
gtk_container_set_border_width (GTK_CONTAINER (box1), 3);
gtk_container_set_border_width (GTK_CONTAINER (box2), 3);
/* Pack widgets */
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4);
gtk_container_add (GTK_CONTAINER (frame1), box2);
gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
gtk_box_pack_start (GTK_BOX (box1), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 4);
gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
/* connect signals */
g_signal_connect_swapped (btnClose, "clicked",
G_CALLBACK (gtk_widget_destroy), window);
g_signal_connect (window, "destroy",
G_CALLBACK (cmw_destroy_cb), NULL);
g_signal_connect (btnColor, "clicked",
G_CALLBACK (cmw_color), window);
g_signal_connect (btnFile, "clicked",
G_CALLBACK (cmw_file), window);
/* Show widgets */
gtk_widget_show_all (window);
/* wait until dialog get destroyed */
gtk_main();
}
/*
* GtkMessageDialog
*/
static void
make_message_dialog (GdkScreen *screen,
GtkWidget **dialog,
GtkMessageType type,
GtkButtonsType buttons,
guint default_response)
{
if (*dialog)
{
gtk_widget_destroy (*dialog);
return;
}
*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);
g_signal_connect_swapped (*dialog,
"response",
G_CALLBACK (gtk_widget_destroy),
*dialog);
g_signal_connect (*dialog,
"destroy",
G_CALLBACK (gtk_widget_destroyed),
dialog);
gtk_dialog_set_default_response (GTK_DIALOG (*dialog), default_response);
gtk_widget_show (*dialog);
}
static 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 (screen, &info, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, GTK_RESPONSE_OK);
make_message_dialog (screen, &warning, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, GTK_RESPONSE_CLOSE);
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_NO);
}
/*
* GtkScrolledWindow
*/
static GtkWidget *sw_parent = NULL;
static GtkWidget *sw_float_parent;
static gulong sw_destroyed_handler = 0;
static gboolean
scrolled_windows_delete_cb (GtkWidget *widget, GdkEventAny *event, GtkWidget *scrollwin)
{
gtk_widget_reparent (scrollwin, sw_parent);
g_signal_handler_disconnect (sw_parent, sw_destroyed_handler);
sw_float_parent = NULL;
sw_parent = NULL;
sw_destroyed_handler = 0;
return FALSE;
}
static void
scrolled_windows_destroy_cb (GtkWidget *widget, GtkWidget *scrollwin)
{
gtk_widget_destroy (sw_float_parent);
sw_float_parent = NULL;
sw_parent = NULL;
sw_destroyed_handler = 0;
}
static void
scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin)
{
if (sw_parent)
{
gtk_widget_reparent (scrollwin, sw_parent);
gtk_widget_destroy (sw_float_parent);
g_signal_handler_disconnect (sw_parent, sw_destroyed_handler);
sw_float_parent = NULL;
sw_parent = NULL;
sw_destroyed_handler = 0;
}
else
{
sw_parent = gtk_widget_get_parent (scrollwin);
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);
gtk_widget_show (sw_float_parent);
sw_destroyed_handler =
g_signal_connect (sw_parent, "destroy",
G_CALLBACK (scrolled_windows_destroy_cb), scrollwin);
g_signal_connect (sw_float_parent, "delete_event",
G_CALLBACK (scrolled_windows_delete_cb), scrollwin);
}
}
static void
create_scrolled_windows (GtkWidget *widget)
{
static GtkWidget *window;
GtkWidget *content_area, *action_area;
GtkWidget *scrolled_window;
GtkWidget *grid;
GtkWidget *button;
char buffer[32];
int i, j;
if (!window)
{
window = gtk_dialog_new ();
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
gtk_window_set_title (GTK_WINDOW (window), "dialog");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (content_area), scrolled_window, TRUE, TRUE, 0);
gtk_widget_show (scrolled_window);
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 10);
gtk_grid_set_column_spacing (GTK_GRID (grid), 10);
gtk_container_add (GTK_CONTAINER (scrolled_window), grid);
gtk_container_set_focus_hadjustment (GTK_CONTAINER (grid),
gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
gtk_container_set_focus_vadjustment (GTK_CONTAINER (grid),
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
gtk_widget_show (grid);
for (i = 0; i < 20; i++)
for (j = 0; j < 20; j++)
{
sprintf (buffer, "button (%d,%d)\n", i, j);
button = gtk_toggle_button_new_with_label (buffer);
gtk_grid_attach (GTK_GRID (grid), button, i, j, 1, 1);
gtk_widget_show (button);
}
button = gtk_button_new_with_label ("Close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
gtk_widget_grab_default (button);
gtk_widget_show (button);
button = gtk_button_new_with_label ("Reparent Out");
g_signal_connect (button, "clicked",
G_CALLBACK (scrolled_windows_remove),
scrolled_window);
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
gtk_widget_grab_default (button);
gtk_widget_show (button);
gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
}
/*
* GtkEntry
*/
static void
entry_toggle_frame (GtkWidget *checkbutton,
GtkWidget *entry)
{
gtk_entry_set_has_frame (GTK_ENTRY(entry),
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)));
}
static void
entry_toggle_sensitive (GtkWidget *checkbutton,
GtkWidget *entry)
{
gtk_widget_set_sensitive (entry,
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(checkbutton)));
}
static gboolean
entry_progress_timeout (gpointer data)
{
if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (data), "progress-pulse")))
{
gtk_entry_progress_pulse (GTK_ENTRY (data));
}
else
{
gdouble fraction;
fraction = gtk_entry_get_progress_fraction (GTK_ENTRY (data));
fraction += 0.05;
if (fraction > 1.0001)
fraction = 0.0;
gtk_entry_set_progress_fraction (GTK_ENTRY (data), fraction);
}
return G_SOURCE_CONTINUE;
}
static void
entry_remove_timeout (gpointer data)
{
g_source_remove (GPOINTER_TO_UINT (data));
}
static void
entry_toggle_progress (GtkWidget *checkbutton,
GtkWidget *entry)
{
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)))
{
guint timeout = gdk_threads_add_timeout (100,
entry_progress_timeout,
entry);
g_object_set_data_full (G_OBJECT (entry), "timeout-id",
GUINT_TO_POINTER (timeout),
entry_remove_timeout);
}
else
{
g_object_set_data (G_OBJECT (entry), "timeout-id",
GUINT_TO_POINTER (0));
gtk_entry_set_progress_fraction (GTK_ENTRY (entry), 0.0);
}
}
static void
entry_toggle_pulse (GtkWidget *checkbutton,
GtkWidget *entry)
{
g_object_set_data (G_OBJECT (entry), "progress-pulse",
GUINT_TO_POINTER ((guint) gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton))));
}
static void
props_clicked (GtkWidget *button,
GObject *object)
{
GtkWidget *window = create_prop_editor (object, 0);
gtk_window_set_title (GTK_WINDOW (window), "Object Properties");
}
static void
create_entry (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *hbox;
GtkWidget *has_frame_check;
GtkWidget *sensitive_check;
GtkWidget *progress_check;
GtkWidget *entry;
GtkComboBoxText *cb;
GtkWidget *cb_entry;
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));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_window_set_title (GTK_WINDOW (window), "entry");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
entry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry), "hello world \330\247\331\204\330\263\331\204\330\247\331\205 \330\271\331\204\331\212\331\203\331\205");
gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
button = gtk_button_new_with_mnemonic ("_Props");
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (props_clicked),
entry);
cb = GTK_COMBO_BOX_TEXT (gtk_combo_box_text_new_with_entry ());
gtk_combo_box_text_append_text (cb, "item0");
gtk_combo_box_text_append_text (cb, "item0");
gtk_combo_box_text_append_text (cb, "item1 item1");
gtk_combo_box_text_append_text (cb, "item2 item2 item2");
gtk_combo_box_text_append_text (cb, "item3 item3 item3 item3");
gtk_combo_box_text_append_text (cb, "item4 item4 item4 item4 item4");
gtk_combo_box_text_append_text (cb, "item5 item5 item5 item5 item5 item5");
gtk_combo_box_text_append_text (cb, "item6 item6 item6 item6 item6");
gtk_combo_box_text_append_text (cb, "item7 item7 item7 item7");
gtk_combo_box_text_append_text (cb, "item8 item8 item8");
gtk_combo_box_text_append_text (cb, "item9 item9");
cb_entry = gtk_bin_get_child (GTK_BIN (cb));
gtk_entry_set_text (GTK_ENTRY (cb_entry), "hello world \n\n\n foo");
gtk_editable_select_region (GTK_EDITABLE (cb_entry), 0, -1);
gtk_box_pack_start (GTK_BOX (box2), GTK_WIDGET (cb), TRUE, TRUE, 0);
sensitive_check = gtk_check_button_new_with_label("Sensitive");
gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
g_signal_connect (sensitive_check, "toggled",
G_CALLBACK (entry_toggle_sensitive), entry);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sensitive_check), TRUE);
has_frame_check = gtk_check_button_new_with_label("Has Frame");
gtk_box_pack_start (GTK_BOX (box2), has_frame_check, FALSE, TRUE, 0);
g_signal_connect (has_frame_check, "toggled",
G_CALLBACK (entry_toggle_frame), entry);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (has_frame_check), TRUE);
progress_check = gtk_check_button_new_with_label("Show Progress");
gtk_box_pack_start (GTK_BOX (box2), progress_check, FALSE, TRUE, 0);
g_signal_connect (progress_check, "toggled",
G_CALLBACK (entry_toggle_progress), entry);
progress_check = gtk_check_button_new_with_label("Pulse Progress");
gtk_box_pack_start (GTK_BOX (box2), progress_check, FALSE, TRUE, 0);
g_signal_connect (progress_check, "toggled",
G_CALLBACK (entry_toggle_pulse), entry);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
static void
create_expander (GtkWidget *widget)
{
GtkWidget *box1;
GtkWidget *expander;
GtkWidget *hidden;
static GtkWidget *window = NULL;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_window_set_title (GTK_WINDOW (window), "expander");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
expander = gtk_expander_new ("The Hidden");
gtk_box_pack_start (GTK_BOX (box1), expander, TRUE, TRUE, 0);
hidden = gtk_label_new ("Revealed!");
gtk_container_add (GTK_CONTAINER (expander), hidden);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/* GtkEventBox */
static void
event_box_label_pressed (GtkWidget *widget,
GdkEventButton *event,
gpointer user_data)
{
g_print ("clicked on event box\n");
}
static void
event_box_button_clicked (GtkWidget *widget,
GtkWidget *button,
gpointer user_data)
{
g_print ("pushed button\n");
}
static void
event_box_toggle_visible_window (GtkWidget *checkbutton,
GtkEventBox *event_box)
{
gtk_event_box_set_visible_window (event_box,
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)));
}
static void
event_box_toggle_above_child (GtkWidget *checkbutton,
GtkEventBox *event_box)
{
gtk_event_box_set_above_child (event_box,
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)));
}
static void
create_event_box (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *button;
GtkWidget *separator;
GtkWidget *event_box;
GtkWidget *label;
GtkWidget *visible_window_check;
GtkWidget *above_child_check;
GdkRGBA color;
if (!window)
{
color.red = 0;
color.blue = 1;
color.green = 0;
color.alpha = 1;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_window_set_title (GTK_WINDOW (window), "event box");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_override_background_color (window, 0, &color);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (box1), hbox, TRUE, FALSE, 0);
event_box = gtk_event_box_new ();
gtk_box_pack_start (GTK_BOX (hbox), event_box, TRUE, FALSE, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (event_box), vbox);
g_signal_connect (event_box, "button_press_event",
G_CALLBACK (event_box_label_pressed),
NULL);
label = gtk_label_new ("Click on this label");
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
button = gtk_button_new_with_label ("button in eventbox");
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, FALSE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (event_box_button_clicked),
NULL);
visible_window_check = gtk_check_button_new_with_label("Visible Window");
gtk_box_pack_start (GTK_BOX (box1), visible_window_check, FALSE, TRUE, 0);
g_signal_connect (visible_window_check, "toggled",
G_CALLBACK (event_box_toggle_visible_window), event_box);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (visible_window_check), FALSE);
above_child_check = gtk_check_button_new_with_label("Above Child");
gtk_box_pack_start (GTK_BOX (box1), above_child_check, FALSE, TRUE, 0);
g_signal_connect (above_child_check, "toggled",
G_CALLBACK (event_box_toggle_above_child), event_box);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (above_child_check), FALSE);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/*
* GtkSizeGroup
*/
#define SIZE_GROUP_INITIAL_SIZE 50
static void
size_group_hsize_changed (GtkSpinButton *spin_button,
GtkWidget *button)
{
gtk_widget_set_size_request (gtk_bin_get_child (GTK_BIN (button)),
gtk_spin_button_get_value_as_int (spin_button),
-1);
}
static void
size_group_vsize_changed (GtkSpinButton *spin_button,
GtkWidget *button)
{
gtk_widget_set_size_request (gtk_bin_get_child (GTK_BIN (button)),
-1,
gtk_spin_button_get_value_as_int (spin_button));
}
static GtkWidget *
create_size_group_window (GdkScreen *screen,
GtkSizeGroup *master_size_group)
{
GtkWidget *content_area;
GtkWidget *window;
GtkWidget *grid;
GtkWidget *main_button;
GtkWidget *button;
GtkWidget *spin_button;
GtkWidget *hbox;
GtkSizeGroup *hgroup1;
GtkSizeGroup *hgroup2;
GtkSizeGroup *vgroup1;
GtkSizeGroup *vgroup2;
window = gtk_dialog_new_with_buttons ("GtkSizeGroup",
NULL, 0,
GTK_STOCK_CLOSE,
GTK_RESPONSE_NONE,
NULL);
gtk_window_set_screen (GTK_WINDOW (window), screen);
gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
g_signal_connect (window, "response",
G_CALLBACK (gtk_widget_destroy),
NULL);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
grid = gtk_grid_new ();
gtk_box_pack_start (GTK_BOX (content_area), grid, TRUE, TRUE, 0);
gtk_grid_set_row_spacing (GTK_GRID (grid), 5);
gtk_grid_set_column_spacing (GTK_GRID (grid), 5);
gtk_container_set_border_width (GTK_CONTAINER (grid), 5);
gtk_widget_set_size_request (grid, 250, 250);
hgroup1 = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
hgroup2 = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
vgroup1 = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
vgroup2 = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
main_button = gtk_button_new_with_label ("X");
gtk_widget_set_hexpand (main_button, TRUE);
gtk_widget_set_vexpand (main_button, TRUE);
gtk_widget_set_halign (main_button, GTK_ALIGN_CENTER);
gtk_widget_set_valign (main_button, GTK_ALIGN_CENTER);
gtk_grid_attach (GTK_GRID (grid), main_button, 0, 0, 1, 1);
gtk_size_group_add_widget (master_size_group, main_button);
gtk_size_group_add_widget (hgroup1, main_button);
gtk_size_group_add_widget (vgroup1, main_button);
gtk_widget_set_size_request (gtk_bin_get_child (GTK_BIN (main_button)),
SIZE_GROUP_INITIAL_SIZE,
SIZE_GROUP_INITIAL_SIZE);
button = gtk_button_new ();
gtk_widget_set_hexpand (button, TRUE);
gtk_widget_set_vexpand (button, TRUE);
gtk_widget_set_halign (button, GTK_ALIGN_CENTER);
gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
gtk_grid_attach (GTK_GRID (grid), button, 1, 0, 1, 1);
gtk_size_group_add_widget (vgroup1, button);
gtk_size_group_add_widget (vgroup2, button);
button = gtk_button_new ();
gtk_widget_set_hexpand (button, TRUE);
gtk_widget_set_vexpand (button, TRUE);
gtk_widget_set_halign (button, GTK_ALIGN_CENTER);
gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
gtk_grid_attach (GTK_GRID (grid), button, 0, 1, 1, 1);
gtk_size_group_add_widget (hgroup1, button);
gtk_size_group_add_widget (hgroup2, button);
button = gtk_button_new ();
gtk_widget_set_hexpand (button, TRUE);
gtk_widget_set_vexpand (button, TRUE);
gtk_widget_set_halign (button, GTK_ALIGN_CENTER);
gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
gtk_grid_attach (GTK_GRID (grid), button, 1, 1, 1, 1);
gtk_size_group_add_widget (hgroup2, button);
gtk_size_group_add_widget (vgroup2, button);
g_object_unref (hgroup1);
g_object_unref (hgroup2);
g_object_unref (vgroup1);
g_object_unref (vgroup2);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start (GTK_BOX (content_area), hbox, FALSE, FALSE, 0);
spin_button = gtk_spin_button_new_with_range (1, 100, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_button), SIZE_GROUP_INITIAL_SIZE);
gtk_box_pack_start (GTK_BOX (hbox), spin_button, TRUE, TRUE, 0);
g_signal_connect (spin_button, "value_changed",
G_CALLBACK (size_group_hsize_changed), main_button);
spin_button = gtk_spin_button_new_with_range (1, 100, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_button), SIZE_GROUP_INITIAL_SIZE);
gtk_box_pack_start (GTK_BOX (hbox), spin_button, TRUE, TRUE, 0);
g_signal_connect (spin_button, "value_changed",
G_CALLBACK (size_group_vsize_changed), main_button);
return window;
}
static void
create_size_groups (GtkWidget *widget)
{
static GtkWidget *window1 = NULL;
static GtkWidget *window2 = NULL;
static GtkSizeGroup *master_size_group;
if (!master_size_group)
master_size_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
if (!window1)
{
window1 = create_size_group_window (gtk_widget_get_screen (widget),
master_size_group);
g_signal_connect (window1, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window1);
}
if (!window2)
{
window2 = create_size_group_window (gtk_widget_get_screen (widget),
master_size_group);
g_signal_connect (window2, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window2);
}
if (gtk_widget_get_visible (window1) && gtk_widget_get_visible (window2))
{
gtk_widget_destroy (window1);
gtk_widget_destroy (window2);
}
else
{
if (!gtk_widget_get_visible (window1))
gtk_widget_show_all (window1);
if (!gtk_widget_get_visible (window2))
gtk_widget_show_all (window2);
}
}
/*
* GtkSpinButton
*/
static GtkWidget *spinner1;
static void
toggle_snap (GtkWidget *widget, GtkSpinButton *spin)
{
gtk_spin_button_set_snap_to_ticks (spin,
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)));
}
static void
toggle_numeric (GtkWidget *widget, GtkSpinButton *spin)
{
gtk_spin_button_set_numeric (spin,
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)));
}
static void
change_digits (GtkWidget *widget, GtkSpinButton *spin)
{
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner1),
gtk_spin_button_get_value_as_int (spin));
}
static void
get_value (GtkWidget *widget, gpointer data)
{
gchar buf[32];
GtkLabel *label;
GtkSpinButton *spin;
spin = GTK_SPIN_BUTTON (spinner1);
label = GTK_LABEL (g_object_get_data (G_OBJECT (widget), "user_data"));
if (GPOINTER_TO_INT (data) == 1)
sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin));
else
sprintf (buf, "%0.*f",
gtk_spin_button_get_digits (spin),
gtk_spin_button_get_value (spin));
gtk_label_set_text (label, buf);
}
static void
get_spin_value (GtkWidget *widget, gpointer data)
{
gchar *buffer;
GtkLabel *label;
GtkSpinButton *spin;
spin = GTK_SPIN_BUTTON (widget);
label = GTK_LABEL (data);
buffer = g_strdup_printf ("%0.*f",
gtk_spin_button_get_digits (spin),
gtk_spin_button_get_value (spin));
gtk_label_set_text (label, buffer);
g_free (buffer);
}
static gint
spin_button_time_output_func (GtkSpinButton *spin_button)
{
GtkAdjustment *adjustment;
static gchar buf[6];
gdouble hours;
gdouble minutes;
adjustment = gtk_spin_button_get_adjustment (spin_button);
hours = gtk_adjustment_get_value (adjustment) / 60.0;
minutes = (fabs(floor (hours) - hours) < 1e-5) ? 0.0 : 30;
sprintf (buf, "%02.0f:%02.0f", floor (hours), minutes);
if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button))))
gtk_entry_set_text (GTK_ENTRY (spin_button), buf);
return TRUE;
}
static gint
spin_button_month_input_func (GtkSpinButton *spin_button,
gdouble *new_val)
{
gint i;
static gchar *month[12] = { "January", "February", "March", "April",
"May", "June", "July", "August",
"September", "October", "November", "December" };
gchar *tmp1, *tmp2;
gboolean found = FALSE;
for (i = 1; i <= 12; i++)
{
tmp1 = g_ascii_strup (month[i - 1], -1);
tmp2 = g_ascii_strup (gtk_entry_get_text (GTK_ENTRY (spin_button)), -1);
if (strstr (tmp1, tmp2) == tmp1)
found = TRUE;
g_free (tmp1);
g_free (tmp2);
if (found)
break;
}
if (!found)
{
*new_val = 0.0;
return GTK_INPUT_ERROR;
}
*new_val = (gdouble) i;
return TRUE;
}
static gint
spin_button_month_output_func (GtkSpinButton *spin_button)
{
GtkAdjustment *adjustment;
gdouble value;
gint i;
static gchar *month[12] = { "January", "February", "March", "April",
"May", "June", "July", "August", "September",
"October", "November", "December" };
adjustment = gtk_spin_button_get_adjustment (spin_button);
value = gtk_adjustment_get_value (adjustment);
for (i = 1; i <= 12; i++)
if (fabs (value - (double)i) < 1e-5)
{
if (strcmp (month[i-1], gtk_entry_get_text (GTK_ENTRY (spin_button))))
gtk_entry_set_text (GTK_ENTRY (spin_button), month[i-1]);
}
return TRUE;
}
static gint
spin_button_hex_input_func (GtkSpinButton *spin_button,
gdouble *new_val)
{
const gchar *buf;
gchar *err;
gdouble res;
buf = gtk_entry_get_text (GTK_ENTRY (spin_button));
res = strtol(buf, &err, 16);
*new_val = res;
if (*err)
return GTK_INPUT_ERROR;
else
return TRUE;
}
static gint
spin_button_hex_output_func (GtkSpinButton *spin_button)
{
GtkAdjustment *adjustment;
static gchar buf[7];
gint val;
adjustment = gtk_spin_button_get_adjustment (spin_button);
val = (gint) gtk_adjustment_get_value (adjustment);
if (fabs (val) < 1e-5)
sprintf (buf, "0x00");
else
sprintf (buf, "0x%.2X", val);
if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button))))
gtk_entry_set_text (GTK_ENTRY (spin_button), buf);
return TRUE;
}
static void
create_spins (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *frame;
GtkWidget *hbox;
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkWidget *vbox2;
GtkWidget *spinner2;
GtkWidget *spinner;
GtkWidget *button;
GtkWidget *label;
GtkWidget *val_label;
GtkAdjustment *adjustment;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 10);
gtk_container_add (GTK_CONTAINER (window), main_vbox);
frame = gtk_frame_new ("Not accelerated");
gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
gtk_container_add (GTK_CONTAINER (frame), vbox);
/* Time, month, hex spinners */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
label = gtk_label_new ("Time :");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
adjustment = gtk_adjustment_new (0, 0, 1410, 30, 60, 0);
spinner = gtk_spin_button_new (adjustment, 0, 0);
gtk_editable_set_editable (GTK_EDITABLE (spinner), FALSE);
g_signal_connect (spinner,
"output",
G_CALLBACK (spin_button_time_output_func),
NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
gtk_entry_set_width_chars (GTK_ENTRY (spinner), 5);
gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
label = gtk_label_new ("Month :");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
adjustment = gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
5.0, 0.0);
spinner = gtk_spin_button_new (adjustment, 0, 0);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spinner),
GTK_UPDATE_IF_VALID);
g_signal_connect (spinner,
"input",
G_CALLBACK (spin_button_month_input_func),
NULL);
g_signal_connect (spinner,
"output",
G_CALLBACK (spin_button_month_output_func),
NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
gtk_entry_set_width_chars (GTK_ENTRY (spinner), 9);
gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
label = gtk_label_new ("Hex :");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
adjustment = gtk_adjustment_new (0, 0, 255, 1, 16, 0);
spinner = gtk_spin_button_new (adjustment, 0, 0);
gtk_editable_set_editable (GTK_EDITABLE (spinner), TRUE);
g_signal_connect (spinner,
"input",
G_CALLBACK (spin_button_hex_input_func),
NULL);
g_signal_connect (spinner,
"output",
G_CALLBACK (spin_button_hex_output_func),
NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
gtk_entry_set_width_chars (GTK_ENTRY (spinner), 4);
gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
frame = gtk_frame_new ("Accelerated");
gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
gtk_container_add (GTK_CONTAINER (frame), vbox);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 5);
label = gtk_label_new ("Value :");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
adjustment = gtk_adjustment_new (0.0, -10000.0, 10000.0,
0.5, 100.0, 0.0);
spinner1 = gtk_spin_button_new (adjustment, 1.0, 2);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE);
gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 5);
label = gtk_label_new ("Digits :");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
adjustment = gtk_adjustment_new (2, 1, 15, 1, 1, 0);
spinner2 = gtk_spin_button_new (adjustment, 0.0, 0);
g_signal_connect (adjustment, "value_changed",
G_CALLBACK (change_digits),
spinner2);
gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 5);
button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
g_signal_connect (button, "clicked",
G_CALLBACK (toggle_snap),
spinner1);
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
button = gtk_check_button_new_with_label ("Numeric only input mode");
g_signal_connect (button, "clicked",
G_CALLBACK (toggle_numeric),
spinner1);
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
val_label = gtk_label_new ("");
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
button = gtk_button_new_with_label ("Value as Int");
g_object_set_data (G_OBJECT (button), "user_data", val_label);
g_signal_connect (button, "clicked",
G_CALLBACK (get_value),
GINT_TO_POINTER (1));
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
button = gtk_button_new_with_label ("Value as Float");
g_object_set_data (G_OBJECT (button), "user_data", val_label);
g_signal_connect (button, "clicked",
G_CALLBACK (get_value),
GINT_TO_POINTER (2));
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
gtk_label_set_text (GTK_LABEL (val_label), "0");
frame = gtk_frame_new ("Using Convenience Constructor");
gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_container_add (GTK_CONTAINER (frame), hbox);
val_label = gtk_label_new ("0.0");
spinner = gtk_spin_button_new_with_range (0.0, 10.0, 0.009);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (spinner), 0.0);
g_signal_connect (spinner, "value_changed",
G_CALLBACK (get_spin_value), val_label);
gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (hbox), val_label, TRUE, TRUE, 5);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("Close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/*
* Cursors
*/
static gint
cursor_draw (GtkWidget *widget,
cairo_t *cr,
gpointer user_data)
{
int width, height;
GtkStyleContext *context;
GdkRGBA bg;
width = gtk_widget_get_allocated_width (widget);
height = gtk_widget_get_allocated_height (widget);
cairo_set_source_rgb (cr, 1, 1, 1);
cairo_rectangle (cr, 0, 0, width, height / 2);
cairo_fill (cr);
cairo_set_source_rgb (cr, 0, 0, 0);
cairo_rectangle (cr, 0, height / 2, width, height / 2);
cairo_fill (cr);
context = gtk_widget_get_style_context (widget);
gtk_style_context_get_background_color (context, GTK_STATE_FLAG_NORMAL, &bg);
gdk_cairo_set_source_rgba (cr, &bg);
cairo_rectangle (cr, width / 3, height / 3, width / 3, height / 3);
cairo_fill (cr);
return TRUE;
}
static void
set_cursor (GtkWidget *spinner,
GtkWidget *widget)
{
guint c;
GdkCursor *cursor;
GtkWidget *label;
GEnumClass *class;
GEnumValue *vals;
c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
c &= 0xfe;
label = g_object_get_data (G_OBJECT (spinner), "user_data");
class = g_type_class_ref (GDK_TYPE_CURSOR_TYPE);
vals = class->values;
while (vals && vals->value != c)
vals++;
if (vals)
gtk_label_set_text (GTK_LABEL (label), vals->value_nick);
else
gtk_label_set_text (GTK_LABEL (label), "<unknown>");
g_type_class_unref (class);
cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget), c);
gdk_window_set_cursor (gtk_widget_get_window (widget),
cursor);
g_object_unref (cursor);
}
static gint
cursor_event (GtkWidget *widget,
GdkEvent *event,
GtkSpinButton *spinner)
{
if ((event->type == GDK_BUTTON_PRESS) &&
((event->button.button == GDK_BUTTON_PRIMARY) ||
(event->button.button == GDK_BUTTON_SECONDARY)))
{
gtk_spin_button_spin (spinner, event->button.button == GDK_BUTTON_PRIMARY ?
GTK_SPIN_STEP_FORWARD : GTK_SPIN_STEP_BACKWARD, 0);
return TRUE;
}
return FALSE;
}
#ifdef GDK_WINDOWING_X11
#include "x11/gdkx.h"
static void
change_cursor_theme (GtkWidget *widget,
gpointer data)
{
const gchar *theme;
gint size;
GList *children;
children = gtk_container_get_children (GTK_CONTAINER (data));
theme = gtk_entry_get_text (GTK_ENTRY (children->next->data));
size = (gint) gtk_spin_button_get_value (GTK_SPIN_BUTTON (children->next->next->data));
g_list_free (children);
gdk_x11_display_set_cursor_theme (gtk_widget_get_display (widget),
theme, size);
}
#endif
static void
create_cursors (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *frame;
GtkWidget *hbox;
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkWidget *darea;
GtkWidget *spinner;
GtkWidget *button;
GtkWidget *label;
GtkWidget *any;
GtkAdjustment *adjustment;
GtkWidget *entry;
GtkWidget *size;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_window_set_title (GTK_WINDOW (window), "Cursors");
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
gtk_container_add (GTK_CONTAINER (window), main_vbox);
vbox =
g_object_new (GTK_TYPE_BOX,
"orientation", GTK_ORIENTATION_VERTICAL,
"GtkBox::homogeneous", FALSE,
"GtkBox::spacing", 5,
"GtkContainer::border_width", 10,
"GtkWidget::parent", main_vbox,
"GtkWidget::visible", TRUE,
NULL);
#ifdef GDK_WINDOWING_X11
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
label = gtk_label_new ("Cursor Theme : ");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
entry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry), "default");
gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, TRUE, 0);
size = gtk_spin_button_new_with_range (1.0, 64.0, 1.0);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (size), 24.0);
gtk_box_pack_start (GTK_BOX (hbox), size, TRUE, TRUE, 0);
g_signal_connect (entry, "changed",
G_CALLBACK (change_cursor_theme), hbox);
g_signal_connect (size, "changed",
G_CALLBACK (change_cursor_theme), hbox);
#endif
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
label = gtk_label_new ("Cursor Value : ");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
adjustment = gtk_adjustment_new (0,
0, 152,
2,
10, 0);
spinner = gtk_spin_button_new (adjustment, 0, 0);
gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
frame =
g_object_new (gtk_frame_get_type (),
"GtkFrame::label_xalign", 0.5,
"GtkFrame::label", "Cursor Area",
"GtkContainer::border_width", 10,
"GtkWidget::parent", vbox,
"GtkWidget::visible", TRUE,
NULL);
darea = gtk_drawing_area_new ();
gtk_widget_set_size_request (darea, 80, 80);
gtk_container_add (GTK_CONTAINER (frame), darea);
g_signal_connect (darea,
"draw",
G_CALLBACK (cursor_draw),
NULL);
gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
g_signal_connect (darea,
"button_press_event",
G_CALLBACK (cursor_event),
spinner);
gtk_widget_show (darea);
g_signal_connect (spinner, "changed",
G_CALLBACK (set_cursor),
darea);
label = g_object_new (GTK_TYPE_LABEL,
"visible", TRUE,
"label", "XXX",
"parent", vbox,
NULL);
gtk_container_child_set (GTK_CONTAINER (vbox), label,
"expand", FALSE,
NULL);
g_object_set_data (G_OBJECT (spinner), "user_data", label);
any = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("Close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
gtk_widget_show_all (window);
set_cursor (spinner, darea);
}
else
gtk_widget_destroy (window);
}
/*
* GtkColorSelection
*/
void
create_color_selection (GtkWidget *widget)
{
static GtkWidget *window = NULL;
if (!window)
{
GtkWidget *picker;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *button;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_window_set_title (GTK_WINDOW (window), "GtkColorButton");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
gtk_container_add (GTK_CONTAINER (window), hbox);
label = gtk_label_new ("Pick a color");
gtk_container_add (GTK_CONTAINER (hbox), label);
picker = gtk_color_button_new ();
gtk_color_chooser_set_use_alpha (GTK_COLOR_CHOOSER (picker), TRUE);
gtk_container_add (GTK_CONTAINER (hbox), picker);
button = gtk_button_new_with_mnemonic ("_Props");
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (props_clicked),
picker);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
void
flipping_toggled_cb (GtkWidget *widget, gpointer data)
{
int state = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
int new_direction = state ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR;
gtk_widget_set_default_direction (new_direction);
}
static void
orientable_toggle_orientation (GtkOrientable *orientable)
{
GtkOrientation orientation;
orientation = gtk_orientable_get_orientation (orientable);
gtk_orientable_set_orientation (orientable,
orientation == GTK_ORIENTATION_HORIZONTAL ?
GTK_ORIENTATION_VERTICAL :
GTK_ORIENTATION_HORIZONTAL);
if (GTK_IS_CONTAINER (orientable))
{
GList *children;
GList *child;
children = gtk_container_get_children (GTK_CONTAINER (orientable));
for (child = children; child; child = child->next)
{
if (GTK_IS_ORIENTABLE (child->data))
orientable_toggle_orientation (child->data);
}
g_list_free (children);
}
}
void
flipping_orientation_toggled_cb (GtkWidget *widget, gpointer data)
{
GtkWidget *content_area;
GtkWidget *toplevel;
toplevel = gtk_widget_get_toplevel (widget);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (toplevel));
orientable_toggle_orientation (GTK_ORIENTABLE (content_area));
}
static void
set_direction_recurse (GtkWidget *widget,
gpointer data)
{
GtkTextDirection *dir = data;
gtk_widget_set_direction (widget, *dir);
if (GTK_IS_CONTAINER (widget))
gtk_container_foreach (GTK_CONTAINER (widget),
set_direction_recurse,
data);
}
static GtkWidget *
create_forward_back (const char *title,
GtkTextDirection text_dir)
{
GtkWidget *frame = gtk_frame_new (title);
GtkWidget *bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
GtkWidget *back_button = gtk_button_new_from_stock (GTK_STOCK_GO_BACK);
GtkWidget *forward_button = gtk_button_new_from_stock (GTK_STOCK_GO_FORWARD);
gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
gtk_container_add (GTK_CONTAINER (frame), bbox);
gtk_container_add (GTK_CONTAINER (bbox), back_button);
gtk_container_add (GTK_CONTAINER (bbox), forward_button);
set_direction_recurse (frame, &text_dir);
return frame;
}
void
create_flipping (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *check_button, *button;
GtkWidget *action_area, *content_area;
if (!window)
{
window = gtk_dialog_new ();
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
gtk_window_set_title (GTK_WINDOW (window), "Bidirectional Flipping");
check_button = gtk_check_button_new_with_label ("Right-to-left global direction");
gtk_container_set_border_width (GTK_CONTAINER (check_button), 10);
gtk_box_pack_start (GTK_BOX (content_area), check_button, TRUE, TRUE, 0);
if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), TRUE);
g_signal_connect (check_button, "toggled",
G_CALLBACK (flipping_toggled_cb), NULL);
check_button = gtk_check_button_new_with_label ("Toggle orientation of all boxes");
gtk_container_set_border_width (GTK_CONTAINER (check_button), 10);
gtk_box_pack_start (GTK_BOX (content_area), check_button, TRUE, TRUE, 0);
g_signal_connect (check_button, "toggled",
G_CALLBACK (flipping_orientation_toggled_cb), NULL);
gtk_box_pack_start (GTK_BOX (content_area),
create_forward_back ("Default", GTK_TEXT_DIR_NONE),
TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (content_area),
create_forward_back ("Left-to-Right", GTK_TEXT_DIR_LTR),
TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (content_area),
create_forward_back ("Right-to-Left", GTK_TEXT_DIR_RTL),
TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy), window);
gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/*
* Focus test
*/
static GtkWidget*
make_focus_table (GList **list)
{
GtkWidget *grid;
gint i, j;
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 10);
gtk_grid_set_column_spacing (GTK_GRID (grid), 10);
for (i = 0; i < 5; i++)
{
for (j = 0; j < 5; j++)
{
GtkWidget *widget;
if ((i + j) % 2)
widget = gtk_entry_new ();
else
widget = gtk_button_new_with_label ("Foo");
*list = g_list_prepend (*list, widget);
gtk_widget_set_hexpand (widget, TRUE);
gtk_widget_set_vexpand (widget, TRUE);
gtk_grid_attach (GTK_GRID (grid), widget, i, j, 1, 1);
}
}
*list = g_list_reverse (*list);
return grid;
}
static void
create_focus (GtkWidget *widget)
{
static GtkWidget *window = NULL;
if (!window)
{
GtkWidget *content_area;
GtkWidget *table;
GtkWidget *frame;
GList *list = NULL;
window = gtk_dialog_new_with_buttons ("Keyboard focus navigation",
NULL, 0,
GTK_STOCK_CLOSE,
GTK_RESPONSE_NONE,
NULL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
g_signal_connect (window, "response",
G_CALLBACK (gtk_widget_destroy),
NULL);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
gtk_window_set_title (GTK_WINDOW (window), "Keyboard Focus Navigation");
frame = gtk_frame_new ("Weird tab focus chain");
gtk_box_pack_start (GTK_BOX (content_area), frame, TRUE, TRUE, 0);
table = make_focus_table (&list);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_container_set_focus_chain (GTK_CONTAINER (table),
list);
g_list_free (list);
frame = gtk_frame_new ("Default tab focus chain");
gtk_box_pack_start (GTK_BOX (content_area), frame, TRUE, TRUE, 0);
list = NULL;
table = make_focus_table (&list);
g_list_free (list);
gtk_container_add (GTK_CONTAINER (frame), table);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/*
* GtkFontSelection
*/
void
create_font_selection (GtkWidget *widget)
{
static GtkWidget *window = NULL;
if (!window)
{
GtkWidget *picker;
GtkWidget *hbox;
GtkWidget *label;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_window_set_title (GTK_WINDOW (window), "GtkFontButton");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
gtk_container_add (GTK_CONTAINER (window), hbox);
label = gtk_label_new ("Pick a font");
gtk_container_add (GTK_CONTAINER (hbox), label);
picker = gtk_font_button_new ();
gtk_font_button_set_use_font (GTK_FONT_BUTTON (picker), TRUE);
gtk_container_add (GTK_CONTAINER (hbox), picker);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/*
* GtkDialog
*/
static GtkWidget *dialog_window = NULL;
static void
label_toggle (GtkWidget *widget,
GtkWidget **label)
{
if (!(*label))
{
*label = gtk_label_new ("Dialog Test");
g_signal_connect (*label,
"destroy",
G_CALLBACK (gtk_widget_destroyed),
label);
g_object_set (*label, "margin", 10, NULL);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog_window))),
*label, TRUE, TRUE, 0);
gtk_widget_show (*label);
}
else
gtk_widget_destroy (*label);
}
static void
create_dialog (GtkWidget *widget)
{
static GtkWidget *label;
GtkWidget *action_area;
GtkWidget *button;
if (!dialog_window)
{
/* This is a terrible example; it's much simpler to create
* dialogs than this. Don't use testgtk for example code,
* use gtk-demo ;-)
*/
dialog_window = gtk_dialog_new ();
gtk_window_set_screen (GTK_WINDOW (dialog_window),
gtk_widget_get_screen (widget));
g_signal_connect (dialog_window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&dialog_window);
action_area = gtk_dialog_get_action_area (GTK_DIALOG (dialog_window));
gtk_window_set_title (GTK_WINDOW (dialog_window), "GtkDialog");
gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
button = gtk_button_new_with_label ("OK");
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
gtk_widget_grab_default (button);
gtk_widget_show (button);
button = gtk_button_new_with_label ("Toggle");
g_signal_connect (button, "clicked",
G_CALLBACK (label_toggle),
&label);
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
gtk_widget_show (button);
label = NULL;
}
if (!gtk_widget_get_visible (dialog_window))
gtk_widget_show (dialog_window);
else
gtk_widget_destroy (dialog_window);
}
/* Display & Screen test
*/
typedef struct
{
GtkWidget *combo;
GtkWidget *entry;
GtkWidget *radio_dpy;
GtkWidget *toplevel;
GtkWidget *dialog_window;
} ScreenDisplaySelection;
static void
screen_display_check (GtkWidget *widget, ScreenDisplaySelection *data)
{
const gchar *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 = gtk_entry_get_text (GTK_ENTRY (data->entry));
display = gdk_display_open (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 (dialog, "response",
G_CALLBACK (gtk_widget_destroy),
NULL);
}
else
{
GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX (data->combo));
gint i = 0;
GtkTreeIter iter;
gboolean found = FALSE;
while (gtk_tree_model_iter_nth_child (model, &iter, NULL, i++))
{
gchar *name;
gtk_tree_model_get (model, &iter, 0, &name, -1);
found = !g_ascii_strcasecmp (display_name, name);
g_free (name);
if (found)
break;
}
if (!found)
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (data->combo), 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 *grid, *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);
GdkDisplay *display = gdk_screen_get_display (screen);
window = g_object_new (gtk_window_get_type (),
"screen", screen,
"type", GTK_WINDOW_TOPLEVEL,
"title", "Screen or Display selection",
"border_width",
10, NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroy), NULL);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
gtk_container_add (GTK_CONTAINER (window), vbox);
frame = gtk_frame_new ("Select screen or display");
gtk_container_add (GTK_CONTAINER (vbox), frame);
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 3);
gtk_grid_set_column_spacing (GTK_GRID (grid), 3);
gtk_container_add (GTK_CONTAINER (frame), grid);
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_box_text_new_with_entry ();
gtk_widget_set_hexpand (combo_dpy, TRUE);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_dpy), "diabolo:0.0");
gtk_entry_set_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (combo_dpy))),
"<hostname>:<X Server Num>.<Screen Num>");
gtk_grid_attach (GTK_GRID (grid), radio_dpy, 0, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), radio_scr, 0, 1, 1, 1);
gtk_grid_attach (GTK_GRID (grid), combo_dpy, 1, 0, 1, 1);
bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
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_bin_get_child (GTK_BIN (combo_dpy));
scr_dpy_data->radio_dpy = radio_dpy;
scr_dpy_data->toplevel = gtk_widget_get_toplevel (widget);
scr_dpy_data->dialog_window = window;
g_signal_connect (cancelb, "clicked",
G_CALLBACK (screen_display_destroy_diag), window);
g_signal_connect (applyb, "clicked",
G_CALLBACK (screen_display_check), scr_dpy_data);
gtk_widget_show_all (window);
}
/* Event Watcher
*/
static gulong event_watcher_enter_id = 0;
static gulong event_watcher_leave_id = 0;
static gboolean
event_watcher (GSignalInvocationHint *ihint,
guint n_param_values,
const GValue *param_values,
gpointer data)
{
g_print ("Watch: \"%s\" emitted for %s\n",
g_signal_name (ihint->signal_id),
G_OBJECT_TYPE_NAME (g_value_get_object (param_values + 0)));
return TRUE;
}
static void
event_watcher_down (void)
{
if (event_watcher_enter_id)
{
guint signal_id;
signal_id = g_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
g_signal_remove_emission_hook (signal_id, event_watcher_enter_id);
event_watcher_enter_id = 0;
signal_id = g_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
g_signal_remove_emission_hook (signal_id, event_watcher_leave_id);
event_watcher_leave_id = 0;
}
}
static void
event_watcher_toggle (void)
{
if (event_watcher_enter_id)
event_watcher_down ();
else
{
guint signal_id;
signal_id = g_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
event_watcher_enter_id = g_signal_add_emission_hook (signal_id, 0, event_watcher, NULL, NULL);
signal_id = g_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
event_watcher_leave_id = g_signal_add_emission_hook (signal_id, 0, event_watcher, NULL, NULL);
}
}
static void
create_event_watcher (GtkWidget *widget)
{
GtkWidget *action_area, *content_area;
GtkWidget *button;
if (!dialog_window)
{
dialog_window = gtk_dialog_new ();
gtk_window_set_screen (GTK_WINDOW (dialog_window),
gtk_widget_get_screen (widget));
g_signal_connect (dialog_window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&dialog_window);
g_signal_connect (dialog_window, "destroy",
G_CALLBACK (event_watcher_down),
NULL);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog_window));
action_area = gtk_dialog_get_action_area (GTK_DIALOG (dialog_window));
gtk_window_set_title (GTK_WINDOW (dialog_window), "Event Watcher");
gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
gtk_widget_set_size_request (dialog_window, 200, 110);
button = gtk_toggle_button_new_with_label ("Activate Watch");
g_signal_connect (button, "clicked",
G_CALLBACK (event_watcher_toggle),
NULL);
gtk_container_set_border_width (GTK_CONTAINER (button), 10);
gtk_box_pack_start (GTK_BOX (content_area), button, TRUE, TRUE, 0);
gtk_widget_show (button);
button = gtk_button_new_with_label ("Close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
dialog_window);
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
gtk_widget_grab_default (button);
gtk_widget_show (button);
}
if (!gtk_widget_get_visible (dialog_window))
gtk_widget_show (dialog_window);
else
gtk_widget_destroy (dialog_window);
}
/*
* GtkRange
*/
static gchar*
reformat_value (GtkScale *scale,
gdouble value)
{
return g_strdup_printf ("-->%0.*g<--",
gtk_scale_get_digits (scale), value);
}
static void
create_range_controls (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *button;
GtkWidget *scrollbar;
GtkWidget *scale;
GtkWidget *separator;
GtkAdjustment *adjustment;
GtkWidget *hbox;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_window_set_title (GTK_WINDOW (window), "range controls");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show (box1);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (adjustment));
gtk_widget_set_size_request (GTK_WIDGET (scale), 150, -1);
gtk_scale_set_digits (GTK_SCALE (scale), 1);
gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (adjustment));
gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
gtk_widget_show (scrollbar);
scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (adjustment));
gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
g_signal_connect (scale,
"format_value",
G_CALLBACK (reformat_value),
NULL);
gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (adjustment));
gtk_widget_set_size_request (scale, -1, 200);
gtk_scale_set_digits (GTK_SCALE (scale), 2);
gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (adjustment));
gtk_widget_set_size_request (scale, -1, 200);
gtk_scale_set_digits (GTK_SCALE (scale), 2);
gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
gtk_range_set_inverted (GTK_RANGE (scale), TRUE);
gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (adjustment));
gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
g_signal_connect (scale,
"format_value",
G_CALLBACK (reformat_value),
NULL);
gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_widget_show (box2);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
gtk_widget_show (button);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
}
struct {
GdkColor color;
gchar *name;
} text_colors[] = {
{ { 0, 0x0000, 0x0000, 0x0000 }, "black" },
{ { 0, 0xFFFF, 0xFFFF, 0xFFFF }, "white" },
{ { 0, 0xFFFF, 0x0000, 0x0000 }, "red" },
{ { 0, 0x0000, 0xFFFF, 0x0000 }, "green" },
{ { 0, 0x0000, 0x0000, 0xFFFF }, "blue" },
{ { 0, 0x0000, 0xFFFF, 0xFFFF }, "cyan" },
{ { 0, 0xFFFF, 0x0000, 0xFFFF }, "magenta" },
{ { 0, 0xFFFF, 0xFFFF, 0x0000 }, "yellow" }
};
int ntext_colors = sizeof(text_colors) / sizeof(text_colors[0]);
/*
* GtkNotebook
*/
static const char * book_open_xpm[] = {
"16 16 4 1",
" c None s None",
". c black",
"X c #808080",
"o c white",
" ",
" .. ",
" .Xo. ... ",
" .Xoo. ..oo. ",
" .Xooo.Xooo... ",
" .Xooo.oooo.X. ",
" .Xooo.Xooo.X. ",
" .Xooo.oooo.X. ",
" .Xooo.Xooo.X. ",
" .Xooo.oooo.X. ",
" .Xoo.Xoo..X. ",
" .Xo.o..ooX. ",
" .X..XXXXX. ",
" ..X....... ",
" .. ",
" "};
static const char * book_closed_xpm[] = {
"16 16 6 1",
" c None s None",
". c black",
"X c red",
"o c yellow",
"O c #808080",
"# c white",
" ",
" .. ",
" ..XX. ",
" ..XXXXX. ",
" ..XXXXXXXX. ",
".ooXXXXXXXXX. ",
"..ooXXXXXXXXX. ",
".X.ooXXXXXXXXX. ",
".XX.ooXXXXXX.. ",
" .XX.ooXXX..#O ",
" .XX.oo..##OO. ",
" .XX..##OO.. ",
" .X.#OO.. ",
" ..O.. ",
" .. ",
" "};
GdkPixbuf *book_open;
GdkPixbuf *book_closed;
GtkWidget *sample_notebook;
static void
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 = g_object_get_data (G_OBJECT (page_widget), "tab_pixmap");
gtk_image_set_from_pixbuf (GTK_IMAGE (pixwid), pixbuf);
pixwid = g_object_get_data (G_OBJECT (page_widget), "menu_pixmap");
gtk_image_set_from_pixbuf (GTK_IMAGE (pixwid), pixbuf);
}
static void
page_switch (GtkWidget *widget, gpointer *page, gint page_num)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
gint old_page_num = gtk_notebook_get_current_page (notebook);
if (page_num == old_page_num)
return;
set_page_image (notebook, page_num, book_open);
if (old_page_num != -1)
set_page_image (notebook, old_page_num, book_closed);
}
static void
tab_fill (GtkToggleButton *button, GtkWidget *child)
{
gtk_container_child_set (GTK_CONTAINER (sample_notebook), child,
"tab-fill", gtk_toggle_button_get_active (button),
NULL);
}
static void
tab_expand (GtkToggleButton *button, GtkWidget *child)
{
gtk_container_child_set (GTK_CONTAINER (sample_notebook), child,
"tab-expand", gtk_toggle_button_get_active (button),
NULL);
}
static void
create_pages (GtkNotebook *notebook, gint start, gint end)
{
GtkWidget *child = NULL;
GtkWidget *button;
GtkWidget *label;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *label_box;
GtkWidget *menu_box;
GtkWidget *pixwid;
gint i;
char buffer[32];
char accel_buffer[32];
for (i = start; i <= end; i++)
{
sprintf (buffer, "Page %d", i);
sprintf (accel_buffer, "Page _%d", i);
child = gtk_frame_new (buffer);
gtk_container_set_border_width (GTK_CONTAINER (child), 10);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_set_homogeneous (GTK_BOX (vbox), TRUE);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
gtk_container_add (GTK_CONTAINER (child), vbox);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
button = gtk_check_button_new_with_label ("Fill Tab");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
g_signal_connect (button, "toggled",
G_CALLBACK (tab_fill), child);
button = gtk_check_button_new_with_label ("Expand Tab");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
g_signal_connect (button, "toggled",
G_CALLBACK (tab_expand), child);
button = gtk_button_new_with_label ("Hide Page");
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 5);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_hide),
child);
gtk_widget_show_all (child);
label_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
pixwid = gtk_image_new_from_pixbuf (book_closed);
g_object_set_data (G_OBJECT (child), "tab_pixmap", pixwid);
gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
gtk_widget_set_margin_left (pixwid, 3);
gtk_widget_set_margin_right (pixwid, 3);
gtk_widget_set_margin_bottom (pixwid, 1);
gtk_widget_set_margin_top (pixwid, 1);
label = gtk_label_new_with_mnemonic (accel_buffer);
gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
gtk_widget_show_all (label_box);
menu_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
pixwid = gtk_image_new_from_pixbuf (book_closed);
g_object_set_data (G_OBJECT (child), "menu_pixmap", pixwid);
gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
gtk_widget_set_margin_left (pixwid, 3);
gtk_widget_set_margin_right (pixwid, 3);
gtk_widget_set_margin_bottom (pixwid, 1);
gtk_widget_set_margin_top (pixwid, 1);
label = gtk_label_new (buffer);
gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
gtk_widget_show_all (menu_box);
gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
}
}
static void
rotate_notebook (GtkButton *button,
GtkNotebook *notebook)
{
gtk_notebook_set_tab_pos (notebook, (gtk_notebook_get_tab_pos (notebook) + 1) % 4);
}
static void
show_all_pages (GtkButton *button,
GtkNotebook *notebook)
{
gtk_container_foreach (GTK_CONTAINER (notebook),
(GtkCallback) gtk_widget_show, NULL);
}
static void
notebook_type_changed (GtkWidget *optionmenu,
gpointer data)
{
GtkNotebook *notebook;
gint i, c;
enum {
STANDARD,
NOTABS,
BORDERLESS,
SCROLLABLE
};
notebook = GTK_NOTEBOOK (data);
c = gtk_combo_box_get_active (GTK_COMBO_BOX (optionmenu));
switch (c)
{
case STANDARD:
/* standard notebook */
gtk_notebook_set_show_tabs (notebook, TRUE);
gtk_notebook_set_show_border (notebook, TRUE);
gtk_notebook_set_scrollable (notebook, FALSE);
break;
case NOTABS:
/* notabs notebook */
gtk_notebook_set_show_tabs (notebook, FALSE);
gtk_notebook_set_show_border (notebook, TRUE);
break;
case BORDERLESS:
/* borderless */
gtk_notebook_set_show_tabs (notebook, FALSE);
gtk_notebook_set_show_border (notebook, FALSE);
break;
case SCROLLABLE:
/* scrollable */
gtk_notebook_set_show_tabs (notebook, TRUE);
gtk_notebook_set_show_border (notebook, TRUE);
gtk_notebook_set_scrollable (notebook, TRUE);
if (gtk_notebook_get_n_pages (notebook) == 5)
create_pages (notebook, 6, 15);
return;
break;
}
if (gtk_notebook_get_n_pages (notebook) == 15)
for (i = 0; i < 10; i++)
gtk_notebook_remove_page (notebook, 5);
}
static void
notebook_popup (GtkToggleButton *button,
GtkNotebook *notebook)
{
if (gtk_toggle_button_get_active (button))
gtk_notebook_popup_enable (notebook);
else
gtk_notebook_popup_disable (notebook);
}
static void
create_notebook (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *button;
GtkWidget *separator;
GtkWidget *omenu;
GtkWidget *label;
static gchar *items[] =
{
"Standard",
"No tabs",
"Borderless",
"Scrollable"
};
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_window_set_title (GTK_WINDOW (window), "notebook");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
sample_notebook = gtk_notebook_new ();
g_signal_connect (sample_notebook, "switch_page",
G_CALLBACK (page_switch), NULL);
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (sample_notebook), GTK_POS_TOP);
gtk_box_pack_start (GTK_BOX (box1), sample_notebook, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (sample_notebook), 10);
gtk_widget_realize (sample_notebook);
if (!book_open)
book_open = gdk_pixbuf_new_from_xpm_data (book_open_xpm);
if (!book_closed)
book_closed = gdk_pixbuf_new_from_xpm_data (book_closed_xpm);
create_pages (GTK_NOTEBOOK (sample_notebook), 1, 5);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
button = gtk_check_button_new_with_label ("popup menu");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (notebook_popup),
sample_notebook);
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
label = gtk_label_new ("Notebook Style :");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
omenu = build_option_menu (items, G_N_ELEMENTS (items), 0,
notebook_type_changed,
sample_notebook);
gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("Show all Pages");
gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (show_all_pages), sample_notebook);
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_set_homogeneous (GTK_BOX (box2), TRUE);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("prev");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_notebook_prev_page),
sample_notebook);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("next");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_notebook_next_page),
sample_notebook);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("rotate");
g_signal_connect (button, "clicked",
G_CALLBACK (rotate_notebook), sample_notebook);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
button = gtk_button_new_with_label ("close");
gtk_container_set_border_width (GTK_CONTAINER (button), 5);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_box_pack_start (GTK_BOX (box1), button, FALSE, FALSE, 0);
gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
void
create_settings (GtkWidget *widget)
{
static GtkWidget *window = NULL;
if (!window)
{
window = create_prop_editor (G_OBJECT (gtk_settings_get_default ()), GTK_TYPE_SETTINGS);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
gtk_widget_hide (window);
gtk_window_set_title (GTK_WINDOW (window), "GTK+ Settings");
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
}
/*
* GtkPanes
*/
void
toggle_resize (GtkWidget *widget, GtkWidget *child)
{
GtkContainer *container = GTK_CONTAINER (gtk_widget_get_parent (child));
GValue value = G_VALUE_INIT;
g_value_init (&value, G_TYPE_BOOLEAN);
gtk_container_child_get_property (container, child, "resize", &value);
g_value_set_boolean (&value, !g_value_get_boolean (&value));
gtk_container_child_set_property (container, child, "resize", &value);
}
void
toggle_shrink (GtkWidget *widget, GtkWidget *child)
{
GtkContainer *container = GTK_CONTAINER (gtk_widget_get_parent (child));
GValue value = G_VALUE_INIT;
g_value_init (&value, G_TYPE_BOOLEAN);
gtk_container_child_get_property (container, child, "shrink", &value);
g_value_set_boolean (&value, !g_value_get_boolean (&value));
gtk_container_child_set_property (container, child, "shrink", &value);
}
static void
paned_props_clicked (GtkWidget *button,
GObject *paned)
{
GtkWidget *window = create_prop_editor (paned, GTK_TYPE_PANED);
gtk_window_set_title (GTK_WINDOW (window), "Paned Properties");
}
GtkWidget *
create_pane_options (GtkPaned *paned,
const gchar *frame_label,
const gchar *label1,
const gchar *label2)
{
GtkWidget *child1, *child2;
GtkWidget *frame;
GtkWidget *grid;
GtkWidget *label;
GtkWidget *button;
GtkWidget *check_button;
child1 = gtk_paned_get_child1 (paned);
child2 = gtk_paned_get_child2 (paned);
frame = gtk_frame_new (frame_label);
gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
grid = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (frame), grid);
label = gtk_label_new (label1);
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
check_button = gtk_check_button_new_with_label ("Resize");
gtk_grid_attach (GTK_GRID (grid), check_button, 0, 1, 1, 1);
g_signal_connect (check_button, "toggled",
G_CALLBACK (toggle_resize),
child1);
check_button = gtk_check_button_new_with_label ("Shrink");
gtk_grid_attach (GTK_GRID (grid), check_button, 0, 2, 1, 1);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
TRUE);
g_signal_connect (check_button, "toggled",
G_CALLBACK (toggle_shrink),
child1);
label = gtk_label_new (label2);
gtk_grid_attach (GTK_GRID (grid), label, 1, 0, 1, 1);
check_button = gtk_check_button_new_with_label ("Resize");
gtk_grid_attach (GTK_GRID (grid), check_button, 1, 1, 1, 1);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
TRUE);
g_signal_connect (check_button, "toggled",
G_CALLBACK (toggle_resize),
child2);
check_button = gtk_check_button_new_with_label ("Shrink");
gtk_grid_attach (GTK_GRID (grid), check_button, 1, 2, 1, 1);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
TRUE);
g_signal_connect (check_button, "toggled",
G_CALLBACK (toggle_shrink),
child2);
button = gtk_button_new_with_mnemonic ("_Properties");
gtk_grid_attach (GTK_GRID (grid), button, 0, 3, 2, 1);
g_signal_connect (button, "clicked",
G_CALLBACK (paned_props_clicked),
paned);
return frame;
}
void
create_panes (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *frame;
GtkWidget *hpaned;
GtkWidget *vpaned;
GtkWidget *button;
GtkWidget *vbox;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_window_set_title (GTK_WINDOW (window), "Panes");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
vpaned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (vbox), vpaned, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER(vpaned), 5);
hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_widget_set_size_request (frame, 60, 60);
gtk_paned_add1 (GTK_PANED (hpaned), frame);
button = gtk_button_new_with_label ("Hi there");
gtk_container_add (GTK_CONTAINER(frame), button);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_widget_set_size_request (frame, 80, 60);
gtk_paned_add2 (GTK_PANED (hpaned), frame);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_widget_set_size_request (frame, 60, 80);
gtk_paned_add2 (GTK_PANED (vpaned), frame);
/* Now create toggle buttons to control sizing */
gtk_box_pack_start (GTK_BOX (vbox),
create_pane_options (GTK_PANED (hpaned),
"Horizontal",
"Left",
"Right"),
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox),
create_pane_options (GTK_PANED (vpaned),
"Vertical",
"Top",
"Bottom"),
FALSE, FALSE, 0);
gtk_widget_show_all (vbox);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
}
/*
* Paned keyboard navigation
*/
static GtkWidget*
paned_keyboard_window1 (GtkWidget *widget)
{
GtkWidget *window1;
GtkWidget *hpaned1;
GtkWidget *frame1;
GtkWidget *vbox1;
GtkWidget *button7;
GtkWidget *button8;
GtkWidget *button9;
GtkWidget *vpaned1;
GtkWidget *frame2;
GtkWidget *frame5;
GtkWidget *hbox1;
GtkWidget *button5;
GtkWidget *button6;
GtkWidget *frame3;
GtkWidget *frame4;
GtkWidget *grid1;
GtkWidget *button1;
GtkWidget *button2;
GtkWidget *button3;
GtkWidget *button4;
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_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_container_add (GTK_CONTAINER (window1), hpaned1);
frame1 = gtk_frame_new (NULL);
gtk_paned_pack1 (GTK_PANED (hpaned1), frame1, FALSE, TRUE);
gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_IN);
vbox1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (frame1), vbox1);
button7 = gtk_button_new_with_label ("button7");
gtk_box_pack_start (GTK_BOX (vbox1), button7, FALSE, FALSE, 0);
button8 = gtk_button_new_with_label ("button8");
gtk_box_pack_start (GTK_BOX (vbox1), button8, FALSE, FALSE, 0);
button9 = gtk_button_new_with_label ("button9");
gtk_box_pack_start (GTK_BOX (vbox1), button9, FALSE, FALSE, 0);
vpaned1 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_paned_pack2 (GTK_PANED (hpaned1), vpaned1, TRUE, TRUE);
frame2 = gtk_frame_new (NULL);
gtk_paned_pack1 (GTK_PANED (vpaned1), frame2, FALSE, TRUE);
gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_IN);
frame5 = gtk_frame_new (NULL);
gtk_container_add (GTK_CONTAINER (frame2), frame5);
hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add (GTK_CONTAINER (frame5), hbox1);
button5 = gtk_button_new_with_label ("button5");
gtk_box_pack_start (GTK_BOX (hbox1), button5, FALSE, FALSE, 0);
button6 = gtk_button_new_with_label ("button6");
gtk_box_pack_start (GTK_BOX (hbox1), button6, FALSE, FALSE, 0);
frame3 = gtk_frame_new (NULL);
gtk_paned_pack2 (GTK_PANED (vpaned1), frame3, TRUE, TRUE);
gtk_frame_set_shadow_type (GTK_FRAME (frame3), GTK_SHADOW_IN);
frame4 = gtk_frame_new ("Buttons");
gtk_container_add (GTK_CONTAINER (frame3), frame4);
gtk_container_set_border_width (GTK_CONTAINER (frame4), 15);
grid1 = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (frame4), grid1);
gtk_container_set_border_width (GTK_CONTAINER (grid1), 11);
button1 = gtk_button_new_with_label ("button1");
gtk_grid_attach (GTK_GRID (grid1), button1, 0, 0, 1, 1);
button2 = gtk_button_new_with_label ("button2");
gtk_grid_attach (GTK_GRID (grid1), button2, 1, 0, 1, 1);
button3 = gtk_button_new_with_label ("button3");
gtk_grid_attach (GTK_GRID (grid1), button3, 0, 1, 1, 1);
button4 = gtk_button_new_with_label ("button4");
gtk_grid_attach (GTK_GRID (grid1), button4, 1, 1, 1, 1);
return window1;
}
static GtkWidget*
paned_keyboard_window2 (GtkWidget *widget)
{
GtkWidget *window2;
GtkWidget *hpaned2;
GtkWidget *frame6;
GtkWidget *button13;
GtkWidget *hbox2;
GtkWidget *vpaned2;
GtkWidget *frame7;
GtkWidget *button12;
GtkWidget *frame8;
GtkWidget *button11;
GtkWidget *button10;
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_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_container_add (GTK_CONTAINER (window2), hpaned2);
frame6 = gtk_frame_new (NULL);
gtk_paned_pack1 (GTK_PANED (hpaned2), frame6, FALSE, TRUE);
gtk_frame_set_shadow_type (GTK_FRAME (frame6), GTK_SHADOW_IN);
button13 = gtk_button_new_with_label ("button13");
gtk_container_add (GTK_CONTAINER (frame6), button13);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_paned_pack2 (GTK_PANED (hpaned2), hbox2, TRUE, TRUE);
vpaned2 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (hbox2), vpaned2, TRUE, TRUE, 0);
frame7 = gtk_frame_new (NULL);
gtk_paned_pack1 (GTK_PANED (vpaned2), frame7, FALSE, TRUE);
gtk_frame_set_shadow_type (GTK_FRAME (frame7), GTK_SHADOW_IN);
button12 = gtk_button_new_with_label ("button12");
gtk_container_add (GTK_CONTAINER (frame7), button12);
frame8 = gtk_frame_new (NULL);
gtk_paned_pack2 (GTK_PANED (vpaned2), frame8, TRUE, TRUE);
gtk_frame_set_shadow_type (GTK_FRAME (frame8), GTK_SHADOW_IN);
button11 = gtk_button_new_with_label ("button11");
gtk_container_add (GTK_CONTAINER (frame8), button11);
button10 = gtk_button_new_with_label ("button10");
gtk_box_pack_start (GTK_BOX (hbox2), button10, FALSE, FALSE, 0);
return window2;
}
static GtkWidget*
paned_keyboard_window3 (GtkWidget *widget)
{
GtkWidget *window3;
GtkWidget *vbox2;
GtkWidget *label1;
GtkWidget *hpaned3;
GtkWidget *frame9;
GtkWidget *button14;
GtkWidget *hpaned4;
GtkWidget *frame10;
GtkWidget *button15;
GtkWidget *hpaned5;
GtkWidget *frame11;
GtkWidget *button16;
GtkWidget *frame12;
GtkWidget *button17;
window3 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_object_set_data (G_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_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window3), vbox2);
label1 = gtk_label_new ("Three panes nested inside each other");
gtk_box_pack_start (GTK_BOX (vbox2), label1, FALSE, FALSE, 0);
hpaned3 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (vbox2), hpaned3, TRUE, TRUE, 0);
frame9 = gtk_frame_new (NULL);
gtk_paned_pack1 (GTK_PANED (hpaned3), frame9, FALSE, TRUE);
gtk_frame_set_shadow_type (GTK_FRAME (frame9), GTK_SHADOW_IN);
button14 = gtk_button_new_with_label ("button14");
gtk_container_add (GTK_CONTAINER (frame9), button14);
hpaned4 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_paned_pack2 (GTK_PANED (hpaned3), hpaned4, TRUE, TRUE);
frame10 = gtk_frame_new (NULL);
gtk_paned_pack1 (GTK_PANED (hpaned4), frame10, FALSE, TRUE);
gtk_frame_set_shadow_type (GTK_FRAME (frame10), GTK_SHADOW_IN);
button15 = gtk_button_new_with_label ("button15");
gtk_container_add (GTK_CONTAINER (frame10), button15);
hpaned5 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_paned_pack2 (GTK_PANED (hpaned4), hpaned5, TRUE, TRUE);
frame11 = gtk_frame_new (NULL);
gtk_paned_pack1 (GTK_PANED (hpaned5), frame11, FALSE, TRUE);
gtk_frame_set_shadow_type (GTK_FRAME (frame11), GTK_SHADOW_IN);
button16 = gtk_button_new_with_label ("button16");
gtk_container_add (GTK_CONTAINER (frame11), button16);
frame12 = gtk_frame_new (NULL);
gtk_paned_pack2 (GTK_PANED (hpaned5), frame12, TRUE, TRUE);
gtk_frame_set_shadow_type (GTK_FRAME (frame12), GTK_SHADOW_IN);
button17 = gtk_button_new_with_label ("button17");
gtk_container_add (GTK_CONTAINER (frame12), button17);
return window3;
}
static GtkWidget*
paned_keyboard_window4 (GtkWidget *widget)
{
GtkWidget *window4;
GtkWidget *vbox3;
GtkWidget *label2;
GtkWidget *hpaned6;
GtkWidget *vpaned3;
GtkWidget *button19;
GtkWidget *button18;
GtkWidget *hbox3;
GtkWidget *vpaned4;
GtkWidget *button21;
GtkWidget *button20;
GtkWidget *vpaned5;
GtkWidget *button23;
GtkWidget *button22;
GtkWidget *vpaned6;
GtkWidget *button25;
GtkWidget *button24;
window4 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_object_set_data (G_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_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window4), vbox3);
label2 = gtk_label_new ("Widget tree:\n\nhpaned \n - vpaned\n - hbox\n - vpaned\n - vpaned\n - vpaned\n");
gtk_box_pack_start (GTK_BOX (vbox3), label2, FALSE, FALSE, 0);
gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);
hpaned6 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (vbox3), hpaned6, TRUE, TRUE, 0);
vpaned3 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_paned_pack1 (GTK_PANED (hpaned6), vpaned3, FALSE, TRUE);
button19 = gtk_button_new_with_label ("button19");
gtk_paned_pack1 (GTK_PANED (vpaned3), button19, FALSE, TRUE);
button18 = gtk_button_new_with_label ("button18");
gtk_paned_pack2 (GTK_PANED (vpaned3), button18, TRUE, TRUE);
hbox3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_paned_pack2 (GTK_PANED (hpaned6), hbox3, TRUE, TRUE);
vpaned4 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (hbox3), vpaned4, TRUE, TRUE, 0);
button21 = gtk_button_new_with_label ("button21");
gtk_paned_pack1 (GTK_PANED (vpaned4), button21, FALSE, TRUE);
button20 = gtk_button_new_with_label ("button20");
gtk_paned_pack2 (GTK_PANED (vpaned4), button20, TRUE, TRUE);
vpaned5 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (hbox3), vpaned5, TRUE, TRUE, 0);
button23 = gtk_button_new_with_label ("button23");
gtk_paned_pack1 (GTK_PANED (vpaned5), button23, FALSE, TRUE);
button22 = gtk_button_new_with_label ("button22");
gtk_paned_pack2 (GTK_PANED (vpaned5), button22, TRUE, TRUE);
vpaned6 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (hbox3), vpaned6, TRUE, TRUE, 0);
button25 = gtk_button_new_with_label ("button25");
gtk_paned_pack1 (GTK_PANED (vpaned6), button25, FALSE, TRUE);
button24 = gtk_button_new_with_label ("button24");
gtk_paned_pack2 (GTK_PANED (vpaned6), button24, TRUE, TRUE);
return window4;
}
static 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 (widget);
g_signal_connect (window1, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window1);
}
if (!window2)
{
window2 = paned_keyboard_window2 (widget);
g_signal_connect (window2, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window2);
}
if (!window3)
{
window3 = paned_keyboard_window3 (widget);
g_signal_connect (window3, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window3);
}
if (!window4)
{
window4 = paned_keyboard_window4 (widget);
g_signal_connect (window4, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window4);
}
if (gtk_widget_get_visible (window1))
gtk_widget_destroy (GTK_WIDGET (window1));
else
gtk_widget_show_all (GTK_WIDGET (window1));
if (gtk_widget_get_visible (window2))
gtk_widget_destroy (GTK_WIDGET (window2));
else
gtk_widget_show_all (GTK_WIDGET (window2));
if (gtk_widget_get_visible (window3))
gtk_widget_destroy (GTK_WIDGET (window3));
else
gtk_widget_show_all (GTK_WIDGET (window3));
if (gtk_widget_get_visible (window4))
gtk_widget_destroy (GTK_WIDGET (window4));
else
gtk_widget_show_all (GTK_WIDGET (window4));
}
/*
* Shaped Windows
*/
typedef struct _cursoroffset {gint x,y;} CursorOffset;
static void
shape_pressed (GtkWidget *widget, GdkEventButton *event)
{
CursorOffset *p;
/* ignore double and triple click */
if (event->type != GDK_BUTTON_PRESS)
return;
p = g_object_get_data (G_OBJECT (widget), "cursor_offset");
p->x = (int) event->x;
p->y = (int) event->y;
gtk_grab_add (widget);
gdk_device_grab (gdk_event_get_device ((GdkEvent*)event),
gtk_widget_get_window (widget),
GDK_OWNERSHIP_NONE,
TRUE,
GDK_BUTTON_RELEASE_MASK |
GDK_BUTTON_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK,
NULL,
event->time);
}
static void
shape_released (GtkWidget *widget,
GdkEventButton *event)
{
gtk_grab_remove (widget);
gdk_device_ungrab (gdk_event_get_device ((GdkEvent*)event), event->time);
}
static void
shape_motion (GtkWidget *widget,
GdkEventMotion *event)
{
gint xp, yp;
CursorOffset * p;
p = g_object_get_data (G_OBJECT (widget), "cursor_offset");
/*
* Can't use event->x / event->y here
* because I need absolute coordinates.
*/
gdk_window_get_device_position (gdk_screen_get_root_window (gtk_widget_get_screen (widget)),
gdk_event_get_device ((GdkEvent *) event),
&xp, &yp, NULL);
gtk_window_move (GTK_WINDOW (widget), xp - p->x, yp - p->y);
}
GtkWidget *
shape_create_icon (GdkScreen *screen,
char *xpm_file,
gint x,
gint y,
gint px,
gint py,
gint window_type)
{
GtkWidget *window;
GtkWidget *image;
GtkWidget *fixed;
CursorOffset* icon_pos;
cairo_surface_t *mask;
cairo_region_t *mask_region;
GdkPixbuf *pixbuf;
cairo_t *cr;
/*
* 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_size_request (fixed, 100, 100);
gtk_container_add (GTK_CONTAINER (window), fixed);
gtk_widget_show (fixed);
gtk_widget_set_events (window,
gtk_widget_get_events (window) |
GDK_BUTTON_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON_PRESS_MASK);
gtk_widget_realize (window);
pixbuf = gdk_pixbuf_new_from_file (xpm_file, NULL);
g_assert (pixbuf); /* FIXME: error handling */
mask = cairo_image_surface_create (CAIRO_FORMAT_A1,
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf));
cr = cairo_create (mask);
gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
cairo_paint (cr);
cairo_destroy (cr);
mask_region = gdk_cairo_region_create_from_surface (mask);
cairo_region_translate (mask_region, px, py);
image = gtk_image_new_from_pixbuf (pixbuf);
gtk_fixed_put (GTK_FIXED (fixed), image, px,py);
gtk_widget_show (image);
gtk_widget_shape_combine_region (window, mask_region);
cairo_region_destroy (mask_region);
cairo_surface_destroy (mask);
g_object_unref (pixbuf);
g_signal_connect (window, "button_press_event",
G_CALLBACK (shape_pressed), NULL);
g_signal_connect (window, "button_release_event",
G_CALLBACK (shape_released), NULL);
g_signal_connect (window, "motion_notify_event",
G_CALLBACK (shape_motion), NULL);
icon_pos = g_new (CursorOffset, 1);
g_object_set_data (G_OBJECT (window), "cursor_offset", icon_pos);
gtk_window_move (GTK_WINDOW (window), x, y);
gtk_widget_show (window);
return window;
}
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") &&
file_exists ("3DRings.xpm")))
return;
if (!modeller)
{
modeller = shape_create_icon (screen, "Modeller.xpm",
440, 140, 0,0, GTK_WINDOW_POPUP);
g_signal_connect (modeller, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&modeller);
}
else
gtk_widget_destroy (modeller);
if (!sheets)
{
sheets = shape_create_icon (screen, "FilesQueue.xpm",
580, 170, 0,0, GTK_WINDOW_POPUP);
g_signal_connect (sheets, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&sheets);
}
else
gtk_widget_destroy (sheets);
if (!rings)
{
rings = shape_create_icon (screen, "3DRings.xpm",
460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
g_signal_connect (rings, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&rings);
}
else
gtk_widget_destroy (rings);
if (!with_region)
{
cairo_region_t *region;
gint x, y;
with_region = shape_create_icon (screen, "3DRings.xpm",
460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
gtk_window_set_decorated (GTK_WINDOW (with_region), FALSE);
g_signal_connect (with_region, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&with_region);
/* reset shape from mask to a region */
x = 0;
y = 0;
region = cairo_region_create ();
while (x < 460)
{
while (y < 270)
{
GdkRectangle rect;
rect.x = x;
rect.y = y;
rect.width = 10;
rect.height = 10;
cairo_region_union_rectangle (region, &rect);
y += 20;
}
y = 0;
x += 20;
}
gdk_window_shape_combine_region (gtk_widget_get_window (with_region),
region,
0, 0);
}
else
gtk_widget_destroy (with_region);
}
/*
* WM Hints demo
*/
void
create_wmhints (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *label;
GtkWidget *separator;
GtkWidget *button;
GtkWidget *box1;
GtkWidget *box2;
GdkWindow *gdk_window;
GdkPixbuf *pixbuf;
GList *list;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_widget_realize (window);
gdk_window = gtk_widget_get_window (window);
pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) openfile);
list = g_list_prepend (NULL, pixbuf);
gdk_window_set_icon_list (gdk_window, list);
g_list_free (list);
g_object_unref (pixbuf);
gdk_window_set_icon_name (gdk_window, "WMHints Test Icon");
gdk_window_set_decorations (gdk_window, GDK_DECOR_ALL | GDK_DECOR_MENU);
gdk_window_set_functions (gdk_window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show (box1);
label = gtk_label_new ("Try iconizing me!");
gtk_widget_set_size_request (label, 150, 50);
gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
gtk_widget_show (label);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_widget_show (box2);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
gtk_widget_show (button);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
}
/*
* Window state tracking
*/
static gint
window_state_callback (GtkWidget *widget,
GdkEventWindowState *event,
gpointer data)
{
GtkWidget *label = data;
gchar *msg;
msg = g_strconcat (gtk_window_get_title (GTK_WINDOW (widget)), ": ",
(event->new_window_state & GDK_WINDOW_STATE_WITHDRAWN) ?
"withdrawn" : "not withdrawn", ", ",
(event->new_window_state & GDK_WINDOW_STATE_ICONIFIED) ?
"iconified" : "not iconified", ", ",
(event->new_window_state & GDK_WINDOW_STATE_STICKY) ?
"sticky" : "not sticky", ", ",
(event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) ?
"maximized" : "not maximized", ", ",
(event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) ?
"fullscreen" : "not fullscreen",
(event->new_window_state & GDK_WINDOW_STATE_ABOVE) ?
"above" : "not above", ", ",
(event->new_window_state & GDK_WINDOW_STATE_BELOW) ?
"below" : "not below", ", ",
NULL);
gtk_label_set_text (GTK_LABEL (label), msg);
g_free (msg);
return FALSE;
}
static GtkWidget*
tracking_label (GtkWidget *window)
{
GtkWidget *label;
GtkWidget *hbox;
GtkWidget *button;
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
g_signal_connect_object (hbox,
"destroy",
G_CALLBACK (gtk_widget_destroy),
window,
G_CONNECT_SWAPPED);
label = gtk_label_new ("<no window state events received>");
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
g_signal_connect (window,
"window_state_event",
G_CALLBACK (window_state_callback),
label);
button = gtk_button_new_with_label ("Deiconify");
g_signal_connect_object (button,
"clicked",
G_CALLBACK (gtk_window_deiconify),
window,
G_CONNECT_SWAPPED);
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Iconify");
g_signal_connect_object (button,
"clicked",
G_CALLBACK (gtk_window_iconify),
window,
G_CONNECT_SWAPPED);
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Fullscreen");
g_signal_connect_object (button,
"clicked",
G_CALLBACK (gtk_window_fullscreen),
window,
G_CONNECT_SWAPPED);
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Unfullscreen");
g_signal_connect_object (button,
"clicked",
G_CALLBACK (gtk_window_unfullscreen),
window,
G_CONNECT_SWAPPED);
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Present");
g_signal_connect_object (button,
"clicked",
G_CALLBACK (gtk_window_present),
window,
G_CONNECT_SWAPPED);
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Show");
g_signal_connect_object (button,
"clicked",
G_CALLBACK (gtk_widget_show),
window,
G_CONNECT_SWAPPED);
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show_all (hbox);
return hbox;
}
void
keep_window_above (GtkToggleButton *togglebutton, gpointer data)
{
GtkWidget *button = g_object_get_data (G_OBJECT (togglebutton), "radio");
gtk_window_set_keep_above (GTK_WINDOW (data),
gtk_toggle_button_get_active (togglebutton));
if (gtk_toggle_button_get_active (togglebutton))
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
}
void
keep_window_below (GtkToggleButton *togglebutton, gpointer data)
{
GtkWidget *button = g_object_get_data (G_OBJECT (togglebutton), "radio");
gtk_window_set_keep_below (GTK_WINDOW (data),
gtk_toggle_button_get_active (togglebutton));
if (gtk_toggle_button_get_active (togglebutton))
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
}
static GtkWidget*
get_state_controls (GtkWidget *window)
{
GtkWidget *vbox;
GtkWidget *button;
GtkWidget *button_above;
GtkWidget *button_below;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
button = gtk_button_new_with_label ("Stick");
g_signal_connect_object (button,
"clicked",
G_CALLBACK (gtk_window_stick),
window,
G_CONNECT_SWAPPED);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Unstick");
g_signal_connect_object (button,
"clicked",
G_CALLBACK (gtk_window_unstick),
window,
G_CONNECT_SWAPPED);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Maximize");
g_signal_connect_object (button,
"clicked",
G_CALLBACK (gtk_window_maximize),
window,
G_CONNECT_SWAPPED);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Unmaximize");
g_signal_connect_object (button,
"clicked",
G_CALLBACK (gtk_window_unmaximize),
window,
G_CONNECT_SWAPPED);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Iconify");
g_signal_connect_object (button,
"clicked",
G_CALLBACK (gtk_window_iconify),
window,
G_CONNECT_SWAPPED);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Fullscreen");
g_signal_connect_object (button,
"clicked",
G_CALLBACK (gtk_window_fullscreen),
window,
G_CONNECT_SWAPPED);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Unfullscreen");
g_signal_connect_object (button,
"clicked",
G_CALLBACK (gtk_window_unfullscreen),
window,
G_CONNECT_SWAPPED);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button_above = gtk_toggle_button_new_with_label ("Keep above");
g_signal_connect (button_above,
"toggled",
G_CALLBACK (keep_window_above),
window);
gtk_box_pack_start (GTK_BOX (vbox), button_above, FALSE, FALSE, 0);
button_below = gtk_toggle_button_new_with_label ("Keep below");
g_signal_connect (button_below,
"toggled",
G_CALLBACK (keep_window_below),
window);
gtk_box_pack_start (GTK_BOX (vbox), button_below, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (button_above), "radio", button_below);
g_object_set_data (G_OBJECT (button_below), "radio", button_above);
button = gtk_button_new_with_label ("Hide (withdraw)");
g_signal_connect_object (button,
"clicked",
G_CALLBACK (gtk_widget_hide),
window,
G_CONNECT_SWAPPED);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show_all (vbox);
return vbox;
}
void
create_window_states (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *label;
GtkWidget *box1;
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));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_window_set_title (GTK_WINDOW (window), "Window states");
box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
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));
g_signal_connect_object (iconified, "destroy",
G_CALLBACK (gtk_widget_destroy),
window,
G_CONNECT_SWAPPED);
gtk_window_iconify (GTK_WINDOW (iconified));
gtk_window_set_title (GTK_WINDOW (iconified), "Iconified initially");
controls = get_state_controls (iconified);
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));
g_signal_connect_object (normal, "destroy",
G_CALLBACK (gtk_widget_destroy),
window,
G_CONNECT_SWAPPED);
gtk_window_set_title (GTK_WINDOW (normal), "Deiconified initially");
controls = get_state_controls (normal);
gtk_container_add (GTK_CONTAINER (normal), controls);
label = tracking_label (iconified);
gtk_container_add (GTK_CONTAINER (box1), label);
label = tracking_label (normal);
gtk_container_add (GTK_CONTAINER (box1), label);
gtk_widget_show_all (iconified);
gtk_widget_show_all (normal);
gtk_widget_show_all (box1);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
}
/*
* Window sizing
*/
static gint
configure_event_callback (GtkWidget *widget,
GdkEventConfigure *event,
gpointer data)
{
GtkWidget *label = data;
gchar *msg;
gint x, y;
gtk_window_get_position (GTK_WINDOW (widget), &x, &y);
msg = g_strdup_printf ("event: %d,%d %d x %d\n"
"position: %d, %d",
event->x, event->y, event->width, event->height,
x, y);
gtk_label_set_text (GTK_LABEL (label), msg);
g_free (msg);
return FALSE;
}
static void
get_ints (GtkWidget *window,
gint *a,
gint *b)
{
GtkWidget *spin1;
GtkWidget *spin2;
spin1 = g_object_get_data (G_OBJECT (window), "spin1");
spin2 = g_object_get_data (G_OBJECT (window), "spin2");
*a = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
*b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
}
static void
set_size_callback (GtkWidget *widget,
gpointer data)
{
gint w, h;
get_ints (data, &w, &h);
gtk_window_resize (GTK_WINDOW (g_object_get_data (data, "target")), w, h);
}
static void
unset_default_size_callback (GtkWidget *widget,
gpointer data)
{
gtk_window_set_default_size (g_object_get_data (data, "target"),
-1, -1);
}
static void
set_default_size_callback (GtkWidget *widget,
gpointer data)
{
gint w, h;
get_ints (data, &w, &h);
gtk_window_set_default_size (g_object_get_data (data, "target"),
w, h);
}
static void
unset_size_request_callback (GtkWidget *widget,
gpointer data)
{
gtk_widget_set_size_request (g_object_get_data (data, "target"),
-1, -1);
}
static void
set_size_request_callback (GtkWidget *widget,
gpointer data)
{
gint w, h;
get_ints (data, &w, &h);
gtk_widget_set_size_request (g_object_get_data (data, "target"),
w, h);
}
static void
set_location_callback (GtkWidget *widget,
gpointer data)
{
gint x, y;
get_ints (data, &x, &y);
gtk_window_move (g_object_get_data (data, "target"), x, y);
}
static void
move_to_position_callback (GtkWidget *widget,
gpointer data)
{
gint x, y;
GtkWindow *window;
window = g_object_get_data (data, "target");
gtk_window_get_position (window, &x, &y);
gtk_window_move (window, x, y);
}
static void
set_geometry_callback (GtkWidget *entry,
gpointer data)
{
gchar *text;
GtkWindow *target;
target = GTK_WINDOW (g_object_get_data (G_OBJECT (data), "target"));
text = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1);
if (!gtk_window_parse_geometry (target, text))
g_print ("Bad geometry string '%s'\n", text);
g_free (text);
}
static void
resizable_callback (GtkWidget *widget,
gpointer data)
{
g_object_set (g_object_get_data (data, "target"),
"resizable", gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)),
NULL);
}
static void
gravity_selected (GtkWidget *widget,
gpointer data)
{
gtk_window_set_gravity (GTK_WINDOW (g_object_get_data (data, "target")),
gtk_combo_box_get_active (GTK_COMBO_BOX (widget)) + GDK_GRAVITY_NORTH_WEST);
}
static void
pos_selected (GtkWidget *widget,
gpointer data)
{
gtk_window_set_position (GTK_WINDOW (g_object_get_data (data, "target")),
gtk_combo_box_get_active (GTK_COMBO_BOX (widget)) + GTK_WIN_POS_NONE);
}
static void
move_gravity_window_to_current_position (GtkWidget *widget,
gpointer data)
{
gint x, y;
GtkWindow *window;
window = GTK_WINDOW (data);
gtk_window_get_position (window, &x, &y);
gtk_window_move (window, x, y);
}
static void
get_screen_corner (GtkWindow *window,
gint *x,
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_get_width (screen) - w;
*y = gdk_screen_get_height (screen) - h;
break;
case GDK_GRAVITY_NORTH_EAST:
*x = gdk_screen_get_width (screen) - w;
*y = 0;
break;
case GDK_GRAVITY_SOUTH_WEST:
*x = 0;
*y = gdk_screen_get_height (screen) - h;
break;
case GDK_GRAVITY_NORTH_WEST:
*x = 0;
*y = 0;
break;
case GDK_GRAVITY_SOUTH:
*x = (gdk_screen_get_width (screen) - w) / 2;
*y = gdk_screen_get_height (screen) - h;
break;
case GDK_GRAVITY_NORTH:
*x = (gdk_screen_get_width (screen) - w) / 2;
*y = 0;
break;
case GDK_GRAVITY_WEST:
*x = 0;
*y = (gdk_screen_get_height (screen) - h) / 2;
break;
case GDK_GRAVITY_EAST:
*x = gdk_screen_get_width (screen) - w;
*y = (gdk_screen_get_height (screen) - h) / 2;
break;
case GDK_GRAVITY_CENTER:
*x = (gdk_screen_get_width (screen) - w) / 2;
*y = (gdk_screen_get_height (screen) - h) / 2;
break;
case GDK_GRAVITY_STATIC:
/* pick some random numbers */
*x = 350;
*y = 350;
break;
default:
g_assert_not_reached ();
break;
}
}
static void
move_gravity_window_to_starting_position (GtkWidget *widget,
gpointer data)
{
gint x, y;
GtkWindow *window;
window = GTK_WINDOW (data);
get_screen_corner (window,
&x, &y);
gtk_window_move (window, x, y);
}
static GtkWidget*
make_gravity_window (GtkWidget *destroy_with,
GdkGravity gravity,
const gchar *title)
{
GtkWidget *window;
GtkWidget *button;
GtkWidget *vbox;
int x, y;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (destroy_with));
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (vbox);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_window_set_title (GTK_WINDOW (window), title);
gtk_window_set_gravity (GTK_WINDOW (window), gravity);
g_signal_connect_object (destroy_with,
"destroy",
G_CALLBACK (gtk_widget_destroy),
window,
G_CONNECT_SWAPPED);
button = gtk_button_new_with_mnemonic ("_Move to current position");
g_signal_connect (button, "clicked",
G_CALLBACK (move_gravity_window_to_current_position),
window);
gtk_container_add (GTK_CONTAINER (vbox), button);
gtk_widget_show (button);
button = gtk_button_new_with_mnemonic ("Move to _starting position");
g_signal_connect (button, "clicked",
G_CALLBACK (move_gravity_window_to_starting_position),
window);
gtk_container_add (GTK_CONTAINER (vbox), button);
gtk_widget_show (button);
/* Pretend this is the result of --geometry.
* DO NOT COPY THIS CODE unless you are setting --geometry results,
* and in that case you probably should just use gtk_window_parse_geometry().
* AGAIN, DO NOT SET GDK_HINT_USER_POS! It violates the ICCCM unless
* you are parsing --geometry or equivalent.
*/
gtk_window_set_geometry_hints (GTK_WINDOW (window),
NULL, NULL,
GDK_HINT_USER_POS);
gtk_window_set_default_size (GTK_WINDOW (window),
200, 200);
get_screen_corner (GTK_WINDOW (window), &x, &y);
gtk_window_move (GTK_WINDOW (window),
x, y);
return window;
}
static void
do_gravity_test (GtkWidget *widget,
gpointer data)
{
GtkWidget *destroy_with = data;
GtkWidget *window;
/* We put a window at each gravity point on the screen. */
window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH_WEST,
"NorthWest");
gtk_widget_show (window);
window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH_EAST,
"SouthEast");
gtk_widget_show (window);
window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH_EAST,
"NorthEast");
gtk_widget_show (window);
window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH_WEST,
"SouthWest");
gtk_widget_show (window);
window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH,
"South");
gtk_widget_show (window);
window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH,
"North");
gtk_widget_show (window);
window = make_gravity_window (destroy_with, GDK_GRAVITY_WEST,
"West");
gtk_widget_show (window);
window = make_gravity_window (destroy_with, GDK_GRAVITY_EAST,
"East");
gtk_widget_show (window);
window = make_gravity_window (destroy_with, GDK_GRAVITY_CENTER,
"Center");
gtk_widget_show (window);
window = make_gravity_window (destroy_with, GDK_GRAVITY_STATIC,
"Static");
gtk_widget_show (window);
}
static GtkWidget*
window_controls (GtkWidget *window)
{
GtkWidget *control_window;
GtkWidget *label;
GtkWidget *vbox;
GtkWidget *button;
GtkWidget *spin;
GtkAdjustment *adjustment;
GtkWidget *entry;
GtkWidget *om;
gint i;
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),
"target",
window);
g_signal_connect_object (control_window,
"destroy",
G_CALLBACK (gtk_widget_destroy),
window,
G_CONNECT_SWAPPED);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add (GTK_CONTAINER (control_window), vbox);
label = gtk_label_new ("<no configure events>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
g_signal_connect (window,
"configure_event",
G_CALLBACK (configure_event_callback),
label);
adjustment = gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0, 5.0, 0.0);
spin = gtk_spin_button_new (adjustment, 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (control_window), "spin1", spin);
adjustment = gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0, 5.0, 0.0);
spin = gtk_spin_button_new (adjustment, 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (control_window), "spin2", spin);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
g_signal_connect (entry, "changed",
G_CALLBACK (set_geometry_callback),
control_window);
button = gtk_button_new_with_label ("Show gravity test windows");
g_signal_connect_swapped (button,
"clicked",
G_CALLBACK (do_gravity_test),
control_window);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Reshow with initial size");
g_signal_connect_object (button,
"clicked",
G_CALLBACK (gtk_window_reshow_with_initial_size),
window,
G_CONNECT_SWAPPED);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Queue resize");
g_signal_connect_object (button,
"clicked",
G_CALLBACK (gtk_widget_queue_resize),
window,
G_CONNECT_SWAPPED);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Resize");
g_signal_connect (button,
"clicked",
G_CALLBACK (set_size_callback),
control_window);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Set default size");
g_signal_connect (button,
"clicked",
G_CALLBACK (set_default_size_callback),
control_window);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Unset default size");
g_signal_connect (button,
"clicked",
G_CALLBACK (unset_default_size_callback),
control_window);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Set size request");
g_signal_connect (button,
"clicked",
G_CALLBACK (set_size_request_callback),
control_window);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Unset size request");
g_signal_connect (button,
"clicked",
G_CALLBACK (unset_size_request_callback),
control_window);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Move");
g_signal_connect (button,
"clicked",
G_CALLBACK (set_location_callback),
control_window);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Move to current position");
g_signal_connect (button,
"clicked",
G_CALLBACK (move_to_position_callback),
control_window);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_check_button_new_with_label ("Allow resize");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
g_signal_connect (button,
"toggled",
G_CALLBACK (resizable_callback),
control_window);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_mnemonic ("_Show");
g_signal_connect_object (button,
"clicked",
G_CALLBACK (gtk_widget_show),
window,
G_CONNECT_SWAPPED);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_mnemonic ("_Hide");
g_signal_connect_object (button,
"clicked",
G_CALLBACK (gtk_widget_hide),
window,
G_CONNECT_SWAPPED);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
om = gtk_combo_box_text_new ();
i = 0;
while (i < 10)
{
static gchar *names[] = {
"GDK_GRAVITY_NORTH_WEST",
"GDK_GRAVITY_NORTH",
"GDK_GRAVITY_NORTH_EAST",
"GDK_GRAVITY_WEST",
"GDK_GRAVITY_CENTER",
"GDK_GRAVITY_EAST",
"GDK_GRAVITY_SOUTH_WEST",
"GDK_GRAVITY_SOUTH",
"GDK_GRAVITY_SOUTH_EAST",
"GDK_GRAVITY_STATIC",
NULL
};
g_assert (names[i]);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (om), names[i]);
++i;
}
g_signal_connect (om,
"changed",
G_CALLBACK (gravity_selected),
control_window);
gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
om = gtk_combo_box_text_new ();
i = 0;
while (i < 5)
{
static gchar *names[] = {
"GTK_WIN_POS_NONE",
"GTK_WIN_POS_CENTER",
"GTK_WIN_POS_MOUSE",
"GTK_WIN_POS_CENTER_ALWAYS",
"GTK_WIN_POS_CENTER_ON_PARENT",
NULL
};
g_assert (names[i]);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (om), names[i]);
++i;
}
g_signal_connect (om,
"changed",
G_CALLBACK (pos_selected),
control_window);
gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
gtk_widget_show_all (vbox);
return control_window;
}
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);
gtk_widget_show (label);
g_signal_connect (target_window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&target_window);
window = window_controls (target_window);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_window_set_title (GTK_WINDOW (target_window), "Window to size");
}
/* don't show target window by default, we want to allow testing
* of behavior on first show.
*/
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
}
/*
* GtkProgressBar
*/
typedef struct _ProgressData {
GtkWidget *window;
GtkWidget *pbar;
GtkWidget *block_spin;
GtkWidget *x_align_spin;
GtkWidget *y_align_spin;
GtkWidget *step_spin;
GtkWidget *act_blocks_spin;
GtkWidget *label;
GtkWidget *omenu1;
GtkWidget *elmenu;
GtkWidget *omenu2;
GtkWidget *entry;
int timer;
gboolean activity;
} ProgressData;
gboolean
progress_timeout (gpointer data)
{
ProgressData *pdata = data;
gdouble new_val;
gchar *text;
if (pdata->activity)
{
gtk_progress_bar_pulse (GTK_PROGRESS_BAR (pdata->pbar));
text = g_strdup_printf ("%s", "???");
}
else
{
new_val = gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (pdata->pbar)) + 0.01;
if (new_val > 1.00)
new_val = 0.00;
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (pdata->pbar), new_val);
text = g_strdup_printf ("%.0f%%", 100 * new_val);
}
gtk_label_set_text (GTK_LABEL (pdata->label), text);
g_free (text);
return TRUE;
}
static void
destroy_progress (GtkWidget *widget,
ProgressData **pdata)
{
if ((*pdata)->timer)
{
g_source_remove ((*pdata)->timer);
(*pdata)->timer = 0;
}
(*pdata)->window = NULL;
g_free (*pdata);
*pdata = NULL;
}
static void
progressbar_toggle_orientation (GtkWidget *widget, gpointer data)
{
ProgressData *pdata;
gint i;
pdata = (ProgressData *) data;
if (!gtk_widget_get_mapped (widget))
return;
i = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
if (i == 0 || i == 1)
gtk_orientable_set_orientation (GTK_ORIENTABLE (pdata->pbar), GTK_ORIENTATION_HORIZONTAL);
else
gtk_orientable_set_orientation (GTK_ORIENTABLE (pdata->pbar), GTK_ORIENTATION_VERTICAL);
if (i == 1 || i == 2)
gtk_progress_bar_set_inverted (GTK_PROGRESS_BAR (pdata->pbar), TRUE);
else
gtk_progress_bar_set_inverted (GTK_PROGRESS_BAR (pdata->pbar), FALSE);
}
static void
toggle_show_text (GtkWidget *widget, ProgressData *pdata)
{
gboolean active;
active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
gtk_progress_bar_set_show_text (GTK_PROGRESS_BAR (pdata->pbar), active);
}
static void
progressbar_toggle_ellipsize (GtkWidget *widget,
gpointer data)
{
ProgressData *pdata = data;
if (gtk_widget_is_drawable (widget))
{
gint i = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (pdata->pbar), i);
}
}
static void
toggle_activity_mode (GtkWidget *widget, ProgressData *pdata)
{
pdata->activity = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
}
static void
toggle_running (GtkWidget *widget, ProgressData *pdata)
{
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
{
if (pdata->timer == 0)
pdata->timer = g_timeout_add (100, (GSourceFunc)progress_timeout, pdata);
}
else
{
if (pdata->timer != 0)
{
g_source_remove (pdata->timer);
pdata->timer = 0;
}
}
}
static void
entry_changed (GtkWidget *widget, ProgressData *pdata)
{
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (pdata->pbar),
gtk_entry_get_text (GTK_ENTRY (pdata->entry)));
}
void
create_progress_bar (GtkWidget *widget)
{
GtkWidget *action_area, *content_area;
GtkWidget *button;
GtkWidget *vbox;
GtkWidget *vbox2;
GtkWidget *hbox;
GtkWidget *check;
GtkWidget *frame;
GtkWidget *grid;
GtkWidget *label;
static ProgressData *pdata = NULL;
static gchar *items1[] =
{
"Left-Right",
"Right-Left",
"Bottom-Top",
"Top-Bottom"
};
static char *ellipsize_items[] = {
"None", // PANGO_ELLIPSIZE_NONE,
"Start", // PANGO_ELLIPSIZE_START,
"Middle", // PANGO_ELLIPSIZE_MIDDLE,
"End", // PANGO_ELLIPSIZE_END
};
if (!pdata)
pdata = g_new0 (ProgressData, 1);
if (!pdata->window)
{
pdata->window = gtk_dialog_new ();
gtk_window_set_screen (GTK_WINDOW (pdata->window),
gtk_widget_get_screen (widget));
gtk_window_set_resizable (GTK_WINDOW (pdata->window), TRUE);
g_signal_connect (pdata->window, "destroy",
G_CALLBACK (destroy_progress),
&pdata);
pdata->timer = 0;
content_area = gtk_dialog_get_content_area (GTK_DIALOG (pdata->window));
action_area = gtk_dialog_get_action_area (GTK_DIALOG (pdata->window));
gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar");
gtk_container_set_border_width (GTK_CONTAINER (pdata->window), 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
gtk_box_pack_start (GTK_BOX (content_area), vbox, FALSE, TRUE, 0);
frame = gtk_frame_new ("Progress");
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add (GTK_CONTAINER (frame), vbox2);
pdata->pbar = gtk_progress_bar_new ();
gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (pdata->pbar),
PANGO_ELLIPSIZE_MIDDLE);
gtk_widget_set_halign (pdata->pbar, GTK_ALIGN_CENTER);
gtk_widget_set_valign (pdata->pbar, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (vbox2), pdata->pbar, FALSE, FALSE, 5);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_widget_set_halign (hbox, GTK_ALIGN_CENTER);
gtk_widget_set_valign (hbox, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 5);
label = gtk_label_new ("Label updated by user :");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
pdata->label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), pdata->label, FALSE, TRUE, 0);
frame = gtk_frame_new ("Options");
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add (GTK_CONTAINER (frame), vbox2);
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 10);
gtk_grid_set_column_spacing (GTK_GRID (grid), 10);
gtk_box_pack_start (GTK_BOX (vbox2), grid, FALSE, TRUE, 0);
label = gtk_label_new ("Orientation :");
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
pdata->omenu1 = build_option_menu (items1, 4, 0,
progressbar_toggle_orientation,
pdata);
gtk_grid_attach (GTK_GRID (grid), pdata->omenu1, 1, 0, 1, 1);
check = gtk_check_button_new_with_label ("Running");
g_signal_connect (check, "toggled",
G_CALLBACK (toggle_running),
pdata);
gtk_grid_attach (GTK_GRID (grid), check, 0, 1, 2, 1);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
check = gtk_check_button_new_with_label ("Show text");
g_signal_connect (check, "clicked",
G_CALLBACK (toggle_show_text),
pdata);
gtk_grid_attach (GTK_GRID (grid), check, 0, 2, 1, 1);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_grid_attach (GTK_GRID (grid), hbox, 1, 2, 1, 1);
label = gtk_label_new ("Text: ");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
pdata->entry = gtk_entry_new ();
gtk_widget_set_hexpand (pdata->entry, TRUE);
g_signal_connect (pdata->entry, "changed",
G_CALLBACK (entry_changed),
pdata);
gtk_box_pack_start (GTK_BOX (hbox), pdata->entry, TRUE, TRUE, 0);
gtk_widget_set_size_request (pdata->entry, 100, -1);
label = gtk_label_new ("Ellipsize text :");
gtk_grid_attach (GTK_GRID (grid), label, 0, 10, 1, 1);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
pdata->elmenu = build_option_menu (ellipsize_items,
sizeof (ellipsize_items) / sizeof (ellipsize_items[0]),
2, // PANGO_ELLIPSIZE_MIDDLE
progressbar_toggle_ellipsize,
pdata);
gtk_grid_attach (GTK_GRID (grid), pdata->elmenu, 1, 10, 1, 1);
check = gtk_check_button_new_with_label ("Activity mode");
g_signal_connect (check, "clicked",
G_CALLBACK (toggle_activity_mode), pdata);
gtk_grid_attach (GTK_GRID (grid), check, 0, 15, 1, 1);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
pdata->window);
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
gtk_widget_grab_default (button);
}
if (!gtk_widget_get_visible (pdata->window))
gtk_widget_show_all (pdata->window);
else
gtk_widget_destroy (pdata->window);
}
/*
* Properties
*/
typedef struct {
int x;
int y;
gboolean found;
gboolean first;
GtkWidget *res_widget;
} FindWidgetData;
static void
find_widget (GtkWidget *widget, FindWidgetData *data)
{
GtkAllocation new_allocation;
gint x_offset = 0;
gint y_offset = 0;
gtk_widget_get_allocation (widget, &new_allocation);
if (data->found || !gtk_widget_get_mapped (widget))
return;
/* Note that in the following code, we only count the
* position as being inside a WINDOW widget if it is inside
* widget->window; points that are outside of widget->window
* but within the allocation are not counted. This is consistent
* with the way we highlight drag targets.
*/
if (gtk_widget_get_has_window (widget))
{
new_allocation.x = 0;
new_allocation.y = 0;
}
if (gtk_widget_get_parent (widget) && !data->first)
{
GdkWindow *window = gtk_widget_get_window (widget);
while (window != gtk_widget_get_window (gtk_widget_get_parent (widget)))
{
gint tx, ty, twidth, theight;
twidth = gdk_window_get_width (window);
theight = gdk_window_get_height (window);
if (new_allocation.x < 0)
{
new_allocation.width += new_allocation.x;
new_allocation.x = 0;
}
if (new_allocation.y < 0)
{
new_allocation.height += new_allocation.y;
new_allocation.y = 0;
}
if (new_allocation.x + new_allocation.width > twidth)
new_allocation.width = twidth - new_allocation.x;
if (new_allocation.y + new_allocation.height > theight)
new_allocation.height = theight - new_allocation.y;
gdk_window_get_position (window, &tx, &ty);
new_allocation.x += tx;
x_offset += tx;
new_allocation.y += ty;
y_offset += ty;
window = gdk_window_get_parent (window);
}
}
if ((data->x >= new_allocation.x) && (data->y >= new_allocation.y) &&
(data->x < new_allocation.x + new_allocation.width) &&
(data->y < new_allocation.y + new_allocation.height))
{
/* First, check if the drag is in a valid drop site in
* one of our children
*/
if (GTK_IS_CONTAINER (widget))
{
FindWidgetData new_data = *data;
new_data.x -= x_offset;
new_data.y -= y_offset;
new_data.found = FALSE;
new_data.first = FALSE;
gtk_container_forall (GTK_CONTAINER (widget),
(GtkCallback)find_widget,
&new_data);
data->found = new_data.found;
if (data->found)
data->res_widget = new_data.res_widget;
}
/* If not, and this widget is registered as a drop site, check to
* emit "drag_motion" to check if we are actually in
* a drop site.
*/
if (!data->found)
{
data->found = TRUE;
data->res_widget = widget;
}
}
}
static GtkWidget *
find_widget_at_pointer (GdkDevice *device)
{
GtkWidget *widget = NULL;
GdkWindow *pointer_window;
gint x, y;
FindWidgetData data;
pointer_window = gdk_device_get_window_at_position (device, NULL, NULL);
if (pointer_window)
{
gpointer widget_ptr;
gdk_window_get_user_data (pointer_window, &widget_ptr);
widget = widget_ptr;
}
if (widget)
{
gdk_window_get_device_position (gtk_widget_get_window (widget),
device,
&x, &y, NULL);
data.x = x;
data.y = y;
data.found = FALSE;
data.first = TRUE;
find_widget (widget, &data);
if (data.found)
return data.res_widget;
return widget;
}
return NULL;
}
struct PropertiesData {
GtkWidget **window;
GdkCursor *cursor;
gboolean in_query;
gulong handler;
};
static void
destroy_properties (GtkWidget *widget,
struct PropertiesData *data)
{
if (data->window)
{
*data->window = NULL;
data->window = NULL;
}
if (data->cursor)
{
g_object_unref (data->cursor);
data->cursor = NULL;
}
if (data->handler)
{
g_signal_handler_disconnect (widget, data->handler);
data->handler = 0;
}
g_free (data);
}
static gint
property_query_event (GtkWidget *widget,
GdkEvent *event,
struct PropertiesData *data)
{
GtkWidget *res_widget = NULL;
if (!data->in_query)
return FALSE;
if (event->type == GDK_BUTTON_RELEASE)
{
gtk_grab_remove (widget);
gdk_device_ungrab (gdk_event_get_device (event), GDK_CURRENT_TIME);
res_widget = find_widget_at_pointer (gdk_event_get_device (event));
if (res_widget)
{
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;
}
return FALSE;
}
static void
query_properties (GtkButton *button,
struct PropertiesData *data)
{
GtkWidget *widget = GTK_WIDGET (button);
GdkDisplay *display;
GdkDeviceManager *device_manager;
GdkDevice *device;
g_signal_connect (button, "event",
G_CALLBACK (property_query_event), data);
display = gtk_widget_get_display (widget);
if (!data->cursor)
data->cursor = gdk_cursor_new_for_display (display, GDK_TARGET);
device_manager = gdk_display_get_device_manager (display);
device = gdk_device_manager_get_client_pointer (device_manager);
gdk_device_grab (device,
gtk_widget_get_window (widget),
GDK_OWNERSHIP_NONE,
TRUE,
GDK_BUTTON_RELEASE_MASK,
data->cursor,
GDK_CURRENT_TIME);
gtk_grab_add (widget);
data->in_query = TRUE;
}
static void
create_properties (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *button;
GtkWidget *vbox;
GtkWidget *label;
struct PropertiesData *data;
data = g_new (struct PropertiesData, 1);
data->window = &window;
data->in_query = FALSE;
data->cursor = NULL;
data->handler = 0;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
data->handler = g_signal_connect (window, "destroy",
G_CALLBACK (destroy_properties),
data);
gtk_window_set_title (GTK_WINDOW (window), "test properties");
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1);
gtk_container_add (GTK_CONTAINER (window), vbox);
label = gtk_label_new ("This is just a dumb test to test properties.\nIf you need a generic module, get GLE.");
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Query properties");
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (query_properties),
data);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
struct SnapshotData {
GtkWidget *toplevel_button;
GtkWidget **window;
GdkCursor *cursor;
gboolean in_query;
gboolean is_toplevel;
gint handler;
};
static void
destroy_snapshot_data (GtkWidget *widget,
struct SnapshotData *data)
{
if (*data->window)
*data->window = NULL;
if (data->cursor)
{
g_object_unref (data->cursor);
data->cursor = NULL;
}
if (data->handler)
{
g_signal_handler_disconnect (widget, data->handler);
data->handler = 0;
}
g_free (data);
}
static gint
snapshot_widget_event (GtkWidget *widget,
GdkEvent *event,
struct SnapshotData *data)
{
GtkWidget *res_widget = NULL;
if (!data->in_query)
return FALSE;
if (event->type == GDK_BUTTON_RELEASE)
{
gtk_grab_remove (widget);
gdk_device_ungrab (gdk_event_get_device (event),
GDK_CURRENT_TIME);
res_widget = find_widget_at_pointer (gdk_event_get_device (event));
if (data->is_toplevel && res_widget)
res_widget = gtk_widget_get_toplevel (res_widget);
if (res_widget)
{
cairo_surface_t *surface;
GtkWidget *window, *image;
GdkPixbuf *pixbuf;
int width, height;
cairo_t *cr;
width = gtk_widget_get_allocated_width (res_widget);
height = gtk_widget_get_allocated_height (res_widget);
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
cr = cairo_create (surface);
gtk_widget_draw (res_widget, cr);
cairo_destroy (cr);
pixbuf = gdk_pixbuf_get_from_surface (surface,
0, 0,
width, height);
cairo_surface_destroy (surface);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
image = gtk_image_new_from_pixbuf (pixbuf);
g_object_unref (pixbuf);
gtk_container_add (GTK_CONTAINER (window), image);
gtk_widget_show_all (window);
}
data->in_query = FALSE;
}
return FALSE;
}
static void
snapshot_widget (GtkButton *button,
struct SnapshotData *data)
{
GtkWidget *widget = GTK_WIDGET (button);
GdkDevice *device;
device = gtk_get_current_event_device ();
if (device == NULL)
return;
if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
device = gdk_device_get_associated_device (device);
data->is_toplevel = widget == data->toplevel_button;
if (!data->cursor)
data->cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
GDK_TARGET);
gdk_device_grab (device,
gtk_widget_get_window (widget),
GDK_OWNERSHIP_APPLICATION,
TRUE,
GDK_BUTTON_RELEASE_MASK,
data->cursor,
GDK_CURRENT_TIME);
g_signal_connect (button, "event",
G_CALLBACK (snapshot_widget_event), data);
gtk_grab_add (widget);
data->in_query = TRUE;
}
static void
create_snapshot (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *button;
GtkWidget *vbox;
struct SnapshotData *data;
data = g_new (struct SnapshotData, 1);
data->window = &window;
data->in_query = FALSE;
data->cursor = NULL;
data->handler = 0;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
data->handler = g_signal_connect (window, "destroy",
G_CALLBACK (destroy_snapshot_data),
data);
gtk_window_set_title (GTK_WINDOW (window), "test snapshot");
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1);
gtk_container_add (GTK_CONTAINER (window), vbox);
button = gtk_button_new_with_label ("Snapshot widget");
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (snapshot_widget),
data);
button = gtk_button_new_with_label ("Snapshot toplevel");
data->toplevel_button = button;
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (snapshot_widget),
data);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/*
* Selection Test
*/
void
selection_test_received (GtkWidget *tree_view,
GtkSelectionData *selection_data)
{
GtkTreeModel *model;
GtkListStore *store;
GdkAtom *atoms;
int i, l;
if (gtk_selection_data_get_length (selection_data) < 0)
{
g_print ("Selection retrieval failed\n");
return;
}
if (gtk_selection_data_get_data_type (selection_data) != GDK_SELECTION_TYPE_ATOM)
{
g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
return;
}
/* Clear out any current list items */
model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view));
store = GTK_LIST_STORE (model);
gtk_list_store_clear (store);
/* Add new items to list */
gtk_selection_data_get_targets (selection_data,
&atoms, &l);
for (i = 0; i < l; i++)
{
char *name;
GtkTreeIter iter;
name = gdk_atom_name (atoms[i]);
if (name != NULL)
{
gtk_list_store_insert_with_values (store, &iter, i, 0, name, -1);
g_free (name);
}
else
gtk_list_store_insert_with_values (store, &iter, i, 0, "(bad atom)", -1);
}
return;
}
void
selection_test_get_targets (GtkWidget *widget, GtkWidget *tree_view)
{
static GdkAtom targets_atom = GDK_NONE;
if (targets_atom == GDK_NONE)
targets_atom = gdk_atom_intern ("TARGETS", FALSE);
gtk_selection_convert (tree_view, GDK_SELECTION_PRIMARY, targets_atom,
GDK_CURRENT_TIME);
}
void
create_selection_test (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *action_area, *content_area;
GtkWidget *button;
GtkWidget *vbox;
GtkWidget *scrolled_win;
GtkListStore* store;
GtkWidget *tree_view;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkWidget *label;
if (!window)
{
window = gtk_dialog_new ();
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
/* Create the list */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
gtk_box_pack_start (GTK_BOX (content_area), vbox, TRUE, TRUE, 0);
label = gtk_label_new ("Gets available targets for current selection");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
gtk_widget_set_size_request (scrolled_win, 100, 200);
store = gtk_list_store_new (1, G_TYPE_STRING);
tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
gtk_container_add (GTK_CONTAINER (scrolled_win), tree_view);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Target", renderer,
"text", 0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
g_signal_connect (tree_view, "selection_received",
G_CALLBACK (selection_test_received), NULL);
/* .. And create some buttons */
button = gtk_button_new_with_label ("Get Targets");
gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (selection_test_get_targets), tree_view);
button = gtk_button_new_with_label ("Quit");
gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/*
* Test scrolling
*/
static int scroll_test_pos = 0.0;
static gint
scroll_test_draw (GtkWidget *widget,
cairo_t *cr,
GtkAdjustment *adjustment)
{
gint i,j;
gint imin, imax, jmin, jmax;
GdkRectangle clip;
gdk_cairo_get_clip_rectangle (cr, &clip);
imin = (clip.x) / 10;
imax = (clip.x + clip.width + 9) / 10;
jmin = ((int)gtk_adjustment_get_value (adjustment) + clip.y) / 10;
jmax = ((int)gtk_adjustment_get_value (adjustment) + clip.y + clip.height + 9) / 10;
for (i=imin; i<imax; i++)
for (j=jmin; j<jmax; j++)
if ((i+j) % 2)
cairo_rectangle (cr, 10*i, 10*j - (int)gtk_adjustment_get_value (adjustment), 1+i%10, 1+j%10);
cairo_fill (cr);
return TRUE;
}
static gint
scroll_test_scroll (GtkWidget *widget, GdkEventScroll *event,
GtkAdjustment *adjustment)
{
gdouble new_value = gtk_adjustment_get_value (adjustment) + ((event->direction == GDK_SCROLL_UP) ?
-gtk_adjustment_get_page_increment (adjustment) / 2:
gtk_adjustment_get_page_increment (adjustment) / 2);
new_value = CLAMP (new_value, gtk_adjustment_get_lower (adjustment), gtk_adjustment_get_upper (adjustment) - gtk_adjustment_get_page_size (adjustment));
gtk_adjustment_set_value (adjustment, new_value);
return TRUE;
}
static void
scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
GtkAdjustment *adjustment)
{
GtkAllocation allocation;
gtk_widget_get_allocation (widget, &allocation);
gtk_adjustment_configure (adjustment,
gtk_adjustment_get_value (adjustment),
gtk_adjustment_get_lower (adjustment),
gtk_adjustment_get_upper (adjustment),
0.1 * allocation.height,
0.9 * allocation.height,
allocation.height);
}
static void
scroll_test_adjustment_changed (GtkAdjustment *adjustment, GtkWidget *widget)
{
GdkWindow *window;
gint dy;
dy = scroll_test_pos - (int)gtk_adjustment_get_value (adjustment);
scroll_test_pos = gtk_adjustment_get_value (adjustment);
if (!gtk_widget_is_drawable (widget))
return;
window = gtk_widget_get_window (widget);
gdk_window_scroll (window, 0, dy);
gdk_window_process_updates (window, FALSE);
}
void
create_scroll_test (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *action_area, *content_area;
GtkWidget *hbox;
GtkWidget *drawing_area;
GtkWidget *scrollbar;
GtkWidget *button;
GtkAdjustment *adjustment;
GdkGeometry geometry;
GdkWindowHints geometry_mask;
if (!window)
{
window = gtk_dialog_new ();
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (content_area), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
drawing_area = gtk_drawing_area_new ();
gtk_widget_set_size_request (drawing_area, 200, 200);
gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
gtk_widget_show (drawing_area);
gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK | GDK_SCROLL_MASK);
adjustment = gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0);
scroll_test_pos = 0.0;
scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, adjustment);
gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
gtk_widget_show (scrollbar);
g_signal_connect (drawing_area, "draw",
G_CALLBACK (scroll_test_draw), adjustment);
g_signal_connect (drawing_area, "configure_event",
G_CALLBACK (scroll_test_configure), adjustment);
g_signal_connect (drawing_area, "scroll_event",
G_CALLBACK (scroll_test_scroll), adjustment);
g_signal_connect (adjustment, "value_changed",
G_CALLBACK (scroll_test_adjustment_changed),
drawing_area);
/* .. And create some buttons */
button = gtk_button_new_with_label ("Quit");
gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_widget_show (button);
/* Set up gridded geometry */
geometry_mask = GDK_HINT_MIN_SIZE |
GDK_HINT_BASE_SIZE |
GDK_HINT_RESIZE_INC;
geometry.min_width = 20;
geometry.min_height = 20;
geometry.base_width = 0;
geometry.base_height = 0;
geometry.width_inc = 10;
geometry.height_inc = 10;
gtk_window_set_geometry_hints (GTK_WINDOW (window),
drawing_area, &geometry, geometry_mask);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
}
/*
* Timeout Test
*/
static int timer = 0;
gint
timeout_test (GtkWidget *label)
{
static int count = 0;
static char buffer[32];
sprintf (buffer, "count: %d", ++count);
gtk_label_set_text (GTK_LABEL (label), buffer);
return TRUE;
}
void
start_timeout_test (GtkWidget *widget,
GtkWidget *label)
{
if (!timer)
{
timer = g_timeout_add (100, (GSourceFunc)timeout_test, label);
}
}
void
stop_timeout_test (GtkWidget *widget,
gpointer data)
{
if (timer)
{
g_source_remove (timer);
timer = 0;
}
}
void
destroy_timeout_test (GtkWidget *widget,
GtkWidget **window)
{
stop_timeout_test (NULL, NULL);
*window = NULL;
}
void
create_timeout_test (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *action_area, *content_area;
GtkWidget *button;
GtkWidget *label;
if (!window)
{
window = gtk_dialog_new ();
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (destroy_timeout_test),
&window);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
action_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
label = gtk_label_new ("count: 0");
g_object_set (label, "margin", 10, NULL);
gtk_box_pack_start (GTK_BOX (content_area), label, TRUE, TRUE, 0);
gtk_widget_show (label);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
gtk_widget_grab_default (button);
gtk_widget_show (button);
button = gtk_button_new_with_label ("start");
g_signal_connect (button, "clicked",
G_CALLBACK(start_timeout_test),
label);
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
gtk_widget_show (button);
button = gtk_button_new_with_label ("stop");
g_signal_connect (button, "clicked",
G_CALLBACK (stop_timeout_test),
NULL);
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
gtk_widget_show (button);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
}
/*
* Idle Test
*/
static int idle_id = 0;
static gint
idle_test (GtkWidget *label)
{
static int count = 0;
static char buffer[32];
sprintf (buffer, "count: %d", ++count);
gtk_label_set_text (GTK_LABEL (label), buffer);
return G_SOURCE_CONTINUE;
}
static void
start_idle_test (GtkWidget *widget,
GtkWidget *label)
{
if (!idle_id)
{
idle_id = g_idle_add ((GSourceFunc) idle_test, label);
}
}
static void
stop_idle_test (GtkWidget *widget,
gpointer data)
{
if (idle_id)
{
g_source_remove (idle_id);
idle_id = 0;
}
}
static void
destroy_idle_test (GtkWidget *widget,
GtkWidget **window)
{
stop_idle_test (NULL, NULL);
*window = NULL;
}
static void
toggle_idle_container (GObject *button,
GtkContainer *container)
{
gtk_container_set_resize_mode (container, GPOINTER_TO_INT (g_object_get_data (button, "user_data")));
}
static void
create_idle_test (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *button;
GtkWidget *label;
GtkWidget *container;
if (!window)
{
GtkWidget *action_area, *content_area;
GtkWidget *button2;
GtkWidget *frame;
GtkWidget *box;
window = gtk_dialog_new ();
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (destroy_idle_test),
&window);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
label = gtk_label_new ("count: 0");
g_object_set (label, "margin", 10, NULL);
gtk_widget_show (label);
container =
g_object_new (GTK_TYPE_BOX,
"visible", TRUE,
/* "GtkContainer::child", g_object_new (GTK_TYPE_HBOX,
* "GtkWidget::visible", TRUE,
*/
"child", label,
/* NULL), */
NULL);
gtk_box_pack_start (GTK_BOX (content_area), container, TRUE, TRUE, 0);
frame =
g_object_new (GTK_TYPE_FRAME,
"border_width", 5,
"label", "Label Container",
"visible", TRUE,
"parent", content_area,
NULL);
box =
g_object_new (GTK_TYPE_BOX,
"visible", TRUE,
"parent", frame,
"orientation", GTK_ORIENTATION_VERTICAL,
NULL);
button =
g_object_connect (g_object_new (GTK_TYPE_RADIO_BUTTON,
"label", "Resize-Parent",
"user_data", (void*)GTK_RESIZE_PARENT,
"visible", TRUE,
"parent", box,
NULL),
"signal::clicked", toggle_idle_container, container,
NULL);
button = g_object_new (GTK_TYPE_RADIO_BUTTON,
"label", "Resize-Queue",
"user_data", (void*)GTK_RESIZE_QUEUE,
"group", button,
"visible", TRUE,
"parent", box,
NULL);
g_object_connect (button,
"signal::clicked", toggle_idle_container, container,
NULL);
button2 = g_object_new (GTK_TYPE_RADIO_BUTTON,
"label", "Resize-Immediate",
"user_data", (void*)GTK_RESIZE_IMMEDIATE,
NULL);
g_object_connect (button2,
"signal::clicked", toggle_idle_container, container,
NULL);
g_object_set (button2,
"group", button,
"visible", TRUE,
"parent", box,
NULL);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
gtk_widget_grab_default (button);
gtk_widget_show (button);
button = gtk_button_new_with_label ("start");
g_signal_connect (button, "clicked",
G_CALLBACK (start_idle_test),
label);
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
gtk_widget_show (button);
button = gtk_button_new_with_label ("stop");
g_signal_connect (button, "clicked",
G_CALLBACK (stop_idle_test),
NULL);
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
gtk_widget_show (button);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
}
/*
* rc file test
*/
void
create_rc_file (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *action_area, *content_area;
GtkWidget *button;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *label;
if (!window)
{
window = gtk_dialog_new ();
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
frame = gtk_aspect_frame_new ("Testing RC file prioritization", 0.5, 0.5, 0.0, TRUE);
gtk_box_pack_start (GTK_BOX (content_area), frame, FALSE, FALSE, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (frame), vbox);
label = gtk_label_new ("This label should be red");
gtk_widget_set_name (label, "testgtk-red-label");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
label = gtk_label_new ("This label should be green");
gtk_widget_set_name (label, "testgtk-green-label");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
label = gtk_label_new ("This label should be blue");
gtk_widget_set_name (label, "testgtk-blue-label");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
button = gtk_button_new_with_label ("Reload");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_style_context_reset_widgets),
gtk_widget_get_screen (button));
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
gtk_widget_grab_default (button);
button = gtk_button_new_with_label ("Close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/*
* Test of recursive mainloop
*/
void
mainloop_destroyed (GtkWidget *w, GtkWidget **window)
{
*window = NULL;
gtk_main_quit ();
}
void
create_mainloop (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *action_area, *content_area;
GtkWidget *label;
GtkWidget *button;
if (!window)
{
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");
g_signal_connect (window, "destroy",
G_CALLBACK (mainloop_destroyed),
&window);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
label = gtk_label_new ("In recursive main loop...");
g_object_set (label, "margin", 20, NULL);
gtk_box_pack_start (GTK_BOX (content_area), label, TRUE, TRUE, 0);
gtk_widget_show (label);
button = gtk_button_new_with_label ("Leave");
gtk_box_pack_start (GTK_BOX (action_area), button, FALSE, TRUE, 0);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
gtk_widget_show (button);
}
if (!gtk_widget_get_visible (window))
{
gtk_widget_show (window);
g_print ("create_mainloop: start\n");
gtk_main ();
g_print ("create_mainloop: done\n");
}
else
gtk_widget_destroy (window);
}
static gboolean
layout_draw_handler (GtkWidget *widget, cairo_t *cr)
{
GtkLayout *layout;
GdkWindow *bin_window;
GdkRectangle clip;
gint i,j,x,y;
gint imin, imax, jmin, jmax;
layout = GTK_LAYOUT (widget);
bin_window = gtk_layout_get_bin_window (layout);
if (!gtk_cairo_should_draw_window (cr, bin_window))
return FALSE;
gdk_window_get_position (bin_window, &x, &y);
cairo_translate (cr, x, y);
gdk_cairo_get_clip_rectangle (cr, &clip);
imin = (clip.x) / 10;
imax = (clip.x + clip.width + 9) / 10;
jmin = (clip.y) / 10;
jmax = (clip.y + clip.height + 9) / 10;
for (i=imin; i<imax; i++)
for (j=jmin; j<jmax; j++)
if ((i+j) % 2)
cairo_rectangle (cr,
10*i, 10*j,
1+i%10, 1+j%10);
cairo_fill (cr);
return FALSE;
}
void create_layout (GtkWidget *widget)
{
GtkAdjustment *hadjustment, *vadjustment;
GtkLayout *layout;
static GtkWidget *window = NULL;
GtkWidget *layout_widget;
GtkWidget *scrolledwindow;
GtkWidget *button;
if (!window)
{
gchar buf[16];
gint i, j;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_window_set_title (GTK_WINDOW (window), "Layout");
gtk_widget_set_size_request (window, 200, 200);
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow),
GTK_SHADOW_IN);
gtk_scrolled_window_set_placement (GTK_SCROLLED_WINDOW (scrolledwindow),
GTK_CORNER_TOP_RIGHT);
gtk_container_add (GTK_CONTAINER (window), scrolledwindow);
layout_widget = gtk_layout_new (NULL, NULL);
layout = GTK_LAYOUT (layout_widget);
gtk_container_add (GTK_CONTAINER (scrolledwindow), layout_widget);
/* We set step sizes here since GtkLayout does not set
* them itself.
*/
hadjustment = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (layout));
vadjustment = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (layout));
gtk_adjustment_set_step_increment (hadjustment, 10.0);
gtk_adjustment_set_step_increment (vadjustment, 10.0);
gtk_scrollable_set_hadjustment (GTK_SCROLLABLE (layout), hadjustment);
gtk_scrollable_set_vadjustment (GTK_SCROLLABLE (layout), vadjustment);
gtk_widget_set_events (layout_widget, GDK_EXPOSURE_MASK);
g_signal_connect (layout, "draw",
G_CALLBACK (layout_draw_handler), NULL);
gtk_layout_set_size (layout, 1600, 128000);
for (i=0 ; i < 16 ; i++)
for (j=0 ; j < 16 ; j++)
{
sprintf(buf, "Button %d, %d", i, j);
if ((i + j) % 2)
button = gtk_button_new_with_label (buf);
else
button = gtk_label_new (buf);
gtk_layout_put (layout, button, j*100, i*100);
}
for (i=16; i < 1280; i++)
{
sprintf(buf, "Button %d, %d", i, 0);
if (i % 2)
button = gtk_button_new_with_label (buf);
else
button = gtk_label_new (buf);
gtk_layout_put (layout, button, 0, i*100);
}
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
#if 0
/* FIXME: need to completely redo this for GtkStyleContext */
void
create_styles (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *content_area, *action_area;
GtkWidget *label;
GtkWidget *button;
GtkWidget *entry;
GtkWidget *vbox;
static GdkRGBA red = { 1,0,0,1 };
static GdkRGBA green = { 0,1,0,1 };
static GdkRGBA blue = { 0,0,1,1 };
static GdkRGBA yellow = { 1,1,0,1 };
static GdkRGBA cyan = { 0,1,1,1 };
PangoFontDescription *font_desc;
GtkRcStyle *rc_style;
if (!window)
{
window = gtk_dialog_new ();
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
button = gtk_button_new_with_label ("Close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
gtk_widget_show (button);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
gtk_box_pack_start (GTK_BOX (content_area), vbox, FALSE, FALSE, 0);
label = gtk_label_new ("Font:");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
font_desc = pango_font_description_from_string ("Helvetica,Sans Oblique 18");
button = gtk_button_new_with_label ("Some Text");
gtk_widget_override_font (gtk_bin_get_child (GTK_BIN (button)), font_desc);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
label = gtk_label_new ("Foreground:");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Some Text");
gtk_widget_override_color (gtk_bin_get_child (GTK_BIN (button)), 0, &red);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
label = gtk_label_new ("Background:");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Some Text");
gtk_widget_override_background_color (button, 0, &green);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
label = gtk_label_new ("Text:");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
entry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
gtk_widget_override_color (entry, 0, &blue);
gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
label = gtk_label_new ("Base:");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
entry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
gtk_widget_override_background_color (entry, 0, &yellow);
gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
label = gtk_label_new ("Cursor:");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
entry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
gtk_widget_modify_cursor (entry, &red, &red);
gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
label = gtk_label_new ("Multiple:");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Some Text");
rc_style = gtk_rc_style_new ();
rc_style->font_desc = pango_font_description_copy (font_desc);
rc_style->color_flags[GTK_STATE_NORMAL] = GTK_RC_FG | GTK_RC_BG;
rc_style->color_flags[GTK_STATE_PRELIGHT] = GTK_RC_FG | GTK_RC_BG;
rc_style->color_flags[GTK_STATE_ACTIVE] = GTK_RC_FG | GTK_RC_BG;
rc_style->fg[GTK_STATE_NORMAL] = yellow;
rc_style->bg[GTK_STATE_NORMAL] = blue;
rc_style->fg[GTK_STATE_PRELIGHT] = blue;
rc_style->bg[GTK_STATE_PRELIGHT] = yellow;
rc_style->fg[GTK_STATE_ACTIVE] = red;
rc_style->bg[GTK_STATE_ACTIVE] = cyan;
rc_style->xthickness = 5;
rc_style->ythickness = 5;
gtk_widget_modify_style (button, rc_style);
gtk_widget_modify_style (gtk_bin_get_child (GTK_BIN (button)), rc_style);
g_object_unref (rc_style);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
#endif
/*
* Main Window and Exit
*/
void
do_exit (GtkWidget *widget, GtkWidget *window)
{
gtk_widget_destroy (window);
gtk_main_quit ();
}
struct {
char *label;
void (*func) (GtkWidget *widget);
gboolean do_not_benchmark;
} buttons[] =
{
{ "alpha window", create_alpha_window },
{ "big windows", create_big_windows },
{ "button box", create_button_box },
{ "buttons", create_buttons },
{ "check buttons", create_check_buttons },
{ "color selection", create_color_selection },
{ "composited window", create_composited_window },
{ "cursors", create_cursors },
{ "dialog", create_dialog },
{ "display & screen", create_display_screen, TRUE },
{ "entry", create_entry },
{ "event box", create_event_box },
{ "event watcher", create_event_watcher },
{ "expander", create_expander },
{ "flipping", create_flipping },
{ "focus", create_focus },
{ "font selection", create_font_selection },
{ "image", create_image },
{ "key lookup", create_key_lookup },
{ "labels", create_labels },
{ "layout", create_layout },
{ "menus", create_menus },
{ "message dialog", create_message_dialog },
{ "modal window", create_modal_window, TRUE },
{ "notebook", create_notebook },
{ "panes", create_panes },
{ "paned keyboard", create_paned_keyboard_navigation },
{ "pixbuf", create_pixbuf },
{ "progress bar", create_progress_bar },
{ "properties", create_properties },
{ "radio buttons", create_radio_buttons },
{ "range controls", create_range_controls },
{ "rc file", create_rc_file },
{ "reparent", create_reparent },
{ "resize grips", create_resize_grips },
{ "rotated label", create_rotated_label },
{ "rotated text", create_rotated_text },
{ "saved position", create_saved_position },
{ "scrolled windows", create_scrolled_windows },
{ "settings", create_settings },
{ "shapes", create_shapes },
{ "size groups", create_size_groups },
{ "snapshot", create_snapshot },
{ "spinbutton", create_spins },
{ "statusbar", create_statusbar },
#if 0
{ "styles", create_styles },
#endif
{ "test idle", create_idle_test },
{ "test mainloop", create_mainloop, TRUE },
{ "test scrolling", create_scroll_test },
{ "test selection", create_selection_test },
{ "test timeout", create_timeout_test },
{ "toggle buttons", create_toggle_buttons },
{ "toolbar", create_toolbar },
{ "tooltips", create_tooltips },
{ "WM hints", create_wmhints },
{ "window sizing", create_window_sizing },
{ "window states", create_window_states }
};
int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
void
create_main_window (void)
{
GtkWidget *window;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *scrolled_window;
GtkWidget *button;
GtkWidget *label;
gchar buffer[64];
GtkWidget *separator;
GdkGeometry geometry;
int i;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_name (window, "main_window");
gtk_window_move (GTK_WINDOW (window), 50, 20);
gtk_window_set_default_size (GTK_WINDOW (window), -1, 400);
geometry.min_width = -1;
geometry.min_height = -1;
geometry.max_width = -1;
geometry.max_height = G_MAXSHORT;
gtk_window_set_geometry_hints (GTK_WINDOW (window), NULL,
&geometry,
GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit),
NULL);
g_signal_connect (window, "delete-event",
G_CALLBACK (gtk_false),
NULL);
box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
if (gtk_micro_version > 0)
sprintf (buffer,
"Gtk+ v%d.%d.%d",
gtk_get_major_version (),
gtk_get_minor_version (),
gtk_get_micro_version ());
else
sprintf (buffer,
"Gtk+ v%d.%d",
gtk_get_major_version (),
gtk_get_minor_version ());
label = gtk_label_new (buffer);
gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
gtk_widget_set_name (label, "testgtk-version-label");
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_container_add (GTK_CONTAINER (scrolled_window), box2);
gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
gtk_widget_show (box2);
for (i = 0; i < nbuttons; i++)
{
button = gtk_button_new_with_label (buttons[i].label);
if (buttons[i].func)
g_signal_connect (button,
"clicked",
G_CALLBACK(buttons[i].func),
NULL);
else
gtk_widget_set_sensitive (button, FALSE);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
}
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
button = gtk_button_new_with_mnemonic ("_Close");
g_signal_connect (button, "clicked",
G_CALLBACK (do_exit),
window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
gtk_widget_show_all (window);
}
static void
test_init (void)
{
if (g_file_test ("../modules/input/immodules.cache", G_FILE_TEST_EXISTS))
g_setenv ("GTK_IM_MODULE_FILE", "../modules/input/immodules.cache", TRUE);
}
static char *
pad (const char *str, int to)
{
static char buf[256];
int len = strlen (str);
int i;
for (i = 0; i < to; i++)
buf[i] = ' ';
buf[to] = '\0';
memcpy (buf, str, len);
return buf;
}
static void
bench_iteration (GtkWidget *widget, void (* fn) (GtkWidget *widget))
{
fn (widget); /* on */
while (g_main_context_iteration (NULL, FALSE));
fn (widget); /* off */
while (g_main_context_iteration (NULL, FALSE));
}
void
do_real_bench (GtkWidget *widget, void (* fn) (GtkWidget *widget), char *name, int num)
{
GTimeVal tv0, tv1;
double dt_first;
double dt;
int n;
static gboolean printed_headers = FALSE;
if (!printed_headers) {
g_print ("Test Iters First Other\n");
g_print ("-------------------- ----- ---------- ----------\n");
printed_headers = TRUE;
}
g_get_current_time (&tv0);
bench_iteration (widget, fn);
g_get_current_time (&tv1);
dt_first = ((double)tv1.tv_sec - tv0.tv_sec) * 1000.0
+ (tv1.tv_usec - tv0.tv_usec) / 1000.0;
g_get_current_time (&tv0);
for (n = 0; n < num - 1; n++)
bench_iteration (widget, fn);
g_get_current_time (&tv1);
dt = ((double)tv1.tv_sec - tv0.tv_sec) * 1000.0
+ (tv1.tv_usec - tv0.tv_usec) / 1000.0;
g_print ("%s %5d ", pad (name, 20), num);
if (num > 1)
g_print ("%10.1f %10.1f\n", dt_first, dt/(num-1));
else
g_print ("%10.1f\n", dt_first);
}
void
do_bench (char* what, int num)
{
int i;
GtkWidget *widget;
void (* fn) (GtkWidget *widget);
fn = NULL;
widget = gtk_window_new (GTK_WINDOW_TOPLEVEL);
if (g_ascii_strcasecmp (what, "ALL") == 0)
{
for (i = 0; i < nbuttons; i++)
{
if (!buttons[i].do_not_benchmark)
do_real_bench (widget, buttons[i].func, buttons[i].label, num);
}
return;
}
else
{
for (i = 0; i < nbuttons; i++)
{
if (strcmp (buttons[i].label, what) == 0)
{
fn = buttons[i].func;
break;
}
}
if (!fn)
g_print ("Can't bench: \"%s\" not found.\n", what);
else
do_real_bench (widget, fn, buttons[i].label, num);
}
}
void
usage (void)
{
fprintf (stderr, "Usage: testgtk [--bench ALL|<bench>[:<count>]]\n");
exit (1);
}
int
main (int argc, char *argv[])
{
GtkCssProvider *provider, *memory_provider;
GdkDisplay *display;
GdkScreen *screen;
GtkBindingSet *binding_set;
int i;
gboolean done_benchmarks = FALSE;
srand (time (NULL));
test_init ();
g_set_application_name ("GTK+ Test Program");
gtk_init (&argc, &argv);
provider = gtk_css_provider_new ();
/* Check to see if we are being run from the correct
* directory.
*/
if (file_exists ("testgtk.css"))
gtk_css_provider_load_from_path (provider, "testgtk.css", NULL);
else if (file_exists ("tests/testgtk.css"))
gtk_css_provider_load_from_path (provider, "tests/testgtk.css", NULL);
else
g_warning ("Couldn't find file \"testgtk.css\".");
display = gdk_display_get_default ();
screen = gdk_display_get_default_screen (display);
gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref (provider);
gtk_accelerator_set_default_mod_mask (GDK_SHIFT_MASK |
GDK_CONTROL_MASK |
GDK_MOD1_MASK |
GDK_META_MASK |
GDK_SUPER_MASK |
GDK_HYPER_MASK |
GDK_MOD4_MASK);
/* benchmarking
*/
for (i = 1; i < argc; i++)
{
if (strncmp (argv[i], "--bench", strlen("--bench")) == 0)
{
int num = 1;
char *nextarg;
char *what;
char *count;
nextarg = strchr (argv[i], '=');
if (nextarg)
nextarg++;
else
{
i++;
if (i == argc)
usage ();
nextarg = argv[i];
}
count = strchr (nextarg, ':');
if (count)
{
what = g_strndup (nextarg, count - nextarg);
count++;
num = atoi (count);
if (num <= 0)
usage ();
}
else
what = g_strdup (nextarg);
do_bench (what, num ? num : 1);
done_benchmarks = TRUE;
}
else
usage ();
}
if (done_benchmarks)
return 0;
/* bindings test
*/
binding_set = gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_WIDGET));
gtk_binding_entry_add_signal (binding_set,
'9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
"debug_msg",
1,
G_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
memory_provider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (memory_provider,
"#testgtk-version-label {\n"
" color: #f00;\n"
" font: Sans 18;\n"
"}",
-1, NULL);
gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER (memory_provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION + 1);
create_main_window ();
gtk_main ();
if (1)
{
while (g_main_context_pending (NULL))
g_main_context_iteration (NULL, FALSE);
#if 0
sleep (1);
while (g_main_context_pending (NULL))
g_main_context_iteration (NULL, FALSE);
#endif
}
return 0;
}