← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/goocanvas/gutsy

« back to all changes in this revision

Viewing changes to demo/demo-grabs.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2007-02-20 18:25:58 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20070220182558-tjofc7wdzkzlxzor
Tags: 0.6-0ubuntu1
* New upstream version (UVF exception #86533):
  - Major rewrite to make the model optional, so people can choose to have
    either a simple canvas or a model/view canvas. The standard items can be
    used in either scenario.
  - Added support for cascading style properties (things like fill color, 
    stroke width, font etc.). Properties use a GQuark for a unique 
    identifier, and a GValue for the property value, so they are very 
    flexible.
  - Added GooCanvasTable item to layout child items.
  - Made it much easier to create new items, by subclassing 
    GooCanvasItemSimple which handles most of the work. See demo/demo-item.c 
    for a simple item.
  - Added support for different units - pixels, points, inches or 
    millimeters, and allow setting of vertical 
    and horizontal resolution (dpi).
  - Added workaround for cairo's 16-bit limit, to support large canvases.
  - Added demo/scalability-demo which creates 100,000 items over a large 
    canvas. It takes a few seconds to create all the items, but once created 
    it seems to work fast enough.
  - Improved the animation code, supporting relative or absolute values for
    the x, y, scale and rotation.
  - Added "clip-path" and "clip-fill-rule" to specify a clip path 
    for an item.
* debian/control:
  - updated GTK requirement to 2.10
* debian/control, debian/libgoocanvas0.install, debian/libgoocanvas1.install,
  debian/rules:
  - updated for soname change

Show diffs side-by-side

added added

removed removed

Lines of Context:
demo/demo-grabs.c
106
106
 
107
107
 
108
108
static gboolean
109
 
on_enter_notify (GooCanvasItemView *view,
110
 
                 GooCanvasItemView *target,
 
109
on_enter_notify (GooCanvasItem *item,
 
110
                 GooCanvasItem *target,
111
111
                 GdkEventCrossing *event,
112
112
                 gpointer data)
113
113
{
114
 
  GooCanvasItem *item = goo_canvas_item_view_get_item (target);
115
114
  char *item_id = g_object_get_data (G_OBJECT (item), "id");
116
115
 
117
116
  g_print ("%s received 'enter-notify' signal\n", item_id);
120
119
 
121
120
 
122
121
static gboolean
123
 
on_leave_notify (GooCanvasItemView *view,
124
 
                 GooCanvasItemView *target,
 
122
on_leave_notify (GooCanvasItem *item,
 
123
                 GooCanvasItem *target,
125
124
                 GdkEventCrossing *event,
126
125
                 gpointer data)
127
126
{
128
 
  GooCanvasItem *item = goo_canvas_item_view_get_item (target);
129
127
  char *item_id = g_object_get_data (G_OBJECT (item), "id");
130
128
 
131
129
  g_print ("%s received 'leave-notify' signal\n", item_id);
134
132
 
135
133
 
136
134
static gboolean
137
 
on_motion_notify (GooCanvasItemView *view,
138
 
                  GooCanvasItemView *target,
 
135
on_motion_notify (GooCanvasItem *item,
 
136
                  GooCanvasItem *target,
139
137
                  GdkEventMotion *event,
140
138
                  gpointer data)
141
139
{
142
 
  GooCanvasItem *item = goo_canvas_item_view_get_item (target);
143
140
  char *item_id = g_object_get_data (G_OBJECT (item), "id");
144
141
 
145
142
  g_print ("%s received 'motion-notify' signal\n", item_id);
148
145
 
149
146
 
150
147
static gboolean
151
 
on_button_press (GooCanvasItemView *view,
152
 
                 GooCanvasItemView *target,
 
148
on_button_press (GooCanvasItem *item,
 
149
                 GooCanvasItem *target,
153
150
                 GdkEventButton *event,
154
151
                 gpointer data)
155
152
{
156
 
  GooCanvasItem *item = goo_canvas_item_view_get_item (target);
157
153
  char *item_id = g_object_get_data (G_OBJECT (item), "id");
158
154
 
159
155
  g_print ("%s received 'button-press' signal\n", item_id);
160
156
 
161
157
  if (strstr (item_id, "explicit"))
162
158
    {
163
 
      GooCanvasView *canvas_view;
 
159
      GooCanvas *canvas;
164
160
      GdkGrabStatus status;
165
161
      GdkEventMask mask = GDK_BUTTON_PRESS_MASK
166
162
        | GDK_BUTTON_RELEASE_MASK
169
165
        | GDK_ENTER_NOTIFY_MASK
170
166
        | GDK_LEAVE_NOTIFY_MASK;
171
167
 
172
 
      canvas_view = goo_canvas_item_view_get_canvas_view (view);
173
 
      status = goo_canvas_view_pointer_grab (canvas_view, view, mask, NULL,
174
 
                                             event->time);
 
168
      canvas = goo_canvas_item_get_canvas (item);
 
169
      status = goo_canvas_pointer_grab (canvas, item, mask, NULL, event->time);
175
170
      if (status == GDK_GRAB_SUCCESS)
176
171
        g_print ("grabbed pointer\n");
177
172
      else
183
178
 
184
179
 
185
180
static gboolean
186
 
on_button_release (GooCanvasItemView *view,
187
 
                   GooCanvasItemView *target,
 
181
on_button_release (GooCanvasItem *item,
 
182
                   GooCanvasItem *target,
188
183
                   GdkEventButton *event,
189
184
                   gpointer data)
190
185
{
191
 
  GooCanvasItem *item = goo_canvas_item_view_get_item (target);
192
186
  char *item_id = g_object_get_data (G_OBJECT (item), "id");
193
187
 
194
188
  g_print ("%s received 'button-release' signal\n", item_id);
195
189
 
196
190
  if (strstr (item_id, "explicit"))
197
191
    {
198
 
      GooCanvasView *canvas_view;
 
192
      GooCanvas *canvas;
199
193
 
200
 
      canvas_view = goo_canvas_item_view_get_canvas_view (view);
201
 
      goo_canvas_view_pointer_ungrab (canvas_view, view, event->time);
 
194
      canvas = goo_canvas_item_get_canvas (item);
 
195
      goo_canvas_pointer_ungrab (canvas, item, event->time);
202
196
      g_print ("released pointer grab\n");
203
197
    }
204
198
 
319
313
 
320
314
 
321
315
static void
322
 
on_item_view_created (GooCanvasView     *view,
323
 
                      GooCanvasItemView *item_view,
324
 
                      GooCanvasItem     *item,
325
 
                      gpointer           data)
 
316
setup_item_signals (GooCanvasItem *item)
326
317
{
327
 
  if (GOO_IS_CANVAS_RECT (item))
328
 
    {
329
 
      g_signal_connect (item_view, "enter_notify_event",
330
 
                        (GtkSignalFunc) on_enter_notify, NULL);
331
 
      g_signal_connect (item_view, "leave_notify_event",
332
 
                        (GtkSignalFunc) on_leave_notify, NULL);
333
 
      g_signal_connect (item_view, "motion_notify_event",
334
 
                        (GtkSignalFunc) on_motion_notify, NULL);
335
 
      g_signal_connect (item_view, "button_press_event",
336
 
                        (GtkSignalFunc) on_button_press, NULL);
337
 
      g_signal_connect (item_view, "button_release_event",
338
 
                        (GtkSignalFunc) on_button_release, NULL);
339
 
    }
 
318
  g_signal_connect (item, "enter_notify_event",
 
319
                    (GtkSignalFunc) on_enter_notify, NULL);
 
320
  g_signal_connect (item, "leave_notify_event",
 
321
                    (GtkSignalFunc) on_leave_notify, NULL);
 
322
  g_signal_connect (item, "motion_notify_event",
 
323
                    (GtkSignalFunc) on_motion_notify, NULL);
 
324
  g_signal_connect (item, "button_press_event",
 
325
                    (GtkSignalFunc) on_button_press, NULL);
 
326
  g_signal_connect (item, "button_release_event",
 
327
                    (GtkSignalFunc) on_button_release, NULL);
340
328
}
341
329
 
342
330
 
344
332
create_canvas (GtkTable *table, gint row, gchar *text, gchar *id)
345
333
{
346
334
  GtkWidget *label, *canvas;
347
 
  GooCanvasModelSimple *canvas_model;
348
335
  GooCanvasItem *root, *rect;
349
336
  char *view_id;
350
337
 
351
338
  label = gtk_label_new (text);
352
 
  gtk_table_attach (table, label, 0, 1, row, row + 1,
353
 
                    0, 0, 0, 0);
 
339
  gtk_table_attach (table, label, 0, 1, row, row + 1, 0, 0, 0, 0);
354
340
  gtk_widget_show (label);
355
341
 
356
 
  canvas = goo_canvas_view_new ();
357
 
 
358
 
  g_signal_connect (canvas, "item_view_created",
359
 
                    (GtkSignalFunc) on_item_view_created,
360
 
                    NULL);
 
342
  canvas = goo_canvas_new ();
361
343
 
362
344
  gtk_widget_set_size_request (canvas, 200, 100);
363
 
  goo_canvas_view_set_bounds (GOO_CANVAS_VIEW (canvas), 0, 0, 200, 100);
364
 
  gtk_table_attach (table, canvas, 1, 2, row, row + 1,
365
 
                    0, 0, 0, 0);
 
345
  goo_canvas_set_bounds (GOO_CANVAS (canvas), 0, 0, 200, 100);
 
346
  gtk_table_attach (table, canvas, 1, 2, row, row + 1, 0, 0, 0, 0);
366
347
  gtk_widget_show (canvas);
367
348
 
368
 
  canvas_model = goo_canvas_model_simple_new ();
369
 
  goo_canvas_view_set_model (GOO_CANVAS_VIEW (canvas),
370
 
                             GOO_CANVAS_MODEL (canvas_model));
371
 
  g_object_unref (canvas_model);
 
349
  root = goo_canvas_get_root_item (GOO_CANVAS (canvas));
372
350
 
373
 
  root = goo_canvas_model_get_root_item (GOO_CANVAS_MODEL (canvas_model));
374
351
  rect = goo_canvas_rect_new (root, 0, 0, 200, 100,
375
352
                              "stroke-pattern", NULL,
376
353
                              "fill-color", "yellow",
377
354
                              NULL);
378
355
  view_id = g_strdup_printf ("%s-yellow", id);
379
356
  g_object_set_data_full (G_OBJECT (rect), "id", view_id, g_free);
 
357
  setup_item_signals (rect);
380
358
 
381
359
  rect = goo_canvas_rect_new (root, 20, 20, 60, 60,
382
360
                              "stroke-pattern", NULL,
384
362
                              NULL);
385
363
  view_id = g_strdup_printf ("%s-blue", id);
386
364
  g_object_set_data_full (G_OBJECT (rect), "id", view_id, g_free);
 
365
  setup_item_signals (rect);
387
366
 
388
367
  rect = goo_canvas_rect_new (root, 120, 20, 60, 60,
389
368
                              "stroke-pattern", NULL,
391
370
                              NULL);
392
371
  view_id = g_strdup_printf ("%s-red", id);
393
372
  g_object_set_data_full (G_OBJECT (rect), "id", view_id, g_free);
 
373
  setup_item_signals (rect);
394
374
}
395
375
 
396
376