#define sleep(n) _sleep(n)
#endif
+#include "prop-editor.h"
+
#include "circles.xbm"
#include "test.xpm"
-typedef struct _OptionMenuItem
-{
- gchar *name;
- GtkSignalFunc func;
-} OptionMenuItem;
-
gboolean
file_exists (const char *filename)
{
gint window_type);
static GtkWidget *
-build_option_menu (OptionMenuItem items[],
- gint num_items,
- gint history,
- gpointer data);
+build_option_menu (gchar *items[],
+ gint num_items,
+ gint history,
+ void (*func)(GtkWidget *widget, gpointer data),
+ gpointer data);
/* macro, structure and variables used by tree window demos */
#define DEFAULT_NUMBER_OF_ITEM 3
/* end of tree section */
static GtkWidget *
-build_option_menu (OptionMenuItem items[],
- gint num_items,
- gint history,
- gpointer data)
+build_option_menu (gchar *items[],
+ gint num_items,
+ gint history,
+ void (*func)(GtkWidget *widget, gpointer data),
+ gpointer data)
{
GtkWidget *omenu;
GtkWidget *menu;
gint i;
omenu = gtk_option_menu_new ();
+ gtk_signal_connect (GTK_OBJECT (omenu), "changed",
+ GTK_SIGNAL_FUNC (func), data);
menu = gtk_menu_new ();
group = NULL;
for (i = 0; i < num_items; i++)
{
- menu_item = gtk_radio_menu_item_new_with_label (group, items[i].name);
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- (GtkSignalFunc) items[i].func, data);
+ menu_item = gtk_radio_menu_item_new_with_label (group, items[i]);
group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
if (i == history)
*window = NULL;
}
+
+/*
+ * Big windows and guffaw scrolling
+ */
+
+static gboolean
+pattern_expose (GtkWidget *widget,
+ GdkEventExpose *event,
+ gpointer data)
+{
+ GdkColor *color;
+ GdkWindow *window = event->window;
+
+ color = g_object_get_data (G_OBJECT (window), "pattern-color");
+ if (color)
+ {
+ GdkGC *tmp_gc = gdk_gc_new (window);
+ gdk_gc_set_rgb_fg_color (tmp_gc, color);
+
+ gdk_draw_rectangle (window, tmp_gc, TRUE,
+ event->area.x, event->area.y,
+ event->area.width, event->area.height);
+
+ g_object_unref (G_OBJECT (tmp_gc));
+ }
+
+ return FALSE;
+}
+
+static void
+pattern_set_bg (GtkWidget *widget,
+ GdkWindow *child,
+ gint level)
+{
+ static const GdkColor colors[] = {
+ { 0, 0x4444, 0x4444, 0xffff },
+ { 0, 0x8888, 0x8888, 0xffff },
+ { 0, 0xaaaa, 0xaaaa, 0xffff }
+ };
+
+ g_object_set_data (G_OBJECT (child), "pattern-color", (gpointer)&colors[level]);
+ gdk_window_set_user_data (child, widget);
+}
+
+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);
+ attributes.colormap = gtk_widget_get_colormap (widget);
+
+ child = gdk_window_new (parent, &attributes,
+ GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP);
+
+ 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 *adj,
+ GtkWidget *darea)
+{
+ gint *old_value = g_object_get_data (G_OBJECT (adj), "old-value");
+ gint new_value = adj->value;
+
+ if (GTK_WIDGET_REALIZED (darea))
+ {
+ gdk_window_scroll (darea->window, *old_value - new_value, 0);
+ *old_value = new_value;
+ }
+}
+
+static void
+pattern_vadj_changed (GtkAdjustment *adj,
+ GtkWidget *darea)
+{
+ gint *old_value = g_object_get_data (G_OBJECT (adj), "old-value");
+ gint new_value = adj->value;
+
+ if (GTK_WIDGET_REALIZED (darea))
+ {
+ gdk_window_scroll (darea->window, 0, *old_value - new_value);
+ *old_value = new_value;
+ }
+}
+
+static void
+pattern_realize (GtkWidget *widget,
+ gpointer data)
+{
+ pattern_set_bg (widget, widget->window, 0);
+ create_pattern (widget, widget->window, 1, PATTERN_SIZE, PATTERN_SIZE);
+}
+
+static void
+create_big_windows (void)
+{
+ static GtkWidget *window = NULL;
+ GtkWidget *darea, *table, *scrollbar;
+ GtkWidget *eventbox;
+ GtkAdjustment *hadj;
+ GtkAdjustment *vadj;
+ 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_default_size (GTK_WINDOW (window), 200, 300);
+
+ gtk_signal_connect (GTK_OBJECT (window), "destroy",
+ GTK_SIGNAL_FUNC (gtk_widget_destroyed),
+ &window);
+
+ gtk_signal_connect (GTK_OBJECT (window), "response",
+ GTK_SIGNAL_FUNC (gtk_widget_destroy),
+ NULL);
+
+ table = gtk_table_new (2, 2, FALSE);
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
+ table, TRUE, TRUE, 0);
+
+ darea = gtk_drawing_area_new ();
+
+ hadj = (GtkAdjustment *)gtk_adjustment_new (0, 0, PATTERN_SIZE, 10, 100, 100);
+ gtk_signal_connect (GTK_OBJECT (hadj), "value_changed",
+ GTK_SIGNAL_FUNC (pattern_hadj_changed), darea);
+ g_object_set_data (G_OBJECT (hadj), "old-value", ¤t_x);
+
+ vadj = (GtkAdjustment *)gtk_adjustment_new (0, 0, PATTERN_SIZE, 10, 100, 100);
+ gtk_signal_connect (GTK_OBJECT (vadj), "value_changed",
+ GTK_SIGNAL_FUNC (pattern_vadj_changed), darea);
+ g_object_set_data (G_OBJECT (vadj), "old-value", ¤t_y);
+
+ gtk_signal_connect (GTK_OBJECT (darea), "realize",
+ GTK_SIGNAL_FUNC (pattern_realize),
+ NULL);
+ gtk_signal_connect (GTK_OBJECT (darea), "expose_event",
+ GTK_SIGNAL_FUNC (pattern_expose),
+ NULL);
+
+ eventbox = gtk_event_box_new ();
+ gtk_table_attach (GTK_TABLE (table), eventbox,
+ 0, 1, 0, 1,
+ GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND,
+ 0, 0);
+
+ gtk_container_add (GTK_CONTAINER (eventbox), darea);
+
+ scrollbar = gtk_hscrollbar_new (hadj);
+ gtk_table_attach (GTK_TABLE (table), scrollbar,
+ 0, 1, 1, 2,
+ GTK_FILL | GTK_EXPAND, GTK_FILL,
+ 0, 0);
+
+ scrollbar = gtk_vscrollbar_new (vadj);
+ gtk_table_attach (GTK_TABLE (table), scrollbar,
+ 1, 2, 0, 1,
+ GTK_FILL, GTK_EXPAND | GTK_FILL,
+ 0, 0);
+
+ }
+
+ if (!GTK_WIDGET_VISIBLE (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_hide (window);
+}
+
/*
* GtkButton
*/
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, 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_hseparator_new ();
+ gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
+
box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
- gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, TRUE);
+ gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window),
"Handle Box Test");
- gtk_window_set_policy (GTK_WINDOW (window),
- TRUE,
- TRUE,
- TRUE);
+ gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
NULL);
accel_group = gtk_accel_group_new ();
- gtk_accel_group_attach (accel_group, G_OBJECT (window));
+ 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);
menuitem = gtk_image_menu_item_new_with_label ("Help");
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, 5, TRUE));
- gtk_menu_item_right_justify (GTK_MENU_ITEM (menuitem));
+ gtk_menu_item_set_right_justified (GTK_MENU_ITEM (menuitem), TRUE);
gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
gtk_widget_show (menuitem);
accel_group,
GDK_F1,
0,
- GTK_ACCEL_VISIBLE | GTK_ACCEL_SIGNAL_VISIBLE);
+ 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);
GDK_F3,
0,
GTK_ACCEL_VISIBLE);
- gtk_widget_lock_accelerators (menuitem);
optionmenu = gtk_option_menu_new ();
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu);
guint callback_action,
GtkWidget *widget)
{
- gtk_item_factory_dump_items (NULL, FALSE, gtk_item_factory_print_func, stdout);
+ gtk_accel_map_save_fd (1 /* stdout */);
}
static GtkItemFactoryEntry menu_items[] =
"<main>",
item_factory,
(GtkDestroyNotify) gtk_object_unref);
- gtk_accel_group_attach (accel_group, G_OBJECT (window));
+ gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
gtk_window_set_title (GTK_WINDOW (window), "Item Factory");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_item_factory_create_items (item_factory, nmenu_items, menu_items, NULL);
gtk_widget_set_sensitive (entry, GTK_TOGGLE_BUTTON(checkbutton)->active);
}
+static void
+entry_props_clicked (GtkWidget *button,
+ GObject *entry)
+{
+ GtkWidget *window = create_prop_editor (entry, 0);
+
+ gtk_window_set_title (GTK_WINDOW (window), "Entry Properties");
+}
+
static void
create_entry (void)
{
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);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (entry_props_clicked),
+ entry);
+
cb = gtk_combo_new ();
gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems);
gtk_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world \n\n\n foo");
gtk_list_clear_items (GTK_LIST (list), 0, -1);
}
-#define RADIOMENUTOGGLED(_rmi_, __i) { \
- GSList * __g; \
- __i = 0; \
- __g = gtk_radio_menu_item_group(_rmi_); \
- while( __g && !((GtkCheckMenuItem *)(__g->data))->active) { \
- __g = __g->next; \
- __i++; \
- }\
-}
-
static GtkWidget *list_omenu;
static void
-list_toggle_sel_mode (GtkWidget *widget, GtkList *list)
+list_toggle_sel_mode (GtkWidget *widget, gpointer data)
{
+ GtkList *list;
gint i;
+ list = GTK_LIST (data);
+
if (!GTK_WIDGET_MAPPED (widget))
return;
- RADIOMENUTOGGLED ((GtkRadioMenuItem *)
- (((GtkOptionMenu *)list_omenu)->menu_item), i);
+ i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
- gtk_list_set_selection_mode (list, (GtkSelectionMode) (3-i));
+ gtk_list_set_selection_mode (list, (GtkSelectionMode) i);
}
static void
{
static GtkWidget *window = NULL;
- static OptionMenuItem items[] =
+ static gchar *items[] =
{
- { "Single", GTK_SIGNAL_FUNC (list_toggle_sel_mode) },
- { "Browse", GTK_SIGNAL_FUNC (list_toggle_sel_mode) },
- { "Multiple", GTK_SIGNAL_FUNC (list_toggle_sel_mode) },
- { "Extended", GTK_SIGNAL_FUNC (list_toggle_sel_mode) }
+ "Single",
+ "Browse",
+ "Multiple"
};
if (!window)
label = gtk_label_new ("Selection Mode :");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
- list_omenu = build_option_menu (items, 4, 3, list);
+ list_omenu = build_option_menu (items, 3, 3,
+ list_toggle_sel_mode,
+ list);
gtk_box_pack_start (GTK_BOX (hbox), list_omenu, FALSE, TRUE, 0);
separator = gtk_hseparator_new ();
}
static void
-clist_toggle_sel_mode (GtkWidget *widget, GtkCList *clist)
+clist_toggle_sel_mode (GtkWidget *widget, gpointer data)
{
+ GtkCList *clist;
gint i;
+ clist = GTK_CLIST (data);
+
if (!GTK_WIDGET_MAPPED (widget))
return;
- RADIOMENUTOGGLED ((GtkRadioMenuItem *)
- (((GtkOptionMenu *)clist_omenu)->menu_item), i);
+ i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
- gtk_clist_set_selection_mode (clist, (GtkSelectionMode) (3-i));
+ gtk_clist_set_selection_mode (clist, (GtkSelectionMode) i);
}
static void
"Title 8", "Title 9", "Title 10", "Title 11"
};
- static OptionMenuItem items[] =
+ static gchar *items[] =
{
- { "Single", GTK_SIGNAL_FUNC (clist_toggle_sel_mode) },
- { "Browse", GTK_SIGNAL_FUNC (clist_toggle_sel_mode) },
- { "Multiple", GTK_SIGNAL_FUNC (clist_toggle_sel_mode) },
- { "Extended", GTK_SIGNAL_FUNC (clist_toggle_sel_mode) }
+ "Single",
+ "Browse",
+ "Multiple",
};
char text[TESTGTK_CLIST_COLUMNS][50];
label = gtk_label_new ("Selection Mode :");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
- clist_omenu = build_option_menu (items, 4, 3, clist);
+ clist_omenu = build_option_menu (items, 3, 3,
+ clist_toggle_sel_mode,
+ clist);
gtk_box_pack_start (GTK_BOX (hbox), clist_omenu, FALSE, TRUE, 0);
/*
style->fg[GTK_STATE_NORMAL] = col1;
style->base[GTK_STATE_NORMAL] = col2;
- style->font_desc->size = 14 * PANGO_SCALE;
- style->font_desc->weight = PANGO_WEIGHT_BOLD;
+ pango_font_description_set_size (style->font_desc, 14 * PANGO_SCALE);
+ pango_font_description_set_weight (style->font_desc, PANGO_WEIGHT_BOLD);
for (i = 0; i < 10; i++)
{
gtk_ctree_node_set_row_style (ctree, node, style);
}
-void ctree_toggle_line_style (GtkWidget *widget, GtkCTree *ctree)
+void
+ctree_toggle_line_style (GtkWidget *widget, gpointer data)
{
+ GtkCTree *ctree;
gint i;
+ ctree = GTK_CTREE (data);
+
if (!GTK_WIDGET_MAPPED (widget))
return;
- RADIOMENUTOGGLED ((GtkRadioMenuItem *)
- (((GtkOptionMenu *)omenu1)->menu_item), i);
-
+ i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
+
if ((ctree->line_style == GTK_CTREE_LINES_TABBED &&
- ((GtkCTreeLineStyle) (3 - i)) != GTK_CTREE_LINES_TABBED) ||
+ ((GtkCTreeLineStyle) i) != GTK_CTREE_LINES_TABBED) ||
(ctree->line_style != GTK_CTREE_LINES_TABBED &&
- ((GtkCTreeLineStyle) (3 - i)) == GTK_CTREE_LINES_TABBED))
+ ((GtkCTreeLineStyle) i) == GTK_CTREE_LINES_TABBED))
gtk_ctree_pre_recursive (ctree, NULL, set_background, NULL);
- gtk_ctree_set_line_style (ctree, 3 - i);
- line_style = 3 - i;
+ gtk_ctree_set_line_style (ctree, i);
+ line_style = i;
}
-void ctree_toggle_expander_style (GtkWidget *widget, GtkCTree *ctree)
+void
+ctree_toggle_expander_style (GtkWidget *widget, gpointer data)
{
+ GtkCTree *ctree;
gint i;
+ ctree = GTK_CTREE (data);
+
if (!GTK_WIDGET_MAPPED (widget))
return;
-
- RADIOMENUTOGGLED ((GtkRadioMenuItem *)
- (((GtkOptionMenu *)omenu2)->menu_item), i);
- gtk_ctree_set_expander_style (ctree, (GtkCTreeExpanderStyle) (3 - i));
+ i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
+
+ gtk_ctree_set_expander_style (ctree, (GtkCTreeExpanderStyle) i);
}
-void ctree_toggle_justify (GtkWidget *widget, GtkCTree *ctree)
+void
+ctree_toggle_justify (GtkWidget *widget, gpointer data)
{
+ GtkCTree *ctree;
gint i;
+ ctree = GTK_CTREE (data);
+
if (!GTK_WIDGET_MAPPED (widget))
return;
- RADIOMENUTOGGLED ((GtkRadioMenuItem *)
- (((GtkOptionMenu *)omenu3)->menu_item), i);
+ i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
gtk_clist_set_column_justification (GTK_CLIST (ctree), ctree->tree_column,
- (GtkJustification) (1 - i));
+ (GtkJustification) i);
}
-void ctree_toggle_sel_mode (GtkWidget *widget, GtkCTree *ctree)
+void
+ctree_toggle_sel_mode (GtkWidget *widget, gpointer data)
{
+ GtkCTree *ctree;
gint i;
+ ctree = GTK_CTREE (data);
+
if (!GTK_WIDGET_MAPPED (widget))
return;
- RADIOMENUTOGGLED ((GtkRadioMenuItem *)
- (((GtkOptionMenu *)omenu4)->menu_item), i);
+ i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
- gtk_clist_set_selection_mode (GTK_CLIST (ctree), (GtkSelectionMode) (3 - i));
+ gtk_clist_set_selection_mode (GTK_CLIST (ctree), (GtkSelectionMode) i);
after_press (ctree, NULL);
}
char *title[] = { "Tree" , "Info" };
char buf[80];
- static OptionMenuItem items1[] =
+ static gchar *items1[] =
{
- { "No lines", GTK_SIGNAL_FUNC (ctree_toggle_line_style) },
- { "Solid", GTK_SIGNAL_FUNC (ctree_toggle_line_style) },
- { "Dotted", GTK_SIGNAL_FUNC (ctree_toggle_line_style) },
- { "Tabbed", GTK_SIGNAL_FUNC (ctree_toggle_line_style) }
+ "No lines",
+ "Solid",
+ "Dotted",
+ "Tabbed"
};
- static OptionMenuItem items2[] =
+ static gchar *items2[] =
{
- { "None", GTK_SIGNAL_FUNC (ctree_toggle_expander_style) },
- { "Square", GTK_SIGNAL_FUNC (ctree_toggle_expander_style) },
- { "Triangle", GTK_SIGNAL_FUNC (ctree_toggle_expander_style) },
- { "Circular", GTK_SIGNAL_FUNC (ctree_toggle_expander_style) }
+ "None",
+ "Square",
+ "Triangle",
+ "Circular"
};
- static OptionMenuItem items3[] =
+ static gchar *items3[] =
{
- { "Left", GTK_SIGNAL_FUNC (ctree_toggle_justify) },
- { "Right", GTK_SIGNAL_FUNC (ctree_toggle_justify) }
+ "Left",
+ "Right"
};
-
- static OptionMenuItem items4[] =
+
+ static gchar *items4[] =
{
- { "Single", GTK_SIGNAL_FUNC (ctree_toggle_sel_mode) },
- { "Browse", GTK_SIGNAL_FUNC (ctree_toggle_sel_mode) },
- { "Multiple", GTK_SIGNAL_FUNC (ctree_toggle_sel_mode) },
- { "Extended", GTK_SIGNAL_FUNC (ctree_toggle_sel_mode) }
+ "Single",
+ "Browse",
+ "Multiple",
};
if (!window)
hbox = gtk_hbox_new (TRUE, 5);
gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
- omenu1 = build_option_menu (items1, 4, 2, ctree);
+ omenu1 = build_option_menu (items1, 4, 2,
+ ctree_toggle_line_style,
+ ctree);
gtk_box_pack_start (GTK_BOX (hbox), omenu1, FALSE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, omenu1, "The tree's line style.", NULL);
- omenu2 = build_option_menu (items2, 4, 1, ctree);
+ omenu2 = build_option_menu (items2, 4, 1,
+ ctree_toggle_expander_style,
+ ctree);
gtk_box_pack_start (GTK_BOX (hbox), omenu2, FALSE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, omenu2, "The tree's expander style.",
NULL);
- omenu3 = build_option_menu (items3, 2, 0, ctree);
+ omenu3 = build_option_menu (items3, 2, 0,
+ ctree_toggle_justify, ctree);
gtk_box_pack_start (GTK_BOX (hbox), omenu3, FALSE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, omenu3, "The tree's justification.",
NULL);
- omenu4 = build_option_menu (items4, 4, 3, ctree);
+ omenu4 = build_option_menu (items4, 3, 3,
+ ctree_toggle_sel_mode, ctree);
gtk_box_pack_start (GTK_BOX (hbox), omenu4, FALSE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, omenu4, "The list's selection mode.",
NULL);
adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
- gtk_widget_set_usize (GTK_WIDGET (scale), 150, 30);
+ gtk_widget_set_usize (GTK_WIDGET (scale), 150, -1);
gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
gtk_scale_set_digits (GTK_SCALE (scale), 1);
gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
}
static void
-standard_notebook (GtkButton *button,
- GtkNotebook *notebook)
+notebook_type_changed (GtkWidget *optionmenu,
+ gpointer data)
{
- gint i;
+ GtkNotebook *notebook;
+ gint i, c;
- gtk_notebook_set_show_tabs (notebook, TRUE);
- gtk_notebook_set_show_border (notebook, TRUE);
- gtk_notebook_set_scrollable (notebook, FALSE);
- if (g_list_length (notebook->children) == 15)
- for (i = 0; i < 10; i++)
- gtk_notebook_remove_page (notebook, 5);
-}
+ enum {
+ STANDARD,
+ NOTABS,
+ BORDERLESS,
+ SCROLLABLE
+ };
-static void
-notabs_notebook (GtkButton *button,
- GtkNotebook *notebook)
-{
- gint i;
+ notebook = GTK_NOTEBOOK (data);
- gtk_notebook_set_show_tabs (notebook, FALSE);
- gtk_notebook_set_show_border (notebook, TRUE);
- if (g_list_length (notebook->children) == 15)
- for (i = 0; i < 10; i++)
- gtk_notebook_remove_page (notebook, 5);
-}
+ c = gtk_option_menu_get_history (GTK_OPTION_MENU (optionmenu));
-static void
-borderless_notebook (GtkButton *button,
- GtkNotebook *notebook)
-{
- gint i;
+ 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;
- gtk_notebook_set_show_tabs (notebook, FALSE);
- gtk_notebook_set_show_border (notebook, FALSE);
+ 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 (g_list_length (notebook->children) == 5)
+ create_pages (notebook, 6, 15);
+
+ return;
+ break;
+ }
+
if (g_list_length (notebook->children) == 15)
for (i = 0; i < 10; i++)
gtk_notebook_remove_page (notebook, 5);
}
-static void
-scrollable_notebook (GtkButton *button,
- GtkNotebook *notebook)
-{
- gtk_notebook_set_show_tabs (notebook, TRUE);
- gtk_notebook_set_show_border (notebook, TRUE);
- gtk_notebook_set_scrollable (notebook, TRUE);
- if (g_list_length (notebook->children) == 5)
- create_pages (notebook, 6, 15);
-}
-
static void
notebook_popup (GtkToggleButton *button,
GtkNotebook *notebook)
GdkColor *transparent = NULL;
GtkWidget *label;
- static OptionMenuItem items[] =
+ static gchar *items[] =
{
- { "Standard", GTK_SIGNAL_FUNC (standard_notebook) },
- { "No tabs", GTK_SIGNAL_FUNC (notabs_notebook) },
- { "Borderless", GTK_SIGNAL_FUNC (borderless_notebook) },
- { "Scrollable", GTK_SIGNAL_FUNC (scrollable_notebook) },
+ "Standard",
+ "No tabs",
+ "Borderless",
+ "Scrollable"
};
if (!window)
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, sample_notebook);
+ 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_widget_unref (child);
}
+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,
GtkWidget *frame;
GtkWidget *table;
GtkWidget *label;
+ GtkWidget *button;
GtkWidget *check_button;
frame = gtk_frame_new (frame_label);
GTK_SIGNAL_FUNC (toggle_shrink),
paned->child2);
+ button = gtk_button_new_with_mnemonic ("_Properties");
+ gtk_table_attach_defaults (GTK_TABLE (table), button,
+ 0, 2, 3, 4);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (paned_props_clicked),
+ paned);
+
return frame;
}
GtkWidget *button;
hbox = gtk_hbox_new (FALSE, 5);
-
+
gtk_signal_connect_object (GTK_OBJECT (hbox),
"destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (window));
-
+
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);
gtk_container_add (GTK_CONTAINER (window), box1);
iconified = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_signal_connect_object (GTK_OBJECT (iconified), "destroy",
+ GTK_SIGNAL_FUNC(gtk_widget_destroy),
+ GTK_OBJECT (window));
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_signal_connect_object (GTK_OBJECT (normal), "destroy",
+ GTK_SIGNAL_FUNC(gtk_widget_destroy),
+ GTK_OBJECT (window));
+
gtk_window_set_title (GTK_WINDOW (normal), "Deiconified initially");
controls = get_state_controls (normal);
gtk_container_add (GTK_CONTAINER (normal), controls);
}
static void
-progressbar_toggle_orientation (GtkWidget *widget, ProgressData *pdata)
+progressbar_toggle_orientation (GtkWidget *widget, gpointer data)
{
+ ProgressData *pdata;
gint i;
+ pdata = (ProgressData *) data;
+
if (!GTK_WIDGET_MAPPED (widget))
return;
- RADIOMENUTOGGLED ((GtkRadioMenuItem *)
- (((GtkOptionMenu *)(pdata->omenu1))->menu_item), i);
+ i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (pdata->pbar),
- (GtkProgressBarOrientation) (3-i));
+ (GtkProgressBarOrientation) i);
}
static void
}
static void
-progressbar_toggle_bar_style (GtkWidget *widget, ProgressData *pdata)
+progressbar_toggle_bar_style (GtkWidget *widget, gpointer data)
{
+ ProgressData *pdata;
gint i;
+ pdata = (ProgressData *) data;
+
if (!GTK_WIDGET_MAPPED (widget))
return;
- RADIOMENUTOGGLED ((GtkRadioMenuItem *)
- (((GtkOptionMenu *)(pdata->omenu2))->menu_item), i);
-
- i = 1 - i;
+ i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
if (i == 1)
gtk_widget_set_sensitive (pdata->block_spin, TRUE);
else
gtk_widget_set_sensitive (pdata->block_spin, FALSE);
-
+
gtk_progress_bar_set_bar_style (GTK_PROGRESS_BAR (pdata->pbar),
(GtkProgressBarStyle) i);
}
GtkAdjustment *adj;
static ProgressData *pdata = NULL;
- static OptionMenuItem items1[] =
+ static gchar *items1[] =
{
- { "Left-Right", GTK_SIGNAL_FUNC (progressbar_toggle_orientation) },
- { "Right-Left", GTK_SIGNAL_FUNC (progressbar_toggle_orientation) },
- { "Bottom-Top", GTK_SIGNAL_FUNC (progressbar_toggle_orientation) },
- { "Top-Bottom", GTK_SIGNAL_FUNC (progressbar_toggle_orientation) }
+ "Left-Right",
+ "Right-Left",
+ "Bottom-Top",
+ "Top-Bottom"
};
- static OptionMenuItem items2[] =
+ static gchar *items2[] =
{
- { "Continuous", GTK_SIGNAL_FUNC (progressbar_toggle_bar_style) },
- { "Discrete", GTK_SIGNAL_FUNC (progressbar_toggle_bar_style) }
+ "Continuous",
+ "Discrete"
};
if (!pdata)
5, 5);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
- pdata->omenu1 = build_option_menu (items1, 4, 0, pdata);
+ pdata->omenu1 = build_option_menu (items1, 4, 0,
+ progressbar_toggle_orientation,
+ pdata);
hbox = gtk_hbox_new (FALSE, 0);
gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
5, 5);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
- pdata->omenu2 = build_option_menu (items2, 2, 0, pdata);
+ pdata->omenu2 = build_option_menu (items2, 2, 0,
+ progressbar_toggle_bar_style,
+ pdata);
hbox = gtk_hbox_new (FALSE, 0);
gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 3, 4,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
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;
+
+ new_allocation = widget->allocation;
+
+ if (data->found || !GTK_WIDGET_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_NO_WINDOW (widget))
+ {
+ new_allocation.x = 0;
+ new_allocation.y = 0;
+ }
+
+ if (widget->parent && !data->first)
+ {
+ GdkWindow *window = widget->window;
+ while (window != widget->parent->window)
+ {
+ gint tx, ty, twidth, theight;
+ gdk_window_get_size (window, &twidth, &theight);
+
+ 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 (void)
+{
+ GtkWidget *widget = NULL;
+ GdkWindow *pointer_window;
+ gint x, y;
+ FindWidgetData data;
+
+ pointer_window = gdk_window_at_pointer (NULL, NULL);
+
+ if (pointer_window)
+ gdk_window_get_user_data (pointer_window, (gpointer*) &widget);
+
+ if (widget)
+ {
+ gdk_window_get_pointer (widget->window,
+ &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;
+ gint handler;
+};
+
+static void
+destroy_properties (GtkWidget *widget,
+ struct PropertiesData *data)
+{
+ if (data->window)
+ {
+ *data->window = NULL;
+ data->window = NULL;
+ }
+
+ if (data->cursor)
+ {
+ gdk_cursor_destroy (data->cursor);
+ data->cursor = NULL;
+ }
+
+ if (data->handler)
+ {
+ gtk_signal_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_pointer_ungrab (GDK_CURRENT_TIME);
+
+ res_widget = find_widget_at_pointer ();
+ if (res_widget)
+ create_prop_editor (G_OBJECT (res_widget), 0);
+
+ data->in_query = FALSE;
+ }
+ return FALSE;
+}
+
+
+static void
+query_properties (GtkButton *button,
+ struct PropertiesData *data)
+{
+ gint failure;
+
+ gtk_signal_connect (GTK_OBJECT (button), "event",
+ (GtkSignalFunc) property_query_event, data);
+
+
+ if (!data->cursor)
+ data->cursor = gdk_cursor_new (GDK_TARGET);
+
+ failure = gdk_pointer_grab (GTK_WIDGET (button)->window,
+ TRUE,
+ GDK_BUTTON_RELEASE_MASK,
+ NULL,
+ data->cursor,
+ GDK_CURRENT_TIME);
+
+ gtk_grab_add (GTK_WIDGET (button));
+
+ data->in_query = TRUE;
+}
+
+static void
+create_properties (void)
+{
+ 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);
+
+ data->handler = gtk_signal_connect (GTK_OBJECT (window), "destroy",
+ GTK_SIGNAL_FUNC(destroy_properties),
+ data);
+
+ gtk_window_set_title (GTK_WINDOW (window), "test properties");
+ gtk_container_set_border_width (GTK_CONTAINER (window), 10);
+
+ vbox = gtk_vbox_new (FALSE, 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);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC(query_properties),
+ data);
+ }
+
+ if (!GTK_WIDGET_VISIBLE (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_destroy (window);
+
+}
+
+
/*
* Color Preview
*/
if (!window)
{
+ GtkWidget *button2;
GtkWidget *frame;
GtkWidget *box;
NULL),
"signal::clicked", toggle_idle_container, container,
NULL);
- button =
- g_object_connect (gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
- "label", "Resize-Queue",
- "user_data", (void*)GTK_RESIZE_QUEUE,
- "group", button,
- "visible", TRUE,
- "parent", box,
- NULL),
- "signal::clicked", toggle_idle_container, container,
- NULL);
- button =
- g_object_set (g_object_connect (gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
- "label", "Resize-Immediate",
- "user_data", (void*)GTK_RESIZE_IMMEDIATE,
- NULL),
- "signal::clicked", toggle_idle_container, container,
- NULL),
- "group", button,
- "visible", TRUE,
- "parent", box,
- NULL);
+ button = gtk_widget_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 = gtk_widget_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");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
rc_style = gtk_rc_style_new ();
- rc_style->font_desc = font_desc;
+ 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;
gboolean do_not_benchmark;
} buttons[] =
{
+ { "big windows", create_big_windows },
{ "button box", create_button_box },
{ "buttons", create_buttons },
{ "check buttons", create_check_buttons },
{ "preview color", create_color_preview, TRUE },
{ "preview gray", create_gray_preview, TRUE },
{ "progress bar", create_progress_bar },
+ { "properties", create_properties },
{ "radio buttons", create_radio_buttons },
{ "range controls", create_range_controls },
{ "rc file", create_rc_file },
srand (time (NULL));
test_init ();
- gtk_set_locale ();
/* Check to see if we are being run from the correct
* directory.