]> git.mxchange.org Git - flightgear.git/blob - src/GUI/menubar.cxx
Boris Koenig:
[flightgear.git] / src / GUI / menubar.cxx
1 #ifdef HAVE_CONFIG_H
2 #  include <config.h>
3 #endif
4
5 #include <string.h>
6 #include <iostream>
7 #include <plib/pu.h>
8 #include <simgear/debug/logstream.hxx>
9
10 #include <Autopilot/auto_gui.hxx>
11 #include <Input/input.hxx>
12 #include <Main/globals.hxx>
13 #include <Main/fg_props.hxx>
14
15 #include "new_gui.hxx"
16 #include "menubar.hxx"
17
18
19 \f
20 ////////////////////////////////////////////////////////////////////////
21 // FIXME!!
22 //
23 // Deprecated wrappers for old menu commands.
24 //
25 // DO NOT ADD TO THESE.  THEY WILL BE DELETED SOON!
26 //
27 // These are defined in gui_funcs.cxx.  They should be replaced with
28 // user-configured dialogs and new commands where necessary.
29 ////////////////////////////////////////////////////////////////////////
30
31 extern void saveFlight (puObject *);
32 static bool
33 do_save_dialog (const SGPropertyNode * arg)
34 {
35     saveFlight(0);
36     return true;
37 }
38
39 extern void loadFlight (puObject *);
40 static bool
41 do_load_dialog (const SGPropertyNode * arg)
42 {
43     loadFlight(0);
44     return true;
45 }
46
47 extern void reInit (puObject *);
48 static bool
49 do_reinit_dialog (const SGPropertyNode * arg)
50 {
51     reInit(0);
52     return true;
53 }
54
55 #if defined(TR_HIRES_SNAP)
56 extern void dumpHiResSnapShot (puObject *);
57 static bool
58 do_hires_snapshot_dialog (const SGPropertyNode * arg)
59 {
60     dumpHiResSnapShot(0);
61     return true;
62 }
63 #endif // TR_HIRES_SNAP
64
65 #if defined( WIN32 ) && !defined( __CYGWIN__) && !defined(__MINGW32__)
66 extern void printScreen (puObject *);
67 static bool
68 do_print_dialog (const SGPropertyNode * arg)
69 {
70     printScreen(0);
71     return true;
72 }
73 #endif
74
75 extern void PilotOffsetAdjust (puObject *);
76 static bool
77 do_pilot_offset_dialog (const SGPropertyNode * arg)
78 {
79     PilotOffsetAdjust(0);
80     return true;
81 }
82
83 extern void fgHUDalphaAdjust (puObject *);
84 static bool
85 do_hud_alpha_dialog (const SGPropertyNode * arg)
86 {
87     fgHUDalphaAdjust(0);
88     return true;
89 }
90
91 extern void prop_pickerView (puObject *);
92 static bool
93 do_properties_dialog (const SGPropertyNode * arg)
94 {
95     prop_pickerView(0);
96     return true;
97 }
98
99 extern void AddWayPoint (puObject *);
100 static bool
101 do_ap_add_waypoint_dialog (const SGPropertyNode * arg)
102 {
103     AddWayPoint(0);
104     return true;
105 }
106
107 extern void PopWayPoint (puObject *);
108 static bool
109 do_ap_pop_waypoint_dialog (const SGPropertyNode * arg)
110 {
111     PopWayPoint(0);
112     return true;
113 }
114
115 extern void ClearRoute (puObject *);
116 static bool
117 do_ap_clear_route_dialog (const SGPropertyNode * arg)
118 {
119     ClearRoute(0);
120     return true;
121 }
122
123 #if 0
124 extern void fgAPAdjust (puObject *);
125 static bool
126 do_ap_adjust_dialog (const SGPropertyNode * arg)
127 {
128     fgAPAdjust(0);
129     return true;
130 }
131 #endif
132
133 extern void fgLatLonFormatToggle (puObject *);
134 static bool
135 do_lat_lon_format_dialog (const SGPropertyNode * arg)
136 {
137     fgLatLonFormatToggle(0);
138     return true;
139 }
140
141 extern void helpCb (puObject *);
142 static bool
143 do_help_dialog (const SGPropertyNode * arg)
144 {
145     helpCb(0);
146     return true;
147 }
148
149 static struct {
150     const char * name;
151     SGCommandMgr::command_t command;
152 } deprecated_dialogs [] = {
153     { "old-save-dialog", do_save_dialog },
154     { "old-load-dialog", do_load_dialog },
155     { "old-reinit-dialog", do_reinit_dialog },
156 #if defined(TR_HIRES_SNAP)
157     { "old-hires-snapshot-dialog", do_hires_snapshot_dialog },
158 #endif
159 #if defined( WIN32 ) && !defined( __CYGWIN__) && !defined(__MINGW32__)
160     { "old-print-dialog", do_print_dialog },
161 #endif
162     { "old-pilot-offset-dialog", do_pilot_offset_dialog },
163     { "old-hud-alpha-dialog", do_hud_alpha_dialog },
164     { "old-properties-dialog", do_properties_dialog },
165     { "old-ap-add-waypoint-dialog", do_ap_add_waypoint_dialog },
166     { "old-ap-pop-waypoint-dialog", do_ap_pop_waypoint_dialog },
167     { "old-ap-clear-route-dialog", do_ap_clear_route_dialog },
168     { "old-lat-lon-format-dialog", do_lat_lon_format_dialog },
169     { "old-help-dialog", do_help_dialog },
170     { 0, 0 }
171 };
172
173 static void
174 add_deprecated_dialogs ()
175 {
176   SG_LOG(SG_GENERAL, SG_INFO, "Initializing old dialog commands:");
177   for (int i = 0; deprecated_dialogs[i].name != 0; i++) {
178     SG_LOG(SG_GENERAL, SG_INFO, "  " << deprecated_dialogs[i].name);
179     globals->get_commands()->addCommand(deprecated_dialogs[i].name,
180                                         deprecated_dialogs[i].command);
181   }
182 }
183
184
185 \f
186 ////////////////////////////////////////////////////////////////////////
187 // Static functions.
188 ////////////////////////////////////////////////////////////////////////
189
190
191 static void
192 menu_callback (puObject * object)
193 {
194     NewGUI * gui = (NewGUI *)globals->get_subsystem("gui");
195     gui->getMenuBar()->fireItem(object);
196 }
197
198
199 \f
200 ////////////////////////////////////////////////////////////////////////
201 // Implementation of FGMenuBar.
202 ////////////////////////////////////////////////////////////////////////
203
204
205 FGMenuBar::FGMenuBar ()
206     : _visible(false),
207       _menuBar(0)
208 {
209 }
210
211 FGMenuBar::~FGMenuBar ()
212 {
213     destroy_menubar();
214 }
215
216 void
217 FGMenuBar::init ()
218 {
219     if (_menuBar != 0)          // FIXME: check if PUI owns the pointer
220         delete _menuBar;
221     make_menubar();
222
223                                 // FIXME: temporary commands to get at
224                                 // old, hard-coded dialogs.
225     add_deprecated_dialogs();
226 }
227
228 void
229 FGMenuBar::show ()
230 {
231     if (_menuBar != 0)
232         _menuBar->reveal();
233     _visible = true;
234 }
235
236 void
237 FGMenuBar::hide ()
238 {
239     if (_menuBar != 0)
240         _menuBar->hide();
241     _visible = false;
242 }
243
244 bool
245 FGMenuBar::isVisible () const
246 {
247     return _visible;
248 }
249
250 void
251 FGMenuBar::fireItem (puObject * item)
252 {
253     const char * name = item->getLegend();
254     vector<FGBinding *> &bindings = _bindings[name];
255     int nBindings = bindings.size();
256
257     for (int i = 0; i < nBindings; i++)
258         bindings[i]->fire();
259 }
260
261 void
262 FGMenuBar::make_menu (SGPropertyNode * node)
263 {
264     const char * name = strdup(node->getStringValue("label"));
265     vector<SGPropertyNode_ptr> item_nodes = node->getChildren("item");
266
267     int array_size = item_nodes.size();
268
269     char ** items = make_char_array(array_size);
270     puCallback * callbacks = make_callback_array(array_size);
271
272     for (unsigned int i = 0, j = item_nodes.size() - 1;
273          i < item_nodes.size();
274          i++, j--) {
275         
276                                 // Set up the PUI entries for this item
277         items[j] = strdup((char *)item_nodes[i]->getStringValue("label"));
278         callbacks[j] = menu_callback;
279
280                                 // Load all the bindings for this item
281         vector<SGPropertyNode_ptr> binding_nodes =
282             item_nodes[i]->getChildren("binding");
283
284         for (unsigned int k = 0; k < binding_nodes.size(); k++)
285             _bindings[items[j]].push_back(new FGBinding(binding_nodes[k]));
286     }
287
288     _menuBar->add_submenu(name, items, callbacks);
289 }
290
291 void
292 FGMenuBar::make_menubar ()
293 {
294     SGPropertyNode *targetpath;
295    
296     targetpath = fgGetNode("/sim/menubar/default",true);
297     // fgLoadProps("gui/menubar.xml", targetpath);
298     
299     /* NOTE: there is no check to see whether there's any usable data at all
300      *
301      * This would also have the advantage of being able to create some kind of
302      * 'fallback' menu - just in case that either menubar.xml is empty OR that
303      * its XML data is not valid, that way we would avoid displaying an
304      * unusable menubar without any functionality - if we decided to add another
305      * char * element to the commands structure in
306      *  $FG_SRC/src/Main/fgcommands.cxx 
307      * we could additionally save each function's (short) description and use
308      * this as label for the fallback PUI menubar item labels - as a workaround
309      * one might simply use the internal fgcommands and put them into the 
310      * fallback menu, so that the user is at least able to re-init the menu
311      * loading - just in case there was some malformed XML in it
312      * (it happend to me ...)
313      */
314     
315     make_menubar(targetpath);
316 }
317
318 /* WARNING: We aren't yet doing any validation of what's found - but since
319  * this isn't done with menubar.xml either, it should not really matter
320  * right now. Although one should later on consider to validate the
321  * contents, whether they are representing a 'legal' menubar structure.
322  */
323 void
324 FGMenuBar::make_menubar(const SGPropertyNode * props) 
325 {    
326     // Just in case.
327     destroy_menubar();
328     _menuBar = new puMenuBar;
329
330     vector<SGPropertyNode_ptr> menu_nodes = props->getChildren("menu");
331     for (unsigned int i = 0; i < menu_nodes.size(); i++)
332         make_menu(menu_nodes[i]);
333
334     _menuBar->close();
335     if (_visible)
336         _menuBar->reveal();
337     else
338         _menuBar->hide();
339 }
340
341 void
342 FGMenuBar::destroy_menubar ()
343 {
344     if ( _menuBar == 0 )
345         return;
346
347     hide();
348     puDeleteObject(_menuBar);
349
350     unsigned int i;
351
352                                 // Delete all the character arrays
353                                 // we were forced to keep around for
354                                 // plib.
355     SG_LOG(SG_GENERAL, SG_INFO, "Deleting char arrays");
356     for (i = 0; i < _char_arrays.size(); i++) {
357         for (int j = 0; _char_arrays[i][j] != 0; j++)
358             free(_char_arrays[i][j]); // added with strdup
359         delete[] _char_arrays[i];
360     }
361
362                                 // Delete all the callback arrays
363                                 // we were forced to keep around for
364                                 // plib.
365     SG_LOG(SG_GENERAL, SG_INFO, "Deleting callback arrays");
366     for (i = 0; i < _callback_arrays.size(); i++)
367         delete[] _callback_arrays[i];
368
369                                 // Delete all those bindings
370     SG_LOG(SG_GENERAL, SG_INFO, "Deleting bindings");
371     map<string,vector<FGBinding *> >::iterator it;
372     it = _bindings.begin();
373     for (it = _bindings.begin(); it != _bindings.end(); it++) {
374         SG_LOG(SG_GENERAL, SG_INFO, "Deleting bindings for " << it->first);
375         for ( i = 0; i < it->second.size(); i++ )
376             delete it->second[i];
377     }
378
379     SG_LOG(SG_GENERAL, SG_INFO, "Done.");
380 }
381
382
383 char **
384 FGMenuBar::make_char_array (int size)
385 {
386     char ** list = new char*[size+1];
387     for (int i = 0; i <= size; i++)
388         list[i] = 0;
389     _char_arrays.push_back(list);
390     return list;
391 }
392
393 puCallback *
394 FGMenuBar::make_callback_array (int size)
395 {
396     puCallback * list = new puCallback[size+1];
397     for (int i = 0; i <= size; i++)
398         list[i] = 0;
399     _callback_arrays.push_back(list);
400     return list;
401 }
402
403 // end of menubar.cxx