?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updated Spanish translation
[anjuta-git-plugin.git] / plugins / build / compiler_options.c
blob84d703003b328f7d3645dc43b3488dce849ec54c
1 /*
2 compiler_options.c
3 Copyright (C) 2000 Kh. Naba Kumar Singh
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18 */
19 #ifdef HAVE_CONFIG_H
20 # include <config.h>
21 #endif
22
23 #include <ctype.h>
24 #include <sys/stat.h>
25 #include <unistd.h>
26 #include <string.h>
27
28 #define _GNU_SOURCE
29 #include <stdio.h>
30
31 #include <gnome.h>
32
33 #include <libanjuta/resources.h>
34
35 #include "anjuta.h"
36 #include "compiler_options.h"
37
38 typedef struct
39 {
40 gint ref_count;
41
42 GtkWidget *window;
43
44 GtkWidget *supp_clist;
45 GtkWidget *inc_clist;
46 GtkWidget *inc_entry;
47
48 GtkWidget *lib_paths_clist;
49 GtkWidget *lib_paths_entry;
50
51 GtkWidget *lib_clist;
52 GtkWidget *lib_stock_clist;
53 GtkWidget *lib_entry;
54
55 GtkWidget *def_clist;
56 GtkWidget *def_stock_clist;
57 GtkWidget *def_entry;
58
59 GtkWidget *warnings_clist;
60 GtkWidget *optimize_button[4];
61 GtkWidget *other_button[2];
62
63 GtkWidget *other_c_flags_entry;
64 GtkWidget *other_l_flags_entry;
65 GtkWidget *other_l_libs_entry;
66 } CompilerOptionsGui;
67
68 struct _CompilerOptionsPriv
69 {
70 GladeXML *gxml;
71 CompilerOptionsGui widgets;
72 gboolean dirty;
73
74 gboolean is_showing;
75 gint win_pos_x, win_pos_y;
76
77 /* This property database is not the one
78 * from which compiler options will be loaded
79 * or saved, but the one in which option
80 * variables will be set for the commands
81 * to use
82 */
83 PropsID props;
84 };
85
86 static void create_compiler_options_gui (CompilerOptions *co);
87 static void on_remove_from_clist_clicked (GtkButton * button, gpointer data);
88
89 #define ANJUTA_SUPPORTS_END_STRING "SUPPORTS_END"
90 #define ANJUTA_SUPPORTS_END \
91 { \
92 ANJUTA_SUPPORTS_END_STRING, NULL, NULL, \
93 NULL, NULL, NULL, NULL, NULL, NULL, NULL \
94 }
95
96 gchar *anjuta_supports[][ANJUTA_SUPPORT_END_MARK] = {
97 {
98 "GLIB",
99 "[gtk+ 1.2] Glib library for most C utilities",
100 "",
101 "AM_MISSING_PROG(GLIB_CONFIG, glib-config, $mising_dir)\n",
102 "`glib-config --cflags`",
103 "`glib-config --libs`",
104 "`glib-config --cflags`",
105 "`glib-config --libs`",
106 "",
107 "glib-config --version"}
108 ,
109 {
110 "GTK",
111 "[gtk+ 1.2] Gimp Toolkit library for GUI development",
112 "",
113 "",
114 "gtk-config --cflags",
115 "$(GTK_LIBS)",
116 "`gtk-config --cflags`",
117 "`gtk-config --libs`",
118 "",
119 "gtk-config --version"}
120 ,
121 {
122 "GNOME",
123 "[gnome 1.4] GNOME is Computing Made Easy",
124 "",
125 "",
126 "$(GNOME_INCLUDESDIR)",
127 "$(GNOME_LIBDIR) $(GNOME_LIBS)",
128 "`gnome-config --cflags glib gtk gnome gnomeui`",
129 "`gnome-config --libs glib gtk gnome gnomeui`",
130 "",
131 "gnome-config --version"}
132 ,
133 {
134 "BONOBO",
135 "[gnome 1.4] GNOME Bonobo component for fast integration",
136 "",
137 "",
138 "$(BONOBO_CFLAGS)",
139 "$(BONOBO_LIBS)",
140 "`gnome-config --cflags glib gtk gnome gnomeui bonobo`",
141 "`gnome-config --libs glib gtk gnome gnomeui bonobo`",
142 "",
143 "gnome-config --version"}
144 ,
145 {
146 "gtkmm",
147 "[gtk+ 1.2] C++ Bindings for GTK",
148 "",
149 "",
150 "$(GTKMM_CFLAGS)",
151 "$(GTKMM_LIBS)",
152 "`gtkmm-config --cflags`",
153 "`gtkmm-config --libs`",
154 "",
155 "gtkmm-config --version"}
156 ,
157 {
158 "gnomemm",
159 "[gnome 1.4] C++ bindings for GNOME",
160 "",
161 "",
162 "$(GNOMEMM_CFLAGS)",
163 "$(GNOMEMM_LIBS)",
164 "`gnome-config --cflags gnomemm`",
165 "`gnome-config --libs gnomemm`",
166 "",
167 "gnome-config --version"}
168 ,
169 {
170 "LIBGLADE",
171 "[gnome 1.4] C program using libglade",
172 "",
173 "",
174 "$(LIBGLADE_CFLAGS)",
175 "$(LIBGLADE_LIBS)",
176 "`libglade-config --cflags gnome`",
177 "`libglade-config --libs gnome`",
178 "",
179 "libglade-config --version"}
180 ,
181 {
182 "WXWINDOWS",
183 "[gtk+ 1.2] C++ program using wxWindows (wxGTK) toolkit",
184 "",
185 "",
186 "$(WX_CXXFLAGS)",
187 "$(WX_LIBS)",
188 "`wx-config --cxxflags`",
189 "`wx-config --libs`",
190 "",
191 "wx-config --version"}
192 ,
193 ANJUTA_SUPPORTS_END
194 };
195
196 static gchar *anjuta_warnings[] = {
197 " -Werror", "Consider warnings as errors",
198 " -w", "No warnings",
199 " -Wall", "Enable most warnings",
200 " -Wimplicit", "Warning for implicit declarations",
201 " -Wreturn-type", "Warning for mismatched return types",
202 " -Wunused", "Warning for unused variables",
203 " -Wswitch", "Warning for unhandled switch case with enums",
204 " -Wcomment", "Warning for nested comments",
205 " -Wuninitialized", "Warning for uninitialized variable use",
206 " -Wparentheses", "Warning for missing parentheses",
207 " -Wtraditional", "Warning for differences to traditionanl syntax",
208 " -Wshadow", "Warning for variable shadowing",
209 " -Wpointer-arith", "Warning for missing prototypes",
210 " -Wmissing-prototypes", "Warning for suspected pointer arithmetic",
211 " -Winline", "Warning if declarations cannot be inlined",
212 " -Woverloaded-virtual", "Warning for overloaded virtuals",
213 NULL, NULL
214 };
215
216 static gchar *anjuta_defines[] = {
217 "HAVE_CONFIG_H",
218 "DEBUG_LEVEL_2",
219 "DEBUG_LEVEL_1",
220 "DEBUG_LEVEL_0",
221 "RELEASE",
222 NULL,
223 };
224
225 static gchar *optimize_button_option[] = {
226 "",
227 " -O1",
228 " -O2",
229 " -O3"
230 };
231
232 static gchar *other_button_option[] = {
233 " -g",
234 " -pg",
235 };
236
237 enum {
238 SUPP_TOGGLE_COLUMN,
239 SUPP_NAME_COLUMN,
240 SUPP_DESCRIPTION_COLUMN,
241 SUPP_PKGCONFIG_COLUMN,
242 N_SUPP_COLUMNS
243 };
244
245 enum {
246 INC_PATHS_COLUMN,
247 N_INC_COLUMNS
248 };
249
250 enum {
251 LIB_PATHS_COLUMN,
252 N_LIB_PATHS_COLUMN
253 };
254
255 enum {
256 LIB_TOGGLE_COLUMN,
257 LIB_COLUMN,
258 N_LIB_COLUMNS
259 };
260
261 enum {
262 LIB_STOCK_COLUMN,
263 LIB_STOCK_DES_COLUMN,
264 N_LIB_STOCK_COLUMNS
265 };
266
267 enum {
268 DEF_TOGGLE_COLUMN,
269 DEF_DEFINE_COLUMN,
270 N_DEF_COLUMNS
271 };
272
273 enum {
274 DEF_STOCK_COLUMN,
275 N_DEF_STOCK_COLUMNS
276 };
277
278 enum {
279 WARNINGS_TOGGLE_COLUMN,
280 WARNINGS_COLUMN,
281 WARNINGS_DES_COLUMN,
282 N_WARNINGS_COLUMNS
283 };
284
285 /* private */
286 static void compiler_options_set_in_properties (CompilerOptions* co,
287 PropsID props);
288
289 static void
290 populate_stock_libs (GtkListStore *tmodel)
291 {
292 gint i, ch;
293 gchar *stock_file;
294 gchar lib_name[256];
295 gchar desbuff[512];
296 FILE *fp;
297
298 /* Now read the stock libraries */
299 stock_file =
300 g_strconcat (app->dirs->data, "/stock_libs.anj",
301 NULL);
302 fp = fopen (stock_file, "r");
303 g_free (stock_file);
304
305 if (fp == NULL)
306 goto down;
307
308 /* Skip the first line which is comment */
309 do
310 {
311 ch = fgetc (fp);
312 if (ch == EOF)
313 goto down;
314 }
315 while (ch != '\n');
316
317 while (feof (fp) == FALSE)
318 {
319 GtkTreeIter iter;
320
321 /* Read a line at a time */
322 fscanf (fp, "%s", lib_name); /* The lib name */
323
324 /* Followed by description */
325 i = 0;
326 do
327 {
328 ch = fgetc (fp);
329 if (ch == EOF)
330 goto down; /* Done when eof */
331 desbuff[i] = (gchar) ch;
332 i++;
333 }
334 while (ch != '\n');
335
336 desbuff[--i] = '\0';
337
338 gtk_list_store_append (tmodel, &iter);
339 gtk_list_store_set (tmodel, &iter,
340 LIB_STOCK_COLUMN, lib_name,
341 LIB_STOCK_DES_COLUMN, desbuff,
342 -1);
343 }
344
345 down:
346 if (fp)
347 fclose (fp);
348 }
349
350 static void
351 populate_supports (GtkListStore *tmodel)
352 {
353 gchar *tmpfile;
354 gchar *pkg_cmd;
355 FILE *pkg_fd;
356 gchar *line;
357 gint length;
358 GtkTreeIter iter;
359
360 int i = 0;
361
362 /* Now setup all the available supports */
363 while (strcmp (anjuta_supports[i][ANJUTA_SUPPORT_ID],
364 ANJUTA_SUPPORTS_END_STRING) != 0)
365 {
366 gtk_list_store_append (tmodel, &iter);
367 gtk_list_store_set (tmodel, &iter,
368 SUPP_TOGGLE_COLUMN, FALSE,
369 SUPP_NAME_COLUMN, anjuta_supports[i][0],
370 SUPP_DESCRIPTION_COLUMN, anjuta_supports[i][1],
371 SUPP_PKGCONFIG_COLUMN, FALSE,
372 -1);
373 i++;
374 }
375 /* Now setup all the pkg-config supports */
376 tmpfile = get_a_tmp_file ();
377 pkg_cmd = g_strconcat ("pkg-config --list-all > ", tmpfile,
378 " 2>/dev/null", NULL);
379 system (pkg_cmd);
380 pkg_fd = fopen (tmpfile, "r");
381 if (!pkg_fd)
382 {
383 g_warning ("Can not open %s for reading", tmpfile);
384 g_free (tmpfile);
385 return;
386 }
387 line = NULL;
388 while (getline (&line, &length, pkg_fd) > 0)
389 {
390 gchar *name_end;
391 gchar *desc_start;
392 gchar *description;
393 gchar *name;
394
395 if (line == NULL)
396 break;
397
398 name_end = line;
399 while (!isspace(*name_end))
400 name_end++;
401 desc_start = name_end;
402 while (isspace(*desc_start))
403 desc_start++;
404
405 name = g_strndup (line, name_end-line);
406 description = g_strndup (desc_start, strlen (desc_start)-1);
407
408 gtk_list_store_append (tmodel, &iter);
409 gtk_list_store_set (tmodel, &iter,
410 SUPP_TOGGLE_COLUMN, FALSE,
411 SUPP_NAME_COLUMN, name,
412 SUPP_DESCRIPTION_COLUMN, description,
413 SUPP_PKGCONFIG_COLUMN, TRUE,
414 -1);
415 g_free (line);
416 line = NULL;
417 }
418 fclose (pkg_fd);
419 remove (tmpfile);
420 g_free (tmpfile);
421 }
422
423 static void
424 populate_stock_defs (GtkListStore *tmodel)
425 {
426 /* Now setup buildin defines */
427 int i = 0;
428 while (anjuta_defines[i])
429 {
430 GtkTreeIter iter;
431 gtk_list_store_append (tmodel, &iter);
432 gtk_list_store_set (tmodel, &iter,
433 DEF_STOCK_COLUMN, anjuta_defines[i],
434 -1);
435 i++;
436 }
437 }
438
439 static void
440 populate_warnings (GtkListStore *tmodel)
441 {
442 /* Now setup buildin defines */
443 int i = 0;
444 while (anjuta_warnings[i])
445 {
446 GtkTreeIter iter;
447 gtk_list_store_append (tmodel, &iter);
448 gtk_list_store_set (tmodel, &iter,
449 WARNINGS_TOGGLE_COLUMN, FALSE,
450 WARNINGS_COLUMN, anjuta_warnings[i],
451 WARNINGS_DES_COLUMN, anjuta_warnings[i+1],
452 -1);
453 i += 2;
454 }
455 }
456
457 typedef struct {
458 CompilerOptions *co;
459 GtkTreeView *tree;
460 GtkEntry *entry;
461 gint col;
462 } EntrySignalInfo;
463
464 typedef struct {
465 CompilerOptions *co;
466 gint col;
467 } ToggleSignalInfo;
468
469 static EntrySignalInfo *
470 entry_signal_info_new (CompilerOptions *co, GtkWidget *tree, GtkWidget *entry,
471 gint col)
472 {
473 EntrySignalInfo *info;
474 g_return_val_if_fail ((GTK_IS_TREE_VIEW (tree) && GTK_IS_ENTRY (entry)),
475 NULL);
476 info = g_new0 (EntrySignalInfo, 1);
477 info->co = co;
478 info->tree = GTK_TREE_VIEW (tree);
479 info->entry = GTK_ENTRY (entry);
480 info->col = col;
481 return info;
482 }
483
484 static ToggleSignalInfo *
485 toggle_signal_info_new (CompilerOptions *co, gint col)
486 {
487 ToggleSignalInfo *info;
488
489 info = g_new0 (ToggleSignalInfo, 1);
490 info->co = co;
491 info->col = col;
492 return info;
493 }
494
495 static void
496 on_comp_finish (CompilerOptions* co)
497 {
498 gboolean should_rebuild;
499
500 if (co->priv->dirty &&
501 app->project_dbase->project_is_open)
502 {
503 gchar* msg = _("You have changed some of the compiler options of the project,\n"
504 "would you like the next build action to perform a complete\n"
505 "rebuild of the project?");
506 should_rebuild = anjuta_boolean_question (msg);
507 if (should_rebuild)
508 app->project_dbase->clean_before_build = TRUE;
509 else
510 app->project_dbase->clean_before_build = FALSE;
511 } else {
512 co->priv->dirty = FALSE;
513 app->project_dbase->clean_before_build = FALSE;
514 }
515 compiler_options_set_in_properties(co, co->priv->props);
516 project_dbase_save_project (app->project_dbase);
517 }
518
519 static gboolean
520 on_compt_delete_event (GtkWidget *widget, GdkEvent *event, gpointer data)
521 {
522 CompilerOptions *co = data;
523 g_return_val_if_fail (co, TRUE);
524
525 on_comp_finish (co);
526 compiler_options_hide(co);
527 return TRUE;
528 }
529
530 static void
531 on_compt_response (GtkWidget *widget, gint response, gpointer data)
532 {
533 CompilerOptions *co = data;
534 g_return_if_fail (co);
535
536 switch (response)
537 {
538 case GTK_RESPONSE_HELP:
539 /* FIXME: Add help for compiler options here */
540 return;
541 case GTK_RESPONSE_CLOSE:
542 on_comp_finish (co);
543 compiler_options_hide (co);
544 return;
545 }
546 }
547
548 static void
549 on_toggle_clist_row_activated (GtkTreeView *treeview,
550 GtkTreePath *arg1,
551 GtkTreeViewColumn *arg2,
552 gpointer data)
553 {
554 GtkTreeModel *model;
555 GtkTreeIter iter;
556 gboolean value;
557 ToggleSignalInfo* info = (ToggleSignalInfo*) data;
558
559 model = gtk_tree_view_get_model (treeview);
560 if (gtk_tree_model_get_iter (model, &iter, arg1))
561 {
562 gtk_tree_model_get (model, &iter, info->col, &value, -1);
563 value = value? FALSE : TRUE;
564 gtk_list_store_set (GTK_LIST_STORE (model), &iter, info->col, value, -1);
565 compiler_options_set_dirty_flag (info->co, TRUE);
566 }
567 }
568
569 static void
570 on_update_selection_changed (GtkTreeSelection *sel, EntrySignalInfo *info)
571 {
572 GtkTreeIter iter;
573 GtkTreeModel *model;
574 const gchar *text;
575 GtkEntry *entry = info->entry;
576 gint col = info->col;
577 if (gtk_tree_selection_get_selected (sel, &model, &iter))
578 {
579 gtk_tree_model_get (model, &iter, col, &text, -1);
580 gtk_entry_set_text (entry, text);
581 compiler_options_set_dirty_flag (info->co, TRUE);
582 }
583 }
584
585
586 static void
587 on_button_selection_changed (GtkToggleButton *togglebutton, gpointer user_data)
588 {
589 CompilerOptions *co = (CompilerOptions*) user_data;
590 compiler_options_set_dirty_flag (co, TRUE);
591 }
592
593 static void
594 on_entry_changed (GtkEntry *togglebutton, gpointer user_data)
595 {
596 CompilerOptions *co = (CompilerOptions*) user_data;
597 compiler_options_set_dirty_flag (co, TRUE);
598 }
599
600
601
602 static gboolean
603 verify_new_entry (GtkTreeView *tree, const gchar *str, gint col)
604 {
605 GtkTreeModel *model;
606 GtkTreeIter iter;
607 gboolean valid;
608
609 model = gtk_tree_view_get_model (GTK_TREE_VIEW(tree));
610 g_assert (model);
611 valid = gtk_tree_model_get_iter_first (model, &iter);
612 while (valid)
613 {
614 gchar *text;
615 gtk_tree_model_get (model, &iter, col, &text, -1);
616 if (strcmp(str, text) == 0)
617 return FALSE;
618 valid = gtk_tree_model_iter_next (model, &iter);
619 }
620 return TRUE;
621 }
622
623 static void
624 on_add_to_clist_clicked (GtkButton * button, gpointer data)
625 {
626 GtkTreeModel *model;
627 GtkTreeIter iter;
628 gchar *text;
629 gchar *str;
630 EntrySignalInfo *info = data;
631 GtkTreeView *tree = info->tree;
632 GtkEntry *entry = info->entry;
633 gint col = info->col;
634
635 str = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
636 text = g_strstrip (str);
637 if (strlen (text) == 0)
638 {
639 g_free (str);
640 return;
641 }
642 if (verify_new_entry (tree, text, col) == FALSE)
643 {
644 gtk_entry_set_text (GTK_ENTRY (entry), "");
645 g_free (str);
646 return;
647 }
648 model = gtk_tree_view_get_model (GTK_TREE_VIEW(tree));
649 g_assert (model);
650 gtk_list_store_append (GTK_LIST_STORE (model), &iter);
651 gtk_list_store_set (GTK_LIST_STORE(model), &iter, col, text, -1);
652 if (col != 0) /* Also enable it */
653 gtk_list_store_set (GTK_LIST_STORE(model), &iter, 0, TRUE, -1);
654 gtk_entry_set_text (GTK_ENTRY (entry), "");
655 g_free (str);
656 compiler_options_set_dirty_flag (info->co, TRUE);
657 }
658
659 static void
660 on_update_in_clist_clicked (GtkButton * button, gpointer data)
661 {
662 GtkTreeModel *model;
663 GtkTreeSelection *sel;
664 GtkTreeIter iter;
665 gchar *text, *str;
666 EntrySignalInfo *info = data;
667 GtkTreeView *tree = info->tree;
668 GtkEntry *entry = info->entry;
669 gint col = info->col;
670
671 str = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
672 text = g_strstrip(str);
673 if (strlen (text) == 0)
674 {
675 g_free (str);
676 return;
677 }
678 if (verify_new_entry (tree, text, col) == FALSE)
679 {
680 gtk_entry_set_text (GTK_ENTRY (entry), "");
681 g_free (str);
682 return;
683 }
684 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW(tree));
685 if (gtk_tree_selection_get_selected (sel, &model, &iter))
686 {
687 gtk_list_store_set (GTK_LIST_STORE(model), &iter, col, text, -1);
688 gtk_entry_set_text (GTK_ENTRY (entry), "");
689 }
690 g_free (str);
691 compiler_options_set_dirty_flag (info->co, TRUE);
692 }
693
694 static void
695 on_remove_from_clist_clicked (GtkButton * button, gpointer data)
696 {
697 GtkTreeModel *model;
698 GtkTreeIter iter;
699 GtkTreeSelection *sel;
700 EntrySignalInfo *info = data;
701 GtkTreeView *tree = info->tree;
702 GtkEntry *entry = info->entry;
703
704 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW(tree));
705 if (gtk_tree_selection_get_selected (sel, &model, &iter))
706 {
707 gtk_list_store_remove (GTK_LIST_STORE(model), &iter);
708 gtk_entry_set_text (GTK_ENTRY (entry), "");
709 compiler_options_set_dirty_flag (info->co, TRUE);
710 }
711 }
712
713 static void
714 on_clear_clist_clicked (GtkButton * button, gpointer data)
715 {
716 GtkWidget *win;
717 GtkWidget *top_level;
718 EntrySignalInfo *info = data;
719 GtkTreeView *tree = info->tree;
720 GtkListStore *model = GTK_LIST_STORE (gtk_tree_view_get_model (tree));
721 top_level = gtk_widget_get_toplevel (GTK_WIDGET (tree));
722 win = gtk_message_dialog_new (GTK_WINDOW (top_level),
723 GTK_DIALOG_DESTROY_WITH_PARENT,
724 GTK_MESSAGE_QUESTION,
725 GTK_BUTTONS_NONE,
726 _("Do you want to clear the list?"));
727 gtk_dialog_add_buttons (GTK_DIALOG (win),
728 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
729 GTK_STOCK_CLEAR, GTK_RESPONSE_YES,
730 NULL);
731 if (gtk_dialog_run (GTK_DIALOG (win)) == GTK_RESPONSE_YES)
732 {
733 gtk_list_store_clear (GTK_LIST_STORE (model));
734 compiler_options_set_dirty_flag (info->co, TRUE);
735 }
736 gtk_widget_destroy (win);
737 }
738
739 #define BUTTON_SIGNAL_CONNECT(w, f, d) \
740 g_signal_connect (G_OBJECT (w), "clicked", G_CALLBACK (f), d);
741
742 static
743 void create_compiler_options_gui (CompilerOptions *co)
744 {
745 GtkTreeView *clist;
746 GtkTreeViewColumn *column;
747 GtkTreeSelection *selection;
748 GtkListStore *store;
749 GtkCellRenderer *renderer;
750 GtkWidget *button;
751 int i;
752
753 /* Compiler Options Dialog */
754 co->priv->gxml = glade_xml_new (GLADE_FILE_ANJUTA, "compiler_options_dialog", NULL);
755 co->priv->widgets.window = glade_xml_get_widget (co->priv->gxml, "compiler_options_dialog");
756 gtk_widget_hide (co->priv->widgets.window);
757 gtk_window_set_transient_for (GTK_WINDOW (co->priv->widgets.window),
758 GTK_WINDOW (app));
759 co->priv->widgets.supp_clist = glade_xml_get_widget (co->priv->gxml, "supp_clist");
760 co->priv->widgets.inc_clist = glade_xml_get_widget (co->priv->gxml, "inc_clist");
761 co->priv->widgets.inc_entry = glade_xml_get_widget (co->priv->gxml, "inc_entry");
762 co->priv->widgets.lib_paths_clist = glade_xml_get_widget (co->priv->gxml, "lib_paths_clist");
763 co->priv->widgets.lib_paths_entry = glade_xml_get_widget (co->priv->gxml, "lib_paths_entry");
764 co->priv->widgets.lib_clist = glade_xml_get_widget (co->priv->gxml, "lib_clist");
765 co->priv->widgets.lib_stock_clist = glade_xml_get_widget (co->priv->gxml, "lib_stock_clist");
766 co->priv->widgets.lib_entry = glade_xml_get_widget (co->priv->gxml, "lib_entry");
767 co->priv->widgets.def_clist = glade_xml_get_widget (co->priv->gxml, "def_clist");
768 co->priv->widgets.def_stock_clist = glade_xml_get_widget (co->priv->gxml, "def_stock_clist");
769 co->priv->widgets.def_entry = glade_xml_get_widget (co->priv->gxml, "def_entry");
770 co->priv->widgets.warnings_clist = glade_xml_get_widget (co->priv->gxml, "warnings_clist");
771 co->priv->widgets.optimize_button[0] = glade_xml_get_widget (co->priv->gxml, "optimization_b_1");
772 co->priv->widgets.optimize_button[1] = glade_xml_get_widget (co->priv->gxml, "optimization_b_2");
773 co->priv->widgets.optimize_button[2] = glade_xml_get_widget (co->priv->gxml, "optimization_b_3");
774 co->priv->widgets.optimize_button[3] = glade_xml_get_widget (co->priv->gxml, "optimization_b_4");
775 co->priv->widgets.other_button[0] = glade_xml_get_widget (co->priv->gxml, "debugging_b");
776 co->priv->widgets.other_button[1] = glade_xml_get_widget (co->priv->gxml, "profiling_b");
777 co->priv->widgets.other_c_flags_entry = glade_xml_get_widget (co->priv->gxml, "other_c_flags_entry");
778 co->priv->widgets.other_l_flags_entry = glade_xml_get_widget (co->priv->gxml, "other_l_flags_entry");
779 co->priv->widgets.other_l_libs_entry = glade_xml_get_widget (co->priv->gxml, "other_l_libs_entry");
780
781 /* Add supports tree model */
782 clist = GTK_TREE_VIEW (co->priv->widgets.supp_clist);
783 store = gtk_list_store_new (N_SUPP_COLUMNS,
784 G_TYPE_BOOLEAN,
785 G_TYPE_STRING,
786 G_TYPE_STRING,
787 G_TYPE_BOOLEAN);
788 gtk_tree_view_set_model (clist, GTK_TREE_MODEL(store));
789
790 /* Add supports columns */
791 renderer = gtk_cell_renderer_toggle_new ();
792 column = gtk_tree_view_column_new_with_attributes ("", renderer,
793 "active",
794 SUPP_TOGGLE_COLUMN,
795 NULL);
796 gtk_tree_view_append_column (clist, column);
797 renderer = gtk_cell_renderer_text_new ();
798 column = gtk_tree_view_column_new_with_attributes (_("Name"),
799 renderer,
800 "text",
801 SUPP_NAME_COLUMN,
802 NULL);
803 gtk_tree_view_append_column (clist, column);
804 renderer = gtk_cell_renderer_text_new ();
805 column = gtk_tree_view_column_new_with_attributes (_("Description"),
806 renderer,
807 "text",
808 SUPP_DESCRIPTION_COLUMN,
809 NULL);
810 gtk_tree_view_append_column (clist, column);
811 populate_supports (store);
812 g_object_unref (G_OBJECT(store));
813
814 /* Add "includes" tree model */
815 clist = GTK_TREE_VIEW (co->priv->widgets.inc_clist);
816 store = gtk_list_store_new (N_INC_COLUMNS, G_TYPE_STRING);
817 gtk_tree_view_set_model (clist, GTK_TREE_MODEL(store));
818
819 renderer = gtk_cell_renderer_text_new ();
820 column = gtk_tree_view_column_new_with_attributes (_("Include paths"),
821 renderer,
822 "text",
823 INC_PATHS_COLUMN,
824 NULL);
825 gtk_tree_view_append_column (clist, column);
826 g_object_unref (G_OBJECT(store));
827
828 /* Add "libraries paths" model */
829 clist = GTK_TREE_VIEW (co->priv->widgets.lib_paths_clist);
830 store = gtk_list_store_new (N_LIB_PATHS_COLUMN, G_TYPE_STRING);
831 gtk_tree_view_set_model (clist, GTK_TREE_MODEL(store));
832
833 /* Add "libraries paths" columns */
834 renderer = gtk_cell_renderer_text_new ();
835 column = gtk_tree_view_column_new_with_attributes (_("Libraries paths"),
836 renderer,
837 "text",
838 LIB_PATHS_COLUMN,
839 NULL);
840 gtk_tree_view_append_column (clist, column);
841 g_object_unref (G_OBJECT(store));
842
843 /* Add "includes" tree model */
844 clist = GTK_TREE_VIEW (co->priv->widgets.lib_clist);
845 store = gtk_list_store_new (N_LIB_COLUMNS, G_TYPE_BOOLEAN,
846 G_TYPE_STRING);
847 gtk_tree_view_set_model (clist, GTK_TREE_MODEL(store));
848
849 /* Add "libraries paths" columns */
850 renderer = gtk_cell_renderer_toggle_new ();
851 column = gtk_tree_view_column_new_with_attributes ("", renderer,
852 "active",
853 LIB_TOGGLE_COLUMN,
854 NULL);
855 gtk_tree_view_append_column (clist, column);
856 renderer = gtk_cell_renderer_text_new ();
857 column =
858 gtk_tree_view_column_new_with_attributes (_("Libraries and modules"),
859 renderer,
860 "text",
861 LIB_COLUMN,
862 NULL);
863 gtk_tree_view_append_column (clist, column);
864 g_object_unref (G_OBJECT(store));
865
866 /* Add "Libraries stock" model */
867 clist = GTK_TREE_VIEW (co->priv->widgets.lib_stock_clist);
868 store = gtk_list_store_new (N_LIB_STOCK_COLUMNS, G_TYPE_STRING,
869 G_TYPE_STRING);
870 gtk_tree_view_set_model (clist, GTK_TREE_MODEL(store));
871
872 /* Add "Libraries stock" column */
873 renderer = gtk_cell_renderer_text_new ();
874 column = gtk_tree_view_column_new_with_attributes (_("Stock"),
875 renderer,
876 "text",
877 LIB_STOCK_COLUMN,
878 NULL);
879 gtk_tree_view_append_column (clist, column);
880 renderer = gtk_cell_renderer_text_new ();
881 column = gtk_tree_view_column_new_with_attributes (_("Description"),
882 renderer,
883 "text",
884 LIB_STOCK_DES_COLUMN,
885 NULL);
886 gtk_tree_view_append_column (clist, column);
887 populate_stock_libs (store);
888 g_object_unref (G_OBJECT(store));
889
890 /* Add "Defines" model */
891 clist = GTK_TREE_VIEW (co->priv->widgets.def_clist);
892 store = gtk_list_store_new (N_DEF_COLUMNS, G_TYPE_BOOLEAN,
893 G_TYPE_STRING);
894 gtk_tree_view_set_model (clist, GTK_TREE_MODEL(store));
895
896 /* Add defines columns */
897 renderer = gtk_cell_renderer_toggle_new ();
898 column = gtk_tree_view_column_new_with_attributes ("", renderer,
899 "active",
900 DEF_TOGGLE_COLUMN,
901 NULL);
902 gtk_tree_view_append_column (clist, column);
903 renderer = gtk_cell_renderer_text_new ();
904 column = gtk_tree_view_column_new_with_attributes (_("Description"),
905 renderer,
906 "text",
907 DEF_DEFINE_COLUMN,
908 NULL);
909 gtk_tree_view_append_column (clist, column);
910 g_object_unref (G_OBJECT(store));
911
912 /* Add "Defines stock" model */
913 clist = GTK_TREE_VIEW (co->priv->widgets.def_stock_clist);
914 store = gtk_list_store_new (N_DEF_STOCK_COLUMNS, G_TYPE_STRING);
915 gtk_tree_view_set_model (clist, GTK_TREE_MODEL(store));
916
917 /* Add defines columns */
918 renderer = gtk_cell_renderer_text_new ();
919 column = gtk_tree_view_column_new_with_attributes (_("Stock Defines"),
920 renderer,
921 "text",
922 DEF_STOCK_COLUMN,
923 NULL);
924 gtk_tree_view_append_column (clist, column);
925 populate_stock_defs (store);
926 g_object_unref (G_OBJECT(store));
927
928 /* Add "warnings" model */
929 clist = GTK_TREE_VIEW (co->priv->widgets.warnings_clist);
930 store = gtk_list_store_new (N_WARNINGS_COLUMNS, G_TYPE_BOOLEAN,
931 G_TYPE_STRING, G_TYPE_STRING);
932 gtk_tree_view_set_model (clist, GTK_TREE_MODEL(store));
933
934 /* Add "warnings" columns */
935 renderer = gtk_cell_renderer_toggle_new ();
936 column = gtk_tree_view_column_new_with_attributes ("", renderer,
937 "active",
938 WARNINGS_TOGGLE_COLUMN,
939 NULL);
940 gtk_tree_view_append_column (clist, column);
941 renderer = gtk_cell_renderer_text_new ();
942 column = gtk_tree_view_column_new_with_attributes (_("Warning"),
943 renderer,
944 "text",
945 WARNINGS_COLUMN,
946 NULL);
947 gtk_tree_view_append_column (clist, column);
948 renderer = gtk_cell_renderer_text_new ();
949 column = gtk_tree_view_column_new_with_attributes (_("Description"),
950 renderer,
951 "text",
952 WARNINGS_DES_COLUMN,
953 NULL);
954 gtk_tree_view_append_column (clist, column);
955 populate_warnings (store);
956 g_object_unref (G_OBJECT(store));
957
958 /* Connect window signals */
959 g_signal_connect (G_OBJECT (co->priv->widgets.window), "delete_event",
960 G_CALLBACK (on_compt_delete_event), co);
961 g_signal_connect (G_OBJECT (co->priv->widgets.window), "response",
962 G_CALLBACK (on_compt_response), co);
963
964 /* Connect toggle signals */
965 g_signal_connect (G_OBJECT (co->priv->widgets.supp_clist), "row_activated",
966 G_CALLBACK (on_toggle_clist_row_activated),
967 toggle_signal_info_new(co,SUPP_TOGGLE_COLUMN));
968 g_signal_connect (G_OBJECT (co->priv->widgets.lib_clist), "row_activated",
969 G_CALLBACK (on_toggle_clist_row_activated),
970 toggle_signal_info_new(co,LIB_TOGGLE_COLUMN));
971 g_signal_connect (G_OBJECT (co->priv->widgets.def_clist), "row_activated",
972 G_CALLBACK (on_toggle_clist_row_activated),
973 toggle_signal_info_new(co,DEF_TOGGLE_COLUMN));
974 g_signal_connect (G_OBJECT (co->priv->widgets.warnings_clist), "row_activated",
975 G_CALLBACK (on_toggle_clist_row_activated),
976 toggle_signal_info_new(co,WARNINGS_TOGGLE_COLUMN));
977
978 /* Connect Entry update signals */
979 clist = GTK_TREE_VIEW (co->priv->widgets.inc_clist);
980 selection = gtk_tree_view_get_selection (clist);
981 g_signal_connect (G_OBJECT (selection), "changed",
982 G_CALLBACK (on_update_selection_changed),
983 entry_signal_info_new (co,
984 co->priv->widgets.inc_clist,
985 co->priv->widgets.inc_entry,
986 INC_PATHS_COLUMN));
987 clist = GTK_TREE_VIEW (co->priv->widgets.lib_clist);
988 selection = gtk_tree_view_get_selection (clist);
989 g_signal_connect (G_OBJECT (selection), "changed",
990 G_CALLBACK (on_update_selection_changed),
991 entry_signal_info_new (co, co->priv->widgets.lib_clist,
992 co->priv->widgets.lib_entry,
993 LIB_COLUMN));
994 clist = GTK_TREE_VIEW (co->priv->widgets.lib_stock_clist);
995 selection = gtk_tree_view_get_selection (clist);
996 g_signal_connect (G_OBJECT (selection), "changed",
997 G_CALLBACK (on_update_selection_changed),
998 entry_signal_info_new (co, co->priv->widgets.lib_stock_clist,
999 co->priv->widgets.lib_entry,
1000 LIB_STOCK_COLUMN));
1001 clist = GTK_TREE_VIEW (co->priv->widgets.lib_paths_clist);
1002 selection = gtk_tree_view_get_selection (clist);
1003 g_signal_connect (G_OBJECT (selection), "changed",
1004 G_CALLBACK (on_update_selection_changed),
1005 entry_signal_info_new (co, co->priv->widgets.lib_paths_clist,
1006 co->priv->widgets.lib_paths_entry,
1007 LIB_PATHS_COLUMN));
1008 clist = GTK_TREE_VIEW (co->priv->widgets.def_clist);
1009 selection = gtk_tree_view_get_selection (clist);
1010 g_signal_connect (G_OBJECT (selection), "changed",
1011 G_CALLBACK (on_update_selection_changed),
1012 entry_signal_info_new (co, co->priv->widgets.def_clist,
1013 co->priv->widgets.def_entry,
1014 DEF_DEFINE_COLUMN));
1015 clist = GTK_TREE_VIEW (co->priv->widgets.def_stock_clist);
1016 selection = gtk_tree_view_get_selection (clist);
1017 g_signal_connect (G_OBJECT (selection), "changed",
1018 G_CALLBACK (on_update_selection_changed),
1019 entry_signal_info_new (co, co->priv->widgets.def_stock_clist,
1020 co->priv->widgets.def_entry,
1021 DEF_STOCK_COLUMN));
1022
1023 g_signal_connect (G_OBJECT (co->priv->widgets.other_c_flags_entry), "changed",
1024 G_CALLBACK (on_entry_changed), co);
1025
1026 g_signal_connect (G_OBJECT (co->priv->widgets.other_l_flags_entry), "changed",
1027 G_CALLBACK (on_entry_changed), co);
1028
1029 g_signal_connect (G_OBJECT (co->priv->widgets.other_l_libs_entry), "changed",
1030 G_CALLBACK (on_entry_changed), co);
1031
1032 /* optimization buttons */
1033 for (i = 0 ; i < 4 ; i++)
1034 g_signal_connect (GTK_TOGGLE_BUTTON (co->priv->widgets.optimize_button[i]),
1035 "toggled", G_CALLBACK (on_button_selection_changed),co);
1036
1037 /* debug and profile */
1038 for (i = 0 ; i < 2 ; i++)
1039 g_signal_connect (GTK_TOGGLE_BUTTON (co->priv->widgets.other_button[i]),
1040 "toggled", G_CALLBACK (on_button_selection_changed),co);
1041
1042 g_signal_connect (G_OBJECT (co->priv->widgets.other_c_flags_entry), "changed",
1043 G_CALLBACK (on_entry_changed), co);
1044
1045 g_signal_connect (G_OBJECT (co->priv->widgets.other_l_flags_entry), "changed",
1046 G_CALLBACK (on_entry_changed), co);
1047
1048 g_signal_connect (G_OBJECT (co->priv->widgets.other_l_libs_entry), "changed",
1049 G_CALLBACK (on_entry_changed), co);
1050
1051 /* optimization buttons */
1052 for (i = 0 ; i < 4 ; i++)
1053 g_signal_connect (GTK_TOGGLE_BUTTON (co->priv->widgets.optimize_button[i]),
1054 "toggled", G_CALLBACK (on_button_selection_changed),co);
1055
1056 /* debug and profile */
1057 for (i = 0 ; i < 2 ; i++)
1058 g_signal_connect (GTK_TOGGLE_BUTTON (co->priv->widgets.other_button[i]),
1059 "toggled", G_CALLBACK (on_button_selection_changed),co);
1060
1061 g_signal_connect (G_OBJECT (co->priv->widgets.other_c_flags_entry), "changed",
1062 G_CALLBACK (on_entry_changed), co);
1063
1064 g_signal_connect (G_OBJECT (co->priv->widgets.other_l_flags_entry), "changed",
1065 G_CALLBACK (on_entry_changed), co);
1066
1067 g_signal_connect (G_OBJECT (co->priv->widgets.other_l_libs_entry), "changed",
1068 G_CALLBACK (on_entry_changed), co);
1069
1070 /* optimization buttons */
1071 for (i = 0 ; i < 4 ; i++)
1072 g_signal_connect (GTK_TOGGLE_BUTTON (co->priv->widgets.optimize_button[i]),
1073 "toggled", G_CALLBACK (on_button_selection_changed),co);
1074
1075 /* debug and profile */
1076 for (i = 0 ; i < 2 ; i++)
1077 g_signal_connect (GTK_TOGGLE_BUTTON (co->priv->widgets.other_button[i]),
1078 "toggled", G_CALLBACK (on_button_selection_changed),co);
1079
1080 /* Connect editiong button signals */
1081 button = glade_xml_get_widget (co->priv->gxml, "inc_add_b");
1082 BUTTON_SIGNAL_CONNECT (button, on_add_to_clist_clicked,
1083 entry_signal_info_new (co, co->priv->widgets.inc_clist,
1084 co->priv->widgets.inc_entry,
1085 INC_PATHS_COLUMN));
1086 button = glade_xml_get_widget (co->priv->gxml, "inc_update_b");
1087 BUTTON_SIGNAL_CONNECT (button, on_update_in_clist_clicked,
1088 entry_signal_info_new (co, co->priv->widgets.inc_clist,
1089 co->priv->widgets.inc_entry,
1090 INC_PATHS_COLUMN));
1091 button = glade_xml_get_widget (co->priv->gxml, "inc_remove_b");
1092 BUTTON_SIGNAL_CONNECT (button, on_remove_from_clist_clicked,
1093 entry_signal_info_new (co, co->priv->widgets.inc_clist,
1094 co->priv->widgets.inc_entry,
1095 INC_PATHS_COLUMN));
1096 button = glade_xml_get_widget (co->priv->gxml, "inc_clear_b");
1097 BUTTON_SIGNAL_CONNECT (button, on_clear_clist_clicked,
1098 entry_signal_info_new (co, co->priv->widgets.inc_clist,
1099 co->priv->widgets.inc_entry,
1100 INC_PATHS_COLUMN));
1101
1102 button = glade_xml_get_widget (co->priv->gxml, "lib_add_b");
1103 BUTTON_SIGNAL_CONNECT (button, on_add_to_clist_clicked,
1104 entry_signal_info_new (co, co->priv->widgets.lib_clist,
1105 co->priv->widgets.lib_entry,
1106 LIB_COLUMN));
1107 button = glade_xml_get_widget (co->priv->gxml, "lib_update_b");
1108 BUTTON_SIGNAL_CONNECT (button, on_update_in_clist_clicked,
1109 entry_signal_info_new (co, co->priv->widgets.lib_clist,
1110 co->priv->widgets.lib_entry,
1111 LIB_COLUMN));
1112 button = glade_xml_get_widget (co->priv->gxml, "lib_remove_b");
1113 BUTTON_SIGNAL_CONNECT (button, on_remove_from_clist_clicked,
1114 entry_signal_info_new (co, co->priv->widgets.lib_clist,
1115 co->priv->widgets.lib_entry,
1116 LIB_COLUMN));
1117 button = glade_xml_get_widget (co->priv->gxml, "lib_clear_b");
1118 BUTTON_SIGNAL_CONNECT (button, on_clear_clist_clicked,
1119 entry_signal_info_new (co, co->priv->widgets.lib_clist,
1120 co->priv->widgets.lib_entry,
1121 LIB_COLUMN));
1122
1123 button = glade_xml_get_widget (co->priv->gxml, "lib_paths_add_b");
1124 BUTTON_SIGNAL_CONNECT (button, on_add_to_clist_clicked,
1125 entry_signal_info_new (co, co->priv->widgets.lib_paths_clist,
1126 co->priv->widgets.lib_paths_entry,
1127 LIB_PATHS_COLUMN));
1128 button = glade_xml_get_widget (co->priv->gxml, "lib_paths_update_b");
1129 BUTTON_SIGNAL_CONNECT (button, on_update_in_clist_clicked,
1130 entry_signal_info_new (co, co->priv->widgets.lib_paths_clist,
1131 co->priv->widgets.lib_paths_entry,
1132 LIB_PATHS_COLUMN));
1133 button = glade_xml_get_widget (co->priv->gxml, "lib_paths_remove_b");
1134 BUTTON_SIGNAL_CONNECT (button, on_remove_from_clist_clicked,
1135 entry_signal_info_new (co, co->priv->widgets.lib_paths_clist,
1136 co->priv->widgets.lib_paths_entry,
1137 LIB_PATHS_COLUMN));
1138 button = glade_xml_get_widget (co->priv->gxml, "lib_paths_clear_b");
1139 BUTTON_SIGNAL_CONNECT (button, on_clear_clist_clicked,
1140 entry_signal_info_new (co, co->priv->widgets.lib_paths_clist,
1141 co->priv->widgets.lib_paths_entry,
1142 LIB_PATHS_COLUMN));
1143
1144 button = glade_xml_get_widget (co->priv->gxml, "def_add_b");
1145 BUTTON_SIGNAL_CONNECT (button, on_add_to_clist_clicked,
1146 entry_signal_info_new (co, co->priv->widgets.def_clist,
1147 co->priv->widgets.def_entry,
1148 DEF_DEFINE_COLUMN));
1149 button = glade_xml_get_widget (co->priv->gxml, "def_update_b");
1150 BUTTON_SIGNAL_CONNECT (button, on_update_in_clist_clicked,
1151 entry_signal_info_new (co, co->priv->widgets.def_clist,
1152 co->priv->widgets.def_entry,
1153 DEF_DEFINE_COLUMN));
1154 button = glade_xml_get_widget (co->priv->gxml, "lib_paths_remove_b");
1155 BUTTON_SIGNAL_CONNECT (button, on_remove_from_clist_clicked,
1156 entry_signal_info_new (co, co->priv->widgets.def_clist,
1157 co->priv->widgets.def_entry,
1158 DEF_DEFINE_COLUMN));
1159 button = glade_xml_get_widget (co->priv->gxml, "lib_paths_clear_b");
1160 BUTTON_SIGNAL_CONNECT (button, on_clear_clist_clicked,
1161 entry_signal_info_new (co, co->priv->widgets.def_clist,
1162 co->priv->widgets.def_entry,
1163 DEF_DEFINE_COLUMN));
1164 gtk_widget_ref (co->priv->widgets.window);
1165 gtk_widget_ref (co->priv->widgets.warnings_clist);
1166 for (i = 0; i < 4; i++)
1167 gtk_widget_ref (co->priv->widgets.optimize_button[i]);
1168 for (i = 0; i < 2; i++)
1169 gtk_widget_ref (co->priv->widgets.other_button[i]);
1170
1171 gtk_widget_ref (co->priv->widgets.inc_clist);
1172 gtk_widget_ref (co->priv->widgets.inc_entry);
1173 gtk_widget_ref (co->priv->widgets.lib_paths_clist);
1174 gtk_widget_ref (co->priv->widgets.lib_paths_entry);
1175 gtk_widget_ref (co->priv->widgets.lib_clist);
1176 gtk_widget_ref (co->priv->widgets.lib_stock_clist);
1177 gtk_widget_ref (co->priv->widgets.lib_entry);
1178 gtk_widget_ref (co->priv->widgets.def_clist);
1179 gtk_widget_ref (co->priv->widgets.def_stock_clist);
1180 gtk_widget_ref (co->priv->widgets.def_entry);
1181 gtk_widget_ref (co->priv->widgets.other_c_flags_entry);
1182 gtk_widget_ref (co->priv->widgets.other_l_flags_entry);
1183 gtk_widget_ref (co->priv->widgets.other_l_libs_entry);
1184 gtk_widget_ref (co->priv->widgets.supp_clist);
1185 }
1186
1187 CompilerOptions *
1188 compiler_options_new (PropsID props)
1189 {
1190 CompilerOptions *co = g_new0 (CompilerOptions, 1);
1191
1192 co->priv = g_new0 (CompilerOptionsPriv, 1);
1193 co->priv->is_showing = FALSE;
1194 co->priv->win_pos_x = 100;
1195 co->priv->win_pos_y = 100;
1196 co->priv->props = props;
1197 create_compiler_options_gui (co);
1198 co->priv->dirty = FALSE;
1199
1200 return co;
1201 }
1202
1203 void
1204 compiler_options_destroy (CompilerOptions * co)
1205 {
1206 gint i;
1207 g_return_if_fail (co);
1208
1209 gtk_widget_unref (co->priv->widgets.window);
1210 gtk_widget_unref (co->priv->widgets.warnings_clist);
1211 for (i = 0; i < 4; i++)
1212 gtk_widget_unref (co->priv->widgets.optimize_button[i]);
1213 for (i = 0; i < 2; i++)
1214 gtk_widget_unref (co->priv->widgets.other_button[i]);
1215
1216 gtk_widget_unref (co->priv->widgets.inc_clist);
1217 gtk_widget_unref (co->priv->widgets.inc_entry);
1218 gtk_widget_unref (co->priv->widgets.lib_paths_clist);
1219 gtk_widget_unref (co->priv->widgets.lib_paths_entry);
1220 gtk_widget_unref (co->priv->widgets.lib_clist);
1221 gtk_widget_unref (co->priv->widgets.lib_stock_clist);
1222 gtk_widget_unref (co->priv->widgets.lib_entry);
1223 gtk_widget_unref (co->priv->widgets.def_clist);
1224 gtk_widget_unref (co->priv->widgets.def_stock_clist);
1225 gtk_widget_unref (co->priv->widgets.def_entry);
1226 gtk_widget_unref (co->priv->widgets.other_c_flags_entry);
1227 gtk_widget_unref (co->priv->widgets.other_l_flags_entry);
1228 gtk_widget_unref (co->priv->widgets.other_l_libs_entry);
1229 gtk_widget_unref (co->priv->widgets.supp_clist);
1230
1231 if (co->priv->widgets.window)
1232 gtk_widget_destroy (co->priv->widgets.window);
1233 g_object_unref (co->priv->gxml);
1234
1235 g_free (co->priv);
1236 g_free (co);
1237 }
1238
1239 gboolean compiler_options_save_yourself (CompilerOptions * co, FILE * stream)
1240 {
1241 if (stream == NULL || co == NULL)
1242 return FALSE;
1243 fprintf (stream, "compiler.options.win.pos.x=%d\n", co->priv->win_pos_x);
1244 fprintf (stream, "compiler.options.win.pos.y=%d\n", co->priv->win_pos_y);
1245 return TRUE;
1246 }
1247
1248 gint compiler_options_save (CompilerOptions * co, FILE * s)
1249 {
1250 const gchar *text;
1251 gint i;
1252 GtkTreeIter iter;
1253 GtkTreeModel *model;
1254 gboolean valid;
1255
1256 g_return_val_if_fail (co != NULL, FALSE);
1257 g_return_val_if_fail (s != NULL, FALSE);
1258
1259 /* Save support list */
1260 model =
1261 gtk_tree_view_get_model (GTK_TREE_VIEW(co->priv->widgets.supp_clist));
1262 valid = gtk_tree_model_get_iter_first (model, &iter);
1263 fprintf (s, "compiler.options.supports=");
1264 while (valid)
1265 {
1266 gboolean state;
1267 gchar *name;
1268 gtk_tree_model_get (model, &iter, SUPP_TOGGLE_COLUMN, &state,
1269 SUPP_NAME_COLUMN, &name, -1);
1270 if(state)
1271 {
1272 if (fprintf (s, "%s ", name) <1)
1273 return FALSE;
1274 }
1275 valid = gtk_tree_model_iter_next (model, &iter);
1276 }
1277 fprintf (s, "\n");
1278
1279 /* Save include paths list */
1280 model =
1281 gtk_tree_view_get_model (GTK_TREE_VIEW(co->priv->widgets.inc_clist));
1282 valid = gtk_tree_model_get_iter_first (model, &iter);
1283 fprintf (s, "compiler.options.include.paths=");
1284 while (valid)
1285 {
1286 gchar *path;
1287 gtk_tree_model_get (model, &iter, INC_PATHS_COLUMN, &path, -1);
1288 if (fprintf (s, "\\\n\t%s", path) <1)
1289 return FALSE;
1290 valid = gtk_tree_model_iter_next (model, &iter);
1291 }
1292 fprintf (s, "\n");
1293
1294 /* Save library paths list */
1295 model =
1296 gtk_tree_view_get_model (GTK_TREE_VIEW(co->priv->widgets.lib_paths_clist));
1297 valid = gtk_tree_model_get_iter_first (model, &iter);
1298 fprintf (s, "compiler.options.library.paths=");
1299 while (valid)
1300 {
1301 gchar *path;
1302 gtk_tree_model_get (model, &iter, LIB_PATHS_COLUMN, &path, -1);
1303 if (fprintf (s, "\\\n\t%s", path) <1)
1304 return FALSE;
1305 valid = gtk_tree_model_iter_next (model, &iter);
1306 }
1307 fprintf (s, "\n");
1308
1309 /* Save libraries list */
1310 model =
1311 gtk_tree_view_get_model (GTK_TREE_VIEW(co->priv->widgets.lib_clist));
1312 valid = gtk_tree_model_get_iter_first (model, &iter);
1313 fprintf (s, "compiler.options.libraries=");
1314 while (valid)
1315 {
1316 gchar *name;
1317 gtk_tree_model_get (model, &iter, LIB_COLUMN, &name, -1);
1318 if (fprintf (s, "\\\n\t%s", name) <1)
1319 return FALSE;
1320 valid = gtk_tree_model_iter_next (model, &iter);
1321 }
1322 fprintf (s, "\n");
1323
1324
1325 /* Save selected libraries list */
1326 model =
1327 gtk_tree_view_get_model (GTK_TREE_VIEW(co->priv->widgets.lib_clist));
1328 valid = gtk_tree_model_get_iter_first (model, &iter);
1329 fprintf (s, "compiler.options.libraries.selected=");
1330 while (valid)
1331 {
1332 gboolean state;
1333 gtk_tree_model_get (model, &iter, LIB_TOGGLE_COLUMN, &state, -1);
1334 if (fprintf (s, "%d ", state) <1)
1335 return FALSE;
1336 valid = gtk_tree_model_iter_next (model, &iter);
1337 }
1338 fprintf (s, "\n");
1339
1340 /* Save defines list */
1341 model =
1342 gtk_tree_view_get_model (GTK_TREE_VIEW(co->priv->widgets.def_clist));
1343 valid = gtk_tree_model_get_iter_first (model, &iter);
1344 fprintf (s, "compiler.options.defines=");
1345 while (valid)
1346 {
1347 gchar *name;
1348 gtk_tree_model_get (model, &iter, DEF_DEFINE_COLUMN, &name, -1);
1349 if (fprintf (s, "\\\n\t%s", name) <1)
1350 return FALSE;
1351 valid = gtk_tree_model_iter_next (model, &iter);
1352 }
1353 fprintf (s, "\n");
1354
1355
1356 /* Save selected defines list */
1357 model =
1358 gtk_tree_view_get_model (GTK_TREE_VIEW(co->priv->widgets.lib_clist));
1359 valid = gtk_tree_model_get_iter_first (model, &iter);
1360 fprintf (s, "compiler.options.defines.selected=");
1361 while (valid)
1362 {
1363 gboolean state;
1364 gtk_tree_model_get (model, &iter, DEF_TOGGLE_COLUMN, &state, -1);
1365 if (fprintf (s, "%d ", state) <1)
1366 return FALSE;
1367 valid = gtk_tree_model_iter_next (model, &iter);
1368 }
1369 fprintf (s, "\n");
1370
1371
1372 /* Save warnings list */
1373 model =
1374 gtk_tree_view_get_model (GTK_TREE_VIEW(co->priv->widgets.warnings_clist));
1375 valid = gtk_tree_model_get_iter_first (model, &iter);
1376 fprintf (s, "compiler.options.warning.buttons=");
1377 while (valid)
1378 {
1379 gboolean state;
1380 gtk_tree_model_get (model, &iter, WARNINGS_TOGGLE_COLUMN, &state, -1);
1381 if (fprintf (s, "%d ", state) <1)
1382 return FALSE;
1383 valid = gtk_tree_model_iter_next (model, &iter);
1384 }
1385 fprintf (s, "\n");
1386
1387 fprintf (s, "compiler.options.optimize.buttons=");
1388 for (i = 0; i < 4; i++)
1389 {
1390 gboolean state;
1391 state = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(co->priv->
1392 widgets.optimize_button[i]));
1393 fprintf (s, "%d ", (int) state);
1394 }
1395 fprintf (s, "\n");
1396
1397 fprintf (s, "compiler.options.other.buttons=");
1398 for (i = 0; i < 2; i++)
1399 {
1400 gboolean state;
1401 state = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(co->priv->
1402 widgets.other_button[i]));
1403 fprintf (s, "%d ", (int) state);
1404 }
1405 fprintf (s, "\n");
1406
1407 text = gtk_entry_get_text (GTK_ENTRY (co->priv->widgets.other_c_flags_entry));
1408 fprintf (s, "compiler.options.other.c.flags=%s\n", text);
1409
1410 text = gtk_entry_get_text (GTK_ENTRY (co->priv->widgets.other_l_flags_entry));
1411 fprintf (s, "compiler.options.other.l.flags=%s\n", text);
1412
1413 text = gtk_entry_get_text (GTK_ENTRY (co->priv->widgets.other_l_libs_entry));
1414 fprintf (s, "compiler.options.other.l.libs=%s\n", text);
1415
1416 fprintf (s, "\n");
1417 return TRUE;
1418 }
1419
1420 gboolean compiler_options_load_yourself (CompilerOptions * co, PropsID props)
1421 {
1422 if (co == NULL)
1423 return FALSE;
1424 co->priv->win_pos_x =
1425 prop_get_int (props, "compiler.options.win.pos.x", 100);
1426 co->priv->win_pos_y =
1427 prop_get_int (props, "compiler.options.win.pos.y", 100);
1428 return TRUE;
1429 }
1430
1431 #define CLIST_CLEAR_ALL(widget) \
1432 model = gtk_tree_view_get_model (GTK_TREE_VIEW(widget)); \
1433 g_assert (model); \
1434 if (model) gtk_list_store_clear (GTK_LIST_STORE (model));
1435
1436 #define CLIST_APPEND_STRING_ALL(property, widget, col) \
1437 list = glist_from_data (props, property); \
1438 model = gtk_tree_view_get_model (GTK_TREE_VIEW(widget)); \
1439 g_assert (model); \
1440 node = list; \
1441 while (node) \
1442 { \
1443 gtk_list_store_append (GTK_LIST_STORE(model), &iter); \
1444 gtk_list_store_set (GTK_LIST_STORE(model), \
1445 &iter, col, node->data, -1); \
1446 node = g_list_next (node); \
1447 } \
1448 glist_strings_free (list);
1449
1450 #define CLIST_UPDATE_BOOLEAN_ALL(property, widget, col) \
1451 list = glist_from_data (props, property); \
1452 model = gtk_tree_view_get_model (GTK_TREE_VIEW(widget)); \
1453 g_assert (model); \
1454 valid = gtk_tree_model_get_iter_first (model, &iter); \
1455 node = list; \
1456 while (node && valid) \
1457 { \
1458 int value = atoi(node->data); \
1459 gtk_list_store_set (GTK_LIST_STORE(model), &iter, col, value, -1); \
1460 node = g_list_next (node); \
1461 valid = gtk_tree_model_iter_next (model, &iter); \
1462 } \
1463 glist_strings_free (list);
1464
1465
1466 void
1467 compiler_options_clear(CompilerOptions *co)
1468 {
1469 gint i;
1470 GtkTreeModel* model;
1471 GtkTreeIter iter;
1472 gboolean valid;
1473
1474 g_return_if_fail (co != NULL);
1475
1476 gtk_widget_set_sensitive (co->priv->widgets.supp_clist, TRUE);
1477
1478 model = gtk_tree_view_get_model (GTK_TREE_VIEW(co->priv->widgets.supp_clist));
1479 g_assert (model);
1480
1481 /* Clear all supports */
1482 valid = gtk_tree_model_get_iter_first (model, &iter);
1483 while (valid)
1484 {
1485 gtk_list_store_set (GTK_LIST_STORE(model), &iter,
1486 SUPP_TOGGLE_COLUMN, FALSE, -1);
1487 valid = gtk_tree_model_iter_next (model, &iter);
1488 }
1489
1490 CLIST_CLEAR_ALL(co->priv->widgets.inc_clist);
1491 CLIST_CLEAR_ALL(co->priv->widgets.lib_paths_clist);
1492 CLIST_CLEAR_ALL(co->priv->widgets.lib_clist);
1493 CLIST_CLEAR_ALL(co->priv->widgets.def_clist);
1494
1495 gtk_entry_set_text (GTK_ENTRY (co->priv->widgets.inc_entry), "");
1496 gtk_entry_set_text (GTK_ENTRY (co->priv->widgets.lib_paths_entry), "");
1497 gtk_entry_set_text (GTK_ENTRY (co->priv->widgets.lib_entry), "");
1498 gtk_entry_set_text (GTK_ENTRY (co->priv->widgets.def_entry), "");
1499
1500 for (i = 0; i < 4; i++)
1501 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(co->priv->widgets.optimize_button[i]), FALSE);
1502 for (i = 0; i < 2; i++)
1503 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(co->priv->widgets.other_button[i]), FALSE);
1504
1505 model = gtk_tree_view_get_model (GTK_TREE_VIEW(co->priv->widgets.warnings_clist));
1506 g_assert (model);
1507 valid = gtk_tree_model_get_iter_first (model, &iter);
1508 while (valid)
1509 {
1510 gtk_list_store_set (GTK_LIST_STORE(model), &iter, 0, FALSE, -1);
1511 valid = gtk_tree_model_iter_next (model, &iter);
1512 }
1513
1514 gtk_entry_set_text (GTK_ENTRY(co->priv->widgets.other_c_flags_entry), "");
1515 gtk_entry_set_text (GTK_ENTRY(co->priv->widgets.other_l_flags_entry), "");
1516 gtk_entry_set_text (GTK_ENTRY(co->priv->widgets.other_l_libs_entry), "");
1517 compiler_options_set_in_properties(co, co->priv->props);
1518 }
1519
1520 #define ASSIGN_PROPERTY_VALUE_TO_ENTRY(props, key, entry) \
1521 { \
1522 gchar *str = prop_get ((props), (key)); \
1523 if (str) { \
1524 gtk_entry_set_text (GTK_ENTRY((entry)), str); \
1525 g_free (str); \
1526 } else { \
1527 gtk_entry_set_text (GTK_ENTRY((entry)), ""); \
1528 } \
1529 }
1530
1531 void
1532 compiler_options_load (CompilerOptions * co, PropsID props)
1533 {
1534 GtkTreeModel *model;
1535 GtkTreeIter iter;
1536 GList *list, *node;
1537 gboolean valid;
1538 gint i;
1539
1540 g_return_if_fail (co != NULL);
1541
1542 compiler_options_clear (co);
1543
1544 /* Read all available supports for the project */
1545 list = glist_from_data (props, "compiler.options.supports");
1546 node = list;
1547 while (node)
1548 {
1549 if (node->data)
1550 {
1551 GtkTreeView *clist;
1552
1553 clist = GTK_TREE_VIEW(co->priv->widgets.supp_clist);
1554 model = gtk_tree_view_get_model (clist);
1555 g_assert (model);
1556 valid = gtk_tree_model_get_iter_first (model, &iter);
1557 while (valid)
1558 {
1559 gchar *name;
1560 gtk_tree_model_get (model, &iter, SUPP_NAME_COLUMN, &name, -1);
1561 if (strcasecmp (name, node->data)==0)
1562 {
1563 gtk_list_store_set (GTK_LIST_STORE(model), &iter,
1564 SUPP_TOGGLE_COLUMN, TRUE, -1);
1565 break;
1566 }
1567 valid = gtk_tree_model_iter_next (model, &iter);
1568 }
1569 }
1570 node = g_list_next (node);
1571 }
1572 glist_strings_free (list);
1573
1574 /* For now, disable supports for projects. */
1575 if (app->project_dbase->project_is_open == TRUE)
1576 {
1577 gtk_widget_set_sensitive (co->priv->widgets.supp_clist, FALSE);
1578 }
1579
1580 CLIST_APPEND_STRING_ALL ("compiler.options.include.paths",
1581 co->priv->widgets.inc_clist, INC_PATHS_COLUMN);
1582 CLIST_APPEND_STRING_ALL ("compiler.options.library.paths",
1583 co->priv->widgets.lib_paths_clist,
1584 LIB_PATHS_COLUMN);
1585 CLIST_APPEND_STRING_ALL ("compiler.options.libraries",
1586 co->priv->widgets.lib_clist, LIB_COLUMN);
1587 CLIST_UPDATE_BOOLEAN_ALL ("compiler.options.libraries.selected",
1588 co->priv->widgets.lib_clist, LIB_TOGGLE_COLUMN);
1589 CLIST_APPEND_STRING_ALL ("compiler.options.defines",
1590 co->priv->widgets.def_clist, DEF_DEFINE_COLUMN);
1591 CLIST_UPDATE_BOOLEAN_ALL ("compiler.options.defines.selected",
1592 co->priv->widgets.def_clist, DEF_TOGGLE_COLUMN);
1593 CLIST_UPDATE_BOOLEAN_ALL ("compiler.options.warning.buttons",
1594 co->priv->widgets.warnings_clist,
1595 WARNINGS_TOGGLE_COLUMN);
1596
1597 list = glist_from_data (props, "compiler.options.optimize.buttons");
1598 node = list;
1599 i = 0;
1600 while (node)
1601 {
1602 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(co->priv->
1603 widgets.optimize_button[i]),
1604 atoi(node->data));
1605 node = g_list_next (node);
1606 i++;
1607 }
1608 glist_strings_free (list);
1609
1610 list = glist_from_data (props, "compiler.options.other.buttons");
1611 node = list;
1612 i = 0;
1613 while (node) {
1614 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(co->priv->
1615 widgets.other_button[i]),
1616 atoi(node->data));
1617 node = g_list_next (node);
1618 i++;
1619 }
1620 glist_strings_free (list);
1621
1622 ASSIGN_PROPERTY_VALUE_TO_ENTRY(props, "compiler.options.other.c.flags",
1623 co->priv->widgets.other_c_flags_entry);
1624 ASSIGN_PROPERTY_VALUE_TO_ENTRY(props, "compiler.options.other.l.flags",
1625 co->priv->widgets.other_l_flags_entry);
1626 ASSIGN_PROPERTY_VALUE_TO_ENTRY(props, "compiler.options.other.l.libs",
1627 co->priv->widgets.other_l_libs_entry);
1628
1629 compiler_options_set_in_properties (co, co->priv->props);
1630
1631 compiler_options_set_dirty_flag (co, FALSE);
1632 }
1633
1634 void
1635 compiler_options_show (CompilerOptions * co)
1636 {
1637 if (co->priv->is_showing)
1638 {
1639 gdk_window_raise (co->priv->widgets.window->window);
1640 return;
1641 }
1642 gtk_widget_set_uposition (co->priv->widgets.window, co->priv->win_pos_x,
1643 co->priv->win_pos_y);
1644 gtk_widget_show (co->priv->widgets.window);
1645 co->priv->is_showing = TRUE;
1646 }
1647
1648 void
1649 compiler_options_hide (CompilerOptions * co)
1650 {
1651 if (!co)
1652 return;
1653 if (co->priv->is_showing == FALSE)
1654 return;
1655 gdk_window_get_root_origin (co->priv->widgets.window->window,
1656 &co->priv->win_pos_x, &co->priv->win_pos_y);
1657 gtk_widget_hide (co->priv->widgets.window);
1658 co->priv->is_showing = FALSE;
1659 }
1660
1661 #define GET_ALL_STRING_DATA(widget, str, separator, col) \
1662 { \
1663 GtkTreeModel *model; \
1664 GtkTreeIter iter; \
1665 gboolean valid; \
1666 gchar* tmp; \
1667 model = gtk_tree_view_get_model (GTK_TREE_VIEW(widget)); \
1668 g_assert(model); \
1669 valid = gtk_tree_model_get_iter_first(model, &iter); \
1670 while (valid) \
1671 { \
1672 gchar *text; \
1673 gtk_tree_model_get (model, &iter, col, &text, -1); \
1674 tmp = g_strconcat (str, separator, text, NULL); \
1675 g_free (str); \
1676 str = tmp; \
1677 valid = gtk_tree_model_iter_next (model, &iter); \
1678 } \
1679 }
1680
1681 static gchar *
1682 get_supports (CompilerOptions *co, gint item, gchar *separator)
1683 {
1684 GtkTreeModel *model;
1685 GtkTreeIter iter;
1686 gboolean valid;
1687 gchar *str;
1688 gchar *pkg_modules;
1689 gint i;
1690 gboolean has_pkg_modules = FALSE;
1691
1692 str = g_strdup ("");
1693 pkg_modules = g_strdup ("");
1694
1695 model =
1696 gtk_tree_view_get_model (GTK_TREE_VIEW(co->priv->widgets.supp_clist));
1697 g_assert(model);
1698 valid = gtk_tree_model_get_iter_first(model, &iter);
1699 i = 0;
1700 while (valid)
1701 {
1702 gboolean value, pkgconfig;
1703 gchar *text, *tmp, *name;
1704
1705 gtk_tree_model_get (model, &iter,
1706 SUPP_TOGGLE_COLUMN, &value,
1707 SUPP_PKGCONFIG_COLUMN, &pkgconfig,
1708 SUPP_NAME_COLUMN, &name, -1);
1709 valid = gtk_tree_model_iter_next (model, &iter);
1710 if (!value)
1711 {
1712 i++;
1713 continue;
1714 }
1715 if (!pkgconfig)
1716 {
1717 text = anjuta_supports [i][item];
1718 tmp = g_strconcat (str, text, separator, NULL);
1719 g_free (str);
1720 str = tmp;
1721 }
1722 else
1723 {
1724 has_pkg_modules = TRUE;
1725 tmp = pkg_modules;
1726 pkg_modules = g_strconcat (tmp, " ", name, NULL);
1727 g_free (tmp);
1728 }
1729 if (name)
1730 g_free(name);
1731 i++;
1732 }
1733 if (has_pkg_modules)
1734 {
1735 gchar *text, *tmp;
1736
1737 switch (item)
1738 {
1739 case ANJUTA_SUPPORT_FILE_CFLAGS:
1740 text = g_strconcat ("`pkg-config --cflags", pkg_modules, "`", NULL);
1741 break;
1742 case ANJUTA_SUPPORT_FILE_LIBS:
1743 text = g_strconcat ("`pkg-config --libs", pkg_modules, "`", NULL);
1744 break;
1745 case ANJUTA_SUPPORT_PRJ_CFLAGS:
1746 text = g_strconcat ("`pkg-config --cflags", pkg_modules, "`", NULL);
1747 break;
1748 case ANJUTA_SUPPORT_PRJ_LIBS:
1749 text = g_strconcat ("`pkg-config --libs", pkg_modules, "`", NULL);
1750 break;
1751 case ANJUTA_SUPPORT_MACROS:
1752 text = g_strdup (""); //FIXME.
1753 break;
1754 }
1755 tmp = str;
1756 str = g_strconcat (tmp, " ", text, NULL);
1757 g_free (tmp);
1758 g_free (text);
1759 }
1760 g_free (pkg_modules);
1761 return str;
1762 }
1763
1764 static gchar *
1765 get_include_paths (CompilerOptions * co, gboolean with_support)
1766 {
1767 gchar *str;
1768
1769 str = g_strdup ("");
1770 GET_ALL_STRING_DATA (co->priv->widgets.inc_clist,
1771 str, " -I", INC_PATHS_COLUMN);
1772
1773 if (with_support)
1774 {
1775 gchar *supports = get_supports (co, ANJUTA_SUPPORT_FILE_CFLAGS, " ");
1776 gchar *tmp = g_strconcat (str, supports, NULL);
1777 g_free (str);
1778 g_free (supports);
1779 str = tmp;
1780 }
1781 return str;
1782 }
1783
1784 static gchar *
1785 get_library_paths (CompilerOptions * co)
1786 {
1787 gchar *str;
1788
1789 str = g_strdup ("");
1790 GET_ALL_STRING_DATA (co->priv->widgets.lib_paths_clist, str,
1791 " -L", LIB_PATHS_COLUMN);
1792 return str;
1793 }
1794
1795 static gchar *
1796 get_libraries (CompilerOptions * co, gboolean with_support)
1797 {
1798 GtkTreeModel *model;
1799 GtkTreeIter iter;
1800 gboolean valid;
1801 gchar *str, *tmp;
1802 gchar *text;
1803
1804 str = g_strdup ("");
1805 model = gtk_tree_view_get_model (GTK_TREE_VIEW(co->priv->widgets.lib_clist));
1806 g_assert(model);
1807 valid = gtk_tree_model_get_iter_first (model, &iter);
1808 while (valid)
1809 {
1810 gboolean value;
1811
1812 gtk_tree_model_get (model, &iter, LIB_TOGGLE_COLUMN,
1813 &value, LIB_COLUMN, &text, -1);
1814 valid = gtk_tree_model_iter_next (model, &iter);
1815 if (!value)
1816 continue;
1817
1818 /* If it starts with '*' then consider it as an object file
1819 * and not a lib file
1820 */
1821 if (*text == '*')
1822 /* Remove the '*' and put the rest */
1823 tmp = g_strconcat (str, " ", &text[1], NULL);
1824 else /* Lib file */
1825 tmp = g_strconcat (str, " -l", text, NULL);
1826 g_free (str);
1827 str = tmp;
1828 }
1829 if (with_support)
1830 {
1831 gchar *supports = get_supports (co, ANJUTA_SUPPORT_FILE_LIBS, " ");
1832 gchar *tmp = g_strconcat (str, supports, NULL);
1833 g_free (str);
1834 g_free (supports);
1835 str = tmp;
1836 }
1837 return str;
1838 }
1839
1840 static gchar *
1841 get_defines (CompilerOptions * co)
1842 {
1843 gchar *str;
1844 str = g_strdup ("");
1845 GET_ALL_STRING_DATA (co->priv->widgets.def_clist, str,
1846 " -D", DEF_DEFINE_COLUMN);
1847 return str;
1848 }
1849
1850 static gchar*
1851 get_warnings(CompilerOptions *co)
1852 {
1853 GtkTreeModel *model;
1854 GtkTreeIter iter;
1855 gboolean valid;
1856 gchar *str, *tmp;
1857 gint i;
1858
1859 str = g_strdup ("");
1860 model = gtk_tree_view_get_model (GTK_TREE_VIEW(co->priv->
1861 widgets.warnings_clist));
1862 g_assert(model);
1863 valid = gtk_tree_model_get_iter_first (model, &iter);
1864 i = 0;
1865 while (valid)
1866 {
1867 gboolean value;
1868 gtk_tree_model_get (model, &iter, WARNINGS_TOGGLE_COLUMN,
1869 &value, -1);
1870 valid = gtk_tree_model_iter_next (model, &iter);
1871 if (!value)
1872 {
1873 i += 2;
1874 continue;
1875 }
1876 tmp = str;
1877 str = g_strconcat (tmp, anjuta_warnings[i], NULL);
1878 g_free (tmp);
1879 i += 2;
1880 }
1881 return str;
1882 }
1883
1884 static gchar*
1885 get_optimization (CompilerOptions *co)
1886 {
1887 gchar *str;
1888 gint i;
1889
1890 str = g_strdup ("");
1891 for (i = 0; i < 4; i++)
1892 {
1893 gboolean state;
1894 gchar *tmp;
1895 GtkToggleButton *b;
1896
1897 b= GTK_TOGGLE_BUTTON (co->priv->widgets.optimize_button[i]);
1898 state = gtk_toggle_button_get_active (b);
1899 if (state)
1900 {
1901 tmp = str;
1902 str = g_strconcat (tmp, optimize_button_option[i], NULL);
1903 g_free (tmp);
1904 }
1905 }
1906 return str;
1907 }
1908
1909 static gchar*
1910 get_others (CompilerOptions *co)
1911 {
1912 gchar *str;
1913 gint i;
1914
1915 str = g_strdup ("");
1916 for (i = 0; i < 2; i++)
1917 {
1918 gboolean state;
1919 gchar *tmp;
1920 GtkToggleButton *b;
1921
1922 b = GTK_TOGGLE_BUTTON (co->priv->widgets.other_button[i]);
1923 state = gtk_toggle_button_get_active (b);
1924 if (state)
1925 {
1926 tmp = str;
1927 str = g_strconcat (tmp, other_button_option[i], NULL);
1928 g_free (tmp);
1929 }
1930 }
1931 return str;
1932 }
1933
1934 void
1935 compiler_options_set_in_properties (CompilerOptions * co, PropsID props)
1936 {
1937 gchar *buff;
1938
1939 buff = get_include_paths (co, TRUE);
1940 prop_set_with_key (props, "anjuta.compiler.includes", buff);
1941 g_free (buff);
1942
1943 buff = get_library_paths (co);
1944 prop_set_with_key (props, "anjuta.linker.library.paths", buff);
1945 g_free (buff);
1946
1947 buff = get_libraries (co, TRUE);
1948 prop_set_with_key (props, "anjuta.linker.libraries", buff);
1949 g_free (buff);
1950
1951 buff = get_defines (co);
1952 prop_set_with_key (props, "anjuta.compiler.defines", buff);
1953 g_free (buff);
1954
1955 buff = get_warnings(co);
1956 prop_set_with_key (props, "anjuta.compiler.warning.flags", buff);
1957 g_free (buff);
1958
1959
1960 buff = get_optimization(co);
1961 prop_set_with_key (props, "anjuta.compiler.optimization.flags", buff);
1962 g_free (buff);
1963
1964 buff = get_others(co);
1965 prop_set_with_key (props, "anjuta.compiler.other.flags", buff);
1966 g_free (buff);
1967
1968 prop_set_with_key (props, "anjuta.compiler.additional.flags",
1969 gtk_entry_get_text (GTK_ENTRY (co->priv->widgets.other_c_flags_entry)));
1970 prop_set_with_key (props, "anjuta.linker.additional.flags",
1971 gtk_entry_get_text (GTK_ENTRY (co->priv->widgets.other_l_flags_entry)));
1972 prop_set_with_key (props, "anjuta.linker.additional.libs",
1973 gtk_entry_get_text (GTK_ENTRY (co->priv->widgets.other_l_libs_entry)));
1974
1975 prop_set_with_key (props, "anjuta.compiler.flags",
1976 "$(anjuta.compiler.includes) $(anjuta.compiler.defines) "
1977 "$(anjuta.compiler.warning.flags) "
1978 "$(anjuta.compiler.optimization.flags) "
1979 "$(anjuta.compiler.other.flags) "
1980 "$(anjuta.compiler.additional.flags)");
1981
1982 prop_set_with_key (props, "anjuta.linker.flags",
1983 "$(anjuta.linker.library.paths) $(anjuta.linker.libraries) "
1984 "$(anjuta.linker.additional.flags) $(anjuta.linker.additional.libs)");
1985 }
1986
1987 #define PRINT_TO_STREAM(stream, format, buff) \
1988 if (buff) \
1989 { \
1990 if (strlen (buff)) \
1991 { \
1992 fprintf (fp, "\\\n\t%s", buff); \
1993 } \
1994 }
1995
1996 #define PRINT_TO_STREAM_AND_FREE(stream, format, buff) \
1997 if (buff) \
1998 { \
1999 if (strlen (buff)) \
2000 { \
2001 fprintf (fp, "\\\n\t%s", buff); \
2002 } \
2003 g_free (buff); \
2004 }
2005
2006 void
2007 compiler_options_set_prjincl_in_file (CompilerOptions* co, FILE* fp)
2008 {
2009 gchar *buff;
2010 buff = get_include_paths (co, FALSE);
2011 PRINT_TO_STREAM_AND_FREE(fp, "\\\n\t%s", buff);
2012 }
2013
2014 void
2015 compiler_options_set_prjcflags_in_file (CompilerOptions * co, FILE* fp)
2016 {
2017 gchar *buff;
2018 /*
2019 buff = get_supports (co, ANJUTA_SUPPORT_PRJ_CFLAGS, " ");
2020 PRINT_TO_STREAM_AND_FREE (fp, "\\\n\t%s", buff);
2021 */
2022 buff = get_defines (co);
2023 PRINT_TO_STREAM_AND_FREE (fp, "\\\n\t%s", buff);
2024
2025 buff = (gchar*)gtk_entry_get_text (GTK_ENTRY(co->priv->widgets.other_c_flags_entry));
2026 PRINT_TO_STREAM (fp, "\\\n\t%s", buff);
2027
2028 buff = get_warnings(co);
2029 PRINT_TO_STREAM_AND_FREE(fp, "\\\n\t%s", buff);
2030
2031 buff = get_optimization(co);
2032 PRINT_TO_STREAM_AND_FREE(fp, "\\\n\t%s", buff);
2033
2034 buff = get_others(co);
2035 PRINT_TO_STREAM_AND_FREE(fp, "\\\n\t%s", buff);
2036 }
2037
2038 void
2039 compiler_options_set_prjlibs_in_file (CompilerOptions * co, FILE* fp)
2040 {
2041 gchar *buff;
2042
2043 buff = get_libraries (co, FALSE);
2044 PRINT_TO_STREAM_AND_FREE(fp, "\\\n\t%s", buff);
2045
2046 buff = (gchar*)gtk_entry_get_text (GTK_ENTRY(co->priv->widgets.other_l_libs_entry));
2047 PRINT_TO_STREAM (fp, "\\\n\t%s", buff);
2048 }
2049
2050 void
2051 compiler_options_set_prjlflags_in_file (CompilerOptions * co, FILE* fp)
2052 {
2053 gchar *buff;
2054
2055 buff = (gchar*)gtk_entry_get_text (GTK_ENTRY(co->priv->widgets.other_l_flags_entry));
2056 PRINT_TO_STREAM (fp, "\\\n\t%s", buff);
2057
2058 buff = get_library_paths (co);
2059 PRINT_TO_STREAM_AND_FREE (fp, "\\\n\t%s", buff);
2060
2061 /*
2062 buff = get_supports (co, ANJUTA_SUPPORT_PRJ_LIBS, " ");
2063 PRINT_TO_STREAM_AND_FREE (fp, "\\\n\t%s", buff);
2064 */
2065 }
2066
2067 void
2068 compiler_options_set_prjmacros_in_file (CompilerOptions * co, FILE* fp)
2069 {
2070 gchar* buff;
2071
2072 buff = get_supports (co, ANJUTA_SUPPORT_MACROS, "\n");
2073 PRINT_TO_STREAM_AND_FREE (fp, "\\\n\t%s", buff);
2074 }
2075
2076
2077 void
2078 compiler_options_set_dirty_flag (CompilerOptions* co, gboolean is_dirty)
2079 {
2080 co->priv->dirty = is_dirty && app->project_dbase->project_is_open;
2081 }
Anjuta IDE Git Plugin Development Tree