source: git/src/guicontrol.cc@ 6fc8577

main stereo-2025 warn-only-for-hanging-survey
Last change on this file since 6fc8577 was 4c83f84, checked in by Olly Betts <olly@…>, 2 years ago

Don't check HAVE_CONFIG_H in most cases

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