source: git/src/guicontrol.cc @ af50685

line_contentsstereotravis-osx
Last change on this file since af50685 was af50685, checked in by Olly Betts <olly@…>, 5 years ago

lib/survex.pot,src/: Add "Colour by Length".

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