--- /dev/null
+/* Hello, world from
+ * http://library.gnome.org/devel/gtk-tutorial/stable/c39.html#SEC-HELLOWORLD
+ */
+
+#include <gtk/gtk.h>
+
+/* This is a callback function. The data arguments are ignored
+ * in this example. More on callbacks below. */
+static void hello( GtkWidget *widget,
+ gpointer data )
+{
+ g_print ("Hello World\n");
+}
+
+static gboolean delete_event( GtkWidget *widget,
+ GdkEvent *event,
+ gpointer data )
+{
+ /* If you return FALSE in the "delete_event" signal handler,
+ * GTK will emit the "destroy" signal. Returning TRUE means
+ * you don't want the window to be destroyed.
+ * This is useful for popping up 'are you sure you want to quit?'
+ * type dialogs. */
+
+ g_print ("delete event occurred\n");
+
+ /* Change TRUE to FALSE and the main window will be destroyed with
+ * a "delete_event". */
+
+ return TRUE;
+}
+
+/* Another callback */
+static void destroy( GtkWidget *widget,
+ gpointer data )
+{
+ gtk_main_quit ();
+}
+
+int main( int argc,
+ char *argv[] )
+{
+ /* GtkWidget is the storage type for widgets */
+ GtkWidget *window;
+ GtkWidget *button;
+
+ /* This is called in all GTK applications. Arguments are parsed
+ * from the command line and are returned to the application. */
+ gtk_init (&argc, &argv);
+
+ /* create a new window */
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ /* When the window is given the "delete_event" signal (this is given
+ * by the window manager, usually by the "close" option, or on the
+ * titlebar), we ask it to call the delete_event () function
+ * as defined above. The data passed to the callback
+ * function is NULL and is ignored in the callback function. */
+ g_signal_connect (G_OBJECT (window), "delete_event",
+ G_CALLBACK (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 (G_OBJECT (window), "destroy",
+ G_CALLBACK (destroy), NULL);
+
+ /* Sets the border width of the window. */
+ gtk_container_set_border_width (GTK_CONTAINER (window), 10);
+
+ /* Creates a new button with the label "Hello World". */
+ button = gtk_button_new_with_label ("Hello World");
+
+ /* When the button receives the "clicked" signal, it will call the
+ * function hello() passing it NULL as its argument. The hello()
+ * function is defined above. */
+ g_signal_connect (G_OBJECT (button), "clicked",
+ G_CALLBACK (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 (G_OBJECT (button), "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ G_OBJECT (window));
+
+ /* This packs the button into the window (a gtk container). */
+ gtk_container_add (GTK_CONTAINER (window), button);
+
+ /* The final step is to display this newly created widget. */
+ gtk_widget_show (button);
+
+ /* and the window */
+ gtk_widget_show (window);
+
+ /* All GTK applications must have a gtk_main(). Control ends here
+ * and waits for an event to occur (like a key press or
+ * mouse event). */
+ gtk_main ();
+
+ return 0;
+}
--- /dev/null
+/* Two-button dialog from
+ * http://library.gnome.org/devel/gtk-tutorial/stable/x345.html
+ */
+
+#include <gtk/gtk.h>
+
+/* Our new improved callback. The data passed to this function
+ * is printed to stdout. */
+static void callback( GtkWidget *widget,
+ gpointer data )
+{
+ g_print ("Hello again - %s was pressed\n", (gchar *) data);
+}
+
+/* another callback */
+static gboolean delete_event( GtkWidget *widget,
+ GdkEvent *event,
+ gpointer data )
+{
+ gtk_main_quit ();
+ return FALSE;
+}
+
+int main( int argc,
+ char *argv[] )
+{
+ /* GtkWidget is the storage type for widgets */
+ GtkWidget *window;
+ GtkWidget *button;
+ GtkWidget *box1;
+
+ /* This is called in all GTK applications. Arguments are parsed
+ * from the command line and are returned to the application. */
+ gtk_init (&argc, &argv);
+
+ /* Create a new window */
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ /* This is a new call, which just sets the title of our
+ * new window to "Hello Buttons!" */
+ gtk_window_set_title (GTK_WINDOW (window), "Hello Buttons!");
+
+ /* Here we just set a handler for delete_event that immediately
+ * exits GTK. */
+ g_signal_connect (G_OBJECT (window), "delete_event",
+ G_CALLBACK (delete_event), NULL);
+
+ /* Sets the border width of the window. */
+ gtk_container_set_border_width (GTK_CONTAINER (window), 10);
+
+ /* 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);
+
+ /* Put the box into the main window. */
+ gtk_container_add (GTK_CONTAINER (window), box1);
+
+ /* Creates a new button with the label "Button 1". */
+ button = gtk_button_new_with_label ("Button 1");
+
+ /* Now when the button is clicked, we call the "callback" function
+ * with a pointer to "button 1" as its argument */
+ g_signal_connect (G_OBJECT (button), "clicked",
+ G_CALLBACK (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);
+
+ /* 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);
+
+ /* Do these same steps again to create a second button */
+ button = gtk_button_new_with_label ("Button 2");
+
+ /* Call the same callback function with a different argument,
+ * passing a pointer to "button 2" instead. */
+ g_signal_connect (G_OBJECT (button), "clicked",
+ G_CALLBACK (callback), (gpointer) "button 2");
+
+ 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 (box1);
+
+ gtk_widget_show (window);
+
+ /* Rest in gtk_main and wait for the fun to begin! */
+ gtk_main ();
+
+ return 0;
+}
--- /dev/null
+/* Calendar tutorial from
+ * http://library.gnome.org/devel/gtk-tutorial/stable/x1102.html
+ */
+
+/*
+ * Copyright (C) 1998 Cesar Miquel, Shawn T. Amundson, Mattias Gr�nlund
+ * Copyright (C) 2000 Tony Gale
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <gtk/gtk.h>
+
+#define DEF_PAD 10
+#define DEF_PAD_SMALL 5
+
+#define TM_YEAR_BASE 1900
+
+typedef struct _CalendarData {
+ GtkWidget *flag_checkboxes[5];
+ gboolean settings[5];
+ GtkWidget *font_dialog;
+ GtkWidget *window;
+ GtkWidget *prev2_sig;
+ GtkWidget *prev_sig;
+ GtkWidget *last_sig;
+ GtkWidget *month;
+} CalendarData;
+
+enum {
+ calendar_show_header,
+ calendar_show_days,
+ calendar_month_change,
+ calendar_show_week,
+ calendar_monday_first
+};
+
+/*
+ * GtkCalendar
+ */
+
+static void calendar_date_to_string( CalendarData *data,
+ char *buffer,
+ gint buff_len )
+{
+ GDate date;
+ guint year, month, day;
+
+ gtk_calendar_get_date (GTK_CALENDAR (data->window),
+ &year, &month, &day);
+ g_date_set_dmy (&date, day, month + 1, year);
+ g_date_strftime (buffer, buff_len - 1, "%x", &date);
+
+}
+
+static void calendar_set_signal_strings( char *sig_str,
+ CalendarData *data )
+{
+ const gchar *prev_sig;
+
+ prev_sig = gtk_label_get_text (GTK_LABEL (data->prev_sig));
+ gtk_label_set_text (GTK_LABEL (data->prev2_sig), prev_sig);
+
+ prev_sig = gtk_label_get_text (GTK_LABEL (data->last_sig));
+ gtk_label_set_text (GTK_LABEL (data->prev_sig), prev_sig);
+ gtk_label_set_text (GTK_LABEL (data->last_sig), sig_str);
+}
+
+static void calendar_month_changed( GtkWidget *widget,
+ CalendarData *data )
+{
+ char buffer[256] = "month_changed: ";
+
+ calendar_date_to_string (data, buffer + 15, 256 - 15);
+ calendar_set_signal_strings (buffer, data);
+}
+
+static void calendar_day_selected( GtkWidget *widget,
+ CalendarData *data )
+{
+ char buffer[256] = "day_selected: ";
+
+ calendar_date_to_string (data, buffer + 14, 256 - 14);
+ calendar_set_signal_strings (buffer, data);
+}
+
+static void calendar_day_selected_double_click ( GtkWidget *widget,
+ CalendarData *data )
+{
+ char buffer[256] = "day_selected_double_click: ";
+ guint day;
+
+ calendar_date_to_string (data, buffer + 27, 256 - 27);
+ calendar_set_signal_strings (buffer, data);
+
+ gtk_calendar_get_date (GTK_CALENDAR (data->window),
+ NULL, NULL, &day);
+
+ if (GTK_CALENDAR (data->window)->marked_date[day-1] == 0) {
+ gtk_calendar_mark_day (GTK_CALENDAR (data->window), day);
+ } else {
+ gtk_calendar_unmark_day (GTK_CALENDAR (data->window), day);
+ }
+}
+
+static void calendar_prev_month( GtkWidget *widget,
+ CalendarData *data )
+{
+ char buffer[256] = "prev_month: ";
+
+ calendar_date_to_string (data, buffer + 12, 256 - 12);
+ calendar_set_signal_strings (buffer, data);
+}
+
+static void calendar_next_month( GtkWidget *widget,
+ CalendarData *data )
+{
+ char buffer[256] = "next_month: ";
+
+ calendar_date_to_string (data, buffer + 12, 256 - 12);
+ calendar_set_signal_strings (buffer, data);
+}
+
+static void calendar_prev_year( GtkWidget *widget,
+ CalendarData *data )
+{
+ char buffer[256] = "prev_year: ";
+
+ calendar_date_to_string (data, buffer + 11, 256 - 11);
+ calendar_set_signal_strings (buffer, data);
+}
+
+static void calendar_next_year( GtkWidget *widget,
+ CalendarData *data )
+{
+ char buffer[256] = "next_year: ";
+
+ calendar_date_to_string (data, buffer + 11, 256 - 11);
+ calendar_set_signal_strings (buffer, data);
+}
+
+
+static void calendar_set_flags( CalendarData *calendar )
+{
+ gint i;
+ gint options = 0;
+ for (i = 0;i < 5; i++)
+ if (calendar->settings[i])
+ {
+ options = options + (1 << i);
+ }
+ if (calendar->window)
+ gtk_calendar_display_options (GTK_CALENDAR (calendar->window), options);
+}
+
+static void calendar_toggle_flag( GtkWidget *toggle,
+ CalendarData *calendar)
+{
+ gint i;
+ gint j;
+ 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);
+
+}
+
+static void calendar_font_selection_ok( GtkWidget *button,
+ CalendarData *calendar )
+{
+ GtkRcStyle *style;
+ char *font_name;
+
+ if (calendar->window)
+ {
+ font_name = gtk_font_selection_dialog_get_font_name (GTK_FONT_SELECTION_DIALOG (calendar->font_dialog));
+ if (font_name)
+ {
+ style = gtk_rc_style_new ();
+ pango_font_description_free (style->font_desc);
+ style->font_desc = pango_font_description_from_string (font_name);
+ gtk_widget_modify_style (calendar->window, style);
+ g_free (font_name);
+ }
+ }
+
+ gtk_widget_destroy (calendar->font_dialog);
+}
+
+static void calendar_select_font( GtkWidget *button,
+ CalendarData *calendar )
+{
+ GtkWidget *window;
+
+ if (!calendar->font_dialog) {
+ window = gtk_font_selection_dialog_new ("Font Selection Dialog");
+ 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);
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &calendar->font_dialog);
+
+ g_signal_connect (GTK_FONT_SELECTION_DIALOG (window)->ok_button,
+ "clicked", G_CALLBACK (calendar_font_selection_ok),
+ calendar);
+ g_signal_connect_swapped (GTK_FONT_SELECTION_DIALOG (window)->cancel_button,
+ "clicked", G_CALLBACK (gtk_widget_destroy),
+ calendar->font_dialog);
+ }
+ window = calendar->font_dialog;
+ if (!GTK_WIDGET_VISIBLE (window))
+ gtk_widget_show (window);
+ else
+ gtk_widget_destroy (window);
+
+}
+
+static void create_calendar( void )
+{
+ GtkWidget *window;
+ GtkWidget *vbox, *vbox2, *vbox3;
+ GtkWidget *hbox;
+ GtkWidget *hbbox;
+ GtkWidget *calendar;
+ GtkWidget *toggle;
+ GtkWidget *button;
+ GtkWidget *frame;
+ GtkWidget *separator;
+ GtkWidget *label;
+ GtkWidget *bbox;
+ static CalendarData calendar_data;
+ gint i;
+
+ struct {
+ char *label;
+ } flags[] =
+ {
+ { "Show Heading" },
+ { "Show Day Names" },
+ { "No Month Change" },
+ { "Show Week Numbers" },
+ { "Week Start Monday" }
+ };
+
+
+ calendar_data.window = NULL;
+ calendar_data.font_dialog = NULL;
+
+ 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_container_set_border_width (GTK_CONTAINER (window), 5);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_main_quit),
+ NULL);
+ g_signal_connect (window, "delete-event",
+ G_CALLBACK (gtk_false),
+ NULL);
+ gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+
+ 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);
+ 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 ();
+ calendar_data.window = calendar;
+ calendar_set_flags (&calendar_data);
+ gtk_calendar_mark_day (GTK_CALENDAR (calendar), 19);
+ gtk_container_add (GTK_CONTAINER (frame), calendar);
+ g_signal_connect (calendar, "month_changed",
+ G_CALLBACK (calendar_month_changed),
+ &calendar_data);
+ g_signal_connect (calendar, "day_selected",
+ G_CALLBACK (calendar_day_selected),
+ &calendar_data);
+ g_signal_connect (calendar, "day_selected_double_click",
+ G_CALLBACK (calendar_day_selected_double_click),
+ &calendar_data);
+ g_signal_connect (calendar, "prev_month",
+ G_CALLBACK (calendar_prev_month),
+ &calendar_data);
+ g_signal_connect (calendar, "next_month",
+ G_CALLBACK (calendar_next_month),
+ &calendar_data);
+ g_signal_connect (calendar, "prev_year",
+ G_CALLBACK (calendar_prev_year),
+ &calendar_data);
+ g_signal_connect (calendar, "next_year",
+ G_CALLBACK (calendar_next_year),
+ &calendar_data);
+
+
+ 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);
+
+ /* 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);
+
+ for (i = 0; i < 5; i++)
+ {
+ toggle = gtk_check_button_new_with_label (flags[i].label);
+ g_signal_connect (toggle,
+ "toggled",
+ G_CALLBACK (calendar_toggle_flag),
+ &calendar_data);
+ gtk_box_pack_start (GTK_BOX (vbox3), toggle, TRUE, TRUE, 0);
+ calendar_data.flag_checkboxes[i] = toggle;
+ }
+ /* Build the right font-button */
+ button = gtk_button_new_with_label ("Font...");
+ g_signal_connect (button,
+ "clicked",
+ G_CALLBACK (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);
+
+ 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);
+ label = gtk_label_new ("Signal:");
+ gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
+ calendar_data.last_sig = gtk_label_new ("");
+ gtk_box_pack_start (GTK_BOX (hbox), calendar_data.last_sig, FALSE, TRUE, 0);
+
+ hbox = gtk_hbox_new (FALSE, 3);
+ gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, TRUE, 0);
+ label = gtk_label_new ("Previous signal:");
+ gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
+ calendar_data.prev_sig = gtk_label_new ("");
+ gtk_box_pack_start (GTK_BOX (hbox), calendar_data.prev_sig, FALSE, TRUE, 0);
+
+ hbox = gtk_hbox_new (FALSE, 3);
+ gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, TRUE, 0);
+ label = gtk_label_new ("Second previous signal:");
+ gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
+ calendar_data.prev2_sig = gtk_label_new ("");
+ gtk_box_pack_start (GTK_BOX (hbox), calendar_data.prev2_sig, FALSE, TRUE, 0);
+
+ 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);
+
+ button = gtk_button_new_with_label ("Close");
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (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);
+}
+
+
+int main (int argc,
+ char *argv[])
+{
+ gtk_init (&argc, &argv);
+
+ create_calendar ();
+
+ gtk_main ();
+
+ return 0;
+}
git.annexia.org / fedora-mingw.git / commitdiff