Pileus Git - ~andy/gtk/blob - tests/testadjustsize.c

   1 /* testadjustsize.c
   2  * Copyright (C) 2010 Havoc Pennington
   3  *
   4  * Author:
   5  *      Havoc Pennington <hp@pobox.com>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #include <gtk/gtk.h>
  24
  25 static GtkWidget *test_window;
  26
  27 enum {
  28   TEST_WIDGET_LABEL,
  29   TEST_WIDGET_VERTICAL_LABEL,
  30   TEST_WIDGET_WRAP_LABEL,
  31   TEST_WIDGET_ALIGNMENT,
  32   TEST_WIDGET_IMAGE,
  33   TEST_WIDGET_BUTTON,
  34   TEST_WIDGET_LAST
  35 };
  36
  37 static GtkWidget *test_widgets[TEST_WIDGET_LAST];
  38
  39 static GtkWidget*
  40 create_image (void)
  41 {
  42   return gtk_image_new_from_stock (GTK_STOCK_OPEN,
  43                                    GTK_ICON_SIZE_BUTTON);
  44 }
  45
  46 static GtkWidget*
  47 create_label (gboolean vertical,
  48               gboolean wrap)
  49 {
  50   GtkWidget *widget;
  51
  52   widget = gtk_label_new ("This is a label, label label label");
  53
  54   if (vertical)
  55     gtk_label_set_angle (GTK_LABEL (widget), 90);
  56
  57   if (wrap)
  58     gtk_label_set_line_wrap (GTK_LABEL (widget), TRUE);
  59
  60   return widget;
  61 }
  62
  63 static GtkWidget*
  64 create_button (void)
  65 {
  66   return gtk_button_new_with_label ("BUTTON!");
  67 }
  68
  69 static gboolean
  70 on_expose_alignment (GtkWidget      *widget,
  71                      GdkEventExpose *event,
  72                      void           *data)
  73 {
  74   cairo_t *cr;
  75   GtkAllocation allocation;
  76
  77   cr = gdk_cairo_create (event->window);
  78
  79   cairo_set_source_rgb (cr, 1.0, 0.0, 0.0);
  80   gtk_widget_get_allocation (widget, &allocation);
  81   cairo_rectangle (cr,
  82                    allocation.x,
  83                    allocation.y,
  84                    allocation.width,
  85                    allocation.height);
  86   cairo_fill (cr);
  87
  88   cairo_destroy (cr);
  89
  90   return FALSE;
  91 }
  92
  93 static GtkWidget*
  94 create_alignment (void)
  95 {
  96   GtkWidget *alignment;
  97
  98   alignment = gtk_alignment_new (0.5, 0.5, 1.0, 1.0);
  99
 100   /* make the alignment visible */
 101   gtk_widget_set_redraw_on_allocate (alignment, TRUE);
 102   g_signal_connect (G_OBJECT (alignment),
 103                     "expose-event",
 104                     G_CALLBACK (on_expose_alignment),
 105                     NULL);
 106
 107   return alignment;
 108 }
 109
 110 static void
 111 open_test_window (void)
 112 {
 113   GtkWidget *table;
 114   int i;
 115
 116   test_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 117   gtk_window_set_title (GTK_WINDOW (test_window), "Tests");
 118
 119   g_signal_connect (test_window, "delete-event",
 120                     G_CALLBACK (gtk_main_quit), test_window);
 121
 122   gtk_window_set_resizable (GTK_WINDOW (test_window), FALSE);
 123
 124   test_widgets[TEST_WIDGET_IMAGE] = create_image ();
 125   test_widgets[TEST_WIDGET_LABEL] = create_label (FALSE, FALSE);
 126   test_widgets[TEST_WIDGET_VERTICAL_LABEL] = create_label (TRUE, FALSE);
 127   test_widgets[TEST_WIDGET_WRAP_LABEL] = create_label (FALSE, TRUE);
 128   test_widgets[TEST_WIDGET_BUTTON] = create_button ();
 129   test_widgets[TEST_WIDGET_ALIGNMENT] = create_alignment ();
 130
 131   table = gtk_table_new (2, 3, FALSE);
 132
 133   gtk_container_add (GTK_CONTAINER (test_window), table);
 134
 135   for (i = 0; i < TEST_WIDGET_LAST; ++i)
 136     {
 137       gtk_table_attach (GTK_TABLE (table),
 138                         test_widgets[i],
 139                         i % 3,
 140                         i % 3 + 1,
 141                         i / 3,
 142                         i / 3 + 1,
 143                         0, 0, 0, 0);
 144     }
 145
 146   gtk_widget_show_all (test_window);
 147 }
 148
 149 static void
 150 on_toggle_border_widths (GtkToggleButton *button,
 151                          void            *data)
 152 {
 153   gboolean has_border;
 154   int i;
 155
 156   has_border = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button));
 157
 158   for (i = 0; i < TEST_WIDGET_LAST; ++i)
 159     {
 160       if (GTK_IS_CONTAINER (test_widgets[i]))
 161         {
 162           gtk_container_set_border_width (GTK_CONTAINER (test_widgets[i]),
 163                                           has_border ? 50 : 0);
 164         }
 165     }
 166 }
 167
 168 static void
 169 on_set_small_size_requests (GtkToggleButton *button,
 170                             void            *data)
 171 {
 172   gboolean has_small_size_requests;
 173   int i;
 174
 175   has_small_size_requests = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button));
 176
 177   for (i = 0; i < TEST_WIDGET_LAST; ++i)
 178     {
 179       gtk_widget_set_size_request (test_widgets[i],
 180                                    has_small_size_requests ? 5 : -1,
 181                                    has_small_size_requests ? 5 : -1);
 182     }
 183 }
 184
 185 static void
 186 on_set_large_size_requests (GtkToggleButton *button,
 187                             void            *data)
 188 {
 189   gboolean has_large_size_requests;
 190   int i;
 191
 192   has_large_size_requests = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button));
 193
 194   for (i = 0; i < TEST_WIDGET_LAST; ++i)
 195     {
 196       gtk_widget_set_size_request (test_widgets[i],
 197                                    has_large_size_requests ? 200 : -1,
 198                                    has_large_size_requests ? 200 : -1);
 199     }
 200 }
 201
 202 static void
 203 open_control_window (void)
 204 {
 205   GtkWidget *window;
 206   GtkWidget *box;
 207   GtkWidget *toggle;
 208
 209   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 210   gtk_window_set_title (GTK_WINDOW (window), "Controls");
 211
 212   g_signal_connect (window, "delete-event",
 213                     G_CALLBACK (gtk_main_quit), window);
 214
 215   box = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 0);
 216   gtk_container_add (GTK_CONTAINER (window), box);
 217
 218   toggle =
 219     gtk_toggle_button_new_with_label ("Containers have borders");
 220   g_signal_connect (G_OBJECT (toggle),
 221                     "toggled", G_CALLBACK (on_toggle_border_widths),
 222                     NULL);
 223   gtk_container_add (GTK_CONTAINER (box), toggle);
 224
 225   toggle =
 226     gtk_toggle_button_new_with_label ("Set small size requests");
 227   g_signal_connect (G_OBJECT (toggle),
 228                     "toggled", G_CALLBACK (on_set_small_size_requests),
 229                     NULL);
 230   gtk_container_add (GTK_CONTAINER (box), toggle);
 231
 232   toggle =
 233     gtk_toggle_button_new_with_label ("Set large size requests");
 234   g_signal_connect (G_OBJECT (toggle),
 235                     "toggled", G_CALLBACK (on_set_large_size_requests),
 236                     NULL);
 237   gtk_container_add (GTK_CONTAINER (box), toggle);
 238
 239
 240   gtk_widget_show_all (window);
 241 }
 242
 243 #define TEST_WIDGET(outer) (gtk_bin_get_child (GTK_BIN (gtk_bin_get_child (GTK_BIN(outer)))))
 244
 245 static GtkWidget*
 246 create_widget_visible_border (const char *text)
 247 {
 248   GtkWidget *outer_box;
 249   GtkWidget *inner_box;
 250   GtkWidget *test_widget;
 251   GtkWidget *label;
 252   GdkColor color;
 253
 254   outer_box = gtk_event_box_new ();
 255   gdk_color_parse ("black", &color);
 256   gtk_widget_modify_bg (outer_box, GTK_STATE_NORMAL, &color);
 257
 258   inner_box = gtk_event_box_new ();
 259   gtk_container_set_border_width (GTK_CONTAINER (inner_box), 5);
 260   gdk_color_parse ("blue", &color);
 261   gtk_widget_modify_bg (inner_box, GTK_STATE_NORMAL, &color);
 262
 263   gtk_container_add (GTK_CONTAINER (outer_box), inner_box);
 264
 265
 266   test_widget = gtk_event_box_new ();
 267   gdk_color_parse ("red", &color);
 268   gtk_widget_modify_bg (test_widget, GTK_STATE_NORMAL, &color);
 269
 270   gtk_container_add (GTK_CONTAINER (inner_box), test_widget);
 271
 272   label = gtk_label_new (text);
 273   gtk_container_add (GTK_CONTAINER (test_widget), label);
 274
 275   g_assert (TEST_WIDGET (outer_box) == test_widget);
 276
 277   gtk_widget_show_all (outer_box);
 278
 279   return outer_box;
 280 }
 281
 282 static const char*
 283 enum_to_string (GType enum_type,
 284                 int   value)
 285 {
 286   GEnumValue *v;
 287
 288   v = g_enum_get_value (g_type_class_peek (enum_type), value);
 289
 290   return v->value_nick;
 291 }
 292
 293 static GtkWidget*
 294 create_aligned (GtkAlign halign,
 295                 GtkAlign valign)
 296 {
 297   GtkWidget *widget;
 298   char *label;
 299
 300   label = g_strdup_printf ("h=%s v=%s",
 301                            enum_to_string (GTK_TYPE_ALIGN, halign),
 302                            enum_to_string (GTK_TYPE_ALIGN, valign));
 303
 304   widget = create_widget_visible_border (label);
 305
 306   g_object_set (G_OBJECT (TEST_WIDGET (widget)),
 307                 "halign", halign,
 308                 "valign", valign,
 309                 NULL);
 310
 311   return widget;
 312 }
 313
 314 static void
 315 open_alignment_window (void)
 316 {
 317   GtkWidget *table;
 318   int i;
 319   GEnumClass *align_class;
 320
 321   test_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 322   gtk_window_set_title (GTK_WINDOW (test_window), "Alignment");
 323
 324   g_signal_connect (test_window, "delete-event",
 325                     G_CALLBACK (gtk_main_quit), test_window);
 326
 327   gtk_window_set_resizable (GTK_WINDOW (test_window), TRUE);
 328   gtk_window_set_default_size (GTK_WINDOW (test_window), 500, 500);
 329
 330   align_class = g_type_class_peek (GTK_TYPE_ALIGN);
 331
 332   table = gtk_table_new (align_class->n_values, align_class->n_values, TRUE);
 333
 334   gtk_container_add (GTK_CONTAINER (test_window), table);
 335
 336   for (i = 0; i < align_class->n_values; ++i)
 337     {
 338       int j;
 339       for (j = 0; j < align_class->n_values; ++j)
 340         {
 341           GtkWidget *child =
 342             create_aligned(align_class->values[i].value,
 343                            align_class->values[j].value);
 344
 345           gtk_table_attach (GTK_TABLE (table),
 346                             child,
 347                             i, i + 1,
 348                             j, j + 1,
 349                             GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 350         }
 351     }
 352
 353   gtk_widget_show_all (test_window);
 354 }
 355
 356 static GtkWidget*
 357 create_margined (const char *propname)
 358 {
 359   GtkWidget *widget;
 360
 361   widget = create_widget_visible_border (propname);
 362
 363   g_object_set (G_OBJECT (TEST_WIDGET (widget)),
 364                 propname, 15,
 365                 NULL);
 366
 367   return widget;
 368 }
 369
 370 static void
 371 open_margin_window (void)
 372 {
 373   GtkWidget *table;
 374   int i;
 375   const char * margins[] = {
 376     "margin-left",
 377     "margin-right",
 378     "margin-top",
 379     "margin-bottom",
 380     "margin"
 381   };
 382
 383   test_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 384   gtk_window_set_title (GTK_WINDOW (test_window), "Margin");
 385
 386   g_signal_connect (test_window, "delete-event",
 387                     G_CALLBACK (gtk_main_quit), test_window);
 388
 389   gtk_window_set_resizable (GTK_WINDOW (test_window), TRUE);
 390
 391   table = gtk_table_new (G_N_ELEMENTS (margins), 1, FALSE);
 392
 393   gtk_container_add (GTK_CONTAINER (test_window), table);
 394
 395   for (i = 0; i < (int) G_N_ELEMENTS (margins); ++i)
 396     {
 397       GtkWidget *child =
 398         create_margined(margins[i]);
 399
 400       gtk_table_attach (GTK_TABLE (table),
 401                         child,
 402                         0, 1,
 403                         i, i + 1,
 404                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 405     }
 406
 407   gtk_widget_show_all (test_window);
 408 }
 409
 410 int
 411 main (int argc, char *argv[])
 412 {
 413   gtk_init (&argc, &argv);
 414
 415   open_test_window ();
 416   open_control_window ();
 417   open_alignment_window ();
 418   open_margin_window ();
 419
 420   gtk_main ();
 421
 422   return 0;
 423 }