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_draw_alignment (GtkWidget      *widget,
  71                    cairo_t        *cr,
  72                    void           *data)
  73 {
  74   cairo_set_source_rgb (cr, 1.0, 0.0, 0.0);
  75   cairo_paint (cr);
  76
  77   return FALSE;
  78 }
  79
  80 static GtkWidget*
  81 create_alignment (void)
  82 {
  83   GtkWidget *alignment;
  84
  85   alignment = gtk_alignment_new (0.5, 0.5, 1.0, 1.0);
  86
  87   /* make the alignment visible */
  88   gtk_widget_set_redraw_on_allocate (alignment, TRUE);
  89   g_signal_connect (G_OBJECT (alignment),
  90                     "draw",
  91                     G_CALLBACK (on_draw_alignment),
  92                     NULL);
  93
  94   return alignment;
  95 }
  96
  97 static void
  98 open_test_window (void)
  99 {
 100   GtkWidget *table;
 101   int i;
 102
 103   test_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 104   gtk_window_set_title (GTK_WINDOW (test_window), "Tests");
 105
 106   g_signal_connect (test_window, "delete-event",
 107                     G_CALLBACK (gtk_main_quit), test_window);
 108
 109   gtk_window_set_resizable (GTK_WINDOW (test_window), FALSE);
 110
 111   test_widgets[TEST_WIDGET_IMAGE] = create_image ();
 112   test_widgets[TEST_WIDGET_LABEL] = create_label (FALSE, FALSE);
 113   test_widgets[TEST_WIDGET_VERTICAL_LABEL] = create_label (TRUE, FALSE);
 114   test_widgets[TEST_WIDGET_WRAP_LABEL] = create_label (FALSE, TRUE);
 115   test_widgets[TEST_WIDGET_BUTTON] = create_button ();
 116   test_widgets[TEST_WIDGET_ALIGNMENT] = create_alignment ();
 117
 118   table = gtk_table_new (2, 3, FALSE);
 119
 120   gtk_container_add (GTK_CONTAINER (test_window), table);
 121
 122   for (i = 0; i < TEST_WIDGET_LAST; ++i)
 123     {
 124       gtk_table_attach (GTK_TABLE (table),
 125                         test_widgets[i],
 126                         i % 3,
 127                         i % 3 + 1,
 128                         i / 3,
 129                         i / 3 + 1,
 130                         0, 0, 0, 0);
 131     }
 132
 133   gtk_widget_show_all (test_window);
 134 }
 135
 136 static void
 137 on_toggle_border_widths (GtkToggleButton *button,
 138                          void            *data)
 139 {
 140   gboolean has_border;
 141   int i;
 142
 143   has_border = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button));
 144
 145   for (i = 0; i < TEST_WIDGET_LAST; ++i)
 146     {
 147       if (GTK_IS_CONTAINER (test_widgets[i]))
 148         {
 149           gtk_container_set_border_width (GTK_CONTAINER (test_widgets[i]),
 150                                           has_border ? 50 : 0);
 151         }
 152     }
 153 }
 154
 155 static void
 156 on_set_small_size_requests (GtkToggleButton *button,
 157                             void            *data)
 158 {
 159   gboolean has_small_size_requests;
 160   int i;
 161
 162   has_small_size_requests = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button));
 163
 164   for (i = 0; i < TEST_WIDGET_LAST; ++i)
 165     {
 166       gtk_widget_set_size_request (test_widgets[i],
 167                                    has_small_size_requests ? 5 : -1,
 168                                    has_small_size_requests ? 5 : -1);
 169     }
 170 }
 171
 172 static void
 173 on_set_large_size_requests (GtkToggleButton *button,
 174                             void            *data)
 175 {
 176   gboolean has_large_size_requests;
 177   int i;
 178
 179   has_large_size_requests = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button));
 180
 181   for (i = 0; i < TEST_WIDGET_LAST; ++i)
 182     {
 183       gtk_widget_set_size_request (test_widgets[i],
 184                                    has_large_size_requests ? 200 : -1,
 185                                    has_large_size_requests ? 200 : -1);
 186     }
 187 }
 188
 189 static void
 190 open_control_window (void)
 191 {
 192   GtkWidget *window;
 193   GtkWidget *box;
 194   GtkWidget *toggle;
 195
 196   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 197   gtk_window_set_title (GTK_WINDOW (window), "Controls");
 198
 199   g_signal_connect (window, "delete-event",
 200                     G_CALLBACK (gtk_main_quit), window);
 201
 202   box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
 203   gtk_container_add (GTK_CONTAINER (window), box);
 204
 205   toggle =
 206     gtk_toggle_button_new_with_label ("Containers have borders");
 207   g_signal_connect (G_OBJECT (toggle),
 208                     "toggled", G_CALLBACK (on_toggle_border_widths),
 209                     NULL);
 210   gtk_container_add (GTK_CONTAINER (box), toggle);
 211
 212   toggle =
 213     gtk_toggle_button_new_with_label ("Set small size requests");
 214   g_signal_connect (G_OBJECT (toggle),
 215                     "toggled", G_CALLBACK (on_set_small_size_requests),
 216                     NULL);
 217   gtk_container_add (GTK_CONTAINER (box), toggle);
 218
 219   toggle =
 220     gtk_toggle_button_new_with_label ("Set large size requests");
 221   g_signal_connect (G_OBJECT (toggle),
 222                     "toggled", G_CALLBACK (on_set_large_size_requests),
 223                     NULL);
 224   gtk_container_add (GTK_CONTAINER (box), toggle);
 225
 226
 227   gtk_widget_show_all (window);
 228 }
 229
 230 #define TEST_WIDGET(outer) (gtk_bin_get_child (GTK_BIN (gtk_bin_get_child (GTK_BIN(outer)))))
 231
 232 static GtkWidget*
 233 create_widget_visible_border (const char *text)
 234 {
 235   GtkWidget *outer_box;
 236   GtkWidget *inner_box;
 237   GtkWidget *test_widget;
 238   GtkWidget *label;
 239   GdkColor color;
 240
 241   outer_box = gtk_event_box_new ();
 242   gdk_color_parse ("black", &color);
 243   gtk_widget_modify_bg (outer_box, GTK_STATE_NORMAL, &color);
 244
 245   inner_box = gtk_event_box_new ();
 246   gtk_container_set_border_width (GTK_CONTAINER (inner_box), 5);
 247   gdk_color_parse ("blue", &color);
 248   gtk_widget_modify_bg (inner_box, GTK_STATE_NORMAL, &color);
 249
 250   gtk_container_add (GTK_CONTAINER (outer_box), inner_box);
 251
 252
 253   test_widget = gtk_event_box_new ();
 254   gdk_color_parse ("red", &color);
 255   gtk_widget_modify_bg (test_widget, GTK_STATE_NORMAL, &color);
 256
 257   gtk_container_add (GTK_CONTAINER (inner_box), test_widget);
 258
 259   label = gtk_label_new (text);
 260   gtk_container_add (GTK_CONTAINER (test_widget), label);
 261
 262   g_assert (TEST_WIDGET (outer_box) == test_widget);
 263
 264   gtk_widget_show_all (outer_box);
 265
 266   return outer_box;
 267 }
 268
 269 static const char*
 270 enum_to_string (GType enum_type,
 271                 int   value)
 272 {
 273   GEnumValue *v;
 274
 275   v = g_enum_get_value (g_type_class_peek (enum_type), value);
 276
 277   return v->value_nick;
 278 }
 279
 280 static GtkWidget*
 281 create_aligned (GtkAlign halign,
 282                 GtkAlign valign)
 283 {
 284   GtkWidget *widget;
 285   char *label;
 286
 287   label = g_strdup_printf ("h=%s v=%s",
 288                            enum_to_string (GTK_TYPE_ALIGN, halign),
 289                            enum_to_string (GTK_TYPE_ALIGN, valign));
 290
 291   widget = create_widget_visible_border (label);
 292
 293   g_object_set (G_OBJECT (TEST_WIDGET (widget)),
 294                 "halign", halign,
 295                 "valign", valign,
 296                 NULL);
 297
 298   return widget;
 299 }
 300
 301 static void
 302 open_alignment_window (void)
 303 {
 304   GtkWidget *table;
 305   int i;
 306   GEnumClass *align_class;
 307
 308   test_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 309   gtk_window_set_title (GTK_WINDOW (test_window), "Alignment");
 310
 311   g_signal_connect (test_window, "delete-event",
 312                     G_CALLBACK (gtk_main_quit), test_window);
 313
 314   gtk_window_set_resizable (GTK_WINDOW (test_window), TRUE);
 315   gtk_window_set_default_size (GTK_WINDOW (test_window), 500, 500);
 316
 317   align_class = g_type_class_peek (GTK_TYPE_ALIGN);
 318
 319   table = gtk_table_new (align_class->n_values, align_class->n_values, TRUE);
 320
 321   gtk_container_add (GTK_CONTAINER (test_window), table);
 322
 323   for (i = 0; i < align_class->n_values; ++i)
 324     {
 325       int j;
 326       for (j = 0; j < align_class->n_values; ++j)
 327         {
 328           GtkWidget *child =
 329             create_aligned(align_class->values[i].value,
 330                            align_class->values[j].value);
 331
 332           gtk_table_attach (GTK_TABLE (table),
 333                             child,
 334                             i, i + 1,
 335                             j, j + 1,
 336                             GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 337         }
 338     }
 339
 340   gtk_widget_show_all (test_window);
 341 }
 342
 343 static GtkWidget*
 344 create_margined (const char *propname)
 345 {
 346   GtkWidget *widget;
 347
 348   widget = create_widget_visible_border (propname);
 349
 350   g_object_set (G_OBJECT (TEST_WIDGET (widget)),
 351                 propname, 15,
 352                 NULL);
 353
 354   return widget;
 355 }
 356
 357 static void
 358 open_margin_window (void)
 359 {
 360   GtkWidget *table;
 361   int i;
 362   const char * margins[] = {
 363     "margin-left",
 364     "margin-right",
 365     "margin-top",
 366     "margin-bottom",
 367     "margin"
 368   };
 369
 370   test_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 371   gtk_window_set_title (GTK_WINDOW (test_window), "Margin");
 372
 373   g_signal_connect (test_window, "delete-event",
 374                     G_CALLBACK (gtk_main_quit), test_window);
 375
 376   gtk_window_set_resizable (GTK_WINDOW (test_window), TRUE);
 377
 378   table = gtk_table_new (G_N_ELEMENTS (margins), 1, FALSE);
 379
 380   gtk_container_add (GTK_CONTAINER (test_window), table);
 381
 382   for (i = 0; i < (int) G_N_ELEMENTS (margins); ++i)
 383     {
 384       GtkWidget *child =
 385         create_margined(margins[i]);
 386
 387       gtk_table_attach (GTK_TABLE (table),
 388                         child,
 389                         0, 1,
 390                         i, i + 1,
 391                         GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 392     }
 393
 394   gtk_widget_show_all (test_window);
 395 }
 396
 397 static void
 398 open_valigned_label_window (void)
 399 {
 400   GtkWidget *window, *box, *label, *frame;
 401
 402   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 403
 404   g_signal_connect (test_window, "delete-event",
 405                     G_CALLBACK (gtk_main_quit), test_window);
 406
 407   box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
 408   gtk_widget_show (box);
 409   gtk_container_add (GTK_CONTAINER (window), box);
 410
 411   label = gtk_label_new ("Both labels expand");
 412   gtk_widget_show (label);
 413   gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0);
 414
 415   label = gtk_label_new ("Some wrapping text with width-chars = 15 and max-width-chars = 35");
 416   gtk_label_set_line_wrap  (GTK_LABEL (label), TRUE);
 417   gtk_label_set_width_chars  (GTK_LABEL (label), 15);
 418   gtk_label_set_max_width_chars  (GTK_LABEL (label), 35);
 419
 420   gtk_widget_show (label);
 421
 422   frame  = gtk_frame_new (NULL);
 423   gtk_widget_show (frame);
 424   gtk_container_add (GTK_CONTAINER (frame), label);
 425
 426   gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
 427   gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
 428
 429   gtk_box_pack_start (GTK_BOX (box), frame, TRUE, TRUE, 0);
 430
 431   gtk_window_present (GTK_WINDOW (window));
 432 }
 433
 434 int
 435 main (int argc, char *argv[])
 436 {
 437   gtk_init (&argc, &argv);
 438
 439   open_test_window ();
 440   open_control_window ();
 441   open_alignment_window ();
 442   open_margin_window ();
 443   open_valigned_label_window ();
 444
 445   gtk_main ();
 446
 447   return 0;
 448 }