562 lines
18 KiB
C++
562 lines
18 KiB
C++
/**************************************************************************
|
|
* gui.cxx
|
|
*
|
|
* Written 1998 by Durk Talsma, started Juni, 1998. For the flight gear
|
|
* project.
|
|
*
|
|
* Additional mouse supported added by David Megginson, 1999.
|
|
*
|
|
* 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.
|
|
*
|
|
* $Id$
|
|
**************************************************************************/
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
# include <config.h>
|
|
#endif
|
|
|
|
#include <simgear/compiler.h>
|
|
|
|
#ifdef FG_MATH_EXCEPTION_CLASH
|
|
# include <math.h>
|
|
#endif
|
|
|
|
#ifdef HAVE_WINDOWS_H
|
|
# include <windows.h>
|
|
#endif
|
|
|
|
#include <GL/glut.h>
|
|
#include <simgear/xgl/xgl.h>
|
|
|
|
#if defined(FX) && defined(XMESA)
|
|
# include <GL/xmesa.h>
|
|
#endif
|
|
|
|
#include STL_STRING
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include <simgear/constants.h>
|
|
#include <simgear/debug/logstream.hxx>
|
|
#include <simgear/misc/fgpath.hxx>
|
|
#include <simgear/screen/screen-dump.hxx>
|
|
|
|
#include <Include/general.hxx>
|
|
//#include <Include/fg_memory.h>
|
|
#include <Aircraft/aircraft.hxx>
|
|
#include <Airports/simple.hxx>
|
|
//#include <Autopilot/auto_gui.hxx>
|
|
#include <Autopilot/newauto.hxx>
|
|
#include <Cockpit/panel.hxx>
|
|
#include <Controls/controls.hxx>
|
|
#include <FDM/flight.hxx>
|
|
#include <Main/options.hxx>
|
|
#include <Main/fg_init.hxx>
|
|
//#include <Main/views.hxx>
|
|
//#include <Network/network.h>
|
|
//#include <Time/fg_time.hxx>
|
|
|
|
#if defined( WIN32 ) && !defined( __CYGWIN__ )
|
|
# include <simgear/screen/win32-printer.h>
|
|
# include <simgear/screen/GlBitmaps.h>
|
|
#endif
|
|
|
|
#include "gui.h"
|
|
#include "gui_local.hxx"
|
|
|
|
FG_USING_STD(string);
|
|
|
|
#ifndef FG_HAVE_NATIVE_SGI_COMPILERS
|
|
FG_USING_STD(cout);
|
|
#endif
|
|
|
|
#if defined(WIN32) || defined(__CYGWIN32__)
|
|
#define WIN32_CURSOR_TWEAKS
|
|
#elif (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
|
|
#define X_CURSOR_TWEAKS
|
|
#endif
|
|
|
|
/* --------------------------------------------------------------------
|
|
Mouse stuff
|
|
---------------------------------------------------------------------*/
|
|
|
|
static int _mX = 0;
|
|
static int _mY = 0;
|
|
static int _savedX = 0;
|
|
static int _savedY = 0;
|
|
static int last_buttons = 0 ;
|
|
static int mouse_active = 0;
|
|
static int mouse_joystick_control = 0;
|
|
|
|
//static time_t mouse_off_time;
|
|
//static int mouse_timed_out;
|
|
|
|
// to allow returning to previous view
|
|
// on second left click in MOUSE_VIEW mode
|
|
// This has file scope so that it can be reset
|
|
// if the little rodent is moved NHV
|
|
static int _mVtoggle;
|
|
|
|
// we break up the glutGetModifiers return mask
|
|
// once per loop and stash what we need in these
|
|
static int glut_active_shift;
|
|
static int glut_active_ctrl;
|
|
static int glut_active_alt;
|
|
|
|
// uncomment this for view to exactly follow mouse in MOUSE_VIEW mode
|
|
// else smooth out the view panning to .01 radian per frame
|
|
// see view_offset smoothing mechanism in main.cxx
|
|
#define NO_SMOOTH_MOUSE_VIEW
|
|
|
|
// uncomment following to
|
|
#define RESET_VIEW_ON_LEAVING_MOUSE_VIEW
|
|
|
|
/* --------------------------------------------------------------------
|
|
Support for mouse as control yoke (david@megginson.com)
|
|
|
|
- right button toggles between pointer and yoke
|
|
- horizontal drag with no buttons moves ailerons
|
|
- vertical drag with no buttons moves elevators
|
|
- horizontal drag with left button moves brakes (left=on)
|
|
- vertical drag with left button moves throttle (up=more)
|
|
- horizontal drag with middle button moves rudder
|
|
- vertical drag with middle button moves trim
|
|
|
|
For the *_sensitivity variables, a lower number means more sensitive.
|
|
|
|
TODO: figure out how to keep pointer from leaving window in yoke mode.
|
|
TODO: add thresholds and null zones
|
|
TODO: sensitivity should be configurable at user option.
|
|
TODO: allow differential braking (this will be useful if FlightGear
|
|
ever supports tail-draggers like the DC-3)
|
|
---------------------------------------------------------------------*/
|
|
|
|
MouseMode mouse_mode = MOUSE_POINTER;
|
|
|
|
static double aileron_sensitivity = 1.0/500.0;
|
|
static double elevator_sensitivity = 1.0/500.0;
|
|
static double brake_sensitivity = 1.0/250.0;
|
|
static double throttle_sensitivity = 1.0/250.0;
|
|
static double rudder_sensitivity = 1.0/500.0;
|
|
static double trim_sensitivity = 1.0/1000.0;
|
|
|
|
static inline int guiGetMouseButton(void)
|
|
{
|
|
return last_buttons;
|
|
}
|
|
|
|
static inline void guiGetMouse(int *x, int *y)
|
|
{
|
|
*x = _mX;
|
|
*y = _mY;
|
|
};
|
|
|
|
static inline int left_button( void ) {
|
|
return( last_buttons & (1 << GLUT_LEFT_BUTTON) );
|
|
}
|
|
|
|
static inline int middle_button( void ) {
|
|
return( last_buttons & (1 << GLUT_MIDDLE_BUTTON) );
|
|
}
|
|
|
|
static inline int right_button( void ) {
|
|
return( last_buttons & (1 << GLUT_RIGHT_BUTTON) );
|
|
}
|
|
|
|
void TurnCursorOn( void )
|
|
{
|
|
mouse_active = ~0;
|
|
#if defined(WIN32_CURSOR_TWEAKS)
|
|
switch (mouse_mode) {
|
|
case MOUSE_POINTER:
|
|
glutSetCursor(GLUT_CURSOR_INHERIT);
|
|
break;
|
|
case MOUSE_YOKE:
|
|
glutSetCursor(GLUT_CURSOR_CROSSHAIR);
|
|
break;
|
|
case MOUSE_VIEW:
|
|
glutSetCursor(GLUT_CURSOR_LEFT_RIGHT);
|
|
break;
|
|
}
|
|
#endif
|
|
#if defined(X_CURSOR_TWEAKS)
|
|
glutWarpPointer( globals->get_options()->get_xsize()/2,
|
|
globals->get_options()->get_ysize()/2);
|
|
#endif
|
|
}
|
|
|
|
void TurnCursorOff( void )
|
|
{
|
|
mouse_active = 0;
|
|
#if defined(WIN32_CURSOR_TWEAKS)
|
|
glutSetCursor(GLUT_CURSOR_NONE);
|
|
#elif defined(X_CURSOR_TWEAKS)
|
|
glutWarpPointer( globals->get_options()->get_xsize(),
|
|
globals->get_options()->get_ysize());
|
|
#endif
|
|
}
|
|
|
|
void maybeToggleMouse( void )
|
|
{
|
|
#if defined(WIN32_CURSOR_TWEAKS)
|
|
static int first_time = ~0;
|
|
static int mouse_changed = 0;
|
|
|
|
if ( first_time ) {
|
|
if(!mouse_active) {
|
|
mouse_changed = ~mouse_changed;
|
|
TurnCursorOn();
|
|
}
|
|
} else {
|
|
if( mouse_mode != MOUSE_POINTER )
|
|
return;
|
|
if( mouse_changed ) {
|
|
mouse_changed = ~mouse_changed;
|
|
if(mouse_active) {
|
|
TurnCursorOff();
|
|
}
|
|
}
|
|
}
|
|
first_time = ~first_time;
|
|
#endif // #ifdef WIN32
|
|
}
|
|
|
|
// Call with FALSE to init and TRUE to restore
|
|
void BusyCursor( int restore )
|
|
{
|
|
static GLenum cursor = (GLenum) 0;
|
|
if( restore ) {
|
|
glutSetCursor(cursor);
|
|
} else {
|
|
cursor = (GLenum) glutGet( (GLenum) GLUT_WINDOW_CURSOR );
|
|
#if defined(WIN32_CURSOR_TWEAKS)
|
|
TurnCursorOn();
|
|
#endif
|
|
glutSetCursor( GLUT_CURSOR_WAIT );
|
|
}
|
|
}
|
|
|
|
|
|
// Center the view offsets
|
|
void CenterView( void ) {
|
|
if( mouse_mode = MOUSE_VIEW ) {
|
|
mouse_mode = MOUSE_POINTER;
|
|
_savedX = globals->get_options()->get_xsize()/2;
|
|
_savedY = globals->get_options()->get_ysize()/2;
|
|
_mVtoggle = 0;
|
|
Quat0();
|
|
build_rotmatrix(GuiQuat_mat, curGuiQuat);
|
|
glutSetCursor(GLUT_CURSOR_INHERIT);
|
|
|
|
// Is this necessary ??
|
|
if( !gui_menu_on ) TurnCursorOff();
|
|
|
|
glutWarpPointer( _savedX, _savedY );
|
|
}
|
|
globals->get_current_view()->set_goal_view_offset(0.0);
|
|
globals->get_current_view()->set_view_offset(0.0);
|
|
}
|
|
|
|
|
|
void guiMotionFunc ( int x, int y )
|
|
{
|
|
int ww, wh, need_warp = 0;
|
|
float W, H;
|
|
double offset;
|
|
|
|
if (mouse_mode == MOUSE_POINTER) {
|
|
puMouse ( x, y ) ;
|
|
glutPostRedisplay () ;
|
|
} else {
|
|
if( x == _mX && y == _mY)
|
|
return;
|
|
|
|
// reset left click MOUSE_VIEW toggle feature
|
|
_mVtoggle = 0;
|
|
|
|
ww = globals->get_options()->get_xsize();
|
|
wh = globals->get_options()->get_ysize();
|
|
|
|
switch (mouse_mode) {
|
|
case MOUSE_YOKE:
|
|
if( !mouse_joystick_control ) {
|
|
mouse_joystick_control = 1;
|
|
globals->get_options()->set_control_mode( FGOptions::FG_MOUSE );
|
|
} else {
|
|
if ( left_button() ) {
|
|
offset = (_mX - x) * brake_sensitivity;
|
|
controls.move_brake(FGControls::ALL_WHEELS, offset);
|
|
offset = (_mY - y) * throttle_sensitivity;
|
|
controls.move_throttle(FGControls::ALL_ENGINES, offset);
|
|
} else if ( right_button() ) {
|
|
if( ! current_autopilot->get_HeadingEnabled() ) {
|
|
offset = (x - _mX) * rudder_sensitivity;
|
|
controls.move_rudder(offset);
|
|
}
|
|
if( ! current_autopilot->get_AltitudeEnabled() ) {
|
|
offset = (_mY - y) * trim_sensitivity;
|
|
controls.move_elevator_trim(offset);
|
|
}
|
|
} else {
|
|
if( ! current_autopilot->get_HeadingEnabled() ) {
|
|
offset = (x - _mX) * aileron_sensitivity;
|
|
controls.move_aileron(offset);
|
|
}
|
|
if( ! current_autopilot->get_AltitudeEnabled() ) {
|
|
offset = (_mY - y) * elevator_sensitivity;
|
|
controls.move_elevator(offset);
|
|
}
|
|
}
|
|
}
|
|
// Keep the mouse in the window.
|
|
if (x < 5 || x > ww-5 || y < 5 || y > wh-5) {
|
|
x = ww / 2;
|
|
y = wh / 2;
|
|
need_warp = 1;
|
|
}
|
|
break;
|
|
|
|
case MOUSE_VIEW:
|
|
if( y <= 0 ) {
|
|
#define CONTRAINED_MOUSE_VIEW_Y
|
|
#ifdef CONTRAINED_MOUSE_VIEW_Y
|
|
y = 1;
|
|
#else
|
|
y = wh-2;
|
|
#endif // CONTRAINED_MOUSE_VIEW_Y
|
|
need_warp = 1;
|
|
} else if( y >= wh-1) {
|
|
#ifdef CONTRAINED_MOUSE_VIEW_Y
|
|
y = wh-2;
|
|
#else
|
|
y = 1;
|
|
#endif // CONTRAINED_MOUSE_VIEW_Y
|
|
need_warp = 1;
|
|
}
|
|
// wrap MOUSE_VIEW mode cursor x position
|
|
if ( x <= 0 ) {
|
|
need_warp = 1;
|
|
x = ww-2;
|
|
} else if ( x >= ww-1 ) {
|
|
need_warp = 1;
|
|
x = 1;
|
|
}
|
|
// try to get FG_PI movement in each half of screen
|
|
// do spherical pan
|
|
W = ww;
|
|
H = wh;
|
|
if( middle_button() ) {
|
|
trackball(lastGuiQuat,
|
|
(2.0f * _mX - W) / W,
|
|
0, //(H - 2.0f * y) / H, // 3
|
|
(2.0f * x - W) / W,
|
|
0 //(H - 2.0f * _mY) / H // 1
|
|
);
|
|
x = _mX;
|
|
y = _mY;
|
|
need_warp = 1;
|
|
} else {
|
|
trackball(lastGuiQuat,
|
|
0, //(2.0f * _mX - W) / W, // 0
|
|
(H - 2.0f * y) / H, // 3
|
|
0, //(2.0f * x - W) / W, // 2
|
|
(H - 2.0f * _mY) / H // 1
|
|
);
|
|
}
|
|
add_quats(lastGuiQuat, curGuiQuat, curGuiQuat);
|
|
build_rotmatrix(GuiQuat_mat, curGuiQuat);
|
|
|
|
// do horizontal pan
|
|
// this could be done in above quat
|
|
// but requires redoing view pipeline
|
|
offset = globals->get_current_view()->get_goal_view_offset();
|
|
offset += ((_mX - x) * FG_2PI / W );
|
|
while (offset < 0.0) {
|
|
offset += FG_2PI;
|
|
}
|
|
while (offset > FG_2PI) {
|
|
offset -= FG_2PI;
|
|
}
|
|
globals->get_current_view()->set_goal_view_offset(offset);
|
|
#ifdef NO_SMOOTH_MOUSE_VIEW
|
|
globals->get_current_view()->set_view_offset(offset);
|
|
#endif
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if( need_warp)
|
|
glutWarpPointer(x, y);
|
|
|
|
// Record the new mouse position.
|
|
_mX = x;
|
|
_mY = y;
|
|
}
|
|
|
|
|
|
void guiMouseFunc(int button, int updown, int x, int y)
|
|
{
|
|
int glutModifiers;
|
|
|
|
// private MOUSE_VIEW state variables
|
|
// to allow alternate left clicks in MOUSE_VIEW mode
|
|
// to toggle between current offsets and straight ahead
|
|
// uses _mVtoggle
|
|
static int _mVx, _mVy, _Vx, _Vy;
|
|
static float _quat[4];
|
|
static double _view_offset;
|
|
|
|
// general purpose variables
|
|
double offset;
|
|
|
|
glutModifiers = glutGetModifiers();
|
|
glut_active_shift = glutModifiers & GLUT_ACTIVE_SHIFT;
|
|
glut_active_ctrl = glutModifiers & GLUT_ACTIVE_CTRL;
|
|
glut_active_alt = glutModifiers & GLUT_ACTIVE_ALT;
|
|
|
|
// Was the left button pressed?
|
|
if (updown == GLUT_DOWN ) {
|
|
if( button == GLUT_LEFT_BUTTON)
|
|
{
|
|
switch (mouse_mode) {
|
|
case MOUSE_POINTER:
|
|
break;
|
|
case MOUSE_YOKE:
|
|
break;
|
|
case MOUSE_VIEW:
|
|
if(_mVtoggle) {
|
|
// resume previous view offsets
|
|
_mX = _mVx;
|
|
_mY = _mVy;
|
|
x = _Vx;
|
|
y = _Vy;
|
|
curGuiQuat[0] = _quat[0];
|
|
curGuiQuat[1] = _quat[1];
|
|
curGuiQuat[2] = _quat[2];
|
|
curGuiQuat[3] = _quat[3];
|
|
globals->get_current_view()->set_goal_view_offset(_view_offset);
|
|
#ifdef NO_SMOOTH_MOUSE_VIEW
|
|
globals->get_current_view()->set_view_offset(_view_offset);
|
|
#endif
|
|
} else {
|
|
// center view
|
|
_mVx = _mX;
|
|
_mVy = _mY;
|
|
_Vx = x;
|
|
_Vy = y;
|
|
_quat[0] = curGuiQuat[0];
|
|
_quat[1] = curGuiQuat[1];
|
|
_quat[2] = curGuiQuat[2];
|
|
_quat[3] = curGuiQuat[3];
|
|
x = globals->get_options()->get_xsize()/2;
|
|
y = globals->get_options()->get_ysize()/2;
|
|
Quat0();
|
|
_view_offset =
|
|
globals->get_current_view()->get_goal_view_offset();
|
|
globals->get_current_view()->set_goal_view_offset(0.0);
|
|
#ifdef NO_SMOOTH_MOUSE_VIEW
|
|
globals->get_current_view()->set_view_offset(0.0);
|
|
#endif
|
|
}
|
|
glutWarpPointer( x , y);
|
|
build_rotmatrix(GuiQuat_mat, curGuiQuat);
|
|
_mVtoggle = ~_mVtoggle;
|
|
break;
|
|
}
|
|
}else if ( button == GLUT_RIGHT_BUTTON) {
|
|
switch (mouse_mode) {
|
|
case MOUSE_POINTER:
|
|
mouse_mode = MOUSE_YOKE;
|
|
mouse_joystick_control = 0;
|
|
_savedX = x;
|
|
_savedY = y;
|
|
// start with zero point in center of screen
|
|
_mX = globals->get_options()->get_xsize()/2;
|
|
_mY = globals->get_options()->get_ysize()/2;
|
|
|
|
// try to have the MOUSE_YOKE position
|
|
// reflect the current stick position
|
|
offset = controls.get_aileron();
|
|
x = _mX - (int)(offset * aileron_sensitivity);
|
|
offset = controls.get_elevator();
|
|
y = _mY - (int)(offset * elevator_sensitivity);
|
|
|
|
glutSetCursor(GLUT_CURSOR_CROSSHAIR);
|
|
FG_LOG( FG_INPUT, FG_INFO, "Mouse in yoke mode" );
|
|
break;
|
|
|
|
case MOUSE_YOKE:
|
|
mouse_mode = MOUSE_VIEW;
|
|
globals->get_options()->set_control_mode( FGOptions::FG_JOYSTICK );
|
|
x = globals->get_options()->get_xsize()/2;
|
|
y = globals->get_options()->get_ysize()/2;
|
|
_mVtoggle = 0;
|
|
Quat0();
|
|
build_rotmatrix(GuiQuat_mat, curGuiQuat);
|
|
glutSetCursor(GLUT_CURSOR_LEFT_RIGHT);
|
|
FG_LOG( FG_INPUT, FG_INFO, "Mouse in view mode" );
|
|
break;
|
|
|
|
case MOUSE_VIEW:
|
|
mouse_mode = MOUSE_POINTER;
|
|
x = _savedX;
|
|
y = _savedY;
|
|
#ifdef RESET_VIEW_ON_LEAVING_MOUSE_VIEW
|
|
Quat0();
|
|
build_rotmatrix(GuiQuat_mat, curGuiQuat);
|
|
globals->get_current_view()->set_goal_view_offset(0.0);
|
|
#ifdef NO_SMOOTH_MOUSE_VIEW
|
|
globals->get_current_view()->set_view_offset(0.0);
|
|
#endif
|
|
#endif // RESET_VIEW_ON_LEAVING_MOUSE_VIEW
|
|
glutSetCursor(GLUT_CURSOR_INHERIT);
|
|
|
|
if(!gui_menu_on)
|
|
TurnCursorOff();
|
|
|
|
FG_LOG( FG_INPUT, FG_INFO, "Mouse in pointer mode" );
|
|
break;
|
|
}
|
|
glutWarpPointer( x, y );
|
|
} // END RIGHT BUTTON
|
|
} // END UPDOWN == GLUT_DOWN
|
|
|
|
// Note which button is pressed.
|
|
if ( updown == GLUT_DOWN ) {
|
|
last_buttons |= ( 1 << button ) ;
|
|
} else {
|
|
last_buttons &= ~( 1 << button ) ;
|
|
}
|
|
|
|
// If we're in pointer mode, let PUI
|
|
// know what's going on.
|
|
if (mouse_mode == MOUSE_POINTER) {
|
|
if (!puMouse (button, updown, x,y)) {
|
|
current_panel->doMouseAction(button, updown, x, y);
|
|
}
|
|
}
|
|
|
|
// Register the new position (if it
|
|
// hasn't been registered already).
|
|
_mX = x;
|
|
_mY = y;
|
|
|
|
glutPostRedisplay ();
|
|
}
|
|
|