AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity

Start mass update for GTK 1.1 Look for the best version of awk Fix FD leak

Browse Source 
Mon Dec  7 15:15:06 GMT 1998  Tony Gale <gale@gtk.org>

        * docs/gtk_tut.sgml: Start mass update for GTK 1.1
        * examples/extract.sh: Look for the best version of awk
        * examples/extract.awk: Fix FD leak
        * example/base: minimal example from Tutorial
This commit is contained in:
GMT 1998 Tony Gale 1998-12-07 15:19:00 +00:00 committed by Tony Gale
parent 621beb8aaf
commit 337bdee253
20 changed files with 2795 additions and 2453 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
ChangeLog
View File

@ -1,3 +1,10 @@
Mon Dec 7 15:15:06 GMT 1998 Tony Gale <gale@gtk.org>
* docs/gtk_tut.sgml: Start mass update for GTK 1.1
* examples/extract.sh: Look for the best version of awk
* examples/extract.awk: Fix FD leak
* example/base: minimal example from Tutorial
Mon Dec 7 01:29:27 1998 Owen Taylor <otaylor@gtk.org> Mon Dec 7 01:29:27 1998 Owen Taylor <otaylor@gtk.org>
* gtk/gtkwindow.c: New functions * gtk/gtkwindow.c: New functions

7
ChangeLog.pre-2-0
View File

@ -1,3 +1,10 @@
Mon Dec 7 15:15:06 GMT 1998 Tony Gale <gale@gtk.org>
* docs/gtk_tut.sgml: Start mass update for GTK 1.1
* examples/extract.sh: Look for the best version of awk
* examples/extract.awk: Fix FD leak
* example/base: minimal example from Tutorial
Mon Dec 7 01:29:27 1998 Owen Taylor <otaylor@gtk.org> Mon Dec 7 01:29:27 1998 Owen Taylor <otaylor@gtk.org>
* gtk/gtkwindow.c: New functions * gtk/gtkwindow.c: New functions

7
ChangeLog.pre-2-10
View File

@ -1,3 +1,10 @@
Mon Dec 7 15:15:06 GMT 1998 Tony Gale <gale@gtk.org>
* docs/gtk_tut.sgml: Start mass update for GTK 1.1
* examples/extract.sh: Look for the best version of awk
* examples/extract.awk: Fix FD leak
* example/base: minimal example from Tutorial
Mon Dec 7 01:29:27 1998 Owen Taylor <otaylor@gtk.org> Mon Dec 7 01:29:27 1998 Owen Taylor <otaylor@gtk.org>
* gtk/gtkwindow.c: New functions * gtk/gtkwindow.c: New functions

7
ChangeLog.pre-2-2
View File

@ -1,3 +1,10 @@
Mon Dec 7 15:15:06 GMT 1998 Tony Gale <gale@gtk.org>
* docs/gtk_tut.sgml: Start mass update for GTK 1.1
* examples/extract.sh: Look for the best version of awk
* examples/extract.awk: Fix FD leak
* example/base: minimal example from Tutorial
Mon Dec 7 01:29:27 1998 Owen Taylor <otaylor@gtk.org> Mon Dec 7 01:29:27 1998 Owen Taylor <otaylor@gtk.org>
* gtk/gtkwindow.c: New functions * gtk/gtkwindow.c: New functions

7
ChangeLog.pre-2-4
View File

@ -1,3 +1,10 @@
Mon Dec 7 15:15:06 GMT 1998 Tony Gale <gale@gtk.org>
* docs/gtk_tut.sgml: Start mass update for GTK 1.1
* examples/extract.sh: Look for the best version of awk
* examples/extract.awk: Fix FD leak
* example/base: minimal example from Tutorial
Mon Dec 7 01:29:27 1998 Owen Taylor <otaylor@gtk.org> Mon Dec 7 01:29:27 1998 Owen Taylor <otaylor@gtk.org>
* gtk/gtkwindow.c: New functions * gtk/gtkwindow.c: New functions

7
ChangeLog.pre-2-6
View File

@ -1,3 +1,10 @@
Mon Dec 7 15:15:06 GMT 1998 Tony Gale <gale@gtk.org>
* docs/gtk_tut.sgml: Start mass update for GTK 1.1
* examples/extract.sh: Look for the best version of awk
* examples/extract.awk: Fix FD leak
* example/base: minimal example from Tutorial
Mon Dec 7 01:29:27 1998 Owen Taylor <otaylor@gtk.org> Mon Dec 7 01:29:27 1998 Owen Taylor <otaylor@gtk.org>
* gtk/gtkwindow.c: New functions * gtk/gtkwindow.c: New functions

7
ChangeLog.pre-2-8
View File

@ -1,3 +1,10 @@
Mon Dec 7 15:15:06 GMT 1998 Tony Gale <gale@gtk.org>
* docs/gtk_tut.sgml: Start mass update for GTK 1.1
* examples/extract.sh: Look for the best version of awk
* examples/extract.awk: Fix FD leak
* example/base: minimal example from Tutorial
Mon Dec 7 01:29:27 1998 Owen Taylor <otaylor@gtk.org> Mon Dec 7 01:29:27 1998 Owen Taylor <otaylor@gtk.org>
* gtk/gtkwindow.c: New functions * gtk/gtkwindow.c: New functions

2115
docs/gtk_tut.sgml
View File

File diff suppressed because it is too large Load Diff

2115
docs/tutorial/gtk_tut.sgml
View File

File diff suppressed because it is too large Load Diff

8
examples/base/Makefile Normal file
View File

@ -0,0 +1,8 @@
CC = gcc
base: base.c
$(CC) `gtk-config --cflags` base.c -o base `gtk-config --libs`
clean:
rm -f *.o base

19
examples/base/base.c Normal file
View File

@ -0,0 +1,19 @@
/* example-start base base.c */
#include <gtk/gtk.h>
int main( int argc,
char *argv[] )
{
GtkWidget *window;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_show (window);
gtk_main ();
return 0;
}
/* example-end */

51
examples/buttons/buttons.c
View File

@ -1,13 +1,13 @@
/* This file extracted from the GTK tutorial. */ /* example-start buttons buttons.c */
/* buttons.c */
#include <gtk/gtk.h> #include <gtk/gtk.h>
/* create a new hbox with an image and a label packed into it /* Create a new hbox with an image and a label packed into it
* and return the box.. */ * and return the box. */
GtkWidget *xpm_label_box (GtkWidget *parent, gchar *xpm_filename, gchar *label_text) GtkWidget *xpm_label_box( GtkWidget *parent,
gchar *xpm_filename,
gchar *label_text )
{ {
GtkWidget *box1; GtkWidget *box1;
GtkWidget *label; GtkWidget *label;
@ -16,24 +16,24 @@ GtkWidget *xpm_label_box (GtkWidget *parent, gchar *xpm_filename, gchar *label_t
GdkBitmap *mask; GdkBitmap *mask;
GtkStyle *style; GtkStyle *style;
/* create box for xpm and label */ /* Create box for xpm and label */
box1 = gtk_hbox_new (FALSE, 0); box1 = gtk_hbox_new (FALSE, 0);
gtk_container_border_width (GTK_CONTAINER (box1), 2); gtk_container_border_width (GTK_CONTAINER (box1), 2);
/* get style of button.. I assume it's to get the background color. /* Get the style of the button to get the
* if someone knows the real reason, please enlighten me. */ * background color. */
style = gtk_widget_get_style(parent); style = gtk_widget_get_style(parent);
/* now on to the xpm stuff.. load xpm */ /* Now on to the xpm stuff */
pixmap = gdk_pixmap_create_from_xpm (parent->window, &mask, pixmap = gdk_pixmap_create_from_xpm (parent->window, &mask,
&style->bg[GTK_STATE_NORMAL], &style->bg[GTK_STATE_NORMAL],
xpm_filename); xpm_filename);
pixmapwid = gtk_pixmap_new (pixmap, mask); pixmapwid = gtk_pixmap_new (pixmap, mask);
/* create label for button */ /* Create a label for the button */
label = gtk_label_new (label_text); label = gtk_label_new (label_text);
/* pack the pixmap and label into the box */ /* Pack the pixmap and label into the box */
gtk_box_pack_start (GTK_BOX (box1), gtk_box_pack_start (GTK_BOX (box1),
pixmapwid, FALSE, FALSE, 3); pixmapwid, FALSE, FALSE, 3);
@ -42,17 +42,19 @@ GtkWidget *xpm_label_box (GtkWidget *parent, gchar *xpm_filename, gchar *label_t
gtk_widget_show(pixmapwid); gtk_widget_show(pixmapwid);
gtk_widget_show(label); gtk_widget_show(label);
return (box1); return(box1);
} }
/* our usual callback function */ /* Our usual callback function */
void callback (GtkWidget *widget, gpointer data) void callback( GtkWidget *widget,
gpointer data )
{ {
g_print ("Hello again - %s was pressed\n", (char *) data); g_print ("Hello again - %s was pressed\n", (char *) data);
} }
int main (int argc, char *argv[]) int main( int argc,
char *argv[] )
{ {
/* GtkWidget is the storage type for widgets */ /* GtkWidget is the storage type for widgets */
GtkWidget *window; GtkWidget *window;
@ -61,7 +63,7 @@ int main (int argc, char *argv[])
gtk_init (&argc, &argv); gtk_init (&argc, &argv);
/* create a new window */ /* Create a new window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL); window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Pixmap'd Buttons!"); gtk_window_set_title (GTK_WINDOW (window), "Pixmap'd Buttons!");
@ -74,21 +76,21 @@ int main (int argc, char *argv[])
GTK_SIGNAL_FUNC (gtk_exit), NULL); GTK_SIGNAL_FUNC (gtk_exit), NULL);
/* sets the border width of the window. */ /* Sets the border width of the window. */
gtk_container_border_width (GTK_CONTAINER (window), 10); gtk_container_border_width (GTK_CONTAINER (window), 10);
gtk_widget_realize(window); gtk_widget_realize(window);
/* create a new button */ /* Create a new button */
button = gtk_button_new (); button = gtk_button_new ();
/* You should be getting used to seeing most of these functions by now */ /* Connect the "clicked" signal of the button to our callback */
gtk_signal_connect (GTK_OBJECT (button), "clicked", gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (callback), (gpointer) "cool button"); GTK_SIGNAL_FUNC (callback), (gpointer) "cool button");
/* this calls our box creating function */ /* This calls our box creating function */
box1 = xpm_label_box(window, "info.xpm", "cool button"); box1 = xpm_label_box(window, "info.xpm", "cool button");
/* pack and show all our widgets */ /* Pack and show all our widgets */
gtk_widget_show(box1); gtk_widget_show(box1);
gtk_container_add (GTK_CONTAINER (button), box1); gtk_container_add (GTK_CONTAINER (button), box1);
@ -99,8 +101,9 @@ int main (int argc, char *argv[])
gtk_widget_show (window); gtk_widget_show (window);
/* rest in gtk_main and wait for the fun to begin! */ /* Rest in gtk_main and wait for the fun to begin! */
gtk_main (); gtk_main ();
return 0; return(0);
} }
/* example-end */

2
examples/extract.awk
View File

@ -35,6 +35,8 @@ $2 == "example-start" { in_example=1 }
$2 == "example-start" && check == 0 \ $2 == "example-start" && check == 0 \
{ if ( (spec_example == "") || (spec_example == $4) ) { { if ( (spec_example == "") || (spec_example == $4) ) {
if ( flatten == 0 ) { if ( flatten == 0 ) {
if (file_name != "")
close(file_name);
file_name = sprintf("%s/%s",$3, $4); file_name = sprintf("%s/%s",$3, $4);
command = sprintf("mkdir -p %s", $3); command = sprintf("mkdir -p %s", $3);
system(command); system(command);

28
examples/extract.sh
View File

@ -1,2 +1,28 @@
#! /bin/sh #! /bin/sh
awk -f extract.awk ../docs/gtk_tut.sgml $1 $2 $3 $4 $5 # extract - extract C source files from GTK Tutorial
# Copyright (C) Tony Gale 1998
# Contact: gale@gtk.org
#
# extract.awk command Switches:
# -c : Just do checking rather than output files
# -f <filename> : Extract a specific file
# -d : Extract files to current directory
if [ -x /usr/bin/gawk ]; then
gawk -f extract.awk ../docs/gtk_tut.sgml $1 $2 $3 $4 $5
else
if [ -x /usr/bin/nawk ]; then
nawk -f extract.awk ../docs/gtk_tut.sgml $1 $2 $3 $4 $5
else
if [ -x /usr/bin/awk ]; then
awk -f extract.awk ../docs/gtk_tut.sgml $1 $2 $3 $4 $5
else
if [ -x /bin/awk ]; then
awk -f extract.awk ../docs/gtk_tut.sgml $1 $2 $3 $4 $5
else
echo "Can't find awk... please edit extract.sh by hand"
fi
fi
fi
fi

102
examples/helloworld/helloworld.c
View File

@ -1,97 +1,101 @@
/* This file extracted from the GTK tutorial. */ /* example-start helloworld helloworld.c */
/* helloworld.c */
#include <gtk/gtk.h> #include <gtk/gtk.h>
/* this is a callback function. the data arguments are ignored in this example. /* This is a callback function. The data arguments are ignored
* More on callbacks below. */ * in this example. More on callbacks below. */
void hello (GtkWidget *widget, gpointer data) void hello( GtkWidget *widget,
gpointer data )
{ {
g_print ("Hello World\n"); g_print ("Hello World\n");
} }
gint delete_event(GtkWidget *widget, GdkEvent *event, gpointer data) gint delete_event( GtkWidget *widget,
GdkEvent *event,
gpointer data )
{ {
g_print ("delete event occured\n"); /* If you return FALSE in the "delete_event" signal handler,
/* if you return FALSE in the "delete_event" signal handler, * GTK will emit the "destroy" signal. Returning TRUE means
* GTK will emit the "destroy" signal. Returning TRUE means
* you don't want the window to be destroyed. * you don't want the window to be destroyed.
* This is useful for popping up 'are you sure you want to quit ?' * This is useful for popping up 'are you sure you want to quit?'
* type dialogs. */ * type dialogs. */
g_print ("delete event occurred\n");
/* Change TRUE to FALSE and the main window will be destroyed with /* Change TRUE to FALSE and the main window will be destroyed with
* a "delete_event". */ * a "delete_event". */
return (TRUE); return(TRUE);
} }
/* another callback */ /* Another callback */
void destroy (GtkWidget *widget, gpointer data) void destroy( GtkWidget *widget,
gpointer data )
{ {
gtk_main_quit (); gtk_main_quit();
} }
int main (int argc, char *argv[]) int main( int argc,
char *argv[] )
{ {
/* GtkWidget is the storage type for widgets */ /* GtkWidget is the storage type for widgets */
GtkWidget *window; GtkWidget *window;
GtkWidget *button; GtkWidget *button;
/* this is called in all GTK applications. arguments are parsed from /* This is called in all GTK applications. Arguments are parsed
* the command line and are returned to the application. */ * from the command line and are returned to the application. */
gtk_init (&argc, &argv); gtk_init(&argc, &argv);
/* create a new window */ /* create a new window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL); window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
/* when the window is given the "delete_event" signal (this is given /* When the window is given the "delete_event" signal (this is given
* by the window manager (usually the 'close' option, or on the * by the window manager, usually by the 'close' option, or on the
* titlebar), we ask it to call the delete_event () function * titlebar), we ask it to call the delete_event () function
* as defined above. The data passed to the callback * as defined above. The data passed to the callback
* function is NULL and is ignored in the callback. */ * function is NULL and is ignored in the callback function. */
gtk_signal_connect (GTK_OBJECT (window), "delete_event", gtk_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC (delete_event), NULL); GTK_SIGNAL_FUNC (delete_event), NULL);
/* here we connect the "destroy" event to a signal handler. /* Here we connect the "destroy" event to a signal handler.
* This event occurs when we call gtk_widget_destroy() on the window, * This event occurs when we call gtk_widget_destroy() on the window,
* or if we return 'FALSE' in the "delete_event" callback. */ * or if we return 'FALSE' in the "delete_event" callback. */
gtk_signal_connect (GTK_OBJECT (window), "destroy", gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (destroy), NULL); GTK_SIGNAL_FUNC (destroy), NULL);
/* sets the border width of the window. */ /* Sets the border width of the window. */
gtk_container_border_width (GTK_CONTAINER (window), 10); gtk_container_border_width (GTK_CONTAINER (window), 10);
/* creates a new button with the label "Hello World". */ /* Creates a new button with the label "Hello World". */
button = gtk_button_new_with_label ("Hello World"); button = gtk_button_new_with_label ("Hello World");
/* When the button receives the "clicked" signal, it will call the /* When the button receives the "clicked" signal, it will call the
* function hello() passing it NULL as it's argument. The hello() * function hello() passing it NULL as its argument. The hello()
* function is defined above. */ * function is defined above. */
gtk_signal_connect (GTK_OBJECT (button), "clicked", gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (hello), NULL); GTK_SIGNAL_FUNC (hello), NULL);
/* This will cause the window to be destroyed by calling /* This will cause the window to be destroyed by calling
* gtk_widget_destroy(window) when "clicked". Again, the destroy * gtk_widget_destroy(window) when "clicked". Again, the destroy
* signal could come from here, or the window manager. */ * signal could come from here, or the window manager. */
gtk_signal_connect_object (GTK_OBJECT (button), "clicked", gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (window)); GTK_OBJECT (window));
/* this packs the button into the window (a gtk container). */ /* This packs the button into the window (a gtk container). */
gtk_container_add (GTK_CONTAINER (window), button); gtk_container_add (GTK_CONTAINER (window), button);
/* the final step is to display this newly created widget... */ /* The final step is to display this newly created widget. */
gtk_widget_show (button); gtk_widget_show (button);
/* and the window */ /* and the window */
gtk_widget_show (window); gtk_widget_show (window);
/* all GTK applications must have a gtk_main(). Control ends here /* All GTK applications must have a gtk_main(). Control ends here
* and waits for an event to occur (like a key press or mouse event). */ * and waits for an event to occur (like a key press or
* mouse event). */
gtk_main (); gtk_main ();
return 0; return(0);
} }
/* example-end */

85
examples/helloworld2/helloworld2.c
View File

@ -1,83 +1,84 @@
/* This file extracted from the GTK tutorial. */ /* example-start helloworld2 helloworld2.c */
/* helloworld2.c */
#include <gtk/gtk.h> #include <gtk/gtk.h>
/* Our new improved callback. The data passed to this function is printed /* Our new improved callback. The data passed to this function
* to stdout. */ * is printed to stdout. */
void callback (GtkWidget *widget, gpointer data) void callback( GtkWidget *widget,
{ gpointer data )
{
g_print ("Hello again - %s was pressed\n", (char *) data); g_print ("Hello again - %s was pressed\n", (char *) data);
} }
/* another callback */ /* another callback */
void delete_event (GtkWidget *widget, GdkEvent *event, gpointer data) void delete_event( GtkWidget *widget,
{ GdkEvent *event,
gpointer data )
{
gtk_main_quit (); gtk_main_quit ();
} }
int main (int argc, char *argv[]) int main( int argc,
char *argv[] )
{ {
/* GtkWidget is the storage type for widgets */ /* GtkWidget is the storage type for widgets */
GtkWidget *window; GtkWidget *window;
GtkWidget *button; GtkWidget *button;
GtkWidget *box1; GtkWidget *box1;
/* this is called in all GTK applications. arguments are parsed from /* This is called in all GTK applications. Arguments are parsed
* the command line and are returned to the application. */ * from the command line and are returned to the application. */
gtk_init (&argc, &argv); gtk_init (&argc, &argv);
/* create a new window */ /* Create a new window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL); window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
/* this is a new call, this just sets the title of our /* This is a new call, this just sets the title of our
* new window to "Hello Buttons!" */ * new window to "Hello Buttons!" */
gtk_window_set_title (GTK_WINDOW (window), "Hello Buttons!"); gtk_window_set_title (GTK_WINDOW (window), "Hello Buttons!");
/* Here we just set a handler for delete_event that immediately /* Here we just set a handler for delete_event that immediately
* exits GTK. */ * exits GTK. */
gtk_signal_connect (GTK_OBJECT (window), "delete_event", gtk_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC (delete_event), NULL); GTK_SIGNAL_FUNC (delete_event), NULL);
/* Sets the border width of the window. */
/* sets the border width of the window. */
gtk_container_border_width (GTK_CONTAINER (window), 10); gtk_container_border_width (GTK_CONTAINER (window), 10);
/* we create a box to pack widgets into. this is described in detail /* We create a box to pack widgets into. This is described in detail
* in the "packing" section below. The box is not really visible, it * in the "packing" section. The box is not really visible, it
* is just used as a tool to arrange widgets. */ * is just used as a tool to arrange widgets. */
box1 = gtk_hbox_new(FALSE, 0); box1 = gtk_hbox_new(FALSE, 0);
/* put the box into the main window. */ /* Put the box into the main window. */
gtk_container_add (GTK_CONTAINER (window), box1); gtk_container_add (GTK_CONTAINER (window), box1);
/* creates a new button with the label "Button 1". */ /* Creates a new button with the label "Button 1". */
button = gtk_button_new_with_label ("Button 1"); button = gtk_button_new_with_label ("Button 1");
/* Now when the button is clicked, we call the "callback" function /* Now when the button is clicked, we call the "callback" function
* with a pointer to "button 1" as it's argument */ * with a pointer to "button 1" as its argument */
gtk_signal_connect (GTK_OBJECT (button), "clicked", gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (callback), (gpointer) "button 1"); GTK_SIGNAL_FUNC (callback), (gpointer) "button 1");
/* instead of gtk_container_add, we pack this button into the invisible /* Instead of gtk_container_add, we pack this button into the invisible
* box, which has been packed into the window. */ * box, which has been packed into the window. */
gtk_box_pack_start(GTK_BOX(box1), button, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(box1), button, TRUE, TRUE, 0);
/* always remember this step, this tells GTK that our preparation for /* Always remember this step, this tells GTK that our preparation for
* this button is complete, and it can be displayed now. */ * this button is complete, and it can now be displayed. */
gtk_widget_show(button); gtk_widget_show(button);
/* do these same steps again to create a second button */ /* Do these same steps again to create a second button */
button = gtk_button_new_with_label ("Button 2"); button = gtk_button_new_with_label ("Button 2");
/* call the same callback function with a different argument, /* Call the same callback function with a different argument,
* passing a pointer to "button 2" instead. */ * passing a pointer to "button 2" instead. */
gtk_signal_connect (GTK_OBJECT (button), "clicked", gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (callback), (gpointer) "button 2"); GTK_SIGNAL_FUNC (callback), (gpointer) "button 2");
gtk_box_pack_start(GTK_BOX(box1), button, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(box1), button, TRUE, TRUE, 0);
/* The order in which we show the buttons is not really important, but I /* The order in which we show the buttons is not really important, but I
* recommend showing the window last, so it all pops up at once. */ * recommend showing the window last, so it all pops up at once. */
gtk_widget_show(button); gtk_widget_show(button);
@ -86,9 +87,9 @@ int main (int argc, char *argv[])
gtk_widget_show (window); gtk_widget_show (window);
/* rest in gtk_main and wait for the fun to begin! */ /* Rest in gtk_main and wait for the fun to begin! */
gtk_main (); gtk_main ();
return 0;
}
return(0);
}
/* example-end */

87
examples/packbox/packbox.c
View File

@ -1,13 +1,11 @@
/* This file extracted from the GTK tutorial. */ /* example-start packbox packbox.c */
/* packbox.c */
#include <stdio.h> #include <stdio.h>
#include <gtk/gtk.h> #include "gtk/gtk.h"
#include <stdlib.h>
void void delete_event( GtkWidget *widget,
delete_event (GtkWidget *widget, GdkEvent *event, gpointer data) GdkEvent *event,
gpointer data )
{ {
gtk_main_quit (); gtk_main_quit ();
} }
@ -15,18 +13,21 @@ delete_event (GtkWidget *widget, GdkEvent *event, gpointer data)
/* Make a new hbox filled with button-labels. Arguments for the /* Make a new hbox filled with button-labels. Arguments for the
* variables we're interested are passed in to this function. * variables we're interested are passed in to this function.
* We do not show the box, but do show everything inside. */ * We do not show the box, but do show everything inside. */
GtkWidget *make_box (gint homogeneous, gint spacing, GtkWidget *make_box( gint homogeneous,
gint expand, gint fill, gint padding) gint spacing,
gint expand,
gint fill,
gint padding )
{ {
GtkWidget *box; GtkWidget *box;
GtkWidget *button; GtkWidget *button;
char padstr[80]; char padstr[80];
/* create a new hbox with the appropriate homogeneous and spacing /* Create a new hbox with the appropriate homogeneous
* settings */ * and spacing settings */
box = gtk_hbox_new (homogeneous, spacing); box = gtk_hbox_new (homogeneous, spacing);
/* create a series of buttons with the appropriate settings */ /* Create a series of buttons with the appropriate settings */
button = gtk_button_new_with_label ("gtk_box_pack"); button = gtk_button_new_with_label ("gtk_box_pack");
gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding); gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
gtk_widget_show (button); gtk_widget_show (button);
@ -39,7 +40,7 @@ GtkWidget *make_box (gint homogeneous, gint spacing,
gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding); gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
gtk_widget_show (button); gtk_widget_show (button);
/* create a button with the label depending on the value of /* Create a button with the label depending on the value of
* expand. */ * expand. */
if (expand == TRUE) if (expand == TRUE)
button = gtk_button_new_with_label ("TRUE,"); button = gtk_button_new_with_label ("TRUE,");
@ -64,8 +65,8 @@ GtkWidget *make_box (gint homogeneous, gint spacing,
return box; return box;
} }
int int main( int argc,
main (int argc, char *argv[]) char *argv[])
{ {
GtkWidget *window; GtkWidget *window;
GtkWidget *button; GtkWidget *button;
@ -91,7 +92,7 @@ main (int argc, char *argv[])
window = gtk_window_new (GTK_WINDOW_TOPLEVEL); window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
/* You should always remember to connect the destroy signal to the /* You should always remember to connect the destroy signal to the
* main window. This is very important for proper intuitive * main window. This is very important for proper intuitive
* behavior */ * behavior */
gtk_signal_connect (GTK_OBJECT (window), "delete_event", gtk_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC (delete_event), NULL); GTK_SIGNAL_FUNC (delete_event), NULL);
@ -102,7 +103,7 @@ main (int argc, char *argv[])
* on top of the other in this vbox. */ * on top of the other in this vbox. */
box1 = gtk_vbox_new (FALSE, 0); box1 = gtk_vbox_new (FALSE, 0);
/* which example to show. These correspond to the pictures above. */ /* which example to show. These correspond to the pictures above. */
switch (which) { switch (which) {
case 1: case 1:
/* create a new label. */ /* create a new label. */
@ -117,16 +118,16 @@ main (int argc, char *argv[])
* order. */ * order. */
gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
/* show the label */ /* Show the label */
gtk_widget_show (label); gtk_widget_show (label);
/* call our make box function - homogeneous = FALSE, spacing = 0, /* Call our make box function - homogeneous = FALSE, spacing = 0,
* expand = FALSE, fill = FALSE, padding = 0 */ * expand = FALSE, fill = FALSE, padding = 0 */
box2 = make_box (FALSE, 0, FALSE, FALSE, 0); box2 = make_box (FALSE, 0, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
gtk_widget_show (box2); gtk_widget_show (box2);
/* call our make box function - homogeneous = FALSE, spacing = 0, /* Call our make box function - homogeneous = FALSE, spacing = 0,
* expand = FALSE, fill = FALSE, padding = 0 */ * expand = FALSE, fill = FALSE, padding = 0 */
box2 = make_box (FALSE, 0, TRUE, FALSE, 0); box2 = make_box (FALSE, 0, TRUE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
@ -137,17 +138,17 @@ main (int argc, char *argv[])
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
gtk_widget_show (box2); gtk_widget_show (box2);
/* creates a separator, we'll learn more about these later, /* Creates a separator, we'll learn more about these later,
* but they are quite simple. */ * but they are quite simple. */
separator = gtk_hseparator_new (); separator = gtk_hseparator_new ();
/* pack the separator into the vbox. Remember each of these /* Cack the separator into the vbox. Remember each of these
* widgets are being packed into a vbox, so they'll be stacked * widgets are being packed into a vbox, so they'll be stacked
* vertically. */ * vertically. */
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
gtk_widget_show (separator); gtk_widget_show (separator);
/* create another new label, and show it. */ /* Create another new label, and show it. */
label = gtk_label_new ("gtk_hbox_new (TRUE, 0);"); label = gtk_label_new ("gtk_hbox_new (TRUE, 0);");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
@ -163,7 +164,7 @@ main (int argc, char *argv[])
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
gtk_widget_show (box2); gtk_widget_show (box2);
/* another new separator. */ /* Another new separator. */
separator = gtk_hseparator_new (); separator = gtk_hseparator_new ();
/* The last 3 arguments to gtk_box_pack_start are: expand, fill, padding. */ /* 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_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
@ -173,7 +174,7 @@ main (int argc, char *argv[])
case 2: case 2:
/* create a new label, remember box1 is a vbox as created /* Create a new label, remember box1 is a vbox as created
* near the beginning of main() */ * near the beginning of main() */
label = gtk_label_new ("gtk_hbox_new (FALSE, 10);"); label = gtk_label_new ("gtk_hbox_new (FALSE, 10);");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
@ -218,27 +219,28 @@ main (int argc, char *argv[])
case 3: case 3:
/* This demonstrates the ability to use gtk_box_pack_end() to /* This demonstrates the ability to use gtk_box_pack_end() to
* right justify widgets. First, we create a new box as before. */ * right justify widgets. First, we create a new box as before. */
box2 = make_box (FALSE, 0, FALSE, FALSE, 0); box2 = make_box (FALSE, 0, FALSE, FALSE, 0);
/* create the label that will be put at the end. */
/* Create the label that will be put at the end. */
label = gtk_label_new ("end"); label = gtk_label_new ("end");
/* pack it using gtk_box_pack_end(), so it is put on the right side /* Pack it using gtk_box_pack_end(), so it is put on the right
* of the hbox created in the make_box() call. */ * side of the hbox created in the make_box() call. */
gtk_box_pack_end (GTK_BOX (box2), label, FALSE, FALSE, 0); gtk_box_pack_end (GTK_BOX (box2), label, FALSE, FALSE, 0);
/* show the label. */ /* Show the label. */
gtk_widget_show (label); gtk_widget_show (label);
/* pack box2 into box1 (the vbox remember ? :) */ /* Pack box2 into box1 (the vbox remember ? :) */
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
gtk_widget_show (box2); gtk_widget_show (box2);
/* a separator for the bottom. */ /* A separator for the bottom. */
separator = gtk_hseparator_new (); separator = gtk_hseparator_new ();
/* this explicitly sets the separator to 400 pixels wide by 5 pixels /* 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, * 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 * 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 * hbox. Otherwise, all the widgets in the hbox would be packed as
* close together as possible. */ * close together as possible. */
gtk_widget_set_usize (separator, 400, 5); gtk_widget_set_usize (separator, 400, 5);
/* pack the separator into the vbox (box1) created near the start /* pack the separator into the vbox (box1) created near the start
@ -253,23 +255,23 @@ main (int argc, char *argv[])
/* Our quit button. */ /* Our quit button. */
button = gtk_button_new_with_label ("Quit"); button = gtk_button_new_with_label ("Quit");
/* setup the signal to destroy the window. Remember that this will send /* 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 * the "destroy" signal to the window which will be caught by our signal
* handler as defined above. */ * handler as defined above. */
gtk_signal_connect_object (GTK_OBJECT (button), "clicked", gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_main_quit), GTK_SIGNAL_FUNC (gtk_main_quit),
GTK_OBJECT (window)); GTK_OBJECT (window));
/* pack the button into the quitbox. /* Pack the button into the quitbox.
* The last 3 arguments to gtk_box_pack_start are: expand, fill, padding. */ * The last 3 arguments to gtk_box_pack_start are: expand, fill, padding. */
gtk_box_pack_start (GTK_BOX (quitbox), button, TRUE, FALSE, 0); gtk_box_pack_start (GTK_BOX (quitbox), button, TRUE, FALSE, 0);
/* pack the quitbox into the vbox (box1) */ /* pack the quitbox into the vbox (box1) */
gtk_box_pack_start (GTK_BOX (box1), quitbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (box1), quitbox, FALSE, FALSE, 0);
/* pack the vbox (box1) which now contains all our widgets, into the /* Pack the vbox (box1) which now contains all our widgets, into the
* main window. */ * main window. */
gtk_container_add (GTK_CONTAINER (window), box1); gtk_container_add (GTK_CONTAINER (window), box1);
/* and show everything left */ /* And show everything left */
gtk_widget_show (button); gtk_widget_show (button);
gtk_widget_show (quitbox); gtk_widget_show (quitbox);
@ -280,8 +282,9 @@ main (int argc, char *argv[])
/* And of course, our main function. */ /* And of course, our main function. */
gtk_main (); gtk_main ();
/* control returns here when gtk_main_quit() is called, but not when /* Control returns here when gtk_main_quit() is called, but not when
* gtk_exit is used. */ * gtk_exit is used. */
return 0; return(0);
} }
/* example-end */

117
examples/radiobuttons/radiobuttons.c
View File

@ -1,77 +1,82 @@
/* This file extracted from the GTK tutorial. */ /* example-start radiobuttons radiobuttons.c */
/* radiobuttons.c */
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include <glib.h> #include <glib.h>
void close_application( GtkWidget *widget, GdkEvent *event, gpointer data ) void close_application( GtkWidget *widget,
GdkEvent *event,
gpointer data )
{ {
gtk_main_quit(); gtk_main_quit();
} }
int main(int argc,char *argv[]) int main( int argc,
char *argv[] )
{ {
static GtkWidget *window = NULL; GtkWidget *window = NULL;
GtkWidget *box1; GtkWidget *box1;
GtkWidget *box2; GtkWidget *box2;
GtkWidget *button; GtkWidget *button;
GtkWidget *separator; GtkWidget *separator;
GSList *group; GSList *group;
gtk_init(&argc,&argv); gtk_init(&argc,&argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_signal_connect (GTK_OBJECT (window), "delete_event", gtk_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC(close_application), GTK_SIGNAL_FUNC(close_application),
NULL); NULL);
gtk_window_set_title (GTK_WINDOW (window), "radio buttons"); gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
gtk_container_border_width (GTK_CONTAINER (window), 0); gtk_container_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_vbox_new (FALSE, 0); box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1); gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show (box1); gtk_widget_show (box1);
box2 = gtk_vbox_new (FALSE, 10); box2 = gtk_vbox_new (FALSE, 10);
gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_container_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2); gtk_widget_show (box2);
button = gtk_radio_button_new_with_label (NULL, "button1"); button = gtk_radio_button_new_with_label (NULL, "button1");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_show (button); gtk_widget_show (button);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
button = gtk_radio_button_new_with_label(group, "button2"); button = gtk_radio_button_new_with_label(group, "button2");
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE); gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_show (button); gtk_widget_show (button);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); button = gtk_radio_button_new_with_label(
button = gtk_radio_button_new_with_label(group, "button3"); gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); "button3");
gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_show (button);
separator = gtk_hseparator_new (); separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator); gtk_widget_show (separator);
box2 = gtk_vbox_new (FALSE, 10); box2 = gtk_vbox_new (FALSE, 10);
gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_container_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_widget_show (box2); gtk_widget_show (box2);
button = gtk_button_new_with_label ("close"); button = gtk_button_new_with_label ("close");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked", gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(close_application), GTK_SIGNAL_FUNC(close_application),
GTK_OBJECT (window)); GTK_OBJECT (window));
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button); gtk_widget_grab_default (button);
gtk_widget_show (button); gtk_widget_show (button);
gtk_widget_show (window); gtk_widget_show (window);
gtk_main(); gtk_main();
return(0);
return(0);
} }
/* example-end */

416
examples/rangewidgets/rangewidgets.c
View File

@ -4,284 +4,288 @@
GtkWidget *hscale, *vscale; GtkWidget *hscale, *vscale;
void cb_pos_menu_select (GtkWidget *item, GtkPositionType pos) void cb_pos_menu_select( GtkWidget *item,
GtkPositionType pos )
{ {
/* set the value position on both scale widgets */ /* Set the value position on both scale widgets */
gtk_scale_set_value_pos (GTK_SCALE (hscale), pos); gtk_scale_set_value_pos (GTK_SCALE (hscale), pos);
gtk_scale_set_value_pos (GTK_SCALE (vscale), pos); gtk_scale_set_value_pos (GTK_SCALE (vscale), pos);
} }
void cb_update_menu_select (GtkWidget *item, GtkUpdateType policy) void cb_update_menu_select( GtkWidget *item,
GtkUpdateType policy )
{ {
/* set the update policy for both scale widgets */ /* Set the update policy for both scale widgets */
gtk_range_set_update_policy (GTK_RANGE (hscale), policy); gtk_range_set_update_policy (GTK_RANGE (hscale), policy);
gtk_range_set_update_policy (GTK_RANGE (vscale), policy); gtk_range_set_update_policy (GTK_RANGE (vscale), policy);
} }
void cb_digits_scale (GtkAdjustment *adj) void cb_digits_scale( GtkAdjustment *adj )
{ {
/* set the number of decimal places to which adj->vaule is rounded /* Set the number of decimal places to which adj->value is rounded */
*/ gtk_scale_set_digits (GTK_SCALE (hscale), (gint) adj->value);
gtk_scale_set_digits (GTK_SCALE (hscale), (gint) adj->value); gtk_scale_set_digits (GTK_SCALE (vscale), (gint) adj->value);
gtk_scale_set_digits (GTK_SCALE (vscale), (gint) adj->value);
} }
void cb_page_size (GtkAdjustment *get, GtkAdjustment *set) void cb_page_size( GtkAdjustment *get,
GtkAdjustment *set )
{ {
/* set the page size and page increment size of the sample /* Set the page size and page increment size of the sample
adjustment to the value specified by the "Page Size" scale */ * adjustment to the value specified by the "Page Size" scale */
set->page_size = get->value; set->page_size = get->value;
set->page_increment = get->value; set->page_increment = get->value;
/* now emit the "changed" signal to reconfigure all the widgets that /* Now emit the "changed" signal to reconfigure all the widgets that
are attached to this adjustment */ * are attached to this adjustment */
gtk_signal_emit_by_name (GTK_OBJECT (set), "changed"); gtk_signal_emit_by_name (GTK_OBJECT (set), "changed");
} }
void cb_draw_value (GtkToggleButton *button) void cb_draw_value( GtkToggleButton *button )
{ {
/* turn the value display on the scale widgets off or on depending /* Turn the value display on the scale widgets off or on depending
on the state of the checkbutton */ * on the state of the checkbutton */
gtk_scale_set_draw_value (GTK_SCALE (hscale), button->active); gtk_scale_set_draw_value (GTK_SCALE (hscale), button->active);
gtk_scale_set_draw_value (GTK_SCALE (vscale), button->active); gtk_scale_set_draw_value (GTK_SCALE (vscale), button->active);
} }
/* convenience functions */ /* Convenience functions */
GtkWidget *make_menu_item (gchar *name, GtkSignalFunc callback, GtkWidget *make_menu_item( gchar *name,
gpointer data) GtkSignalFunc callback,
gpointer data )
{ {
GtkWidget *item; GtkWidget *item;
item = gtk_menu_item_new_with_label (name); item = gtk_menu_item_new_with_label (name);
gtk_signal_connect (GTK_OBJECT (item), "activate", gtk_signal_connect (GTK_OBJECT (item), "activate",
callback, data); callback, data);
gtk_widget_show (item); gtk_widget_show (item);
return item; return(item);
} }
void scale_set_default_values (GtkScale *scale) void scale_set_default_values( GtkScale *scale )
{ {
gtk_range_set_update_policy (GTK_RANGE (scale), gtk_range_set_update_policy (GTK_RANGE (scale),
GTK_UPDATE_CONTINUOUS); GTK_UPDATE_CONTINUOUS);
gtk_scale_set_digits (scale, 1); gtk_scale_set_digits (scale, 1);
gtk_scale_set_value_pos (scale, GTK_POS_TOP); gtk_scale_set_value_pos (scale, GTK_POS_TOP);
gtk_scale_set_draw_value (scale, TRUE); gtk_scale_set_draw_value (scale, TRUE);
} }
/* makes the sample window */ /* makes the sample window */
void create_range_controls (void) void create_range_controls( void )
{ {
GtkWidget *window; GtkWidget *window;
GtkWidget *box1, *box2, *box3; GtkWidget *box1, *box2, *box3;
GtkWidget *button; GtkWidget *button;
GtkWidget *scrollbar; GtkWidget *scrollbar;
GtkWidget *separator; GtkWidget *separator;
GtkWidget *opt, *menu, *item; GtkWidget *opt, *menu, *item;
GtkWidget *label; GtkWidget *label;
GtkWidget *scale; GtkWidget *scale;
GtkObject *adj1, *adj2; GtkObject *adj1, *adj2;
/* standard window-creating stuff */ /* Standard window-creating stuff */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL); window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_signal_connect (GTK_OBJECT (window), "destroy", gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_main_quit), GTK_SIGNAL_FUNC(gtk_main_quit),
NULL); NULL);
gtk_window_set_title (GTK_WINDOW (window), "range controls"); gtk_window_set_title (GTK_WINDOW (window), "range controls");
box1 = gtk_vbox_new (FALSE, 0); box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1); gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show (box1); gtk_widget_show (box1);
box2 = gtk_hbox_new (FALSE, 10); box2 = gtk_hbox_new (FALSE, 10);
gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_container_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2); gtk_widget_show (box2);
/* value, lower, upper, step_increment, page_increment, page_size */ /* calue, lower, upper, step_increment, page_increment, page_size */
/* note that the page_size value only makes a difference for /* Note that the page_size value only makes a difference for
scrollbar widgets, and the highest value you'll get is actually * scrollbar widgets, and the highest value you'll get is actually
(upper - page_size). */ * (upper - page_size). */
adj1 = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0); adj1 = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
vscale = gtk_vscale_new (GTK_ADJUSTMENT (adj1)); vscale = gtk_vscale_new (GTK_ADJUSTMENT (adj1));
scale_set_default_values (GTK_SCALE (vscale)); scale_set_default_values (GTK_SCALE (vscale));
gtk_box_pack_start (GTK_BOX (box2), vscale, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box2), vscale, TRUE, TRUE, 0);
gtk_widget_show (vscale); gtk_widget_show (vscale);
box3 = gtk_vbox_new (FALSE, 10); box3 = gtk_vbox_new (FALSE, 10);
gtk_box_pack_start (GTK_BOX (box2), box3, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box2), box3, TRUE, TRUE, 0);
gtk_widget_show (box3); gtk_widget_show (box3);
/* reuse the same adjustment */ /* Reuse the same adjustment */
hscale = gtk_hscale_new (GTK_ADJUSTMENT (adj1)); hscale = gtk_hscale_new (GTK_ADJUSTMENT (adj1));
gtk_widget_set_usize (GTK_WIDGET (hscale), 200, 30); gtk_widget_set_usize (GTK_WIDGET (hscale), 200, 30);
scale_set_default_values (GTK_SCALE (hscale)); scale_set_default_values (GTK_SCALE (hscale));
gtk_box_pack_start (GTK_BOX (box3), hscale, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box3), hscale, TRUE, TRUE, 0);
gtk_widget_show (hscale); gtk_widget_show (hscale);
/* reuse the same adjustment again */ /* Reuse the same adjustment again */
scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adj1)); scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adj1));
/* notice how this causes the scales to always be updated /* Notice how this causes the scales to always be updated
continuously when the scrollbar is moved */ * continuously when the scrollbar is moved */
gtk_range_set_update_policy (GTK_RANGE (scrollbar), gtk_range_set_update_policy (GTK_RANGE (scrollbar),
GTK_UPDATE_CONTINUOUS); GTK_UPDATE_CONTINUOUS);
gtk_box_pack_start (GTK_BOX (box3), scrollbar, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box3), scrollbar, TRUE, TRUE, 0);
gtk_widget_show (scrollbar); gtk_widget_show (scrollbar);
box2 = gtk_hbox_new (FALSE, 10); box2 = gtk_hbox_new (FALSE, 10);
gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_container_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2); gtk_widget_show (box2);
/* a checkbutton to control whether the value is displayed or not */ /* A checkbutton to control whether the value is displayed or not */
button = gtk_check_button_new_with_label button = gtk_check_button_new_with_label("Display value on scale widgets");
("Display value on scale widgets"); gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE); gtk_signal_connect (GTK_OBJECT (button), "toggled",
gtk_signal_connect (GTK_OBJECT (button), "toggled", GTK_SIGNAL_FUNC GTK_SIGNAL_FUNC(cb_draw_value), NULL);
(cb_draw_value), NULL); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_widget_show (button);
gtk_widget_show (button);
box2 = gtk_hbox_new (FALSE, 10); box2 = gtk_hbox_new (FALSE, 10);
gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_container_border_width (GTK_CONTAINER (box2), 10);
/* an option menu to change the position of the value */ /* An option menu to change the position of the value */
label = gtk_label_new ("Scale Value Position:"); label = gtk_label_new ("Scale Value Position:");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label); gtk_widget_show (label);
opt = gtk_option_menu_new(); opt = gtk_option_menu_new();
menu = gtk_menu_new(); menu = gtk_menu_new();
item = make_menu_item ("Top", GTK_SIGNAL_FUNC (cb_pos_menu_select), item = make_menu_item ("Top",
GINT_TO_POINTER (GTK_POS_TOP)); GTK_SIGNAL_FUNC(cb_pos_menu_select),
gtk_menu_append (GTK_MENU (menu), item); GINT_TO_POINTER (GTK_POS_TOP));
gtk_menu_append (GTK_MENU (menu), item);
item = make_menu_item ("Bottom", GTK_SIGNAL_FUNC (cb_pos_menu_select), item = make_menu_item ("Bottom", GTK_SIGNAL_FUNC (cb_pos_menu_select),
GINT_TO_POINTER (GTK_POS_BOTTOM)); GINT_TO_POINTER (GTK_POS_BOTTOM));
gtk_menu_append (GTK_MENU (menu), item); gtk_menu_append (GTK_MENU (menu), item);
item = make_menu_item ("Left", GTK_SIGNAL_FUNC (cb_pos_menu_select), item = make_menu_item ("Left", GTK_SIGNAL_FUNC (cb_pos_menu_select),
GINT_TO_POINTER (GTK_POS_LEFT)); GINT_TO_POINTER (GTK_POS_LEFT));
gtk_menu_append (GTK_MENU (menu), item); gtk_menu_append (GTK_MENU (menu), item);
item = make_menu_item ("Right", GTK_SIGNAL_FUNC (cb_pos_menu_select), item = make_menu_item ("Right", GTK_SIGNAL_FUNC (cb_pos_menu_select),
GINT_TO_POINTER (GTK_POS_RIGHT)); GINT_TO_POINTER (GTK_POS_RIGHT));
gtk_menu_append (GTK_MENU (menu), item); gtk_menu_append (GTK_MENU (menu), item);
gtk_option_menu_set_menu (GTK_OPTION_MENU (opt), menu); gtk_option_menu_set_menu (GTK_OPTION_MENU (opt), menu);
gtk_box_pack_start (GTK_BOX (box2), opt, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box2), opt, TRUE, TRUE, 0);
gtk_widget_show (opt); gtk_widget_show (opt);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2); gtk_widget_show (box2);
box2 = gtk_hbox_new (FALSE, 10); box2 = gtk_hbox_new (FALSE, 10);
gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_container_border_width (GTK_CONTAINER (box2), 10);
/* yet another option menu, this time for the update policy of the /* Yet another option menu, this time for the update policy of the
scale widgets */ * scale widgets */
label = gtk_label_new ("Scale Update Policy:"); label = gtk_label_new ("Scale Update Policy:");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label); gtk_widget_show (label);
opt = gtk_option_menu_new(); opt = gtk_option_menu_new();
menu = gtk_menu_new(); menu = gtk_menu_new();
item = make_menu_item ("Continuous", item = make_menu_item ("Continuous",
GTK_SIGNAL_FUNC (cb_update_menu_select), GTK_SIGNAL_FUNC (cb_update_menu_select),
GINT_TO_POINTER (GTK_UPDATE_CONTINUOUS)); GINT_TO_POINTER (GTK_UPDATE_CONTINUOUS));
gtk_menu_append (GTK_MENU (menu), item); gtk_menu_append (GTK_MENU (menu), item);
item = make_menu_item ("Discontinuous", item = make_menu_item ("Discontinuous",
GTK_SIGNAL_FUNC (cb_update_menu_select), GTK_SIGNAL_FUNC (cb_update_menu_select),
GINT_TO_POINTER (GTK_UPDATE_DISCONTINUOUS)); GINT_TO_POINTER (GTK_UPDATE_DISCONTINUOUS));
gtk_menu_append (GTK_MENU (menu), item); gtk_menu_append (GTK_MENU (menu), item);
item = make_menu_item ("Delayed", item = make_menu_item ("Delayed",
GTK_SIGNAL_FUNC (cb_update_menu_select), GTK_SIGNAL_FUNC (cb_update_menu_select),
GINT_TO_POINTER (GTK_UPDATE_DELAYED)); GINT_TO_POINTER (GTK_UPDATE_DELAYED));
gtk_menu_append (GTK_MENU (menu), item); gtk_menu_append (GTK_MENU (menu), item);
gtk_option_menu_set_menu (GTK_OPTION_MENU (opt), menu); gtk_option_menu_set_menu (GTK_OPTION_MENU (opt), menu);
gtk_box_pack_start (GTK_BOX (box2), opt, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box2), opt, TRUE, TRUE, 0);
gtk_widget_show (opt); gtk_widget_show (opt);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2); gtk_widget_show (box2);
box2 = gtk_hbox_new (FALSE, 10); box2 = gtk_hbox_new (FALSE, 10);
gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_container_border_width (GTK_CONTAINER (box2), 10);
/* a GtkHScale widget for adjusting the number of digits on the /* A GtkHScale widget for adjusting the number of digits on the
sample scales. */ * sample scales. */
label = gtk_label_new ("Scale Digits:"); label = gtk_label_new ("Scale Digits:");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label); gtk_widget_show (label);
adj2 = gtk_adjustment_new (1.0, 0.0, 5.0, 1.0, 1.0, 0.0); adj2 = gtk_adjustment_new (1.0, 0.0, 5.0, 1.0, 1.0, 0.0);
gtk_signal_connect (GTK_OBJECT (adj2), "value_changed", gtk_signal_connect (GTK_OBJECT (adj2), "value_changed",
GTK_SIGNAL_FUNC (cb_digits_scale), NULL); GTK_SIGNAL_FUNC (cb_digits_scale), NULL);
scale = gtk_hscale_new (GTK_ADJUSTMENT (adj2)); scale = gtk_hscale_new (GTK_ADJUSTMENT (adj2));
gtk_scale_set_digits (GTK_SCALE (scale), 0); gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2); gtk_widget_show (box2);
box2 = gtk_hbox_new (FALSE, 10); box2 = gtk_hbox_new (FALSE, 10);
gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_container_border_width (GTK_CONTAINER (box2), 10);
/* And, one last GtkHScale widget for adjusting the page size of the /* And, one last GtkHScale widget for adjusting the page size of the
scrollbar. */ * scrollbar. */
label = gtk_label_new ("Scrollbar Page Size:"); label = gtk_label_new ("Scrollbar Page Size:");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label); gtk_widget_show (label);
adj2 = gtk_adjustment_new (1.0, 1.0, 101.0, 1.0, 1.0, 0.0); adj2 = gtk_adjustment_new (1.0, 1.0, 101.0, 1.0, 1.0, 0.0);
gtk_signal_connect (GTK_OBJECT (adj2), "value_changed", gtk_signal_connect (GTK_OBJECT (adj2), "value_changed",
GTK_SIGNAL_FUNC (cb_page_size), adj1); GTK_SIGNAL_FUNC (cb_page_size), adj1);
scale = gtk_hscale_new (GTK_ADJUSTMENT (adj2)); scale = gtk_hscale_new (GTK_ADJUSTMENT (adj2));
gtk_scale_set_digits (GTK_SCALE (scale), 0); gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2); gtk_widget_show (box2);
separator = gtk_hseparator_new (); separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator); gtk_widget_show (separator);
box2 = gtk_vbox_new (FALSE, 10); box2 = gtk_vbox_new (FALSE, 10);
gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_container_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_widget_show (box2); gtk_widget_show (box2);
button = gtk_button_new_with_label ("Quit"); button = gtk_button_new_with_label ("Quit");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked", gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(gtk_main_quit), GTK_SIGNAL_FUNC(gtk_main_quit),
NULL); NULL);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button); gtk_widget_grab_default (button);
gtk_widget_show (button); gtk_widget_show (button);
gtk_widget_show (window); gtk_widget_show (window);
} }
int main (int argc, char *argv[]) int main( int argc,
char *argv[] )
{ {
gtk_init(&argc, &argv); gtk_init(&argc, &argv);
create_range_controls(); create_range_controls();
gtk_main(); gtk_main();
return 0; return(0);
} }
/* example-end */ /* example-end */

54
examples/table/table.c
View File

@ -1,22 +1,25 @@
/* This file extracted from the GTK tutorial. */ /* example-start table table.c */
/* table.c */
#include <gtk/gtk.h> #include <gtk/gtk.h>
/* our callback. /* Our callback.
* the data passed to this function is printed to stdout */ * The data passed to this function is printed to stdout */
void callback (GtkWidget *widget, gpointer data) void callback( GtkWidget *widget,
gpointer data )
{ {
g_print ("Hello again - %s was pressed\n", (char *) data); g_print ("Hello again - %s was pressed\n", (char *) data);
} }
/* this callback quits the program */ /* This callback quits the program */
void delete_event (GtkWidget *widget, GdkEvent *event, gpointer data) void delete_event( GtkWidget *widget,
GdkEvent *event,
gpointer data )
{ {
gtk_main_quit (); gtk_main_quit ();
} }
int main (int argc, char *argv[]) int main( int argc,
char *argv[] )
{ {
GtkWidget *window; GtkWidget *window;
GtkWidget *button; GtkWidget *button;
@ -24,62 +27,62 @@ int main (int argc, char *argv[])
gtk_init (&argc, &argv); gtk_init (&argc, &argv);
/* create a new window */ /* Create a new window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL); window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
/* set the window title */ /* Set the window title */
gtk_window_set_title (GTK_WINDOW (window), "Table"); gtk_window_set_title (GTK_WINDOW (window), "Table");
/* set a handler for delete_event that immediately /* Set a handler for delete_event that immediately
* exits GTK. */ * exits GTK. */
gtk_signal_connect (GTK_OBJECT (window), "delete_event", gtk_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC (delete_event), NULL); GTK_SIGNAL_FUNC (delete_event), NULL);
/* sets the border width of the window. */ /* Sets the border width of the window. */
gtk_container_border_width (GTK_CONTAINER (window), 20); gtk_container_border_width (GTK_CONTAINER (window), 20);
/* create a 2x2 table */ /* Create a 2x2 table */
table = gtk_table_new (2, 2, TRUE); table = gtk_table_new (2, 2, TRUE);
/* put the table in the main window */ /* Put the table in the main window */
gtk_container_add (GTK_CONTAINER (window), table); gtk_container_add (GTK_CONTAINER (window), table);
/* create first button */ /* Create first button */
button = gtk_button_new_with_label ("button 1"); button = gtk_button_new_with_label ("button 1");
/* when the button is clicked, we call the "callback" function /* When the button is clicked, we call the "callback" function
* with a pointer to "button 1" as it's argument */ * with a pointer to "button 1" as its argument */
gtk_signal_connect (GTK_OBJECT (button), "clicked", gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (callback), (gpointer) "button 1"); GTK_SIGNAL_FUNC (callback), (gpointer) "button 1");
/* insert button 1 into the upper left quadrant of the table */ /* Insert button 1 into the upper left quadrant of the table */
gtk_table_attach_defaults (GTK_TABLE(table), button, 0, 1, 0, 1); gtk_table_attach_defaults (GTK_TABLE(table), button, 0, 1, 0, 1);
gtk_widget_show (button); gtk_widget_show (button);
/* create second button */ /* Create second button */
button = gtk_button_new_with_label ("button 2"); button = gtk_button_new_with_label ("button 2");
/* when the button is clicked, we call the "callback" function /* When the button is clicked, we call the "callback" function
* with a pointer to "button 2" as it's argument */ * with a pointer to "button 2" as its argument */
gtk_signal_connect (GTK_OBJECT (button), "clicked", gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (callback), (gpointer) "button 2"); GTK_SIGNAL_FUNC (callback), (gpointer) "button 2");
/* insert button 2 into the upper right quadrant of the table */ /* Insert button 2 into the upper right quadrant of the table */
gtk_table_attach_defaults (GTK_TABLE(table), button, 1, 2, 0, 1); gtk_table_attach_defaults (GTK_TABLE(table), button, 1, 2, 0, 1);
gtk_widget_show (button); gtk_widget_show (button);
/* create "Quit" button */ /* Create "Quit" button */
button = gtk_button_new_with_label ("Quit"); button = gtk_button_new_with_label ("Quit");
/* when the button is clicked, we call the "delete_event" function /* When the button is clicked, we call the "delete_event" function
* and the program exits */ * and the program exits */
gtk_signal_connect (GTK_OBJECT (button), "clicked", gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (delete_event), NULL); GTK_SIGNAL_FUNC (delete_event), NULL);
/* insert the quit button into the both /* Insert the quit button into the both
* lower quadrants of the table */ * lower quadrants of the table */
gtk_table_attach_defaults (GTK_TABLE(table), button, 0, 2, 1, 2); gtk_table_attach_defaults (GTK_TABLE(table), button, 0, 2, 1, 2);
@ -92,3 +95,4 @@ int main (int argc, char *argv[])
return 0; return 0;
} }
/* example-end */