X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Ftestgtk.c;h=c3c24e421d682d9fceaa400d0c9a40407d45ea52;hb=7cb2ce4d117906925f7cdac6d4b1dbed4babf1fd;hp=47c01b30942c37139f97fedbf32b6f4b05df1330;hpb=79f69b1676b3efb8a1b7706c9c8d4a43e47a269c;p=~andy%2Fgtk diff --git a/gtk/testgtk.c b/gtk/testgtk.c index 47c01b309..c3c24e421 100644 --- a/gtk/testgtk.c +++ b/gtk/testgtk.c @@ -12,23 +12,61 @@ * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public - * License along with this library; if not, write to the Free - * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. */ #include #include +#include +#include #include "gtk.h" #include "../gdk/gdk.h" #include "../gdk/gdkx.h" -void -destroy_window (GtkWidget *widget, - GtkWidget **window) +#include "circles.xbm" + +GtkWidget *shape_create_icon (char *xpm_file, + gint x, + gint y, + gint px, + gint py, + gint window_type); + +/* macro, structure and variables used by tree window demos */ +#define DEFAULT_NUMBER_OF_ITEM 3 +#define DEFAULT_RECURSION_LEVEL 3 + +struct { + GSList* selection_mode_group; + GtkWidget* single_button; + GtkWidget* browse_button; + GtkWidget* multiple_button; + GtkWidget* draw_line_button; + GtkWidget* view_line_button; + GtkWidget* no_root_item_button; + GtkWidget* nb_item_spinner; + GtkWidget* recursion_spinner; +} sTreeSampleSelection; + +typedef struct sTreeButtons { + guint nb_item_add; + GtkWidget* add_button; + GtkWidget* remove_button; + GtkWidget* subtree_button; +} sTreeButtons; +/* end of tree section */ + +static 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; } -void +static void button_window (GtkWidget *widget, GtkWidget *button) { @@ -38,8 +76,8 @@ button_window (GtkWidget *widget, gtk_widget_hide (button); } -void -create_buttons () +static void +create_buttons (void) { static GtkWidget *window = NULL; GtkWidget *box1; @@ -53,10 +91,7 @@ create_buttons () window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), + GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "buttons"); @@ -178,8 +213,8 @@ create_buttons () gtk_widget_destroy (window); } -void -create_toggle_buttons () +static void +create_toggle_buttons (void) { static GtkWidget *window = NULL; GtkWidget *box1; @@ -192,10 +227,7 @@ create_toggle_buttons () window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "toggle buttons"); @@ -253,8 +285,8 @@ create_toggle_buttons () gtk_widget_destroy (window); } -void -create_check_buttons () +static void +create_check_buttons (void) { static GtkWidget *window = NULL; GtkWidget *box1; @@ -267,10 +299,7 @@ create_check_buttons () window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "check buttons"); @@ -328,8 +357,8 @@ create_check_buttons () gtk_widget_destroy (window); } -void -create_radio_buttons () +static void +create_radio_buttons (void) { static GtkWidget *window = NULL; GtkWidget *box1; @@ -342,10 +371,7 @@ create_radio_buttons () window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "radio buttons"); @@ -408,12 +434,12 @@ create_radio_buttons () gtk_widget_destroy (window); } -void +static void bbox_widget_destroy (GtkWidget* widget, GtkWidget* todestroy) { } -void +static void create_bbox_window (gint horizontal, char* title, gint pos, @@ -433,8 +459,6 @@ create_bbox_window (gint horizontal, gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(bbox_widget_destroy), window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(bbox_widget_destroy), window); if (horizontal) { @@ -483,8 +507,8 @@ create_bbox_window (gint horizontal, gtk_widget_show (window); } -void -test_hbbox () +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); @@ -492,8 +516,8 @@ test_hbbox () create_bbox_window (TRUE, "End", 500, 15, 30, 25, GTK_BUTTONBOX_END); } -void -test_vbbox () +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); @@ -501,8 +525,8 @@ test_vbbox () create_bbox_window (FALSE, "End", 650, 15, 30, 25, GTK_BUTTONBOX_END); } -void -create_button_box () +static void +create_button_box (void) { static GtkWidget* window = NULL; GtkWidget* bbox; @@ -515,9 +539,8 @@ create_button_box () "Button Box Test"); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), &window); + GTK_SIGNAL_FUNC(gtk_widget_destroyed), + &window); gtk_container_border_width (GTK_CONTAINER (window), 20); @@ -547,7 +570,7 @@ create_button_box () gtk_widget_destroy (window); } -GtkWidget * +static GtkWidget* new_pixmap (char *filename, GdkWindow *window, GdkColor *background) @@ -558,76 +581,90 @@ new_pixmap (char *filename, pixmap = gdk_pixmap_create_from_xpm (window, &mask, background, - "test.xpm"); + filename); wpixmap = gtk_pixmap_new (pixmap, mask); return wpixmap; } -void +static void set_toolbar_horizontal (GtkWidget *widget, gpointer data) { gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_HORIZONTAL); } -void +static void set_toolbar_vertical (GtkWidget *widget, gpointer data) { gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_VERTICAL); } -void +static void set_toolbar_icons (GtkWidget *widget, gpointer data) { gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_ICONS); } -void +static void set_toolbar_text (GtkWidget *widget, gpointer data) { gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_TEXT); } -void +static void set_toolbar_both (GtkWidget *widget, gpointer data) { gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH); } -void +static void set_toolbar_small_space (GtkWidget *widget, gpointer data) { gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 5); } -void +static void set_toolbar_big_space (GtkWidget *widget, gpointer data) { gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 10); } -void +static void set_toolbar_enable (GtkWidget *widget, gpointer data) { gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), TRUE); } -void +static void set_toolbar_disable (GtkWidget *widget, gpointer data) { gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), FALSE); } -void +static void +set_toolbar_borders (GtkWidget *widget, + gpointer data) +{ + gtk_toolbar_set_button_relief (GTK_TOOLBAR (data), GTK_RELIEF_NORMAL); +} + +static void +set_toolbar_borderless (GtkWidget *widget, + gpointer data) +{ + gtk_toolbar_set_button_relief (GTK_TOOLBAR (data), GTK_RELIEF_NONE); +} + +static void create_toolbar (void) { static GtkWidget *window = NULL; @@ -641,78 +678,78 @@ create_toolbar (void) gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, TRUE); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC (destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC (destroy_window), + GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window); gtk_container_border_width (GTK_CONTAINER (window), 0); gtk_widget_realize (window); toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH); + gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), - "Horizontal", "Horizontal toolbar layout", - GTK_PIXMAP (new_pixmap ("test.xpm", window->window, - &window->style->bg[GTK_STATE_NORMAL])), + "Horizontal", "Horizontal toolbar layout", "Toolbar/Horizontal", + new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_horizontal, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), - "Vertical", "Vertical toolbar layout", - GTK_PIXMAP (new_pixmap ("test.xpm", window->window, - &window->style->bg[GTK_STATE_NORMAL])), + "Vertical", "Vertical toolbar layout", "Toolbar/Vertical", + new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_vertical, toolbar); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), - "Icons", "Only show toolbar icons", - GTK_PIXMAP (new_pixmap ("test.xpm", window->window, - &window->style->bg[GTK_STATE_NORMAL])), + "Icons", "Only show toolbar icons", "Toolbar/IconsOnly", + new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_icons, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), - "Text", "Only show toolbar text", - GTK_PIXMAP (new_pixmap ("test.xpm", window->window, - &window->style->bg[GTK_STATE_NORMAL])), + "Text", "Only show toolbar text", "Toolbar/TextOnly", + new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_text, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), - "Both", "Show toolbar icons and text", - GTK_PIXMAP (new_pixmap ("test.xpm", window->window, - &window->style->bg[GTK_STATE_NORMAL])), + "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_space (GTK_TOOLBAR (toolbar)); entry = gtk_entry_new (); gtk_widget_show(entry); - gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar), NULL, 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)); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), - "Small", "Use small spaces", - GTK_PIXMAP (new_pixmap ("test.xpm", window->window, - &window->style->bg[GTK_STATE_NORMAL])), + "Small", "Use small spaces", "Toolbar/Small", + new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_small_space, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), - "Big", "Use big spaces", - GTK_PIXMAP (new_pixmap ("test.xpm", window->window, - &window->style->bg[GTK_STATE_NORMAL])), + "Big", "Use big spaces", "Toolbar/Big", + new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_big_space, toolbar); gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), - "Enable", "Enable tooltips", - GTK_PIXMAP (new_pixmap ("test.xpm", window->window, - &window->style->bg[GTK_STATE_NORMAL])), + "Enable", "Enable tooltips", NULL, + new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_enable, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), - "Disable", "Disable tooltips", - GTK_PIXMAP (new_pixmap ("test.xpm", window->window, - &window->style->bg[GTK_STATE_NORMAL])), + "Disable", "Disable tooltips", NULL, + new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_disable, toolbar); + gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)); + + gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), + "Borders", "Show Borders", NULL, + new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), + (GtkSignalFunc) set_toolbar_borders, toolbar); + gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), + "Borderless", "Hide Borders", NULL, + new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), + (GtkSignalFunc) set_toolbar_borderless, toolbar); + gtk_container_add (GTK_CONTAINER (window), toolbar); gtk_widget_show (toolbar); } @@ -723,7 +760,7 @@ create_toolbar (void) gtk_widget_destroy (window); } -GtkWidget * +static GtkWidget* make_toolbar (GtkWidget *window) { GtkWidget *toolbar; @@ -732,136 +769,173 @@ make_toolbar (GtkWidget *window) gtk_widget_realize (window); toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH); + gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), - "Horizontal", "Horizontal toolbar layout", - GTK_PIXMAP (new_pixmap ("test.xpm", window->window, - &window->style->bg[GTK_STATE_NORMAL])), + "Horizontal", "Horizontal toolbar layout", NULL, + new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_horizontal, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), - "Vertical", "Vertical toolbar layout", - GTK_PIXMAP (new_pixmap ("test.xpm", window->window, - &window->style->bg[GTK_STATE_NORMAL])), + "Vertical", "Vertical toolbar layout", NULL, + new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_vertical, toolbar); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), - "Icons", "Only show toolbar icons", - GTK_PIXMAP (new_pixmap ("test.xpm", window->window, - &window->style->bg[GTK_STATE_NORMAL])), + "Icons", "Only show toolbar icons", NULL, + new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_icons, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), - "Text", "Only show toolbar text", - GTK_PIXMAP (new_pixmap ("test.xpm", window->window, - &window->style->bg[GTK_STATE_NORMAL])), + "Text", "Only show toolbar text", NULL, + new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_text, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), - "Both", "Show toolbar icons and text", - GTK_PIXMAP (new_pixmap ("test.xpm", window->window, - &window->style->bg[GTK_STATE_NORMAL])), + "Both", "Show toolbar icons and text", NULL, + new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_both, toolbar); gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), - "Small", "Use small spaces", - GTK_PIXMAP (new_pixmap ("test.xpm", window->window, - &window->style->bg[GTK_STATE_NORMAL])), + "Small", "Use small spaces", NULL, + new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_small_space, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), - "Big", "Use big spaces", - GTK_PIXMAP (new_pixmap ("test.xpm", window->window, - &window->style->bg[GTK_STATE_NORMAL])), + "Big", "Use big spaces", "Toolbar/Big", + new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_big_space, toolbar); gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), - "Enable", "Enable tooltips", - GTK_PIXMAP (new_pixmap ("test.xpm", window->window, - &window->style->bg[GTK_STATE_NORMAL])), + "Enable", "Enable tooltips", NULL, + new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_enable, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), - "Disable", "Disable tooltips", - GTK_PIXMAP (new_pixmap ("test.xpm", window->window, - &window->style->bg[GTK_STATE_NORMAL])), + "Disable", "Disable tooltips", NULL, + new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_disable, toolbar); + gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)); + + gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), + "Borders", "Show Borders", NULL, + new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), + (GtkSignalFunc) set_toolbar_borders, toolbar); + gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), + "Borderless", "Hide Borders", NULL, + new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), + (GtkSignalFunc) set_toolbar_borderless, toolbar); + return toolbar; } -void -create_handle_box () +static guint statusbar_counter = 1; + +static void +statusbar_push (GtkWidget *button, + GtkStatusbar *statusbar) { - static GtkWidget* window = NULL; - GtkWidget *hbox; - GtkWidget *toolbar; - - if (!window) - { - window = gtk_window_new (GTK_WINDOW_TOPLEVEL); - gtk_window_set_title (GTK_WINDOW (window), - "Handle Box Test"); - - gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), &window); - - gtk_container_border_width (GTK_CONTAINER (window), 20); - - hbox = gtk_handle_box_new (); - gtk_container_add (GTK_CONTAINER (window), hbox); - gtk_widget_show (hbox); + gchar text[1024]; - toolbar = make_toolbar (window); - gtk_container_add (GTK_CONTAINER (hbox), toolbar); - gtk_widget_show (toolbar); - } + sprintf (text, "something %d", statusbar_counter++); - if (!GTK_WIDGET_VISIBLE (window)) - gtk_widget_show (window); - else - gtk_widget_destroy (window); + gtk_statusbar_push (statusbar, 1, text); } +static void +statusbar_pop (GtkWidget *button, + GtkStatusbar *statusbar) +{ + gtk_statusbar_pop (statusbar, 1); +} -void -reparent_label (GtkWidget *widget, - GtkWidget *new_parent) +static void +statusbar_steal (GtkWidget *button, + GtkStatusbar *statusbar) { - GtkWidget *label; + gtk_statusbar_remove (statusbar, 1, 4); +} - label = gtk_object_get_user_data (GTK_OBJECT (widget)); +static void +statusbar_popped (GtkStatusbar *statusbar, + guint context_id, + const gchar *text) +{ + if (!statusbar->messages) + statusbar_counter = 1; +} - gtk_widget_reparent (label, new_parent); +static void +statusbar_contexts (GtkWidget *button, + GtkStatusbar *statusbar) +{ + gchar *string; + + string = "any context"; + g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n", + string, + gtk_statusbar_get_context_id (statusbar, string)); + + string = "idle messages"; + g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n", + string, + gtk_statusbar_get_context_id (statusbar, string)); + + string = "some text"; + g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n", + string, + gtk_statusbar_get_context_id (statusbar, string)); + + string = "hit the mouse"; + g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n", + string, + gtk_statusbar_get_context_id (statusbar, string)); + + string = "hit the mouse2"; + g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n", + string, + gtk_statusbar_get_context_id (statusbar, string)); } -void -create_reparent () +static void +statusbar_dump_stack (GtkWidget *button, + GtkStatusbar *statusbar) +{ + GSList *list; + + for (list = statusbar->messages; list; list = list->next) + { + GtkStatusbarMsg *msg; + + msg = list->data; + g_print ("context_id: %d, message_id: %d, status_text: \"%s\"\n", + msg->context_id, + msg->message_id, + msg->text); + } +} + +static void +create_statusbar (void) { static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; - GtkWidget *box3; - GtkWidget *frame; GtkWidget *button; - GtkWidget *label; GtkWidget *separator; + GtkWidget *statusbar; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), + GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window); - gtk_window_set_title (GTK_WINDOW (window), "buttons"); + gtk_window_set_title (GTK_WINDOW (window), "statusbar"); gtk_container_border_width (GTK_CONTAINER (window), 0); @@ -870,52 +944,53 @@ create_reparent () gtk_widget_show (box1); - box2 = gtk_hbox_new (FALSE, 5); + 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); + 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), + NULL); - 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_add (GTK_CONTAINER (frame), box3); - gtk_widget_show (box3); - - button = gtk_button_new_with_label ("switch"); - gtk_signal_connect (GTK_OBJECT (button), "clicked", - GTK_SIGNAL_FUNC(reparent_label), - 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_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_add (GTK_CONTAINER (frame), box3); - gtk_widget_show (box3); - - button = gtk_button_new_with_label ("switch"); - gtk_signal_connect (GTK_OBJECT (button), "clicked", - GTK_SIGNAL_FUNC(reparent_label), - 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); - + button = gtk_widget_new (gtk_button_get_type (), + "GtkButton::label", "push something", + "GtkWidget::visible", TRUE, + "GtkWidget::parent", box2, + "GtkObject::signal::clicked", statusbar_push, statusbar, + NULL); + + button = gtk_widget_new (gtk_button_get_type (), + "GtkButton::label", "pop", + "GtkWidget::visible", TRUE, + "GtkWidget::parent", box2, + "GtkObject::signal::clicked", statusbar_pop, statusbar, + NULL); + + button = gtk_widget_new (gtk_button_get_type (), + "GtkButton::label", "steal #4", + "GtkWidget::visible", TRUE, + "GtkWidget::parent", box2, + "GtkObject::signal::clicked", statusbar_steal, statusbar, + NULL); + + button = gtk_widget_new (gtk_button_get_type (), + "GtkButton::label", "dump stack", + "GtkWidget::visible", TRUE, + "GtkWidget::parent", box2, + "GtkObject::signal::clicked", statusbar_dump_stack, statusbar, + NULL); + + button = gtk_widget_new (gtk_button_get_type (), + "GtkButton::label", "test contexts", + "GtkWidget::visible", TRUE, + "GtkWidget::parent", box2, + "GtkObject::signal::clicked", statusbar_contexts, statusbar, + NULL); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); @@ -944,86 +1019,612 @@ create_reparent () gtk_widget_destroy (window); } -void -create_pixmap () +static void +handle_box_child_signal (GtkHandleBox *hb, + GtkWidget *child, + const gchar *action) { - static GtkWidget *window = NULL; - GtkWidget *box1; - GtkWidget *box2; - GtkWidget *box3; - GtkWidget *button; - GtkWidget *label; - GtkWidget *separator; - GtkWidget *pixmapwid; - GdkPixmap *pixmap; - GdkBitmap *mask; - GtkStyle *style; + printf ("%s: child <%s> %sed\n", + gtk_type_name (GTK_OBJECT_TYPE (hb)), + gtk_type_name (GTK_OBJECT_TYPE (child)), + action); +} - if (!window) - { - window = gtk_window_new (GTK_WINDOW_TOPLEVEL); +static void +cb_tree_destroy_event(GtkWidget* w) +{ + sTreeButtons* tree_buttons; - gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), - &window); + /* free buttons structure associate at this tree */ + tree_buttons = gtk_object_get_user_data(GTK_OBJECT(w)); + free(tree_buttons); +} +static void +cb_add_new_item(GtkWidget* w, GtkTree* tree) +{ + sTreeButtons* tree_buttons; + GList* selected_list; + GtkWidget* selected_item; + GtkWidget* subtree; + GtkWidget* item_new; + char buffer[255]; - gtk_window_set_title (GTK_WINDOW (window), "pixmap"); - gtk_container_border_width (GTK_CONTAINER (window), 0); - gtk_widget_realize(window); + tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree)); - box1 = gtk_vbox_new (FALSE, 0); - gtk_container_add (GTK_CONTAINER (window), box1); - gtk_widget_show (box1); + selected_list = GTK_TREE_SELECTION(tree); - 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); + if(selected_list == NULL) + { + /* there is no item in tree */ + subtree = GTK_WIDGET(tree); + } + else + { + /* list can have only one element */ + selected_item = GTK_WIDGET(selected_list->data); + + subtree = GTK_TREE_ITEM_SUBTREE(selected_item); - button = gtk_button_new (); - gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0); - gtk_widget_show (button); + if(subtree == NULL) + { + /* current selected item have not subtree ... create it */ + subtree = gtk_tree_new(); + gtk_tree_item_set_subtree(GTK_TREE_ITEM(selected_item), + subtree); + } + } - style=gtk_widget_get_style(button); + /* at this point, we know which subtree will be used to add new item */ + /* create a new item */ + sprintf(buffer, "item add %d", tree_buttons->nb_item_add); + item_new = gtk_tree_item_new_with_label(buffer); + gtk_tree_append(GTK_TREE(subtree), item_new); + gtk_widget_show(item_new); - pixmap = gdk_pixmap_create_from_xpm (window->window, &mask, - &style->bg[GTK_STATE_NORMAL], - "test.xpm"); - pixmapwid = gtk_pixmap_new (pixmap, mask); + tree_buttons->nb_item_add++; +} - label = gtk_label_new ("Pixmap\ntest"); - box3 = gtk_hbox_new (FALSE, 0); - gtk_container_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); +static void +cb_remove_item(GtkWidget*w, GtkTree* tree) +{ + GList* selected_list; + GList* clear_list; + + selected_list = GTK_TREE_SELECTION(tree); - separator = gtk_hseparator_new (); - gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); - gtk_widget_show (separator); + clear_list = NULL; + + while (selected_list) + { + clear_list = g_list_prepend (clear_list, selected_list->data); + selected_list = selected_list->next; + } + + clear_list = g_list_reverse (clear_list); + gtk_tree_remove_items(tree, clear_list); + g_list_free (clear_list); +} - 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); +static void +cb_remove_subtree(GtkWidget*w, GtkTree* tree) +{ + GList* selected_list; + GtkTreeItem *item; + + selected_list = GTK_TREE_SELECTION(tree); + if (selected_list) + { + item = GTK_TREE_ITEM (selected_list->data); + if (item->subtree) + gtk_tree_item_remove_subtree (item); + } +} - button = gtk_button_new_with_label ("close"); +static void +cb_tree_changed(GtkTree* tree) +{ + sTreeButtons* tree_buttons; + GList* selected_list; + guint nb_selected; + + tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree)); + + selected_list = GTK_TREE_SELECTION(tree); + nb_selected = g_list_length(selected_list); + + if(nb_selected == 0) + { + if(tree->children == NULL) + gtk_widget_set_sensitive(tree_buttons->add_button, TRUE); + else + gtk_widget_set_sensitive(tree_buttons->add_button, FALSE); + gtk_widget_set_sensitive(tree_buttons->remove_button, FALSE); + gtk_widget_set_sensitive(tree_buttons->subtree_button, FALSE); + } + else + { + gtk_widget_set_sensitive(tree_buttons->remove_button, TRUE); + gtk_widget_set_sensitive(tree_buttons->add_button, (nb_selected == 1)); + gtk_widget_set_sensitive(tree_buttons->subtree_button, (nb_selected == 1)); + } +} + +static void +create_subtree(GtkWidget* item, guint level, guint nb_item_max, guint recursion_level_max) +{ + GtkWidget* item_subtree; + GtkWidget* item_new; + guint nb_item; + char buffer[255]; + int no_root_item; + + if(level == recursion_level_max) return; + + if(level == -1) + { + /* query with no root item */ + level = 0; + item_subtree = item; + no_root_item = 1; + } + else + { + /* query with no root item */ + /* create subtree and associate it with current item */ + item_subtree = gtk_tree_new(); + no_root_item = 0; + } + + for(nb_item = 0; nb_item < nb_item_max; nb_item++) + { + sprintf(buffer, "item %d-%d", level, nb_item); + item_new = gtk_tree_item_new_with_label(buffer); + gtk_tree_append(GTK_TREE(item_subtree), item_new); + create_subtree(item_new, level+1, nb_item_max, recursion_level_max); + gtk_widget_show(item_new); + } + + if(!no_root_item) + gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), item_subtree); +} + +static void +create_tree_sample(guint selection_mode, + guint draw_line, guint view_line, guint no_root_item, + guint nb_item_max, guint recursion_level_max) +{ + GtkWidget* window; + GtkWidget* box1; + GtkWidget* box2; + GtkWidget* separator; + GtkWidget* button; + GtkWidget* scrolled_win; + GtkWidget* root_tree; + GtkWidget* root_item; + sTreeButtons* tree_buttons; + + /* create tree buttons struct */ + if((tree_buttons = g_malloc(sizeof(sTreeButtons))) == NULL) + { + g_error("can't allocate memory for tree structure !\n"); + return; + } + tree_buttons->nb_item_add = 0; + + /* create top level window */ + window = gtk_window_new(GTK_WINDOW_TOPLEVEL); + gtk_window_set_title(GTK_WINDOW(window), "Tree Sample"); + gtk_signal_connect(GTK_OBJECT(window), "destroy", + (GtkSignalFunc) cb_tree_destroy_event, NULL); + gtk_object_set_user_data(GTK_OBJECT(window), tree_buttons); + + box1 = gtk_vbox_new(FALSE, 0); + gtk_container_add(GTK_CONTAINER(window), box1); + gtk_widget_show(box1); + + /* 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_widget_show(box2); + + /* create scrolled window */ + scrolled_win = gtk_scrolled_window_new (NULL, NULL); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), + GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); + gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0); + gtk_widget_set_usize (scrolled_win, 200, 200); + gtk_widget_show (scrolled_win); + + /* create root tree widget */ + root_tree = gtk_tree_new(); + gtk_signal_connect(GTK_OBJECT(root_tree), "selection_changed", + (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_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); + gtk_widget_show(root_tree); + + if ( no_root_item ) + { + /* set root tree to subtree function with root item variable */ + root_item = GTK_WIDGET(root_tree); + } + else + { + /* create root tree item widget */ + root_item = gtk_tree_item_new_with_label("root item"); + gtk_tree_append(GTK_TREE(root_tree), root_item); + gtk_widget_show(root_item); + } + create_subtree(root_item, -no_root_item, nb_item_max, recursion_level_max); + + 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_widget_show(box2); + + button = gtk_button_new_with_label("Add Item"); + gtk_widget_set_sensitive(button, FALSE); + gtk_signal_connect(GTK_OBJECT (button), "clicked", + (GtkSignalFunc) cb_add_new_item, + (gpointer)root_tree); + gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0); + gtk_widget_show(button); + tree_buttons->add_button = button; + + button = gtk_button_new_with_label("Remove Item(s)"); + gtk_widget_set_sensitive(button, FALSE); + gtk_signal_connect(GTK_OBJECT (button), "clicked", + (GtkSignalFunc) cb_remove_item, + (gpointer)root_tree); + gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0); + gtk_widget_show(button); + tree_buttons->remove_button = button; + + button = gtk_button_new_with_label("Remove Subtree"); + gtk_widget_set_sensitive(button, FALSE); + gtk_signal_connect(GTK_OBJECT (button), "clicked", + (GtkSignalFunc) cb_remove_subtree, + (gpointer)root_tree); + gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0); + gtk_widget_show(button); + tree_buttons->subtree_button = button; + + /* create separator */ + separator = gtk_hseparator_new(); + gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0); + gtk_widget_show(separator); + + /* 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_widget_show(box2); + + 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", + (GtkSignalFunc) gtk_widget_destroy, + GTK_OBJECT(window)); + gtk_widget_show(button); + + gtk_widget_show(window); +} + +static void +cb_create_tree(GtkWidget* w) +{ + guint selection_mode = GTK_SELECTION_SINGLE; + guint view_line; + guint draw_line; + guint no_root_item; + guint nb_item; + guint recursion_level; + + /* get selection mode choice */ + if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.single_button)->active) + selection_mode = GTK_SELECTION_SINGLE; + else + if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.browse_button)->active) + selection_mode = GTK_SELECTION_BROWSE; + else + selection_mode = GTK_SELECTION_MULTIPLE; + + /* get options choice */ + draw_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.draw_line_button)->active; + view_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.view_line_button)->active; + no_root_item = GTK_TOGGLE_BUTTON(sTreeSampleSelection.no_root_item_button)->active; + + /* get levels */ + nb_item = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.nb_item_spinner)); + recursion_level = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.recursion_spinner)); + + if (pow (nb_item, recursion_level) > 10000) + { + g_print ("%g total items? That will take a very long time. Try less\n", + pow (nb_item, recursion_level)); + return; + } + + create_tree_sample(selection_mode, draw_line, view_line, no_root_item, nb_item, recursion_level); +} + +void +create_tree_mode_window(void) +{ + static GtkWidget* window; + GtkWidget* box1; + GtkWidget* box2; + GtkWidget* box3; + GtkWidget* box4; + GtkWidget* box5; + GtkWidget* button; + GtkWidget* frame; + GtkWidget* separator; + GtkWidget* label; + GtkWidget* spinner; + GtkAdjustment *adj; + + if (!window) + { + /* create toplevel window */ + window = gtk_window_new(GTK_WINDOW_TOPLEVEL); + gtk_window_set_title(GTK_WINDOW(window), "Tree Mode Selection Window"); + 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 */ + 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); + + 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); + + /* 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); + + /* 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); + 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); + 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); + + /* 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"); + 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"); + 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); + gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0); + gtk_container_border_width(GTK_CONTAINER(box2), 5); + gtk_widget_show(box2); + + button = gtk_button_new_with_label("Create Tree Sample"); + 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_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(button); + } + if (!GTK_WIDGET_VISIBLE (window)) + gtk_widget_show (window); + else + gtk_widget_destroy (window); +} + +/* end of function used by tree demos */ + +static void +create_handle_box (void) +{ + static GtkWidget* window = NULL; + GtkWidget *handle_box; + GtkWidget *handle_box2; + GtkWidget *vbox; + GtkWidget *hbox; + GtkWidget *toolbar; + GtkWidget *label; + GtkWidget *separator; + + if (!window) + { + window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_title (GTK_WINDOW (window), + "Handle Box Test"); + gtk_window_set_policy (GTK_WINDOW (window), + TRUE, + TRUE, + FALSE); + + gtk_signal_connect (GTK_OBJECT (window), "destroy", + GTK_SIGNAL_FUNC(gtk_widget_destroyed), + &window); + + gtk_container_border_width (GTK_CONTAINER (window), 20); + + vbox = gtk_vbox_new (FALSE, 0); + gtk_container_add (GTK_CONTAINER (window), vbox); + gtk_widget_show (vbox); + + label = gtk_label_new ("Above"); + gtk_container_add (GTK_CONTAINER (vbox), label); + gtk_widget_show (label); + + separator = gtk_hseparator_new (); + gtk_container_add (GTK_CONTAINER (vbox), separator); + gtk_widget_show (separator); + + hbox = gtk_hbox_new (FALSE, 10); + gtk_container_add (GTK_CONTAINER (vbox), hbox); + gtk_widget_show (hbox); + + separator = gtk_hseparator_new (); + gtk_container_add (GTK_CONTAINER (vbox), separator); + gtk_widget_show (separator); + + label = gtk_label_new ("Below"); + gtk_container_add (GTK_CONTAINER (vbox), label); + gtk_widget_show (label); + + handle_box = gtk_handle_box_new (); + gtk_container_add (GTK_CONTAINER (hbox), handle_box); + gtk_signal_connect (GTK_OBJECT (handle_box), + "child_attached", + GTK_SIGNAL_FUNC (handle_box_child_signal), + "attached"); + gtk_signal_connect (GTK_OBJECT (handle_box), + "child_detached", + GTK_SIGNAL_FUNC (handle_box_child_signal), + "detached"); + gtk_widget_show (handle_box); + + toolbar = make_toolbar (window); + gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NORMAL); + gtk_container_add (GTK_CONTAINER (handle_box), toolbar); + gtk_widget_show (toolbar); + + handle_box = gtk_handle_box_new (); + gtk_container_add (GTK_CONTAINER (hbox), handle_box); + gtk_signal_connect (GTK_OBJECT (handle_box), + "child_attached", + GTK_SIGNAL_FUNC (handle_box_child_signal), + "attached"); + gtk_signal_connect (GTK_OBJECT (handle_box), + "child_detached", + GTK_SIGNAL_FUNC (handle_box_child_signal), + "detached"); + gtk_widget_show (handle_box); + + handle_box2 = gtk_handle_box_new (); + gtk_container_add (GTK_CONTAINER (handle_box), handle_box2); + gtk_signal_connect (GTK_OBJECT (handle_box2), + "child_attached", + GTK_SIGNAL_FUNC (handle_box_child_signal), + "attached"); + gtk_signal_connect (GTK_OBJECT (handle_box2), + "child_detached", + GTK_SIGNAL_FUNC (handle_box_child_signal), + "detached"); + gtk_widget_show (handle_box2); + + label = gtk_label_new ("Fooo!"); + gtk_container_add (GTK_CONTAINER (handle_box2), label); + gtk_widget_show (label); + } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); @@ -1031,60 +1632,109 @@ create_pixmap () gtk_widget_destroy (window); } -void -create_tooltips () + +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, + GtkWidget *old_parent, + gpointer func_data) +{ + g_print ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n", + gtk_type_name (GTK_OBJECT_TYPE (child)), + child->parent ? gtk_type_name (GTK_OBJECT_TYPE (child->parent)) : "NULL", + old_parent ? gtk_type_name (GTK_OBJECT_TYPE (old_parent)) : "NULL", + GPOINTER_TO_INT (func_data)); +} + +static void +create_reparent (void) { static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; + GtkWidget *box3; + GtkWidget *frame; GtkWidget *button; + GtkWidget *label; GtkWidget *separator; - GtkTooltips *tooltips; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), - &window); + GTK_SIGNAL_FUNC(gtk_widget_destroyed), + &window); - gtk_window_set_title (GTK_WINDOW (window), "tooltips"); + gtk_window_set_title (GTK_WINDOW (window), "buttons"); gtk_container_border_width (GTK_CONTAINER (window), 0); - tooltips=gtk_tooltips_new(); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); gtk_widget_show (box1); - box2 = gtk_vbox_new (FALSE, 10); + box2 = gtk_hbox_new (FALSE, 5); gtk_container_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); + label = gtk_label_new ("Hello World"); - gtk_tooltips_set_tips(tooltips,button,"This is button 1"); + frame = gtk_frame_new ("Frame 1"); + gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0); + gtk_widget_show (frame); - button = gtk_toggle_button_new_with_label ("button2"); - gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); + box3 = gtk_vbox_new (FALSE, 5); + gtk_container_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", + GTK_SIGNAL_FUNC(reparent_label), + 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_tooltips_set_tips(tooltips,button,"This is button 2"); + 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); - button = gtk_toggle_button_new_with_label ("button3"); - gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); + + 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_add (GTK_CONTAINER (frame), box3); + gtk_widget_show (box3); + + button = gtk_button_new_with_label ("switch"); + gtk_signal_connect (GTK_OBJECT (button), "clicked", + GTK_SIGNAL_FUNC(reparent_label), + 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_tooltips_set_tips (tooltips, button, "This is button 3. This is also a really long tooltip which probably won't fit on a single line and will therefore need to be wrapped. Hopefully the wrapping will work correctly."); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); @@ -1099,14 +1749,12 @@ create_tooltips () 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_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); - - gtk_tooltips_set_tips (tooltips, button, "Push this button to close window"); } if (!GTK_WIDGET_VISIBLE (window)) @@ -1115,95 +1763,343 @@ create_tooltips () gtk_widget_destroy (window); } -GtkWidget* -create_menu (int depth) -{ - GtkWidget *menu; - GtkWidget *submenu; - GtkWidget *menuitem; - GSList *group; - char buf[32]; - int i, j; - - if (depth < 1) - return NULL; - - menu = gtk_menu_new (); - submenu = NULL; - group = NULL; - - for (i = 0, j = 1; i < 5; i++, j++) - { - sprintf (buf, "item %2d - %d", depth, j); - menuitem = gtk_radio_menu_item_new_with_label (group, buf); - group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem)); - if (depth % 2) - gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (menuitem), TRUE); - gtk_menu_append (GTK_MENU (menu), menuitem); - gtk_widget_show (menuitem); - - if (depth > 0) - { - if (!submenu) - submenu = create_menu (depth - 1); - gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu); - } - } - - return menu; -} - -void -create_menus () +static void +create_pixmap (void) { static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; + GtkWidget *box3; GtkWidget *button; - GtkWidget *menu; - GtkWidget *menubar; - GtkWidget *menuitem; - GtkWidget *optionmenu; + GtkWidget *label; GtkWidget *separator; + GtkWidget *pixmapwid; + GdkPixmap *pixmap; + GdkBitmap *mask; + GtkStyle *style; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), - &window); + GTK_SIGNAL_FUNC(gtk_widget_destroyed), + &window); - gtk_window_set_title (GTK_WINDOW (window), "menus"); + gtk_window_set_title (GTK_WINDOW (window), "pixmap"); gtk_container_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_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); + gtk_widget_show (box2); - menubar = gtk_menu_bar_new (); - gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0); - gtk_widget_show (menubar); - - menu = create_menu (2); + button = gtk_button_new (); + gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0); + gtk_widget_show (button); - menuitem = gtk_menu_item_new_with_label ("test\nline2"); - gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu); - gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem); - gtk_widget_show (menuitem); + style=gtk_widget_get_style(button); - menuitem = gtk_menu_item_new_with_label ("foo"); - gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu); + pixmap = gdk_pixmap_create_from_xpm (window->window, &mask, + &style->bg[GTK_STATE_NORMAL], + "test.xpm"); + pixmapwid = gtk_pixmap_new (pixmap, mask); + + label = gtk_label_new ("Pixmap\ntest"); + box3 = gtk_hbox_new (FALSE, 0); + gtk_container_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_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_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); + else + gtk_widget_destroy (window); +} + +static void +tips_query_widget_entered (GtkTipsQuery *tips_query, + GtkWidget *widget, + const gchar *tip_text, + const gchar *tip_private, + GtkWidget *toggle) +{ + if (GTK_TOGGLE_BUTTON (toggle)->active) + { + gtk_label_set (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"); + } +} + +static gint +tips_query_widget_selected (GtkWidget *tips_query, + GtkWidget *widget, + const gchar *tip_text, + const gchar *tip_private, + GdkEventButton *event, + gpointer func_data) +{ + if (widget) + g_print ("Help \"%s\" requested for <%s>\n", + tip_private ? tip_private : "None", + gtk_type_name (GTK_OBJECT_TYPE (widget))); + + return TRUE; +} + +static void +create_tooltips (void) +{ + static GtkWidget *window = NULL; + GtkWidget *box1; + GtkWidget *box2; + GtkWidget *box3; + GtkWidget *button; + GtkWidget *toggle; + GtkWidget *frame; + GtkWidget *tips_query; + GtkWidget *separator; + GtkTooltips *tooltips; + + if (!window) + { + window = + gtk_widget_new (gtk_window_get_type (), + "GtkWindow::type", GTK_WINDOW_TOPLEVEL, + "GtkContainer::border_width", 0, + "GtkWindow::title", "Tooltips", + "GtkWindow::allow_shrink", TRUE, + "GtkWindow::allow_grow", FALSE, + "GtkWindow::auto_shrink", TRUE, + "GtkWidget::width", 200, + NULL); + + gtk_signal_connect (GTK_OBJECT (window), "destroy", + GTK_SIGNAL_FUNC (destroy_tooltips), + &window); + + tooltips=gtk_tooltips_new(); + gtk_object_set_data (GTK_OBJECT (window), "tooltips", tooltips); + + 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); + + + 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, + "This is button 2. This is also a really long tooltip which probably won't fit on a single line and will therefore need to be wrapped. Hopefully the wrapping will work correctly.", + "ContextHelp/buttons/2_long"); + + 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! ;)"); + + box3 = + gtk_widget_new (gtk_vbox_get_type (), + "GtkBox::homogeneous", FALSE, + "GtkBox::spacing", 5, + "GtkContainer::border_width", 5, + "GtkWidget::visible", TRUE, + NULL); + + tips_query = gtk_tips_query_new (); + + button = + gtk_widget_new (gtk_button_get_type (), + "GtkButton::label", "[?]", + "GtkWidget::visible", TRUE, + "GtkWidget::parent", box3, + "GtkObject::object_signal::clicked", gtk_tips_query_start_query, tips_query, + NULL); + gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START); + gtk_tooltips_set_tip (tooltips, + button, + "Start the Tooltips Inspector", + "ContextHelp/buttons/?"); + + + gtk_widget_set (tips_query, + "GtkWidget::visible", TRUE, + "GtkWidget::parent", box3, + "GtkTipsQuery::caller", button, + "GtkObject::signal::widget_entered", tips_query_widget_entered, toggle, + "GtkObject::signal::widget_selected", tips_query_widget_selected, NULL, + NULL); + + frame = + gtk_widget_new (gtk_frame_get_type (), + "GtkFrame::label", "ToolTips Inspector", + "GtkFrame::label_xalign", (double) 0.5, + "GtkContainer::border_width", 0, + "GtkWidget::visible", TRUE, + "GtkWidget::parent", box2, + "GtkContainer::child", box3, + NULL); + gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START); + + 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_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_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); + + gtk_tooltips_set_tip (tooltips, button, "Push this button to close window", "ContextHelp/buttons/Close"); + } + + if (!GTK_WIDGET_VISIBLE (window)) + gtk_widget_show (window); + else + gtk_widget_destroy (window); +} + +static GtkWidget* +create_menu (int depth) +{ + GtkWidget *menu; + GtkWidget *menuitem; + GSList *group; + char buf[32]; + int i, j; + + if (depth < 1) + return NULL; + + menu = gtk_menu_new (); + group = NULL; + + for (i = 0, j = 1; i < 5; i++, j++) + { + sprintf (buf, "item %2d - %d", depth, j); + menuitem = gtk_radio_menu_item_new_with_label (group, buf); + group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem)); + if (depth % 2) + gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (menuitem), TRUE); + gtk_menu_append (GTK_MENU (menu), menuitem); + gtk_widget_show (menuitem); + if (i == 3) + gtk_widget_set_sensitive (menuitem, FALSE); + + gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1)); + } + + return menu; +} + +static void +create_menus (void) +{ + static GtkWidget *window = NULL; + GtkWidget *box1; + GtkWidget *box2; + GtkWidget *button; + GtkWidget *menu; + GtkWidget *menubar; + GtkWidget *menuitem; + GtkWidget *optionmenu; + GtkWidget *separator; + + 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_connect (GTK_OBJECT (window), "delete-event", + GTK_SIGNAL_FUNC (gtk_true), + NULL); + + gtk_window_set_title (GTK_WINDOW (window), "menus"); + 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); + + + menubar = gtk_menu_bar_new (); + gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0); + gtk_widget_show (menubar); + + menu = create_menu (2); + + menuitem = gtk_menu_item_new_with_label ("test\nline2"); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu); + gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem); + gtk_widget_show (menuitem); + + menuitem = gtk_menu_item_new_with_label ("foo"); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3)); 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), menu); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4)); gtk_menu_item_right_justify (GTK_MENU_ITEM (menuitem)); gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem); gtk_widget_show (menuitem); @@ -1252,8 +2148,33 @@ create_menus () /* * GtkScrolledWindow */ -void -create_scrolled_windows () +static void +scrolled_windows_remove (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_reparent (scrollwin, float_parent); + gtk_widget_show (float_parent); + } +} + +/* + * GtkScrolledWindow + */ +static void +create_scrolled_windows (void) { static GtkWidget *window; GtkWidget *scrolled_window; @@ -1267,10 +2188,7 @@ create_scrolled_windows () window = gtk_dialog_new (); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "dialog"); @@ -1290,6 +2208,10 @@ create_scrolled_windows () 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_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_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window))); gtk_widget_show (table); for (i = 0; i < 20; i++) @@ -1312,6 +2234,17 @@ create_scrolled_windows () button, TRUE, TRUE, 0); gtk_widget_grab_default (button); gtk_widget_show (button); + + button = gtk_button_new_with_label ("remove"); + gtk_signal_connect_object (GTK_OBJECT (button), "clicked", + GTK_SIGNAL_FUNC(scrolled_windows_remove), + GTK_OBJECT (scrolled_window)); + GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), + button, TRUE, TRUE, 0); + gtk_widget_grab_default (button); + gtk_widget_show (button); + } if (!GTK_WIDGET_VISIBLE (window)) @@ -1324,15 +2257,24 @@ create_scrolled_windows () * GtkEntry */ -void entry_toggle_editable (GtkWidget *checkbutton, - GtkWidget *entry) +static void +entry_toggle_editable (GtkWidget *checkbutton, + GtkWidget *entry) { gtk_entry_set_editable(GTK_ENTRY(entry), GTK_TOGGLE_BUTTON(checkbutton)->active); } -void -create_entry () +static void +entry_toggle_visibility (GtkWidget *checkbutton, + GtkWidget *entry) +{ + gtk_entry_set_visibility(GTK_ENTRY(entry), + GTK_TOGGLE_BUTTON(checkbutton)->active); +} + +static void +create_entry (void) { static GtkWidget *window = NULL; GtkWidget *box1; @@ -1345,16 +2287,21 @@ create_entry () if (!window) { - cbitems = g_list_append(cbitems, "item1"); - cbitems = g_list_append(cbitems, "item2"); - cbitems = g_list_append(cbitems, "and item3"); + cbitems = g_list_append(cbitems, "item0"); + cbitems = g_list_append(cbitems, "item1 item1"); + cbitems = g_list_append(cbitems, "item2 item2 item2"); + cbitems = g_list_append(cbitems, "item3 item3 item3 item3"); + cbitems = g_list_append(cbitems, "item4 item4 item4 item4 item4"); + cbitems = g_list_append(cbitems, "item5 item5 item5 item5 item5 item5"); + cbitems = g_list_append(cbitems, "item6 item6 item6 item6 item6"); + cbitems = g_list_append(cbitems, "item7 item7 item7 item7"); + cbitems = g_list_append(cbitems, "item8 item8 item8"); + cbitems = g_list_append(cbitems, "item9 item9"); + window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "entry"); @@ -1373,25 +2320,32 @@ create_entry () entry = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry), "hello world"); - gtk_entry_select_region (GTK_ENTRY (entry), - 0, GTK_ENTRY(entry)->text_length); + gtk_editable_select_region (GTK_EDITABLE (entry), 0, -1); gtk_box_pack_start (GTK_BOX (box2), entry, TRUE, TRUE, 0); gtk_widget_show (entry); - cb = gtk_combo_box_new (cbitems); - gtk_entry_set_text (GTK_ENTRY (cb), "hello world"); - gtk_entry_select_region (GTK_ENTRY (cb), - 0, GTK_ENTRY(entry)->text_length); + cb = gtk_combo_new (); + gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems); + gtk_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world"); + gtk_editable_select_region (GTK_EDITABLE (GTK_COMBO(cb)->entry), + 0, -1); gtk_box_pack_start (GTK_BOX (box2), cb, TRUE, TRUE, 0); gtk_widget_show (cb); editable_check = gtk_check_button_new_with_label("Editable"); - gtk_box_pack_start (GTK_BOX (box2), editable_check, TRUE, TRUE, 0); + 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_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_widget_show (editable_check); + separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_widget_show (separator); @@ -1415,30 +2369,444 @@ create_entry () if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); - /* else - gtk_widget_destroy (window); */ + else + gtk_widget_destroy (window); } /* - * GtkList + * GtkSpinButton */ -void -list_add (GtkWidget *widget, - GtkWidget *list) -{ - static int i = 1; - gchar buffer[64]; - GtkWidget *list_item; - 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); +static GtkWidget *spinner1; + +static void +toggle_snap (GtkWidget *widget, GtkSpinButton *spin) +{ + gtk_spin_button_set_snap_to_ticks (spin, GTK_TOGGLE_BUTTON (widget)->active); } -void -list_remove (GtkWidget *widget, - GtkWidget *list) +static void +toggle_numeric (GtkWidget *widget, GtkSpinButton *spin) +{ + gtk_spin_button_set_numeric (spin, GTK_TOGGLE_BUTTON (widget)->active); +} + +static void +change_digits (GtkWidget *widget, GtkSpinButton *spin) +{ + gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner1), + gtk_spin_button_get_value_as_int (spin)); +} + +static void +get_value (GtkWidget *widget, gpointer data) +{ + gchar buf[32]; + GtkLabel *label; + GtkSpinButton *spin; + + spin = GTK_SPIN_BUTTON (spinner1); + label = GTK_LABEL (gtk_object_get_user_data (GTK_OBJECT (widget))); + if (GPOINTER_TO_INT (data) == 1) + sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin)); + else + sprintf (buf, "%0.*f", spin->digits, + gtk_spin_button_get_value_as_float (spin)); + gtk_label_set (label, buf); +} + +static void +create_spins (void) +{ + static GtkWidget *window = NULL; + GtkWidget *frame; + GtkWidget *hbox; + GtkWidget *main_vbox; + GtkWidget *vbox; + GtkWidget *vbox2; + GtkWidget *spinner2; + GtkWidget *spinner; + GtkWidget *button; + GtkWidget *label; + GtkWidget *val_label; + GtkAdjustment *adj; + + if (!window) + { + 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), "GtkSpinButton"); + + main_vbox = gtk_vbox_new (FALSE, 5); + gtk_container_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_add (GTK_CONTAINER (frame), vbox); + + /* Day, month, year 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 :"); + 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); + spinner = gtk_spin_button_new (adj, 0, 0); + gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE); + gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner), + GTK_SHADOW_NONE); + 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 ("Month :"); + 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, 12.0, 1.0, + 5.0, 0.0); + spinner = gtk_spin_button_new (adj, 0, 0); + 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_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 :"); + 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); + spinner = gtk_spin_button_new (adj, 0, 0); + 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); + + frame = gtk_frame_new ("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_add (GTK_CONTAINER (frame), vbox); + + hbox = gtk_hbox_new (FALSE, 0); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5); + + vbox2 = gtk_vbox_new (FALSE, 0); + gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5); + + label = gtk_label_new ("Value :"); + 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 (0.0, -10000.0, 10000.0, + 0.5, 100.0, 0.0); + spinner1 = gtk_spin_button_new (adj, 1.0, 2); + gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE); + gtk_widget_set_usize (spinner1, 100, 0); + gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0); + + vbox2 = gtk_vbox_new (FALSE, 0); + gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5); + + label = gtk_label_new ("Digits :"); + 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 (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_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0); + + hbox = gtk_hbox_new (FALSE, 0); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5); + + button = gtk_check_button_new_with_label ("Snap to 0.5-ticks"); + gtk_signal_connect (GTK_OBJECT (button), "clicked", + 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); + + 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); + + val_label = gtk_label_new (""); + + hbox = gtk_hbox_new (FALSE, 0); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5); + + button = gtk_button_new_with_label ("Value as Int"); + gtk_object_set_user_data (GTK_OBJECT (button), val_label); + gtk_signal_connect (GTK_OBJECT (button), "clicked", + GTK_SIGNAL_FUNC (get_value), + GINT_TO_POINTER (1)); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5); + + button = gtk_button_new_with_label ("Value as Float"); + gtk_object_set_user_data (GTK_OBJECT (button), val_label); + gtk_signal_connect (GTK_OBJECT (button), "clicked", + GTK_SIGNAL_FUNC (get_value), + GINT_TO_POINTER (2)); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5); + + gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0); + gtk_label_set (GTK_LABEL (val_label), "0"); + + hbox = gtk_hbox_new (FALSE, 0); + 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); + } + + if (!GTK_WIDGET_VISIBLE (window)) + gtk_widget_show_all (window); + else + gtk_widget_destroy (window); +} + +/* + * Cursors + */ + +static gint +cursor_expose_event (GtkWidget *widget, + GdkEvent *event, + gpointer user_data) +{ + GtkDrawingArea *darea; + GdkDrawable *drawable; + GdkGC *black_gc; + GdkGC *gray_gc; + GdkGC *white_gc; + guint max_width; + guint max_height; + + g_return_val_if_fail (widget != NULL, TRUE); + g_return_val_if_fail (GTK_IS_DRAWING_AREA (widget), TRUE); + + darea = GTK_DRAWING_AREA (widget); + drawable = widget->window; + white_gc = widget->style->white_gc; + gray_gc = widget->style->bg_gc[GTK_STATE_NORMAL]; + black_gc = widget->style->black_gc; + max_width = widget->allocation.width; + max_height = widget->allocation.height; + + gdk_draw_rectangle (drawable, white_gc, + TRUE, + 0, + 0, + max_width, + max_height / 2); + + gdk_draw_rectangle (drawable, black_gc, + TRUE, + 0, + max_height / 2, + max_width, + max_height / 2); + + gdk_draw_rectangle (drawable, gray_gc, + TRUE, + max_width / 3, + max_height / 3, + max_width / 3, + max_height / 3); + + return TRUE; +} + +static void +set_cursor (GtkWidget *spinner, + GtkWidget *widget) +{ + guint c; + GdkCursor *cursor; + + c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152); + c &= 0xfe; + + cursor = gdk_cursor_new (c); + gdk_window_set_cursor (widget->window, cursor); + gdk_cursor_destroy (cursor); +} + +static gint +cursor_event (GtkWidget *widget, + GdkEvent *event, + GtkSpinButton *spinner) +{ + if ((event->type == GDK_BUTTON_PRESS) && + ((event->button.button == 1) || + (event->button.button == 3))) + { + gtk_spin_button_spin (spinner, + event->button.button == 1 ? GTK_ARROW_UP : GTK_ARROW_DOWN, + spinner->adjustment->step_increment); + return TRUE; + } + + return FALSE; +} + +static void +create_cursors (void) +{ + static GtkWidget *window = NULL; + GtkWidget *frame; + GtkWidget *hbox; + GtkWidget *main_vbox; + GtkWidget *vbox; + GtkWidget *darea; + GtkWidget *spinner; + GtkWidget *button; + GtkWidget *label; + GtkWidget *any; + GtkAdjustment *adj; + + if (!window) + { + 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), "Cursors"); + + main_vbox = gtk_vbox_new (FALSE, 5); + gtk_container_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_border_width (GTK_CONTAINER (hbox), 5); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); + + 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); + + adj = (GtkAdjustment *) gtk_adjustment_new (0, + 0, 152, + 2, + 10, 0); + spinner = gtk_spin_button_new (adj, 0, 0); + gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0); + + frame = + gtk_widget_new (gtk_frame_get_type (), + "GtkFrame::shadow", GTK_SHADOW_ETCHED_IN, + "GtkFrame::label_xalign", 0.5, + "GtkFrame::label", "Cursor Area", + "GtkContainer::border_width", 10, + "GtkWidget::parent", vbox, + "GtkWidget::visible", TRUE, + NULL); + + darea = gtk_drawing_area_new (); + gtk_widget_set_usize (darea, 80, 80); + gtk_container_add (GTK_CONTAINER (frame), darea); + gtk_signal_connect (GTK_OBJECT (darea), + "expose_event", + GTK_SIGNAL_FUNC (cursor_expose_event), + NULL); + gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK); + gtk_signal_connect (GTK_OBJECT (darea), + "button_press_event", + GTK_SIGNAL_FUNC (cursor_event), + spinner); + gtk_widget_show (darea); + + gtk_signal_connect (GTK_OBJECT (spinner), "changed", + GTK_SIGNAL_FUNC (set_cursor), + darea); + + 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_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_show_all (window); + + set_cursor (spinner, darea); + } + else + gtk_widget_destroy (window); +} + +/* + * GtkList + */ +static void +list_add (GtkWidget *widget, + GtkWidget *list) +{ + static int i = 1; + gchar buffer[64]; + GtkWidget *list_item; + + 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); +} + +static void +list_remove (GtkWidget *widget, + GtkWidget *list) { GList *tmp_list; GList *clear_list; @@ -1456,19 +2824,18 @@ list_remove (GtkWidget *widget, gtk_list_remove_items (GTK_LIST (list), clear_list); - tmp_list = clear_list; - - while (tmp_list) - { - gtk_widget_destroy (GTK_WIDGET (tmp_list->data)); - tmp_list = tmp_list->next; - } - g_list_free (clear_list); } -void -create_list () +static void +list_clear (GtkWidget *widget, + GtkWidget *list) +{ + gtk_list_clear_items (GTK_LIST (list), 3 - 1, 6 - 1); +} + +static void +create_list (void) { static GtkWidget *window = NULL; static char *list_items[] = @@ -1486,416 +2853,1398 @@ create_list () }; 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; + GtkWidget *box1; + GtkWidget *box2; + GtkWidget *scrolled_win; + GtkWidget *list; + GtkWidget *list_item; + GtkWidget *button; + GtkWidget *separator; + int i; + + if (!window) + { + 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), "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); + + + scrolled_win = gtk_scrolled_window_new (NULL, NULL); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), + GTK_POLICY_AUTOMATIC, + GTK_POLICY_AUTOMATIC); + gtk_box_pack_start (GTK_BOX (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++) + { + list_item = gtk_list_item_new_with_label (list_items[i]); + gtk_container_add (GTK_CONTAINER (list), list_item); + gtk_widget_show (list_item); + } + + button = gtk_button_new_with_label ("add"); + GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS); + gtk_signal_connect (GTK_OBJECT (button), "clicked", + 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); + gtk_signal_connect (GTK_OBJECT (button), "clicked", + 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); + gtk_signal_connect (GTK_OBJECT (button), "clicked", + GTK_SIGNAL_FUNC(list_remove), + list); + gtk_box_pack_start (GTK_BOX (box2), 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_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_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); + else + gtk_widget_destroy (window); +} + +/* + * GtkCList + */ +#define TESTGTK_CLIST_COLUMNS 7 +static gint clist_rows = 0; +static gint clist_selected_row = 0; + +static void +add1000_clist (GtkWidget *widget, gpointer data) +{ + gint i, row; + char text[TESTGTK_CLIST_COLUMNS][50]; + char *texts[TESTGTK_CLIST_COLUMNS]; + GdkBitmap *mask; + GdkPixmap *pixmap; + + pixmap = gdk_pixmap_create_from_xpm (GTK_CLIST (data)->clist_window, + &mask, + >K_WIDGET (data)->style->white, + "3DRings.xpm"); + + for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++) + { + texts[i] = text[i]; + sprintf (text[i], "Column %d", i); + } + + texts[3] = NULL; + sprintf (text[1], "Right"); + sprintf (text[2], "Center"); + + 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); + } + gtk_clist_thaw (GTK_CLIST (data)); + + gdk_pixmap_unref (pixmap); + gdk_bitmap_unref (mask); +} + +static void +add10000_clist (GtkWidget *widget, gpointer data) +{ + gint i; + char text[TESTGTK_CLIST_COLUMNS][50]; + char *texts[TESTGTK_CLIST_COLUMNS]; + + for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++) + { + texts[i] = text[i]; + sprintf (text[i], "Column %d", i); + } + + sprintf (text[1], "Right"); + sprintf (text[2], "Center"); + + gtk_clist_freeze (GTK_CLIST (data)); + for (i = 0; i < 10000; i++) + { + sprintf (text[0], "Row %d", clist_rows++); + gtk_clist_append (GTK_CLIST (data), texts); + } + gtk_clist_thaw (GTK_CLIST (data)); + +} + +void +clear_clist (GtkWidget *widget, gpointer data) +{ + gtk_clist_clear (GTK_CLIST (data)); + clist_rows = 0; +} + +void +remove_row_clist (GtkWidget *widget, gpointer data) +{ + gtk_clist_remove (GTK_CLIST (data), clist_selected_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) +{ + 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); + + 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; + } + + g_print ("\n\n\n"); + + clist_selected_row = row; +} + +void +unselect_clist (GtkWidget *widget, + gint row, + gint column, + GdkEventButton * bevent) +{ + 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; + } + + g_print ("\n\n\n"); + + clist_selected_row = row; +} + +static void +insert_row_clist (GtkWidget *widget, gpointer data) +{ + static char *text[] = + { + "This", + "is", + "a", + "inserted", + "row", + "la la la la la", + "la la la la" + }; + + gtk_clist_insert (GTK_CLIST (data), clist_selected_row, text); + clist_rows++; +} + +static void +clist_warning_test (GtkWidget *button, + GtkWidget *clist) +{ + GtkWidget *child; + static gboolean add_remove = FALSE; + + add_remove = !add_remove; + + child = gtk_label_new ("Test"); + gtk_widget_ref (child); + gtk_object_sink (GTK_OBJECT (child)); + + if (add_remove) + gtk_container_add (GTK_CONTAINER (clist), child); + else + { + child->parent = clist; + gtk_container_remove (GTK_CONTAINER (clist), child); + child->parent = NULL; + } + + gtk_widget_destroy (child); + gtk_widget_unref (child); +} + +static void +create_clist (void) +{ + gint i; + static GtkWidget *window = NULL; + + static char *titles[] = + { + "Title 0", + "Title 1", + "Title 2", + "Title 3", + "Title 4", + "Title 5", + "Title 6" + }; + + char text[TESTGTK_CLIST_COLUMNS][50]; + char *texts[TESTGTK_CLIST_COLUMNS]; + + GtkWidget *box1; + GtkWidget *box2; + GtkWidget *clist; + GtkWidget *button; + GtkWidget *separator; + + + if (!window) + { + 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), "clist"); + 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_hbox_new (FALSE, 10); + gtk_container_border_width (GTK_CONTAINER (box2), 10); + gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0); + gtk_widget_show (box2); + + /* 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);*/ + + /* 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); + + gtk_widget_show (button); + + + 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); + + gtk_widget_show (button); + + button = gtk_button_new_with_label ("Clear List"); + gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); + + gtk_signal_connect (GTK_OBJECT (button), + "clicked", + (GtkSignalFunc) clear_clist, + (gpointer) clist); + + gtk_widget_show (button); + + button = gtk_button_new_with_label ("Remove Row"); + gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); + + gtk_signal_connect (GTK_OBJECT (button), + "clicked", + (GtkSignalFunc) remove_row_clist, + (gpointer) clist); + + gtk_widget_show (button); + + /* 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); + gtk_widget_show (box2); + + button = gtk_button_new_with_label ("Insert Row"); + gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); - if (!window) - { - window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_signal_connect (GTK_OBJECT (button), + "clicked", + (GtkSignalFunc) insert_row_clist, + (gpointer) clist); - gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), - &window); + gtk_widget_show (button); - gtk_window_set_title (GTK_WINDOW (window), "list"); - gtk_container_border_width (GTK_CONTAINER (window), 0); + button = gtk_button_new_with_label ("Show Title Buttons"); + gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); + gtk_signal_connect (GTK_OBJECT (button), + "clicked", + (GtkSignalFunc) show_titles_clist, + (gpointer) clist); - box1 = gtk_vbox_new (FALSE, 0); - gtk_container_add (GTK_CONTAINER (window), box1); - gtk_widget_show (box1); + gtk_widget_show (button); + + button = gtk_button_new_with_label ("Hide Title Buttons"); + gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); + + gtk_signal_connect (GTK_OBJECT (button), + "clicked", + (GtkSignalFunc) hide_titles_clist, + (gpointer) clist); + + gtk_widget_show (button); + + button = gtk_button_new_with_label ("Warning Test"); + gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); + + gtk_signal_connect (GTK_OBJECT (button), + "clicked", + (GtkSignalFunc) clist_warning_test, + (gpointer) clist); + gtk_widget_show (button); + /* 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); gtk_widget_show (box2); + /* + * the rest of the clist configuration + */ + gtk_clist_set_row_height (GTK_CLIST (clist), 20); + + gtk_signal_connect (GTK_OBJECT (clist), + "select_row", + (GtkSignalFunc) select_clist, + NULL); - scrolled_win = gtk_scrolled_window_new (NULL, NULL); - gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), - GTK_POLICY_AUTOMATIC, - GTK_POLICY_AUTOMATIC); - gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0); - gtk_widget_show (scrolled_win); + gtk_signal_connect (GTK_OBJECT (clist), + "unselect_row", + (GtkSignalFunc) unselect_clist, + NULL); - 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_widget_show (list); + gtk_clist_set_column_width (GTK_CLIST (clist), 0, 100); - for (i = 0; i < nlist_items; i++) + for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++) + gtk_clist_set_column_width (GTK_CLIST (clist), i, 80); + + gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_BROWSE); + 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, GTK_JUSTIFY_CENTER); + + for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++) { - list_item = gtk_list_item_new_with_label (list_items[i]); - gtk_container_add (GTK_CONTAINER (list), list_item); - gtk_widget_show (list_item); + texts[i] = text[i]; + sprintf (text[i], "Column %d", i); } - button = gtk_button_new_with_label ("add"); - GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS); - gtk_signal_connect (GTK_OBJECT (button), "clicked", - GTK_SIGNAL_FUNC(list_add), - list); - gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0); - gtk_widget_show (button); + sprintf (text[1], "Right"); + sprintf (text[2], "Center"); - button = gtk_button_new_with_label ("remove"); - GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS); - gtk_signal_connect (GTK_OBJECT (button), "clicked", - GTK_SIGNAL_FUNC(list_remove), - list); - gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0); - gtk_widget_show (button); + for (i = 0; i < 100; i++) + { + sprintf (text[0], "Row %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); + gtk_widget_show (clist); 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_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_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); else - gtk_widget_destroy (window); + { + clist_rows = 0; + gtk_widget_destroy (window); + } + } + /* - * GtkCList + * GtkCTree */ -#define TESTGTK_CLIST_COLUMNS 7 -static gint clist_rows = 0; -static gint clist_selected_row = 0; -void -add1000_clist (GtkWidget *widget, gpointer data) +static char * book_open_xpm[] = { +"16 16 4 1", +" c None s None", +". c black", +"X c #808080", +"o c white", +" ", +" .. ", +" .Xo. ... ", +" .Xoo. ..oo. ", +" .Xooo.Xooo... ", +" .Xooo.oooo.X. ", +" .Xooo.Xooo.X. ", +" .Xooo.oooo.X. ", +" .Xooo.Xooo.X. ", +" .Xooo.oooo.X. ", +" .Xoo.Xoo..X. ", +" .Xo.o..ooX. ", +" .X..XXXXX. ", +" ..X....... ", +" .. ", +" "}; + +static char * book_closed_xpm[] = { +"16 16 6 1", +" c None s None", +". c black", +"X c red", +"o c yellow", +"O c #808080", +"# c white", +" ", +" .. ", +" ..XX. ", +" ..XXXXX. ", +" ..XXXXXXXX. ", +".ooXXXXXXXXX. ", +"..ooXXXXXXXXX. ", +".X.ooXXXXXXXXX. ", +".XX.ooXXXXXX.. ", +" .XX.ooXXX..#O ", +" .XX.oo..##OO. ", +" .XX..##OO.. ", +" .X.#OO.. ", +" ..O.. ", +" .. ", +" "}; + +static char * mini_page_xpm[] = { +"16 16 4 1", +" c None s None", +". c black", +"X c white", +"o c #808080", +" ", +" ....... ", +" .XXXXX.. ", +" .XoooX.X. ", +" .XXXXX.... ", +" .XooooXoo.o ", +" .XXXXXXXX.o ", +" .XooooooX.o ", +" .XXXXXXXX.o ", +" .XooooooX.o ", +" .XXXXXXXX.o ", +" .XooooooX.o ", +" .XXXXXXXX.o ", +" ..........o ", +" oooooooooo ", +" "}; + +GdkPixmap *pixmap1; +GdkPixmap *pixmap2; +GdkPixmap *pixmap3; +GdkBitmap *mask1; +GdkBitmap *mask2; +GdkBitmap *mask3; + +static gint books = 0; +static gint pages = 0; + +static GtkWidget *book_label; +static GtkWidget *page_label; +static GtkWidget *sel_label; +static GtkWidget *vis_label; +static GtkWidget *omenu; +static GtkWidget *omenu2; +static GtkWidget *omenu3; +static GtkWidget *spin1; +static GtkWidget *spin2; +static GtkWidget *spin3; + +#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++; \ + }\ +} + +#define RADIOBUTTONTOGGLED(_rb_, __i) { \ + GSList * __g; \ + __i = 0; \ + __g = gtk_radio_button_group(_rb_); \ + while( __g && !((GtkToggleButton *)(__g->data))->active) { \ + __g = __g->next; \ + __i++; \ + }\ +} + +void after_press (GtkCTree *ctree, gpointer data) { - gint i; - char text[TESTGTK_CLIST_COLUMNS][50]; - char *texts[TESTGTK_CLIST_COLUMNS]; + char buf[80]; - for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++) - { - texts[i] = text[i]; - sprintf (text[i], "Column %d", i); - } - - sprintf (text[1], "Right"); - sprintf (text[2], "Center"); - - gtk_clist_freeze (GTK_CLIST (data)); - for (i = 0; i < 1000; i++) - { - sprintf (text[0], "Row %d", clist_rows++); - gtk_clist_append (GTK_CLIST (data), texts); - } - gtk_clist_thaw (GTK_CLIST (data)); + sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection)); + gtk_label_set (GTK_LABEL (sel_label), buf); + + sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list)); + gtk_label_set (GTK_LABEL (vis_label), buf); + + sprintf (buf, "%d", books); + gtk_label_set (GTK_LABEL (book_label), buf); + sprintf (buf, "%d", pages); + gtk_label_set (GTK_LABEL (page_label), buf); } -void -add10000_clist (GtkWidget *widget, gpointer data) +void after_move (GtkCTree *ctree, GList *child, GList *parent, + GList *sibling, gpointer data) { - gint i; - char text[TESTGTK_CLIST_COLUMNS][50]; - char *texts[TESTGTK_CLIST_COLUMNS]; + char *source; + char *target1; + char *target2; + + gtk_ctree_get_node_info (ctree, child, &source, + NULL, NULL, NULL, NULL, NULL, NULL, NULL); + if (parent) + gtk_ctree_get_node_info (ctree, parent, &target1, + NULL, NULL, NULL, NULL, NULL, NULL, NULL); + if (sibling) + gtk_ctree_get_node_info (ctree, sibling, &target2, + NULL, NULL, NULL, NULL, NULL, NULL, NULL); + + g_print ("Moving \"%s\" to \"%s\" with sibling \"%s\".\n", source, + (parent) ? target1 : "nil", (sibling) ? target2 : "nil"); +} - for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++) +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) { - texts[i] = text[i]; - sprintf (text[i], "Column %d", i); + 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; - sprintf (text[1], "Right"); - sprintf (text[2], "Center"); - - gtk_clist_freeze (GTK_CLIST (data)); - for (i = 0; i < 10000; i++) + 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) { - sprintf (text[0], "Row %d", clist_rows++); - gtk_clist_append (GTK_CLIST (data), texts); + 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"); } - gtk_clist_thaw (GTK_CLIST (data)); + return FALSE; +} +void count_items (GtkCTree *ctree, GList *list) +{ + if (GTK_CTREE_ROW (list)->is_leaf) + pages--; + else + books--; } -void -clear_clist (GtkWidget *widget, gpointer data) +void expand_all (GtkWidget *widget, GtkCTree *ctree) { - gtk_clist_clear (GTK_CLIST (data)); - clist_rows = 0; + gtk_ctree_expand_recursive (ctree, NULL); + after_press (ctree, NULL); } -void -remove_row_clist (GtkWidget *widget, gpointer data) +void collapse_all (GtkWidget *widget, GtkCTree *ctree) { - gtk_clist_remove (GTK_CLIST (data), clist_selected_row); - clist_rows--; + gtk_ctree_collapse_recursive (ctree, NULL); + after_press (ctree, NULL); } -void -show_titles_clist (GtkWidget *widget, gpointer data) +void select_all (GtkWidget *widget, GtkCTree *ctree) { - gtk_clist_column_titles_show (GTK_CLIST (data)); + gtk_ctree_select_recursive (ctree, NULL); + after_press (ctree, NULL); } -void -hide_titles_clist (GtkWidget *widget, gpointer data) +void unselect_all (GtkWidget *widget, GtkCTree *ctree) { - gtk_clist_column_titles_hide (GTK_CLIST (data)); + gtk_ctree_unselect_recursive (ctree, NULL); + after_press (ctree, NULL); } -void -select_clist (GtkWidget *widget, - gint row, - gint column, - GdkEventButton *bevent) +void remove_selection (GtkWidget *widget, GtkCTree *ctree) { - gint button = 0; + GList *work; + GList *selection; + GList *new_sel; - if (bevent) - button = bevent->button; + selection = GTK_CLIST (ctree)->selection; + new_sel = NULL; - g_print ("GtkCList Selection: row %d column %d button %d\n", - row, column, button); + gtk_clist_freeze (GTK_CLIST (ctree)); - clist_selected_row = row; + while (selection) + { + work = selection->data; + if (GTK_CTREE_ROW (work)->is_leaf) + pages--; + else + gtk_ctree_post_recursive (ctree, work, + (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 (ctree, work); + selection = GTK_CLIST (ctree)->selection; + } + + if (new_sel) + gtk_ctree_select (ctree, new_sel); + + gtk_clist_thaw (GTK_CLIST (ctree)); + after_press (ctree, NULL); } -void -list_selection_clist (GtkWidget *widget, gpointer data) +void sort_all (GtkWidget *widget, GtkCTree *ctree) { - GList *list; - GtkCListRow *clist_row; - GtkCList *clist; + gtk_ctree_sort_recursive (ctree, NULL); +} +void change_indent (GtkWidget *widget, GtkCTree *ctree) +{ + gtk_ctree_set_indent (ctree, GTK_ADJUSTMENT (widget)->value); } -void -create_clist () +void toggle_reorderable (GtkWidget *widget, GtkCTree *ctree) { - gint i; - static GtkWidget *window = NULL; + gtk_ctree_set_reorderable (ctree, GTK_TOGGLE_BUTTON (widget)->active); +} - static char *titles[] = - { - "Title 0", - "Title 1", - "Title 2", - "Title 3", - "Title 4", - "Title 5", - "Title 6" - }; +void toggle_line_style (GtkWidget *widget, GtkCTree *ctree) +{ + gint i; - char text[TESTGTK_CLIST_COLUMNS][50]; - char *texts[TESTGTK_CLIST_COLUMNS]; - GtkWidget *box1; - GtkWidget *box2; - GtkWidget *clist; - GtkWidget *button; - GtkWidget *separator; + if (!GTK_WIDGET_MAPPED (widget)) + return; + RADIOMENUTOGGLED ((GtkRadioMenuItem *) + (((GtkOptionMenu *)omenu2)->menu_item),i); - if (!window) - { - window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_ctree_set_line_style (ctree, (GtkCTreeLineStyle) (2-i)); +} - gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), - &window); +void toggle_justify (GtkWidget *widget, GtkCTree *ctree) +{ + gint i; - gtk_window_set_title (GTK_WINDOW (window), "clist"); - gtk_container_border_width (GTK_CONTAINER (window), 0); + if (!GTK_WIDGET_MAPPED (widget)) + return; + RADIOMENUTOGGLED ((GtkRadioMenuItem *) + (((GtkOptionMenu *)omenu3)->menu_item),i); - box1 = gtk_vbox_new (FALSE, 0); - gtk_container_add (GTK_CONTAINER (window), box1); - gtk_widget_show (box1); + gtk_clist_set_column_justification (GTK_CLIST (ctree), 0, + (GtkJustification) (1-i)); +} +void toggle_sel_mode (GtkWidget *widget, GtkCTree *ctree) +{ + gint i; - 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); - gtk_widget_show (box2); + if (!GTK_WIDGET_MAPPED (widget)) + return; - /* 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); + RADIOMENUTOGGLED ((GtkRadioMenuItem *) + (((GtkOptionMenu *)omenu)->menu_item), i); - /* control buttons */ - button = gtk_button_new_with_label ("Add 1,000 Rows"); - gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); + gtk_ctree_set_selection_mode (ctree, (GtkSelectionMode) (3-i)); + after_press (ctree, NULL); +} - gtk_signal_connect (GTK_OBJECT (button), - "clicked", - (GtkSignalFunc) add1000_clist, - (gpointer) clist); - gtk_widget_show (button); +void build_recursive (GtkCTree *ctree, gint cur_depth, gint depth, + gint num_books, gint num_pages, GList *parent) +{ + gchar *text[2]; + gchar buf1[60]; + gchar buf2[60]; + GList *sibling; + gint i; + + text[0] = buf1; + text[1] = buf2; + sibling = NULL; + for (i = num_pages + num_books; i > num_books; i--) + { + pages++; + sprintf (buf1, "Page %02d", (gint) random() % 100); + sprintf (buf2, "Item %d-%d", cur_depth, i); + sibling = gtk_ctree_insert (ctree, parent, sibling, text, 5, pixmap3, + mask3, NULL, NULL, TRUE, FALSE); + } - button = gtk_button_new_with_label ("Add 10,000 Rows"); - gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); + if (cur_depth == depth) + return; - gtk_signal_connect (GTK_OBJECT (button), - "clicked", - (GtkSignalFunc) add10000_clist, - (gpointer) clist); + for (i = num_books; i > 0; i--) + { + books++; + sprintf (buf1, "Book %02d", (gint) random() % 100); + sprintf (buf2, "Item %d-%d", cur_depth, i); + sibling = gtk_ctree_insert (ctree, parent, sibling, text, 5, pixmap1, + mask1, pixmap2, mask2, FALSE, FALSE); + build_recursive (ctree, cur_depth + 1, depth, num_books, num_pages, sibling); + } +} - gtk_widget_show (button); +void rebuild_tree (GtkWidget *widget, GtkCTree *ctree) +{ + gchar *text [2]; + gchar label1[] = "Root"; + gchar label2[] = ""; + GList *parent; + guint b, d, p, n; + + text[0] = label1; + text[1] = label2; + + d = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1)); + b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2)); + p = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin3)); - button = gtk_button_new_with_label ("Clear List"); - gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); + n = ((pow (b, d) - 1) / (b - 1)) * (p + 1); - gtk_signal_connect (GTK_OBJECT (button), - "clicked", - (GtkSignalFunc) clear_clist, - (gpointer) clist); + if (n > 200000) + { + g_print ("%d total items? Try less\n",n); + return; + } - gtk_widget_show (button); + gtk_clist_freeze (GTK_CLIST (ctree)); + gtk_ctree_clear (ctree); - button = gtk_button_new_with_label ("Remove Row"); - gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); + books = 1; + pages = 0; - gtk_signal_connect (GTK_OBJECT (button), - "clicked", - (GtkSignalFunc) remove_row_clist, - (gpointer) clist); + parent = gtk_ctree_insert (ctree, NULL, NULL, text, 5, pixmap1, + mask1, pixmap2, mask2, FALSE, TRUE); - gtk_widget_show (button); + build_recursive (ctree, 1, d, b, p, parent); + gtk_clist_thaw (GTK_CLIST (ctree)); + after_press (ctree, NULL); +} - /* 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); - gtk_widget_show (box2); +void create_ctree (void) +{ + static GtkWidget *window = NULL; + GtkTooltips *tooltips; + GtkCTree *ctree; + GtkWidget *vbox; + 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; - button = gtk_button_new_with_label ("Show Title Buttons"); - gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); + char *title[] = { "Tree" , "Info" }; + char buf[80]; - gtk_signal_connect (GTK_OBJECT (button), - "clicked", - (GtkSignalFunc) show_titles_clist, - (gpointer) clist); + if (!window) + { + window = gtk_window_new (GTK_WINDOW_TOPLEVEL); - gtk_widget_show (button); + gtk_signal_connect (GTK_OBJECT (window), "destroy", + GTK_SIGNAL_FUNC (gtk_widget_destroyed), + &window); - button = gtk_button_new_with_label ("Hide Title Buttons"); - gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); + gtk_window_set_title (GTK_WINDOW (window), "GtkCTree"); + gtk_container_border_width (GTK_CONTAINER (window), 0); - gtk_signal_connect (GTK_OBJECT (button), - "clicked", - (GtkSignalFunc) hide_titles_clist, - (gpointer) clist); + tooltips = gtk_tooltips_new (); + gtk_object_ref (GTK_OBJECT (tooltips)); + gtk_object_sink (GTK_OBJECT (tooltips)); - gtk_widget_show (button); + gtk_object_set_data_full (GTK_OBJECT (window), + "tooltips", + tooltips, + (GtkDestroyNotify) gtk_object_unref); - /* 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); - gtk_widget_show (box2); + vbox = gtk_vbox_new (FALSE, 0); + gtk_container_add (GTK_CONTAINER (window), vbox); - /* - * the rest of the clist configuration - */ - gtk_clist_set_row_height (GTK_CLIST (clist), 20); + 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); - gtk_signal_connect (GTK_OBJECT (clist), - "select_row", - (GtkSignalFunc) select_clist, - NULL); + label = gtk_label_new ("Depth :"); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); + + adj = (GtkAdjustment *) gtk_adjustment_new (4, 1, 10, 1, 5, 0); + spin1 = gtk_spin_button_new (adj, 0, 0); + gtk_box_pack_start (GTK_BOX (hbox), spin1, FALSE, TRUE, 5); + + label = gtk_label_new ("Books :"); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); + + adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0); + spin2 = gtk_spin_button_new (adj, 0, 0); + gtk_box_pack_start (GTK_BOX (hbox), spin2, FALSE, TRUE, 5); - gtk_clist_set_column_width (GTK_CLIST (clist), 0, 100); + label = gtk_label_new ("Pages :"); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); + + adj = (GtkAdjustment *) gtk_adjustment_new (5, 1, 20, 1, 5, 0); + spin3 = gtk_spin_button_new (adj, 0, 0); + gtk_box_pack_start (GTK_BOX (hbox), spin3, FALSE, TRUE, 5); - for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++) - gtk_clist_set_column_width (GTK_CLIST (clist), i, 80); + button = gtk_button_new_with_label ("Close"); + gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0); - gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_BROWSE); + gtk_signal_connect_object(GTK_OBJECT (button), "clicked", + (GtkSignalFunc) gtk_widget_destroy, + GTK_OBJECT(window)); - gtk_clist_set_policy (GTK_CLIST (clist), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); + button = gtk_button_new_with_label ("Rebuild tree"); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); + + ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title)); + 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); + 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_move), 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_column_justification (GTK_CLIST (ctree), 2, + GTK_JUSTIFY_RIGHT); + gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_MULTIPLE); + 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_clist_set_column_justification (GTK_CLIST (clist), 1, GTK_JUSTIFY_RIGHT); - gtk_clist_set_column_justification (GTK_CLIST (clist), 2, GTK_JUSTIFY_CENTER); + gtk_signal_connect (GTK_OBJECT (button), "clicked", + GTK_SIGNAL_FUNC (rebuild_tree), ctree); - for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++) - { - texts[i] = text[i]; - sprintf (text[i], "Column %d", i); - } + 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); - sprintf (text[1], "Right"); - sprintf (text[2], "Center"); + 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); - for (i = 0; i < 100; i++) - { - sprintf (text[0], "Row %d", clist_rows++); - gtk_clist_append (GTK_CLIST (clist), texts); - } + 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); - gtk_container_border_width (GTK_CONTAINER (clist), 5); - gtk_box_pack_start (GTK_BOX (box2), clist, TRUE, TRUE, 0); - gtk_widget_show (clist); + 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); + 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); - separator = gtk_hseparator_new (); - gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); - gtk_widget_show (separator); + button = gtk_button_new_with_label ("Select all"); + gtk_signal_connect (GTK_OBJECT (button), "clicked", + GTK_SIGNAL_FUNC (select_all), ctree); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, 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); + button = gtk_button_new_with_label ("Unselect all"); + gtk_signal_connect (GTK_OBJECT (button), "clicked", + GTK_SIGNAL_FUNC (unselect_all), ctree); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, 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)); + button = gtk_button_new_with_label ("Remove selection"); + gtk_signal_connect (GTK_OBJECT (button), "clicked", + GTK_SIGNAL_FUNC (remove_selection), ctree); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); - gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); - GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); - gtk_widget_grab_default (button); + 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_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_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, "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_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, "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_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), 2); + + 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_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_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_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_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_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_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); - gtk_widget_show (button); + rebuild_tree (NULL, ctree); } if (!GTK_WIDGET_VISIBLE (window)) - gtk_widget_show (window); + gtk_widget_show_all (window); else gtk_widget_destroy (window); - } + /* * GtkColorSelect */ @@ -1924,16 +4273,12 @@ color_selection_changed (GtkWidget *w, } void -create_color_selection () +create_color_selection (void) { static GtkWidget *window = NULL; if (!window) { - gtk_preview_set_install_cmap (TRUE); - gtk_widget_push_visual (gtk_preview_get_visual ()); - gtk_widget_push_colormap (gtk_preview_get_cmap ()); - window = gtk_color_selection_dialog_new ("color selection dialog"); gtk_color_selection_set_opacity ( @@ -1947,10 +4292,7 @@ create_color_selection () gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_signal_connect ( @@ -1965,55 +4307,116 @@ create_color_selection () GTK_SIGNAL_FUNC(color_selection_ok), window); - gtk_signal_connect_object ( - GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button), - "clicked", - GTK_SIGNAL_FUNC(gtk_widget_destroy), - GTK_OBJECT (window)); + gtk_signal_connect_object ( + GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button), + "clicked", + GTK_SIGNAL_FUNC(gtk_widget_destroy), + GTK_OBJECT (window)); + } + + if (!GTK_WIDGET_VISIBLE (window)) + gtk_widget_show (window); + else + gtk_widget_destroy (window); +} + +void +file_selection_hide_fileops (GtkWidget *widget, + GtkFileSelection *fs) +{ + gtk_file_selection_hide_fileop_buttons (fs); +} + +void +file_selection_ok (GtkWidget *w, + GtkFileSelection *fs) +{ + g_print ("%s\n", gtk_file_selection_get_filename (fs)); + gtk_widget_destroy (GTK_WIDGET (fs)); +} + +void +create_file_selection (void) +{ + static GtkWidget *window = NULL; + GtkWidget *button; + + if (!window) + { + window = gtk_file_selection_new ("file selection dialog"); + + gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window)); + + gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE); + + gtk_signal_connect (GTK_OBJECT (window), "destroy", + GTK_SIGNAL_FUNC(gtk_widget_destroyed), + &window); - gtk_widget_pop_colormap (); - gtk_widget_pop_visual (); - } + gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button), + "clicked", GTK_SIGNAL_FUNC(file_selection_ok), + window); + gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button), + "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), + GTK_OBJECT (window)); + + button = gtk_button_new_with_label ("Hide Fileops"); + gtk_signal_connect (GTK_OBJECT (button), "clicked", + (GtkSignalFunc) file_selection_hide_fileops, + (gpointer) window); + gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area), + button, FALSE, FALSE, 0); + gtk_widget_show (button); + + button = gtk_button_new_with_label ("Show Fileops"); + gtk_signal_connect_object (GTK_OBJECT (button), "clicked", + (GtkSignalFunc) gtk_file_selection_show_fileop_buttons, + (gpointer) window); + 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_show (window); else gtk_widget_destroy (window); } - void -file_selection_ok (GtkWidget *w, - GtkFileSelection *fs) +font_selection_ok (GtkWidget *w, + GtkFontSelection *fs) { - g_print ("%s\n", gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs))); + g_print ("%s\n", gtk_font_selection_get_font_name (fs)); + gtk_widget_destroy (GTK_WIDGET (fs)); } void -create_file_selection () +create_font_selection (void) { static GtkWidget *window = NULL; if (!window) { - window = gtk_file_selection_new ("file selection dialog"); + window = gtk_font_selection_dialog_new ("Font Selection Dialog"); + gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); - gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button), - "clicked", GTK_SIGNAL_FUNC(file_selection_ok), - window); - gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button), + gtk_signal_connect (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->ok_button), + "clicked", GTK_SIGNAL_FUNC(font_selection_ok), + GTK_FONT_SELECTION_DIALOG (window)->fontsel); + gtk_signal_connect_object (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->cancel_button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); } - + if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else @@ -2033,20 +4436,21 @@ label_toggle (GtkWidget *widget, if (!(*label)) { *label = gtk_label_new ("Dialog Test"); + gtk_signal_connect (GTK_OBJECT (*label), + "destroy", + GTK_SIGNAL_FUNC (gtk_widget_destroyed), + label); gtk_misc_set_padding (GTK_MISC (*label), 10, 10); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox), *label, TRUE, TRUE, 0); gtk_widget_show (*label); } else - { - gtk_widget_destroy (*label); - *label = NULL; - } + gtk_widget_destroy (*label); } void -create_dialog () +create_dialog (void) { static GtkWidget *label; GtkWidget *button; @@ -2056,10 +4460,7 @@ create_dialog () dialog_window = gtk_dialog_new (); gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &dialog_window); - gtk_signal_connect (GTK_OBJECT (dialog_window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &dialog_window); gtk_window_set_title (GTK_WINDOW (dialog_window), "dialog"); @@ -2074,7 +4475,7 @@ create_dialog () button = gtk_button_new_with_label ("Toggle"); gtk_signal_connect (GTK_OBJECT (button), "clicked", - GTK_SIGNAL_FUNC(label_toggle), + GTK_SIGNAL_FUNC (label_toggle), &label); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area), @@ -2095,7 +4496,7 @@ create_dialog () * GtkRange */ void -create_range_controls () +create_range_controls (void) { static GtkWidget *window = NULL; GtkWidget *box1; @@ -2111,10 +4512,7 @@ create_range_controls () window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "range controls"); @@ -2181,7 +4579,7 @@ create_range_controls () * GtkRulers */ void -create_rulers () +create_rulers (void) { static GtkWidget *window = NULL; GtkWidget *table; @@ -2190,12 +4588,10 @@ create_rulers () if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, FALSE); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "rulers"); @@ -2210,7 +4606,8 @@ create_rulers () gtk_widget_show (table); ruler = gtk_hruler_new (); - gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20); + gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS); + gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20); gtk_signal_connect_object ( GTK_OBJECT (window), @@ -2245,32 +4642,51 @@ create_rulers () } +static void +text_toggle_editable (GtkWidget *checkbutton, + GtkWidget *text) +{ + gtk_text_set_editable(GTK_TEXT(text), + GTK_TOGGLE_BUTTON(checkbutton)->active); +} + +static void +text_toggle_word_wrap (GtkWidget *checkbutton, + GtkWidget *text) +{ + gtk_text_set_word_wrap(GTK_TEXT(text), + GTK_TOGGLE_BUTTON(checkbutton)->active); +} + /* * GtkText */ void -create_text () +create_text (void) { static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; + GtkWidget *hbox; GtkWidget *button; + GtkWidget *check; GtkWidget *separator; GtkWidget *table; GtkWidget *hscrollbar; GtkWidget *vscrollbar; GtkWidget *text; + FILE *infile; + if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_name (window, "text window"); + gtk_widget_set_usize (window, 500, 500); + gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "test"); @@ -2295,69 +4711,73 @@ create_text () gtk_widget_show (table); text = gtk_text_new (NULL, NULL); - gtk_text_set_editable (text, TRUE); - gtk_table_attach_defaults (GTK_TABLE (table), text, 0, 1, 0, 1); + 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_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_FILL, 0, 0); + 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_FILL, 0, 0); + GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (vscrollbar); gtk_text_freeze (GTK_TEXT (text)); gtk_widget_realize (text); + infile = fopen("testgtk.c", "r"); + + if (infile) + { + char buffer[1024]; + int nchars; + + while (1) + { + nchars = fread(buffer, 1, 1024, infile); + gtk_text_insert (GTK_TEXT (text), NULL, NULL, + NULL, buffer, nchars); + + if (nchars < 1024) + break; + } + + fclose (infile); + } + gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL, - "spencer blah blah blah\n", -1); - gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL, - "kimball\n", -1); - gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL, - "is\n", -1); - gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL, - "a\n", -1); - gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL, - "wuss.\n", -1); - gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL, - "but\n", -1); - gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL, - "josephine\n", -1); - gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL, - "(his\n", -1); - gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL, - "girlfriend\n", -1); - gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL, - "is\n", -1); - gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL, - "not).\n", -1); - gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL, - "why?\n", -1); - gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL, - "because\n", -1); - gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL, - "spencer\n", -1); - gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL, - "puked\n", -1); - gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL, - "last\n", -1); - gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL, - "night\n", -1); - gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL, - "but\n", -1); - gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL, - "josephine\n", -1); - gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL, - "did\n", -1); + "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, - "not", -1); + "text", -1); gtk_text_thaw (GTK_TEXT (text)); + hbox = gtk_hbutton_box_new (); + gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + check = gtk_check_button_new_with_label("Editable"); + 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_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_widget_show (check); + separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_widget_show (separator); @@ -2389,15 +4809,197 @@ create_text () /* * GtkNotebook */ -void + +GdkPixmap *book_open; +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); + } +} + +static void +page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num) +{ + GtkNotebookPage *oldpage; + GtkWidget *pixwid; + + oldpage = GTK_NOTEBOOK (widget)->cur_page; + + if (page == oldpage) + return; + + 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; + gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask); + + if (oldpage) + { + 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; + gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask); + } +} + +static void +create_pages (GtkNotebook *notebook, gint start, gint end) +{ + GtkWidget *child = NULL; + GtkWidget *label; + GtkWidget *entry; + GtkWidget *box; + GtkWidget *hbox; + 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); + + 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); + + button = gtk_button_new_with_label ("Ok"); + gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, 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); + + label = gtk_label_new (buffer); + gtk_container_add (GTK_CONTAINER (child), label); + break; + } + + gtk_widget_show_all (child); + + label_box = gtk_hbox_new (FALSE, 0); + pixwid = gtk_pixmap_new (book_closed, book_closed_mask); + gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0); + gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1); + 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); + gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1); + label = gtk_label_new (buffer); + gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0); + gtk_widget_show_all (menu_box); + + gtk_notebook_append_page_menu (notebook, child, label_box, menu_box); + } +} + +static void rotate_notebook (GtkButton *button, GtkNotebook *notebook) { gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4); } -void -create_notebook () +static void +standard_notebook (GtkButton *button, + GtkNotebook *notebook) +{ + gint i; + + gtk_notebook_set_show_tabs (notebook, TRUE); + gtk_notebook_set_scrollable (notebook, FALSE); + if (g_list_length (notebook->children) == 15) + for (i = 0; i < 10; i++) + gtk_notebook_remove_page (notebook, 5); +} + +static void +notabs_notebook (GtkButton *button, + GtkNotebook *notebook) +{ + gint i; + + gtk_notebook_set_show_tabs (notebook, FALSE); + if (g_list_length (notebook->children) == 15) + for (i = 0; i < 10; i++) + gtk_notebook_remove_page (notebook, 5); +} + +static void +scrollable_notebook (GtkButton *button, + GtkNotebook *notebook) +{ + gtk_notebook_set_show_tabs (notebook, TRUE); + gtk_notebook_set_scrollable (notebook, TRUE); + if (g_list_length (notebook->children) == 5) + create_pages (notebook, 6, 15); +} + +static void +notebook_popup (GtkToggleButton *button, + GtkNotebook *notebook) +{ + if (button->active) + gtk_notebook_popup_enable (notebook); + else + gtk_notebook_popup_disable (notebook); +} + +static void +create_notebook (void) { static GtkWidget *window = NULL; GtkWidget *box1; @@ -2405,105 +5007,130 @@ create_notebook () GtkWidget *button; GtkWidget *separator; GtkWidget *notebook; - GtkWidget *frame; - GtkWidget *label; - char buffer[32]; - int i; + GtkWidget *omenu; + GtkWidget *menu; + GtkWidget *submenu; + GtkWidget *menuitem; + GSList *group; + GdkColor *transparent = NULL; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "notebook"); 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); - notebook = gtk_notebook_new (); + gtk_signal_connect (GTK_OBJECT (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 (box2), notebook, TRUE, TRUE, 0); - gtk_widget_show (notebook); - - - for (i = 0; i < 5; i++) - { - sprintf (buffer, "Page %d", i+1); + gtk_box_pack_start (GTK_BOX (box1), notebook, TRUE, TRUE, 0); + gtk_container_border_width (GTK_CONTAINER (notebook), 10); - frame = gtk_frame_new (buffer); - gtk_container_border_width (GTK_CONTAINER (frame), 10); - gtk_widget_set_usize (frame, 200, 150); - gtk_widget_show (frame); - - label = gtk_label_new (buffer); - gtk_container_add (GTK_CONTAINER (frame), label); - gtk_widget_show (label); - - label = gtk_label_new (buffer); - gtk_notebook_append_page (GTK_NOTEBOOK (notebook), frame, label); - } + gtk_widget_realize (notebook); + book_open = gdk_pixmap_create_from_xpm_d (notebook->window, + &book_open_mask, + transparent, + book_open_xpm); + book_closed = gdk_pixmap_create_from_xpm_d (notebook->window, + &book_closed_mask, + transparent, + book_closed_xpm); + create_pages (GTK_NOTEBOOK (notebook), 1, 5); separator = gtk_hseparator_new (); - gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); - gtk_widget_show (separator); - - + 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); + 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_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_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); button = gtk_button_new_with_label ("next"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", - GTK_SIGNAL_FUNC(gtk_notebook_next_page), + GTK_SIGNAL_FUNC (gtk_notebook_next_page), GTK_OBJECT (notebook)); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); - gtk_widget_show (button); + 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_SIGNAL_FUNC (gtk_notebook_prev_page), GTK_OBJECT (notebook)); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); - gtk_widget_show (button); + 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), + GTK_SIGNAL_FUNC (rotate_notebook), notebook); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); - gtk_widget_show (button); + 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); + GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); } if (!GTK_WIDGET_VISIBLE (window)) - gtk_widget_show (window); + gtk_widget_show_all (window); else gtk_widget_destroy (window); } @@ -2513,22 +5140,20 @@ create_notebook () * GtkPanes */ void -create_panes () +create_panes (void) { static GtkWidget *window = NULL; GtkWidget *frame; GtkWidget *hpaned; GtkWidget *vpaned; + GtkWidget *button; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "Panes"); @@ -2547,6 +5172,10 @@ create_panes () 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); @@ -2574,7 +5203,7 @@ create_panes () * Drag -N- Drop */ -gboolean +gint dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window) { if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */ @@ -2583,7 +5212,8 @@ dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window) gtk_grab_remove(GTK_WIDGET(*window)); *window = NULL; } - return TRUE; + + return FALSE; } void @@ -2593,14 +5223,20 @@ dnd_drop (GtkWidget *button, GdkEvent *event) GtkWidget *vbox, *lbl, *btn; gchar *msg; + /* DND doesn't obey gtk_grab's, so check if we're already displaying + * drop modal dialog first + */ + if (window) + return; + window = gtk_window_new(GTK_WINDOW_DIALOG); gtk_container_border_width (GTK_CONTAINER(window), 10); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(dnd_drop_destroy_popup), &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(dnd_drop_destroy_popup), + gtk_signal_connect (GTK_OBJECT (window), "delete-event", + GTK_SIGNAL_FUNC(gtk_false), &window); vbox = gtk_vbox_new(FALSE, 5); @@ -2619,9 +5255,9 @@ dnd_drop (GtkWidget *button, GdkEvent *event) /* Provide an obvious way out of this heinousness */ btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression"); - gtk_signal_connect (GTK_OBJECT (btn), "clicked", - GTK_SIGNAL_FUNC(dnd_drop_destroy_popup), - &window); + gtk_signal_connect_object (GTK_OBJECT (btn), "clicked", + GTK_SIGNAL_FUNC(gtk_widget_destroy), + GTK_OBJECT (window)); gtk_widget_show(btn); gtk_box_pack_start_defaults(GTK_BOX(vbox), btn); @@ -2640,7 +5276,7 @@ dnd_drag_request (GtkWidget *button, GdkEvent *event) } void -create_dnd () +create_dnd (void) { static GtkWidget *window = NULL; GtkWidget *box1; @@ -2650,19 +5286,50 @@ create_dnd () GtkWidget *button; GtkWidget *separator; - /* For clarity... */ - char *possible_drag_types[] = {"text/plain"}; - char *accepted_drop_types[] = {"text/plain"}; + /* For clarity... */ + char *possible_drag_types[] = {"text/plain"}; + char *accepted_drop_types[] = {"text/plain"}; + + static GtkWidget *drag_icon = NULL; + static GtkWidget *drop_icon = NULL; + + if (!window) + { + GdkPoint hotspot = {5,5}; + + if (!drag_icon) + { + drag_icon = shape_create_icon ("Modeller.xpm", + 440, 140, 0,0, GTK_WINDOW_POPUP); + + gtk_signal_connect (GTK_OBJECT (drag_icon), "destroy", + GTK_SIGNAL_FUNC(gtk_widget_destroyed), + &drag_icon); + + gtk_widget_hide (drag_icon); + } + + if (!drop_icon) + { + drop_icon = shape_create_icon ("3DRings.xpm", + 440, 140, 0,0, GTK_WINDOW_POPUP); + + gtk_signal_connect (GTK_OBJECT (drop_icon), "destroy", + GTK_SIGNAL_FUNC(gtk_widget_destroyed), + &drop_icon); + + gtk_widget_hide (drop_icon); + } + + gdk_dnd_set_drag_shape(drag_icon->window, + &hotspot, + drop_icon->window, + &hotspot); - if (!window) - { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop"); @@ -2765,9 +5432,6 @@ create_dnd () * Shaped Windows */ static GdkWindow *root_win = NULL; -static GtkWidget *modeller = NULL; -static GtkWidget *sheets = NULL; -static GtkWidget *rings = NULL; typedef struct _cursoroffset {gint x,y;} CursorOffset; @@ -2787,7 +5451,8 @@ shape_pressed (GtkWidget *widget, GdkEventButton *event) gtk_grab_add (widget); gdk_pointer_grab (widget->window, TRUE, GDK_BUTTON_RELEASE_MASK | - GDK_BUTTON_MOTION_MASK, + GDK_BUTTON_MOTION_MASK | + GDK_POINTER_MOTION_HINT_MASK, NULL, NULL, 0); } @@ -2809,6 +5474,10 @@ shape_motion (GtkWidget *widget, p = gtk_object_get_user_data (GTK_OBJECT (widget)); + /* + * Can't use event->x / event->y here + * because I need absolute coordinates. + */ gdk_window_get_pointer (root_win, &xp, &yp, &mask); gtk_widget_set_uposition (widget, xp - p->x, yp - p->y); } @@ -2843,6 +5512,13 @@ shape_create_icon (char *xpm_file, gtk_container_add (GTK_CONTAINER (window), fixed); gtk_widget_show (fixed); + gtk_widget_set_events (window, + gtk_widget_get_events (window) | + GDK_BUTTON_MOTION_MASK | + GDK_POINTER_MOTION_HINT_MASK | + GDK_BUTTON_PRESS_MASK); + + gtk_widget_realize (window); gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask, &style->bg[GTK_STATE_NORMAL], xpm_file); @@ -2853,10 +5529,6 @@ shape_create_icon (char *xpm_file, gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py); - gtk_widget_set_events (window, - gtk_widget_get_events (window) | - GDK_BUTTON_MOTION_MASK | - GDK_BUTTON_PRESS_MASK); gtk_signal_connect (GTK_OBJECT (window), "button_press_event", GTK_SIGNAL_FUNC (shape_pressed),NULL); @@ -2870,13 +5542,18 @@ shape_create_icon (char *xpm_file, gtk_widget_set_uposition (window, x, y); gtk_widget_show (window); - + return window; } void -create_shapes () +create_shapes (void) { + /* Variables used by the Drag/Drop and Shape Window demos */ + static GtkWidget *modeller = NULL; + static GtkWidget *sheets = NULL; + static GtkWidget *rings = NULL; + root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ()); if (!modeller) @@ -2885,10 +5562,7 @@ create_shapes () 440, 140, 0,0, GTK_WINDOW_POPUP); gtk_signal_connect (GTK_OBJECT (modeller), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &modeller); - gtk_signal_connect (GTK_OBJECT (modeller), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &modeller); } else @@ -2900,10 +5574,7 @@ create_shapes () 580, 170, 0,0, GTK_WINDOW_POPUP); gtk_signal_connect (GTK_OBJECT (sheets), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &sheets); - gtk_signal_connect (GTK_OBJECT (sheets), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &sheets); } @@ -2916,16 +5587,88 @@ create_shapes () 460, 270, 25,25, GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (rings), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &rings); - gtk_signal_connect (GTK_OBJECT (rings), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &rings); } else gtk_widget_destroy (rings); } +void +create_wmhints (void) +{ + static GtkWidget *window = NULL; + GtkWidget *label; + GtkWidget *separator; + GtkWidget *button; + GtkWidget *box1; + GtkWidget *box2; + + GdkBitmap *circles; + + if (!window) + { + 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), "WM Hints"); + gtk_container_border_width (GTK_CONTAINER (window), 0); + + gtk_widget_realize (window); + + circles = gdk_bitmap_create_from_data (window->window, + circles_bits, + circles_width, + circles_height); + gdk_window_set_icon (window->window, NULL, + circles, circles); + + gdk_window_set_icon_name (window->window, "WMHints Test Icon"); + + gdk_window_set_decorations (window->window, GDK_DECOR_ALL | GDK_DECOR_MENU); + gdk_window_set_functions (window->window, GDK_FUNC_ALL | GDK_FUNC_RESIZE); + + box1 = gtk_vbox_new (FALSE, 0); + gtk_container_add (GTK_CONTAINER (window), box1); + gtk_widget_show (box1); + + label = gtk_label_new ("Try iconizing me!"); + gtk_widget_set_usize (label, 150, 50); + gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0); + gtk_widget_show (label); + + + 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_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_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); + else + gtk_widget_destroy (window); +} /* * Progress Bar @@ -2947,24 +5690,25 @@ progress_timeout (gpointer data) return TRUE; } -void +static void destroy_progress (GtkWidget *widget, GtkWidget **window) { - destroy_window (widget, window); gtk_timeout_remove (progress_timer); progress_timer = 0; + *window = NULL; } void -create_progress_bar () +create_progress_bar (void) { static GtkWidget *window = NULL; GtkWidget *button; GtkWidget *vbox; GtkWidget *pbar; GtkWidget *label; - + GtkTooltips *tooltips; + if (!window) { window = gtk_dialog_new (); @@ -2972,13 +5716,11 @@ create_progress_bar () gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(destroy_progress), &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_progress), - &window); gtk_window_set_title (GTK_WINDOW (window), "dialog"); gtk_container_border_width (GTK_CONTAINER (window), 0); + tooltips = gtk_tooltips_new(); vbox = gtk_vbox_new (FALSE, 5); gtk_container_border_width (GTK_CONTAINER (vbox), 10); @@ -2992,9 +5734,12 @@ create_progress_bar () gtk_widget_show (label); pbar = gtk_progress_bar_new (); + gtk_widget_set_events (pbar, GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK); gtk_widget_set_usize (pbar, 200, 20); gtk_box_pack_start (GTK_BOX (vbox), pbar, TRUE, TRUE, 0); gtk_widget_show (pbar); + gtk_tooltips_set_tip (tooltips, pbar, "Countdown is progressing yet!", "Secret!"); + gtk_tooltips_set_delay (tooltips, 0); progress_timer = gtk_timeout_add (100, progress_timeout, pbar); @@ -3048,18 +5793,18 @@ color_idle_func (GtkWidget *preview) return TRUE; } -void +static void color_preview_destroy (GtkWidget *widget, GtkWidget **window) { gtk_idle_remove (color_idle); color_idle = 0; - destroy_window (widget, window); + *window = NULL; } void -create_color_preview () +create_color_preview (void) { static GtkWidget *window = NULL; GtkWidget *preview; @@ -3068,17 +5813,11 @@ create_color_preview () if (!window) { - gtk_widget_push_visual (gtk_preview_get_visual ()); - gtk_widget_push_colormap (gtk_preview_get_cmap ()); - window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(color_preview_destroy), &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(color_preview_destroy), - &window); gtk_window_set_title (GTK_WINDOW (window), "test"); gtk_container_border_width (GTK_CONTAINER (window), 10); @@ -3102,9 +5841,6 @@ create_color_preview () } color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview); - - gtk_widget_pop_colormap (); - gtk_widget_pop_visual (); } if (!GTK_WIDGET_VISIBLE (window)) @@ -3141,18 +5877,18 @@ gray_idle_func (GtkWidget *preview) return TRUE; } -void +static void gray_preview_destroy (GtkWidget *widget, GtkWidget **window) { gtk_idle_remove (gray_idle); gray_idle = 0; - destroy_window (widget, window); + *window = NULL; } void -create_gray_preview () +create_gray_preview (void) { static GtkWidget *window = NULL; GtkWidget *preview; @@ -3161,17 +5897,11 @@ create_gray_preview () if (!window) { - gtk_widget_push_visual (gtk_preview_get_visual ()); - gtk_widget_push_colormap (gtk_preview_get_cmap ()); - window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gray_preview_destroy), &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(gray_preview_destroy), - &window); gtk_window_set_title (GTK_WINDOW (window), "test"); gtk_container_border_width (GTK_CONTAINER (window), 10); @@ -3190,9 +5920,6 @@ create_gray_preview () } gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview); - - gtk_widget_pop_colormap (); - gtk_widget_pop_visual (); } if (!GTK_WIDGET_VISIBLE (window)) @@ -3268,7 +5995,7 @@ selection_test_get_targets (GtkWidget *widget, GtkWidget *list) } void -create_selection_test () +create_selection_test (void) { static GtkWidget *window = NULL; GtkWidget *button; @@ -3282,10 +6009,7 @@ create_selection_test () window = gtk_dialog_new (); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "Selection Test"); @@ -3348,7 +6072,7 @@ create_selection_test () * Gamma Curve */ void -create_gamma_curve () +create_gamma_curve (void) { static GtkWidget *window = NULL, *curve; static int count = 0; @@ -3363,10 +6087,7 @@ create_gamma_curve () gtk_container_border_width (GTK_CONTAINER (window), 10); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); curve = gtk_gamma_curve_new (); @@ -3512,7 +6233,7 @@ scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget) void -create_scroll_test () +create_scroll_test (void) { static GtkWidget *window = NULL; GtkWidget *hbox; @@ -3526,10 +6247,7 @@ create_scroll_test () window = gtk_dialog_new (); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(destroy_window), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_window), + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "Scroll Test"); @@ -3587,7 +6305,7 @@ create_scroll_test () */ static int timer = 0; -void +gint timeout_test (GtkWidget *label) { static int count = 0; @@ -3595,6 +6313,8 @@ timeout_test (GtkWidget *label) sprintf (buffer, "count: %d", ++count); gtk_label_set (GTK_LABEL (label), buffer); + + return TRUE; } void @@ -3622,12 +6342,13 @@ void destroy_timeout_test (GtkWidget *widget, GtkWidget **window) { - destroy_window (widget, window); stop_timeout_test (NULL, NULL); + + *window = NULL; } void -create_timeout_test () +create_timeout_test (void) { static GtkWidget *window = NULL; GtkWidget *button; @@ -3640,9 +6361,6 @@ create_timeout_test () gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(destroy_timeout_test), &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_timeout_test), - &window); gtk_window_set_title (GTK_WINDOW (window), "Timeout Test"); gtk_container_border_width (GTK_CONTAINER (window), 0); @@ -3731,12 +6449,13 @@ void destroy_idle_test (GtkWidget *widget, GtkWidget **window) { - destroy_window (widget, window); stop_idle_test (NULL, NULL); + + *window = NULL; } void -create_idle_test () +create_idle_test (void) { static GtkWidget *window = NULL; GtkWidget *button; @@ -3749,9 +6468,6 @@ create_idle_test () gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(destroy_idle_test), &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(destroy_idle_test), - &window); gtk_window_set_title (GTK_WINDOW (window), "Idle Test"); gtk_container_border_width (GTK_CONTAINER (window), 0); @@ -3798,44 +6514,152 @@ create_idle_test () } void -test_destroy (GtkWidget *widget, - GtkWidget **window) +reload_rc_file (void) { - destroy_window (widget, window); - gtk_main_quit (); + GList *toplevels; + + if (gtk_rc_reparse_all ()) + { + toplevels = gdk_window_get_toplevels(); + while (toplevels) + { + GtkWidget *widget; + gdk_window_get_user_data (toplevels->data, (gpointer *)&widget); + + if (widget) + gtk_widget_reset_rc_styles (widget); + + toplevels = toplevels->next; + } + g_list_free (toplevels); + } +} + +void +reload_all_rc_files (void) +{ + static GdkAtom atom_rcfiles = GDK_NONE; + + GdkEventClient sev; + int i; + + if (!atom_rcfiles) + atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE); + + for(i = 0; i < 5; i++) + sev.data.l[i] = 0; + sev.data_format = 32; + sev.message_type = atom_rcfiles; + gdk_event_send_clientmessage_toall ((GdkEvent *) &sev); +} + +void +create_rc_file (void) +{ + static GtkWidget *window = NULL; + GtkWidget *button; + + if (!window) + { + window = gtk_dialog_new (); + + gtk_signal_connect (GTK_OBJECT (window), "destroy", + GTK_SIGNAL_FUNC(destroy_idle_test), + &window); + + gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file"); + gtk_container_border_width (GTK_CONTAINER (window), 0); + + button = gtk_button_new_with_label ("Reload"); + gtk_signal_connect (GTK_OBJECT (button), "clicked", + GTK_SIGNAL_FUNC(reload_rc_file), NULL); + GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), + button, TRUE, TRUE, 0); + gtk_widget_grab_default (button); + gtk_widget_show (button); + + button = gtk_button_new_with_label ("Reload All"); + gtk_signal_connect (GTK_OBJECT (button), "clicked", + GTK_SIGNAL_FUNC(reload_all_rc_files), NULL); + GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), + 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_OBJECT (window)); + GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), + button, TRUE, TRUE, 0); + gtk_widget_show (button); + + } + + if (!GTK_WIDGET_VISIBLE (window)) + gtk_widget_show (window); + else + gtk_widget_destroy (window); } /* - * Basic Test + * Test of recursive mainloop */ + +void +mainloop_destroyed (GtkWidget *w, GtkWidget **window) +{ + *window = NULL; + gtk_main_quit (); +} + void -create_test () +create_mainloop (void) { static GtkWidget *window = NULL; + GtkWidget *label; + GtkWidget *button; if (!window) { - window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + window = gtk_dialog_new (); + + gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop"); gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC(test_destroy), - &window); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(test_destroy), + GTK_SIGNAL_FUNC(mainloop_destroyed), &window); + label = gtk_label_new ("In recursive main loop..."); + gtk_misc_set_padding (GTK_MISC(label), 20, 20); - gtk_window_set_title (GTK_WINDOW (window), "test"); - gtk_container_border_width (GTK_CONTAINER (window), 0); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label, + TRUE, TRUE, 0); + gtk_widget_show (label); + + button = gtk_button_new_with_label ("Leave"); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, + FALSE, TRUE, 0); + + gtk_signal_connect_object (GTK_OBJECT (button), "clicked", + GTK_SIGNAL_FUNC (gtk_widget_destroy), + GTK_OBJECT (window)); + + 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); - g_print ("create_test: start\n"); + g_print ("create_mainloop: start\n"); gtk_main (); - g_print ("create_test: done\n"); + g_print ("create_mainloop: done\n"); } else gtk_widget_destroy (window); @@ -3846,55 +6670,63 @@ create_test () * Main Window and Exit */ void -do_exit () +do_exit (GtkWidget *widget, GtkWidget *window) { - gtk_exit (0); + gtk_widget_destroy (window); + gtk_main_quit (); } void -create_main_window () +create_main_window (void) { struct { char *label; void (*func) (); } buttons[] = { + { "button box", create_button_box }, { "buttons", create_buttons }, - { "toggle buttons", create_toggle_buttons }, { "check buttons", create_check_buttons }, - { "radio buttons", create_radio_buttons }, - { "button box", create_button_box }, - { "toolbar", create_toolbar }, - { "handle box", create_handle_box }, - { "reparent", create_reparent }, - { "pixmap", create_pixmap }, - { "tooltips", create_tooltips }, - { "menus", create_menus }, - { "scrolled windows", create_scrolled_windows }, - { "drawing areas", NULL }, - { "entry", create_entry }, - { "list", create_list }, { "clist", create_clist}, { "color selection", create_color_selection }, - { "file selection", create_file_selection }, + { "ctree", create_ctree }, + { "cursors", create_cursors }, { "dialog", create_dialog }, + { "dnd", create_dnd }, + { "entry", create_entry }, + { "file selection", create_file_selection }, + { "font selection", create_font_selection }, + { "gamma curve", create_gamma_curve }, + { "handle box", create_handle_box }, + { "list", create_list }, + { "menus", create_menus }, { "miscellaneous", NULL }, - { "range controls", create_range_controls }, - { "rulers", create_rulers }, - { "text", create_text }, { "notebook", create_notebook }, { "panes", create_panes }, - { "shapes", create_shapes }, - { "dnd", create_dnd }, - { "progress bar", create_progress_bar }, + { "pixmap", create_pixmap }, { "preview color", create_color_preview }, { "preview gray", create_gray_preview }, - { "gamma curve", create_gamma_curve }, + { "progress bar", create_progress_bar }, + { "radio buttons", create_radio_buttons }, + { "range controls", create_range_controls }, + { "rc file", create_rc_file }, + { "reparent", create_reparent }, + { "rulers", create_rulers }, + { "scrolled windows", create_scrolled_windows }, + { "shapes", create_shapes }, + { "spinbutton", create_spins }, + { "statusbar", create_statusbar }, + { "test idle", create_idle_test }, + { "test mainloop", create_mainloop }, { "test scrolling", create_scroll_test }, { "test selection", create_selection_test }, { "test timeout", create_timeout_test }, - { "test idle", create_idle_test }, - { "test", create_test }, + { "text", create_text }, + { "toggle buttons", create_toggle_buttons }, + { "toolbar", create_toolbar }, + { "tooltips", create_tooltips }, + { "tree", create_tree_mode_window}, + { "WM hints", create_wmhints }, }; int nbuttons = sizeof (buttons) / sizeof (buttons[0]); GtkWidget *window; @@ -3902,10 +6734,13 @@ create_main_window () GtkWidget *box2; GtkWidget *scrolled_window; GtkWidget *button; + GtkWidget *label; + gchar buffer[64]; GtkWidget *separator; int i; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_policy (GTK_WINDOW (window), FALSE, FALSE, FALSE); gtk_widget_set_name (window, "main window"); gtk_widget_set_usize (window, 200, 400); gtk_widget_set_uposition (window, 20, 20); @@ -3913,25 +6748,44 @@ create_main_window () gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_main_quit), NULL); - gtk_signal_connect (GTK_OBJECT (window), "delete_event", - GTK_SIGNAL_FUNC(gtk_main_quit), + gtk_signal_connect (GTK_OBJECT (window), "delete-event", + GTK_SIGNAL_FUNC (gtk_false), NULL); 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+ v%d.%d.%d", + gtk_major_version, + gtk_minor_version, + gtk_micro_version); + else + sprintf (buffer, + "Gtk+ v%d.%d", + gtk_major_version, + 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_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_focus_vadjustment (GTK_CONTAINER (box2), + gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window))); gtk_widget_show (box2); for (i = 0; i < nbuttons; i++) @@ -3959,7 +6813,8 @@ create_main_window () button = gtk_button_new_with_label ("close"); gtk_signal_connect (GTK_OBJECT (button), "clicked", - GTK_SIGNAL_FUNC(do_exit), NULL); + GTK_SIGNAL_FUNC (do_exit), + 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); @@ -3974,6 +6829,11 @@ main (int argc, char *argv[]) gtk_set_locale (); gtk_init (&argc, &argv); + +#ifdef HAVE_LIBGLE + gle_init (&argc, &argv); +#endif /* !HAVE_LIBGLE */ + gtk_rc_parse ("testgtkrc"); create_main_window ();