diff --git a/src/GUI/CanvasWidget.hxx b/src/GUI/CanvasWidget.hxx
index 0dd654367..011c80944 100644
--- a/src/GUI/CanvasWidget.hxx
+++ b/src/GUI/CanvasWidget.hxx
@@ -20,7 +20,7 @@
#define CANVASWIDGET_HXX_
#include <Main/fg_props.hxx>
-#include <plib/pu.h>
+#include "pu.h"
#include <simgear/canvas/canvas_fwd.hxx>
diff --git a/src/GUI/FGFontCache.cxx b/src/GUI/FGFontCache.cxx
index cd73999e3..e23beef30 100755
--- a/src/GUI/FGFontCache.cxx
+++ b/src/GUI/FGFontCache.cxx
@@ -19,8 +19,7 @@
// this is our one in 3rdparty
#include "fnt.h"
-
-#include <plib/pu.h>
+#include "pu.h"
#include <simgear/props/props.hxx>
#include <simgear/misc/sg_dir.hxx>
diff --git a/src/GUI/FGPUIMenuBar.cxx b/src/GUI/FGPUIMenuBar.cxx
index 3c055767a..cf1678769 100644
--- a/src/GUI/FGPUIMenuBar.cxx
+++ b/src/GUI/FGPUIMenuBar.cxx
@@ -4,7 +4,6 @@
#include <string.h>
#include <iostream>
-#include <plib/pu.h>
#include <simgear/debug/logstream.hxx>
#include <simgear/structure/SGBinding.hxx>
#include <simgear/props/props_io.hxx>
@@ -15,6 +14,7 @@
#include "new_gui.hxx"
#include "FGPUIMenuBar.hxx"
+#include "pu.h"
using std::vector;
using std::string;
diff --git a/src/GUI/MapWidget.hxx b/src/GUI/MapWidget.hxx
index 39a8ab4c8..4c49ed124 100644
--- a/src/GUI/MapWidget.hxx
+++ b/src/GUI/MapWidget.hxx
@@ -7,8 +7,8 @@
#include <simgear/props/props.hxx>
#include <Navaids/positioned.hxx>
-#include <plib/pu.h>
+#include "pu.h"
#include "FGPUIDialog.hxx"
// forward decls
diff --git a/src/GUI/QQuickDrawable.cxx b/src/GUI/QQuickDrawable.cxx
index 4ea21233d..76b065502 100755
--- a/src/GUI/QQuickDrawable.cxx
+++ b/src/GUI/QQuickDrawable.cxx
@@ -64,7 +64,7 @@
#include <simgear/structure/commands.hxx>
#if defined(HAVE_PUI)
-#include <plib/pu.h>
+#include "pu.h"
#endif
using namespace osgGA;
diff --git a/src/GUI/WaypointList.hxx b/src/GUI/WaypointList.hxx
index 27d17a217..240649e1a 100644
--- a/src/GUI/WaypointList.hxx
+++ b/src/GUI/WaypointList.hxx
@@ -9,8 +9,7 @@
#include <simgear/timing/timestamp.hxx>
#include <simgear/misc/strutils.hxx>
-#include <plib/pu.h>
-
+#include "pu.h"
#include "FGPUIDialog.hxx" // for GUI_ID
// forward decls
diff --git a/src/GUI/fonts.cxx b/src/GUI/fonts.cxx
index ee9f0f591..33db83801 100644
--- a/src/GUI/fonts.cxx
+++ b/src/GUI/fonts.cxx
@@ -2,8 +2,7 @@
#include <config.h>
#endif
-#include <plib/pu.h>
-
+#include "pu.h"
#include "fnt.h"
diff --git a/src/GUI/gui.cxx b/src/GUI/gui.cxx
index 7efb5edeb..a31debd07 100644
--- a/src/GUI/gui.cxx
+++ b/src/GUI/gui.cxx
@@ -39,8 +39,6 @@
#include <simgear/props/props.hxx>
#include <simgear/props/props_io.hxx>
-#include <plib/pu.h>
-
#include <Main/main.hxx>
#include <Main/globals.hxx>
#include <Main/locale.hxx>
diff --git a/src/GUI/gui.h b/src/GUI/gui.h
index c6a533cfd..1f1048505 100644
--- a/src/GUI/gui.h
+++ b/src/GUI/gui.h
@@ -29,10 +29,10 @@
# include <config.h>
#endif
-#include <plib/pu.h>
-
#include <simgear/structure/exception.hxx>
+#include "pu.h"
+
#define TR_HIRES_SNAP 1
namespace osg
diff --git a/src/GUI/layout-props.cxx b/src/GUI/layout-props.cxx
index 2d691036f..765717a79 100644
--- a/src/GUI/layout-props.cxx
+++ b/src/GUI/layout-props.cxx
@@ -2,9 +2,9 @@
# include <config.h>
#endif
-#include <plib/pu.h>
#include <simgear/props/props.hxx>
+#include "pu.h"
#include "layout.hxx"
// This file contains the code implementing the LayoutWidget class in
diff --git a/src/GUI/new_gui.cxx b/src/GUI/new_gui.cxx
index 3ff7a7bc3..1562edef2 100644
--- a/src/GUI/new_gui.cxx
+++ b/src/GUI/new_gui.cxx
@@ -11,7 +11,7 @@
#include <cstring>
#include <sys/types.h>
-#include <plib/pu.h>
+#include "pu.h"
#include <simgear/compiler.h>
#include <simgear/structure/exception.hxx>
diff --git a/src/GUI/pu.h b/src/GUI/pu.h
new file mode 100644
index 000000000..08a9e9bbd
--- /dev/null
+++ b/src/GUI/pu.h
@@ -0,0 +1,1615 @@
+/*
+ PLIB - A Suite of Portable Game Libraries
+ Copyright (C) 1998,2002 Steve Baker
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library 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
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+ For further information visit http://plib.sourceforge.net
+
+ $Id: pu.h 2160 2010-02-27 03:48:23Z fayjf $
+*/
+
+#ifndef _PU_H_
+#define _PU_H_ 1
+
+#include <stdio.h>
+#include <plib/fnt.h>
+#include <plib/ulRTTI.h>
+
+/*
+ Configuration
+*/
+
+#define PU_NOBUTTON -1
+#define PU_LEFT_BUTTON 0
+#define PU_MIDDLE_BUTTON 1
+#define PU_RIGHT_BUTTON 2
+#define PU_SCROLL_UP_BUTTON 3
+#define PU_SCROLL_DOWN_BUTTON 4
+#define PU_DOWN 0
+#define PU_UP 1
+
+class puFont
+{
+protected:
+ fntFont * fnt_font_handle ;
+ float pointsize ;
+ float slant ;
+
+public:
+
+ puFont () ;
+
+ puFont ( fntFont *tfh, float ps = 13, float sl = 0 )
+ {
+ initialize ( tfh, ps, sl ) ;
+ }
+
+ void initialize ( fntFont *tfh, float ps, float sl = 0 )
+ {
+ fnt_font_handle = tfh ;
+ pointsize = ps ;
+ slant = sl ;
+ }
+
+ float getPointSize ( ) const { return pointsize; }
+
+ int getStringDescender ( void ) const ;
+ int getStringHeight ( const char *str ) const ;
+ int getStringHeight ( void ) const { return getStringHeight ( "" ) ; }
+
+ float getFloatStringWidth ( const char *str ) const ;
+ int getStringWidth ( const char *str ) const /* Deprecated ? */
+ {
+ return (int) getFloatStringWidth ( str ) ;
+ }
+
+ void drawString ( const char *str, int x, int y ) ;
+} ;
+
+
+extern puFont PUFONT_8_BY_13 ;
+extern puFont PUFONT_9_BY_15 ;
+extern puFont PUFONT_TIMES_ROMAN_10 ;
+extern puFont PUFONT_TIMES_ROMAN_24 ;
+extern puFont PUFONT_HELVETICA_10 ;
+extern puFont PUFONT_HELVETICA_12 ;
+extern puFont PUFONT_HELVETICA_18 ;
+
+#define PU_UP_AND_DOWN 254
+#define PU_DRAG 255
+#define PU_CONTINUAL PU_DRAG
+
+/*
+ WARNING: These have to be the same as PW_KEY_whatever and also
+ the same as (GLUT_KEY_whatever+256)
+*/
+
+#define PU_KEY_GLUT_SPECIAL_OFFSET 256
+
+#define PU_KEY_F1 (1 + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F2 (2 + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F3 (3 + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F4 (4 + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F5 (5 + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F6 (6 + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F7 (7 + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F8 (8 + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F9 (9 + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F10 (10 + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F11 (11 + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F12 (12 + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_LEFT (100 + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_UP (101 + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_RIGHT (102 + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_DOWN (103 + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_PAGE_UP (104 + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_PAGE_DOWN (105 + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_HOME (106 + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_END (107 + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_INSERT (108 + PU_KEY_GLUT_SPECIAL_OFFSET)
+
+#define PUARROW_UP 0
+#define PUARROW_DOWN 1
+#define PUARROW_FASTUP 2
+#define PUARROW_FASTDOWN 3
+#define PUARROW_LEFT 4
+#define PUARROW_RIGHT 5
+#define PUARROW_FASTLEFT 6
+#define PUARROW_FASTRIGHT 7
+
+#define PUBUTTON_NORMAL 0
+#define PUBUTTON_RADIO 1
+#define PUBUTTON_CIRCLE 2
+#define PUBUTTON_VCHECK 3 /* v-shaped checkmark */
+#define PUBUTTON_XCHECK 4 /* X checkmark */
+
+/* Rational Definitions of PUI Legend and Label Places */
+#define PUPLACE_TOP_LEFT 0
+#define PUPLACE_TOP_CENTERED 1
+#define PUPLACE_TOP_RIGHT 2
+
+#define PUPLACE_CENTERED_LEFT 3
+#define PUPLACE_CENTERED_RIGHT 4
+
+#define PUPLACE_BOTTOM_LEFT 5
+#define PUPLACE_BOTTOM_CENTERED 6
+#define PUPLACE_BOTTOM_RIGHT 7
+
+/* Additional definitions for PUI Legend places */
+#define PUPLACE_CENTERED_CENTERED 8
+
+/* Additional definitions for PUI Label places */
+#define PUPLACE_ABOVE_LEFT 9
+#define PUPLACE_ABOVE_RIGHT 10
+
+#define PUPLACE_BELOW_LEFT 11
+#define PUPLACE_BELOW_RIGHT 12
+
+#define PUPLACE_UPPER_LEFT 13
+#define PUPLACE_UPPER_RIGHT 14
+
+#define PUPLACE_LOWER_LEFT 15
+#define PUPLACE_LOWER_RIGHT 16
+
+/* Default places */
+#define PUPLACE_LABEL_DEFAULT PUPLACE_LOWER_RIGHT
+#define PUPLACE_LEGEND_DEFAULT PUPLACE_CENTERED_CENTERED
+
+/* Keep these for backwards compatibility but deprecate them */
+#define PUPLACE_ABOVE PUPLACE_TOP_LEFT
+#define PUPLACE_BELOW PUPLACE_BOTTOM_LEFT
+#define PUPLACE_LEFT PUPLACE_LOWER_LEFT
+#define PUPLACE_RIGHT PUPLACE_LOWER_RIGHT
+#define PUPLACE_CENTERED PUPLACE_CENTERED_CENTERED
+#define PUPLACE_TOP_CENTER PUPLACE_TOP_CENTERED
+#define PUPLACE_BOTTOM_CENTER PUPLACE_BOTTOM_CENTERED
+#define PUPLACE_LEFT_CENTER PUPLACE_CENTERED_LEFT
+#define PUPLACE_RIGHT_CENTER PUPLACE_CENTERED_RIGHT
+
+#define PUPLACE_DEFAULT PUPLACE_LABEL_DEFAULT
+
+#define PUCOL_FOREGROUND 0
+#define PUCOL_BACKGROUND 1
+#define PUCOL_HIGHLIGHT 2
+#define PUCOL_LABEL 3
+#define PUCOL_LEGEND 4
+#define PUCOL_MISC 5
+#define PUCOL_EDITFIELD 6
+#define PUCOL_MAX 7
+
+#define PUSLIDER_CLICK 0
+#define PUSLIDER_ALWAYS 1
+#define PUSLIDER_DELTA 2
+
+/* These styles may be negated to get 'highlighted' graphics */
+
+#define PUSTYLE_DEFAULT PUSTYLE_SHADED
+#define PUSTYLE_NONE 0
+#define PUSTYLE_PLAIN 1
+#define PUSTYLE_BEVELLED 2
+#define PUSTYLE_BOXED 3
+#define PUSTYLE_DROPSHADOW 4
+#define PUSTYLE_SPECIAL_UNDERLINED 5
+#define PUSTYLE_SMALL_BEVELLED 6
+#define PUSTYLE_RADIO 7 /* deprecated ! */
+#define PUSTYLE_SHADED 8
+#define PUSTYLE_SMALL_SHADED 9
+#define PUSTYLE_MAX 10
+
+/* These are the gaps that we try to leave around text objects */
+
+#define PUSTR_TGAP 5
+#define PUSTR_BGAP 5
+#define PUSTR_LGAP 5
+#define PUSTR_RGAP 5
+
+#define PU_RADIO_BUTTON_SIZE 16
+
+/* When to deactivate a widget and call its down callback */
+#define PUDEACTIVATE_ON_MOUSE_CLICK 0
+#define PUDEACTIVATE_ON_NEXT_WIDGET_ACTIVATION 1
+
+extern int puRefresh ; /* Should not be used directly by applications any
+ longer. Instead, use puPostRefresh () and
+ puNeedRefresh (). */
+
+#define PUCLASS_VALUE 0x00000001
+#define PUCLASS_OBJECT 0x00000002
+#define PUCLASS_GROUP 0x00000004
+#define PUCLASS_INTERFACE 0x00000008
+#define PUCLASS_FRAME 0x00000010
+#define PUCLASS_TEXT 0x00000020
+#define PUCLASS_BUTTON 0x00000040
+#define PUCLASS_ONESHOT 0x00000080
+#define PUCLASS_POPUP 0x00000100
+#define PUCLASS_POPUPMENU 0x00000200
+#define PUCLASS_MENUBAR 0x00000400
+#define PUCLASS_INPUT 0x00000800
+#define PUCLASS_BUTTONBOX 0x00001000
+#define PUCLASS_SLIDER 0x00002000
+#define PUCLASS_DIALOGBOX 0x00004000
+#define PUCLASS_ARROW 0x00008000
+#define PUCLASS_LISTBOX 0x00010000
+#define PUCLASS_DIAL 0x00020000
+
+class puValue ;
+class puObject ;
+class puGroup ;
+class puInterface ;
+class puButtonBox ;
+class puFrame ;
+class puText ;
+class puButton ;
+class puOneShot ;
+class puPopup ;
+class puPopupMenu ;
+class puMenuBar ;
+class puInput ;
+class puSlider ;
+class puListBox ;
+class puArrowButton ;
+class puDial ;
+
+// Global function to move active object to the end of the "dlist"
+// so it is displayed in front of everything else
+
+void puMoveToLast ( puObject *ob ) ;
+
+typedef float puColour [ 4 ] ; /* RGBA */
+typedef puColour puColor ;
+
+struct puBox
+{
+ int min [ 2 ] ;
+ int max [ 2 ] ;
+
+ void draw ( int dx, int dy, int style, puColour colour[], int am_default, int border ) ;
+ void extend ( puBox *bx ) ;
+
+ void empty ( void ) { min[0]=min[1]=1000000 ; max[0]=max[1]=-1000000 ; }
+ int isEmpty ( void ) const { return min[0]>max[0] || min[1]>max[1] ; }
+} ;
+
+#define PUSTRING_MAX 256
+
+/* With many memory managers, allocating powers of two is more efficient */
+#define PUSTRING_INITIAL 64
+
+
+inline void puSetColour ( puColour dst, const puColour src )
+{
+ dst[0] = src[0] ; dst[1] = src[1] ; dst[2] = src[2] ; dst[3] = src[3] ;
+}
+inline void puSetColor ( puColour dst, const puColour src )
+{
+ dst[0] = src[0] ; dst[1] = src[1] ; dst[2] = src[2] ; dst[3] = src[3] ;
+}
+
+inline void puSetColour ( puColour c, float r, float g, float b, float a = 1.0f )
+{
+ c [ 0 ] = r ; c [ 1 ] = g ; c [ 2 ] = b ; c [ 3 ] = a ;
+}
+inline void puSetColor ( puColour c, float r, float g, float b, float a = 1.0f )
+{
+ c [ 0 ] = r ; c [ 1 ] = g ; c [ 2 ] = b ; c [ 3 ] = a ;
+}
+
+
+// puInit () -- is a macro, see below
+void puRealInit ( void ) ;
+void puExit ( void ) ;
+void puDisplay ( void ) ;
+void puDisplay ( int window_number ) ; /* Deprecated */
+int puMouse ( int button, int updown, int x, int y ) ;
+int puMouse ( int x, int y ) ;
+int puKeyboard ( int key, int updown, int x, int y ) ; /* For PW */
+int puKeyboard ( int key, int updown ) ;
+void puHideCursor ( void ) ;
+void puShowCursor ( void ) ;
+int puCursorIsHidden ( void ) ;
+void puDeleteObject ( puObject *ob ) ;
+
+int puNeedRefresh ( void ) ;
+void puPostRefresh ( void ) ;
+
+int puGetWindow ( void ) ;
+void puGetWindowSize ( int *width, int *height ) ;
+int puGetWindowWidth ( void ) ;
+int puGetWindowHeight ( void ) ;
+
+void puSetWindow ( int w ) ; // don't use it!
+void puSetWindowSize ( int width, int height ) ; // don't use it!
+
+void puSetResizeMode ( int mode ) ; // DEPRECATED
+
+
+// Active widget functions
+
+void puDeactivateWidget ( void ) ;
+void puSetActiveWidget ( puObject *w, int x, int y ) ;
+puObject *puActiveWidget ( void ) ;
+
+// Return the currently active mouse button
+extern int puGetPressedButton () ;
+
+
+
+class puValue
+{
+ UL_TYPE_DATA
+
+protected:
+ int type ;
+
+ int integer ;
+ float floater ;
+ char *string ;
+ bool boolean ;
+
+ int *res_integer ;
+ float *res_floater ;
+ char *res_string ;
+ bool *res_bool ;
+
+ int string_size ;
+ int res_string_sz ;
+
+ int convert ;
+
+ void re_eval ( void ) ;
+ void update_res ( void ) const { } /* Obsolete ! */ ;
+
+ void copy_stringval ( const char *str ) ;
+
+ int * getIntegerp ( void ) { return res_integer != NULL ? res_integer : &integer ; }
+ float * getFloaterp ( void ) { return res_floater != NULL ? res_floater : &floater ; }
+ char * getStringp ( void ) { return res_string != NULL ? res_string : string ; }
+ bool * getBooleanp ( void ) { return res_bool != NULL ? res_bool : &boolean ; }
+
+ void enableConversion ( void ) { convert = TRUE ; }
+ void disableConversion ( void ) { convert = FALSE ; }
+ int conversionEnabled ( void ) const { return convert ; }
+
+public:
+ puValue ()
+ {
+ convert = TRUE ;
+
+ string_size = PUSTRING_INITIAL ;
+ string = new char [ string_size ] ;
+
+ type = PUCLASS_VALUE ;
+ res_integer = NULL ;
+ res_floater = NULL ;
+ res_string = NULL ;
+ res_bool = NULL ;
+ clrValue () ;
+ }
+
+ virtual ~puValue () { delete [] string ; }
+
+ int getType ( void ) const { return type ; }
+ const char *getTypeString ( void ) const ;
+ void clrValue ( void ) { setValue ( "" ) ; }
+
+ virtual void setValue ( puValue *pv )
+ {
+ *getIntegerp () = pv -> getIntegerValue () ;
+ *getFloaterp () = pv -> getFloatValue () ;
+ copy_stringval ( pv -> getStringValue () ) ;
+ *getBooleanp () = pv -> getBooleanValue () ;
+ puPostRefresh () ;
+ }
+
+ void setValuator ( int *i )
+ {
+ res_integer = i ;
+
+ if ( convert == TRUE )
+ {
+ res_floater = NULL ; res_string = NULL ; res_bool = NULL ;
+ re_eval () ;
+ }
+ }
+
+ void setValuator ( float *f )
+ {
+ res_floater = f ;
+
+ if ( convert == TRUE )
+ {
+ res_integer = NULL ; res_string = NULL ; res_bool = NULL ;
+ re_eval () ;
+ }
+ }
+
+ void setValuator ( char *s, int size )
+ {
+ res_string = s ;
+ res_string_sz = size ;
+
+ if ( convert == TRUE )
+ {
+ res_integer = NULL ; res_floater = NULL ; res_bool = NULL ;
+ re_eval () ;
+ }
+ }
+
+ void setValuator ( bool *b )
+ {
+ res_bool = b ;
+
+ if ( convert == TRUE )
+ {
+ res_integer = NULL ; res_floater = NULL ; res_string = NULL ;
+ re_eval () ;
+ }
+ }
+
+ /* Obsolete ! */
+ void setValuator ( char *s ) { setValuator ( s, PUSTRING_MAX ) ; }
+
+ virtual void setValue ( int i )
+ {
+ *getIntegerp () = i ;
+
+ if ( convert == TRUE )
+ {
+ *getFloaterp () = (float) i ; sprintf ( getStringp (), "%d", i ) ; *getBooleanp () = ( i != 0 ) ;
+ }
+
+ puPostRefresh () ;
+ }
+
+ virtual void setValue ( float f )
+ {
+ *getFloaterp () = f ;
+
+ if ( convert == TRUE )
+ {
+ *getIntegerp () = (int) f ; sprintf ( getStringp (), "%g", f ) ; *getBooleanp () = ( f != 0.0 ) ;
+ }
+
+ puPostRefresh () ;
+ }
+
+ virtual void setValue ( const char *s ) ;
+
+ virtual void setValue ( bool b )
+ {
+ *getBooleanp () = b ;
+
+ if ( convert == TRUE )
+ {
+ *getIntegerp () = b ? 1 : 0 ; *getFloaterp () = b ? 1.0f : 0.0f ; sprintf ( getStringp (), "%s", b ? "1" : "0" ) ;
+ }
+
+ puPostRefresh () ;
+ }
+
+ void getValue ( int *i ) { re_eval () ; *i = *getIntegerp () ; }
+ void getValue ( float *f ) { re_eval () ; *f = *getFloaterp () ; }
+ void getValue ( char **s ) { re_eval () ; *s = getStringp () ; }
+ void getValue ( char *s, int size )
+ {
+ re_eval () ;
+
+ /* Work around ANSI strncpy's null-fill behaviour */
+
+ s[0] = '\0' ;
+ strncat ( s, getStringp (), size-1 ) ;
+ }
+
+ void getValue ( char *s ) { getValue ( s, PUSTRING_MAX ) ; } /* Obsolete ! */
+ void getValue ( bool *b ) { re_eval () ; *b = *getBooleanp () ; }
+
+ int getValue ( void ) { return getIntegerValue () ; } /* Obsolete ! */
+
+ virtual int getIntegerValue ( void ) { re_eval () ; return *getIntegerp () ; }
+ virtual float getFloatValue ( void ) { re_eval () ; return *getFloaterp () ; }
+ virtual char getCharValue ( void ) { re_eval () ; return getStringp ()[0]; }
+ virtual char *getStringValue ( void ) { re_eval () ; return getStringp () ; }
+ virtual bool getBooleanValue ( void ) { re_eval () ; return *getBooleanp () ; }
+
+ /* RTTI */
+ ulRTTItypeid getTypeInfo ( void ) const { return RTTI_vinfo () ; }
+} ;
+
+typedef void (*puCallback)(class puObject *) ;
+typedef void (*puRenderCallback)(class puObject *, int dx, int dy, void *) ;
+
+void puSetDefaultStyle ( int style ) ;
+int puGetDefaultStyle ( void ) ;
+void puSetDefaultBorderThickness ( int t ) ;
+int puGetDefaultBorderThickness ( void ) ;
+void puSetDefaultFonts ( puFont legendFont, puFont labelFont ) ;
+void puGetDefaultFonts ( puFont *legendFont, puFont *labelFont ) ;
+
+puFont puGetDefaultLabelFont ( void ) ;
+puFont puGetDefaultLegendFont ( void ) ;
+
+void puSetDefaultColourScheme ( float r, float g, float b, float a = 1.0f ) ;
+inline void puSetDefaultColorScheme ( float r, float g, float b, float a = 1.0f )
+{
+ puSetDefaultColourScheme ( r, g, b, a ) ;
+}
+
+void puGetDefaultColourScheme ( float *r, float *g, float *b, float *a = NULL );
+inline void puGetDefaultColorScheme ( float *r, float *g, float *b, float *a = NULL )
+{
+ puGetDefaultColourScheme ( r, g, b, a ) ;
+}
+
+class puObject : public puValue
+{
+ UL_TYPE_DATA
+
+protected:
+ puValue default_value ;
+
+ puBox bbox ; /* Bounding box of entire Object */
+ puBox abox ; /* Active (clickable) area */
+ puColour colour [ PUCOL_MAX ] ;
+ puGroup *parent ;
+
+ int active_mouse_edge ; /* is it PU_UP or PU_DOWN (or both) that activates this? */
+ int active_mouse_button ; /* which mouse button or buttons activate this */
+ int style ;
+ int visible ;
+ int active ;
+ int highlighted ;
+ int am_default ;
+ int window ; /* Which window does the object appear in? */
+ int v_status ; /* 1 if the Object should lock in the top left corner, 0 if not */
+
+ const char *label ; puFont labelFont ; int labelPlace ;
+ const char *legend ; puFont legendFont ; int legendPlace ;
+
+ void *user_data ;
+ puCallback cb ;
+ puCallback active_cb ;
+ puCallback down_cb ;
+ puRenderCallback r_cb ;
+ void *render_data ;
+ int border_thickness ;
+
+ short when_to_deactivate ; /* On next mouseclick or on next widget activation */
+
+ virtual void draw_legend ( int dx, int dy ) ;
+ virtual void draw_label ( int dx, int dy ) ;
+
+public:
+ virtual int isHit ( int x, int y ) const { return isVisible() && isActive() &&
+ x > abox.min[0] &&
+ x < abox.max[0] &&
+ y > abox.min[1] &&
+ y < abox.max[1] &&
+ window == puGetWindow () ; }
+
+ virtual void doHit ( int button, int updown, int x, int y ) ;
+
+ puObject ( int minx, int miny, int maxx, int maxy ) ;
+ ~puObject () ;
+
+ puObject *next ; /* Should not be used directly by applications any longer. */
+ puObject *prev ; /* Instead, use the setNextObject and setPrevObject
+ methods. */
+
+ puBox *getBBox ( void ) const { return (puBox *) &bbox ; }
+ puBox *getABox ( void ) const { return (puBox *) &abox ; }
+
+ void getAbsolutePosition ( int *x, int *y ) const ;
+
+ virtual void setPosition ( int x, int y )
+ {
+ if ( abox.isEmpty() )
+ {
+ abox.max[0] = abox.min[0] = x ;
+ abox.max[1] = abox.min[1] = y ;
+ }
+ else
+ {
+ abox.max[0] += x - abox.min[0] ;
+ abox.max[1] += y - abox.min[1] ;
+ abox.min[0] = x ;
+ abox.min[1] = y ;
+ }
+ recalc_bbox() ; puPostRefresh () ;
+ }
+
+ virtual void setSize ( int w, int h )
+ {
+ abox.max[0] = abox.min[0] + w ;
+ abox.max[1] = abox.min[1] + h ;
+ recalc_bbox() ; puPostRefresh () ;
+ }
+
+ void getPosition ( int *x, int *y ) const
+ {
+ if ( abox.isEmpty () )
+ {
+ if ( x ) *x = 0 ;
+ if ( y ) *y = 0 ;
+ }
+ else
+ {
+ if ( x ) *x = abox.min[0] ;
+ if ( y ) *y = abox.min[1] ;
+ }
+ }
+
+ void getSize ( int *w, int *h ) const
+ {
+ if ( abox.isEmpty () )
+ {
+ if ( w ) *w = 0 ;
+ if ( h ) *h = 0 ;
+ }
+ else
+ {
+ if ( w ) *w = abox.max[0] - abox.min[0] ;
+ if ( h ) *h = abox.max[1] - abox.min[1] ;
+ }
+ }
+
+ virtual void recalc_bbox ( void ) ;
+ virtual int checkHit ( int button, int updown, int x, int y ) ;
+ virtual int checkKey ( int key , int updown ) ;
+ virtual void draw ( int dx, int dy ) = 0 ;
+
+ puGroup *getParent ( void ) const { return parent ; }
+ void setParent ( puGroup* p ) { parent = p ; }
+
+ void setNextObject ( puObject *obj ) { next = obj ; }
+ puObject *getNextObject ( void ) const { return next ; }
+ void setPrevObject ( puObject *obj ) { prev = obj ; }
+ puObject *getPrevObject ( void ) const { return prev ; }
+
+ void setCallback ( puCallback c ) { cb = c ; }
+ puCallback getCallback ( void ) const { return cb ; }
+ void invokeCallback ( void ) { if ( cb != NULL ) (*cb)(this) ; }
+
+ void setActiveCallback ( puCallback c ) { active_cb = c ; }
+ puCallback getActiveCallback ( void ) const { return active_cb ; }
+ void invokeActiveCallback ( void ) { if ( active_cb != NULL ) (*active_cb)(this) ; }
+
+ void setDownCallback ( puCallback c ) { down_cb = c ; }
+ puCallback getDownCallback ( void ) const { return down_cb ; }
+ virtual void invokeDownCallback ( void ) { if ( down_cb != NULL ) (*down_cb)(this) ; }
+
+ void setRenderCallback ( puRenderCallback c, void *d = NULL ) { r_cb = c ; render_data = d ; }
+ puRenderCallback getRenderCallback ( void ) const { return r_cb ; }
+ void *getRenderCallbackData ( void ) const { return render_data ; }
+ void invokeRenderCallback ( int dx, int dy ) { if ( r_cb != NULL ) (*r_cb)(this, dx, dy, render_data) ; }
+
+ void setBorderThickness ( int t ) { border_thickness = t ; puPostRefresh () ; }
+ int getBorderThickness ( void ) const { return border_thickness ; }
+
+ void makeReturnDefault ( int def ) { am_default = def ; puPostRefresh () ; }
+ int isReturnDefault ( void ) const { return am_default ; }
+
+ int getWindow ( void ) const { return window ; }
+ void setWindow ( int w ) { window = w ; puPostRefresh () ; }
+
+ void setActiveDirn ( int e ) { active_mouse_edge = e ; }
+ int getActiveDirn ( void ) const { return active_mouse_edge ; }
+
+ void setActiveButton ( int b ) { active_mouse_button = b ; }
+ int getActiveButton ( void ) const { return active_mouse_button ; }
+
+ void setWhenToDeactivate ( short d ) { when_to_deactivate = d ; }
+ short getWhenToDeactivate ( void ) const { return when_to_deactivate ; }
+
+ void setLegend ( const char *l ) { legend = l ; recalc_bbox() ; puPostRefresh () ; }
+ const char *getLegend ( void ) const { return legend ; }
+
+ void setLegendFont ( puFont f ) { legendFont = f ; recalc_bbox() ; puPostRefresh () ; }
+ puFont getLegendFont ( void ) const { return legendFont ; }
+
+ void setLegendPlace ( int lp ) { legendPlace = lp ; recalc_bbox() ; puPostRefresh () ; }
+ int getLegendPlace ( void ) const { return legendPlace ; }
+
+ void setLabel ( const char *l ) { label = l ; recalc_bbox() ; puPostRefresh () ; }
+ const char *getLabel ( void ) const { return label ; }
+
+ void setLabelFont ( puFont f ) { labelFont = f ; recalc_bbox() ; puPostRefresh () ; }
+ puFont getLabelFont ( void ) const { return labelFont ; }
+
+ void setLabelPlace ( int lp ) { labelPlace = lp ; recalc_bbox() ; puPostRefresh () ; }
+ int getLabelPlace ( void ) const { return labelPlace ; }
+
+ void activate ( void ) { if ( ! active ) { active = TRUE ; puPostRefresh () ; } }
+ void greyOut ( void ) { if ( active ) { active = FALSE ; puPostRefresh () ; } }
+ int isActive ( void ) const { return active ; }
+
+ void highlight ( void ) { if ( ! highlighted ) { highlighted = TRUE ; puPostRefresh () ; } }
+ void lowlight ( void ) { if ( highlighted ) { highlighted = FALSE ; puPostRefresh () ; } }
+ int isHighlighted( void ) const { return highlighted ; }
+
+ void reveal ( void ) { if ( ! visible ) { visible = TRUE ; puPostRefresh () ; } }
+ void hide ( void ) { if ( visible ) { visible = FALSE ; puPostRefresh () ; } }
+ int isVisible ( void ) const { return visible ; }
+
+ void setStyle ( int which )
+ {
+ style = which ;
+
+ switch ( abs(style) )
+ {
+ case PUSTYLE_SPECIAL_UNDERLINED :
+ border_thickness = 1 ;
+ break ;
+
+ case PUSTYLE_SMALL_BEVELLED :
+ case PUSTYLE_SMALL_SHADED :
+ case PUSTYLE_BOXED :
+ border_thickness = 2 ;
+ break ;
+
+ case PUSTYLE_BEVELLED :
+ case PUSTYLE_SHADED :
+ case PUSTYLE_DROPSHADOW :
+ border_thickness = 5 ;
+ break ;
+ }
+
+ recalc_bbox () ;
+ puPostRefresh () ;
+ }
+
+ int getStyle ( void ) const { return style ; }
+
+ virtual void setColourScheme ( float r, float g, float b, float a = 1.0f ) ;
+ void setColorScheme ( float r, float g, float b, float a = 1.0f )
+ {
+ setColourScheme ( r, g, b, a ) ;
+ }
+
+ virtual void setColour ( int which, float r, float g, float b, float a = 1.0f )
+ {
+ puSetColour ( colour [ which ], r, g, b, a ) ;
+ puPostRefresh () ;
+ }
+ void setColor ( int which, float r, float g, float b, float a = 1.0f )
+ {
+ setColour ( which, r, g, b, a ) ;
+ }
+
+ void getColour ( int which, float *r, float *g, float *b, float *a = NULL ) const
+ {
+ if ( r ) *r = colour[which][0] ;
+ if ( g ) *g = colour[which][1] ;
+ if ( b ) *b = colour[which][2] ;
+ if ( a ) *a = colour[which][3] ;
+ }
+ void getColor ( int which, float *r, float *g, float *b, float *a = NULL ) const
+ {
+ getColour ( which, r, g, b, a );
+ }
+
+ void setUserData ( void *data ) { user_data = data ; }
+ void *getUserData ( void ) const { return user_data ; }
+
+ void defaultValue ( void ) { setValue ( & default_value ) ; }
+
+ void setDefaultValue ( int i ) { default_value.setValue ( i ) ; }
+ void setDefaultValue ( float f ) { default_value.setValue ( f ) ; }
+ void setDefaultValue ( const char *s ) { default_value.setValue ( s ) ; }
+
+ void getDefaultValue ( int *i ) { default_value.getValue ( i ) ; }
+ void getDefaultValue ( float *f ) { default_value.getValue ( f ) ; }
+ void getDefaultValue ( char **s ) { default_value.getValue ( s ) ; }
+ void getDefaultValue ( char *s ) { default_value.getValue ( s ) ; }
+
+ int getDefaultValue ( void ) { return default_value.getValue () ; } /* Obsolete ! */
+
+ int getDefaultIntegerValue ( void ) { return default_value.getIntegerValue () ; }
+ float getDefaultFloatValue ( void ) { return default_value.getFloatValue () ; }
+ char *getDefaultStringValue ( void ) { return default_value.getStringValue () ; }
+
+ int getVStatus ( void ) const { return v_status ; } /* JCJ 6 Jun 2002 */
+ void setVStatus ( int vstat ) { v_status = vstat ; }
+} ;
+
+/*
+ The 'live' interface stack is used for clicking and rendering.
+*/
+
+void puPushLiveInterface ( puInterface *in ) ;
+void puPopLiveInterface ( puInterface *in = 0 ) ;
+int puNoLiveInterface ( void ) ;
+puInterface *puGetBaseLiveInterface ( void ) ;
+puInterface *puGetUltimateLiveInterface ( void ) ;
+
+/*
+ The regular group stack is used for adding widgets
+*/
+
+void puPushGroup ( puGroup *in ) ;
+void puPopGroup ( void ) ;
+int puNoGroup ( void ) ;
+puGroup *puGetCurrGroup ( void ) ;
+
+class puGroup : public puObject
+{
+ UL_TYPE_DATA
+
+protected:
+ int num_children ;
+ puObject *dlist ;
+
+ int mouse_x ; // Coordinates of mouse when right button pressed for
+ int mouse_y ; // drag and drop
+
+ int mouse_active; // Flag telling whether interface is presently being dragged
+
+ void doHit ( int button, int updown, int x, int y ) ;
+
+ int floating; // DEPRECATED! -- Flag telling whether the interface floats in the window or stays put
+
+public:
+
+ puGroup ( int x, int y ) : puObject ( x, y, x, y )
+ {
+ type |= PUCLASS_GROUP ;
+ dlist = NULL ;
+ num_children = 0 ;
+ mouse_x = 0 ;
+ mouse_y = 0 ;
+ mouse_active = FALSE ;
+ floating = FALSE ; // DEPRECATED!
+ puPushGroup ( this ) ;
+ }
+
+ ~puGroup () ;
+
+ void recalc_bbox ( void ) ;
+ virtual void add ( puObject *new_object ) ;
+ virtual void remove ( puObject *old_object ) ;
+ virtual void empty ( void ) ;
+
+ void draw ( int dx, int dy ) ;
+ int checkHit ( int button, int updown, int x, int y ) ;
+ int checkKey ( int key , int updown ) ;
+
+ puObject *getFirstChild ( void ) const { return dlist ; }
+ puObject *getLastChild ( void ) const
+ {
+ puObject *bo = dlist ;
+
+ if ( bo != NULL )
+ {
+ while ( bo -> getNextObject() != NULL )
+ bo = bo -> getNextObject() ;
+ }
+
+ return bo ;
+ }
+ int getNumChildren ( void ) const { return num_children ; }
+
+ virtual void close ( void )
+ {
+ if ( puGetCurrGroup () != this )
+ ulSetError ( UL_WARNING, "PUI: puGroup::close() is mismatched!" ) ;
+ else
+ puPopGroup () ;
+ }
+
+ void setFloating ( int value ) { floating = value ; } // DEPRECATED!
+ int getFloating ( void ) const { return floating ; } // DEPRECATED!
+
+ void setChildStyle ( int childs, int which, int recursive = FALSE ) ;
+ void setChildBorderThickness ( int childs, int t, int recursive = FALSE ) ;
+
+ void setChildColour ( int childs, int which,
+ float r, float g, float b, float a = 1.0f,
+ int recursive = FALSE ) ;
+ void setChildColor ( int childs, int which,
+ float r, float g, float b, float a = 1.0f,
+ int recursive = FALSE )
+ {
+ setChildColour ( childs, which, r, g, b, a, recursive ) ;
+ }
+
+ void setChildColourScheme ( int childs,
+ float r, float g, float b, float a = 1.0f,
+ int recursive = FALSE ) ;
+ void setChildColorScheme ( int childs,
+ float r, float g, float b, float a = 1.0f,
+ int recursive = FALSE )
+ {
+ setChildColourScheme ( childs, r, g, b, a, recursive ) ;
+ }
+
+ void setChildLegendFont ( int childs, puFont f, int recursive = FALSE ) ;
+ void setChildLabelFont ( int childs, puFont f, int recursive = FALSE ) ;
+} ;
+
+
+class puInterface : public puGroup
+{
+ UL_TYPE_DATA
+
+public:
+
+ puInterface ( int x, int y ) : puGroup ( x, y )
+ {
+ type |= PUCLASS_INTERFACE ;
+ puPushLiveInterface ( this ) ;
+ }
+
+ ~puInterface () ;
+} ;
+
+
+class puFrame : public puObject
+{
+ UL_TYPE_DATA
+
+public:
+ void draw ( int dx, int dy ) ;
+ puFrame ( int minx, int miny, int maxx, int maxy ) :
+ puObject ( minx, miny, maxx, maxy )
+ {
+ type |= PUCLASS_FRAME ;
+ }
+
+ void doHit ( int button, int updown, int x, int y )
+ {
+ if ( puActiveWidget() && ( this != puActiveWidget() ) )
+ {
+ // Active widget exists and is not this one; call its down callback if it exists
+
+ puActiveWidget() -> invokeDownCallback () ;
+ puDeactivateWidget () ;
+ }
+
+ if ( isHit ( x, y ) && ( updown != PU_DRAG ) )
+ puMoveToLast ( this -> parent );
+ }
+} ;
+
+
+
+class puText : public puObject
+{
+ UL_TYPE_DATA
+
+public:
+ virtual int isHit ( int /* x */, int /* y */ ) const { return FALSE ; }
+ void draw ( int dx, int dy ) ;
+ puText ( int x, int y ) : puObject ( x, y, x, y )
+ {
+ type |= PUCLASS_TEXT ;
+ }
+} ;
+
+
+class puButton : public puObject
+{
+ UL_TYPE_DATA
+
+protected:
+ int button_type ;
+
+public:
+ void doHit ( int button, int updown, int x, int y ) ;
+ void draw ( int dx, int dy ) ;
+
+ int getButtonType ( void ) const { return button_type ; }
+ void setButtonType ( int btype ) { button_type = btype ; puPostRefresh () ; }
+
+ puButton ( int minx, int miny, const char *l ) :
+ puObject ( minx, miny,
+ minx + puGetDefaultLegendFont().getStringWidth ( l ) + PUSTR_LGAP + PUSTR_RGAP,
+ miny + puGetDefaultLegendFont().getStringHeight ( l ) + puGetDefaultLegendFont().getStringDescender () + PUSTR_TGAP + PUSTR_BGAP )
+ {
+ type |= PUCLASS_BUTTON ;
+ button_type = PUBUTTON_NORMAL ;
+ setLegend ( l ) ;
+ }
+
+ puButton ( int minx, int miny, int maxx, int maxy, int btype = PUBUTTON_NORMAL ) :
+ puObject ( minx, miny, maxx, maxy )
+ {
+ type |= PUCLASS_BUTTON ;
+ button_type = btype ;
+ }
+} ;
+
+
+class puOneShot : public puButton
+{
+ UL_TYPE_DATA
+
+protected:
+public:
+ void doHit ( int button, int updown, int x, int y ) ;
+
+ puOneShot ( int minx, int miny, const char *l ) : puButton ( minx, miny, l )
+ {
+ type |= PUCLASS_ONESHOT ;
+ }
+
+ puOneShot ( int minx, int miny, int maxx, int maxy ) :
+ puButton ( minx, miny, maxx, maxy )
+ {
+ type |= PUCLASS_ONESHOT ;
+ }
+} ;
+
+
+
+class puArrowButton : public puOneShot
+{
+ UL_TYPE_DATA
+
+protected:
+ int arrow_type ;
+
+public:
+ void draw ( int dx, int dy ) ;
+
+ int getArrowType ( void ) const { return arrow_type ; }
+ void setArrowType ( int i ) { arrow_type = i ; puPostRefresh () ; }
+
+ puArrowButton ( int minx, int miny, int maxx, int maxy, int ptype ) :
+ puOneShot ( minx, miny, maxx, maxy )
+ {
+ type |= PUCLASS_ARROW ;
+ arrow_type = ptype ;
+ }
+} ;
+
+class puRange
+{
+ UL_TYPE_DATA
+
+protected:
+ float minimum_value ;
+ float maximum_value ;
+ float step_size ;
+ float last_cb_value ;
+ float cb_delta ;
+ int cb_mode ;
+
+ void puRange_init ( float minval, float maxval, float step )
+ {
+ if ( maxval == minval )
+ {
+ maxval = 1.0f ;
+ minval = 0.0f ;
+ }
+
+ minimum_value = minval ;
+ maximum_value = maxval ;
+ step_size = step ;
+ last_cb_value = -1.0f ;
+ cb_delta = 0.1f ;
+ cb_mode = PUSLIDER_ALWAYS ;
+ }
+
+ float clamp ( float f )
+ {
+ if ( f < minimum_value ) return minimum_value ;
+ else if ( f > maximum_value ) return maximum_value ;
+ return f ;
+ }
+
+public:
+ puRange ()
+ {
+ puRange_init ( 0.0f, 1.0f, 0.0f ) ;
+ }
+
+ puRange ( float minval, float maxval, float step = 0.0f )
+ {
+ puRange_init ( minval, maxval, step ) ;
+ }
+
+ virtual ~puRange()
+ {
+ }
+
+ float getMaxValue ( void ) const { return maximum_value ; }
+ virtual void setMaxValue ( float f ) { maximum_value = f ; }
+
+ float getMinValue ( void ) const { return minimum_value ; }
+ virtual void setMinValue ( float f ) { minimum_value = f ; }
+
+ float getStepSize ( void ) const { return step_size ; }
+ void setStepSize ( float f ) { step_size = f ; }
+
+ float checkStep ( float val_to_check ) const
+ {
+ float step = val_to_check ;
+
+ if ( getStepSize () > 0.0f )
+ {
+ step = val_to_check - (float) fmod ( val_to_check, getStepSize () ) ;
+
+ if ( ( val_to_check - step ) > ( step + getStepSize() - val_to_check ) )
+ step += getStepSize () ;
+ }
+
+ return step ;
+ }
+
+ void setCBMode ( int m ) { cb_mode = m ; }
+ int getCBMode ( void ) const { return cb_mode ; }
+
+ void setDelta ( float f ) { cb_delta = (f<=0.0f) ? 0.1f : (f>=1.0f) ? 0.9f : f ; }
+ float getDelta ( void ) const { return cb_delta ; }
+} ;
+
+class puSlider : public puRange, public puObject
+{
+ UL_TYPE_DATA
+
+protected:
+ int vert ;
+ int start_offset ;
+ float slider_fraction ;
+ float page_step_size ;
+ void draw_slider_box ( int dx, int dy, const puBox &box, float val, const char *box_label = NULL ) ;
+
+ void puSlider_init ( int vertical )
+ {
+ type |= PUCLASS_SLIDER ;
+ vert = vertical ;
+ slider_fraction = 0.1f ;
+ page_step_size = 0.0f ;
+ }
+
+public:
+ void doHit ( int button, int updown, int x, int y ) ;
+ void draw ( int dx, int dy ) ;
+ puSlider ( int minx, int miny, int sz, int vertical = FALSE ) :
+ puRange (),
+ puObject ( minx, miny, vertical ?
+ ( minx + puGetDefaultLegendFont().getStringWidth ( "W" ) +
+ PUSTR_LGAP + PUSTR_RGAP ) :
+ ( minx + sz ),
+ vertical ?
+ ( miny + sz ) :
+ ( miny + puGetDefaultLegendFont().getStringHeight () +
+ puGetDefaultLegendFont().getStringDescender () +
+ PUSTR_TGAP + PUSTR_BGAP )
+ )
+ {
+ puSlider_init ( vertical ) ;
+ }
+
+ /* Blake Friesen - alternate constructor which lets you explicitly set width */
+ puSlider ( int minx, int miny, int sz, int vertical, int width ) :
+ puRange (),
+ puObject ( minx, miny, vertical ?
+ ( minx + width ) :
+ ( minx + sz ),
+ vertical ?
+ ( miny + sz ) :
+ ( miny + width )
+ )
+ {
+ puSlider_init ( vertical ) ;
+ }
+
+ int isVertical ( void ) const { return vert ; }
+
+ void setSliderFraction ( float f ) ;
+ float getSliderFraction ( void ) const { return slider_fraction ; }
+ void setPageStepSize ( float s ) { page_step_size = s ; }
+ float getPageStepSize ( void ) const { return page_step_size ; }
+} ;
+
+
+class puListBox : public puButton
+{
+ UL_TYPE_DATA
+
+protected:
+ char ** list ;
+ int num ;
+ int top ;
+
+public:
+ void doHit ( int button, int updown, int x, int y ) ;
+ void draw ( int dx, int dy ) ;
+ puListBox ( int minx, int miny, int maxx, int maxy, char** list = NULL ) ;
+
+ void newList ( char ** _list ) ;
+ int getNumItems ( void ) const { return num ; }
+ int getNumVisible ( void ) const
+ {
+ int ysize = abox.max[1] - abox.min[1] + 1 ;
+ int yinc = legendFont.getStringHeight () + PUSTR_BGAP ;
+ return (ysize - PUSTR_BGAP) / yinc ;
+ }
+
+ int getTopItem ( void ) const { return top ; }
+ void setTopItem ( int item_index ) ;
+} ;
+
+
+class puDial : public puRange, public puObject
+{
+ UL_TYPE_DATA
+
+protected:
+ int wrap ; // Flag telling whether you can wrap around the bottom of the dial
+public:
+ void doHit ( int button, int updown, int x, int y ) ;
+ void draw ( int dx, int dy ) ;
+
+ puDial ( int minx, int miny, int sz ) :
+ puRange (), puObject ( minx, miny, minx+sz, miny+sz )
+ {
+ type |= PUCLASS_DIAL ;
+ setValue ( 0.0f ) ;
+ wrap = TRUE ;
+ }
+
+ puDial ( int minx, int miny, int sz, float minval, float maxval, float step = 0.0f ) :
+ puRange ( minval, maxval, step ),
+ puObject ( minx, miny, minx+sz, miny+sz )
+ {
+ type |= PUCLASS_DIAL ;
+ setValue ( 0.0f ) ;
+ wrap = TRUE ;
+ }
+
+ void setWrap ( int in ) { wrap = in ; }
+ int getWrap ( void ) const { return wrap ; }
+} ;
+
+
+
+class puPopup : public puInterface
+{
+ UL_TYPE_DATA
+
+protected:
+public:
+ puPopup ( int x, int y ) : puInterface ( x, y )
+ {
+ type |= PUCLASS_POPUP ;
+ hide () ;
+ }
+} ;
+
+
+class puPopupMenu : public puPopup
+{
+ UL_TYPE_DATA
+
+protected:
+public:
+ puPopupMenu ( int x, int y ) : puPopup ( x, y )
+ {
+ type |= PUCLASS_POPUPMENU ;
+ }
+
+ puObject *add_item ( const char *str, puCallback _cb,
+ void *_user_data = NULL ) ;
+ int checkHit ( int button, int updown, int x, int y ) ;
+ int checkKey ( int key , int updown ) ;
+ void close ( void ) ;
+} ;
+
+
+class puMenuBar : public puInterface
+{
+ UL_TYPE_DATA
+
+protected:
+ int bar_height ;
+
+public:
+ puMenuBar ( int h = -1 ) : puInterface ( 0, 0 )
+ {
+ type |= PUCLASS_MENUBAR ;
+
+ bar_height = h ;
+ }
+
+ void add_submenu ( const char *str, char *items[], puCallback _cb[],
+ void *_user_data[] = NULL ) ;
+ void close ( void ) ;
+} ;
+
+
+class puInputBase
+{
+ UL_TYPE_DATA
+
+protected:
+ int accepting ;
+ int cursor_position ;
+ int select_start_position ;
+ int select_end_position ;
+ char *valid_data ;
+ int input_disabled ;
+
+ char *displayed_text ; // Pointer to text as it is displayed in the box (chopped or word-wrapped)
+
+ puObject *widget ; /* Pointer to associated input box widget */
+
+ virtual void normalizeCursors ( void ) ;
+ virtual void removeSelectRegion ( void ) ;
+
+public:
+ int isAcceptingInput ( void ) const { return accepting ; }
+ void rejectInput ( void ) { accepting = FALSE ; puPostRefresh () ; }
+
+ void acceptInput ( void )
+ {
+ accepting = TRUE ;
+ cursor_position = strlen ( widget -> getStringValue () ) ;
+ select_start_position = select_end_position = -1 ;
+ puPostRefresh () ;
+ }
+
+ int getCursor ( void ) const { return cursor_position ; }
+ void setCursor ( int c ) { cursor_position = c ; puPostRefresh () ; }
+
+ virtual void setSelectRegion ( int s, int e )
+ {
+ select_start_position = s ;
+ select_end_position = e ;
+ puPostRefresh () ;
+ }
+
+ void getSelectRegion ( int *s, int *e ) const
+ {
+ if ( s ) *s = select_start_position ;
+ if ( e ) *e = select_end_position ;
+ }
+
+ char *getValidData ( void ) const { return valid_data ; }
+ void setValidData ( const char *data )
+ {
+ delete [] valid_data ;
+ valid_data = ( data != NULL ) ? ulStrDup ( data ) : NULL ;
+ }
+
+ void addValidData ( const char *data ) ;
+
+ int isValidCharacter ( char c ) const
+ {
+ if ( valid_data != NULL )
+ return ( strchr ( valid_data, c ) != NULL ) ? 1 : 0 ;
+ else
+ return 1 ;
+ }
+
+ void enableInput ( void ) { input_disabled = FALSE ; }
+ void disableInput ( void ) { input_disabled = TRUE ; }
+ int inputDisabled ( void ) const { return input_disabled ; }
+
+ puInputBase ( void )
+ {
+ accepting = FALSE ;
+ cursor_position = 0 ;
+ select_start_position = -1 ;
+ select_end_position = -1 ;
+ valid_data = NULL;
+ displayed_text = NULL ;
+
+ widget = (puObject *)NULL ;
+
+ input_disabled = FALSE ;
+ }
+
+ virtual ~puInputBase () { delete [] valid_data ; delete [] displayed_text ; }
+} ;
+
+
+class puInput : public puInputBase, public puObject
+{
+ UL_TYPE_DATA
+
+ int display_starting_point ;
+
+ char *getDisplayedText ( void )
+ {
+ return ( displayed_text == NULL ? getStringValue () : displayed_text ) ;
+ }
+
+public:
+ void draw ( int dx, int dy ) ;
+ void doHit ( int button, int updown, int x, int y ) ;
+ int checkKey ( int key, int updown ) ;
+
+ void invokeDownCallback ( void )
+ {
+ rejectInput () ;
+ normalizeCursors () ;
+ if ( down_cb != NULL ) (*down_cb)(this) ;
+ }
+
+ puInput ( int minx, int miny, int maxx, int maxy ) :
+ puInputBase (), puObject ( minx, miny, maxx, maxy )
+ {
+ type |= PUCLASS_INPUT ;
+
+ display_starting_point = 0 ;
+
+ setColourScheme ( colour [ PUCOL_EDITFIELD ][0],
+ colour [ PUCOL_EDITFIELD ][1],
+ colour [ PUCOL_EDITFIELD ][2],
+ colour [ PUCOL_EDITFIELD ][3] ) ;
+ setColour ( PUCOL_MISC, 0.1f, 0.1f, 1.0f ) ; /* Colour of 'I' bar cursor */
+
+ widget = this ;
+ }
+
+ virtual void setValue ( puValue *pv )
+ {
+ puValue::setValue ( pv ) ;
+ delete [] displayed_text ; displayed_text = NULL ;
+ }
+
+ virtual void setValue ( int i )
+ {
+ puValue::setValue ( i ) ;
+ delete [] displayed_text ; displayed_text = NULL ;
+ }
+
+ virtual void setValue ( float f )
+ {
+ puValue::setValue ( f ) ;
+ delete [] displayed_text ; displayed_text = NULL ;
+ }
+
+ virtual void setValue ( const char *s )
+ {
+ puValue::setValue ( s ) ;
+ delete [] displayed_text ; displayed_text = NULL ;
+ }
+
+ virtual void setValue ( bool b )
+ {
+ puValue::setValue ( b ) ;
+ delete [] displayed_text ; displayed_text = NULL ;
+ }
+} ;
+
+
+class puButtonBox : public puObject
+{
+ UL_TYPE_DATA
+
+protected:
+ int one_only ;
+ int num_kids ;
+ char **button_labels ;
+
+public:
+
+ puButtonBox ( int minx, int miny, int maxx, int maxy,
+ char **labels, int one_button ) ;
+
+ int isOneButton ( void ) const { return one_only ; }
+
+ void newList ( char ** _list ) ;
+ int getNumItems ( void ) const { return num_kids ; }
+
+ int checkKey ( int key , int updown ) ;
+ int checkHit ( int button, int updown, int x, int y ) ;
+ void draw ( int dx, int dy ) ;
+} ;
+
+
+class puDialogBox : public puPopup
+{
+ UL_TYPE_DATA
+
+protected:
+public:
+
+ puDialogBox ( int x, int y ) : puPopup ( x, y )
+ {
+ type |= PUCLASS_DIALOGBOX ;
+ }
+} ;
+
+
+
+/*
+ * Window System Integration
+ * -------------------------
+ *
+ * PUI has direct support for GLUT, PW, FLTK, SDL and GTK. All code is provided
+ * inline, making PUI itself independent. There are several ways to choose
+ * implementation, for instance:
+ *
+ * #include <FL/Fl.H>
+ * #include <plib/pu.h>
+ *
+ * or simply:
+ *
+ * #include <plib/puFLTK.h>
+ *
+ * Note that both cases may fail if pu.h has been included earlier.
+ * A safer option is therefore to compile with -DPU_USE_FLTK.
+ *
+ * The default system is GLUT for backwards compability.
+ *
+ * To use PUI with an unsupported system, define PU_USE_NONE and
+ * provide your own callbacks (if needed, the defaults will work
+ * in many cases).
+ *
+ * When compiling the PUI library itself, PU_USE_NONE must be defined.
+ *
+ */
+
+typedef int (*puGetWindowCallback) ( ) ;
+typedef void (*puSetWindowCallback) ( int window ) ;
+typedef void (*puGetWindowSizeCallback) ( int *width, int *height ) ;
+typedef void (*puSetWindowSizeCallback) ( int width, int height ) ;
+
+void puSetWindowFuncs ( puGetWindowCallback,
+ puSetWindowCallback,
+ puGetWindowSizeCallback,
+ puSetWindowSizeCallback ) ;
+
+
+// Choose implementation
+
+#if !defined(PU_USE_GLUT) && \
+ !defined(PU_USE_PW) && \
+ !defined(PU_USE_FLTK) && \
+ !defined(PU_USE_SDL) && \
+ !defined(PU_USE_NATIVE) && \
+ !defined(PU_USE_NONE)
+
+// Nothing selected. Try to figure out which one to use.
+#if defined(PW_IS_PRESENT)
+# define PU_USE_PW
+#elif defined(FL_MAJOR_VERSION)
+# define PU_USE_FLTK
+#elif defined(SDL_MAJOR_VERSION)
+# define PU_USE_SDL
+#else
+# define PU_USE_GLUT
+#endif
+
+#endif
+
+
+// Roll out the code and define puInit
+
+#if defined(PU_USE_GLUT)
+# include "puGLUT.h"
+# define puInit puInitGLUT
+#elif defined(PU_USE_PW)
+# include "puPW.h"
+# define puInit puInitPW
+#elif defined(PU_USE_FLTK)
+# include "puFLTK.h"
+# define puInit puInitFLTK
+#elif defined(PU_USE_SDL)
+# include "puSDL.h"
+# define puInit puInitSDL
+#elif defined(PU_USE_NATIVE)
+# include "puNative.h"
+# define puInit puInitNative
+#else
+# define puInit
+#endif
+
+
+#endif
diff --git a/src/Main/fg_os_common.cxx b/src/Main/fg_os_common.cxx
index 3dd07c610..8af604cf8 100644
--- a/src/Main/fg_os_common.cxx
+++ b/src/Main/fg_os_common.cxx
@@ -21,7 +21,7 @@
#include <config.h>
#endif
-#include <plib/pu.h>
+#include <GUI/pu.h>
#include <osg/GraphicsContext>
#include <Viewer/renderer.hxx>
diff --git a/src/Model/panelnode.cxx b/src/Model/panelnode.cxx
index e59b9a5b6..c493e54c3 100644
--- a/src/Model/panelnode.cxx
+++ b/src/Model/panelnode.cxx
@@ -20,8 +20,7 @@
#include <simgear/scene/util/SGSceneUserData.hxx>
#include <simgear/scene/util/SGNodeMasks.hxx>
-#include <plib/pu.h>
-
+#include <GUI/pu.h>
#include <Main/fg_os.hxx>
#include <Cockpit/panel.hxx>
#include <Cockpit/panel_io.hxx>
diff --git a/src/Viewer/FGEventHandler.cxx b/src/Viewer/FGEventHandler.cxx
index 620e2bf88..f837ba37d 100644
--- a/src/Viewer/FGEventHandler.cxx
+++ b/src/Viewer/FGEventHandler.cxx
@@ -7,7 +7,7 @@
#include <osg/Viewport>
#include <osgViewer/Viewer>
-#include <plib/pu.h>
+#include <GUI/pu.h>
#include <Main/fg_props.hxx>
#include "CameraGroup.hxx"
#include "FGEventHandler.hxx"
diff --git a/src/Viewer/PUICamera.cxx b/src/Viewer/PUICamera.cxx
index 4d5b94414..45a467c47 100644
--- a/src/Viewer/PUICamera.cxx
+++ b/src/Viewer/PUICamera.cxx
@@ -34,10 +34,9 @@
#include <osgUtil/CullVisitor>
#include <osgViewer/Viewer>
-#include <plib/pu.h>
-
#include <simgear/scene/util/SGNodeMasks.hxx>
+#include <GUI/pu.h>
#include <Main/fg_props.hxx>
#include <Main/globals.hxx>
#include <Main/locale.hxx>