← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gcompris/trusty

« back to all changes in this revision

Viewing changes to src/boards/draw.c

  • Committer: Bazaar Package Importer
  • Author(s): Yann Dirson
  • Date: 2006-12-15 23:08:17 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20061215230817-exr5ks1hd73s3tlk
Tags: 8.2.2-1
http://bugs.debian.org/396523
* New upstream bugfix release, fixes among other things the support for
  the version of gnucap shipped in etch.
* Add missing dependency on python-gtk2 (Closes: #396523).
* Removed reference to non-existent sound file from memory.c (upstream
  fix - impacts 8.2 as well).  
* Now suggests gnuchess, gnucap, and tuxpaint.
* Updated extended description for the main package.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/boards/draw.c
24
24
#include <libxml/parser.h>
25
25
 
26
26
#include <math.h>
 
27
#include <string.h>
27
28
 
28
29
#include "gcompris/gcompris.h"
 
30
#include "gcompris/pixbuf_util.h"
29
31
 
30
32
#define SOUNDLISTFILE PACKAGE
31
 
#define IMG_DATA_SET PACKAGE_DATA_DIR "/dataset/mrpatate.xml"
32
33
#define FILE_SELECTOR_ROOT "drawings"
33
34
 
34
35
/* Represent the drawing area */
177
178
static void      start_board (GcomprisBoard *agcomprisBoard);
178
179
static void      pause_board (gboolean pause);
179
180
static void      end_board (void);
180
 
static gint      key_press(guint keyval);
 
181
static gint      key_press(guint keyval, gchar *commit_str, gchar *preedit_str);
181
182
static gboolean  is_our_board (GcomprisBoard *gcomprisBoard);
182
183
static void      config(void);
183
184
 
190
191
static void      display_tool_selector(GnomeCanvasGroup *parent);
191
192
static void      display_drawing_area(GnomeCanvasGroup *parent);
192
193
static void      display_grid(gboolean status);
193
 
static gint      color_event(GnomeCanvasItem *item, GdkEvent *event, gchar *color);
194
194
static gint      ext_color_event(GnomeCanvasItem *item, GdkEvent *event, gpointer color_rgba);
195
195
static void      set_current_tool(GnomeCanvasItem *item, gint tool);
196
196
static gint      tool_event(GnomeCanvasItem *item, GdkEvent *event, gint tool);
201
201
static void      highlight_color_item(GnomeCanvasItem *item);
202
202
static guint     get_tool_cursor(ToolList tool);
203
203
static guint     get_resize_cursor(AnchorType anchor);
204
 
static void      realign_to_grid(GnomeCanvasItem *item);
205
204
static void      snap_to_grid(double *x, double *y);
206
205
static void      image_selected(gchar *image);
207
 
static void      load_drawing(gchar *file);
208
 
static void      save_drawing(gchar *file);
 
206
static void      load_drawing(gchar *file, gchar *type);
 
207
static void      save_drawing(gchar *file, gchar *type);
209
208
 
210
209
/* Description of this plugin */
211
210
static BoardPlugin menu_bp =
212
211
  {
213
212
    NULL,
214
213
    NULL,
215
 
    N_("A simple vector drawing tool"),
216
 
    N_("Creative board where you can draw freely"),
 
214
    "A simple vector drawing tool",
 
215
    "Creative board where you can draw freely",
217
216
    "Bruno Coudoin <bruno.coudoin@free.fr>",
218
217
    NULL,
219
218
    NULL,
227
226
    NULL,
228
227
    NULL,
229
228
    config,
 
229
    NULL,
 
230
    NULL,
230
231
    NULL
231
232
  };
232
233
 
236
237
 *
237
238
 */
238
239
 
239
 
BoardPlugin
240
 
*get_bplugin_info(void)
241
 
{
242
 
  return &menu_bp;
243
 
}
 
240
GET_BPLUGIN_INFO(draw)
244
241
 
245
242
/*
246
243
 * in : boolean TRUE = PAUSE : FALSE = CONTINUE
262
259
 
263
260
  if(agcomprisBoard!=NULL)
264
261
    {
 
262
      gchar *img;
 
263
 
265
264
      gcomprisBoard=agcomprisBoard;
266
265
 
267
 
      gcompris_set_background(gnome_canvas_root(gcomprisBoard->canvas), "draw/draw-bg.jpg");
 
266
      /* disable im_context */
 
267
      gcomprisBoard->disable_im_context = TRUE;
 
268
 
 
269
      img = gc_skin_image_get("gcompris-bg.jpg");
 
270
      gc_set_background(gnome_canvas_root(gcomprisBoard->canvas), 
 
271
                              img);
 
272
      g_free(img);
268
273
 
269
274
 
270
275
      /* set initial values for this level */
271
276
      gcomprisBoard->level = 1;
272
277
      gcomprisBoard->maxlevel=1;
273
 
      gcompris_bar_set(0);
 
278
      gc_bar_set(0);
274
279
 
275
280
      gcomprisBoard->number_of_sublevel=0;
276
281
      gcomprisBoard->sublevel = 0;
280
285
      drawing_area_x2 = gcomprisBoard->width  - 15;
281
286
      drawing_area_y2 = gcomprisBoard->height - 78;
282
287
 
283
 
      gcompris_bar_set(0);
 
288
      gc_bar_set(0);
284
289
 
285
290
      draw_next_level();
286
291
 
299
304
 
300
305
  if(gcomprisBoard!=NULL)
301
306
    {
302
 
      gcompris_set_cursor(GCOMPRIS_DEFAULT_CURSOR);
 
307
      gc_cursor_set(GCOMPRIS_DEFAULT_CURSOR);
303
308
      pause_board(TRUE);
304
309
      draw_destroy_all_items();
305
310
      gcomprisBoard->level = 1;       // Restart this game to zero
308
313
}
309
314
 
310
315
/* Get the user keys to use with the text tool */
311
 
static gint key_press(guint keyval)
 
316
static gint key_press(guint keyval, gchar *commit_str, gchar *preedit_str)
312
317
{
313
318
  char str[2];
314
319
  char utf8char[6];
322
327
  switch (keyval)
323
328
    {
324
329
    case GDK_F1:
325
 
      gcompris_file_selector_load(gcomprisBoard, FILE_SELECTOR_ROOT, load_drawing);
 
330
      gc_selector_file_load(gcomprisBoard, FILE_SELECTOR_ROOT, "", load_drawing);
326
331
      break;
327
332
    case GDK_F2:
328
 
      gcompris_file_selector_save(gcomprisBoard, FILE_SELECTOR_ROOT, save_drawing);
 
333
      gc_selector_file_save(gcomprisBoard, FILE_SELECTOR_ROOT, "", save_drawing);
329
334
      break;
330
335
    case GDK_Shift_L:
331
336
    case GDK_Shift_R:
345
350
    case GDK_dead_circumflex:
346
351
    case GDK_Num_Lock:
347
352
      return FALSE;
348
 
    case GDK_KP_0:
349
 
      keyval=GDK_0;
350
 
      break;
351
 
    case GDK_KP_1:
352
 
      keyval=GDK_1;
353
 
      break;
354
 
    case GDK_KP_2:
355
 
      keyval=GDK_2;
356
 
      break;
357
 
    case GDK_KP_3:
358
 
      keyval=GDK_3;
359
 
      break;
360
 
    case GDK_KP_4:
361
 
      keyval=GDK_4;
362
 
      break;
363
 
    case GDK_KP_5:
364
 
      keyval=GDK_5;
365
 
      break;
366
 
    case GDK_KP_6:
367
 
      keyval=GDK_6;
368
 
      break;
369
 
    case GDK_KP_7:
370
 
      keyval=GDK_7;
371
 
      break;
372
 
    case GDK_KP_8:
373
 
      keyval=GDK_8;
374
 
      break;
375
 
    case GDK_KP_9:
376
 
      keyval=GDK_9;
377
 
      break;
378
353
    }
379
354
 
380
355
  if(selected_anchors_item == NULL)
472
447
static void draw_next_level()
473
448
{
474
449
 
475
 
  gcompris_bar_set_level(gcomprisBoard);
 
450
  gc_bar_set_level(gcomprisBoard);
476
451
 
477
452
  draw_destroy_all_items();
478
453
 
527
502
  gint c  = 0;
528
503
  guint color_pixmap_height = 0;
529
504
 
530
 
  pixmap = gcompris_load_pixmap("draw/color-selector.jpg");
 
505
  pixmap = gc_pixmap_load("draw/color-selector.png");
531
506
  if(pixmap)
532
507
    {
533
508
      x = (drawing_area_x2 - drawing_area_x1
620
595
  gint y   = 0;
621
596
  guint toolIndex = 0;
622
597
 
623
 
  pixmap = gcompris_load_pixmap("draw/tool-selector.jpg");
 
598
  pixmap = gc_pixmap_load("draw/tool-selector.png");
624
599
  if(pixmap)
625
600
    {
626
601
      x = 3;
637
612
  y += 15;
638
613
  x  = 10;
639
614
  x2 = 55;
640
 
  pixmap = gcompris_load_pixmap(tool_pixmap_name[0 + PIXMAP_ON]);
 
615
  pixmap = gc_pixmap_load(tool_pixmap_name[0 + PIXMAP_ON]);
641
616
  if(pixmap)
642
617
    {
643
618
      item = gnome_canvas_item_new (parent,
654
629
 
655
630
      gtk_signal_connect(GTK_OBJECT(item), "event",
656
631
                         (GtkSignalFunc) tool_event,
657
 
                         (void *)TOOL_SAVE);
 
632
                         GINT_TO_POINTER(TOOL_SAVE) );
658
633
 
659
634
    }
660
635
  currentTool = TOOL_SAVE;
663
638
  for( toolIndex = 1 ; toolIndex < NUMBER_OF_TOOL ; toolIndex++)
664
639
    {
665
640
      y += (toolIndex%2 == 0 ? SELECTOR_VERTICAL_SPACING : 0);
666
 
      pixmap = gcompris_load_pixmap(tool_pixmap_name[(2*toolIndex) + PIXMAP_OFF]);
 
641
      pixmap = gc_pixmap_load(tool_pixmap_name[(2*toolIndex) + PIXMAP_OFF]);
667
642
 
668
643
      if(pixmap)
669
644
        {
693
668
 
694
669
          gtk_signal_connect(GTK_OBJECT(item), "event",
695
670
                             (GtkSignalFunc) tool_event,
696
 
                             (void *)toolIndex);
 
671
                             GINT_TO_POINTER(toolIndex));
697
672
        }
698
673
    }
699
674
}
707
682
  guint x, y;
708
683
  GdkPixbuf *pixmap = NULL;
709
684
 
710
 
  pixmap = gcompris_load_pixmap(tool_pixmap_name[(TOOL_GRID*2) +
 
685
  pixmap = gc_pixmap_load(tool_pixmap_name[(TOOL_GRID*2) +
711
686
                                                 (status == TRUE ? PIXMAP_ON : PIXMAP_OFF)]);
712
687
  if(pixmap)
713
688
    {
777
752
}
778
753
 
779
754
/*
780
 
 * Given an object, realign it to the grid
781
 
 * if the grid is on
782
 
 * FIXME: Does not work yet as expected
783
 
 */
784
 
static void realign_to_grid(GnomeCanvasItem *item)
785
 
{
786
 
 
787
 
  if(grid_step!=0)
788
 
    {
789
 
      double x1, y1, x2, y2;
790
 
      double xsnap1, ysnap1;
791
 
 
792
 
      gnome_canvas_item_get_bounds  (item,
793
 
                                     &x1,
794
 
                                     &y1,
795
 
                                     &x2,
796
 
                                     &y2);
797
 
 
798
 
      xsnap1 = x1;
799
 
      ysnap1 = y1;
800
 
      snap_to_grid(&xsnap1, &ysnap1);
801
 
 
802
 
      // Realign our object on the grid
803
 
      gnome_canvas_item_move(item,
804
 
                             x1 - xsnap1,
805
 
                             y1 - ysnap1);
806
 
    }
807
 
}
808
 
 
809
 
/*
810
755
 * Given a pair (x,y) rewrite them so that (x,y) is on a grid node
811
756
 * Do nothing if grid_step is 0
812
757
 */
889
834
 
890
835
  if(currentToolItem)
891
836
    {
892
 
      pixmap = gcompris_load_pixmap(tool_pixmap_name[(currentTool*2) + PIXMAP_OFF]);
 
837
      pixmap = gc_pixmap_load(tool_pixmap_name[(currentTool*2) + PIXMAP_OFF]);
893
838
      if(pixmap)
894
839
        {
895
840
          gnome_canvas_item_set (currentToolItem,
902
847
  currentTool = tool;
903
848
  currentToolItem = item;
904
849
 
905
 
  pixmap = gcompris_load_pixmap(tool_pixmap_name[(currentTool*2) + PIXMAP_ON]);
 
850
  pixmap = gc_pixmap_load(tool_pixmap_name[(currentTool*2) + PIXMAP_ON]);
906
851
  if(pixmap)
907
852
    {
908
853
      gnome_canvas_item_set (item,
932
877
          switch(tool)
933
878
            {
934
879
            case TOOL_LOAD:
935
 
              gcompris_file_selector_load(gcomprisBoard, FILE_SELECTOR_ROOT, load_drawing);
 
880
              //              gc_selector_file_load(gcomprisBoard, FILE_SELECTOR_ROOT, "", load_drawing);
936
881
              break;
937
882
            case TOOL_SAVE:
938
 
              gcompris_file_selector_save(gcomprisBoard, FILE_SELECTOR_ROOT, save_drawing);
 
883
              //              gc_selector_file_save(gcomprisBoard, FILE_SELECTOR_ROOT, "", save_drawing);
939
884
              break;
940
885
            case TOOL_GRID:
941
886
              display_grid((grid_step==0 ? TRUE : FALSE));
942
887
              return TRUE;
943
888
              break;
944
889
            case TOOL_IMAGE:
945
 
              gcompris_images_selector_start(gcomprisBoard, IMG_DATA_SET, image_selected);
946
 
            break;
 
890
              gc_selector_images_start(gcomprisBoard, "dataset", image_selected);
 
891
              break;
947
892
            case TOOL_RAISE:
948
893
            case TOOL_LOWER:
949
894
              if(selected_anchors_item)
1118
1063
{
1119
1064
  GnomeCanvasItem *item;
1120
1065
  double x1, x2, y1, y2;
1121
 
  double x, y;
1122
1066
  GnomeCanvasPoints *points;
1123
1067
 
1124
1068
  item = anchorsItem->item;
1854
1798
      // This is an image
1855
1799
      x = (drawing_area_x2-drawing_area_x1)/2;
1856
1800
      y = (drawing_area_y2-drawing_area_y1)/2;
1857
 
      pixmap = gcompris_load_pixmap(imagename);
 
1801
      pixmap = gc_pixmap_load(imagename);
1858
1802
      item = gnome_canvas_item_new (GNOME_CANVAS_GROUP(item_root_item),
1859
1803
                                    gnome_canvas_pixbuf_get_type (),
1860
1804
                                    "pixbuf", pixmap,
1946
1890
        item = gnome_canvas_item_new (GNOME_CANVAS_GROUP(item_root_item),
1947
1891
                                      gnome_canvas_text_get_type (),
1948
1892
                                      "text", "?",
1949
 
                                      "font", gcompris_skin_font_board_big_bold,
 
1893
                                      "font", gc_skin_font_board_big_bold,
1950
1894
                                      "x", (double) x,
1951
1895
                                      "y", (double) y,
1952
1896
                                      "anchor", GTK_ANCHOR_CENTER,
2032
1976
        case 1:
2033
1977
          fleur = gdk_cursor_new(get_resize_cursor(anchor));
2034
1978
          
2035
 
          gnome_canvas_item_grab(item,
 
1979
          gc_canvas_item_grab(item,
2036
1980
                                 GDK_POINTER_MOTION_MASK |
2037
1981
                                 GDK_BUTTON_RELEASE_MASK,
2038
1982
                                 fleur,
2055
1999
    case GDK_BUTTON_RELEASE:
2056
2000
      if(dragging)
2057
2001
        {
2058
 
          gnome_canvas_item_ungrab(item, event->button.time);
 
2002
          gc_canvas_item_ungrab(item, event->button.time);
2059
2003
          dragging = FALSE;
2060
2004
          draggingItem = NULL;
2061
2005
        }
2062
2006
      break;
2063
2007
    case GDK_ENTER_NOTIFY:
2064
 
      gcompris_set_cursor(get_resize_cursor(anchor));
 
2008
      gc_cursor_set(get_resize_cursor(anchor));
2065
2009
      break;
2066
2010
 
2067
2011
    case GDK_LEAVE_NOTIFY:
2068
 
      gcompris_set_cursor(get_tool_cursor(currentTool));
 
2012
      gc_cursor_set(get_tool_cursor(currentTool));
2069
2013
      break;
2070
2014
 
2071
2015
    case GDK_MOTION_NOTIFY:
2150
2094
/**
2151
2095
 * Callback for the drawing load
2152
2096
 */
2153
 
static void load_drawing(gchar *file)
 
2097
static void load_drawing(gchar *file, gchar *type)
2154
2098
{
2155
 
  printf("callback in draw, load_drawing got image %s\n", file);
2156
 
 
2157
 
  /* Delete the current drawing */
2158
 
  /* WARNING: We should have a YES/NO Dialog box */
2159
 
  gtk_object_destroy (GTK_OBJECT(draw_root_item));
2160
 
  draw_root_item = \
2161
 
    gnome_canvas_item_new (GNOME_CANVAS_GROUP(shape_root_item),
2162
 
                           gnome_canvas_group_get_type (),
2163
 
                           "x", (double)0,
2164
 
                           "y", (double)0,
2165
 
                           NULL);
2166
 
 
2167
 
 
2168
 
  gcompris_svg_restore(FILE_SELECTOR_ROOT, file, GNOME_CANVAS_GROUP(draw_root_item));
2169
 
 
2170
 
  /* For each item we need to recreate the anchors */
2171
 
  g_list_foreach(GNOME_CANVAS_GROUP(draw_root_item)->item_list, (GFunc) recreate_item, NULL);
2172
 
 
2173
 
  /* Set current_tool */
2174
 
  set_current_tool(selectionToolItem, TOOL_SELECT);
2175
2099
 
2176
2100
}
2177
2101
 
2178
2102
/**
2179
2103
 * Callback for the drawing save
2180
2104
 */
2181
 
static void save_drawing(gchar *file)
 
2105
static void save_drawing(gchar *file, gchar *type)
2182
2106
{
2183
 
  printf("callback in draw, save_drawing got image %s\n", file);
2184
 
  gcompris_svg_save(FILE_SELECTOR_ROOT, file, draw_root_item, BOARDWIDTH, BOARDHEIGHT, 0);
 
2107
 
2185
2108
}
2186
2109
 
2187
2110
/*
2224
2147
 
2225
2148
            fleur = gdk_cursor_new(GDK_FLEUR);
2226
2149
 
2227
 
            gnome_canvas_item_grab(item,
 
2150
            gc_canvas_item_grab(item,
2228
2151
                                   GDK_POINTER_MOTION_MASK |
2229
2152
                                   GDK_BUTTON_RELEASE_MASK,
2230
2153
                                   fleur,
2268
2191
            break;
2269
2192
 
2270
2193
          case TOOL_ROTATE_CW:
2271
 
            item_rotate_relative(anchorsItem->rootitem, 10);
 
2194
            gc_item_rotate_relative(anchorsItem->rootitem, 10);
2272
2195
            reset_anchors_bounded(anchorsItem);
2273
2196
            break;
2274
2197
 
2275
2198
          case TOOL_ROTATE_CCW:
2276
 
            item_rotate_relative(anchorsItem->rootitem, -10);
 
2199
            gc_item_rotate_relative(anchorsItem->rootitem, -10);
2277
2200
            reset_anchors_bounded(anchorsItem);
2278
2201
            break;
2279
2202
 
2313
2236
          switch(currentTool) {
2314
2237
            /* Perform the reverse operation when it makes sense */
2315
2238
          case TOOL_ROTATE_CW:
2316
 
            item_rotate_relative(anchorsItem->rootitem, -10);
 
2239
            gc_item_rotate_relative(anchorsItem->rootitem, -10);
2317
2240
            reset_anchors_bounded(anchorsItem);
2318
2241
            break;
2319
2242
          case TOOL_ROTATE_CCW:
2320
 
            item_rotate_relative(anchorsItem->rootitem, 10);
 
2243
            gc_item_rotate_relative(anchorsItem->rootitem, 10);
2321
2244
            reset_anchors_bounded(anchorsItem);
2322
2245
            break;
2323
2246
          case TOOL_RAISE:
2341
2264
    case GDK_BUTTON_RELEASE:
2342
2265
      if(dragging)
2343
2266
        {
2344
 
          gnome_canvas_item_ungrab(item, event->button.time);
 
2267
          gc_canvas_item_ungrab(item, event->button.time);
2345
2268
          dragging = FALSE;
2346
2269
          draggingItem = NULL;
2347
2270
 
2361
2284
      case TOOL_DELETE:
2362
2285
      case TOOL_FILL:
2363
2286
      case TOOL_TEXT:
2364
 
        gcompris_set_cursor(get_tool_cursor(currentTool));
 
2287
        gc_cursor_set(get_tool_cursor(currentTool));
2365
2288
        break;
2366
2289
      case TOOL_SELECT:
2367
 
        gcompris_set_cursor(GDK_FLEUR);
 
2290
        gc_cursor_set(GDK_FLEUR);
2368
2291
        break;
2369
2292
      default:
2370
2293
        break;
2371
2294
      }
2372
2295
      break;
2373
2296
    case GDK_LEAVE_NOTIFY:
2374
 
      gcompris_set_cursor(get_tool_cursor(currentTool));
 
2297
      gc_cursor_set(get_tool_cursor(currentTool));
2375
2298
      break;
2376
2299
 
2377
2300
    case GDK_MOTION_NOTIFY:
2477
2400
      break;
2478
2401
 
2479
2402
    case GDK_ENTER_NOTIFY:
2480
 
      gcompris_set_cursor(get_tool_cursor(currentTool));
 
2403
      gc_cursor_set(get_tool_cursor(currentTool));
2481
2404
      break;
2482
2405
 
2483
2406
    case GDK_LEAVE_NOTIFY:
2484
 
      gcompris_set_cursor(GCOMPRIS_DEFAULT_CURSOR);
 
2407
      gc_cursor_set(GCOMPRIS_DEFAULT_CURSOR);
2485
2408
      break;
2486
2409
 
2487
2410
    case GDK_MOTION_NOTIFY: