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