?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Initial German translation of the build tutorial
[anjuta.git] / plugins / project-manager / dialogs.c
blob85e915af75b88042630667371a04c67e898dab11
1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4; coding: utf-8 -*- */
2 /* am-dialogs.c
3 *
4 * Copyright (C) 2009 Sébastien Granjoux
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation; either version 2 of the
9 * License, or (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 GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public
17 * License along with this program; if not, write to the
18 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19 * Boston, MA 02110-1301, USA.
20 *
21 */
22
23 #ifdef HAVE_CONFIG_H
24 #include <config.h>
25 #endif
26
27 #include <glib/gi18n.h>
28
29 #include "dialogs.h"
30
31 #include "project-model.h"
32 #include "project-view.h"
33
34 #include <libanjuta/anjuta-debug.h>
35 #include <libanjuta/anjuta-utils.h>
36 #include <libanjuta/anjuta-pkg-config-chooser.h>
37 #include <libanjuta/anjuta-tree-combo.h>
38 #include <libanjuta/interfaces/ianjuta-project-chooser.h>
39 #include <libanjuta/interfaces/ianjuta-project-backend.h>
40
41 #define ICON_SIZE 16
42
43 #define GLADE_FILE PACKAGE_DATA_DIR "/glade/pm_dialogs.ui"
44
45 #define ANJUTA_MANUAL "anjuta-manual"
46 #define ADD_SOURCE_HELP "project-manager-source-add"
47 #define ADD_TARGET_HELP "project-manager-target-add"
48 #define ADD_PACKAGE_HELP "project-manager-module-new"
49 #define ADD_MODULE_HELP "project-manager-module-add"
50 #define ADD_FOLDER_HELP "project-manager-folder-add"
51
52
53 /* Types
54 *---------------------------------------------------------------------------*/
55
56 typedef struct _PropertiesTable
57 {
58 AnjutaPmProject *project;
59 AnjutaPluginHandle *new_backend;
60 GtkWidget *dialog;
61 GtkWidget *table;
62 GtkWidget *head;
63 GtkWidget *main;
64 GtkWidget *expand;
65 GtkWidget *extra;
66 GtkWidget *viewport;
67 GtkWidget *scrolledwindow;
68 GbfTreeData *data;
69 AnjutaProjectNode *node;
70 GtkWidget *help_button;
71 const gchar *help_id;
72 GList *properties;
73 } PropertiesTable;
74
75 typedef struct _PropertyEntry
76 {
77 GtkWidget *entry;
78 AnjutaProjectPropertyInfo *info;
79 } PropertyEntry;
80
81 typedef struct _PropertyValue
82 {
83 AnjutaProjectProperty *property;
84 const gchar *value;
85 } PropertyValue;
86
87 enum {
88 NAME_COLUMN,
89 VALUE_COLUMN,
90 EDITABLE_COLUMN,
91 PROPERTY_COLUMN,
92 LIST_COLUMNS_NB
93 };
94
95 /* Sources list columns in new source dialog */
96 enum {
97 COLUMN_FILE,
98 COLUMN_URI,
99 N_COLUMNS
100 };
101
102 /* Helper functions
103 *---------------------------------------------------------------------------*/
104
105 static GtkBuilder *
106 load_interface (const gchar *top_widget)
107 {
108 GtkBuilder *xml = gtk_builder_new ();
109 GError* error = NULL;
110
111 if (!gtk_builder_add_from_file (xml, GLADE_FILE, &error))
112 {
113 g_warning ("Couldn't load builder file: %s", error->message);
114 g_error_free (error);
115 return NULL;
116 }
117
118 return xml;
119 }
120
121 static void
122 error_dialog (GtkWindow *parent, const gchar *summary, const gchar *msg, ...)
123 {
124 va_list ap;
125 gchar *tmp;
126 GtkWidget *dialog;
127
128 va_start (ap, msg);
129 tmp = g_strdup_vprintf (msg, ap);
130 va_end (ap);
131
132 dialog = gtk_message_dialog_new_with_markup (parent,
133 GTK_DIALOG_DESTROY_WITH_PARENT,
134 GTK_MESSAGE_ERROR,
135 GTK_BUTTONS_OK,
136 "<b>%s</b>\n\n%s", summary, tmp);
137 g_free (tmp);
138
139 gtk_dialog_run (GTK_DIALOG (dialog));
140 gtk_widget_destroy (dialog);
141 }
142
143
144 /* Private nodes functions
145 *---------------------------------------------------------------------------*/
146
147 static PropertyEntry*
148 pm_property_entry_new (GtkWidget *entry, AnjutaProjectPropertyInfo *info)
149 {
150 PropertyEntry *prop;
151
152 prop = g_slice_new0(PropertyEntry);
153 prop->entry = entry;
154 prop->info = info;
155
156 return prop;
157 }
158
159 static void
160 pm_property_entry_free (PropertyEntry *prop)
161 {
162 g_slice_free (PropertyEntry, prop);
163 }
164
165 static gboolean
166 parent_filter_func (GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data)
167 {
168 GbfTreeData *data = NULL;
169 gboolean visible = FALSE;
170 AnjutaProjectNodeType type = (AnjutaProjectNodeType)GPOINTER_TO_INT (user_data);
171 AnjutaProjectNode *parent;
172 AnjutaProjectNode *node;
173 gint need;
174
175 switch (type)
176 {
177 case ANJUTA_PROJECT_GROUP:
178 need = ANJUTA_PROJECT_CAN_ADD_GROUP;
179 break;
180 case ANJUTA_PROJECT_TARGET:
181 need = ANJUTA_PROJECT_CAN_ADD_TARGET;
182 break;
183 case ANJUTA_PROJECT_SOURCE:
184 /* Add node containing target too because target can contains module
185 * It would be probably better to check recursively if any children
186 * can accept a module and keep all parents then. */
187 need = ANJUTA_PROJECT_CAN_ADD_SOURCE | ANJUTA_PROJECT_CAN_ADD_TARGET;
188 break;
189 case ANJUTA_PROJECT_MODULE:
190 /* Add node containing target too because target can contains module
191 * It would be probably better to check recursively if any children
192 * can accept a module and keep all parents then. */
193 need = ANJUTA_PROJECT_CAN_ADD_MODULE | ANJUTA_PROJECT_CAN_ADD_TARGET;
194 break;
195 case ANJUTA_PROJECT_PACKAGE:
196 need = ANJUTA_PROJECT_CAN_ADD_PACKAGE;
197 break;
198 default:
199 need = 0;
200 break;
201 }
202
203 gtk_tree_model_get (model, iter,
204 GBF_PROJECT_MODEL_COLUMN_DATA, &data, -1);
205 if (data->shortcut != NULL)
206 {
207 visible = FALSE;
208 }
209 else
210 {
211 node = data == NULL ? NULL : gbf_tree_data_get_node (data);
212 if (node != NULL)
213 {
214 if (anjuta_project_node_get_state (node) & need)
215 {
216 /* Current node can be used as parent */
217 visible = TRUE;
218 }
219 else if (anjuta_project_node_get_node_type (node) == type)
220 {
221 /* Check if node can be used as sibling */
222 parent = anjuta_project_node_parent (node);
223 visible = anjuta_project_node_get_state (parent) & need ? TRUE : FALSE;
224 }
225 }
226 }
227
228 return visible;
229 }
230
231 static gboolean
232 module_filter_func (GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data)
233 {
234 GbfTreeData *data = NULL;
235 gboolean visible = FALSE;
236 AnjutaProjectNode *node;
237
238 gtk_tree_model_get (model, iter,
239 GBF_PROJECT_MODEL_COLUMN_DATA, &data, -1);
240 node = data == NULL ? NULL : gbf_tree_data_get_node (data);
241 if (node != NULL)
242 {
243 AnjutaProjectNodeType type = anjuta_project_node_get_node_type (node);
244
245 visible = (type == ANJUTA_PROJECT_MODULE) || (type == ANJUTA_PROJECT_PACKAGE);
246 }
247
248 return visible;
249 }
250
251 static void
252 setup_nodes_treeview (GbfProjectView *view,
253 GbfProjectView *parent,
254 GtkTreePath *root,
255 GtkTreeModelFilterVisibleFunc func,
256 gpointer data,
257 GtkTreeIter *selected)
258 {
259 g_return_if_fail (view != NULL && GBF_IS_PROJECT_VIEW (view));
260 g_return_if_fail (parent != NULL);
261
262 gbf_project_view_set_parent_view (view, parent, root);
263 gbf_project_view_set_visible_func (view, func, data, NULL);
264 gbf_project_view_set_cursor_to_iter (view, selected);
265 }
266
267 static void
268 entry_changed_cb (GtkEditable *editable, gpointer user_data)
269 {
270 GtkWidget *button = user_data;
271 gchar *text;
272
273 if (!button)
274 return;
275
276 text = gtk_editable_get_chars (editable, 0, -1);
277 if (strlen (text) > 0) {
278 gtk_widget_set_sensitive (button, TRUE);
279 gtk_widget_grab_default (button);
280 } else {
281 gtk_widget_set_sensitive (button, FALSE);
282 }
283 g_free (text);
284 }
285
286 static void
287 on_value_edited (GtkCellRendererText *cell,
288 gchar *path_string,
289 gchar *text,
290 gpointer user_data)
291 {
292 GtkTreeView *view = (GtkTreeView *)user_data;
293 GtkTreeIter iter;
294 GtkTreeModel * model;
295
296 model = gtk_tree_view_get_model (GTK_TREE_VIEW (view));
297 if (gtk_tree_model_get_iter_from_string (model, &iter, path_string))
298 {
299 gtk_list_store_set (GTK_LIST_STORE (model), &iter, VALUE_COLUMN, text, -1);
300 }
301 }
302
303 static void
304 on_row_changed(GtkTreeModel* model, GtkTreePath* path, GtkTreeIter* iter, gpointer data)
305 {
306 GtkWidget* button = GTK_WIDGET(data);
307 if (gtk_list_store_iter_is_valid(GTK_LIST_STORE(model), iter))
308 gtk_widget_set_sensitive(button, TRUE);
309 else
310 gtk_widget_set_sensitive(button, FALSE);
311 }
312
313 static void
314 browse_button_clicked_cb (GtkWidget *widget, gpointer user_data)
315 {
316 GtkTreeView *tree = user_data;
317 GtkTreeView *treeview;
318 GtkFileChooserDialog* dialog;
319 GtkTreeModel* model;
320 AnjutaProjectNode *parent;
321 gint result;
322
323 g_return_if_fail (user_data != NULL && GTK_IS_TREE_VIEW (user_data));
324
325 model = gtk_tree_view_get_model(tree);
326 /*if (gtk_tree_model_get_iter_first(model, &iter))
327 {
328 gtk_tree_model_get(model, &iter, COLUMN_URI, &file, -1);
329 uri = g_strdup(file);
330 }
331 else
332 uri = g_strdup("");*/
333
334 dialog = GTK_FILE_CHOOSER_DIALOG(gtk_file_chooser_dialog_new (_("Select sources…"),
335 GTK_WINDOW (gtk_widget_get_toplevel (widget)),
336 GTK_FILE_CHOOSER_ACTION_OPEN,
337 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
338 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
339 NULL));
340
341 /* Get default directory */
342 treeview = g_object_get_data (G_OBJECT (widget), "treeview");
343 parent = gbf_project_view_find_selected (GBF_PROJECT_VIEW (treeview), ANJUTA_PROJECT_UNKNOWN);
344 if (!(anjuta_project_node_get_state (parent) & ANJUTA_PROJECT_CAN_ADD_SOURCE))
345 {
346 parent = anjuta_project_node_parent (parent);
347 }
348 gtk_file_chooser_set_current_folder_file(GTK_FILE_CHOOSER(dialog),
349 anjuta_project_node_get_file (parent), NULL);
350
351 gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER(dialog), TRUE);
352
353 result = gtk_dialog_run (GTK_DIALOG (dialog));
354 switch (result)
355 {
356 case GTK_RESPONSE_ACCEPT:
357 {
358 GSList* uris = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER(dialog));
359 GSList* node_uri = uris;
360
361 gtk_list_store_clear (GTK_LIST_STORE (model));
362
363 while (node_uri != NULL)
364 {
365 GtkTreeIter iter;
366 gchar* uri = node_uri->data;
367 gchar* file = g_path_get_basename (uri);
368 gtk_list_store_append (GTK_LIST_STORE (model), &iter);
369 gtk_list_store_set (GTK_LIST_STORE (model), &iter, COLUMN_FILE,
370 file, COLUMN_URI, uri, -1);
371 node_uri = g_slist_next (node_uri);
372 }
373 g_slist_free (uris);
374 break;
375 }
376 default:
377 break;
378 }
379 gtk_widget_destroy (GTK_WIDGET(dialog));
380 }
381
382 /* Private properties functions
383 *---------------------------------------------------------------------------*/
384
385 static GtkWidget *
386 add_entry (IAnjutaProject *project, AnjutaProjectNode *node, AnjutaProjectProperty *prop, GtkWidget *table, gint *position)
387 {
388 GtkWidget *label;
389 GtkWidget *entry = NULL;
390 GtkWidget *view;
391 static GType column_type[LIST_COLUMNS_NB] = {
392 G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_POINTER};
393 GtkCellRenderer *renderer;
394 GtkTreeViewColumn *column;
395 GtkTreeModel *model;
396 GtkTreeIter iter;
397 GList *item;
398 gchar *tooltip = NULL;
399 gboolean editable = TRUE;
400
401 label = gtk_label_new (_(prop->info->name));
402
403 editable = prop->info->flags & ANJUTA_PROJECT_PROPERTY_READ_ONLY ? FALSE : TRUE;
404
405 if (prop->info->description != NULL)
406 {
407 if (!editable)
408 {
409 tooltip = g_strconcat (_(prop->info->description), _(" This property is not modifiable."), NULL);
410 }
411 else
412 {
413 tooltip = g_strdup (_(prop->info->description));
414 }
415 }
416
417 if (tooltip != NULL)
418 {
419 gtk_widget_set_tooltip_markup (label, tooltip);
420 }
421 gtk_misc_set_alignment (GTK_MISC (label), 0, -1);
422 gtk_widget_show (label);
423 gtk_grid_attach (GTK_GRID (table), label, 0, *position, 1, 1);
424
425 switch (prop->info->type)
426 {
427 case ANJUTA_PROJECT_PROPERTY_STRING:
428 case ANJUTA_PROJECT_PROPERTY_LIST:
429 if (editable)
430 {
431 entry = gtk_entry_new ();
432 gtk_entry_set_text (GTK_ENTRY (entry), prop->value != NULL ? prop->value : "");
433 }
434 else
435 {
436 entry = gtk_label_new (prop->value != NULL ? prop->value : "");
437 gtk_misc_set_alignment (GTK_MISC (entry), 0, 0.5);
438 }
439 break;
440 case ANJUTA_PROJECT_PROPERTY_BOOLEAN:
441 entry = gtk_check_button_new ();
442 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (entry), (prop->value != NULL) && (*prop->value == '1'));
443 gtk_widget_set_sensitive (entry, editable);
444 break;
445 case ANJUTA_PROJECT_PROPERTY_MAP:
446 model = GTK_TREE_MODEL (gtk_list_store_newv (LIST_COLUMNS_NB, column_type));
447
448 for (item = anjuta_project_node_get_properties (node); item != NULL; item = g_list_next (item))
449 {
450 AnjutaProjectProperty *cust_prop = (AnjutaProjectProperty *)item->data;
451
452 if (cust_prop->info == prop->info)
453 {
454 gtk_list_store_append (GTK_LIST_STORE (model), &iter);
455 gtk_list_store_set (GTK_LIST_STORE (model), &iter,
456 NAME_COLUMN, cust_prop->name,
457 VALUE_COLUMN, cust_prop->value,
458 EDITABLE_COLUMN, TRUE,
459 PROPERTY_COLUMN, cust_prop,
460 -1);
461 }
462 }
463
464 gtk_list_store_append (GTK_LIST_STORE (model), &iter);
465 gtk_list_store_set (GTK_LIST_STORE (model), &iter,
466 NAME_COLUMN, "",
467 VALUE_COLUMN, "",
468 EDITABLE_COLUMN, TRUE,
469 PROPERTY_COLUMN, NULL,
470 -1);
471
472 entry = gtk_frame_new (NULL);
473 gtk_frame_set_shadow_type (GTK_FRAME (entry), GTK_SHADOW_IN);
474
475 view = gtk_tree_view_new_with_model (model);
476 gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (view)),
477 GTK_SELECTION_SINGLE);
478 gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW (view), TRUE);
479 g_object_unref (G_OBJECT (model));
480
481 renderer = gtk_cell_renderer_text_new ();
482 column = gtk_tree_view_column_new_with_attributes (_("Name"),
483 renderer,
484 "text",
485 NAME_COLUMN,
486 NULL);
487 gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
488 gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
489 renderer = gtk_cell_renderer_text_new ();
490 column = gtk_tree_view_column_new_with_attributes (_("Value"),
491 renderer,
492 "text",
493 VALUE_COLUMN,
494 "editable",
495 EDITABLE_COLUMN,
496 NULL);
497 g_signal_connect(renderer, "edited", (GCallback) on_value_edited, view);
498 gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
499 gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
500
501 gtk_container_add (GTK_CONTAINER (entry), view);
502
503 break;
504 default:
505 return NULL;
506 }
507 if (tooltip != NULL)
508 {
509 gtk_widget_set_tooltip_markup (entry, tooltip);
510 }
511 g_free (tooltip);
512
513 gtk_widget_set_hexpand (entry, TRUE);
514 gtk_grid_attach (GTK_GRID (table), entry, 1, *position, 1, 1);
515 gtk_widget_show (entry);
516
517 *position = *position + 1;
518
519 return entry;
520 }
521
522 static void
523 add_label (const gchar *display_name, const gchar *value, GtkWidget *table, gint *position)
524 {
525 GtkWidget *label;
526
527 label = gtk_label_new (display_name);
528 gtk_misc_set_alignment (GTK_MISC (label), 0, -1);
529 gtk_widget_show (label);
530 gtk_grid_attach (GTK_GRID (table), label, 0, *position, 1, 1);
531
532 label = gtk_label_new (value);
533 gtk_misc_set_alignment (GTK_MISC (label), 0, -1);
534 gtk_widget_set_hexpand (label, TRUE);
535 gtk_widget_show (label);
536 gtk_grid_attach (GTK_GRID (table), label, 1, *position, 1, 1);
537
538 *position = *position + 1;
539 }
540
541 static void
542 add_button (const gchar *display_name, const gchar *value, GCallback on_clicked, PropertiesTable *properties, GtkWidget *table, gint *position)
543 {
544 GtkWidget *label;
545 GtkWidget *button;
546
547 label = gtk_label_new (display_name);
548 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
549 gtk_widget_show (label);
550 gtk_grid_attach (GTK_GRID (table), label, 0, *position, 1, 1);
551
552 button = gtk_button_new_with_label (value);
553 gtk_button_set_alignment (GTK_BUTTON (button), 0, 0.5);
554 gtk_widget_show (button);
555 gtk_grid_attach (GTK_GRID (table), button, 1, *position, 1, 1);
556 if (on_clicked != NULL)
557 {
558 g_signal_connect (G_OBJECT (button), "clicked", on_clicked, properties);
559 }
560
561 *position = *position + 1;
562 }
563
564 static void
565 pm_project_resize_properties_dialog (PropertiesTable *table)
566 {
567 gint border_width, maximum_width, maximum_height;
568 GtkRequisition dialog, head, viewport, scrolledwindow_minimum, vscrollbar_minimum;
569 GtkWidget *vscrollbar = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (table->scrolledwindow));
570
571 gtk_widget_get_preferred_size (table->dialog, NULL, &dialog);
572 gtk_widget_get_preferred_size (table->head, NULL, &head);
573 gtk_widget_get_preferred_size (table->viewport, NULL, &viewport);
574 gtk_widget_get_preferred_size (table->scrolledwindow, &scrolledwindow_minimum, NULL);
575 gtk_widget_get_preferred_size (vscrollbar, &vscrollbar_minimum, NULL);
576
577 //auxiliary variables
578 border_width = dialog.width - head.width;
579 maximum_width = gdk_screen_width() * 3/4;
580 maximum_height = gdk_screen_height() * 3/4;
581
582 gint height = dialog.height - scrolledwindow_minimum.height + viewport.height;
583 gint width = (head.width > viewport.width) ? dialog.width : viewport.width + vscrollbar_minimum.width + border_width;
584
585 if (height > maximum_height)
586 height = maximum_height;
587
588 if (width > maximum_width)
589 width = maximum_width;
590
591 gtk_window_resize (GTK_WINDOW (table->dialog), width, height);
592 }
593
594 static void
595 on_change_project_backend (GtkButton *button,
596 gpointer user_data)
597 {
598 PropertiesTable *table = (PropertiesTable *)user_data;
599 AnjutaPluginManager *plugin_manager;
600 GList *handles = NULL;
601 GList *node;
602 AnjutaPluginHandle *backend;
603
604 /* Search for all valid project backend */
605 plugin_manager = anjuta_shell_get_plugin_manager (ANJUTA_PLUGIN(table->project->plugin)->shell, NULL);
606 handles = anjuta_plugin_manager_query (plugin_manager,
607 "Anjuta Plugin",
608 "Interfaces",
609 "IAnjutaProjectBackend",
610 NULL);
611 for (node = g_list_first (handles); node != NULL;) {
612 IAnjutaProjectBackend *plugin;
613 GList *next;
614
615 backend = (AnjutaPluginHandle *)node->data;
616 plugin = (IAnjutaProjectBackend *)anjuta_plugin_manager_get_plugin_by_handle (plugin_manager, backend);
617
618 next = g_list_next (node);
619
620 /* Probe the project directory to find if the backend can handle it */
621 if (ianjuta_project_backend_probe (plugin, anjuta_project_node_get_file (table->node), NULL) <= 0)
622 {
623 /* Remove invalid backend */
624 handles = g_list_delete_link (handles, node);
625 }
626
627 node = next;
628 }
629
630 if (handles != NULL)
631 {
632 /* Move the current backend at the beginning of the list */
633 backend = anjuta_pm_project_get_backend (table->project);
634 for (node = g_list_first (handles); node != NULL; node = g_list_next (node)) {
635 if (node->data == backend)
636 {
637 handles = g_list_remove_link (handles, node);
638 handles = g_list_concat (node, handles);
639 break;
640 }
641 }
642
643 /* Several backend are possible, ask the user to select one */
644 gchar* message = g_strdup_printf (_("Please select a project backend to use."));
645
646 backend = anjuta_plugin_manager_select (plugin_manager,
647 _("Open With"),
648 message,
649 handles);
650 g_free (message);
651 g_list_free (handles);
652
653 if (backend != NULL)
654 {
655 gtk_button_set_label (button, anjuta_plugin_handle_get_name (backend));
656 table->new_backend = backend;
657 }
658 }
659 }
660
661 static void
662 update_properties (PropertiesTable *table)
663 {
664 GFile *file;
665 const gchar *title;
666 gint head_pos;
667 gint main_pos;
668 gint extra_pos;
669 const GList *item;
670 AnjutaProjectNodeType type;
671 AnjutaProjectNodeInfo* node_info;
672 gboolean single;
673 GList *children;
674
675 head_pos = 0;
676 main_pos = 0;
677 extra_pos = 0;
678
679 /* Update dialog type */
680 switch (anjuta_project_node_get_node_type (table->node))
681 {
682 case ANJUTA_PROJECT_ROOT:
683 title = _("Project properties");
684 break;
685 case ANJUTA_PROJECT_GROUP:
686 if ((anjuta_project_node_get_full_type (table->node) & ANJUTA_PROJECT_ID_MASK) == ANJUTA_PROJECT_ROOT_GROUP)
687 {
688 title = _("Project properties");
689 }
690 else
691 {
692 title = _("Folder properties");
693 }
694 break;
695 case ANJUTA_PROJECT_TARGET:
696 title = _("Target properties");
697 break;
698 case ANJUTA_PROJECT_SOURCE:
699 title = _("Source properties");
700 break;
701 case ANJUTA_PROJECT_MODULE:
702 title = _("Module properties");
703 break;
704 case ANJUTA_PROJECT_PACKAGE:
705 title = _("Package properties");
706 break;
707 default:
708 title = _("Unknown properties");
709 break;
710 }
711 gtk_window_set_title (GTK_WINDOW (table->dialog), title);
712
713 /* Clear table */
714 children = gtk_container_get_children (GTK_CONTAINER (table->head));
715 g_list_foreach (children, (GFunc)gtk_widget_destroy, NULL);
716 g_list_free (children);
717 children = gtk_container_get_children (GTK_CONTAINER (table->main));
718 g_list_foreach (children, (GFunc)gtk_widget_destroy, NULL);
719 g_list_free (children);
720 children = gtk_container_get_children (GTK_CONTAINER (table->extra));
721 g_list_foreach (children, (GFunc)gtk_widget_destroy, NULL);
722 g_list_free (children);
723 g_list_foreach (table->properties, (GFunc)pm_property_entry_free, NULL);
724 g_list_free (table->properties);
725 table->properties = NULL;
726
727 /* Display project backend if the root node is selected */
728 if ((anjuta_project_node_get_node_type (table->node) == ANJUTA_PROJECT_ROOT) ||
729 ((anjuta_project_node_get_full_type (table->node) & ANJUTA_PROJECT_ID_MASK) == ANJUTA_PROJECT_ROOT_GROUP))
730 {
731 AnjutaPluginHandle *backend;
732
733 backend = anjuta_pm_project_get_backend (table->project);
734 if (backend)
735 {
736 const gchar *name = anjuta_plugin_handle_get_name (backend);
737 add_button (_("Backend:"), name, G_CALLBACK (on_change_project_backend), table, table->head, &head_pos);
738 }
739 }
740
741 /* Update node name */
742 file = anjuta_project_node_get_file (table->node);
743 if (file != NULL)
744 {
745 gchar *path;
746
747 path = g_file_get_path (file);
748 add_label (_("Path:"), path, table->head, &head_pos);
749 g_free (path);
750 }
751 else
752 {
753 add_label (_("Name:"), anjuta_project_node_get_name (table->node), table->head, &head_pos);
754 }
755
756 /* Display node type only if several types are possible */
757 node_info = NULL;
758 single = TRUE;
759 type = anjuta_project_node_get_full_type (table->node);
760 for (item = ianjuta_project_get_node_info (table->project->project, NULL); item != NULL; item = g_list_next (item))
761 {
762 AnjutaProjectNodeInfo* info = (AnjutaProjectNodeInfo *)item->data;
763
764 if (info->type == type)
765 {
766 node_info = info;
767 }
768 else if ((info->type & ANJUTA_PROJECT_TYPE_MASK) == (type & ANJUTA_PROJECT_TYPE_MASK))
769 {
770 single = FALSE;
771 }
772 }
773 if (!single && (node_info != NULL))
774 {
775 add_label (_("Type:"), anjuta_project_node_info_name (node_info), table->main, &main_pos);
776 }
777
778 /* Show help button if existing */
779 if ((node_info != NULL) && (anjuta_project_node_info_property_help_id (node_info) != NULL))
780 {
781 table->help_id = anjuta_project_node_info_property_help_id (node_info);
782 gtk_widget_show (table->help_button);
783 }
784 else
785 {
786 table->help_id = NULL;
787 gtk_widget_hide (table->help_button);
788 }
789
790 /* Display other node properties */
791 single = FALSE;
792
793 for (item = anjuta_project_node_get_properties_info (table->node); item != NULL; item = g_list_next (item))
794 {
795 AnjutaProjectPropertyInfo *info = (AnjutaProjectPropertyInfo *)item->data;
796
797 if (!(info->flags & ANJUTA_PROJECT_PROPERTY_HIDDEN))
798 {
799 AnjutaProjectProperty *prop;
800 GtkWidget *entry;
801
802 prop = anjuta_project_node_get_property (table->node, info->id);
803 if (prop != prop->info->default_value)
804 {
805 /* This property has been set, display it in the main part */
806 entry = add_entry (table->project->project, table->node, prop, table->main, &main_pos);
807 }
808 else
809 {
810 /* This property has not been set, hide it by default */
811 entry = add_entry (table->project->project, table->node, info->default_value, table->extra, &extra_pos);
812 single = TRUE;
813 }
814
815 if (entry != NULL)
816 {
817 table->properties = g_list_prepend (table->properties,
818 pm_property_entry_new (entry, info));
819 }
820 }
821 }
822 table->properties = g_list_reverse (table->properties);
823 gtk_widget_show_all (table->table);
824
825 /* Hide expander if it is empty */
826 if (single)
827 gtk_widget_show (table->expand);
828 else
829 gtk_widget_hide (table->expand);
830
831 pm_project_resize_properties_dialog (table);
832 }
833
834 static void
835 on_properties_dialog_response (GtkWidget *dialog,
836 gint id,
837 PropertiesTable *table)
838 {
839 if (id == GTK_RESPONSE_APPLY)
840 {
841 GList *item;
842
843 /* Get all modified properties */
844 for (item = g_list_first (table->properties); item != NULL; item = g_list_next (item))
845 {
846 PropertyEntry *entry = (PropertyEntry *)item->data;
847 AnjutaProjectProperty *prop;
848 const gchar *text;
849 gboolean valid;
850 gboolean active;
851 GtkTreeIter iter;
852 GtkTreeModel *model;
853
854 /* Get property value in node */
855 prop = anjuta_project_node_get_property (table->node, entry->info->id);
856
857 switch (prop->info->type)
858 {
859 case ANJUTA_PROJECT_PROPERTY_STRING:
860 case ANJUTA_PROJECT_PROPERTY_LIST:
861 if (GTK_IS_ENTRY (entry->entry))
862 {
863 text = gtk_entry_get_text (GTK_ENTRY (entry->entry));
864 if (*text == '\0')
865 {
866 if ((prop->value != NULL) && (*prop->value != '\0'))
867 {
868 /* Remove */
869 ianjuta_project_set_property (table->project->project, table->node, entry->info->id, NULL, NULL, NULL);
870 }
871 }
872 else
873 {
874 if (g_strcmp0 (prop->value, text) != 0)
875 {
876 /* Modified */
877 ianjuta_project_set_property (table->project->project, table->node, entry->info->id, NULL, text, NULL);
878 }
879 }
880 }
881 break;
882 case ANJUTA_PROJECT_PROPERTY_BOOLEAN:
883 active = prop->value == NULL ? FALSE : (*prop->value == '1' ? TRUE : FALSE);
884 text = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (entry->entry)) ? "1" : "0";
885
886 if (active != (*text == '1'))
887 {
888 /* Modified */
889 ianjuta_project_set_property (table->project->project, table->node, entry->info->id, NULL, text, NULL);
890 }
891 break;
892 case ANJUTA_PROJECT_PROPERTY_MAP:
893 model = gtk_tree_view_get_model (GTK_TREE_VIEW (gtk_bin_get_child (GTK_BIN (entry->entry))));
894 for (valid = gtk_tree_model_get_iter_first (model, &iter); valid; valid = gtk_tree_model_iter_next (model, &iter))
895 {
896 AnjutaProjectProperty *cust_prop;
897 gchar *value;
898
899 value = NULL;
900 cust_prop = NULL;
901 gtk_tree_model_get (model, &iter, VALUE_COLUMN, &value, PROPERTY_COLUMN, &cust_prop, -1);
902 if ((cust_prop != NULL) && (g_strcmp0 (cust_prop->value, value) != 0))
903 {
904 /* Modified */
905 ianjuta_project_set_property (table->project->project, table->node, entry->info->id, cust_prop->name, value, NULL);
906 }
907 g_free (value);
908 }
909 break;
910 default:
911 break;
912 }
913 }
914
915 /* Update backend if needed */
916 if ((table->new_backend != NULL) && (table->new_backend != anjuta_pm_project_get_backend (table->project)))
917 {
918 GFile *root;
919 AnjutaStatus *status;
920 gchar *path;
921
922 change_project_backend (ANJUTA_PLUGIN_PROJECT_MANAGER (table->project->plugin), table->new_backend);
923
924 root = g_object_ref (anjuta_project_node_get_file (table->node));
925 path = g_file_get_path (root);
926
927 status = anjuta_shell_get_status (table->project->plugin->shell, NULL);
928 anjuta_status_progress_add_ticks (status, 1);
929 anjuta_status_push (status, _("Reloading project: %s"), path);
930 g_free (path);
931 anjuta_status_busy_push (status);
932 ANJUTA_PLUGIN_PROJECT_MANAGER (table->project->plugin)->busy = TRUE;
933 anjuta_pm_project_unload (table->project, NULL);
934 anjuta_pm_project_load_with_backend (table->project, root, table->new_backend, NULL);
935 g_object_unref (root);
936 }
937 }
938 else if (id == GTK_RESPONSE_HELP)
939 {
940 anjuta_util_help_display (GTK_WIDGET (dialog), ANJUTA_MANUAL, table->help_id);
941 return;
942 }
943 g_list_foreach (table->properties, (GFunc)pm_property_entry_free, NULL);
944 g_free (table);
945 gtk_widget_destroy (dialog);
946 }
947
948 static void
949 on_node_changed (AnjutaTreeComboBox *view,
950 gpointer user_data)
951 {
952 PropertiesTable *table = (PropertiesTable *)user_data;
953 GtkTreeIter iter;
954
955 if (anjuta_tree_combo_box_get_active_iter (view, &iter))
956 {
957 GtkTreeModel *model;
958 GbfTreeData *data;
959
960 model = anjuta_tree_combo_box_get_model (view);
961 gtk_tree_model_get (model, &iter, GBF_PROJECT_MODEL_COLUMN_DATA, &data, -1);
962
963 if (table->data->properties_dialog != NULL)
964 {
965 g_object_remove_weak_pointer (G_OBJECT (table->dialog), (gpointer *)&table->data->properties_dialog);
966 table->data->properties_dialog = NULL;
967 }
968 if (data->properties_dialog != NULL)
969 {
970 g_object_unref (data->properties_dialog);
971 }
972 table->data = data;
973 data->properties_dialog = table->dialog;
974 g_object_add_weak_pointer (G_OBJECT (table->dialog), (gpointer *)&table->data->properties_dialog);
975
976 table->node = gbf_tree_data_get_node (data);
977 update_properties (table);
978 }
979 }
980
981 static void
982 on_expand_changed (GtkWidget * widget, gpointer user_data)
983 {
984 PropertiesTable *table = (PropertiesTable *)user_data;
985 pm_project_resize_properties_dialog (table);
986 }
987
988 static GtkWidget *
989 pm_project_create_properties_dialog (AnjutaPmProject *project, GtkWindow *parent, GbfProjectView *view, GbfTreeData *data, GtkTreeIter *selected)
990 {
991 PropertiesTable *table;
992 GtkBuilder *bxml;
993 GtkWidget *node_combo;
994 GtkTreeIter iter;
995
996 g_return_val_if_fail (data != NULL, NULL);
997
998 bxml = anjuta_util_builder_new (GLADE_FILE, NULL);
999 if (!bxml) return NULL;
1000
1001 table = g_new0 (PropertiesTable, 1);
1002 table->data = data;
1003 table->node = gbf_tree_data_get_node (data);
1004 table->project = project;
1005 table->new_backend = NULL;
1006 anjuta_util_builder_get_objects (bxml,
1007 "property_dialog", &table->dialog,
1008 "properties", &table->table,
1009 "nodes_combo", &node_combo,
1010 "head_table", &table->head,
1011 "main_table", &table->main,
1012 "extra_table", &table->extra,
1013 "extra_expand", &table->expand,
1014 "viewport", &table->viewport,
1015 "scrolledwindow", &table->scrolledwindow,
1016 "property_help_button", &table->help_button,
1017 NULL);
1018 g_object_ref (table->table);
1019 g_object_unref (bxml);
1020
1021 /* Add combo node selection */
1022 ianjuta_project_chooser_set_project_model (IANJUTA_PROJECT_CHOOSER (node_combo),
1023 IANJUTA_PROJECT_MANAGER (table->project->plugin),
1024 ANJUTA_PROJECT_ROOT,
1025 NULL);
1026 if (pm_convert_project_iter_to_model_iter (GTK_TREE_MODEL (anjuta_tree_combo_box_get_model (ANJUTA_TREE_COMBO_BOX (node_combo))),
1027 &iter, selected))
1028 {
1029 anjuta_tree_combo_box_set_active_iter (ANJUTA_TREE_COMBO_BOX (node_combo), &iter);
1030 }
1031 g_signal_connect (node_combo, "changed",
1032 G_CALLBACK (on_node_changed),
1033 table);
1034
1035 g_signal_connect_after (table->expand, "activate",
1036 G_CALLBACK (on_expand_changed),
1037 table);
1038
1039 update_properties (table);
1040
1041 g_signal_connect (table->dialog, "response",
1042 G_CALLBACK (on_properties_dialog_response),
1043 table);
1044
1045 pm_project_resize_properties_dialog (table);
1046 gtk_widget_show (table->dialog);
1047
1048 return table->dialog;
1049 }
1050
1051 /* Properties dialog
1052 *---------------------------------------------------------------------------*/
1053
1054 /* Display properties dialog. These dialogs are not modal, so a pointer on each
1055 * dialog is kept with in node data to be able to destroy them if the node is
1056 * removed. It is useful to put the dialog at the top if the same target is
1057 * selected while the corresponding dialog already exist instead of creating
1058 * two times the same dialog.
1059 * The project properties dialog is display if the node iterator is NULL. */
1060
1061 gboolean
1062 anjuta_pm_project_show_properties_dialog (ProjectManagerPlugin *plugin, GtkTreeIter *selected)
1063 {
1064 GtkWidget **dialog_ptr;
1065 GtkTreeIter iter;
1066
1067 if (selected == NULL)
1068 {
1069 /* Display root properties by default */
1070 if (gbf_project_view_get_project_root (plugin->view, &iter))
1071 {
1072 selected = &iter;
1073 }
1074 }
1075
1076 if (selected)
1077 {
1078 GbfTreeData *data;
1079
1080 gtk_tree_model_get (GTK_TREE_MODEL (gbf_project_view_get_model (plugin->view)), selected, GBF_PROJECT_MODEL_COLUMN_DATA, &data, -1);
1081 dialog_ptr = &data->properties_dialog;
1082
1083 if (*dialog_ptr != NULL)
1084 {
1085 /* Show already existing dialog */
1086 gtk_window_present (GTK_WINDOW (*dialog_ptr));
1087 }
1088 else
1089 {
1090 *dialog_ptr = pm_project_create_properties_dialog (
1091 plugin->project,
1092 GTK_WINDOW (plugin->project->plugin->shell),
1093 plugin->view,
1094 data,
1095 selected);
1096 if (*dialog_ptr != NULL)
1097 {
1098 g_object_add_weak_pointer (G_OBJECT (*dialog_ptr), (gpointer *)dialog_ptr);
1099 }
1100 }
1101 }
1102
1103 return selected != NULL;
1104 }
1105
1106
1107
1108 /* Group dialog
1109 *---------------------------------------------------------------------------*/
1110
1111 AnjutaProjectNode*
1112 anjuta_pm_project_new_group (ProjectManagerPlugin *plugin, GtkWindow *parent, GtkTreeIter *selected, const gchar *default_name)
1113 {
1114 GtkBuilder *gui;
1115 GtkWidget *dialog, *group_name_entry, *ok_button;
1116 GtkWidget *groups_view;
1117 gint response;
1118 gboolean finished = FALSE;
1119 AnjutaProjectNode *new_group = NULL;
1120
1121 g_return_val_if_fail (plugin->project != NULL, NULL);
1122
1123 gui = load_interface ("new_group_dialog");
1124 g_return_val_if_fail (gui != NULL, NULL);
1125
1126 /* get all needed widgets */
1127 dialog = GTK_WIDGET (gtk_builder_get_object (gui, "new_group_dialog"));
1128 groups_view = GTK_WIDGET (gtk_builder_get_object (gui, "groups_view"));
1129 group_name_entry = GTK_WIDGET (gtk_builder_get_object (gui, "group_name_entry"));
1130 ok_button = GTK_WIDGET (gtk_builder_get_object (gui, "ok_group_button"));
1131
1132 /* set up dialog */
1133 if (default_name)
1134 gtk_entry_set_text (GTK_ENTRY (group_name_entry),
1135 default_name);
1136 g_signal_connect (group_name_entry, "changed",
1137 (GCallback) entry_changed_cb, ok_button);
1138 if (default_name)
1139 gtk_widget_set_sensitive (ok_button, TRUE);
1140 else
1141 gtk_widget_set_sensitive (ok_button, FALSE);
1142
1143 setup_nodes_treeview (GBF_PROJECT_VIEW (groups_view),
1144 plugin->view,
1145 NULL,
1146 parent_filter_func,
1147 GINT_TO_POINTER (ANJUTA_PROJECT_GROUP),
1148 selected);
1149 gtk_widget_show (groups_view);
1150
1151 if (parent)
1152 {
1153 gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
1154 }
1155
1156 /* execute dialog */
1157 while (!finished)
1158 {
1159 response = gtk_dialog_run (GTK_DIALOG (dialog));
1160
1161 switch (response) {
1162 case GTK_RESPONSE_OK:
1163 {
1164 GError *err = NULL;
1165 AnjutaProjectNode *group;
1166 gchar *name;
1167
1168 name = gtk_editable_get_chars (
1169 GTK_EDITABLE (group_name_entry), 0, -1);
1170
1171 group = gbf_project_view_find_selected_state (GTK_TREE_VIEW (groups_view),
1172 ANJUTA_PROJECT_CAN_ADD_GROUP);
1173 if (group)
1174 {
1175 new_group = anjuta_pm_project_add_group (plugin->project, group, NULL, name, &err);
1176 if (err)
1177 {
1178 error_dialog (parent, _("Cannot add group"), "%s",
1179 err->message);
1180 g_error_free (err);
1181 }
1182 else
1183 {
1184 finished = TRUE;
1185 }
1186 }
1187 else
1188 {
1189 error_dialog (parent, _("Cannot add group"),
1190 "%s", _("No parent group selected"));
1191 }
1192 g_free (name);
1193 break;
1194 }
1195 case GTK_RESPONSE_HELP:
1196 anjuta_util_help_display (GTK_WIDGET (dialog), ANJUTA_MANUAL, ADD_FOLDER_HELP);
1197 break;
1198 default:
1199 finished = TRUE;
1200 break;
1201 }
1202 }
1203
1204 /* destroy stuff */
1205 gtk_widget_destroy (dialog);
1206 g_object_unref (gui);
1207
1208 return new_group;
1209 }
1210
1211 /* Source dialog
1212 *---------------------------------------------------------------------------*/
1213
1214 AnjutaProjectNode*
1215 anjuta_pm_project_new_source (ProjectManagerPlugin *plugin,
1216 GtkWindow *parent,
1217 GtkTreeIter *default_parent,
1218 const gchar *default_uri)
1219 {
1220 GList* new_sources;
1221 gchar* uri = NULL;
1222 GList* uris = NULL;
1223
1224 if (default_uri)
1225 {
1226 uri = g_strdup (default_uri);
1227 uris = g_list_append (NULL, uri);
1228 }
1229 new_sources =
1230 anjuta_pm_project_new_multiple_source (plugin, parent,
1231 default_parent, uris);
1232 g_free (uri);
1233 g_list_free (uris);
1234
1235 if (new_sources && g_list_length (new_sources))
1236 {
1237 AnjutaProjectNode *new_source = new_sources->data;
1238 g_list_free (new_sources);
1239 return new_source;
1240 }
1241 else
1242 return NULL;
1243 }
1244
1245 static void
1246 on_target_changed (GtkWidget *chooser, GtkWidget *button)
1247 {
1248 GFile *file;
1249
1250 file = ianjuta_project_chooser_get_selected (IANJUTA_PROJECT_CHOOSER (chooser), NULL);
1251 gtk_widget_set_sensitive (button, file != NULL);
1252 }
1253
1254 GList*
1255 anjuta_pm_add_source_dialog (ProjectManagerPlugin *plugin,
1256 GtkWindow *top_window,
1257 GtkTreeIter *default_target,
1258 GFile *default_source)
1259 {
1260 GtkBuilder *gui;
1261 GtkWidget *dialog;
1262 GtkWidget *ok_button;
1263 GtkWidget *target_chooser;
1264 GtkWidget *source_chooser;
1265 gint response;
1266 gboolean finished = FALSE;
1267 GList *sources = NULL;
1268
1269 g_return_val_if_fail (plugin->project != NULL, NULL);
1270
1271 gui = load_interface ("add_source_dialog");
1272 g_return_val_if_fail (gui != NULL, NULL);
1273
1274 /* get all needed widgets */
1275 dialog = GTK_WIDGET (gtk_builder_get_object (gui, "add_source_dialog"));
1276 target_chooser = GTK_WIDGET (gtk_builder_get_object (gui, "target_chooser"));
1277 source_chooser = GTK_WIDGET (gtk_builder_get_object (gui, "source_chooser"));
1278 ok_button = GTK_WIDGET (gtk_builder_get_object (gui, "ok_add_source_button"));
1279
1280 /* Fill target selection */
1281 ianjuta_project_chooser_set_project_model (IANJUTA_PROJECT_CHOOSER (target_chooser),
1282 IANJUTA_PROJECT_MANAGER (plugin),
1283 ANJUTA_PROJECT_SOURCE,
1284 NULL);
1285 if (default_target != NULL)
1286 {
1287 GtkTreeIter iter;
1288 if (pm_convert_project_iter_to_model_iter (GTK_TREE_MODEL (anjuta_tree_combo_box_get_model (ANJUTA_TREE_COMBO_BOX (target_chooser))),
1289 &iter, default_target))
1290 {
1291 anjuta_tree_combo_box_set_active_iter (ANJUTA_TREE_COMBO_BOX (target_chooser), &iter);
1292 }
1293 }
1294 g_signal_connect (target_chooser, "changed",
1295 G_CALLBACK (on_target_changed),
1296 ok_button);
1297 on_target_changed (target_chooser, ok_button);
1298
1299 /* Selected default file */
1300 if (default_source != NULL) gtk_file_chooser_set_file (GTK_FILE_CHOOSER (source_chooser), default_source, NULL);
1301
1302 if (top_window) {
1303 gtk_window_set_transient_for (GTK_WINDOW (dialog), top_window);
1304 }
1305
1306 /* execute dialog */
1307 while (!finished) {
1308 response = gtk_dialog_run (GTK_DIALOG (dialog));
1309
1310 switch (response)
1311 {
1312 case GTK_RESPONSE_OK:
1313 {
1314 GFile *target_file;
1315 AnjutaProjectNode *target;
1316 GSList *files;
1317
1318 target_file = ianjuta_project_chooser_get_selected (IANJUTA_PROJECT_CHOOSER (target_chooser), NULL);
1319 target = gbf_project_view_get_node_from_file (plugin->view, ANJUTA_PROJECT_UNKNOWN, target_file);
1320 files = gtk_file_chooser_get_files (GTK_FILE_CHOOSER (source_chooser));
1321 if ((target != NULL) && (files != NULL))
1322 {
1323 GString *err_mesg = g_string_new (NULL);
1324 GSList *item;
1325
1326 for (item = files; item != NULL; item = g_slist_next (item))
1327 {
1328 gchar *path = g_file_get_path ((GFile *)item->data);
1329 GError *err = NULL;
1330 AnjutaProjectNode *node;
1331
1332 node = anjuta_pm_project_add_source (plugin->project,
1333 target,
1334 NULL,
1335 path,
1336 &err);
1337 sources = g_list_prepend (sources, node);
1338 if (err) {
1339 gchar *str = g_strdup_printf ("%s: %s\n",
1340 path,
1341 err->message);
1342 g_string_append (err_mesg, str);
1343 g_error_free (err);
1344 g_free (str);
1345 }
1346 g_free (path);
1347 }
1348 if (err_mesg->str && strlen (err_mesg->str) > 0)
1349 {
1350 error_dialog (top_window, _("Cannot add source files"),
1351 "%s", err_mesg->str);
1352 }
1353 else {
1354 finished = TRUE;
1355 }
1356 g_string_free (err_mesg, TRUE);
1357 g_slist_foreach (files, (GFunc)g_object_unref, NULL);
1358 g_slist_free (files);
1359 }
1360 else
1361 {
1362 error_dialog (top_window, _("Cannot add source files"),
1363 "%s", _("The selected node cannot contain source files."));
1364 }
1365 break;
1366 }
1367 case GTK_RESPONSE_HELP:
1368 anjuta_util_help_display (GTK_WIDGET (dialog), ANJUTA_MANUAL, ADD_SOURCE_HELP);
1369 break;
1370 default:
1371 finished = TRUE;
1372 break;
1373 }
1374 }
1375
1376 /* destroy stuff */
1377 gtk_widget_destroy (dialog);
1378 g_object_unref (gui);
1379
1380 sources = g_list_reverse (sources);
1381 return sources;
1382 }
1383
1384
1385 GList*
1386 anjuta_pm_project_new_multiple_source (ProjectManagerPlugin *plugin,
1387 GtkWindow *top_window,
1388 GtkTreeIter *default_parent,
1389 GList *uris_to_add)
1390 {
1391 GtkBuilder *gui;
1392 GtkWidget *dialog, *source_file_tree;
1393 GtkWidget *ok_button, *browse_button;
1394 GtkWidget *targets_view;
1395 gint response;
1396 gboolean finished = FALSE;
1397 GtkListStore* list;
1398 GtkCellRenderer* renderer;
1399 GtkTreeViewColumn* column_filename;
1400 GList* new_sources = NULL;
1401 GList* uri_node;
1402 GtkTreePath *root;
1403
1404 g_return_val_if_fail (plugin->project != NULL, NULL);
1405
1406 gui = load_interface ("new_source_dialog");
1407 g_return_val_if_fail (gui != NULL, NULL);
1408
1409 /* get all needed widgets */
1410 dialog = GTK_WIDGET (gtk_builder_get_object (gui, "new_source_dialog"));
1411 targets_view = GTK_WIDGET (gtk_builder_get_object (gui, "targets_view"));
1412 source_file_tree = GTK_WIDGET (gtk_builder_get_object (gui, "source_file_tree"));
1413 browse_button = GTK_WIDGET (gtk_builder_get_object (gui, "browse_button"));
1414 ok_button = GTK_WIDGET (gtk_builder_get_object (gui, "ok_source_button"));
1415
1416 /* Prepare file tree */
1417 list = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING);
1418 gtk_tree_view_set_model (GTK_TREE_VIEW (source_file_tree),
1419 GTK_TREE_MODEL (list));
1420 renderer = gtk_cell_renderer_text_new ();
1421 column_filename = gtk_tree_view_column_new_with_attributes ("Files",
1422 renderer,
1423 "text",
1424 COLUMN_FILE,
1425 NULL);
1426 gtk_tree_view_column_set_sizing (column_filename,
1427 GTK_TREE_VIEW_COLUMN_FIXED);
1428 gtk_tree_view_append_column (GTK_TREE_VIEW (source_file_tree),
1429 column_filename);
1430
1431 /* set up dialog */
1432 uri_node = uris_to_add;
1433 while (uri_node)
1434 {
1435 GtkTreeIter iter;
1436 gchar* filename = g_path_get_basename (uri_node->data);
1437 if (!filename)
1438 filename = g_strdup (uri_node->data);
1439 gtk_list_store_append (list, &iter);
1440 gtk_list_store_set (list, &iter, COLUMN_FILE, filename,
1441 COLUMN_URI, g_strdup(uri_node->data), -1);
1442 g_free (filename);
1443 uri_node = g_list_next (uri_node);
1444 }
1445 if (!g_list_length (uris_to_add))
1446 gtk_widget_set_sensitive (ok_button, FALSE);
1447 else
1448 gtk_widget_set_sensitive (ok_button, TRUE);
1449
1450 g_signal_connect (G_OBJECT(list), "row_changed",
1451 G_CALLBACK(on_row_changed), ok_button);
1452
1453 g_signal_connect (browse_button, "clicked",
1454 G_CALLBACK (browse_button_clicked_cb), source_file_tree);
1455
1456 g_object_set_data_full (G_OBJECT (browse_button), "treeview", targets_view, NULL);
1457 /*project_root = g_file_get_uri (anjuta_project_node_get_file (anjuta_pm_project_get_root (project)));
1458 g_object_set_data_full (G_OBJECT (browse_button), "root", project_root, g_free);*/
1459
1460 root = gbf_project_model_get_project_root (gbf_project_view_get_model (plugin->view));
1461 setup_nodes_treeview (GBF_PROJECT_VIEW (targets_view),
1462 plugin->view,
1463 root,
1464 parent_filter_func,
1465 GINT_TO_POINTER (ANJUTA_PROJECT_SOURCE),
1466 default_parent);
1467 gtk_tree_path_free (root);
1468 gtk_widget_show (targets_view);
1469
1470 if (top_window) {
1471 gtk_window_set_transient_for (GTK_WINDOW (dialog), top_window);
1472 }
1473
1474 if (default_parent)
1475 gtk_widget_grab_focus (source_file_tree);
1476 else
1477 gtk_widget_grab_focus (targets_view);
1478
1479 /* execute dialog */
1480 while (!finished) {
1481 response = gtk_dialog_run (GTK_DIALOG (dialog));
1482
1483 switch (response)
1484 {
1485 case GTK_RESPONSE_OK:
1486 {
1487 AnjutaProjectNode *parent = NULL;
1488 AnjutaProjectNode *sibling = NULL;
1489
1490 parent = gbf_project_view_find_selected (GBF_PROJECT_VIEW (targets_view),
1491 ANJUTA_PROJECT_UNKNOWN);
1492
1493 /* Check that selected node can be used as a parent or a sibling */
1494 if (parent)
1495 {
1496 if (!(anjuta_project_node_get_state (parent) & ANJUTA_PROJECT_CAN_ADD_SOURCE))
1497 {
1498 sibling = parent;
1499 parent = anjuta_project_node_parent (parent);
1500 }
1501 if (!(anjuta_project_node_get_state (parent) & ANJUTA_PROJECT_CAN_ADD_SOURCE))
1502 {
1503 parent = NULL;
1504 }
1505 }
1506
1507 if (parent)
1508 {
1509 GtkTreeIter iter;
1510 GString *err_mesg = g_string_new (NULL);
1511
1512 if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list),
1513 &iter))
1514 break;
1515 do
1516 {
1517 GError *err = NULL;
1518 AnjutaProjectNode* new_source;
1519 gchar* uri;
1520
1521 gtk_tree_model_get (GTK_TREE_MODEL(list), &iter,
1522 COLUMN_URI, &uri, -1);
1523
1524 new_source = anjuta_pm_project_add_source (plugin->project,
1525 parent,
1526 sibling,
1527 uri,
1528 &err);
1529 if (err) {
1530 gchar *str = g_strdup_printf ("%s: %s\n",
1531 uri,
1532 err->message);
1533 g_string_append (err_mesg, str);
1534 g_error_free (err);
1535 g_free (str);
1536 }
1537 else
1538 new_sources = g_list_append (new_sources,
1539 new_source);
1540
1541 g_free (uri);
1542 } while (gtk_tree_model_iter_next (GTK_TREE_MODEL(list),
1543 &iter));
1544
1545 if (err_mesg->str && strlen (err_mesg->str) > 0)
1546 {
1547 error_dialog (top_window, _("Cannot add source files"),
1548 "%s", err_mesg->str);
1549 }
1550 else {
1551 finished = TRUE;
1552 }
1553 g_string_free (err_mesg, TRUE);
1554 }
1555 else
1556 {
1557 error_dialog (top_window, _("Cannot add source files"),
1558 "%s", _("The selected node cannot contain source files."));
1559 }
1560 break;
1561 }
1562 case GTK_RESPONSE_HELP:
1563 anjuta_util_help_display (GTK_WIDGET (dialog), ANJUTA_MANUAL, ADD_SOURCE_HELP);
1564 break;
1565 default:
1566 gtk_list_store_clear (GTK_LIST_STORE (list));
1567 finished = TRUE;
1568 break;
1569 }
1570 }
1571
1572 /* destroy stuff */
1573 gtk_widget_destroy (dialog);
1574 g_object_unref (gui);
1575
1576 return new_sources;
1577 }
1578
1579 /* Target dialog
1580 *---------------------------------------------------------------------------*/
1581
1582 enum {
1583 TARGET_TYPE_TYPE = 0,
1584 TARGET_TYPE_NAME,
1585 TARGET_TYPE_PIXBUF,
1586 TARGET_TYPE_N_COLUMNS
1587 };
1588
1589 /* create a tree model with the target types */
1590 static GtkListStore *
1591 build_types_store (AnjutaPmProject *project, AnjutaProjectNodeType store_type)
1592 {
1593 GtkListStore *store;
1594 GtkTreeIter iter;
1595 const GList *types;
1596 const GList *node;
1597
1598 types = anjuta_pm_project_get_node_info (project);
1599 store = gtk_list_store_new (TARGET_TYPE_N_COLUMNS,
1600 G_TYPE_POINTER,
1601 G_TYPE_STRING,
1602 GDK_TYPE_PIXBUF);
1603
1604 for (node = types; node != NULL; node = g_list_next (node)) {
1605 GdkPixbuf *pixbuf;
1606 const gchar *name;
1607 AnjutaProjectNodeType type;
1608
1609 type = anjuta_project_node_info_type ((AnjutaProjectNodeInfo *)node->data);
1610 if (((store_type == 0) || ((type & ANJUTA_PROJECT_TYPE_MASK) == store_type)) && !(type & ANJUTA_PROJECT_READ_ONLY))
1611 {
1612 name = anjuta_project_node_info_name ((AnjutaProjectNodeInfo *)node->data);
1613 pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default(),
1614 GTK_STOCK_CONVERT,
1615 ICON_SIZE,
1616 0,
1617 NULL);
1618
1619 gtk_list_store_append (store, &iter);
1620 gtk_list_store_set (store, &iter,
1621 TARGET_TYPE_TYPE, type,
1622 TARGET_TYPE_NAME, name,
1623 TARGET_TYPE_PIXBUF, pixbuf,
1624 -1);
1625
1626 if (pixbuf)
1627 g_object_unref (pixbuf);
1628 }
1629 }
1630
1631 return store;
1632 }
1633
1634 AnjutaProjectNode*
1635 anjuta_pm_project_new_target (ProjectManagerPlugin *plugin,
1636 GtkWindow *parent,
1637 GtkTreeIter *default_group,
1638 const gchar *default_target_name_to_add)
1639 {
1640 GtkBuilder *gui;
1641 GtkWidget *dialog, *target_name_entry, *ok_button;
1642 GtkWidget *target_type_combo, *groups_view;
1643 GtkListStore *types_store;
1644 GtkCellRenderer *renderer;
1645 gint response;
1646 gboolean finished = FALSE;
1647 AnjutaProjectNode *new_target = NULL;
1648
1649 g_return_val_if_fail (plugin->project != NULL, NULL);
1650
1651 gui = load_interface ("new_target_dialog");
1652 g_return_val_if_fail (gui != NULL, NULL);
1653
1654 /* get all needed widgets */
1655 dialog = GTK_WIDGET (gtk_builder_get_object (gui, "new_target_dialog"));
1656 groups_view = GTK_WIDGET (gtk_builder_get_object (gui, "target_groups_view"));
1657 target_name_entry = GTK_WIDGET (gtk_builder_get_object (gui, "target_name_entry"));
1658 target_type_combo = GTK_WIDGET (gtk_builder_get_object (gui, "target_type_combo"));
1659 ok_button = GTK_WIDGET (gtk_builder_get_object (gui, "ok_target_button"));
1660
1661 /* set up dialog */
1662 if (default_target_name_to_add)
1663 gtk_entry_set_text (GTK_ENTRY (target_name_entry),
1664 default_target_name_to_add);
1665 g_signal_connect (target_name_entry, "changed",
1666 (GCallback) entry_changed_cb, ok_button);
1667 if (default_target_name_to_add)
1668 gtk_widget_set_sensitive (ok_button, TRUE);
1669 else
1670 gtk_widget_set_sensitive (ok_button, FALSE);
1671
1672 setup_nodes_treeview (GBF_PROJECT_VIEW (groups_view),
1673 plugin->view,
1674 NULL,
1675 parent_filter_func,
1676 GINT_TO_POINTER (ANJUTA_PROJECT_TARGET),
1677 default_group);
1678 gtk_widget_show (groups_view);
1679
1680 /* setup target types combo box */
1681 types_store = build_types_store (plugin->project, ANJUTA_PROJECT_TARGET);
1682 gtk_combo_box_set_model (GTK_COMBO_BOX (target_type_combo),
1683 GTK_TREE_MODEL (types_store));
1684
1685 /* create cell renderers */
1686 renderer = gtk_cell_renderer_pixbuf_new ();
1687 gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (target_type_combo),
1688 renderer, FALSE);
1689 gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (target_type_combo),
1690 renderer,
1691 "pixbuf", TARGET_TYPE_PIXBUF,
1692 NULL);
1693
1694 renderer = gtk_cell_renderer_text_new ();
1695 gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (target_type_combo),
1696 renderer, TRUE);
1697 gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (target_type_combo),
1698 renderer,
1699 "text", TARGET_TYPE_NAME,
1700 NULL);
1701 gtk_widget_show (target_type_combo);
1702
1703 /* preselect */
1704 gtk_combo_box_set_active (GTK_COMBO_BOX (target_type_combo), 0);
1705
1706 if (parent)
1707 {
1708 gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
1709 }
1710
1711 /* execute dialog */
1712 while (!finished)
1713 {
1714 response = gtk_dialog_run (GTK_DIALOG (dialog));
1715
1716 switch (response)
1717 {
1718 case GTK_RESPONSE_OK:
1719 {
1720 GError *err = NULL;
1721 AnjutaProjectNode *group;
1722 GtkTreeIter iter;
1723 gchar *name;
1724 AnjutaProjectNodeType type;
1725
1726 name = gtk_editable_get_chars (
1727 GTK_EDITABLE (target_name_entry), 0, -1);
1728 group = gbf_project_view_find_selected (GBF_PROJECT_VIEW (groups_view),
1729 ANJUTA_PROJECT_GROUP);
1730
1731 /* retrieve target type */
1732 if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (target_type_combo), &iter))
1733 {
1734 gtk_tree_model_get (GTK_TREE_MODEL (types_store), &iter,
1735 TARGET_TYPE_TYPE, &type,
1736 -1);
1737 }
1738
1739 if (group && type)
1740 {
1741 new_target = anjuta_pm_project_add_target (plugin->project, group, NULL, name, type, &err);
1742 if (err)
1743 {
1744 error_dialog (parent, _("Cannot add target"), "%s",
1745 err->message);
1746 g_error_free (err);
1747 }
1748 else
1749 {
1750 finished = TRUE;
1751 }
1752 }
1753 else
1754 {
1755 error_dialog (parent, _("Cannot add target"), "%s",
1756 _("No group selected"));
1757 }
1758
1759 g_free (name);
1760
1761 break;
1762 }
1763 case GTK_RESPONSE_HELP:
1764 anjuta_util_help_display (GTK_WIDGET (dialog), ANJUTA_MANUAL, ADD_TARGET_HELP);
1765 break;
1766 default:
1767 finished = TRUE;
1768 break;
1769 }
1770 }
1771
1772 /* destroy stuff */
1773 g_object_unref (types_store);
1774 gtk_widget_destroy (dialog);
1775 g_object_unref (gui);
1776
1777 return new_target;
1778 }
1779
1780
1781 /* Module dialog
1782 *---------------------------------------------------------------------------*/
1783
1784 static void
1785 on_cursor_changed(GtkTreeView* view, gpointer data)
1786 {
1787 GtkWidget* button = GTK_WIDGET(data);
1788 GtkTreeSelection *selection = gtk_tree_view_get_selection(view);
1789
1790 if (gtk_tree_selection_count_selected_rows (selection) > 0)
1791 gtk_widget_set_sensitive(button, TRUE);
1792 else
1793 gtk_widget_set_sensitive(button, FALSE);
1794 }
1795
1796 static void
1797 on_new_library(GtkButton *button, gpointer user_data)
1798 {
1799 ProjectManagerPlugin *plugin = ANJUTA_PLUGIN_PROJECT_MANAGER (user_data);
1800 GList *packages;
1801
1802 packages = anjuta_pm_project_new_package (plugin,
1803 get_plugin_parent_window (plugin),
1804 NULL,
1805 NULL);
1806 g_list_free (packages);
1807 }
1808
1809 GList*
1810 anjuta_pm_project_new_module (ProjectManagerPlugin *plugin,
1811 GtkWindow *parent,
1812 GtkTreeIter *default_target,
1813 const gchar *default_module)
1814 {
1815 GtkBuilder *gui;
1816 GtkWidget *dialog;
1817 GtkWidget *ok_button, *new_button;
1818 GtkWidget *target_chooser;
1819 GtkWidget *modules_view;
1820 GtkTreePath *root;
1821 gint response;
1822 gboolean finished = FALSE;
1823 GList* new_modules = NULL;
1824 GtkTreeSelection *module_selection;
1825
1826 g_return_val_if_fail (plugin->project != NULL, NULL);
1827
1828 gui = load_interface ("add_module_dialog");
1829 g_return_val_if_fail (gui != NULL, NULL);
1830
1831 /* get all needed widgets */
1832 dialog = GTK_WIDGET (gtk_builder_get_object (gui, "add_module_dialog"));
1833 target_chooser = GTK_WIDGET (gtk_builder_get_object (gui, "module_targets_chooser"));
1834 modules_view = GTK_WIDGET (gtk_builder_get_object (gui, "modules_view"));
1835 new_button = GTK_WIDGET (gtk_builder_get_object (gui, "new_package_button"));
1836 ok_button = GTK_WIDGET (gtk_builder_get_object (gui, "ok_module_button"));
1837
1838 /* Fill target selection */
1839 ianjuta_project_chooser_set_project_model (IANJUTA_PROJECT_CHOOSER (target_chooser),
1840 IANJUTA_PROJECT_MANAGER (plugin),
1841 ANJUTA_PROJECT_MODULE,
1842 NULL);
1843 gtk_widget_show (target_chooser);
1844 root = gbf_project_model_get_project_root (gbf_project_view_get_model (plugin->view));
1845 setup_nodes_treeview (GBF_PROJECT_VIEW (modules_view),
1846 plugin->view,
1847 root,
1848 module_filter_func,
1849 NULL,
1850 NULL);
1851 gtk_tree_path_free (root);
1852 gtk_widget_show (modules_view);
1853 module_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (modules_view));
1854 gtk_tree_selection_set_mode (module_selection, GTK_SELECTION_MULTIPLE);
1855
1856 if (gbf_project_view_find_selected (GBF_PROJECT_VIEW (modules_view), ANJUTA_PROJECT_MODULE))
1857 {
1858 gtk_widget_set_sensitive (ok_button, TRUE);
1859 }
1860 else
1861 {
1862 gtk_widget_set_sensitive (ok_button, FALSE);
1863 }
1864 g_signal_connect (G_OBJECT(modules_view), "cursor-changed",
1865 G_CALLBACK(on_cursor_changed), ok_button);
1866 g_signal_connect (G_OBJECT(new_button), "clicked",
1867 G_CALLBACK(on_new_library), plugin);
1868
1869
1870 if (parent)
1871 {
1872 gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
1873 }
1874
1875 gtk_widget_grab_focus (modules_view);
1876
1877 /* execute dialog */
1878 while (!finished)
1879 {
1880 response = gtk_dialog_run (GTK_DIALOG (dialog));
1881
1882 switch (response) {
1883 case GTK_RESPONSE_OK:
1884 {
1885 GFile *target_file;
1886 AnjutaProjectNode *target;
1887
1888 target_file = ianjuta_project_chooser_get_selected (IANJUTA_PROJECT_CHOOSER (target_chooser), NULL);
1889 target = gbf_project_view_get_node_from_file (plugin->view, ANJUTA_PROJECT_UNKNOWN, target_file);
1890 if (target)
1891 {
1892 GString *err_mesg = g_string_new (NULL);
1893 GList *list;
1894 GList *node;
1895
1896 list = gbf_project_view_get_all_selected (GBF_PROJECT_VIEW (modules_view));
1897 for (node = g_list_first (list); node != NULL; node = g_list_next (node))
1898 {
1899 GError *error = NULL;
1900 AnjutaProjectNode* new_module;
1901 const gchar *name;
1902
1903 new_module = gbf_tree_data_get_node (node->data);
1904 name = anjuta_project_node_get_name (new_module);
1905
1906 new_module = ianjuta_project_add_node_after (plugin->project->project, target, NULL, ANJUTA_PROJECT_MODULE, NULL, name, &error);
1907 if (error) {
1908 gchar *str = g_strdup_printf ("%s: %s\n",
1909 name,
1910 error->message);
1911 g_string_append (err_mesg, str);
1912 g_error_free (error);
1913 g_free (str);
1914 }
1915 else
1916 new_modules = g_list_append (new_modules, new_module);
1917 }
1918 g_list_free (list);
1919
1920 if (err_mesg->str && strlen (err_mesg->str) > 0)
1921 {
1922 error_dialog (parent, _("Cannot add modules"),
1923 "%s", err_mesg->str);
1924 }
1925 else
1926 {
1927 finished = TRUE;
1928 }
1929 g_string_free (err_mesg, TRUE);
1930 }
1931 else
1932 {
1933 error_dialog (parent, _("Cannot add modules"),
1934 "%s", _("No target has been selected"));
1935 }
1936
1937 break;
1938 }
1939 case GTK_RESPONSE_HELP:
1940 anjuta_util_help_display (GTK_WIDGET (dialog), ANJUTA_MANUAL, ADD_MODULE_HELP);
1941 break;
1942 default:
1943 finished = TRUE;
1944 break;
1945 }
1946 }
1947
1948 /* destroy stuff */
1949 gtk_widget_destroy (dialog);
1950 g_object_unref (gui);
1951
1952 return new_modules;
1953 }
1954
1955 /* Package dialog
1956 *---------------------------------------------------------------------------*/
1957
1958 static void on_changed_disconnect (GtkEditable* entry, gpointer data);
1959
1960 static void
1961 on_cursor_changed_set_entry(GtkTreeView* view, gpointer data)
1962 {
1963 GtkWidget* entry = GTK_WIDGET(data);
1964 AnjutaPkgConfigChooser* chooser = ANJUTA_PKG_CONFIG_CHOOSER (view);
1965 GList* packages = anjuta_pkg_config_chooser_get_active_packages (chooser);
1966
1967 if (packages)
1968 {
1969 gchar* name = packages->data;
1970 gchar* ptr;
1971 /* Remove numeric suffix */
1972 ptr = name + strlen(name) - 1;
1973 while (g_ascii_isdigit (*ptr))
1974 {
1975 while (g_ascii_isdigit (*ptr)) ptr--;
1976 if ((*ptr != '_') && (*ptr != '-') && (*ptr != '.')) break;
1977 *ptr = '\0';
1978 ptr--;
1979 }
1980
1981 /* Convert to upper case and remove invalid characters */
1982 for (ptr = name; *ptr != '\0'; ptr++)
1983 {
1984 if (g_ascii_isalnum (*ptr))
1985 {
1986 *ptr = g_ascii_toupper (*ptr);
1987 }
1988 else
1989 {
1990 *ptr = '_';
1991 }
1992 }
1993
1994 g_signal_handlers_block_by_func (G_OBJECT (entry), on_changed_disconnect, view);
1995 gtk_entry_set_text (GTK_ENTRY (entry), name);
1996 g_signal_handlers_unblock_by_func (G_OBJECT (entry), on_changed_disconnect, view);
1997 anjuta_util_glist_strings_free (packages);
1998 }
1999 }
2000
2001 static void
2002 on_changed_disconnect (GtkEditable* entry, gpointer data)
2003 {
2004 g_signal_handlers_block_by_func (G_OBJECT (data), on_cursor_changed_set_entry, entry);
2005 }
2006
2007 static void
2008 on_pkg_chooser_selection_changed (AnjutaPkgConfigChooser* chooser,
2009 gchar* package,
2010 gpointer data)
2011 {
2012 GtkWidget* button = GTK_WIDGET(data);
2013 GList* packages = anjuta_pkg_config_chooser_get_active_packages (chooser);
2014
2015 if (packages != NULL)
2016 gtk_widget_set_sensitive(button, TRUE);
2017 else
2018 gtk_widget_set_sensitive(button, FALSE);
2019
2020 anjuta_util_glist_strings_free (packages);
2021 }
2022
2023 GList*
2024 anjuta_pm_project_new_package (ProjectManagerPlugin *plugin,
2025 GtkWindow *parent,
2026 GtkTreeIter *default_module,
2027 GList *packages_to_add)
2028 {
2029 GtkBuilder *gui;
2030 GtkWidget *dialog;
2031 GtkWidget *ok_button;
2032 GtkWidget *module_entry;
2033 GtkWidget *packages_view;
2034 GList *packages = NULL;
2035 gint response;
2036 gboolean finished = FALSE;
2037 GtkListStore *store;
2038 AnjutaProjectNode *root;
2039 AnjutaProjectNode *node;
2040 AnjutaProjectNode *module = NULL;
2041 gint default_pos = -1;
2042 gint pos;
2043
2044 g_return_val_if_fail (plugin->project != NULL, NULL);
2045
2046 gui = load_interface ("add_package_dialog");
2047 g_return_val_if_fail (gui != NULL, NULL);
2048
2049 /* get all needed widgets */
2050 dialog = GTK_WIDGET (gtk_builder_get_object (gui, "add_package_dialog"));
2051 module_entry = GTK_WIDGET (gtk_builder_get_object (gui, "module_entry"));
2052 packages_view = GTK_WIDGET (gtk_builder_get_object (gui, "packages_view"));
2053 ok_button = GTK_WIDGET (gtk_builder_get_object (gui, "ok_package_button"));
2054
2055 /* Get default parent */
2056 if (default_module != NULL)
2057 {
2058 GbfTreeData *data;
2059 GbfProjectModel *model;
2060
2061 model = gbf_project_view_get_model(plugin->view);
2062 gtk_tree_model_get (GTK_TREE_MODEL (model), default_module, GBF_PROJECT_MODEL_COLUMN_DATA, &data, -1);
2063 if (data != NULL)
2064 {
2065 module = gbf_tree_data_get_node (data);
2066 }
2067 }
2068
2069 /* Fill combo box with modules */
2070 store = gtk_list_store_new(1, G_TYPE_STRING);
2071 gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (module_entry), 0);
2072
2073 root = ianjuta_project_get_root (plugin->project->project, NULL);
2074 pos = 0;
2075 for (node = anjuta_project_node_first_child (root); node != NULL; node = anjuta_project_node_next_sibling (node))
2076 {
2077 if (anjuta_project_node_get_node_type (node) == ANJUTA_PROJECT_MODULE)
2078 {
2079 GtkTreeIter list_iter;
2080 const gchar *name;
2081
2082 name = anjuta_project_node_get_name (node);
2083 gtk_list_store_append (store, &list_iter);
2084 gtk_list_store_set (store, &list_iter, 0, name, -1);
2085
2086 if (node == module)
2087 {
2088 default_pos = pos;
2089 }
2090 pos ++;
2091 }
2092 }
2093 gtk_combo_box_set_model (GTK_COMBO_BOX(module_entry), GTK_TREE_MODEL(store));
2094 gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (module_entry), 0);
2095 g_object_unref (store);
2096 if (default_pos >= 0)
2097 {
2098 gtk_combo_box_set_active (GTK_COMBO_BOX (module_entry), default_pos);
2099 }
2100 else
2101 {
2102 /* Create automatically a module name from the package name when missing */
2103 GtkWidget *entry = gtk_bin_get_child (GTK_BIN (module_entry));
2104
2105 g_signal_connect (G_OBJECT(packages_view), "cursor-changed",
2106 G_CALLBACK(on_cursor_changed_set_entry), entry);
2107 g_signal_connect (G_OBJECT(entry), "changed",
2108 G_CALLBACK(on_changed_disconnect), packages_view);
2109 }
2110
2111 /* Fill package list */
2112 anjuta_pkg_config_chooser_show_active_column (ANJUTA_PKG_CONFIG_CHOOSER (packages_view),
2113 TRUE);
2114 g_signal_connect (G_OBJECT(packages_view), "package-activated",
2115 G_CALLBACK(on_pkg_chooser_selection_changed), ok_button);
2116 g_signal_connect (G_OBJECT(packages_view), "package-deactivated",
2117 G_CALLBACK(on_pkg_chooser_selection_changed), ok_button);
2118
2119 if (parent) {
2120 gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
2121 }
2122
2123 /* execute dialog */
2124 while (!finished) {
2125 response = gtk_dialog_run (GTK_DIALOG (dialog));
2126
2127 switch (response) {
2128 case GTK_RESPONSE_OK:
2129 {
2130 gchar *name;
2131 AnjutaProjectNode *module = NULL;
2132 GString *error_message = g_string_new (NULL);
2133
2134 name = g_strdup (gtk_entry_get_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (module_entry)))));
2135 if (name != NULL) name = g_strstrip (name);
2136
2137 if ((name == NULL) || (*name == '\0'))
2138 {
2139 /* Missing module name */
2140 g_string_append (error_message, _("Missing module name"));
2141 }
2142 else
2143 {
2144 /* Look for already existing module */
2145 module = anjuta_pm_project_get_module (plugin->project, name);
2146 if (module == NULL)
2147 {
2148 /* Create new module */
2149 AnjutaProjectNode *root;
2150 GError *error = NULL;
2151
2152 root = ianjuta_project_get_root (plugin->project->project, NULL);
2153
2154 module = ianjuta_project_add_node_after (plugin->project->project, root, NULL, ANJUTA_PROJECT_MODULE, NULL, name, &error);
2155 if (error != NULL)
2156 {
2157 gchar *str = g_strdup_printf ("%s: %s\n", name, error->message);
2158
2159 g_string_append (error_message, str);
2160 g_error_free (error);
2161 g_free (str);
2162 }
2163 }
2164 }
2165 g_free (name);
2166
2167 if (module != NULL)
2168 {
2169 GList *list;
2170 GList *node;
2171
2172 list = anjuta_pkg_config_chooser_get_active_packages (ANJUTA_PKG_CONFIG_CHOOSER (packages_view));
2173 for (node = list; node != NULL; node = g_list_next (node))
2174 {
2175 gchar *name;
2176 AnjutaProjectNode* new_package;
2177 GError *error = NULL;
2178
2179 name = node->data;
2180
2181 new_package = ianjuta_project_add_node_after (plugin->project->project, module, NULL, ANJUTA_PROJECT_PACKAGE, NULL, name, &error);
2182 if (error)
2183 {
2184 gchar *str = g_strdup_printf ("%s: %s\n",
2185 name,
2186 error->message);
2187 g_string_append (error_message, str);
2188 g_error_free (error);
2189 g_free (str);
2190 }
2191 else
2192 {
2193 packages = g_list_append (packages, new_package);
2194 finished = TRUE;
2195 }
2196 }
2197 anjuta_util_glist_strings_free (list);
2198 }
2199
2200 if (error_message->len != 0)
2201 {
2202 error_dialog (parent, _("Cannot add packages"),
2203 "%s",error_message->str);
2204 }
2205 else
2206 {
2207 finished = TRUE;
2208 }
2209 g_string_free (error_message, TRUE);
2210 break;
2211 }
2212 case GTK_RESPONSE_HELP:
2213 anjuta_util_help_display (GTK_WIDGET (dialog), ANJUTA_MANUAL, ADD_PACKAGE_HELP);
2214 break;
2215 default:
2216 finished = TRUE;
2217 break;
2218 }
2219 }
2220
2221 /* destroy stuff */
2222 gtk_widget_destroy (dialog);
2223 g_object_unref (gui);
2224
2225 return packages;
2226 }
anjuta mirror