1
// panel.hxx - generic support classes for a 2D panel.
3
// Written by David Megginson, started January 2000.
5
// This program is free software; you can redistribute it and/or
6
// modify it under the terms of the GNU General Public License as
7
// published by the Free Software Foundation; either version 2 of the
8
// License, or (at your option) any later version.
10
// This program is distributed in the hope that it will be useful, but
11
// WITHOUT ANY WARRANTY; without even the implied warranty of
12
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13
// General Public License for more details.
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., 675 Mass Ave, Cambridge, MA 02139, USA.
19
// $Id: panel.hxx,v 1.34 2001/12/22 16:33:27 david Exp $
25
# error This library requires C++
33
#include <simgear/compiler.h>
42
#include <simgear/math/interpolater.hxx>
43
#include <simgear/misc/props.hxx>
44
#include <simgear/timing/timestamp.hxx>
50
#include <Main/fgfs.hxx>
51
#include <Main/fg_props.hxx>
53
#include <Input/input.hxx>
58
class FGPanelInstrument;
62
////////////////////////////////////////////////////////////////////////
63
// Texture management.
64
////////////////////////////////////////////////////////////////////////
68
* Texture manager (should migrate out into FGFS).
70
* This class ensures that no texture is loaded more than once.
72
class FGTextureManager
75
static ssgTexture * createTexture(const string &relativePath);
77
static map<string,ssgTexture *> _textureMap;
82
* Cropped texture (should migrate out into FGFS).
84
* This structure wraps an SSG texture with cropping information.
86
class FGCroppedTexture
91
FGCroppedTexture (const string &path,
92
float _minX = 0.0, float _minY = 0.0,
93
float _maxX = 1.0, float _maxY = 1.0);
94
virtual ~FGCroppedTexture ();
96
virtual void setPath (const string &path) { _path = path; }
98
virtual const string &getPath () const { return _path; }
100
virtual ssgTexture * getTexture ();
102
virtual void setCrop (float minX, float minY, float maxX, float maxY) {
103
_minX = minX; _minY = minY; _maxX = maxX; _maxY = maxY;
106
virtual float getMinX () const { return _minX; }
107
virtual float getMinY () const { return _minY; }
108
virtual float getMaxX () const { return _maxX; }
109
virtual float getMaxY () const { return _maxY; }
114
ssgTexture * _texture;
115
float _minX, _minY, _maxX, _maxY;
120
////////////////////////////////////////////////////////////////////////
122
////////////////////////////////////////////////////////////////////////
126
* Instrument panel class.
128
* The panel is a container that has a background texture and holds
129
* zero or more instruments. The panel will order the instruments to
130
* redraw themselves when necessary, and will pass mouse clicks on to
131
* the appropriate instruments for processing.
133
class FGPanel : public FGSubsystem
140
// Update the panel (every frame).
141
virtual void init ();
142
virtual void bind ();
143
virtual void unbind ();
144
virtual void update (int dt);
145
virtual void update (GLfloat winx, GLfloat winw, GLfloat winy, GLfloat winh);
147
// transfer pointer ownership!!!
148
virtual void addInstrument (FGPanelInstrument * instrument);
150
// Background texture.
151
virtual void setBackground (ssgTexture * texture);
153
// Make the panel visible or invisible.
154
virtual bool getVisibility () const;
155
virtual void setVisibility (bool visibility);
157
// Full width of panel.
158
virtual void setWidth (int width) { _width = width; }
159
virtual int getWidth () const { return _width; }
161
// Full height of panel.
162
virtual void setHeight (int height) { _height = height; }
163
virtual int getHeight () const { return _height; }
166
virtual void setXOffset (int offset);
167
virtual int getXOffset () const { return _x_offset; }
170
virtual void setYOffset (int offset);
171
virtual int getYOffset () const { return _y_offset; }
174
virtual void setViewHeight (int height) { _view_height = height; }
175
virtual int getViewHeight () const { return _view_height; }
177
// Handle a mouse click.
178
virtual bool doMouseAction (int button, int updown, int x, int y);
181
mutable bool _visibility;
182
mutable bool _mouseDown;
183
mutable int _mouseButton, _mouseX, _mouseY;
184
mutable int _mouseDelay;
185
mutable FGPanelInstrument * _mouseInstrument;
186
typedef vector<FGPanelInstrument *> instrument_list_type;
195
const SGPropertyNode * _xsize_node;
196
const SGPropertyNode * _ysize_node;
199
// List of instruments in panel.
200
instrument_list_type _instruments;
205
////////////////////////////////////////////////////////////////////////
207
////////////////////////////////////////////////////////////////////////
211
* Class for user actions.
213
* The actions are command bindings, like bindings for the keyboard
214
* or joystick, but they are tied to specific mouse actions in
215
* rectangular areas of the panel.
217
class FGPanelAction : public FGConditional
221
FGPanelAction (int button, int x, int y, int w, int h);
222
virtual ~FGPanelAction ();
225
virtual int getButton () const { return _button; }
226
virtual int getX () const { return _x; }
227
virtual int getY () const { return _y; }
228
virtual int getWidth () const { return _w; }
229
virtual int getHeight () const { return _h; }
233
// transfer pointer ownership
234
virtual void addBinding (FGBinding * binding);
235
virtual void setButton (int button) { _button = button; }
236
virtual void setX (int x) { _x = x; }
237
virtual void setY (int y) { _y = y; }
238
virtual void setWidth (int w) { _w = w; }
239
virtual void setHeight (int h) { _h = h; }
241
// Check whether we're in the area.
242
virtual bool inArea (int button, int x, int y)
244
return (button == _button &&
251
// Perform the action.
252
virtual void doAction ();
255
typedef vector<FGBinding *> binding_list_t;
262
binding_list_t _bindings;
267
////////////////////////////////////////////////////////////////////////
269
////////////////////////////////////////////////////////////////////////
273
* A transformation for a layer.
275
class FGPanelTransformation : public FGConditional
285
FGPanelTransformation ();
286
virtual ~FGPanelTransformation ();
289
const SGPropertyNode * node;
294
SGInterpTable * table;
300
////////////////////////////////////////////////////////////////////////
302
////////////////////////////////////////////////////////////////////////
306
* A single layer of a multi-layered instrument.
308
* Each layer can be subject to a series of transformations based
309
* on current FGFS instrument readings: for example, a texture
310
* representing a needle can rotate to show the airspeed.
312
class FGInstrumentLayer : public FGConditional
316
FGInstrumentLayer (int w = -1, int h = -1);
317
virtual ~FGInstrumentLayer ();
319
virtual void draw () = 0;
320
virtual void transform () const;
322
virtual int getWidth () const { return _w; }
323
virtual int getHeight () const { return _h; }
324
virtual void setWidth (int w) { _w = w; }
325
virtual void setHeight (int h) { _h = h; }
327
// Transfer pointer ownership!!
329
virtual void addTransformation (FGPanelTransformation * transformation);
334
typedef vector<FGPanelTransformation *> transformation_list;
335
transformation_list _transformations;
340
////////////////////////////////////////////////////////////////////////
342
////////////////////////////////////////////////////////////////////////
346
* Abstract base class for a panel instrument.
348
* A panel instrument consists of zero or more actions, associated
349
* with mouse clicks in rectangular areas. Currently, the only
350
* concrete class derived from this is FGLayeredInstrument, but others
351
* may show up in the future (some complex instruments could be
352
* entirely hand-coded, for example).
354
class FGPanelInstrument : public FGConditional
357
FGPanelInstrument ();
358
FGPanelInstrument (int x, int y, int w, int h);
359
virtual ~FGPanelInstrument ();
361
virtual void draw () = 0;
363
virtual void setPosition(int x, int y);
364
virtual void setSize(int w, int h);
366
virtual int getXPos () const;
367
virtual int getYPos () const;
368
virtual int getWidth () const;
369
virtual int getHeight () const;
371
// Coordinates relative to centre.
372
// Transfer pointer ownership!!
373
virtual void addAction (FGPanelAction * action);
375
// Coordinates relative to centre.
376
virtual bool doMouseAction (int button, int x, int y);
380
typedef vector<FGPanelAction *> action_list_type;
381
action_list_type _actions;
386
* An instrument constructed of multiple layers.
388
* Each individual layer can be rotated or shifted to correspond
389
* to internal FGFS instrument readings.
391
class FGLayeredInstrument : public FGPanelInstrument
394
FGLayeredInstrument (int x, int y, int w, int h);
395
virtual ~FGLayeredInstrument ();
397
virtual void draw ();
399
// Transfer pointer ownership!!
400
virtual int addLayer (FGInstrumentLayer *layer);
401
virtual int addLayer (FGCroppedTexture &texture, int w = -1, int h = -1);
403
// Transfer pointer ownership!!
404
virtual void addTransformation (FGPanelTransformation * transformation);
407
typedef vector<FGInstrumentLayer *> layer_list;
413
* An instrument layer containing a group of sublayers.
415
* This class is useful for gathering together a group of related
416
* layers, either to hold in an external file or to work under
417
* the same condition.
419
class FGGroupLayer : public FGInstrumentLayer
423
virtual ~FGGroupLayer ();
424
virtual void draw ();
425
// transfer pointer ownership
426
virtual void addLayer (FGInstrumentLayer * layer);
428
vector<FGInstrumentLayer *> _layers;
433
* A textured layer of an instrument.
435
* This is a layer holding a single texture. Normally, the texture's
436
* backgound should be transparent so that lower layers and the panel
437
* background can show through.
439
class FGTexturedLayer : public FGInstrumentLayer
442
FGTexturedLayer (int w = -1, int h = -1) : FGInstrumentLayer(w, h) {}
443
FGTexturedLayer (const FGCroppedTexture &texture, int w = -1, int h = -1);
444
virtual ~FGTexturedLayer ();
446
virtual void draw ();
448
virtual void setTexture (const FGCroppedTexture &texture) {
451
virtual FGCroppedTexture &getTexture () { return _texture; }
452
virtual const FGCroppedTexture &getTexture () const { return _texture; }
455
mutable FGCroppedTexture _texture;
460
* A text layer of an instrument.
462
* This is a layer holding a string of static and/or generated text.
463
* It is useful for instruments that have text displays, such as
464
* a chronometer, GPS, or NavCom radio.
466
class FGTextLayer : public FGInstrumentLayer
469
typedef enum ChunkType {
475
class Chunk : public FGConditional
478
Chunk (const string &text, const string &fmt = "%s");
479
Chunk (ChunkType type, const SGPropertyNode * node,
480
const string &fmt = "", float mult = 1.0);
482
const char * getValue () const;
486
const SGPropertyNode * _node;
489
mutable char _buf[1024];
492
FGTextLayer (int w = -1, int h = -1);
493
virtual ~FGTextLayer ();
495
virtual void draw ();
497
// Transfer pointer!!
498
virtual void addChunk (Chunk * chunk);
499
virtual void setColor (float r, float g, float b);
500
virtual void setPointSize (float size);
501
virtual void setFont (fntFont * font);
505
void recalc_value () const;
507
typedef vector<Chunk *> chunk_list;
513
mutable string _value;
514
mutable SGTimeStamp _then;
515
mutable SGTimeStamp _now;
520
* A layer that switches between two other layers.
522
* The usefulness of this layer is questionable now that all layers
523
* can have conditions, and it may be deprecated soon.
525
class FGSwitchLayer : public FGInstrumentLayer
528
// Transfer pointers!!
529
FGSwitchLayer (int w, int h, const SGPropertyNode * node,
530
FGInstrumentLayer * layer1,
531
FGInstrumentLayer * layer2);
532
virtual ~FGSwitchLayer ();
534
virtual void draw ();
537
const SGPropertyNode * _node;
538
FGInstrumentLayer * _layer1, * _layer2;
544
////////////////////////////////////////////////////////////////////////
546
////////////////////////////////////////////////////////////////////////
549
* Test whether the panel should be visible.
551
bool fgPanelVisible ();
555
////////////////////////////////////////////////////////////////////////
556
// The current panel, if any.
557
////////////////////////////////////////////////////////////////////////
559
extern FGPanel * current_panel; // TODO: move to globals
563
#endif // __PANEL_HXX
added
removed
src/Cockpit/panel.hxx
