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

   1 /* testgeometry.c
   2  * Author: Owen Taylor <otaylor@redhat.com>
   3  * Copyright © 2010 Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <gtk/gtk.h>
  20
  21 #define GRID_SIZE 20
  22 #define BORDER 6
  23
  24 static int window_count = 0;
  25 const char *geometry_string;
  26
  27 static void
  28 on_window_destroy (GtkWidget *widget)
  29 {
  30   window_count--;
  31   if (window_count == 0)
  32     gtk_main_quit();
  33 }
  34
  35 static gboolean
  36 on_drawing_area_draw (GtkWidget *drawing_area,
  37                       cairo_t   *cr,
  38                       gpointer   data)
  39 {
  40   int width = gtk_widget_get_allocated_width (drawing_area);
  41   int height = gtk_widget_get_allocated_height (drawing_area);
  42   int x, y;
  43   int border = 0;
  44   GdkWindowHints mask = GPOINTER_TO_UINT(data);
  45
  46   cairo_set_source_rgb (cr, 1, 1, 1);
  47   cairo_paint (cr);
  48
  49   if ((mask & GDK_HINT_BASE_SIZE) != 0)
  50     border = BORDER;
  51
  52   cairo_set_source_rgb (cr, 0, 0, 0);
  53   for (y = 0; y < height - 2 * border; y += GRID_SIZE)
  54     for (x = 0; x < width - 2 * border; x += GRID_SIZE)
  55       if (((x + y) / GRID_SIZE) % 2 == 0)
  56         {
  57           cairo_rectangle (cr, border + x, border + y, GRID_SIZE, GRID_SIZE);
  58           cairo_fill (cr);
  59         }
  60
  61   if (border > 0)
  62     {
  63       cairo_set_source_rgb (cr, 0, 0, 1);
  64       cairo_save (cr);
  65       cairo_set_line_width (cr, border);
  66       cairo_rectangle (cr,
  67                        border / 2., border / 2., width - border, height - border);
  68       cairo_stroke (cr);
  69     }
  70
  71   return FALSE;
  72 }
  73
  74 static void
  75 on_resize_clicked (GtkWidget *button,
  76                    gpointer   data)
  77 {
  78   GtkWidget *window = gtk_widget_get_toplevel (button);
  79   GdkWindowHints mask = GPOINTER_TO_UINT(data);
  80
  81   if ((mask & GDK_HINT_RESIZE_INC) != 0)
  82     gtk_window_resize_to_geometry (GTK_WINDOW (window), 8, 8);
  83   else
  84     gtk_window_resize_to_geometry (GTK_WINDOW (window), 8 * GRID_SIZE, 8 * GRID_SIZE);
  85 }
  86
  87 static void
  88 create_window (GdkWindowHints  mask)
  89 {
  90   GtkWidget *window;
  91   GtkWidget *drawing_area;
  92   GtkWidget *grid;
  93   GtkWidget *label;
  94   GtkWidget *button;
  95   GdkGeometry geometry;
  96   GString *label_text = g_string_new (NULL);
  97   int border = 0;
  98
  99   if ((mask & GDK_HINT_RESIZE_INC) != 0)
 100     g_string_append (label_text, "Gridded\n");
 101   if ((mask & GDK_HINT_BASE_SIZE) != 0)
 102     g_string_append (label_text, "Base\n");
 103   if ((mask & GDK_HINT_MIN_SIZE) != 0)
 104     {
 105       g_string_append (label_text, "Minimum\n");
 106       if ((mask & GDK_HINT_BASE_SIZE) == 0)
 107         g_string_append (label_text, "(base=min)\n");
 108     }
 109   if ((mask & GDK_HINT_MAX_SIZE) != 0)
 110     g_string_append (label_text, "Maximum\n");
 111
 112   if (label_text->len > 0)
 113     g_string_erase (label_text, label_text->len - 1, 1);
 114   else
 115     g_string_append (label_text, "No Options");
 116
 117   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 118   g_signal_connect (window, "destroy",
 119                     G_CALLBACK (on_window_destroy), NULL);
 120
 121   grid = gtk_grid_new ();
 122   gtk_container_set_border_width (GTK_CONTAINER (grid), 10);
 123
 124   label = gtk_label_new (label_text->str);
 125   gtk_widget_set_hexpand (label, TRUE);
 126   gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
 127
 128   label = gtk_label_new ("A\nB\nC\nD\nE");
 129   gtk_grid_attach (GTK_GRID (grid), label, 1, 1, 1, 1);
 130
 131   drawing_area = gtk_drawing_area_new ();
 132   g_signal_connect (drawing_area, "draw",
 133                     G_CALLBACK (on_drawing_area_draw),
 134                     GUINT_TO_POINTER (mask));
 135   gtk_widget_set_hexpand (drawing_area, TRUE);
 136   gtk_widget_set_vexpand (drawing_area, TRUE);
 137   gtk_grid_attach (GTK_GRID (grid), drawing_area, 0, 1, 1, 1);
 138
 139   button = gtk_button_new_with_label ("Resize");
 140   g_signal_connect (button, "clicked",
 141                     G_CALLBACK (on_resize_clicked),
 142                     GUINT_TO_POINTER (mask));
 143   gtk_widget_set_hexpand (button, TRUE);
 144   gtk_grid_attach (GTK_GRID (grid), button, 0, 2, 1, 1);
 145
 146   gtk_container_add (GTK_CONTAINER (window), grid);
 147
 148   if ((mask & GDK_HINT_BASE_SIZE) != 0)
 149     {
 150       border = BORDER;
 151       geometry.base_width = border * 2;
 152       geometry.base_height = border * 2;
 153     }
 154
 155   if ((mask & GDK_HINT_RESIZE_INC) != 0)
 156     {
 157       geometry.width_inc = GRID_SIZE;
 158       geometry.height_inc = GRID_SIZE;
 159     }
 160
 161   if ((mask & GDK_HINT_MIN_SIZE) != 0)
 162     {
 163       geometry.min_width = 5 * GRID_SIZE + 2 * border;
 164       geometry.min_height = 5 * GRID_SIZE + 2 * border;
 165     }
 166
 167   if ((mask & GDK_HINT_MAX_SIZE) != 0)
 168     {
 169       geometry.max_width = 15 * GRID_SIZE + 2 * border;
 170       geometry.max_height = 15 * GRID_SIZE + 2 * border;
 171     }
 172
 173   /* Contents must be set up before gtk_window_parse_geometry() */
 174   gtk_widget_show_all (grid);
 175
 176   gtk_window_set_geometry_hints (GTK_WINDOW (window),
 177                                  drawing_area,
 178                                  &geometry,
 179                                  mask);
 180
 181   if ((mask & GDK_HINT_RESIZE_INC) != 0)
 182     {
 183       if (geometry_string)
 184         gtk_window_parse_geometry (GTK_WINDOW (window), geometry_string);
 185       else
 186         gtk_window_set_default_geometry (GTK_WINDOW (window), 10, 10);
 187     }
 188   else
 189     {
 190       gtk_window_set_default_geometry (GTK_WINDOW (window), 10 * GRID_SIZE, 10 * GRID_SIZE);
 191     }
 192
 193   gtk_widget_show (window);
 194   window_count++;
 195 }
 196
 197 int
 198 main(int argc, char **argv)
 199 {
 200   GError *error;
 201   GOptionEntry options[] = {
 202     { "geometry", 'g', 0, G_OPTION_ARG_STRING, &geometry_string, "Window geometry (only for gridded windows)", "GEOMETRY" },
 203     { NULL }
 204   };
 205
 206   if (!gtk_init_with_args (&argc, &argv, "", options, NULL, &error))
 207     {
 208       g_print ("Failed to parse args: %s\n", error->message);
 209       g_error_free (error);
 210       return 1;
 211     }
 212
 213   create_window (GDK_HINT_MIN_SIZE);
 214   create_window (GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE);
 215   create_window (GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE);
 216   create_window (GDK_HINT_RESIZE_INC | GDK_HINT_MIN_SIZE);
 217   create_window (GDK_HINT_RESIZE_INC | GDK_HINT_MAX_SIZE);
 218   create_window (GDK_HINT_RESIZE_INC | GDK_HINT_BASE_SIZE);
 219   create_window (GDK_HINT_RESIZE_INC | GDK_HINT_BASE_SIZE | GDK_HINT_MIN_SIZE);
 220
 221   gtk_main ();
 222
 223   return 0;
 224 }