gtktreednd.c 10.9 KB
Newer Older
Havoc Pennington's avatar
Havoc Pennington committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/* gtktreednd.c
 * Copyright (C) 2001  Red Hat, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
Javier Jardón's avatar
Javier Jardón committed
15
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
Havoc Pennington's avatar
Havoc Pennington committed
16
17
 */

18
#include "config.h"
Havoc Pennington's avatar
Havoc Pennington committed
19
20
#include <string.h>
#include "gtktreednd.h"
Matthias Clasen's avatar
Matthias Clasen committed
21
#include "gtkintl.h"
Havoc Pennington's avatar
Havoc Pennington committed
22

23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

/**
 * SECTION:gtktreednd
 * @Short_description: Interfaces for drag-and-drop support in GtkTreeView
 * @Title: GtkTreeView drag-and-drop
 *
 * GTK+ supports Drag-and-Drop in tree views with a high-level and a low-level
 * API.
 *
 * The low-level API consists of the GTK+ DND API, augmented by some treeview
 * utility functions: gtk_tree_view_set_drag_dest_row(),
 * gtk_tree_view_get_drag_dest_row(), gtk_tree_view_get_dest_row_at_pos(),
 * gtk_tree_view_create_row_drag_icon(), gtk_tree_set_row_drag_data() and
 * gtk_tree_get_row_drag_data(). This API leaves a lot of flexibility, but
 * nothing is done automatically, and implementing advanced features like
 * hover-to-open-rows or autoscrolling on top of this API is a lot of work.
 *
 * On the other hand, if you write to the high-level API, then all the
 * bookkeeping of rows is done for you, as well as things like hover-to-open
 * and auto-scroll, but your models have to implement the
 * #GtkTreeDragSource and #GtkTreeDragDest interfaces.
 */


Havoc Pennington's avatar
Havoc Pennington committed
47
48
49
50
51
52
53
GType
gtk_tree_drag_source_get_type (void)
{
  static GType our_type = 0;

  if (!our_type)
    {
54
      const GTypeInfo our_info =
Havoc Pennington's avatar
Havoc Pennington committed
55
56
57
58
59
60
61
62
63
64
65
66
      {
        sizeof (GtkTreeDragSourceIface), /* class_size */
	NULL,		/* base_init */
	NULL,		/* base_finalize */
	NULL,
	NULL,		/* class_finalize */
	NULL,		/* class_data */
	0,
	0,              /* n_preallocs */
	NULL
      };

Matthias Clasen's avatar
Matthias Clasen committed
67
68
      our_type = g_type_register_static (G_TYPE_INTERFACE, 
					 I_("GtkTreeDragSource"),
Manish Singh's avatar
Manish Singh committed
69
					 &our_info, 0);
Havoc Pennington's avatar
Havoc Pennington committed
70
71
72
73
74
75
76
77
78
79
80
81
82
    }
  
  return our_type;
}


GType
gtk_tree_drag_dest_get_type (void)
{
  static GType our_type = 0;

  if (!our_type)
    {
83
      const GTypeInfo our_info =
Havoc Pennington's avatar
Havoc Pennington committed
84
85
86
87
88
89
90
91
92
93
94
95
      {
        sizeof (GtkTreeDragDestIface), /* class_size */
	NULL,		/* base_init */
	NULL,		/* base_finalize */
	NULL,
	NULL,		/* class_finalize */
	NULL,		/* class_data */
	0,
	0,              /* n_preallocs */
	NULL
      };

Matthias Clasen's avatar
Matthias Clasen committed
96
      our_type = g_type_register_static (G_TYPE_INTERFACE, I_("GtkTreeDragDest"), &our_info, 0);
Havoc Pennington's avatar
Havoc Pennington committed
97
98
99
100
101
    }
  
  return our_type;
}

102
103
104
105
106
107
/**
 * gtk_tree_drag_source_row_draggable:
 * @drag_source: a #GtkTreeDragSource
 * @path: row on which user is initiating a drag
 * 
 * Asks the #GtkTreeDragSource whether a particular row can be used as
108
 * the source of a DND operation. If the source doesn’t implement
109
110
 * this interface, the row is assumed draggable.
 *
111
 * Returns: %TRUE if the row can be dragged
112
113
114
115
116
117
118
119
120
121
122
123
124
 **/
gboolean
gtk_tree_drag_source_row_draggable (GtkTreeDragSource *drag_source,
                                    GtkTreePath       *path)
{
  GtkTreeDragSourceIface *iface = GTK_TREE_DRAG_SOURCE_GET_IFACE (drag_source);

  g_return_val_if_fail (path != NULL, FALSE);

  if (iface->row_draggable)
    return (* iface->row_draggable) (drag_source, path);
  else
    return TRUE;
Murray Cumming's avatar
Murray Cumming committed
125
126
127
    /* Returning TRUE if row_draggable is not implemented is a fallback.
       Interface implementations such as GtkTreeStore and GtkListStore really should
       implement row_draggable. */
128
129
}

Havoc Pennington's avatar
Havoc Pennington committed
130
131
132
133
134
135
136
137
138
139
140
141

/**
 * gtk_tree_drag_source_drag_data_delete:
 * @drag_source: a #GtkTreeDragSource
 * @path: row that was being dragged
 * 
 * Asks the #GtkTreeDragSource to delete the row at @path, because
 * it was moved somewhere else via drag-and-drop. Returns %FALSE
 * if the deletion fails because @path no longer exists, or for
 * some model-specific reason. Should robustly handle a @path no
 * longer found in the model!
 * 
142
 * Returns: %TRUE if the row was successfully deleted
Havoc Pennington's avatar
Havoc Pennington committed
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 **/
gboolean
gtk_tree_drag_source_drag_data_delete (GtkTreeDragSource *drag_source,
                                       GtkTreePath       *path)
{
  GtkTreeDragSourceIface *iface = GTK_TREE_DRAG_SOURCE_GET_IFACE (drag_source);

  g_return_val_if_fail (iface->drag_data_delete != NULL, FALSE);
  g_return_val_if_fail (path != NULL, FALSE);

  return (* iface->drag_data_delete) (drag_source, path);
}

/**
 * gtk_tree_drag_source_drag_data_get:
 * @drag_source: a #GtkTreeDragSource
 * @path: row that was dragged
160
 * @selection_data: a #GtkSelectionData to fill with data
161
 *                  from the dragged row
Havoc Pennington's avatar
Havoc Pennington committed
162
163
164
165
166
167
 * 
 * Asks the #GtkTreeDragSource to fill in @selection_data with a
 * representation of the row at @path. @selection_data->target gives
 * the required type of the data.  Should robustly handle a @path no
 * longer found in the model!
 * 
168
 * Returns: %TRUE if data of the required type was provided 
Havoc Pennington's avatar
Havoc Pennington committed
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
 **/
gboolean
gtk_tree_drag_source_drag_data_get    (GtkTreeDragSource *drag_source,
                                       GtkTreePath       *path,
                                       GtkSelectionData  *selection_data)
{
  GtkTreeDragSourceIface *iface = GTK_TREE_DRAG_SOURCE_GET_IFACE (drag_source);

  g_return_val_if_fail (iface->drag_data_get != NULL, FALSE);
  g_return_val_if_fail (path != NULL, FALSE);
  g_return_val_if_fail (selection_data != NULL, FALSE);

  return (* iface->drag_data_get) (drag_source, path, selection_data);
}

/**
 * gtk_tree_drag_dest_drag_data_received:
 * @drag_dest: a #GtkTreeDragDest
 * @dest: row to drop in front of
 * @selection_data: data to drop
 * 
 * Asks the #GtkTreeDragDest to insert a row before the path @dest,
 * deriving the contents of the row from @selection_data. If @dest is
 * outside the tree so that inserting before it is impossible, %FALSE
 * will be returned. Also, %FALSE may be returned if the new row is
 * not created for some model-specific reason.  Should robustly handle
 * a @dest no longer found in the model!
 * 
197
 * Returns: whether a new row was created before position @dest
Havoc Pennington's avatar
Havoc Pennington committed
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
 **/
gboolean
gtk_tree_drag_dest_drag_data_received (GtkTreeDragDest  *drag_dest,
                                       GtkTreePath      *dest,
                                       GtkSelectionData *selection_data)
{
  GtkTreeDragDestIface *iface = GTK_TREE_DRAG_DEST_GET_IFACE (drag_dest);

  g_return_val_if_fail (iface->drag_data_received != NULL, FALSE);
  g_return_val_if_fail (dest != NULL, FALSE);
  g_return_val_if_fail (selection_data != NULL, FALSE);

  return (* iface->drag_data_received) (drag_dest, dest, selection_data);
}

213
214

/**
Matthias Clasen's avatar
Matthias Clasen committed
215
 * gtk_tree_drag_dest_row_drop_possible:
216
217
 * @drag_dest: a #GtkTreeDragDest
 * @dest_path: destination row
218
 * @selection_data: the data being dragged
219
220
 * 
 * Determines whether a drop is possible before the given @dest_path,
221
222
 * at the same depth as @dest_path. i.e., can we drop the data in
 * @selection_data at that location. @dest_path does not have to
223
 * exist; the return value will almost certainly be %FALSE if the
224
 * parent of @dest_path doesn’t exist, though.
225
 * 
226
 * Returns: %TRUE if a drop is possible before @dest_path
227
228
229
 **/
gboolean
gtk_tree_drag_dest_row_drop_possible (GtkTreeDragDest   *drag_dest,
230
231
                                      GtkTreePath       *dest_path,
				      GtkSelectionData  *selection_data)
232
233
234
235
{
  GtkTreeDragDestIface *iface = GTK_TREE_DRAG_DEST_GET_IFACE (drag_dest);

  g_return_val_if_fail (iface->row_drop_possible != NULL, FALSE);
236
  g_return_val_if_fail (selection_data != NULL, FALSE);
237
238
  g_return_val_if_fail (dest_path != NULL, FALSE);

239
  return (* iface->row_drop_possible) (drag_dest, dest_path, selection_data);
240
241
}

Havoc Pennington's avatar
Havoc Pennington committed
242
243
244
245
246
247
248
249
250
typedef struct _TreeRowData TreeRowData;

struct _TreeRowData
{
  GtkTreeModel *model;
  gchar path[4];
};

/**
251
 * gtk_tree_set_row_drag_data:
Havoc Pennington's avatar
Havoc Pennington committed
252
253
254
255
256
257
258
 * @selection_data: some #GtkSelectionData
 * @tree_model: a #GtkTreeModel
 * @path: a row in @tree_model
 * 
 * Sets selection data of target type %GTK_TREE_MODEL_ROW. Normally used
 * in a drag_data_get handler.
 * 
259
 * Returns: %TRUE if the #GtkSelectionData had the proper target type to allow us to set a tree row
Havoc Pennington's avatar
Havoc Pennington committed
260
261
 **/
gboolean
262
263
264
gtk_tree_set_row_drag_data (GtkSelectionData *selection_data,
			    GtkTreeModel     *tree_model,
			    GtkTreePath      *path)
Havoc Pennington's avatar
Havoc Pennington committed
265
266
267
268
269
270
271
272
273
274
{
  TreeRowData *trd;
  gchar *path_str;
  gint len;
  gint struct_size;
  
  g_return_val_if_fail (selection_data != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_TREE_MODEL (tree_model), FALSE);
  g_return_val_if_fail (path != NULL, FALSE);

275
  if (gtk_selection_data_get_target (selection_data) != gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
Havoc Pennington's avatar
Havoc Pennington committed
276
277
278
279
280
281
282
283
284
285
286
287
288
    return FALSE;
  
  path_str = gtk_tree_path_to_string (path);

  len = strlen (path_str);

  /* the old allocate-end-of-struct-to-hold-string trick */
  struct_size = sizeof (TreeRowData) + len + 1 -
    (sizeof (TreeRowData) - G_STRUCT_OFFSET (TreeRowData, path));

  trd = g_malloc (struct_size); 

  strcpy (trd->path, path_str);
Jonathan Blandford's avatar
Jonathan Blandford committed
289
290

  g_free (path_str);
Havoc Pennington's avatar
Havoc Pennington committed
291
292
293
294
  
  trd->model = tree_model;
  
  gtk_selection_data_set (selection_data,
295
                          gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"),
Havoc Pennington's avatar
Havoc Pennington committed
296
297
298
299
300
301
302
303
304
305
                          8, /* bytes */
                          (void*)trd,
                          struct_size);

  g_free (trd);
  
  return TRUE;
}

/**
306
 * gtk_tree_get_row_drag_data:
Havoc Pennington's avatar
Havoc Pennington committed
307
 * @selection_data: a #GtkSelectionData
308
309
 * @tree_model: (nullable) (optional) (transfer none) (out): a #GtkTreeModel
 * @path: (nullable) (optional) (out): row in @tree_model
Havoc Pennington's avatar
Havoc Pennington committed
310
311
312
313
 * 
 * Obtains a @tree_model and @path from selection data of target type
 * %GTK_TREE_MODEL_ROW. Normally called from a drag_data_received handler.
 * This function can only be used if @selection_data originates from the same
314
 * process that’s calling this function, because a pointer to the tree model
315
 * is being passed around. If you aren’t in the same process, then you'll
Havoc Pennington's avatar
Havoc Pennington committed
316
317
318
319
320
 * get memory corruption. In the #GtkTreeDragDest drag_data_received handler,
 * you can assume that selection data of type %GTK_TREE_MODEL_ROW is
 * in from the current process. The returned path must be freed with
 * gtk_tree_path_free().
 * 
321
 * Returns: %TRUE if @selection_data had target type %GTK_TREE_MODEL_ROW and
Havoc Pennington's avatar
Havoc Pennington committed
322
323
324
 *  is otherwise valid
 **/
gboolean
325
326
327
gtk_tree_get_row_drag_data (GtkSelectionData  *selection_data,
			    GtkTreeModel     **tree_model,
			    GtkTreePath      **path)
Havoc Pennington's avatar
Havoc Pennington committed
328
329
330
331
332
333
334
335
336
337
{
  TreeRowData *trd;
  
  g_return_val_if_fail (selection_data != NULL, FALSE);  

  if (tree_model)
    *tree_model = NULL;

  if (path)
    *path = NULL;
338
339

  if (gtk_selection_data_get_target (selection_data) != gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
Havoc Pennington's avatar
Havoc Pennington committed
340
341
    return FALSE;

342
  if (gtk_selection_data_get_length (selection_data) < 0)
343
344
    return FALSE;

345
  trd = (void*) gtk_selection_data_get_data (selection_data);
Havoc Pennington's avatar
Havoc Pennington committed
346
347
348
349
350
351
352
353
354

  if (tree_model)
    *tree_model = trd->model;

  if (path)
    *path = gtk_tree_path_new_from_string (trd->path);
  
  return TRUE;
}