* 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 <stdio.h>
#include <stdlib.h>
#include "gtk.h"
#include "../gdk/gdk.h"
#include "../gdk/gdkx.h"
-#include "gtkhandlebox.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)
{
gtk_widget_hide (button);
}
-void
+static void
create_buttons ()
{
static GtkWidget *window = NULL;
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_widget_destroy (window);
}
-void
+static void
create_toggle_buttons ()
{
static GtkWidget *window = NULL;
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");
gtk_widget_destroy (window);
}
-void
+static void
create_check_buttons ()
{
static GtkWidget *window = NULL;
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");
gtk_widget_destroy (window);
}
-void
+static void
create_radio_buttons ()
{
static GtkWidget *window = NULL;
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");
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,
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)
{
gtk_widget_show (window);
}
-void
+static void
test_hbbox ()
{
create_bbox_window (TRUE, "Spread", 50, 40, 85, 28, GTK_BUTTONBOX_SPREAD);
create_bbox_window (TRUE, "End", 500, 15, 30, 25, GTK_BUTTONBOX_END);
}
-void
+static void
test_vbbox ()
{
create_bbox_window (FALSE, "Spread", 50, 40, 85, 25, GTK_BUTTONBOX_SPREAD);
create_bbox_window (FALSE, "End", 650, 15, 30, 25, GTK_BUTTONBOX_END);
}
-void
+static void
create_button_box ()
{
static GtkWidget* window = NULL;
"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);
gtk_widget_destroy (window);
}
-GtkWidget *
+static GtkWidget*
new_pixmap (char *filename,
GdkWindow *window,
GdkColor *background)
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
create_toolbar (void)
{
static GtkWidget *window = NULL;
GtkWidget *toolbar;
+ GtkWidget *entry;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
- gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, TRUE);
+ 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);
toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
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), 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_container_add (GTK_CONTAINER (window), toolbar);
gtk_widget_destroy (window);
}
-GtkWidget *
+static GtkWidget*
make_toolbar (GtkWidget *window)
{
GtkWidget *toolbar;
toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
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);
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;
-#if 0
- GtkWidget* button;
-#endif
-
- 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);
-#if 0
-#if 0
- button = gtk_toggle_button_new_with_label ("Let's try this");
-#else
- button = gtk_label_new ("Let's try this");
-#endif
- gtk_container_add (GTK_CONTAINER (hbox), button);
- gtk_widget_set_usize(button, 250, 40);
- gtk_widget_show (button);
-#else
- {
- GtkWidget *toolbar = make_toolbar (window);
- gtk_container_add (GTK_CONTAINER (hbox), toolbar);
- gtk_widget_show (toolbar);
- }
-#endif
- }
+ gchar text[1024];
- if (!GTK_WIDGET_VISIBLE (window))
- gtk_widget_show (window);
- else
- gtk_widget_destroy (window);
+ sprintf (text, "something %d", statusbar_counter++);
+
+ 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 ()
{
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);
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);
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;
-
- if (!window)
- {
- window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ printf ("%s: child <%s> %sed\n",
+ gtk_type_name (GTK_OBJECT_TYPE (hb)),
+ gtk_type_name (GTK_OBJECT_TYPE (child)),
+ action);
+}
- 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);
+static void
+cb_tree_destroy_event(GtkWidget* w)
+{
+ sTreeButtons* tree_buttons;
- gtk_window_set_title (GTK_WINDOW (window), "pixmap");
- gtk_container_border_width (GTK_CONTAINER (window), 0);
- gtk_widget_realize(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];
- box1 = gtk_vbox_new (FALSE, 0);
- gtk_container_add (GTK_CONTAINER (window), box1);
- gtk_widget_show (box1);
+ tree_buttons = gtk_object_get_user_data(GTK_OBJECT(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);
+ selected_list = GTK_TREE_SELECTION(tree);
- button = gtk_button_new ();
- gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
- gtk_widget_show (button);
+ 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);
- style=gtk_widget_get_style(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);
+ }
+ }
- pixmap = gdk_pixmap_create_from_xpm (window->window, &mask,
- &style->bg[GTK_STATE_NORMAL],
- "test.xpm");
- pixmapwid = gtk_pixmap_new (pixmap, mask);
+ /* 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);
- 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);
+ tree_buttons->nb_item_add++;
+}
- separator = gtk_hseparator_new ();
- gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
- gtk_widget_show (separator);
+static void
+cb_remove_item(GtkWidget*w, GtkTree* tree)
+{
+ GList* selected_list;
+ GList* clear_list;
+
+ selected_list = GTK_TREE_SELECTION(tree);
+ 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);
- 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);
+ g_list_free (clear_list);
+}
+static void
+cb_remove_subtree(GtkWidget*w, GtkTree* tree)
+{
+ GList* selected_list;
+ GtkTreeItem *item;
+
+ selected_list = GTK_TREE_SELECTION(tree);
- button = gtk_button_new_with_label ("close");
+ if (selected_list)
+ {
+ item = GTK_TREE_ITEM (selected_list->data);
+ if (item->subtree)
+ gtk_tree_item_remove_subtree (item);
+ }
+}
+
+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 ()
+{
+ 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_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);
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",
+ (gint) func_data);
+}
+
+static void
+create_reparent ()
{
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),
+ (GtkObject*) 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);
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))
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 ()
{
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);
+ button = gtk_button_new ();
+ gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
+ gtk_widget_show (button);
- menu = create_menu (2);
+ style=gtk_widget_get_style(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);
+ 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 ()
+{
+ 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);
- menuitem = gtk_menu_item_new_with_label ("foo");
+ gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1));
+ }
+
+ return menu;
+}
+
+static void
+create_menus ()
+{
+ 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);
gtk_widget_destroy (window);
}
-void
+/*
+ * GtkScrolledWindow
+ */
+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 ()
{
static GtkWidget *window;
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");
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++)
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))
gtk_widget_destroy (window);
}
-void
+/*
+ * GtkEntry
+ */
+
+static void
+entry_toggle_editable (GtkWidget *checkbutton,
+ GtkWidget *entry)
+{
+ gtk_entry_set_editable(GTK_ENTRY(entry),
+ GTK_TOGGLE_BUTTON(checkbutton)->active);
+}
+
+static void
create_entry ()
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
- GtkWidget *entry;
+ GtkWidget *editable_check;
+ GtkWidget *entry, *cb;
GtkWidget *button;
GtkWidget *separator;
+ GList *cbitems = NULL;
- /* if (!window) */
+ if (!window)
{
+ 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");
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
-
entry = gtk_entry_new ();
- /* gtk_widget_set_usize (entry, 0, 25); */
gtk_entry_set_text (GTK_ENTRY (entry), "hello world");
+ 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_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, 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);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
if (!GTK_WIDGET_VISIBLE (window))
gtk_widget_show (window);
- /* else
- gtk_widget_destroy (window); */
+ else
+ gtk_widget_destroy (window);
}
-void
-list_add (GtkWidget *widget,
- GtkWidget *list)
-{
- static int i = 1;
- gchar buffer[64];
- GtkWidget *list_item;
+/*
+ * GtkSpinButton
+ */
- 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;
-void
+static void
+toggle_snap (GtkWidget *widget, GtkSpinButton *spin)
+{
+ if (GTK_TOGGLE_BUTTON (widget)->active)
+ gtk_spin_button_set_update_policy (spin, GTK_UPDATE_ALWAYS
+ | GTK_UPDATE_SNAP_TO_TICKS);
+ else
+ gtk_spin_button_set_update_policy (spin, GTK_UPDATE_ALWAYS);
+}
+
+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, gint 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 (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 ()
+{
+ 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_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_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_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_spin_button_set_update_policy (GTK_SPIN_BUTTON (spinner1),
+ GTK_UPDATE_ALWAYS);
+ 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),
+ (gpointer) 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),
+ (gpointer) 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 ()
+{
+ 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)
{
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
+static void
+list_clear (GtkWidget *widget,
+ GtkWidget *list)
+{
+ gtk_list_clear_items (GTK_LIST (list), 3 - 1, 5 - 1);
+}
+
+static void
create_list ()
{
static GtkWidget *window = NULL;
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), "list");
gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_MULTIPLE);
gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_BROWSE);
gtk_container_add (GTK_CONTAINER (scrolled_win), list);
+ gtk_container_set_focus_vadjustment (GTK_CONTAINER (list),
+ gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_win)));
gtk_widget_show (list);
for (i = 0; i < nlist_items; i++)
gtk_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_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);
+ 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,
+ "test.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, "Testing", 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: %d\n", (int) pixmap);
+ g_print ("MASK: %d\n", (int) 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: %d\n", (int) pixmap);
+ g_print ("MASK: %d\n", (int) mask);
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ /* print selections list */
+ g_print ("\nSelected Rows:");
+ list = GTK_CLIST (widget)->selection;
+ while (list)
+ {
+ g_print (" %d ", (gint) 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: %d\n", (int) pixmap);
+ g_print ("MASK: %d\n", (int) 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: %d\n", (int) pixmap);
+ g_print ("MASK: %d\n", (int) mask);
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ /* print selections list */
+ g_print ("\nSelected Rows:");
+ list = GTK_CLIST (widget)->selection;
+ while (list)
+ {
+ g_print (" %d ", (gint) 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 ()
+{
+ 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);
+
+ gtk_signal_connect (GTK_OBJECT (button),
+ "clicked",
+ (GtkSignalFunc) insert_row_clist,
+ (gpointer) clist);
+
+ gtk_widget_show (button);
+
+ 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);
+
+ 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);
+
+ gtk_signal_connect (GTK_OBJECT (clist),
+ "unselect_row",
+ (GtkSignalFunc) unselect_clist,
+ NULL);
+
+ gtk_clist_set_column_width (GTK_CLIST (clist), 0, 100);
+
+ for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
+ gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
+
+ gtk_clist_set_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++)
+ {
+ texts[i] = text[i];
+ sprintf (text[i], "Column %d", i);
+ }
+
+ sprintf (text[1], "Right");
+ sprintf (text[2], "Center");
+
+ 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
+ {
+ clist_rows = 0;
+ gtk_widget_destroy (window);
+ }
+
+}
+
+
+/*
+ * GtkCTree
+ */
+
+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)
+{
+ char buf[80];
+
+ 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 after_move (GtkCTree *ctree, GList *child, GList *parent,
+ GList *sibling, gpointer data)
+{
+ 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");
+}
+
+gint button_press (GtkCTree *ctree, GdkEventButton *event, gpointer data)
+{
+ gint row;
+ gint column;
+ GList *work;
+ gint res;
+
+ res = gtk_clist_get_selection_info (GTK_CLIST (ctree), event->x, event->y,
+ &row, &column);
+ if (!res && event->button != 3)
+ return FALSE;
+
+ work = g_list_nth (GTK_CLIST (ctree)->row_list, row);
+
+ switch (event->button)
+ {
+ case 1:
+ if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_MULTIPLE &&
+ event->state & GDK_SHIFT_MASK)
+ gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),"button_press_event");
+ break;
+ case 2:
+ if (GTK_CTREE_ROW (work)->children &&
+ gtk_ctree_is_hot_spot (ctree, event->x, event->y))
+ {
+ if (GTK_CTREE_ROW (work)->expanded)
+ gtk_ctree_collapse_recursive (ctree, work);
+ else
+ gtk_ctree_expand_recursive (ctree, work);
+ after_press (ctree, NULL);
+ gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),
+ "button_press_event");
+ }
+ break;
+ default:
+ break;
+ }
+ return FALSE;
+}
+
+gint button_release (GtkCTree *ctree, GdkEventButton *event, gpointer data)
+{
+ gint row;
+ gint column;
+ GList *work;
+ gint res;
+
+ res = gtk_clist_get_selection_info (GTK_CLIST (ctree), event->x, event->y,
+ &row, &column);
+ if (!res || event->button != 1)
+ return FALSE;
+
+ work = g_list_nth (GTK_CLIST (ctree)->row_list, row);
+
+ if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_MULTIPLE &&
+ event->state & GDK_SHIFT_MASK)
+ {
+ if (GTK_CTREE_ROW (work)->row.state == GTK_STATE_SELECTED)
+ gtk_ctree_unselect_recursive (ctree, work);
+ else
+ gtk_ctree_select_recursive (ctree, work);
+ after_press (ctree, NULL);
+ gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),
+ "button_release_event");
+ }
+ return FALSE;
+}
+
+void count_items (GtkCTree *ctree, GList *list)
+{
+ if (GTK_CTREE_ROW (list)->is_leaf)
+ pages--;
+ else
+ books--;
+}
+
+void expand_all (GtkWidget *widget, GtkCTree *ctree)
+{
+ gtk_ctree_expand_recursive (ctree, NULL);
+ after_press (ctree, NULL);
+}
+
+void collapse_all (GtkWidget *widget, GtkCTree *ctree)
+{
+ gtk_ctree_collapse_recursive (ctree, NULL);
+ after_press (ctree, NULL);
+}
+
+void select_all (GtkWidget *widget, GtkCTree *ctree)
+{
+ if (GTK_CLIST (ctree)->selection_mode != GTK_SELECTION_MULTIPLE)
+ return;
+ gtk_ctree_select_recursive (ctree, NULL);
+ after_press (ctree, NULL);
+}
+
+void unselect_all (GtkWidget *widget, GtkCTree *ctree)
+{
+ GList *work;
+ GList *ptr;
+
+ if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_BROWSE)
+ return;
+
+ work = GTK_CLIST (ctree)->selection;
+
+ while (work)
+ {
+ ptr = work->data;
+ work = work->next;
+ gtk_ctree_unselect (ctree, ptr);
+ }
+ after_press (ctree, NULL);
+}
+
+void remove_selection (GtkWidget *widget, GtkCTree *ctree)
+{
+ GList *work;
+ GList *selection;
+ GList *new_sel;
+
+ selection = GTK_CLIST (ctree)->selection;
+ new_sel = NULL;
+
+ gtk_clist_freeze (GTK_CLIST (ctree));
+
+ 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 sort_all (GtkWidget *widget, GtkCTree *ctree)
+{
+ gtk_ctree_sort_recursive (ctree, NULL);
+}
+
+void change_indent (GtkWidget *widget, GtkCTree *ctree)
+{
+ gtk_ctree_set_indent (ctree, GTK_ADJUSTMENT (widget)->value);
+}
+
+void toggle_reorderable (GtkWidget *widget, GtkCTree *ctree)
+{
+ gtk_ctree_set_reorderable (ctree, GTK_TOGGLE_BUTTON (widget)->active);
+}
+
+void toggle_line_style (GtkWidget *widget, GtkCTree *ctree)
+{
+ gint i;
+
+
+ if (!GTK_WIDGET_MAPPED (widget))
+ return;
+
+ RADIOMENUTOGGLED ((GtkRadioMenuItem *)
+ (((GtkOptionMenu *)omenu2)->menu_item),i);
+
+ gtk_ctree_set_line_style (ctree, (GtkCTreeLineStyle) (2-i));
+}
+
+void toggle_justify (GtkWidget *widget, GtkCTree *ctree)
+{
+ gint i;
+
+ if (!GTK_WIDGET_MAPPED (widget))
+ return;
+
+ RADIOMENUTOGGLED ((GtkRadioMenuItem *)
+ (((GtkOptionMenu *)omenu3)->menu_item),i);
+
+ gtk_clist_set_column_justification (GTK_CLIST (ctree), 0,
+ (GtkJustification) (1-i));
+}
+
+void toggle_sel_mode (GtkWidget *widget, GtkCTree *ctree)
+{
+ gint i;
+
+ if (!GTK_WIDGET_MAPPED (widget))
+ return;
+
+ RADIOMENUTOGGLED ((GtkRadioMenuItem *)
+ (((GtkOptionMenu *)omenu)->menu_item), i);
+
+ gtk_ctree_set_selection_mode (ctree, (GtkSelectionMode) (3-i));
+ after_press (ctree, NULL);
+}
+
+
+void build_recursive (GtkCTree *ctree, gint cur_depth, gint depth,
+ gint num_books, gint num_pages, GList *parent)
+{
+ 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", 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);
+ }
+
+ if (cur_depth == depth)
+ return;
+
+ for (i = num_books; i > 0; i--)
+ {
+ books++;
+ sprintf (buf1, "Book %02d", 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);
+ }
+}
+
+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));
+
+ n = ((pow (b, d) - 1) / (b - 1)) * (p + 1);
+
+ if (n > 200000)
+ {
+ g_print ("%d total items? Try less\n",n);
+ return;
+ }
+
+ gtk_clist_freeze (GTK_CLIST (ctree));
+ gtk_ctree_clear (ctree);
+
+ books = 1;
+ pages = 0;
+
+ parent = gtk_ctree_insert (ctree, NULL, NULL, text, 5, pixmap1,
+ mask1, pixmap2, mask2, FALSE, TRUE);
+
+ build_recursive (ctree, 1, d, b, p, parent);
+ gtk_clist_thaw (GTK_CLIST (ctree));
+ after_press (ctree, NULL);
+}
+
+void create_ctree ()
+{
+ 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;
+
+ char *title[] = { "Tree" , "Info" };
+ char buf[80];
+
+ 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), "GtkCTree");
+ gtk_container_border_width (GTK_CONTAINER (window), 0);
+
+ tooltips = gtk_tooltips_new ();
+ gtk_object_ref (GTK_OBJECT (tooltips));
+ gtk_object_sink (GTK_OBJECT (tooltips));
+
+ gtk_object_set_data_full (GTK_OBJECT (window),
+ "tooltips",
+ tooltips,
+ (GtkDestroyNotify) gtk_object_unref);
+
+ vbox = gtk_vbox_new (FALSE, 0);
+ gtk_container_add (GTK_CONTAINER (window), vbox);
+
+ hbox = gtk_hbox_new (FALSE, 5);
+ gtk_container_border_width (GTK_CONTAINER (hbox), 5);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
+
+ label = gtk_label_new ("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);
+
+ 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);
+
+ button = gtk_button_new_with_label ("Close");
+ gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+
+ gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
+ (GtkSignalFunc) gtk_widget_destroy,
+ GTK_OBJECT(window));
+
+ 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_signal_connect (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (rebuild_tree), ctree);
+
+ hbox = gtk_hbox_new (FALSE, 5);
+ gtk_container_border_width (GTK_CONTAINER (hbox), 5);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
+
+ 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);
+
+ 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);
+
+ 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);
+
+ 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);
+
+ 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 ("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);
+
+ 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);
+
+ rebuild_tree (NULL, ctree);
}
if (!GTK_WIDGET_VISIBLE (window))
- gtk_widget_show (window);
+ gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
+
+/*
+ * GtkColorSelect
+ */
void
color_selection_ok (GtkWidget *w,
GtkColorSelectionDialog *cs)
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_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 (GTK_FILE_SELECTION (fs)));
+ gtk_widget_destroy (GTK_WIDGET (fs));
}
void
create_file_selection ()
{
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(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),
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
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
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");
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),
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");
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), "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
*/
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");
gtk_widget_show (table);
text = gtk_text_new (NULL, NULL);
- 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);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
- "spencer blah blah blah\n", -1);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
- "kimball\n", -1);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
- "is\n", -1);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
- "a\n", -1);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
- "wuss.\n", -1);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
- "but\n", -1);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
- "josephine\n", -1);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
- "(his\n", -1);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
- "girlfriend\n", -1);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
- "is\n", -1);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
- "not).\n", -1);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
- "why?\n", -1);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
- "because\n", -1);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
- "spencer\n", -1);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
- "puked\n", -1);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
- "last\n", -1);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
- "night\n", -1);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
- "but\n", -1);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
- "josephine\n", -1);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
- "did\n", -1);
- gtk_text_insert (GTK_TEXT (text), NULL, &text->style->white, NULL,
- "not", -1);
+ 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,
+ "And even ", -1);
+ gtk_text_insert (GTK_TEXT (text), NULL, &text->style->bg[GTK_STATE_NORMAL], NULL,
+ "colored", -1);
+ gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
+ "text", -1);
gtk_text_thaw (GTK_TEXT (text));
+ hbox = gtk_hbutton_box_new ();
+ gtk_box_pack_start (GTK_BOX (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);
/*
* 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
+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 ()
{
static GtkWidget *window = NULL;
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);
-
- 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);
+ gtk_box_pack_start (GTK_BOX (box1), notebook, TRUE, TRUE, 0);
+ gtk_container_border_width (GTK_CONTAINER (notebook), 10);
- 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);
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);
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);
+
+ 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);
+
}
if (!GTK_WIDGET_VISIBLE (window))
- gtk_widget_show (window);
+ gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
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");
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);
* 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 */
gtk_grab_remove(GTK_WIDGET(*window));
*window = NULL;
}
- return TRUE;
+
+ return FALSE;
}
void
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_FUNC(dnd_drop_destroy_popup),
&window);
gtk_signal_connect (GTK_OBJECT (window), "delete_event",
- GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
+ GTK_SIGNAL_FUNC(gtk_false),
&window);
vbox = gtk_vbox_new(FALSE, 5);
/* 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);
gtk_widget_show(vbox);
gtk_grab_add(window);
gtk_widget_show(window);
-
- g_free (event->dropdataavailable.data);
- g_free (event->dropdataavailable.data_type);
}
void
GtkWidget *frame;
GtkWidget *button;
GtkWidget *separator;
+
/* 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);
+
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");
* 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;
static void
-shape_pressed (GtkWidget *widget)
+shape_pressed (GtkWidget *widget, GdkEventButton *event)
{
CursorOffset *p;
+ /* ignore double and triple click */
+ if (event->type != GDK_BUTTON_PRESS)
+ return;
+
p = gtk_object_get_user_data (GTK_OBJECT(widget));
- gtk_widget_get_pointer (widget, &(p->x), &(p->y));
+ p->x = (int) event->x;
+ p->y = (int) event->y;
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);
}
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);
}
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);
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);
gtk_widget_set_uposition (window, x, y);
gtk_widget_show (window);
-
+
return window;
}
void
create_shapes ()
{
+ /* 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)
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
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);
}
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 ()
+{
+ 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
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
GtkWidget *vbox;
GtkWidget *pbar;
GtkWidget *label;
-
+ GtkTooltips *tooltips;
+
if (!window)
{
window = gtk_dialog_new ();
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);
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);
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
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);
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
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);
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");
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 ();
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");
*/
static int timer = 0;
-void
+gint
timeout_test (GtkWidget *label)
{
static int count = 0;
sprintf (buffer, "count: %d", ++count);
gtk_label_set (GTK_LABEL (label), buffer);
+
+ return TRUE;
}
void
destroy_timeout_test (GtkWidget *widget,
GtkWidget **window)
{
- destroy_window (widget, window);
stop_timeout_test (NULL, NULL);
+
+ *window = NULL;
}
void
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);
destroy_idle_test (GtkWidget *widget,
GtkWidget **window)
{
- destroy_window (widget, window);
stop_idle_test (NULL, NULL);
+
+ *window = NULL;
}
void
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);
}
void
-test_destroy (GtkWidget *widget,
- GtkWidget **window)
+reload_rc_file (void)
{
- destroy_window (widget, window);
- gtk_main_quit ();
+ GList *toplevels;
+
+ 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
+create_rc_file ()
+{
+ 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 ("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 ()
{
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);
* Main Window and Exit
*/
void
-do_exit ()
+do_exit (GtkWidget *widget, GtkWidget *window)
{
- gtk_exit (0);
+ gtk_widget_destroy (window);
+ gtk_main_quit ();
}
void
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 },
+ { "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;
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);
GTK_SIGNAL_FUNC(gtk_main_quit),
NULL);
gtk_signal_connect (GTK_OBJECT (window), "delete_event",
- GTK_SIGNAL_FUNC(gtk_main_quit),
+ 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++)
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);
gtk_set_locale ();
gtk_init (&argc, &argv);
+
+#ifdef HAVE_LIBGLE
+ gle_init (&argc, &argv);
+#endif /* !HAVE_LIBGLE */
+
gtk_rc_parse ("testgtkrc");
create_main_window ();
projects / ~andy / gtk / blobdiff