forked from AuroraMiddleware/gtk
Tue Mar 31 15:41:57 PST 1998 Shawn T. Amundson
* Makefile.am: * examples/*: added the rest of the tutorial examples
This commit is contained in:
parent
30f22e0208
commit
c36ca76bb8
@ -1,3 +1,8 @@
|
||||
Tue Mar 31 15:41:57 PST 1998 Shawn T. Amundson
|
||||
|
||||
* Makefile.am:
|
||||
* examples/*: added the rest of the tutorial examples
|
||||
|
||||
Tue Mar 31 06:37:16 1998 Tim Janik <timj@gtk.org>
|
||||
|
||||
* gtk/testgtk.c (create_cursors): forgot to set the initial `0' cursor.
|
||||
|
@ -1,3 +1,8 @@
|
||||
Tue Mar 31 15:41:57 PST 1998 Shawn T. Amundson
|
||||
|
||||
* Makefile.am:
|
||||
* examples/*: added the rest of the tutorial examples
|
||||
|
||||
Tue Mar 31 06:37:16 1998 Tim Janik <timj@gtk.org>
|
||||
|
||||
* gtk/testgtk.c (create_cursors): forgot to set the initial `0' cursor.
|
||||
|
@ -1,3 +1,8 @@
|
||||
Tue Mar 31 15:41:57 PST 1998 Shawn T. Amundson
|
||||
|
||||
* Makefile.am:
|
||||
* examples/*: added the rest of the tutorial examples
|
||||
|
||||
Tue Mar 31 06:37:16 1998 Tim Janik <timj@gtk.org>
|
||||
|
||||
* gtk/testgtk.c (create_cursors): forgot to set the initial `0' cursor.
|
||||
|
@ -1,3 +1,8 @@
|
||||
Tue Mar 31 15:41:57 PST 1998 Shawn T. Amundson
|
||||
|
||||
* Makefile.am:
|
||||
* examples/*: added the rest of the tutorial examples
|
||||
|
||||
Tue Mar 31 06:37:16 1998 Tim Janik <timj@gtk.org>
|
||||
|
||||
* gtk/testgtk.c (create_cursors): forgot to set the initial `0' cursor.
|
||||
|
@ -1,3 +1,8 @@
|
||||
Tue Mar 31 15:41:57 PST 1998 Shawn T. Amundson
|
||||
|
||||
* Makefile.am:
|
||||
* examples/*: added the rest of the tutorial examples
|
||||
|
||||
Tue Mar 31 06:37:16 1998 Tim Janik <timj@gtk.org>
|
||||
|
||||
* gtk/testgtk.c (create_cursors): forgot to set the initial `0' cursor.
|
||||
|
@ -1,3 +1,8 @@
|
||||
Tue Mar 31 15:41:57 PST 1998 Shawn T. Amundson
|
||||
|
||||
* Makefile.am:
|
||||
* examples/*: added the rest of the tutorial examples
|
||||
|
||||
Tue Mar 31 06:37:16 1998 Tim Janik <timj@gtk.org>
|
||||
|
||||
* gtk/testgtk.c (create_cursors): forgot to set the initial `0' cursor.
|
||||
|
@ -1,3 +1,8 @@
|
||||
Tue Mar 31 15:41:57 PST 1998 Shawn T. Amundson
|
||||
|
||||
* Makefile.am:
|
||||
* examples/*: added the rest of the tutorial examples
|
||||
|
||||
Tue Mar 31 06:37:16 1998 Tim Janik <timj@gtk.org>
|
||||
|
||||
* gtk/testgtk.c (create_cursors): forgot to set the initial `0' cursor.
|
||||
|
41
Makefile.am
41
Makefile.am
@ -12,6 +12,7 @@ EXTRA_DIST = \
|
||||
TODO \
|
||||
examples/gtkdial/Makefile \
|
||||
examples/gtkdial/dial_test.c \
|
||||
examples/gtkdial/gtkdial.h \
|
||||
examples/gtkdial/gtkdial.c \
|
||||
examples/helloworld/Makefile \
|
||||
examples/helloworld/helloworld.c \
|
||||
@ -20,11 +21,49 @@ EXTRA_DIST = \
|
||||
examples/scribble-simple/Makefile \
|
||||
examples/scribble-simple/scribble-simple.c \
|
||||
examples/tictactoe/Makefile \
|
||||
examples/tictactoe/tictactoe.h \
|
||||
examples/tictactoe/tictactoe.c \
|
||||
examples/tictactoe/ttt_test.c \
|
||||
examples/buttons/Makefile \
|
||||
examples/buttons/info.xpm \
|
||||
examples/buttons/buttons.c
|
||||
examples/buttons/buttons.c \
|
||||
examples/packbox/Makefile \
|
||||
examples/packbox/packbox.c \
|
||||
examples/entry/Makefile \
|
||||
examples/entry/entry.c \
|
||||
examples/eventbox/Makefile \
|
||||
examples/eventbox/eventbox.c \
|
||||
examples/list/Makefile \
|
||||
examples/list/list.c \
|
||||
examples/menu/Makefile \
|
||||
examples/menu/menufactory.h \
|
||||
examples/menu/menu.c \
|
||||
examples/menu/mfmain.c \
|
||||
examples/menu/menufactory.c \
|
||||
examples/menu/mfmain.h \
|
||||
examples/notebook/Makefile \
|
||||
examples/notebook/notebook.c \
|
||||
examples/pixmap/Makefile \
|
||||
examples/pixmap/pixmap.c \
|
||||
examples/progressbar/Makefile \
|
||||
examples/progressbar/progressbar.c \
|
||||
examples/table/Makefile \
|
||||
examples/table/table.c \
|
||||
examples/radiobuttons/Makefile \
|
||||
examples/radiobuttons/radiobuttons.c \
|
||||
examples/rulers/Makefile \
|
||||
examples/rulers/rulers.c \
|
||||
examples/scrolledwin/Makefile \
|
||||
examples/scrolledwin/scrolledwin.c \
|
||||
examples/wheelbarrow/Makefile \
|
||||
examples/wheelbarrow/wheelbarrow.c \
|
||||
examples/statusbar/Makefile \
|
||||
examples/statusbar/statusbar.c \
|
||||
examples/selection/Makefile \
|
||||
examples/selection/gettargets.c \
|
||||
examples/selection/setselection.c \
|
||||
examples/filesel/Makefile \
|
||||
examples/filesel/filesel.c
|
||||
|
||||
|
||||
m4datadir = $(datadir)/aclocal
|
||||
|
8
examples/entry/Makefile
Normal file
8
examples/entry/Makefile
Normal file
@ -0,0 +1,8 @@
|
||||
|
||||
CC = gcc
|
||||
|
||||
entry: entry.c
|
||||
$(CC) `gtk-config --cflags` `gtk-config --libs` entry.c -o entry
|
||||
|
||||
clean:
|
||||
rm -f *.o entry
|
92
examples/entry/entry.c
Normal file
92
examples/entry/entry.c
Normal file
@ -0,0 +1,92 @@
|
||||
/* This file extracted from the GTK tutorial. */
|
||||
|
||||
/* entry.c */
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
void enter_callback(GtkWidget *widget, GtkWidget *entry)
|
||||
{
|
||||
gchar *entry_text;
|
||||
entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
|
||||
printf("Entry contents: %s\n", entry_text);
|
||||
}
|
||||
|
||||
void entry_toggle_editable (GtkWidget *checkbutton,
|
||||
GtkWidget *entry)
|
||||
{
|
||||
gtk_entry_set_editable(GTK_ENTRY(entry),
|
||||
GTK_TOGGLE_BUTTON(checkbutton)->active);
|
||||
}
|
||||
|
||||
void entry_toggle_visibility (GtkWidget *checkbutton,
|
||||
GtkWidget *entry)
|
||||
{
|
||||
gtk_entry_set_visibility(GTK_ENTRY(entry),
|
||||
GTK_TOGGLE_BUTTON(checkbutton)->active);
|
||||
}
|
||||
|
||||
int main (int argc, char *argv[])
|
||||
{
|
||||
|
||||
GtkWidget *window;
|
||||
GtkWidget *vbox, *hbox;
|
||||
GtkWidget *entry;
|
||||
GtkWidget *button;
|
||||
GtkWidget *check;
|
||||
|
||||
gtk_init (&argc, &argv);
|
||||
|
||||
/* create a new window */
|
||||
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
||||
gtk_widget_set_usize( GTK_WIDGET (window), 200, 100);
|
||||
gtk_window_set_title(GTK_WINDOW (window), "GTK Entry");
|
||||
gtk_signal_connect(GTK_OBJECT (window), "delete_event",
|
||||
(GtkSignalFunc) gtk_exit, NULL);
|
||||
|
||||
vbox = gtk_vbox_new (FALSE, 0);
|
||||
gtk_container_add (GTK_CONTAINER (window), vbox);
|
||||
gtk_widget_show (vbox);
|
||||
|
||||
entry = gtk_entry_new_with_max_length (50);
|
||||
gtk_signal_connect(GTK_OBJECT(entry), "activate",
|
||||
GTK_SIGNAL_FUNC(enter_callback),
|
||||
entry);
|
||||
gtk_entry_set_text (GTK_ENTRY (entry), "hello");
|
||||
gtk_entry_append_text (GTK_ENTRY (entry), " world");
|
||||
gtk_entry_select_region (GTK_ENTRY (entry),
|
||||
0, GTK_ENTRY(entry)->text_length);
|
||||
gtk_box_pack_start (GTK_BOX (vbox), entry, TRUE, TRUE, 0);
|
||||
gtk_widget_show (entry);
|
||||
|
||||
hbox = gtk_hbox_new (FALSE, 0);
|
||||
gtk_container_add (GTK_CONTAINER (vbox), hbox);
|
||||
gtk_widget_show (hbox);
|
||||
|
||||
check = gtk_check_button_new_with_label("Editable");
|
||||
gtk_box_pack_start (GTK_BOX (hbox), check, TRUE, TRUE, 0);
|
||||
gtk_signal_connect (GTK_OBJECT(check), "toggled",
|
||||
GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
|
||||
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
|
||||
gtk_widget_show (check);
|
||||
|
||||
check = gtk_check_button_new_with_label("Visible");
|
||||
gtk_box_pack_start (GTK_BOX (hbox), check, TRUE, TRUE, 0);
|
||||
gtk_signal_connect (GTK_OBJECT(check), "toggled",
|
||||
GTK_SIGNAL_FUNC(entry_toggle_visibility), entry);
|
||||
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
|
||||
gtk_widget_show (check);
|
||||
|
||||
button = gtk_button_new_with_label ("Close");
|
||||
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
|
||||
GTK_SIGNAL_FUNC(gtk_exit),
|
||||
GTK_OBJECT (window));
|
||||
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
|
||||
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
|
||||
gtk_widget_grab_default (button);
|
||||
gtk_widget_show (button);
|
||||
|
||||
gtk_widget_show(window);
|
||||
|
||||
gtk_main();
|
||||
return(0);
|
||||
}
|
8
examples/eventbox/Makefile
Normal file
8
examples/eventbox/Makefile
Normal file
@ -0,0 +1,8 @@
|
||||
|
||||
CC = gcc
|
||||
|
||||
eventbox: eventbox.c
|
||||
$(CC) `gtk-config --cflags` `gtk-config --libs` eventbox.c -o eventbox
|
||||
|
||||
clean:
|
||||
rm -f *.o eventbox
|
55
examples/eventbox/eventbox.c
Normal file
55
examples/eventbox/eventbox.c
Normal file
@ -0,0 +1,55 @@
|
||||
/* This file extracted from the GTK tutorial. */
|
||||
|
||||
/* eventbox.c */
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
int
|
||||
main (int argc, char *argv[])
|
||||
{
|
||||
GtkWidget *window;
|
||||
GtkWidget *event_box;
|
||||
GtkWidget *label;
|
||||
|
||||
gtk_init (&argc, &argv);
|
||||
|
||||
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
|
||||
|
||||
gtk_window_set_title (GTK_WINDOW (window), "Event Box");
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (window), "destroy",
|
||||
GTK_SIGNAL_FUNC (gtk_exit), NULL);
|
||||
|
||||
gtk_container_border_width (GTK_CONTAINER (window), 10);
|
||||
|
||||
/* Create an EventBox and add it to our toplevel window */
|
||||
|
||||
event_box = gtk_event_box_new ();
|
||||
gtk_container_add (GTK_CONTAINER(window), event_box);
|
||||
gtk_widget_show (event_box);
|
||||
|
||||
/* Create a long label */
|
||||
|
||||
label = gtk_label_new ("Click here to quit, quit, quit, quit, quit");
|
||||
gtk_container_add (GTK_CONTAINER (event_box), label);
|
||||
gtk_widget_show (label);
|
||||
|
||||
/* Clip it short. */
|
||||
gtk_widget_set_usize (label, 110, 20);
|
||||
|
||||
/* And bind an action to it */
|
||||
gtk_widget_set_events (event_box, GDK_BUTTON_PRESS_MASK);
|
||||
gtk_signal_connect (GTK_OBJECT(event_box), "button_press_event",
|
||||
GTK_SIGNAL_FUNC (gtk_exit), NULL);
|
||||
|
||||
/* Yet one more thing you need an X window for ... */
|
||||
|
||||
gtk_widget_realize (event_box);
|
||||
gdk_window_set_cursor (event_box->window, gdk_cursor_new (GDK_HAND1));
|
||||
|
||||
gtk_widget_show (window);
|
||||
|
||||
gtk_main ();
|
||||
|
||||
return 0;
|
||||
}
|
8
examples/filesel/Makefile
Normal file
8
examples/filesel/Makefile
Normal file
@ -0,0 +1,8 @@
|
||||
|
||||
CC = gcc
|
||||
|
||||
filesel: filesel.c
|
||||
$(CC) `gtk-config --cflags` `gtk-config --libs` filesel.c -o filesel
|
||||
|
||||
clean:
|
||||
rm -f *.o filesel
|
46
examples/filesel/filesel.c
Normal file
46
examples/filesel/filesel.c
Normal file
@ -0,0 +1,46 @@
|
||||
/* This file extracted from the GTK tutorial. */
|
||||
|
||||
/* filesel.c */
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
/* Get the selected filename and print it to the console */
|
||||
void file_ok_sel (GtkWidget *w, GtkFileSelection *fs)
|
||||
{
|
||||
g_print ("%s\n", gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
|
||||
}
|
||||
|
||||
void destroy (GtkWidget *widget, gpointer *data)
|
||||
{
|
||||
gtk_main_quit ();
|
||||
}
|
||||
|
||||
int main (int argc, char *argv[])
|
||||
{
|
||||
GtkWidget *filew;
|
||||
|
||||
gtk_init (&argc, &argv);
|
||||
|
||||
/* Create a new file selection widget */
|
||||
filew = gtk_file_selection_new ("File selection");
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (filew), "destroy",
|
||||
(GtkSignalFunc) destroy, &filew);
|
||||
/* Connect the ok_button to file_ok_sel function */
|
||||
gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (filew)->ok_button),
|
||||
"clicked", (GtkSignalFunc) file_ok_sel, filew );
|
||||
|
||||
/* Connect the cancel_button to destroy the widget */
|
||||
gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (filew)->cancel_button),
|
||||
"clicked", (GtkSignalFunc) gtk_widget_destroy,
|
||||
GTK_OBJECT (filew));
|
||||
|
||||
/* Lets set the filename, as if this were a save dialog, and we are giving
|
||||
a default filename */
|
||||
gtk_file_selection_set_filename (GTK_FILE_SELECTION(filew),
|
||||
"penguin.png");
|
||||
|
||||
gtk_widget_show(filew);
|
||||
gtk_main ();
|
||||
return 0;
|
||||
}
|
8
examples/list/Makefile
Normal file
8
examples/list/Makefile
Normal file
@ -0,0 +1,8 @@
|
||||
|
||||
CC = gcc
|
||||
|
||||
list: list.c
|
||||
$(CC) `gtk-config --cflags` `gtk-config --libs` list.c -o list
|
||||
|
||||
clean:
|
||||
rm -f *.o list
|
284
examples/list/list.c
Normal file
284
examples/list/list.c
Normal file
@ -0,0 +1,284 @@
|
||||
/* This file extracted from the GTK tutorial. */
|
||||
|
||||
/* list.c */
|
||||
|
||||
/* include the gtk+ header files
|
||||
* include stdio.h, we need that for the printf() function
|
||||
*/
|
||||
#include <gtk/gtk.h>
|
||||
#include <stdio.h>
|
||||
|
||||
/* this is our data identification string to store
|
||||
* data in list items
|
||||
*/
|
||||
const gchar *list_item_data_key="list_item_data";
|
||||
|
||||
|
||||
/* prototypes for signal handler that we are going to connect
|
||||
* to the GtkList widget
|
||||
*/
|
||||
static void sigh_print_selection (GtkWidget *gtklist,
|
||||
gpointer func_data);
|
||||
static void sigh_button_event (GtkWidget *gtklist,
|
||||
GdkEventButton *event,
|
||||
GtkWidget *frame);
|
||||
|
||||
|
||||
/* main function to set up the user interface */
|
||||
|
||||
gint main (int argc, gchar *argv[])
|
||||
{
|
||||
GtkWidget *separator;
|
||||
GtkWidget *window;
|
||||
GtkWidget *vbox;
|
||||
GtkWidget *scrolled_window;
|
||||
GtkWidget *frame;
|
||||
GtkWidget *gtklist;
|
||||
GtkWidget *button;
|
||||
GtkWidget *list_item;
|
||||
GList *dlist;
|
||||
guint i;
|
||||
gchar buffer[64];
|
||||
|
||||
|
||||
/* initialize gtk+ (and subsequently gdk) */
|
||||
|
||||
gtk_init(&argc, &argv);
|
||||
|
||||
|
||||
/* create a window to put all the widgets in
|
||||
* connect gtk_main_quit() to the "destroy" event of
|
||||
* the window to handle window manager close-window-events
|
||||
*/
|
||||
window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
||||
gtk_window_set_title(GTK_WINDOW(window), "GtkList Example");
|
||||
gtk_signal_connect(GTK_OBJECT(window),
|
||||
"destroy",
|
||||
GTK_SIGNAL_FUNC(gtk_main_quit),
|
||||
NULL);
|
||||
|
||||
|
||||
/* inside the window we need a box to arrange the widgets
|
||||
* vertically */
|
||||
vbox=gtk_vbox_new(FALSE, 5);
|
||||
gtk_container_border_width(GTK_CONTAINER(vbox), 5);
|
||||
gtk_container_add(GTK_CONTAINER(window), vbox);
|
||||
gtk_widget_show(vbox);
|
||||
|
||||
/* this is the scolled window to put the GtkList widget inside */
|
||||
scrolled_window=gtk_scrolled_window_new(NULL, NULL);
|
||||
gtk_widget_set_usize(scrolled_window, 250, 150);
|
||||
gtk_container_add(GTK_CONTAINER(vbox), scrolled_window);
|
||||
gtk_widget_show(scrolled_window);
|
||||
|
||||
/* create the GtkList widget
|
||||
* connect the sigh_print_selection() signal handler
|
||||
* function to the "selection_changed" signal of the GtkList
|
||||
* to print out the selected items each time the selection
|
||||
* has changed */
|
||||
gtklist=gtk_list_new();
|
||||
gtk_container_add(GTK_CONTAINER(scrolled_window), gtklist);
|
||||
gtk_widget_show(gtklist);
|
||||
gtk_signal_connect(GTK_OBJECT(gtklist),
|
||||
"selection_changed",
|
||||
GTK_SIGNAL_FUNC(sigh_print_selection),
|
||||
NULL);
|
||||
|
||||
/* we create a "Prison" to put a list item in ;)
|
||||
*/
|
||||
frame=gtk_frame_new("Prison");
|
||||
gtk_widget_set_usize(frame, 200, 50);
|
||||
gtk_container_border_width(GTK_CONTAINER(frame), 5);
|
||||
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT);
|
||||
gtk_container_add(GTK_CONTAINER(vbox), frame);
|
||||
gtk_widget_show(frame);
|
||||
|
||||
/* connect the sigh_button_event() signal handler to the GtkList
|
||||
* wich will handle the "arresting" of list items
|
||||
*/
|
||||
gtk_signal_connect(GTK_OBJECT(gtklist),
|
||||
"button_release_event",
|
||||
GTK_SIGNAL_FUNC(sigh_button_event),
|
||||
frame);
|
||||
|
||||
/* create a separator
|
||||
*/
|
||||
separator=gtk_hseparator_new();
|
||||
gtk_container_add(GTK_CONTAINER(vbox), separator);
|
||||
gtk_widget_show(separator);
|
||||
|
||||
/* finaly create a button and connect it´s "clicked" signal
|
||||
* to the destroyment of the window
|
||||
*/
|
||||
button=gtk_button_new_with_label("Close");
|
||||
gtk_container_add(GTK_CONTAINER(vbox), button);
|
||||
gtk_widget_show(button);
|
||||
gtk_signal_connect_object(GTK_OBJECT(button),
|
||||
"clicked",
|
||||
GTK_SIGNAL_FUNC(gtk_widget_destroy),
|
||||
GTK_OBJECT(window));
|
||||
|
||||
|
||||
/* now we create 5 list items, each having it´s own
|
||||
* label and add them to the GtkList using gtk_container_add()
|
||||
* also we query the text string from the label and
|
||||
* associate it with the list_item_data_key for each list item
|
||||
*/
|
||||
for (i=0; i<5; i++) {
|
||||
GtkWidget *label;
|
||||
gchar *string;
|
||||
|
||||
sprintf(buffer, "ListItemContainer with Label #%d", i);
|
||||
label=gtk_label_new(buffer);
|
||||
list_item=gtk_list_item_new();
|
||||
gtk_container_add(GTK_CONTAINER(list_item), label);
|
||||
gtk_widget_show(label);
|
||||
gtk_container_add(GTK_CONTAINER(gtklist), list_item);
|
||||
gtk_widget_show(list_item);
|
||||
gtk_label_get(GTK_LABEL(label), &string);
|
||||
gtk_object_set_data(GTK_OBJECT(list_item),
|
||||
list_item_data_key,
|
||||
string);
|
||||
}
|
||||
/* here, we are creating another 5 labels, this time
|
||||
* we use gtk_list_item_new_with_label() for the creation
|
||||
* we can´t query the text string from the label because
|
||||
* we don´t have the labels pointer and therefore
|
||||
* we just associate the list_item_data_key of each
|
||||
* list item with the same text string
|
||||
* for adding of the list items we put them all into a doubly
|
||||
* linked list (GList), and then add them by a single call to
|
||||
* gtk_list_append_items()
|
||||
* because we use g_list_prepend() to put the items into the
|
||||
* doubly linked list, their order will be descending (instead
|
||||
* of ascending when using g_list_append())
|
||||
*/
|
||||
dlist=NULL;
|
||||
for (; i<10; i++) {
|
||||
sprintf(buffer, "List Item with Label %d", i);
|
||||
list_item=gtk_list_item_new_with_label(buffer);
|
||||
dlist=g_list_prepend(dlist, list_item);
|
||||
gtk_widget_show(list_item);
|
||||
gtk_object_set_data(GTK_OBJECT(list_item),
|
||||
list_item_data_key,
|
||||
"ListItem with integrated Label");
|
||||
}
|
||||
gtk_list_append_items(GTK_LIST(gtklist), dlist);
|
||||
|
||||
/* finaly we want to see the window, don´t we? ;)
|
||||
*/
|
||||
gtk_widget_show(window);
|
||||
|
||||
/* fire up the main event loop of gtk
|
||||
*/
|
||||
gtk_main();
|
||||
|
||||
/* we get here after gtk_main_quit() has been called which
|
||||
* happens if the main window gets destroyed
|
||||
*/
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* this is the signal handler that got connected to button
|
||||
* press/release events of the GtkList
|
||||
*/
|
||||
void
|
||||
sigh_button_event (GtkWidget *gtklist,
|
||||
GdkEventButton *event,
|
||||
GtkWidget *frame)
|
||||
{
|
||||
/* we only do something if the third (rightmost mouse button
|
||||
* was released
|
||||
*/
|
||||
if (event->type==GDK_BUTTON_RELEASE &&
|
||||
event->button==3) {
|
||||
GList *dlist, *free_list;
|
||||
GtkWidget *new_prisoner;
|
||||
|
||||
/* fetch the currently selected list item which
|
||||
* will be our next prisoner ;)
|
||||
*/
|
||||
dlist=GTK_LIST(gtklist)->selection;
|
||||
if (dlist)
|
||||
new_prisoner=GTK_WIDGET(dlist->data);
|
||||
else
|
||||
new_prisoner=NULL;
|
||||
|
||||
/* look for already prisoned list items, we
|
||||
* will put them back into the list
|
||||
* remember to free the doubly linked list that
|
||||
* gtk_container_children() returns
|
||||
*/
|
||||
dlist=gtk_container_children(GTK_CONTAINER(frame));
|
||||
free_list=dlist;
|
||||
while (dlist) {
|
||||
GtkWidget *list_item;
|
||||
|
||||
list_item=dlist->data;
|
||||
|
||||
gtk_widget_reparent(list_item, gtklist);
|
||||
|
||||
dlist=dlist->next;
|
||||
}
|
||||
g_list_free(free_list);
|
||||
|
||||
/* if we have a new prisoner, remove him from the
|
||||
* GtkList and put him into the frame "Prison"
|
||||
* we need to unselect the item before
|
||||
*/
|
||||
if (new_prisoner) {
|
||||
GList static_dlist;
|
||||
|
||||
static_dlist.data=new_prisoner;
|
||||
static_dlist.next=NULL;
|
||||
static_dlist.prev=NULL;
|
||||
|
||||
gtk_list_unselect_child(GTK_LIST(gtklist),
|
||||
new_prisoner);
|
||||
gtk_widget_reparent(new_prisoner, frame);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* this is the signal handler that gets called if GtkList
|
||||
* emits the "selection_changed" signal
|
||||
*/
|
||||
void
|
||||
sigh_print_selection (GtkWidget *gtklist,
|
||||
gpointer func_data)
|
||||
{
|
||||
GList *dlist;
|
||||
|
||||
/* fetch the doubly linked list of selected items
|
||||
* of the GtkList, remember to treat this as read-only!
|
||||
*/
|
||||
dlist=GTK_LIST(gtklist)->selection;
|
||||
|
||||
/* if there are no selected items there is nothing more
|
||||
* to do than just telling the user so
|
||||
*/
|
||||
if (!dlist) {
|
||||
g_print("Selection cleared\n");
|
||||
return;
|
||||
}
|
||||
/* ok, we got a selection and so we print it
|
||||
*/
|
||||
g_print("The selection is a ");
|
||||
|
||||
/* get the list item from the doubly linked list
|
||||
* and then query the data associated with list_item_data_key
|
||||
* we then just print it
|
||||
*/
|
||||
while (dlist) {
|
||||
GtkObject *list_item;
|
||||
gchar *item_data_string;
|
||||
|
||||
list_item=GTK_OBJECT(dlist->data);
|
||||
item_data_string=gtk_object_get_data(list_item,
|
||||
list_item_data_key);
|
||||
g_print("%s ", item_data_string);
|
||||
|
||||
dlist=dlist->next;
|
||||
}
|
||||
g_print("\n");
|
||||
}
|
19
examples/menu/Makefile
Normal file
19
examples/menu/Makefile
Normal file
@ -0,0 +1,19 @@
|
||||
|
||||
CC = gcc
|
||||
|
||||
all: menu menufactory
|
||||
|
||||
menu: menu.c
|
||||
$(CC) `gtk-config --cflags` `gtk-config --libs` menu.c -o menu
|
||||
|
||||
menufactory: menufactory.o mfmain.o
|
||||
$(CC) `gtk-config --libs` menufactory.o mfmain.o -o menufactory
|
||||
|
||||
menufactory.o:
|
||||
$(CC) `gtk-config --cflags` -c menufactory.c -o menufactory.o
|
||||
|
||||
mfmain.o:
|
||||
$(CC) `gtk-config --cflags` -c mfmain.c -o mfmain.o
|
||||
|
||||
clean:
|
||||
rm -f *.o menu menufactory
|
134
examples/menu/menu.c
Normal file
134
examples/menu/menu.c
Normal file
@ -0,0 +1,134 @@
|
||||
/* This file extracted from the GTK tutorial. */
|
||||
|
||||
/* menu.c */
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
static gint button_press (GtkWidget *, GdkEvent *);
|
||||
static void menuitem_response (gchar *);
|
||||
|
||||
int main (int argc, char *argv[])
|
||||
{
|
||||
|
||||
GtkWidget *window;
|
||||
GtkWidget *menu;
|
||||
GtkWidget *menu_bar;
|
||||
GtkWidget *root_menu;
|
||||
GtkWidget *menu_items;
|
||||
GtkWidget *vbox;
|
||||
GtkWidget *button;
|
||||
char buf[128];
|
||||
int i;
|
||||
|
||||
gtk_init (&argc, &argv);
|
||||
|
||||
/* create a new window */
|
||||
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
||||
gtk_widget_set_usize( GTK_WIDGET (window), 200, 100);
|
||||
gtk_window_set_title(GTK_WINDOW (window), "GTK Menu Test");
|
||||
gtk_signal_connect(GTK_OBJECT (window), "delete_event",
|
||||
(GtkSignalFunc) gtk_exit, NULL);
|
||||
|
||||
/* Init the menu-widget, and remember -- never
|
||||
* gtk_show_widget() the menu widget!!
|
||||
* This is the menu that holds the menu items, the one that
|
||||
* will pop up when you click on the "Root Menu" in the app */
|
||||
menu = gtk_menu_new();
|
||||
|
||||
/* Next we make a little loop that makes three menu-entries for "test-menu".
|
||||
* Notice the call to gtk_menu_append. Here we are adding a list of
|
||||
* menu items to our menu. Normally, we'd also catch the "clicked"
|
||||
* signal on each of the menu items and setup a callback for it,
|
||||
* but it's omitted here to save space. */
|
||||
|
||||
for(i = 0; i < 3; i++)
|
||||
{
|
||||
/* Copy the names to the buf. */
|
||||
sprintf(buf, "Test-undermenu - %d", i);
|
||||
|
||||
/* Create a new menu-item with a name... */
|
||||
menu_items = gtk_menu_item_new_with_label(buf);
|
||||
|
||||
/* ...and add it to the menu. */
|
||||
gtk_menu_append(GTK_MENU (menu), menu_items);
|
||||
|
||||
/* Do something interesting when the menuitem is selected */
|
||||
gtk_signal_connect_object(GTK_OBJECT(menu_items), "activate",
|
||||
GTK_SIGNAL_FUNC(menuitem_response), (gpointer) g_strdup(buf));
|
||||
|
||||
/* Show the widget */
|
||||
gtk_widget_show(menu_items);
|
||||
}
|
||||
|
||||
/* This is the root menu, and will be the label
|
||||
* displayed on the menu bar. There won't be a signal handler attached,
|
||||
* as it only pops up the rest of the menu when pressed. */
|
||||
root_menu = gtk_menu_item_new_with_label("Root Menu");
|
||||
|
||||
gtk_widget_show(root_menu);
|
||||
|
||||
/* Now we specify that we want our newly created "menu" to be the menu
|
||||
* for the "root menu" */
|
||||
gtk_menu_item_set_submenu(GTK_MENU_ITEM (root_menu), menu);
|
||||
|
||||
/* A vbox to put a menu and a button in: */
|
||||
vbox = gtk_vbox_new(FALSE, 0);
|
||||
gtk_container_add(GTK_CONTAINER(window), vbox);
|
||||
gtk_widget_show(vbox);
|
||||
|
||||
/* Create a menu-bar to hold the menus and add it to our main window */
|
||||
menu_bar = gtk_menu_bar_new();
|
||||
gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, FALSE, 2);
|
||||
gtk_widget_show(menu_bar);
|
||||
|
||||
/* Create a button to which to attach menu as a popup */
|
||||
button = gtk_button_new_with_label("press me");
|
||||
gtk_signal_connect_object(GTK_OBJECT(button), "event",
|
||||
GTK_SIGNAL_FUNC (button_press), GTK_OBJECT(menu));
|
||||
gtk_box_pack_end(GTK_BOX(vbox), button, TRUE, TRUE, 2);
|
||||
gtk_widget_show(button);
|
||||
|
||||
/* And finally we append the menu-item to the menu-bar -- this is the
|
||||
* "root" menu-item I have been raving about =) */
|
||||
gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), root_menu);
|
||||
|
||||
/* always display the window as the last step so it all splashes on
|
||||
* the screen at once. */
|
||||
gtk_widget_show(window);
|
||||
|
||||
gtk_main ();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* Respond to a button-press by posting a menu passed in as widget.
|
||||
*
|
||||
* Note that the "widget" argument is the menu being posted, NOT
|
||||
* the button that was pressed.
|
||||
*/
|
||||
|
||||
static gint button_press (GtkWidget *widget, GdkEvent *event)
|
||||
{
|
||||
|
||||
if (event->type == GDK_BUTTON_PRESS) {
|
||||
GdkEventButton *bevent = (GdkEventButton *) event;
|
||||
gtk_menu_popup (GTK_MENU(widget), NULL, NULL, NULL, NULL,
|
||||
bevent->button, bevent->time);
|
||||
/* Tell calling code that we have handled this event; the buck
|
||||
* stops here. */
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/* Tell calling code that we have not handled this event; pass it on. */
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
|
||||
/* Print a string when a menu item is selected */
|
||||
|
||||
static void menuitem_response (gchar *string)
|
||||
{
|
||||
printf("%s\n", string);
|
||||
}
|
151
examples/menu/menufactory.c
Normal file
151
examples/menu/menufactory.c
Normal file
@ -0,0 +1,151 @@
|
||||
/* This file extracted from the GTK tutorial. */
|
||||
|
||||
/* menufactory.c */
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
#include <strings.h>
|
||||
|
||||
#include "mfmain.h"
|
||||
|
||||
|
||||
static void menus_remove_accel(GtkWidget * widget, gchar * signal_name, gchar * path);
|
||||
static gint menus_install_accel(GtkWidget * widget, gchar * signal_name, gchar key, gchar modifiers, gchar * path);
|
||||
void menus_init(void);
|
||||
void menus_create(GtkMenuEntry * entries, int nmenu_entries);
|
||||
|
||||
|
||||
/* this is the GtkMenuEntry structure used to create new menus. The
|
||||
* first member is the menu definition string. The second, the
|
||||
* default accelerator key used to access this menu function with
|
||||
* the keyboard. The third is the callback function to call when
|
||||
* this menu item is selected (by the accelerator key, or with the
|
||||
* mouse.) The last member is the data to pass to your callback function.
|
||||
*/
|
||||
|
||||
static GtkMenuEntry menu_items[] =
|
||||
{
|
||||
{"<Main>/File/New", "<control>N", NULL, NULL},
|
||||
{"<Main>/File/Open", "<control>O", NULL, NULL},
|
||||
{"<Main>/File/Save", "<control>S", NULL, NULL},
|
||||
{"<Main>/File/Save as", NULL, NULL, NULL},
|
||||
{"<Main>/File/<separator>", NULL, NULL, NULL},
|
||||
{"<Main>/File/Quit", "<control>Q", file_quit_cmd_callback, "OK, I'll quit"},
|
||||
{"<Main>/Options/Test", NULL, NULL, NULL}
|
||||
};
|
||||
|
||||
/* calculate the number of menu_item's */
|
||||
static int nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
|
||||
|
||||
static int initialize = TRUE;
|
||||
static GtkMenuFactory *factory = NULL;
|
||||
static GtkMenuFactory *subfactory[1];
|
||||
static GHashTable *entry_ht = NULL;
|
||||
|
||||
void get_main_menu(GtkWidget ** menubar, GtkAcceleratorTable ** table)
|
||||
{
|
||||
if (initialize)
|
||||
menus_init();
|
||||
|
||||
if (menubar)
|
||||
*menubar = subfactory[0]->widget;
|
||||
if (table)
|
||||
*table = subfactory[0]->table;
|
||||
}
|
||||
|
||||
void menus_init(void)
|
||||
{
|
||||
if (initialize) {
|
||||
initialize = FALSE;
|
||||
|
||||
factory = gtk_menu_factory_new(GTK_MENU_FACTORY_MENU_BAR);
|
||||
subfactory[0] = gtk_menu_factory_new(GTK_MENU_FACTORY_MENU_BAR);
|
||||
|
||||
gtk_menu_factory_add_subfactory(factory, subfactory[0], "<Main>");
|
||||
menus_create(menu_items, nmenu_items);
|
||||
}
|
||||
}
|
||||
|
||||
void menus_create(GtkMenuEntry * entries, int nmenu_entries)
|
||||
{
|
||||
char *accelerator;
|
||||
int i;
|
||||
|
||||
if (initialize)
|
||||
menus_init();
|
||||
|
||||
if (entry_ht)
|
||||
for (i = 0; i < nmenu_entries; i++) {
|
||||
accelerator = g_hash_table_lookup(entry_ht, entries[i].path);
|
||||
if (accelerator) {
|
||||
if (accelerator[0] == '\0')
|
||||
entries[i].accelerator = NULL;
|
||||
else
|
||||
entries[i].accelerator = accelerator;
|
||||
}
|
||||
}
|
||||
gtk_menu_factory_add_entries(factory, entries, nmenu_entries);
|
||||
|
||||
for (i = 0; i < nmenu_entries; i++)
|
||||
if (entries[i].widget) {
|
||||
gtk_signal_connect(GTK_OBJECT(entries[i].widget), "install_accelerator",
|
||||
(GtkSignalFunc) menus_install_accel,
|
||||
entries[i].path);
|
||||
gtk_signal_connect(GTK_OBJECT(entries[i].widget), "remove_accelerator",
|
||||
(GtkSignalFunc) menus_remove_accel,
|
||||
entries[i].path);
|
||||
}
|
||||
}
|
||||
|
||||
static gint menus_install_accel(GtkWidget * widget, gchar * signal_name, gchar key, gchar modifiers, gchar * path)
|
||||
{
|
||||
char accel[64];
|
||||
char *t1, t2[2];
|
||||
|
||||
accel[0] = '\0';
|
||||
if (modifiers & GDK_CONTROL_MASK)
|
||||
strcat(accel, "<control>");
|
||||
if (modifiers & GDK_SHIFT_MASK)
|
||||
strcat(accel, "<shift>");
|
||||
if (modifiers & GDK_MOD1_MASK)
|
||||
strcat(accel, "<alt>");
|
||||
|
||||
t2[0] = key;
|
||||
t2[1] = '\0';
|
||||
strcat(accel, t2);
|
||||
|
||||
if (entry_ht) {
|
||||
t1 = g_hash_table_lookup(entry_ht, path);
|
||||
g_free(t1);
|
||||
} else
|
||||
entry_ht = g_hash_table_new(g_str_hash, g_str_equal);
|
||||
|
||||
g_hash_table_insert(entry_ht, path, g_strdup(accel));
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static void menus_remove_accel(GtkWidget * widget, gchar * signal_name, gchar * path)
|
||||
{
|
||||
char *t;
|
||||
|
||||
if (entry_ht) {
|
||||
t = g_hash_table_lookup(entry_ht, path);
|
||||
g_free(t);
|
||||
|
||||
g_hash_table_insert(entry_ht, path, g_strdup(""));
|
||||
}
|
||||
}
|
||||
|
||||
void menus_set_sensitive(char *path, int sensitive)
|
||||
{
|
||||
GtkMenuPath *menu_path;
|
||||
|
||||
if (initialize)
|
||||
menus_init();
|
||||
|
||||
menu_path = gtk_menu_factory_find(factory, path);
|
||||
if (menu_path)
|
||||
gtk_widget_set_sensitive(menu_path->widget, sensitive);
|
||||
else
|
||||
g_warning("Unable to set sensitivity for menu which doesn't exist: %s", path);
|
||||
}
|
19
examples/menu/menufactory.h
Normal file
19
examples/menu/menufactory.h
Normal file
@ -0,0 +1,19 @@
|
||||
/* This file extracted from the GTK tutorial. */
|
||||
|
||||
/* menufactory.h */
|
||||
|
||||
#ifndef __MENUFACTORY_H__
|
||||
#define __MENUFACTORY_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
void get_main_menu (GtkWidget **menubar, GtkAcceleratorTable **table);
|
||||
void menus_create(GtkMenuEntry *entries, int nmenu_entries);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __MENUFACTORY_H__ */
|
52
examples/menu/mfmain.c
Normal file
52
examples/menu/mfmain.c
Normal file
@ -0,0 +1,52 @@
|
||||
/* This file extracted from the GTK tutorial. */
|
||||
|
||||
/* mfmain.c */
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#include "mfmain.h"
|
||||
#include "menufactory.h"
|
||||
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
GtkWidget *window;
|
||||
GtkWidget *main_vbox;
|
||||
GtkWidget *menubar;
|
||||
|
||||
GtkAcceleratorTable *accel;
|
||||
|
||||
gtk_init(&argc, &argv);
|
||||
|
||||
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
||||
gtk_signal_connect(GTK_OBJECT(window), "destroy",
|
||||
GTK_SIGNAL_FUNC(file_quit_cmd_callback),
|
||||
"WM destroy");
|
||||
gtk_window_set_title(GTK_WINDOW(window), "Menu Factory");
|
||||
gtk_widget_set_usize(GTK_WIDGET(window), 300, 200);
|
||||
|
||||
main_vbox = gtk_vbox_new(FALSE, 1);
|
||||
gtk_container_border_width(GTK_CONTAINER(main_vbox), 1);
|
||||
gtk_container_add(GTK_CONTAINER(window), main_vbox);
|
||||
gtk_widget_show(main_vbox);
|
||||
|
||||
get_main_menu(&menubar, &accel);
|
||||
gtk_window_add_accelerator_table(GTK_WINDOW(window), accel);
|
||||
gtk_box_pack_start(GTK_BOX(main_vbox), menubar, FALSE, TRUE, 0);
|
||||
gtk_widget_show(menubar);
|
||||
|
||||
gtk_widget_show(window);
|
||||
gtk_main();
|
||||
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* This is just to demonstrate how callbacks work when using the
|
||||
* menufactory. Often, people put all the callbacks from the menus
|
||||
* in a separate file, and then have them call the appropriate functions
|
||||
* from there. Keeps it more organized. */
|
||||
void file_quit_cmd_callback (GtkWidget *widget, gpointer data)
|
||||
{
|
||||
g_print ("%s\n", (char *) data);
|
||||
gtk_exit(0);
|
||||
}
|
19
examples/menu/mfmain.h
Normal file
19
examples/menu/mfmain.h
Normal file
@ -0,0 +1,19 @@
|
||||
/* This file extracted from the GTK tutorial. */
|
||||
|
||||
/* mfmain.h */
|
||||
|
||||
#ifndef __MFMAIN_H__
|
||||
#define __MFMAIN_H__
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
void file_quit_cmd_callback(GtkWidget *widget, gpointer data);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __MFMAIN_H__ */
|
8
examples/notebook/Makefile
Normal file
8
examples/notebook/Makefile
Normal file
@ -0,0 +1,8 @@
|
||||
|
||||
CC = gcc
|
||||
|
||||
notebook: notebook.c
|
||||
$(CC) `gtk-config --cflags` `gtk-config --libs` notebook.c -o notebook
|
||||
|
||||
clean:
|
||||
rm -f *.o notebook
|
174
examples/notebook/notebook.c
Normal file
174
examples/notebook/notebook.c
Normal file
@ -0,0 +1,174 @@
|
||||
/* This file extracted from the GTK tutorial. */
|
||||
|
||||
/* notebook.c */
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
/* This function rotates the position of the tabs */
|
||||
void rotate_book (GtkButton *button, GtkNotebook *notebook)
|
||||
{
|
||||
gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos +1) %4);
|
||||
}
|
||||
|
||||
/* Add/Remove the page tabs and the borders */
|
||||
void tabsborder_book (GtkButton *button, GtkNotebook *notebook)
|
||||
{
|
||||
gint tval = FALSE;
|
||||
gint bval = FALSE;
|
||||
if (notebook->show_tabs == 0)
|
||||
tval = TRUE;
|
||||
if (notebook->show_border == 0)
|
||||
bval = TRUE;
|
||||
|
||||
gtk_notebook_set_show_tabs (notebook, tval);
|
||||
gtk_notebook_set_show_border (notebook, bval);
|
||||
}
|
||||
|
||||
/* Remove a page from the notebook */
|
||||
void remove_book (GtkButton *button, GtkNotebook *notebook)
|
||||
{
|
||||
gint page;
|
||||
|
||||
page = gtk_notebook_current_page(notebook);
|
||||
gtk_notebook_remove_page (notebook, page);
|
||||
/* Need to refresh the widget --
|
||||
This forces the widget to redraw itself. */
|
||||
gtk_widget_draw(GTK_WIDGET(notebook), NULL);
|
||||
}
|
||||
|
||||
void delete (GtkWidget *widget, gpointer *data)
|
||||
{
|
||||
gtk_main_quit ();
|
||||
}
|
||||
|
||||
int main (int argc, char *argv[])
|
||||
{
|
||||
GtkWidget *window;
|
||||
GtkWidget *button;
|
||||
GtkWidget *table;
|
||||
GtkWidget *notebook;
|
||||
GtkWidget *frame;
|
||||
GtkWidget *label;
|
||||
GtkWidget *checkbutton;
|
||||
int i;
|
||||
char bufferf[32];
|
||||
char bufferl[32];
|
||||
|
||||
gtk_init (&argc, &argv);
|
||||
|
||||
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (window), "delete_event",
|
||||
GTK_SIGNAL_FUNC (delete), NULL);
|
||||
|
||||
gtk_container_border_width (GTK_CONTAINER (window), 10);
|
||||
|
||||
table = gtk_table_new(2,6,TRUE);
|
||||
gtk_container_add (GTK_CONTAINER (window), table);
|
||||
|
||||
/* Create a new notebook, place the position of the tabs */
|
||||
notebook = gtk_notebook_new ();
|
||||
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
|
||||
gtk_table_attach_defaults(GTK_TABLE(table), notebook, 0,6,0,1);
|
||||
gtk_widget_show(notebook);
|
||||
|
||||
/* lets append a bunch of pages to the notebook */
|
||||
for (i=0; i < 5; i++) {
|
||||
sprintf(bufferf, "Append Frame %d", i+1);
|
||||
sprintf(bufferl, "Page %d", i+1);
|
||||
|
||||
frame = gtk_frame_new (bufferf);
|
||||
gtk_container_border_width (GTK_CONTAINER (frame), 10);
|
||||
gtk_widget_set_usize (frame, 100, 75);
|
||||
gtk_widget_show (frame);
|
||||
|
||||
label = gtk_label_new (bufferf);
|
||||
gtk_container_add (GTK_CONTAINER (frame), label);
|
||||
gtk_widget_show (label);
|
||||
|
||||
label = gtk_label_new (bufferl);
|
||||
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), frame, label);
|
||||
}
|
||||
|
||||
|
||||
/* now lets add a page to a specific spot */
|
||||
checkbutton = gtk_check_button_new_with_label ("Check me please!");
|
||||
gtk_widget_set_usize(checkbutton, 100, 75);
|
||||
gtk_widget_show (checkbutton);
|
||||
|
||||
label = gtk_label_new ("Add spot");
|
||||
gtk_container_add (GTK_CONTAINER (checkbutton), label);
|
||||
gtk_widget_show (label);
|
||||
label = gtk_label_new ("Add page");
|
||||
gtk_notebook_insert_page (GTK_NOTEBOOK (notebook), checkbutton, label, 2);
|
||||
|
||||
/* Now finally lets prepend pages to the notebook */
|
||||
for (i=0; i < 5; i++) {
|
||||
sprintf(bufferf, "Prepend Frame %d", i+1);
|
||||
sprintf(bufferl, "PPage %d", i+1);
|
||||
|
||||
frame = gtk_frame_new (bufferf);
|
||||
gtk_container_border_width (GTK_CONTAINER (frame), 10);
|
||||
gtk_widget_set_usize (frame, 100, 75);
|
||||
gtk_widget_show (frame);
|
||||
|
||||
label = gtk_label_new (bufferf);
|
||||
gtk_container_add (GTK_CONTAINER (frame), label);
|
||||
gtk_widget_show (label);
|
||||
|
||||
label = gtk_label_new (bufferl);
|
||||
gtk_notebook_prepend_page (GTK_NOTEBOOK(notebook), frame, label);
|
||||
}
|
||||
|
||||
/* Set what page to start at (page 4) */
|
||||
gtk_notebook_set_page (GTK_NOTEBOOK(notebook), 3);
|
||||
|
||||
|
||||
/* create a bunch of buttons */
|
||||
button = gtk_button_new_with_label ("close");
|
||||
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
|
||||
GTK_SIGNAL_FUNC (delete), NULL);
|
||||
gtk_table_attach_defaults(GTK_TABLE(table), button, 0,1,1,2);
|
||||
gtk_widget_show(button);
|
||||
|
||||
button = gtk_button_new_with_label ("next page");
|
||||
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
|
||||
(GtkSignalFunc) gtk_notebook_next_page,
|
||||
GTK_OBJECT (notebook));
|
||||
gtk_table_attach_defaults(GTK_TABLE(table), button, 1,2,1,2);
|
||||
gtk_widget_show(button);
|
||||
|
||||
button = gtk_button_new_with_label ("prev page");
|
||||
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
|
||||
(GtkSignalFunc) gtk_notebook_prev_page,
|
||||
GTK_OBJECT (notebook));
|
||||
gtk_table_attach_defaults(GTK_TABLE(table), button, 2,3,1,2);
|
||||
gtk_widget_show(button);
|
||||
|
||||
button = gtk_button_new_with_label ("tab position");
|
||||
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
|
||||
(GtkSignalFunc) rotate_book, GTK_OBJECT(notebook));
|
||||
gtk_table_attach_defaults(GTK_TABLE(table), button, 3,4,1,2);
|
||||
gtk_widget_show(button);
|
||||
|
||||
button = gtk_button_new_with_label ("tabs/border on/off");
|
||||
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
|
||||
(GtkSignalFunc) tabsborder_book,
|
||||
GTK_OBJECT (notebook));
|
||||
gtk_table_attach_defaults(GTK_TABLE(table), button, 4,5,1,2);
|
||||
gtk_widget_show(button);
|
||||
|
||||
button = gtk_button_new_with_label ("remove page");
|
||||
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
|
||||
(GtkSignalFunc) remove_book,
|
||||
GTK_OBJECT(notebook));
|
||||
gtk_table_attach_defaults(GTK_TABLE(table), button, 5,6,1,2);
|
||||
gtk_widget_show(button);
|
||||
|
||||
gtk_widget_show(table);
|
||||
gtk_widget_show(window);
|
||||
|
||||
gtk_main ();
|
||||
|
||||
return 0;
|
||||
}
|
8
examples/packbox/Makefile
Normal file
8
examples/packbox/Makefile
Normal file
@ -0,0 +1,8 @@
|
||||
|
||||
CC = gcc
|
||||
|
||||
packbox: packbox.c
|
||||
$(CC) `gtk-config --cflags` `gtk-config --libs` packbox.c -o packbox
|
||||
|
||||
clean:
|
||||
rm -f *.o packbox
|
285
examples/packbox/packbox.c
Normal file
285
examples/packbox/packbox.c
Normal file
@ -0,0 +1,285 @@
|
||||
/* This file extracted from the GTK tutorial. */
|
||||
|
||||
/* packbox.c */
|
||||
|
||||
#include "gtk/gtk.h"
|
||||
|
||||
void
|
||||
delete_event (GtkWidget *widget, gpointer *data)
|
||||
{
|
||||
gtk_main_quit ();
|
||||
}
|
||||
|
||||
/* Make a new hbox filled with button-labels. Arguments for the
|
||||
* variables we're interested are passed in to this function.
|
||||
* We do not show the box, but do show everything inside. */
|
||||
GtkWidget *make_box (gint homogeneous, gint spacing,
|
||||
gint expand, gint fill, gint padding)
|
||||
{
|
||||
GtkWidget *box;
|
||||
GtkWidget *button;
|
||||
char padstr[80];
|
||||
|
||||
/* create a new hbox with the appropriate homogeneous and spacing
|
||||
* settings */
|
||||
box = gtk_hbox_new (homogeneous, spacing);
|
||||
|
||||
/* create a series of buttons with the appropriate settings */
|
||||
button = gtk_button_new_with_label ("gtk_box_pack");
|
||||
gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
|
||||
gtk_widget_show (button);
|
||||
|
||||
button = gtk_button_new_with_label ("(box,");
|
||||
gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
|
||||
gtk_widget_show (button);
|
||||
|
||||
button = gtk_button_new_with_label ("button,");
|
||||
gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
|
||||
gtk_widget_show (button);
|
||||
|
||||
/* create a button with the label depending on the value of
|
||||
* expand. */
|
||||
if (expand == TRUE)
|
||||
button = gtk_button_new_with_label ("TRUE,");
|
||||
else
|
||||
button = gtk_button_new_with_label ("FALSE,");
|
||||
|
||||
gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
|
||||
gtk_widget_show (button);
|
||||
|
||||
/* This is the same as the button creation for "expand"
|
||||
* above, but uses the shorthand form. */
|
||||
button = gtk_button_new_with_label (fill ? "TRUE," : "FALSE,");
|
||||
gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
|
||||
gtk_widget_show (button);
|
||||
|
||||
sprintf (padstr, "%d);", padding);
|
||||
|
||||
button = gtk_button_new_with_label (padstr);
|
||||
gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
|
||||
gtk_widget_show (button);
|
||||
|
||||
return box;
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc, char *argv[])
|
||||
{
|
||||
GtkWidget *window;
|
||||
GtkWidget *button;
|
||||
GtkWidget *box1;
|
||||
GtkWidget *box2;
|
||||
GtkWidget *separator;
|
||||
GtkWidget *label;
|
||||
GtkWidget *quitbox;
|
||||
int which;
|
||||
|
||||
/* Our init, don't forget this! :) */
|
||||
gtk_init (&argc, &argv);
|
||||
|
||||
if (argc != 2) {
|
||||
fprintf (stderr, "usage: packbox num, where num is 1, 2, or 3.\n");
|
||||
/* this just does cleanup in GTK, and exits with an exit status of 1. */
|
||||
gtk_exit (1);
|
||||
}
|
||||
|
||||
which = atoi (argv[1]);
|
||||
|
||||
/* Create our window */
|
||||
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
|
||||
|
||||
/* You should always remember to connect the destroy signal to the
|
||||
* main window. This is very important for proper intuitive
|
||||
* behavior */
|
||||
gtk_signal_connect (GTK_OBJECT (window), "delete_event",
|
||||
GTK_SIGNAL_FUNC (delete_event), NULL);
|
||||
gtk_container_border_width (GTK_CONTAINER (window), 10);
|
||||
|
||||
/* We create a vertical box (vbox) to pack the horizontal boxes into.
|
||||
* This allows us to stack the horizontal boxes filled with buttons one
|
||||
* on top of the other in this vbox. */
|
||||
box1 = gtk_vbox_new (FALSE, 0);
|
||||
|
||||
/* which example to show. These correspond to the pictures above. */
|
||||
switch (which) {
|
||||
case 1:
|
||||
/* create a new label. */
|
||||
label = gtk_label_new ("gtk_hbox_new (FALSE, 0);");
|
||||
|
||||
/* Align the label to the left side. We'll discuss this function and
|
||||
* others in the section on Widget Attributes. */
|
||||
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
|
||||
|
||||
/* Pack the label into the vertical box (vbox box1). Remember that
|
||||
* widgets added to a vbox will be packed one on top of the other in
|
||||
* order. */
|
||||
gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
|
||||
|
||||
/* show the label */
|
||||
gtk_widget_show (label);
|
||||
|
||||
/* call our make box function - homogeneous = FALSE, spacing = 0,
|
||||
* expand = FALSE, fill = FALSE, padding = 0 */
|
||||
box2 = make_box (FALSE, 0, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
|
||||
gtk_widget_show (box2);
|
||||
|
||||
/* call our make box function - homogeneous = FALSE, spacing = 0,
|
||||
* expand = FALSE, fill = FALSE, padding = 0 */
|
||||
box2 = make_box (FALSE, 0, TRUE, FALSE, 0);
|
||||
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
|
||||
gtk_widget_show (box2);
|
||||
|
||||
/* Args are: homogeneous, spacing, expand, fill, padding */
|
||||
box2 = make_box (FALSE, 0, TRUE, TRUE, 0);
|
||||
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
|
||||
gtk_widget_show (box2);
|
||||
|
||||
/* creates a separator, we'll learn more about these later,
|
||||
* but they are quite simple. */
|
||||
separator = gtk_hseparator_new ();
|
||||
|
||||
/* pack the separator into the vbox. Remember each of these
|
||||
* widgets are being packed into a vbox, so they'll be stacked
|
||||
* vertically. */
|
||||
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
|
||||
gtk_widget_show (separator);
|
||||
|
||||
/* create another new label, and show it. */
|
||||
label = gtk_label_new ("gtk_hbox_new (TRUE, 0);");
|
||||
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
|
||||
gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
|
||||
gtk_widget_show (label);
|
||||
|
||||
/* Args are: homogeneous, spacing, expand, fill, padding */
|
||||
box2 = make_box (TRUE, 0, TRUE, FALSE, 0);
|
||||
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
|
||||
gtk_widget_show (box2);
|
||||
|
||||
/* Args are: homogeneous, spacing, expand, fill, padding */
|
||||
box2 = make_box (TRUE, 0, TRUE, TRUE, 0);
|
||||
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
|
||||
gtk_widget_show (box2);
|
||||
|
||||
/* another new separator. */
|
||||
separator = gtk_hseparator_new ();
|
||||
/* The last 3 arguments to gtk_box_pack_start are: expand, fill, padding. */
|
||||
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
|
||||
gtk_widget_show (separator);
|
||||
|
||||
break;
|
||||
|
||||
case 2:
|
||||
|
||||
/* create a new label, remember box1 is a vbox as created
|
||||
* near the beginning of main() */
|
||||
label = gtk_label_new ("gtk_hbox_new (FALSE, 10);");
|
||||
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
|
||||
gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
|
||||
gtk_widget_show (label);
|
||||
|
||||
/* Args are: homogeneous, spacing, expand, fill, padding */
|
||||
box2 = make_box (FALSE, 10, TRUE, FALSE, 0);
|
||||
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
|
||||
gtk_widget_show (box2);
|
||||
|
||||
/* Args are: homogeneous, spacing, expand, fill, padding */
|
||||
box2 = make_box (FALSE, 10, TRUE, TRUE, 0);
|
||||
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
|
||||
gtk_widget_show (box2);
|
||||
|
||||
separator = gtk_hseparator_new ();
|
||||
/* The last 3 arguments to gtk_box_pack_start are: expand, fill, padding. */
|
||||
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
|
||||
gtk_widget_show (separator);
|
||||
|
||||
label = gtk_label_new ("gtk_hbox_new (FALSE, 0);");
|
||||
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
|
||||
gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
|
||||
gtk_widget_show (label);
|
||||
|
||||
/* Args are: homogeneous, spacing, expand, fill, padding */
|
||||
box2 = make_box (FALSE, 0, TRUE, FALSE, 10);
|
||||
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
|
||||
gtk_widget_show (box2);
|
||||
|
||||
/* Args are: homogeneous, spacing, expand, fill, padding */
|
||||
box2 = make_box (FALSE, 0, TRUE, TRUE, 10);
|
||||
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
|
||||
gtk_widget_show (box2);
|
||||
|
||||
separator = gtk_hseparator_new ();
|
||||
/* The last 3 arguments to gtk_box_pack_start are: expand, fill, padding. */
|
||||
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
|
||||
gtk_widget_show (separator);
|
||||
break;
|
||||
|
||||
case 3:
|
||||
|
||||
/* This demonstrates the ability to use gtk_box_pack_end() to
|
||||
* right justify widgets. First, we create a new box as before. */
|
||||
box2 = make_box (FALSE, 0, FALSE, FALSE, 0);
|
||||
/* create the label that will be put at the end. */
|
||||
label = gtk_label_new ("end");
|
||||
/* pack it using gtk_box_pack_end(), so it is put on the right side
|
||||
* of the hbox created in the make_box() call. */
|
||||
gtk_box_pack_end (GTK_BOX (box2), label, FALSE, FALSE, 0);
|
||||
/* show the label. */
|
||||
gtk_widget_show (label);
|
||||
|
||||
/* pack box2 into box1 (the vbox remember ? :) */
|
||||
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
|
||||
gtk_widget_show (box2);
|
||||
|
||||
/* a separator for the bottom. */
|
||||
separator = gtk_hseparator_new ();
|
||||
/* this explicitly sets the separator to 400 pixels wide by 5 pixels
|
||||
* high. This is so the hbox we created will also be 400 pixels wide,
|
||||
* and the "end" label will be separated from the other labels in the
|
||||
* hbox. Otherwise, all the widgets in the hbox would be packed as
|
||||
* close together as possible. */
|
||||
gtk_widget_set_usize (separator, 400, 5);
|
||||
/* pack the separator into the vbox (box1) created near the start
|
||||
* of main() */
|
||||
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
|
||||
gtk_widget_show (separator);
|
||||
}
|
||||
|
||||
/* Create another new hbox.. remember we can use as many as we need! */
|
||||
quitbox = gtk_hbox_new (FALSE, 0);
|
||||
|
||||
/* Our quit button. */
|
||||
button = gtk_button_new_with_label ("Quit");
|
||||
|
||||
/* setup the signal to destroy the window. Remember that this will send
|
||||
* the "destroy" signal to the window which will be caught by our signal
|
||||
* handler as defined above. */
|
||||
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
|
||||
GTK_SIGNAL_FUNC (gtk_main_quit),
|
||||
GTK_OBJECT (window));
|
||||
/* pack the button into the quitbox.
|
||||
* The last 3 arguments to gtk_box_pack_start are: expand, fill, padding. */
|
||||
gtk_box_pack_start (GTK_BOX (quitbox), button, TRUE, FALSE, 0);
|
||||
/* pack the quitbox into the vbox (box1) */
|
||||
gtk_box_pack_start (GTK_BOX (box1), quitbox, FALSE, FALSE, 0);
|
||||
|
||||
/* pack the vbox (box1) which now contains all our widgets, into the
|
||||
* main window. */
|
||||
gtk_container_add (GTK_CONTAINER (window), box1);
|
||||
|
||||
/* and show everything left */
|
||||
gtk_widget_show (button);
|
||||
gtk_widget_show (quitbox);
|
||||
|
||||
gtk_widget_show (box1);
|
||||
/* Showing the window last so everything pops up at once. */
|
||||
gtk_widget_show (window);
|
||||
|
||||
/* And of course, our main function. */
|
||||
gtk_main ();
|
||||
|
||||
/* control returns here when gtk_main_quit() is called, but not when
|
||||
* gtk_exit is used. */
|
||||
|
||||
return 0;
|
||||
}
|
8
examples/pixmap/Makefile
Normal file
8
examples/pixmap/Makefile
Normal file
@ -0,0 +1,8 @@
|
||||
|
||||
CC = gcc
|
||||
|
||||
pixmap: pixmap.c
|
||||
$(CC) `gtk-config --cflags` `gtk-config --libs` pixmap.c -o pixmap
|
||||
|
||||
clean:
|
||||
rm -f *.o pixmap
|
85
examples/pixmap/pixmap.c
Normal file
85
examples/pixmap/pixmap.c
Normal file
@ -0,0 +1,85 @@
|
||||
/* This file extracted from the GTK tutorial. */
|
||||
|
||||
/* pixmap.c */
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
|
||||
/* XPM data of Open-File icon */
|
||||
static const char * xpm_data[] = {
|
||||
"16 16 3 1",
|
||||
" c None",
|
||||
". c #000000000000",
|
||||
"X c #FFFFFFFFFFFF",
|
||||
" ",
|
||||
" ...... ",
|
||||
" .XXX.X. ",
|
||||
" .XXX.XX. ",
|
||||
" .XXX.XXX. ",
|
||||
" .XXX..... ",
|
||||
" .XXXXXXX. ",
|
||||
" .XXXXXXX. ",
|
||||
" .XXXXXXX. ",
|
||||
" .XXXXXXX. ",
|
||||
" .XXXXXXX. ",
|
||||
" .XXXXXXX. ",
|
||||
" .XXXXXXX. ",
|
||||
" ......... ",
|
||||
" ",
|
||||
" "};
|
||||
|
||||
|
||||
/* when invoked (via signal delete_event), terminates the application.
|
||||
*/
|
||||
void close_application( GtkWidget *widget, gpointer *data ) {
|
||||
gtk_main_quit();
|
||||
}
|
||||
|
||||
|
||||
/* is invoked when the button is clicked. It just prints a message.
|
||||
*/
|
||||
void button_clicked( GtkWidget *widget, gpointer *data ) {
|
||||
printf( "button clicked\n" );
|
||||
}
|
||||
|
||||
int main( int argc, char *argv[] )
|
||||
{
|
||||
/* GtkWidget is the storage type for widgets */
|
||||
GtkWidget *window, *pixmapwid, *button;
|
||||
GdkPixmap *pixmap;
|
||||
GdkBitmap *mask;
|
||||
GtkStyle *style;
|
||||
|
||||
/* create the main window, and attach delete_event signal to terminating
|
||||
the application */
|
||||
gtk_init( &argc, &argv );
|
||||
window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
|
||||
gtk_signal_connect( GTK_OBJECT (window), "delete_event",
|
||||
GTK_SIGNAL_FUNC (close_application), NULL );
|
||||
gtk_container_border_width( GTK_CONTAINER (window), 10 );
|
||||
gtk_widget_show( window );
|
||||
|
||||
/* now for the pixmap from gdk */
|
||||
style = gtk_widget_get_style( window );
|
||||
pixmap = gdk_pixmap_create_from_xpm_d( window->window, &mask,
|
||||
&style->bg[GTK_STATE_NORMAL],
|
||||
(gchar **)xpm_data );
|
||||
|
||||
/* a pixmap widget to contain the pixmap */
|
||||
pixmapwid = gtk_pixmap_new( pixmap, mask );
|
||||
gtk_widget_show( pixmapwid );
|
||||
|
||||
/* a button to contain the pixmap widget */
|
||||
button = gtk_button_new();
|
||||
gtk_container_add( GTK_CONTAINER(button), pixmapwid );
|
||||
gtk_container_add( GTK_CONTAINER(window), button );
|
||||
gtk_widget_show( button );
|
||||
|
||||
gtk_signal_connect( GTK_OBJECT(button), "clicked",
|
||||
GTK_SIGNAL_FUNC(button_clicked), NULL );
|
||||
|
||||
/* show the window */
|
||||
gtk_main ();
|
||||
|
||||
return 0;
|
||||
}
|
8
examples/progressbar/Makefile
Normal file
8
examples/progressbar/Makefile
Normal file
@ -0,0 +1,8 @@
|
||||
|
||||
CC = gcc
|
||||
|
||||
progressbar: progressbar.c
|
||||
$(CC) `gtk-config --cflags` `gtk-config --libs` progressbar.c -o progressbar
|
||||
|
||||
clean:
|
||||
rm -f *.o progressbar
|
93
examples/progressbar/progressbar.c
Normal file
93
examples/progressbar/progressbar.c
Normal file
@ -0,0 +1,93 @@
|
||||
/* This file extracted from the GTK tutorial. */
|
||||
|
||||
/* progressbar.c */
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
static int ptimer = 0;
|
||||
int pstat = TRUE;
|
||||
|
||||
/* This function increments and updates the progress bar, it also resets
|
||||
the progress bar if pstat is FALSE */
|
||||
gint progress (gpointer data)
|
||||
{
|
||||
gfloat pvalue;
|
||||
|
||||
/* get the current value of the progress bar */
|
||||
pvalue = GTK_PROGRESS_BAR (data)->percentage;
|
||||
|
||||
if ((pvalue >= 1.0) || (pstat == FALSE)) {
|
||||
pvalue = 0.0;
|
||||
pstat = TRUE;
|
||||
}
|
||||
pvalue += 0.01;
|
||||
|
||||
gtk_progress_bar_update (GTK_PROGRESS_BAR (data), pvalue);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/* This function signals a reset of the progress bar */
|
||||
void progress_r (void)
|
||||
{
|
||||
pstat = FALSE;
|
||||
}
|
||||
|
||||
void destroy (GtkWidget *widget, gpointer *data)
|
||||
{
|
||||
gtk_main_quit ();
|
||||
}
|
||||
|
||||
int main (int argc, char *argv[])
|
||||
{
|
||||
GtkWidget *window;
|
||||
GtkWidget *button;
|
||||
GtkWidget *label;
|
||||
GtkWidget *table;
|
||||
GtkWidget *pbar;
|
||||
|
||||
gtk_init (&argc, &argv);
|
||||
|
||||
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (window), "delete_event",
|
||||
GTK_SIGNAL_FUNC (destroy), NULL);
|
||||
|
||||
gtk_container_border_width (GTK_CONTAINER (window), 10);
|
||||
|
||||
table = gtk_table_new(3,2,TRUE);
|
||||
gtk_container_add (GTK_CONTAINER (window), table);
|
||||
|
||||
label = gtk_label_new ("Progress Bar Example");
|
||||
gtk_table_attach_defaults(GTK_TABLE(table), label, 0,2,0,1);
|
||||
gtk_widget_show(label);
|
||||
|
||||
/* Create a new progress bar, pack it into the table, and show it */
|
||||
pbar = gtk_progress_bar_new ();
|
||||
gtk_table_attach_defaults(GTK_TABLE(table), pbar, 0,2,1,2);
|
||||
gtk_widget_show (pbar);
|
||||
|
||||
/* Set the timeout to handle automatic updating of the progress bar */
|
||||
ptimer = gtk_timeout_add (100, progress, pbar);
|
||||
|
||||
/* This button signals the progress bar to be reset */
|
||||
button = gtk_button_new_with_label ("Reset");
|
||||
gtk_signal_connect (GTK_OBJECT (button), "clicked",
|
||||
GTK_SIGNAL_FUNC (progress_r), NULL);
|
||||
gtk_table_attach_defaults(GTK_TABLE(table), button, 0,1,2,3);
|
||||
gtk_widget_show(button);
|
||||
|
||||
button = gtk_button_new_with_label ("Cancel");
|
||||
gtk_signal_connect (GTK_OBJECT (button), "clicked",
|
||||
GTK_SIGNAL_FUNC (destroy), NULL);
|
||||
|
||||
gtk_table_attach_defaults(GTK_TABLE(table), button, 1,2,2,3);
|
||||
gtk_widget_show (button);
|
||||
|
||||
gtk_widget_show(table);
|
||||
gtk_widget_show(window);
|
||||
|
||||
gtk_main ();
|
||||
|
||||
return 0;
|
||||
}
|
8
examples/radiobuttons/Makefile
Normal file
8
examples/radiobuttons/Makefile
Normal file
@ -0,0 +1,8 @@
|
||||
|
||||
CC = gcc
|
||||
|
||||
radiobuttons: radiobuttons.c
|
||||
$(CC) `gtk-config --cflags` `gtk-config --libs` radiobuttons.c -o radiobuttons
|
||||
|
||||
clean:
|
||||
rm -f *.o radiobuttons
|
76
examples/radiobuttons/radiobuttons.c
Normal file
76
examples/radiobuttons/radiobuttons.c
Normal file
@ -0,0 +1,76 @@
|
||||
/* This file extracted from the GTK tutorial. */
|
||||
|
||||
/* radiobuttons.c */
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
#include <glib.h>
|
||||
|
||||
void close_application( GtkWidget *widget, gpointer *data ) {
|
||||
gtk_main_quit();
|
||||
}
|
||||
|
||||
int main(int argc,char *argv[])
|
||||
{
|
||||
static GtkWidget *window = NULL;
|
||||
GtkWidget *box1;
|
||||
GtkWidget *box2;
|
||||
GtkWidget *button;
|
||||
GtkWidget *separator;
|
||||
GSList *group;
|
||||
|
||||
gtk_init(&argc,&argv);
|
||||
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (window), "delete_event",
|
||||
GTK_SIGNAL_FUNC(close_application),
|
||||
NULL);
|
||||
|
||||
gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
|
||||
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);
|
||||
|
||||
button = gtk_radio_button_new_with_label (NULL, "button1");
|
||||
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
|
||||
gtk_widget_show (button);
|
||||
|
||||
group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
|
||||
button = gtk_radio_button_new_with_label(group, "button2");
|
||||
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
|
||||
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
|
||||
gtk_widget_show (button);
|
||||
|
||||
group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
|
||||
button = gtk_radio_button_new_with_label(group, "button3");
|
||||
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
|
||||
gtk_widget_show (button);
|
||||
|
||||
separator = gtk_hseparator_new ();
|
||||
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
|
||||
gtk_widget_show (separator);
|
||||
|
||||
box2 = gtk_vbox_new (FALSE, 10);
|
||||
gtk_container_border_width (GTK_CONTAINER (box2), 10);
|
||||
gtk_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(close_application),
|
||||
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 (window);
|
||||
|
||||
gtk_main();
|
||||
return(0);
|
||||
}
|
8
examples/rulers/Makefile
Normal file
8
examples/rulers/Makefile
Normal file
@ -0,0 +1,8 @@
|
||||
|
||||
CC = gcc
|
||||
|
||||
rulers: rulers.c
|
||||
$(CC) `gtk-config --cflags` `gtk-config --libs` rulers.c -o rulers
|
||||
|
||||
clean:
|
||||
rm -f *.o rulers
|
75
examples/rulers/rulers.c
Normal file
75
examples/rulers/rulers.c
Normal file
@ -0,0 +1,75 @@
|
||||
/* This file extracted from the GTK tutorial. */
|
||||
|
||||
/* rulers.c */
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
#define EVENT_METHOD(i, x) GTK_WIDGET_CLASS(GTK_OBJECT(i)->klass)->x
|
||||
|
||||
#define XSIZE 600
|
||||
#define YSIZE 400
|
||||
|
||||
/* this routine gets control when the close button is clicked
|
||||
*/
|
||||
void close_application( GtkWidget *widget, gpointer *data ) {
|
||||
gtk_main_quit();
|
||||
}
|
||||
|
||||
|
||||
/* the main routine
|
||||
*/
|
||||
int main( int argc, char *argv[] ) {
|
||||
GtkWidget *window, *table, *area, *hrule, *vrule;
|
||||
|
||||
/* initialize gtk and create the main window */
|
||||
gtk_init( &argc, &argv );
|
||||
|
||||
window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
|
||||
gtk_signal_connect (GTK_OBJECT (window), "delete_event",
|
||||
GTK_SIGNAL_FUNC( close_application ), NULL);
|
||||
gtk_container_border_width (GTK_CONTAINER (window), 10);
|
||||
|
||||
/* create a table for placing the ruler and the drawing area */
|
||||
table = gtk_table_new( 3, 2, FALSE );
|
||||
gtk_container_add( GTK_CONTAINER(window), table );
|
||||
|
||||
area = gtk_drawing_area_new();
|
||||
gtk_drawing_area_size( (GtkDrawingArea *)area, XSIZE, YSIZE );
|
||||
gtk_table_attach( GTK_TABLE(table), area, 1, 2, 1, 2,
|
||||
GTK_EXPAND|GTK_FILL, GTK_FILL, 0, 0 );
|
||||
gtk_widget_set_events( area, GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK );
|
||||
|
||||
/* The horizontal ruler goes on top. As the mouse moves across the drawing area,
|
||||
a motion_notify_event is passed to the appropriate event handler for the ruler. */
|
||||
hrule = gtk_hruler_new();
|
||||
gtk_ruler_set_metric( GTK_RULER(hrule), GTK_PIXELS );
|
||||
gtk_ruler_set_range( GTK_RULER(hrule), 7, 13, 0, 20 );
|
||||
gtk_signal_connect_object( GTK_OBJECT(area), "motion_notify_event",
|
||||
(GtkSignalFunc)EVENT_METHOD(hrule, motion_notify_event),
|
||||
GTK_OBJECT(hrule) );
|
||||
/* GTK_WIDGET_CLASS(GTK_OBJECT(hrule)->klass)->motion_notify_event, */
|
||||
gtk_table_attach( GTK_TABLE(table), hrule, 1, 2, 0, 1,
|
||||
GTK_EXPAND|GTK_SHRINK|GTK_FILL, GTK_FILL, 0, 0 );
|
||||
|
||||
/* The vertical ruler goes on the left. As the mouse moves across the drawing area,
|
||||
a motion_notify_event is passed to the appropriate event handler for the ruler. */
|
||||
vrule = gtk_vruler_new();
|
||||
gtk_ruler_set_metric( GTK_RULER(vrule), GTK_PIXELS );
|
||||
gtk_ruler_set_range( GTK_RULER(vrule), 0, YSIZE, 10, YSIZE );
|
||||
gtk_signal_connect_object( GTK_OBJECT(area), "motion_notify_event",
|
||||
(GtkSignalFunc)
|
||||
GTK_WIDGET_CLASS(GTK_OBJECT(vrule)->klass)->motion_notify_event,
|
||||
GTK_OBJECT(vrule) );
|
||||
gtk_table_attach( GTK_TABLE(table), vrule, 0, 1, 1, 2,
|
||||
GTK_FILL, GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0 );
|
||||
|
||||
/* now show everything */
|
||||
gtk_widget_show( area );
|
||||
gtk_widget_show( hrule );
|
||||
gtk_widget_show( vrule );
|
||||
gtk_widget_show( table );
|
||||
gtk_widget_show( window );
|
||||
gtk_main();
|
||||
|
||||
return 0;
|
||||
}
|
8
examples/scrolledwin/Makefile
Normal file
8
examples/scrolledwin/Makefile
Normal file
@ -0,0 +1,8 @@
|
||||
|
||||
CC = gcc
|
||||
|
||||
scrolledwin: scrolledwin.c
|
||||
$(CC) `gtk-config --cflags` `gtk-config --libs` scrolledwin.c -o scrolledwin
|
||||
|
||||
clean:
|
||||
rm -f *.o scrolledwin
|
94
examples/scrolledwin/scrolledwin.c
Normal file
94
examples/scrolledwin/scrolledwin.c
Normal file
@ -0,0 +1,94 @@
|
||||
/* This file extracted from the GTK tutorial. */
|
||||
|
||||
/* scrolledwin.c */
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
void destroy(GtkWidget *widget, gpointer *data)
|
||||
{
|
||||
gtk_main_quit();
|
||||
}
|
||||
|
||||
int main (int argc, char *argv[])
|
||||
{
|
||||
static GtkWidget *window;
|
||||
GtkWidget *scrolled_window;
|
||||
GtkWidget *table;
|
||||
GtkWidget *button;
|
||||
char buffer[32];
|
||||
int i, j;
|
||||
|
||||
gtk_init (&argc, &argv);
|
||||
|
||||
/* Create a new dialog window for the scrolled window to be
|
||||
* packed into. A dialog is just like a normal window except it has a
|
||||
* vbox and a horizontal seperator packed into it. It's just a shortcut
|
||||
* for creating dialogs */
|
||||
window = gtk_dialog_new ();
|
||||
gtk_signal_connect (GTK_OBJECT (window), "destroy",
|
||||
(GtkSignalFunc) destroy, NULL);
|
||||
gtk_window_set_title (GTK_WINDOW (window), "dialog");
|
||||
gtk_container_border_width (GTK_CONTAINER (window), 0);
|
||||
gtk_widget_set_usize(window, 300, 300);
|
||||
|
||||
/* create a new scrolled window. */
|
||||
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
|
||||
|
||||
gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
|
||||
|
||||
/* the policy is one of GTK_POLICY AUTOMATIC, or GTK_POLICY_ALWAYS.
|
||||
* GTK_POLICY_AUTOMATIC will automatically decide whether you need
|
||||
* scrollbars, wheras GTK_POLICY_ALWAYS will always leave the scrollbars
|
||||
* there. The first one is the horizontal scrollbar, the second,
|
||||
* the vertical. */
|
||||
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
|
||||
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
|
||||
/* The dialog window is created with a vbox packed into it. */
|
||||
gtk_box_pack_start (GTK_BOX (GTK_DIALOG(window)->vbox), scrolled_window,
|
||||
TRUE, TRUE, 0);
|
||||
gtk_widget_show (scrolled_window);
|
||||
|
||||
/* create a table of 10 by 10 squares. */
|
||||
table = gtk_table_new (10, 10, FALSE);
|
||||
|
||||
/* set the spacing to 10 on x and 10 on y */
|
||||
gtk_table_set_row_spacings (GTK_TABLE (table), 10);
|
||||
gtk_table_set_col_spacings (GTK_TABLE (table), 10);
|
||||
|
||||
/* pack the table into the scrolled window */
|
||||
gtk_container_add (GTK_CONTAINER (scrolled_window), table);
|
||||
gtk_widget_show (table);
|
||||
|
||||
/* this simply creates a grid of toggle buttons on the table
|
||||
* to demonstrate the scrolled window. */
|
||||
for (i = 0; i < 10; i++)
|
||||
for (j = 0; j < 10; j++) {
|
||||
sprintf (buffer, "button (%d,%d)\n", i, j);
|
||||
button = gtk_toggle_button_new_with_label (buffer);
|
||||
gtk_table_attach_defaults (GTK_TABLE (table), button,
|
||||
i, i+1, j, j+1);
|
||||
gtk_widget_show (button);
|
||||
}
|
||||
|
||||
/* Add a "close" button to the bottom of the dialog */
|
||||
button = gtk_button_new_with_label ("close");
|
||||
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
|
||||
(GtkSignalFunc) gtk_widget_destroy,
|
||||
GTK_OBJECT (window));
|
||||
|
||||
/* this makes it so the button is the default. */
|
||||
|
||||
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
|
||||
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0);
|
||||
|
||||
/* This grabs this button to be the default button. Simply hitting
|
||||
* the "Enter" key will cause this button to activate. */
|
||||
gtk_widget_grab_default (button);
|
||||
gtk_widget_show (button);
|
||||
|
||||
gtk_widget_show (window);
|
||||
|
||||
gtk_main();
|
||||
|
||||
return(0);
|
||||
}
|
13
examples/selection/Makefile
Normal file
13
examples/selection/Makefile
Normal file
@ -0,0 +1,13 @@
|
||||
|
||||
CC = gcc
|
||||
|
||||
all: gettargets setselection
|
||||
|
||||
gettargets: gettargets.c
|
||||
$(CC) `gtk-config --cflags` `gtk-config --libs` gettargets.c -o gettargets
|
||||
|
||||
setselection: setselection.c
|
||||
$(CC) `gtk-config --cflags` `gtk-config --libs` setselection.c -o setselection
|
||||
|
||||
clean:
|
||||
rm -f *.o gettargets setselection
|
98
examples/selection/gettargets.c
Normal file
98
examples/selection/gettargets.c
Normal file
@ -0,0 +1,98 @@
|
||||
/* This file extracted from the GTK tutorial. */
|
||||
|
||||
/* gettargets.c */
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
void selection_received (GtkWidget *widget,
|
||||
GtkSelectionData *selection_data,
|
||||
gpointer data);
|
||||
|
||||
/* Signal handler invoked when user clicks on the "Get Targets" button */
|
||||
void
|
||||
get_targets (GtkWidget *widget, gpointer data)
|
||||
{
|
||||
static GdkAtom targets_atom = GDK_NONE;
|
||||
|
||||
/* Get the atom corresonding to the string "TARGETS" */
|
||||
if (targets_atom == GDK_NONE)
|
||||
targets_atom = gdk_atom_intern ("TARGETS", FALSE);
|
||||
|
||||
/* And request the "TARGETS" target for the primary selection */
|
||||
gtk_selection_convert (widget, GDK_SELECTION_PRIMARY, targets_atom,
|
||||
GDK_CURRENT_TIME);
|
||||
}
|
||||
|
||||
/* Signal handler called when the selections owner returns the data */
|
||||
void
|
||||
selection_received (GtkWidget *widget, GtkSelectionData *selection_data,
|
||||
gpointer data)
|
||||
{
|
||||
GdkAtom *atoms;
|
||||
GList *item_list;
|
||||
int i;
|
||||
|
||||
/* **** IMPORTANT **** Check to see if retrieval succeeded */
|
||||
if (selection_data->length < 0)
|
||||
{
|
||||
g_print ("Selection retrieval failed\n");
|
||||
return;
|
||||
}
|
||||
/* Make sure we got the data in the expected form */
|
||||
if (selection_data->type != GDK_SELECTION_TYPE_ATOM)
|
||||
{
|
||||
g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
|
||||
return;
|
||||
}
|
||||
|
||||
/* Print out the atoms we received */
|
||||
atoms = (GdkAtom *)selection_data->data;
|
||||
|
||||
item_list = NULL;
|
||||
for (i=0; i<selection_data->length/sizeof(GdkAtom); i++)
|
||||
{
|
||||
char *name;
|
||||
name = gdk_atom_name (atoms[i]);
|
||||
if (name != NULL)
|
||||
g_print ("%s\n",name);
|
||||
else
|
||||
g_print ("(bad atom)\n");
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc, char *argv[])
|
||||
{
|
||||
GtkWidget *window;
|
||||
GtkWidget *button;
|
||||
|
||||
gtk_init (&argc, &argv);
|
||||
|
||||
/* Create the toplevel window */
|
||||
|
||||
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
|
||||
gtk_window_set_title (GTK_WINDOW (window), "Event Box");
|
||||
gtk_container_border_width (GTK_CONTAINER (window), 10);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (window), "destroy",
|
||||
GTK_SIGNAL_FUNC (gtk_exit), NULL);
|
||||
|
||||
/* Create a button the user can click to get targets */
|
||||
|
||||
button = gtk_button_new_with_label ("Get Targets");
|
||||
gtk_container_add (GTK_CONTAINER (window), button);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT(button), "clicked",
|
||||
GTK_SIGNAL_FUNC (get_targets), NULL);
|
||||
gtk_signal_connect (GTK_OBJECT(button), "selection_received",
|
||||
GTK_SIGNAL_FUNC (selection_received), NULL);
|
||||
|
||||
gtk_widget_show (button);
|
||||
gtk_widget_show (window);
|
||||
|
||||
gtk_main ();
|
||||
|
||||
return 0;
|
||||
}
|
106
examples/selection/setselection.c
Normal file
106
examples/selection/setselection.c
Normal file
@ -0,0 +1,106 @@
|
||||
/* This file extracted from the GTK tutorial. */
|
||||
|
||||
/* setselection.c */
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
#include <time.h>
|
||||
|
||||
/* Callback when the user toggles the selection */
|
||||
void
|
||||
selection_toggled (GtkWidget *widget, gint *have_selection)
|
||||
{
|
||||
if (GTK_TOGGLE_BUTTON(widget)->active)
|
||||
{
|
||||
*have_selection = gtk_selection_owner_set (widget,
|
||||
GDK_SELECTION_PRIMARY,
|
||||
GDK_CURRENT_TIME);
|
||||
/* if claiming the selection failed, we return the button to
|
||||
the out state */
|
||||
if (!*have_selection)
|
||||
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON(widget), FALSE);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (*have_selection)
|
||||
{
|
||||
/* Before clearing the selection by setting the owner to NULL,
|
||||
we check if we are the actual owner */
|
||||
if (gdk_selection_owner_get (GDK_SELECTION_PRIMARY) == widget->window)
|
||||
gtk_selection_owner_set (NULL, GDK_SELECTION_PRIMARY,
|
||||
GDK_CURRENT_TIME);
|
||||
*have_selection = FALSE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Called when another application claims the selection */
|
||||
gint
|
||||
selection_clear (GtkWidget *widget, GdkEventSelection *event,
|
||||
gint *have_selection)
|
||||
{
|
||||
*have_selection = FALSE;
|
||||
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON(widget), FALSE);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/* Supplies the current time as the selection. */
|
||||
void
|
||||
selection_handle (GtkWidget *widget,
|
||||
GtkSelectionData *selection_data,
|
||||
gpointer data)
|
||||
{
|
||||
gchar *timestr;
|
||||
time_t current_time;
|
||||
|
||||
current_time = time (NULL);
|
||||
timestr = asctime (localtime(¤t_time));
|
||||
/* When we return a single string, it should not be null terminated.
|
||||
That will be done for us */
|
||||
|
||||
gtk_selection_data_set (selection_data, GDK_SELECTION_TYPE_STRING,
|
||||
8, timestr, strlen(timestr));
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc, char *argv[])
|
||||
{
|
||||
GtkWidget *window;
|
||||
|
||||
GtkWidget *selection_button;
|
||||
|
||||
static int have_selection = FALSE;
|
||||
|
||||
gtk_init (&argc, &argv);
|
||||
|
||||
/* Create the toplevel window */
|
||||
|
||||
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
|
||||
gtk_window_set_title (GTK_WINDOW (window), "Event Box");
|
||||
gtk_container_border_width (GTK_CONTAINER (window), 10);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT (window), "destroy",
|
||||
GTK_SIGNAL_FUNC (gtk_exit), NULL);
|
||||
|
||||
/* Create a toggle button to act as the selection */
|
||||
|
||||
selection_button = gtk_toggle_button_new_with_label ("Claim Selection");
|
||||
gtk_container_add (GTK_CONTAINER (window), selection_button);
|
||||
gtk_widget_show (selection_button);
|
||||
|
||||
gtk_signal_connect (GTK_OBJECT(selection_button), "toggled",
|
||||
GTK_SIGNAL_FUNC (selection_toggled), &have_selection);
|
||||
gtk_signal_connect (GTK_OBJECT(selection_button), "selection_clear_event",
|
||||
GTK_SIGNAL_FUNC (selection_clear), &have_selection);
|
||||
|
||||
gtk_selection_add_handler (selection_button, GDK_SELECTION_PRIMARY,
|
||||
GDK_SELECTION_TYPE_STRING,
|
||||
selection_handle, NULL);
|
||||
|
||||
gtk_widget_show (selection_button);
|
||||
gtk_widget_show (window);
|
||||
|
||||
gtk_main ();
|
||||
|
||||
return 0;
|
||||
}
|
8
examples/statusbar/Makefile
Normal file
8
examples/statusbar/Makefile
Normal file
@ -0,0 +1,8 @@
|
||||
|
||||
CC = gcc
|
||||
|
||||
statusbar: statusbar.c
|
||||
$(CC) `gtk-config --cflags` `gtk-config --libs` statusbar.c -o statusbar
|
||||
|
||||
clean:
|
||||
rm -f *.o statusbar
|
74
examples/statusbar/statusbar.c
Normal file
74
examples/statusbar/statusbar.c
Normal file
@ -0,0 +1,74 @@
|
||||
/* This file extracted from the GTK tutorial. */
|
||||
|
||||
/* statusbar.c (Tony Gale) */
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
#include <glib.h>
|
||||
|
||||
GtkWidget *status_bar;
|
||||
|
||||
void push_item (GtkWidget *widget, gpointer *data)
|
||||
{
|
||||
static int count = 1;
|
||||
char buff[20];
|
||||
|
||||
g_snprintf(buff, 20, "Item %d", count++);
|
||||
gtk_statusbar_push( GTK_STATUSBAR(status_bar), (guint) &data, buff);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
void pop_item (GtkWidget *widget, gpointer *data)
|
||||
{
|
||||
gtk_statusbar_pop( GTK_STATUSBAR(status_bar), (guint) &data );
|
||||
return;
|
||||
}
|
||||
|
||||
int main (int argc, char *argv[])
|
||||
{
|
||||
|
||||
GtkWidget *window;
|
||||
GtkWidget *vbox;
|
||||
GtkWidget *button;
|
||||
|
||||
int context_id;
|
||||
|
||||
gtk_init (&argc, &argv);
|
||||
|
||||
/* create a new window */
|
||||
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
||||
gtk_widget_set_usize( GTK_WIDGET (window), 200, 100);
|
||||
gtk_window_set_title(GTK_WINDOW (window), "GTK Statusbar Example");
|
||||
gtk_signal_connect(GTK_OBJECT (window), "delete_event",
|
||||
(GtkSignalFunc) gtk_exit, NULL);
|
||||
|
||||
vbox = gtk_vbox_new(FALSE, 1);
|
||||
gtk_container_add(GTK_CONTAINER(window), vbox);
|
||||
gtk_widget_show(vbox);
|
||||
|
||||
status_bar = gtk_statusbar_new();
|
||||
gtk_box_pack_start (GTK_BOX (vbox), status_bar, TRUE, TRUE, 0);
|
||||
gtk_widget_show (status_bar);
|
||||
|
||||
context_id = gtk_statusbar_get_context_id( GTK_STATUSBAR(status_bar), "Statusbar example");
|
||||
|
||||
button = gtk_button_new_with_label("push item");
|
||||
gtk_signal_connect(GTK_OBJECT(button), "clicked",
|
||||
GTK_SIGNAL_FUNC (push_item), &context_id);
|
||||
gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 2);
|
||||
gtk_widget_show(button);
|
||||
|
||||
button = gtk_button_new_with_label("pop last item");
|
||||
gtk_signal_connect(GTK_OBJECT(button), "clicked",
|
||||
GTK_SIGNAL_FUNC (pop_item), &context_id);
|
||||
gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 2);
|
||||
gtk_widget_show(button);
|
||||
|
||||
/* always display the window as the last step so it all splashes on
|
||||
* the screen at once. */
|
||||
gtk_widget_show(window);
|
||||
|
||||
gtk_main ();
|
||||
|
||||
return 0;
|
||||
}
|
8
examples/table/Makefile
Normal file
8
examples/table/Makefile
Normal file
@ -0,0 +1,8 @@
|
||||
|
||||
CC = gcc
|
||||
|
||||
table: table.c
|
||||
$(CC) `gtk-config --cflags` `gtk-config --libs` table.c -o table
|
||||
|
||||
clean:
|
||||
rm -f *.o table
|
94
examples/table/table.c
Normal file
94
examples/table/table.c
Normal file
@ -0,0 +1,94 @@
|
||||
/* This file extracted from the GTK tutorial. */
|
||||
|
||||
/* table.c */
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
/* our callback.
|
||||
* the data passed to this function is printed to stdout */
|
||||
void callback (GtkWidget *widget, gpointer *data)
|
||||
{
|
||||
g_print ("Hello again - %s was pressed\n", (char *) data);
|
||||
}
|
||||
|
||||
/* this callback quits the program */
|
||||
void delete_event (GtkWidget *widget, gpointer *data)
|
||||
{
|
||||
gtk_main_quit ();
|
||||
}
|
||||
|
||||
int main (int argc, char *argv[])
|
||||
{
|
||||
GtkWidget *window;
|
||||
GtkWidget *button;
|
||||
GtkWidget *table;
|
||||
|
||||
gtk_init (&argc, &argv);
|
||||
|
||||
/* create a new window */
|
||||
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
|
||||
|
||||
/* set the window title */
|
||||
gtk_window_set_title (GTK_WINDOW (window), "Table");
|
||||
|
||||
/* set a handler for delete_event that immediately
|
||||
* exits GTK. */
|
||||
gtk_signal_connect (GTK_OBJECT (window), "delete_event",
|
||||
GTK_SIGNAL_FUNC (delete_event), NULL);
|
||||
|
||||
/* sets the border width of the window. */
|
||||
gtk_container_border_width (GTK_CONTAINER (window), 20);
|
||||
|
||||
/* create a 2x2 table */
|
||||
table = gtk_table_new (2, 2, TRUE);
|
||||
|
||||
/* put the table in the main window */
|
||||
gtk_container_add (GTK_CONTAINER (window), table);
|
||||
|
||||
/* create first button */
|
||||
button = gtk_button_new_with_label ("button 1");
|
||||
|
||||
/* when the button is clicked, we call the "callback" function
|
||||
* with a pointer to "button 1" as it's argument */
|
||||
gtk_signal_connect (GTK_OBJECT (button), "clicked",
|
||||
GTK_SIGNAL_FUNC (callback), (gpointer) "button 1");
|
||||
|
||||
|
||||
/* insert button 1 into the upper left quadrant of the table */
|
||||
gtk_table_attach_defaults (GTK_TABLE(table), button, 0, 1, 0, 1);
|
||||
|
||||
gtk_widget_show (button);
|
||||
|
||||
/* create second button */
|
||||
|
||||
button = gtk_button_new_with_label ("button 2");
|
||||
|
||||
/* when the button is clicked, we call the "callback" function
|
||||
* with a pointer to "button 2" as it's argument */
|
||||
gtk_signal_connect (GTK_OBJECT (button), "clicked",
|
||||
GTK_SIGNAL_FUNC (callback), (gpointer) "button 2");
|
||||
/* insert button 2 into the upper right quadrant of the table */
|
||||
gtk_table_attach_defaults (GTK_TABLE(table), button, 1, 2, 0, 1);
|
||||
|
||||
gtk_widget_show (button);
|
||||
|
||||
/* create "Quit" button */
|
||||
button = gtk_button_new_with_label ("Quit");
|
||||
|
||||
/* when the button is clicked, we call the "delete_event" function
|
||||
* and the program exits */
|
||||
gtk_signal_connect (GTK_OBJECT (button), "clicked",
|
||||
GTK_SIGNAL_FUNC (delete_event), NULL);
|
||||
|
||||
/* insert the quit button into the both
|
||||
* lower quadrants of the table */
|
||||
gtk_table_attach_defaults (GTK_TABLE(table), button, 0, 2, 1, 2);
|
||||
|
||||
gtk_widget_show (button);
|
||||
|
||||
gtk_widget_show (table);
|
||||
gtk_widget_show (window);
|
||||
|
||||
gtk_main ();
|
||||
|
||||
return 0;
|
||||
}
|
8
examples/wheelbarrow/Makefile
Normal file
8
examples/wheelbarrow/Makefile
Normal file
@ -0,0 +1,8 @@
|
||||
|
||||
CC = gcc
|
||||
|
||||
wheelbarrow: wheelbarrow.c
|
||||
$(CC) `gtk-config --cflags` `gtk-config --libs` wheelbarrow.c -o wheelbarrow
|
||||
|
||||
clean:
|
||||
rm -f *.o wheelbarrow
|
173
examples/wheelbarrow/wheelbarrow.c
Normal file
173
examples/wheelbarrow/wheelbarrow.c
Normal file
@ -0,0 +1,173 @@
|
||||
/* This file extracted from the GTK tutorial. */
|
||||
|
||||
/* wheelbarrow.c */
|
||||
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
/* XPM */
|
||||
static char * WheelbarrowFull_xpm[] = {
|
||||
"48 48 64 1",
|
||||
" c None",
|
||||
". c #DF7DCF3CC71B",
|
||||
"X c #965875D669A6",
|
||||
"o c #71C671C671C6",
|
||||
"O c #A699A289A699",
|
||||
"+ c #965892489658",
|
||||
"@ c #8E38410330C2",
|
||||
"# c #D75C7DF769A6",
|
||||
"$ c #F7DECF3CC71B",
|
||||
"% c #96588A288E38",
|
||||
"& c #A69992489E79",
|
||||
"* c #8E3886178E38",
|
||||
"= c #104008200820",
|
||||
"- c #596510401040",
|
||||
"; c #C71B30C230C2",
|
||||
": c #C71B9A699658",
|
||||
"> c #618561856185",
|
||||
", c #20811C712081",
|
||||
"< c #104000000000",
|
||||
"1 c #861720812081",
|
||||
"2 c #DF7D4D344103",
|
||||
"3 c #79E769A671C6",
|
||||
"4 c #861782078617",
|
||||
"5 c #41033CF34103",
|
||||
"6 c #000000000000",
|
||||
"7 c #49241C711040",
|
||||
"8 c #492445144924",
|
||||
"9 c #082008200820",
|
||||
"0 c #69A618611861",
|
||||
"q c #B6DA71C65144",
|
||||
"w c #410330C238E3",
|
||||
"e c #CF3CBAEAB6DA",
|
||||
"r c #71C6451430C2",
|
||||
"t c #EFBEDB6CD75C",
|
||||
"y c #28A208200820",
|
||||
"u c #186110401040",
|
||||
"i c #596528A21861",
|
||||
"p c #71C661855965",
|
||||
"a c #A69996589658",
|
||||
"s c #30C228A230C2",
|
||||
"d c #BEFBA289AEBA",
|
||||
"f c #596545145144",
|
||||
"g c #30C230C230C2",
|
||||
"h c #8E3882078617",
|
||||
"j c #208118612081",
|
||||
"k c #38E30C300820",
|
||||
"l c #30C2208128A2",
|
||||
"z c #38E328A238E3",
|
||||
"x c #514438E34924",
|
||||
"c c #618555555965",
|
||||
"v c #30C2208130C2",
|
||||
"b c #38E328A230C2",
|
||||
"n c #28A228A228A2",
|
||||
"m c #41032CB228A2",
|
||||
"M c #104010401040",
|
||||
"N c #492438E34103",
|
||||
"B c #28A2208128A2",
|
||||
"V c #A699596538E3",
|
||||
"C c #30C21C711040",
|
||||
"Z c #30C218611040",
|
||||
"A c #965865955965",
|
||||
"S c #618534D32081",
|
||||
"D c #38E31C711040",
|
||||
"F c #082000000820",
|
||||
" ",
|
||||
" .XoO ",
|
||||
" +@#$%o& ",
|
||||
" *=-;#::o+ ",
|
||||
" >,<12#:34 ",
|
||||
" 45671#:X3 ",
|
||||
" +89<02qwo ",
|
||||
"e* >,67;ro ",
|
||||
"ty> 459@>+&& ",
|
||||
"$2u+ ><ipas8* ",
|
||||
"%$;=* *3:.Xa.dfg> ",
|
||||
"Oh$;ya *3d.a8j,Xe.d3g8+ ",
|
||||
" Oh$;ka *3d$a8lz,,xxc:.e3g54 ",
|
||||
" Oh$;kO *pd$%svbzz,sxxxxfX..&wn> ",
|
||||
" Oh$@mO *3dthwlsslszjzxxxxxxx3:td8M4 ",
|
||||
" Oh$@g& *3d$XNlvvvlllm,mNwxxxxxxxfa.:,B* ",
|
||||
" Oh$@,Od.czlllllzlmmqV@V#V@fxxxxxxxf:%j5& ",
|
||||
" Oh$1hd5lllslllCCZrV#r#:#2AxxxxxxxxxcdwM* ",
|
||||
" OXq6c.%8vvvllZZiqqApA:mq:Xxcpcxxxxxfdc9* ",
|
||||
" 2r<6gde3bllZZrVi7S@SV77A::qApxxxxxxfdcM ",
|
||||
" :,q-6MN.dfmZZrrSS:#riirDSAX@Af5xxxxxfevo",
|
||||
" +A26jguXtAZZZC7iDiCCrVVii7Cmmmxxxxxx%3g",
|
||||
" *#16jszN..3DZZZZrCVSA2rZrV7Dmmwxxxx&en",
|
||||
" p2yFvzssXe:fCZZCiiD7iiZDiDSSZwwxx8e*>",
|
||||
" OA1<jzxwwc:$d%NDZZZZCCCZCCZZCmxxfd.B ",
|
||||
" 3206Bwxxszx%et.eaAp77m77mmmf3&eeeg* ",
|
||||
" @26MvzxNzvlbwfpdettttttttttt.c,n& ",
|
||||
" *;16=lsNwwNwgsvslbwwvccc3pcfu<o ",
|
||||
" p;<69BvwwsszslllbBlllllllu<5+ ",
|
||||
" OS0y6FBlvvvzvzss,u=Blllj=54 ",
|
||||
" c1-699Blvlllllu7k96MMMg4 ",
|
||||
" *10y8n6FjvllllB<166668 ",
|
||||
" S-kg+>666<M<996-y6n<8* ",
|
||||
" p71=4 m69996kD8Z-66698&& ",
|
||||
" &i0ycm6n4 ogk17,0<6666g ",
|
||||
" N-k-<> >=01-kuu666> ",
|
||||
" ,6ky& &46-10ul,66, ",
|
||||
" Ou0<> o66y<ulw<66& ",
|
||||
" *kk5 >66By7=xu664 ",
|
||||
" <<M4 466lj<Mxu66o ",
|
||||
" *>> +66uv,zN666* ",
|
||||
" 566,xxj669 ",
|
||||
" 4666FF666> ",
|
||||
" >966666M ",
|
||||
" oM6668+ ",
|
||||
" *4 ",
|
||||
" ",
|
||||
" "};
|
||||
|
||||
|
||||
/* when invoked (via signal delete_event), terminates the application.
|
||||
*/
|
||||
void close_application( GtkWidget *widget, gpointer *data ) {
|
||||
gtk_main_quit();
|
||||
}
|
||||
|
||||
int main (int argc, char *argv[])
|
||||
{
|
||||
/* GtkWidget is the storage type for widgets */
|
||||
GtkWidget *window, *pixmap, *fixed;
|
||||
GdkPixmap *gdk_pixmap;
|
||||
GdkBitmap *mask;
|
||||
GtkStyle *style;
|
||||
GdkGC *gc;
|
||||
|
||||
/* create the main window, and attach delete_event signal to terminate
|
||||
the application. Note that the main window will not have a titlebar
|
||||
since we're making it a popup. */
|
||||
gtk_init (&argc, &argv);
|
||||
window = gtk_window_new( GTK_WINDOW_POPUP );
|
||||
gtk_signal_connect (GTK_OBJECT (window), "delete_event",
|
||||
GTK_SIGNAL_FUNC (close_application), NULL);
|
||||
gtk_widget_show (window);
|
||||
|
||||
/* now for the pixmap and the pixmap widget */
|
||||
style = gtk_widget_get_default_style();
|
||||
gc = style->black_gc;
|
||||
gdk_pixmap = gdk_pixmap_create_from_xpm_d( window->window, &mask,
|
||||
&style->bg[GTK_STATE_NORMAL],
|
||||
WheelbarrowFull_xpm );
|
||||
pixmap = gtk_pixmap_new( gdk_pixmap, mask );
|
||||
gtk_widget_show( pixmap );
|
||||
|
||||
/* To display the pixmap, we use a fixed widget to place the pixmap */
|
||||
fixed = gtk_fixed_new();
|
||||
gtk_widget_set_usize( fixed, 200, 200 );
|
||||
gtk_fixed_put( GTK_FIXED(fixed), pixmap, 0, 0 );
|
||||
gtk_container_add( GTK_CONTAINER(window), fixed );
|
||||
gtk_widget_show( fixed );
|
||||
|
||||
/* This masks out everything except for the image itself */
|
||||
gtk_widget_shape_combine_mask( window, mask, 0, 0 );
|
||||
|
||||
/* show the window */
|
||||
gtk_widget_set_uposition( window, 20, 400 );
|
||||
gtk_widget_show( window );
|
||||
gtk_main ();
|
||||
|
||||
return 0;
|
||||
}
|
Loading…
Reference in New Issue
Block a user