project.c

   1 /*
   2  *  geanyprj - Alternative project support for geany light IDE.
   3  *
   4  *  Copyright 2007 Frank Lanitz <frank(at)frank(dot)uvena(dot)de>
   5  *  Copyright 2007 Enrico Tröger <enrico.troeger@uvena.de>
   6  *  Copyright 2007 Nick Treleaven <nick.treleaven@btinternet.com>
   7  *  Copyright 2007,2008 Yura Siamashka <yurand2@gmail.com>
   8  *
   9  *  This program is free software: you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation, either version 3 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 #include <sys/time.h>
  24
  25 #include "geany.h"
  26 #include "support.h"
  27 #include "prefs.h"
  28 #include "plugindata.h"
  29 #include "document.h"
  30 #include "filetypes.h"
  31 #include "utils.h"
  32 #include "pluginmacros.h"
  33
  34 #include "project.h"
  35
  36 #include "geanyprj.h"
  37
  38 extern GeanyData *geany_data;
  39
  40 const gchar *project_type_string[NEW_PROJECT_TYPE_SIZE] = {
  41         "All",
  42         "C/C++",
  43         "C",
  44         "Python",
  45         "None"
  46 };
  47
  48 static gboolean
  49 project_filter_c_cpp(const gchar * file)
  50 {
  51         if (geany_data->filetype->detect_from_filename(file)->id == GEANY_FILETYPES_C ||
  52             geany_data->filetype->detect_from_filename(file)->id == GEANY_FILETYPES_CPP)
  53                 return TRUE;
  54         return FALSE;
  55 }
  56
  57 static gboolean
  58 project_filter_c(const gchar * file)
  59 {
  60         if (geany_data->filetype->detect_from_filename(file)->id == GEANY_FILETYPES_C)
  61                 return TRUE;
  62         return FALSE;
  63 }
  64
  65 static gboolean
  66 project_filter_python(const gchar * file)
  67 {
  68         if (geany_data->filetype->detect_from_filename(file)->id == GEANY_FILETYPES_PYTHON)
  69                 return TRUE;
  70         return FALSE;
  71 }
  72
  73 static gboolean
  74 project_filter_all(const gchar * file)
  75 {
  76         if (geany_data->filetype->detect_from_filename(file)->id != GEANY_FILETYPES_ALL)
  77                 return TRUE;
  78         return FALSE;
  79 }
  80
  81 static gboolean
  82 project_filter_none(UNUSED(const gchar * file))
  83 {
  84         return FALSE;
  85 }
  86
  87
  88 void *project_type_filter[NEW_PROJECT_TYPE_SIZE] = {
  89         project_filter_all,
  90         project_filter_c_cpp,
  91         project_filter_c,
  92         project_filter_python,
  93         project_filter_none
  94 };
  95
  96
  97 static void
  98 free_tag_object(gpointer obj)
  99 {
 100         p_tm->workspace_remove_object((TMWorkObject *) obj, TRUE, FALSE);
 101 }
 102
 103 struct GeanyProject *
 104 geany_project_new()
 105 {
 106         struct GeanyProject *ret;
 107
 108         ret = (struct GeanyProject *) g_new0(struct GeanyProject, 1);
 109         ret->tags = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, free_tag_object);
 110
 111         return ret;
 112 }
 113
 114 struct GeanyProject *
 115 geany_project_load(const gchar * path)
 116 {
 117         struct GeanyProject *ret;
 118         TMWorkObject *tm_obj = NULL;
 119         GKeyFile *config;
 120         gint i = 0;
 121         gchar *file;
 122         gchar *filename, *locale_filename;
 123         gchar *key;
 124         gchar *tmp;
 125
 126         debug("%s path=%s\n", __FUNCTION__, path);
 127
 128         if (!path)
 129                 return NULL;
 130
 131         config = g_key_file_new();
 132         if (!g_key_file_load_from_file(config, path, G_KEY_FILE_NONE, NULL))
 133         {
 134                 g_key_file_free(config);
 135                 return NULL;
 136         }
 137
 138
 139         ret = geany_project_new();
 140         geany_project_set_path(ret, path);
 141
 142         tmp = p_utils->get_setting_string(config, "project", "name", GEANY_STRING_UNTITLED);
 143         geany_project_set_name(ret, tmp);
 144         g_free(tmp);
 145
 146         tmp = p_utils->get_setting_string(config, "project", "description", "");
 147         geany_project_set_description(ret, tmp);
 148         g_free(tmp);
 149
 150         tmp = p_utils->get_setting_string(config, "project", "base_path", "");
 151         geany_project_set_base_path(ret, tmp);
 152         g_free(tmp);
 153
 154         tmp = p_utils->get_setting_string(config, "project", "run_cmd", "");
 155         geany_project_set_run_cmd(ret, tmp);
 156         g_free(tmp);
 157
 158         geany_project_set_type_string(ret,
 159                                       p_utils->get_setting_string(config, "project", "type",
 160                                                                   project_type_string[0]));
 161         geany_project_set_regenerate(ret,
 162                                      g_key_file_get_boolean(config, "project", "regenerate", NULL));
 163
 164         if (ret->regenerate)
 165         {
 166                 geany_project_regenerate_file_list(ret);
 167         }
 168         else
 169         {
 170                 // Create tag files
 171                 key = g_strdup_printf("file%d", i);
 172                 while ((file = g_key_file_get_string(config, "files", key, NULL)))
 173                 {
 174                         filename = get_full_path(path, file);
 175
 176                         locale_filename = p_utils->get_locale_from_utf8(filename);
 177                         tm_obj = p_tm->source_file_new(locale_filename, FALSE,
 178                                                        geany_data->filetype->
 179                                                        detect_from_filename(filename)->name);
 180                         g_free(locale_filename);
 181                         if (tm_obj)
 182                         {
 183                                 g_hash_table_insert(ret->tags, filename, tm_obj);
 184                                 p_tm->source_file_update(tm_obj, TRUE, FALSE, TRUE);
 185                         }
 186                         else
 187                                 g_free(filename);
 188                         i++;
 189                         g_free(key);
 190                         g_free(file);
 191                         key = g_strdup_printf("file%d", i);
 192                 }
 193                 g_free(key);
 194         }
 195         g_key_file_free(config);
 196         return ret;
 197 }
 198
 199 void
 200 geany_project_regenerate_file_list(struct GeanyProject *prj)
 201 {
 202         GSList *lst;
 203
 204         debug("%s path=%s\n", __FUNCTION__, prj->base_path);
 205         g_hash_table_remove_all(prj->tags);
 206
 207         lst = get_file_list(prj->base_path, NULL, project_type_filter[prj->type], NULL);
 208         geany_project_set_tags_from_list(prj, lst);
 209
 210         g_slist_foreach(lst, (GFunc) g_free, NULL);
 211         g_slist_free(lst);
 212 }
 213
 214 void
 215 geany_project_set_path(struct GeanyProject *prj, const gchar * path)
 216 {
 217         gchar *norm_path = normpath(path);
 218         if (prj->path)
 219         {
 220                 if (strcmp(prj->path, norm_path) == 0)
 221                 {
 222                         g_free(norm_path);
 223                         return;
 224                 }
 225         }
 226         prj->path = norm_path;
 227 }
 228
 229 void
 230 geany_project_set_name(struct GeanyProject *prj, const gchar * name)
 231 {
 232         if (prj->name)
 233                 g_free(prj->name);
 234         prj->name = g_strdup(name);
 235
 236         if (prj == g_current_project)
 237         {
 238                 if (project)
 239                 {
 240                         if (project->name)
 241                                 g_free(project->name);
 242                         project->name = g_strdup(name);
 243                 }
 244         }
 245 }
 246
 247 void
 248 geany_project_set_type_int(struct GeanyProject *prj, gint val)
 249 {
 250         prj->type = val;
 251 }
 252
 253 void
 254 geany_project_set_type_string(struct GeanyProject *prj, const gchar * val)
 255 {
 256         guint i;
 257
 258         for (i = 0; i < sizeof(project_type_string) / sizeof(project_type_string[0]); i++)
 259         {
 260                 if (strcmp(val, project_type_string[i]) == 0)
 261                         return geany_project_set_type_int(prj, i);
 262         }
 263 }
 264
 265 void
 266 geany_project_set_regenerate(struct GeanyProject *prj, gboolean val)
 267 {
 268         prj->regenerate = val;
 269 }
 270
 271 void
 272 geany_project_set_description(struct GeanyProject *prj, const gchar * description)
 273 {
 274         if (prj->description)
 275                 g_free(prj->description);
 276         prj->description = g_strdup(description);
 277
 278         if (prj == g_current_project)
 279         {
 280                 if (project)
 281                 {
 282                         if (project->description)
 283                                 g_free(project->description);
 284                         project->description = g_strdup(description);
 285                 }
 286         }
 287 }
 288
 289 void
 290 geany_project_set_base_path(struct GeanyProject *prj, const gchar * base_path)
 291 {
 292         if (prj->base_path)
 293                 g_free(prj->base_path);
 294
 295         if (g_path_is_absolute(base_path))
 296         {
 297                 prj->base_path = g_strdup(base_path);
 298         }
 299         else
 300         {
 301                 prj->base_path = get_full_path(prj->path, base_path);
 302         }
 303
 304         if (prj == g_current_project)
 305         {
 306                 if (project)
 307                 {
 308                         if (project->base_path)
 309                                 g_free(project->base_path);
 310                         project->base_path = g_strdup(base_path);
 311                 }
 312         }
 313 }
 314
 315 void
 316 geany_project_set_run_cmd(struct GeanyProject *prj, const gchar * run_cmd)
 317 {
 318         if (prj->run_cmd)
 319                 g_free(prj->run_cmd);
 320         prj->run_cmd = g_strdup(run_cmd);
 321
 322         if (prj == g_current_project)
 323         {
 324                 if (project)
 325                 {
 326                         if (project->run_cmd)
 327                                 g_free(project->run_cmd);
 328                         project->run_cmd = g_strdup(run_cmd);
 329                 }
 330         }
 331 }
 332
 333
 334 // list in utf8
 335 void
 336 geany_project_set_tags_from_list(struct GeanyProject *prj, GSList * files)
 337 {
 338         GSList *tmp;
 339         gchar *locale_filename;
 340         TMWorkObject *tm_obj = NULL;
 341
 342         if (prj->tags)
 343                 g_hash_table_destroy(prj->tags);
 344         prj->tags = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, free_tag_object);
 345
 346         for (tmp = files; tmp != NULL; tmp = g_slist_next(tmp))
 347         {
 348                 locale_filename = p_utils->get_locale_from_utf8(tmp->data);
 349                 tm_obj = p_tm->source_file_new(locale_filename, FALSE,
 350                                                geany_data->filetype->
 351                                                detect_from_filename(tmp->data)->name);
 352                 g_free(locale_filename);
 353                 if (tm_obj)
 354                 {
 355                         g_hash_table_insert(prj->tags, g_strdup(tmp->data), tm_obj);
 356                         p_tm->source_file_update(tm_obj, TRUE, FALSE, TRUE);
 357                 }
 358         }
 359 }
 360
 361
 362 void
 363 geany_project_free(struct GeanyProject *prj)
 364 {
 365         debug("%s prj=%p\n", __FUNCTION__, prj);
 366         g_return_if_fail(prj);
 367
 368         if (prj->path)
 369                 g_free(prj->path);
 370         if (prj->name)
 371                 g_free(prj->name);
 372         if (prj->description)
 373                 g_free(prj->description);
 374         if (prj->base_path)
 375                 g_free(prj->base_path);
 376         if (prj->run_cmd)
 377                 g_free(prj->run_cmd);
 378         if (prj->tags)
 379                 g_hash_table_destroy(prj->tags);
 380
 381         g_free(prj);
 382 }
 383
 384 gboolean
 385 geany_project_add_file(struct GeanyProject *prj, const gchar * path)
 386 {
 387         gchar *filename;
 388         TMWorkObject *tm_obj = NULL;
 389
 390         GKeyFile *config;
 391
 392         config = g_key_file_new();
 393         if (!g_key_file_load_from_file(config, prj->path, G_KEY_FILE_NONE, NULL))
 394         {
 395                 g_key_file_free(config);
 396                 return FALSE;
 397         }
 398
 399         if (g_hash_table_lookup(prj->tags, path))
 400         {
 401                 g_key_file_free(config);
 402                 return TRUE;
 403         }
 404
 405         filename = p_utils->get_locale_from_utf8(path);
 406         tm_obj = p_tm->source_file_new(filename, FALSE,
 407                                        geany_data->filetype->detect_from_filename(path)->name);
 408         g_free(filename);
 409         if (tm_obj)
 410         {
 411                 g_hash_table_insert(prj->tags, g_strdup(path), tm_obj);
 412                 p_tm->source_file_update(tm_obj, TRUE, FALSE, TRUE);
 413         }
 414         geany_project_save(prj);
 415         return TRUE;
 416 }
 417
 418 struct CFGData
 419 {
 420         struct GeanyProject *prj;
 421         GKeyFile *config;
 422         int i;
 423 };
 424
 425 static void
 426 geany_project_save_files(gpointer key, UNUSED(gpointer value), gpointer user_data)
 427 {
 428         gchar *fkey;
 429         gchar *filename;
 430         struct CFGData *data = (struct CFGData *) user_data;
 431
 432         filename = get_relative_path(data->prj->path, (const gchar *) key);
 433         if (filename)
 434         {
 435                 fkey = g_strdup_printf("file%d", data->i);
 436                 g_key_file_set_string(data->config, "files", fkey, filename);
 437                 data->i++;
 438                 g_free(fkey);
 439                 g_free(filename);
 440         }
 441 }
 442
 443 gboolean
 444 geany_project_remove_file(struct GeanyProject *prj, const gchar * path)
 445 {
 446         if (!g_hash_table_remove(prj->tags, path))
 447         {
 448                 return FALSE;
 449         }
 450
 451         geany_project_save(prj);
 452         return TRUE;
 453 }
 454
 455 void
 456 geany_project_save(struct GeanyProject *prj)
 457 {
 458         GKeyFile *config;
 459         struct CFGData data;
 460         gchar *base_path;
 461
 462         base_path = get_relative_path(prj->path, prj->base_path);
 463
 464         config = g_key_file_new();
 465         g_key_file_load_from_file(config, prj->path, G_KEY_FILE_NONE, NULL);
 466
 467         g_key_file_set_string(config, "project", "name", prj->name);
 468         g_key_file_set_string(config, "project", "description", prj->description);
 469         g_key_file_set_string(config, "project", "base_path", base_path);
 470         g_key_file_set_string(config, "project", "run_cmd", prj->run_cmd);
 471         g_key_file_set_boolean(config, "project", "regenerate", prj->regenerate);
 472         g_key_file_set_string(config, "project", "type", project_type_string[prj->type]);
 473
 474         data.prj = prj;
 475         data.config = config;
 476         data.i = 0;
 477
 478         g_key_file_remove_group(config, "files", NULL);
 479         if (!prj->regenerate)
 480         {
 481                 g_hash_table_foreach(prj->tags, geany_project_save_files, &data);
 482         }
 483         save_config(config, prj->path);
 484         g_free(base_path);
 485 }