drawingarea.c 9.56 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/* Drawing Area
 *
 * GtkDrawingArea is a blank area where you can draw custom displays
 * of various kinds.
 *
 * This demo has two drawing areas. The checkerboard area shows
 * how you can just draw something; all you have to do is write
 * a signal handler for expose_event, as shown here.
 *
 * The "scribble" area is a bit more advanced, and shows how to handle
 * events such as button presses and mouse motion. Click the mouse
 * and drag in the scribble area to draw squiggles. Resize the window
 * to clear the area.
 */

#include <gtk/gtk.h>

static GtkWidget *window = NULL;
/* Pixmap for scribble area, to store current scribbles */
static GdkPixmap *pixmap = NULL;

/* Create a new pixmap of the appropriate size to store our scribbles */
static gboolean
Matthias Clasen's avatar
Matthias Clasen committed
24 25 26
scribble_configure_event (GtkWidget         *widget,
                          GdkEventConfigure *event,
                          gpointer           data)
27 28
{
  if (pixmap)
Manish Singh's avatar
Manish Singh committed
29
    g_object_unref (pixmap);
30 31

  pixmap = gdk_pixmap_new (widget->window,
Matthias Clasen's avatar
Matthias Clasen committed
32 33 34
                           widget->allocation.width,
                           widget->allocation.height,
                           -1);
35 36 37

  /* Initialize the pixmap to white */
  gdk_draw_rectangle (pixmap,
Matthias Clasen's avatar
Matthias Clasen committed
38 39 40 41 42
                      widget->style->white_gc,
                      TRUE,
                      0, 0,
                      widget->allocation.width,
                      widget->allocation.height);
43 44 45 46 47 48 49 50

  /* We've handled the configure event, no need for further processing. */
  return TRUE;
}

/* Redraw the screen from the pixmap */
static gboolean
scribble_expose_event (GtkWidget      *widget,
Matthias Clasen's avatar
Matthias Clasen committed
51 52
                       GdkEventExpose *event,
                       gpointer        data)
53 54 55 56 57 58 59
{
  /* We use the "foreground GC" for the widget since it already exists,
   * but honestly any GC would work. The only thing to worry about
   * is whether the GC has an inappropriate clip region set.
   */
  
  gdk_draw_drawable (widget->window,
Matthias Clasen's avatar
Matthias Clasen committed
60 61 62 63 64 65
                     widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
                     pixmap,
                     /* Only copy the area that was exposed. */
                     event->area.x, event->area.y,
                     event->area.x, event->area.y,
                     event->area.width, event->area.height);
66 67 68 69 70 71 72
  
  return FALSE;
}

/* Draw a rectangle on the screen */
static void
draw_brush (GtkWidget *widget,
Matthias Clasen's avatar
Matthias Clasen committed
73 74
            gdouble    x,
            gdouble    y)
75 76 77 78 79 80 81 82 83 84
{
  GdkRectangle update_rect;

  update_rect.x = x - 3;
  update_rect.y = y - 3;
  update_rect.width = 6;
  update_rect.height = 6;

  /* Paint to the pixmap, where we store our state */
  gdk_draw_rectangle (pixmap,
Matthias Clasen's avatar
Matthias Clasen committed
85 86 87 88
                      widget->style->black_gc,
                      TRUE,
                      update_rect.x, update_rect.y,
                      update_rect.width, update_rect.height);
89 90 91

  /* Now invalidate the affected region of the drawing area. */
  gdk_window_invalidate_rect (widget->window,
Matthias Clasen's avatar
Matthias Clasen committed
92 93
                              &update_rect,
                              FALSE);
94 95 96
}

static gboolean
Matthias Clasen's avatar
Matthias Clasen committed
97 98 99
scribble_button_press_event (GtkWidget      *widget,
                             GdkEventButton *event,
                             gpointer        data)
100 101 102 103 104 105 106 107 108 109 110 111
{
  if (pixmap == NULL)
    return FALSE; /* paranoia check, in case we haven't gotten a configure event */
  
  if (event->button == 1)
    draw_brush (widget, event->x, event->y);

  /* We've handled the event, stop processing */
  return TRUE;
}

static gboolean
Matthias Clasen's avatar
Matthias Clasen committed
112 113 114
scribble_motion_notify_event (GtkWidget      *widget,
                              GdkEventMotion *event,
                              gpointer        data)
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
{
  int x, y;
  GdkModifierType state;

  if (pixmap == NULL)
    return FALSE; /* paranoia check, in case we haven't gotten a configure event */

  /* This call is very important; it requests the next motion event.
   * If you don't call gdk_window_get_pointer() you'll only get
   * a single motion event. The reason is that we specified
   * GDK_POINTER_MOTION_HINT_MASK to gtk_widget_set_events().
   * If we hadn't specified that, we could just use event->x, event->y
   * as the pointer location. But we'd also get deluged in events.
   * By requesting the next event as we handle the current one,
   * we avoid getting a huge number of events faster than we
   * can cope.
   */
  
  gdk_window_get_pointer (event->window, &x, &y, &state);
    
  if (state & GDK_BUTTON1_MASK)
    draw_brush (widget, x, y);

  /* We've handled it, stop processing */
  return TRUE;
}


static gboolean
Matthias Clasen's avatar
Matthias Clasen committed
144 145 146
checkerboard_expose (GtkWidget      *da,
                     GdkEventExpose *event,
                     gpointer        data)
147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
{
  gint i, j, xcount, ycount;
  GdkGC *gc1, *gc2;
  GdkColor color;
  
#define CHECK_SIZE 10
#define SPACING 2
  
  /* At the start of an expose handler, a clip region of event->area
   * is set on the window, and event->area has been cleared to the
   * widget's background color. The docs for
   * gdk_window_begin_paint_region() give more details on how this
   * works.
   */

  /* It would be a bit more efficient to keep these
   * GC's around instead of recreating on each expose, but
   * this is the lazy/slow way.
   */
  gc1 = gdk_gc_new (da->window);
  color.red = 30000;
  color.green = 0;
  color.blue = 30000;
  gdk_gc_set_rgb_fg_color (gc1, &color);

  gc2 = gdk_gc_new (da->window);
  color.red = 65535;
  color.green = 65535;
  color.blue = 65535;
  gdk_gc_set_rgb_fg_color (gc2, &color);
  
  xcount = 0;
  i = SPACING;
  while (i < da->allocation.width)
    {
      j = SPACING;
      ycount = xcount % 2; /* start with even/odd depending on row */
      while (j < da->allocation.height)
Matthias Clasen's avatar
Matthias Clasen committed
185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
        {
          GdkGC *gc;
          
          if (ycount % 2)
            gc = gc1;
          else
            gc = gc2;

          /* If we're outside event->area, this will do nothing.
           * It might be mildly more efficient if we handled
           * the clipping ourselves, but again we're feeling lazy.
           */
          gdk_draw_rectangle (da->window,
                              gc,
                              TRUE,
                              i, j,
                              CHECK_SIZE,
                              CHECK_SIZE);

          j += CHECK_SIZE + SPACING;
          ++ycount;
        }
207 208 209 210 211

      i += CHECK_SIZE + SPACING;
      ++xcount;
    }
  
Manish Singh's avatar
Manish Singh committed
212 213
  g_object_unref (gc1);
  g_object_unref (gc2);
214 215 216 217 218 219 220
  
  /* return TRUE because we've handled this event, so no
   * further processing is required.
   */
  return TRUE;
}

221 222 223 224 225 226 227 228 229 230
static void
close_window (void)
{
  window = NULL;

  if (pixmap)
    g_object_unref (pixmap);
  pixmap = NULL;
}

231
GtkWidget *
232
do_drawingarea (GtkWidget *do_widget)
233 234 235 236 237 238 239 240 241
{
  GtkWidget *frame;
  GtkWidget *vbox;
  GtkWidget *da;
  GtkWidget *label;
  
  if (!window)
    {
      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
242
      gtk_window_set_screen (GTK_WINDOW (window),
Matthias Clasen's avatar
Matthias Clasen committed
243
                             gtk_widget_get_screen (do_widget));
244 245
      gtk_window_set_title (GTK_WINDOW (window), "Drawing Area");

246
      g_signal_connect (window, "destroy", G_CALLBACK (close_window), NULL);
247 248 249 250 251 252 253 254 255 256 257 258 259

      gtk_container_set_border_width (GTK_CONTAINER (window), 8);

      vbox = gtk_vbox_new (FALSE, 8);
      gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
      gtk_container_add (GTK_CONTAINER (window), vbox);

      /*
       * Create the checkerboard area
       */
      
      label = gtk_label_new (NULL);
      gtk_label_set_markup (GTK_LABEL (label),
Matthias Clasen's avatar
Matthias Clasen committed
260
                            "<u>Checkerboard pattern</u>");
261 262 263 264 265 266 267 268
      gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
      
      frame = gtk_frame_new (NULL);
      gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
      gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
      
      da = gtk_drawing_area_new ();
      /* set a minimum size */
269
      gtk_widget_set_size_request (da, 100, 100);
270 271 272

      gtk_container_add (GTK_CONTAINER (frame), da);

273
      g_signal_connect (da, "expose_event",
Matthias Clasen's avatar
Matthias Clasen committed
274
                        G_CALLBACK (checkerboard_expose), NULL);
275 276 277 278 279 280 281

      /*
       * Create the scribble area
       */
      
      label = gtk_label_new (NULL);
      gtk_label_set_markup (GTK_LABEL (label),
Matthias Clasen's avatar
Matthias Clasen committed
282
                            "<u>Scribble area</u>");
283 284 285 286 287 288 289 290
      gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
      
      frame = gtk_frame_new (NULL);
      gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
      gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
      
      da = gtk_drawing_area_new ();
      /* set a minimum size */
291
      gtk_widget_set_size_request (da, 100, 100);
292 293 294 295 296

      gtk_container_add (GTK_CONTAINER (frame), da);

      /* Signals used to handle backing pixmap */
      
297
      g_signal_connect (da, "expose_event",
Matthias Clasen's avatar
Matthias Clasen committed
298
                        G_CALLBACK (scribble_expose_event), NULL);
299
      g_signal_connect (da,"configure_event",
Matthias Clasen's avatar
Matthias Clasen committed
300
                        G_CALLBACK (scribble_configure_event), NULL);
301 302 303
      
      /* Event signals */
      
304
      g_signal_connect (da, "motion_notify_event",
Matthias Clasen's avatar
Matthias Clasen committed
305
                        G_CALLBACK (scribble_motion_notify_event), NULL);
306
      g_signal_connect (da, "button_press_event",
Matthias Clasen's avatar
Matthias Clasen committed
307
                        G_CALLBACK (scribble_button_press_event), NULL);
308 309 310 311 312 313


      /* Ask to receive events the drawing area doesn't normally
       * subscribe to
       */
      gtk_widget_set_events (da, gtk_widget_get_events (da)
Matthias Clasen's avatar
Matthias Clasen committed
314 315 316 317
                             | GDK_LEAVE_NOTIFY_MASK
                             | GDK_BUTTON_PRESS_MASK
                             | GDK_POINTER_MOTION_MASK
                             | GDK_POINTER_MOTION_HINT_MASK);
318 319 320 321 322 323 324 325 326 327

    }

  if (!GTK_WIDGET_VISIBLE (window))
      gtk_widget_show_all (window);
  else
      gtk_widget_destroy (window);

  return window;
}