src/GUI/mouse.cxx

   1 /**************************************************************************
   2  * gui.cxx
   3  *
   4  * Written 1998 by Durk Talsma, started Juni, 1998.  For the flight gear
   5  * project.
   6  *
   7  * Additional mouse supported added by David Megginson, 1999.
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License as
  11  * published by the Free Software Foundation; either version 2 of the
  12  * License, or (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  *
  23  * $Id$
  24  **************************************************************************/
  25
  26
  27 #ifdef HAVE_CONFIG_H
  28 #  include <config.h>
  29 #endif
  30
  31 #include <simgear/compiler.h>
  32
  33 #ifdef SG_MATH_EXCEPTION_CLASH
  34 #  include <math.h>
  35 #endif
  36
  37 #ifdef HAVE_WINDOWS_H
  38 #  include <windows.h>
  39 #endif
  40
  41 #include GLUT_H
  42
  43 #if defined(FX) && defined(XMESA)
  44 #  include <GL/xmesa.h>
  45 #endif
  46
  47 #include STL_STRING
  48
  49 #include <stdlib.h>
  50 #include <string.h>
  51
  52 #include <simgear/constants.h>
  53 #include <simgear/debug/logstream.hxx>
  54 #include <simgear/misc/sg_path.hxx>
  55 #include <simgear/screen/screen-dump.hxx>
  56
  57 #include <Include/general.hxx>
  58 //#include <Include/fg_memory.h>
  59 #include <Aircraft/aircraft.hxx>
  60 #include <Airports/simple.hxx>
  61 //#include <Autopilot/auto_gui.hxx>
  62 #include <Autopilot/newauto.hxx>
  63 #include <Cockpit/panel.hxx>
  64 #include <Controls/controls.hxx>
  65 #include <FDM/flight.hxx>
  66 #include <Main/fg_init.hxx>
  67 #include <Main/fg_props.hxx>
  68 #include <Main/viewmgr.hxx>
  69
  70 #include "gui.h"
  71 #include "gui_local.hxx"
  72
  73 SG_USING_STD(string);
  74 SG_USING_STD(cout);
  75
  76 /* --------------------------------------------------------------------
  77 Mouse stuff
  78 ---------------------------------------------------------------------*/
  79
  80 static int _mX = 0;
  81 static int _mY = 0;
  82 static int _savedX = 0;
  83 static int _savedY = 0;
  84 static int last_buttons = 0 ;
  85 static int mouse_active = 0;
  86 static int mouse_joystick_control = 0;
  87
  88 //static time_t mouse_off_time;
  89 //static int mouse_timed_out;
  90
  91 // to allow returning to previous view
  92 // on second left click in MOUSE_VIEW mode
  93 // This has file scope so that it can be reset
  94 // if the little rodent is moved  NHV
  95 static  int _mVtoggle = 0;
  96
  97 // we break up the glutGetModifiers return mask
  98 // once per loop and stash what we need in these
  99 static int glut_active_shift = 0;
 100 static int glut_active_ctrl = 0;
 101 static int glut_active_alt = 0;
 102
 103 static int MOUSE_XSIZE = 0;
 104 static int MOUSE_YSIZE = 0;
 105
 106 // uncomment this for view to exactly follow mouse in MOUSE_VIEW mode
 107 // else smooth out the view panning to .01 radian per frame
 108 // see view_offset smoothing mechanism in main.cxx
 109 #define NO_SMOOTH_MOUSE_VIEW
 110
 111 // uncomment following to
 112 #define RESET_VIEW_ON_LEAVING_MOUSE_VIEW
 113
 114 /* --------------------------------------------------------------------
 115 Support for mouse as control yoke (david@megginson.com)
 116
 117 - right button toggles between pointer and yoke
 118 - horizontal drag with no buttons moves ailerons
 119 - vertical drag with no buttons moves elevators
 120 - horizontal drag with left button moves brakes (left=on)
 121 - vertical drag with left button moves throttle (up=more)
 122 - horizontal drag with middle button moves rudder
 123 - vertical drag with middle button moves trim
 124
 125 For the *_sensitivity variables, a lower number means more sensitive.
 126
 127 TODO: figure out how to keep pointer from leaving window in yoke mode.
 128 TODO: add thresholds and null zones
 129 TODO: sensitivity should be configurable at user option.
 130 TODO: allow differential braking (this will be useful if FlightGear
 131       ever supports tail-draggers like the DC-3)
 132 ---------------------------------------------------------------------*/
 133
 134 MouseMode mouse_mode = MOUSE_POINTER;
 135
 136 static double aileron_sensitivity = 1.0/500.0;
 137 static double elevator_sensitivity = 1.0/500.0;
 138 static double brake_sensitivity = 1.0/250.0;
 139 static double throttle_sensitivity = 1.0/250.0;
 140 static double rudder_sensitivity = 1.0/500.0;
 141 static double trim_sensitivity = 1.0/1000.0;
 142
 143 void guiInitMouse(int width, int height)
 144 {
 145         MOUSE_XSIZE = width;
 146         MOUSE_YSIZE = height;
 147 }
 148
 149 static inline int guiGetMouseButton(void)
 150 {
 151         return last_buttons;
 152 }
 153
 154 static inline void guiGetMouse(int *x, int *y)
 155 {
 156         *x = _mX;
 157         *y = _mY;
 158 };
 159
 160 static inline int left_button( void ) {
 161     return( last_buttons & (1 << GLUT_LEFT_BUTTON) );
 162 }
 163
 164 static inline int middle_button( void ) {
 165     return( last_buttons & (1 << GLUT_MIDDLE_BUTTON) );
 166 }
 167
 168 static inline int right_button( void ) {
 169     return( last_buttons & (1 << GLUT_RIGHT_BUTTON) );
 170 }
 171
 172 static inline void set_goal_view_offset( float offset )
 173 {
 174         globals->get_current_view()->setGoalHeadingOffset_deg(offset * SGD_RADIANS_TO_DEGREES);
 175 }
 176
 177 static inline void set_view_offset( float offset )
 178 {
 179         globals->get_current_view()->setHeadingOffset_deg(offset * SGD_RADIANS_TO_DEGREES);
 180 }
 181
 182 static inline void set_goal_view_tilt( float tilt )
 183 {
 184         globals->get_current_view()->setGoalPitchOffset_deg(tilt);
 185 }
 186
 187 static inline void set_view_tilt( float tilt )
 188 {
 189         globals->get_current_view()->setPitchOffset_deg(tilt);
 190 }
 191
 192 static inline float get_view_offset() {
 193         return globals->get_current_view()->getHeadingOffset_deg() * SGD_DEGREES_TO_RADIANS;
 194 }
 195
 196 static inline float get_goal_view_offset() {
 197         return globals->get_current_view()->getGoalHeadingOffset_deg() * SGD_DEGREES_TO_RADIANS;
 198 }
 199
 200 static inline void move_brake(float offset) {
 201         globals->get_controls()->move_brake(FGControls::ALL_WHEELS, offset);
 202 }
 203
 204 static inline void move_throttle(float offset) {
 205         globals->get_controls()->move_throttle(FGControls::ALL_ENGINES, offset);
 206 }
 207
 208 static inline void move_rudder(float offset) {
 209         globals->get_controls()->move_rudder(offset);
 210 }
 211
 212 static inline void move_elevator_trim(float offset) {
 213         globals->get_controls()->move_elevator_trim(offset);
 214 }
 215
 216 static inline void move_aileron(float offset) {
 217         globals->get_controls()->move_aileron(offset);
 218 }
 219
 220 static inline void move_elevator(float offset) {
 221         globals->get_controls()->move_elevator(offset);
 222 }
 223
 224 static inline float get_aileron() {
 225         return globals->get_controls()->get_aileron();
 226 }
 227
 228 static inline float get_elevator() {
 229         return globals->get_controls()->get_elevator();
 230 }
 231
 232 static inline bool AP_HeadingEnabled() {
 233         return globals->get_autopilot()->get_HeadingEnabled();
 234 }
 235
 236 static inline bool AP_AltitudeEnabled() {
 237         return globals->get_autopilot()->get_AltitudeEnabled();
 238 }
 239
 240 void TurnCursorOn( void )
 241 {
 242     mouse_active = ~0;
 243 #if defined(WIN32)
 244     switch (mouse_mode) {
 245         case MOUSE_POINTER:
 246             glutSetCursor(GLUT_CURSOR_INHERIT);
 247             break;
 248         case MOUSE_YOKE:
 249             glutSetCursor(GLUT_CURSOR_CROSSHAIR);
 250             break;
 251         case MOUSE_VIEW:
 252             glutSetCursor(GLUT_CURSOR_LEFT_RIGHT);
 253             break;
 254     }
 255 #endif
 256 #if defined(X_CURSOR_TWEAKS)
 257     glutWarpPointer( MOUSE_XSIZE/2,
 258                      MOUSE_YSIZE/2);
 259 #endif
 260 }
 261
 262 void TurnCursorOff( void )
 263 {
 264     mouse_active = 0;
 265 #if defined(WIN32_CURSOR_TWEAKS)
 266     glutSetCursor(GLUT_CURSOR_NONE);
 267 #elif defined(X_CURSOR_TWEAKS)
 268     glutWarpPointer( MOUSE_XSIZE,
 269                      MOUSE_YSIZE);
 270 #endif
 271 }
 272
 273 void maybeToggleMouse( void )
 274 {
 275 #if defined(WIN32_CURSOR_TWEAKS_OFF)
 276     static int first_time = ~0;
 277     static int mouse_changed = 0;
 278
 279     if ( first_time ) {
 280         if(!mouse_active) {
 281             mouse_changed = ~mouse_changed;
 282             TurnCursorOn();
 283         }
 284     } else {
 285         if( mouse_mode != MOUSE_POINTER )
 286             return;
 287         if( mouse_changed ) {
 288             mouse_changed = ~mouse_changed;
 289             if(mouse_active) {
 290                 TurnCursorOff();
 291             }
 292         }
 293     }
 294     first_time = ~first_time;
 295 #endif // #ifdef WIN32
 296 }
 297
 298 // Call with FALSE to init and TRUE to restore
 299 void BusyCursor( int restore )
 300 {
 301     static GLenum cursor = (GLenum) 0;
 302     if( restore ) {
 303         glutSetCursor(cursor);
 304     } else {
 305         cursor = (GLenum) glutGet( (GLenum) GLUT_WINDOW_CURSOR );
 306 #if defined(WIN32_CURSOR_TWEAKS)
 307         TurnCursorOn();
 308 #endif
 309         glutSetCursor( GLUT_CURSOR_WAIT );
 310     }
 311 }
 312
 313
 314 // Center the view offsets
 315 void CenterView( void ) {
 316     if( mouse_mode == MOUSE_VIEW ) {
 317         mouse_mode = MOUSE_POINTER;
 318         _savedX = MOUSE_XSIZE/2;
 319         _savedY = MOUSE_YSIZE/2;
 320         _mVtoggle = 0;
 321         Quat0();
 322         build_rotmatrix(GuiQuat_mat, curGuiQuat);
 323         glutSetCursor(GLUT_CURSOR_INHERIT);
 324
 325         // Is this necessary ??
 326 #if defined(FG_OLD_MENU)
 327         if( !gui_menu_on )   TurnCursorOff();
 328 #endif
 329
 330         glutWarpPointer( _savedX, _savedY );
 331     }
 332     set_goal_view_offset(0.0);
 333     set_view_offset(0.0);
 334 }
 335
 336
 337 //#define TRANSLATE_HUD
 338 // temporary hack until pitch_offset is added to view pipeline
 339 void fgTranslateHud( void ) {
 340 #ifdef TRANSLATE_HUD
 341     if(mouse_mode == MOUSE_VIEW) {
 342
 343         int ww = MOUSE_XSIZE;
 344         int wh = MOUSE_YSIZE;
 345
 346         float y = 4*(_mY-(wh/2));// * ((wh/SGD_PI)*SG_RADIANS_TO_DEGREES);
 347
 348         float x =  get_view_offset() * SG_RADIANS_TO_DEGREES;
 349
 350         if( x < -180 )      x += 360;
 351         else if( x > 180 )      x -= 360;
 352
 353         x *= ww/90.0;
 354         //      x *= ww/180.0;
 355         //      x *= ww/360.0;
 356
 357         //      glTranslatef( x*ww/640, y*wh/480, 0 );
 358         glTranslatef( x*640/ww, y*480/wh, 0 );
 359     }
 360 #endif // TRANSLATE_HUD
 361 }
 362
 363 void guiMotionFunc ( int x, int y )
 364 {
 365     int ww, wh, need_warp = 0;
 366     float W, H;
 367     double offset;
 368
 369     ww = MOUSE_XSIZE;
 370     wh = MOUSE_YSIZE;
 371
 372     if (mouse_mode == MOUSE_POINTER) {
 373 #if defined(FG_OLD_MENU)
 374         // TURN MENU ON IF MOUSE AT TOP
 375         if( y < 1 ) {
 376             if( !gui_menu_on )
 377                 guiToggleMenu();
 378         }
 379         // TURN MENU OFF IF MOUSE AT BOTTOM
 380         else if( y > wh-2 ) {
 381             if( gui_menu_on )
 382                 guiToggleMenu();
 383         }
 384 #endif
 385         puMouse ( x, y ) ;
 386         glutPostRedisplay () ;
 387     } else {
 388         if( x == _mX && y == _mY)
 389             return;
 390
 391         // reset left click MOUSE_VIEW toggle feature
 392         _mVtoggle = 0;
 393
 394         switch (mouse_mode) {
 395             case MOUSE_YOKE:
 396                 if( !mouse_joystick_control ) {
 397                     mouse_joystick_control = 1;
 398                     fgSetString("/sim/control-mode", "mouse");
 399                 } else {
 400                     if ( left_button() ) {
 401                         move_brake(   (_mX - x) * brake_sensitivity);
 402                         move_throttle((_mY - y) * throttle_sensitivity);
 403                     } else if ( right_button() ) {
 404                         if( ! AP_HeadingEnabled() ) {
 405                             move_rudder((x - _mX) * rudder_sensitivity);
 406                         }
 407                         if( ! AP_AltitudeEnabled() ) {
 408                             move_elevator_trim((_mY - y) * trim_sensitivity);
 409                         }
 410                     } else {
 411                         if( ! AP_HeadingEnabled() ) {
 412                             move_aileron((x - _mX) * aileron_sensitivity);
 413                         }
 414                         if( ! AP_AltitudeEnabled() ) {
 415                             move_elevator((_mY - y) * elevator_sensitivity);
 416                         }
 417                     }
 418                 }
 419                 // Keep the mouse in the window.
 420                 if (x < 5 || x > ww-5 || y < 5 || y > wh-5) {
 421                     x = ww / 2;
 422                     y = wh / 2;
 423                     need_warp = 1;
 424                 }
 425                 break;
 426
 427             case MOUSE_VIEW:
 428                 if( y <= 0 ) {
 429 #define CONTRAINED_MOUSE_VIEW_Y
 430 #ifdef CONTRAINED_MOUSE_VIEW_Y
 431                     y = 1;
 432 #else
 433                     y = wh-2;
 434 #endif // CONTRAINED_MOUSE_VIEW_Y
 435                     need_warp = 1;
 436                 } else if( y >= wh-1) {
 437 #ifdef CONTRAINED_MOUSE_VIEW_Y
 438                     y = wh-2;
 439 #else
 440                     y = 1;
 441 #endif // CONTRAINED_MOUSE_VIEW_Y
 442                     need_warp = 1;
 443                 }
 444                 // wrap MOUSE_VIEW mode cursor x position
 445                 if ( x <= 0 ) {
 446                     need_warp = 1;
 447                     x = ww-2;
 448                 } else if ( x >= ww-1 ) {
 449                     need_warp = 1;
 450                     x = 1;
 451                 }
 452                 // try to get SGD_PI movement in each half of screen
 453                 // do spherical pan
 454                 W = ww;
 455                 H = wh;
 456                 if( middle_button() ) {
 457                     trackball(lastGuiQuat,
 458                               (2.0f * _mX - W) / W,
 459                               0, //(H - 2.0f * y) / H,         // 3
 460                               (2.0f * x - W) / W,
 461                               0 //(H - 2.0f * _mY) / H       // 1
 462                              );
 463                     x = _mX;
 464                     y = _mY;
 465                     need_warp = 1;
 466                 } else {
 467                     trackball(lastGuiQuat,
 468                               0, //(2.0f * _mX - W) / W,  // 0
 469                               (H - 2.0f * y) / H,         // 3
 470                               0, //(2.0f * x - W) / W,    // 2
 471                               (H - 2.0f * _mY) / H        // 1
 472                              );
 473                 }
 474                 add_quats(lastGuiQuat, curGuiQuat, curGuiQuat);
 475                 build_rotmatrix(GuiQuat_mat, curGuiQuat);
 476
 477                 // do horizontal pan
 478                 // this could be done in above quat
 479                 // but requires redoing view pipeline
 480                 offset = get_goal_view_offset();
 481                 offset += ((_mX - x) * SGD_2PI / W );
 482                 while (offset < 0.0) {
 483                     offset += SGD_2PI;
 484                 }
 485                 while (offset > SGD_2PI) {
 486                     offset -= SGD_2PI;
 487                 }
 488                 set_goal_view_offset(offset);
 489                 set_goal_view_tilt(asin( GuiQuat_mat[1][2]) * SGD_RADIANS_TO_DEGREES );
 490 #ifdef NO_SMOOTH_MOUSE_VIEW
 491                 set_view_offset(offset);
 492                 set_view_tilt(asin( GuiQuat_mat[1][2]) * SGD_RADIANS_TO_DEGREES );
 493 #endif
 494                 break;
 495
 496             default:
 497                 break;
 498         }
 499     }
 500     if( need_warp)
 501         glutWarpPointer(x, y);
 502
 503     // Record the new mouse position.
 504     _mX = x;
 505     _mY = y;
 506 }
 507
 508
 509 void guiMouseFunc(int button, int updown, int x, int y)
 510 {
 511     int glutModifiers;
 512
 513     // private MOUSE_VIEW state variables
 514     // to allow alternate left clicks in MOUSE_VIEW mode
 515     // to toggle between current offsets and straight ahead
 516     // uses _mVtoggle
 517     static int _mVx, _mVy, _Vx, _Vy;
 518     static float _quat[4];
 519     static double _view_offset;
 520
 521     glutModifiers = glutGetModifiers();
 522     glut_active_shift = glutModifiers & GLUT_ACTIVE_SHIFT;
 523     glut_active_ctrl  = glutModifiers & GLUT_ACTIVE_CTRL;
 524     glut_active_alt   = glutModifiers & GLUT_ACTIVE_ALT;
 525
 526     // Was the left button pressed?
 527     if (updown == GLUT_DOWN ) {
 528         if( button == GLUT_LEFT_BUTTON)
 529         {
 530             switch (mouse_mode) {
 531                 case MOUSE_POINTER:
 532                     break;
 533                 case MOUSE_YOKE:
 534                     break;
 535                 case MOUSE_VIEW:
 536                     if(_mVtoggle) {
 537                         // resume previous view offsets
 538                         _mX = _mVx;
 539                         _mY = _mVy;
 540                         x = _Vx;
 541                         y = _Vy;
 542                         sgCopyVec4(curGuiQuat, _quat);
 543                         set_goal_view_offset(_view_offset);
 544                         set_goal_view_tilt(0.0);
 545 #ifdef NO_SMOOTH_MOUSE_VIEW
 546                         set_view_offset(_view_offset);
 547 #endif
 548                     } else {
 549                         // center view
 550                         _mVx = _mX;
 551                         _mVy = _mY;
 552                         _Vx = x;
 553                         _Vy = y;
 554                         sgCopyVec4(_quat,curGuiQuat);
 555                         x = MOUSE_XSIZE/2;
 556                         y = MOUSE_YSIZE/2;
 557                         Quat0();
 558                         _view_offset = get_goal_view_offset();
 559                         set_goal_view_offset(0.0);
 560                         set_goal_view_tilt(0.0);
 561 #ifdef NO_SMOOTH_MOUSE_VIEW
 562                         set_view_offset(0.0);
 563                         set_view_tilt(0.0);
 564 #endif
 565                     }
 566                     glutWarpPointer( x , y);
 567                     build_rotmatrix(GuiQuat_mat, curGuiQuat);
 568                     _mVtoggle = ~_mVtoggle;
 569                     break;
 570             }
 571         } else if ( button == GLUT_RIGHT_BUTTON) {
 572             switch (mouse_mode) {
 573
 574                 case MOUSE_POINTER:
 575                     SG_LOG( SG_INPUT, SG_INFO, "Mouse in yoke mode" );
 576
 577                     mouse_mode = MOUSE_YOKE;
 578                     mouse_joystick_control = 0;
 579                     _savedX = x;
 580                     _savedY = y;
 581                     // start with zero point in center of screen
 582                     _mX = MOUSE_XSIZE/2;
 583                     _mY = MOUSE_YSIZE/2;
 584
 585                     // try to have the MOUSE_YOKE position
 586                     // reflect the current stick position
 587                     x = _mX - (int)(get_aileron() * aileron_sensitivity);
 588                     y = _mY - (int)(get_elevator() * elevator_sensitivity);
 589
 590                     glutSetCursor(GLUT_CURSOR_CROSSHAIR);
 591                     break;
 592
 593                 case MOUSE_YOKE:
 594                     SG_LOG( SG_INPUT, SG_INFO, "Mouse in view mode" );
 595
 596                     mouse_mode = MOUSE_VIEW;
 597                     fgSetString("/sim/control-mode", "joystick");
 598
 599                                         // recenter cursor and reset
 600                     x = MOUSE_XSIZE/2;
 601                     y = MOUSE_YSIZE/2;
 602                     _mVtoggle = 0;
 603 // #ifndef RESET_VIEW_ON_LEAVING_MOUSE_VIEW
 604                     Quat0();
 605                     build_rotmatrix(GuiQuat_mat, curGuiQuat);
 606 // #endif
 607                     glutSetCursor(GLUT_CURSOR_LEFT_RIGHT);
 608                     break;
 609
 610                 case MOUSE_VIEW:
 611                     SG_LOG( SG_INPUT, SG_INFO, "Mouse in pointer mode" );
 612
 613                     mouse_mode = MOUSE_POINTER;
 614                     x = _savedX;
 615                     y = _savedY;
 616 #ifdef RESET_VIEW_ON_LEAVING_MOUSE_VIEW
 617                     Quat0();
 618                     build_rotmatrix(GuiQuat_mat, curGuiQuat);
 619                     set_goal_view_offset(0.0);
 620                     set_goal_view_tilt(0.0);
 621 #ifdef NO_SMOOTH_MOUSE_VIEW
 622                     set_view_offset(0.0);
 623                     set_view_tilt(0.0);
 624 #endif // NO_SMOOTH_MOUSE_VIEW
 625 #endif // RESET_VIEW_ON_LEAVING_MOUSE_VIEW
 626                     glutSetCursor(GLUT_CURSOR_INHERIT);
 627
 628 #if defined(FG_OLD_MENU)
 629 #if defined(WIN32_CURSOR_TWEAKS_OFF)
 630                     if(!gui_menu_on)
 631                         TurnCursorOff();
 632 #endif // WIN32_CURSOR_TWEAKS_OFF
 633 #endif // FG_OLD_MENU
 634                     break;
 635             } // end switch (mouse_mode)
 636             glutWarpPointer( x, y );
 637         } // END RIGHT BUTTON
 638     } // END UPDOWN == GLUT_DOWN
 639
 640     // Note which button is pressed.
 641     if ( updown == GLUT_DOWN ) {
 642         last_buttons |=  ( 1 << button ) ;
 643     } else {
 644         last_buttons &= ~( 1 << button ) ;
 645     }
 646
 647     // If we're in pointer mode, let PUI
 648     // know what's going on.
 649     if (mouse_mode == MOUSE_POINTER) {
 650       if (!puMouse (button, updown, x,y)) {
 651         if ( globals->get_current_panel() != NULL ) {
 652           globals->get_current_panel()->doMouseAction(button, updown, x, y);
 653         }
 654       }
 655     }
 656
 657     // Register the new position (if it
 658     // hasn't been registered already).
 659     _mX = x;
 660     _mY = y;
 661
 662     glutPostRedisplay ();
 663 }
 664
 665
 666
 667