drawingarea.c 8.54 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 221
  
  /* return TRUE because we've handled this event, so no
   * further processing is required.
   */
  return TRUE;
}

GtkWidget *
222
do_drawingarea (GtkWidget *do_widget)
223 224 225 226 227 228 229 230 231
{
  GtkWidget *frame;
  GtkWidget *vbox;
  GtkWidget *da;
  GtkWidget *label;
  
  if (!window)
    {
      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
232 233
      gtk_window_set_screen (GTK_WINDOW (window),
			     gtk_widget_get_screen (do_widget));
234 235
      gtk_window_set_title (GTK_WINDOW (window), "Drawing Area");

236
      g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window);
237 238 239 240 241 242 243 244 245 246 247 248 249

      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),
250
			    "<u>Checkerboard pattern</u>");
251 252 253 254 255 256 257 258
      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 */
259
      gtk_widget_set_size_request (da, 100, 100);
260 261 262

      gtk_container_add (GTK_CONTAINER (frame), da);

263 264
      g_signal_connect (da, "expose_event",
			G_CALLBACK (checkerboard_expose), NULL);
265 266 267 268 269 270 271

      /*
       * Create the scribble area
       */
      
      label = gtk_label_new (NULL);
      gtk_label_set_markup (GTK_LABEL (label),
272
			    "<u>Scribble area</u>");
273 274 275 276 277 278 279 280
      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 */
281
      gtk_widget_set_size_request (da, 100, 100);
282 283 284 285 286

      gtk_container_add (GTK_CONTAINER (frame), da);

      /* Signals used to handle backing pixmap */
      
287 288 289 290
      g_signal_connect (da, "expose_event",
			G_CALLBACK (scribble_expose_event), NULL);
      g_signal_connect (da,"configure_event",
			G_CALLBACK (scribble_configure_event), NULL);
291 292 293
      
      /* Event signals */
      
294 295 296 297
      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);
298 299 300 301 302 303


      /* Ask to receive events the drawing area doesn't normally
       * subscribe to
       */
      gtk_widget_set_events (da, gtk_widget_get_events (da)
304 305 306 307
			     | GDK_LEAVE_NOTIFY_MASK
			     | GDK_BUTTON_PRESS_MASK
			     | GDK_POINTER_MOTION_MASK
			     | GDK_POINTER_MOTION_HINT_MASK);
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322

    }

  if (!GTK_WIDGET_VISIBLE (window))
    {
      gtk_widget_show_all (window);
    }
  else
    {
      gtk_widget_destroy (window);
      window = NULL;
    }

  return window;
}