?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2008-06-16 Abderrahim Kitouni <a.kitouni@gmail.com>
[anjuta-git-plugin.git] / plugins / project-manager / plugin.c
blob8692b6be8a594d17d4dbd70ba6f565d0151394e3
1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
2 /*
3 plugin.c
4 Copyright (C) 2000 Naba Kumar
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 #include <config.h>
22 #include <libgnomevfs/gnome-vfs-utils.h>
23 #include <libgnomevfs/gnome-vfs-ops.h>
24 #include <libanjuta/interfaces/ianjuta-file.h>
25 #include <libanjuta/interfaces/ianjuta-file-savable.h>
26 #include <libanjuta/interfaces/ianjuta-file-loader.h>
27 #include <libanjuta/interfaces/ianjuta-project-manager.h>
28 #include <libanjuta/interfaces/ianjuta-document-manager.h>
29 #include <libanjuta/interfaces/ianjuta-file-manager.h>
30 #include <libanjuta/anjuta-profile-manager.h>
31 #include <libanjuta/anjuta-debug.h>
32 #include <libanjuta/anjuta-status.h>
33
34 #include <gbf/gbf-project-util.h>
35 #include <gbf/gbf-backend.h>
36
37 #include "plugin.h"
38
39 #define UI_FILE PACKAGE_DATA_DIR"/ui/anjuta-project-manager.ui"
40 #define PREFS_GLADE PACKAGE_DATA_DIR"/glade/anjuta-project-manager-plugin.glade"
41 #define ICON_FILE "anjuta-project-manager-plugin-48.png"
42 #define DEFAULT_PROFILE "file://"PACKAGE_DATA_DIR"/profiles/default.profile"
43 #define PROJECT_PROFILE_NAME "project"
44
45 static gpointer parent_class;
46
47 static gboolean uri_is_inside_project (ProjectManagerPlugin *plugin,
48 const gchar *uri);
49 static void project_manager_plugin_close (ProjectManagerPlugin *plugin);
50
51 static GtkWindow*
52 get_plugin_parent_window (ProjectManagerPlugin *plugin)
53 {
54 GtkWindow *win;
55 GtkWidget *toplevel;
56
57 toplevel = gtk_widget_get_toplevel (plugin->scrolledwindow);
58 if (toplevel && GTK_IS_WINDOW (toplevel))
59 win = GTK_WINDOW (toplevel);
60 else
61 win = GTK_WINDOW (ANJUTA_PLUGIN (plugin)->shell);
62 return win;
63 }
64
65 static void
66 update_title (ProjectManagerPlugin* plugin, const gchar *project_uri)
67 {
68 AnjutaStatus *status;
69 status = anjuta_shell_get_status (ANJUTA_PLUGIN (plugin)->shell, NULL);
70 if (project_uri)
71 {
72 gchar* uri_basename;
73 gchar* unescape_basename;
74 gchar* ext;
75
76 uri_basename = g_path_get_basename (project_uri);
77 unescape_basename = gnome_vfs_unescape_string (uri_basename, "");
78 ext = strrchr (unescape_basename, '.');
79 if (ext)
80 *ext = '\0';
81 anjuta_status_set_title (status, unescape_basename);
82 g_free (unescape_basename);
83 g_free (uri_basename);
84 }
85 else
86 {
87 anjuta_status_set_title (status, NULL);
88 }
89 }
90
91 static gchar*
92 get_session_dir (ProjectManagerPlugin *plugin)
93 {
94 GnomeVFSURI *vfs_uri;
95 gchar *session_dir = NULL;
96
97 g_return_val_if_fail (plugin->project_root_uri, NULL);
98
99 vfs_uri = gnome_vfs_uri_new (plugin->project_root_uri);
100 if (vfs_uri && gnome_vfs_uri_is_local (vfs_uri))
101 {
102 gchar *local_dir;
103
104 local_dir = gnome_vfs_get_local_path_from_uri (plugin->project_root_uri);
105 if (local_dir)
106 {
107 session_dir = g_build_filename (local_dir, ".anjuta", "session",
108 NULL);
109 }
110 g_free (local_dir);
111 }
112 if (vfs_uri)
113 gnome_vfs_uri_unref (vfs_uri);
114
115 return session_dir;
116 }
117
118 static void
119 project_manager_save_session (ProjectManagerPlugin *plugin)
120 {
121 gchar *session_dir;
122 session_dir = get_session_dir (plugin);
123 g_return_if_fail (session_dir != NULL);
124
125 plugin->session_by_me = TRUE;
126 anjuta_shell_session_save (ANJUTA_PLUGIN (plugin)->shell,
127 session_dir, NULL);
128 plugin->session_by_me = FALSE;
129 g_free (session_dir);
130 }
131
132 static void
133 on_session_save (AnjutaShell *shell, AnjutaSessionPhase phase,
134 AnjutaSession *session, ProjectManagerPlugin *plugin)
135 {
136 GList *files;
137
138 if (phase != ANJUTA_SESSION_PHASE_NORMAL)
139 return;
140
141 /*
142 * When a project session is being saved (session_by_me == TRUE),
143 * we should not save the current project uri, because project
144 * sessions are loaded when the project has already been loaded.
145 */
146 if (plugin->project_uri && !plugin->session_by_me)
147 {
148 files = anjuta_session_get_string_list (session,
149 "File Loader",
150 "Files");
151 files = g_list_append (files, g_strdup (plugin->project_uri));
152 anjuta_session_set_string_list (session, "File Loader",
153 "Files", files);
154 g_list_foreach (files, (GFunc)g_free, NULL);
155 g_list_free (files);
156 }
157 }
158
159 static void
160 on_shell_exiting (AnjutaShell *shell, ProjectManagerPlugin *plugin)
161 {
162 if (plugin->project_uri)
163 {
164 /* Also make sure we save the project session also */
165 project_manager_save_session (plugin);
166 }
167 }
168
169 static gboolean
170 on_close_project_idle (gpointer plugin)
171 {
172 project_manager_plugin_close (ANJUTA_PLUGIN_PROJECT_MANAGER (plugin));
173 ANJUTA_PLUGIN_PROJECT_MANAGER(plugin)->close_project_idle = -1;
174
175 return FALSE;
176 }
177
178 static void
179 on_close_project (GtkAction *action, ProjectManagerPlugin *plugin)
180 {
181 if (plugin->project_uri)
182 plugin->close_project_idle = g_idle_add (on_close_project_idle, plugin);
183 }
184
185 static GList *
186 find_missing_uris (GList *pre, GList *post)
187 {
188 GHashTable *hash;
189 GList *ret = NULL;
190 GList *node;
191
192 hash = g_hash_table_new (g_str_hash, g_str_equal);
193 node = pre;
194 while (node)
195 {
196 g_hash_table_insert (hash, node->data, node->data);
197 node = g_list_next (node);
198 }
199
200 node = post;
201 while (node)
202 {
203 if (g_hash_table_lookup (hash, node->data) == NULL)
204 ret = g_list_prepend (ret, node->data);
205 node = g_list_next (node);
206 }
207 g_hash_table_destroy (hash);
208 return g_list_reverse (ret);
209 }
210
211 static void
212 update_operation_emit_signals (ProjectManagerPlugin *plugin, GList *pre,
213 GList *post)
214 {
215 GList *missing_uris, *node;
216
217 missing_uris = find_missing_uris (pre, post);
218 node = missing_uris;
219 while (node)
220 {
221 DEBUG_PRINT ("URI added emitting: %s", (char*)node->data);
222 g_signal_emit_by_name (G_OBJECT (plugin), "element_added",
223 node->data);
224 node = g_list_next (node);
225 }
226 g_list_free (missing_uris);
227
228 missing_uris = find_missing_uris (post, pre);
229 node = missing_uris;
230 while (node)
231 {
232 DEBUG_PRINT ("URI removed emitting: %s", (char*)node->data);
233 g_signal_emit_by_name (G_OBJECT (plugin), "element_removed",
234 node->data);
235 node = g_list_next (node);
236 }
237 g_list_free (missing_uris);
238 }
239
240 static void
241 update_operation_end (ProjectManagerPlugin *plugin, gboolean emit_signal)
242 {
243 if (emit_signal)
244 {
245 if (plugin->pre_update_sources)
246 {
247 GList *post_update_sources =
248 ianjuta_project_manager_get_elements (IANJUTA_PROJECT_MANAGER (plugin),
249 IANJUTA_PROJECT_MANAGER_SOURCE,
250 NULL);
251 update_operation_emit_signals (plugin, plugin->pre_update_sources,
252 post_update_sources);
253 if (post_update_sources)
254 {
255 g_list_foreach (post_update_sources, (GFunc)g_free, NULL);
256 g_list_free (post_update_sources);
257 }
258 }
259 if (plugin->pre_update_targets)
260 {
261 GList *post_update_targets =
262 ianjuta_project_manager_get_elements (IANJUTA_PROJECT_MANAGER (plugin),
263 IANJUTA_PROJECT_MANAGER_TARGET,
264 NULL);
265 update_operation_emit_signals (plugin, plugin->pre_update_targets,
266 post_update_targets);
267 if (post_update_targets)
268 {
269 g_list_foreach (post_update_targets, (GFunc)g_free, NULL);
270 g_list_free (post_update_targets);
271 }
272 }
273 if (plugin->pre_update_groups)
274 {
275 GList *post_update_groups =
276 ianjuta_project_manager_get_elements (IANJUTA_PROJECT_MANAGER (plugin),
277 IANJUTA_PROJECT_MANAGER_GROUP,
278 NULL);
279 update_operation_emit_signals (plugin, plugin->pre_update_groups,
280 post_update_groups);
281 if (post_update_groups)
282 {
283 g_list_foreach (post_update_groups, (GFunc)g_free, NULL);
284 g_list_free (post_update_groups);
285 }
286 }
287 }
288 if (plugin->pre_update_sources)
289 {
290 g_list_foreach (plugin->pre_update_sources, (GFunc)g_free, NULL);
291 g_list_free (plugin->pre_update_sources);
292 plugin->pre_update_sources = NULL;
293 }
294 if (plugin->pre_update_targets)
295 {
296 g_list_foreach (plugin->pre_update_targets, (GFunc)g_free, NULL);
297 g_list_free (plugin->pre_update_targets);
298 plugin->pre_update_targets = NULL;
299 }
300 if (plugin->pre_update_groups)
301 {
302 g_list_foreach (plugin->pre_update_groups, (GFunc)g_free, NULL);
303 g_list_free (plugin->pre_update_groups);
304 plugin->pre_update_groups = NULL;
305 }
306 }
307
308 static void
309 update_operation_begin (ProjectManagerPlugin *plugin)
310 {
311 update_operation_end (plugin, FALSE);
312 plugin->pre_update_sources =
313 ianjuta_project_manager_get_elements (IANJUTA_PROJECT_MANAGER (plugin),
314 IANJUTA_PROJECT_MANAGER_SOURCE,
315 NULL);
316 plugin->pre_update_targets =
317 ianjuta_project_manager_get_elements (IANJUTA_PROJECT_MANAGER (plugin),
318 IANJUTA_PROJECT_MANAGER_TARGET,
319 NULL);
320 plugin->pre_update_groups =
321 ianjuta_project_manager_get_elements (IANJUTA_PROJECT_MANAGER (plugin),
322 IANJUTA_PROJECT_MANAGER_GROUP,
323 NULL);
324 }
325
326 static gboolean
327 on_refresh_idle (gpointer user_data)
328 {
329 ProjectManagerPlugin *plugin;
330 AnjutaStatus *status;
331 GError *err = NULL;
332
333 plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (user_data);
334
335 status = anjuta_shell_get_status (ANJUTA_PLUGIN (plugin)->shell, NULL);
336 anjuta_status_push (status, "Refreshing symbol tree...");
337 anjuta_status_busy_push (status);
338
339 gbf_project_refresh (GBF_PROJECT (plugin->project), &err);
340 if (err)
341 {
342 anjuta_util_dialog_error (get_plugin_parent_window (plugin),
343 _("Failed to refresh project: %s"),
344 err->message);
345 g_error_free (err);
346 }
347 anjuta_status_busy_pop (status);
348 anjuta_status_pop (status);
349 return FALSE;
350 }
351
352 static void
353 on_refresh (GtkAction *action, ProjectManagerPlugin *plugin)
354 {
355 g_idle_add (on_refresh_idle, plugin);
356 }
357
358 static void
359 on_properties (GtkAction *action, ProjectManagerPlugin *plugin)
360 {
361 GtkWidget *win, *properties;
362
363 properties = gbf_project_configure (plugin->project, NULL);
364 if (properties)
365 {
366 win = gtk_dialog_new_with_buttons (_("Project properties"),
367 GTK_WINDOW (ANJUTA_PLUGIN(plugin)->shell),
368 GTK_DIALOG_DESTROY_WITH_PARENT,
369 GTK_STOCK_CLOSE, GTK_RESPONSE_CANCEL, NULL);
370 g_signal_connect_swapped (win, "response",
371 G_CALLBACK (gtk_widget_destroy), win);
372
373 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(win)->vbox),
374 properties);
375 gtk_window_set_default_size (GTK_WINDOW (win), 450, -1);
376 gtk_widget_show (win);
377 }
378 else
379 {
380 anjuta_util_dialog_info (GTK_WINDOW (ANJUTA_PLUGIN(plugin)->shell),
381 _("No properties available for this target"));
382 }
383 }
384
385 static void
386 on_add_group (GtkAction *action, ProjectManagerPlugin *plugin)
387 {
388 gchar *group_uri, *default_group_uri = NULL;
389 if (plugin->current_editor_uri)
390 default_group_uri = g_path_get_dirname (plugin->current_editor_uri);
391 else
392 default_group_uri = g_strdup ("");
393 group_uri =
394 ianjuta_project_manager_add_group (IANJUTA_PROJECT_MANAGER (plugin),
395 "", default_group_uri,
396 NULL);
397 g_free (group_uri);
398 g_free (default_group_uri);
399 }
400
401 static void
402 on_add_target (GtkAction *action, ProjectManagerPlugin *plugin)
403 {
404 gchar *target_uri, *default_group_uri = NULL;
405 if (plugin->current_editor_uri)
406 default_group_uri = g_path_get_dirname (plugin->current_editor_uri);
407 else
408 default_group_uri = g_strdup ("");
409 target_uri =
410 ianjuta_project_manager_add_target (IANJUTA_PROJECT_MANAGER (plugin),
411 "", default_group_uri,
412 NULL);
413 g_free (target_uri);
414 g_free (default_group_uri);
415 }
416
417 static void
418 on_add_source (GtkAction *action, ProjectManagerPlugin *plugin)
419 {
420 gchar *default_group_uri = NULL, *default_source_uri;
421 gchar* source_uri;
422
423 if (plugin->current_editor_uri)
424 {
425 default_group_uri = g_path_get_dirname (plugin->current_editor_uri);
426 default_source_uri = plugin->current_editor_uri;
427 }
428 else
429 {
430 default_group_uri = g_strdup ("");
431 default_source_uri = "";
432 }
433 source_uri =
434 ianjuta_project_manager_add_source (IANJUTA_PROJECT_MANAGER (plugin),
435 default_source_uri,
436 default_group_uri, NULL);
437 g_free (source_uri);
438 g_free (default_group_uri);
439 }
440
441 static void
442 on_popup_properties (GtkAction *action, ProjectManagerPlugin *plugin)
443 {
444 GbfTreeData *data;
445 const gchar *selected_target;
446 GtkWidget *properties, *win;
447
448 data = gbf_project_view_find_selected (GBF_PROJECT_VIEW (plugin->view),
449 GBF_TREE_NODE_TARGET);
450 selected_target = NULL;
451 if (data)
452 {
453 selected_target = data->id;
454 properties = gbf_project_configure_target (plugin->project,
455 selected_target, NULL);
456 if (properties)
457 {
458 win = gtk_dialog_new_with_buttons (_("Target properties"),
459 GTK_WINDOW (ANJUTA_PLUGIN(plugin)->shell),
460 GTK_DIALOG_DESTROY_WITH_PARENT,
461 GTK_STOCK_CLOSE, GTK_RESPONSE_CANCEL, NULL);
462 g_signal_connect_swapped (win, "response",
463 G_CALLBACK (gtk_widget_destroy), win);
464
465 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(win)->vbox),
466 properties);
467 gtk_window_set_default_size (GTK_WINDOW (win), 450, -1);
468 gtk_widget_show (win);
469 }
470 else
471 {
472 anjuta_util_dialog_info (GTK_WINDOW (ANJUTA_PLUGIN(plugin)->shell),
473 _("No properties available for this target"));
474 }
475 return;
476 }
477 data = gbf_project_view_find_selected (GBF_PROJECT_VIEW (plugin->view),
478 GBF_TREE_NODE_GROUP);
479 selected_target = NULL;
480 if (data)
481 {
482 selected_target = data->id;
483 properties = gbf_project_configure_group (plugin->project,
484 selected_target, NULL);
485 if (properties)
486 {
487 win = gtk_dialog_new_with_buttons (_("Group properties"),
488 GTK_WINDOW (ANJUTA_PLUGIN(plugin)->shell),
489 GTK_DIALOG_DESTROY_WITH_PARENT,
490 _("Close"), GTK_RESPONSE_CANCEL, NULL);
491 g_signal_connect_swapped (win, "response",
492 G_CALLBACK (gtk_widget_destroy), win);
493
494 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(win)->vbox),
495 properties);
496 gtk_window_set_default_size (GTK_WINDOW (win), 450, -1);
497 gtk_widget_show (win);
498 }
499 else
500 {
501 anjuta_util_dialog_info (GTK_WINDOW (ANJUTA_PLUGIN(plugin)->shell),
502 _("No properties available for this group"));
503 }
504 return;
505 }
506 /* FIXME: */
507 }
508
509 static void
510 on_popup_add_group (GtkAction *action, ProjectManagerPlugin *plugin)
511 {
512 GbfTreeData *data;
513 const gchar *selected_group;
514 gchar *group_id;
515
516 update_operation_begin (plugin);
517 data = gbf_project_view_find_selected (GBF_PROJECT_VIEW (plugin->view),
518 GBF_TREE_NODE_GROUP);
519 selected_group = NULL;
520 if (data)
521 selected_group = data->id;
522 group_id = gbf_project_util_new_group (plugin->model,
523 get_plugin_parent_window (plugin),
524 selected_group, NULL);
525 if (data)
526 gbf_tree_data_free (data);
527 update_operation_end (plugin, TRUE);
528 g_free (group_id);
529 }
530
531 static void
532 on_popup_add_target (GtkAction *action, ProjectManagerPlugin *plugin)
533 {
534 GbfTreeData *data;
535 const gchar *selected_group;
536 gchar *target_id;
537
538 update_operation_begin (plugin);
539 data = gbf_project_view_find_selected (GBF_PROJECT_VIEW (plugin->view),
540 GBF_TREE_NODE_GROUP);
541 selected_group = NULL;
542 if (data)
543 selected_group = data->id;
544 target_id = gbf_project_util_new_target (plugin->model,
545 get_plugin_parent_window (plugin),
546 selected_group, NULL);
547 if (data)
548 gbf_tree_data_free (data);
549 update_operation_end (plugin, TRUE);
550 g_free (target_id);
551 }
552
553 static void
554 on_popup_add_source (GtkAction *action, ProjectManagerPlugin *plugin)
555 {
556 GbfTreeData *data;
557 const gchar *selected_target;
558 gchar *source_id;
559
560 update_operation_begin (plugin);
561 data = gbf_project_view_find_selected (GBF_PROJECT_VIEW (plugin->view),
562 GBF_TREE_NODE_TARGET);
563 selected_target = NULL;
564 if (data)
565 selected_target = data->id;
566 source_id = gbf_project_util_add_source (plugin->model,
567 get_plugin_parent_window (plugin),
568 selected_target, NULL, NULL);
569 if (data)
570 gbf_tree_data_free (data);
571 update_operation_end (plugin, TRUE);
572 g_free (source_id);
573 }
574
575 static gboolean
576 confirm_removal (ProjectManagerPlugin *plugin, GbfTreeData *data)
577 {
578 gboolean answer;
579 gchar *mesg;
580 gchar* question;
581 gchar* full_mesg;
582
583 switch (data->type)
584 {
585 case GBF_TREE_NODE_GROUP:
586 question = _("Are you sure you want to remove the following group from project?\n\n");
587 mesg = _("Group: %s\n\nThe group will not be deleted from file system.");
588 break;
589 case GBF_TREE_NODE_TARGET:
590 question = _("Are you sure you want to remove the following target from project?\n\n");
591 mesg = _("Target: %s");
592 break;
593 case GBF_TREE_NODE_TARGET_SOURCE:
594 question = _("Are you sure you want to remove the following source file from project?\n\n");
595 mesg = _("Source: %s\n\nThe source file will not be deleted from file system.");
596 break;
597 default:
598 g_warning ("Unknown node");
599 return FALSE;
600 }
601 full_mesg = g_strconcat (question, mesg, NULL);
602 answer =
603 anjuta_util_dialog_boolean_question (get_plugin_parent_window (plugin),
604 full_mesg, data->name);
605 g_free (full_mesg);
606 return answer;
607 }
608
609 static void
610 on_popup_remove (GtkAction *action, ProjectManagerPlugin *plugin)
611 {
612 GbfTreeData *data;
613
614 data = gbf_project_view_find_selected (GBF_PROJECT_VIEW (plugin->view),
615 GBF_TREE_NODE_TARGET_SOURCE);
616 if (data == NULL)
617 {
618 data = gbf_project_view_find_selected (GBF_PROJECT_VIEW (plugin->view),
619 GBF_TREE_NODE_TARGET);
620 }
621 if (data == NULL)
622 {
623 data = gbf_project_view_find_selected (GBF_PROJECT_VIEW (plugin->view),
624 GBF_TREE_NODE_GROUP);
625 }
626 if (data)
627 {
628 if (confirm_removal (plugin, data))
629 {
630 GError *err = NULL;
631 update_operation_begin (plugin);
632 switch (data->type)
633 {
634 case GBF_TREE_NODE_GROUP:
635 gbf_project_remove_group (plugin->project, data->id, &err);
636 break;
637 case GBF_TREE_NODE_TARGET:
638 gbf_project_remove_target (plugin->project, data->id, &err);
639 break;
640 case GBF_TREE_NODE_TARGET_SOURCE:
641 gbf_project_remove_source (plugin->project, data->id, &err);
642 break;
643 default:
644 g_warning ("Should not reach here!!!");
645 }
646 update_operation_end (plugin, TRUE);
647 if (err)
648 {
649 anjuta_util_dialog_error (get_plugin_parent_window (plugin),
650 _("Failed to remove '%s':\n%s"),
651 data->name, err->message);
652 g_error_free (err);
653 }
654 }
655 gbf_tree_data_free (data);
656 }
657 }
658
659 static void
660 on_popup_add_to_project (GtkAction *action, ProjectManagerPlugin *plugin)
661 {
662 GtkWindow *win;
663 GnomeVFSFileInfo info;
664 GnomeVFSResult res;
665 gchar *parent_directory, *filename;
666
667 win = get_plugin_parent_window (plugin);
668 res = gnome_vfs_get_file_info (plugin->fm_current_uri, &info,
669 GNOME_VFS_FILE_INFO_DEFAULT |
670 GNOME_VFS_FILE_INFO_FOLLOW_LINKS);
671 if (res == GNOME_VFS_OK)
672 {
673 parent_directory = g_path_get_dirname (plugin->fm_current_uri);
674 if (!parent_directory)
675 parent_directory = g_strdup ("");
676
677 filename = g_path_get_basename (plugin->fm_current_uri);
678 if (info.type == GNOME_VFS_FILE_TYPE_DIRECTORY)
679 {
680 gchar *group_id =
681 ianjuta_project_manager_add_group (IANJUTA_PROJECT_MANAGER (plugin),
682 filename, parent_directory,
683 NULL);
684 g_free (group_id);
685 }
686 else
687 {
688 gchar *source_id =
689 ianjuta_project_manager_add_source (IANJUTA_PROJECT_MANAGER
690 (plugin),
691 plugin->fm_current_uri,
692 parent_directory,
693 NULL);
694 g_free(source_id);
695 }
696 g_free (filename);
697 g_free (parent_directory);
698 }
699 else
700 {
701 const gchar *mesg;
702
703 if (res != GNOME_VFS_OK)
704 mesg = gnome_vfs_result_to_string (res);
705 else
706 mesg = _("The file you selected is a link and can't be added to the project");
707 anjuta_util_dialog_error (win,
708 _("Failed to retrieve URI info of %s: %s"),
709 plugin->fm_current_uri, mesg);
710 }
711 }
712
713 static void
714 on_uri_activated (GtkWidget *widget, const gchar *uri,
715 ProjectManagerPlugin *plugin)
716 {
717 IAnjutaFileLoader *loader;
718 GFile* file = g_file_new_for_uri (uri);
719
720 loader = anjuta_shell_get_interface (ANJUTA_PLUGIN (plugin)->shell,
721 IAnjutaFileLoader, NULL);
722 if (loader)
723 ianjuta_file_loader_load (loader, file, FALSE, NULL);
724 g_object_unref (file);
725 }
726
727 static void
728 on_target_activated (GtkWidget *widget, const gchar *target_id,
729 ProjectManagerPlugin *plugin)
730 {
731 on_popup_properties (NULL, plugin);
732 }
733
734 static void
735 on_group_activated (GtkWidget *widget, const gchar *group_id,
736 ProjectManagerPlugin *plugin)
737 {
738 on_popup_properties (NULL, plugin);
739 }
740
741 static GtkActionEntry pm_actions[] =
742 {
743 {
744 "ActionMenuProject", NULL,
745 N_("_Project"), NULL, NULL, NULL
746 },
747 {
748 "ActionProjectProperties", GTK_STOCK_PROPERTIES,
749 N_("_Properties"), NULL, N_("Project properties"),
750 G_CALLBACK (on_properties)
751 },
752 {
753 "ActionProjectRefresh", GTK_STOCK_REFRESH,
754 N_("_Refresh"), NULL, N_("Refresh project manager tree"),
755 G_CALLBACK (on_refresh)
756 },
757 {
758 "ActionProjectAddGroup", GTK_STOCK_ADD,
759 N_("Add _Group..."), NULL, N_("Add a group to project"),
760 G_CALLBACK (on_add_group)
761 },
762 {
763 "ActionProjectAddTarget", GTK_STOCK_ADD,
764 N_("Add _Target..."), NULL, N_("Add a target to project"),
765 G_CALLBACK (on_add_target)
766 },
767 {
768 "ActionProjectAddSource", GTK_STOCK_ADD,
769 N_("Add _Source File..."), NULL, N_("Add a source file to project"),
770 G_CALLBACK (on_add_source)
771 },
772 {
773 "ActionFileCloseProject", NULL,
774 N_("Close Pro_ject"), NULL, N_("Close project"),
775 G_CALLBACK (on_close_project)
776 },
777 };
778
779 static GtkActionEntry popup_actions[] =
780 {
781 {
782 "ActionPopupProjectProperties", GTK_STOCK_PROPERTIES,
783 N_("_Properties"), NULL, N_("Properties of group/target/source"),
784 G_CALLBACK (on_popup_properties)
785 },
786 {
787 "ActionPopupProjectAddToProject", GTK_STOCK_ADD,
788 N_("_Add To Project"), NULL, N_("Add a source file to project"),
789 G_CALLBACK (on_popup_add_to_project)
790 },
791 {
792 "ActionPopupProjectAddGroup", GTK_STOCK_ADD,
793 N_("Add _Group"), NULL, N_("Add a group to project"),
794 G_CALLBACK (on_popup_add_group)
795 },
796 {
797 "ActionPopupProjectAddTarget", GTK_STOCK_ADD,
798 N_("Add _Target"), NULL, N_("Add a target to project"),
799 G_CALLBACK (on_popup_add_target)
800 },
801 {
802 "ActionPopupProjectAddSource", GTK_STOCK_ADD,
803 N_("Add _Source File"), NULL, N_("Add a source file to project"),
804 G_CALLBACK (on_popup_add_source)
805 },
806 {
807 "ActionPopupProjectRemove", GTK_STOCK_REMOVE,
808 N_("Re_move"), NULL, N_("Remove from project"),
809 G_CALLBACK (on_popup_remove)
810 }
811 };
812
813 static void
814 update_ui (ProjectManagerPlugin *plugin)
815 {
816 AnjutaUI *ui;
817 gint j;
818 GtkAction *action;
819 GbfProjectCapabilities caps = GBF_PROJECT_CAN_ADD_NONE;
820
821 if (plugin->project)
822 caps = gbf_project_get_capabilities (plugin->project, NULL);
823
824 ui = anjuta_shell_get_ui (ANJUTA_PLUGIN (plugin)->shell, NULL);
825 for (j = 0; j < G_N_ELEMENTS (pm_actions); j++)
826 {
827 action = anjuta_ui_get_action (ui, "ActionGroupProjectManager",
828 pm_actions[j].name);
829 if (pm_actions[j].callback &&
830 strcmp (pm_actions[j].name, "ActionFileCloseProject") != 0)
831 {
832 /* 'close' menuitem is never disabled */
833 g_object_set (G_OBJECT (action), "sensitive",
834 (plugin->project != NULL), NULL);
835 }
836 }
837
838 /* Main menu */
839 action = anjuta_ui_get_action (ui, "ActionGroupProjectManager",
840 "ActionProjectAddGroup");
841 g_object_set (G_OBJECT (action), "sensitive",
842 ((plugin->project != NULL) &&
843 (caps & GBF_PROJECT_CAN_ADD_GROUP)), NULL);
844
845 action = anjuta_ui_get_action (ui, "ActionGroupProjectManager",
846 "ActionProjectAddTarget");
847 g_object_set (G_OBJECT (action), "sensitive",
848 ((plugin->project != NULL) &&
849 (caps & GBF_PROJECT_CAN_ADD_TARGET)), NULL);
850
851 action = anjuta_ui_get_action (ui, "ActionGroupProjectManager",
852 "ActionProjectAddSource");
853 g_object_set (G_OBJECT (action), "sensitive",
854 ((plugin->project != NULL) &&
855 (caps & GBF_PROJECT_CAN_ADD_SOURCE)), NULL);
856
857 /* Popup menus */
858 for (j = 0; j < G_N_ELEMENTS (popup_actions); j++)
859 {
860 action = anjuta_ui_get_action (ui, "ActionGroupProjectManagerPopup",
861 popup_actions[j].name);
862 if (popup_actions[j].callback)
863 {
864 g_object_set (G_OBJECT (action), "sensitive",
865 (plugin->project != NULL), NULL);
866 }
867 }
868 }
869
870 static void
871 on_treeview_selection_changed (GtkTreeSelection *sel,
872 ProjectManagerPlugin *plugin)
873 {
874 AnjutaUI *ui;
875 GtkAction *action;
876 GbfTreeData *data;
877 gchar *selected_uri;
878 GbfProjectCapabilities caps = GBF_PROJECT_CAN_ADD_NONE;
879
880 ui = anjuta_shell_get_ui (ANJUTA_PLUGIN (plugin)->shell, NULL);
881 /* Popup menu */
882 action = anjuta_ui_get_action (ui, "ActionGroupProjectManagerPopup",
883 "ActionPopupProjectAddGroup");
884 g_object_set (G_OBJECT (action), "sensitive", FALSE, NULL);
885 action = anjuta_ui_get_action (ui, "ActionGroupProjectManagerPopup",
886 "ActionPopupProjectAddTarget");
887 g_object_set (G_OBJECT (action), "sensitive", FALSE, NULL);
888 action = anjuta_ui_get_action (ui, "ActionGroupProjectManagerPopup",
889 "ActionPopupProjectAddSource");
890 g_object_set (G_OBJECT (action), "sensitive", FALSE, NULL);
891 action = anjuta_ui_get_action (ui, "ActionGroupProjectManagerPopup",
892 "ActionPopupProjectRemove");
893 g_object_set (G_OBJECT (action), "sensitive", FALSE, NULL);
894
895 if (plugin->project)
896 caps = gbf_project_get_capabilities (plugin->project, NULL);
897 data = gbf_project_view_find_selected (GBF_PROJECT_VIEW (plugin->view),
898 GBF_TREE_NODE_TARGET_SOURCE);
899 if (data && data->type == GBF_TREE_NODE_TARGET_SOURCE)
900 {
901 if (caps & GBF_PROJECT_CAN_ADD_SOURCE)
902 {
903 action = anjuta_ui_get_action (ui, "ActionGroupProjectManagerPopup",
904 "ActionPopupProjectAddSource");
905 g_object_set (G_OBJECT (action), "sensitive", TRUE, NULL);
906 }
907 action = anjuta_ui_get_action (ui, "ActionGroupProjectManagerPopup",
908 "ActionPopupProjectRemove");
909 g_object_set (G_OBJECT (action), "sensitive", TRUE, NULL);
910 gbf_tree_data_free (data);
911 goto finally;
912 }
913
914 gbf_tree_data_free (data);
915 data = gbf_project_view_find_selected (GBF_PROJECT_VIEW (plugin->view),
916 GBF_TREE_NODE_TARGET);
917 if (data && data->type == GBF_TREE_NODE_TARGET)
918 {
919 if (caps & GBF_PROJECT_CAN_ADD_SOURCE)
920 {
921 action = anjuta_ui_get_action (ui, "ActionGroupProjectManagerPopup",
922 "ActionPopupProjectAddSource");
923 g_object_set (G_OBJECT (action), "sensitive", TRUE, NULL);
924 }
925 action = anjuta_ui_get_action (ui, "ActionGroupProjectManagerPopup",
926 "ActionPopupProjectRemove");
927 g_object_set (G_OBJECT (action), "sensitive", TRUE, NULL);
928 gbf_tree_data_free (data);
929 goto finally;
930 }
931
932 gbf_tree_data_free (data);
933 data = gbf_project_view_find_selected (GBF_PROJECT_VIEW (plugin->view),
934 GBF_TREE_NODE_GROUP);
935 if (data && data->type == GBF_TREE_NODE_GROUP)
936 {
937 if (caps & GBF_PROJECT_CAN_ADD_GROUP)
938 {
939 action = anjuta_ui_get_action (ui, "ActionGroupProjectManagerPopup",
940 "ActionPopupProjectAddGroup");
941 g_object_set (G_OBJECT (action), "sensitive", TRUE, NULL);
942 }
943 if (caps & GBF_PROJECT_CAN_ADD_TARGET)
944 {
945 action = anjuta_ui_get_action (ui, "ActionGroupProjectManagerPopup",
946 "ActionPopupProjectAddTarget");
947 g_object_set (G_OBJECT (action), "sensitive", TRUE, NULL);
948 }
949 action = anjuta_ui_get_action (ui, "ActionGroupProjectManagerPopup",
950 "ActionPopupProjectRemove");
951 g_object_set (G_OBJECT (action), "sensitive", TRUE, NULL);
952 gbf_tree_data_free (data);
953 goto finally;
954 }
955 finally:
956 selected_uri =
957 ianjuta_project_manager_get_selected (IANJUTA_PROJECT_MANAGER (plugin),
958 NULL);
959 if (selected_uri)
960 {
961 GValue *value;
962 value = g_new0 (GValue, 1);
963 g_value_init (value, G_TYPE_STRING);
964 g_value_set_string (value, selected_uri);
965 anjuta_shell_add_value (ANJUTA_PLUGIN(plugin)->shell,
966 IANJUTA_PROJECT_MANAGER_CURRENT_URI,
967 value, NULL);
968 g_signal_emit_by_name (G_OBJECT (plugin), "element_selected",
969 selected_uri);
970 g_free (selected_uri);
971 } else {
972 anjuta_shell_remove_value (ANJUTA_PLUGIN(plugin)->shell,
973 IANJUTA_PROJECT_MANAGER_CURRENT_URI, NULL);
974 }
975 }
976
977 static gboolean
978 on_treeview_event (GtkWidget *widget,
979 GdkEvent *event,
980 ProjectManagerPlugin *plugin)
981 {
982 AnjutaUI *ui;
983
984 ui = anjuta_shell_get_ui (ANJUTA_PLUGIN (plugin)->shell, NULL);
985 if (event->type == GDK_BUTTON_PRESS) {
986 GdkEventButton *e = (GdkEventButton *) event;
987 if (e->button == 3) {
988 GtkWidget *popup;
989 popup = gtk_ui_manager_get_widget (GTK_UI_MANAGER (ui),
990 "/PopupProjectManager");
991 g_return_val_if_fail (GTK_IS_WIDGET (popup), FALSE);
992 gtk_menu_popup (GTK_MENU (popup),
993 NULL, NULL, NULL, NULL,
994 ((GdkEventButton *) event)->button,
995 ((GdkEventButton *) event)->time);
996 return TRUE;
997 }
998 }
999 return FALSE;
1000 }
1001
1002 static void
1003 register_stock_icons (AnjutaPlugin *plugin)
1004 {
1005 static gboolean registered = FALSE;
1006
1007 if (registered)
1008 return;
1009 registered = TRUE;
1010
1011 /* Register stock icons */
1012 BEGIN_REGISTER_ICON(plugin);
1013 REGISTER_ICON (ICON_FILE,
1014 "project-manager-plugin-icon");
1015 END_REGISTER_ICON;
1016 }
1017
1018 static void
1019 value_added_fm_current_file (AnjutaPlugin *plugin, const char *name,
1020 const GValue *value, gpointer data)
1021 {
1022 AnjutaUI *ui;
1023 GtkAction *action;
1024 gchar *uri;
1025 ProjectManagerPlugin *pm_plugin;
1026
1027 GFile* file = g_value_get_object (value);
1028 uri = g_file_get_uri (file);
1029
1030 pm_plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (plugin);
1031 ui = anjuta_shell_get_ui (plugin->shell, NULL);
1032
1033 if (pm_plugin->fm_current_uri)
1034 g_free (pm_plugin->fm_current_uri);
1035 pm_plugin->fm_current_uri = g_strdup (uri);
1036
1037 action = anjuta_ui_get_action (ui, "ActionGroupProjectManagerPopup",
1038 "ActionPopupProjectAddToProject");
1039 g_object_set (G_OBJECT (action), "sensitive", TRUE, NULL);
1040 g_free (uri);
1041 }
1042
1043 static void
1044 value_removed_fm_current_file (AnjutaPlugin *plugin,
1045 const char *name, gpointer data)
1046 {
1047 AnjutaUI *ui;
1048 GtkAction *action;
1049 ProjectManagerPlugin *pm_plugin;
1050
1051 pm_plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (plugin);
1052
1053 if (pm_plugin->fm_current_uri)
1054 g_free (pm_plugin->fm_current_uri);
1055 pm_plugin->fm_current_uri = NULL;
1056
1057 ui = anjuta_shell_get_ui (plugin->shell, NULL);
1058 action = anjuta_ui_get_action (ui, "ActionGroupProjectManagerPopup",
1059 "ActionPopupProjectAddToProject");
1060 g_object_set (G_OBJECT (action), "sensitive", FALSE, NULL);
1061 }
1062
1063 static void
1064 value_added_current_editor (AnjutaPlugin *plugin, const char *name,
1065 const GValue *value, gpointer data)
1066 {
1067 GObject *editor;
1068 ProjectManagerPlugin *pm_plugin;
1069 GFile* file;
1070
1071 editor = g_value_get_object (value);
1072 if (!IANJUTA_IS_EDITOR(editor))
1073 return;
1074
1075 pm_plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (plugin);
1076
1077 if (pm_plugin->current_editor_uri)
1078 g_free (pm_plugin->current_editor_uri);
1079 file = ianjuta_file_get_file (IANJUTA_FILE (editor), NULL);
1080 if (file)
1081 {
1082 pm_plugin->current_editor_uri = g_file_get_uri (file);
1083 g_object_unref (file);
1084 }
1085 else
1086 pm_plugin->current_editor_uri = NULL;
1087
1088 }
1089
1090 static void
1091 value_removed_current_editor (AnjutaPlugin *plugin,
1092 const char *name, gpointer data)
1093 {
1094 ProjectManagerPlugin *pm_plugin;
1095
1096 pm_plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (plugin);
1097
1098 if (pm_plugin->current_editor_uri)
1099 g_free (pm_plugin->current_editor_uri);
1100 pm_plugin->current_editor_uri = NULL;
1101 }
1102
1103 static void
1104 project_manager_load_gbf (ProjectManagerPlugin *pm_plugin)
1105 {
1106 AnjutaStatus *status;
1107 gchar *dirname;
1108 const gchar *root_uri;
1109 GSList *l;
1110 GError *error = NULL;
1111 GbfBackend *backend = NULL;
1112
1113 root_uri = pm_plugin->project_root_uri;
1114
1115 dirname = gnome_vfs_get_local_path_from_uri (root_uri);
1116
1117 g_return_if_fail (dirname != NULL);
1118
1119 if (pm_plugin->project != NULL)
1120 g_object_unref (pm_plugin->project);
1121
1122 DEBUG_PRINT ("initializing gbf backend...\n");
1123 gbf_backend_init ();
1124 for (l = gbf_backend_get_backends (); l; l = l->next) {
1125 backend = l->data;
1126
1127 pm_plugin->project = gbf_backend_new_project (backend->id);
1128 if (pm_plugin->project)
1129 {
1130 if (gbf_project_probe (pm_plugin->project, dirname, NULL))
1131 {
1132 /* Backend found */
1133 break;
1134 }
1135 g_object_unref (pm_plugin->project);
1136 pm_plugin->project = NULL;
1137 }
1138 /*
1139 if (!strcmp (backend->id, "gbf-am:GbfAmProject"))
1140 break;
1141 */
1142 backend = NULL;
1143 }
1144
1145 if (!backend)
1146 {
1147 /* FIXME: Set err */
1148 g_warning ("no backend available for this project\n");
1149 g_free (dirname);
1150 return;
1151 }
1152
1153 DEBUG_PRINT ("Creating new gbf project\n");
1154
1155 /* pm_plugin->project = gbf_backend_new_project (backend->id); */
1156 if (!pm_plugin->project)
1157 {
1158 /* FIXME: Set err */
1159 g_warning ("project creation failed\n");
1160 g_free (dirname);
1161 return;
1162 }
1163
1164 status = anjuta_shell_get_status (ANJUTA_PLUGIN (pm_plugin)->shell, NULL);
1165 anjuta_status_progress_add_ticks (status, 1);
1166 anjuta_status_push (status, _("Loading project: %s"), g_basename (dirname));
1167 anjuta_status_busy_push (status);
1168
1169 DEBUG_PRINT ("loading project %s\n\n", dirname);
1170 /* FIXME: use the error parameter to determine if the project
1171 * was loaded successfully */
1172 gbf_project_load (pm_plugin->project, dirname, &error);
1173
1174 anjuta_status_progress_tick (status, NULL, _("Created project view..."));
1175
1176 if (error)
1177 {
1178 GtkWidget *toplevel;
1179 GtkWindow *win;
1180
1181 toplevel = gtk_widget_get_toplevel (pm_plugin->scrolledwindow);
1182 if (toplevel && GTK_IS_WINDOW (toplevel))
1183 win = GTK_WINDOW (toplevel);
1184 else
1185 win = GTK_WINDOW (ANJUTA_PLUGIN (pm_plugin)->shell);
1186
1187 anjuta_util_dialog_error (win, _("Failed to parse project (the project is opened, but there will be no project view) %s: %s\n"
1188 ""),
1189 dirname, error->message);
1190 /* g_propagate_error (err, error); */
1191 g_object_unref (pm_plugin->project);
1192 pm_plugin->project = NULL;
1193 g_free (dirname);
1194 /* gtk_widget_destroy (progress_win); */
1195 anjuta_status_pop (status);
1196 anjuta_status_busy_pop (status);
1197 return;
1198 }
1199 g_object_set (G_OBJECT (pm_plugin->model), "project",
1200 pm_plugin->project, NULL);
1201
1202 update_ui (pm_plugin);
1203 anjuta_shell_present_widget (ANJUTA_PLUGIN (pm_plugin)->shell,
1204 pm_plugin->scrolledwindow,
1205 NULL);
1206
1207 anjuta_status_set_default (status, _("Project"), g_basename (dirname));
1208 anjuta_status_pop (status);
1209 anjuta_status_busy_pop (status);
1210 g_free (dirname);
1211 }
1212
1213 static void
1214 project_manager_unload_gbf (ProjectManagerPlugin *pm_plugin)
1215 {
1216 AnjutaStatus *status;
1217
1218 if (pm_plugin->project)
1219 {
1220 IAnjutaDocumentManager *docman;
1221
1222 /* Close files that belong to this project (that are saved) */
1223 docman = anjuta_shell_get_interface (ANJUTA_PLUGIN (pm_plugin)->shell,
1224 IAnjutaDocumentManager, NULL);
1225 if (docman)
1226 {
1227 GList *to_remove = NULL;
1228 GList *editors;
1229 GList *node;
1230
1231 editors =
1232 ianjuta_document_manager_get_doc_widgets (docman, NULL);
1233 node = editors;
1234 while (node)
1235 {
1236 if (!IANJUTA_IS_EDITOR(node->data))
1237 {
1238 node = g_list_next(node);
1239 continue;
1240 }
1241 GFile* editor_file = ianjuta_file_get_file (IANJUTA_FILE (node->data), NULL);
1242 gchar *editor_uri = g_file_get_uri (editor_file);
1243 g_object_unref (editor_file);
1244
1245
1246 /* Only remove if it does not have unsaved data */
1247 if (editor_uri && (!IANJUTA_IS_FILE_SAVABLE (node->data) ||
1248 !ianjuta_file_savable_is_dirty
1249 (IANJUTA_FILE_SAVABLE (node->data),
1250 NULL)))
1251 {
1252 if (strncmp (editor_uri, pm_plugin->project_root_uri,
1253 strlen (pm_plugin->project_root_uri)) == 0 &&
1254 editor_uri[strlen (pm_plugin->project_root_uri)] == '/')
1255 {
1256 to_remove = g_list_prepend (to_remove, node->data);
1257 }
1258 }
1259 g_free (editor_uri);
1260 node = g_list_next (node);
1261 }
1262 node = to_remove;
1263 while (node)
1264 {
1265 ianjuta_document_manager_remove_document (docman,
1266 IANJUTA_DOCUMENT (node->data),
1267 FALSE,
1268 NULL);
1269 node = g_list_next (node);
1270 }
1271 if (editors)
1272 g_list_free (editors);
1273 if (to_remove)
1274 g_list_free (to_remove);
1275 }
1276
1277 /* Release project */
1278 g_object_unref (pm_plugin->project);
1279 pm_plugin->project = NULL;
1280 g_object_set (G_OBJECT (pm_plugin->model), "project", NULL, NULL);
1281 update_ui (pm_plugin);
1282 status = anjuta_shell_get_status (ANJUTA_PLUGIN (pm_plugin)->shell,
1283 NULL);
1284 anjuta_status_set_default (status, _("Project"), NULL);
1285 }
1286 }
1287
1288 static void
1289 on_profile_scoped (AnjutaProfileManager *profile_manager,
1290 AnjutaProfile *profile, ProjectManagerPlugin *plugin)
1291 {
1292 GValue *value;
1293 gchar *session_dir;
1294 DEBUG_PRINT ("Profile scoped: %s", anjuta_profile_get_name (profile));
1295 if (strcmp (anjuta_profile_get_name (profile), PROJECT_PROFILE_NAME) != 0)
1296 return;
1297
1298 DEBUG_PRINT ("Project profile loaded; Restoring project session");
1299
1300 /* Load gbf project */
1301 project_manager_load_gbf (plugin);
1302
1303 /* Export project */
1304 value = g_new0 (GValue, 1);
1305 g_value_init (value, G_TYPE_STRING);
1306 g_value_set_string (value, plugin->project_root_uri);
1307
1308 update_title (plugin, plugin->project_root_uri);
1309 anjuta_shell_add_value (ANJUTA_PLUGIN(plugin)->shell,
1310 "project_root_uri",
1311 value, NULL);
1312
1313 /* If profile scoped to "project", restore project session */
1314 session_dir = get_session_dir (plugin);
1315 g_return_if_fail (session_dir != NULL);
1316
1317 /*
1318 * If there is a session load already in progress (that is this
1319 * project is being opened in session restoration), our session
1320 * load would be ignored. Good thing.
1321 */
1322 plugin->session_by_me = TRUE;
1323 anjuta_shell_session_load (ANJUTA_PLUGIN (plugin)->shell,
1324 session_dir, NULL);
1325 plugin->session_by_me = FALSE;
1326 g_free (session_dir);
1327 }
1328
1329 static void
1330 on_profile_descoped (AnjutaProfileManager *profile_manager,
1331 AnjutaProfile *profile, ProjectManagerPlugin *plugin)
1332 {
1333 DEBUG_PRINT ("Profile descoped: %s", anjuta_profile_get_name (profile));
1334
1335 if (strcmp (anjuta_profile_get_name (profile), PROJECT_PROFILE_NAME) != 0)
1336 return;
1337
1338 DEBUG_PRINT ("Project profile descoped; Saving project session");
1339
1340 /* Save current project session */
1341 g_return_if_fail (plugin->project_root_uri != NULL);
1342
1343 /* Save project session */
1344 project_manager_save_session (plugin);
1345
1346 /* Close current project */
1347 project_manager_unload_gbf (plugin);
1348
1349 g_free (plugin->project_root_uri);
1350 g_free (plugin->project_uri);
1351 plugin->project_uri = NULL;
1352 plugin->project_root_uri = NULL;
1353
1354 update_title (ANJUTA_PLUGIN_PROJECT_MANAGER (plugin), NULL);
1355 anjuta_shell_remove_value (ANJUTA_PLUGIN (plugin)->shell,
1356 "project_root_uri", NULL);
1357 }
1358
1359 static void
1360 project_manager_plugin_close (ProjectManagerPlugin *plugin)
1361 {
1362 AnjutaProfileManager *profile_manager;
1363 GError *error = NULL;
1364
1365 /* Remove project profile */
1366 profile_manager =
1367 anjuta_shell_get_profile_manager (ANJUTA_PLUGIN (plugin)->shell, NULL);
1368 anjuta_profile_manager_pop (profile_manager, PROJECT_PROFILE_NAME, &error);
1369 if (error)
1370 {
1371 anjuta_util_dialog_error (get_plugin_parent_window (plugin),
1372 _("Error closing project: %s"),
1373 error->message);
1374 g_error_free (error);
1375 }
1376 }
1377
1378 static gboolean
1379 project_manager_plugin_activate_plugin (AnjutaPlugin *plugin)
1380 {
1381 AnjutaProfileManager *profile_manager;
1382 GtkWidget *view, *scrolled_window;
1383 GbfProjectModel *model;
1384 static gboolean initialized = FALSE;
1385 GtkTreeSelection *selection;
1386 /* GladeXML *gxml; */
1387 ProjectManagerPlugin *pm_plugin;
1388
1389 DEBUG_PRINT ("ProjectManagerPlugin: Activating Project Manager plugin...");
1390
1391 if (!initialized)
1392 register_stock_icons (plugin);
1393
1394 pm_plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (plugin);
1395 pm_plugin->ui = anjuta_shell_get_ui (plugin->shell, NULL);
1396 pm_plugin->prefs = anjuta_shell_get_preferences (plugin->shell, NULL);
1397
1398 /* create model & view and bind them */
1399 model = gbf_project_model_new (NULL);
1400 view = gbf_project_view_new ();
1401
1402 gtk_tree_view_set_model (GTK_TREE_VIEW (view),
1403 GTK_TREE_MODEL (model));
1404
1405 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
1406 g_signal_connect (view, "uri-activated",
1407 G_CALLBACK (on_uri_activated), plugin);
1408 g_signal_connect (view, "target-selected",
1409 G_CALLBACK (on_target_activated), plugin);
1410 g_signal_connect (view, "group-selected",
1411 G_CALLBACK (on_group_activated), plugin);
1412 g_signal_connect (selection, "changed",
1413 G_CALLBACK (on_treeview_selection_changed), plugin);
1414 g_signal_connect (view, "event",
1415 G_CALLBACK (on_treeview_event), plugin);
1416
1417 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
1418 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
1419 GTK_POLICY_AUTOMATIC,
1420 GTK_POLICY_AUTOMATIC);
1421 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
1422 GTK_SHADOW_IN);
1423 gtk_container_add (GTK_CONTAINER (scrolled_window), view);
1424 gtk_widget_show (view);
1425 gtk_widget_show (scrolled_window);
1426
1427 pm_plugin->scrolledwindow = scrolled_window;
1428 pm_plugin->view = view;
1429 pm_plugin->model = model;
1430
1431 /* Action groups */
1432 pm_plugin->pm_action_group =
1433 anjuta_ui_add_action_group_entries (pm_plugin->ui,
1434 "ActionGroupProjectManager",
1435 _("Project manager actions"),
1436 pm_actions,
1437 G_N_ELEMENTS(pm_actions),
1438 GETTEXT_PACKAGE, TRUE,
1439 plugin);
1440 pm_plugin->popup_action_group =
1441 anjuta_ui_add_action_group_entries (pm_plugin->ui,
1442 "ActionGroupProjectManagerPopup",
1443 _("Project manager popup actions"),
1444 popup_actions,
1445 G_N_ELEMENTS (popup_actions),
1446 GETTEXT_PACKAGE, TRUE,
1447 plugin);
1448 /* Merge UI */
1449 pm_plugin->merge_id =
1450 anjuta_ui_merge (pm_plugin->ui, UI_FILE);
1451
1452 update_ui (pm_plugin);
1453
1454 /* Added widget in shell */
1455 anjuta_shell_add_widget (plugin->shell, pm_plugin->scrolledwindow,
1456 "AnjutaProjectManager", _("Project"),
1457 "project-manager-plugin-icon",
1458 ANJUTA_SHELL_PLACEMENT_LEFT, NULL);
1459 #if 0
1460 /* Add preferences page */
1461 gxml = glade_xml_new (PREFS_GLADE, "dialog.project.manager", NULL);
1462
1463 anjuta_preferences_add_page (pm_plugin->prefs,
1464 gxml, "Project Manager", ICON_FILE);
1465 preferences_changed(pm_plugin->prefs, pm_plugin);
1466 g_object_unref (G_OBJECT (gxml));
1467 #endif
1468
1469 /* Add watches */
1470 pm_plugin->fm_watch_id =
1471 anjuta_plugin_add_watch (plugin, IANJUTA_FILE_MANAGER_SELECTED_FILE,
1472 value_added_fm_current_file,
1473 value_removed_fm_current_file, NULL);
1474 pm_plugin->editor_watch_id =
1475 anjuta_plugin_add_watch (plugin, IANJUTA_DOCUMENT_MANAGER_CURRENT_DOCUMENT,
1476 value_added_current_editor,
1477 value_removed_current_editor, NULL);
1478 /* Connect to save session */
1479 g_signal_connect (G_OBJECT (plugin->shell), "save_session",
1480 G_CALLBACK (on_session_save), plugin);
1481 g_signal_connect (G_OBJECT (plugin->shell), "exiting",
1482 G_CALLBACK (on_shell_exiting), plugin);
1483 profile_manager = anjuta_shell_get_profile_manager (plugin->shell, NULL);
1484
1485 /* Connect to profile scoping */
1486 g_signal_connect (profile_manager, "profile-scoped",
1487 G_CALLBACK (on_profile_scoped), plugin);
1488 g_signal_connect (profile_manager, "profile-descoped",
1489 G_CALLBACK (on_profile_descoped), plugin);
1490 return TRUE;
1491 }
1492
1493 static gboolean
1494 project_manager_plugin_deactivate_plugin (AnjutaPlugin *plugin)
1495 {
1496 AnjutaProfileManager *profile_manager;
1497 ProjectManagerPlugin *pm_plugin;
1498 pm_plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (plugin);
1499
1500 if (pm_plugin->close_project_idle > -1)
1501 {
1502 g_source_remove (pm_plugin->close_project_idle);
1503 }
1504
1505 /* Close project if it's open */
1506 if (pm_plugin->project_root_uri)
1507 project_manager_plugin_close (pm_plugin);
1508
1509 profile_manager = anjuta_shell_get_profile_manager (plugin->shell, NULL);
1510
1511 /* Disconnect signals */
1512 g_signal_handlers_disconnect_by_func (G_OBJECT (plugin->shell),
1513 G_CALLBACK (on_session_save),
1514 plugin);
1515 g_signal_handlers_disconnect_by_func (G_OBJECT (plugin->shell),
1516 G_CALLBACK (on_shell_exiting),
1517 plugin);
1518 g_signal_handlers_disconnect_by_func (G_OBJECT (profile_manager),
1519 G_CALLBACK (on_profile_descoped),
1520 plugin);
1521 g_signal_handlers_disconnect_by_func (G_OBJECT (profile_manager),
1522 G_CALLBACK (on_profile_scoped),
1523 plugin);
1524 /* Remove watches */
1525 anjuta_plugin_remove_watch (plugin, pm_plugin->fm_watch_id, TRUE);
1526 anjuta_plugin_remove_watch (plugin, pm_plugin->editor_watch_id, TRUE);
1527
1528 g_object_unref (G_OBJECT (pm_plugin->model));
1529
1530 /* Widget is removed from the shell when destroyed */
1531 gtk_widget_destroy (pm_plugin->scrolledwindow);
1532
1533 anjuta_ui_unmerge (pm_plugin->ui, pm_plugin->merge_id);
1534 anjuta_ui_remove_action_group (pm_plugin->ui, pm_plugin->pm_action_group);
1535 anjuta_ui_remove_action_group (pm_plugin->ui,
1536 pm_plugin->popup_action_group);
1537
1538 return TRUE;
1539 }
1540
1541 static void
1542 project_manager_plugin_finalize (GObject *obj)
1543 {
1544 /* FIXME: */
1545 G_OBJECT_CLASS (parent_class)->finalize (obj);
1546 }
1547
1548 static void
1549 project_manager_plugin_dispose (GObject *obj)
1550 {
1551 /* FIXME: */
1552 G_OBJECT_CLASS (parent_class)->dispose (obj);
1553 }
1554
1555 static void
1556 project_manager_plugin_instance_init (GObject *obj)
1557 {
1558 ProjectManagerPlugin *plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (obj);
1559 plugin->scrolledwindow = NULL;
1560 plugin->project = NULL;
1561 plugin->view = NULL;
1562 plugin->model = NULL;
1563 plugin->pre_update_sources = NULL;
1564 plugin->pre_update_targets = NULL;
1565 plugin->pre_update_groups = NULL;
1566 plugin->project_root_uri = NULL;
1567 plugin->project_uri = NULL;
1568 plugin->fm_current_uri = NULL;
1569 plugin->current_editor_uri = NULL;
1570 plugin->session_by_me = FALSE;
1571 plugin->close_project_idle = -1;
1572 }
1573
1574 static void
1575 project_manager_plugin_class_init (GObjectClass *klass)
1576 {
1577 AnjutaPluginClass *plugin_class = ANJUTA_PLUGIN_CLASS (klass);
1578
1579 parent_class = g_type_class_peek_parent (klass);
1580
1581 plugin_class->activate = project_manager_plugin_activate_plugin;
1582 plugin_class->deactivate = project_manager_plugin_deactivate_plugin;
1583 klass->dispose = project_manager_plugin_finalize;
1584 klass->dispose = project_manager_plugin_dispose;
1585 }
1586
1587 /* IAnjutaProjectManager implementation */
1588
1589 static GnomeVFSFileType
1590 get_uri_vfs_type (const gchar *uri)
1591 {
1592 GnomeVFSFileInfo info;
1593 gnome_vfs_get_file_info (uri, &info, 0);
1594 return info.type;
1595 }
1596
1597 static gboolean
1598 uri_is_inside_project (ProjectManagerPlugin *plugin, const gchar *uri)
1599 {
1600 if (strncmp (uri, plugin->project_root_uri,
1601 strlen (plugin->project_root_uri)) == 0)
1602 return TRUE;
1603
1604 if (uri[0] == '/')
1605 {
1606 const gchar *project_root_path = strchr (plugin->project_root_uri, ':');
1607 if (project_root_path)
1608 project_root_path += 3;
1609 else
1610 project_root_path = plugin->project_root_uri;
1611 return (strncmp (uri, project_root_path,
1612 strlen (project_root_path)) == 0);
1613 }
1614 return FALSE;
1615 }
1616
1617 static gchar *
1618 get_element_uri_from_id (ProjectManagerPlugin *plugin, const gchar *id)
1619 {
1620 gchar *path, *ptr;
1621 gchar *uri;
1622 const gchar *project_root;
1623
1624 if (!id)
1625 return NULL;
1626
1627 path = g_strdup (id);
1628 ptr = strrchr (path, ':');
1629 if (ptr)
1630 {
1631 if (ptr[1] == '/')
1632 {
1633 /* ID is source ID, extract source uri */
1634 ptr = strrchr (ptr, ':');
1635 return g_strdup (ptr+1);
1636 }
1637 *ptr = '\0';
1638 }
1639
1640 anjuta_shell_get (ANJUTA_PLUGIN (plugin)->shell,
1641 "project_root_uri", G_TYPE_STRING,
1642 &project_root, NULL);
1643 uri = g_build_filename (project_root, path, NULL);
1644 /* DEBUG_PRINT ("Converting id: %s to %s", id, uri); */
1645 g_free (path);
1646 return uri;
1647 }
1648
1649 static const gchar *
1650 get_element_relative_path (ProjectManagerPlugin *plugin, const gchar *uri)
1651 {
1652 const gchar *project_root = NULL;
1653
1654 anjuta_shell_get (ANJUTA_PLUGIN (plugin)->shell,
1655 "project_root_uri", G_TYPE_STRING,
1656 &project_root, NULL);
1657 if (project_root)
1658 {
1659 if (uri[0] != '/')
1660 {
1661 return uri + strlen (project_root);
1662 }
1663 else
1664 {
1665 const gchar *project_root_path = strchr (project_root, ':');
1666 if (project_root_path)
1667 project_root_path += 3;
1668 else
1669 project_root_path = project_root;
1670 return uri + strlen (project_root_path);
1671 }
1672 }
1673 return NULL;
1674 }
1675
1676 static GbfProjectTarget*
1677 get_target_from_uri (ProjectManagerPlugin *plugin, const gchar *uri)
1678 {
1679 GbfProjectTarget *data;
1680 const gchar *rel_path;
1681 gchar *test_id;
1682
1683 rel_path = get_element_relative_path (plugin, uri);
1684
1685 if (!rel_path)
1686 return NULL;
1687
1688 /* FIXME: More target types should be handled */
1689 /* Test for shared lib */
1690 test_id = g_strconcat (rel_path, ":shared_lib", NULL);
1691 data = gbf_project_get_target (GBF_PROJECT (plugin->project),
1692 test_id, NULL);
1693 g_free (test_id);
1694
1695 if (!data)
1696 {
1697 /* Test for static lib */
1698 test_id = g_strconcat (rel_path, ":static_lib", NULL);
1699 data = gbf_project_get_target (GBF_PROJECT (plugin->project),
1700 test_id, NULL);
1701 g_free (test_id);
1702 }
1703 if (!data)
1704 {
1705 /* Test for program */
1706 test_id = g_strconcat (rel_path, ":program", NULL);
1707 data = gbf_project_get_target (GBF_PROJECT (plugin->project),
1708 test_id, NULL);
1709 g_free (test_id);
1710 }
1711 return data;
1712 }
1713
1714 static gchar *
1715 get_element_id_from_uri (ProjectManagerPlugin *plugin, const gchar *uri)
1716 {
1717 GbfProjectTarget *target;
1718 gchar *id;
1719
1720 if (!uri_is_inside_project (plugin, uri))
1721 return NULL;
1722
1723 target = get_target_from_uri (plugin, uri);
1724 if (target)
1725 {
1726 id = g_strdup (target->id);
1727 gbf_project_target_free (target);
1728 }
1729 else if (get_uri_vfs_type (uri) | GNOME_VFS_FILE_TYPE_DIRECTORY)
1730 {
1731 id = g_strconcat (get_element_relative_path (plugin, uri), "/", NULL);
1732 }
1733 else
1734 {
1735 id = strdup (get_element_relative_path (plugin, uri));
1736 }
1737 return id;
1738 }
1739
1740 static IAnjutaProjectManagerElementType
1741 iproject_manager_get_element_type (IAnjutaProjectManager *project_manager,
1742 const gchar *element_uri,
1743 GError **err)
1744 {
1745 GnomeVFSFileType ftype;
1746 ProjectManagerPlugin *plugin;
1747
1748 g_return_val_if_fail (ANJUTA_IS_PLUGIN (project_manager),
1749 IANJUTA_PROJECT_MANAGER_UNKNOWN);
1750
1751 plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (G_OBJECT (project_manager));
1752 g_return_val_if_fail (GBF_IS_PROJECT (plugin->project),
1753 IANJUTA_PROJECT_MANAGER_UNKNOWN);
1754 g_return_val_if_fail (uri_is_inside_project (plugin, element_uri),
1755 IANJUTA_PROJECT_MANAGER_UNKNOWN);
1756
1757 ftype = get_uri_vfs_type (element_uri);
1758 if (ftype | GNOME_VFS_FILE_TYPE_DIRECTORY)
1759 {
1760 return IANJUTA_PROJECT_MANAGER_GROUP;
1761 }
1762 else if (ianjuta_project_manager_get_target_type (project_manager,
1763 element_uri, NULL) !=
1764 IANJUTA_PROJECT_MANAGER_TARGET_UNKNOWN)
1765 {
1766 return IANJUTA_PROJECT_MANAGER_TARGET;
1767 }
1768 else if (ftype | GNOME_VFS_FILE_TYPE_REGULAR)
1769 {
1770 return IANJUTA_PROJECT_MANAGER_SOURCE;
1771 }
1772 return IANJUTA_PROJECT_MANAGER_UNKNOWN;
1773 }
1774
1775 static GList*
1776 iproject_manager_get_elements (IAnjutaProjectManager *project_manager,
1777 IAnjutaProjectManagerElementType element_type,
1778 GError **err)
1779 {
1780 GList *elements;
1781 ProjectManagerPlugin *plugin;
1782
1783 g_return_val_if_fail (ANJUTA_IS_PLUGIN (project_manager), NULL);
1784
1785 plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (G_OBJECT (project_manager));
1786 g_return_val_if_fail (GBF_IS_PROJECT (plugin->project), NULL);
1787
1788 elements = NULL;
1789 switch (element_type)
1790 {
1791 case IANJUTA_PROJECT_MANAGER_SOURCE:
1792 {
1793 GList *sources, *node;
1794 GbfProjectTargetSource *source;
1795 sources = gbf_project_get_all_sources (plugin->project, NULL);
1796 node = sources;
1797 while (node)
1798 {
1799 source = gbf_project_get_source (plugin->project,
1800 (const gchar *) node->data,
1801 NULL);
1802 if (source)
1803 elements = g_list_prepend (elements,
1804 g_strdup (source->source_uri));
1805 gbf_project_target_source_free (source);
1806 g_free (node->data);
1807 node = node->next;
1808 }
1809 g_list_free (sources);
1810 break;
1811 }
1812 case IANJUTA_PROJECT_MANAGER_TARGET:
1813 {
1814 GList *targets, *node;
1815 targets = gbf_project_get_all_targets (plugin->project, NULL);
1816 node = targets;
1817 while (node)
1818 {
1819 elements = g_list_prepend (elements,
1820 get_element_uri_from_id (plugin,
1821 (const gchar *)node->data));
1822 g_free (node->data);
1823 node = node->next;
1824 }
1825 g_list_free (targets);
1826 break;
1827 }
1828 case IANJUTA_PROJECT_MANAGER_GROUP:
1829 {
1830 GList *groups, *node;
1831 groups = gbf_project_get_all_groups (plugin->project, NULL);
1832 node = groups;
1833 while (node)
1834 {
1835 elements = g_list_prepend (elements,
1836 get_element_uri_from_id (plugin,
1837 (const gchar *)node->data));
1838 g_free (node->data);
1839 node = node->next;
1840 }
1841 g_list_free (groups);
1842 break;
1843 }
1844 default:
1845 elements = NULL;
1846 }
1847 return g_list_reverse (elements);
1848 }
1849
1850 static IAnjutaProjectManagerTargetType
1851 iproject_manager_get_target_type (IAnjutaProjectManager *project_manager,
1852 const gchar *target_uri,
1853 GError **err)
1854 {
1855 IAnjutaProjectManagerElementType element_type;
1856 IAnjutaProjectManagerTargetType target_type;
1857 ProjectManagerPlugin *plugin;
1858 GbfProjectTarget *data;
1859
1860 g_return_val_if_fail (ANJUTA_IS_PLUGIN (project_manager),
1861 IANJUTA_PROJECT_MANAGER_TARGET_UNKNOWN);
1862
1863 plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (G_OBJECT (project_manager));
1864 g_return_val_if_fail (GBF_IS_PROJECT (plugin->project),
1865 IANJUTA_PROJECT_MANAGER_TARGET_UNKNOWN);
1866
1867 element_type = ianjuta_project_manager_get_element_type (project_manager,
1868 target_uri, NULL);
1869
1870 g_return_val_if_fail (uri_is_inside_project (plugin, target_uri),
1871 IANJUTA_PROJECT_MANAGER_TARGET_UNKNOWN);
1872
1873 data = get_target_from_uri (plugin, target_uri);
1874
1875 if (data && data->type && strcmp (data->type, "shared_lib") == 0)
1876 {
1877 target_type = IANJUTA_PROJECT_MANAGER_TARGET_SHAREDLIB;
1878 }
1879 else if (data && data->type && strcmp (data->type, "static_lib") == 0)
1880 {
1881 target_type = IANJUTA_PROJECT_MANAGER_TARGET_STATICLIB;
1882 }
1883 else if (data && data->type && strcmp (data->type, "program") == 0)
1884 {
1885 target_type = IANJUTA_PROJECT_MANAGER_TARGET_STATICLIB;
1886 }
1887 else
1888 {
1889 target_type = IANJUTA_PROJECT_MANAGER_TARGET_UNKNOWN;
1890 }
1891 if (data)
1892 gbf_project_target_free (data);
1893 return target_type;
1894 }
1895
1896 static GList*
1897 iproject_manager_get_targets (IAnjutaProjectManager *project_manager,
1898 IAnjutaProjectManagerTargetType target_type,
1899 GError **err)
1900 {
1901 GList *targets, *node;
1902 const gchar *target_id;
1903 GList *elements;
1904 ProjectManagerPlugin *plugin;
1905 GList *target_types = NULL;
1906
1907 g_return_val_if_fail (ANJUTA_IS_PLUGIN (project_manager), NULL);
1908
1909 plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (G_OBJECT (project_manager));
1910 g_return_val_if_fail (GBF_IS_PROJECT (plugin->project), NULL);
1911
1912 switch (target_type)
1913 {
1914 case IANJUTA_PROJECT_MANAGER_TARGET_SHAREDLIB:
1915 target_types = g_list_append(target_types, "shared_lib");
1916 break;
1917 case IANJUTA_PROJECT_MANAGER_TARGET_STATICLIB:
1918 target_types = g_list_append(target_types, "static_lib");
1919 break;
1920 case IANJUTA_PROJECT_MANAGER_TARGET_EXECUTABLE:
1921 target_types = g_list_append(target_types, "program");
1922 target_types = g_list_append(target_types, "script");
1923 break;
1924 default:
1925 /* FIXME: there are some more target types */
1926 g_warning ("Unsupported target type");
1927 return NULL;
1928 }
1929
1930 elements = NULL;
1931 targets = gbf_project_get_all_targets (plugin->project, NULL);
1932 node = targets;
1933 while (node)
1934 {
1935 const gchar *t_type;
1936
1937 target_id = (const gchar*) node->data;
1938
1939 t_type = strrchr (target_id, ':');
1940 if (t_type && strlen (t_type) > 2)
1941 {
1942 GList* type_node;
1943 t_type++;
1944 for (type_node = target_types; type_node != NULL;
1945 type_node = type_node->next)
1946 {
1947 if (strcmp (t_type, type_node->data) == 0)
1948 {
1949 gchar *target_uri = get_element_uri_from_id (plugin,
1950 target_id);
1951 elements = g_list_prepend (elements, target_uri);
1952 }
1953 }
1954 }
1955 g_free (node->data);
1956 node = node->next;
1957 }
1958 g_list_free (targets);
1959 return g_list_reverse (elements);
1960 }
1961
1962 static gchar*
1963 iproject_manager_get_parent (IAnjutaProjectManager *project_manager,
1964 const gchar *element_uri,
1965 GError **err)
1966 {
1967 IAnjutaProjectManagerElementType type;
1968 ProjectManagerPlugin *plugin;
1969
1970 g_return_val_if_fail (ANJUTA_IS_PLUGIN (project_manager), NULL);
1971
1972 plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (G_OBJECT (project_manager));
1973 g_return_val_if_fail (GBF_IS_PROJECT (plugin->project), NULL);
1974
1975 type = ianjuta_project_manager_get_element_type (project_manager,
1976 element_uri, NULL);
1977 /* FIXME: */
1978 return NULL;
1979 }
1980
1981 static GList*
1982 iproject_manager_get_children (IAnjutaProjectManager *project_manager,
1983 const gchar *element_uri,
1984 GError **err)
1985 {
1986 ProjectManagerPlugin *plugin;
1987
1988 g_return_val_if_fail (ANJUTA_IS_PLUGIN (project_manager), NULL);
1989
1990 plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (G_OBJECT (project_manager));
1991 g_return_val_if_fail (GBF_IS_PROJECT (plugin->project), NULL);
1992 /* FIXME: */
1993 return NULL;
1994 }
1995
1996 static gchar*
1997 iproject_manager_get_selected (IAnjutaProjectManager *project_manager,
1998 GError **err)
1999 {
2000 gchar *uri;
2001 GbfTreeData *data;
2002 ProjectManagerPlugin *plugin;
2003
2004 g_return_val_if_fail (ANJUTA_IS_PLUGIN (project_manager), NULL);
2005
2006 plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (G_OBJECT (project_manager));
2007 g_return_val_if_fail (GBF_IS_PROJECT (plugin->project), NULL);
2008
2009 data = gbf_project_view_find_selected (GBF_PROJECT_VIEW (plugin->view),
2010 GBF_TREE_NODE_TARGET_SOURCE);
2011 if (data && data->type == GBF_TREE_NODE_TARGET_SOURCE)
2012 {
2013 uri = g_strdup (data->uri);
2014 gbf_tree_data_free (data);
2015 return uri;
2016 }
2017
2018 if (data)
2019 gbf_tree_data_free (data);
2020
2021 data = gbf_project_view_find_selected (GBF_PROJECT_VIEW (plugin->view),
2022 GBF_TREE_NODE_TARGET);
2023 if (data && data->type == GBF_TREE_NODE_TARGET)
2024 {
2025 uri = get_element_uri_from_id (plugin, data->id);
2026 gbf_tree_data_free (data);
2027 return uri;
2028 }
2029
2030 if (data)
2031 gbf_tree_data_free (data);
2032
2033 data = gbf_project_view_find_selected (GBF_PROJECT_VIEW (plugin->view),
2034 GBF_TREE_NODE_GROUP);
2035 if (data && data->type == GBF_TREE_NODE_GROUP)
2036 {
2037 uri = g_strdup (data->uri);
2038 gbf_tree_data_free (data);
2039 return uri;;
2040 }
2041
2042 if (data)
2043 gbf_tree_data_free (data);
2044
2045 return NULL;
2046 }
2047
2048 static IAnjutaProjectManagerCapabilities
2049 iproject_manager_get_capabilities (IAnjutaProjectManager *project_manager,
2050 GError **err)
2051 {
2052 ProjectManagerPlugin *plugin;
2053
2054 g_return_val_if_fail (ANJUTA_IS_PLUGIN (project_manager),
2055 IANJUTA_PROJECT_MANAGER_CAN_ADD_NONE);
2056
2057 plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (G_OBJECT (project_manager));
2058 return gbf_project_get_capabilities (plugin->project, NULL);
2059 }
2060
2061 static gchar*
2062 iproject_manager_add_source (IAnjutaProjectManager *project_manager,
2063 const gchar *source_uri_to_add,
2064 const gchar *default_location_uri,
2065 GError **err)
2066 {
2067 ProjectManagerPlugin *plugin;
2068 IAnjutaProjectManagerElementType default_location_type;
2069 gchar *location_id;
2070 gchar* source_id;
2071 gchar* source_uri;
2072
2073 g_return_val_if_fail (ANJUTA_IS_PLUGIN (project_manager), FALSE);
2074
2075 plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (G_OBJECT (project_manager));
2076 g_return_val_if_fail (GBF_IS_PROJECT (plugin->project), FALSE);
2077
2078 update_operation_begin (plugin);
2079 default_location_type =
2080 ianjuta_project_manager_get_element_type (project_manager,
2081 default_location_uri, NULL);
2082 location_id = get_element_id_from_uri (plugin, default_location_uri);
2083 if (default_location_type == IANJUTA_PROJECT_MANAGER_GROUP)
2084 {
2085 source_id = gbf_project_util_add_source (plugin->model,
2086 get_plugin_parent_window (plugin),
2087 NULL, location_id,
2088 source_uri_to_add);
2089 }
2090 else if (default_location_type == IANJUTA_PROJECT_MANAGER_TARGET)
2091 {
2092 source_id = gbf_project_util_add_source (plugin->model,
2093 get_plugin_parent_window (plugin),
2094 location_id, NULL,
2095 source_uri_to_add);
2096 }
2097 else
2098 {
2099 source_id = gbf_project_util_add_source (plugin->model,
2100 get_plugin_parent_window (plugin),
2101 NULL, NULL,
2102 source_uri_to_add);
2103 }
2104 update_operation_end (plugin, TRUE);
2105
2106 source_uri = get_element_uri_from_id(plugin, source_id);
2107 g_free(source_id);
2108
2109 return source_uri;
2110 }
2111
2112 static GList*
2113 iproject_manager_add_source_multi (IAnjutaProjectManager *project_manager,
2114 GList *source_add_uris,
2115 const gchar *default_location_uri,
2116 GError **err)
2117 {
2118 ProjectManagerPlugin *plugin;
2119 IAnjutaProjectManagerElementType default_location_type;
2120 gchar *location_id;
2121 GList* source_ids;
2122 GList* source_uris = NULL;
2123
2124 g_return_val_if_fail (ANJUTA_IS_PLUGIN (project_manager), FALSE);
2125
2126 plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (G_OBJECT (project_manager));
2127 g_return_val_if_fail (GBF_IS_PROJECT (plugin->project), FALSE);
2128
2129 update_operation_begin (plugin);
2130 default_location_type =
2131 ianjuta_project_manager_get_element_type (project_manager,
2132 default_location_uri, NULL);
2133 location_id = get_element_id_from_uri (plugin, default_location_uri);
2134 if (default_location_type == IANJUTA_PROJECT_MANAGER_GROUP)
2135 {
2136 source_ids = gbf_project_util_add_source_multi (plugin->model,
2137 get_plugin_parent_window (plugin),
2138 NULL, location_id,
2139 source_add_uris);
2140 }
2141 else if (default_location_type == IANJUTA_PROJECT_MANAGER_TARGET)
2142 {
2143 source_ids =
2144 gbf_project_util_add_source_multi (plugin->model,
2145 get_plugin_parent_window (plugin),
2146 location_id, NULL,
2147 source_add_uris);
2148 }
2149 else
2150 {
2151 source_ids =
2152 gbf_project_util_add_source_multi (plugin->model,
2153 get_plugin_parent_window (plugin),
2154 NULL, NULL,
2155 source_add_uris);
2156 }
2157 update_operation_end (plugin, TRUE);
2158
2159 while (source_ids)
2160 {
2161 source_uris = g_list_append (source_uris,
2162 get_element_uri_from_id (plugin,
2163 source_ids->data));
2164 g_free (source_ids->data);
2165 source_ids = g_list_next(source_ids);
2166 }
2167 g_list_free (source_ids);
2168 return source_uris;
2169 }
2170
2171 static gchar*
2172 iproject_manager_add_target (IAnjutaProjectManager *project_manager,
2173 const gchar *target_name_to_add,
2174 const gchar *default_group_uri,
2175 GError **err)
2176 {
2177 ProjectManagerPlugin *plugin;
2178 gchar *default_group_id, *target_id, *target_uri = NULL;
2179
2180 g_return_val_if_fail (ANJUTA_IS_PLUGIN (project_manager), FALSE);
2181
2182 plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (G_OBJECT (project_manager));
2183
2184 g_return_val_if_fail (GBF_IS_PROJECT (plugin->project), FALSE);
2185
2186 default_group_id = get_element_id_from_uri (plugin, default_group_uri);
2187
2188 update_operation_begin (plugin);
2189 target_id = gbf_project_util_new_target (plugin->model,
2190 get_plugin_parent_window (plugin),
2191 default_group_id,
2192 target_name_to_add);
2193 update_operation_end (plugin, TRUE);
2194 target_uri = get_element_uri_from_id (plugin, target_id);
2195 g_free (target_id);
2196 g_free (default_group_id);
2197 return target_uri;
2198 }
2199
2200 static gchar*
2201 iproject_manager_add_group (IAnjutaProjectManager *project_manager,
2202 const gchar *group_name_to_add,
2203 const gchar *default_group_uri,
2204 GError **err)
2205 {
2206 ProjectManagerPlugin *plugin;
2207 gchar *group_id, *group_uri = NULL;
2208 gchar *default_group_id;
2209
2210 g_return_val_if_fail (ANJUTA_IS_PLUGIN (project_manager), FALSE);
2211
2212 plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (G_OBJECT (project_manager));
2213 g_return_val_if_fail (GBF_IS_PROJECT (plugin->project), FALSE);
2214
2215 default_group_id = get_element_id_from_uri (plugin, default_group_uri);
2216
2217 update_operation_begin (plugin);
2218 group_id = gbf_project_util_new_group (plugin->model,
2219 get_plugin_parent_window (plugin),
2220 default_group_id,
2221 group_name_to_add);
2222 update_operation_end (plugin, TRUE);
2223 group_uri = get_element_uri_from_id (plugin, group_id);
2224 g_free (group_id);
2225 g_free (default_group_id);
2226 return group_uri;
2227 }
2228
2229 static gboolean
2230 iproject_manager_is_open (IAnjutaProjectManager *project_manager, GError **err)
2231 {
2232 ProjectManagerPlugin *plugin;
2233
2234 plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (G_OBJECT (project_manager));
2235
2236 return GBF_IS_PROJECT (plugin->project);
2237 }
2238
2239 static GList*
2240 iproject_manager_get_packages (IAnjutaProjectManager *project_manager, GError **err)
2241 {
2242 ProjectManagerPlugin *plugin;
2243 GList *modules = NULL;
2244 GList *packages = NULL;
2245 GList* node;
2246
2247 plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (G_OBJECT (project_manager));
2248
2249 modules = gbf_project_get_config_modules (plugin->project, NULL);
2250 for (node = modules; node != NULL; node = g_list_next (node))
2251 {
2252 GList* mod_pkgs = gbf_project_get_config_packages (plugin->project,
2253 node->data, NULL);
2254 packages = g_list_concat (packages, mod_pkgs);
2255 }
2256 g_list_foreach (modules, (GFunc)g_free, NULL);
2257 g_list_free (modules);
2258 return packages;
2259 }
2260
2261 static void
2262 iproject_manager_iface_init(IAnjutaProjectManagerIface *iface)
2263 {
2264 iface->get_element_type = iproject_manager_get_element_type;
2265 iface->get_elements = iproject_manager_get_elements;
2266 iface->get_target_type = iproject_manager_get_target_type;
2267 iface->get_targets = iproject_manager_get_targets;
2268 iface->get_parent = iproject_manager_get_parent;
2269 iface->get_children = iproject_manager_get_children;
2270 iface->get_selected = iproject_manager_get_selected;
2271 iface->get_capabilities = iproject_manager_get_capabilities;
2272 iface->add_source = iproject_manager_add_source;
2273 iface->add_sources = iproject_manager_add_source_multi;
2274 iface->add_target = iproject_manager_add_target;
2275 iface->add_group = iproject_manager_add_group;
2276 iface->is_open = iproject_manager_is_open;
2277 iface->get_packages = iproject_manager_get_packages;
2278 }
2279
2280 static void
2281 ifile_open (IAnjutaFile *ifile, GFile* file, GError **e)
2282 {
2283 AnjutaProfile *profile;
2284 AnjutaProfileManager *profile_manager;
2285 AnjutaPluginManager *plugin_manager;
2286 AnjutaStatus *status;
2287 gchar *dirname, *dirname_tmp, *vfs_dir;
2288 gchar *session_profile, *profile_name;
2289 ProjectManagerPlugin *plugin;
2290 GError *error = NULL;
2291 gchar* uri = g_file_get_uri (file);
2292 GnomeVFSURI* vfs_uri;
2293
2294 plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (ifile);
2295
2296 /* If there is already a project loaded, load in separate anjuta window */
2297 if (plugin->project_root_uri)
2298 {
2299 gchar *quoted_uri = g_shell_quote (uri);
2300 gchar *cmd = g_strconcat ("anjuta --no-splash --no-client ", quoted_uri, NULL);
2301 g_free (quoted_uri);
2302 anjuta_util_execute_shell (NULL, cmd);
2303 g_free (cmd);
2304 return;
2305 }
2306
2307 plugin_manager =
2308 anjuta_shell_get_plugin_manager (ANJUTA_PLUGIN (ifile)->shell, NULL);
2309 profile_manager =
2310 anjuta_shell_get_profile_manager (ANJUTA_PLUGIN (ifile)->shell, NULL);
2311 status = anjuta_shell_get_status (ANJUTA_PLUGIN (ifile)->shell, NULL);
2312
2313 anjuta_status_progress_add_ticks (status, 2);
2314 /* Prepare profile */
2315 profile = anjuta_profile_new (PROJECT_PROFILE_NAME, plugin_manager);
2316
2317 /* System default profile */
2318 anjuta_profile_add_plugins_from_xml (profile, DEFAULT_PROFILE,
2319 TRUE, &error);
2320 if (error)
2321 {
2322 anjuta_util_dialog_error (GTK_WINDOW (ANJUTA_PLUGIN (ifile)->shell),
2323 "%s", error->message);
2324 g_error_free (error);
2325 error = NULL;
2326 }
2327
2328 /* Project default profile */
2329 anjuta_profile_add_plugins_from_xml (profile, uri, TRUE, &error);
2330 if (error)
2331 {
2332 anjuta_util_dialog_error (GTK_WINDOW (ANJUTA_PLUGIN (ifile)->shell),
2333 "%s", error->message);
2334 g_error_free (error);
2335 error = NULL;
2336 }
2337
2338 /* Project session profile */
2339 vfs_uri = gnome_vfs_uri_new (uri);
2340
2341 dirname_tmp = gnome_vfs_uri_extract_dirname (vfs_uri);
2342 dirname = gnome_vfs_unescape_string (dirname_tmp, "");
2343 g_free (dirname_tmp);
2344
2345 profile_name = g_path_get_basename (DEFAULT_PROFILE);
2346 gnome_vfs_uri_unref (vfs_uri);
2347
2348 session_profile = g_build_filename (dirname, ".anjuta",
2349 profile_name, NULL);
2350 DEBUG_PRINT ("Loading project session profile: %s", session_profile);
2351
2352 if (g_file_test (session_profile, G_FILE_TEST_EXISTS))
2353 {
2354 anjuta_profile_add_plugins_from_xml (profile, session_profile,
2355 FALSE, &error);
2356 if (error)
2357 {
2358 anjuta_util_dialog_error (GTK_WINDOW (ANJUTA_PLUGIN (ifile)->shell),
2359 "%s", error->message);
2360 g_error_free (error);
2361 error = NULL;
2362 }
2363 }
2364 anjuta_profile_set_sync_uri (profile, session_profile);
2365 g_free (session_profile);
2366 g_free (profile_name);
2367
2368 /* Set project uri */
2369 g_free (plugin->project_root_uri);
2370 g_free (plugin->project_uri);
2371
2372 vfs_dir = gnome_vfs_get_uri_from_local_path (dirname);
2373 plugin->project_uri = g_strdup (uri);
2374 plugin->project_root_uri = vfs_dir;
2375 g_free (dirname);
2376
2377 /* Load profile */
2378 anjuta_profile_manager_push (profile_manager, profile, &error);
2379 if (error)
2380 {
2381 anjuta_util_dialog_error (GTK_WINDOW (ANJUTA_PLUGIN (ifile)->shell),
2382 "%s", error->message);
2383 g_error_free (error);
2384 error = NULL;
2385 }
2386
2387 anjuta_status_progress_tick (status, NULL,
2388 _("Loaded Project... Initializing"));
2389 update_ui (plugin);
2390
2391 anjuta_status_progress_tick (status, NULL, _("Loaded Project..."));
2392 g_free (uri);
2393 }
2394
2395 static GFile*
2396 ifile_get_file (IAnjutaFile *ifile, GError **e)
2397 {
2398 ProjectManagerPlugin *plugin;
2399
2400 plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (ifile);
2401 if (plugin->project_root_uri)
2402 return g_file_new_for_uri (plugin->project_root_uri);
2403 else
2404 return NULL;
2405 }
2406
2407 static void
2408 ifile_iface_init(IAnjutaFileIface *iface)
2409 {
2410 iface->open = ifile_open;
2411 iface->get_file = ifile_get_file;
2412 }
2413
2414 ANJUTA_PLUGIN_BEGIN (ProjectManagerPlugin, project_manager_plugin);
2415 ANJUTA_PLUGIN_ADD_INTERFACE (iproject_manager, IANJUTA_TYPE_PROJECT_MANAGER);
2416 ANJUTA_PLUGIN_ADD_INTERFACE (ifile, IANJUTA_TYPE_FILE);
2417 ANJUTA_PLUGIN_END;
2418
2419 ANJUTA_SIMPLE_PLUGIN (ProjectManagerPlugin, project_manager_plugin);
Anjuta IDE Git Plugin Development Tree