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

Trivial formatting fixes to all examples, simple functional fixes to

Browse Source 
* docs/tutorial/gtk-tut.sgml, docs/examples/*: Trivial formatting
	fixes to all examples, simple functional fixes to rangewidgets example.
This commit is contained in:
Matthias Clasen 2002-02-19 01:25:26 +00:00
parent c3940d4a07
commit bd73a312f0
51 changed files with 1525 additions and 1448 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
ChangeLog
View File

@ -1,3 +1,8 @@
2002-02-19 Matthias Clasen <maclas@gmx.de>
* docs/tutorial/gtk-tut.sgml, docs/examples/*: Trivial formatting
fixes to all examples, simple functional fixes to rangewidgets example.
Mon Feb 18 18:27:45 2002 Owen Taylor <otaylor@redhat.com>
* gtk/gtkfontsel.c (gtk_font_selection_set_font_name): Select

5
ChangeLog.pre-2-0
View File

@ -1,3 +1,8 @@
2002-02-19 Matthias Clasen <maclas@gmx.de>
* docs/tutorial/gtk-tut.sgml, docs/examples/*: Trivial formatting
fixes to all examples, simple functional fixes to rangewidgets example.
Mon Feb 18 18:27:45 2002 Owen Taylor <otaylor@redhat.com>
* gtk/gtkfontsel.c (gtk_font_selection_set_font_name): Select

5
ChangeLog.pre-2-10
View File

@ -1,3 +1,8 @@
2002-02-19 Matthias Clasen <maclas@gmx.de>
* docs/tutorial/gtk-tut.sgml, docs/examples/*: Trivial formatting
fixes to all examples, simple functional fixes to rangewidgets example.
Mon Feb 18 18:27:45 2002 Owen Taylor <otaylor@redhat.com>
* gtk/gtkfontsel.c (gtk_font_selection_set_font_name): Select

5
ChangeLog.pre-2-2
View File

@ -1,3 +1,8 @@
2002-02-19 Matthias Clasen <maclas@gmx.de>
* docs/tutorial/gtk-tut.sgml, docs/examples/*: Trivial formatting
fixes to all examples, simple functional fixes to rangewidgets example.
Mon Feb 18 18:27:45 2002 Owen Taylor <otaylor@redhat.com>
* gtk/gtkfontsel.c (gtk_font_selection_set_font_name): Select

5
ChangeLog.pre-2-4
View File

@ -1,3 +1,8 @@
2002-02-19 Matthias Clasen <maclas@gmx.de>
* docs/tutorial/gtk-tut.sgml, docs/examples/*: Trivial formatting
fixes to all examples, simple functional fixes to rangewidgets example.
Mon Feb 18 18:27:45 2002 Owen Taylor <otaylor@redhat.com>
* gtk/gtkfontsel.c (gtk_font_selection_set_font_name): Select

5
ChangeLog.pre-2-6
View File

@ -1,3 +1,8 @@
2002-02-19 Matthias Clasen <maclas@gmx.de>
* docs/tutorial/gtk-tut.sgml, docs/examples/*: Trivial formatting
fixes to all examples, simple functional fixes to rangewidgets example.
Mon Feb 18 18:27:45 2002 Owen Taylor <otaylor@redhat.com>
* gtk/gtkfontsel.c (gtk_font_selection_set_font_name): Select

5
ChangeLog.pre-2-8
View File

@ -1,3 +1,8 @@
2002-02-19 Matthias Clasen <maclas@gmx.de>
* docs/tutorial/gtk-tut.sgml, docs/examples/*: Trivial formatting
fixes to all examples, simple functional fixes to rangewidgets example.
Mon Feb 18 18:27:45 2002 Owen Taylor <otaylor@redhat.com>
* gtk/gtkfontsel.c (gtk_font_selection_set_font_name): Select

1494
docs/tutorial/gtk-tut.sgml
View File

File diff suppressed because it is too large Load Diff

20
examples/arrow/arrow.c
View File

@ -9,15 +9,15 @@ GtkWidget *create_arrow_button( GtkArrowType arrow_type,
GtkWidget *button;
GtkWidget *arrow;
button = gtk_button_new();
button = gtk_button_new ();
arrow = gtk_arrow_new (arrow_type, shadow_type);
gtk_container_add (GTK_CONTAINER (button), arrow);
gtk_widget_show(button);
gtk_widget_show(arrow);
gtk_widget_show (button);
gtk_widget_show (arrow);
return(button);
return button;
}
int main( int argc,
@ -49,18 +49,18 @@ int main( int argc,
gtk_container_add (GTK_CONTAINER (window), box);
/* Pack and show all our widgets */
gtk_widget_show(box);
gtk_widget_show (box);
button = create_arrow_button(GTK_ARROW_UP, GTK_SHADOW_IN);
button = create_arrow_button (GTK_ARROW_UP, GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 3);
button = create_arrow_button(GTK_ARROW_DOWN, GTK_SHADOW_OUT);
button = create_arrow_button (GTK_ARROW_DOWN, GTK_SHADOW_OUT);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 3);
button = create_arrow_button(GTK_ARROW_LEFT, GTK_SHADOW_ETCHED_IN);
button = create_arrow_button (GTK_ARROW_LEFT, GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 3);
button = create_arrow_button(GTK_ARROW_RIGHT, GTK_SHADOW_ETCHED_OUT);
button = create_arrow_button (GTK_ARROW_RIGHT, GTK_SHADOW_ETCHED_OUT);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 3);
gtk_widget_show (window);
@ -68,5 +68,5 @@ int main( int argc,
/* Rest in gtk_main and wait for the fun to begin! */
gtk_main ();
return(0);
return 0;
}

4
examples/aspectframe/aspectframe.c
View File

@ -23,7 +23,7 @@ int main( int argc,
2, /* xsize/ysize = 2 */
FALSE /* ignore child's aspect */);
gtk_container_add (GTK_CONTAINER(window), aspect_frame);
gtk_container_add (GTK_CONTAINER (window), aspect_frame);
gtk_widget_show (aspect_frame);
/* Now add a child widget to the aspect frame */
@ -33,7 +33,7 @@ int main( int argc,
/* Ask for a 200x200 window, but the AspectFrame will give us a 200x100
* window since we are forcing a 2x1 aspect ratio */
gtk_widget_set_size_request (drawing_area, 200, 200);
gtk_container_add (GTK_CONTAINER(aspect_frame), drawing_area);
gtk_container_add (GTK_CONTAINER (aspect_frame), drawing_area);
gtk_widget_show (drawing_area);
gtk_widget_show (window);

2
examples/base/base.c
View File

@ -13,5 +13,5 @@ int main( int argc,
gtk_main ();
return(0);
return 0;
}

8
examples/buttonbox/buttonbox.c
View File

@ -37,7 +37,7 @@ GtkWidget *create_bbox( gint horizontal,
button = gtk_button_new_with_label ("Help");
gtk_container_add (GTK_CONTAINER (bbox), button);
return(frame);
return frame;
}
int main( int argc,
@ -51,13 +51,13 @@ int main( int argc,
GtkWidget *frame_vert;
/* Initialize GTK */
gtk_init( &argc, &argv );
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Button Boxes");
g_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_main_quit),
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
@ -116,5 +116,5 @@ int main( int argc,
/* Enter the event loop */
gtk_main ();
return(0);
return 0;
}

16
examples/buttons/buttons.c
View File

@ -22,7 +22,7 @@ GtkWidget *xpm_label_box( GtkWidget *parent,
/* Get the style of the button to get the
* background color. */
style = gtk_widget_get_style(parent);
style = gtk_widget_get_style (parent);
/* Now on to the xpm stuff */
pixmap = gdk_pixmap_create_from_xpm (parent->window, &mask,
@ -39,10 +39,10 @@ GtkWidget *xpm_label_box( GtkWidget *parent,
gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 3);
gtk_widget_show(pixmapwid);
gtk_widget_show(label);
gtk_widget_show (pixmapwid);
gtk_widget_show (label);
return(box1);
return box1;
}
/* Our usual callback function */
@ -78,7 +78,7 @@ int main( int argc,
/* Sets the border width of the window. */
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
gtk_widget_realize(window);
gtk_widget_realize (window);
/* Create a new button */
button = gtk_button_new ();
@ -91,11 +91,11 @@ int main( int argc,
box1 = xpm_label_box(window, "info.xpm", "cool button");
/* Pack and show all our widgets */
gtk_widget_show(box1);
gtk_widget_show (box1);
gtk_container_add (GTK_CONTAINER (button), box1);
gtk_widget_show(button);
gtk_widget_show (button);
gtk_container_add (GTK_CONTAINER (window), button);
@ -104,5 +104,5 @@ int main( int argc,
/* Rest in gtk_main and wait for the fun to begin! */
gtk_main ();
return(0);
return 0;
}

131
examples/calendar/calendar.c
View File

@ -59,11 +59,11 @@ void calendar_date_to_string( CalendarData *data,
time_t time;
memset (&tm, 0, sizeof (tm));
gtk_calendar_get_date (GTK_CALENDAR(data->window),
gtk_calendar_get_date (GTK_CALENDAR (data->window),
&tm.tm_year, &tm.tm_mon, &tm.tm_mday);
tm.tm_year -= TM_YEAR_BASE;
time = mktime(&tm);
strftime (buffer, buff_len-1, "%x", gmtime(&time));
time = mktime (&tm);
strftime (buffer, buff_len-1, "%x", gmtime (&time));
}
void calendar_set_signal_strings( char *sig_str,
@ -107,15 +107,18 @@ void calendar_day_selected_double_click( GtkWidget *widget,
calendar_set_signal_strings (buffer, data);
memset (&tm, 0, sizeof (tm));
gtk_calendar_get_date (GTK_CALENDAR(data->window),
gtk_calendar_get_date (GTK_CALENDAR (data->window),
&tm.tm_year, &tm.tm_mon, &tm.tm_mday);
tm.tm_year -= TM_YEAR_BASE;
if(GTK_CALENDAR(data->window)->marked_date[tm.tm_mday-1] == 0) {
gtk_calendar_mark_day(GTK_CALENDAR(data->window),tm.tm_mday);
} else {
gtk_calendar_unmark_day(GTK_CALENDAR(data->window),tm.tm_mday);
}
if (GTK_CALENDAR (data->window)->marked_date[tm.tm_mday-1] == 0)
{
gtk_calendar_mark_day (GTK_CALENDAR (data->window), tm.tm_mday);
}
else
{
gtk_calendar_unmark_day (GTK_CALENDAR (data->window), tm.tm_mday);
}
}
void calendar_prev_month( GtkWidget *widget,
@ -158,8 +161,8 @@ void calendar_next_year( GtkWidget *widget,
void calendar_set_flags( CalendarData *calendar )
{
gint i;
gint options=0;
for (i=0;i<5;i++)
gint options = 0;
for (i = 0; i < 5; i++)
if (calendar->settings[i])
{
options=options + (1<<i);
@ -173,13 +176,13 @@ void calendar_toggle_flag( GtkWidget *toggle,
{
gint i;
gint j;
j=0;
for (i=0; i<5; i++)
j = 0;
for (i = 0; i < 5; i++)
if (calendar->flag_checkboxes[i] == toggle)
j = i;
calendar->settings[j]=!calendar->settings[j];
calendar_set_flags(calendar);
calendar->settings[j] = !calendar->settings[j];
calendar_set_flags (calendar);
}
@ -189,7 +192,7 @@ void calendar_font_selection_ok( GtkWidget *button,
GtkStyle *style;
PangoFontDescription *font_desc;
calendar->font = gtk_font_selection_dialog_get_font_name(
calendar->font = gtk_font_selection_dialog_get_font_name (
GTK_FONT_SELECTION_DIALOG (calendar->font_dialog));
if (calendar->window)
{
@ -210,7 +213,7 @@ void calendar_select_font( GtkWidget *button,
if (!calendar->font_dialog) {
window = gtk_font_selection_dialog_new ("Font Selection Dialog");
g_return_if_fail(GTK_IS_FONT_SELECTION_DIALOG(window));
g_return_if_fail (GTK_IS_FONT_SELECTION_DIALOG (window));
calendar->font_dialog = window;
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
@ -220,7 +223,7 @@ void calendar_select_font( GtkWidget *button,
&calendar->font_dialog);
g_signal_connect (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->ok_button),
"clicked", GTK_SIGNAL_FUNC(calendar_font_selection_ok),
"clicked", GTK_SIGNAL_FUNC (calendar_font_selection_ok),
calendar);
g_signal_connect_swapped (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->cancel_button),
"clicked",
@ -267,44 +270,44 @@ void create_calendar()
calendar_data.font = NULL;
calendar_data.font_dialog = NULL;
for (i=0; i<5; i++) {
calendar_data.settings[i]=0;
for (i = 0; i < 5; i++) {
calendar_data.settings[i] = 0;
}
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "GtkCalendar Example");
gtk_window_set_title (GTK_WINDOW (window), "GtkCalendar Example");
gtk_container_set_border_width (GTK_CONTAINER (window), 5);
g_signal_connect(GTK_OBJECT(window), "destroy",
GTK_SIGNAL_FUNC(gtk_main_quit),
NULL);
g_signal_connect(GTK_OBJECT(window), "delete-event",
GTK_SIGNAL_FUNC(gtk_false),
NULL);
g_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
g_signal_connect (GTK_OBJECT (window), "delete-event",
GTK_SIGNAL_FUNC (gtk_false),
NULL);
gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
vbox = gtk_vbox_new(FALSE, DEF_PAD);
vbox = gtk_vbox_new (FALSE, DEF_PAD);
gtk_container_add (GTK_CONTAINER (window), vbox);
/*
* The top part of the window, Calendar, flags and fontsel.
*/
hbox = gtk_hbox_new(FALSE, DEF_PAD);
gtk_box_pack_start (GTK_BOX(vbox), hbox, TRUE, TRUE, DEF_PAD);
hbbox = gtk_hbutton_box_new();
gtk_box_pack_start(GTK_BOX(hbox), hbbox, FALSE, FALSE, DEF_PAD);
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbbox), GTK_BUTTONBOX_SPREAD);
hbox = gtk_hbox_new (FALSE, DEF_PAD);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, DEF_PAD);
hbbox = gtk_hbutton_box_new ();
gtk_box_pack_start (GTK_BOX (hbox), hbbox, FALSE, FALSE, DEF_PAD);
gtk_button_box_set_layout (GTK_BUTTON_BOX(hbbox), GTK_BUTTONBOX_SPREAD);
gtk_box_set_spacing (GTK_BOX (hbbox), 5);
/* Calendar widget */
frame = gtk_frame_new("Calendar");
gtk_box_pack_start(GTK_BOX(hbbox), frame, FALSE, TRUE, DEF_PAD);
calendar=gtk_calendar_new();
frame = gtk_frame_new ("Calendar");
gtk_box_pack_start (GTK_BOX (hbbox), frame, FALSE, TRUE, DEF_PAD);
calendar=gtk_calendar_new ();
calendar_data.window = calendar;
calendar_set_flags(&calendar_data);
gtk_calendar_mark_day ( GTK_CALENDAR(calendar), 19);
gtk_container_add( GTK_CONTAINER( frame), calendar);
calendar_set_flags (&calendar_data);
gtk_calendar_mark_day (GTK_CALENDAR (calendar), 19);
gtk_container_add( GTK_CONTAINER (frame), calendar);
g_signal_connect (GTK_OBJECT (calendar), "month_changed",
GTK_SIGNAL_FUNC (calendar_month_changed),
&calendar_data);
@ -331,43 +334,43 @@ void create_calendar()
separator = gtk_vseparator_new ();
gtk_box_pack_start (GTK_BOX (hbox), separator, FALSE, TRUE, 0);
vbox2 = gtk_vbox_new(FALSE, DEF_PAD);
gtk_box_pack_start(GTK_BOX(hbox), vbox2, FALSE, FALSE, DEF_PAD);
vbox2 = gtk_vbox_new (FALSE, DEF_PAD);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, DEF_PAD);
/* Build the Right frame with the flags in */
frame = gtk_frame_new("Flags");
gtk_box_pack_start(GTK_BOX(vbox2), frame, TRUE, TRUE, DEF_PAD);
vbox3 = gtk_vbox_new(TRUE, DEF_PAD_SMALL);
gtk_container_add(GTK_CONTAINER(frame), vbox3);
frame = gtk_frame_new ("Flags");
gtk_box_pack_start (GTK_BOX (vbox2), frame, TRUE, TRUE, DEF_PAD);
vbox3 = gtk_vbox_new (TRUE, DEF_PAD_SMALL);
gtk_container_add (GTK_CONTAINER (frame), vbox3);
for (i = 0; i < 5; i++)
{
toggle = gtk_check_button_new_with_label(flags[i].label);
toggle = gtk_check_button_new_with_label (flags[i].label);
g_signal_connect (GTK_OBJECT (toggle),
"toggled",
GTK_SIGNAL_FUNC(calendar_toggle_flag),
&calendar_data);
"toggled",
GTK_SIGNAL_FUNC (calendar_toggle_flag),
&calendar_data);
gtk_box_pack_start (GTK_BOX (vbox3), toggle, TRUE, TRUE, 0);
calendar_data.flag_checkboxes[i]=toggle;
calendar_data.flag_checkboxes[i] = toggle;
}
/* Build the right font-button */
button = gtk_button_new_with_label("Font...");
button = gtk_button_new_with_label ("Font...");
g_signal_connect (GTK_OBJECT (button),
"clicked",
GTK_SIGNAL_FUNC(calendar_select_font),
&calendar_data);
"clicked",
GTK_SIGNAL_FUNC (calendar_select_font),
&calendar_data);
gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
/*
* Build the Signal-event part.
*/
frame = gtk_frame_new("Signal events");
gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, DEF_PAD);
frame = gtk_frame_new ("Signal events");
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, DEF_PAD);
vbox2 = gtk_vbox_new(TRUE, DEF_PAD_SMALL);
gtk_container_add(GTK_CONTAINER(frame), vbox2);
vbox2 = gtk_vbox_new (TRUE, DEF_PAD_SMALL);
gtk_container_add (GTK_CONTAINER (frame), vbox2);
hbox = gtk_hbox_new (FALSE, 3);
gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, TRUE, 0);
@ -392,17 +395,17 @@ void create_calendar()
bbox = gtk_hbutton_box_new ();
gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0);
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END);
button = gtk_button_new_with_label ("Close");
g_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
gtk_container_add (GTK_CONTAINER (bbox), button);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
gtk_widget_show_all(window);
gtk_widget_show_all (window);
}
@ -411,9 +414,9 @@ int main(int argc,
{
gtk_init (&argc, &argv);
create_calendar();
create_calendar ();
gtk_main();
gtk_main ();
return 0;
}

101
examples/clist/clist.c
View File

@ -15,8 +15,8 @@ void button_add_clicked( gpointer data )
/* Here we do the actual adding of the text. It's done once for
* each row.
*/
for ( indx=0 ; indx < 4 ; indx++ )
gtk_clist_append( (GtkCList *) data, drink[indx]);
for (indx = 0; indx < 4; indx++)
gtk_clist_append ((GtkCList *)data, drink[indx]);
return;
}
@ -27,7 +27,7 @@ void button_clear_clicked( gpointer data )
/* Clear the list using gtk_clist_clear. This is much faster than
* calling gtk_clist_remove once for each row.
*/
gtk_clist_clear( (GtkCList *) data);
gtk_clist_clear ((GtkCList *)data);
return;
}
@ -41,13 +41,13 @@ void button_hide_show_clicked( gpointer data )
if (flag == 0)
{
/* Hide the titles and set the flag to 1 */
gtk_clist_column_titles_hide((GtkCList *) data);
gtk_clist_column_titles_hide ((GtkCList *)data);
flag++;
}
else
{
/* Show the titles and reset flag to 0 */
gtk_clist_column_titles_show((GtkCList *) data);
gtk_clist_column_titles_show ((GtkCList *)data);
flag--;
}
@ -67,12 +67,12 @@ void selection_made( GtkWidget *clist,
* which was clicked in. We will receive it as a pointer in the
* argument text.
*/
gtk_clist_get_text(GTK_CLIST(clist), row, column, &text);
gtk_clist_get_text (GTK_CLIST (clist), row, column, &text);
/* Just prints some information about the selected row */
g_print("You selected row %d. More specifically you clicked in "
"column %d, and the text in this cell is %s\n\n",
row, column, text);
g_print ("You selected row %d. More specifically you clicked in "
"column %d, and the text in this cell is %s\n\n",
row, column, text);
return;
}
@ -88,85 +88,86 @@ int main( int argc,
gtk_init(&argc, &argv);
window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
window=gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (GTK_WIDGET (window), 300, 150);
gtk_window_set_title(GTK_WINDOW(window), "GtkCList Example");
gtk_signal_connect(GTK_OBJECT(window),
"destroy",
GTK_SIGNAL_FUNC(gtk_main_quit),
NULL);
gtk_window_set_title (GTK_WINDOW (window), "GtkCList Example");
gtk_signal_connect (GTK_OBJECT (window),
"destroy",
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
vbox=gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 5);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_widget_show(vbox);
vbox=gtk_vbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
/* Create a scrolled window to pack the CList widget into */
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(vbox), scrolled_window, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), scrolled_window, TRUE, TRUE, 0);
gtk_widget_show (scrolled_window);
/* Create the CList. For this example we use 2 columns */
clist = gtk_clist_new_with_titles( 2, titles);
clist = gtk_clist_new_with_titles (2, titles);
/* When a selection is made, we want to know about it. The callback
* used is selection_made, and its code can be found further down */
gtk_signal_connect(GTK_OBJECT(clist), "select_row",
GTK_SIGNAL_FUNC(selection_made),
gtk_signal_connect(GTK_OBJECT (clist), "select_row",
GTK_SIGNAL_FUNC (selection_made),
NULL);
/* It isn't necessary to shadow the border, but it looks nice :) */
gtk_clist_set_shadow_type (GTK_CLIST(clist), GTK_SHADOW_OUT);
gtk_clist_set_shadow_type (GTK_CLIST (clist), GTK_SHADOW_OUT);
/* What however is important, is that we set the column widths as
* they will never be right otherwise. Note that the columns are
* numbered from 0 and up (to 1 in this case).
*/
gtk_clist_set_column_width (GTK_CLIST(clist), 0, 150);
gtk_clist_set_column_width (GTK_CLIST (clist), 0, 150);
/* Add the CList widget to the vertical box and show it. */
gtk_container_add(GTK_CONTAINER(scrolled_window), clist);
gtk_widget_show(clist);
gtk_container_add (GTK_CONTAINER (scrolled_window), clist);
gtk_widget_show (clist);
/* Create the buttons and add them to the window. See the button
* tutorial for more examples and comments on this.
*/
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_widget_show(hbox);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
gtk_widget_show (hbox);
button_add = gtk_button_new_with_label("Add List");
button_clear = gtk_button_new_with_label("Clear List");
button_hide_show = gtk_button_new_with_label("Hide/Show titles");
button_add = gtk_button_new_with_label ("Add List");
button_clear = gtk_button_new_with_label ("Clear List");
button_hide_show = gtk_button_new_with_label ("Hide/Show titles");
gtk_box_pack_start(GTK_BOX(hbox), button_add, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), button_clear, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), button_hide_show, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), button_add, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), button_clear, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), button_hide_show, TRUE, TRUE, 0);
/* Connect our callbacks to the three buttons */
gtk_signal_connect_object(GTK_OBJECT(button_add), "clicked",
GTK_SIGNAL_FUNC(button_add_clicked),
(gpointer) clist);
gtk_signal_connect_object(GTK_OBJECT(button_clear), "clicked",
GTK_SIGNAL_FUNC(button_clear_clicked),
(gpointer) clist);
gtk_signal_connect_object(GTK_OBJECT(button_hide_show), "clicked",
GTK_SIGNAL_FUNC(button_hide_show_clicked),
(gpointer) clist);
gtk_signal_connect_object (GTK_OBJECT (button_add), "clicked",
GTK_SIGNAL_FUNC (button_add_clicked),
(gpointer) clist);
gtk_signal_connect_object (GTK_OBJECT (button_clear), "clicked",
GTK_SIGNAL_FUNC (button_clear_clicked),
(gpointer) clist);
gtk_signal_connect_object (GTK_OBJECT (button_hide_show), "clicked",
GTK_SIGNAL_FUNC (button_hide_show_clicked),
(gpointer) clist);
gtk_widget_show(button_add);
gtk_widget_show(button_clear);
gtk_widget_show(button_hide_show);
gtk_widget_show (button_add);
gtk_widget_show (button_clear);
gtk_widget_show (button_hide_show);
/* The interface is completely set up so we show the window and
* enter the gtk_main loop.
*/
gtk_widget_show(window);
gtk_widget_show (window);
gtk_main();
return(0);
return 0;
}

45
examples/entry/entry.c
View File

@ -7,7 +7,7 @@ void enter_callback( GtkWidget *widget,
GtkWidget *entry )
{
const gchar *entry_text;
entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
entry_text = gtk_entry_get_text (GTK_ENTRY (entry));
printf("Entry contents: %s\n", entry_text);
}
@ -21,8 +21,8 @@ void entry_toggle_editable( GtkWidget *checkbutton,
void entry_toggle_visibility( GtkWidget *checkbutton,
GtkWidget *entry )
{
gtk_entry_set_visibility(GTK_ENTRY(entry),
GTK_TOGGLE_BUTTON(checkbutton)->active);
gtk_entry_set_visibility (GTK_ENTRY (entry),
GTK_TOGGLE_BUTTON (checkbutton)->active);
}
int main( int argc,
@ -39,11 +39,11 @@ int main( int argc,
gtk_init (&argc, &argv);
/* create a new window */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (GTK_WIDGET (window), 200, 100);
gtk_window_set_title(GTK_WINDOW (window), "GTK Entry");
g_signal_connect(GTK_OBJECT (window), "delete_event",
(GtkSignalFunc) exit, NULL);
gtk_window_set_title (GTK_WINDOW (window), "GTK Entry");
g_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC (exit), NULL);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
@ -51,14 +51,14 @@ int main( int argc,
entry = gtk_entry_new ();
gtk_entry_set_max_length (GTK_ENTRY (entry), 50);
g_signal_connect(GTK_OBJECT(entry), "activate",
GTK_SIGNAL_FUNC(enter_callback),
entry);
g_signal_connect (GTK_OBJECT (entry), "activate",
GTK_SIGNAL_FUNC (enter_callback),
entry);
gtk_entry_set_text (GTK_ENTRY (entry), "hello");
tmp_pos = GTK_ENTRY (entry)->text_length;
gtk_editable_insert_text (GTK_EDITABLE (entry), " world", -1, &tmp_pos);
gtk_editable_select_region (GTK_EDITABLE (entry),
0, GTK_ENTRY(entry)->text_length);
0, GTK_ENTRY (entry)->text_length);
gtk_box_pack_start (GTK_BOX (vbox), entry, TRUE, TRUE, 0);
gtk_widget_show (entry);
@ -66,31 +66,32 @@ int main( int argc,
gtk_container_add (GTK_CONTAINER (vbox), hbox);
gtk_widget_show (hbox);
check = gtk_check_button_new_with_label("Editable");
check = gtk_check_button_new_with_label ("Editable");
gtk_box_pack_start (GTK_BOX (hbox), check, TRUE, TRUE, 0);
g_signal_connect (GTK_OBJECT(check), "toggled",
GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
g_signal_connect (GTK_OBJECT (check), "toggled",
GTK_SIGNAL_FUNC (entry_toggle_editable), entry);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
gtk_widget_show (check);
check = gtk_check_button_new_with_label("Visible");
check = gtk_check_button_new_with_label ("Visible");
gtk_box_pack_start (GTK_BOX (hbox), check, TRUE, TRUE, 0);
g_signal_connect (GTK_OBJECT(check), "toggled",
GTK_SIGNAL_FUNC(entry_toggle_visibility), entry);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
g_signal_connect (GTK_OBJECT (check), "toggled",
GTK_SIGNAL_FUNC (entry_toggle_visibility), entry);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
gtk_widget_show (check);
button = gtk_button_new_with_label ("Close");
g_signal_connect_swapped (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(exit),
GTK_OBJECT (window));
GTK_SIGNAL_FUNC (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_widget_show (window);
gtk_main();
return 0;
}

8
examples/eventbox/eventbox.c
View File

@ -16,14 +16,14 @@ int main( int argc,
gtk_window_set_title (GTK_WINDOW (window), "Event Box");
g_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (exit), NULL);
GTK_SIGNAL_FUNC (exit), NULL);
gtk_container_set_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_container_add (GTK_CONTAINER (window), event_box);
gtk_widget_show (event_box);
/* Create a long label */
@ -37,8 +37,8 @@ int main( int argc,
/* And bind an action to it */
gtk_widget_set_events (event_box, GDK_BUTTON_PRESS_MASK);
g_signal_connect (GTK_OBJECT(event_box), "button_press_event",
GTK_SIGNAL_FUNC (exit), NULL);
g_signal_connect (GTK_OBJECT (event_box), "button_press_event",
GTK_SIGNAL_FUNC (exit), NULL);
/* Yet one more thing you need an X window for ... */

13
examples/filesel/filesel.c
View File

@ -25,23 +25,22 @@ int main( int argc,
filew = gtk_file_selection_new ("File selection");
g_signal_connect (GTK_OBJECT (filew), "destroy",
GTK_SIGNAL_FUNC (destroy), &filew);
GTK_SIGNAL_FUNC (destroy), &filew);
/* Connect the ok_button to file_ok_sel function */
g_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (filew)->ok_button),
"clicked", GTK_SIGNAL_FUNC (file_ok_sel), filew );
"clicked", GTK_SIGNAL_FUNC (file_ok_sel), filew );
/* Connect the cancel_button to destroy the widget */
g_signal_connect_swapped (GTK_OBJECT (GTK_FILE_SELECTION
(filew)->cancel_button),
"clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (filew));
g_signal_connect_swapped (GTK_OBJECT (GTK_FILE_SELECTION (filew)->cancel_button),
"clicked", GTK_SIGNAL_FUNC (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_widget_show (filew);
gtk_main ();
return 0;
}

24
examples/fixed/fixed.c
View File

@ -4,17 +4,17 @@
/* I'm going to be lazy and use some global variables to
* store the position of the widget within the fixed
* container */
gint x=50;
gint y=50;
gint x = 50;
gint y = 50;
/* This callback function moves the button to a new position
* in the Fixed container. */
void move_button( GtkWidget *widget,
GtkWidget *fixed )
{
x = (x+30)%300;
y = (y+50)%300;
gtk_fixed_move( GTK_FIXED(fixed), widget, x, y);
x = (x + 30) % 300;
y = (y + 50) % 300;
gtk_fixed_move (GTK_FIXED (fixed), widget, x, y);
}
int main( int argc,
@ -27,23 +27,23 @@ int main( int argc,
gint i;
/* Initialise GTK */
gtk_init(&argc, &argv);
gtk_init (&argc, &argv);
/* Create a new window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "Fixed Container");
gtk_window_set_title (GTK_WINDOW (window), "Fixed Container");
/* Here we connect the "destroy" event to a signal handler */
g_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
/* Sets the border width of the window. */
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
/* Create a Fixed Container */
fixed = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), fixed);
gtk_widget_show(fixed);
fixed = gtk_fixed_new ();
gtk_container_add (GTK_CONTAINER (window), fixed);
gtk_widget_show (fixed);
for (i = 1 ; i <= 3 ; i++) {
/* Creates a new button with the label "Press me" */
@ -53,7 +53,7 @@ int main( int argc,
* function move_button() passing it the Fixed Container as its
* argument. */
g_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (move_button), fixed);
GTK_SIGNAL_FUNC (move_button), fixed);
/* This packs the button into the fixed containers window. */
gtk_fixed_put (GTK_FIXED (fixed), button, i*50, i*50);

18
examples/frame/frame.c
View File

@ -9,34 +9,34 @@ int main( int argc,
GtkWidget *frame;
/* Initialise GTK */
gtk_init(&argc, &argv);
gtk_init (&argc, &argv);
/* Create a new window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "Frame Example");
gtk_window_set_title (GTK_WINDOW (window), "Frame Example");
/* Here we connect the "destroy" event to a signal handler */
g_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
gtk_widget_set_size_request (window, 300, 300);
/* Sets the border width of the window. */
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
/* Create a Frame */
frame = gtk_frame_new(NULL);
gtk_container_add(GTK_CONTAINER(window), frame);
frame = gtk_frame_new (NULL);
gtk_container_add (GTK_CONTAINER (window), frame);
/* Set the frame's label */
gtk_frame_set_label( GTK_FRAME(frame), "GTK Frame Widget" );
gtk_frame_set_label (GTK_FRAME (frame), "GTK Frame Widget");
/* Align the label at the right of the frame */
gtk_frame_set_label_align( GTK_FRAME(frame), 1.0, 0.0);
gtk_frame_set_label_align (GTK_FRAME (frame), 1.0, 0.0);
/* Set the style of the frame */
gtk_frame_set_shadow_type( GTK_FRAME(frame), GTK_SHADOW_ETCHED_OUT);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_OUT);
gtk_widget_show(frame);
gtk_widget_show (frame);
/* Display the window */
gtk_widget_show (window);

20
examples/gtkdial/dial_test.c
View File

@ -29,34 +29,34 @@ int main( int argc,
gtk_window_set_title (GTK_WINDOW (window), "Dial");
g_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (exit), NULL);
GTK_SIGNAL_FUNC (exit), NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
vbox = gtk_vbox_new (FALSE, 5);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show(vbox);
gtk_widget_show (vbox);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (vbox), frame);
gtk_widget_show (frame);
adjustment = GTK_ADJUSTMENT(gtk_adjustment_new (0, 0, 100, 0.01, 0.1, 0));
adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 100, 0.01, 0.1, 0));
dial = gtk_dial_new(adjustment);
gtk_dial_set_update_policy (GTK_DIAL(dial), GTK_UPDATE_DELAYED);
dial = gtk_dial_new (adjustment);
gtk_dial_set_update_policy (GTK_DIAL (dial), GTK_UPDATE_DELAYED);
/* gtk_widget_set_size_request (dial, 100, 100); */
gtk_container_add (GTK_CONTAINER (frame), dial);
gtk_widget_show (dial);
label = gtk_label_new("0.00");
gtk_box_pack_end (GTK_BOX(vbox), label, 0, 0, 0);
label = gtk_label_new ("0.00");
gtk_box_pack_end (GTK_BOX (vbox), label, 0, 0, 0);
gtk_widget_show (label);
g_signal_connect (GTK_OBJECT(adjustment), "value_changed",
GTK_SIGNAL_FUNC (value_changed), label);
g_signal_connect (GTK_OBJECT (adjustment), "value_changed",
GTK_SIGNAL_FUNC (value_changed), label);
gtk_widget_show (window);

46
examples/gtkdial/gtkdial.c
View File

@ -189,11 +189,11 @@ gtk_dial_set_adjustment (GtkDial *dial,
g_object_ref (GTK_OBJECT (dial->adjustment));
g_signal_connect (GTK_OBJECT (adjustment), "changed",
GTK_SIGNAL_FUNC (gtk_dial_adjustment_changed),
(gpointer) dial);
GTK_SIGNAL_FUNC (gtk_dial_adjustment_changed),
(gpointer) dial);
g_signal_connect (GTK_OBJECT (adjustment), "value_changed",
GTK_SIGNAL_FUNC (gtk_dial_adjustment_value_changed),
(gpointer) dial);
GTK_SIGNAL_FUNC (gtk_dial_adjustment_value_changed),
(gpointer) dial);
dial->old_value = adjustment->value;
dial->old_lower = adjustment->lower;
@ -267,7 +267,7 @@ gtk_dial_size_allocate (GtkWidget *widget,
allocation->width, allocation->height);
}
dial->radius = MIN(allocation->width,allocation->height) * 0.45;
dial->radius = MIN (allocation->width, allocation->height) * 0.45;
dial->pointer_width = dial->radius / 5;
}
@ -299,16 +299,16 @@ gtk_dial_expose (GtkWidget *widget,
widget->allocation.width,
widget->allocation.height);
*/
xc = widget->allocation.width/2;
yc = widget->allocation.height/2;
xc = widget->allocation.width / 2;
yc = widget->allocation.height / 2;
upper = dial->adjustment->upper;
lower = dial->adjustment->lower;
/* Erase old pointer */
s = sin(dial->last_angle);
c = cos(dial->last_angle);
s = sin (dial->last_angle);
c = cos (dial->last_angle);
dial->last_angle = dial->angle;
points[0].x = xc + s*dial->pointer_width/2;
@ -342,7 +342,7 @@ gtk_dial_expose (GtkWidget *widget,
points, 5,
FALSE);
g_object_unref(blankstyle);
g_object_unref (blankstyle);
/* Draw ticks */
@ -350,26 +350,26 @@ gtk_dial_expose (GtkWidget *widget,
if ((upper - lower) == 0)
return FALSE;
increment = (100*M_PI)/(dial->radius*dial->radius);
increment = (100*M_PI) / (dial->radius*dial->radius);
inc = (upper - lower);
while (inc < 100) inc *=10;
while (inc >= 1000) inc /=10;
while (inc < 100) inc *= 10;
while (inc >= 1000) inc /= 10;
last = -1;
for (i=0; i<=inc; i++)
for (i = 0; i <= inc; i++)
{
theta = ((gfloat)i*M_PI/(18*inc/24.) - M_PI/6.);
theta = ((gfloat)i*M_PI / (18*inc/24.) - M_PI/6.);
if ((theta - last) < (increment))
continue;
last = theta;
s = sin(theta);
c = cos(theta);
s = sin (theta);
c = cos (theta);
tick_length = (i%(inc/10) == 0) ? dial->pointer_width : dial->pointer_width/2;
tick_length = (i%(inc/10) == 0) ? dial->pointer_width : dial->pointer_width / 2;
gdk_draw_line (widget->window,
widget->style->fg_gc[widget->state],
@ -381,8 +381,8 @@ gtk_dial_expose (GtkWidget *widget,
/* Draw pointer */
s = sin(dial->angle);
c = cos(dial->angle);
s = sin (dial->angle);
c = cos (dial->angle);
dial->last_angle = dial->angle;
points[0].x = xc + s*dial->pointer_width/2;
@ -434,11 +434,11 @@ gtk_dial_button_press (GtkWidget *widget,
dx = event->x - widget->allocation.width / 2;
dy = widget->allocation.height / 2 - event->y;
s = sin(dial->angle);
c = cos(dial->angle);
s = sin (dial->angle);
c = cos (dial->angle);
d_parallel = s*dy + c*dx;
d_perpendicular = fabs(s*dx - c*dy);
d_perpendicular = fabs (s*dx - c*dy);
if (!dial->button &&
(d_perpendicular < dial->pointer_width/2) &&

16
examples/helloworld/helloworld.c
View File

@ -24,14 +24,14 @@ gint delete_event( GtkWidget *widget,
/* Change TRUE to FALSE and the main window will be destroyed with
* a "delete_event". */
return(TRUE);
return TRUE;
}
/* Another callback */
void destroy( GtkWidget *widget,
gpointer data )
{
gtk_main_quit();
gtk_main_quit ();
}
int main( int argc,
@ -43,7 +43,7 @@ int main( int argc,
/* This is called in all GTK applications. Arguments are parsed
* from the command line and are returned to the application. */
gtk_init(&argc, &argv);
gtk_init (&argc, &argv);
/* create a new window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
@ -54,13 +54,13 @@ int main( int argc,
* as defined above. The data passed to the callback
* function is NULL and is ignored in the callback function. */
g_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.
* This event occurs when we call gtk_widget_destroy() on the window,
* or if we return FALSE in the "delete_event" callback. */
g_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (destroy), NULL);
GTK_SIGNAL_FUNC (destroy), NULL);
/* Sets the border width of the window. */
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
@ -72,14 +72,14 @@ int main( int argc,
* function hello() passing it NULL as its argument. The hello()
* function is defined above. */
g_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
* gtk_widget_destroy(window) when "clicked". Again, the destroy
* signal could come from here, or the window manager. */
g_signal_connect_swapped (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (window));
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (window));
/* This packs the button into the window (a gtk container). */
gtk_container_add (GTK_CONTAINER (window), button);

22
examples/helloworld2/helloworld2.c
View File

@ -14,8 +14,8 @@ gint delete_event( GtkWidget *widget,
GdkEvent *event,
gpointer data )
{
gtk_main_quit();
return(FALSE);
gtk_main_quit ();
return FALSE;
}
int main( int argc,
@ -40,7 +40,7 @@ int main( int argc,
/* Here we just set a handler for delete_event that immediately
* exits GTK. */
g_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. */
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
@ -48,7 +48,7 @@ int main( int argc,
/* We create a box to pack widgets into. This is described in detail
* in the "packing" section. The box is not really visible, it
* 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. */
gtk_container_add (GTK_CONTAINER (window), box1);
@ -59,15 +59,15 @@ int main( int argc,
/* Now when the button is clicked, we call the "callback" function
* with a pointer to "button 1" as its argument */
g_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
* 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
* 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 */
button = gtk_button_new_with_label ("Button 2");
@ -75,15 +75,15 @@ int main( int argc,
/* Call the same callback function with a different argument,
* passing a pointer to "button 2" instead. */
g_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
* recommend showing the window last, so it all pops up at once. */
gtk_widget_show(button);
gtk_widget_show (button);
gtk_widget_show(box1);
gtk_widget_show (box1);
gtk_widget_show (window);

6
examples/label/label.c
View File

@ -11,12 +11,12 @@ int main( int argc,
GtkWidget *label;
/* Initialise GTK */
gtk_init(&argc, &argv);
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_main_quit),
NULL);
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
gtk_window_set_title (GTK_WINDOW (window), "Label");
vbox = gtk_vbox_new (FALSE, 5);

174
examples/list/list.c
View File

@ -42,78 +42,78 @@ gint main( int argc,
/* Initialize GTK (and subsequently GDK) */
gtk_init(&argc, &argv);
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");
g_signal_connect(GTK_OBJECT(window),
"destroy",
GTK_SIGNAL_FUNC(gtk_main_quit),
NULL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "GtkList Example");
g_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);
vbox=gtk_vbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_widget_show(vbox);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
/* This is the scrolled window to put the List widget inside */
scrolled_window=gtk_scrolled_window_new(NULL, NULL);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_size_request (scrolled_window, 250, 150);
gtk_container_add(GTK_CONTAINER(vbox), scrolled_window);
gtk_widget_show(scrolled_window);
gtk_container_add (GTK_CONTAINER (vbox), scrolled_window);
gtk_widget_show (scrolled_window);
/* Create thekList widget.
* Connect the sigh_print_selection() signal handler
* function to the "selection_changed" signal of the List
* to print out the selected items each time the selection
* has changed */
gtklist=gtk_list_new();
gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW(scrolled_window),
gtklist=gtk_list_new ();
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window),
gtklist);
gtk_widget_show(gtklist);
gtk_signal_connect(GTK_OBJECT(gtklist),
"selection_changed",
GTK_SIGNAL_FUNC(sigh_print_selection),
NULL);
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");
frame=gtk_frame_new ("Prison");
gtk_widget_set_size_request (frame, 200, 50);
gtk_container_set_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);
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 List
* which will handle the "arresting" of list items
*/
gtk_signal_connect(GTK_OBJECT(gtklist),
"button_release_event",
GTK_SIGNAL_FUNC(sigh_button_event),
frame);
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);
separator=gtk_hseparator_new ();
gtk_container_add (GTK_CONTAINER (vbox), separator);
gtk_widget_show (separator);
/* Finally create a button and connect its "clicked" signal
* to the destruction 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));
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 its own
@ -121,21 +121,21 @@ gint main( int argc,
* 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++) {
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);
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
@ -150,28 +150,28 @@ gint main( int argc,
* doubly linked list, their order will be descending (instead
* of ascending when using g_list_append())
*/
dlist=NULL;
for (; i<10; i++) {
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");
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);
gtk_list_append_items (GTK_LIST (gtklist), dlist);
/* Finally we want to see the window, don't we? ;) */
gtk_widget_show(window);
gtk_widget_show (window);
/* Fire up the main event loop of gtk */
gtk_main();
gtk_main ();
/* We get here after gtk_main_quit() has been called which
* happens if the main window gets destroyed
*/
return(0);
return 0;
}
/* This is the signal handler that got connected to button
@ -184,37 +184,37 @@ void sigh_button_event( GtkWidget *gtklist,
/* We only do something if the third (rightmost mouse button
* was released
*/
if (event->type==GDK_BUTTON_RELEASE &&
event->button==3) {
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;
dlist = GTK_LIST (gtklist)->selection;
if (dlist)
new_prisoner=GTK_WIDGET(dlist->data);
new_prisoner = GTK_WIDGET (dlist->data);
else
new_prisoner=NULL;
new_prisoner = NULL;
/* Look for already imprisoned 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;
dlist = gtk_container_children (GTK_CONTAINER (frame));
free_list = dlist;
while (dlist) {
GtkWidget *list_item;
list_item=dlist->data;
list_item = dlist->data;
gtk_widget_reparent(list_item, gtklist);
gtk_widget_reparent (list_item, gtklist);
dlist=dlist->next;
dlist = dlist->next;
}
g_list_free(free_list);
g_list_free (free_list);
/* If we have a new prisoner, remove him from the
* List and put him into the frame "Prison".
@ -223,13 +223,13 @@ void sigh_button_event( GtkWidget *gtklist,
if (new_prisoner) {
GList static_dlist;
static_dlist.data=new_prisoner;
static_dlist.next=NULL;
static_dlist.prev=NULL;
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);
gtk_list_unselect_child (GTK_LIST (gtklist),
new_prisoner);
gtk_widget_reparent (new_prisoner, frame);
}
}
}
@ -245,18 +245,18 @@ void sigh_print_selection( GtkWidget *gtklist,
/* Fetch the doubly linked list of selected items
* of the List, remember to treat this as read-only!
*/
dlist=GTK_LIST(gtklist)->selection;
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");
g_print ("Selection cleared\n");
return;
}
/* Ok, we got a selection and so we print it
*/
g_print("The selection is a ");
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.
@ -265,12 +265,12 @@ void sigh_print_selection( GtkWidget *gtklist,
GtkObject *list_item;
gchar *item_data_string;
list_item=GTK_OBJECT(dlist->data);
item_data_string=g_object_get_data(G_OBJECT (list_item),
list_item_data_key);
list_item = GTK_OBJECT (dlist->data);
item_data_string = g_object_get_data (G_OBJECT (list_item),
list_item_data_key);
g_print("%s ", item_data_string);
dlist=dlist->next;
dlist = dlist->next;
}
g_print("\n");
g_print ("\n");
}

7
examples/menu/itemfactory.c
View File

@ -91,9 +91,9 @@ int main( int argc,
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit),
"WM destroy");
gtk_window_set_title (GTK_WINDOW(window), "Item Factory");
GTK_SIGNAL_FUNC (gtk_main_quit),
"WM destroy");
gtk_window_set_title (GTK_WINDOW (window), "Item Factory");
gtk_widget_set_size_request (GTK_WIDGET (window), 300, 200);
main_vbox = gtk_vbox_new (FALSE, 1);
@ -106,6 +106,7 @@ int main( int argc,
gtk_widget_show (menubar);
gtk_widget_show (window);
gtk_main ();
return 0;

8
examples/menu/menu.c
View File

@ -26,7 +26,7 @@ int main( int argc,
gtk_widget_set_size_request (GTK_WIDGET (window), 200, 100);
gtk_window_set_title (GTK_WINDOW (window), "GTK Menu Test");
g_signal_connect (GTK_OBJECT (window), "delete_event",
(GtkSignalFunc) gtk_main_quit, NULL);
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
/* Init the menu-widget, and remember -- never
* gtk_show_widget() the menu widget!!
@ -53,7 +53,8 @@ int main( int argc,
/* Do something interesting when the menuitem is selected */
g_signal_connect_swapped (GTK_OBJECT (menu_items), "activate",
GTK_SIGNAL_FUNC (menuitem_response), (gpointer) g_strdup (buf));
GTK_SIGNAL_FUNC (menuitem_response),
(gpointer) g_strdup (buf));
/* Show the widget */
gtk_widget_show (menu_items);
@ -83,7 +84,8 @@ int main( int argc,
/* Create a button to which to attach menu as a popup */
button = gtk_button_new_with_label ("press me");
g_signal_connect_swapped (GTK_OBJECT (button), "event",
GTK_SIGNAL_FUNC (button_press), GTK_OBJECT (menu));
GTK_SIGNAL_FUNC (button_press),
GTK_OBJECT (menu));
gtk_box_pack_end (GTK_BOX (vbox), button, TRUE, TRUE, 2);
gtk_widget_show (button);

78
examples/notebook/notebook.c
View File

@ -6,7 +6,7 @@
void rotate_book( GtkButton *button,
GtkNotebook *notebook )
{
gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos +1) %4);
gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
}
/* Add/Remove the page tabs and the borders */
@ -30,7 +30,7 @@ void remove_book( GtkButton *button,
{
gint page;
page = gtk_notebook_get_current_page(notebook);
page = gtk_notebook_get_current_page (notebook);
gtk_notebook_remove_page (notebook, page);
/* Need to refresh the widget --
This forces the widget to redraw itself. */
@ -64,23 +64,23 @@ int main( int argc,
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC (delete), NULL);
GTK_SIGNAL_FUNC (delete), NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
table = gtk_table_new(3,6,FALSE);
table = gtk_table_new (3, 6, FALSE);
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);
gtk_table_attach_defaults (GTK_TABLE (table), notebook, 0, 6, 0, 1);
gtk_widget_show (notebook);
/* Let's 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);
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_set_border_width (GTK_CONTAINER (frame), 10);
@ -104,9 +104,9 @@ int main( int argc,
gtk_notebook_insert_page (GTK_NOTEBOOK (notebook), checkbutton, label, 2);
/* Now finally let's prepend pages to the notebook */
for (i=0; i < 5; i++) {
sprintf(bufferf, "Prepend Frame %d", i+1);
sprintf(bufferl, "PPage %d", i+1);
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_set_border_width (GTK_CONTAINER (frame), 10);
@ -118,56 +118,56 @@ int main( int argc,
gtk_widget_show (label);
label = gtk_label_new (bufferl);
gtk_notebook_prepend_page (GTK_NOTEBOOK(notebook), frame, label);
gtk_notebook_prepend_page (GTK_NOTEBOOK (notebook), frame, label);
}
/* Set what page to start at (page 4) */
gtk_notebook_set_current_page (GTK_NOTEBOOK(notebook), 3);
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), 3);
/* Create a bunch of buttons */
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (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);
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");
g_signal_connect_swapped (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_notebook_next_page),
GTK_OBJECT (notebook));
gtk_table_attach_defaults(GTK_TABLE(table), button, 1,2,1,2);
gtk_widget_show(button);
GTK_SIGNAL_FUNC (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");
g_signal_connect_swapped (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
GTK_OBJECT (notebook));
gtk_table_attach_defaults(GTK_TABLE(table), button, 2,3,1,2);
gtk_widget_show(button);
GTK_SIGNAL_FUNC (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");
g_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (rotate_book),
GTK_OBJECT(notebook));
gtk_table_attach_defaults(GTK_TABLE(table), button, 3,4,1,2);
gtk_widget_show(button);
GTK_SIGNAL_FUNC (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");
g_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (tabsborder_book),
GTK_OBJECT (notebook));
gtk_table_attach_defaults(GTK_TABLE(table), button, 4,5,1,2);
gtk_widget_show(button);
GTK_SIGNAL_FUNC (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");
g_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (remove_book),
GTK_OBJECT(notebook));
gtk_table_attach_defaults(GTK_TABLE(table), button, 5,6,1,2);
gtk_widget_show(button);
GTK_SIGNAL_FUNC (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_widget_show (table);
gtk_widget_show (window);
gtk_main ();

8
examples/packbox/packbox.c
View File

@ -7,7 +7,7 @@ gint delete_event( GtkWidget *widget,
GdkEvent *event,
gpointer data )
{
gtk_main_quit();
gtk_main_quit ();
return FALSE;
}
@ -96,7 +96,7 @@ int main( int argc,
* to the main window. This is very important for proper intuitive
* behavior */
g_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC (delete_event), NULL);
GTK_SIGNAL_FUNC (delete_event), NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
/* We create a vertical box (vbox) to pack the horizontal boxes into.
@ -260,8 +260,8 @@ int main( int argc,
/* Setup the signal to terminate the program when the button is clicked */
g_signal_connect_swapped (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_main_quit),
GTK_OBJECT (window));
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. */

4
examples/paned/paned.c
View File

@ -110,7 +110,7 @@ int main( int argc,
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Paned Windows");
g_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
gtk_widget_set_size_request (GTK_WIDGET (window), 450, 400);
@ -130,6 +130,8 @@ int main( int argc,
gtk_paned_add2 (GTK_PANED (vpaned), text);
gtk_widget_show (text);
gtk_widget_show (window);
gtk_main ();
return 0;
}

40
examples/pixmap/pixmap.c
View File

@ -32,8 +32,8 @@ gint close_application( GtkWidget *widget,
GdkEvent *event,
gpointer data )
{
gtk_main_quit();
return(FALSE);
gtk_main_quit ();
return FALSE;
}
@ -41,7 +41,7 @@ gint close_application( GtkWidget *widget,
*/
void button_clicked( GtkWidget *widget,
gpointer data ) {
g_print( "button clicked\n" );
g_print ("button clicked\n");
}
int main( int argc,
@ -55,31 +55,31 @@ int main( int argc,
/* 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_set_border_width( GTK_CONTAINER (window), 10 );
gtk_widget_show( 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_set_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 = gtk_widget_get_style (window);
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **)xpm_data );
(gchar **)xpm_data);
/* a pixmap widget to contain the pixmap */
pixmapwid = gtk_pixmap_new( pixmap, mask );
gtk_widget_show( pixmapwid );
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 );
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 );
g_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (button_clicked), NULL);
/* show the window */
gtk_main ();

54
examples/progressbar/progressbar.c
View File

@ -17,7 +17,7 @@ gint progress_timeout( gpointer data )
/* Calculate the value of the progress bar using the
* value range set in the adjustment object */
new_val = gtk_progress_get_value( GTK_PROGRESS(data) ) + 1;
new_val = gtk_progress_get_value (GTK_PROGRESS (data)) + 1;
adj = GTK_PROGRESS (data)->adjustment;
if (new_val > adj->upper)
@ -74,8 +74,8 @@ void destroy_progress( GtkWidget *widget,
gtk_timeout_remove (pdata->timer);
pdata->timer = 0;
pdata->window = NULL;
g_free(pdata);
gtk_main_quit();
g_free (pdata);
gtk_main_quit ();
}
int main( int argc,
@ -92,27 +92,27 @@ int main( int argc,
gtk_init (&argc, &argv);
/* Allocate memory for the data that is passwd to the callbacks */
pdata = g_malloc( sizeof(ProgressData) );
/* Allocate memory for the data that is passed to the callbacks */
pdata = g_malloc (sizeof (ProgressData));
pdata->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_resizable (GTK_WINDOW (pdata->window), TRUE);
g_signal_connect (GTK_OBJECT (pdata->window), "destroy",
GTK_SIGNAL_FUNC (destroy_progress),
pdata);
GTK_SIGNAL_FUNC (destroy_progress),
pdata);
gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar");
gtk_container_set_border_width (GTK_CONTAINER (pdata->window), 0);
vbox = gtk_vbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
gtk_container_add (GTK_CONTAINER (pdata->window), vbox);
gtk_widget_show(vbox);
gtk_widget_show (vbox);
/* Create a centering alignment object */
align = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, FALSE, 5);
gtk_widget_show(align);
gtk_widget_show (align);
/* Create a Adjusment object to hold the range of the
* progress bar */
@ -130,19 +130,19 @@ int main( int argc,
gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
"%v from [%l-%u] (=%p%%)");
gtk_container_add (GTK_CONTAINER (align), pdata->pbar);
gtk_widget_show(pdata->pbar);
gtk_widget_show (pdata->pbar);
/* Add a timer callback to update the value of the progress bar */
pdata->timer = gtk_timeout_add (100, progress_timeout, pdata->pbar);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 0);
gtk_widget_show(separator);
gtk_widget_show (separator);
/* rows, columns, homogeneous */
table = gtk_table_new (2, 3, FALSE);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, TRUE, 0);
gtk_widget_show(table);
gtk_widget_show (table);
/* Add a check button to select displaying of the trough text */
check = gtk_check_button_new_with_label ("Show text");
@ -150,9 +150,9 @@ int main( int argc,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
5, 5);
g_signal_connect (GTK_OBJECT (check), "clicked",
GTK_SIGNAL_FUNC (toggle_show_text),
pdata);
gtk_widget_show(check);
GTK_SIGNAL_FUNC (toggle_show_text),
pdata);
gtk_widget_show (check);
/* Add a check button to toggle activity mode */
check = gtk_check_button_new_with_label ("Activity mode");
@ -160,15 +160,15 @@ int main( int argc,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
5, 5);
g_signal_connect (GTK_OBJECT (check), "clicked",
GTK_SIGNAL_FUNC (toggle_activity_mode),
pdata);
gtk_widget_show(check);
GTK_SIGNAL_FUNC (toggle_activity_mode),
pdata);
gtk_widget_show (check);
separator = gtk_vseparator_new ();
gtk_table_attach (GTK_TABLE (table), separator, 1, 2, 0, 2,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
5, 5);
gtk_widget_show(separator);
gtk_widget_show (separator);
/* Add a radio button to select continuous display mode */
button = gtk_radio_button_new_with_label (NULL, "Continuous");
@ -176,8 +176,8 @@ int main( int argc,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
5, 5);
g_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (set_continuous_mode),
pdata);
GTK_SIGNAL_FUNC (set_continuous_mode),
pdata);
gtk_widget_show (button);
/* Add a radio button to select discrete display mode */
@ -188,19 +188,19 @@ int main( int argc,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
5, 5);
g_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (set_discrete_mode),
pdata);
GTK_SIGNAL_FUNC (set_discrete_mode),
pdata);
gtk_widget_show (button);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 0);
gtk_widget_show(separator);
gtk_widget_show (separator);
/* Add a button to exit the program */
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT (pdata->window));
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (pdata->window));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
/* This makes it so the button is the default. */
@ -209,7 +209,7 @@ int main( int argc,
/* 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 (button);
gtk_widget_show (pdata->window);

16
examples/radiobuttons/radiobuttons.c
View File

@ -6,7 +6,7 @@ gint close_application( GtkWidget *widget,
GdkEvent *event,
gpointer data )
{
gtk_main_quit();
gtk_main_quit ();
return FALSE;
}
@ -20,13 +20,13 @@ int main( int argc,
GtkWidget *separator;
GSList *group;
gtk_init(&argc,&argv);
gtk_init (&argc,&argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC(close_application),
NULL);
GTK_SIGNAL_FUNC (close_application),
NULL);
gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
@ -45,7 +45,7 @@ int main( int argc,
gtk_widget_show (button);
group = gtk_radio_button_get_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_active (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_show (button);
@ -67,15 +67,15 @@ int main( int argc,
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(close_application),
GTK_OBJECT (window));
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();
gtk_main ();
return 0;
}

45
examples/rangewidgets/rangewidgets.c
View File

@ -33,6 +33,11 @@ void cb_page_size( GtkAdjustment *get,
* adjustment to the value specified by the "Page Size" scale */
set->page_size = get->value;
set->page_increment = get->value;
gtk_adjustment_set_value (set, CLAMP (set->value,
set->lower,
(set->upper - set->page_size)));
/* Now emit the "changed" signal to reconfigure all the widgets that
* are attached to this adjustment */
g_signal_emit_by_name (GTK_OBJECT (set), "changed");
@ -56,7 +61,7 @@ GtkWidget *make_menu_item( gchar *name,
item = gtk_menu_item_new_with_label (name);
g_signal_connect (GTK_OBJECT (item), "activate",
callback, data);
callback, data);
gtk_widget_show (item);
return item;
@ -88,8 +93,8 @@ void create_range_controls( void )
/* Standard window-creating stuff */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_main_quit),
NULL);
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
gtk_window_set_title (GTK_WINDOW (window), "range controls");
box1 = gtk_vbox_new (FALSE, 0);
@ -118,7 +123,7 @@ void create_range_controls( void )
/* Reuse the same adjustment */
hscale = gtk_hscale_new (GTK_ADJUSTMENT (adj1));
gtk_widget_set_size_request (GTK_WIDGET (hscale), 200, 30);
gtk_widget_set_size_request (GTK_WIDGET (hscale), 200, -1);
scale_set_default_values (GTK_SCALE (hscale));
gtk_box_pack_start (GTK_BOX (box3), hscale, TRUE, TRUE, 0);
gtk_widget_show (hscale);
@ -141,7 +146,7 @@ void create_range_controls( void )
button = gtk_check_button_new_with_label("Display value on scale widgets");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
g_signal_connect (GTK_OBJECT (button), "toggled",
GTK_SIGNAL_FUNC(cb_draw_value), NULL);
GTK_SIGNAL_FUNC (cb_draw_value), NULL);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_show (button);
@ -153,11 +158,11 @@ void create_range_controls( void )
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label);
opt = gtk_option_menu_new();
menu = gtk_menu_new();
opt = gtk_option_menu_new ();
menu = gtk_menu_new ();
item = make_menu_item ("Top",
GTK_SIGNAL_FUNC(cb_pos_menu_select),
GTK_SIGNAL_FUNC (cb_pos_menu_select),
GINT_TO_POINTER (GTK_POS_TOP));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
@ -170,7 +175,7 @@ void create_range_controls( void )
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
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_shell_append (GTK_MENU_SHELL (menu), item);
gtk_option_menu_set_menu (GTK_OPTION_MENU (opt), menu);
@ -189,8 +194,8 @@ void create_range_controls( void )
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label);
opt = gtk_option_menu_new();
menu = gtk_menu_new();
opt = gtk_option_menu_new ();
menu = gtk_menu_new ();
item = make_menu_item ("Continuous",
GTK_SIGNAL_FUNC (cb_update_menu_select),
@ -198,8 +203,8 @@ void create_range_controls( void )
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = make_menu_item ("Discontinuous",
GTK_SIGNAL_FUNC (cb_update_menu_select),
GINT_TO_POINTER (GTK_UPDATE_DISCONTINUOUS));
GTK_SIGNAL_FUNC (cb_update_menu_select),
GINT_TO_POINTER (GTK_UPDATE_DISCONTINUOUS));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = make_menu_item ("Delayed",
@ -225,7 +230,7 @@ void create_range_controls( void )
adj2 = gtk_adjustment_new (1.0, 0.0, 5.0, 1.0, 1.0, 0.0);
g_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));
gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
@ -245,7 +250,7 @@ void create_range_controls( void )
adj2 = gtk_adjustment_new (1.0, 1.0, 101.0, 1.0, 1.0, 0.0);
g_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));
gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
@ -265,8 +270,8 @@ void create_range_controls( void )
button = gtk_button_new_with_label ("Quit");
g_signal_connect_swapped (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(gtk_main_quit),
NULL);
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
@ -278,11 +283,11 @@ void create_range_controls( void )
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;
}

68
examples/rulers/rulers.c
View File

@ -11,7 +11,7 @@ gint close_application( GtkWidget *widget,
GdkEvent *event,
gpointer data )
{
gtk_main_quit();
gtk_main_quit ();
return FALSE;
}
@ -21,57 +21,55 @@ int main( int argc,
GtkWidget *window, *table, *area, *hrule, *vrule;
/* Initialize GTK and create the main window */
gtk_init( &argc, &argv );
gtk_init (&argc, &argv);
window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC( close_application ), NULL);
GTK_SIGNAL_FUNC (close_application), NULL);
gtk_container_set_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 );
table = gtk_table_new (3, 2, FALSE);
gtk_container_add (GTK_CONTAINER (window), table);
area = gtk_drawing_area_new();
area = gtk_drawing_area_new ();
gtk_widget_set_size_request (GTK_WIDGET (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 );
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 );
g_signal_connect_swapped( GTK_OBJECT(area), "motion_notify_event",
(GtkSignalFunc)EVENT_METHOD(hrule,
motion_notify_event),
GTK_OBJECT(hrule) );
gtk_table_attach( GTK_TABLE(table), hrule, 1, 2, 0, 1,
GTK_EXPAND|GTK_SHRINK|GTK_FILL, GTK_FILL, 0, 0 );
hrule = gtk_hruler_new ();
gtk_ruler_set_metric (GTK_RULER (hrule), GTK_PIXELS);
gtk_ruler_set_range (GTK_RULER (hrule), 7, 13, 0, 20);
g_signal_connect_swapped (GTK_OBJECT (area), "motion_notify_event",
GTK_SIGNAL_FUNC (EVENT_METHOD (hrule, motion_notify_event)),
GTK_OBJECT (hrule));
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 );
g_signal_connect_swapped( GTK_OBJECT(area), "motion_notify_event",
(GtkSignalFunc)EVENT_METHOD(vrule,
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 );
vrule = gtk_vruler_new ();
gtk_ruler_set_metric (GTK_RULER (vrule), GTK_PIXELS);
gtk_ruler_set_range (GTK_RULER (vrule), 0, YSIZE, 10, YSIZE );
g_signal_connect_swapped (GTK_OBJECT (area), "motion_notify_event",
GTK_SIGNAL_FUNC (EVENT_METHOD (vrule, 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();
gtk_widget_show (area);
gtk_widget_show (hrule);
gtk_widget_show (vrule);
gtk_widget_show (table);
gtk_widget_show (window);
gtk_main ();
return 0;
}

36
examples/scribble-simple/scribble-simple.c
View File

@ -28,12 +28,12 @@ static gint configure_event( GtkWidget *widget,
GdkEventConfigure *event )
{
if (pixmap)
g_object_unref(pixmap);
g_object_unref (pixmap);
pixmap = gdk_pixmap_new(widget->window,
widget->allocation.width,
widget->allocation.height,
-1);
pixmap = gdk_pixmap_new (widget->window,
widget->allocation.width,
widget->allocation.height,
-1);
gdk_draw_rectangle (pixmap,
widget->style->white_gc,
TRUE,
@ -48,12 +48,12 @@ static gint configure_event( GtkWidget *widget,
static gint expose_event( GtkWidget *widget,
GdkEventExpose *event )
{
gdk_draw_drawable(widget->window,
widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
pixmap,
event->area.x, event->area.y,
event->area.x, event->area.y,
event->area.width, event->area.height);
gdk_draw_drawable (widget->window,
widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
pixmap,
event->area.x, event->area.y,
event->area.x, event->area.y,
event->area.width, event->area.height);
return FALSE;
}
@ -146,16 +146,16 @@ int main( int argc,
/* Signals used to handle backing pixmap */
g_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
(GtkSignalFunc) expose_event, NULL);
g_signal_connect (GTK_OBJECT(drawing_area),"configure_event",
(GtkSignalFunc) configure_event, NULL);
GTK_SIGNAL_FUNC (expose_event), NULL);
g_signal_connect (GTK_OBJECT (drawing_area),"configure_event",
GTK_SIGNAL_FUNC (configure_event), NULL);
/* Event signals */
g_signal_connect (GTK_OBJECT (drawing_area), "motion_notify_event",
(GtkSignalFunc) motion_notify_event, NULL);
GTK_SIGNAL_FUNC (motion_notify_event), NULL);
g_signal_connect (GTK_OBJECT (drawing_area), "button_press_event",
(GtkSignalFunc) button_press_event, NULL);
GTK_SIGNAL_FUNC (button_press_event), NULL);
gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK
| GDK_LEAVE_NOTIFY_MASK
@ -168,8 +168,8 @@ int main( int argc,
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
g_signal_connect_swapped (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (window));
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (window));
gtk_widget_show (button);
gtk_widget_show (window);

58
examples/scribble-xinput/scribble-xinput.c
View File

@ -28,12 +28,12 @@ static gint
configure_event (GtkWidget *widget, GdkEventConfigure *event)
{
if (pixmap)
g_object_unref(pixmap);
g_object_unref (pixmap);
pixmap = gdk_pixmap_new(widget->window,
widget->allocation.width,
widget->allocation.height,
-1);
pixmap = gdk_pixmap_new (widget->window,
widget->allocation.width,
widget->allocation.height,
-1);
gdk_draw_rectangle (pixmap,
widget->style->white_gc,
TRUE,
@ -48,12 +48,12 @@ configure_event (GtkWidget *widget, GdkEventConfigure *event)
static gint
expose_event (GtkWidget *widget, GdkEventExpose *event)
{
gdk_draw_drawable(widget->window,
widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
pixmap,
event->area.x, event->area.y,
event->area.x, event->area.y,
event->area.width, event->area.height);
gdk_draw_drawable (widget->window,
widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
pixmap,
event->area.x, event->area.y,
event->area.x, event->area.y,
event->area.width, event->area.height);
return FALSE;
}
@ -97,7 +97,7 @@ draw_brush (GtkWidget *widget, GdkInputSource source,
static void
print_button_press (GdkDevice *device)
{
g_print("Button press on device '%s'\n", device->name);
g_print ("Button press on device '%s'\n", device->name);
}
static gint
@ -157,22 +157,22 @@ create_input_dialog ()
{
inputd = gtk_input_dialog_new();
g_signal_connect (GTK_OBJECT(inputd), "destroy",
(GtkSignalFunc)input_dialog_destroy, &inputd);
g_signal_connect_swapped (GTK_OBJECT(GTK_INPUT_DIALOG(inputd)->close_button),
"clicked",
(GtkSignalFunc)gtk_widget_hide,
GTK_OBJECT(inputd));
gtk_widget_hide ( GTK_INPUT_DIALOG(inputd)->save_button);
g_signal_connect (GTK_OBJECT (inputd), "destroy",
GTK_SIGNAL_FUNC (input_dialog_destroy), &inputd);
g_signal_connect_swapped (GTK_OBJECT (GTK_INPUT_DIALOG (inputd)->close_button),
"clicked",
GTK_SIGNAL_FUNC (gtk_widget_hide),
GTK_OBJECT (inputd));
gtk_widget_hide (GTK_INPUT_DIALOG (inputd)->save_button);
gtk_widget_show (inputd);
}
else
{
if (!GTK_WIDGET_MAPPED(inputd))
gtk_widget_show(inputd);
if (!GTK_WIDGET_MAPPED (inputd))
gtk_widget_show (inputd);
else
gdk_window_raise(inputd->window);
gdk_window_raise (inputd->window);
}
}
@ -201,7 +201,7 @@ main (int argc, char *argv[])
gtk_widget_show (vbox);
g_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (quit), NULL);
GTK_SIGNAL_FUNC (quit), NULL);
/* Create the drawing area */
@ -214,16 +214,16 @@ main (int argc, char *argv[])
/* Signals used to handle backing pixmap */
g_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
(GtkSignalFunc) expose_event, NULL);
GTK_SIGNAL_FUNC (expose_event), NULL);
g_signal_connect (GTK_OBJECT(drawing_area),"configure_event",
(GtkSignalFunc) configure_event, NULL);
GTK_SIGNAL_FUNC (configure_event), NULL);
/* Event signals */
g_signal_connect (GTK_OBJECT (drawing_area), "motion_notify_event",
(GtkSignalFunc) motion_notify_event, NULL);
GTK_SIGNAL_FUNC (motion_notify_event), NULL);
g_signal_connect (GTK_OBJECT (drawing_area), "button_press_event",
(GtkSignalFunc) button_press_event, NULL);
GTK_SIGNAL_FUNC (button_press_event), NULL);
gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK
| GDK_LEAVE_NOTIFY_MASK
@ -247,8 +247,8 @@ main (int argc, char *argv[])
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
g_signal_connect_swapped (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (window));
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (window));
gtk_widget_show (button);
gtk_widget_show (window);

8
examples/scrolledwin/scrolledwin.c
View File

@ -5,7 +5,7 @@
void destroy( GtkWidget *widget,
gpointer data )
{
gtk_main_quit();
gtk_main_quit ();
}
int main( int argc,
@ -24,7 +24,7 @@ int main( int argc,
* packed into. */
window = gtk_dialog_new ();
g_signal_connect (GTK_OBJECT (window), "destroy",
(GtkSignalFunc) destroy, NULL);
GTK_SIGNAL_FUNC (destroy), NULL);
gtk_window_set_title (GTK_WINDOW (window), "GtkScrolledWindow example");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_widget_set_size_request (window, 300, 300);
@ -72,8 +72,8 @@ int main( int argc,
/* Add a "close" button to the bottom of the dialog */
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT (window));
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (window));
/* this makes it so the button is the default. */

8
examples/selection/gettargets.c
View File

@ -47,7 +47,7 @@ void selection_received( GtkWidget *widget,
atoms = (GdkAtom *)selection_data->data;
item_list = NULL;
for (i=0; i<selection_data->length/sizeof(GdkAtom); i++)
for (i = 0; i < selection_data->length / sizeof(GdkAtom); i++)
{
char *name;
name = gdk_atom_name (atoms[i]);
@ -75,7 +75,7 @@ int main( int argc,
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
g_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (exit), NULL);
GTK_SIGNAL_FUNC (exit), NULL);
/* Create a button the user can click to get targets */
@ -83,9 +83,9 @@ int main( int argc,
gtk_container_add (GTK_CONTAINER (window), button);
g_signal_connect (GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC (get_targets), NULL);
GTK_SIGNAL_FUNC (get_targets), NULL);
g_signal_connect (GTK_OBJECT(button), "selection_received",
GTK_SIGNAL_FUNC (selection_received), NULL);
GTK_SIGNAL_FUNC (selection_received), NULL);
gtk_widget_show (button);
gtk_widget_show (window);

26
examples/selection/setselection.c
View File

@ -7,7 +7,7 @@
void selection_toggled( GtkWidget *widget,
gint *have_selection )
{
if (GTK_TOGGLE_BUTTON(widget)->active)
if (GTK_TOGGLE_BUTTON (widget)->active)
{
*have_selection = gtk_selection_owner_set (widget,
GDK_SELECTION_PRIMARY,
@ -15,7 +15,7 @@ void selection_toggled( GtkWidget *widget,
/* if claiming the selection failed, we return the button to
the out state */
if (!*have_selection)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(widget), FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
}
else
{
@ -37,7 +37,7 @@ gint selection_clear( GtkWidget *widget,
gint *have_selection )
{
*have_selection = FALSE;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(widget), FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
return TRUE;
}
@ -52,13 +52,13 @@ void selection_handle( GtkWidget *widget,
gchar *timestr;
time_t current_time;
current_time = time(NULL);
timestr = asctime (localtime(&current_time));
current_time = time (NULL);
timestr = asctime (localtime (&current_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));
8, timestr, strlen (timestr));
}
int main( int argc,
@ -78,7 +78,7 @@ int main( int argc,
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
g_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (exit), NULL);
GTK_SIGNAL_FUNC (exit), NULL);
/* Create a toggle button to act as the selection */
@ -86,17 +86,17 @@ int main( int argc,
gtk_container_add (GTK_CONTAINER (window), selection_button);
gtk_widget_show (selection_button);
g_signal_connect (GTK_OBJECT(selection_button), "toggled",
GTK_SIGNAL_FUNC (selection_toggled), &have_selection);
g_signal_connect (GTK_OBJECT(selection_button), "selection_clear_event",
GTK_SIGNAL_FUNC (selection_clear), &have_selection);
g_signal_connect (GTK_OBJECT (selection_button), "toggled",
GTK_SIGNAL_FUNC (selection_toggled), &have_selection);
g_signal_connect (GTK_OBJECT (selection_button), "selection_clear_event",
GTK_SIGNAL_FUNC (selection_clear), &have_selection);
gtk_selection_add_target (selection_button,
GDK_SELECTION_PRIMARY,
GDK_SELECTION_TYPE_STRING,
1);
g_signal_connect (GTK_OBJECT(selection_button), "selection_get",
GTK_SIGNAL_FUNC (selection_handle), &have_selection);
g_signal_connect (GTK_OBJECT (selection_button), "selection_get",
GTK_SIGNAL_FUNC (selection_handle), &have_selection);
gtk_widget_show (selection_button);
gtk_widget_show (window);

26
examples/spinbutton/spinbutton.c
View File

@ -58,13 +58,13 @@ int main( int argc,
GtkAdjustment *adj;
/* Initialise GTK */
gtk_init(&argc, &argv);
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
gtk_window_set_title (GTK_WINDOW (window), "Spin Button");
@ -159,8 +159,8 @@ int main( int argc,
spinner2 = gtk_spin_button_new (adj, 0.0, 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner2), TRUE);
g_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (change_digits),
(gpointer) spinner2);
GTK_SIGNAL_FUNC (change_digits),
(gpointer) spinner2);
gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
hbox = gtk_hbox_new (FALSE, 0);
@ -168,15 +168,15 @@ int main( int argc,
button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
g_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (toggle_snap),
spinner1);
GTK_SIGNAL_FUNC (toggle_snap),
spinner1);
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
button = gtk_check_button_new_with_label ("Numeric only input mode");
g_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (toggle_numeric),
spinner1);
GTK_SIGNAL_FUNC (toggle_numeric),
spinner1);
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
@ -187,15 +187,15 @@ int main( int argc,
button = gtk_button_new_with_label ("Value as Int");
g_object_set_data (G_OBJECT (button), "user_data", val_label);
g_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (get_value),
GINT_TO_POINTER (1));
GTK_SIGNAL_FUNC (get_value),
GINT_TO_POINTER (1));
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
button = gtk_button_new_with_label ("Value as Float");
g_object_set_data (G_OBJECT (button), "user_data", val_label);
g_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (get_value),
GINT_TO_POINTER (2));
GTK_SIGNAL_FUNC (get_value),
GINT_TO_POINTER (2));
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);

51
examples/statusbar/statusbar.c
View File

@ -11,8 +11,8 @@ void push_item( GtkWidget *widget,
static int count = 1;
char buff[20];
g_snprintf(buff, 20, "Item %d", count++);
gtk_statusbar_push( GTK_STATUSBAR(status_bar), GPOINTER_TO_INT(data), buff);
g_snprintf (buff, 20, "Item %d", count++);
gtk_statusbar_push (GTK_STATUSBAR (status_bar), GPOINTER_TO_INT (data), buff);
return;
}
@ -20,7 +20,7 @@ void push_item( GtkWidget *widget,
void pop_item( GtkWidget *widget,
gpointer data )
{
gtk_statusbar_pop( GTK_STATUSBAR(status_bar), GPOINTER_TO_INT(data) );
gtk_statusbar_pop (GTK_STATUSBAR (status_bar), GPOINTER_TO_INT (data));
return;
}
@ -37,33 +37,40 @@ int main( int argc,
gtk_init (&argc, &argv);
/* create a new window */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (GTK_WIDGET (window), 200, 100);
gtk_window_set_title(GTK_WINDOW (window), "GTK Statusbar Example");
g_signal_connect(GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC (exit), NULL);
gtk_window_set_title (GTK_WINDOW (window), "GTK Statusbar Example");
g_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC (exit), NULL);
vbox = gtk_vbox_new(FALSE, 1);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_widget_show(vbox);
vbox = gtk_vbox_new (FALSE, 1);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
status_bar = gtk_statusbar_new();
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");
GTK_STATUSBAR (status_bar), "Statusbar example");
button = gtk_button_new_with_label("push item");
g_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC (push_item), GINT_TO_POINTER(context_id) );
gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 2);
gtk_widget_show(button);
button = gtk_button_new_with_label ("push item");
g_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (push_item), GINT_TO_POINTER (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");
g_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC (pop_item), GINT_TO_POINTER(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");
g_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (pop_item), GINT_TO_POINTER (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;
}

14
examples/table/table.c
View File

@ -36,7 +36,7 @@ int main( int argc,
/* Set a handler for delete_event that immediately
* exits GTK. */
g_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. */
gtk_container_set_border_width (GTK_CONTAINER (window), 20);
@ -53,11 +53,11 @@ int main( int argc,
/* When the button is clicked, we call the "callback" function
* with a pointer to "button 1" as its argument */
g_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 */
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);
@ -68,9 +68,9 @@ int main( int argc,
/* When the button is clicked, we call the "callback" function
* with a pointer to "button 2" as its argument */
g_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 */
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);
@ -80,11 +80,11 @@ int main( int argc,
/* When the button is clicked, we call the "delete_event" function
* and the program exits */
g_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
* 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);
gtk_widget_show (button);

12
examples/text/Makefile
View File

@ -1,11 +1,13 @@
CC = gcc
CFLAGS = -Wall \
-DG_DISABLE_DEPRECATED \
-DGDK_DISABLE_DEPRECATED \
-DGDK_PIXBUF_DISABLE_DEPRECATED \
-DGTK_DISABLE_DEPRECATED
#CFLAGS = -Wall \
# -DG_DISABLE_DEPRECATED \
# -DGDK_DISABLE_DEPRECATED \
# -DGDK_PIXBUF_DISABLE_DEPRECATED \
# -DGTK_DISABLE_DEPRECATED
CFLAGS =
text: text.c
$(CC) text.c -o text $(CFLAGS) `pkg-config gtk+-2.0 --cflags --libs`

48
examples/text/text.c
View File

@ -8,21 +8,21 @@
void text_toggle_editable (GtkWidget *checkbutton,
GtkWidget *text)
{
gtk_text_set_editable(GTK_TEXT(text),
GTK_TOGGLE_BUTTON(checkbutton)->active);
gtk_text_set_editable (GTK_TEXT (text),
GTK_TOGGLE_BUTTON (checkbutton)->active);
}
void text_toggle_word_wrap (GtkWidget *checkbutton,
GtkWidget *text)
{
gtk_text_set_word_wrap(GTK_TEXT(text),
GTK_TOGGLE_BUTTON(checkbutton)->active);
gtk_text_set_word_wrap (GTK_TEXT (text),
GTK_TOGGLE_BUTTON (checkbutton)->active);
}
void close_application( GtkWidget *widget,
gpointer data )
{
gtk_main_quit();
gtk_main_quit ();
}
int main( int argc,
@ -48,9 +48,9 @@ int main( int argc,
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (window, 600, 500);
gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, FALSE);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(close_application),
GTK_SIGNAL_FUNC (close_application),
NULL);
gtk_window_set_title (GTK_WINDOW (window), "Text Widget Example");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
@ -88,12 +88,12 @@ int main( int argc,
gtk_widget_show (vscrollbar);
/* Get the system color map and allocate the color red */
cmap = gdk_colormap_get_system();
cmap = gdk_colormap_get_system ();
color.red = 0xffff;
color.green = 0;
color.blue = 0;
if (!gdk_color_alloc(cmap, &color)) {
g_error("couldn't allocate color");
if (!gdk_color_alloc (cmap, &color)) {
g_error ("couldn't allocate color");
}
/* Load a fixed font */
@ -118,7 +118,7 @@ int main( int argc,
/* Load the file text.c into the text window */
infile = fopen("text.c", "r");
infile = fopen ("text.c", "r");
if (infile) {
char buffer[1024];
@ -126,7 +126,7 @@ int main( int argc,
while (1)
{
nchars = fread(buffer, 1, 1024, infile);
nchars = fread (buffer, 1, 1024, infile);
gtk_text_insert (GTK_TEXT (text), fixed_font, NULL,
NULL, buffer, nchars);
@ -144,17 +144,17 @@ int main( int argc,
gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
check = gtk_check_button_new_with_label("Editable");
check = gtk_check_button_new_with_label ("Editable");
gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT(check), "toggled",
GTK_SIGNAL_FUNC(text_toggle_editable), text);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
gtk_signal_connect (GTK_OBJECT (check), "toggled",
GTK_SIGNAL_FUNC (text_toggle_editable), text);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
gtk_widget_show (check);
check = gtk_check_button_new_with_label("Wrap Words");
check = gtk_check_button_new_with_label ("Wrap Words");
gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT(check), "toggled",
GTK_SIGNAL_FUNC(text_toggle_word_wrap), text);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), FALSE);
gtk_signal_connect (GTK_OBJECT (check), "toggled",
GTK_SIGNAL_FUNC (text_toggle_word_wrap), text);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), FALSE);
gtk_widget_show (check);
separator = gtk_hseparator_new ();
@ -167,9 +167,9 @@ int main( int argc,
gtk_widget_show (box2);
button = gtk_button_new_with_label ("close");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(close_application),
NULL);
g_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (close_application),
NULL);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
@ -179,5 +179,5 @@ int main( int argc,
gtk_main ();
return(0);
return 0;
}

28
examples/tictactoe/tictactoe.c
View File

@ -86,17 +86,17 @@ tictactoe_init (Tictactoe *ttt)
gint i,j;
table = gtk_table_new (3, 3, TRUE);
gtk_container_add (GTK_CONTAINER(ttt), table);
gtk_container_add (GTK_CONTAINER (ttt), table);
gtk_widget_show (table);
for (i=0;i<3; i++)
for (j=0;j<3; j++)
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++)
{
ttt->buttons[i][j] = gtk_toggle_button_new ();
gtk_table_attach_defaults (GTK_TABLE(table), ttt->buttons[i][j],
gtk_table_attach_defaults (GTK_TABLE (table), ttt->buttons[i][j],
i, i+1, j, j+1);
g_signal_connect (GTK_OBJECT (ttt->buttons[i][j]), "toggled",
GTK_SIGNAL_FUNC (tictactoe_toggle), ttt);
GTK_SIGNAL_FUNC (tictactoe_toggle), ttt);
gtk_widget_set_size_request (ttt->buttons[i][j], 20, 20);
gtk_widget_show (ttt->buttons[i][j]);
}
@ -113,13 +113,13 @@ tictactoe_clear (Tictactoe *ttt)
{
int i,j;
for (i=0;i<3;i++)
for (j=0;j<3;j++)
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++)
{
g_signal_handlers_block_by_func (GTK_OBJECT(ttt->buttons[i][j]), NULL, ttt);
g_signal_handlers_block_by_func (GTK_OBJECT (ttt->buttons[i][j]), NULL, ttt);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ttt->buttons[i][j]),
FALSE);
g_signal_handlers_unblock_by_func (GTK_OBJECT(ttt->buttons[i][j]), NULL, ttt);
FALSE);
g_signal_handlers_unblock_by_func (GTK_OBJECT (ttt->buttons[i][j]), NULL, ttt);
}
}
@ -137,15 +137,15 @@ tictactoe_toggle (GtkWidget *widget, Tictactoe *ttt)
int success, found;
for (k=0; k<8; k++)
for (k = 0; k < 8; k++)
{
success = TRUE;
found = FALSE;
for (i=0;i<3;i++)
for (i = 0; i < 3; i++)
{
success = success &&
GTK_TOGGLE_BUTTON(ttt->buttons[rwins[k][i]][cwins[k][i]])->active;
GTK_TOGGLE_BUTTON (ttt->buttons[rwins[k][i]][cwins[k][i]])->active;
found = found ||
ttt->buttons[rwins[k][i]][cwins[k][i]] == widget;
}
@ -153,7 +153,7 @@ tictactoe_toggle (GtkWidget *widget, Tictactoe *ttt)
if (success && found)
{
g_signal_emit (GTK_OBJECT (ttt),
tictactoe_signals[TICTACTOE_SIGNAL], 0);
tictactoe_signals[TICTACTOE_SIGNAL], 0);
break;
}
}

4
examples/tictactoe/ttt_test.c
View File

@ -23,7 +23,7 @@ int main( int argc,
gtk_window_set_title (GTK_WINDOW (window), "Aspect Frame");
g_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (exit), NULL);
GTK_SIGNAL_FUNC (exit), NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
@ -33,7 +33,7 @@ int main( int argc,
gtk_widget_show (ttt);
g_signal_connect (GTK_OBJECT (ttt), "tictactoe",
GTK_SIGNAL_FUNC (win), NULL);
GTK_SIGNAL_FUNC (win), NULL);
gtk_widget_show (window);

12
examples/tree/Makefile
View File

@ -1,11 +1,13 @@
CC = gcc
CFLAGS = -Wall \
-DG_DISABLE_DEPRECATED \
-DGDK_DISABLE_DEPRECATED \
-DGDK_PIXBUF_DISABLE_DEPRECATED \
-DGTK_DISABLE_DEPRECATED
#CFLAGS = -Wall \
# -DG_DISABLE_DEPRECATED \
# -DGDK_DISABLE_DEPRECATED \
# -DGDK_PIXBUF_DISABLE_DEPRECATED \
# -DGTK_DISABLE_DEPRECATED
CFLAGS =
tree: tree.c
$(CC) tree.c -o tree $(CFLAGS) `pkg-config gtk+-2.0 --cflags --libs`

86
examples/tree/tree.c
View File

@ -44,8 +44,8 @@ static void cb_selection_changed( GtkWidget *tree )
g_print ("selection_change called for tree %p\n", tree);
g_print ("selected objects are:\n");
i = GTK_TREE_SELECTION_OLD(tree);
while (i){
i = GTK_TREE_SELECTION_OLD (tree);
while (i) {
gchar *name;
GtkLabel *label;
GtkWidget *item;
@ -72,9 +72,9 @@ int main( int argc,
/* a generic toplevel window */
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 (gtk_main_quit), NULL);
gtk_container_set_border_width (GTK_CONTAINER(window), 5);
gtk_container_set_border_width (GTK_CONTAINER (window), 5);
/* A generic scrolled window */
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
@ -82,24 +82,24 @@ int main( int argc,
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request (scrolled_win, 150, 200);
gtk_container_add (GTK_CONTAINER(window), scrolled_win);
gtk_container_add (GTK_CONTAINER (window), scrolled_win);
gtk_widget_show (scrolled_win);
/* Create the root tree */
tree = gtk_tree_new();
tree = gtk_tree_new ();
g_print ("root tree is %p\n", tree);
/* connect all GtkTree:: signals */
gtk_signal_connect (GTK_OBJECT(tree), "select_child",
GTK_SIGNAL_FUNC(cb_select_child), tree);
gtk_signal_connect (GTK_OBJECT(tree), "unselect_child",
GTK_SIGNAL_FUNC(cb_unselect_child), tree);
gtk_signal_connect (GTK_OBJECT (tree), "select_child",
GTK_SIGNAL_FUNC (cb_select_child), tree);
gtk_signal_connect (GTK_OBJECT (tree), "unselect_child",
GTK_SIGNAL_FUNC (cb_unselect_child), tree);
gtk_signal_connect (GTK_OBJECT(tree), "selection_changed",
GTK_SIGNAL_FUNC(cb_selection_changed), tree);
/* Add it to the scrolled window */
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW(scrolled_win),
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win),
tree);
/* Set the selection mode */
gtk_tree_set_selection_mode (GTK_TREE(tree),
gtk_tree_set_selection_mode (GTK_TREE (tree),
GTK_SELECTION_MULTIPLE);
/* Show it */
gtk_widget_show (tree);
@ -111,44 +111,44 @@ int main( int argc,
/* Create a tree item */
item = gtk_tree_item_new_with_label (itemnames[i]);
/* Connect all GtkItem:: and GtkTreeItem:: signals */
gtk_signal_connect (GTK_OBJECT(item), "select",
GTK_SIGNAL_FUNC(cb_itemsignal), "select");
gtk_signal_connect (GTK_OBJECT(item), "deselect",
GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
gtk_signal_connect (GTK_OBJECT(item), "toggle",
GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
gtk_signal_connect (GTK_OBJECT(item), "expand",
GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
gtk_signal_connect (GTK_OBJECT(item), "collapse",
GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
gtk_signal_connect (GTK_OBJECT (item), "select",
GTK_SIGNAL_FUNC (cb_itemsignal), "select");
gtk_signal_connect (GTK_OBJECT (item), "deselect",
GTK_SIGNAL_FUNC (cb_itemsignal), "deselect");
gtk_signal_connect (GTK_OBJECT (item), "toggle",
GTK_SIGNAL_FUNC (cb_itemsignal), "toggle");
gtk_signal_connect (GTK_OBJECT (item), "expand",
GTK_SIGNAL_FUNC (cb_itemsignal), "expand");
gtk_signal_connect (GTK_OBJECT (item), "collapse",
GTK_SIGNAL_FUNC (cb_itemsignal), "collapse");
/* Add it to the parent tree */
gtk_tree_append (GTK_TREE(tree), item);
gtk_tree_append (GTK_TREE (tree), item);
/* Show it - this can be done at any time */
gtk_widget_show (item);
/* Create this item's subtree */
subtree = gtk_tree_new();
subtree = gtk_tree_new ();
g_print ("-> item %s->%p, subtree %p\n", itemnames[i], item,
subtree);
/* This is still necessary if you want these signals to be called
for the subtree's children. Note that selection_change will be
signalled for the root tree regardless. */
gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
GTK_SIGNAL_FUNC(cb_select_child), subtree);
gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
GTK_SIGNAL_FUNC(cb_unselect_child), subtree);
gtk_signal_connect (GTK_OBJECT (subtree), "select_child",
GTK_SIGNAL_FUNC (cb_select_child), subtree);
gtk_signal_connect (GTK_OBJECT (subtree), "unselect_child",
GTK_SIGNAL_FUNC (cb_unselect_child), subtree);
/* This has absolutely no effect, because it is completely ignored
in subtrees */
gtk_tree_set_selection_mode (GTK_TREE(subtree),
gtk_tree_set_selection_mode (GTK_TREE (subtree),
GTK_SELECTION_SINGLE);
/* Neither does this, but for a rather different reason - the
view_mode and view_line values of a tree are propagated to
subtrees when they are mapped. So, setting it later on would
actually have a (somewhat unpredictable) effect */
gtk_tree_set_view_mode (GTK_TREE(subtree), GTK_TREE_VIEW_ITEM);
gtk_tree_set_view_mode (GTK_TREE (subtree), GTK_TREE_VIEW_ITEM);
/* Set this item's subtree - note that you cannot do this until
AFTER the item has been added to its parent tree! */
gtk_tree_item_set_subtree (GTK_TREE_ITEM(item), subtree);
gtk_tree_item_set_subtree (GTK_TREE_ITEM (item), subtree);
for (j = 0; j < 5; j++){
GtkWidget *subitem;
@ -156,19 +156,19 @@ int main( int argc,
/* Create a subtree item, in much the same way */
subitem = gtk_tree_item_new_with_label (itemnames[j]);
/* Connect all GtkItem:: and GtkTreeItem:: signals */
gtk_signal_connect (GTK_OBJECT(subitem), "select",
GTK_SIGNAL_FUNC(cb_itemsignal), "select");
gtk_signal_connect (GTK_OBJECT(subitem), "deselect",
GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
gtk_signal_connect (GTK_OBJECT(subitem), "toggle",
GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
gtk_signal_connect (GTK_OBJECT(subitem), "expand",
GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
gtk_signal_connect (GTK_OBJECT(subitem), "collapse",
GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
gtk_signal_connect (GTK_OBJECT (subitem), "select",
GTK_SIGNAL_FUNC (cb_itemsignal), "select");
gtk_signal_connect (GTK_OBJECT (subitem), "deselect",
GTK_SIGNAL_FUNC (cb_itemsignal), "deselect");
gtk_signal_connect (GTK_OBJECT (subitem), "toggle",
GTK_SIGNAL_FUNC (cb_itemsignal), "toggle");
gtk_signal_connect (GTK_OBJECT (subitem), "expand",
GTK_SIGNAL_FUNC (cb_itemsignal), "expand");
gtk_signal_connect (GTK_OBJECT (subitem), "collapse",
GTK_SIGNAL_FUNC (cb_itemsignal), "collapse");
g_print ("-> -> item %s->%p\n", itemnames[j], subitem);
/* Add it to its parent tree */
gtk_tree_append (GTK_TREE(subtree), subitem);
gtk_tree_append (GTK_TREE (subtree), subitem);
/* Show it */
gtk_widget_show (subitem);
}
@ -176,6 +176,8 @@ int main( int argc,
/* Show the window and loop endlessly */
gtk_widget_show (window);
gtk_main();
return 0;
}

25
examples/wheelbarrow/wheelbarrow.c
View File

@ -141,33 +141,32 @@ int main (int argc,
* 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 );
window = gtk_window_new (GTK_WINDOW_POPUP);
g_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC (close_application), NULL);
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 );
gdk_pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
WheelbarrowFull_xpm);
pixmap = gtk_image_new_from_pixmap (gdk_pixmap, mask);
gtk_widget_show( pixmap );
gtk_widget_show (pixmap);
/* To display the pixmap, we use a fixed widget to place the pixmap */
fixed = gtk_fixed_new();
fixed = gtk_fixed_new ();
gtk_widget_set_size_request (fixed, 200, 200);
gtk_fixed_put( GTK_FIXED(fixed), pixmap, 0, 0 );
gtk_container_add( GTK_CONTAINER(window), fixed );
gtk_widget_show( fixed );
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 );
gtk_widget_shape_combine_mask (window, mask, 0, 0);
/* show the window */
/*gtk_widget_set_uposition( window, 20, 400 );*/
gtk_widget_show( window );
gtk_widget_show (window);
gtk_main ();
return 0;