drawingarea.c 9.48 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
{
  /* 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.
   */
58

59
  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
{
  if (pixmap == NULL)
    return FALSE; /* paranoia check, in case we haven't gotten a configure event */
103

104 105 106 107 108 109 110 111
  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
{
  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.
   */
132

133
  gdk_window_get_pointer (event->window, &x, &y, &state);
134

135 136 137 138 139 140 141 142 143
  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
{
  gint i, j, xcount, ycount;
  GdkGC *gc1, *gc2;
  GdkColor color;
151

152 153
#define CHECK_SIZE 10
#define SPACING 2
154

155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
  /* 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);
177

178 179 180 181 182 183 184
  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
        {
          GdkGC *gc;
187

Matthias Clasen's avatar
Matthias Clasen committed
188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
          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

      i += CHECK_SIZE + SPACING;
      ++xcount;
    }
211

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
{
  GtkWidget *frame;
  GtkWidget *vbox;
  GtkWidget *da;
  GtkWidget *label;
238

239 240 241
  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

      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
       */
257

258 259
      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
      gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
262

263 264 265
      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);
266

267 268
      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

      /*
       * Create the scribble area
       */
279

280 281
      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
      gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
284

285 286 287
      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);
288

289 290
      da = gtk_drawing_area_new ();
      /* set a minimum size */
291
      gtk_widget_set_size_request (da, 100, 100);
292 293 294 295

      gtk_container_add (GTK_CONTAINER (frame), da);

      /* Signals used to handle backing pixmap */
296 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
      /* Event signals */
303 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;
}