X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FCockpit%2Fpanel.hxx;h=bde2930a6d47b957db7af1d46f20e44561f0b732;hb=938d006188e70e891bc04e91610c7b8caaca87b6;hp=b90b4fa797febc45a0c89d088a4a043cf2de4cea;hpb=a975fd77c5cdee59b940cc72607978d1ccf734fe;p=flightgear.git diff --git a/src/Cockpit/panel.hxx b/src/Cockpit/panel.hxx index b90b4fa79..bde2930a6 100644 --- a/src/Cockpit/panel.hxx +++ b/src/Cockpit/panel.hxx @@ -1,4 +1,4 @@ -// panel.hxx - default, 2D single-engine prop instrument panel +// panel.hxx - generic support classes for a 2D panel. // // Written by David Megginson, started January 2000. // @@ -30,6 +30,8 @@ # include #endif +#include + #ifdef HAVE_WINDOWS_H # include #endif @@ -37,74 +39,170 @@ #include #include +#include +#include +#include + #include #include #include -FG_USING_STD(vector); -FG_USING_STD(map); +#include
+#include
+ +#include + +SG_USING_STD(vector); +SG_USING_STD(map); class FGPanelInstrument; //////////////////////////////////////////////////////////////////////// -// Texture manager (should migrate out into FGFS). -// -// This class ensures that no texture is loaded more than once. +// Texture management. //////////////////////////////////////////////////////////////////////// + +/** + * 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 char * relativePath); + static ssgTexture * createTexture(const string &relativePath); +private: + static map _textureMap; +}; + + +/** + * Cropped texture (should migrate out into FGFS). + * + * 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: - static map_textureMap; + string _path; + ssgTexture * _texture; + float _minX, _minY, _maxX, _maxY; }; + //////////////////////////////////////////////////////////////////////// -// 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. +// Top-level panel. //////////////////////////////////////////////////////////////////////// -class FGPanel + +/** + * 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. + */ +class FGPanel : public FGSubsystem { public: - FGPanel (int x, int y, int w, int h); + FGPanel (); virtual ~FGPanel (); + // Update the panel (every frame). + virtual void init (); + virtual void bind (); + virtual void unbind (); + virtual void update (int dt); + virtual void update (GLfloat winx, GLfloat winw, GLfloat winy, GLfloat winh); + // transfer pointer ownership!!! virtual void addInstrument (FGPanelInstrument * instrument); - // Update the panel (every frame). - virtual void update () const; - // Background texture. virtual void setBackground (ssgTexture * texture); + // Background multiple textures. + virtual void setMultiBackground (ssgTexture * texture, int idx); + // Make the panel visible or invisible. virtual bool getVisibility () const; virtual void setVisibility (bool visibility); + // 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); private: - bool _visibility; - bool _mouseDown; - int _mouseButton, _mouseX, _mouseY; + void setupVirtualCockpit(); + void cleanupVirtualCockpit(); + + mutable bool _visibility; + mutable bool _mouseDown; + mutable int _mouseButton, _mouseX, _mouseY; mutable int _mouseDelay; - FGPanelInstrument * _mouseInstrument; + mutable FGPanelInstrument * _mouseInstrument; typedef vector instrument_list_type; - int _x, _y, _w, _h; - int _panel_h; + int _width; + int _height; + int _x_offset; + int _y_offset; + int _view_height; + bool _bound; + float _jitter; + + const SGPropertyNode * _xsize_node; + const SGPropertyNode * _ysize_node; + ssgTexture * _bg; + ssgTexture * _mbg[8]; // List of instruments in panel. instrument_list_type _instruments; }; @@ -112,118 +210,162 @@ private: //////////////////////////////////////////////////////////////////////// -// Base class for user action types. -// -// Individual instruments can have actions associated with a mouse -// click in a rectangular area. Current concrete classes are -// FGAdjustAction and FGSwapAction. +// Actions //////////////////////////////////////////////////////////////////////// -class FGPanelAction -{ -public: - virtual void doAction () = 0; -}; - - - -//////////////////////////////////////////////////////////////////////// -// 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 +/** + * Class for user actions. + * + * The actions are command bindings, like bindings for the keyboard + * or joystick, but they are tied to specific mouse actions in + * rectangular areas of the panel. + */ +class FGPanelAction : public FGConditional { public: - typedef double (*getter_type)(); - typedef void (*setter_type)(double); - - FGAdjustAction (getter_type getter, setter_type setter, double increment, - double min, double max, bool wrap=false); - virtual ~FGAdjustAction (); + FGPanelAction (); + FGPanelAction (int button, int x, int y, int w, int h); + virtual ~FGPanelAction (); + + // 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; } + + // Setters. + + // transfer pointer ownership + virtual void addBinding (FGBinding * binding); + 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; } + + // 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); + } + + // Perform the action. virtual void doAction (); private: - getter_type _getter; - setter_type _setter; - double _increment; - double _min; - double _max; - bool _wrap; + typedef vector binding_list_t; + + int _button; + int _x; + int _y; + int _w; + int _h; + binding_list_t _bindings; }; //////////////////////////////////////////////////////////////////////// -// Swap action. -// -// This is an action to swap two values. It's currently used in the -// navigation radios. +// Transformations. //////////////////////////////////////////////////////////////////////// -class FGSwapAction : public FGPanelAction + +/** + * A transformation for a layer. + */ +class FGPanelTransformation : public FGConditional { public: - typedef double (*getter_type)(); - typedef void (*setter_type)(double); - FGSwapAction (getter_type getter1, setter_type setter1, - getter_type getter2, setter_type setter2); - virtual ~FGSwapAction (); - virtual void doAction (); + enum Type { + XSHIFT, + YSHIFT, + ROTATION + }; -private: - getter_type _getter1, _getter2; - setter_type _setter1, _setter2; + FGPanelTransformation (); + virtual ~FGPanelTransformation (); + + Type type; + const SGPropertyNode * node; + float min; + float max; + float factor; + float offset; + SGInterpTable * table; }; + //////////////////////////////////////////////////////////////////////// -// Toggle action. -// -// This is an action to toggle a boolean value. +// Layers //////////////////////////////////////////////////////////////////////// -class FGToggleAction : public FGPanelAction + +/** + * 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 FGConditional { public: - typedef bool (*getter_type)(); - typedef void (*setter_type)(bool); - FGToggleAction (getter_type getter, setter_type setter); - virtual ~FGToggleAction (); - virtual void doAction (); + FGInstrumentLayer (int w = -1, int h = -1); + virtual ~FGInstrumentLayer (); -private: - getter_type _getter; - setter_type _setter; + 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); + +protected: + int _w, _h; + + typedef vector transformation_list; + transformation_list _transformations; }; //////////////////////////////////////////////////////////////////////// -// 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). +// Instruments. //////////////////////////////////////////////////////////////////////// -class FGPanelInstrument + +/** + * 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). + */ +class FGPanelInstrument : public FGConditional { public: FGPanelInstrument (); FGPanelInstrument (int x, int y, int w, int h); virtual ~FGPanelInstrument (); - virtual void draw () const = 0; + virtual void draw () = 0; virtual void setPosition(int x, int y); virtual void setSize(int w, int h); @@ -235,95 +377,18 @@ public: // Coordinates relative to centre. // Transfer pointer ownership!! - virtual void addAction (int button, int x, int y, int w, int h, - FGPanelAction * action); + virtual void addAction (FGPanelAction * action); // Coordinates relative to centre. virtual bool doMouseAction (int button, int x, int y); protected: int _x, _y, _w, _h; - typedef struct { - int button; - int x; - int y; - int w; - int h; - FGPanelAction * action; - } inst_action; - typedef vector action_list_type; + typedef vector action_list_type; action_list_type _actions; }; - -//////////////////////////////////////////////////////////////////////// -// 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. -//////////////////////////////////////////////////////////////////////// - -/** - * 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: - typedef enum { - XSHIFT, - YSHIFT, - ROTATION - } transform_type; - - typedef double (*transform_func)(); - - - FGInstrumentLayer (); - FGInstrumentLayer (int w, int h); - virtual ~FGInstrumentLayer (); - - virtual void draw () const = 0; - virtual void transform () const; - - virtual void addTransformation (transform_type type, transform_func func, - double min, double max, - double factor = 1.0, double offset = 0.0); - -protected: - int _w, _h; - - typedef struct { - transform_type type; - transform_func func; - double min; - double max; - double factor; - double offset; - } transformation; - typedef vector transformation_list; - transformation_list _transformations; -}; - - - -//////////////////////////////////////////////////////////////////////// -// 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. -//////////////////////////////////////////////////////////////////////// - - /** * An instrument constructed of multiple layers. * @@ -333,143 +398,173 @@ protected: class FGLayeredInstrument : public FGPanelInstrument { public: - typedef vector layer_list; FGLayeredInstrument (int x, int y, int w, int h); virtual ~FGLayeredInstrument (); - virtual void draw () const; + virtual void draw (); // Transfer pointer ownership!! virtual int addLayer (FGInstrumentLayer *layer); - virtual int addLayer (ssgTexture * texture); - virtual void addTransformation (FGInstrumentLayer::transform_type type, - FGInstrumentLayer::transform_func func, - double min, double max, - double factor = 1.0, double offset = 0.0); - virtual void addTransformation (FGInstrumentLayer::transform_type type, - double offset); + virtual int addLayer (FGCroppedTexture &texture, int w = -1, int h = -1); + + // Transfer pointer ownership!! + virtual void addTransformation (FGPanelTransformation * transformation); protected: + typedef vector layer_list; layer_list _layers; }; - -//////////////////////////////////////////////////////////////////////// -// 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. -//////////////////////////////////////////////////////////////////////// +/** + * An instrument layer containing a group of sublayers. + * + * This class is useful for gathering together a group of related + * layers, either to hold in an external file or to work under + * the same condition. + */ +class FGGroupLayer : public FGInstrumentLayer +{ +public: + FGGroupLayer (); + virtual ~FGGroupLayer (); + virtual void draw (); + // transfer pointer ownership + virtual void addLayer (FGInstrumentLayer * layer); +private: + vector _layers; +}; + +/** + * 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. + */ class FGTexturedLayer : public FGInstrumentLayer { public: - FGTexturedLayer (ssgTexture * texture, int w, int h, - double texX1 = 0.0, double texY1 = 0.0, - double texX2 = 1.0, double texY2 = 1.0); + 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 () const; + virtual void draw (); - virtual void setTexture (ssgTexture * texture) { _texture = texture; } + virtual void setTexture (const FGCroppedTexture &texture) { + _texture = texture; + } + virtual FGCroppedTexture &getTexture () { return _texture; } + virtual const FGCroppedTexture &getTexture () const { return _texture; } private: - ssgTexture * _texture; - double _texX1, _texY1, _texX2, _texY2; + mutable FGCroppedTexture _texture; }; - -//////////////////////////////////////////////////////////////////////// -// 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. -//////////////////////////////////////////////////////////////////////// - +/** + * 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. + */ class FGTextLayer : public FGInstrumentLayer { public: - typedef char * (*text_func)(); - typedef double (*double_func)(); typedef enum ChunkType { TEXT, - TEXT_FUNC, - DOUBLE_FUNC + TEXT_VALUE, + DOUBLE_VALUE }; - class Chunk { + class Chunk : public FGConditional + { public: - Chunk (char * text, char * fmt = "%s"); - Chunk (text_func func, char * fmt = "%s"); - Chunk (double_func func, char * fmt = "%.2f", double mult = 1.0); + Chunk (const string &text, const string &fmt = "%s"); + Chunk (ChunkType type, const SGPropertyNode * node, + const string &fmt = "", float mult = 1.0); - char * getValue () const; + const char * getValue () const; private: ChunkType _type; - union { - char * _text; - text_func _tfunc; - double_func _dfunc; - } _value; - char * _fmt; - double _mult; + string _text; + const SGPropertyNode * _node; + string _fmt; + float _mult; mutable char _buf[1024]; }; - FGTextLayer (int w, int h); + FGTextLayer (int w = -1, int h = -1); virtual ~FGTextLayer (); - virtual void draw () const; + 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 setFontName ( const string &name ); virtual void setFont (fntFont * font); private: + + void recalc_value () const; + typedef vector chunk_list; chunk_list _chunks; float _color[4]; - // FIXME: need only one globally - mutable fntRenderer _renderer; -}; + float _pointSize; + mutable string _font_name; + mutable string _value; + mutable SGTimeStamp _then; + mutable SGTimeStamp _now; +}; - -//////////////////////////////////////////////////////////////////////// -// A layer that switches between two other layers. -//////////////////////////////////////////////////////////////////////// +/** + * A layer that switches between two other layers. + * + * The usefulness of this layer is questionable now that all layers + * can have conditions, and it may be deprecated soon. + */ class FGSwitchLayer : public FGInstrumentLayer { public: - typedef bool (*switch_func)(); - // Transfer pointers!! - FGSwitchLayer (int w, int h, switch_func func, + FGSwitchLayer (int w, int h, const SGPropertyNode * node, FGInstrumentLayer * layer1, FGInstrumentLayer * layer2); virtual ~FGSwitchLayer (); - virtual void draw () const; + virtual void draw (); private: - switch_func _func; + const SGPropertyNode * _node; FGInstrumentLayer * _layer1, * _layer2; }; + + +//////////////////////////////////////////////////////////////////////// +// Functions. +//////////////////////////////////////////////////////////////////////// + +/** + * Test whether the panel should be visible. + */ +bool fgPanelVisible (); + + //////////////////////////////////////////////////////////////////////// // The current panel, if any. //////////////////////////////////////////////////////////////////////// -extern FGPanel * current_panel; +extern FGPanel * current_panel; // TODO: move to globals @@ -478,3 +573,4 @@ extern FGPanel * current_panel; // end of panel.hxx +