* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
+
+/*
+ * Modified by the GTK+ Team and others 1997-1999. 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/.
+ */
+
+#undef G_LOG_DOMAIN
+
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <sys/stat.h>
#include <math.h>
#include <time.h>
+#include <unistd.h>
#include "gtk.h"
-#include "../gdk/gdk.h"
-#include "../gdk/gdkx.h"
-#include "../gdk/gdkkeysyms.h"
+#include "gdk/gdk.h"
+#include "gdk/gdkkeysyms.h"
+#include "gdkx.h"
#include "circles.xbm"
-GtkWidget *shape_create_icon (char *xpm_file,
- gint x,
- gint y,
- gint px,
- gint py,
- gint window_type);
+typedef struct _OptionMenuItem
+{
+ gchar *name;
+ GtkSignalFunc func;
+} OptionMenuItem;
+
+GtkWidget *
+shape_create_icon (char *xpm_file,
+ gint x,
+ gint y,
+ gint px,
+ gint py,
+ gint window_type);
+
+static GtkWidget *
+build_option_menu (OptionMenuItem items[],
+ gint num_items,
+ gint history,
+ gpointer data);
/* macro, structure and variables used by tree window demos */
#define DEFAULT_NUMBER_OF_ITEM 3
} sTreeButtons;
/* end of tree section */
+static GtkWidget *
+build_option_menu (OptionMenuItem items[],
+ gint num_items,
+ gint history,
+ gpointer data)
+{
+ GtkWidget *omenu;
+ GtkWidget *menu;
+ GtkWidget *menu_item;
+ GSList *group;
+ gint i;
+
+ omenu = gtk_option_menu_new ();
+
+ 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);
+ group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
+ gtk_menu_append (GTK_MENU (menu), menu_item);
+ if (i == history)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
+ gtk_widget_show (menu_item);
+ }
+
+ gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
+ gtk_option_menu_set_history (GTK_OPTION_MENU (omenu), history);
+
+ return omenu;
+}
+
static void
destroy_tooltips (GtkWidget *widget, GtkWindow **window)
{
GtkTooltips *tt = gtk_object_get_data (GTK_OBJECT (*window), "tooltips");
gtk_object_unref (GTK_OBJECT (tt));
-
*window = NULL;
}
+/*
+ * GtkButton
+ */
+
static void
button_window (GtkWidget *widget,
GtkWidget *button)
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
&window);
- gtk_window_set_title (GTK_WINDOW (window), "buttons");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
+ gtk_window_set_title (GTK_WINDOW (window), "GtkButton");
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
- gtk_widget_show (box1);
-
table = gtk_table_new (3, 3, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 5);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
- gtk_container_border_width (GTK_CONTAINER (table), 10);
+ gtk_container_set_border_width (GTK_CONTAINER (table), 10);
gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
- gtk_widget_show (table);
-
button[0] = gtk_button_new_with_label ("button1");
button[1] = gtk_button_new_with_label ("button2");
gtk_table_attach (GTK_TABLE (table), button[0], 0, 1, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
- gtk_widget_show (button[0]);
gtk_signal_connect (GTK_OBJECT (button[1]), "clicked",
GTK_SIGNAL_FUNC(button_window),
gtk_table_attach (GTK_TABLE (table), button[1], 1, 2, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
- gtk_widget_show (button[1]);
gtk_signal_connect (GTK_OBJECT (button[2]), "clicked",
GTK_SIGNAL_FUNC(button_window),
button[3]);
gtk_table_attach (GTK_TABLE (table), button[2], 2, 3, 2, 3,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
- gtk_widget_show (button[2]);
gtk_signal_connect (GTK_OBJECT (button[3]), "clicked",
GTK_SIGNAL_FUNC(button_window),
button[4]);
gtk_table_attach (GTK_TABLE (table), button[3], 0, 1, 2, 3,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
- gtk_widget_show (button[3]);
gtk_signal_connect (GTK_OBJECT (button[4]), "clicked",
GTK_SIGNAL_FUNC(button_window),
button[5]);
gtk_table_attach (GTK_TABLE (table), button[4], 2, 3, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
- gtk_widget_show (button[4]);
gtk_signal_connect (GTK_OBJECT (button[5]), "clicked",
GTK_SIGNAL_FUNC(button_window),
button[6]);
gtk_table_attach (GTK_TABLE (table), button[5], 1, 2, 2, 3,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
- gtk_widget_show (button[5]);
gtk_signal_connect (GTK_OBJECT (button[6]), "clicked",
GTK_SIGNAL_FUNC(button_window),
button[7]);
gtk_table_attach (GTK_TABLE (table), button[6], 1, 2, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
- gtk_widget_show (button[6]);
gtk_signal_connect (GTK_OBJECT (button[7]), "clicked",
GTK_SIGNAL_FUNC(button_window),
button[8]);
gtk_table_attach (GTK_TABLE (table), button[7], 2, 3, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
- gtk_widget_show (button[7]);
gtk_signal_connect (GTK_OBJECT (button[8]), "clicked",
GTK_SIGNAL_FUNC(button_window),
button[0]);
gtk_table_attach (GTK_TABLE (table), button[8], 0, 1, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
- gtk_widget_show (button[8]);
-
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
- gtk_widget_show (separator);
-
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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[9] = gtk_button_new_with_label ("close");
gtk_signal_connect_object (GTK_OBJECT (button[9]), "clicked",
gtk_box_pack_start (GTK_BOX (box2), button[9], TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button[9], GTK_CAN_DEFAULT);
gtk_widget_grab_default (button[9]);
- gtk_widget_show (button[9]);
}
if (!GTK_WIDGET_VISIBLE (window))
- gtk_widget_show (window);
+ gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
+/*
+ * GtkToggleButton
+ */
+
static void
create_toggle_buttons (void)
{
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
- gtk_window_set_title (GTK_WINDOW (window), "toggle buttons");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
-
+ gtk_window_set_title (GTK_WINDOW (window), "GtkToggleButton");
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
- gtk_widget_show (box1);
-
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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);
-
button = gtk_toggle_button_new_with_label ("button1");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- gtk_widget_show (button);
button = gtk_toggle_button_new_with_label ("button2");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- gtk_widget_show (button);
button = gtk_toggle_button_new_with_label ("button3");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- gtk_widget_show (button);
-
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
- gtk_widget_show (separator);
-
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
- gtk_widget_show (button);
}
if (!GTK_WIDGET_VISIBLE (window))
- gtk_widget_show (window);
+ gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
+/*
+ * GtkCheckButton
+ */
+
static void
create_check_buttons (void)
{
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
- gtk_window_set_title (GTK_WINDOW (window), "check buttons");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
-
+ gtk_window_set_title (GTK_WINDOW (window), "GtkCheckButton");
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
- gtk_widget_show (box1);
-
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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);
-
button = gtk_check_button_new_with_label ("button1");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- gtk_widget_show (button);
button = gtk_check_button_new_with_label ("button2");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- gtk_widget_show (button);
button = gtk_check_button_new_with_label ("button3");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- gtk_widget_show (button);
-
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
- gtk_widget_show (separator);
-
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
- gtk_widget_show (button);
}
if (!GTK_WIDGET_VISIBLE (window))
- gtk_widget_show (window);
+ gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
+/*
+ * GtkRadioButton
+ */
+
static void
create_radio_buttons (void)
{
&window);
gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
-
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
- gtk_widget_show (box1);
-
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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);
-
button = gtk_radio_button_new_with_label (NULL, "button1");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- gtk_widget_show (button);
button = gtk_radio_button_new_with_label (
gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
"button2");
- gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- gtk_widget_show (button);
button = gtk_radio_button_new_with_label (
gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
"button3");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- gtk_widget_show (button);
-
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
- gtk_widget_show (separator);
-
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
- gtk_widget_show (button);
}
if (!GTK_WIDGET_VISIBLE (window))
- gtk_widget_show (window);
+ gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
-static void
-bbox_widget_destroy (GtkWidget* widget, GtkWidget* todestroy)
-{
-}
+/*
+ * GtkButtonBox
+ */
-static void
-create_bbox_window (gint horizontal,
- char* title,
- gint pos,
- gint spacing,
- gint child_w,
- gint child_h,
- gint layout)
+static GtkWidget *
+create_bbox (gint horizontal,
+ char* title,
+ gint spacing,
+ gint child_w,
+ gint child_h,
+ gint layout)
{
- GtkWidget* window;
- GtkWidget* box1;
- GtkWidget* bbox;
- GtkWidget* button;
+ GtkWidget *frame;
+ GtkWidget *bbox;
+ GtkWidget *button;
- /* create a new window */
- window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), title);
+ frame = gtk_frame_new (title);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(bbox_widget_destroy), window);
-
- if (horizontal)
- {
- gtk_widget_set_usize (window, 550, 60);
- gtk_widget_set_uposition (window, 150, pos);
- box1 = gtk_vbox_new (FALSE, 0);
- }
- else
- {
- gtk_widget_set_usize (window, 150, 400);
- gtk_widget_set_uposition (window, pos, 200);
- box1 = gtk_vbox_new (FALSE, 0);
- }
-
- gtk_container_add (GTK_CONTAINER (window), box1);
- gtk_widget_show (box1);
-
if (horizontal)
- bbox = gtk_hbutton_box_new();
+ bbox = gtk_hbutton_box_new ();
else
- bbox = gtk_vbutton_box_new();
+ bbox = gtk_vbutton_box_new ();
+
+ 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_button_box_set_spacing (GTK_BUTTON_BOX (bbox), spacing);
gtk_button_box_set_child_size (GTK_BUTTON_BOX (bbox), child_w, child_h);
- gtk_widget_show (bbox);
-
- gtk_container_border_width (GTK_CONTAINER(box1), 25);
- gtk_box_pack_start (GTK_BOX (box1), bbox, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("OK");
- gtk_container_add (GTK_CONTAINER(bbox), button);
-
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(bbox_widget_destroy), window);
-
- gtk_widget_show (button);
+ gtk_container_add (GTK_CONTAINER (bbox), button);
button = gtk_button_new_with_label ("Cancel");
- gtk_container_add (GTK_CONTAINER(bbox), button);
- gtk_widget_show (button);
+ gtk_container_add (GTK_CONTAINER (bbox), button);
button = gtk_button_new_with_label ("Help");
- gtk_container_add (GTK_CONTAINER(bbox), button);
- gtk_widget_show (button);
-
- gtk_widget_show (window);
-}
+ gtk_container_add (GTK_CONTAINER (bbox), button);
-static void
-test_hbbox (void)
-{
- create_bbox_window (TRUE, "Spread", 50, 40, 85, 28, GTK_BUTTONBOX_SPREAD);
- create_bbox_window (TRUE, "Edge", 200, 40, 85, 25, GTK_BUTTONBOX_EDGE);
- create_bbox_window (TRUE, "Start", 350, 40, 85, 25, GTK_BUTTONBOX_START);
- create_bbox_window (TRUE, "End", 500, 15, 30, 25, GTK_BUTTONBOX_END);
+ return frame;
}
-static void
-test_vbbox (void)
-{
- create_bbox_window (FALSE, "Spread", 50, 40, 85, 25, GTK_BUTTONBOX_SPREAD);
- create_bbox_window (FALSE, "Edge", 250, 40, 85, 28, GTK_BUTTONBOX_EDGE);
- create_bbox_window (FALSE, "Start", 450, 40, 85, 25, GTK_BUTTONBOX_START);
- create_bbox_window (FALSE, "End", 650, 15, 30, 25, GTK_BUTTONBOX_END);
-}
-
static void
create_button_box (void)
{
static GtkWidget* window = NULL;
- GtkWidget* bbox;
- GtkWidget* button;
+ 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_title (GTK_WINDOW (window),
- "Button Box Test");
+ gtk_window_set_title (GTK_WINDOW (window), "Button Boxes");
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
- gtk_container_border_width (GTK_CONTAINER (window), 20);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 10);
+
+ main_vbox = gtk_vbox_new (FALSE, 0);
+ gtk_container_add (GTK_CONTAINER (window), main_vbox);
- /*
- *these 15 lines are a nice and easy example for GtkHButtonBox
- */
- bbox = gtk_hbutton_box_new ();
- gtk_container_add (GTK_CONTAINER (window), bbox);
- gtk_widget_show (bbox);
+ frame_horz = gtk_frame_new ("Horizontal Button Boxes");
+ gtk_box_pack_start (GTK_BOX (main_vbox), frame_horz, TRUE, TRUE, 10);
- button = gtk_button_new_with_label ("Horizontal");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(test_hbbox), 0);
- gtk_container_add (GTK_CONTAINER (bbox), button);
- gtk_widget_show (button);
+ vbox = gtk_vbox_new (FALSE, 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);
+
+ frame_vert = gtk_frame_new ("Vertical Button Boxes");
+ gtk_box_pack_start (GTK_BOX (main_vbox), frame_vert, TRUE, TRUE, 10);
- button = gtk_button_new_with_label ("Vertical");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(test_vbbox), 0);
- gtk_container_add (GTK_CONTAINER (bbox), button);
- gtk_widget_show (button);
+ hbox = gtk_hbox_new (FALSE, 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);
}
if (!GTK_WIDGET_VISIBLE (window))
- gtk_widget_show (window);
+ gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
+/*
+ * GtkToolBar
+ */
+
static GtkWidget*
new_pixmap (char *filename,
GdkWindow *window,
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_small_space (GtkWidget *widget,
gpointer data)
gtk_toolbar_set_button_relief (GTK_TOOLBAR (data), GTK_RELIEF_NONE);
}
+static void
+set_toolbar_space_style_empty (GtkWidget *widget,
+ gpointer data)
+{
+ gtk_toolbar_set_space_style (GTK_TOOLBAR (data), GTK_TOOLBAR_SPACE_EMPTY);
+}
+
+static void
+set_toolbar_space_style_line (GtkWidget *widget,
+ gpointer data)
+{
+ gtk_toolbar_set_space_style (GTK_TOOLBAR (data), GTK_TOOLBAR_SPACE_LINE);
+}
+
static void
create_toolbar (void)
{
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
&window);
- gtk_container_border_width (GTK_CONTAINER (window), 0);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_widget_realize (window);
toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
"Both", "Show toolbar icons and text", "Toolbar/Both",
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
(GtkSignalFunc) set_toolbar_both, toolbar);
-
+ gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
+ "Both (horizontal)",
+ "Show toolbar icons and text in a horizontal fashion",
+ "Toolbar/BothHoriz",
+ new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
+ (GtkSignalFunc) set_toolbar_both_horiz, toolbar);
+
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
entry = gtk_entry_new ();
- gtk_widget_show(entry);
+
gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar), entry, "This is an unusable GtkEntry ;)", "Hey don't click me!!!");
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
(GtkSignalFunc) set_toolbar_borderless, toolbar);
+ gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
+
+ gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
+ "Empty", "Empty spaces", NULL,
+ new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
+ (GtkSignalFunc) set_toolbar_space_style_empty, toolbar);
+ gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
+ "Lines", "Lines in spaces", NULL,
+ new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
+ (GtkSignalFunc) set_toolbar_space_style_line, toolbar);
+
gtk_container_add (GTK_CONTAINER (window), toolbar);
- gtk_widget_show (toolbar);
}
if (!GTK_WIDGET_VISIBLE (window))
- gtk_widget_show (window);
+ gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
return toolbar;
}
+/*
+ * GtkStatusBar
+ */
+
static guint statusbar_counter = 1;
static void
&window);
gtk_window_set_title (GTK_WINDOW (window), "statusbar");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
-
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
- gtk_widget_show (box1);
-
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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);
statusbar = gtk_statusbar_new ();
gtk_box_pack_end (GTK_BOX (box1), statusbar, TRUE, TRUE, 0);
- gtk_widget_show (statusbar);
gtk_signal_connect (GTK_OBJECT (statusbar),
"text_popped",
GTK_SIGNAL_FUNC (statusbar_popped),
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
- gtk_widget_show (separator);
-
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
- gtk_widget_show (button);
}
if (!GTK_WIDGET_VISIBLE (window))
- gtk_widget_show (window);
+ gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
-static void
-handle_box_child_signal (GtkHandleBox *hb,
- GtkWidget *child,
- const gchar *action)
-{
- printf ("%s: child <%s> %sed\n",
- gtk_type_name (GTK_OBJECT_TYPE (hb)),
- gtk_type_name (GTK_OBJECT_TYPE (child)),
- action);
-}
+/*
+ * GtkTree
+ */
static void
cb_tree_destroy_event(GtkWidget* w)
sTreeButtons* tree_buttons;
/* free buttons structure associate at this tree */
- tree_buttons = gtk_object_get_user_data(GTK_OBJECT(w));
- free(tree_buttons);
+ tree_buttons = gtk_object_get_user_data (GTK_OBJECT (w));
+ g_free (tree_buttons);
}
+
static void
cb_add_new_item(GtkWidget* w, GtkTree* tree)
{
sTreeButtons* tree_buttons;
/* create tree buttons struct */
- if((tree_buttons = g_malloc(sizeof(sTreeButtons))) == NULL)
+ if ((tree_buttons = g_malloc (sizeof (sTreeButtons))) == NULL)
{
g_error("can't allocate memory for tree structure !\n");
return;
/* create tree box */
box2 = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
- gtk_container_border_width(GTK_CONTAINER(box2), 5);
+ gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
gtk_widget_show(box2);
/* create scrolled window */
(GtkSignalFunc)cb_tree_changed,
(gpointer)NULL);
gtk_object_set_user_data(GTK_OBJECT(root_tree), tree_buttons);
- gtk_container_add(GTK_CONTAINER(scrolled_win), root_tree);
+ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), root_tree);
gtk_tree_set_selection_mode(GTK_TREE(root_tree), selection_mode);
gtk_tree_set_view_lines(GTK_TREE(root_tree), draw_line);
gtk_tree_set_view_mode(GTK_TREE(root_tree), !view_line);
box2 = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
- gtk_container_border_width(GTK_CONTAINER(box2), 5);
+ gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
gtk_widget_show(box2);
button = gtk_button_new_with_label("Add Item");
/* create button box */
box2 = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
- gtk_container_border_width(GTK_CONTAINER(box2), 5);
+ gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
gtk_widget_show(box2);
button = gtk_button_new_with_label("Close");
{
/* create toplevel window */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title(GTK_WINDOW(window), "Tree Mode Selection Window");
+ gtk_window_set_title(GTK_WINDOW(window), "Set Tree Parameters");
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
box1 = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), box1);
- gtk_widget_show(box1);
- /* create upper box - selection box */
+ /* create upper box - selection box */
box2 = gtk_vbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
- gtk_container_border_width(GTK_CONTAINER(box2), 5);
- gtk_widget_show(box2);
+ gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
box3 = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(box2), box3, TRUE, TRUE, 0);
- gtk_widget_show(box3);
/* create selection mode frame */
frame = gtk_frame_new("Selection Mode");
gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0);
- gtk_widget_show(frame);
box4 = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), box4);
- gtk_container_border_width(GTK_CONTAINER(box4), 5);
- gtk_widget_show(box4);
+ gtk_container_set_border_width(GTK_CONTAINER(box4), 5);
/* create radio button */
button = gtk_radio_button_new_with_label(NULL, "SINGLE");
gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
- gtk_widget_show(button);
sTreeSampleSelection.single_button = button;
button = gtk_radio_button_new_with_label(gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
"BROWSE");
gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
- gtk_widget_show(button);
sTreeSampleSelection.browse_button = button;
button = gtk_radio_button_new_with_label(gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
"MULTIPLE");
gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
- gtk_widget_show(button);
sTreeSampleSelection.multiple_button = button;
sTreeSampleSelection.selection_mode_group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
/* create option mode frame */
frame = gtk_frame_new("Options");
gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0);
- gtk_widget_show(frame);
box4 = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), box4);
- gtk_container_border_width(GTK_CONTAINER(box4), 5);
- gtk_widget_show(box4);
+ gtk_container_set_border_width(GTK_CONTAINER(box4), 5);
/* create check button */
button = gtk_check_button_new_with_label("Draw line");
gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
- gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
- gtk_widget_show(button);
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
sTreeSampleSelection.draw_line_button = button;
button = gtk_check_button_new_with_label("View Line mode");
gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
- gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
- gtk_widget_show(button);
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
sTreeSampleSelection.view_line_button = button;
button = gtk_check_button_new_with_label("Without Root item");
gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
- gtk_widget_show(button);
sTreeSampleSelection.no_root_item_button = button;
/* create recursion parameter */
frame = gtk_frame_new("Size Parameters");
gtk_box_pack_start(GTK_BOX(box2), frame, TRUE, TRUE, 0);
- gtk_widget_show(frame);
box4 = gtk_hbox_new(FALSE, 5);
gtk_container_add(GTK_CONTAINER(frame), box4);
- gtk_container_border_width(GTK_CONTAINER(box4), 5);
- gtk_widget_show(box4);
+ gtk_container_set_border_width(GTK_CONTAINER(box4), 5);
/* create number of item spin button */
box5 = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0);
- gtk_widget_show(box5);
- label = gtk_label_new("Number of Item");
+ label = gtk_label_new("Number of items : ");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
- gtk_widget_show(label);
adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_NUMBER_OF_ITEM, 1.0, 255.0, 1.0,
5.0, 0.0);
spinner = gtk_spin_button_new (adj, 0, 0);
gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
- gtk_widget_show(spinner);
sTreeSampleSelection.nb_item_spinner = spinner;
/* create recursion level spin button */
box5 = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0);
- gtk_widget_show(box5);
- label = gtk_label_new("Depth Level");
+ label = gtk_label_new("Depth : ");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
- gtk_widget_show(label);
adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_RECURSION_LEVEL, 0.0, 255.0, 1.0,
5.0, 0.0);
spinner = gtk_spin_button_new (adj, 0, 0);
gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
- gtk_widget_show(spinner);
sTreeSampleSelection.recursion_spinner = spinner;
/* create horizontal separator */
separator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
- gtk_widget_show(separator);
/* create bottom button box */
- box2 = gtk_hbox_new(FALSE, 0);
+ box2 = gtk_hbox_new(TRUE, 10);
gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
- gtk_container_border_width(GTK_CONTAINER(box2), 5);
- gtk_widget_show(box2);
+ gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
- button = gtk_button_new_with_label("Create Tree Sample");
+ button = gtk_button_new_with_label("Create Tree");
gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (button), "clicked",
(GtkSignalFunc) cb_create_tree, NULL);
- gtk_widget_show(button);
button = gtk_button_new_with_label("Close");
gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT (window));
- gtk_widget_show(button);
-
}
if (!GTK_WIDGET_VISIBLE (window))
- gtk_widget_show (window);
+ gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
-/* end of function used by tree demos */
+/*
+ * GtkHandleBox
+ */
+
+static void
+handle_box_child_signal (GtkHandleBox *hb,
+ GtkWidget *child,
+ const gchar *action)
+{
+ printf ("%s: child <%s> %sed\n",
+ gtk_type_name (GTK_OBJECT_TYPE (hb)),
+ gtk_type_name (GTK_OBJECT_TYPE (child)),
+ action);
+}
static void
create_handle_box (void)
gtk_window_set_policy (GTK_WINDOW (window),
TRUE,
TRUE,
- FALSE);
+ TRUE);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
- gtk_container_border_width (GTK_CONTAINER (window), 20);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 20);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (label);
handle_box = gtk_handle_box_new ();
- gtk_container_add (GTK_CONTAINER (hbox), handle_box);
+ gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (handle_box),
"child_attached",
GTK_SIGNAL_FUNC (handle_box_child_signal),
gtk_widget_show (toolbar);
handle_box = gtk_handle_box_new ();
- gtk_container_add (GTK_CONTAINER (hbox), handle_box);
+ gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (handle_box),
"child_attached",
GTK_SIGNAL_FUNC (handle_box_child_signal),
gtk_widget_destroy (window);
}
-
-static void
-reparent_label (GtkWidget *widget,
- GtkWidget *new_parent)
+/*
+ * Label Demo
+ */
+void create_labels (void)
{
+ static GtkWidget *window = NULL;
+ GtkWidget *hbox;
+ GtkWidget *vbox;
+ GtkWidget *frame;
GtkWidget *label;
- label = gtk_object_get_user_data (GTK_OBJECT (widget));
+ if (!window)
+ {
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_signal_connect (GTK_OBJECT (window), "destroy",
+ GTK_SIGNAL_FUNC(gtk_widget_destroyed),
+ &window);
- gtk_widget_reparent (label, new_parent);
-}
+ gtk_window_set_title (GTK_WINDOW (window), "Label");
+ vbox = gtk_vbox_new (FALSE, 5);
+ hbox = gtk_hbox_new (FALSE, 5);
+ gtk_container_add (GTK_CONTAINER (window), hbox);
+ 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_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_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_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");
+ 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);
+
+ vbox = gtk_vbox_new (FALSE, 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 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);
+
+ }
+ if (!GTK_WIDGET_VISIBLE (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_destroy (window);
+}
+
+/*
+ * Reparent demo
+ */
+
+static void
+reparent_label (GtkWidget *widget,
+ GtkWidget *new_parent)
+{
+ GtkWidget *label;
+
+ label = gtk_object_get_user_data (GTK_OBJECT (widget));
+
+ gtk_widget_reparent (label, new_parent);
+}
static void
set_parent_signal (GtkWidget *child,
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
- gtk_window_set_title (GTK_WINDOW (window), "buttons");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
-
+ gtk_window_set_title (GTK_WINDOW (window), "reparent");
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
- gtk_widget_show (box1);
-
box2 = gtk_hbox_new (FALSE, 5);
- gtk_container_border_width (GTK_CONTAINER (box2), 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);
-
label = gtk_label_new ("Hello World");
frame = gtk_frame_new ("Frame 1");
gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
- gtk_widget_show (frame);
box3 = gtk_vbox_new (FALSE, 5);
- gtk_container_border_width (GTK_CONTAINER (box3), 5);
+ gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
gtk_container_add (GTK_CONTAINER (frame), box3);
- gtk_widget_show (box3);
button = gtk_button_new_with_label ("switch");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
box3);
gtk_object_set_user_data (GTK_OBJECT (button), label);
gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
- gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (box3), label, FALSE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (label),
"parent_set",
GTK_SIGNAL_FUNC (set_parent_signal),
GINT_TO_POINTER (42));
- gtk_widget_show (label);
-
frame = gtk_frame_new ("Frame 2");
gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
- gtk_widget_show (frame);
box3 = gtk_vbox_new (FALSE, 5);
- gtk_container_border_width (GTK_CONTAINER (box3), 5);
+ gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
gtk_container_add (GTK_CONTAINER (frame), box3);
- gtk_widget_show (box3);
button = gtk_button_new_with_label ("switch");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
box3);
gtk_object_set_user_data (GTK_OBJECT (button), label);
gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
- gtk_widget_show (button);
-
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
- gtk_widget_show (separator);
-
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
- gtk_widget_show (button);
}
if (!GTK_WIDGET_VISIBLE (window))
- gtk_widget_show (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 = gtk_object_get_data (GTK_OBJECT (window), "x");
+ ly = gtk_object_get_data (GTK_OBJECT (window), "y");
+
+ gdk_window_get_root_origin (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
+create_saved_position (void)
+{
+ 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 = gtk_widget_new (GTK_TYPE_WINDOW,
+ "type", GTK_WINDOW_TOPLEVEL,
+ "signal::configure_event", uposition_configure, NULL,
+ "x", upositionx,
+ "y", upositiony,
+ "title", "Saved Position",
+ NULL);
+
+ gtk_signal_connect (GTK_OBJECT (window), "destroy",
+ GTK_SIGNAL_FUNC (gtk_widget_destroyed),
+ &window);
+
+ main_vbox = gtk_vbox_new (FALSE, 5);
+ gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
+ gtk_container_add (GTK_CONTAINER (window), main_vbox);
+
+ vbox =
+ gtk_widget_new (gtk_vbox_get_type (),
+ "GtkBox::homogeneous", FALSE,
+ "GtkBox::spacing", 5,
+ "GtkContainer::border_width", 10,
+ "GtkWidget::parent", main_vbox,
+ "GtkWidget::visible", TRUE,
+ NULL);
+
+ hbox = gtk_hbox_new (FALSE, 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_misc_set_alignment (GTK_MISC (label), 0, 0.5);
+ 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);
+ gtk_object_set_data (GTK_OBJECT (window), "x", x_label);
+
+ hbox = gtk_hbox_new (FALSE, 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_misc_set_alignment (GTK_MISC (label), 0, 0.5);
+ 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);
+ gtk_object_set_data (GTK_OBJECT (window), "y", y_label);
+
+ any =
+ gtk_widget_new (gtk_hseparator_get_type (),
+ "GtkWidget::visible", TRUE,
+ NULL);
+ gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
+
+ hbox = gtk_hbox_new (FALSE, 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");
+ gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (gtk_widget_destroy),
+ GTK_OBJECT (window));
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
+ GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_grab_default (button);
+
+ gtk_widget_show_all (window);
+ }
else
gtk_widget_destroy (window);
}
+/*
+ * GtkPixmap
+ */
+
static void
create_pixmap (void)
{
GtkWidget *pixmapwid;
GdkPixmap *pixmap;
GdkBitmap *mask;
- GtkStyle *style;
if (!window)
{
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
- gtk_window_set_title (GTK_WINDOW (window), "pixmap");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
+ gtk_window_set_title (GTK_WINDOW (window), "GtkPixmap");
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_widget_realize(window);
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
- gtk_widget_show (box1);
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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);
button = gtk_button_new ();
gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
- gtk_widget_show (button);
- style=gtk_widget_get_style(button);
-
- pixmap = gdk_pixmap_create_from_xpm (window->window, &mask,
- &style->bg[GTK_STATE_NORMAL],
+ pixmap = gdk_pixmap_create_from_xpm (window->window, &mask, NULL,
"test.xpm");
pixmapwid = gtk_pixmap_new (pixmap, mask);
+ gdk_pixmap_unref (pixmap);
+ gdk_pixmap_unref (mask);
label = gtk_label_new ("Pixmap\ntest");
box3 = gtk_hbox_new (FALSE, 0);
- gtk_container_border_width (GTK_CONTAINER (box3), 2);
+ gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
gtk_container_add (GTK_CONTAINER (box3), pixmapwid);
gtk_container_add (GTK_CONTAINER (box3), label);
gtk_container_add (GTK_CONTAINER (button), box3);
- gtk_widget_show (pixmapwid);
- gtk_widget_show (label);
- gtk_widget_show (box3);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
- gtk_widget_show (separator);
-
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
- gtk_widget_show (button);
}
if (!GTK_WIDGET_VISIBLE (window))
- gtk_widget_show (window);
+ gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
{
if (GTK_TOGGLE_BUTTON (toggle)->active)
{
- gtk_label_set (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!");
+ gtk_label_set_text (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!");
/* don't let GtkTipsQuery reset it's label */
gtk_signal_emit_stop_by_name (GTK_OBJECT (tips_query), "widget_entered");
}
g_print ("Help \"%s\" requested for <%s>\n",
tip_private ? tip_private : "None",
gtk_type_name (GTK_OBJECT_TYPE (widget)));
-
return TRUE;
}
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
- gtk_widget_show (box1);
-
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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);
-
button = gtk_toggle_button_new_with_label ("button1");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- gtk_widget_show (button);
gtk_tooltips_set_tip (tooltips,button,"This is button 1", "ContextHelp/buttons/1");
button = gtk_toggle_button_new_with_label ("button2");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- gtk_widget_show (button);
gtk_tooltips_set_tip (tooltips,
button,
toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
- gtk_widget_show (toggle);
gtk_tooltips_set_tip (tooltips, toggle, "Toggle TipsQuery view.", "Hi msw! ;)");
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
- gtk_widget_show (separator);
-
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
- gtk_widget_show (button);
gtk_tooltips_set_tip (tooltips, button, "Push this button to close window", "ContextHelp/buttons/Close");
}
if (!GTK_WIDGET_VISIBLE (window))
- gtk_widget_show (window);
+ gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
+/*
+ * Menu demo
+ */
+
static GtkWidget*
-create_menu (int depth)
+create_menu (gint depth, gboolean tearoff)
{
GtkWidget *menu;
GtkWidget *menuitem;
menu = gtk_menu_new ();
group = NULL;
+ if (tearoff)
+ {
+ menuitem = gtk_tearoff_menu_item_new ();
+ gtk_menu_append (GTK_MENU (menu), menuitem);
+ gtk_widget_show (menuitem);
+ }
+
for (i = 0, j = 1; i < 5; i++, j++)
{
sprintf (buf, "item %2d - %d", depth, j);
if (i == 3)
gtk_widget_set_sensitive (menuitem, FALSE);
- gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1));
+ gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1, TRUE));
}
return menu;
GTK_SIGNAL_FUNC (gtk_true),
NULL);
+ accel_group = gtk_accel_group_new ();
+ gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
+
gtk_window_set_title (GTK_WINDOW (window), "menus");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_vbox_new (FALSE, 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 (2);
+ menu = create_menu (2, TRUE);
menuitem = gtk_menu_item_new_with_label ("test\nline2");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("foo");
- gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3));
+ gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3, TRUE));
gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
gtk_widget_show (menuitem);
-
+
menuitem = gtk_menu_item_new_with_label ("bar");
- gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4));
+ gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, TRUE));
gtk_menu_item_right_justify (GTK_MENU_ITEM (menuitem));
gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
gtk_widget_show (menuitem);
-
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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 (1);
- accel_group = gtk_accel_group_get_default ();
+ menu = create_menu (1, FALSE);
gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
GDK_F3,
0,
GTK_ACCEL_VISIBLE);
- gtk_widget_freeze_accelerators (menuitem);
+ gtk_widget_lock_accelerators (menuitem);
optionmenu = gtk_option_menu_new ();
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu);
gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
gtk_widget_show (optionmenu);
-
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
-
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
gtk_widget_destroy (window);
}
+static void
+gtk_ifactory_cb (gpointer callback_data,
+ guint callback_action,
+ GtkWidget *widget)
+{
+ g_message ("ItemFactory: activated \"%s\"", gtk_item_factory_path_from_widget (widget));
+}
+
+static GtkItemFactoryEntry menu_items[] =
+{
+ { "/_File", NULL, 0, 0, "<Branch>" },
+ { "/File/tearoff1", NULL, gtk_ifactory_cb, 0, "<Tearoff>" },
+ { "/File/_New", "<control>N", gtk_ifactory_cb, 0 },
+ { "/File/_Open", "<control>O", gtk_ifactory_cb, 0 },
+ { "/File/_Save", "<control>S", gtk_ifactory_cb, 0 },
+ { "/File/Save _As...", NULL, gtk_ifactory_cb, 0 },
+ { "/File/sep1", NULL, gtk_ifactory_cb, 0, "<Separator>" },
+ { "/File/_Quit", "<control>Q", gtk_ifactory_cb, 0 },
+
+ { "/_Preferences", NULL, 0, 0, "<Branch>" },
+ { "/_Preferences/_Color", NULL, 0, 0, "<Branch>" },
+ { "/_Preferences/Color/_Red", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
+ { "/_Preferences/Color/_Green", NULL, gtk_ifactory_cb, 0, "/Preferences/Color/Red" },
+ { "/_Preferences/Color/_Blue", NULL, gtk_ifactory_cb, 0, "/Preferences/Color/Red" },
+ { "/_Preferences/_Shape", NULL, 0, 0, "<Branch>" },
+ { "/_Preferences/Shape/_Square", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
+ { "/_Preferences/Shape/_Rectangle", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Square" },
+ { "/_Preferences/Shape/_Oval", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Rectangle" },
+
+ { "/_Help", NULL, 0, 0, "<LastBranch>" },
+ { "/Help/_About", NULL, gtk_ifactory_cb, 0 },
+};
+
+static int nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
+
+static void
+create_item_factory (void)
+{
+ static GtkWidget *window = NULL;
+
+ if (!window)
+ {
+ GtkWidget *box1;
+ GtkWidget *box2;
+ GtkWidget *separator;
+ GtkWidget *label;
+ GtkWidget *button;
+ GtkAccelGroup *accel_group;
+ GtkItemFactory *item_factory;
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_signal_connect (GTK_OBJECT (window), "destroy",
+ GTK_SIGNAL_FUNC(gtk_widget_destroyed),
+ &window);
+ gtk_signal_connect (GTK_OBJECT (window), "delete-event",
+ GTK_SIGNAL_FUNC (gtk_true),
+ NULL);
+
+ accel_group = gtk_accel_group_new ();
+ item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
+ gtk_object_set_data_full (GTK_OBJECT (window),
+ "<main>",
+ item_factory,
+ (GtkDestroyNotify) gtk_object_unref);
+ gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
+ 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);
+
+ /* preselect /Preferences/Shape/Oval over the other radios
+ */
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_item_factory_get_item (item_factory,
+ "/Preferences/Shape/Oval")),
+ TRUE);
+
+ box1 = gtk_vbox_new (FALSE, 0);
+ gtk_container_add (GTK_CONTAINER (window), box1);
+
+ gtk_box_pack_start (GTK_BOX (box1),
+ gtk_item_factory_get_widget (item_factory, "<main>"),
+ FALSE, FALSE, 0);
+
+ label = gtk_label_new ("Type\n<alt>\nto start");
+ gtk_widget_set_usize (label, 200, 200);
+ gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
+ gtk_box_pack_start (GTK_BOX (box1), label, 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);
+
+ button = gtk_button_new_with_label ("close");
+ gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC(gtk_widget_destroy),
+ GTK_OBJECT (window));
+ gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
+ GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_grab_default (button);
+
+ gtk_widget_show_all (window);
+ }
+ else
+ gtk_widget_destroy (window);
+}
+
/*
* GtkScrolledWindow
*/
+
static void
scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin)
{
}
/*
- * GtkScrolledWindow
+ 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
-create_scrolled_windows (void)
+cmw_color (GtkWidget *widget, GtkWidget *parent)
{
- static GtkWidget *window;
- GtkWidget *scrolled_window;
- GtkWidget *table;
- GtkWidget *button;
- char buffer[32];
- int i, j;
+ GtkWidget *csd;
- if (!window)
- {
- window = gtk_dialog_new ();
+ csd=gtk_color_selection_dialog_new ("This is a modal color selection dialog");
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ /* Set as modal */
+ gtk_window_set_modal (GTK_WINDOW(csd),TRUE);
- gtk_window_set_title (GTK_WINDOW (window), "dialog");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
+ /* And mark it as a transient dialog */
+ gtk_window_set_transient_for (GTK_WINDOW (csd), GTK_WINDOW (parent));
+
+ gtk_signal_connect (GTK_OBJECT(csd), "destroy",
+ GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
+
+ gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->ok_button),
+ "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
+ GTK_OBJECT (csd));
+ gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->cancel_button),
+ "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
+ GTK_OBJECT (csd));
+
+ /* wait until destroy calls gtk_main_quit */
+ gtk_widget_show (csd);
+ gtk_main ();
+}
+static void
+cmw_file (GtkWidget *widget, GtkWidget *parent)
+{
+ GtkWidget *fs;
- scrolled_window = gtk_scrolled_window_new (NULL, NULL);
- gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
- gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
- GTK_POLICY_AUTOMATIC,
+ fs = gtk_file_selection_new("This is a modal file selection dialog");
+
+ /* Set as modal */
+ gtk_window_set_modal (GTK_WINDOW(fs),TRUE);
+
+ /* And mark it as a transient dialog */
+ gtk_window_set_transient_for (GTK_WINDOW (fs), GTK_WINDOW (parent));
+
+ gtk_signal_connect (GTK_OBJECT(fs), "destroy",
+ GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
+
+ gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
+ "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
+ GTK_OBJECT (fs));
+ gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->cancel_button),
+ "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
+ GTK_OBJECT (fs));
+
+ /* wait until destroy calls gtk_main_quit */
+ gtk_widget_show (fs);
+
+ gtk_main();
+}
+
+
+static void
+create_modal_window (void)
+{
+ 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_title (GTK_WINDOW(window),"This window is modal");
+
+ /* Set window as modal */
+ gtk_window_set_modal (GTK_WINDOW(window),TRUE);
+
+ /* Create widgets */
+ box1 = gtk_vbox_new (FALSE,5);
+ frame1 = gtk_frame_new ("Standard dialogs in modal form");
+ box2 = gtk_vbox_new (TRUE,5);
+ 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_hseparator_new (), FALSE, FALSE, 4);
+ gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
+
+ /* connect signals */
+ gtk_signal_connect_object (GTK_OBJECT (btnClose), "clicked",
+ GTK_SIGNAL_FUNC (gtk_widget_destroy),
+ GTK_OBJECT (window));
+
+ gtk_signal_connect (GTK_OBJECT (window), "destroy",
+ GTK_SIGNAL_FUNC (cmw_destroy_cb),NULL);
+
+ gtk_signal_connect (GTK_OBJECT (btnColor), "clicked",
+ GTK_SIGNAL_FUNC (cmw_color),window);
+ gtk_signal_connect (GTK_OBJECT (btnFile), "clicked",
+ GTK_SIGNAL_FUNC (cmw_file),window);
+
+ /* Show widgets */
+ gtk_widget_show_all (window);
+
+ /* wait until dialog get destroyed */
+ gtk_main();
+}
+
+/*
+ * GtkScrolledWindow
+ */
+
+static void
+create_scrolled_windows (void)
+{
+ static GtkWidget *window;
+ GtkWidget *scrolled_window;
+ GtkWidget *table;
+ GtkWidget *button;
+ char buffer[32];
+ int i, j;
+
+ if (!window)
+ {
+ window = gtk_dialog_new ();
+
+ gtk_signal_connect (GTK_OBJECT (window), "destroy",
+ GTK_SIGNAL_FUNC(gtk_widget_destroyed),
+ &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 (GTK_DIALOG (window)->vbox),
scrolled_window, TRUE, TRUE, 0);
table = gtk_table_new (20, 20, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 10);
gtk_table_set_col_spacings (GTK_TABLE (table), 10);
- gtk_container_add (GTK_CONTAINER (scrolled_window), table);
+ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), table);
gtk_container_set_focus_hadjustment (GTK_CONTAINER (table),
gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
gtk_container_set_focus_vadjustment (GTK_CONTAINER (table),
gtk_widget_grab_default (button);
gtk_widget_show (button);
+ gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
}
if (!GTK_WIDGET_VISIBLE (window))
&window);
gtk_window_set_title (GTK_WINDOW (window), "entry");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_vbox_new (FALSE, 0);
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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);
gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
- gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(editable_check), TRUE);
gtk_widget_show (editable_check);
editable_check = gtk_check_button_new_with_label("Visible");
gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
GTK_SIGNAL_FUNC(entry_toggle_visibility), entry);
- gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(editable_check), TRUE);
gtk_widget_show (editable_check);
sensitive_check = gtk_check_button_new_with_label("Sensitive");
gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT(sensitive_check), "toggled",
GTK_SIGNAL_FUNC(entry_toggle_sensitive), entry);
- gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(sensitive_check), TRUE);
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sensitive_check), TRUE);
gtk_widget_show (sensitive_check);
separator = gtk_hseparator_new ();
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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);
else
sprintf (buf, "%0.*f", spin->digits,
gtk_spin_button_get_value_as_float (spin));
- gtk_label_set (label, buf);
+ gtk_label_set_text (label, buf);
+}
+
+static gint
+spin_button_time_output_func (GtkSpinButton *spin_button)
+{
+ static gchar buf[6];
+ gfloat hours;
+ gfloat minutes;
+
+ hours = spin_button->adjustment->value / 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,
+ gfloat *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_strdup (month[i-1]);
+ g_strup (tmp1);
+ tmp2 = g_strdup (gtk_entry_get_text (GTK_ENTRY (spin_button)));
+ g_strup (tmp2);
+ if (strstr (tmp1, tmp2) == tmp1)
+ found = TRUE;
+ g_free (tmp1);
+ g_free (tmp2);
+ if (found)
+ break;
+ }
+ if (!found)
+ {
+ *new_val = 0.0;
+ return INPUT_ERROR;
+ }
+ *new_val = (gfloat) i;
+ return TRUE;
+}
+
+static gint
+spin_button_month_output_func (GtkSpinButton *spin_button)
+{
+ gint i;
+ static gchar *month[12] = { "January", "February", "March", "April",
+ "May", "June", "July", "August", "September",
+ "October", "November", "December" };
+
+ for (i = 1; i <= 12; i++)
+ if (fabs (spin_button->adjustment->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,
+ gfloat *new_val)
+{
+ gchar *buf;
+ gchar *err;
+ gfloat res;
+
+ buf = gtk_entry_get_text (GTK_ENTRY (spin_button));
+ res = (gfloat)(strtol(buf, &err, 16));
+ *new_val = res;
+ if (*err)
+ return INPUT_ERROR;
+ else
+ return TRUE;
+}
+
+static gint
+spin_button_hex_output_func (GtkSpinButton *spin_button)
+{
+ static gchar buf[7];
+ gint val;
+
+ val = (gint) spin_button->adjustment->value;
+ 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
gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
main_vbox = gtk_vbox_new (FALSE, 5);
- gtk_container_border_width (GTK_CONTAINER (main_vbox), 10);
+ 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_vbox_new (FALSE, 0);
- gtk_container_border_width (GTK_CONTAINER (vbox), 5);
+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
gtk_container_add (GTK_CONTAINER (frame), vbox);
- /* Day, month, year spinners */
+ /* Time, month, hex spinners */
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
- label = gtk_label_new ("Day :");
+ label = gtk_label_new ("Time :");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
- adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 31.0, 1.0,
- 5.0, 0.0);
+ adj = (GtkAdjustment *) gtk_adjustment_new (0, 0, 1410, 30, 60, 0);
spinner = gtk_spin_button_new (adj, 0, 0);
+ gtk_editable_set_editable (GTK_EDITABLE (spinner), FALSE);
+ gtk_signal_connect (GTK_OBJECT (spinner),
+ "output",
+ GTK_SIGNAL_FUNC (spin_button_time_output_func),
+ NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
- gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
- GTK_SHADOW_OUT);
+ gtk_widget_set_usize (spinner, 55, -1);
gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
vbox2 = gtk_vbox_new (FALSE, 0);
adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
5.0, 0.0);
spinner = gtk_spin_button_new (adj, 0, 0);
+ gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spinner),
+ GTK_UPDATE_IF_VALID);
+ gtk_signal_connect (GTK_OBJECT (spinner),
+ "input",
+ GTK_SIGNAL_FUNC (spin_button_month_input_func),
+ NULL);
+ gtk_signal_connect (GTK_OBJECT (spinner),
+ "output",
+ GTK_SIGNAL_FUNC (spin_button_month_output_func),
+ NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
- gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
- GTK_SHADOW_ETCHED_IN);
+ gtk_widget_set_usize (spinner, 85, -1);
gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
- label = gtk_label_new ("Year :");
+ label = gtk_label_new ("Hex :");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
- adj = (GtkAdjustment *) gtk_adjustment_new (1998.0, 0.0, 2100.0,
- 1.0, 100.0, 0.0);
+ adj = (GtkAdjustment *) gtk_adjustment_new (0, 0, 255, 1, 16, 0);
spinner = gtk_spin_button_new (adj, 0, 0);
+ gtk_editable_set_editable (GTK_EDITABLE (spinner), TRUE);
+ gtk_signal_connect (GTK_OBJECT (spinner),
+ "input",
+ GTK_SIGNAL_FUNC (spin_button_hex_input_func),
+ NULL);
+ gtk_signal_connect (GTK_OBJECT (spinner),
+ "output",
+ GTK_SIGNAL_FUNC (spin_button_hex_output_func),
+ NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
- gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
- GTK_SHADOW_IN);
gtk_widget_set_usize (spinner, 55, 0);
gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
vbox = gtk_vbox_new (FALSE, 0);
- gtk_container_border_width (GTK_CONTAINER (vbox), 5);
+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
gtk_container_add (GTK_CONTAINER (frame), vbox);
hbox = gtk_hbox_new (FALSE, 0);
adj = (GtkAdjustment *) gtk_adjustment_new (2, 1, 5, 1, 1, 0);
spinner2 = gtk_spin_button_new (adj, 0.0, 0);
- gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner2), TRUE);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (change_digits),
(gpointer) spinner2);
GTK_SIGNAL_FUNC (toggle_snap),
spinner1);
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
- gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
button = gtk_check_button_new_with_label ("Numeric only input mode");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (toggle_numeric),
spinner1);
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
- gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
val_label = gtk_label_new ("");
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 (GTK_LABEL (val_label), "0");
+ gtk_label_set_text (GTK_LABEL (val_label), "0");
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
gtk_widget_destroy (window);
}
+
/*
* Cursors
*/
while (vals && vals->value != c)
vals++;
if (vals)
- gtk_label_set (GTK_LABEL (label), vals->value_nick);
+ gtk_label_set_text (GTK_LABEL (label), vals->value_nick);
else
- gtk_label_set (GTK_LABEL (label), "<unknown>");
+ gtk_label_set_text (GTK_LABEL (label), "<unknown>");
cursor = gdk_cursor_new (c);
gdk_window_set_cursor (widget->window, cursor);
gtk_window_set_title (GTK_WINDOW (window), "Cursors");
main_vbox = gtk_vbox_new (FALSE, 5);
- gtk_container_border_width (GTK_CONTAINER (main_vbox), 0);
+ gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
gtk_container_add (GTK_CONTAINER (window), main_vbox);
vbox =
NULL);
hbox = gtk_hbox_new (FALSE, 0);
- gtk_container_border_width (GTK_CONTAINER (hbox), 5);
+ 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:");
+ label = gtk_label_new ("Cursor Value : ");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
hbox = gtk_hbox_new (FALSE, 0);
- gtk_container_border_width (GTK_CONTAINER (hbox), 10);
+ 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");
/*
* GtkList
*/
+
static void
list_add (GtkWidget *widget,
GtkWidget *list)
static int i = 1;
gchar buffer[64];
GtkWidget *list_item;
+ GtkContainer *container;
+
+ container = GTK_CONTAINER (list);
sprintf (buffer, "added item %d", i++);
list_item = gtk_list_item_new_with_label (buffer);
gtk_widget_show (list_item);
- gtk_container_add (GTK_CONTAINER (list), list_item);
+
+ gtk_container_add (container, list_item);
}
static void
list_remove (GtkWidget *widget,
- GtkWidget *list)
+ GtkList *list)
{
- GList *tmp_list;
- GList *clear_list;
-
- tmp_list = GTK_LIST (list)->selection;
- clear_list = NULL;
+ GList *clear_list = NULL;
+ GList *sel_row = NULL;
+ GList *work = NULL;
- while (tmp_list)
+ if (list->selection_mode == GTK_SELECTION_EXTENDED)
{
- clear_list = g_list_prepend (clear_list, tmp_list->data);
- tmp_list = tmp_list->next;
+ GtkWidget *item;
+
+ item = GTK_CONTAINER (list)->focus_child;
+ if (!item && list->selection)
+ item = list->selection->data;
+
+ if (item)
+ {
+ work = g_list_find (list->children, item);
+ for (sel_row = work; sel_row; sel_row = sel_row->next)
+ if (GTK_WIDGET (sel_row->data)->state != GTK_STATE_SELECTED)
+ break;
+
+ if (!sel_row)
+ {
+ for (sel_row = work; sel_row; sel_row = sel_row->prev)
+ if (GTK_WIDGET (sel_row->data)->state != GTK_STATE_SELECTED)
+ break;
+ }
+ }
}
- clear_list = g_list_reverse (clear_list);
+ for (work = list->selection; work; work = work->next)
+ clear_list = g_list_prepend (clear_list, work->data);
+ clear_list = g_list_reverse (clear_list);
gtk_list_remove_items (GTK_LIST (list), clear_list);
-
g_list_free (clear_list);
+
+ if (list->selection_mode == GTK_SELECTION_EXTENDED && sel_row)
+ gtk_list_select_child (list, GTK_WIDGET(sel_row->data));
}
static void
list_clear (GtkWidget *widget,
GtkWidget *list)
{
- gtk_list_clear_items (GTK_LIST (list), 3 - 1, 6 - 1);
+ 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)
+{
+ gint i;
+
+ if (!GTK_WIDGET_MAPPED (widget))
+ return;
+
+ RADIOMENUTOGGLED ((GtkRadioMenuItem *)
+ (((GtkOptionMenu *)list_omenu)->menu_item), i);
+
+ gtk_list_set_selection_mode (list, (GtkSelectionMode) (3-i));
}
static void
create_list (void)
{
static GtkWidget *window = NULL;
- static char *list_items[] =
+
+ static OptionMenuItem items[] =
{
- "hello",
- "world",
- "blah",
- "foo",
- "bar",
- "argh",
- "spencer",
- "is a",
- "wussy",
- "programmer",
+ { "Single", list_toggle_sel_mode },
+ { "Browse", list_toggle_sel_mode },
+ { "Multiple", list_toggle_sel_mode },
+ { "Extended", list_toggle_sel_mode }
};
- static int nlist_items = sizeof (list_items) / sizeof (list_items[0]);
-
- GtkWidget *box1;
- GtkWidget *box2;
- GtkWidget *scrolled_win;
- GtkWidget *list;
- GtkWidget *list_item;
- GtkWidget *button;
- GtkWidget *separator;
- int i;
if (!window)
{
+ GtkWidget *cbox;
+ GtkWidget *vbox;
+ GtkWidget *hbox;
+ GtkWidget *label;
+ GtkWidget *scrolled_win;
+ GtkWidget *list;
+ GtkWidget *button;
+ GtkWidget *separator;
+ FILE *infile;
+
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
&window);
gtk_window_set_title (GTK_WINDOW (window), "list");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
-
-
- box1 = gtk_vbox_new (FALSE, 0);
- gtk_container_add (GTK_CONTAINER (window), box1);
- gtk_widget_show (box1);
-
-
- box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 10);
- gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
- gtk_widget_show (box2);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
+ vbox = gtk_vbox_new (FALSE, 0);
+ gtk_container_add (GTK_CONTAINER (window), vbox);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
+ gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
+ gtk_widget_set_usize (scrolled_win, -1, 300);
+ gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
- GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
- gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
- gtk_widget_show (scrolled_win);
list = gtk_list_new ();
- gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_MULTIPLE);
- gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_BROWSE);
- gtk_container_add (GTK_CONTAINER (scrolled_win), list);
- gtk_container_set_focus_vadjustment (GTK_CONTAINER (list),
- gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_win)));
- gtk_widget_show (list);
-
- for (i = 0; i < nlist_items; i++)
+ gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_EXTENDED);
+ gtk_scrolled_window_add_with_viewport
+ (GTK_SCROLLED_WINDOW (scrolled_win), list);
+ gtk_container_set_focus_vadjustment
+ (GTK_CONTAINER (list),
+ gtk_scrolled_window_get_vadjustment
+ (GTK_SCROLLED_WINDOW (scrolled_win)));
+ gtk_container_set_focus_hadjustment
+ (GTK_CONTAINER (list),
+ gtk_scrolled_window_get_hadjustment
+ (GTK_SCROLLED_WINDOW (scrolled_win)));
+
+ if ((infile = fopen("gtkenums.h", "r")))
{
- list_item = gtk_list_item_new_with_label (list_items[i]);
- gtk_container_add (GTK_CONTAINER (list), list_item);
- gtk_widget_show (list_item);
+ char buffer[256];
+ char *pos;
+ GtkWidget *item;
+
+ while (fgets (buffer, 256, infile))
+ {
+ if ((pos = strchr (buffer, '\n')))
+ *pos = 0;
+ item = gtk_list_item_new_with_label (buffer);
+ gtk_container_add (GTK_CONTAINER (list), item);
+ }
+
+ fclose (infile);
}
- button = gtk_button_new_with_label ("add");
- GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
+
+ hbox = gtk_hbox_new (TRUE, 5);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
+
+ button = gtk_button_new_with_label ("Insert Row");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(list_add),
+ GTK_SIGNAL_FUNC (list_add),
list);
- gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
- gtk_widget_show (button);
- button = gtk_button_new_with_label ("clear items 3 - 5");
- GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
+ button = gtk_button_new_with_label ("Clear List");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(list_clear),
+ GTK_SIGNAL_FUNC (list_clear),
list);
- gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
- gtk_widget_show (button);
- button = gtk_button_new_with_label ("remove");
- GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
+ button = gtk_button_new_with_label ("Remove Selection");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(list_remove),
+ GTK_SIGNAL_FUNC (list_remove),
list);
- gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
- gtk_widget_show (button);
+ cbox = gtk_hbox_new (FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), cbox, FALSE, TRUE, 0);
- separator = gtk_hseparator_new ();
- gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
- gtk_widget_show (separator);
+ hbox = gtk_hbox_new (FALSE, 5);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
+ gtk_box_pack_start (GTK_BOX (cbox), hbox, TRUE, FALSE, 0);
+
+ 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);
+ gtk_box_pack_start (GTK_BOX (hbox), list_omenu, FALSE, TRUE, 0);
- box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 10);
- gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
- gtk_widget_show (box2);
+ separator = gtk_hseparator_new ();
+ gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, TRUE, 0);
+ cbox = gtk_hbox_new (FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), cbox, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("close");
+ gtk_container_set_border_width (GTK_CONTAINER (button), 10);
+ gtk_box_pack_start (GTK_BOX (cbox), button, TRUE, TRUE, 0);
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT (window));
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
+
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
- gtk_widget_show (button);
}
if (!GTK_WIDGET_VISIBLE (window))
- gtk_widget_show (window);
+ gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
-
/*
* GtkCList
*/
" oooooooooo ",
" "};
-#define TESTGTK_CLIST_COLUMNS 20
+static char * gtk_mini_xpm[] = {
+"15 20 17 1",
+" c None",
+". c #14121F",
+"+ c #278828",
+"@ c #9B3334",
+"# c #284C72",
+"$ c #24692A",
+"% c #69282E",
+"& c #37C539",
+"* c #1D2F4D",
+"= c #6D7076",
+"- c #7D8482",
+"; c #E24A49",
+"> c #515357",
+", c #9B9C9B",
+"' c #2FA232",
+") c #3CE23D",
+"! c #3B6CCB",
+" ",
+" ***> ",
+" >.*!!!* ",
+" ***....#*= ",
+" *!*.!!!**!!# ",
+" .!!#*!#*!!!!# ",
+" @%#!.##.*!!$& ",
+" @;%*!*.#!#')) ",
+" @;;@%!!*$&)'' ",
+" @%.%@%$'&)$+' ",
+" @;...@$'*'*)+ ",
+" @;%..@$+*.')$ ",
+" @;%%;;$+..$)# ",
+" @;%%;@$$$'.$# ",
+" %;@@;;$$+))&* ",
+" %;;;@+$&)&* ",
+" %;;@'))+> ",
+" %;@'&# ",
+" >%$$ ",
+" >= "};
+
+#define TESTGTK_CLIST_COLUMNS 12
static gint clist_rows = 0;
static GtkWidget *clist_omenu;
char *texts[TESTGTK_CLIST_COLUMNS];
GdkBitmap *mask;
GdkPixmap *pixmap;
-
- pixmap = gdk_pixmap_create_from_xpm_d (GTK_CLIST (data)->clist_window,
+ GtkCList *clist;
+
+ clist = GTK_CLIST (data);
+
+ pixmap = gdk_pixmap_create_from_xpm_d (clist->clist_window,
&mask,
>K_WIDGET (data)->style->white,
- mini_page_xpm);
+ gtk_mini_xpm);
for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
{
gtk_clist_freeze (GTK_CLIST (data));
for (i = 0; i < 1000; i++)
{
- sprintf (text[0], "Row %d", clist_rows++);
- row = gtk_clist_append (GTK_CLIST (data), texts);
- gtk_clist_set_pixtext (GTK_CLIST (data), row, 3, "Hello World", 5, pixmap, mask);
+ sprintf (text[0], "CListRow %d", rand() % 10000);
+ row = gtk_clist_append (clist, texts);
+ gtk_clist_set_pixtext (clist, row, 3, "gtk+", 5, pixmap, mask);
}
+
gtk_clist_thaw (GTK_CLIST (data));
gdk_pixmap_unref (pixmap);
gtk_clist_freeze (GTK_CLIST (data));
for (i = 0; i < 10000; i++)
{
- sprintf (text[0], "Row %d", clist_rows++);
+ sprintf (text[0], "CListRow %d", rand() % 10000);
gtk_clist_append (GTK_CLIST (data), texts);
}
gtk_clist_thaw (GTK_CLIST (data));
clist_rows = 0;
}
-void
-remove_row_clist (GtkWidget *widget, gpointer data)
-{
- gtk_clist_remove (GTK_CLIST (data), GTK_CLIST (data)->focus_row);
- clist_rows--;
-}
-
-void
-show_titles_clist (GtkWidget *widget, gpointer data)
-{
- gtk_clist_column_titles_show (GTK_CLIST (data));
-}
-
-void
-hide_titles_clist (GtkWidget *widget, gpointer data)
-{
- gtk_clist_column_titles_hide (GTK_CLIST (data));
-}
-
-void
-select_clist (GtkWidget *widget,
- gint row,
- gint column,
- GdkEventButton * bevent,
- GtkWidget *button)
+void clist_remove_selection (GtkWidget *widget, GtkCList *clist)
{
- gint i;
- guint8 spacing;
- gchar *text;
- GdkPixmap *pixmap;
- GdkBitmap *mask;
- GList *list;
-
- g_print ("GtkCList Selection: row %d column %d button %d\n",
- row, column, bevent ? bevent->button : 0);
+ gtk_clist_freeze (clist);
- for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
+ while (clist->selection)
{
- switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
- {
- case GTK_CELL_TEXT:
- g_print ("CELL %d GTK_CELL_TEXT\n", i);
- gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
- g_print ("TEXT: %s\n", text);
- break;
+ gint row;
- case GTK_CELL_PIXMAP:
- g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
- gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
- g_print ("PIXMAP: %p\n", pixmap);
- g_print ("MASK: %p\n", mask);
- break;
+ clist_rows--;
+ row = GPOINTER_TO_INT (clist->selection->data);
- case GTK_CELL_PIXTEXT:
- g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
- gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
- g_print ("TEXT: %s\n", text);
- g_print ("SPACING: %d\n", spacing);
- g_print ("PIXMAP: %p\n", pixmap);
- g_print ("MASK: %p\n", mask);
- break;
+ gtk_clist_remove (clist, row);
- default:
- break;
- }
+ if (clist->selection_mode == GTK_SELECTION_BROWSE)
+ break;
}
- /* print selections list */
- g_print ("\nSelected Rows:");
- list = GTK_CLIST (widget)->selection;
- while (list)
- {
- g_print (" %d ", GPOINTER_TO_INT (list->data));
- list = list->next;
- }
+ if (clist->selection_mode == GTK_SELECTION_EXTENDED && !clist->selection &&
+ clist->focus_row >= 0)
+ gtk_clist_select_row (clist, clist->focus_row, -1);
- g_print ("\n\n\n");
+ gtk_clist_thaw (clist);
}
-void
-unselect_clist (GtkWidget *widget,
- gint row,
- gint column,
- GdkEventButton * bevent,
- GtkWidget *button)
+void toggle_title_buttons (GtkWidget *widget, GtkCList *clist)
{
- gint i;
- guint8 spacing;
- gchar *text;
- GdkPixmap *pixmap;
- GdkBitmap *mask;
- GList *list;
-
- g_print ("GtkCList Unselection: row %d column %d button %d\n",
- row, column, bevent ? bevent->button : 0);
-
- for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
- {
- switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
- {
- case GTK_CELL_TEXT:
- g_print ("CELL %d GTK_CELL_TEXT\n", i);
- gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
- g_print ("TEXT: %s\n", text);
- break;
-
- case GTK_CELL_PIXMAP:
- g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
- gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
- g_print ("PIXMAP: %p\n", pixmap);
- g_print ("MASK: %p\n", mask);
- break;
-
- case GTK_CELL_PIXTEXT:
- g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
- gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
- g_print ("TEXT: %s\n", text);
- g_print ("SPACING: %d\n", spacing);
- g_print ("PIXMAP: %p\n", pixmap);
- g_print ("MASK: %p\n", mask);
- break;
-
- default:
- break;
- }
- }
-
- /* print selections list */
- g_print ("\nSelected Rows:");
- list = GTK_CLIST (widget)->selection;
- while (list)
- {
- g_print (" %d ", GPOINTER_TO_INT (list->data));
- list = list->next;
- }
+ if (GTK_TOGGLE_BUTTON (widget)->active)
+ gtk_clist_column_titles_show (clist);
+ else
+ gtk_clist_column_titles_hide (clist);
+}
- g_print ("\n\n\n");
+void toggle_reorderable (GtkWidget *widget, GtkCList *clist)
+{
+ gtk_clist_set_reorderable (clist, GTK_TOGGLE_BUTTON (widget)->active);
}
static void
{
static char *text[] =
{
- "This", "is", "a", "inserted", "row.",
- "This", "is", "a", "inserted", "row.",
- "This", "is", "a", "inserted", "row.",
- "This", "is", "a", "inserted", "row."
+ "This", "is an", "inserted", "row.",
+ "This", "is an", "inserted", "row.",
+ "This", "is an", "inserted", "row."
};
- gtk_clist_insert (GTK_CLIST (data), GTK_CLIST (data)->focus_row, text);
+ static GtkStyle *style1 = NULL;
+ static GtkStyle *style2 = NULL;
+ static GtkStyle *style3 = NULL;
+ gint row;
+
+ if (GTK_CLIST (data)->focus_row >= 0)
+ row = gtk_clist_insert (GTK_CLIST (data), GTK_CLIST (data)->focus_row,
+ text);
+ else
+ row = gtk_clist_prepend (GTK_CLIST (data), text);
+
+ if (!style1)
+ {
+ GdkColor col1;
+ GdkColor col2;
+
+ col1.red = 0;
+ col1.green = 56000;
+ col1.blue = 0;
+ col2.red = 32000;
+ col2.green = 0;
+ col2.blue = 56000;
+
+ style1 = gtk_style_copy (GTK_WIDGET (data)->style);
+ style1->base[GTK_STATE_NORMAL] = col1;
+ style1->base[GTK_STATE_SELECTED] = col2;
+
+ style2 = gtk_style_copy (GTK_WIDGET (data)->style);
+ style2->fg[GTK_STATE_NORMAL] = col1;
+ style2->fg[GTK_STATE_SELECTED] = col2;
+
+ style3 = gtk_style_copy (GTK_WIDGET (data)->style);
+ style3->fg[GTK_STATE_NORMAL] = col1;
+ style3->base[GTK_STATE_NORMAL] = col2;
+ gdk_font_unref (style3->font);
+ style3->font =
+ gdk_font_load ("-*-courier-medium-*-*-*-*-120-*-*-*-*-*-*");
+ }
+
+ gtk_clist_set_cell_style (GTK_CLIST (data), row, 3, style1);
+ gtk_clist_set_cell_style (GTK_CLIST (data), row, 4, style2);
+ gtk_clist_set_cell_style (GTK_CLIST (data), row, 0, style3);
clist_rows++;
}
gtk_clist_undo_selection (clist);
}
-#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 void
clist_toggle_sel_mode (GtkWidget *widget, GtkCList *clist)
{
gtk_clist_set_selection_mode (clist, (GtkSelectionMode) (3-i));
}
+static void
+clist_click_column (GtkCList *clist, gint column, gpointer data)
+{
+ if (column == 4)
+ gtk_clist_set_column_visibility (clist, column, FALSE);
+ else if (column == clist->sort_column)
+ {
+ if (clist->sort_type == GTK_SORT_ASCENDING)
+ clist->sort_type = GTK_SORT_DESCENDING;
+ else
+ clist->sort_type = GTK_SORT_ASCENDING;
+ }
+ else
+ gtk_clist_set_sort_column (clist, column);
+
+ gtk_clist_sort (clist);
+}
+
static void
create_clist (void)
{
static char *titles[] =
{
- "Title 0",
- "Title 1",
- "Title 2",
- "Title 3",
- "Title 4",
- "Title 5",
- "Title 6",
- "Title 7",
- "Title 8",
- "Title 9",
- "Title 10",
- "Title 11",
- "Title 12",
- "Title 13",
- "Title 14",
- "Title 15",
- "Title 16",
- "Title 17",
- "Title 18",
- "Title 19"
+ "auto resize", "not resizeable", "max width 100", "min width 50",
+ "hide column", "Title 5", "Title 6", "Title 7",
+ "Title 8", "Title 9", "Title 10", "Title 11"
+ };
+
+ static OptionMenuItem items[] =
+ {
+ { "Single", clist_toggle_sel_mode },
+ { "Browse", clist_toggle_sel_mode },
+ { "Multiple", clist_toggle_sel_mode },
+ { "Extended", clist_toggle_sel_mode }
};
char text[TESTGTK_CLIST_COLUMNS][50];
char *texts[TESTGTK_CLIST_COLUMNS];
- GtkWidget *box1;
- GtkWidget *box2;
+ GtkWidget *vbox;
+ GtkWidget *hbox;
GtkWidget *clist;
GtkWidget *button;
GtkWidget *separator;
+ GtkWidget *scrolled_win;
+ GtkWidget *check;
GtkWidget *undo_button;
GtkWidget *label;
- GtkWidget *menu;
- GtkWidget *menu_item;
- GSList *group;
+
+ GtkStyle *style;
+ GdkColor col1;
+ GdkColor col2;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window);
gtk_window_set_title (GTK_WINDOW (window), "clist");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
- box1 = gtk_vbox_new (FALSE, 0);
- gtk_container_add (GTK_CONTAINER (window), box1);
+ vbox = gtk_vbox_new (FALSE, 0);
+ gtk_container_add (GTK_CONTAINER (window), vbox);
- box2 = gtk_hbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 10);
- gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+ scrolled_win = gtk_scrolled_window_new (NULL, NULL);
+ gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
/* create GtkCList here so we have a pointer to throw at the
* button callbacks -- more is done with it later */
clist = gtk_clist_new_with_titles (TESTGTK_CLIST_COLUMNS, titles);
- /*clist = gtk_clist_new (TESTGTK_CLIST_COLUMNS);*/
+ gtk_container_add (GTK_CONTAINER (scrolled_win), clist);
+ gtk_signal_connect (GTK_OBJECT (clist), "click_column",
+ (GtkSignalFunc) clist_click_column, NULL);
/* control buttons */
- button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
-
- gtk_signal_connect (GTK_OBJECT (button),
- "clicked",
- (GtkSignalFunc) add1000_clist,
- (gpointer) clist);
-
- button = gtk_button_new_with_label ("Add 10,000 Rows");
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
-
- gtk_signal_connect (GTK_OBJECT (button),
- "clicked",
- (GtkSignalFunc) add10000_clist,
- (gpointer) clist);
-
- button = gtk_button_new_with_label ("Clear List");
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
+ hbox = gtk_hbox_new (FALSE, 5);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
- gtk_signal_connect (GTK_OBJECT (button),
- "clicked",
- (GtkSignalFunc) clear_clist,
- (gpointer) clist);
+ button = gtk_button_new_with_label ("Insert Row");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ (GtkSignalFunc) insert_row_clist, (gpointer) clist);
- button = gtk_button_new_with_label ("Remove Row");
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
+ button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ (GtkSignalFunc) add1000_clist, (gpointer) clist);
- gtk_signal_connect (GTK_OBJECT (button),
- "clicked",
- (GtkSignalFunc) remove_row_clist,
- (gpointer) clist);
+ button = gtk_button_new_with_label ("Add 10,000 Rows");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ (GtkSignalFunc) add10000_clist, (gpointer) clist);
/* second layer of buttons */
- box2 = gtk_hbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 10);
- gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
-
- button = gtk_button_new_with_label ("Insert Row");
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
-
- gtk_signal_connect (GTK_OBJECT (button),
- "clicked",
- (GtkSignalFunc) insert_row_clist,
- (gpointer) clist);
-
- button = gtk_button_new_with_label ("Show Title Buttons");
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
+ hbox = gtk_hbox_new (FALSE, 5);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
- gtk_signal_connect (GTK_OBJECT (button),
- "clicked",
- (GtkSignalFunc) show_titles_clist,
- (gpointer) clist);
+ button = gtk_button_new_with_label ("Clear List");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ (GtkSignalFunc) clear_clist, (gpointer) clist);
- button = gtk_button_new_with_label ("Hide Title Buttons");
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
+ button = gtk_button_new_with_label ("Remove Selection");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ (GtkSignalFunc) clist_remove_selection,
+ (gpointer) clist);
- gtk_signal_connect (GTK_OBJECT (button),
- "clicked",
- (GtkSignalFunc) hide_titles_clist,
- (gpointer) clist);
+ undo_button = gtk_button_new_with_label ("Undo Selection");
+ gtk_box_pack_start (GTK_BOX (hbox), undo_button, TRUE, TRUE, 0);
+ gtk_signal_connect (GTK_OBJECT (undo_button), "clicked",
+ (GtkSignalFunc) undo_selection, (gpointer) clist);
button = gtk_button_new_with_label ("Warning Test");
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ (GtkSignalFunc) clist_warning_test,(gpointer) clist);
- gtk_signal_connect (GTK_OBJECT (button),
- "clicked",
- (GtkSignalFunc) clist_warning_test,
- (gpointer) clist);
+ /* third layer of buttons */
+ hbox = gtk_hbox_new (FALSE, 5);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
- box2 = gtk_hbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 10);
- gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+ check = gtk_check_button_new_with_label ("Show Title Buttons");
+ gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
+ gtk_signal_connect (GTK_OBJECT (check), "clicked",
+ GTK_SIGNAL_FUNC (toggle_title_buttons), clist);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
- undo_button = gtk_button_new_with_label ("Undo last selection");
- gtk_box_pack_start (GTK_BOX (box2), undo_button, TRUE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT (undo_button),
- "clicked",
- (GtkSignalFunc) undo_selection,
- (gpointer) clist);
+ check = gtk_check_button_new_with_label ("Reorderable");
+ gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
+ gtk_signal_connect (GTK_OBJECT (check), "clicked",
+ GTK_SIGNAL_FUNC (toggle_reorderable), clist);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
label = gtk_label_new ("Selection Mode :");
- gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
+ gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
- clist_omenu = gtk_option_menu_new ();
-
- menu = gtk_menu_new ();
- group = NULL;
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Single");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (clist_toggle_sel_mode), clist);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_widget_show (menu_item);
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Browse");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (clist_toggle_sel_mode), clist);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_widget_show (menu_item);
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Multiple");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (clist_toggle_sel_mode), clist);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_widget_show (menu_item);
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Extended");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (clist_toggle_sel_mode), clist);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
- gtk_widget_show (menu_item);
-
- gtk_option_menu_set_menu (GTK_OPTION_MENU (clist_omenu), menu);
- gtk_box_pack_start (GTK_BOX (box2), clist_omenu, FALSE, TRUE, 0);
-
- gtk_option_menu_set_history (GTK_OPTION_MENU (clist_omenu), 3);
-
- /* vbox for the list itself */
- box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 10);
- gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
+ clist_omenu = build_option_menu (items, 4, 3, clist);
+ gtk_box_pack_start (GTK_BOX (hbox), clist_omenu, FALSE, TRUE, 0);
/*
* the rest of the clist configuration
*/
- /*
- gtk_signal_connect (GTK_OBJECT (clist),
- "select_row",
- (GtkSignalFunc) select_clist,
- undo_button);
-
- gtk_signal_connect (GTK_OBJECT (clist),
- "unselect_row",
- (GtkSignalFunc) unselect_clist,
- undo_button);
- */
-
+ gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
gtk_clist_set_row_height (GTK_CLIST (clist), 18);
gtk_widget_set_usize (clist, -1, 300);
- gtk_clist_set_column_width (GTK_CLIST (clist), 0, 100);
-
for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
+ gtk_clist_set_column_auto_resize (GTK_CLIST (clist), 0, TRUE);
+ gtk_clist_set_column_resizeable (GTK_CLIST (clist), 1, FALSE);
+ gtk_clist_set_column_max_width (GTK_CLIST (clist), 2, 100);
+ gtk_clist_set_column_min_width (GTK_CLIST (clist), 3, 50);
gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_EXTENDED);
- gtk_clist_set_policy (GTK_CLIST (clist), GTK_POLICY_AUTOMATIC,
- GTK_POLICY_AUTOMATIC);
-
gtk_clist_set_column_justification (GTK_CLIST (clist), 1,
GTK_JUSTIFY_RIGHT);
gtk_clist_set_column_justification (GTK_CLIST (clist), 2,
sprintf (text[1], "Right");
sprintf (text[2], "Center");
+ col1.red = 56000;
+ col1.green = 0;
+ col1.blue = 0;
+ col2.red = 0;
+ col2.green = 56000;
+ col2.blue = 32000;
+
+ style = gtk_style_new ();
+ style->fg[GTK_STATE_NORMAL] = col1;
+ style->base[GTK_STATE_NORMAL] = col2;
+
+ gdk_font_unref (style->font);
+ style->font =
+ gdk_font_load ("-adobe-helvetica-bold-r-*-*-*-140-*-*-*-*-*-*");
+
for (i = 0; i < 10; i++)
{
- sprintf (text[0], "Row %d", clist_rows++);
+ sprintf (text[0], "CListRow %d", clist_rows++);
gtk_clist_append (GTK_CLIST (clist), texts);
- }
- gtk_container_border_width (GTK_CONTAINER (clist), 5);
- gtk_box_pack_start (GTK_BOX (box2), clist, TRUE, TRUE, 0);
+ switch (i % 4)
+ {
+ case 2:
+ gtk_clist_set_row_style (GTK_CLIST (clist), i, style);
+ break;
+ default:
+ gtk_clist_set_cell_style (GTK_CLIST (clist), i, i % 4, style);
+ break;
+ }
+ }
separator = gtk_hseparator_new ();
- gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, TRUE, 0);
- box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 10);
- gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
+ hbox = gtk_hbox_new (FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("close");
+ gtk_container_set_border_width (GTK_CONTAINER (button), 10);
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT (window));
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
}
static GtkWidget *page_label;
static GtkWidget *sel_label;
static GtkWidget *vis_label;
-static GtkWidget *omenu;
+static GtkWidget *omenu1;
static GtkWidget *omenu2;
static GtkWidget *omenu3;
+static GtkWidget *omenu4;
static GtkWidget *spin1;
static GtkWidget *spin2;
static GtkWidget *spin3;
-static GdkColor *col_bg;
+static gint line_style;
void after_press (GtkCTree *ctree, gpointer data)
{
char buf[80];
sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
- gtk_label_set (GTK_LABEL (sel_label), buf);
+ gtk_label_set_text (GTK_LABEL (sel_label), buf);
sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
- gtk_label_set (GTK_LABEL (vis_label), buf);
+ gtk_label_set_text (GTK_LABEL (vis_label), buf);
sprintf (buf, "%d", books);
- gtk_label_set (GTK_LABEL (book_label), buf);
+ gtk_label_set_text (GTK_LABEL (book_label), buf);
sprintf (buf, "%d", pages);
- gtk_label_set (GTK_LABEL (page_label), buf);
+ gtk_label_set_text (GTK_LABEL (page_label), buf);
}
-void after_move (GtkCTree *ctree, GList *child, GList *parent,
- GList *sibling, gpointer data)
+void after_move (GtkCTree *ctree, GtkCTreeNode *child, GtkCTreeNode *parent,
+ GtkCTreeNode *sibling, gpointer data)
{
char *source;
char *target1;
(parent) ? target1 : "nil", (sibling) ? target2 : "nil");
}
-gint button_press (GtkCTree *ctree, GdkEventButton *event, gpointer data)
-{
- gint row;
- gint column;
- GList *work;
- gint res;
-
- res = gtk_clist_get_selection_info (GTK_CLIST (ctree), event->x, event->y,
- &row, &column);
- if (!res && event->button != 3)
- return FALSE;
-
- work = g_list_nth (GTK_CLIST (ctree)->row_list, row);
-
- switch (event->button)
- {
- case 1:
- if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_MULTIPLE &&
- event->state & GDK_SHIFT_MASK)
- gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),"button_press_event");
- break;
- case 2:
- if (GTK_CTREE_ROW (work)->children &&
- gtk_ctree_is_hot_spot (ctree, event->x, event->y))
- {
- if (GTK_CTREE_ROW (work)->expanded)
- gtk_ctree_collapse_recursive (ctree, work);
- else
- gtk_ctree_expand_recursive (ctree, work);
- after_press (ctree, NULL);
- gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),
- "button_press_event");
- }
- break;
- default:
- break;
- }
- return FALSE;
-}
-
-gint button_release (GtkCTree *ctree, GdkEventButton *event, gpointer data)
-{
- gint row;
- gint column;
- GList *work;
- gint res;
-
- res = gtk_clist_get_selection_info (GTK_CLIST (ctree), event->x, event->y,
- &row, &column);
- if (!res || event->button != 1)
- return FALSE;
-
- work = g_list_nth (GTK_CLIST (ctree)->row_list, row);
-
- if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_MULTIPLE &&
- event->state & GDK_SHIFT_MASK)
- {
- if (GTK_CTREE_ROW (work)->row.state == GTK_STATE_SELECTED)
- gtk_ctree_unselect_recursive (ctree, work);
- else
- gtk_ctree_select_recursive (ctree, work);
- after_press (ctree, NULL);
- gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),
- "button_release_event");
- }
- return FALSE;
-}
-
-void count_items (GtkCTree *ctree, GList *list)
+void count_items (GtkCTree *ctree, GtkCTreeNode *list)
{
if (GTK_CTREE_ROW (list)->is_leaf)
pages--;
after_press (ctree, NULL);
}
+void change_style (GtkWidget *widget, GtkCTree *ctree)
+{
+ static GtkStyle *style1 = NULL;
+ static GtkStyle *style2 = NULL;
+
+ GtkCTreeNode *node;
+ GdkColor col1;
+ GdkColor col2;
+
+ if (GTK_CLIST (ctree)->focus_row >= 0)
+ node = GTK_CTREE_NODE
+ (g_list_nth (GTK_CLIST (ctree)->row_list,GTK_CLIST (ctree)->focus_row));
+ else
+ node = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
+
+ if (!node)
+ return;
+
+ if (!style1)
+ {
+ col1.red = 0;
+ col1.green = 56000;
+ col1.blue = 0;
+ col2.red = 32000;
+ col2.green = 0;
+ col2.blue = 56000;
+
+ style1 = gtk_style_new ();
+ style1->base[GTK_STATE_NORMAL] = col1;
+ style1->fg[GTK_STATE_SELECTED] = col2;
+
+ style2 = gtk_style_new ();
+ style2->base[GTK_STATE_SELECTED] = col2;
+ style2->fg[GTK_STATE_NORMAL] = col1;
+ style2->base[GTK_STATE_NORMAL] = col2;
+ gdk_font_unref (style2->font);
+ style2->font =
+ gdk_font_load ("-*-courier-medium-*-*-*-*-300-*-*-*-*-*-*");
+ }
+
+ gtk_ctree_node_set_cell_style (ctree, node, 1, style1);
+ gtk_ctree_node_set_cell_style (ctree, node, 0, style2);
+
+ if (GTK_CTREE_ROW (node)->children)
+ gtk_ctree_node_set_row_style (ctree, GTK_CTREE_ROW (node)->children,
+ style2);
+}
+
void unselect_all (GtkWidget *widget, GtkCTree *ctree)
{
gtk_ctree_unselect_recursive (ctree, NULL);
void remove_selection (GtkWidget *widget, GtkCTree *ctree)
{
- GList *work;
- GList *selection;
- GList *new_sel;
+ GtkCList *clist;
+ GtkCTreeNode *node;
- selection = GTK_CLIST (ctree)->selection;
- new_sel = NULL;
+ clist = GTK_CLIST (ctree);
- gtk_clist_freeze (GTK_CLIST (ctree));
+ gtk_clist_freeze (clist);
- while (selection)
+ while (clist->selection)
{
- work = selection->data;
- if (GTK_CTREE_ROW (work)->is_leaf)
+ node = clist->selection->data;
+
+ if (GTK_CTREE_ROW (node)->is_leaf)
pages--;
else
- gtk_ctree_post_recursive (ctree, work,
+ gtk_ctree_post_recursive (ctree, node,
(GtkCTreeFunc) count_items, NULL);
- if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_BROWSE)
- {
- if (GTK_CTREE_ROW (work)->children)
- {
- new_sel = GTK_CTREE_ROW (work)->sibling;
- if (!new_sel)
- new_sel = work->prev;
- }
- else
- {
- if (work->next)
- new_sel = work->next;
- else
- new_sel = work->prev;
- }
- }
+ gtk_ctree_remove_node (ctree, node);
- gtk_ctree_remove (ctree, work);
- selection = GTK_CLIST (ctree)->selection;
+ if (clist->selection_mode == GTK_SELECTION_BROWSE)
+ break;
}
- if (new_sel)
- gtk_ctree_select (ctree, new_sel);
+ if (clist->selection_mode == GTK_SELECTION_EXTENDED && !clist->selection &&
+ clist->focus_row >= 0)
+ {
+ node = gtk_ctree_node_nth (ctree, clist->focus_row);
- gtk_clist_thaw (GTK_CLIST (ctree));
+ if (node)
+ gtk_ctree_select (ctree, node);
+ }
+
+ gtk_clist_thaw (clist);
after_press (ctree, NULL);
}
-void sort_all (GtkWidget *widget, GtkCTree *ctree)
+struct _ExportStruct {
+ gchar *tree;
+ gchar *info;
+ gboolean is_leaf;
+};
+
+typedef struct _ExportStruct ExportStruct;
+
+gboolean
+gnode2ctree (GtkCTree *ctree,
+ guint depth,
+ GNode *gnode,
+ GtkCTreeNode *cnode,
+ gpointer data)
{
- gtk_ctree_sort_recursive (ctree, NULL);
+ ExportStruct *es;
+ GdkPixmap *pixmap_closed;
+ GdkBitmap *mask_closed;
+ GdkPixmap *pixmap_opened;
+ GdkBitmap *mask_opened;
+
+ if (!cnode || !gnode || (!(es = gnode->data)))
+ return FALSE;
+
+ if (es->is_leaf)
+ {
+ pixmap_closed = pixmap3;
+ mask_closed = mask3;
+ pixmap_opened = NULL;
+ mask_opened = NULL;
+ }
+ else
+ {
+ pixmap_closed = pixmap1;
+ mask_closed = mask1;
+ pixmap_opened = pixmap2;
+ mask_opened = mask2;
+ }
+
+ gtk_ctree_set_node_info (ctree, cnode, es->tree, 2, pixmap_closed,
+ mask_closed, pixmap_opened, mask_opened,
+ es->is_leaf, (depth < 3));
+ gtk_ctree_node_set_text (ctree, cnode, 1, es->info);
+ g_free (es);
+ gnode->data = NULL;
+
+ return TRUE;
+}
+
+gboolean
+ctree2gnode (GtkCTree *ctree,
+ guint depth,
+ GNode *gnode,
+ GtkCTreeNode *cnode,
+ gpointer data)
+{
+ ExportStruct *es;
+
+ if (!cnode || !gnode)
+ return FALSE;
+
+ es = g_new (ExportStruct, 1);
+ gnode->data = es;
+ es->is_leaf = GTK_CTREE_ROW (cnode)->is_leaf;
+ es->tree = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[0])->text;
+ es->info = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[1])->text;
+ return TRUE;
+}
+
+void export_ctree (GtkWidget *widget, GtkCTree *ctree)
+{
+ char *title[] = { "Tree" , "Info" };
+ static GtkWidget *export_window = NULL;
+ static GtkCTree *export_ctree;
+ GtkWidget *vbox;
+ GtkWidget *scrolled_win;
+ GtkWidget *button;
+ GtkWidget *sep;
+ GNode *gnode;
+ GtkCTreeNode *node;
+
+ if (!export_window)
+ {
+ export_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_signal_connect (GTK_OBJECT (export_window), "destroy",
+ GTK_SIGNAL_FUNC (gtk_widget_destroyed),
+ &export_window);
+
+ gtk_window_set_title (GTK_WINDOW (export_window), "exported ctree");
+ gtk_container_set_border_width (GTK_CONTAINER (export_window), 5);
+
+ vbox = gtk_vbox_new (FALSE, 0);
+ gtk_container_add (GTK_CONTAINER (export_window), vbox);
+
+ button = gtk_button_new_with_label ("Close");
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, TRUE, 0);
+
+ gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+ (GtkSignalFunc) gtk_widget_destroy,
+ GTK_OBJECT(export_window));
+
+ sep = gtk_hseparator_new ();
+ gtk_box_pack_end (GTK_BOX (vbox), sep, FALSE, TRUE, 10);
+
+ export_ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
+ gtk_ctree_set_line_style (export_ctree, GTK_CTREE_LINES_DOTTED);
+
+ scrolled_win = gtk_scrolled_window_new (NULL, NULL);
+ gtk_container_add (GTK_CONTAINER (scrolled_win),
+ GTK_WIDGET (export_ctree));
+ 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_clist_set_selection_mode (GTK_CLIST (export_ctree),
+ GTK_SELECTION_EXTENDED);
+ gtk_clist_set_column_width (GTK_CLIST (export_ctree), 0, 200);
+ gtk_clist_set_column_width (GTK_CLIST (export_ctree), 1, 200);
+ gtk_widget_set_usize (GTK_WIDGET (export_ctree), 300, 200);
+ }
+
+ if (!GTK_WIDGET_VISIBLE (export_window))
+ gtk_widget_show_all (export_window);
+
+ gtk_clist_clear (GTK_CLIST (export_ctree));
+
+ node = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list,
+ GTK_CLIST (ctree)->focus_row));
+ if (!node)
+ return;
+
+ gnode = gtk_ctree_export_to_gnode (ctree, NULL, NULL, node,
+ ctree2gnode, NULL);
+ if (gnode)
+ {
+ gtk_ctree_insert_gnode (export_ctree, NULL, NULL, gnode,
+ gnode2ctree, NULL);
+ g_node_destroy (gnode);
+ }
}
void change_indent (GtkWidget *widget, GtkCTree *ctree)
gtk_ctree_set_indent (ctree, GTK_ADJUSTMENT (widget)->value);
}
-void change_row_height (GtkWidget *widget, GtkCList *clist)
+void change_spacing (GtkWidget *widget, GtkCTree *ctree)
{
- gtk_clist_set_row_height (clist, GTK_ADJUSTMENT (widget)->value);
+ gtk_ctree_set_spacing (ctree, GTK_ADJUSTMENT (widget)->value);
}
-void toggle_reorderable (GtkWidget *widget, GtkCTree *ctree)
+void change_row_height (GtkWidget *widget, GtkCList *clist)
{
- gtk_ctree_set_reorderable (ctree, GTK_TOGGLE_BUTTON (widget)->active);
+ gtk_clist_set_row_height (clist, GTK_ADJUSTMENT (widget)->value);
}
-void set_background (GtkCTree *ctree, GList *node, gpointer data)
+void set_background (GtkCTree *ctree, GtkCTreeNode *node, gpointer data)
{
+ GtkStyle *style = NULL;
+
if (!node)
return;
if (ctree->line_style != GTK_CTREE_LINES_TABBED)
{
- if (GTK_CTREE_ROW (node)->is_leaf)
- gtk_ctree_set_background
- (ctree, node,
- GTK_CTREE_ROW (GTK_CTREE_ROW (node)->parent)->row.data);
- else
- gtk_ctree_set_background (ctree, node, GTK_CTREE_ROW (node)->row.data);
+ if (!GTK_CTREE_ROW (node)->is_leaf)
+ style = GTK_CTREE_ROW (node)->row.data;
+ else if (GTK_CTREE_ROW (node)->parent)
+ style = GTK_CTREE_ROW (GTK_CTREE_ROW (node)->parent)->row.data;
}
- else
- gtk_ctree_set_background (ctree, node, NULL);
+
+ gtk_ctree_node_set_row_style (ctree, node, style);
}
-void toggle_line_style (GtkWidget *widget, GtkCTree *ctree)
+void ctree_toggle_line_style (GtkWidget *widget, GtkCTree *ctree)
{
gint i;
return;
RADIOMENUTOGGLED ((GtkRadioMenuItem *)
- (((GtkOptionMenu *)omenu2)->menu_item),i);
+ (((GtkOptionMenu *)omenu1)->menu_item), i);
if ((ctree->line_style == GTK_CTREE_LINES_TABBED &&
- ((GtkCTreeLineStyle) (3-i)) != GTK_CTREE_LINES_TABBED) ||
+ ((GtkCTreeLineStyle) (3 - i)) != GTK_CTREE_LINES_TABBED) ||
(ctree->line_style != GTK_CTREE_LINES_TABBED &&
- ((GtkCTreeLineStyle) (3-i)) == GTK_CTREE_LINES_TABBED))
- gtk_ctree_pre_recursive (ctree, GTK_CLIST (ctree)->row_list,
- set_background, NULL);
- gtk_ctree_set_line_style (ctree, (GtkCTreeLineStyle) (3-i));
+ ((GtkCTreeLineStyle) (3 - 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;
}
-void toggle_justify (GtkWidget *widget, GtkCTree *ctree)
+void ctree_toggle_expander_style (GtkWidget *widget, GtkCTree *ctree)
{
gint i;
return;
RADIOMENUTOGGLED ((GtkRadioMenuItem *)
- (((GtkOptionMenu *)omenu3)->menu_item),i);
+ (((GtkOptionMenu *)omenu2)->menu_item), i);
+
+ gtk_ctree_set_expander_style (ctree, (GtkCTreeExpanderStyle) (3 - i));
+}
+
+void ctree_toggle_justify (GtkWidget *widget, GtkCTree *ctree)
+{
+ gint i;
+
+ if (!GTK_WIDGET_MAPPED (widget))
+ return;
+
+ RADIOMENUTOGGLED ((GtkRadioMenuItem *)
+ (((GtkOptionMenu *)omenu3)->menu_item), i);
gtk_clist_set_column_justification (GTK_CLIST (ctree), ctree->tree_column,
- (GtkJustification) (1-i));
+ (GtkJustification) (1 - i));
}
-void toggle_sel_mode (GtkWidget *widget, GtkCTree *ctree)
+void ctree_toggle_sel_mode (GtkWidget *widget, GtkCTree *ctree)
{
gint i;
return;
RADIOMENUTOGGLED ((GtkRadioMenuItem *)
- (((GtkOptionMenu *)omenu)->menu_item), i);
+ (((GtkOptionMenu *)omenu4)->menu_item), i);
- gtk_clist_set_selection_mode (GTK_CLIST (ctree), (GtkSelectionMode) (3-i));
+ gtk_clist_set_selection_mode (GTK_CLIST (ctree), (GtkSelectionMode) (3 - i));
after_press (ctree, NULL);
}
-
+
void build_recursive (GtkCTree *ctree, gint cur_depth, gint depth,
- gint num_books, gint num_pages, GList *parent)
+ gint num_books, gint num_pages, GtkCTreeNode *parent)
{
gchar *text[2];
gchar buf1[60];
gchar buf2[60];
- GList *sibling;
+ GtkCTreeNode *sibling;
gint i;
text[0] = buf1;
pages++;
sprintf (buf1, "Page %02d", (gint) rand() % 100);
sprintf (buf2, "Item %d-%d", cur_depth, i);
- sibling = gtk_ctree_insert (ctree, parent, sibling, text, 5, pixmap3,
- mask3, NULL, NULL, TRUE, FALSE);
+ sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
+ pixmap3, mask3, NULL, NULL,
+ TRUE, FALSE);
- if (ctree->line_style == GTK_CTREE_LINES_TABBED)
- gtk_ctree_set_background (ctree, sibling, col_bg);
+ if (parent && ctree->line_style == GTK_CTREE_LINES_TABBED)
+ gtk_ctree_node_set_row_style (ctree, sibling,
+ GTK_CTREE_ROW (parent)->row.style);
}
if (cur_depth == depth)
for (i = num_books; i > 0; i--)
{
+ GtkStyle *style;
+
books++;
sprintf (buf1, "Book %02d", (gint) rand() % 100);
sprintf (buf2, "Item %d-%d", cur_depth, i);
- sibling = gtk_ctree_insert (ctree, parent, sibling, text, 5, pixmap1,
- mask1, pixmap2, mask2, FALSE, FALSE);
-
- col_bg = g_new (GdkColor, 1);
+ sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
+ pixmap1, mask1, pixmap2, mask2,
+ FALSE, FALSE);
- if (cur_depth % 3 == 0)
+ style = gtk_style_new ();
+ switch (cur_depth % 3)
{
- col_bg->red = 10000 * (cur_depth % 6);
- col_bg->green = 0;
- col_bg->blue = 65535 - ((i * 10000) % 65535);
- }
- else if (cur_depth % 3 == 1)
- {
- col_bg->red = 10000 * (cur_depth % 6);
- col_bg->green = 65535 - ((i * 10000) % 65535);
- col_bg->blue = 0;
- }
- else
- {
- col_bg->red = 65535 - ((i * 10000) % 65535);
- col_bg->green = 0;
- col_bg->blue = 10000 * (cur_depth % 6);
+ case 0:
+ style->base[GTK_STATE_NORMAL].red = 10000 * (cur_depth % 6);
+ style->base[GTK_STATE_NORMAL].green = 0;
+ style->base[GTK_STATE_NORMAL].blue = 65535 - ((i * 10000) % 65535);
+ break;
+ case 1:
+ style->base[GTK_STATE_NORMAL].red = 10000 * (cur_depth % 6);
+ style->base[GTK_STATE_NORMAL].green = 65535 - ((i * 10000) % 65535);
+ style->base[GTK_STATE_NORMAL].blue = 0;
+ break;
+ default:
+ style->base[GTK_STATE_NORMAL].red = 65535 - ((i * 10000) % 65535);
+ style->base[GTK_STATE_NORMAL].green = 0;
+ style->base[GTK_STATE_NORMAL].blue = 10000 * (cur_depth % 6);
+ break;
}
-
- gdk_color_alloc (gtk_widget_get_colormap (GTK_WIDGET (ctree)), col_bg);
- gtk_ctree_set_row_data_full (ctree, sibling, col_bg, g_free);
+ gtk_ctree_node_set_row_data_full (ctree, sibling, style,
+ (GtkDestroyNotify) gtk_style_unref);
if (ctree->line_style == GTK_CTREE_LINES_TABBED)
- gtk_ctree_set_background (ctree, sibling, col_bg);
+ gtk_ctree_node_set_row_style (ctree, sibling, style);
build_recursive (ctree, cur_depth + 1, depth, num_books, num_pages,
sibling);
gchar *text [2];
gchar label1[] = "Root";
gchar label2[] = "";
- GList *parent;
+ GtkCTreeNode *parent;
+ GtkStyle *style;
guint b, d, p, n;
text[0] = label1;
books = 1;
pages = 0;
- parent = gtk_ctree_insert (ctree, NULL, NULL, text, 5, pixmap1,
- mask1, pixmap2, mask2, FALSE, TRUE);
+ parent = gtk_ctree_insert_node (ctree, NULL, NULL, text, 5, pixmap1,
+ mask1, pixmap2, mask2, FALSE, TRUE);
+
+ style = gtk_style_new ();
+ style->base[GTK_STATE_NORMAL].red = 0;
+ style->base[GTK_STATE_NORMAL].green = 45000;
+ style->base[GTK_STATE_NORMAL].blue = 55000;
+ gtk_ctree_node_set_row_data_full (ctree, parent, style,
+ (GtkDestroyNotify) gtk_style_unref);
- col_bg = g_new (GdkColor, 1);
- col_bg->red = 0;
- col_bg->green = 45000;
- col_bg->blue = 55000;
- gdk_color_alloc (gtk_widget_get_colormap (GTK_WIDGET (ctree)), col_bg);
- gtk_ctree_set_row_data_full (ctree, parent, col_bg, g_free);
if (ctree->line_style == GTK_CTREE_LINES_TABBED)
- gtk_ctree_set_background (ctree, parent, col_bg);
+ gtk_ctree_node_set_row_style (ctree, parent, style);
build_recursive (ctree, 1, d, b, p, parent);
gtk_clist_thaw (GTK_CLIST (ctree));
after_press (ctree, NULL);
}
+static void
+ctree_click_column (GtkCTree *ctree, gint column, gpointer data)
+{
+ GtkCList *clist;
+
+ clist = GTK_CLIST (ctree);
+
+ if (column == clist->sort_column)
+ {
+ if (clist->sort_type == GTK_SORT_ASCENDING)
+ clist->sort_type = GTK_SORT_DESCENDING;
+ else
+ clist->sort_type = GTK_SORT_ASCENDING;
+ }
+ else
+ gtk_clist_set_sort_column (clist, column);
+
+ gtk_ctree_sort_recursive (ctree, NULL);
+}
+
void create_ctree (void)
{
static GtkWidget *window = NULL;
GtkTooltips *tooltips;
GtkCTree *ctree;
+ GtkWidget *scrolled_win;
GtkWidget *vbox;
+ GtkWidget *bbox;
+ GtkWidget *mbox;
GtkWidget *hbox;
GtkWidget *hbox2;
GtkWidget *frame;
GtkWidget *label;
GtkWidget *button;
- GtkWidget *menu_item;
- GtkWidget *menu;
- GtkWidget *submenu;
GtkWidget *check;
GtkAdjustment *adj;
GtkWidget *spinner;
- GSList *group;
- GdkColor transparent;
+ GdkColor transparent = { 0 };
char *title[] = { "Tree" , "Info" };
char buf[80];
+ static OptionMenuItem items1[] =
+ {
+ { "No lines", ctree_toggle_line_style },
+ { "Solid", ctree_toggle_line_style },
+ { "Dotted", ctree_toggle_line_style },
+ { "Tabbed", ctree_toggle_line_style }
+ };
+
+ static OptionMenuItem items2[] =
+ {
+ { "None", ctree_toggle_expander_style },
+ { "Square", ctree_toggle_expander_style },
+ { "Triangle", ctree_toggle_expander_style },
+ { "Circular", ctree_toggle_expander_style }
+ };
+
+ static OptionMenuItem items3[] =
+ {
+ { "Left", ctree_toggle_justify },
+ { "Right", ctree_toggle_justify }
+ };
+
+ static OptionMenuItem items4[] =
+ {
+ { "Single", ctree_toggle_sel_mode },
+ { "Browse", ctree_toggle_sel_mode },
+ { "Multiple", ctree_toggle_sel_mode },
+ { "Extended", ctree_toggle_sel_mode }
+ };
+
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
&window);
gtk_window_set_title (GTK_WINDOW (window), "GtkCTree");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
tooltips = gtk_tooltips_new ();
gtk_object_ref (GTK_OBJECT (tooltips));
gtk_container_add (GTK_CONTAINER (window), vbox);
hbox = gtk_hbox_new (FALSE, 5);
- gtk_container_border_width (GTK_CONTAINER (hbox), 5);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
label = gtk_label_new ("Depth :");
(GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT(window));
- button = gtk_button_new_with_label ("Rebuild tree");
+ button = gtk_button_new_with_label ("Rebuild Tree");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
-
+
+ scrolled_win = gtk_scrolled_window_new (NULL, NULL);
+ gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_ALWAYS);
+ gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
+
ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
+ gtk_container_add (GTK_CONTAINER (scrolled_win), GTK_WIDGET (ctree));
+
+ gtk_clist_set_column_auto_resize (GTK_CLIST (ctree), 0, TRUE);
+ gtk_clist_set_column_width (GTK_CLIST (ctree), 1, 200);
+ gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_EXTENDED);
gtk_ctree_set_line_style (ctree, GTK_CTREE_LINES_DOTTED);
- gtk_ctree_set_reorderable (ctree, TRUE);
- gtk_signal_connect (GTK_OBJECT (ctree), "button_press_event",
- GTK_SIGNAL_FUNC (button_press), NULL);
+ line_style = GTK_CTREE_LINES_DOTTED;
+
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (rebuild_tree), ctree);
+ gtk_signal_connect (GTK_OBJECT (ctree), "click_column",
+ (GtkSignalFunc) ctree_click_column, NULL);
+
gtk_signal_connect_after (GTK_OBJECT (ctree), "button_press_event",
GTK_SIGNAL_FUNC (after_press), NULL);
- gtk_signal_connect (GTK_OBJECT (ctree), "button_release_event",
- GTK_SIGNAL_FUNC (button_release), NULL);
gtk_signal_connect_after (GTK_OBJECT (ctree), "button_release_event",
GTK_SIGNAL_FUNC (after_press), NULL);
gtk_signal_connect_after (GTK_OBJECT (ctree), "tree_move",
GTK_SIGNAL_FUNC (after_press), NULL);
gtk_signal_connect_after (GTK_OBJECT (ctree), "scroll_vertical",
GTK_SIGNAL_FUNC (after_press), NULL);
-
- gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (ctree), TRUE, TRUE, 0);
- gtk_clist_column_titles_passive (GTK_CLIST (ctree));
- gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_EXTENDED);
- gtk_clist_set_policy (GTK_CLIST (ctree), GTK_POLICY_ALWAYS,
- GTK_POLICY_AUTOMATIC);
- gtk_clist_set_column_width (GTK_CLIST (ctree), 0, 200);
- gtk_clist_set_column_width (GTK_CLIST (ctree), 1, 200);
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (rebuild_tree), ctree);
-
- hbox = gtk_hbox_new (FALSE, 5);
- gtk_container_border_width (GTK_CONTAINER (hbox), 5);
- gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
+ bbox = gtk_hbox_new (FALSE, 5);
+ gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
+ gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, TRUE, 0);
- button = gtk_button_new_with_label ("Expand all");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (expand_all), ctree);
- gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+ mbox = gtk_vbox_new (TRUE, 5);
+ gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
- button = gtk_button_new_with_label ("Collapse all");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (collapse_all), ctree);
- gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+ label = gtk_label_new ("Row Height :");
+ gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
- button = gtk_button_new_with_label ("Sort tree");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (sort_all), ctree);
- gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+ label = gtk_label_new ("Indent :");
+ gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
- hbox = gtk_hbox_new (FALSE, 5);
- gtk_container_border_width (GTK_CONTAINER (hbox), 5);
- gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
+ label = gtk_label_new ("Spacing :");
+ gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
+
+ mbox = gtk_vbox_new (TRUE, 5);
+ gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
- label = gtk_label_new ("Row height :");
- gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
-
adj = (GtkAdjustment *) gtk_adjustment_new (20, 12, 100, 1, 10, 0);
spinner = gtk_spin_button_new (adj, 0, 0);
+ gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
gtk_tooltips_set_tip (tooltips, spinner,
"Row height of list items", NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (change_row_height), ctree);
- gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, TRUE, 5);
gtk_clist_set_row_height ( GTK_CLIST (ctree), adj->value);
- button = gtk_button_new_with_label ("Select all");
+ adj = (GtkAdjustment *) gtk_adjustment_new (20, 0, 60, 1, 10, 0);
+ spinner = gtk_spin_button_new (adj, 0, 0);
+ gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
+ gtk_tooltips_set_tip (tooltips, spinner, "Tree Indentation.", NULL);
+ gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
+ GTK_SIGNAL_FUNC (change_indent), ctree);
+
+ adj = (GtkAdjustment *) gtk_adjustment_new (5, 0, 60, 1, 10, 0);
+ spinner = gtk_spin_button_new (adj, 0, 0);
+ gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
+ gtk_tooltips_set_tip (tooltips, spinner, "Tree Spacing.", NULL);
+ gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
+ GTK_SIGNAL_FUNC (change_spacing), ctree);
+
+ mbox = gtk_vbox_new (TRUE, 5);
+ gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
+
+ hbox = gtk_hbox_new (FALSE, 5);
+ gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Expand All");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (select_all), ctree);
+ GTK_SIGNAL_FUNC (expand_all), ctree);
+
+ button = gtk_button_new_with_label ("Collapse All");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (collapse_all), ctree);
- button = gtk_button_new_with_label ("Unselect all");
+ button = gtk_button_new_with_label ("Change Style");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (unselect_all), ctree);
+ GTK_SIGNAL_FUNC (change_style), ctree);
+
+ button = gtk_button_new_with_label ("Export Tree");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (export_ctree), ctree);
- button = gtk_button_new_with_label ("Remove selection");
+ hbox = gtk_hbox_new (FALSE, 5);
+ gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Select All");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (remove_selection), ctree);
+ GTK_SIGNAL_FUNC (select_all), ctree);
+
+ button = gtk_button_new_with_label ("Unselect All");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (unselect_all), ctree);
+
+ button = gtk_button_new_with_label ("Remove Selection");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (remove_selection), ctree);
- hbox = gtk_hbox_new (TRUE, 5);
- gtk_container_border_width (GTK_CONTAINER (hbox), 5);
- gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
-
- hbox2 = gtk_hbox_new (FALSE, 0);
- gtk_box_pack_start (GTK_BOX (hbox), hbox2, FALSE, TRUE, 0);
-
- label = gtk_label_new ("Indent :");
- gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
-
- adj = (GtkAdjustment *) gtk_adjustment_new (20, 0, 60, 1, 10, 0);
- spinner = gtk_spin_button_new (adj, 0, 0);
- gtk_tooltips_set_tip (tooltips, spinner, "Tree indentation.", NULL);
- gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
- GTK_SIGNAL_FUNC (change_indent), ctree);
- gtk_box_pack_start (GTK_BOX (hbox2), spinner, FALSE, TRUE, 5);
-
check = gtk_check_button_new_with_label ("Reorderable");
+ gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, check,
"Tree items can be reordered by dragging.", NULL);
gtk_signal_connect (GTK_OBJECT (check), "clicked",
GTK_SIGNAL_FUNC (toggle_reorderable), ctree);
- gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
- gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (check), TRUE);
-
- omenu2 = gtk_option_menu_new ();
- gtk_tooltips_set_tip (tooltips, omenu2, "The tree's line style.", NULL);
-
- menu = gtk_menu_new ();
- submenu = NULL;
- group = NULL;
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Solid");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (toggle_line_style), ctree);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_widget_show (menu_item);
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Dotted");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (toggle_line_style), ctree);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_widget_show (menu_item);
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Tabbed");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (toggle_line_style), ctree);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_widget_show (menu_item);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
+
+ 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);
+ 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);
+ 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);
+ 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);
+ gtk_box_pack_start (GTK_BOX (hbox), omenu4, FALSE, TRUE, 0);
+ gtk_tooltips_set_tip (tooltips, omenu4, "The list's selection mode.",
+ NULL);
- menu_item = gtk_radio_menu_item_new_with_label (group, "No lines");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (toggle_line_style), ctree);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_widget_show (menu_item);
-
- gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu2), menu);
- gtk_box_pack_start (GTK_BOX (hbox), omenu2, FALSE, TRUE, 0);
-
- gtk_option_menu_set_history (GTK_OPTION_MENU (omenu2), 1);
-
- omenu3 = gtk_option_menu_new ();
- gtk_tooltips_set_tip (tooltips, omenu3, "The tree's justification.",
- NULL);
-
- menu = gtk_menu_new ();
- submenu = NULL;
- group = NULL;
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Left");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (toggle_justify), ctree);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
- gtk_widget_show (menu_item);
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Right");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (toggle_justify), ctree);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_widget_show (menu_item);
-
- gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu3), menu);
- gtk_box_pack_start (GTK_BOX (hbox), omenu3, FALSE, TRUE, 0);
-
- gtk_option_menu_set_history (GTK_OPTION_MENU (omenu3), 0);
-
- omenu = gtk_option_menu_new ();
- gtk_tooltips_set_tip (tooltips, omenu, "The list's selection mode.",
- NULL);
-
- menu = gtk_menu_new ();
- submenu = NULL;
- group = NULL;
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Single");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (toggle_sel_mode), ctree);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_widget_show (menu_item);
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Browse");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (toggle_sel_mode), ctree);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_widget_show (menu_item);
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Multiple");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (toggle_sel_mode), ctree);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_widget_show (menu_item);
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Extended");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (toggle_sel_mode), ctree);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
- gtk_widget_show (menu_item);
-
- gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
- gtk_box_pack_start (GTK_BOX (hbox), omenu, FALSE, TRUE, 0);
-
- gtk_option_menu_set_history (GTK_OPTION_MENU (omenu), 3);
-
gtk_widget_realize (window);
-
+
pixmap1 = gdk_pixmap_create_from_xpm_d (window->window, &mask1,
&transparent, book_closed_xpm);
pixmap2 = gdk_pixmap_create_from_xpm_d (window->window, &mask2,
&transparent, book_open_xpm);
pixmap3 = gdk_pixmap_create_from_xpm_d (window->window, &mask3,
&transparent, mini_page_xpm);
-
+
gtk_widget_set_usize (GTK_WIDGET (ctree), 0, 300);
-
+
frame = gtk_frame_new (NULL);
- gtk_container_border_width (GTK_CONTAINER (frame), 0);
+ gtk_container_set_border_width (GTK_CONTAINER (frame), 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
-
+
hbox = gtk_hbox_new (TRUE, 2);
- gtk_container_border_width (GTK_CONTAINER (hbox), 2);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
gtk_container_add (GTK_CONTAINER (frame), hbox);
-
+
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
-
+
hbox2 = gtk_hbox_new (FALSE, 0);
- gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
gtk_container_add (GTK_CONTAINER (frame), hbox2);
-
+
label = gtk_label_new ("Books :");
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
-
+
sprintf (buf, "%d", books);
book_label = gtk_label_new (buf);
gtk_box_pack_end (GTK_BOX (hbox2), book_label, FALSE, TRUE, 5);
-
+
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
-
+
hbox2 = gtk_hbox_new (FALSE, 0);
- gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
gtk_container_add (GTK_CONTAINER (frame), hbox2);
-
+
label = gtk_label_new ("Pages :");
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
-
+
sprintf (buf, "%d", pages);
page_label = gtk_label_new (buf);
gtk_box_pack_end (GTK_BOX (hbox2), page_label, FALSE, TRUE, 5);
-
+
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
-
+
hbox2 = gtk_hbox_new (FALSE, 0);
- gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
gtk_container_add (GTK_CONTAINER (frame), hbox2);
-
+
label = gtk_label_new ("Selected :");
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
-
+
sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
sel_label = gtk_label_new (buf);
gtk_box_pack_end (GTK_BOX (hbox2), sel_label, FALSE, TRUE, 5);
-
+
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
-
+
hbox2 = gtk_hbox_new (FALSE, 0);
- gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
gtk_container_add (GTK_CONTAINER (frame), hbox2);
-
+
label = gtk_label_new ("Visible :");
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
-
+
sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
vis_label = gtk_label_new (buf);
gtk_box_pack_end (GTK_BOX (hbox2), vis_label, FALSE, TRUE, 5);
}
/*
- * GtkColorSelect
+ * GtkColorSelection
*/
+
void
color_selection_ok (GtkWidget *w,
GtkColorSelectionDialog *cs)
GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
GTK_UPDATE_CONTINUOUS);
- gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
+ gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
gtk_widget_destroy (window);
}
+/*
+ * GtkFileSelection
+ */
+
void
file_selection_hide_fileops (GtkWidget *widget,
GtkFileSelection *fs)
gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window));
- gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
+ gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
button, FALSE, FALSE, 0);
gtk_widget_show (button);
-
-
-
}
if (!GTK_WIDGET_VISIBLE (window))
gtk_widget_destroy (window);
}
+/*
+ * GtkFontSelection
+ */
+
void
font_selection_ok (GtkWidget *w,
GtkFontSelectionDialog *fs)
{
- g_print ("%s\n", gtk_font_selection_dialog_get_font_name (fs));
+ gchar *s = gtk_font_selection_dialog_get_font_name (fs);
+
+ g_print ("%s\n", s);
+ g_free (s);
gtk_widget_destroy (GTK_WIDGET (fs));
}
{
window = gtk_font_selection_dialog_new ("Font Selection Dialog");
- gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
+ gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
gtk_widget_destroy (window);
}
-
/*
* GtkDialog
*/
+
static GtkWidget *dialog_window = NULL;
-void
+static void
label_toggle (GtkWidget *widget,
GtkWidget **label)
{
gtk_widget_destroy (*label);
}
-void
+static void
create_dialog (void)
{
static GtkWidget *label;
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&dialog_window);
- gtk_window_set_title (GTK_WINDOW (dialog_window), "dialog");
- gtk_container_border_width (GTK_CONTAINER (dialog_window), 0);
+ gtk_window_set_title (GTK_WINDOW (dialog_window), "GtkDialog");
+ gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
+ gtk_widget_set_usize (dialog_window, 200, 110);
button = gtk_button_new_with_label ("OK");
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_destroy (dialog_window);
}
+/* Event Watcher
+ */
+static gboolean event_watcher_enter_id = 0;
+static gboolean event_watcher_leave_id = 0;
+
+static gboolean
+event_watcher (GtkObject *object,
+ guint signal_id,
+ guint n_params,
+ GtkArg *params,
+ gpointer data)
+{
+ g_print ("Watch: \"%s\" emitted for %s\n",
+ gtk_signal_name (signal_id),
+ gtk_type_name (GTK_OBJECT_TYPE (object)));
+
+ return TRUE;
+}
+
+static void
+event_watcher_down (void)
+{
+ if (event_watcher_enter_id)
+ {
+ guint signal_id;
+
+ signal_id = gtk_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
+ gtk_signal_remove_emission_hook (signal_id, event_watcher_enter_id);
+ event_watcher_enter_id = 0;
+ signal_id = gtk_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
+ gtk_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 = gtk_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
+ event_watcher_enter_id = gtk_signal_add_emission_hook (signal_id, event_watcher, NULL);
+ signal_id = gtk_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
+ event_watcher_leave_id = gtk_signal_add_emission_hook (signal_id, event_watcher, NULL);
+ }
+}
+
+static void
+create_event_watcher (void)
+{
+ GtkWidget *button;
+
+ if (!dialog_window)
+ {
+ dialog_window = gtk_dialog_new ();
+
+ gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
+ GTK_SIGNAL_FUNC (gtk_widget_destroyed),
+ &dialog_window);
+ gtk_signal_connect (GTK_OBJECT (dialog_window),
+ "destroy",
+ GTK_SIGNAL_FUNC (event_watcher_down),
+ NULL);
+
+ gtk_window_set_title (GTK_WINDOW (dialog_window), "Event Watcher");
+ gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
+ gtk_widget_set_usize (dialog_window, 200, 110);
+
+ button = gtk_toggle_button_new_with_label ("Activate Watch");
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (event_watcher_toggle),
+ NULL);
+ gtk_container_set_border_width (GTK_CONTAINER (button), 10);
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
+ button, TRUE, TRUE, 0);
+ gtk_widget_show (button);
+
+ button = gtk_button_new_with_label ("Close");
+ gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (gtk_widget_destroy),
+ (GtkObject*) dialog_window);
+ GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
+ button, TRUE, TRUE, 0);
+ gtk_widget_grab_default (button);
+ gtk_widget_show (button);
+ }
+
+ if (!GTK_WIDGET_VISIBLE (dialog_window))
+ gtk_widget_show (dialog_window);
+ else
+ gtk_widget_destroy (dialog_window);
+}
/*
* GtkRange
*/
-void
+
+static void
create_range_controls (void)
{
static GtkWidget *window = NULL;
&window);
gtk_window_set_title (GTK_WINDOW (window), "range controls");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_vbox_new (FALSE, 0);
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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);
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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);
gtk_widget_destroy (window);
}
-
/*
* GtkRulers
*/
+
void
create_rulers (void)
{
gtk_widget_set_events (window,
GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK);
- gtk_container_border_width (GTK_CONTAINER (window), 0);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
table = gtk_table_new (2, 2, FALSE);
gtk_container_add (GTK_CONTAINER (window), table);
gtk_widget_destroy (window);
}
-
static void
text_toggle_editable (GtkWidget *checkbutton,
GtkWidget *text)
GTK_TOGGLE_BUTTON(checkbutton)->active);
}
+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]);
+
/*
* GtkText
*/
+void
+text_insert_random (GtkWidget *w, GtkText *text)
+{
+ int i;
+ char c;
+ for (i=0; i<10; i++)
+ {
+ c = 'A' + rand() % ('Z' - 'A');
+ gtk_text_set_point (text, rand() % gtk_text_get_length (text));
+ gtk_text_insert (text, NULL, NULL, NULL, &c, 1);
+ }
+}
+
void
create_text (void)
{
+ int i, j;
+
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *button;
GtkWidget *check;
GtkWidget *separator;
- GtkWidget *table;
- GtkWidget *hscrollbar;
- GtkWidget *vscrollbar;
+ GtkWidget *scrolled_window;
GtkWidget *text;
+ GdkFont *font;
FILE *infile;
&window);
gtk_window_set_title (GTK_WINDOW (window), "test");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_vbox_new (FALSE, 0);
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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);
- table = gtk_table_new (2, 2, FALSE);
- gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
- gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
- gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
- gtk_widget_show (table);
+ scrolled_window = gtk_scrolled_window_new (NULL, NULL);
+ gtk_box_pack_start (GTK_BOX (box2), scrolled_window, TRUE, TRUE, 0);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
+ GTK_POLICY_NEVER,
+ GTK_POLICY_ALWAYS);
+ gtk_widget_show (scrolled_window);
text = gtk_text_new (NULL, NULL);
gtk_text_set_editable (GTK_TEXT (text), TRUE);
- gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
- GTK_EXPAND | GTK_SHRINK | GTK_FILL,
- GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
+ gtk_container_add (GTK_CONTAINER (scrolled_window), text);
+ gtk_widget_grab_focus (text);
gtk_widget_show (text);
- hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
- gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
- GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0);
- gtk_widget_show (hscrollbar);
-
- vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
- gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
- GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
- gtk_widget_show (vscrollbar);
gtk_text_freeze (GTK_TEXT (text));
- gtk_widget_realize (text);
+ font = gdk_font_load ("-adobe-courier-medium-r-normal--*-120-*-*-*-*-*-*");
+
+ for (i=0; i<ntext_colors; i++)
+ {
+ gtk_text_insert (GTK_TEXT (text), font, NULL, NULL,
+ text_colors[i].name, -1);
+ gtk_text_insert (GTK_TEXT (text), font, NULL, NULL, "\t", -1);
+
+ for (j=0; j<ntext_colors; j++)
+ {
+ gtk_text_insert (GTK_TEXT (text), font,
+ &text_colors[j].color, &text_colors[i].color,
+ "XYZ", -1);
+ }
+ gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL, "\n", -1);
+ }
+
+ /* The Text widget will reference count the font, so we
+ * unreference it here
+ */
+ gdk_font_unref (font);
infile = fopen("testgtk.c", "r");
if (infile)
{
- char buffer[1024];
- int nchars;
+ char *buffer;
+ int nbytes_read, nbytes_alloc;
+ nbytes_read = 0;
+ nbytes_alloc = 1024;
+ buffer = g_new (char, nbytes_alloc);
while (1)
{
- nchars = fread(buffer, 1, 1024, infile);
- gtk_text_insert (GTK_TEXT (text), NULL, NULL,
- NULL, buffer, nchars);
-
- if (nchars < 1024)
+ int len;
+ if (nbytes_alloc < nbytes_read + 1024)
+ {
+ nbytes_alloc *= 2;
+ buffer = g_realloc (buffer, nbytes_alloc);
+ }
+ len = fread (buffer + nbytes_read, 1, 1024, infile);
+ nbytes_read += len;
+ if (len < 1024)
break;
}
+ gtk_text_insert (GTK_TEXT (text), NULL, NULL,
+ NULL, buffer, nbytes_read);
+ g_free(buffer);
fclose (infile);
}
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
- "And even ", -1);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->bg[GTK_STATE_NORMAL], NULL,
- "colored", -1);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
- "text", -1);
-
gtk_text_thaw (GTK_TEXT (text));
hbox = gtk_hbutton_box_new ();
gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT(check), "toggled",
GTK_SIGNAL_FUNC(text_toggle_editable), text);
- gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
gtk_widget_show (check);
check = gtk_check_button_new_with_label("Wrap Words");
gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT(check), "toggled",
GTK_SIGNAL_FUNC(text_toggle_word_wrap), text);
- gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), FALSE);
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), FALSE);
gtk_widget_show (check);
separator = gtk_hseparator_new ();
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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 ("insert random");
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC(text_insert_random),
+ GTK_TEXT (text));
+ gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
+ gtk_widget_show (button);
+
button = gtk_button_new_with_label ("close");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
gtk_widget_destroy (window);
}
-
/*
* GtkNotebook
*/
GdkPixmap *book_closed;
GdkBitmap *book_open_mask;
GdkBitmap *book_closed_mask;
-
-
-static void
-notebook_reparent (GtkWidget *widget, GtkWidget *scrollwin)
-{
- static GtkWidget *parent = NULL;
- static GtkWidget *float_parent;
-
- if (parent)
- {
- gtk_widget_reparent (scrollwin, parent);
- gtk_widget_destroy (float_parent);
- float_parent = NULL;
- parent = NULL;
- }
- else
- {
- parent = widget->parent;
- float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_widget_show (float_parent);
- gtk_widget_reparent (scrollwin, float_parent);
- }
-}
+GtkWidget *sample_notebook;
static void
page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
if (page == oldpage)
return;
-
- pixwid = ((GtkBoxChild*)(GTK_BOX (page->tab_label)->children->data))->widget;
+ pixwid = ((GtkBoxChild*)
+ (GTK_BOX (page->tab_label)->children->data))->widget;
gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
- pixwid = ((GtkBoxChild*) (GTK_BOX (page->menu_label)->children->data))->widget;
+ pixwid = ((GtkBoxChild*)
+ (GTK_BOX (page->menu_label)->children->data))->widget;
gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
if (oldpage)
{
- pixwid = ((GtkBoxChild*) (GTK_BOX
- (oldpage->tab_label)->children->data))->widget;
+ pixwid = ((GtkBoxChild*)
+ (GTK_BOX (oldpage->tab_label)->children->data))->widget;
gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
- pixwid = ((GtkBoxChild*) (GTK_BOX (oldpage->menu_label)->children->data))->widget;
+ pixwid = ((GtkBoxChild*)
+ (GTK_BOX (oldpage->menu_label)->children->data))->widget;
gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
}
}
+static void
+tab_fill (GtkToggleButton *button, GtkWidget *child)
+{
+ gboolean expand;
+ GtkPackType pack_type;
+
+ gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
+ &expand, NULL, &pack_type);
+ gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
+ expand, button->active, pack_type);
+}
+
+static void
+tab_expand (GtkToggleButton *button, GtkWidget *child)
+{
+ gboolean fill;
+ GtkPackType pack_type;
+
+ gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
+ NULL, &fill, &pack_type);
+ gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
+ button->active, fill, pack_type);
+}
+
+static void
+tab_pack (GtkToggleButton *button, GtkWidget *child)
+
+{
+ gboolean expand;
+ gboolean fill;
+
+ gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
+ &expand, &fill, NULL);
+ gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
+ expand, fill, button->active);
+}
+
static void
create_pages (GtkNotebook *notebook, gint start, gint end)
{
GtkWidget *child = NULL;
+ GtkWidget *button;
GtkWidget *label;
- GtkWidget *entry;
- GtkWidget *box;
GtkWidget *hbox;
+ GtkWidget *vbox;
GtkWidget *label_box;
GtkWidget *menu_box;
- GtkWidget *button;
GtkWidget *pixwid;
gint i;
char buffer[32];
for (i = start; i <= end; i++)
{
sprintf (buffer, "Page %d", i);
-
- switch (i%4)
- {
- case 3:
- child = gtk_button_new_with_label (buffer);
- gtk_container_border_width (GTK_CONTAINER(child), 10);
- break;
- case 2:
- child = gtk_label_new (buffer);
- break;
- case 1:
- child = gtk_frame_new (buffer);
- gtk_container_border_width (GTK_CONTAINER (child), 10);
-
- box = gtk_vbox_new (TRUE,0);
- gtk_container_border_width (GTK_CONTAINER (box), 10);
- gtk_container_add (GTK_CONTAINER (child), box);
- label = gtk_label_new (buffer);
- gtk_box_pack_start (GTK_BOX(box), label, TRUE, TRUE, 5);
+ child = gtk_frame_new (buffer);
+ gtk_container_set_border_width (GTK_CONTAINER (child), 10);
- entry = gtk_entry_new ();
- gtk_box_pack_start (GTK_BOX(box), entry, TRUE, TRUE, 5);
-
- hbox = gtk_hbox_new (TRUE,0);
- gtk_box_pack_start (GTK_BOX(box), hbox, TRUE, TRUE, 5);
+ vbox = gtk_vbox_new (TRUE,0);
+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
+ gtk_container_add (GTK_CONTAINER (child), vbox);
- button = gtk_button_new_with_label ("Ok");
- gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
+ hbox = gtk_hbox_new (TRUE,0);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
- button = gtk_button_new_with_label ("Cancel");
- gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
- break;
- case 0:
- child = gtk_frame_new (buffer);
- gtk_container_border_width (GTK_CONTAINER (child), 10);
+ 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);
+ gtk_signal_connect (GTK_OBJECT (button), "toggled",
+ GTK_SIGNAL_FUNC (tab_fill), child);
- label = gtk_label_new (buffer);
- gtk_container_add (GTK_CONTAINER (child), label);
- break;
- }
+ button = gtk_check_button_new_with_label ("Expand Tab");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
+ gtk_signal_connect (GTK_OBJECT (button), "toggled",
+ GTK_SIGNAL_FUNC (tab_expand), child);
+
+ button = gtk_check_button_new_with_label ("Pack end");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
+ gtk_signal_connect (GTK_OBJECT (button), "toggled",
+ GTK_SIGNAL_FUNC (tab_pack), child);
+
+ button = gtk_button_new_with_label ("Hide Page");
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 5);
+ gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (gtk_widget_hide),
+ GTK_OBJECT (child));
gtk_widget_show_all (child);
label = gtk_label_new (buffer);
gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
gtk_widget_show_all (label_box);
-
+
menu_box = gtk_hbox_new (FALSE, 0);
pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
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);
}
}
gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
}
+static void
+show_all_pages (GtkButton *button,
+ GtkNotebook *notebook)
+{
+ gtk_container_foreach (GTK_CONTAINER (notebook),
+ (GtkCallback) gtk_widget_show, NULL);
+}
+
static void
standard_notebook (GtkButton *button,
- GtkNotebook *notebook)
+ GtkNotebook *notebook)
{
gint i;
static void
notabs_notebook (GtkButton *button,
- GtkNotebook *notebook)
+ GtkNotebook *notebook)
{
gint i;
static void
scrollable_notebook (GtkButton *button,
- GtkNotebook *notebook)
+ GtkNotebook *notebook)
{
gtk_notebook_set_show_tabs (notebook, TRUE);
gtk_notebook_set_scrollable (notebook, TRUE);
gtk_notebook_popup_disable (notebook);
}
+static void
+notebook_homogeneous (GtkToggleButton *button,
+ GtkNotebook *notebook)
+{
+ gtk_notebook_set_homogeneous_tabs (notebook, button->active);
+}
+
static void
create_notebook (void)
{
GtkWidget *box2;
GtkWidget *button;
GtkWidget *separator;
- GtkWidget *notebook;
GtkWidget *omenu;
- GtkWidget *menu;
- GtkWidget *submenu;
- GtkWidget *menuitem;
- GSList *group;
GdkColor *transparent = NULL;
+ GtkWidget *label;
+
+ static OptionMenuItem items[] =
+ {
+ { "Standard", standard_notebook },
+ { "No tabs", notabs_notebook },
+ { "Scrollable", scrollable_notebook }
+ };
if (!window)
{
&window);
gtk_window_set_title (GTK_WINDOW (window), "notebook");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
- notebook = gtk_notebook_new ();
- gtk_signal_connect (GTK_OBJECT (notebook), "switch_page",
+ sample_notebook = gtk_notebook_new ();
+ gtk_signal_connect (GTK_OBJECT (sample_notebook), "switch_page",
GTK_SIGNAL_FUNC (page_switch), NULL);
- gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
- gtk_box_pack_start (GTK_BOX (box1), notebook, TRUE, TRUE, 0);
- gtk_container_border_width (GTK_CONTAINER (notebook), 10);
+ 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 (notebook);
- book_open = gdk_pixmap_create_from_xpm_d (notebook->window,
+ gtk_widget_realize (sample_notebook);
+ book_open = gdk_pixmap_create_from_xpm_d (sample_notebook->window,
&book_open_mask,
transparent,
book_open_xpm);
- book_closed = gdk_pixmap_create_from_xpm_d (notebook->window,
+ book_closed = gdk_pixmap_create_from_xpm_d (sample_notebook->window,
&book_closed_mask,
transparent,
book_closed_xpm);
- create_pages (GTK_NOTEBOOK (notebook), 1, 5);
+ create_pages (GTK_NOTEBOOK (sample_notebook), 1, 5);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
- box2 = gtk_hbox_new (TRUE, 5);
- gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
-
- omenu = gtk_option_menu_new ();
- menu = gtk_menu_new ();
- submenu = NULL;
- group = NULL;
-
- menuitem = gtk_radio_menu_item_new_with_label (group, "Standard");
- gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
- GTK_SIGNAL_FUNC (standard_notebook),
- GTK_OBJECT (notebook));
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
- gtk_menu_append (GTK_MENU (menu), menuitem);
- gtk_widget_show (menuitem);
- menuitem = gtk_radio_menu_item_new_with_label (group, "w/o Tabs");
- gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
- GTK_SIGNAL_FUNC (notabs_notebook),
- GTK_OBJECT (notebook));
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
- gtk_menu_append (GTK_MENU (menu), menuitem);
- gtk_widget_show (menuitem);
- menuitem = gtk_radio_menu_item_new_with_label (group, "Scrollable");
- gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
- GTK_SIGNAL_FUNC (scrollable_notebook),
- GTK_OBJECT (notebook));
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
- gtk_menu_append (GTK_MENU (menu), menuitem);
- gtk_widget_show (menuitem);
-
- gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
- gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, FALSE, 0);
- button = gtk_check_button_new_with_label ("enable popup menu");
- gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
+ box2 = gtk_hbox_new (FALSE, 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);
gtk_signal_connect (GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC (notebook_popup),
- GTK_OBJECT (notebook));
-
- box2 = gtk_hbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 10);
+ GTK_OBJECT (sample_notebook));
+
+ button = gtk_check_button_new_with_label ("homogeneous tabs");
+ gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
+ gtk_signal_connect (GTK_OBJECT(button), "clicked",
+ GTK_SIGNAL_FUNC (notebook_homogeneous),
+ GTK_OBJECT (sample_notebook));
+
+ box2 = gtk_hbox_new (FALSE, 5);
+ 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");
+
+ label = gtk_label_new ("Notebook Style :");
+ gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
+
+ omenu = build_option_menu (items, 3, 0, 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);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (show_all_pages), sample_notebook);
+
+ box2 = gtk_hbox_new (TRUE, 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 ("prev");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (gtk_widget_destroy),
- GTK_OBJECT (window));
+ GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
+ GTK_OBJECT (sample_notebook));
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
- gtk_widget_grab_default (button);
button = gtk_button_new_with_label ("next");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_notebook_next_page),
- GTK_OBJECT (notebook));
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
-
- button = gtk_button_new_with_label ("prev");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
- GTK_OBJECT (notebook));
+ GTK_OBJECT (sample_notebook));
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
button = gtk_button_new_with_label ("rotate");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (rotate_notebook),
- notebook);
+ GTK_SIGNAL_FUNC (rotate_notebook), sample_notebook);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
- button = gtk_button_new_with_label ("reparent");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (notebook_reparent),
- notebook);
- 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, 5);
+
+ button = gtk_button_new_with_label ("close");
+ gtk_container_set_border_width (GTK_CONTAINER (button), 5);
+ gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (gtk_widget_destroy),
+ GTK_OBJECT (window));
+ gtk_box_pack_start (GTK_BOX (box1), button, FALSE, FALSE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_grab_default (button);
}
if (!GTK_WIDGET_VISIBLE (window))
gtk_widget_destroy (window);
}
-
/*
* GtkPanes
*/
+
+void
+toggle_resize (GtkWidget *widget, GtkWidget *child)
+{
+ GtkPaned *paned = GTK_PANED (child->parent);
+ gboolean is_child1 = (child == paned->child1);
+ gboolean resize, shrink;
+
+ resize = is_child1 ? paned->child1_resize : paned->child2_resize;
+ shrink = is_child1 ? paned->child1_shrink : paned->child2_shrink;
+
+ gtk_widget_ref (child);
+ gtk_container_remove (GTK_CONTAINER (child->parent), child);
+ if (is_child1)
+ gtk_paned_pack1 (paned, child, !resize, shrink);
+ else
+ gtk_paned_pack2 (paned, child, !resize, shrink);
+ gtk_widget_unref (child);
+}
+
+void
+toggle_shrink (GtkWidget *widget, GtkWidget *child)
+{
+ GtkPaned *paned = GTK_PANED (child->parent);
+ gboolean is_child1 = (child == paned->child1);
+ gboolean resize, shrink;
+
+ resize = is_child1 ? paned->child1_resize : paned->child2_resize;
+ shrink = is_child1 ? paned->child1_shrink : paned->child2_shrink;
+
+ gtk_widget_ref (child);
+ gtk_container_remove (GTK_CONTAINER (child->parent), child);
+ if (is_child1)
+ gtk_paned_pack1 (paned, child, resize, !shrink);
+ else
+ gtk_paned_pack2 (paned, child, resize, !shrink);
+ gtk_widget_unref (child);
+}
+
+GtkWidget *
+create_pane_options (GtkPaned *paned,
+ const gchar *frame_label,
+ const gchar *label1,
+ const gchar *label2)
+{
+ GtkWidget *frame;
+ GtkWidget *table;
+ GtkWidget *label;
+ GtkWidget *check_button;
+
+ frame = gtk_frame_new (frame_label);
+ gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
+
+ table = gtk_table_new (3, 2, 4);
+ gtk_container_add (GTK_CONTAINER (frame), table);
+
+ label = gtk_label_new (label1);
+ gtk_table_attach_defaults (GTK_TABLE (table), label,
+ 0, 1, 0, 1);
+
+ check_button = gtk_check_button_new_with_label ("Resize");
+ gtk_table_attach_defaults (GTK_TABLE (table), check_button,
+ 0, 1, 1, 2);
+ gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
+ GTK_SIGNAL_FUNC (toggle_resize),
+ paned->child1);
+
+ check_button = gtk_check_button_new_with_label ("Shrink");
+ gtk_table_attach_defaults (GTK_TABLE (table), check_button,
+ 0, 1, 2, 3);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
+ TRUE);
+ gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
+ GTK_SIGNAL_FUNC (toggle_shrink),
+ paned->child1);
+
+ label = gtk_label_new (label2);
+ gtk_table_attach_defaults (GTK_TABLE (table), label,
+ 1, 2, 0, 1);
+
+ check_button = gtk_check_button_new_with_label ("Resize");
+ gtk_table_attach_defaults (GTK_TABLE (table), check_button,
+ 1, 2, 1, 2);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
+ TRUE);
+ gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
+ GTK_SIGNAL_FUNC (toggle_resize),
+ paned->child2);
+
+ check_button = gtk_check_button_new_with_label ("Shrink");
+ gtk_table_attach_defaults (GTK_TABLE (table), check_button,
+ 1, 2, 2, 3);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
+ TRUE);
+ gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
+ GTK_SIGNAL_FUNC (toggle_shrink),
+ paned->child2);
+
+ return frame;
+}
+
void
create_panes (void)
{
GtkWidget *hpaned;
GtkWidget *vpaned;
GtkWidget *button;
+ GtkWidget *vbox;
if (!window)
{
&window);
gtk_window_set_title (GTK_WINDOW (window), "Panes");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
+ vbox = gtk_vbox_new (FALSE, 0);
+ gtk_container_add (GTK_CONTAINER (window), vbox);
+
vpaned = gtk_vpaned_new ();
- gtk_container_add (GTK_CONTAINER (window), vpaned);
- gtk_container_border_width (GTK_CONTAINER(vpaned), 5);
- gtk_widget_show (vpaned);
+ gtk_box_pack_start (GTK_BOX (vbox), vpaned, TRUE, TRUE, 0);
+ gtk_container_set_border_width (GTK_CONTAINER(vpaned), 5);
hpaned = gtk_hpaned_new ();
gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_widget_set_usize (frame, 60, 60);
gtk_paned_add1 (GTK_PANED (hpaned), frame);
- gtk_widget_show (frame);
button = gtk_button_new_with_label ("Hi there");
gtk_container_add (GTK_CONTAINER(frame), button);
- gtk_widget_show (button);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_widget_set_usize (frame, 80, 60);
gtk_paned_add2 (GTK_PANED (hpaned), frame);
- gtk_widget_show (frame);
-
- gtk_widget_show (hpaned);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_widget_set_usize (frame, 60, 80);
gtk_paned_add2 (GTK_PANED (vpaned), frame);
- gtk_widget_show (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_VISIBLE (window))
gtk_widget_destroy (window);
}
-
/*
* Drag -N- Drop
*/
+#if 0
gint
dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window)
{
return;
window = gtk_window_new(GTK_WINDOW_DIALOG);
- gtk_container_border_width (GTK_CONTAINER(window), 10);
+ gtk_container_set_border_width (GTK_CONTAINER(window), 10);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
&window);
gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show (box1);
box2 = gtk_hbox_new (FALSE, 5);
- gtk_container_border_width (GTK_CONTAINER (box2), 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);
gtk_widget_show (frame);
box3 = gtk_vbox_new (FALSE, 5);
- gtk_container_border_width (GTK_CONTAINER (box3), 5);
+ gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
gtk_container_add (GTK_CONTAINER (frame), box3);
gtk_widget_show (box3);
gtk_widget_show (frame);
box3 = gtk_vbox_new (FALSE, 5);
- gtk_container_border_width (GTK_CONTAINER (box3), 5);
+ gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
gtk_container_add (GTK_CONTAINER (frame), box3);
gtk_widget_show (box3);
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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);
else
gtk_widget_destroy (window);
}
+#endif
/*
* Shaped Windows
*/
-static GdkWindow *root_win = NULL;
typedef struct _cursoroffset {gint x,y;} CursorOffset;
NULL, NULL, 0);
}
-
static void
shape_released (GtkWidget *widget)
{
* Can't use event->x / event->y here
* because I need absolute coordinates.
*/
- gdk_window_get_pointer (root_win, &xp, &yp, &mask);
+ gdk_window_get_pointer (NULL, &xp, &yp, &mask);
gtk_widget_set_uposition (widget, xp - p->x, yp - p->y);
}
static GtkWidget *sheets = NULL;
static GtkWidget *rings = NULL;
- root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
-
if (!modeller)
{
modeller = shape_create_icon ("Modeller.xpm",
gtk_widget_destroy (rings);
}
+/*
+ * WM Hints demo
+ */
+
void
create_wmhints (void)
{
&window);
gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_widget_realize (window);
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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);
}
/*
- * Progress Bar
+ * GtkProgressBar
*/
typedef struct _ProgressData {
GtkWidget *x_align_spin;
GtkWidget *y_align_spin;
GtkWidget *step_spin;
+ GtkWidget *act_blocks_spin;
GtkWidget *label;
GtkWidget *omenu1;
- GtkWidget *omenu3;
+ GtkWidget *omenu2;
GtkWidget *entry;
int timer;
} ProgressData;
-
gint
progress_timeout (gpointer data)
{
}
static void
-toggle_orientation (GtkWidget *widget, ProgressData *pdata)
+progressbar_toggle_orientation (GtkWidget *widget, ProgressData *pdata)
{
gint i;
}
static void
-toggle_bar_style (GtkWidget *widget, ProgressData *pdata)
+progressbar_toggle_bar_style (GtkWidget *widget, ProgressData *pdata)
{
gint i;
return;
RADIOMENUTOGGLED ((GtkRadioMenuItem *)
- (((GtkOptionMenu *)(pdata->omenu3))->menu_item), i);
+ (((GtkOptionMenu *)(pdata->omenu2))->menu_item), i);
i = 1 - i;
else
sprintf (buf, "%.0f%%", 100 *
gtk_progress_get_current_percentage (GTK_PROGRESS (pdata->pbar)));
- gtk_label_set (GTK_LABEL (pdata->label), buf);
+ gtk_label_set_text (GTK_LABEL (pdata->label), buf);
}
static void
adjust_blocks (GtkAdjustment *adj, ProgressData *pdata)
{
gtk_progress_set_percentage (GTK_PROGRESS (pdata->pbar), 0);
- gtk_progress_bar_set_number_of_blocks (GTK_PROGRESS_BAR (pdata->pbar),
+ gtk_progress_bar_set_discrete_blocks (GTK_PROGRESS_BAR (pdata->pbar),
gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->block_spin)));
}
gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->step_spin)));
}
+static void
+adjust_act_blocks (GtkAdjustment *adj, ProgressData *pdata)
+{
+ gtk_progress_bar_set_activity_blocks (GTK_PROGRESS_BAR (pdata->pbar),
+ gtk_spin_button_get_value_as_int
+ (GTK_SPIN_BUTTON (pdata->act_blocks_spin)));
+}
+
static void
adjust_align (GtkAdjustment *adj, ProgressData *pdata)
{
GTK_TOGGLE_BUTTON (widget)->active);
gtk_widget_set_sensitive (pdata->step_spin,
GTK_TOGGLE_BUTTON (widget)->active);
+ gtk_widget_set_sensitive (pdata->act_blocks_spin,
+ GTK_TOGGLE_BUTTON (widget)->active);
}
static void
GtkWidget *label;
GtkWidget *align;
GtkAdjustment *adj;
- GtkWidget *menu_item;
- GtkWidget *menu;
- GtkWidget *submenu;
- GSList *group;
static ProgressData *pdata = NULL;
+ static OptionMenuItem items1[] =
+ {
+ { "Left-Right", progressbar_toggle_orientation },
+ { "Right-Left", progressbar_toggle_orientation },
+ { "Bottom-Top", progressbar_toggle_orientation },
+ { "Top-Bottom", progressbar_toggle_orientation }
+ };
+
+ static OptionMenuItem items2[] =
+ {
+ { "Continuous", progressbar_toggle_bar_style },
+ { "Discrete", progressbar_toggle_bar_style }
+ };
+
if (!pdata)
pdata = g_new0 (ProgressData, 1);
pdata->timer = 0;
gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar");
- gtk_container_border_width (GTK_CONTAINER (pdata->window), 0);
+ gtk_container_set_border_width (GTK_CONTAINER (pdata->window), 0);
vbox = gtk_vbox_new (FALSE, 5);
- gtk_container_border_width (GTK_CONTAINER (vbox), 10);
+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->vbox),
vbox, FALSE, TRUE, 0);
vbox2 = gtk_vbox_new (FALSE, 5);
gtk_container_add (GTK_CONTAINER (frame), vbox2);
- tab = gtk_table_new (6, 2, FALSE);
+ tab = gtk_table_new (7, 2, FALSE);
gtk_box_pack_start (GTK_BOX (vbox2), tab, FALSE, TRUE, 0);
label = gtk_label_new ("Orientation :");
5, 5);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
- pdata->omenu1 = gtk_option_menu_new ();
-
- menu = gtk_menu_new ();
- submenu = NULL;
- group = NULL;
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Left-Right");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (toggle_orientation),
- pdata);
- gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_widget_show (menu_item);
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Right-Left");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (toggle_orientation),
- pdata);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_widget_show (menu_item);
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Bottom-Top");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (toggle_orientation),
- pdata);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_widget_show (menu_item);
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Top-Bottom");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (toggle_orientation),
- pdata);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_widget_show (menu_item);
-
- gtk_option_menu_set_menu (GTK_OPTION_MENU (pdata->omenu1), menu);
- gtk_option_menu_set_history (GTK_OPTION_MENU (pdata->omenu1), 0);
+ pdata->omenu1 = build_option_menu (items1, 4, 0, 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->omenu3 = gtk_option_menu_new ();
-
- menu = gtk_menu_new ();
- submenu = NULL;
- group = NULL;
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Continuous");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (toggle_bar_style),
- pdata);
- gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_widget_show (menu_item);
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Discrete");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (toggle_bar_style),
- pdata);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_widget_show (menu_item);
-
- gtk_option_menu_set_menu (GTK_OPTION_MENU (pdata->omenu3), menu);
- gtk_option_menu_set_history (GTK_OPTION_MENU (pdata->omenu3), 0);
+ pdata->omenu2 = build_option_menu (items2, 2, 0, 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,
5, 5);
- gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu3, TRUE, TRUE, 0);
+ gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu2, TRUE, TRUE, 0);
label = gtk_label_new ("Block count :");
gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 4, 5,
gtk_box_pack_start (GTK_BOX (hbox), pdata->step_spin, FALSE, TRUE, 0);
gtk_widget_set_sensitive (pdata->step_spin, FALSE);
+ hbox = gtk_hbox_new (FALSE, 0);
+ gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 6, 7,
+ GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
+ 5, 5);
+ label = gtk_label_new ("Blocks : ");
+ gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
+ adj = (GtkAdjustment *) gtk_adjustment_new (5, 2, 10, 1, 5, 0);
+ pdata->act_blocks_spin = gtk_spin_button_new (adj, 0, 0);
+ gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
+ GTK_SIGNAL_FUNC (adjust_act_blocks), pdata);
+ gtk_box_pack_start (GTK_BOX (hbox), pdata->act_blocks_spin, FALSE, TRUE,
+ 0);
+ gtk_widget_set_sensitive (pdata->act_blocks_spin, FALSE);
+
button = gtk_button_new_with_label ("close");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
/*
* Color Preview
*/
+
static int color_idle = 0;
gint
if (!window)
{
+ gtk_widget_push_visual (gdk_rgb_get_visual ());
+ gtk_widget_push_colormap (gdk_rgb_get_cmap ());
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_widget_pop_colormap ();
+ gtk_widget_pop_visual ();
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(color_preview_destroy),
&window);
gtk_window_set_title (GTK_WINDOW (window), "test");
- gtk_container_border_width (GTK_CONTAINER (window), 10);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 10);
preview = gtk_preview_new (GTK_PREVIEW_COLOR);
gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
gtk_container_add (GTK_CONTAINER (window), preview);
- gtk_widget_show (preview);
for (i = 0; i < 256; i++)
{
}
if (!GTK_WIDGET_VISIBLE (window))
- gtk_widget_show (window);
+ gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
-
/*
* Gray Preview
*/
+
static int gray_idle = 0;
gint
&window);
gtk_window_set_title (GTK_WINDOW (window), "test");
- gtk_container_border_width (GTK_CONTAINER (window), 10);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 10);
preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
gtk_container_add (GTK_CONTAINER (window), preview);
- gtk_widget_show (preview);
for (i = 0; i < 256; i++)
{
}
if (!GTK_WIDGET_VISIBLE (window))
- gtk_widget_show (window);
+ gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/*
* Selection Test
*/
+
void
selection_test_received (GtkWidget *list, GtkSelectionData *data)
{
&window);
gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
/* Create the list */
vbox = gtk_vbox_new (FALSE, 5);
- gtk_container_border_width (GTK_CONTAINER (vbox), 10);
+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
TRUE, TRUE, 0);
- gtk_widget_show (vbox);
label = gtk_label_new ("Gets available targets for current selection");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
- gtk_widget_show (label);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
gtk_widget_set_usize (scrolled_win, 100, 200);
- gtk_widget_show (scrolled_win);
list = gtk_list_new ();
- gtk_container_add (GTK_CONTAINER (scrolled_win), list);
+ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), list);
gtk_signal_connect (GTK_OBJECT(list), "selection_received",
GTK_SIGNAL_FUNC (selection_test_received), NULL);
- gtk_widget_show (list);
/* .. And create some buttons */
button = gtk_button_new_with_label ("Get Targets");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (selection_test_get_targets), list);
- gtk_widget_show (button);
button = gtk_button_new_with_label ("Quit");
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (window));
- gtk_widget_show (button);
}
if (!GTK_WIDGET_VISIBLE (window))
- gtk_widget_show (window);
+ gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
-
/*
* Gamma Curve
*/
+
void
create_gamma_curve (void)
{
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "test");
- gtk_container_border_width (GTK_CONTAINER (window), 10);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 10);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
++count;
}
+/*
+ * Test scrolling
+ */
+
static int scroll_test_pos = 0.0;
static GdkGC *scroll_test_gc = NULL;
}
}
-
if (rect.height != 0)
gtk_widget_draw (widget, &rect);
}
GtkWidget *scrollbar;
GtkWidget *button;
GtkAdjustment *adj;
+ GdkGeometry geometry;
+ GdkWindowHints geometry_mask;
if (!window)
{
&window);
gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (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_VISIBLE (window))
/*
* Timeout Test
*/
+
static int timer = 0;
gint
static char buffer[32];
sprintf (buffer, "count: %d", ++count);
- gtk_label_set (GTK_LABEL (label), buffer);
+ gtk_label_set_text (GTK_LABEL (label), buffer);
return TRUE;
}
&window);
gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
label = gtk_label_new ("count: 0");
gtk_misc_set_padding (GTK_MISC (label), 10, 10);
gtk_widget_destroy (window);
}
-
/*
* Idle Test
*/
-static int idle = 0;
+
+static int idle_id = 0;
static gint
idle_test (GtkWidget *label)
static char buffer[32];
sprintf (buffer, "count: %d", ++count);
- gtk_label_set (GTK_LABEL (label), buffer);
+ gtk_label_set_text (GTK_LABEL (label), buffer);
return TRUE;
}
start_idle_test (GtkWidget *widget,
GtkWidget *label)
{
- if (!idle)
+ if (!idle_id)
{
- idle = gtk_idle_add ((GtkFunction) idle_test, label);
+ idle_id = gtk_idle_add ((GtkFunction) idle_test, label);
}
}
stop_idle_test (GtkWidget *widget,
gpointer data)
{
- if (idle)
+ if (idle_id)
{
- gtk_idle_remove (idle);
- idle = 0;
+ gtk_idle_remove (idle_id);
+ idle_id = 0;
}
}
toggle_idle_container (GtkObject *button,
GtkContainer *container)
{
- gtk_container_set_resize_mode (container, (guint) gtk_object_get_user_data (button));
+ gtk_container_set_resize_mode (container, GPOINTER_TO_INT (gtk_object_get_user_data (button)));
}
static void
&window);
gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
label = gtk_label_new ("count: 0");
gtk_misc_set_padding (GTK_MISC (label), 10, 10);
gtk_widget_destroy (window);
}
+/*
+ * rc file test
+ */
+
void
reload_rc_file (void)
{
&window);
gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
button = gtk_button_new_with_label ("Reload");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
gtk_widget_destroy (window);
}
+gint
+layout_expose_handler (GtkWidget *widget, GdkEventExpose *event)
+{
+ GtkLayout *layout;
+
+ gint i,j;
+ gint imin, imax, jmin, jmax;
+
+ layout = GTK_LAYOUT (widget);
+
+ imin = (layout->xoffset + event->area.x) / 10;
+ imax = (layout->xoffset + event->area.x + event->area.width + 9) / 10;
+
+ jmin = (layout->yoffset + event->area.y) / 10;
+ jmax = (layout->yoffset + event->area.y + event->area.height + 9) / 10;
+
+ gdk_window_clear_area (widget->window,
+ event->area.x, event->area.y,
+ event->area.width, event->area.height);
+
+ for (i=imin; i<imax; i++)
+ for (j=jmin; j<jmax; j++)
+ if ((i+j) % 2)
+ gdk_draw_rectangle (layout->bin_window,
+ widget->style->black_gc,
+ TRUE,
+ 10*i - layout->xoffset, 10*j - layout->yoffset,
+ 1+i%10, 1+j%10);
+
+ return TRUE;
+}
+
+void create_layout (void)
+{
+ static GtkWidget *window = NULL;
+ GtkWidget *layout;
+ GtkWidget *scrolledwindow;
+ GtkWidget *button;
+
+ if (!window)
+ {
+ gchar buf[16];
+
+ gint i, j;
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_signal_connect (GTK_OBJECT (window), "destroy",
+ GTK_SIGNAL_FUNC(gtk_widget_destroyed),
+ &window);
+
+ gtk_window_set_title (GTK_WINDOW (window), "Layout");
+ gtk_widget_set_usize (window, 200, 200);
+
+ scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
+
+ gtk_container_add (GTK_CONTAINER (window), scrolledwindow);
+
+ layout = gtk_layout_new (NULL, NULL);
+ gtk_container_add (GTK_CONTAINER (scrolledwindow), layout);
+
+ /* We set step sizes here since GtkLayout does not set
+ * them itself.
+ */
+ GTK_LAYOUT (layout)->hadjustment->step_increment = 10.0;
+ GTK_LAYOUT (layout)->vadjustment->step_increment = 10.0;
+
+ gtk_widget_set_events (layout, GDK_EXPOSURE_MASK);
+ gtk_signal_connect (GTK_OBJECT (layout), "expose_event",
+ GTK_SIGNAL_FUNC (layout_expose_handler), NULL);
+
+ gtk_layout_set_size (GTK_LAYOUT (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 (GTK_LAYOUT (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 (GTK_LAYOUT (layout), button,
+ 0, i*100);
+ }
+ }
+
+ if (!GTK_WIDGET_VISIBLE (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_destroy (window);
+}
/*
* Main Window and Exit
*/
+
void
do_exit (GtkWidget *widget, GtkWidget *window)
{
{ "ctree", create_ctree },
{ "cursors", create_cursors },
{ "dialog", create_dialog },
- { "dnd", create_dnd },
+ /* { "dnd", create_dnd }, */
{ "entry", create_entry },
+ { "event watcher", create_event_watcher },
{ "file selection", create_file_selection },
{ "font selection", create_font_selection },
{ "gamma curve", create_gamma_curve },
{ "handle box", create_handle_box },
+ { "item factory", create_item_factory },
+ { "labels", create_labels },
+ { "layout", create_layout },
{ "list", create_list },
{ "menus", create_menus },
- { "miscellaneous", NULL },
+ { "modal window", create_modal_window },
{ "notebook", create_notebook },
{ "panes", create_panes },
{ "pixmap", create_pixmap },
{ "rc file", create_rc_file },
{ "reparent", create_reparent },
{ "rulers", create_rulers },
+ { "saved position", create_saved_position },
{ "scrolled windows", create_scrolled_windows },
{ "shapes", create_shapes },
{ "spinbutton", create_spins },
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
- gtk_widget_show (box1);
if (gtk_micro_version > 0)
sprintf (buffer,
gtk_minor_version);
label = gtk_label_new (buffer);
- gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
- gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
+ 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_WIDGET_UNSET_FLAGS (GTK_SCROLLED_WINDOW (scrolled_window)->vscrollbar, GTK_CAN_FOCUS);
gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
- gtk_widget_show (scrolled_window);
box2 = gtk_vbox_new (FALSE, 0);
- gtk_container_border_width (GTK_CONTAINER (box2), 10);
- gtk_container_add (GTK_CONTAINER (scrolled_window), box2);
+ gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
+ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (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);
else
gtk_widget_set_sensitive (button, FALSE);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- gtk_widget_show (button);
}
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
- gtk_widget_show (separator);
box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_border_width (GTK_CONTAINER (box2), 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");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
- gtk_widget_show (button);
- gtk_widget_show (window);
+ gtk_widget_show_all (window);
}
-#ifdef HAVE_LIBGLE
-#include <gle/gle.h>
-#endif /* !HAVE_LIBGLE */
-
int
main (int argc, char *argv[])
{
+ GtkBindingSet *binding_set;
+ struct stat statbuf;
+
srand (time (NULL));
gtk_set_locale ();
+ /* Check to see if we are being run from the correct
+ * directory.
+ */
+ if (stat("./testgtkrc", &statbuf) < 0)
+ {
+ fprintf (stderr, "*** The testgtk program must be run from within the\n"
+ "*** gtk/ subdirectory of the GTK+ distribution.\n");
+ exit (1);
+ }
+
+ gtk_rc_add_default_file ("testgtkrc");
+
gtk_init (&argc, &argv);
-#ifdef HAVE_LIBGLE
- gle_init (&argc, &argv);
-#endif /* !HAVE_LIBGLE */
+ gdk_rgb_init ();
- gtk_rc_parse ("testgtkrc");
+ /* bindings test
+ */
+ binding_set = gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_WIDGET));
+ gtk_binding_entry_add_signal (binding_set,
+ '9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
+ "debug_msg",
+ 1,
+ GTK_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
create_main_window ();
projects / ~andy / gtk / blobdiff