support -sRGBcolor for all _color keys
[divverent/netradiant.git] / radiant / build.cpp
1 /*
2 Copyright (C) 2001-2006, William Joseph.
3 All Rights Reserved.
4
5 This file is part of GtkRadiant.
6
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20 */
21
22 #include "build.h"
23 #include "debugging/debugging.h"
24
25 #include <map>
26 #include <list>
27 #include "stream/stringstream.h"
28 #include "versionlib.h"
29
30 #include "mainframe.h"
31
32 typedef std::map<CopiedString, CopiedString> Variables;
33 Variables g_build_variables;
34
35 void build_clear_variables()
36 {
37   g_build_variables.clear();
38 }
39
40 void build_set_variable(const char* name, const char* value)
41 {
42   g_build_variables[name] = value;
43 }
44
45 const char* build_get_variable(const char* name)
46 {
47   Variables::iterator i = g_build_variables.find(name);
48   if(i != g_build_variables.end())
49   {
50     return (*i).second.c_str();
51   }
52   globalErrorStream() << "undefined build variable: " << makeQuoted(name) << "\n";
53   return "";
54 }
55
56 #include "xml/ixml.h"
57 #include "xml/xmlelement.h"
58
59 class Evaluatable
60 {
61 public:
62   virtual void evaluate(StringBuffer& output) = 0;
63   virtual void exportXML(XMLImporter& importer) = 0;
64 };
65
66 class VariableString : public Evaluatable
67 {
68   CopiedString m_string;
69 public:
70   VariableString() : m_string()
71   {
72   }
73   VariableString(const char* string) : m_string(string)
74   {
75   }
76   const char* c_str() const
77   {
78     return m_string.c_str();
79   }
80   void setString(const char* string)
81   {
82     m_string = string;
83   }
84   void evaluate(StringBuffer& output)
85   {
86     StringBuffer variable;
87     bool in_variable = false;
88     for(const char* i = m_string.c_str(); *i != '\0'; ++i)
89     {
90       if(!in_variable)
91       {
92         switch(*i)
93         {
94         case '[':
95           in_variable = true;
96           break;
97         default:
98           output.push_back(*i);
99           break;
100         }
101       }
102       else
103       {
104         switch(*i)
105         {
106         case ']':
107           in_variable = false;
108           output.push_string(build_get_variable(variable.c_str()));
109           variable.clear();
110           break;
111         default:
112           variable.push_back(*i);
113           break;
114         }
115       }
116     }
117   }
118   void exportXML(XMLImporter& importer)
119   {
120     importer << c_str();
121   }
122 };
123
124 class Conditional : public Evaluatable
125 {
126   VariableString* m_test;
127 public:
128   Evaluatable* m_result;
129   Conditional(VariableString* test) : m_test(test)
130   {
131   }
132   ~Conditional()
133   {
134     delete m_test;
135     delete m_result;
136   }
137   void evaluate(StringBuffer& output)
138   {
139     StringBuffer buffer;
140     m_test->evaluate(buffer);
141     if(!string_empty(buffer.c_str()))
142     {
143       m_result->evaluate(output);
144     }
145   }
146   void exportXML(XMLImporter& importer)
147   {
148     StaticElement conditionElement("cond");
149     conditionElement.insertAttribute("value", m_test->c_str());
150     importer.pushElement(conditionElement);
151     m_result->exportXML(importer);
152     importer.popElement(conditionElement.name());
153   }
154 };
155
156 typedef std::vector<Evaluatable*> Evaluatables;
157
158 class Tool : public Evaluatable
159 {
160   Evaluatables m_evaluatables;
161 public:
162   ~Tool()
163   {
164     for(Evaluatables::iterator i = m_evaluatables.begin(); i != m_evaluatables.end(); ++i)
165     {
166       delete (*i);
167     }
168   }
169   void push_back(Evaluatable* evaluatable)
170   {
171     m_evaluatables.push_back(evaluatable);
172   }
173   void evaluate(StringBuffer& output)
174   {
175     for(Evaluatables::iterator i = m_evaluatables.begin(); i != m_evaluatables.end(); ++i)
176     {
177       (*i)->evaluate(output);
178     }
179   }
180   void exportXML(XMLImporter& importer)
181   {
182     for(Evaluatables::iterator i = m_evaluatables.begin(); i != m_evaluatables.end(); ++i)
183     {
184       (*i)->exportXML(importer);
185     }
186   }
187 };
188
189 #include "xml/ixml.h"
190
191 class XMLElementParser : public TextOutputStream
192 {
193 public:
194   virtual XMLElementParser& pushElement(const XMLElement& element) = 0;
195   virtual void popElement(const char* name) = 0;
196 };
197
198 class VariableStringXMLConstructor : public XMLElementParser
199 {
200   StringBuffer m_buffer;
201   VariableString& m_variableString;
202 public:
203   VariableStringXMLConstructor(VariableString& variableString) : m_variableString(variableString)
204   {
205   }
206   ~VariableStringXMLConstructor()
207   {
208     m_variableString.setString(m_buffer.c_str());
209   }
210   std::size_t write(const char* buffer, std::size_t length)
211   {
212     m_buffer.push_range(buffer, buffer + length);
213     return length;
214   }
215   XMLElementParser& pushElement(const XMLElement& element)
216   {
217     ERROR_MESSAGE("parse error: invalid element \"" << element.name() << "\"");
218     return *this;
219   }
220   void popElement(const char* name)
221   {
222   }
223 };
224
225 class ConditionalXMLConstructor : public XMLElementParser
226 {
227   StringBuffer m_buffer;
228   Conditional& m_conditional;
229 public:
230   ConditionalXMLConstructor(Conditional& conditional) : m_conditional(conditional)
231   {
232   }
233   ~ConditionalXMLConstructor()
234   {
235     m_conditional.m_result = new VariableString(m_buffer.c_str());
236   }
237   std::size_t write(const char* buffer, std::size_t length)
238   {
239     m_buffer.push_range(buffer, buffer + length);
240     return length;
241   }
242   XMLElementParser& pushElement(const XMLElement& element)
243   {
244     ERROR_MESSAGE("parse error: invalid element \"" << element.name() << "\"");
245     return *this;
246   }
247   void popElement(const char* name)
248   {
249   }
250 };
251
252 class ToolXMLConstructor : public XMLElementParser
253 {
254   StringBuffer m_buffer;
255   Tool& m_tool;
256   ConditionalXMLConstructor* m_conditional;
257 public:
258   ToolXMLConstructor(Tool& tool) : m_tool(tool)
259   {
260   }
261   ~ToolXMLConstructor()
262   {
263     flush();
264   }
265   std::size_t write(const char* buffer, std::size_t length)
266   {
267     m_buffer.push_range(buffer, buffer + length);
268     return length;
269   }
270   XMLElementParser& pushElement(const XMLElement& element)
271   {
272     if(string_equal(element.name(), "cond"))
273     {
274       flush();
275       Conditional* conditional = new Conditional(new VariableString(element.attribute("value")));
276       m_tool.push_back(conditional);
277       m_conditional = new ConditionalXMLConstructor(*conditional);
278       return *m_conditional;
279     }
280     else
281     {
282       ERROR_MESSAGE("parse error: invalid element \"" << element.name() << "\"");
283       return *this;
284     }
285   }
286   void popElement(const char* name)
287   {
288     if(string_equal(name, "cond"))
289     {
290       delete m_conditional;
291     }
292   }
293
294   void flush()
295   {
296     if(!m_buffer.empty())
297     {
298       m_tool.push_back(new VariableString(m_buffer.c_str()));
299       m_buffer.clear();
300     }
301   }
302 };
303
304 typedef VariableString BuildCommand;
305 typedef std::list<BuildCommand> Build;
306
307 class BuildXMLConstructor : public XMLElementParser
308 {
309   VariableStringXMLConstructor* m_variableString;
310   Build& m_build;
311 public:
312   BuildXMLConstructor(Build& build) : m_build(build)
313   {
314   }
315   std::size_t write(const char* buffer, std::size_t length)
316   {
317     return length;
318   }
319   XMLElementParser& pushElement(const XMLElement& element)
320   {
321     if(string_equal(element.name(), "command"))
322     {
323       m_build.push_back(BuildCommand());
324       m_variableString = new VariableStringXMLConstructor(m_build.back());
325       return *m_variableString;
326     }
327     else
328     {
329       ERROR_MESSAGE("parse error: invalid element");
330       return *this;
331     }
332   }
333   void popElement(const char* name)
334   {
335     delete m_variableString;
336   }
337 };
338
339 typedef std::pair<CopiedString, Build> BuildPair;
340
341 class BuildPairEqual
342 {
343   const char* m_name;
344 public:
345   BuildPairEqual(const char* name) : m_name(name)
346   {
347   }
348   bool operator()(const BuildPair& self) const
349   {
350     return string_equal(self.first.c_str(), m_name);
351   }
352 };
353
354 typedef std::list<BuildPair> Project;
355
356 Project::iterator Project_find(Project& project, const char* name)
357 {
358   return std::find_if(project.begin(), project.end(), BuildPairEqual(name));
359 }
360
361 Project::iterator Project_find(Project& project, std::size_t index)
362 {
363   Project::iterator i = project.begin();
364   while(index-- != 0 && i != project.end())
365   {
366     ++i;
367   }
368   return i;
369 }
370
371 Build& project_find(Project& project, const char* build)
372 {
373   Project::iterator i = Project_find(project, build);
374   ASSERT_MESSAGE(i != project.end(), "error finding build command");
375   return (*i).second;
376 }
377
378 Build::iterator Build_find(Build& build, std::size_t index)
379 {
380   Build::iterator i = build.begin();
381   while(index-- != 0 && i != build.end())
382   {
383     ++i;
384   }
385   return i;
386 }
387
388 typedef std::map<CopiedString, Tool> Tools;
389
390 class ProjectXMLConstructor : public XMLElementParser
391 {
392   ToolXMLConstructor* m_tool;
393   BuildXMLConstructor* m_build;
394   Project& m_project;
395   Tools& m_tools;
396 public:
397   ProjectXMLConstructor(Project& project, Tools& tools) : m_project(project), m_tools(tools)
398   {
399   }
400   std::size_t write(const char* buffer, std::size_t length)
401   {
402     return length;
403   }
404   XMLElementParser& pushElement(const XMLElement& element)
405   {
406     if(string_equal(element.name(), "var"))
407     {
408       Tools::iterator i = m_tools.insert(Tools::value_type(element.attribute("name"), Tool())).first;
409       m_tool = new ToolXMLConstructor((*i).second);
410       return *m_tool;
411     }
412     else if(string_equal(element.name(), "build"))
413     {
414       m_project.push_back(Project::value_type(element.attribute("name"), Build()));
415       m_build = new BuildXMLConstructor(m_project.back().second);
416       return *m_build;
417     }
418     else
419     {
420       ERROR_MESSAGE("parse error: invalid element");
421       return *this;
422     }
423   }
424   void popElement(const char* name)
425   {
426     if(string_equal(name, "var"))
427     {
428       delete m_tool;
429     }
430     else if(string_equal(name, "build"))
431     {
432       delete m_build;
433     }
434   }
435 };
436
437 class SkipAllParser : public XMLElementParser
438 {
439 public:
440   std::size_t write(const char* buffer, std::size_t length)
441   {
442     return length;
443   }
444   XMLElementParser& pushElement(const XMLElement& element)
445   {
446     return *this;
447   }
448   void popElement(const char* name)
449   {
450   }
451 };
452
453 class RootXMLConstructor : public XMLElementParser
454 {
455   CopiedString m_elementName;
456   XMLElementParser& m_parser;
457   SkipAllParser m_skip;
458   Version m_version;
459   bool m_compatible;
460 public:
461   RootXMLConstructor(const char* elementName, XMLElementParser& parser, const char* version) :
462     m_elementName(elementName),
463     m_parser(parser),
464     m_version(version_parse(version)),
465     m_compatible(false)
466   {
467   }
468   std::size_t write(const char* buffer, std::size_t length)
469   {
470     return length;
471   }
472   XMLElementParser& pushElement(const XMLElement& element)
473   {
474     if(string_equal(element.name(), m_elementName.c_str()))
475     {
476       Version dataVersion(version_parse(element.attribute("version")));
477       if(version_compatible(m_version, dataVersion))
478       {
479         m_compatible = true;
480         return m_parser;
481       }
482       else
483       {
484         return m_skip;
485       }
486     }
487     else
488     {
489       //ERROR_MESSAGE("parse error: invalid element \"" << element.name() << "\"");
490       return *this;
491     }
492   }
493   void popElement(const char* name)
494   {
495   }
496
497   bool versionCompatible() const
498   {
499     return m_compatible;
500   }
501 };
502
503 namespace
504 {
505   Project g_build_project;
506   Tools g_build_tools;
507   bool g_build_changed = false;
508 }
509
510 void build_error_undefined_tool(const char* build, const char* tool)
511 {
512   globalErrorStream() << "build " << makeQuoted(build) << " refers to undefined tool " << makeQuoted(tool) << '\n';
513 }
514
515 void project_verify(Project& project, Tools& tools)
516 {
517 #if 0
518   for(Project::iterator i = project.begin(); i != project.end(); ++i)
519   {
520     Build& build = (*i).second;
521     for(Build::iterator j = build.begin(); j != build.end(); ++j)
522     {
523       Tools::iterator k = tools.find((*j).first);
524       if(k == g_build_tools.end())
525       {
526         build_error_undefined_tool((*i).first.c_str(), (*j).first.c_str());
527       }
528     }
529   }
530 #endif
531 }
532
533 void build_run(const char* name, CommandListener& listener)
534 {
535   for(Tools::iterator i = g_build_tools.begin(); i != g_build_tools.end(); ++i)
536   {
537     StringBuffer output;
538     (*i).second.evaluate(output);
539     build_set_variable((*i).first.c_str(), output.c_str());
540   }
541
542   {
543     Project::iterator i = Project_find(g_build_project, name);
544     if(i != g_build_project.end())
545     {
546       Build& build = (*i).second;
547       for(Build::iterator j = build.begin(); j != build.end(); ++j)
548       {
549         StringBuffer output;
550         (*j).evaluate(output);
551         listener.execute(output.c_str());
552       }
553     }
554     else
555     {
556       globalErrorStream() << "build " << makeQuoted(name) << " not defined";
557     }
558   }
559 }
560
561
562 typedef std::vector<XMLElementParser*> XMLElementStack;
563
564 class XMLParser : public XMLImporter
565 {
566   XMLElementStack m_stack;
567 public:
568   XMLParser(XMLElementParser& parser)
569   {
570     m_stack.push_back(&parser);
571   }
572   std::size_t write(const char* buffer, std::size_t length)
573   {
574     return m_stack.back()->write(buffer, length);
575   }
576   void pushElement(const XMLElement& element)
577   {
578     m_stack.push_back(&m_stack.back()->pushElement(element));
579   }
580   void popElement(const char* name)
581   {
582     m_stack.pop_back();
583     m_stack.back()->popElement(name);
584   }
585 };
586
587 #include "stream/textfilestream.h"
588 #include "xml/xmlparser.h"
589
590 const char* const BUILDMENU_VERSION = "2.0";
591
592 bool build_commands_parse(const char* filename)
593 {
594   TextFileInputStream projectFile(filename);
595   if(!projectFile.failed())
596   {
597     ProjectXMLConstructor projectConstructor(g_build_project, g_build_tools);
598     RootXMLConstructor rootConstructor("project", projectConstructor, BUILDMENU_VERSION);
599     XMLParser importer(rootConstructor);
600     XMLStreamParser parser(projectFile);
601     parser.exportXML(importer);
602
603     if(rootConstructor.versionCompatible())
604     {
605       project_verify(g_build_project, g_build_tools);
606
607       return true;
608     }
609     globalErrorStream() << "failed to parse build menu: " << makeQuoted(filename) << "\n";
610   }
611   return false;
612 }
613
614 void build_commands_clear()
615 {
616   g_build_project.clear();
617   g_build_tools.clear();
618 }
619
620 class BuildXMLExporter
621 {
622   Build& m_build;
623 public:
624   BuildXMLExporter(Build& build) : m_build(build)
625   {
626   }
627   void exportXML(XMLImporter& importer)
628   {
629     importer << "\n";
630     for(Build::iterator i = m_build.begin(); i != m_build.end(); ++i)
631     {
632       StaticElement commandElement("command");
633       importer.pushElement(commandElement);
634       (*i).exportXML(importer);
635       importer.popElement(commandElement.name());
636       importer << "\n";
637     }
638   }
639 };
640
641 class ProjectXMLExporter
642 {
643   Project& m_project;
644   Tools& m_tools;
645 public:
646   ProjectXMLExporter(Project& project, Tools& tools) : m_project(project), m_tools(tools)
647   {
648   }
649   void exportXML(XMLImporter& importer)
650   {
651     StaticElement projectElement("project");
652     projectElement.insertAttribute("version", BUILDMENU_VERSION);
653     importer.pushElement(projectElement);
654     importer << "\n";
655
656     for(Tools::iterator i = m_tools.begin(); i != m_tools.end(); ++i)
657     {
658       StaticElement toolElement("var");
659       toolElement.insertAttribute("name", (*i).first.c_str());
660       importer.pushElement(toolElement);
661       (*i).second.exportXML(importer);
662       importer.popElement(toolElement.name());
663       importer << "\n";
664     }
665     for(Project::iterator i = m_project.begin(); i != m_project.end(); ++i)
666     {
667       StaticElement buildElement("build");
668       buildElement.insertAttribute("name", (*i).first.c_str());
669       importer.pushElement(buildElement);
670       BuildXMLExporter buildExporter((*i).second);
671       buildExporter.exportXML(importer);
672       importer.popElement(buildElement.name());
673       importer << "\n";
674     }
675     importer.popElement(projectElement.name());
676   }
677 };
678
679 #include "xml/xmlwriter.h"
680
681 void build_commands_write(const char* filename)
682 {
683   TextFileOutputStream projectFile(filename);
684   if(!projectFile.failed())
685   {
686     XMLStreamWriter writer(projectFile);
687     ProjectXMLExporter projectExporter(g_build_project, g_build_tools);
688     writer << "\n";
689     projectExporter.exportXML(writer);
690     writer << "\n";
691   }
692 }
693
694
695 #include <gdk/gdkkeysyms.h>
696 #include <gtk/gtkmain.h>
697 #include <gtk/gtkbox.h>
698 #include <gtk/gtktable.h>
699 #include <gtk/gtktreeview.h>
700 #include <gtk/gtkcellrenderertext.h>
701 #include <gtk/gtktreeselection.h>
702 #include <gtk/gtkliststore.h>
703 #include <gtk/gtkscrolledwindow.h>
704
705 #include "gtkutil/dialog.h"
706 #include "gtkutil/closure.h"
707 #include "gtkutil/window.h"
708 #include "gtkdlgs.h"
709
710 void Build_refreshMenu(GtkMenu* menu);
711
712
713 void BSPCommandList_Construct(GtkListStore* store, Project& project)
714 {
715   gtk_list_store_clear(store);
716
717   for(Project::iterator i = project.begin(); i != project.end(); ++i)
718   {
719     const char* buildName = (*i).first.c_str();
720
721     GtkTreeIter buildIter;
722     gtk_list_store_append(store, &buildIter);
723     gtk_list_store_set(store, &buildIter, 0, const_cast<char*>(buildName), -1);
724   }
725
726   GtkTreeIter lastIter;
727   gtk_list_store_append(store, &lastIter);
728 }
729
730 class ProjectList
731 {
732 public:
733   Project& m_project;
734   GtkListStore* m_store;
735   bool m_changed;
736   ProjectList(Project& project) : m_project(project), m_changed(false)
737   {
738   }
739 };
740
741 gboolean project_cell_edited(GtkCellRendererText* cell, gchar* path_string, gchar* new_text, ProjectList* projectList)
742 {
743   Project& project = projectList->m_project;
744
745   GtkTreePath* path = gtk_tree_path_new_from_string(path_string);
746
747   ASSERT_MESSAGE(gtk_tree_path_get_depth(path) == 1, "invalid path length");
748
749   GtkTreeIter iter;
750   gtk_tree_model_get_iter(GTK_TREE_MODEL(projectList->m_store), &iter, path);
751
752   Project::iterator i = Project_find(project, gtk_tree_path_get_indices(path)[0]);
753   if(i != project.end())
754   {
755     projectList->m_changed = true;
756     if(string_empty(new_text))
757     {
758       project.erase(i);
759       Build_refreshMenu(g_bsp_menu);
760
761       gtk_list_store_remove(projectList->m_store, &iter);
762     }
763     else
764     {
765       (*i).first = new_text;
766       Build_refreshMenu(g_bsp_menu);
767
768       gtk_list_store_set(projectList->m_store, &iter, 0, new_text, -1);
769     }
770   }
771   else if(!string_empty(new_text))
772   {
773     projectList->m_changed = true;
774     project.push_back(Project::value_type(new_text, Build()));
775     Build_refreshMenu(g_bsp_menu);
776
777     gtk_list_store_set(projectList->m_store, &iter, 0, new_text, -1);
778     GtkTreeIter lastIter;
779     gtk_list_store_append(projectList->m_store, &lastIter);
780   }
781
782   gtk_tree_path_free(path);
783
784   return FALSE;
785 }
786
787 gboolean project_key_press(GtkWidget* widget, GdkEventKey* event, ProjectList* projectList)
788 {
789   Project& project = projectList->m_project;
790
791   if(event->keyval == GDK_Delete)
792   {
793     GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
794     GtkTreeIter iter;
795     GtkTreeModel* model;
796     if(gtk_tree_selection_get_selected(selection, &model, &iter))
797     {
798       GtkTreePath* path = gtk_tree_model_get_path(model, &iter);
799       Project::iterator x = Project_find(project, gtk_tree_path_get_indices(path)[0]);
800       gtk_tree_path_free(path);
801
802       if(x != project.end())
803       {
804         projectList->m_changed = true;
805         project.erase(x);
806         Build_refreshMenu(g_bsp_menu);
807
808         gtk_list_store_remove(projectList->m_store, &iter);
809       }
810     }
811   }
812   return FALSE;
813 }
814
815
816 Build* g_current_build = 0;
817
818 gboolean project_selection_changed(GtkTreeSelection* selection, GtkListStore* store)
819 {
820   Project& project = g_build_project;
821
822   gtk_list_store_clear(store);
823
824   GtkTreeIter iter;
825   GtkTreeModel* model;
826   if(gtk_tree_selection_get_selected(selection, &model, &iter))
827   {
828     GtkTreePath* path = gtk_tree_model_get_path(model, &iter);
829     Project::iterator x = Project_find(project, gtk_tree_path_get_indices(path)[0]);
830     gtk_tree_path_free(path);
831
832     if(x != project.end())
833     {
834       Build& build = (*x).second;
835       g_current_build = &build;
836
837       for(Build::iterator i = build.begin(); i != build.end(); ++i)
838       {
839         GtkTreeIter commandIter;
840         gtk_list_store_append(store, &commandIter);
841         gtk_list_store_set(store, &commandIter, 0, const_cast<char*>((*i).c_str()), -1);
842       }
843       GtkTreeIter lastIter;
844       gtk_list_store_append(store, &lastIter);
845     }
846     else
847     {
848       g_current_build = 0;
849     }
850   }
851   else
852   {
853     g_current_build = 0;
854   }
855
856   return FALSE;
857 }
858
859 gboolean commands_cell_edited(GtkCellRendererText* cell, gchar* path_string, gchar* new_text, GtkListStore* store)
860 {
861   if(g_current_build == 0)
862   {
863     return FALSE;
864   }
865   Build& build = *g_current_build;
866
867   GtkTreePath* path = gtk_tree_path_new_from_string(path_string);
868
869   ASSERT_MESSAGE(gtk_tree_path_get_depth(path) == 1, "invalid path length");
870
871   GtkTreeIter iter;
872   gtk_tree_model_get_iter(GTK_TREE_MODEL(store), &iter, path);
873
874   Build::iterator i = Build_find(build, gtk_tree_path_get_indices(path)[0]);
875   if(i != build.end())
876   {
877     g_build_changed = true;
878     (*i).setString(new_text);
879
880     gtk_list_store_set(store, &iter, 0, new_text, -1);
881   }
882   else if(!string_empty(new_text))
883   {
884     g_build_changed = true;
885     build.push_back(Build::value_type(VariableString(new_text)));
886
887     gtk_list_store_set(store, &iter, 0, new_text, -1);
888
889     GtkTreeIter lastIter;
890     gtk_list_store_append(store, &lastIter);
891   }
892
893   gtk_tree_path_free(path);
894
895   return FALSE;
896 }
897
898 gboolean commands_key_press(GtkWidget* widget, GdkEventKey* event, GtkListStore* store)
899 {
900   if(g_current_build == 0)
901   {
902     return FALSE;
903   }
904   Build& build = *g_current_build;
905
906   if(event->keyval == GDK_Delete)
907   {
908     GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
909     GtkTreeIter iter;
910     GtkTreeModel* model;
911     if(gtk_tree_selection_get_selected(selection, &model, &iter))
912     {
913       GtkTreePath* path = gtk_tree_model_get_path(model, &iter);
914       Build::iterator i = Build_find(build, gtk_tree_path_get_indices(path)[0]);
915       gtk_tree_path_free(path);
916
917       if(i != build.end())
918       {
919         g_build_changed = true;
920         build.erase(i);
921
922         gtk_list_store_remove(store, &iter);
923       }
924     }
925   }
926   return FALSE;
927 }
928
929
930 GtkWindow* BuildMenuDialog_construct(ModalDialog& modal, ProjectList& projectList)
931 {
932   GtkWindow* window = create_dialog_window(MainFrame_getWindow(), "Build Menu", G_CALLBACK(dialog_delete_callback), &modal, -1, 400);
933
934   GtkWidget* buildView = 0;
935
936   {
937     GtkTable* table1 = create_dialog_table(2, 2, 4, 4, 4);
938     gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(table1));
939     {
940       GtkVBox* vbox = create_dialog_vbox(4);
941       gtk_table_attach(table1, GTK_WIDGET(vbox), 1, 2, 0, 1,
942                         (GtkAttachOptions) (GTK_FILL),
943                         (GtkAttachOptions) (GTK_FILL), 0, 0);
944       {
945         GtkButton* button = create_dialog_button("OK", G_CALLBACK(dialog_button_ok), &modal);
946         gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(button), FALSE, FALSE, 0);
947       }
948       {
949         GtkButton* button = create_dialog_button("Cancel", G_CALLBACK(dialog_button_cancel), &modal);
950         gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(button), FALSE, FALSE, 0);
951       }
952     }
953     {
954       GtkFrame* frame = create_dialog_frame("Build menu");
955       gtk_table_attach(table1, GTK_WIDGET(frame), 0, 1, 0, 1,
956                         (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
957                         (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
958       {
959         GtkScrolledWindow* scr = create_scrolled_window(GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC, 4);
960         gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(scr));
961
962         {
963           GtkListStore* store = gtk_list_store_new(1, G_TYPE_STRING);
964
965           GtkWidget* view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
966           gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);
967
968           GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
969           object_set_boolean_property(G_OBJECT(renderer), "editable", TRUE);
970           g_signal_connect(renderer, "edited", G_CALLBACK(project_cell_edited), &projectList);
971  
972           GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, 0);
973           gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
974
975           GtkTreeSelection* selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(view));
976           gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
977
978           gtk_widget_show(view);
979
980           buildView = view;
981           projectList.m_store = store;
982           gtk_container_add(GTK_CONTAINER (scr), view);
983   
984           g_signal_connect(G_OBJECT(view), "key_press_event", G_CALLBACK(project_key_press), &projectList);
985
986           g_object_unref(G_OBJECT(store));
987         }
988       }
989     }
990     {
991       GtkFrame* frame = create_dialog_frame("Commandline");
992       gtk_table_attach(table1, GTK_WIDGET(frame), 0, 1, 1, 2,
993                         (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
994                         (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
995       {
996         GtkScrolledWindow* scr = create_scrolled_window(GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC, 4);
997         gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(scr));
998
999         {
1000           GtkListStore* store = gtk_list_store_new(1, G_TYPE_STRING);
1001
1002           GtkWidget* view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
1003           gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);
1004
1005           GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
1006           object_set_boolean_property(G_OBJECT(renderer), "editable", TRUE);
1007           g_signal_connect(renderer, "edited", G_CALLBACK(commands_cell_edited), store);
1008  
1009           GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, 0);
1010           gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
1011
1012           GtkTreeSelection* selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(view));
1013           gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
1014
1015           gtk_widget_show(view);
1016
1017           gtk_container_add(GTK_CONTAINER (scr), view);
1018   
1019           g_object_unref(G_OBJECT(store));
1020
1021           g_signal_connect(G_OBJECT(view), "key_press_event", G_CALLBACK(commands_key_press), store);
1022          
1023           g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(buildView))), "changed", G_CALLBACK(project_selection_changed), store);
1024         }
1025       }
1026     }
1027   }
1028
1029   BSPCommandList_Construct(projectList.m_store, g_build_project);
1030
1031   return window;
1032 }
1033
1034 namespace
1035 {
1036   CopiedString g_buildMenu;
1037 }
1038
1039 void LoadBuildMenu();
1040
1041 void DoBuildMenu()
1042 {
1043   ModalDialog modal;
1044
1045   ProjectList projectList(g_build_project);
1046
1047   GtkWindow* window = BuildMenuDialog_construct(modal, projectList);
1048
1049   if(modal_dialog_show(window, modal) == eIDCANCEL)
1050   {
1051     build_commands_clear();
1052     LoadBuildMenu();
1053
1054     Build_refreshMenu(g_bsp_menu);
1055   }
1056   else if(projectList.m_changed)
1057   {
1058     g_build_changed = true;
1059   }
1060
1061   gtk_widget_destroy(GTK_WIDGET(window));
1062 }
1063
1064
1065
1066 #include "gtkutil/menu.h"
1067 #include "mainframe.h"
1068 #include "preferences.h"
1069 #include "qe3.h"
1070
1071 typedef struct _GtkMenuItem GtkMenuItem;
1072
1073 class BuildMenuItem
1074 {
1075   const char* m_name;
1076 public:
1077   GtkMenuItem* m_item;
1078   BuildMenuItem(const char* name, GtkMenuItem* item)
1079     : m_name(name), m_item(item)
1080   {
1081   }
1082   void run()
1083   {
1084     RunBSP(m_name);
1085   }
1086   typedef MemberCaller<BuildMenuItem, &BuildMenuItem::run> RunCaller;
1087 };
1088
1089 typedef std::list<BuildMenuItem> BuildMenuItems;
1090 BuildMenuItems g_BuildMenuItems;
1091
1092
1093 GtkMenu* g_bsp_menu;
1094
1095 void Build_constructMenu(GtkMenu* menu)
1096 {
1097   for(Project::iterator i = g_build_project.begin(); i != g_build_project.end(); ++i)
1098   {
1099     g_BuildMenuItems.push_back(BuildMenuItem((*i).first.c_str(), 0));
1100     g_BuildMenuItems.back().m_item = create_menu_item_with_mnemonic(menu, (*i).first.c_str(), BuildMenuItem::RunCaller(g_BuildMenuItems.back()));
1101   }
1102 }
1103
1104
1105 void Build_refreshMenu(GtkMenu* menu)
1106 {
1107   for(BuildMenuItems::iterator i = g_BuildMenuItems.begin(); i != g_BuildMenuItems.end(); ++i)
1108   {
1109     gtk_container_remove(GTK_CONTAINER(menu), GTK_WIDGET((*i).m_item));
1110   }
1111
1112   g_BuildMenuItems.clear();
1113
1114   Build_constructMenu(menu);
1115 }
1116
1117
1118 void LoadBuildMenu()
1119 {
1120   if(string_empty(g_buildMenu.c_str()) || !build_commands_parse(g_buildMenu.c_str()))
1121   {
1122     {
1123       StringOutputStream buffer(256);
1124       buffer << GameToolsPath_get() << "default_build_menu.xml";
1125
1126       bool success = build_commands_parse(buffer.c_str());
1127       ASSERT_MESSAGE(success, "failed to parse default build commands: " << buffer.c_str());
1128     }
1129     {
1130       StringOutputStream buffer(256);
1131       buffer << SettingsPath_get() << g_pGameDescription->mGameFile.c_str() << "/build_menu.xml";
1132
1133       g_buildMenu = buffer.c_str();
1134     }
1135   }
1136 }
1137
1138 void SaveBuildMenu()
1139 {
1140   if(g_build_changed)
1141   {
1142     g_build_changed = false;
1143     build_commands_write(g_buildMenu.c_str());
1144   }
1145 }
1146
1147 #include "preferencesystem.h"
1148 #include "stringio.h"
1149
1150 void BuildMenu_Construct()
1151 {
1152   GlobalPreferenceSystem().registerPreference("BuildMenu", CopiedStringImportStringCaller(g_buildMenu), CopiedStringExportStringCaller(g_buildMenu));
1153   LoadBuildMenu();
1154 }
1155 void BuildMenu_Destroy()
1156 {
1157   SaveBuildMenu();
1158 }