plugins/project-manager/tree-data.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /* tree-data.c
   3  *
   4  * Copyright (C) 2010  Sébastien Granjoux
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2 of the
   9  * License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public
  17  * License along with this program; if not, write to the
  18  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <gio/gio.h>
  27 #include "tree-data.h"
  28
  29 #include <string.h>
  30
  31 /**
  32  * The GbfTreeData object store all data needed by each element of the project
  33  * tree view. It has the same role than AnjutaProjectNode in the project
  34  * backend and normally there is one GbfTreeData for each AnjutaProjectNode.
  35  *
  36  * The GbfTreeData objects do not have a pointer to their corresponding
  37  * AnjutaProjectNode because they do not have the same life time. By example
  38  * when a project is reloaded all AnjutaProjectNode are destroyed but the
  39  * GbfTreeData stay alive. They contain enough information to be able to
  40  * find the corresponding AnjutaProjectNode though, but it is a search so
  41  * it takes more time.
  42  *
  43  * Several GbfTreeData can correspond to the same AnjutaProjectNode because
  44  * the tree view can contain shortcuts on alreay existing  project node. Each
  45  * shortcut has its own GbfTreeData object containing the same data than the
  46  * root object.
  47  *
  48  * The GbfTreeData objects are not owned by the tree view which keeps only
  49  * pointer on them. When removing a element in the tree view, it is the
  50  * responsability of the routine to free all GbfTreeData objects before. On
  51  * the other hand, it must not be freed after getting one pointer from
  52  * the tree view.
  53  */
  54
  55 gchar *
  56 gbf_tree_data_get_uri (GbfTreeData *data)
  57 {
  58         return data->node ? g_file_get_uri (anjuta_project_node_get_file (data->node)) : NULL;
  59 }
  60
  61 GFile *
  62 gbf_tree_data_get_file (GbfTreeData *data)
  63 {
  64         if (data->source != NULL)
  65         {
  66                 return g_object_ref (g_file_get_uri (data->source));
  67         }
  68         else if (data->target != NULL)
  69         {
  70                 GFile *target;
  71
  72                 target = g_file_get_child (data->group, data->target);
  73
  74                 return target;
  75         }
  76         else if (data->group != NULL)
  77         {
  78                 return g_object_ref (g_file_get_uri (data->group));
  79         }
  80
  81         return NULL;
  82 }
  83
  84 gchar *
  85 gbf_tree_data_get_path (GbfTreeData *data)
  86 {
  87         return data->node ? g_file_get_path (anjuta_project_node_get_file (data->node)) : NULL;
  88 }
  89
  90 const gchar *
  91 gbf_tree_data_get_name (GbfTreeData *data)
  92 {
  93         return data->node != NULL ? anjuta_project_node_get_name (data->node) : data->name;
  94 }
  95
  96 AnjutaProjectNode *
  97 gbf_tree_data_get_node (GbfTreeData *data)
  98 {
  99         return data->node;
 100 }
 101
 102 gboolean
 103 gbf_tree_data_equal (GbfTreeData *data_a, GbfTreeData *data_b)
 104 {
 105         gboolean equal;
 106
 107         equal = data_a == data_b;
 108         if (!equal && (data_a != NULL) && (data_b != NULL))
 109         {
 110                 equal = data_a->type == data_b->type;
 111                 if (equal)
 112                 {
 113                         if ((data_a->group != NULL) && (data_b->group != NULL))
 114                         {
 115                                 equal = g_file_equal (data_a->group, data_b->group);
 116                         }
 117
 118                         if (equal)
 119                         {
 120                                 if ((data_a->target != NULL) && (data_b->target != NULL))
 121                                 {
 122                                         equal = strcmp (data_a->target, data_b->target) == 0;
 123                                 }
 124
 125                                 if (equal)
 126                                 {
 127                                         if ((data_a->source != NULL) && (data_b->source != NULL))
 128                                         {
 129                                                 equal = g_file_equal (data_a->source, data_b->source);
 130                                         }
 131                                 }
 132                         }
 133                 }
 134                 else if ((data_a->type == GBF_TREE_NODE_UNKNOWN) || (data_b->type == GBF_TREE_NODE_UNKNOWN))
 135                 {
 136                         equal = strcmp (data_b->name, data_a->name);
 137                 }
 138         }
 139
 140         return equal;
 141 }
 142
 143 gboolean
 144 gbf_tree_data_equal_file (GbfTreeData *data,  GbfTreeNodeType type, GFile *file)
 145 {
 146         gboolean equal = FALSE;
 147
 148         if (data != NULL)
 149         {
 150                 AnjutaProjectNode *node = gbf_tree_data_get_node (data);
 151
 152                 if (node != NULL)
 153                 {
 154                         if ((type == GBF_TREE_NODE_UNKNOWN) || (type == data->type))
 155                         {
 156                                 GFile* node_file = anjuta_project_node_get_file (node);
 157                                 if (node_file && g_file_equal (node_file, file))
 158                                 {
 159                                         equal = TRUE;
 160                                 }
 161                         }
 162                 }
 163         }
 164
 165         return equal;
 166 }
 167
 168 gboolean
 169 gbf_tree_data_equal_name (GbfTreeData *data, const gchar *name)
 170 {
 171         return g_strcmp0 (data->name, name) == 0;
 172 }
 173
 174 GbfTreeNodeType
 175 gbf_tree_node_type_from_project (AnjutaProjectNodeType type)
 176 {
 177         GbfTreeNodeType tree_type;
 178
 179         switch (type & ANJUTA_PROJECT_TYPE_MASK)
 180         {
 181         case ANJUTA_PROJECT_ROOT:
 182                 tree_type = GBF_TREE_NODE_ROOT;
 183                 break;
 184         case ANJUTA_PROJECT_GROUP:
 185                 tree_type = GBF_TREE_NODE_GROUP;
 186                 break;
 187         case ANJUTA_PROJECT_TARGET:
 188                 tree_type = GBF_TREE_NODE_TARGET;
 189                 break;
 190         case ANJUTA_PROJECT_SOURCE:
 191                 tree_type = GBF_TREE_NODE_SOURCE;
 192                 break;
 193         case ANJUTA_PROJECT_MODULE:
 194                 tree_type = GBF_TREE_NODE_MODULE;
 195                 break;
 196         case ANJUTA_PROJECT_PACKAGE:
 197                 tree_type = GBF_TREE_NODE_PACKAGE;
 198                 break;
 199         default:
 200                 tree_type = GBF_TREE_NODE_UNKNOWN;
 201                 break;
 202         }
 203
 204         return tree_type;
 205 }
 206
 207 void
 208 gbf_tree_data_invalidate (GbfTreeData *data)
 209 {
 210         data->type = GBF_TREE_NODE_INVALID;
 211 }
 212
 213 GbfTreeData *
 214 gbf_tree_data_new_string (const gchar *string)
 215 {
 216         GbfTreeData *data = g_slice_new0 (GbfTreeData);
 217
 218         data->type = GBF_TREE_NODE_STRING;
 219         data->name = g_strdup (string);
 220
 221         return data;
 222 }
 223
 224 GbfTreeData *
 225 gbf_tree_data_new_shortcut (GbfTreeData *src)
 226 {
 227         GbfTreeData *data = g_slice_new0 (GbfTreeData);
 228
 229         data->type = GBF_TREE_NODE_SHORTCUT;
 230         data->node = src->node;
 231         data->name = g_strdup (src->name);
 232         data->group = src->group == NULL ? NULL : g_object_ref (src->group);
 233         data->target = g_strdup (src->target);
 234         data->source = src->source == NULL ? NULL : g_object_ref (src->source);
 235         data->is_shortcut = TRUE;
 236         data->shortcut = src;
 237         //src->shortcut = data;
 238
 239         return data;
 240 }
 241
 242 GbfTreeData *
 243 gbf_tree_data_new_proxy (const char *name, gboolean expanded)
 244 {
 245         GbfTreeData *data = g_slice_new0 (GbfTreeData);
 246
 247         data->type = GBF_TREE_NODE_UNKNOWN;
 248         data->node = NULL;
 249         data->name = g_strdup (name);
 250         data->expanded = expanded;
 251
 252         return data;
 253 }
 254
 255 GbfTreeData *
 256 gbf_tree_data_new_group (AnjutaProjectNode *group)
 257 {
 258         GbfTreeData *data = g_slice_new0 (GbfTreeData);
 259
 260         data->type = anjuta_project_node_parent(group) == NULL ? GBF_TREE_NODE_ROOT : GBF_TREE_NODE_GROUP;
 261         data->node = group;
 262
 263         data->name = g_strdup (anjuta_project_node_get_name (group));
 264
 265         data->group = g_object_ref (anjuta_project_node_get_file (group));
 266
 267         return data;
 268 }
 269
 270 GbfTreeData *
 271 gbf_tree_data_new_target (AnjutaProjectNode *target)
 272 {
 273         GbfTreeData *data = g_slice_new0 (GbfTreeData);
 274         AnjutaProjectNode *group;
 275
 276         data->type = GBF_TREE_NODE_TARGET;
 277         data->node = target;
 278         data->name = g_strdup (anjuta_project_node_get_name (target));
 279
 280         group = anjuta_project_node_parent (target);
 281         data->group = g_object_ref (anjuta_project_node_get_file (group));
 282         data->target = g_strdup (anjuta_project_node_get_name (target));
 283
 284         return data;
 285 }
 286
 287 GbfTreeData *
 288 gbf_tree_data_new_object (AnjutaProjectNode *node)
 289 {
 290         GbfTreeData *data = g_slice_new0 (GbfTreeData);
 291         GFileInfo *ginfo;
 292         AnjutaProjectNode *parent;
 293
 294         data->type = GBF_TREE_NODE_OBJECT;
 295         data->node = node;
 296
 297         data->source = g_object_ref (anjuta_project_node_get_file (node));
 298
 299         ginfo = g_file_query_info (data->source,
 300             G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME,
 301             G_FILE_QUERY_INFO_NONE,
 302             NULL, NULL);
 303         if (ginfo)
 304         {
 305                 data->name = g_strdup (g_file_info_get_display_name (ginfo));
 306                 g_object_unref(ginfo);
 307         }
 308         else
 309         {
 310                 data->name = g_file_get_basename (data->source);
 311         }
 312
 313         parent = anjuta_project_node_parent (node);
 314         if (anjuta_project_node_get_node_type (parent) == ANJUTA_PROJECT_GROUP)
 315         {
 316                 data->group = g_object_ref (anjuta_project_node_get_file (parent));
 317         }
 318         else if (anjuta_project_node_get_node_type (parent) == ANJUTA_PROJECT_TARGET)
 319         {
 320                 AnjutaProjectNode *group;
 321
 322                 group = anjuta_project_node_parent (parent);
 323                 data->group = g_object_ref (anjuta_project_node_get_file (group));
 324                 data->target = g_strdup (anjuta_project_node_get_name (parent));
 325         }
 326
 327         return data;
 328 }
 329
 330 GbfTreeData *
 331 gbf_tree_data_new_source (AnjutaProjectNode *source)
 332 {
 333         GbfTreeData *data = g_slice_new0 (GbfTreeData);
 334         GFileInfo *ginfo;
 335         AnjutaProjectNode *parent;
 336
 337         data->type = GBF_TREE_NODE_SOURCE;
 338         data->node = source;
 339
 340         data->source = g_object_ref (anjuta_project_node_get_file (source));
 341
 342         ginfo = g_file_query_info (data->source,
 343             G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME,
 344             G_FILE_QUERY_INFO_NONE,
 345             NULL, NULL);
 346         if (ginfo)
 347         {
 348                 data->name = g_strdup (g_file_info_get_display_name (ginfo));
 349                 g_object_unref(ginfo);
 350         }
 351         else
 352         {
 353                 data->name = g_file_get_basename (data->source);
 354         }
 355
 356         parent = anjuta_project_node_parent (source);
 357         if (anjuta_project_node_get_node_type (parent) == ANJUTA_PROJECT_GROUP)
 358         {
 359                 data->group = g_object_ref (anjuta_project_node_get_file (parent));
 360         }
 361         else if (anjuta_project_node_get_node_type (parent) == ANJUTA_PROJECT_TARGET)
 362         {
 363                 AnjutaProjectNode *group;
 364
 365                 group = anjuta_project_node_parent (parent);
 366                 data->group = g_object_ref (anjuta_project_node_get_file (group));
 367                 data->target = g_strdup (anjuta_project_node_get_name (parent));
 368         }
 369
 370         return data;
 371 }
 372
 373 GbfTreeData *
 374 gbf_tree_data_new_root (AnjutaProjectNode *root)
 375 {
 376         GbfTreeData *data = g_slice_new0 (GbfTreeData);
 377
 378         data->type = GBF_TREE_NODE_ROOT;
 379         data->node = root;
 380         data->name = g_strdup (anjuta_project_node_get_name (root));
 381
 382         return data;
 383 }
 384
 385 GbfTreeData *
 386 gbf_tree_data_new_module (AnjutaProjectNode *module)
 387 {
 388         GbfTreeData *data = g_slice_new0 (GbfTreeData);
 389
 390         data->type = GBF_TREE_NODE_MODULE;
 391         data->node = module;
 392         data->name = g_strdup (anjuta_project_node_get_name (module));
 393
 394         return data;
 395 }
 396
 397 GbfTreeData *
 398 gbf_tree_data_new_package (AnjutaProjectNode *package)
 399 {
 400         GbfTreeData *data = g_slice_new0 (GbfTreeData);
 401
 402         data->type = GBF_TREE_NODE_PACKAGE;
 403         data->node = package;
 404         data->name = g_strdup (anjuta_project_node_get_name (package));
 405
 406         return data;
 407 }
 408
 409 GbfTreeData *
 410 gbf_tree_data_new_node (AnjutaProjectNode *node)
 411 {
 412         GbfTreeData *data = NULL;
 413
 414         switch (anjuta_project_node_get_node_type (node))
 415         {
 416                 case ANJUTA_PROJECT_GROUP:
 417                         data = gbf_tree_data_new_group (node);
 418                         break;
 419                 case ANJUTA_PROJECT_TARGET:
 420                         data = gbf_tree_data_new_target(node);
 421                         break;
 422                 case ANJUTA_PROJECT_OBJECT:
 423                         data = gbf_tree_data_new_object (node);
 424                         break;
 425                 case ANJUTA_PROJECT_SOURCE:
 426                         data = gbf_tree_data_new_source (node);
 427                         break;
 428                 case ANJUTA_PROJECT_MODULE:
 429                         data = gbf_tree_data_new_module (node);
 430                         break;
 431                 case ANJUTA_PROJECT_PACKAGE:
 432                         data = gbf_tree_data_new_package (node);
 433                         break;
 434                 case ANJUTA_PROJECT_ROOT:
 435                         data = gbf_tree_data_new_root (node);
 436                         break;
 437                 default:
 438                         break;
 439         }
 440
 441         return data;
 442 }
 443
 444
 445 void
 446 gbf_tree_data_free (GbfTreeData *data)
 447 {
 448         if (data)
 449         {
 450                 g_free (data->name);
 451                 if (data->group != NULL) g_object_unref (data->group);
 452                 g_free (data->target);
 453                 if (data->source != NULL) g_object_unref (data->source);
 454                 //if (data->shortcut) data->shortcut->shortcut = NULL;
 455                 if (data->properties_dialog) gtk_widget_destroy (data->properties_dialog);
 456                 g_slice_free (GbfTreeData, data);
 457         }
 458 }