From fa9b096b6bb96ae397b8b642fa7c315ed789b84a Mon Sep 17 00:00:00 2001 From: "Richard W.M. Jones" Date: Thu, 1 Jan 1970 00:00:00 +0000 Subject: [PATCH] Add some simple test programs which build Linux and Windows versions so we can check if the latest Gtk + Cairo + Wine produces something reasonable. --- .hgignore | 4 + gtk2/Makefile | 32 +++++ gtk2/test1.c | 102 ++++++++++++++ gtk2/test2.c | 97 ++++++++++++++ gtk2/test3.c | 417 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 652 insertions(+) create mode 100644 gtk2/Makefile create mode 100644 gtk2/test1.c create mode 100644 gtk2/test2.c create mode 100644 gtk2/test3.c diff --git a/.hgignore b/.hgignore index 9b9042f..9785643 100644 --- a/.hgignore +++ b/.hgignore @@ -33,6 +33,10 @@ gsl/gsl-1.11.tar.gz gtk2/gtk+-2.14.0.tar.bz2 gtk2/gtk+-2.14.2.tar.bz2 gtk2/gtk+-2.14.4.tar.bz2 +gtk2/test1 +gtk2/test2 +gtk2/test3 +gtk2/*.exe gtkmm24/gtkmm-2.14.1.tar.bz2 gtk-vnc/gtk-vnc-0.3.7.tar.gz iconv/libiconv-1.12.tar.gz diff --git a/gtk2/Makefile b/gtk2/Makefile new file mode 100644 index 0000000..7f04289 --- /dev/null +++ b/gtk2/Makefile @@ -0,0 +1,32 @@ +# Build some Gtk test programs under Wine. + +CFLAGS = -g `pkg-config --cflags gtk+-2.0` +LIBS = `pkg-config --libs gtk+-2.0` + +MINGW32_LIBDIR=/usr/i686-pc-mingw32/sys-root/mingw/lib + +all: test1 test1.exe test2 test2.exe test3 test3.exe + +test1: test1.c + gcc $(CFLAGS) $< $(LIBS) -o $@ + +test1.exe: test1.c + export PKG_CONFIG_PATH=$(MINGW32_LIBDIR)/pkgconfig; \ + i686-pc-mingw32-gcc $(CFLAGS) $< $(LIBS) -o $@ + +test2: test2.c + gcc $(CFLAGS) $< $(LIBS) -o $@ + +test2.exe: test2.c + export PKG_CONFIG_PATH=$(MINGW32_LIBDIR)/pkgconfig; \ + i686-pc-mingw32-gcc $(CFLAGS) $< $(LIBS) -o $@ + +test3: test3.c + gcc $(CFLAGS) $< $(LIBS) -o $@ + +test3.exe: test3.c + export PKG_CONFIG_PATH=$(MINGW32_LIBDIR)/pkgconfig; \ + i686-pc-mingw32-gcc $(CFLAGS) $< $(LIBS) -o $@ + +clean: + rm -f test1 test2 test3 *.exe *~ diff --git a/gtk2/test1.c b/gtk2/test1.c new file mode 100644 index 0000000..c9ff03d --- /dev/null +++ b/gtk2/test1.c @@ -0,0 +1,102 @@ +/* Hello, world from + * http://library.gnome.org/devel/gtk-tutorial/stable/c39.html#SEC-HELLOWORLD + */ + +#include + +/* 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; +} diff --git a/gtk2/test2.c b/gtk2/test2.c new file mode 100644 index 0000000..94d3a96 --- /dev/null +++ b/gtk2/test2.c @@ -0,0 +1,97 @@ +/* Two-button dialog from + * http://library.gnome.org/devel/gtk-tutorial/stable/x345.html + */ + +#include + +/* 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; +} diff --git a/gtk2/test3.c b/gtk2/test3.c new file mode 100644 index 0000000..5c1a7a1 --- /dev/null +++ b/gtk2/test3.c @@ -0,0 +1,417 @@ +/* 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 +#include +#include + +#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; +} -- 1.8.3.1