plugins/project-wizard/header.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3     header.c
   4     Copyright (C) 2004 Sebastien Granjoux
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (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
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  19 */
  20
  21 /*
  22  * header data read in .wiz file, used in the first page (project selection)
  23  *
  24  *---------------------------------------------------------------------------*/
  25
  26 #include <config.h>
  27 #include <sys/wait.h>
  28 #include <unistd.h>
  29
  30 #include "header.h"
  31
  32 #include <glib/gdir.h>
  33 #include <libanjuta/anjuta-utils.h>
  34
  35 /*---------------------------------------------------------------------------*/
  36
  37 #define STRING_CHUNK_SIZE       256
  38
  39 /*---------------------------------------------------------------------------*/
  40
  41 struct _NPWHeaderList
  42 {
  43         GNode* list;
  44         GStringChunk* string_pool;
  45         GMemChunk* data_pool;
  46 };
  47
  48 struct _NPWHeader {
  49         gchar* name;
  50         gchar* description;
  51         gchar* iconfile;
  52         gchar* category;
  53         gchar* filename;
  54         GList* required_programs;
  55         GList* required_packages;
  56         NPWHeaderList* owner;
  57         GNode* node;
  58 };
  59
  60 /* Header
  61  *---------------------------------------------------------------------------*/
  62
  63 NPWHeader*
  64 npw_header_new (NPWHeaderList* owner)
  65 {
  66         NPWHeader* this;
  67
  68         g_return_val_if_fail (owner, NULL);
  69
  70         this = g_chunk_new0(NPWHeader, owner->data_pool);
  71         this->owner = owner;
  72         this->node = g_node_append_data (owner->list, this);
  73
  74         return this;
  75 }
  76
  77 void
  78 npw_header_free (NPWHeader* this)
  79 {
  80         GNode* node;
  81
  82         /* Memory allocated in string pool and project pool is not free */
  83         node = g_node_find (this->owner->list, G_IN_ORDER, G_TRAVERSE_ALL, this);
  84         if (node != NULL)
  85                 g_node_destroy (node);
  86         if (this->required_programs)
  87                 g_list_free (this->required_programs);
  88         if (this->required_packages)
  89                 g_list_free (this->required_packages);
  90 }
  91
  92 void
  93 npw_header_set_name (NPWHeader* this, const gchar* name)
  94 {
  95         this->name = g_string_chunk_insert (this->owner->string_pool, name);
  96 }
  97
  98 const gchar*
  99 npw_header_get_name (const NPWHeader* this)
 100 {
 101         return this->name;
 102 }
 103
 104 void
 105 npw_header_set_filename (NPWHeader* this, const gchar* filename)
 106 {
 107         this->filename = g_string_chunk_insert (this->owner->string_pool, filename);
 108 }
 109
 110 const gchar*
 111 npw_header_get_filename (const NPWHeader* this)
 112 {
 113         return this->filename;
 114 }
 115
 116 void
 117 npw_header_set_category (NPWHeader* this, const gchar* category)
 118 {
 119         npw_header_list_organize(this->owner, category, this);
 120         this->category = ((NPWHeader *)this->node->parent->data)->category;
 121 }
 122
 123 const gchar*
 124 npw_header_get_category (const NPWHeader* this)
 125 {
 126         return this->category;
 127 }
 128
 129 void
 130 npw_header_set_description (NPWHeader* this, const gchar* description)
 131 {
 132         this->description = g_string_chunk_insert (this->owner->string_pool, description);
 133 }
 134
 135 const gchar*
 136 npw_header_get_description (const NPWHeader* this)
 137 {
 138         return this->description;
 139 }
 140
 141 void
 142 npw_header_set_iconfile (NPWHeader* this, const gchar* iconfile)
 143 {
 144         this->iconfile = g_string_chunk_insert (this->owner->string_pool, iconfile);
 145 }
 146
 147 const gchar*
 148 npw_header_get_iconfile (const NPWHeader* this)
 149 {
 150         return this->iconfile;
 151 }
 152
 153 void
 154 npw_header_add_required_program (NPWHeader* this, const gchar* program)
 155 {
 156         this->required_programs =
 157                 g_list_prepend (this->required_programs,
 158                                                 g_string_chunk_insert (this->owner->string_pool,
 159                                                                                            program));
 160
 161 }
 162
 163 void
 164 npw_header_add_required_package (NPWHeader* this, const gchar* package)
 165 {
 166         this->required_packages =
 167                 g_list_prepend (this->required_packages,
 168                                                 g_string_chunk_insert (this->owner->string_pool,
 169                                                                                            package));
 170 }
 171
 172 GList*
 173 npw_header_check_required_programs (NPWHeader* this)
 174 {
 175         GList *node = NULL;
 176         GList *failed_programs = NULL;
 177         for (node = this->required_programs; node; node = g_list_next (node))
 178         {
 179                 if (!anjuta_util_prog_is_installed (node->data, FALSE))
 180                 {
 181                         failed_programs = g_list_prepend (failed_programs, node->data);
 182                 }
 183         }
 184         return failed_programs;
 185 }
 186
 187 static gboolean
 188 package_is_installed (const gchar *package)
 189 {
 190         int status;
 191         int exit_status;
 192         pid_t pid;
 193         if ((pid = fork()) == 0)
 194         {
 195                 execlp ("pkg-config", "pkg-config", "--exists", package, NULL);
 196         }
 197         waitpid (pid, &status, 0);
 198         exit_status = WEXITSTATUS (status);
 199         return (exit_status == 0);
 200 }
 201
 202 GList*
 203 npw_header_check_required_packages (NPWHeader* this)
 204 {
 205         GList *node = NULL;
 206         GList *failed_packages = NULL;
 207         for (node = this->required_packages; node; node = g_list_next (node))
 208         {
 209                 if (!package_is_installed (node->data))
 210                 {
 211                         failed_packages = g_list_prepend (failed_packages, node->data);
 212                 }
 213         }
 214         return failed_packages;
 215 }
 216
 217 gboolean
 218 npw_header_is_leaf(const NPWHeader* this)
 219 {
 220         return G_NODE_IS_LEAF(this->node);
 221 }
 222
 223
 224 /* Header list
 225  *---------------------------------------------------------------------------*/
 226
 227 static GNode*
 228 npw_header_list_find_parent(NPWHeaderList* this, const gchar* category, gboolean create)
 229 {
 230         GNode* node;
 231         gint order;
 232
 233         for (node = g_node_first_child(this->list); node != NULL; node = g_node_next_sibling(node))
 234         {
 235                 const char* s;
 236
 237                 s = ((NPWHeader *)node->data)->category;
 238                 if (s != NULL)
 239                 {
 240                         order = g_ascii_strcasecmp (s, category);
 241                         if (order == 0)
 242                         {
 243                                 /* Find right category */
 244                                 break;
 245                         }
 246                         else if (order > 0)
 247                         {
 248                                 if (create == TRUE)
 249                                 {
 250                                         /* Category doesn't exist create a new node */
 251                                         NPWHeader* new_parent;
 252
 253                                         new_parent = npw_header_new (this);
 254                                         new_parent->category = g_string_chunk_insert (this->string_pool, category);
 255                                         g_node_unlink (new_parent->node);
 256                                         g_node_insert_before (this->list, node, new_parent->node);
 257                                         node = new_parent->node;
 258                                 }
 259                                 else
 260                                 {
 261                                         node = NULL;
 262                                 }
 263                                 break;
 264                         }
 265                 }
 266         }
 267
 268         if (create && (node == NULL))
 269         {
 270                 NPWHeader* new_parent;
 271
 272                 new_parent = npw_header_new (this);
 273                 new_parent->category = g_string_chunk_insert (this->string_pool, category);
 274                 node = new_parent->node;
 275         }
 276
 277         return node;
 278 }
 279
 280 typedef struct _HeaderListForeachProjectData
 281 {
 282         NPWHeaderForeachFunc func;
 283         gpointer data;
 284 } HeaderListForeachProjectData;
 285
 286 static void
 287 cb_header_list_foreach_project (GNode* node, gpointer data)
 288 {
 289         HeaderListForeachProjectData* d = (HeaderListForeachProjectData *)data;
 290
 291         (d->func)((NPWHeader*)node->data, d->data);
 292 }
 293
 294 static gboolean
 295 npw_header_list_foreach_node (GNode* list, NPWHeaderForeachFunc func, gpointer data, GTraverseFlags flag)
 296 {
 297         HeaderListForeachProjectData d;
 298
 299         if (g_node_first_child (list) == NULL) return FALSE;
 300
 301         d.func = func;
 302         d.data = data;
 303
 304         g_node_children_foreach (list, flag, cb_header_list_foreach_project, &d);
 305
 306         return TRUE;
 307 }
 308
 309 /*---------------------------------------------------------------------------*/
 310
 311 NPWHeaderList*
 312 npw_header_list_new (void)
 313 {
 314         NPWHeaderList* this;
 315
 316         this = g_new (NPWHeaderList, 1);
 317         this->string_pool = g_string_chunk_new (STRING_CHUNK_SIZE);
 318         this->data_pool = g_mem_chunk_new ("project pool", sizeof (NPWHeader), STRING_CHUNK_SIZE * sizeof (NPWHeader) / 4, G_ALLOC_ONLY);
 319         this->list = g_node_new (NULL);
 320
 321         return this;
 322 }
 323
 324 void
 325 npw_header_list_free (NPWHeaderList* this)
 326 {
 327         g_return_if_fail (this != NULL);
 328
 329         g_string_chunk_free (this->string_pool);
 330         g_mem_chunk_destroy (this->data_pool);
 331         g_node_destroy (this->list);
 332         g_free (this);
 333 }
 334
 335 void
 336 npw_header_list_organize(NPWHeaderList* this, const gchar* category, NPWHeader* header)
 337 {
 338         GNode* parent;
 339         GNode* node;
 340         const gchar* name;
 341
 342         /* node without a category stay on top */
 343         if ((category == NULL) || (*category == '\0')) return;
 344
 345         /* Detach the node */
 346         g_node_unlink(header->node);
 347
 348         /* Find parent */
 349         parent = npw_header_list_find_parent(this, category, TRUE);
 350
 351         /* Insert node as a child in alphabetic order*/
 352         name = npw_header_get_name (header);
 353         for (node = g_node_first_child(parent); node != NULL; node = g_node_next_sibling(node))
 354         {
 355                 if (g_ascii_strcasecmp (npw_header_get_name ((NPWHeader *)node->data), name) > 0)
 356                 {
 357                         g_node_insert_before (parent, node, header->node);
 358                         return;
 359                 }
 360         }
 361         g_node_insert(parent, -1, header->node);
 362 }
 363
 364 gboolean
 365 npw_header_list_foreach_project (const NPWHeaderList* this, NPWHeaderForeachFunc func, gpointer data)
 366 {
 367         return npw_header_list_foreach_node (this->list, func, data, G_TRAVERSE_LEAFS);
 368 }
 369
 370 gboolean
 371 npw_header_list_foreach_project_in (const NPWHeaderList* this, const gchar* category, NPWHeaderForeachFunc func, gpointer data)
 372 {
 373         GNode* node;
 374
 375         /* FIXME: const modified has been removed because the find function
 376          * with TRUE as the third argument could create a parent if it
 377          * doesn't exist. It could be better to split this function in two */
 378         node = npw_header_list_find_parent((NPWHeaderList*)this, category, FALSE);
 379         if (node == NULL) return FALSE;
 380
 381         return npw_header_list_foreach_node (node, func, data, G_TRAVERSE_LEAFS);
 382 }
 383
 384 gboolean
 385 npw_header_list_foreach_category (const NPWHeaderList* this, NPWHeaderForeachFunc func, gpointer data)
 386 {
 387         return npw_header_list_foreach_node (this->list, func, data, G_TRAVERSE_NON_LEAFS);
 388 }