src/guicontrol.cc

   1 //
   2 //  guicontrol.cc
   3 //
   4 //  Handlers for events relating to the display of a survey.
   5 //
   6 //  Copyright (C) 2000-2002,2005 Mark R. Shinwell
   7 //  Copyright (C) 2001,2003,2004,2005,2006,2011,2012,2014,2015,2016 Olly Betts
   8 //
   9 //  This program is free software; you can redistribute it and/or modify
  10 //  it under the terms of the GNU General Public License as published by
  11 //  the Free Software Foundation; either version 2 of the License, or
  12 //  (at your option) any later version.
  13 //
  14 //  This program is distributed in the hope that it will be useful,
  15 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 //  GNU 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  22 //
  23
  24 #include <config.h>
  25
  26 #include "guicontrol.h"
  27 #include "gfxcore.h"
  28 #include <wx/confbase.h>
  29
  30 const int DISPLAY_SHIFT = 10;
  31 const double FLYFREE_SHIFT = 0.2;
  32 const double ROTATE_STEP = 2.0;
  33
  34 void GUIControl::SetView(GfxCore* view)
  35 {
  36     m_View = view;
  37 }
  38
  39 bool GUIControl::MouseDown() const
  40 {
  41     return (dragging != NO_DRAG);
  42 }
  43
  44 void GUIControl::HandleTilt(wxPoint point)
  45 {
  46     // Handle a mouse movement during tilt mode.
  47
  48     // wxGTK (at least) fails to update the cursor while dragging.
  49     m_View->UpdateCursor(GfxCore::CURSOR_ROTATE_VERTICALLY);
  50
  51     int dy = point.y - m_DragStart.y;
  52
  53     if (m_ReverseControls != m_View->GetPerspective()) dy = -dy;
  54
  55     m_View->TiltCave(dy * 0.36);
  56
  57     m_DragStart = point;
  58
  59     m_View->ForceRefresh();
  60 }
  61
  62 void GUIControl::HandleTranslate(wxPoint point)
  63 {
  64     // Handle a mouse movement during translation mode.
  65
  66     // wxGTK (at least) fails to update the cursor while dragging.
  67     m_View->UpdateCursor(GfxCore::CURSOR_DRAGGING_HAND);
  68
  69     int dx = point.x - m_DragStart.x;
  70     int dy = point.y - m_DragStart.y;
  71
  72     if (m_ReverseControls) {
  73         dx = -dx;
  74         dy = -dy;
  75     }
  76
  77     if (m_View->GetPerspective())
  78         m_View->MoveViewer(0, -dy * .1, dx * .1);
  79     else
  80         m_View->TranslateCave(dx, dy);
  81
  82     m_DragStart = point;
  83 }
  84
  85 void GUIControl::HandleScaleRotate(wxPoint point)
  86 {
  87     // Handle a mouse movement during scale/rotate mode.
  88
  89     // wxGTK (at least) fails to update the cursor while dragging.
  90     m_View->UpdateCursor(GfxCore::CURSOR_ZOOM_ROTATE);
  91
  92     int dx, dy;
  93     int threshold;
  94     if (m_ScaleRotateLock == lock_NONE) {
  95         // Dragging to scale or rotate but we've not decided which yet.
  96         dx = point.x - m_DragRealStart.x;
  97         dy = point.y - m_DragRealStart.y;
  98         threshold = 8 * 8;
  99     } else {
 100         dx = point.x - m_DragStart.x;
 101         dy = point.y - m_DragStart.y;
 102         threshold = 5;
 103     }
 104     int dx2 = dx * dx;
 105     int dy2 = dy * dy;
 106     if (dx2 + dy2 < threshold) return;
 107
 108     switch (m_ScaleRotateLock) {
 109         case lock_NONE:
 110             if (dx2 > dy2) {
 111                 m_ScaleRotateLock = lock_ROTATE;
 112 //              m_View->UpdateCursor(GfxCore::CURSOR_ROTATE_HORIZONTALLY);
 113             } else {
 114                 m_ScaleRotateLock = lock_SCALE;
 115 //              m_View->UpdateCursor(GfxCore::CURSOR_ZOOM);
 116             }
 117             break;
 118         case lock_SCALE:
 119             if (dx2 >= 8 * dy2) {
 120                 m_ScaleRotateLock = lock_ROTATE;
 121 //              m_View->UpdateCursor(GfxCore::CURSOR_ROTATE_HORIZONTALLY);
 122             }
 123             break;
 124         case lock_ROTATE:
 125             if (dy2 >= 8 * dx2) {
 126                 m_ScaleRotateLock = lock_SCALE;
 127 //              m_View->UpdateCursor(GfxCore::CURSOR_ZOOM);
 128             }
 129             break;
 130     }
 131
 132     if (m_ScaleRotateLock == lock_ROTATE) {
 133         dy = 0;
 134     } else {
 135         dx = 0;
 136     }
 137
 138     if (m_ReverseControls) {
 139         dx = -dx;
 140         dy = -dy;
 141     }
 142
 143     if (m_View->GetPerspective()) {
 144         if (dy) m_View->MoveViewer(-dy * .1, 0, 0);
 145     } else {
 146         // up/down => scale.
 147         if (dy) m_View->SetScale(m_View->GetScale() * pow(1.06, 0.08 * dy));
 148         // left/right => rotate.
 149         if (dx) m_View->TurnCave(dx * -0.36);
 150         if (dx || dy) m_View->ForceRefresh();
 151     }
 152
 153     m_DragStart = point;
 154 }
 155
 156 void GUIControl::HandleTiltRotate(wxPoint point)
 157 {
 158     // Handle a mouse movement during tilt/rotate mode.
 159     if (m_View->IsExtendedElevation()) return;
 160
 161     // wxGTK (at least) fails to update the cursor while dragging.
 162     m_View->UpdateCursor(GfxCore::CURSOR_ROTATE_EITHER_WAY);
 163
 164     int dx = point.x - m_DragStart.x;
 165     int dy = point.y - m_DragStart.y;
 166
 167     if (m_ReverseControls != m_View->GetPerspective()) {
 168         dx = -dx;
 169         dy = -dy;
 170     }
 171
 172     // left/right => rotate, up/down => tilt.
 173     // Make tilt less sensitive than rotate as that feels better.
 174     m_View->TurnCave(dx * -0.36);
 175     m_View->TiltCave(dy * 0.18);
 176
 177     m_View->ForceRefresh();
 178
 179     m_DragStart = point;
 180 }
 181
 182 void GUIControl::HandleRotate(wxPoint point)
 183 {
 184     // Handle a mouse movement during rotate mode.
 185     if (m_View->IsExtendedElevation()) return;
 186
 187     // wxGTK (at least) fails to update the cursor while dragging.
 188     m_View->UpdateCursor(GfxCore::CURSOR_ROTATE_HORIZONTALLY);
 189
 190     int dx = point.x - m_DragStart.x;
 191     int dy = point.y - m_DragStart.y;
 192
 193     if (m_ReverseControls != m_View->GetPerspective()) {
 194         dx = -dx;
 195         dy = -dy;
 196     }
 197
 198     // left/right => rotate.
 199     m_View->TurnCave(dx * -0.36);
 200
 201     m_View->ForceRefresh();
 202
 203     m_DragStart = point;
 204 }
 205
 206 void GUIControl::RestoreCursor()
 207 {
 208     if (m_View->HereIsReal()) {
 209         m_View->UpdateCursor(GfxCore::CURSOR_POINTING_HAND);
 210     } else {
 211         m_View->UpdateCursor(GfxCore::CURSOR_DEFAULT);
 212     }
 213 }
 214
 215 void GUIControl::HandleNonDrag(const wxPoint & point) {
 216     if (m_View->IsFullScreen()) {
 217         if (m_View->FullScreenModeShowingMenus()) {
 218             if (point.y > 8)
 219                 m_View->FullScreenModeShowMenus(false);
 220         } else {
 221             if (point.y == 0) {
 222                 m_View->FullScreenModeShowMenus(true);
 223             }
 224         }
 225     }
 226     if (m_View->CheckHitTestGrid(point, false)) {
 227         m_View->UpdateCursor(GfxCore::CURSOR_POINTING_HAND);
 228     } else if (m_View->PointWithinScaleBar(point)) {
 229         m_View->UpdateCursor(GfxCore::CURSOR_HORIZONTAL_RESIZE);
 230     } else if (m_View->PointWithinCompass(point)) {
 231         m_View->UpdateCursor(GfxCore::CURSOR_ROTATE_HORIZONTALLY);
 232     } else if (m_View->PointWithinClino(point)) {
 233         m_View->UpdateCursor(GfxCore::CURSOR_ROTATE_VERTICALLY);
 234     } else {
 235         RestoreCursor();
 236     }
 237 }
 238
 239 //
 240 //  Mouse event handling methods
 241 //
 242
 243 void GUIControl::OnMouseMove(wxMouseEvent& event)
 244 {
 245     // Mouse motion event handler.
 246     if (!m_View->HasData()) return;
 247
 248     // Ignore moves which don't change the position.
 249     if (event.GetPosition() == m_DragStart) {
 250         return;
 251     }
 252
 253     static long timestamp = LONG_MIN;
 254     if (dragging != NO_DRAG && m_ScaleRotateLock != lock_NONE &&
 255         timestamp != LONG_MIN) {
 256         // If no motion for a second, reset the direction lock.
 257         if (event.GetTimestamp() - timestamp >= 1000) {
 258             m_ScaleRotateLock = lock_NONE;
 259             m_DragRealStart = m_DragStart;
 260             RestoreCursor();
 261         }
 262     }
 263     timestamp = event.GetTimestamp();
 264
 265     wxPoint point(event.GetPosition());
 266
 267     // Check hit-test grid (only if no buttons are pressed).
 268     if (!event.LeftIsDown() && !event.MiddleIsDown() && !event.RightIsDown()) {
 269         HandleNonDrag(point);
 270     }
 271
 272     // Update coordinate display if in plan view,
 273     // or altitude if in elevation view.
 274     m_View->SetCoords(point);
 275
 276     switch (dragging) {
 277         case LEFT_DRAG:
 278             switch (m_LastDrag) {
 279                 case drag_COMPASS:
 280                     // Drag in heading indicator.
 281                     m_View->SetCompassFromPoint(point);
 282                     break;
 283                 case drag_ELEV:
 284                     // Drag in clinometer.
 285                     m_View->SetClinoFromPoint(point);
 286                     break;
 287                 case drag_SCALE:
 288                     m_View->SetScaleBarFromOffset(point.x - m_DragLast.x);
 289                     break;
 290                 case drag_MAIN:
 291                     if (event.ControlDown()) {
 292                         HandleTiltRotate(point);
 293                     } else {
 294                         HandleScaleRotate(point);
 295                     }
 296                     break;
 297                 case drag_ZOOM:
 298                     m_View->SetZoomBox(m_DragStart, point, !event.ShiftDown(), event.ControlDown());
 299                     break;
 300                 case drag_NONE:
 301                     // Shouldn't happen?!  FIXME: assert or something.
 302                     break;
 303             }
 304             break;
 305         case MIDDLE_DRAG:
 306             HandleTilt(point);
 307             break;
 308         case RIGHT_DRAG:
 309             HandleTranslate(point);
 310             break;
 311         case NO_DRAG:
 312             break;
 313     }
 314
 315     m_DragLast = point;
 316 }
 317
 318 void GUIControl::OnLButtonDown(wxMouseEvent& event)
 319 {
 320     if (m_View->HasData()) {
 321         m_DragStart = m_DragRealStart = event.GetPosition();
 322
 323         if (m_View->PointWithinCompass(m_DragStart)) {
 324             m_LastDrag = drag_COMPASS;
 325             m_View->UpdateCursor(GfxCore::CURSOR_ROTATE_HORIZONTALLY);
 326         } else if (m_View->PointWithinClino(m_DragStart)) {
 327             m_LastDrag = drag_ELEV;
 328             m_View->UpdateCursor(GfxCore::CURSOR_ROTATE_VERTICALLY);
 329         } else if (m_View->PointWithinScaleBar(m_DragStart)) {
 330             m_LastDrag = drag_SCALE;
 331             m_View->UpdateCursor(GfxCore::CURSOR_HORIZONTAL_RESIZE);
 332         } else if (event.ShiftDown()) {
 333             m_LastDrag = drag_ZOOM;
 334             m_View->UpdateCursor(GfxCore::CURSOR_ZOOM);
 335         } else {
 336             if (event.ControlDown() && !m_View->IsExtendedElevation()) {
 337                 m_View->UpdateCursor(GfxCore::CURSOR_ROTATE_EITHER_WAY);
 338             } else {
 339                 m_View->UpdateCursor(GfxCore::CURSOR_ZOOM_ROTATE);
 340             }
 341
 342             m_LastDrag = drag_MAIN;
 343             m_ScaleRotateLock = lock_NONE;
 344         }
 345
 346         // We need to release and recapture for the cursor to update (noticed
 347         // with wxGTK).
 348         if (dragging != NO_DRAG) m_View->ReleaseMouse();
 349         m_View->CaptureMouse();
 350
 351         dragging = LEFT_DRAG;
 352     }
 353 }
 354
 355 void GUIControl::OnLButtonUp(wxMouseEvent& event)
 356 {
 357     if (m_View->HasData()) {
 358         if (dragging != LEFT_DRAG)
 359             return;
 360
 361         if (event.MiddleIsDown()) {
 362             if (m_LastDrag == drag_ZOOM)
 363                 m_View->UnsetZoomBox();
 364             OnMButtonDown(event);
 365             return;
 366         }
 367
 368         if (event.RightIsDown()) {
 369             if (m_LastDrag == drag_ZOOM)
 370                 m_View->UnsetZoomBox();
 371             OnRButtonDown(event);
 372             return;
 373         }
 374
 375         if (m_LastDrag == drag_ZOOM) {
 376             m_View->ZoomBoxGo();
 377         }
 378
 379         m_View->ReleaseMouse();
 380
 381         m_LastDrag = drag_NONE;
 382         dragging = NO_DRAG;
 383
 384         m_View->DragFinished();
 385
 386         if (event.GetPosition() == m_DragRealStart) {
 387             // Just a "click"...
 388             m_View->CheckHitTestGrid(m_DragStart, true);
 389             RestoreCursor();
 390         } else {
 391             HandleNonDrag(event.GetPosition());
 392         }
 393     }
 394 }
 395
 396 void GUIControl::OnMButtonDown(wxMouseEvent& event)
 397 {
 398     if (m_View->HasData() && !m_View->IsExtendedElevation()) {
 399         m_DragStart = event.GetPosition();
 400
 401         m_View->UpdateCursor(GfxCore::CURSOR_ROTATE_VERTICALLY);
 402
 403         if (dragging != NO_DRAG) {
 404             if (m_LastDrag == drag_ZOOM)
 405                 m_View->UnsetZoomBox();
 406             // We need to release and recapture for the cursor to update
 407             // (noticed with wxGTK).
 408             m_View->ReleaseMouse();
 409         }
 410         m_View->CaptureMouse();
 411         dragging = MIDDLE_DRAG;
 412     }
 413 }
 414
 415 void GUIControl::OnMButtonUp(wxMouseEvent& event)
 416 {
 417     if (m_View->HasData()) {
 418         if (dragging != MIDDLE_DRAG)
 419             return;
 420
 421         if (event.LeftIsDown()) {
 422             OnLButtonDown(event);
 423             return;
 424         }
 425
 426         if (event.RightIsDown()) {
 427             OnRButtonDown(event);
 428             return;
 429         }
 430
 431         dragging = NO_DRAG;
 432         m_View->ReleaseMouse();
 433         m_View->DragFinished();
 434
 435         RestoreCursor();
 436     }
 437 }
 438
 439 void GUIControl::OnRButtonDown(wxMouseEvent& event)
 440 {
 441     if (m_View->HasData()) {
 442         if (dragging != NO_DRAG) {
 443             if (m_LastDrag == drag_ZOOM)
 444                 m_View->UnsetZoomBox();
 445             // We need to release and recapture for the cursor to update
 446             // (noticed with wxGTK).
 447             m_View->ReleaseMouse();
 448             dragging = NO_DRAG;
 449         }
 450
 451         if (m_View->HandleRClick(event.GetPosition()))
 452             return;
 453
 454         m_DragStart = event.GetPosition();
 455
 456         m_View->UpdateCursor(GfxCore::CURSOR_DRAGGING_HAND);
 457
 458         m_View->CaptureMouse();
 459         dragging = RIGHT_DRAG;
 460     }
 461 }
 462
 463 void GUIControl::OnRButtonUp(wxMouseEvent& event)
 464 {
 465     if (dragging != RIGHT_DRAG)
 466         return;
 467
 468     if (event.LeftIsDown()) {
 469         OnLButtonDown(event);
 470         return;
 471     }
 472
 473     if (event.MiddleIsDown()) {
 474         OnMButtonDown(event);
 475         return;
 476     }
 477
 478     m_LastDrag = drag_NONE;
 479     m_View->ReleaseMouse();
 480
 481     dragging = NO_DRAG;
 482
 483     RestoreCursor();
 484
 485     m_View->DragFinished();
 486 }
 487
 488 void GUIControl::OnMouseWheel(wxMouseEvent& event) {
 489     int dy = event.GetWheelRotation();
 490     if (m_View->GetPerspective()) {
 491         m_View->MoveViewer(-dy, 0, 0);
 492     } else {
 493         m_View->SetScale(m_View->GetScale() * pow(1.06, -0.04 * dy));
 494         m_View->ForceRefresh();
 495     }
 496 }
 497
 498 void GUIControl::OnDisplayOverlappingNames()
 499 {
 500     m_View->ToggleOverlappingNames();
 501 }
 502
 503 void GUIControl::OnDisplayOverlappingNamesUpdate(wxUpdateUIEvent& cmd)
 504 {
 505     cmd.Enable(m_View->HasData() && m_View->ShowingStationNames());
 506     cmd.Check(m_View->ShowingOverlappingNames());
 507 }
 508
 509 void GUIControl::OnColourByDepth()
 510 {
 511     if (m_View->ColouringBy() == COLOUR_BY_DEPTH) {
 512         m_View->SetColourBy(COLOUR_BY_NONE);
 513     } else {
 514         m_View->SetColourBy(COLOUR_BY_DEPTH);
 515     }
 516 }
 517
 518 void GUIControl::OnColourByDate()
 519 {
 520     if (m_View->ColouringBy() == COLOUR_BY_DATE) {
 521         m_View->SetColourBy(COLOUR_BY_NONE);
 522     } else {
 523         m_View->SetColourBy(COLOUR_BY_DATE);
 524     }
 525 }
 526
 527 void GUIControl::OnColourByError()
 528 {
 529     if (m_View->ColouringBy() == COLOUR_BY_ERROR) {
 530         m_View->SetColourBy(COLOUR_BY_NONE);
 531     } else {
 532         m_View->SetColourBy(COLOUR_BY_ERROR);
 533     }
 534 }
 535
 536 void GUIControl::OnColourByHError()
 537 {
 538     if (m_View->ColouringBy() == COLOUR_BY_H_ERROR) {
 539         m_View->SetColourBy(COLOUR_BY_NONE);
 540     } else {
 541         m_View->SetColourBy(COLOUR_BY_H_ERROR);
 542     }
 543 }
 544
 545 void GUIControl::OnColourByVError()
 546 {
 547     if (m_View->ColouringBy() == COLOUR_BY_V_ERROR) {
 548         m_View->SetColourBy(COLOUR_BY_NONE);
 549     } else {
 550         m_View->SetColourBy(COLOUR_BY_V_ERROR);
 551     }
 552 }
 553
 554 void GUIControl::OnColourByGradient()
 555 {
 556     if (m_View->ColouringBy() == COLOUR_BY_GRADIENT) {
 557         m_View->SetColourBy(COLOUR_BY_NONE);
 558     } else {
 559         m_View->SetColourBy(COLOUR_BY_GRADIENT);
 560     }
 561 }
 562
 563 void GUIControl::OnColourByLength()
 564 {
 565     if (m_View->ColouringBy() == COLOUR_BY_LENGTH) {
 566         m_View->SetColourBy(COLOUR_BY_NONE);
 567     } else {
 568         m_View->SetColourBy(COLOUR_BY_LENGTH);
 569     }
 570 }
 571
 572 void GUIControl::OnColourBySurvey()
 573 {
 574     if (m_View->ColouringBy() == COLOUR_BY_SURVEY) {
 575         m_View->SetColourBy(COLOUR_BY_NONE);
 576     } else {
 577         m_View->SetColourBy(COLOUR_BY_SURVEY);
 578     }
 579 }
 580
 581 void GUIControl::OnColourByStyle()
 582 {
 583     if (m_View->ColouringBy() == COLOUR_BY_STYLE) {
 584         m_View->SetColourBy(COLOUR_BY_NONE);
 585     } else {
 586         m_View->SetColourBy(COLOUR_BY_STYLE);
 587     }
 588 }
 589
 590 void GUIControl::OnColourByUpdate(wxUpdateUIEvent& cmd)
 591 {
 592     cmd.Enable(m_View->HasData());
 593 }
 594
 595 void GUIControl::OnColourByDepthUpdate(wxUpdateUIEvent& cmd)
 596 {
 597     cmd.Enable(m_View->HasData());
 598     cmd.Check(m_View->ColouringBy() == COLOUR_BY_DEPTH);
 599 }
 600
 601 void GUIControl::OnColourByDateUpdate(wxUpdateUIEvent& cmd)
 602 {
 603     cmd.Enable(m_View->HasData());
 604     cmd.Check(m_View->ColouringBy() == COLOUR_BY_DATE);
 605 }
 606
 607 void GUIControl::OnColourByErrorUpdate(wxUpdateUIEvent& cmd)
 608 {
 609     cmd.Enable(m_View->HasData());
 610     cmd.Check(m_View->ColouringBy() == COLOUR_BY_ERROR);
 611 }
 612
 613 void GUIControl::OnColourByHErrorUpdate(wxUpdateUIEvent& cmd)
 614 {
 615     cmd.Enable(m_View->HasData());
 616     cmd.Check(m_View->ColouringBy() == COLOUR_BY_H_ERROR);
 617 }
 618
 619 void GUIControl::OnColourByVErrorUpdate(wxUpdateUIEvent& cmd)
 620 {
 621     cmd.Enable(m_View->HasData());
 622     cmd.Check(m_View->ColouringBy() == COLOUR_BY_V_ERROR);
 623 }
 624
 625 void GUIControl::OnColourByGradientUpdate(wxUpdateUIEvent& cmd)
 626 {
 627     cmd.Enable(m_View->HasData());
 628     cmd.Check(m_View->ColouringBy() == COLOUR_BY_GRADIENT);
 629 }
 630
 631 void GUIControl::OnColourByLengthUpdate(wxUpdateUIEvent& cmd)
 632 {
 633     cmd.Enable(m_View->HasData());
 634     cmd.Check(m_View->ColouringBy() == COLOUR_BY_LENGTH);
 635 }
 636
 637 void GUIControl::OnColourBySurveyUpdate(wxUpdateUIEvent& cmd)
 638 {
 639     cmd.Enable(m_View->HasData());
 640     cmd.Check(m_View->ColouringBy() == COLOUR_BY_SURVEY);
 641 }
 642
 643 void GUIControl::OnColourByStyleUpdate(wxUpdateUIEvent& cmd)
 644 {
 645     cmd.Enable(m_View->HasData());
 646     cmd.Check(m_View->ColouringBy() == COLOUR_BY_STYLE);
 647 }
 648
 649 void GUIControl::OnShowCrosses()
 650 {
 651     m_View->ToggleCrosses();
 652 }
 653
 654 void GUIControl::OnShowCrossesUpdate(wxUpdateUIEvent& cmd)
 655 {
 656     cmd.Enable(m_View->HasData());
 657     cmd.Check(m_View->ShowingCrosses());
 658 }
 659
 660 void GUIControl::OnShowStationNames()
 661 {
 662     m_View->ToggleStationNames();
 663 }
 664
 665 void GUIControl::OnShowStationNamesUpdate(wxUpdateUIEvent& cmd)
 666 {
 667     cmd.Enable(m_View->HasData());
 668     cmd.Check(m_View->ShowingStationNames());
 669 }
 670
 671 void GUIControl::OnShowSurveyLegs()
 672 {
 673     m_View->ToggleUndergroundLegs();
 674 }
 675
 676 void GUIControl::OnShowSurveyLegsUpdate(wxUpdateUIEvent& cmd)
 677 {
 678     cmd.Enable(m_View->HasData() && m_View->HasUndergroundLegs());
 679     cmd.Check(m_View->ShowingUndergroundLegs());
 680 }
 681
 682 void GUIControl::OnHideSplays()
 683 {
 684     m_View->SetSplaysMode(SHOW_HIDE);
 685 }
 686
 687 void GUIControl::OnShowSplaysDashed()
 688 {
 689     m_View->SetSplaysMode(SHOW_DASHED);
 690 }
 691
 692 void GUIControl::OnShowSplaysFaded()
 693 {
 694     m_View->SetSplaysMode(SHOW_FADED);
 695 }
 696
 697 void GUIControl::OnShowSplaysNormal()
 698 {
 699     m_View->SetSplaysMode(SHOW_NORMAL);
 700 }
 701
 702 void GUIControl::OnSplaysUpdate(wxUpdateUIEvent& cmd)
 703 {
 704     cmd.Enable(m_View->HasData() && m_View->HasSplays());
 705 }
 706
 707 void GUIControl::OnHideSplaysUpdate(wxUpdateUIEvent& cmd)
 708 {
 709     cmd.Enable(m_View->HasData() && m_View->HasSplays());
 710     cmd.Check(m_View->ShowingSplaysMode() == SHOW_HIDE);
 711 }
 712
 713 void GUIControl::OnShowSplaysDashedUpdate(wxUpdateUIEvent& cmd)
 714 {
 715     cmd.Enable(m_View->HasData() && m_View->HasSplays());
 716     cmd.Check(m_View->ShowingSplaysMode() == SHOW_DASHED);
 717 }
 718
 719 void GUIControl::OnShowSplaysFadedUpdate(wxUpdateUIEvent& cmd)
 720 {
 721     cmd.Enable(m_View->HasData() && m_View->HasSplays());
 722     cmd.Check(m_View->ShowingSplaysMode() == SHOW_FADED);
 723 }
 724
 725 void GUIControl::OnShowSplaysNormalUpdate(wxUpdateUIEvent& cmd)
 726 {
 727     cmd.Enable(m_View->HasData() && m_View->HasSplays());
 728     cmd.Check(m_View->ShowingSplaysMode() == SHOW_NORMAL);
 729 }
 730
 731 void GUIControl::OnHideDupes() {
 732     m_View->SetDupesMode(SHOW_HIDE);
 733 }
 734
 735 void GUIControl::OnShowDupesDashed() {
 736     m_View->SetDupesMode(SHOW_DASHED);
 737 }
 738
 739 void GUIControl::OnShowDupesFaded() {
 740     m_View->SetDupesMode(SHOW_FADED);
 741 }
 742
 743 void GUIControl::OnShowDupesNormal() {
 744     m_View->SetDupesMode(SHOW_NORMAL);
 745 }
 746
 747 void GUIControl::OnDupesUpdate(wxUpdateUIEvent& cmd) {
 748     cmd.Enable(m_View->HasData() && m_View->HasDupes());
 749 }
 750
 751 void GUIControl::OnHideDupesUpdate(wxUpdateUIEvent& cmd) {
 752     cmd.Enable(m_View->HasData() && m_View->HasDupes());
 753     cmd.Check(m_View->ShowingDupesMode() == SHOW_HIDE);
 754 }
 755
 756 void GUIControl::OnShowDupesDashedUpdate(wxUpdateUIEvent& cmd) {
 757     cmd.Enable(m_View->HasData() && m_View->HasDupes());
 758     cmd.Check(m_View->ShowingDupesMode() == SHOW_DASHED);
 759 }
 760
 761 void GUIControl::OnShowDupesFadedUpdate(wxUpdateUIEvent& cmd) {
 762     cmd.Enable(m_View->HasData() && m_View->HasDupes());
 763     cmd.Check(m_View->ShowingDupesMode() == SHOW_FADED);
 764 }
 765
 766 void GUIControl::OnShowDupesNormalUpdate(wxUpdateUIEvent& cmd) {
 767     cmd.Enable(m_View->HasData() && m_View->HasDupes());
 768     cmd.Check(m_View->ShowingDupesMode() == SHOW_NORMAL);
 769 }
 770
 771 void GUIControl::OnMoveEast()
 772 {
 773     m_View->TurnCaveTo(90.0);
 774     m_View->ForceRefresh();
 775 }
 776
 777 void GUIControl::OnMoveEastUpdate(wxUpdateUIEvent& cmd)
 778 {
 779     cmd.Enable(m_View->HasData() && !m_View->IsExtendedElevation() && m_View->GetCompassValue() != 90.0);
 780 }
 781
 782 void GUIControl::OnMoveNorth()
 783 {
 784     m_View->TurnCaveTo(0.0);
 785     m_View->ForceRefresh();
 786 }
 787
 788 void GUIControl::OnMoveNorthUpdate(wxUpdateUIEvent& cmd)
 789 {
 790     cmd.Enable(m_View->HasData() && m_View->GetCompassValue() != 0.0);
 791 }
 792
 793 void GUIControl::OnMoveSouth()
 794 {
 795     m_View->TurnCaveTo(180.0);
 796     m_View->ForceRefresh();
 797 }
 798
 799 void GUIControl::OnMoveSouthUpdate(wxUpdateUIEvent& cmd)
 800 {
 801     cmd.Enable(m_View->HasData() && m_View->GetCompassValue() != 180.0);
 802 }
 803
 804 void GUIControl::OnMoveWest()
 805 {
 806     m_View->TurnCaveTo(270.0);
 807     m_View->ForceRefresh();
 808 }
 809
 810 void GUIControl::OnMoveWestUpdate(wxUpdateUIEvent& cmd)
 811 {
 812     cmd.Enable(m_View->HasData() && !m_View->IsExtendedElevation() && m_View->GetCompassValue() != 270.0);
 813 }
 814
 815 void GUIControl::OnToggleRotation()
 816 {
 817     m_View->ToggleRotation();
 818 }
 819
 820 void GUIControl::OnToggleRotationUpdate(wxUpdateUIEvent& cmd)
 821 {
 822     cmd.Enable(m_View->HasData() && !m_View->IsExtendedElevation());
 823     cmd.Check(m_View->HasData() && m_View->IsRotating());
 824 }
 825
 826 void GUIControl::OnReverseControls()
 827 {
 828     m_ReverseControls = !m_ReverseControls;
 829 }
 830
 831 void GUIControl::OnReverseControlsUpdate(wxUpdateUIEvent& cmd)
 832 {
 833     cmd.Enable(m_View->HasData());
 834     cmd.Check(m_ReverseControls);
 835 }
 836
 837 void GUIControl::OnReverseDirectionOfRotation()
 838 {
 839     m_View->ReverseRotation();
 840 }
 841
 842 void GUIControl::OnReverseDirectionOfRotationUpdate(wxUpdateUIEvent& cmd)
 843 {
 844     cmd.Enable(m_View->HasData() && !m_View->IsExtendedElevation());
 845 }
 846
 847 void GUIControl::OnStepOnceAnticlockwise(bool accel)
 848 {
 849     if (m_View->GetPerspective()) {
 850         m_View->TurnCave(accel ? -5.0 * ROTATE_STEP : -ROTATE_STEP);
 851     } else {
 852         m_View->TurnCave(accel ? 5.0 * ROTATE_STEP : ROTATE_STEP);
 853     }
 854     m_View->ForceRefresh();
 855 }
 856
 857 void GUIControl::OnStepOnceClockwise(bool accel)
 858 {
 859     if (m_View->GetPerspective()) {
 860         m_View->TurnCave(accel ? 5.0 * ROTATE_STEP : ROTATE_STEP);
 861     } else {
 862         m_View->TurnCave(accel ? -5.0 * ROTATE_STEP : -ROTATE_STEP);
 863     }
 864     m_View->ForceRefresh();
 865 }
 866
 867 void GUIControl::OnDefaults()
 868 {
 869     m_View->Defaults();
 870 }
 871
 872 void GUIControl::OnDefaultsUpdate(wxUpdateUIEvent& cmd)
 873 {
 874     cmd.Enable(m_View->HasData());
 875 }
 876
 877 void GUIControl::OnElevation()
 878 {
 879     // Switch to elevation view.
 880
 881     m_View->SwitchToElevation();
 882 }
 883
 884 void GUIControl::OnElevationUpdate(wxUpdateUIEvent& cmd)
 885 {
 886     cmd.Enable(m_View->HasData() && !m_View->IsExtendedElevation() && !m_View->ShowingElevation());
 887 }
 888
 889 void GUIControl::OnHigherViewpoint(bool accel)
 890 {
 891     // Raise the viewpoint.
 892     if (m_View->GetPerspective()) {
 893         m_View->TiltCave(accel ? 5.0 * ROTATE_STEP : ROTATE_STEP);
 894     } else {
 895         m_View->TiltCave(accel ? -5.0 * ROTATE_STEP : -ROTATE_STEP);
 896     }
 897     m_View->ForceRefresh();
 898 }
 899
 900 void GUIControl::OnLowerViewpoint(bool accel)
 901 {
 902     // Lower the viewpoint.
 903     if (m_View->GetPerspective()) {
 904         m_View->TiltCave(accel ? -5.0 * ROTATE_STEP : -ROTATE_STEP);
 905     } else {
 906         m_View->TiltCave(accel ? 5.0 * ROTATE_STEP : ROTATE_STEP);
 907     }
 908     m_View->ForceRefresh();
 909 }
 910
 911 void GUIControl::OnPlan()
 912 {
 913     // Switch to plan view.
 914     m_View->SwitchToPlan();
 915 }
 916
 917 void GUIControl::OnPlanUpdate(wxUpdateUIEvent& cmd)
 918 {
 919     cmd.Enable(m_View->HasData() && !m_View->IsExtendedElevation() && !m_View->ShowingPlan());
 920 }
 921
 922 void GUIControl::OnShiftDisplayDown(bool accel)
 923 {
 924     if (m_View->GetPerspective())
 925         m_View->MoveViewer(0, accel ? 5 * FLYFREE_SHIFT : FLYFREE_SHIFT, 0);
 926     else
 927         m_View->TranslateCave(0, accel ? 5 * DISPLAY_SHIFT : DISPLAY_SHIFT);
 928 }
 929
 930 void GUIControl::OnShiftDisplayLeft(bool accel)
 931 {
 932     if (m_View->GetPerspective())
 933         m_View->MoveViewer(0, 0, accel ? 5 * FLYFREE_SHIFT : FLYFREE_SHIFT);
 934     else
 935         m_View->TranslateCave(accel ? -5 * DISPLAY_SHIFT : -DISPLAY_SHIFT, 0);
 936 }
 937
 938 void GUIControl::OnShiftDisplayRight(bool accel)
 939 {
 940     if (m_View->GetPerspective())
 941         m_View->MoveViewer(0, 0, accel ? -5 * FLYFREE_SHIFT : -FLYFREE_SHIFT);
 942     else
 943         m_View->TranslateCave(accel ? 5 * DISPLAY_SHIFT : DISPLAY_SHIFT, 0);
 944 }
 945
 946 void GUIControl::OnShiftDisplayUp(bool accel)
 947 {
 948     if (m_View->GetPerspective())
 949         m_View->MoveViewer(0, accel ? -5 * FLYFREE_SHIFT : -FLYFREE_SHIFT, 0);
 950     else
 951         m_View->TranslateCave(0, accel ? -5 * DISPLAY_SHIFT : -DISPLAY_SHIFT);
 952 }
 953
 954 void GUIControl::OnZoomIn(bool accel)
 955 {
 956     // Increase the scale.
 957
 958     if (m_View->GetPerspective()) {
 959         m_View->MoveViewer(accel ? 5 * FLYFREE_SHIFT : FLYFREE_SHIFT, 0, 0);
 960     } else {
 961         m_View->SetScale(m_View->GetScale() * (accel ? 1.1236 : 1.06));
 962         m_View->ForceRefresh();
 963     }
 964 }
 965
 966 void GUIControl::OnZoomOut(bool accel)
 967 {
 968     // Decrease the scale.
 969
 970     if (m_View->GetPerspective()) {
 971         m_View->MoveViewer(accel ? -5 * FLYFREE_SHIFT : -FLYFREE_SHIFT, 0, 0);
 972     } else {
 973         m_View->SetScale(m_View->GetScale() / (accel ? 1.1236 : 1.06));
 974         m_View->ForceRefresh();
 975     }
 976 }
 977
 978 void GUIControl::OnToggleScalebar()
 979 {
 980     m_View->ToggleScaleBar();
 981 }
 982
 983 void GUIControl::OnToggleScalebarUpdate(wxUpdateUIEvent& cmd)
 984 {
 985     cmd.Enable(m_View->HasData());
 986     cmd.Check(m_View->ShowingScaleBar());
 987 }
 988
 989 void GUIControl::OnToggleColourKey()
 990 {
 991     m_View->ToggleColourKey();
 992 }
 993
 994 void GUIControl::OnToggleColourKeyUpdate(wxUpdateUIEvent& cmd)
 995 {
 996     cmd.Enable(m_View->HasData() && m_View->ColouringBy() != COLOUR_BY_NONE);
 997     cmd.Check(m_View->ShowingColourKey());
 998 }
 999
1000 void GUIControl::OnViewCompass()
1001 {
1002     m_View->ToggleCompass();
1003 }
1004
1005 void GUIControl::OnViewCompassUpdate(wxUpdateUIEvent& cmd)
1006 {
1007     cmd.Enable(m_View->HasData() && !m_View->IsExtendedElevation());
1008     cmd.Check(m_View->ShowingCompass());
1009 }
1010
1011 void GUIControl::OnViewClino()
1012 {
1013     m_View->ToggleClino();
1014 }
1015
1016 void GUIControl::OnViewClinoUpdate(wxUpdateUIEvent& cmd)
1017 {
1018     cmd.Enable(m_View->HasData() && !m_View->IsExtendedElevation());
1019     cmd.Check(m_View->ShowingClino());
1020 }
1021
1022 void GUIControl::OnShowSurface()
1023 {
1024     m_View->ToggleSurfaceLegs();
1025 }
1026
1027 void GUIControl::OnShowSurfaceUpdate(wxUpdateUIEvent& cmd)
1028 {
1029     cmd.Enable(m_View->HasData() && m_View->HasSurfaceLegs());
1030     cmd.Check(m_View->ShowingSurfaceLegs());
1031 }
1032
1033 void GUIControl::OnShowEntrances()
1034 {
1035     m_View->ToggleEntrances();
1036 }
1037
1038 void GUIControl::OnShowEntrancesUpdate(wxUpdateUIEvent& cmd)
1039 {
1040     cmd.Enable(m_View->HasData() && (m_View->GetNumEntrances() > 0));
1041     cmd.Check(m_View->ShowingEntrances());
1042 }
1043
1044 void GUIControl::OnShowFixedPts()
1045 {
1046     m_View->ToggleFixedPts();
1047 }
1048
1049 void GUIControl::OnShowFixedPtsUpdate(wxUpdateUIEvent& cmd)
1050 {
1051     cmd.Enable(m_View->HasData() && (m_View->GetNumFixedPts() > 0));
1052     cmd.Check(m_View->ShowingFixedPts());
1053 }
1054
1055 void GUIControl::OnShowExportedPts()
1056 {
1057     m_View->ToggleExportedPts();
1058 }
1059
1060 void GUIControl::OnShowExportedPtsUpdate(wxUpdateUIEvent& cmd)
1061 {
1062     cmd.Enable(m_View->HasData() && (m_View->GetNumExportedPts() > 0));
1063     cmd.Check(m_View->ShowingExportedPts());
1064 }
1065
1066 void GUIControl::OnViewGrid()
1067 {
1068     m_View->ToggleGrid();
1069 }
1070
1071 void GUIControl::OnViewGridUpdate(wxUpdateUIEvent& cmd)
1072 {
1073     cmd.Enable(m_View->HasData());
1074     cmd.Check(m_View->ShowingGrid());
1075 }
1076
1077 void GUIControl::OnIndicatorsUpdate(wxUpdateUIEvent& cmd)
1078 {
1079     cmd.Enable(m_View->HasData());
1080 }
1081
1082 void GUIControl::OnViewPerspective()
1083 {
1084     m_View->TogglePerspective();
1085     // Force update of coordinate display.
1086     if (m_View->GetPerspective()) {
1087         m_View->MoveViewer(0, 0, 0);
1088     } else {
1089         m_View->ClearCoords();
1090     }
1091 }
1092
1093 void GUIControl::OnViewPerspectiveUpdate(wxUpdateUIEvent& cmd)
1094 {
1095     cmd.Enable(m_View->HasData() && !m_View->IsExtendedElevation());
1096     cmd.Check(m_View->GetPerspective());
1097 }
1098
1099 void GUIControl::OnViewSmoothShading()
1100 {
1101     m_View->ToggleSmoothShading();
1102 }
1103
1104 void GUIControl::OnViewSmoothShadingUpdate(wxUpdateUIEvent& cmd)
1105 {
1106     cmd.Enable(m_View->HasData());
1107     cmd.Check(m_View->GetSmoothShading());
1108 }
1109
1110 void GUIControl::OnViewTextured()
1111 {
1112     m_View->ToggleTextured();
1113 }
1114
1115 void GUIControl::OnViewTexturedUpdate(wxUpdateUIEvent& cmd)
1116 {
1117     cmd.Enable(m_View->HasData());
1118     cmd.Check(m_View->GetTextured());
1119 }
1120
1121 void GUIControl::OnViewFog()
1122 {
1123     m_View->ToggleFog();
1124 }
1125
1126 void GUIControl::OnViewFogUpdate(wxUpdateUIEvent& cmd)
1127 {
1128     cmd.Enable(m_View->HasData());
1129     cmd.Check(m_View->GetFog());
1130 }
1131
1132 void GUIControl::OnViewSmoothLines()
1133 {
1134     m_View->ToggleAntiAlias();
1135 }
1136
1137 void GUIControl::OnViewSmoothLinesUpdate(wxUpdateUIEvent& cmd)
1138 {
1139     cmd.Enable(m_View->HasData());
1140     cmd.Check(m_View->GetAntiAlias());
1141 }
1142
1143 void GUIControl::OnToggleMetric()
1144 {
1145     m_View->ToggleMetric();
1146
1147     wxConfigBase::Get()->Write(wxT("metric"), m_View->GetMetric());
1148     wxConfigBase::Get()->Flush();
1149 }
1150
1151 void GUIControl::OnToggleMetricUpdate(wxUpdateUIEvent& cmd)
1152 {
1153     cmd.Enable(m_View->HasData());
1154     cmd.Check(m_View->GetMetric());
1155 }
1156
1157 void GUIControl::OnToggleDegrees()
1158 {
1159     m_View->ToggleDegrees();
1160
1161     wxConfigBase::Get()->Write(wxT("degrees"), m_View->GetDegrees());
1162     wxConfigBase::Get()->Flush();
1163 }
1164
1165 void GUIControl::OnToggleDegreesUpdate(wxUpdateUIEvent& cmd)
1166 {
1167     cmd.Enable(m_View->HasData());
1168     cmd.Check(m_View->GetDegrees());
1169 }
1170
1171 void GUIControl::OnTogglePercent()
1172 {
1173     m_View->TogglePercent();
1174
1175     wxConfigBase::Get()->Write(wxT("percent"), m_View->GetPercent());
1176     wxConfigBase::Get()->Flush();
1177 }
1178
1179 void GUIControl::OnTogglePercentUpdate(wxUpdateUIEvent& cmd)
1180 {
1181     cmd.Enable(m_View->HasData());
1182     cmd.Check(m_View->GetPercent());
1183 }
1184
1185 void GUIControl::OnToggleTubes()
1186 {
1187     m_View->ToggleTubes();
1188 }
1189
1190 void GUIControl::OnToggleTubesUpdate(wxUpdateUIEvent& cmd)
1191 {
1192     cmd.Enable(m_View->HasData() && m_View->HasTubes());
1193     cmd.Check(m_View->GetTubes());
1194 }
1195
1196 void GUIControl::OnCancelDistLine()
1197 {
1198     m_View->ClearTreeSelection();
1199 }
1200
1201 void GUIControl::OnCancelDistLineUpdate(wxUpdateUIEvent& cmd)
1202 {
1203     cmd.Enable(m_View->ShowingMeasuringLine());
1204 }
1205
1206 void GUIControl::OnKeyPress(wxKeyEvent &e)
1207 {
1208     if (!m_View->HasData() ||
1209         (e.GetModifiers() &~ (wxMOD_CONTROL|wxMOD_SHIFT))) {
1210         // Pass on the event if there's no survey data, or if any modifier keys
1211         // other than Ctrl and Shift are pressed.
1212         e.Skip();
1213         return;
1214     }
1215
1216     // The changelog says this is meant to keep animation going while keys are
1217     // pressed, but that happens anyway (on linux at least - perhaps it helps
1218     // on windows?)  FIXME : check!
1219     //bool refresh = m_View->Animate();
1220
1221     switch (e.GetKeyCode()) {
1222         case '/': case '?':
1223             if (m_View->CanLowerViewpoint() && !m_View->IsExtendedElevation())
1224                 OnLowerViewpoint(e.GetModifiers() == wxMOD_SHIFT);
1225             break;
1226         case '\'': case '@': case '"': // both shifted forms - US and UK kbd
1227             if (m_View->CanRaiseViewpoint() && !m_View->IsExtendedElevation())
1228                 OnHigherViewpoint(e.GetModifiers() == wxMOD_SHIFT);
1229             break;
1230         case 'C': case 'c':
1231             if (!m_View->IsExtendedElevation() && !m_View->IsRotating())
1232                 OnStepOnceAnticlockwise(e.GetModifiers() == wxMOD_SHIFT);
1233             break;
1234         case 'V': case 'v':
1235             if (!m_View->IsExtendedElevation() && !m_View->IsRotating())
1236                 OnStepOnceClockwise(e.GetModifiers() == wxMOD_SHIFT);
1237             break;
1238         case ']': case '}':
1239             OnZoomIn(e.GetModifiers() == wxMOD_SHIFT);
1240             break;
1241         case '[': case '{':
1242             OnZoomOut(e.GetModifiers() == wxMOD_SHIFT);
1243             break;
1244         case 'N': case 'n':
1245             OnMoveNorth();
1246             break;
1247         case 'S': case 's':
1248             OnMoveSouth();
1249             break;
1250         case 'E': case 'e':
1251             if (!m_View->IsExtendedElevation())
1252                 OnMoveEast();
1253             break;
1254         case 'W': case 'w':
1255             if (!m_View->IsExtendedElevation())
1256                 OnMoveWest();
1257             break;
1258         case 'Z': case 'z':
1259             if (!m_View->IsExtendedElevation())
1260                 m_View->RotateFaster(e.GetModifiers() == wxMOD_SHIFT);
1261             break;
1262         case 'X': case 'x':
1263             if (!m_View->IsExtendedElevation())
1264                 m_View->RotateSlower(e.GetModifiers() == wxMOD_SHIFT);
1265             break;
1266         case 'R': case 'r':
1267             if (!m_View->IsExtendedElevation())
1268                 OnReverseDirectionOfRotation();
1269             break;
1270         case 'P': case 'p':
1271             if (!m_View->IsExtendedElevation() && !m_View->ShowingPlan())
1272                 OnPlan();
1273             break;
1274         case 'L': case 'l':
1275             if (!m_View->IsExtendedElevation() && !m_View->ShowingElevation())
1276                 OnElevation();
1277             break;
1278         case 'O': case 'o':
1279             OnDisplayOverlappingNames();
1280             break;
1281         case WXK_DELETE:
1282             if (e.GetModifiers() == 0)
1283                 OnDefaults();
1284             break;
1285         case WXK_RETURN:
1286             if (e.GetModifiers() == 0) {
1287                 // For compatibility with older versions.
1288                 if (!m_View->IsExtendedElevation() && !m_View->IsRotating())
1289                     m_View->StartRotation();
1290             }
1291             break;
1292         case WXK_SPACE:
1293             if (e.GetModifiers() == 0) {
1294                 if (!m_View->IsExtendedElevation())
1295                     OnToggleRotation();
1296             }
1297             break;
1298         case WXK_LEFT:
1299             if ((e.GetModifiers() &~ wxMOD_SHIFT) == wxMOD_CONTROL) {
1300                 if (!m_View->IsExtendedElevation() && !m_View->IsRotating())
1301                     OnStepOnceAnticlockwise(e.GetModifiers() == wxMOD_SHIFT);
1302             } else {
1303                 OnShiftDisplayLeft(e.GetModifiers() == wxMOD_SHIFT);
1304             }
1305             break;
1306         case WXK_RIGHT:
1307             if ((e.GetModifiers() &~ wxMOD_SHIFT) == wxMOD_CONTROL) {
1308                 if (!m_View->IsExtendedElevation() && !m_View->IsRotating())
1309                     OnStepOnceClockwise(e.GetModifiers() == wxMOD_SHIFT);
1310             } else {
1311                 OnShiftDisplayRight(e.GetModifiers() == wxMOD_SHIFT);
1312             }
1313             break;
1314         case WXK_UP:
1315             if ((e.GetModifiers() &~ wxMOD_SHIFT) == wxMOD_CONTROL) {
1316                 if (m_View->CanRaiseViewpoint() && !m_View->IsExtendedElevation())
1317                     OnHigherViewpoint(e.GetModifiers() == wxMOD_SHIFT);
1318             } else {
1319                 OnShiftDisplayUp(e.GetModifiers() == wxMOD_SHIFT);
1320             }
1321             break;
1322         case WXK_DOWN:
1323             if ((e.GetModifiers() &~ wxMOD_SHIFT) == wxMOD_CONTROL) {
1324                 if (m_View->CanLowerViewpoint() && !m_View->IsExtendedElevation())
1325                     OnLowerViewpoint(e.GetModifiers() == wxMOD_SHIFT);
1326             } else {
1327                 OnShiftDisplayDown(e.GetModifiers() == wxMOD_SHIFT);
1328             }
1329             break;
1330         case WXK_ESCAPE:
1331             if (e.GetModifiers() == 0) {
1332                 if (m_View->ShowingMeasuringLine()) {
1333                     OnCancelDistLine();
1334                 } else if (m_View->IsFullScreen()) {
1335                     // Cancel full-screen mode on "Escape" if it isn't cancelling
1336                     // the measuring line.
1337                     m_View->FullScreenMode();
1338                 }
1339             }
1340             break;
1341         case WXK_F2:
1342             if (e.GetModifiers() == 0)
1343                 m_View->ToggleFatFinger();
1344             break;
1345         case WXK_F3:
1346             if (e.GetModifiers() == 0)
1347                 m_View->ToggleHitTestDebug();
1348             break;
1349         case WXK_F4: {
1350             if (e.GetModifiers() == 0) {
1351                 const wxChar * msg;
1352 #if wxDEBUG_LEVEL
1353                 if (wxTheAssertHandler)
1354                     wxTheAssertHandler = NULL;
1355                 else
1356                     wxSetDefaultAssertHandler();
1357                 if (wxTheAssertHandler)
1358                     msg = wxT("Assertions enabled");
1359                 else
1360                     msg = wxT("Assertions disabled");
1361 #else
1362                 msg = wxT("wxWidgets was built without assertions");
1363 #endif
1364                 wxMessageBox(msg, wxT("Aven Debug"), wxOK | wxICON_INFORMATION);
1365             }
1366             break;
1367         }
1368         case WXK_F5:
1369             if (e.GetModifiers() == 0) {
1370                 m_View->InvalidateAllLists();
1371                 m_View->ForceRefresh();
1372             }
1373             break;
1374         case WXK_F6:
1375             if (e.GetModifiers() == 0)
1376                 m_View->ToggleRenderStats();
1377             break;
1378         default:
1379             e.Skip();
1380     }
1381
1382     //if (refresh) m_View->ForceRefresh();
1383 }
1384
1385 void GUIControl::OnViewFullScreenUpdate(wxUpdateUIEvent& cmd)
1386 {
1387     cmd.Check(m_View->IsFullScreen());
1388 }
1389
1390 void GUIControl::OnViewFullScreen()
1391 {
1392     m_View->FullScreenMode();
1393 }
1394
1395 void GUIControl::OnViewBoundingBoxUpdate(wxUpdateUIEvent& cmd)
1396 {
1397     cmd.Enable(m_View->HasData());
1398     cmd.Check(m_View->DisplayingBoundingBox());
1399 }
1400
1401 void GUIControl::OnViewBoundingBox()
1402 {
1403     m_View->ToggleBoundingBox();
1404 }
1405
1406 void GUIControl::OnViewTerrainUpdate(wxUpdateUIEvent& cmd)
1407 {
1408     cmd.Enable(m_View->HasTerrain());
1409     cmd.Check(m_View->DisplayingTerrain());
1410 }
1411
1412 void GUIControl::OnViewTerrain()
1413 {
1414     m_View->ToggleTerrain();
1415 }