Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/lib/gui/gtk_gui/gui_exec.cc @ 5625

Last change on this file since 5625 was 5241, checked in by bensch, 19 years ago

orxonox/trunk: minor gui-fixes…

File size: 11.4 KB
Line 
1/*
2   orxonox - the future of 3D-vertical-scrollers
3
4   Copyright (C) 2004 orx
5
6   This program is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation; either version 2, or (at your option)
9   any later version.
10
11   This program is distributed in the hope that it will be useful,
12   but WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   GNU General Public License for more details.
15
16   You should have received a copy of the GNU General Public License
17   along with this program; if not, write to the Free Software Foundation,
18   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19
20
21   ### File Specific:
22   main-programmer: Benjamin Grauer
23
24*/
25
26#include "gui_exec.h"
27
28#include "resource_manager.h"
29#include "ini_parser.h"
30
31#include <string.h>
32#include <stdlib.h>
33#include <sys/stat.h>
34#include <sys/types.h>
35
36
37#ifdef __WIN32__
38#include <direct.h>
39#endif /* __WIN32__ */
40HashTable* orxonoxFlagHash;
41
42/**
43  *  Creates the Exec-Frame
44*/
45GuiExec::GuiExec()
46{
47  Frame* execFrame;            //!< The Frame that holds the ExecutionOptions.
48
49  this->confFile = NULL;
50  this->confDir = NULL;
51
52  execFrame = new Frame("Execute-Tags:");
53  {
54    Box* execBox;                //!< The Box that holds the ExecutionOptions.
55
56    execBox = new Box('v');
57    execFrame->setGroupName(CONFIG_SECTION_MISC);
58    {
59      Button* start;               //!< The start Button of orxonox.
60      Menu* verboseMode;           //!< A Menu for setting the verbose-Mode. @todo setting up a verbose-class.
61      CheckButton* alwaysShow;     //!< A CheckButton, for if orxonox should start with or without gui.
62      Button* quit;                //!< A Button to quit the Gui without starting orxonox.
63
64      start = new Button("Start");
65#ifdef HAVE_GTK2
66      start->connectSignal("clicked", this, startOrxonox);
67#endif /* HAVE_GTK2 */
68      execBox->fill(start);
69      this->saveSettings = new CheckButton(CONFIG_NAME_SAVE_SETTINGS);
70      this->saveSettings->value = 1;
71      this->saveSettings->saveability();
72      execBox->fill(this->saveSettings);
73
74#ifdef DEBUG
75      verboseMode = new Menu(CONFIG_NAME_VERBOSE_MODE, "nothing",
76#if DEBUG >=1
77                             "error",
78#endif
79#if DEBUG >=2
80                             "warning",
81#endif
82#if DEBUG >=3
83                             "info",
84#endif
85#if DEBUG >=4
86                             "debug",
87#endif
88#if DEBUG >=5
89                             "heavydebug",
90#endif
91                             "lastItem");
92      verboseMode->setFlagName("verbose", "v", 2);
93      verboseMode->setDescription("Sets the Output Mode", "This Enables Outbug messages\n"
94                                  "0: nothing will be displayed, but stuff one cannot do without (eg.GUI)\n"
95#if DEBUG >=1
96                                  "1: error: outputs all the above and errors"
97#endif
98#if DEBUG >=2
99                                  "2: warning: outputs all the above plus warnings"
100#endif
101#if DEBUG >=3
102                                  "3: info: outputs all the above plus Information"
103#endif
104#if DEBUG >=4
105                                  "4: debug: displays all the above plus debug information"
106#endif
107#if DEBUG >=5
108                                  "5: heavydebug: displays all the above plus heavy debug information: WARNING: the game will run very slow with this."
109#endif
110                                  );
111      verboseMode->saveability();
112      execBox->fill(verboseMode);
113#endif
114
115      alwaysShow = new CheckButton(CONFIG_NAME_ALWAYS_SHOW_GUI);
116      alwaysShow->setFlagName("gui", "g", 0);
117      alwaysShow->setDescription("shows the gui when starting orxonox");
118      alwaysShow->saveability();
119      execBox->fill(alwaysShow);
120
121      quit = new Button("Quit");
122#ifdef HAVE_GTK2
123      quit->connectSignal("clicked", this, GuiExec::quitGui);
124      //  Window::mainWindow->connectSignal("remove", this, GuiExec::quitGui);
125      Window::mainWindow->connectSignal("destroy", this, GuiExec::quitGui);
126#endif /* HAVE_GTK2 */
127      execBox->fill(quit);
128    }
129    execFrame->fill(execBox);
130  }
131  setMainWidget(execFrame);
132}
133
134/**
135 *  Destructs the Execution-stuff
136*/
137GuiExec::~GuiExec()
138{
139  if(this->confFile)
140    delete []this->confFile;
141  if(this->confDir)
142    delete []this->confDir;
143}
144
145/* FILE HANDLING */
146
147/**
148 *  sets the Directory of the configuration files
149 * @param confDir the Directory for the configuration files
150*/
151void GuiExec::setConfDir(const char* confDir)
152{
153  this->confDir = ResourceManager::homeDirCheck(confDir);
154
155  PRINTF(5)("Config Directory is: %s.\n", this->confDir);
156  //! @todo F** Windows-support
157#ifndef __WIN32__
158  mkdir(this->confDir, 0755);
159#else /* __WiN32__ */
160  mkdir(this->confDir);
161#endif /* __WIN32__ */
162}
163
164/**
165 *  Sets the location of the configuration File.
166 * @param fileName the location of the configFile
167
168   The name will be parsed from ~/ to /home/[username] on unix and c:/Documents and Settings/username/Settings/ on Windows
169*/
170void GuiExec::setConfFile(const char* fileName)
171{
172  if (!this->confDir)
173    this->setConfDir("~/");
174  this->confFile = new char[strlen(this->confDir)+strlen(fileName)+2];
175  sprintf(this->confFile, "%s/%s", this->confDir, fileName);
176  PRINTF(5)("ConfigurationFile is %s.\n", this->confFile);
177}
178
179/**
180 * @returns The name of the Configuration-File
181*/
182const char* GuiExec::getConfigFile() const
183{
184  return this->confFile;
185}
186
187/**
188 *  checks if a option should be saved.
189 * @return 1 if it should 0 if not/
190*/
191int GuiExec::shouldsave()
192{
193  return(static_cast<Option*>(this->saveSettings)->value);
194}
195
196/**
197  *  Saves the configuration-file to the Disk.\n
198  * @param widget from which Widget on should be saved.
199
200    this Function only opens and closes the file, in between GuiExec::writeFileText(Widget* widget) will execute the real writing process.
201*/
202void GuiExec::writeToFile(Widget* widget)
203{
204  IniParser iniParser;
205  this->writeFileText(widget, &iniParser, 0);
206  char* fileName = ResourceManager::homeDirCheck(confFile);
207  iniParser.writeFile(fileName);
208  delete[] fileName;
209}
210
211/**
212 *  Actually writes into the configuration file to the disk.
213 * @param widget from which Widget on should be saved.
214 * @param parser the IniParser to write to.
215 * @param depth initially "0", and grows higher, while new Groups are bundeled.
216*/
217void GuiExec::writeFileText(Widget* widget, IniParser* parser, int depth)
218{
219//   int counter = 0;
220//   while(counter < depth &&((widget->optionType > GUI_NOTHING
221//                               &&(static_cast<Option*>(widget)->isSaveable()))
222//                              ||(widget->optionType < GUI_NOTHING
223//                                 && static_cast<Packer*>(widget)->getGroupName())))
224//     {
225//       fprintf(this->CONFIG_FILE, "  ", depth);
226//       counter++;
227//     }
228
229  // check if it is a Packer, and if it is, check if it has a name and if there is something in it.
230  if(widget->optionType < GUI_NOTHING)
231    {
232      if(static_cast<Packer*>(widget)->getGroupName())
233        {
234          parser->addSection(static_cast<Packer*>(widget)->getGroupName());
235          this->writeFileText(static_cast<Packer*>(widget)->down, parser, depth+1);
236        }
237      else
238        {
239          this->writeFileText(static_cast<Packer*>(widget)->down, parser, depth);
240        }
241    }
242
243  if(widget->optionType > GUI_NOTHING)
244    if (static_cast<Option*>(widget)->isSaveable())
245    {
246      char* saveName = static_cast<Option*>(widget)->save();
247      parser->addVar(static_cast<Option*>(widget)->title, saveName);
248      delete[] saveName;
249    }
250
251  if(widget->next != NULL)
252    this->writeFileText(widget->next, parser, depth);
253}
254
255/**
256 *  Reads in Configuration Data.
257 * @param widget from which Widget on should be saved.
258*/
259void GuiExec::readFromFile(Widget* widget)
260{
261  char* fileName = ResourceManager::homeDirCheck(confFile);
262  IniParser iniParser(fileName);
263  delete[] fileName;
264  if (!iniParser.isOpen())
265    return;
266
267  iniParser.getFirstSection();
268  Widget* groupWidget = widget;
269  const char* groupName;
270  const char* widgetName;
271  VarInfo varInfo;
272  while (groupName = iniParser.getCurrentSection())
273  {
274    if((groupWidget = locateGroup(widget, groupName, 1))==NULL)
275    {
276      PRINTF(2)("!!There is no group called %s in this GUI.\n First best Widget will get the Infos assigned.\n Config-File will be updated in next Save\n", groupName);
277      groupWidget = widget;
278      continue;
279    }
280    else
281      PRINT(0)("Group %s located.\n", static_cast<Packer*>(groupWidget)->groupName);
282
283    iniParser.getFirstVar();
284    while(iniParser.getCurrentName())
285    {
286      varInfo.variableName = iniParser.getCurrentName();
287      varInfo.variableValue = iniParser.getCurrentValue();
288      groupWidget->walkThrough(this->readFileText, &varInfo, 0);
289      iniParser.nextVar();
290    }
291
292    iniParser.nextSection();
293  }
294  widget->walkThrough(widget->setOptions, 0);
295}
296
297/**
298 *  Maps Confugurations to the Options.
299 * @param widget which widget downwards
300 * @param varInfo Information about the Variable to read
301*/
302void GuiExec::readFileText(Widget* widget, void* varInfo)
303{
304  VarInfo* info =(VarInfo*)varInfo;
305  if(widget->title && !strcmp(widget->title, info->variableName))
306    {
307      PRINT(5)("Located Option %s.\n", widget->title);
308      if(widget->optionType > GUI_NOTHING)
309        static_cast<Option*>(widget)->load(info->variableValue);
310    }
311}
312
313/**
314 *  Locates a Group.
315 * @param widget The Widget from where to search from
316 * @param groupName The GroupName for which to search.
317 * @param depth The Depth of the search seen from the first widget we searched from.
318 * @returns The Widget that holds the Group, or the NULL if the Group wasn't found.
319
320   @todo do this in gui-gtk.
321*/
322Widget* GuiExec::locateGroup(Widget* widget, const char* groupName, int depth)
323{
324  Widget* tmp;
325
326  if(widget->optionType < GUI_NOTHING)
327    {
328      if(static_cast<Packer*>(widget)->getGroupName() &&
329         !strcmp(groupName, static_cast<Packer*>(widget)->getGroupName()))
330        {
331          return widget;
332        }
333      else
334        {
335          if((tmp = locateGroup(static_cast<Packer*>(widget)->down, groupName, depth+1)) != NULL)
336            return tmp;
337        }
338    }
339
340  if(widget->next != NULL && depth != 0)
341    {
342      if((tmp = locateGroup(widget->next, groupName, depth)) != NULL)
343        return tmp;
344    }
345  return NULL;
346}
347
348/**
349 *  Starts ORXONOX.(not really implemented yet, but the function is there.\n
350 * @param widget the widget that executed the start command
351 * @param data additional data
352
353   This is a Signal and can be executed through Widget::signal_connect
354*/
355#ifdef HAVE_GTK2
356int GuiExec::startOrxonox(GtkWidget* widget, void* data)
357#else /* HAVE_GTK2 */
358int GuiExec::startOrxonox(void* widget, void* data)
359#endif /* HAVE_GTK2 */
360{
361  Window::mainWindow->hide();
362
363#ifdef HAVE_GTK2
364  gtk_widget_destroy(Window::mainWindow->widget);
365#else
366  quitGui(widget, data);
367#endif /* HAVE_GTK2 */
368
369  PRINT(3)("Starting Orxonox\n");
370  Gui::startOrxonox = true;
371}
372
373/**
374 *  Starts ORXONOX.(not really implemented yet, but the function is there.\n
375 * @param widget the widget that executed the start command
376 * @param data additional data
377
378   This is a Signal and can be executed through Widget::signal_connect
379*/
380#ifdef HAVE_GTK2
381int GuiExec::quitGui(GtkWidget* widget, void* data)
382#else /* HAVE_GTK2 */
383int GuiExec::quitGui(void* widget, void* data)
384#endif /* HAVE_GTK2 */
385{
386  GuiExec* exec = (GuiExec*)data;
387  if(exec->shouldsave())
388    exec->writeToFile(Window::mainWindow);
389#ifdef HAVE_GTK2
390  gtk_main_quit();
391  while(gtk_events_pending()) gtk_main_iteration();
392#endif /* HAVE_GTK2 */
393}
Note: See TracBrowser for help on using the repository browser.