1
0
Fork 0
flightgear/src/Cockpit/panel.hxx

599 lines
15 KiB
C++
Raw Normal View History

2000-09-13 21:51:07 +00:00
// panel.hxx - generic support classes for a 2D panel.
2000-02-15 03:30:01 +00:00
//
// Written by David Megginson, started January 2000.
//
1999-01-07 19:25:53 +00:00
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//
1999-01-07 19:25:53 +00:00
// $Id$
2000-02-15 03:30:01 +00:00
#ifndef __PANEL_HXX
#define __PANEL_HXX
#ifndef __cplusplus
# error This library requires C++
#endif
1998-11-09 23:38:50 +00:00
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <simgear/compiler.h>
1999-01-07 19:25:53 +00:00
#ifdef HAVE_WINDOWS_H
1998-11-09 23:38:50 +00:00
# include <windows.h>
#endif
#include <GL/glut.h>
2000-02-15 03:30:01 +00:00
#include <plib/ssg.h>
1998-11-09 23:38:50 +00:00
2001-05-15 23:08:25 +00:00
#include <simgear/math/interpolater.hxx>
#include <simgear/misc/props.hxx>
#include <simgear/timing/timestamp.hxx>
#include <vector>
#include <map>
#include <plib/fnt.h>
#include <Main/fgfs.hxx>
2001-03-23 22:59:18 +00:00
SG_USING_STD(vector);
SG_USING_STD(map);
2000-02-15 03:30:01 +00:00
class FGPanelInstrument;
////////////////////////////////////////////////////////////////////////
// Texture manager (should migrate out into FGFS).
//
// This class ensures that no texture is loaded more than once.
////////////////////////////////////////////////////////////////////////
class FGTextureManager
{
public:
static ssgTexture * createTexture(const string &relativePath);
private:
2000-09-13 21:51:07 +00:00
static map<string,ssgTexture *> _textureMap;
};
////////////////////////////////////////////////////////////////////////
// Cropped texture (should migrate out into FGFS).
//
2000-09-13 21:51:07 +00:00
// This structure wraps an SSG texture with cropping information.
////////////////////////////////////////////////////////////////////////
class FGCroppedTexture
{
public:
FGCroppedTexture ();
FGCroppedTexture (const string &path,
float _minX = 0.0, float _minY = 0.0,
float _maxX = 1.0, float _maxY = 1.0);
virtual ~FGCroppedTexture ();
virtual void setPath (const string &path) { _path = path; }
virtual const string &getPath () const { return _path; }
virtual ssgTexture * getTexture ();
virtual void setCrop (float minX, float minY, float maxX, float maxY) {
_minX = minX; _minY = minY; _maxX = maxX; _maxY = maxY;
}
virtual float getMinX () const { return _minX; }
virtual float getMinY () const { return _minY; }
virtual float getMaxX () const { return _maxX; }
virtual float getMaxY () const { return _maxY; }
private:
string _path;
ssgTexture * _texture;
float _minX, _minY, _maxX, _maxY;
};
2000-02-15 03:30:01 +00:00
////////////////////////////////////////////////////////////////////////
// Instrument panel class.
//
// The panel is a container that has a background texture and holds
// zero or more instruments. The panel will order the instruments to
// redraw themselves when necessary, and will pass mouse clicks on to
// the appropriate instruments for processing.
2000-02-15 03:30:01 +00:00
////////////////////////////////////////////////////////////////////////
class FGPanel : public FGSubsystem
2000-02-15 03:30:01 +00:00
{
public:
David Megginson writes: I have a scrollable panel working (it didn't take long in the end). A panel can now be much wider or higher than the available area, and the user can scroll around using [Shift]F5, [Shift]F6, [Shift]F7, and [Shift]F8. The user can also scroll the panel down to get a bigger external view. Mouse clicks seem still to be working correctly. To set the panel's (virtual) height and width, use the panel file's /w and /h properties in a panel XML file; to set the initial x- and y- offsets (untested), use the panel file's /x-offset and /y-offset properties; to set the initial height of the external view (untested and optional), use the panel file's /view-height property. Note that none of these show up in the regular FGFS property manager. Unfortunately, these patches will not affect your initialization problems with the property manager -- I'm having a hard time tracking them down because I cannot reproduce them. I have also made some patches to main.cxx and views.cxx to do two things: 1. Expand or shrink the external view as the panel moves up and down. 2. Set the window ratio correctly, so that we don't get an oval sun and flat clouds when the panel is visible (the problem before was integer division, so I added casts). Unfortunately, the window ratio is not set properly at start-up -- there are too many dependencies, and I haven't figured that part out yet. As soon as you hide and redisplay the panel or move it vertically (i.e. force fgReshape to be called), you'll see the correct ratio.
2000-10-06 21:16:01 +00:00
FGPanel (int window_x, int window_y, int window_w, int window_h);
virtual ~FGPanel ();
// Update the panel (every frame).
virtual void init ();
virtual void bind ();
virtual void unbind ();
virtual void update ();
// transfer pointer ownership!!!
virtual void addInstrument (FGPanelInstrument * instrument);
// Background texture.
virtual void setBackground (ssgTexture * texture);
// Make the panel visible or invisible.
virtual bool getVisibility () const;
virtual void setVisibility (bool visibility);
David Megginson writes: I have a scrollable panel working (it didn't take long in the end). A panel can now be much wider or higher than the available area, and the user can scroll around using [Shift]F5, [Shift]F6, [Shift]F7, and [Shift]F8. The user can also scroll the panel down to get a bigger external view. Mouse clicks seem still to be working correctly. To set the panel's (virtual) height and width, use the panel file's /w and /h properties in a panel XML file; to set the initial x- and y- offsets (untested), use the panel file's /x-offset and /y-offset properties; to set the initial height of the external view (untested and optional), use the panel file's /view-height property. Note that none of these show up in the regular FGFS property manager. Unfortunately, these patches will not affect your initialization problems with the property manager -- I'm having a hard time tracking them down because I cannot reproduce them. I have also made some patches to main.cxx and views.cxx to do two things: 1. Expand or shrink the external view as the panel moves up and down. 2. Set the window ratio correctly, so that we don't get an oval sun and flat clouds when the panel is visible (the problem before was integer division, so I added casts). Unfortunately, the window ratio is not set properly at start-up -- there are too many dependencies, and I haven't figured that part out yet. As soon as you hide and redisplay the panel or move it vertically (i.e. force fgReshape to be called), you'll see the correct ratio.
2000-10-06 21:16:01 +00:00
// Full width of panel.
virtual void setWidth (int width) { _width = width; }
virtual int getWidth () const { return _width; }
// Full height of panel.
virtual void setHeight (int height) { _height = height; }
virtual int getHeight () const { return _height; }
// X-offset
virtual void setXOffset (int offset);
virtual int getXOffset () const { return _x_offset; }
// Y-offset.
virtual void setYOffset (int offset);
virtual int getYOffset () const { return _y_offset; }
// View height.
virtual void setViewHeight (int height) { _view_height = height; }
virtual int getViewHeight () const { return _view_height; }
// Handle a mouse click.
virtual bool doMouseAction (int button, int updown, int x, int y);
2000-02-15 03:30:01 +00:00
private:
mutable bool _visibility;
mutable bool _mouseDown;
mutable int _mouseButton, _mouseX, _mouseY;
mutable int _mouseDelay;
mutable FGPanelInstrument * _mouseInstrument;
typedef vector<FGPanelInstrument *> instrument_list_type;
David Megginson writes: I have a scrollable panel working (it didn't take long in the end). A panel can now be much wider or higher than the available area, and the user can scroll around using [Shift]F5, [Shift]F6, [Shift]F7, and [Shift]F8. The user can also scroll the panel down to get a bigger external view. Mouse clicks seem still to be working correctly. To set the panel's (virtual) height and width, use the panel file's /w and /h properties in a panel XML file; to set the initial x- and y- offsets (untested), use the panel file's /x-offset and /y-offset properties; to set the initial height of the external view (untested and optional), use the panel file's /view-height property. Note that none of these show up in the regular FGFS property manager. Unfortunately, these patches will not affect your initialization problems with the property manager -- I'm having a hard time tracking them down because I cannot reproduce them. I have also made some patches to main.cxx and views.cxx to do two things: 1. Expand or shrink the external view as the panel moves up and down. 2. Set the window ratio correctly, so that we don't get an oval sun and flat clouds when the panel is visible (the problem before was integer division, so I added casts). Unfortunately, the window ratio is not set properly at start-up -- there are too many dependencies, and I haven't figured that part out yet. As soon as you hide and redisplay the panel or move it vertically (i.e. force fgReshape to be called), you'll see the correct ratio.
2000-10-06 21:16:01 +00:00
int _winx, _winy, _winw, _winh;
int _width;
int _height;
int _x_offset;
int _y_offset;
int _view_height;
bool _bound;
David Megginson writes: I have a scrollable panel working (it didn't take long in the end). A panel can now be much wider or higher than the available area, and the user can scroll around using [Shift]F5, [Shift]F6, [Shift]F7, and [Shift]F8. The user can also scroll the panel down to get a bigger external view. Mouse clicks seem still to be working correctly. To set the panel's (virtual) height and width, use the panel file's /w and /h properties in a panel XML file; to set the initial x- and y- offsets (untested), use the panel file's /x-offset and /y-offset properties; to set the initial height of the external view (untested and optional), use the panel file's /view-height property. Note that none of these show up in the regular FGFS property manager. Unfortunately, these patches will not affect your initialization problems with the property manager -- I'm having a hard time tracking them down because I cannot reproduce them. I have also made some patches to main.cxx and views.cxx to do two things: 1. Expand or shrink the external view as the panel moves up and down. 2. Set the window ratio correctly, so that we don't get an oval sun and flat clouds when the panel is visible (the problem before was integer division, so I added casts). Unfortunately, the window ratio is not set properly at start-up -- there are too many dependencies, and I haven't figured that part out yet. As soon as you hide and redisplay the panel or move it vertically (i.e. force fgReshape to be called), you'll see the correct ratio.
2000-10-06 21:16:01 +00:00
2000-02-15 03:30:01 +00:00
ssgTexture * _bg;
// List of instruments in panel.
instrument_list_type _instruments;
};
////////////////////////////////////////////////////////////////////////
// Base class for user action types.
//
// Individual instruments can have actions associated with a mouse
// click in a rectangular area. Current concrete classes include
// FGAdjustAction, FGSwapAction, and FGToggleAction.
////////////////////////////////////////////////////////////////////////
class FGPanelAction
{
public:
FGPanelAction ();
FGPanelAction (int button, int x, int y, int w, int h);
virtual ~FGPanelAction ();
2000-09-13 21:51:07 +00:00
// Getters.
virtual int getButton () const { return _button; }
virtual int getX () const { return _x; }
virtual int getY () const { return _y; }
virtual int getWidth () const { return _w; }
virtual int getHeight () const { return _h; }
2000-09-13 21:51:07 +00:00
// Setters.
virtual void setButton (int button) { _button = button; }
virtual void setX (int x) { _x = x; }
virtual void setY (int y) { _y = y; }
virtual void setWidth (int w) { _w = w; }
virtual void setHeight (int h) { _h = h; }
2000-09-13 21:51:07 +00:00
// Check whether we're in the area.
virtual bool inArea (int button, int x, int y)
{
return (button == _button &&
x >= _x &&
x < _x + _w &&
y >= _y &&
y < _y + _h);
}
2000-09-13 21:51:07 +00:00
// Perform the action.
virtual void doAction () = 0;
private:
int _button;
int _x;
int _y;
int _w;
int _h;
};
////////////////////////////////////////////////////////////////////////
// Adjustment action.
//
// This is an action to increase or decrease an FGFS value by a certain
// increment within a certain range. If the wrap flag is true, the
// value will wrap around if it goes below min or above max; otherwise,
// it will simply stop at min or max.
////////////////////////////////////////////////////////////////////////
class FGAdjustAction : public FGPanelAction
{
public:
FGAdjustAction (int button, int x, int y, int w, int h,
SGPropertyNode * node, float increment,
float min, float max, bool wrap=false);
virtual ~FGAdjustAction ();
virtual void doAction ();
private:
SGPropertyNode * _node;
float _increment;
float _min;
float _max;
bool _wrap;
};
2000-02-15 03:30:01 +00:00
////////////////////////////////////////////////////////////////////////
// Swap action.
//
// This is an action to swap two values. It's currently used in the
// navigation radios.
////////////////////////////////////////////////////////////////////////
class FGSwapAction : public FGPanelAction
{
public:
FGSwapAction (int button, int x, int y, int w, int h,
SGPropertyNode * node1, SGPropertyNode * node2);
virtual ~FGSwapAction ();
virtual void doAction ();
private:
SGPropertyNode * _node1;
SGPropertyNode * _node2;
};
////////////////////////////////////////////////////////////////////////
// Toggle action.
//
// This is an action to toggle a boolean value.
////////////////////////////////////////////////////////////////////////
class FGToggleAction : public FGPanelAction
{
public:
FGToggleAction (int button, int x, int y, int w, int h,
SGPropertyNode * node);
virtual ~FGToggleAction ();
virtual void doAction ();
private:
SGPropertyNode * _node;
};
////////////////////////////////////////////////////////////////////////
// Abstract base class for a panel instrument.
//
// A panel instrument consists of zero or more actions, associated
// with mouse clicks in rectangular areas. Currently, the only
// concrete class derived from this is FGLayeredInstrument, but others
// may show up in the future (some complex instruments could be
// entirely hand-coded, for example).
2000-02-15 03:30:01 +00:00
////////////////////////////////////////////////////////////////////////
2000-02-15 03:30:01 +00:00
class FGPanelInstrument
{
public:
2000-02-15 03:30:01 +00:00
FGPanelInstrument ();
FGPanelInstrument (int x, int y, int w, int h);
virtual ~FGPanelInstrument ();
virtual void draw () = 0;
2000-02-15 03:30:01 +00:00
virtual void setPosition(int x, int y);
virtual void setSize(int w, int h);
2000-02-15 03:30:01 +00:00
virtual int getXPos () const;
virtual int getYPos () const;
virtual int getWidth () const;
virtual int getHeight () const;
// Coordinates relative to centre.
// Transfer pointer ownership!!
virtual void addAction (FGPanelAction * action);
// Coordinates relative to centre.
virtual bool doMouseAction (int button, int x, int y);
2000-02-15 03:30:01 +00:00
protected:
int _x, _y, _w, _h;
typedef vector<FGPanelAction *> action_list_type;
action_list_type _actions;
};
2000-02-15 03:30:01 +00:00
////////////////////////////////////////////////////////////////////////
// Abstract base class for an instrument layer.
//
// The FGLayeredInstrument class builds up instruments by using layers
// of textures or text. Each layer can have zero or more
// transformations applied to it: for example, a needle layer can
// rotate to show the altitude or airspeed.
2000-02-15 03:30:01 +00:00
////////////////////////////////////////////////////////////////////////
/**
* A transformation for a layer.
*/
class FGPanelTransformation {
public:
enum Type {
XSHIFT,
YSHIFT,
ROTATION
};
FGPanelTransformation ();
virtual ~FGPanelTransformation ();
Type type;
const SGPropertyNode * node;
float min;
float max;
float factor;
float offset;
2001-05-15 23:08:25 +00:00
SGInterpTable * table;
};
/**
* A single layer of a multi-layered instrument.
*
* Each layer can be subject to a series of transformations based
* on current FGFS instrument readings: for example, a texture
* representing a needle can rotate to show the airspeed.
*/
class FGInstrumentLayer
{
public:
2000-02-15 03:30:01 +00:00
FGInstrumentLayer (int w = -1, int h = -1);
virtual ~FGInstrumentLayer ();
virtual void draw () = 0;
virtual void transform () const;
virtual int getWidth () const { return _w; }
virtual int getHeight () const { return _h; }
virtual void setWidth (int w) { _w = w; }
virtual void setHeight (int h) { _h = h; }
// Transfer pointer ownership!!
// DEPRECATED
virtual void addTransformation (FGPanelTransformation * transformation);
2000-02-15 03:30:01 +00:00
protected:
int _w, _h;
typedef vector<FGPanelTransformation *> transformation_list;
transformation_list _transformations;
};
2000-02-15 03:30:01 +00:00
////////////////////////////////////////////////////////////////////////
// An instrument composed of layers.
//
// This class represents an instrument which is simply a series of
// layers piled one on top of the other, each one undergoing its own
// set of transformations. For example, one layer can represent
// the instrument's face (which doesn't move), while the next layer
// can represent a needle that rotates depending on an FGFS variable.
2000-02-15 03:30:01 +00:00
////////////////////////////////////////////////////////////////////////
/**
* An instrument constructed of multiple layers.
*
* Each individual layer can be rotated or shifted to correspond
* to internal FGFS instrument readings.
*/
class FGLayeredInstrument : public FGPanelInstrument
2000-02-15 03:30:01 +00:00
{
public:
FGLayeredInstrument (int x, int y, int w, int h);
virtual ~FGLayeredInstrument ();
virtual void draw ();
// Transfer pointer ownership!!
virtual int addLayer (FGInstrumentLayer *layer);
virtual int addLayer (FGCroppedTexture &texture, int w = -1, int h = -1);
// Transfer pointer ownership!!
virtual void addTransformation (FGPanelTransformation * transformation);
2000-02-15 03:30:01 +00:00
protected:
typedef vector<FGInstrumentLayer *> layer_list;
layer_list _layers;
2000-02-15 03:30:01 +00:00
};
2000-02-15 03:30:01 +00:00
////////////////////////////////////////////////////////////////////////
// A textured layer of an instrument.
//
// This is a layer holding a single texture. Normally, the texture's
// backgound should be transparent so that lower layers and the panel
// background can show through.
2000-02-15 03:30:01 +00:00
////////////////////////////////////////////////////////////////////////
class FGTexturedLayer : public FGInstrumentLayer
2000-02-15 03:30:01 +00:00
{
public:
FGTexturedLayer (int w = -1, int h = -1) : FGInstrumentLayer(w, h) {}
FGTexturedLayer (const FGCroppedTexture &texture, int w = -1, int h = -1);
virtual ~FGTexturedLayer ();
virtual void draw ();
virtual void setTexture (const FGCroppedTexture &texture) {
2000-09-13 21:51:07 +00:00
_texture = texture;
}
virtual FGCroppedTexture &getTexture () { return _texture; }
virtual const FGCroppedTexture &getTexture () const { return _texture; }
2000-02-15 03:30:01 +00:00
private:
mutable FGCroppedTexture _texture;
2000-02-15 03:30:01 +00:00
};
2000-02-15 03:30:01 +00:00
////////////////////////////////////////////////////////////////////////
// A text layer of an instrument.
//
// This is a layer holding a string of static and/or generated text.
// It is useful for instruments that have text displays, such as
// a chronometer, GPS, or NavCom radio.
2000-02-15 03:30:01 +00:00
////////////////////////////////////////////////////////////////////////
class FGTextLayer : public FGInstrumentLayer
2000-02-15 03:30:01 +00:00
{
public:
typedef enum ChunkType {
TEXT,
TEXT_VALUE,
DOUBLE_VALUE
};
class Chunk {
public:
2000-09-13 21:51:07 +00:00
Chunk (const string &text, const string &fmt = "%s");
Chunk (ChunkType type, const SGPropertyNode * node,
2000-09-13 21:51:07 +00:00
const string &fmt = "", float mult = 1.0);
2000-09-13 21:51:07 +00:00
const char * getValue () const;
private:
ChunkType _type;
2000-09-13 21:51:07 +00:00
string _text;
const SGPropertyNode * _node;
2000-09-13 21:51:07 +00:00
string _fmt;
float _mult;
mutable char _buf[1024];
};
FGTextLayer (int w = -1, int h = -1);
virtual ~FGTextLayer ();
virtual void draw ();
// Transfer pointer!!
virtual void addChunk (Chunk * chunk);
virtual void setColor (float r, float g, float b);
virtual void setPointSize (float size);
virtual void setFont (fntFont * font);
private:
void recalc_value () const;
typedef vector<Chunk *> chunk_list;
chunk_list _chunks;
2000-03-17 06:16:15 +00:00
float _color[4];
2000-09-13 21:51:07 +00:00
float _pointSize;
mutable string _value;
mutable SGTimeStamp _then;
mutable SGTimeStamp _now;
};
////////////////////////////////////////////////////////////////////////
// A layer that switches between two other layers.
////////////////////////////////////////////////////////////////////////
class FGSwitchLayer : public FGInstrumentLayer
{
public:
// Transfer pointers!!
FGSwitchLayer (int w, int h, const SGPropertyNode * node,
FGInstrumentLayer * layer1,
FGInstrumentLayer * layer2);
virtual ~FGSwitchLayer ();
virtual void draw ();
private:
const SGPropertyNode * _node;
FGInstrumentLayer * _layer1, * _layer2;
};
////////////////////////////////////////////////////////////////////////
// Functions.
////////////////////////////////////////////////////////////////////////
bool fgPanelVisible ();
////////////////////////////////////////////////////////////////////////
// The current panel, if any.
////////////////////////////////////////////////////////////////////////
extern FGPanel * current_panel;
2000-02-15 03:30:01 +00:00
#endif // __PANEL_HXX
// end of panel.hxx
1998-11-09 23:38:50 +00:00