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