← Back to branch summary

~ml-launchpad/ubuntu/natty/gcompris/fix-for-777349

« back to all changes in this revision

Viewing changes to src/gcompris/drag.c

  • Committer: Bazaar Package Importer
  • Author(s): Marc Gariepy, Marc Gariepy, Stephane Graber
  • Date: 2010-01-04 17:42:49 UTC
  • mfrom: (1.1.14 upstream)
  • Revision ID: james.westby@ubuntu.com-20100104174249-7bupatd9dtxyhvs4
Tags: 9.0-0ubuntu1
[Marc Gariepy]
* New upstream release (9.0).
* Remove cache.c from POTFILES to avoid FTBFS
* Remove unneeded rm in debian/rules (file no longer exists upstream)

[Stephane Graber]
* Bump Debian standards to 3.8.3
* Add patch system (dpatch)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gcompris/drag.c
1
1
/* gcompris - drag.c
2
2
 *
3
 
 * Copyright (C) 2006 Miguel de Izarra
 
3
 * Copyright (C) 2006, 2008 Miguel de Izarra
4
4
 *
5
5
 *   This program is free software; you can redistribute it and/or modify
6
6
 *   it under the terms of the GNU General Public License as published by
18
18
 
19
19
#include "drag.h"
20
20
 
21
 
static gc_Drag_Func gc_drag_func;
 
21
static GcDragFunc gc_drag_func;
 
22
static gpointer gc_drag_user_data;
22
23
static int gc_drag_status;
23
24
 
24
25
/*  Values of status are :
27
28
    2 - follow mouse pointer and waiting for a BUTTON_RELEASE */
28
29
 
29
30
static gc_drag_mode_type gc_drag_mode;
30
 
static GnomeCanvasItem *gc_drag_item;
 
31
static GooCanvasItem *gc_drag_item;
 
32
static GooCanvasItem *gc_drag_target;
31
33
static double gc_drag_offset_x, gc_drag_offset_y;
32
34
 
33
 
GnomeCanvasItem * gc_drag_item_get(void)
34
 
{
35
 
    return gc_drag_item;
36
 
}
37
 
 
38
 
void gc_drag_item_set(GnomeCanvasItem *item)
39
 
{
40
 
    if(gc_drag_status != 0)
41
 
        g_warning("Don't use gc_drag_set_item during a dragging");
42
 
    if(item)
43
 
        gc_drag_item = item;
44
 
}
45
 
 
46
 
void gc_drag_item_move(GdkEvent *event)
47
 
{
48
 
    double item_x, item_y;
49
 
 
50
 
    item_x = event->button.x;
51
 
    item_y = event->button.y;
52
 
    gnome_canvas_item_w2i(gc_drag_item->parent, &item_x, &item_y);
53
 
 
54
 
    gnome_canvas_item_set(gc_drag_item,
55
 
            "x", item_x - gc_drag_offset_x,
56
 
            "y", item_y - gc_drag_offset_y, NULL);
57
 
}
58
 
 
59
 
void gc_drag_offset_get(double *x, double *y)
60
 
{
61
 
    *x = gc_drag_offset_x;
62
 
    *y = gc_drag_offset_y;
63
 
}
64
 
 
65
 
void gc_drag_offset_set(double x, double y)
66
 
{
67
 
    gc_drag_offset_x = x;
68
 
    gc_drag_offset_y = y;
69
 
}
70
 
 
71
 
void gc_drag_offset_save(GdkEvent *event)
72
 
{
73
 
    double x, y, item_x, item_y;
74
 
 
75
 
    x=event->button.x;
76
 
    y=event->button.y;
77
 
    gnome_canvas_item_w2i(gc_drag_item->parent, &x, &y);
78
 
 
79
 
    gnome_canvas_item_get_bounds(gc_drag_item, &item_x, &item_y, NULL, NULL);
80
 
 
81
 
    gc_drag_offset_set(x - item_x, y - item_y);
82
 
}
83
 
 
84
 
gint gc_drag_event(GnomeCanvasItem *item, GdkEvent *event, gpointer data)
85
 
{
86
 
    switch(event->type)
87
 
    {
88
 
        case GDK_BUTTON_PRESS:
89
 
            if(gc_drag_status ==0 && event->button.button == 1)
90
 
            {
91
 
                gc_drag_item = item;
92
 
                if(gc_drag_mode == GC_DRAG_MODE_GRAB)
93
 
                    gc_drag_status = 2;
94
 
                else
95
 
                    gc_drag_status = 1;
96
 
 
97
 
                gc_drag_func(item, event, data);
98
 
            }
99
 
            break;
100
 
        case GDK_BUTTON_RELEASE:
101
 
            if(gc_drag_status == 2)
102
 
            {
103
 
                gc_drag_func(gc_drag_item, event, data);
104
 
                gc_drag_status = 0;
105
 
                gc_drag_item = NULL;
106
 
            }
107
 
            else if (gc_drag_status == 1 && gc_drag_mode & GC_DRAG_MODE_2CLICKS)
108
 
                gc_drag_status = 2;
109
 
            break;
110
 
        default:
111
 
            break;
112
 
    }
113
 
    return FALSE;
114
 
}
115
 
 
116
 
gint gc_drag_event_root(GnomeCanvasItem * item, GdkEvent *event, gpointer data)
117
 
{
118
 
    switch(event->type)
119
 
    {
120
 
        case GDK_MOTION_NOTIFY:
121
 
            if(gc_drag_status > 0)
122
 
            {
123
 
                if(gc_drag_status==1 && gc_drag_mode & GC_DRAG_MODE_GRAB)
124
 
                    gc_drag_status=2;
125
 
                gc_drag_func(gc_drag_item, event, data);
126
 
            }
127
 
            break;
128
 
        default:
129
 
            break;
130
 
    }
131
 
    return FALSE;
132
 
}
133
 
 
134
 
void gc_drag_start(GnomeCanvasGroup *root_item, gc_Drag_Func function, gc_drag_mode_type mode)
135
 
{
136
 
    gtk_signal_connect(GTK_OBJECT(root_item), "event",
137
 
            (GtkSignalFunc) gc_drag_event_root, NULL);
138
 
    gc_drag_func = function;
139
 
    gc_drag_status = 0;
140
 
    gc_drag_item = NULL;
141
 
    gc_drag_offset_x = gc_drag_offset_y = 0;
 
35
GooCanvasItem*
 
36
gc_drag_item_get(void)
 
37
{
 
38
  return gc_drag_item;
 
39
}
 
40
 
 
41
void
 
42
gc_drag_item_set(GooCanvasItem *item)
 
43
{
 
44
  /* Don't use gc_drag_set_item during a dragging */
 
45
  g_assert(gc_drag_status == 0);
 
46
 
 
47
  if(item)
 
48
    gc_drag_item = item;
 
49
}
 
50
 
 
51
/* Move the current dragging item of the group if given */
 
52
void
 
53
gc_drag_item_move(GdkEvent *event, GooCanvasItem *group)
 
54
{
 
55
  double new_x = event->button.x;
 
56
  double new_y = event->button.y;
 
57
  GooCanvasBounds bounds;
 
58
 
 
59
  /* Check board boundaries */
 
60
  goo_canvas_item_get_bounds(gc_drag_item, &bounds);
 
61
  if((bounds.x1 < 0 && new_x < gc_drag_offset_x)
 
62
     || (bounds.x2 > BOARDWIDTH && new_x > gc_drag_offset_x))
 
63
      new_x = gc_drag_offset_x;
 
64
 
 
65
  if((bounds.y1 < 0 && new_y < gc_drag_offset_y)
 
66
     || (bounds.y2 > BOARDHEIGHT && new_y > gc_drag_offset_y))
 
67
      new_y = gc_drag_offset_y;
 
68
 
 
69
  goo_canvas_item_translate ((group ? group : gc_drag_item),
 
70
                             new_x - gc_drag_offset_x,
 
71
                             new_y - gc_drag_offset_y);
 
72
}
 
73
 
 
74
void
 
75
gc_drag_offset_get(double *x, double *y)
 
76
{
 
77
  *x = gc_drag_offset_x;
 
78
  *y = gc_drag_offset_y;
 
79
}
 
80
 
 
81
void
 
82
gc_drag_offset_set(double x, double y)
 
83
{
 
84
  gc_drag_offset_x = x;
 
85
  gc_drag_offset_y = y;
 
86
}
 
87
 
 
88
void
 
89
gc_drag_offset_save(GdkEvent *event)
 
90
{
 
91
  double x, y;
 
92
  GooCanvasBounds bounds;
 
93
 
 
94
  x = event->button.x;
 
95
  y = event->button.y;
 
96
 
 
97
  goo_canvas_item_get_bounds(gc_drag_item, &bounds);
 
98
  goo_canvas_convert_to_item_space(goo_canvas_item_get_canvas(gc_drag_item),
 
99
                                   gc_drag_item, &bounds.x1, &bounds.y1);
 
100
 
 
101
  gc_drag_offset_set(x - bounds.x1, y - bounds.y1);
 
102
}
 
103
 
 
104
gboolean
 
105
gc_drag_event (GooCanvasItem *item,
 
106
               GooCanvasItem *target,
 
107
               GdkEventButton *event,
 
108
               gpointer data)
 
109
{
 
110
  switch(event->type)
 
111
    {
 
112
    case GDK_BUTTON_PRESS:
 
113
      if(gc_drag_status == 0 && event->button == 1)
 
114
        {
 
115
          gc_drag_item = item;
 
116
          gc_drag_target = target;
 
117
          if(gc_drag_mode == GC_DRAG_MODE_GRAB)
 
118
            gc_drag_status = 2;
 
119
          else
 
120
            gc_drag_status = 1;
 
121
 
 
122
          gc_drag_user_data = data;
 
123
          gc_drag_func(item, target, (GdkEvent*)event, data);
 
124
        }
 
125
      break;
 
126
    case GDK_BUTTON_RELEASE:
 
127
      if(gc_drag_status == 2)
 
128
        {
 
129
          gc_drag_func(gc_drag_item,
 
130
                       item,
 
131
                       (GdkEvent*)event,
 
132
                       data);
 
133
          gc_drag_status = 0;
 
134
          gc_drag_item = NULL;
 
135
          gc_drag_target = NULL;
 
136
          gc_drag_user_data = NULL;
 
137
        }
 
138
      else if (gc_drag_status == 1 && gc_drag_mode & GC_DRAG_MODE_2CLICKS)
 
139
        gc_drag_status = 2;
 
140
      break;
 
141
    default:
 
142
      break;
 
143
    }
 
144
  return FALSE;
 
145
}
 
146
 
 
147
gint
 
148
gc_drag_event_root(GooCanvasItem * item,
 
149
                   GooCanvasItem *target,
 
150
                   GdkEventMotion *event,
 
151
                   gpointer data)
 
152
{
 
153
  if(gc_drag_target != target)
 
154
    return FALSE;
 
155
 
 
156
  switch(event->type)
 
157
    {
 
158
    case GDK_MOTION_NOTIFY:
 
159
      if(gc_drag_status > 0)
 
160
        {
 
161
          if(gc_drag_status==1 && gc_drag_mode & GC_DRAG_MODE_GRAB)
 
162
            gc_drag_status=2;
 
163
 
 
164
          gc_drag_func(gc_drag_item,
 
165
                       item,
 
166
                       (GdkEvent*)event,
 
167
                       gc_drag_user_data);
 
168
        }
 
169
      break;
 
170
    default:
 
171
      break;
 
172
    }
 
173
  return FALSE;
 
174
}
 
175
 
 
176
void
 
177
gc_drag_start(GooCanvasItem *root_item,
 
178
              GcDragFunc function,
 
179
              gc_drag_mode_type mode)
 
180
{
 
181
  g_signal_connect(root_item, "motion_notify_event",
 
182
                   (GtkSignalFunc) gc_drag_event_root, NULL);
 
183
  gc_drag_func = function;
 
184
  gc_drag_user_data = NULL;
 
185
  gc_drag_status = 0;
 
186
  gc_drag_item = NULL;
 
187
  gc_drag_target = NULL;
 
188
  gc_drag_offset_x = gc_drag_offset_y = 0;
 
189
  if (mode == GC_DRAG_MODE_DEFAULT)
 
190
    gc_drag_mode = gc_prop_get()->drag_mode;
 
191
  else
 
192
    gc_drag_mode = mode;
 
193
}
 
194
 
 
195
void
 
196
gc_drag_stop(GooCanvasItem *root_item)
 
197
{
 
198
  if(gc_drag_status > 0)
 
199
    {
 
200
      GdkEvent event;
 
201
      event.type = GDK_BUTTON_RELEASE;
 
202
      event.button.x = event.button.y =0;
 
203
      event.button.button = 1;
 
204
      gc_drag_func(gc_drag_item, NULL, &event, gc_drag_user_data);
 
205
    }
 
206
  g_signal_handlers_disconnect_by_func(root_item,
 
207
                                       (GtkSignalFunc) gc_drag_event_root,
 
208
                                       NULL);
 
209
  gc_drag_func = NULL;
 
210
  gc_drag_user_data = NULL;
 
211
  gc_drag_status = -1;
 
212
  gc_drag_item = NULL;
 
213
  gc_drag_target = NULL;
 
214
  gc_drag_mode = 0;
 
215
}
 
216
 
 
217
void
 
218
gc_drag_change_mode (gc_drag_mode_type mode)
 
219
{
 
220
  if(gc_drag_status != 0)
 
221
    g_warning("Don't use gc_change_mode during a dragging");
 
222
  else {
142
223
    if (mode == GC_DRAG_MODE_DEFAULT)
143
224
      gc_drag_mode = gc_prop_get()->drag_mode;
144
225
    else
145
226
      gc_drag_mode = mode;
146
 
}
147
 
 
148
 
void gc_drag_stop(GnomeCanvasGroup *root_item)
149
 
{
150
 
    if(gc_drag_status>0)
151
 
    {
152
 
        GdkEvent event;
153
 
        event.type = GDK_BUTTON_RELEASE;
154
 
        event.button.x = event.button.y =0;
155
 
        event.button.button = 1;
156
 
        gc_drag_func(gc_drag_item, &event, NULL);
157
 
    }
158
 
    gtk_signal_disconnect_by_func(GTK_OBJECT(root_item),
159
 
            (GtkSignalFunc) gc_drag_event_root, NULL);
160
 
    gc_drag_func = NULL;
161
 
    gc_drag_status = -1;
162
 
    gc_drag_item = NULL;
163
 
    gc_drag_mode = 0;
164
 
}
165
 
 
166
 
void gc_drag_change_mode (gc_drag_mode_type mode)
167
 
{
168
 
    if(gc_drag_status != 0)
169
 
        g_warning("Don't use gc_change_mode during a dragging");
170
 
    else {
171
 
      if (mode == GC_DRAG_MODE_DEFAULT)
172
 
        gc_drag_mode = gc_prop_get()->drag_mode;
173
 
      else
174
 
        gc_drag_mode = mode;
175
 
    }
 
227
  }
176
228
}