drawingarea.c 8.6 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
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,
32 33 34
			   widget->allocation.width,
			   widget->allocation.height,
			   -1);
35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

  /* Initialize the pixmap to white */
  gdk_draw_rectangle (pixmap,
		      widget->style->white_gc,
		      TRUE,
		      0, 0,
		      widget->allocation.width,
		      widget->allocation.height);

  /* 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,
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,
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,
73 74
	    gdouble    x,
	    gdouble    y)
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91
{
  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,
		      widget->style->black_gc,
		      TRUE,
		      update_rect.x, update_rect.y,
		      update_rect.width, update_rect.height);

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

static gboolean
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
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
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)
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 243
      gtk_window_set_screen (GTK_WINDOW (window),
			     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),
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 274
      g_signal_connect (da, "expose_event",
			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),
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 298 299 300
      g_signal_connect (da, "expose_event",
			G_CALLBACK (scribble_expose_event), NULL);
      g_signal_connect (da,"configure_event",
			G_CALLBACK (scribble_configure_event), NULL);
301 302 303
      
      /* Event signals */
      
304 305 306 307
      g_signal_connect (da, "motion_notify_event",
			G_CALLBACK (scribble_motion_notify_event), NULL);
      g_signal_connect (da, "button_press_event",
			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)
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;
}