source: git/src/gfxcore.cc @ a786810

RELEASE/1.2debug-cidebug-ci-sanitisersstereowalls-data
Last change on this file since a786810 was ff1601e, checked in by Olly Betts <olly@…>, 9 years ago

src/gfxcore.cc,src/gfxcore.h: Factor out MAX_FRAMERATE.

  • Property mode set to 100644
File size: 90.4 KB
Line 
1//
2//  gfxcore.cc
3//
4//  Core drawing code for Aven.
5//
6//  Copyright (C) 2000-2003,2005,2006 Mark R. Shinwell
7//  Copyright (C) 2001-2003,2004,2005,2006,2007,2010,2011,2012,2014,2015 Olly Betts
8//  Copyright (C) 2005 Martin Green
9//
10//  This program is free software; you can redistribute it and/or modify
11//  it under the terms of the GNU General Public License as published by
12//  the Free Software Foundation; either version 2 of the License, or
13//  (at your option) any later version.
14//
15//  This program is distributed in the hope that it will be useful,
16//  but WITHOUT ANY WARRANTY; without even the implied warranty of
17//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18//  GNU General Public License for more details.
19//
20//  You should have received a copy of the GNU General Public License
21//  along with this program; if not, write to the Free Software
22//  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
23//
24
25#ifdef HAVE_CONFIG_H
26#include <config.h>
27#endif
28
29#include <assert.h>
30#include <float.h>
31
32#include "aven.h"
33#include "date.h"
34#include "gfxcore.h"
35#include "mainfrm.h"
36#include "message.h"
37#include "useful.h"
38#include "printwx.h"
39#include "guicontrol.h"
40#include "moviemaker.h"
41
42#include <wx/confbase.h>
43#include <wx/image.h>
44
45#define MAX(a, b) ((a) > (b) ? (a) : (b))
46#define MAX3(a, b, c) ((a) > (b) ? MAX(a, c) : MAX(b, c))
47
48// Values for m_SwitchingTo
49#define PLAN 1
50#define ELEVATION 2
51#define NORTH 3
52#define EAST 4
53#define SOUTH 5
54#define WEST 6
55
56// Any error value higher than this is clamped to this.
57#define MAX_ERROR 12.0
58
59// How many bins per letter height to use when working out non-overlapping
60// labels.
61const unsigned int QUANTISE_FACTOR = 2;
62
63#include "avenpal.h"
64
65static const int INDICATOR_BOX_SIZE = 60;
66static const int INDICATOR_GAP = 2;
67static const int INDICATOR_MARGIN = 5;
68static const int INDICATOR_OFFSET_X = 15;
69static const int INDICATOR_OFFSET_Y = 15;
70static const int INDICATOR_RADIUS = INDICATOR_BOX_SIZE / 2 - INDICATOR_MARGIN;
71static const int CLINO_OFFSET_X = 6 + INDICATOR_OFFSET_X +
72                                  INDICATOR_BOX_SIZE + INDICATOR_GAP;
73static const int KEY_OFFSET_X = 10;
74static const int KEY_OFFSET_Y = 10;
75static const int KEY_EXTRA_LEFT_MARGIN = 2;
76static const int KEY_BLOCK_WIDTH = 20;
77static const int KEY_BLOCK_HEIGHT = 16;
78static const int TICK_LENGTH = 4;
79static const int SCALE_BAR_OFFSET_X = 15;
80static const int SCALE_BAR_OFFSET_Y = 12;
81static const int SCALE_BAR_HEIGHT = 12;
82
83static const gla_colour TEXT_COLOUR = col_GREEN;
84static const gla_colour HERE_COLOUR = col_WHITE;
85static const gla_colour NAME_COLOUR = col_GREEN;
86static const gla_colour SEL_COLOUR = col_WHITE;
87
88// Number of entries across and down the hit-test grid:
89#define HITTEST_SIZE 20
90
91// How close the pointer needs to be to a station to be considered:
92#define MEASURE_THRESHOLD 7
93
94// vector for lighting angle
95static const Vector3 light(.577, .577, .577);
96
97BEGIN_EVENT_TABLE(GfxCore, GLACanvas)
98    EVT_PAINT(GfxCore::OnPaint)
99    EVT_LEFT_DOWN(GfxCore::OnLButtonDown)
100    EVT_LEFT_UP(GfxCore::OnLButtonUp)
101    EVT_MIDDLE_DOWN(GfxCore::OnMButtonDown)
102    EVT_MIDDLE_UP(GfxCore::OnMButtonUp)
103    EVT_RIGHT_DOWN(GfxCore::OnRButtonDown)
104    EVT_RIGHT_UP(GfxCore::OnRButtonUp)
105    EVT_MOUSEWHEEL(GfxCore::OnMouseWheel)
106    EVT_MOTION(GfxCore::OnMouseMove)
107    EVT_LEAVE_WINDOW(GfxCore::OnLeaveWindow)
108    EVT_SIZE(GfxCore::OnSize)
109    EVT_IDLE(GfxCore::OnIdle)
110    EVT_CHAR(GfxCore::OnKeyPress)
111END_EVENT_TABLE()
112
113GfxCore::GfxCore(MainFrm* parent, wxWindow* parent_win, GUIControl* control) :
114    GLACanvas(parent_win, 100),
115    m_Scale(0.0),
116    m_ScaleBarWidth(0),
117    m_Control(control),
118    m_LabelGrid(NULL),
119    m_Parent(parent),
120    m_DoneFirstShow(false),
121    m_TiltAngle(0.0),
122    m_PanAngle(0.0),
123    m_Rotating(false),
124    m_RotationStep(0.0),
125    m_SwitchingTo(0),
126    m_Crosses(false),
127    m_Legs(true),
128    m_Splays(SPLAYS_SHOW_FADED),
129    m_Names(false),
130    m_Scalebar(true),
131    m_ColourKey(true),
132    m_OverlappingNames(false),
133    m_Compass(true),
134    m_Clino(true),
135    m_Tubes(false),
136    m_ColourBy(COLOUR_BY_DEPTH),
137    m_HaveData(false),
138    m_MouseOutsideCompass(false),
139    m_MouseOutsideElev(false),
140    m_Surface(false),
141    m_Entrances(false),
142    m_FixedPts(false),
143    m_ExportedPts(false),
144    m_Grid(false),
145    m_BoundingBox(false),
146    m_Degrees(false),
147    m_Metric(false),
148    m_Percent(false),
149    m_HitTestDebug(false),
150    m_PointGrid(NULL),
151    m_HitTestGridValid(false),
152    m_here(NULL),
153    m_there(NULL),
154    presentation_mode(0),
155    pres_reverse(false),
156    pres_speed(0.0),
157    movie(NULL),
158    current_cursor(GfxCore::CURSOR_DEFAULT),
159    sqrd_measure_threshold(sqrd(MEASURE_THRESHOLD))
160{
161    AddQuad = &GfxCore::AddQuadrilateralDepth;
162    AddPoly = &GfxCore::AddPolylineDepth;
163    wxConfigBase::Get()->Read(wxT("metric"), &m_Metric, true);
164    wxConfigBase::Get()->Read(wxT("degrees"), &m_Degrees, true);
165    wxConfigBase::Get()->Read(wxT("percent"), &m_Percent, false);
166
167    for (int pen = 0; pen < NUM_COLOUR_BANDS + 1; ++pen) {
168        m_Pens[pen].SetColour(REDS[pen] / 255.0,
169                              GREENS[pen] / 255.0,
170                              BLUES[pen] / 255.0);
171    }
172
173    timer.Start();
174}
175
176GfxCore::~GfxCore()
177{
178    TryToFreeArrays();
179
180    delete[] m_PointGrid;
181}
182
183void GfxCore::TryToFreeArrays()
184{
185    // Free up any memory allocated for arrays.
186    delete[] m_LabelGrid;
187    m_LabelGrid = NULL;
188}
189
190//
191//  Initialisation methods
192//
193
194void GfxCore::Initialise(bool same_file)
195{
196    // Initialise the view from the parent holding the survey data.
197
198    TryToFreeArrays();
199
200    m_DoneFirstShow = false;
201
202    m_HitTestGridValid = false;
203    m_here = NULL;
204    m_there = NULL;
205
206    m_MouseOutsideCompass = m_MouseOutsideElev = false;
207
208    if (!same_file) {
209        // Apply default parameters unless reloading the same file.
210        DefaultParameters();
211
212        // Set the initial scale.
213        SetScale(1.0);
214    }
215
216    m_HaveData = true;
217
218    // Clear any cached OpenGL lists which depend on the data.
219    InvalidateList(LIST_SCALE_BAR);
220    InvalidateList(LIST_DEPTH_KEY);
221    InvalidateList(LIST_DATE_KEY);
222    InvalidateList(LIST_ERROR_KEY);
223    InvalidateList(LIST_UNDERGROUND_LEGS);
224    InvalidateList(LIST_TUBES);
225    InvalidateList(LIST_SURFACE_LEGS);
226    InvalidateList(LIST_BLOBS);
227    InvalidateList(LIST_CROSSES);
228    InvalidateList(LIST_GRID);
229    InvalidateList(LIST_SHADOW);
230
231    ForceRefresh();
232}
233
234void GfxCore::FirstShow()
235{
236    GLACanvas::FirstShow();
237
238    const unsigned int quantise(GetFontSize() / QUANTISE_FACTOR);
239    list<LabelInfo*>::iterator pos = m_Parent->GetLabelsNC();
240    while (pos != m_Parent->GetLabelsNCEnd()) {
241        LabelInfo* label = *pos++;
242        // Calculate and set the label width for use when plotting
243        // none-overlapping labels.
244        int ext_x;
245        GLACanvas::GetTextExtent(label->GetText(), &ext_x, NULL);
246        label->set_width(unsigned(ext_x) / quantise + 1);
247    }
248
249    // Set diameter of the viewing volume.
250    SetVolumeDiameter(sqrt(sqrd(m_Parent->GetXExtent()) +
251                           sqrd(m_Parent->GetYExtent()) +
252                           sqrd(m_Parent->GetZExtent())));
253
254    m_DoneFirstShow = true;
255}
256
257//
258//  Recalculating methods
259//
260
261void GfxCore::SetScale(Double scale)
262{
263    if (scale < 0.05) {
264        scale = 0.05;
265    } else if (scale > GetVolumeDiameter()) {
266        scale = GetVolumeDiameter();
267    }
268
269    m_Scale = scale;
270    m_HitTestGridValid = false;
271    if (m_here && m_here == &temp_here) SetHere();
272
273    GLACanvas::SetScale(scale);
274}
275
276bool GfxCore::HasUndergroundLegs() const
277{
278    return m_Parent->HasUndergroundLegs();
279}
280
281bool GfxCore::HasSplays() const
282{
283    return m_Parent->HasSplays();
284}
285
286bool GfxCore::HasSurfaceLegs() const
287{
288    return m_Parent->HasSurfaceLegs();
289}
290
291bool GfxCore::HasTubes() const
292{
293    return m_Parent->HasTubes();
294}
295
296void GfxCore::UpdateBlobs()
297{
298    InvalidateList(LIST_BLOBS);
299}
300
301//
302//  Event handlers
303//
304
305void GfxCore::OnLeaveWindow(wxMouseEvent&) {
306    SetHere();
307    ClearCoords();
308}
309
310void GfxCore::OnIdle(wxIdleEvent& event)
311{
312    // Handle an idle event.
313    if (Animating()) {
314        Animate();
315        // If still animating, we want more idle events.
316        if (Animating())
317            event.RequestMore();
318    }
319}
320
321void GfxCore::OnPaint(wxPaintEvent&)
322{
323    // Redraw the window.
324
325    // Get a graphics context.
326    wxPaintDC dc(this);
327
328    if (m_HaveData) {
329        // Make sure we're initialised.
330        bool first_time = !m_DoneFirstShow;
331        if (first_time) {
332            FirstShow();
333        }
334
335        StartDrawing();
336
337        // Clear the background.
338        Clear();
339
340        // Set up model transformation matrix.
341        SetDataTransform();
342
343        if (m_Legs || m_Tubes) {
344            if (m_Tubes) {
345                EnableSmoothPolygons(true); // FIXME: allow false for wireframe view
346                DrawList(LIST_TUBES);
347                DisableSmoothPolygons();
348            }
349
350            // Draw the underground legs.  Do this last so that anti-aliasing
351            // works over polygons.
352            SetColour(col_GREEN);
353            DrawList(LIST_UNDERGROUND_LEGS);
354        }
355
356        if (m_Surface) {
357            // Draw the surface legs.
358            DrawList(LIST_SURFACE_LEGS);
359        }
360
361        if (m_BoundingBox) {
362            DrawShadowedBoundingBox();
363        }
364        if (m_Grid) {
365            // Draw the grid.
366            DrawList(LIST_GRID);
367        }
368
369        DrawList(LIST_BLOBS);
370
371        if (m_Crosses) {
372            DrawList(LIST_CROSSES);
373        }
374
375        SetIndicatorTransform();
376
377        // Draw station names.
378        if (m_Names /*&& !m_Control->MouseDown() && !Animating()*/) {
379            SetColour(NAME_COLOUR);
380
381            if (m_OverlappingNames) {
382                SimpleDrawNames();
383            } else {
384                NattyDrawNames();
385            }
386        }
387
388        if (m_HitTestDebug) {
389            // Show the hit test grid bucket sizes...
390            SetColour(m_HitTestGridValid ? col_LIGHT_GREY : col_DARK_GREY);
391            if (m_PointGrid) {
392                for (int i = 0; i != HITTEST_SIZE; ++i) {
393                    int x = (GetXSize() + 1) * i / HITTEST_SIZE + 2;
394                    for (int j = 0; j != HITTEST_SIZE; ++j) {
395                        int square = i + j * HITTEST_SIZE;
396                        unsigned long bucket_size = m_PointGrid[square].size();
397                        if (bucket_size) {
398                            int y = (GetYSize() + 1) * (HITTEST_SIZE - 1 - j) / HITTEST_SIZE;
399                            DrawIndicatorText(x, y, wxString::Format("%lu", bucket_size));
400                        }
401                    }
402                }
403            }
404
405            EnableDashedLines();
406            BeginLines();
407            for (int i = 0; i != HITTEST_SIZE; ++i) {
408                int x = (GetXSize() + 1) * i / HITTEST_SIZE;
409                PlaceIndicatorVertex(x, 0);
410                PlaceIndicatorVertex(x, GetYSize());
411            }
412            for (int j = 0; j != HITTEST_SIZE; ++j) {
413                int y = (GetYSize() + 1) * (HITTEST_SIZE - 1 - j) / HITTEST_SIZE;
414                PlaceIndicatorVertex(0, y);
415                PlaceIndicatorVertex(GetXSize(), y);
416            }
417            EndLines();
418            DisableDashedLines();
419        }
420
421        // Draw indicators.
422        //
423        // There's no advantage in generating an OpenGL list for the
424        // indicators since they change with almost every redraw (and
425        // sometimes several times between redraws).  This way we avoid
426        // the need to track when to update the indicator OpenGL list,
427        // and also avoid indicator update bugs when we don't quite get this
428        // right...
429        DrawIndicators();
430
431        if (zoombox.active()) {
432            SetColour(SEL_COLOUR);
433            EnableDashedLines();
434            BeginPolyline();
435            glaCoord Y = GetYSize();
436            PlaceIndicatorVertex(zoombox.x1, Y - zoombox.y1);
437            PlaceIndicatorVertex(zoombox.x1, Y - zoombox.y2);
438            PlaceIndicatorVertex(zoombox.x2, Y - zoombox.y2);
439            PlaceIndicatorVertex(zoombox.x2, Y - zoombox.y1);
440            PlaceIndicatorVertex(zoombox.x1, Y - zoombox.y1);
441            EndPolyline();
442            DisableDashedLines();
443        } else if (MeasuringLineActive()) {
444            // Draw "here" and "there".
445            double hx, hy;
446            SetColour(HERE_COLOUR);
447            if (m_here) {
448                double dummy;
449                Transform(*m_here, &hx, &hy, &dummy);
450                if (m_here != &temp_here) DrawRing(hx, hy);
451            }
452            if (m_there) {
453                double tx, ty;
454                double dummy;
455                Transform(*m_there, &tx, &ty, &dummy);
456                if (m_here) {
457                    BeginLines();
458                    PlaceIndicatorVertex(hx, hy);
459                    PlaceIndicatorVertex(tx, ty);
460                    EndLines();
461                }
462                BeginBlobs();
463                DrawBlob(tx, ty);
464                EndBlobs();
465            }
466        }
467
468        FinishDrawing();
469    } else {
470        dc.SetBackground(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWFRAME));
471        dc.Clear();
472    }
473}
474
475void GfxCore::DrawBoundingBox()
476{
477    const Vector3 v = 0.5 * m_Parent->GetExtent();
478
479    SetColour(col_BLUE);
480    EnableDashedLines();
481    BeginPolyline();
482    PlaceVertex(-v.GetX(), -v.GetY(), v.GetZ());
483    PlaceVertex(-v.GetX(), v.GetY(), v.GetZ());
484    PlaceVertex(v.GetX(), v.GetY(), v.GetZ());
485    PlaceVertex(v.GetX(), -v.GetY(), v.GetZ());
486    PlaceVertex(-v.GetX(), -v.GetY(), v.GetZ());
487    EndPolyline();
488    BeginPolyline();
489    PlaceVertex(-v.GetX(), -v.GetY(), -v.GetZ());
490    PlaceVertex(-v.GetX(), v.GetY(), -v.GetZ());
491    PlaceVertex(v.GetX(), v.GetY(), -v.GetZ());
492    PlaceVertex(v.GetX(), -v.GetY(), -v.GetZ());
493    PlaceVertex(-v.GetX(), -v.GetY(), -v.GetZ());
494    EndPolyline();
495    BeginLines();
496    PlaceVertex(-v.GetX(), -v.GetY(), v.GetZ());
497    PlaceVertex(-v.GetX(), -v.GetY(), -v.GetZ());
498    PlaceVertex(-v.GetX(), v.GetY(), v.GetZ());
499    PlaceVertex(-v.GetX(), v.GetY(), -v.GetZ());
500    PlaceVertex(v.GetX(), v.GetY(), v.GetZ());
501    PlaceVertex(v.GetX(), v.GetY(), -v.GetZ());
502    PlaceVertex(v.GetX(), -v.GetY(), v.GetZ());
503    PlaceVertex(v.GetX(), -v.GetY(), -v.GetZ());
504    EndLines();
505    DisableDashedLines();
506}
507
508void GfxCore::DrawShadowedBoundingBox()
509{
510    const Vector3 v = 0.5 * m_Parent->GetExtent();
511
512    DrawBoundingBox();
513
514    PolygonOffset(true);
515    SetColour(col_DARK_GREY);
516    BeginQuadrilaterals();
517    PlaceVertex(-v.GetX(), -v.GetY(), -v.GetZ());
518    PlaceVertex(-v.GetX(), v.GetY(), -v.GetZ());
519    PlaceVertex(v.GetX(), v.GetY(), -v.GetZ());
520    PlaceVertex(v.GetX(), -v.GetY(), -v.GetZ());
521    EndQuadrilaterals();
522    PolygonOffset(false);
523
524    DrawList(LIST_SHADOW);
525}
526
527void GfxCore::DrawGrid()
528{
529    // Draw the grid.
530    SetColour(col_RED);
531
532    // Calculate the extent of the survey, in metres across the screen plane.
533    Double m_across_screen = SurveyUnitsAcrossViewport();
534    // Calculate the length of the scale bar in metres.
535    //--move this elsewhere
536    Double size_snap = pow(10.0, floor(log10(0.75 * m_across_screen)));
537    Double t = m_across_screen * 0.75 / size_snap;
538    if (t >= 5.0) {
539        size_snap *= 5.0;
540    }
541    else if (t >= 2.0) {
542        size_snap *= 2.0;
543    }
544
545    Double grid_size = size_snap * 0.1;
546    Double edge = grid_size * 2.0;
547    Double grid_z = -m_Parent->GetZExtent() * 0.5 - grid_size;
548    Double left = -m_Parent->GetXExtent() * 0.5 - edge;
549    Double right = m_Parent->GetXExtent() * 0.5 + edge;
550    Double bottom = -m_Parent->GetYExtent() * 0.5 - edge;
551    Double top = m_Parent->GetYExtent() * 0.5 + edge;
552    int count_x = (int) ceil((right - left) / grid_size);
553    int count_y = (int) ceil((top - bottom) / grid_size);
554    Double actual_right = left + count_x*grid_size;
555    Double actual_top = bottom + count_y*grid_size;
556
557    BeginLines();
558
559    for (int xc = 0; xc <= count_x; xc++) {
560        Double x = left + xc*grid_size;
561
562        PlaceVertex(x, bottom, grid_z);
563        PlaceVertex(x, actual_top, grid_z);
564    }
565
566    for (int yc = 0; yc <= count_y; yc++) {
567        Double y = bottom + yc*grid_size;
568        PlaceVertex(left, y, grid_z);
569        PlaceVertex(actual_right, y, grid_z);
570    }
571
572    EndLines();
573}
574
575int GfxCore::GetClinoOffset() const
576{
577    return m_Compass ? CLINO_OFFSET_X : INDICATOR_OFFSET_X;
578}
579
580void GfxCore::DrawTick(int angle_cw)
581{
582    const Double theta = rad(angle_cw);
583    const wxCoord length1 = INDICATOR_RADIUS;
584    const wxCoord length0 = length1 + TICK_LENGTH;
585    wxCoord x0 = wxCoord(length0 * sin(theta));
586    wxCoord y0 = wxCoord(length0 * cos(theta));
587    wxCoord x1 = wxCoord(length1 * sin(theta));
588    wxCoord y1 = wxCoord(length1 * cos(theta));
589
590    PlaceIndicatorVertex(x0, y0);
591    PlaceIndicatorVertex(x1, y1);
592}
593
594void GfxCore::DrawArrow(gla_colour col1, gla_colour col2) {
595    Vector3 p1(0, INDICATOR_RADIUS, 0);
596    Vector3 p2(INDICATOR_RADIUS/2, INDICATOR_RADIUS*-.866025404, 0); // 150deg
597    Vector3 p3(-INDICATOR_RADIUS/2, INDICATOR_RADIUS*-.866025404, 0); // 210deg
598    Vector3 pc(0, 0, 0);
599
600    DrawTriangle(col_LIGHT_GREY, col1, p2, p1, pc);
601    DrawTriangle(col_LIGHT_GREY, col2, p3, p1, pc);
602}
603
604void GfxCore::DrawCompass() {
605    // Ticks.
606    BeginLines();
607    for (int angle = 315; angle > 0; angle -= 45) {
608        DrawTick(angle);
609    }
610    SetColour(col_GREEN);
611    DrawTick(0);
612    EndLines();
613
614    // Compass background.
615    DrawCircle(col_LIGHT_GREY_2, col_GREY, 0, 0, INDICATOR_RADIUS);
616
617    // Compass arrow.
618    DrawArrow(col_INDICATOR_1, col_INDICATOR_2);
619}
620
621// Draw the non-rotating background to the clino.
622void GfxCore::DrawClinoBack() {
623    BeginLines();
624    for (int angle = 0; angle <= 180; angle += 90) {
625        DrawTick(angle);
626    }
627
628    SetColour(col_GREY);
629    PlaceIndicatorVertex(0, INDICATOR_RADIUS);
630    PlaceIndicatorVertex(0, -INDICATOR_RADIUS);
631    PlaceIndicatorVertex(0, 0);
632    PlaceIndicatorVertex(INDICATOR_RADIUS, 0);
633
634    EndLines();
635}
636
637void GfxCore::DrawClino() {
638    // Ticks.
639    SetColour(col_GREEN);
640    BeginLines();
641    DrawTick(0);
642    EndLines();
643
644    // Clino background.
645    DrawSemicircle(col_LIGHT_GREY_2, col_GREY, 0, 0, INDICATOR_RADIUS, 0);
646
647    // Elevation arrow.
648    DrawArrow(col_INDICATOR_2, col_INDICATOR_1);
649}
650
651void GfxCore::Draw2dIndicators()
652{
653    // Draw the compass and elevation indicators.
654
655    const int centre_y = INDICATOR_BOX_SIZE / 2 + INDICATOR_OFFSET_Y;
656
657    const int comp_centre_x = GetCompassXPosition();
658
659    if (m_Compass && !m_Parent->IsExtendedElevation()) {
660        // If the user is dragging the compass with the pointer outside the
661        // compass, we snap to 45 degree multiples, and the ticks go white.
662        SetColour(m_MouseOutsideCompass ? col_WHITE : col_LIGHT_GREY_2);
663        DrawList2D(LIST_COMPASS, comp_centre_x, centre_y, -m_PanAngle);
664    }
665
666    const int elev_centre_x = GetClinoXPosition();
667
668    if (m_Clino) {
669        // If the user is dragging the clino with the pointer outside the
670        // clino, we snap to 90 degree multiples, and the ticks go white.
671        SetColour(m_MouseOutsideElev ? col_WHITE : col_LIGHT_GREY_2);
672        DrawList2D(LIST_CLINO_BACK, elev_centre_x, centre_y, 0);
673        DrawList2D(LIST_CLINO, elev_centre_x, centre_y, 90 - m_TiltAngle);
674    }
675
676    SetColour(TEXT_COLOUR);
677
678    static int triple_zero_width = 0;
679    static int height = 0;
680    if (!triple_zero_width) {
681        GetTextExtent(wxT("000"), &triple_zero_width, &height);
682    }
683    const int y_off = INDICATOR_OFFSET_Y + INDICATOR_BOX_SIZE + height / 2;
684
685    if (m_Compass && !m_Parent->IsExtendedElevation()) {
686        wxString str;
687        int value;
688        int brg_unit;
689        if (m_Degrees) {
690            value = int(m_PanAngle);
691            /* TRANSLATORS: degree symbol - probably should be translated to
692             * itself. */
693            brg_unit = /*°*/344;
694        } else {
695            value = int(m_PanAngle * 200.0 / 180.0);
696            /* TRANSLATORS: symbol for grad (400 grad = 360 degrees = full
697             * circle). */
698            brg_unit = /*ᵍ*/76;
699        }
700        str.Printf(wxT("%03d"), value);
701        str += wmsg(brg_unit);
702        DrawIndicatorText(comp_centre_x - triple_zero_width / 2, y_off, str);
703
704        str = wmsg(/*Facing*/203);
705        int w;
706        GetTextExtent(str, &w, NULL);
707        DrawIndicatorText(comp_centre_x - w / 2, y_off + height, str);
708    }
709
710    if (m_Clino) {
711        if (m_TiltAngle == -90.0) {
712            // TRANSLATORS: Label used for "clino" in Aven when the view is
713            // from directly above.
714            wxString str = wmsg(/*Plan*/432);
715            static int width = 0;
716            if (!width) {
717                GetTextExtent(str, &width, NULL);
718            }
719            int x = elev_centre_x - width / 2;
720            DrawIndicatorText(x, y_off + height / 2, str);
721        } else if (m_TiltAngle == 90.0) {
722            // TRANSLATORS: Label used for "clino" in Aven when the view is
723            // from directly below.
724            wxString str = wmsg(/*Kiwi Plan*/433);
725            static int width = 0;
726            if (!width) {
727                GetTextExtent(str, &width, NULL);
728            }
729            int x = elev_centre_x - width / 2;
730            DrawIndicatorText(x, y_off + height / 2, str);
731        } else {
732            int angle;
733            wxString str;
734            int width;
735            int unit;
736            if (m_Percent) {
737                static int zero_width = 0;
738                if (!zero_width) {
739                    GetTextExtent(wxT("0"), &zero_width, NULL);
740                }
741                width = zero_width;
742                if (m_TiltAngle > 89.99) {
743                    angle = 1000000;
744                } else if (m_TiltAngle < -89.99) {
745                    angle = -1000000;
746                } else {
747                    angle = int(100 * tan(rad(m_TiltAngle)));
748                }
749                if (angle > 99999 || angle < -99999) {
750                    str = angle > 0 ? wxT("+") : wxT("-");
751                    /* TRANSLATORS: used for the percentage gradient on
752                     * vertical angles. */
753                    str += wmsg(/*∞*/431);
754                } else {
755                    str = angle ? wxString::Format(wxT("%+03d"), angle) : wxT("0");
756                }
757                /* TRANSLATORS: symbol for percentage gradient (100% = 45
758                 * degrees = 50 grad). */
759                unit = /*%*/96;
760            } else if (m_Degrees) {
761                static int zero_zero_width = 0;
762                if (!zero_zero_width) {
763                    GetTextExtent(wxT("00"), &zero_zero_width, NULL);
764                }
765                width = zero_zero_width;
766                angle = int(m_TiltAngle);
767                str = angle ? wxString::Format(wxT("%+03d"), angle) : wxT("00");
768                unit = /*°*/344;
769            } else {
770                width = triple_zero_width;
771                angle = int(m_TiltAngle * 200.0 / 180.0);
772                str = angle ? wxString::Format(wxT("%+04d"), angle) : wxT("000");
773                unit = /*ᵍ*/76;
774            }
775
776            int sign_offset = 0;
777            if (unit == /*%*/96) {
778                // Right align % since the width changes so much.
779                GetTextExtent(str, &sign_offset, NULL);
780                sign_offset -= width;
781            } else if (angle < 0) {
782                // Adjust horizontal position so the left of the first digit is
783                // always in the same place.
784                static int minus_width = 0;
785                if (!minus_width) {
786                    GetTextExtent(wxT("-"), &minus_width, NULL);
787                }
788                sign_offset = minus_width;
789            } else if (angle > 0) {
790                // Adjust horizontal position so the left of the first digit is
791                // always in the same place.
792                static int plus_width = 0;
793                if (!plus_width) {
794                    GetTextExtent(wxT("+"), &plus_width, NULL);
795                }
796                sign_offset = plus_width;
797            }
798
799            str += wmsg(unit);
800            DrawIndicatorText(elev_centre_x - sign_offset - width / 2, y_off, str);
801
802            str = wmsg(/*Elevation*/118);
803            static int elevation_width = 0;
804            if (!elevation_width) {
805                GetTextExtent(str, &elevation_width, NULL);
806            }
807            int x = elev_centre_x - elevation_width / 2;
808            DrawIndicatorText(x, y_off + height, str);
809        }
810    }
811}
812
813void GfxCore::NattyDrawNames()
814{
815    // Draw station names, without overlapping.
816
817    const unsigned int quantise(GetFontSize() / QUANTISE_FACTOR);
818    const unsigned int quantised_x = GetXSize() / quantise;
819    const unsigned int quantised_y = GetYSize() / quantise;
820    const size_t buffer_size = quantised_x * quantised_y;
821
822    if (!m_LabelGrid) m_LabelGrid = new char[buffer_size];
823
824    memset((void*) m_LabelGrid, 0, buffer_size);
825
826    list<LabelInfo*>::const_iterator label = m_Parent->GetLabels();
827    for ( ; label != m_Parent->GetLabelsEnd(); ++label) {
828        if (!((m_Surface && (*label)->IsSurface()) ||
829              (m_Legs && (*label)->IsUnderground()) ||
830              (!(*label)->IsSurface() && !(*label)->IsUnderground()))) {
831            // if this station isn't to be displayed, skip to the next
832            // (last case is for stns with no legs attached)
833            continue;
834        }
835
836        double x, y, z;
837
838        Transform(**label, &x, &y, &z);
839        // Check if the label is behind us (in perspective view).
840        if (z <= 0.0 || z >= 1.0) continue;
841
842        // Apply a small shift so that translating the view doesn't make which
843        // labels are displayed change as the resulting twinkling effect is
844        // distracting.
845        double tx, ty, tz;
846        Transform(Vector3(), &tx, &ty, &tz);
847        tx -= floor(tx / quantise) * quantise;
848        ty -= floor(ty / quantise) * quantise;
849
850        tx = x - tx;
851        if (tx < 0) continue;
852
853        ty = y - ty;
854        if (ty < 0) continue;
855
856        unsigned int iy = unsigned(ty) / quantise;
857        if (iy >= quantised_y) continue;
858        unsigned int width = (*label)->get_width();
859        unsigned int ix = unsigned(tx) / quantise;
860        if (ix + width >= quantised_x) continue;
861
862        char * test = m_LabelGrid + ix + iy * quantised_x;
863        if (memchr(test, 1, width)) continue;
864
865        x += 3;
866        y -= GetFontSize() / 2;
867        DrawIndicatorText((int)x, (int)y, (*label)->GetText());
868
869        if (iy > QUANTISE_FACTOR) iy = QUANTISE_FACTOR;
870        test -= quantised_x * iy;
871        iy += 4;
872        while (--iy && test < m_LabelGrid + buffer_size) {
873            memset(test, 1, width);
874            test += quantised_x;
875        }
876    }
877}
878
879void GfxCore::SimpleDrawNames()
880{
881    // Draw all station names, without worrying about overlaps
882    list<LabelInfo*>::const_iterator label = m_Parent->GetLabels();
883    for ( ; label != m_Parent->GetLabelsEnd(); ++label) {
884        if (!((m_Surface && (*label)->IsSurface()) ||
885              (m_Legs && (*label)->IsUnderground()) ||
886              (!(*label)->IsSurface() && !(*label)->IsUnderground()))) {
887            // if this station isn't to be displayed, skip to the next
888            // (last case is for stns with no legs attached)
889            continue;
890        }
891
892        double x, y, z;
893        Transform(**label, &x, &y, &z);
894
895        // Check if the label is behind us (in perspective view).
896        if (z <= 0) continue;
897
898        x += 3;
899        y -= GetFontSize() / 2;
900        DrawIndicatorText((int)x, (int)y, (*label)->GetText());
901    }
902}
903
904void GfxCore::DrawColourKey(int num_bands, const wxString & other, const wxString & units)
905{
906    int total_block_height =
907        KEY_BLOCK_HEIGHT * (num_bands == 1 ? num_bands : num_bands - 1);
908    if (!other.empty()) total_block_height += KEY_BLOCK_HEIGHT * 2;
909    if (!units.empty()) total_block_height += KEY_BLOCK_HEIGHT;
910
911    const int bottom = -total_block_height;
912
913    int size = 0;
914    if (!other.empty()) GetTextExtent(other, &size, NULL);
915    int band;
916    for (band = 0; band < num_bands; ++band) {
917        int x;
918        GetTextExtent(key_legends[band], &x, NULL);
919        if (x > size) size = x;
920    }
921
922    int left = -KEY_BLOCK_WIDTH - size;
923
924    key_lowerleft[m_ColourBy].x = left - KEY_EXTRA_LEFT_MARGIN;
925    key_lowerleft[m_ColourBy].y = bottom;
926
927    int y = bottom;
928    if (!units.empty()) y += KEY_BLOCK_HEIGHT;
929
930    if (!other.empty()) {
931        DrawShadedRectangle(GetSurfacePen(), GetSurfacePen(), left, y,
932                KEY_BLOCK_WIDTH, KEY_BLOCK_HEIGHT);
933        SetColour(col_BLACK);
934        BeginPolyline();
935        PlaceIndicatorVertex(left, y);
936        PlaceIndicatorVertex(left + KEY_BLOCK_WIDTH, y);
937        PlaceIndicatorVertex(left + KEY_BLOCK_WIDTH, y + KEY_BLOCK_HEIGHT);
938        PlaceIndicatorVertex(left, y + KEY_BLOCK_HEIGHT);
939        PlaceIndicatorVertex(left, y);
940        EndPolyline();
941        y += KEY_BLOCK_HEIGHT * 2;
942    }
943
944    int start = y;
945    if (num_bands == 1) {
946        DrawShadedRectangle(GetPen(0), GetPen(0), left, y,
947                            KEY_BLOCK_WIDTH, KEY_BLOCK_HEIGHT);
948        y += KEY_BLOCK_HEIGHT;
949    } else {
950        for (band = 0; band < num_bands - 1; ++band) {
951            DrawShadedRectangle(GetPen(band), GetPen(band + 1), left, y,
952                                KEY_BLOCK_WIDTH, KEY_BLOCK_HEIGHT);
953            y += KEY_BLOCK_HEIGHT;
954        }
955    }
956
957    SetColour(col_BLACK);
958    BeginPolyline();
959    PlaceIndicatorVertex(left, y);
960    PlaceIndicatorVertex(left + KEY_BLOCK_WIDTH, y);
961    PlaceIndicatorVertex(left + KEY_BLOCK_WIDTH, start);
962    PlaceIndicatorVertex(left, start);
963    PlaceIndicatorVertex(left, y);
964    EndPolyline();
965
966    SetColour(TEXT_COLOUR);
967
968    y = bottom;
969    if (!units.empty()) {
970        GetTextExtent(units, &size, NULL);
971        DrawIndicatorText(left + (KEY_BLOCK_WIDTH - size) / 2, y, units);
972        y += KEY_BLOCK_HEIGHT;
973    }
974    y -= GetFontSize() / 2;
975    left += KEY_BLOCK_WIDTH + 5;
976
977    if (!other.empty()) {
978        y += KEY_BLOCK_HEIGHT / 2;
979        DrawIndicatorText(left, y, other);
980        y += KEY_BLOCK_HEIGHT * 2 - KEY_BLOCK_HEIGHT / 2;
981    }
982
983    if (num_bands == 1) {
984        y += KEY_BLOCK_HEIGHT / 2;
985        DrawIndicatorText(left, y, key_legends[0]);
986    } else {
987        for (band = 0; band < num_bands; ++band) {
988            DrawIndicatorText(left, y, key_legends[band]);
989            y += KEY_BLOCK_HEIGHT;
990        }
991    }
992}
993
994void GfxCore::DrawDepthKey()
995{
996    Double z_ext = m_Parent->GetDepthExtent();
997    int num_bands = 1;
998    int sf = 0;
999    if (z_ext > 0.0) {
1000        num_bands = GetNumColourBands();
1001        Double z_range = z_ext;
1002        if (!m_Metric) z_range /= METRES_PER_FOOT;
1003        sf = max(0, 1 - (int)floor(log10(z_range)));
1004    }
1005
1006    Double z_min = m_Parent->GetDepthMin() + m_Parent->GetOffset().GetZ();
1007    for (int band = 0; band < num_bands; ++band) {
1008        Double z = z_min;
1009        if (band)
1010            z += z_ext * band / (num_bands - 1);
1011
1012        if (!m_Metric)
1013            z /= METRES_PER_FOOT;
1014
1015        key_legends[band].Printf(wxT("%.*f"), sf, z);
1016    }
1017
1018    DrawColourKey(num_bands, wxString(), wmsg(m_Metric ? /*m*/424: /*ft*/428));
1019}
1020
1021void GfxCore::DrawDateKey()
1022{
1023    int num_bands;
1024    if (!HasDateInformation()) {
1025        num_bands = 0;
1026    } else {
1027        int date_ext = m_Parent->GetDateExtent();
1028        if (date_ext == 0) {
1029            num_bands = 1;
1030        } else {
1031            num_bands = GetNumColourBands();
1032        }
1033        for (int band = 0; band < num_bands; ++band) {
1034            int y, m, d;
1035            int days = m_Parent->GetDateMin();
1036            if (band)
1037                days += date_ext * band / (num_bands - 1);
1038            ymd_from_days_since_1900(days, &y, &m, &d);
1039            key_legends[band].Printf(wxT("%04d-%02d-%02d"), y, m, d);
1040        }
1041    }
1042
1043    wxString other;
1044    if (!m_Parent->HasCompleteDateInfo()) {
1045        /* TRANSLATORS: Used in the "colour key" for "colour by date" if there
1046         * are surveys without date information. */
1047        other = wmsg(/*Undated*/221);
1048    }
1049
1050    DrawColourKey(num_bands, other, wxString());
1051}
1052
1053void GfxCore::DrawErrorKey()
1054{
1055    int num_bands;
1056    if (HasErrorInformation()) {
1057        // Use fixed colours for each error factor so it's directly visually
1058        // comparable between surveys.
1059        num_bands = GetNumColourBands();
1060        for (int band = 0; band < num_bands; ++band) {
1061            double E = MAX_ERROR * band / (num_bands - 1);
1062            key_legends[band].Printf(wxT("%.2f"), E);
1063        }
1064    } else {
1065        num_bands = 0;
1066    }
1067
1068    // Always show the "Not in loop" legend for now (FIXME).
1069    /* TRANSLATORS: Used in the "colour key" for "colour by error" for surveys
1070     * which aren’t part of a loop and so have no error information. */
1071    DrawColourKey(num_bands, wmsg(/*Not in loop*/290), wxString());
1072}
1073
1074void GfxCore::DrawScaleBar()
1075{
1076    // Draw the scalebar.
1077    if (GetPerspective()) return;
1078
1079    // Calculate how many metres of survey are currently displayed across the
1080    // screen.
1081    Double across_screen = SurveyUnitsAcrossViewport();
1082
1083    double f = double(GetClinoXPosition() - INDICATOR_BOX_SIZE / 2 - SCALE_BAR_OFFSET_X) / GetXSize();
1084    if (f > 0.75) {
1085        f = 0.75;
1086    } else if (f < 0.5) {
1087        // Stop it getting squeezed to nothing.
1088        // FIXME: In this case we should probably move the compass and clino up
1089        // to make room rather than letting stuff overlap.
1090        f = 0.5;
1091    }
1092
1093    // Convert to imperial measurements if required.
1094    Double multiplier = 1.0;
1095    if (!m_Metric) {
1096        across_screen /= METRES_PER_FOOT;
1097        multiplier = METRES_PER_FOOT;
1098        if (across_screen >= 5280.0 / f) {
1099            across_screen /= 5280.0;
1100            multiplier *= 5280.0;
1101        }
1102    }
1103
1104    // Calculate the length of the scale bar.
1105    Double size_snap = pow(10.0, floor(log10(f * across_screen)));
1106    Double t = across_screen * f / size_snap;
1107    if (t >= 5.0) {
1108        size_snap *= 5.0;
1109    } else if (t >= 2.0) {
1110        size_snap *= 2.0;
1111    }
1112
1113    if (!m_Metric) size_snap *= multiplier;
1114
1115    // Actual size of the thing in pixels:
1116    int size = int((size_snap / SurveyUnitsAcrossViewport()) * GetXSize());
1117    m_ScaleBarWidth = size;
1118
1119    // Draw it...
1120    const int end_y = SCALE_BAR_OFFSET_Y + SCALE_BAR_HEIGHT;
1121    int interval = size / 10;
1122
1123    gla_colour col = col_WHITE;
1124    for (int ix = 0; ix < 10; ix++) {
1125        int x = SCALE_BAR_OFFSET_X + int(ix * ((Double) size / 10.0));
1126
1127        DrawRectangle(col, col, x, end_y, interval + 2, SCALE_BAR_HEIGHT);
1128
1129        col = (col == col_WHITE) ? col_GREY : col_WHITE;
1130    }
1131
1132    // Add labels.
1133    wxString str;
1134    int units;
1135    if (m_Metric) {
1136        Double km = size_snap * 1e-3;
1137        if (km >= 1.0) {
1138            size_snap = km;
1139            /* TRANSLATORS: abbreviation for "kilometres" (unit of length),
1140             * used e.g.  "5km".
1141             *
1142             * If there should be a space between the number and this, include
1143             * one in the translation. */
1144            units = /*km*/423;
1145        } else if (size_snap >= 1.0) {
1146            /* TRANSLATORS: abbreviation for "metres" (unit of length), used
1147             * e.g. "10m".
1148             *
1149             * If there should be a space between the number and this, include
1150             * one in the translation. */
1151            units = /*m*/424;
1152        } else {
1153            size_snap *= 1e2;
1154            /* TRANSLATORS: abbreviation for "centimetres" (unit of length),
1155             * used e.g.  "50cm".
1156             *
1157             * If there should be a space between the number and this, include
1158             * one in the translation. */
1159            units = /*cm*/425;
1160        }
1161    } else {
1162        size_snap /= METRES_PER_FOOT;
1163        Double miles = size_snap / 5280.0;
1164        if (miles >= 1.0) {
1165            size_snap = miles;
1166            if (size_snap >= 2.0) {
1167                /* TRANSLATORS: abbreviation for "miles" (unit of length,
1168                 * plural), used e.g.  "2 miles".
1169                 *
1170                 * If there should be a space between the number and this,
1171                 * include one in the translation. */
1172                units = /* miles*/426;
1173            } else {
1174                /* TRANSLATORS: abbreviation for "mile" (unit of length,
1175                 * singular), used e.g.  "1 mile".
1176                 *
1177                 * If there should be a space between the number and this,
1178                 * include one in the translation. */
1179                units = /* mile*/427;
1180            }
1181        } else if (size_snap >= 1.0) {
1182            /* TRANSLATORS: abbreviation for "feet" (unit of length), used e.g.
1183             * as "10ft".
1184             *
1185             * If there should be a space between the number and this, include
1186             * one in the translation. */
1187            units = /*ft*/428;
1188        } else {
1189            size_snap *= 12.0;
1190            /* TRANSLATORS: abbreviation for "inches" (unit of length), used
1191             * e.g. as "6in".
1192             *
1193             * If there should be a space between the number and this, include
1194             * one in the translation. */
1195            units = /*in*/429;
1196        }
1197    }
1198    if (size_snap >= 1.0) {
1199        str.Printf(wxT("%.f%s"), size_snap, wmsg(units).c_str());
1200    } else {
1201        int sf = -(int)floor(log10(size_snap));
1202        str.Printf(wxT("%.*f%s"), sf, size_snap, wmsg(units).c_str());
1203    }
1204
1205    int text_width, text_height;
1206    GetTextExtent(str, &text_width, &text_height);
1207    const int text_y = end_y - text_height + 1;
1208    SetColour(TEXT_COLOUR);
1209    DrawIndicatorText(SCALE_BAR_OFFSET_X, text_y, wxT("0"));
1210    DrawIndicatorText(SCALE_BAR_OFFSET_X + size - text_width, text_y, str);
1211}
1212
1213bool GfxCore::CheckHitTestGrid(const wxPoint& point, bool centre)
1214{
1215    if (Animating()) return false;
1216
1217    if (point.x < 0 || point.x >= GetXSize() ||
1218        point.y < 0 || point.y >= GetYSize()) {
1219        return false;
1220    }
1221
1222    SetDataTransform();
1223
1224    if (!m_HitTestGridValid) CreateHitTestGrid();
1225
1226    int grid_x = point.x * HITTEST_SIZE / (GetXSize() + 1);
1227    int grid_y = point.y * HITTEST_SIZE / (GetYSize() + 1);
1228
1229    LabelInfo *best = NULL;
1230    int dist_sqrd = sqrd_measure_threshold;
1231    int square = grid_x + grid_y * HITTEST_SIZE;
1232    list<LabelInfo*>::iterator iter = m_PointGrid[square].begin();
1233
1234    while (iter != m_PointGrid[square].end()) {
1235        LabelInfo *pt = *iter++;
1236
1237        double cx, cy, cz;
1238
1239        Transform(*pt, &cx, &cy, &cz);
1240
1241        cy = GetYSize() - cy;
1242
1243        int dx = point.x - int(cx);
1244        int ds = dx * dx;
1245        if (ds >= dist_sqrd) continue;
1246        int dy = point.y - int(cy);
1247
1248        ds += dy * dy;
1249        if (ds >= dist_sqrd) continue;
1250
1251        dist_sqrd = ds;
1252        best = pt;
1253
1254        if (ds == 0) break;
1255    }
1256
1257    if (best) {
1258        m_Parent->ShowInfo(best, m_there);
1259        if (centre) {
1260            // FIXME: allow Ctrl-Click to not set there or something?
1261            CentreOn(*best);
1262            WarpPointer(GetXSize() / 2, GetYSize() / 2);
1263            SetThere(best);
1264            m_Parent->SelectTreeItem(best);
1265        }
1266    } else {
1267        // Left-clicking not on a survey cancels the measuring line.
1268        if (centre) {
1269            ClearTreeSelection();
1270        } else {
1271            m_Parent->ShowInfo(best, m_there);
1272            double x, y, z;
1273            ReverseTransform(point.x, GetYSize() - point.y, &x, &y, &z);
1274            temp_here.assign(Vector3(x, y, z));
1275            SetHere(&temp_here);
1276        }
1277    }
1278
1279    return best;
1280}
1281
1282void GfxCore::OnSize(wxSizeEvent& event)
1283{
1284    // Handle a change in window size.
1285    wxSize size = event.GetSize();
1286
1287    if (size.GetWidth() <= 0 || size.GetHeight() <= 0) {
1288        // Before things are fully initialised, we sometimes get a bogus
1289        // resize message...
1290        // FIXME have changes in MainFrm cured this?  It still happens with
1291        // 1.0.32 and wxGTK 2.5.2 (load a file from the command line).
1292        // With 1.1.6 and wxGTK 2.4.2 we only get negative sizes if MainFrm
1293        // is resized such that the GfxCore window isn't visible.
1294        //printf("OnSize(%d,%d)\n", size.GetWidth(), size.GetHeight());
1295        return;
1296    }
1297
1298    event.Skip();
1299
1300    if (m_DoneFirstShow) {
1301        TryToFreeArrays();
1302
1303        m_HitTestGridValid = false;
1304
1305        ForceRefresh();
1306    }
1307}
1308
1309void GfxCore::DefaultParameters()
1310{
1311    // Set default viewing parameters.
1312
1313    m_Surface = false;
1314    if (!m_Parent->HasUndergroundLegs()) {
1315        if (m_Parent->HasSurfaceLegs()) {
1316            // If there are surface legs, but no underground legs, turn
1317            // surface surveys on.
1318            m_Surface = true;
1319        } else {
1320            // If there are no legs (e.g. after loading a .pos file), turn
1321            // crosses on.
1322            m_Crosses = true;
1323        }
1324    }
1325
1326    m_PanAngle = 0.0;
1327    if (m_Parent->IsExtendedElevation()) {
1328        m_TiltAngle = 0.0;
1329    } else {
1330        m_TiltAngle = -90.0;
1331    }
1332
1333    SetRotation(m_PanAngle, m_TiltAngle);
1334    SetTranslation(Vector3());
1335
1336    m_RotationStep = 30.0;
1337    m_Rotating = false;
1338    m_SwitchingTo = 0;
1339    m_Entrances = false;
1340    m_FixedPts = false;
1341    m_ExportedPts = false;
1342    m_Grid = false;
1343    m_BoundingBox = false;
1344    m_Tubes = false;
1345    if (GetPerspective()) TogglePerspective();
1346}
1347
1348void GfxCore::Defaults()
1349{
1350    // Restore default scale, rotation and translation parameters.
1351    DefaultParameters();
1352    SetScale(1.0);
1353
1354    // Invalidate all the cached lists.
1355    GLACanvas::FirstShow();
1356
1357    ForceRefresh();
1358}
1359
1360void GfxCore::Animate()
1361{
1362    // Don't show pointer coordinates while animating.
1363    // FIXME : only do this when we *START* animating!  Use a static copy
1364    // of the value of "Animating()" last time we were here to track this?
1365    // MainFrm now checks if we're trying to clear already cleared labels
1366    // and just returns, but it might be simpler to check here!
1367    ClearCoords();
1368    m_Parent->ShowInfo();
1369
1370    long t;
1371    if (movie) {
1372        ReadPixels(movie->GetWidth(), movie->GetHeight(), movie->GetBuffer());
1373        if (!movie->AddFrame()) {
1374            wxGetApp().ReportError(wxString(movie->get_error_string(), wxConvUTF8));
1375            delete movie;
1376            movie = NULL;
1377            presentation_mode = 0;
1378            return;
1379        }
1380        t = 1000 / 25; // 25 frames per second
1381    } else {
1382        static long t_prev = 0;
1383        t = timer.Time();
1384        // Avoid redrawing twice in the same frame.
1385        long delta_t = (t_prev == 0 ? 1000 / MAX_FRAMERATE : t - t_prev);
1386        if (delta_t < 1000 / MAX_FRAMERATE)
1387            return;
1388        t_prev = t;
1389        if (presentation_mode == PLAYING && pres_speed != 0.0)
1390            t = delta_t;
1391    }
1392
1393    if (presentation_mode == PLAYING && pres_speed != 0.0) {
1394        // FIXME: It would probably be better to work relative to the time we
1395        // passed the last mark, but that's complicated by the speed
1396        // potentially changing (or even the direction of playback reversing)
1397        // at any point during playback.
1398        Double tick = t * 0.001 * fabs(pres_speed);
1399        while (tick >= next_mark_time) {
1400            tick -= next_mark_time;
1401            this_mark_total = 0;
1402            PresentationMark prev_mark = next_mark;
1403            if (prev_mark.angle < 0) prev_mark.angle += 360.0;
1404            else if (prev_mark.angle >= 360.0) prev_mark.angle -= 360.0;
1405            if (pres_reverse)
1406                next_mark = m_Parent->GetPresMark(MARK_PREV);
1407            else
1408                next_mark = m_Parent->GetPresMark(MARK_NEXT);
1409            if (!next_mark.is_valid()) {
1410                SetView(prev_mark);
1411                presentation_mode = 0;
1412                if (movie && !movie->Close()) {
1413                    wxGetApp().ReportError(wxString(movie->get_error_string(), wxConvUTF8));
1414                }
1415                delete movie;
1416                movie = NULL;
1417                break;
1418            }
1419
1420            double tmp = (pres_reverse ? prev_mark.time : next_mark.time);
1421            if (tmp > 0) {
1422                next_mark_time = tmp;
1423            } else {
1424                double d = (next_mark - prev_mark).magnitude();
1425                // FIXME: should ignore component of d which is unseen in
1426                // non-perspective mode?
1427                next_mark_time = sqrd(d / 30.0);
1428                double a = next_mark.angle - prev_mark.angle;
1429                if (a > 180.0) {
1430                    next_mark.angle -= 360.0;
1431                    a = 360.0 - a;
1432                } else if (a < -180.0) {
1433                    next_mark.angle += 360.0;
1434                    a += 360.0;
1435                } else {
1436                    a = fabs(a);
1437                }
1438                next_mark_time += sqrd(a / 60.0);
1439                double ta = fabs(next_mark.tilt_angle - prev_mark.tilt_angle);
1440                next_mark_time += sqrd(ta / 60.0);
1441                double s = fabs(log(next_mark.scale) - log(prev_mark.scale));
1442                next_mark_time += sqrd(s / 2.0);
1443                next_mark_time = sqrt(next_mark_time);
1444                // was: next_mark_time = max(max(d / 30, s / 2), max(a, ta) / 60);
1445                //printf("*** %.6f from (\nd: %.6f\ns: %.6f\na: %.6f\nt: %.6f )\n",
1446                //       next_mark_time, d/30.0, s/2.0, a/60.0, ta/60.0);
1447                if (tmp < 0) next_mark_time /= -tmp;
1448            }
1449        }
1450
1451        if (presentation_mode) {
1452            // Advance position towards next_mark
1453            double p = tick / next_mark_time;
1454            double q = 1 - p;
1455            PresentationMark here = GetView();
1456            if (next_mark.angle < 0) {
1457                if (here.angle >= next_mark.angle + 360.0)
1458                    here.angle -= 360.0;
1459            } else if (next_mark.angle >= 360.0) {
1460                if (here.angle <= next_mark.angle - 360.0)
1461                    here.angle += 360.0;
1462            }
1463            here.assign(q * here + p * next_mark);
1464            here.angle = q * here.angle + p * next_mark.angle;
1465            if (here.angle < 0) here.angle += 360.0;
1466            else if (here.angle >= 360.0) here.angle -= 360.0;
1467            here.tilt_angle = q * here.tilt_angle + p * next_mark.tilt_angle;
1468            here.scale = exp(q * log(here.scale) + p * log(next_mark.scale));
1469            SetView(here);
1470            this_mark_total += tick;
1471            next_mark_time -= tick;
1472        }
1473
1474        ForceRefresh();
1475        return;
1476    }
1477
1478    // When rotating...
1479    if (m_Rotating) {
1480        Double step = base_pan + (t - base_pan_time) * 1e-3 * m_RotationStep - m_PanAngle;
1481        TurnCave(step);
1482    }
1483
1484    if (m_SwitchingTo == PLAN) {
1485        // When switching to plan view...
1486        Double step = base_tilt - (t - base_tilt_time) * 1e-3 * 90.0 - m_TiltAngle;
1487        TiltCave(step);
1488        if (m_TiltAngle == -90.0) {
1489            m_SwitchingTo = 0;
1490        }
1491    } else if (m_SwitchingTo == ELEVATION) {
1492        // When switching to elevation view...
1493        Double step;
1494        if (m_TiltAngle > 0.0) {
1495            step = base_tilt - (t - base_tilt_time) * 1e-3 * 90.0 - m_TiltAngle;
1496        } else {
1497            step = base_tilt + (t - base_tilt_time) * 1e-3 * 90.0 - m_TiltAngle;
1498        }
1499        if (fabs(step) >= fabs(m_TiltAngle)) {
1500            m_SwitchingTo = 0;
1501            step = -m_TiltAngle;
1502        }
1503        TiltCave(step);
1504    } else if (m_SwitchingTo) {
1505        // Rotate the shortest way around to the destination angle.  If we're
1506        // 180 off, we favour turning anticlockwise, as auto-rotation does by
1507        // default.
1508        Double target = (m_SwitchingTo - NORTH) * 90;
1509        Double diff = target - m_PanAngle;
1510        diff = fmod(diff, 360);
1511        if (diff <= -180)
1512            diff += 360;
1513        else if (diff > 180)
1514            diff -= 360;
1515        if (m_RotationStep < 0 && diff == 180.0)
1516            diff = -180.0;
1517        Double step = base_pan - m_PanAngle;
1518        Double delta = (t - base_pan_time) * 1e-3 * fabs(m_RotationStep);
1519        if (diff > 0) {
1520            step += delta;
1521        } else {
1522            step -= delta;
1523        }
1524        step = fmod(step, 360);
1525        if (step <= -180)
1526            step += 360;
1527        else if (step > 180)
1528            step -= 360;
1529        if (fabs(step) >= fabs(diff)) {
1530            m_SwitchingTo = 0;
1531            step = diff;
1532        }
1533        TurnCave(step);
1534    }
1535
1536    ForceRefresh();
1537}
1538
1539// How much to allow around the box - this is because of the ring shape
1540// at one end of the line.
1541static const int HIGHLIGHTED_PT_SIZE = 2; // FIXME: tie in to blob and ring size
1542#define MARGIN (HIGHLIGHTED_PT_SIZE * 2 + 1)
1543void GfxCore::RefreshLine(const Point *a, const Point *b, const Point *c)
1544{
1545#ifdef __WXMSW__
1546    (void)a;
1547    (void)b;
1548    (void)c;
1549    // FIXME: We get odd redraw artifacts if we just update the line, and
1550    // redrawing the whole scene doesn't actually seem to be measurably
1551    // slower.  That may not be true with software rendering though...
1552    ForceRefresh();
1553#else
1554    // Best of all might be to copy the window contents before we draw the
1555    // line, then replace each time we redraw.
1556
1557    // Calculate the minimum rectangle which includes the old and new
1558    // measuring lines to minimise the redraw time
1559    int l = INT_MAX, r = INT_MIN, u = INT_MIN, d = INT_MAX;
1560    double X, Y, Z;
1561    if (a) {
1562        if (!Transform(*a, &X, &Y, &Z)) {
1563            printf("oops\n");
1564        } else {
1565            int x = int(X);
1566            int y = GetYSize() - 1 - int(Y);
1567            l = x;
1568            r = x;
1569            u = y;
1570            d = y;
1571        }
1572    }
1573    if (b) {
1574        if (!Transform(*b, &X, &Y, &Z)) {
1575            printf("oops\n");
1576        } else {
1577            int x = int(X);
1578            int y = GetYSize() - 1 - int(Y);
1579            l = min(l, x);
1580            r = max(r, x);
1581            u = max(u, y);
1582            d = min(d, y);
1583        }
1584    }
1585    if (c) {
1586        if (!Transform(*c, &X, &Y, &Z)) {
1587            printf("oops\n");
1588        } else {
1589            int x = int(X);
1590            int y = GetYSize() - 1 - int(Y);
1591            l = min(l, x);
1592            r = max(r, x);
1593            u = max(u, y);
1594            d = min(d, y);
1595        }
1596    }
1597    l -= MARGIN;
1598    r += MARGIN;
1599    u += MARGIN;
1600    d -= MARGIN;
1601    RefreshRect(wxRect(l, d, r - l, u - d), false);
1602#endif
1603}
1604
1605void GfxCore::SetHereFromTree(const LabelInfo * p)
1606{
1607    SetHere(p);
1608    m_Parent->ShowInfo(m_here, m_there);
1609}
1610
1611void GfxCore::SetHere()
1612{
1613    if (!m_here) return;
1614    bool line_active = MeasuringLineActive();
1615    const LabelInfo * old = m_here;
1616    m_here = NULL;
1617    if (line_active || MeasuringLineActive())
1618        RefreshLine(old, m_there, m_here);
1619}
1620
1621void GfxCore::SetHere(const LabelInfo *p)
1622{
1623    bool line_active = MeasuringLineActive();
1624    const LabelInfo * old = m_here;
1625    m_here = p;
1626    if (line_active || MeasuringLineActive())
1627        RefreshLine(old, m_there, m_here);
1628}
1629
1630void GfxCore::SetThere()
1631{
1632    if (!m_there) return;
1633    const LabelInfo * old = m_there;
1634    m_there = NULL;
1635    RefreshLine(m_here, old, m_there);
1636}
1637
1638void GfxCore::SetThere(const LabelInfo * p)
1639{
1640    const LabelInfo * old = m_there;
1641    m_there = p;
1642    RefreshLine(m_here, old, m_there);
1643}
1644
1645void GfxCore::CreateHitTestGrid()
1646{
1647    if (!m_PointGrid) {
1648        // Initialise hit-test grid.
1649        m_PointGrid = new list<LabelInfo*>[HITTEST_SIZE * HITTEST_SIZE];
1650    } else {
1651        // Clear hit-test grid.
1652        for (int i = 0; i < HITTEST_SIZE * HITTEST_SIZE; i++) {
1653            m_PointGrid[i].clear();
1654        }
1655    }
1656
1657    // Fill the grid.
1658    list<LabelInfo*>::const_iterator pos = m_Parent->GetLabels();
1659    list<LabelInfo*>::const_iterator end = m_Parent->GetLabelsEnd();
1660    while (pos != end) {
1661        LabelInfo* label = *pos++;
1662
1663        if (!((m_Surface && label->IsSurface()) ||
1664              (m_Legs && label->IsUnderground()) ||
1665              (!label->IsSurface() && !label->IsUnderground()))) {
1666            // if this station isn't to be displayed, skip to the next
1667            // (last case is for stns with no legs attached)
1668            continue;
1669        }
1670
1671        // Calculate screen coordinates.
1672        double cx, cy, cz;
1673        Transform(*label, &cx, &cy, &cz);
1674        if (cx < 0 || cx >= GetXSize()) continue;
1675        if (cy < 0 || cy >= GetYSize()) continue;
1676
1677        cy = GetYSize() - cy;
1678
1679        // On-screen, so add to hit-test grid...
1680        int grid_x = int(cx * HITTEST_SIZE / (GetXSize() + 1));
1681        int grid_y = int(cy * HITTEST_SIZE / (GetYSize() + 1));
1682
1683        m_PointGrid[grid_x + grid_y * HITTEST_SIZE].push_back(label);
1684    }
1685
1686    m_HitTestGridValid = true;
1687}
1688
1689//
1690//  Methods for controlling the orientation of the survey
1691//
1692
1693void GfxCore::TurnCave(Double angle)
1694{
1695    // Turn the cave around its z-axis by a given angle.
1696
1697    m_PanAngle += angle;
1698    // Wrap to range [0, 360):
1699    m_PanAngle = fmod(m_PanAngle, 360.0);
1700    if (m_PanAngle < 0.0) {
1701        m_PanAngle += 360.0;
1702    }
1703
1704    m_HitTestGridValid = false;
1705    if (m_here && m_here == &temp_here) SetHere();
1706
1707    SetRotation(m_PanAngle, m_TiltAngle);
1708}
1709
1710void GfxCore::TurnCaveTo(Double angle)
1711{
1712    if (m_Rotating) {
1713        // If we're rotating, jump to the specified angle.
1714        TurnCave(angle - m_PanAngle);
1715        SetPanBase();
1716        return;
1717    }
1718
1719    int new_switching_to = ((int)angle) / 90 + NORTH;
1720    if (new_switching_to == m_SwitchingTo) {
1721        // A second order to switch takes us there right away
1722        TurnCave(angle - m_PanAngle);
1723        m_SwitchingTo = 0;
1724        ForceRefresh();
1725    } else {
1726        SetPanBase();
1727        m_SwitchingTo = new_switching_to;
1728    }
1729}
1730
1731void GfxCore::TiltCave(Double tilt_angle)
1732{
1733    // Tilt the cave by a given angle.
1734    if (m_TiltAngle + tilt_angle > 90.0) {
1735        m_TiltAngle = 90.0;
1736    } else if (m_TiltAngle + tilt_angle < -90.0) {
1737        m_TiltAngle = -90.0;
1738    } else {
1739        m_TiltAngle += tilt_angle;
1740    }
1741
1742    m_HitTestGridValid = false;
1743    if (m_here && m_here == &temp_here) SetHere();
1744
1745    SetRotation(m_PanAngle, m_TiltAngle);
1746}
1747
1748void GfxCore::TranslateCave(int dx, int dy)
1749{
1750    AddTranslationScreenCoordinates(dx, dy);
1751    m_HitTestGridValid = false;
1752
1753    if (m_here && m_here == &temp_here) SetHere();
1754
1755    ForceRefresh();
1756}
1757
1758void GfxCore::DragFinished()
1759{
1760    m_MouseOutsideCompass = m_MouseOutsideElev = false;
1761    ForceRefresh();
1762}
1763
1764void GfxCore::ClearCoords()
1765{
1766    m_Parent->ClearCoords();
1767}
1768
1769void GfxCore::SetCoords(wxPoint point)
1770{
1771    // We can't work out 2D coordinates from a perspective view, and it
1772    // doesn't really make sense to show coordinates while we're animating.
1773    if (GetPerspective() || Animating()) return;
1774
1775    // Update the coordinate or altitude display, given the (x, y) position in
1776    // window coordinates.  The relevant display is updated depending on
1777    // whether we're in plan or elevation view.
1778
1779    double cx, cy, cz;
1780
1781    SetDataTransform();
1782    ReverseTransform(point.x, GetYSize() - 1 - point.y, &cx, &cy, &cz);
1783
1784    if (ShowingPlan()) {
1785        m_Parent->SetCoords(cx + m_Parent->GetOffset().GetX(),
1786                            cy + m_Parent->GetOffset().GetY(),
1787                            m_there);
1788    } else if (ShowingElevation()) {
1789        m_Parent->SetAltitude(cz + m_Parent->GetOffset().GetZ(),
1790                              m_there);
1791    } else {
1792        m_Parent->ClearCoords();
1793    }
1794}
1795
1796int GfxCore::GetCompassXPosition() const
1797{
1798    // Return the x-coordinate of the centre of the compass in window
1799    // coordinates.
1800    return GetXSize() - INDICATOR_OFFSET_X - INDICATOR_BOX_SIZE / 2;
1801}
1802
1803int GfxCore::GetClinoXPosition() const
1804{
1805    // Return the x-coordinate of the centre of the compass in window
1806    // coordinates.
1807    return GetXSize() - GetClinoOffset() - INDICATOR_BOX_SIZE / 2;
1808}
1809
1810int GfxCore::GetIndicatorYPosition() const
1811{
1812    // Return the y-coordinate of the centre of the indicators in window
1813    // coordinates.
1814    return GetYSize() - INDICATOR_OFFSET_Y - INDICATOR_BOX_SIZE / 2;
1815}
1816
1817int GfxCore::GetIndicatorRadius() const
1818{
1819    // Return the radius of each indicator.
1820    return (INDICATOR_BOX_SIZE - INDICATOR_MARGIN * 2) / 2;
1821}
1822
1823bool GfxCore::PointWithinCompass(wxPoint point) const
1824{
1825    // Determine whether a point (in window coordinates) lies within the
1826    // compass.
1827    if (!ShowingCompass()) return false;
1828
1829    glaCoord dx = point.x - GetCompassXPosition();
1830    glaCoord dy = point.y - GetIndicatorYPosition();
1831    glaCoord radius = GetIndicatorRadius();
1832
1833    return (dx * dx + dy * dy <= radius * radius);
1834}
1835
1836bool GfxCore::PointWithinClino(wxPoint point) const
1837{
1838    // Determine whether a point (in window coordinates) lies within the clino.
1839    if (!ShowingClino()) return false;
1840
1841    glaCoord dx = point.x - GetClinoXPosition();
1842    glaCoord dy = point.y - GetIndicatorYPosition();
1843    glaCoord radius = GetIndicatorRadius();
1844
1845    return (dx * dx + dy * dy <= radius * radius);
1846}
1847
1848bool GfxCore::PointWithinScaleBar(wxPoint point) const
1849{
1850    // Determine whether a point (in window coordinates) lies within the scale
1851    // bar.
1852    if (!ShowingScaleBar()) return false;
1853
1854    return (point.x >= SCALE_BAR_OFFSET_X &&
1855            point.x <= SCALE_BAR_OFFSET_X + m_ScaleBarWidth &&
1856            point.y <= GetYSize() - SCALE_BAR_OFFSET_Y - SCALE_BAR_HEIGHT &&
1857            point.y >= GetYSize() - SCALE_BAR_OFFSET_Y - SCALE_BAR_HEIGHT*2);
1858}
1859
1860bool GfxCore::PointWithinColourKey(wxPoint point) const
1861{
1862    // Determine whether a point (in window coordinates) lies within the key.
1863    point.x -= GetXSize() - KEY_OFFSET_X;
1864    point.y = KEY_OFFSET_Y - point.y;
1865    return (point.x >= key_lowerleft[m_ColourBy].x && point.x <= 0 &&
1866            point.y >= key_lowerleft[m_ColourBy].y && point.y <= 0);
1867}
1868
1869void GfxCore::SetCompassFromPoint(wxPoint point)
1870{
1871    // Given a point in window coordinates, set the heading of the survey.  If
1872    // the point is outside the compass, it snaps to 45 degree intervals;
1873    // otherwise it operates as normal.
1874
1875    wxCoord dx = point.x - GetCompassXPosition();
1876    wxCoord dy = point.y - GetIndicatorYPosition();
1877    wxCoord radius = GetIndicatorRadius();
1878
1879    double angle = deg(atan2(double(dx), double(dy))) - 180.0;
1880    if (dx * dx + dy * dy <= radius * radius) {
1881        TurnCave(angle - m_PanAngle);
1882        m_MouseOutsideCompass = false;
1883    } else {
1884        TurnCave(int(angle / 45.0) * 45.0 - m_PanAngle);
1885        m_MouseOutsideCompass = true;
1886    }
1887
1888    ForceRefresh();
1889}
1890
1891void GfxCore::SetClinoFromPoint(wxPoint point)
1892{
1893    // Given a point in window coordinates, set the elevation of the survey.
1894    // If the point is outside the clino, it snaps to 90 degree intervals;
1895    // otherwise it operates as normal.
1896
1897    glaCoord dx = point.x - GetClinoXPosition();
1898    glaCoord dy = point.y - GetIndicatorYPosition();
1899    glaCoord radius = GetIndicatorRadius();
1900
1901    if (dx >= 0 && dx * dx + dy * dy <= radius * radius) {
1902        TiltCave(-deg(atan2(double(dy), double(dx))) - m_TiltAngle);
1903        m_MouseOutsideElev = false;
1904    } else if (dy >= INDICATOR_MARGIN) {
1905        TiltCave(-90.0 - m_TiltAngle);
1906        m_MouseOutsideElev = true;
1907    } else if (dy <= -INDICATOR_MARGIN) {
1908        TiltCave(90.0 - m_TiltAngle);
1909        m_MouseOutsideElev = true;
1910    } else {
1911        TiltCave(-m_TiltAngle);
1912        m_MouseOutsideElev = true;
1913    }
1914
1915    ForceRefresh();
1916}
1917
1918void GfxCore::SetScaleBarFromOffset(wxCoord dx)
1919{
1920    // Set the scale of the survey, given an offset as to how much the mouse has
1921    // been dragged over the scalebar since the last scale change.
1922
1923    SetScale((m_ScaleBarWidth + dx) * m_Scale / m_ScaleBarWidth);
1924    ForceRefresh();
1925}
1926
1927void GfxCore::RedrawIndicators()
1928{
1929    // Redraw the compass and clino indicators.
1930
1931    RefreshRect(wxRect(GetXSize() - INDICATOR_OFFSET_X - INDICATOR_BOX_SIZE*2 -
1932                       INDICATOR_GAP,
1933                       GetYSize() - INDICATOR_OFFSET_Y - INDICATOR_BOX_SIZE,
1934                       INDICATOR_BOX_SIZE*2 + INDICATOR_GAP,
1935                       INDICATOR_BOX_SIZE), false);
1936}
1937
1938void GfxCore::StartRotation()
1939{
1940    // Start the survey rotating.
1941
1942    if (m_SwitchingTo >= NORTH)
1943        m_SwitchingTo = 0;
1944    m_Rotating = true;
1945    SetPanBase();
1946}
1947
1948void GfxCore::ToggleRotation()
1949{
1950    // Toggle the survey rotation on/off.
1951
1952    if (m_Rotating) {
1953        StopRotation();
1954    } else {
1955        StartRotation();
1956    }
1957}
1958
1959void GfxCore::StopRotation()
1960{
1961    // Stop the survey rotating.
1962
1963    m_Rotating = false;
1964    ForceRefresh();
1965}
1966
1967bool GfxCore::IsExtendedElevation() const
1968{
1969    return m_Parent->IsExtendedElevation();
1970}
1971
1972void GfxCore::ReverseRotation()
1973{
1974    // Reverse the direction of rotation.
1975
1976    m_RotationStep = -m_RotationStep;
1977    if (m_Rotating)
1978        SetPanBase();
1979}
1980
1981void GfxCore::RotateSlower(bool accel)
1982{
1983    // Decrease the speed of rotation, optionally by an increased amount.
1984    if (fabs(m_RotationStep) == 1.0)
1985        return;
1986
1987    m_RotationStep *= accel ? (1 / 1.44) : (1 / 1.2);
1988
1989    if (fabs(m_RotationStep) < 1.0) {
1990        m_RotationStep = (m_RotationStep > 0 ? 1.0 : -1.0);
1991    }
1992    if (m_Rotating)
1993        SetPanBase();
1994}
1995
1996void GfxCore::RotateFaster(bool accel)
1997{
1998    // Increase the speed of rotation, optionally by an increased amount.
1999    if (fabs(m_RotationStep) == 180.0)
2000        return;
2001
2002    m_RotationStep *= accel ? 1.44 : 1.2;
2003    if (fabs(m_RotationStep) > 180.0) {
2004        m_RotationStep = (m_RotationStep > 0 ? 180.0 : -180.0);
2005    }
2006    if (m_Rotating)
2007        SetPanBase();
2008}
2009
2010void GfxCore::SwitchToElevation()
2011{
2012    // Perform an animated switch to elevation view.
2013
2014    if (m_SwitchingTo != ELEVATION) {
2015        SetTiltBase();
2016        m_SwitchingTo = ELEVATION;
2017    } else {
2018        // A second order to switch takes us there right away
2019        TiltCave(-m_TiltAngle);
2020        m_SwitchingTo = 0;
2021        ForceRefresh();
2022    }
2023}
2024
2025void GfxCore::SwitchToPlan()
2026{
2027    // Perform an animated switch to plan view.
2028
2029    if (m_SwitchingTo != PLAN) {
2030        SetTiltBase();
2031        m_SwitchingTo = PLAN;
2032    } else {
2033        // A second order to switch takes us there right away
2034        TiltCave(-90.0 - m_TiltAngle);
2035        m_SwitchingTo = 0;
2036        ForceRefresh();
2037    }
2038}
2039
2040void GfxCore::SetViewTo(Double xmin, Double xmax, Double ymin, Double ymax, Double zmin, Double zmax)
2041{
2042
2043    SetTranslation(-Vector3((xmin + xmax) / 2, (ymin + ymax) / 2, (zmin + zmax) / 2));
2044    Double scale = HUGE_VAL;
2045    const Vector3 ext = m_Parent->GetExtent();
2046    if (xmax > xmin) {
2047        Double s = ext.GetX() / (xmax - xmin);
2048        if (s < scale) scale = s;
2049    }
2050    if (ymax > ymin) {
2051        Double s = ext.GetY() / (ymax - ymin);
2052        if (s < scale) scale = s;
2053    }
2054    if (!ShowingPlan() && zmax > zmin) {
2055        Double s = ext.GetZ() / (zmax - zmin);
2056        if (s < scale) scale = s;
2057    }
2058    if (scale != HUGE_VAL) SetScale(scale);
2059    ForceRefresh();
2060}
2061
2062bool GfxCore::CanRaiseViewpoint() const
2063{
2064    // Determine if the survey can be viewed from a higher angle of elevation.
2065
2066    return GetPerspective() ? (m_TiltAngle < 90.0) : (m_TiltAngle > -90.0);
2067}
2068
2069bool GfxCore::CanLowerViewpoint() const
2070{
2071    // Determine if the survey can be viewed from a lower angle of elevation.
2072
2073    return GetPerspective() ? (m_TiltAngle > -90.0) : (m_TiltAngle < 90.0);
2074}
2075
2076bool GfxCore::HasDepth() const
2077{
2078    return m_Parent->GetDepthExtent() == 0.0;
2079}
2080
2081bool GfxCore::HasErrorInformation() const
2082{
2083    return m_Parent->HasErrorInformation();
2084}
2085
2086bool GfxCore::HasDateInformation() const
2087{
2088    return m_Parent->GetDateMin() >= 0;
2089}
2090
2091bool GfxCore::ShowingPlan() const
2092{
2093    // Determine if the survey is in plan view.
2094
2095    return (m_TiltAngle == -90.0);
2096}
2097
2098bool GfxCore::ShowingElevation() const
2099{
2100    // Determine if the survey is in elevation view.
2101
2102    return (m_TiltAngle == 0.0);
2103}
2104
2105bool GfxCore::ShowingMeasuringLine() const
2106{
2107    // Determine if the measuring line is being shown.  Only check if "there"
2108    // is valid, since that means the measuring line anchor is out.
2109
2110    return m_there;
2111}
2112
2113void GfxCore::ToggleFlag(bool* flag, int update)
2114{
2115    *flag = !*flag;
2116    if (update == UPDATE_BLOBS) {
2117        UpdateBlobs();
2118    } else if (update == UPDATE_BLOBS_AND_CROSSES) {
2119        UpdateBlobs();
2120        InvalidateList(LIST_CROSSES);
2121        m_HitTestGridValid = false;
2122    }
2123    ForceRefresh();
2124}
2125
2126int GfxCore::GetNumEntrances() const
2127{
2128    return m_Parent->GetNumEntrances();
2129}
2130
2131int GfxCore::GetNumFixedPts() const
2132{
2133    return m_Parent->GetNumFixedPts();
2134}
2135
2136int GfxCore::GetNumExportedPts() const
2137{
2138    return m_Parent->GetNumExportedPts();
2139}
2140
2141void GfxCore::ToggleFatFinger()
2142{
2143    if (sqrd_measure_threshold == sqrd(MEASURE_THRESHOLD)) {
2144        sqrd_measure_threshold = sqrd(5 * MEASURE_THRESHOLD);
2145        wxMessageBox("Fat finger enabled", "Aven Debug", wxOK | wxICON_INFORMATION);
2146    } else {
2147        sqrd_measure_threshold = sqrd(MEASURE_THRESHOLD);
2148        wxMessageBox("Fat finger disabled", "Aven Debug", wxOK | wxICON_INFORMATION);
2149    }
2150}
2151
2152void GfxCore::ClearTreeSelection()
2153{
2154    m_Parent->ClearTreeSelection();
2155}
2156
2157void GfxCore::CentreOn(const Point &p)
2158{
2159    SetTranslation(-p);
2160    m_HitTestGridValid = false;
2161
2162    ForceRefresh();
2163}
2164
2165void GfxCore::ForceRefresh()
2166{
2167    Refresh(false);
2168}
2169
2170void GfxCore::GenerateList(unsigned int l)
2171{
2172    assert(m_HaveData);
2173
2174    switch (l) {
2175        case LIST_COMPASS:
2176            DrawCompass();
2177            break;
2178        case LIST_CLINO:
2179            DrawClino();
2180            break;
2181        case LIST_CLINO_BACK:
2182            DrawClinoBack();
2183            break;
2184        case LIST_SCALE_BAR:
2185            DrawScaleBar();
2186            break;
2187        case LIST_DEPTH_KEY:
2188            DrawDepthKey();
2189            break;
2190        case LIST_DATE_KEY:
2191            DrawDateKey();
2192            break;
2193        case LIST_ERROR_KEY:
2194            DrawErrorKey();
2195            break;
2196        case LIST_UNDERGROUND_LEGS:
2197            GenerateDisplayList();
2198            break;
2199        case LIST_TUBES:
2200            GenerateDisplayListTubes();
2201            break;
2202        case LIST_SURFACE_LEGS:
2203            GenerateDisplayListSurface();
2204            break;
2205        case LIST_BLOBS:
2206            GenerateBlobsDisplayList();
2207            break;
2208        case LIST_CROSSES: {
2209            BeginCrosses();
2210            SetColour(col_LIGHT_GREY);
2211            list<LabelInfo*>::const_iterator pos = m_Parent->GetLabels();
2212            while (pos != m_Parent->GetLabelsEnd()) {
2213                const LabelInfo* label = *pos++;
2214
2215                if ((m_Surface && label->IsSurface()) ||
2216                    (m_Legs && label->IsUnderground()) ||
2217                    (!label->IsSurface() && !label->IsUnderground())) {
2218                    // Check if this station should be displayed
2219                    // (last case is for stns with no legs attached)
2220                    DrawCross(label->GetX(), label->GetY(), label->GetZ());
2221                }
2222            }
2223            EndCrosses();
2224            break;
2225        }
2226        case LIST_GRID:
2227            DrawGrid();
2228            break;
2229        case LIST_SHADOW:
2230            GenerateDisplayListShadow();
2231            break;
2232        default:
2233            assert(false);
2234            break;
2235    }
2236}
2237
2238void GfxCore::ToggleSmoothShading()
2239{
2240    GLACanvas::ToggleSmoothShading();
2241    InvalidateList(LIST_TUBES);
2242    ForceRefresh();
2243}
2244
2245void GfxCore::GenerateDisplayList()
2246{
2247    // Generate the display list for the underground legs.
2248    list<traverse>::const_iterator trav = m_Parent->traverses_begin();
2249    list<traverse>::const_iterator tend = m_Parent->traverses_end();
2250
2251    if (m_Splays == SPLAYS_SHOW_FADED) {
2252        SetAlpha(0.4);
2253        while (trav != tend) {
2254            if ((*trav).isSplay)
2255                (this->*AddPoly)(*trav);
2256            ++trav;
2257        }
2258        SetAlpha(1.0);
2259        trav = m_Parent->traverses_begin();
2260    }
2261
2262    while (trav != tend) {
2263        if (m_Splays == SPLAYS_SHOW_NORMAL || !(*trav).isSplay)
2264            (this->*AddPoly)(*trav);
2265        ++trav;
2266    }
2267}
2268
2269void GfxCore::GenerateDisplayListTubes()
2270{
2271    // Generate the display list for the tubes.
2272    list<vector<XSect> >::iterator trav = m_Parent->tubes_begin();
2273    list<vector<XSect> >::iterator tend = m_Parent->tubes_end();
2274    while (trav != tend) {
2275        SkinPassage(*trav);
2276        ++trav;
2277    }
2278}
2279
2280void GfxCore::GenerateDisplayListSurface()
2281{
2282    // Generate the display list for the surface legs.
2283    EnableDashedLines();
2284    list<traverse>::const_iterator trav = m_Parent->surface_traverses_begin();
2285    list<traverse>::const_iterator tend = m_Parent->surface_traverses_end();
2286    while (trav != tend) {
2287        if (m_ColourBy == COLOUR_BY_ERROR) {
2288            AddPolylineError(*trav);
2289        } else {
2290            AddPolyline(*trav);
2291        }
2292        ++trav;
2293    }
2294    DisableDashedLines();
2295}
2296
2297void GfxCore::GenerateDisplayListShadow()
2298{
2299    SetColour(col_BLACK);
2300    list<traverse>::const_iterator trav = m_Parent->traverses_begin();
2301    list<traverse>::const_iterator tend = m_Parent->traverses_end();
2302    while (trav != tend) {
2303        AddPolylineShadow(*trav);
2304        ++trav;
2305    }
2306}
2307
2308// Plot blobs.
2309void GfxCore::GenerateBlobsDisplayList()
2310{
2311    if (!(m_Entrances || m_FixedPts || m_ExportedPts ||
2312          m_Parent->GetNumHighlightedPts()))
2313        return;
2314
2315    // Plot blobs.
2316    gla_colour prev_col = col_BLACK; // not a colour used for blobs
2317    list<LabelInfo*>::const_iterator pos = m_Parent->GetLabels();
2318    BeginBlobs();
2319    while (pos != m_Parent->GetLabelsEnd()) {
2320        const LabelInfo* label = *pos++;
2321
2322        // When more than one flag is set on a point:
2323        // search results take priority over entrance highlighting
2324        // which takes priority over fixed point
2325        // highlighting, which in turn takes priority over exported
2326        // point highlighting.
2327
2328        if (!((m_Surface && label->IsSurface()) ||
2329              (m_Legs && label->IsUnderground()) ||
2330              (!label->IsSurface() && !label->IsUnderground()))) {
2331            // if this station isn't to be displayed, skip to the next
2332            // (last case is for stns with no legs attached)
2333            continue;
2334        }
2335
2336        gla_colour col;
2337
2338        if (label->IsHighLighted()) {
2339            col = col_YELLOW;
2340        } else if (m_Entrances && label->IsEntrance()) {
2341            col = col_GREEN;
2342        } else if (m_FixedPts && label->IsFixedPt()) {
2343            col = col_RED;
2344        } else if (m_ExportedPts && label->IsExportedPt()) {
2345            col = col_TURQUOISE;
2346        } else {
2347            continue;
2348        }
2349
2350        // Stations are sorted by blob type, so colour changes are infrequent.
2351        if (col != prev_col) {
2352            SetColour(col);
2353            prev_col = col;
2354        }
2355        DrawBlob(label->GetX(), label->GetY(), label->GetZ());
2356    }
2357    EndBlobs();
2358}
2359
2360void GfxCore::DrawIndicators()
2361{
2362    // Draw colour key.
2363    if (m_ColourKey) {
2364        if (m_ColourBy == COLOUR_BY_DEPTH) {
2365            DrawList2D(LIST_DEPTH_KEY, GetXSize() - KEY_OFFSET_X,
2366                       GetYSize() - KEY_OFFSET_Y, 0);
2367        } else if (m_ColourBy == COLOUR_BY_DATE) {
2368            DrawList2D(LIST_DATE_KEY, GetXSize() - KEY_OFFSET_X,
2369                       GetYSize() - KEY_OFFSET_Y, 0);
2370        } else if (m_ColourBy == COLOUR_BY_ERROR) {
2371            DrawList2D(LIST_ERROR_KEY, GetXSize() - KEY_OFFSET_X,
2372                       GetYSize() - KEY_OFFSET_Y, 0);
2373        }
2374    }
2375
2376    // Draw compass or elevation/heading indicators.
2377    if (m_Compass || m_Clino) {
2378        if (!m_Parent->IsExtendedElevation()) Draw2dIndicators();
2379    }
2380
2381    // Draw scalebar.
2382    if (m_Scalebar) {
2383        DrawList2D(LIST_SCALE_BAR, 0, 0, 0);
2384    }
2385}
2386
2387void GfxCore::PlaceVertexWithColour(const Vector3 & v,
2388                                    glaTexCoord tex_x, glaTexCoord tex_y,
2389                                    Double factor)
2390{
2391    SetColour(col_WHITE, factor);
2392    PlaceVertex(v, tex_x, tex_y);
2393}
2394
2395void GfxCore::SetDepthColour(Double z, Double factor) {
2396    // Set the drawing colour based on the altitude.
2397    Double z_ext = m_Parent->GetDepthExtent();
2398
2399    z -= m_Parent->GetDepthMin();
2400    // points arising from tubes may be slightly outside the limits...
2401    if (z < 0) z = 0;
2402    if (z > z_ext) z = z_ext;
2403
2404    if (z == 0) {
2405        SetColour(GetPen(0), factor);
2406        return;
2407    }
2408
2409    assert(z_ext > 0.0);
2410    Double how_far = z / z_ext;
2411    assert(how_far >= 0.0);
2412    assert(how_far <= 1.0);
2413
2414    int band = int(floor(how_far * (GetNumColourBands() - 1)));
2415    GLAPen pen1 = GetPen(band);
2416    if (band < GetNumColourBands() - 1) {
2417        const GLAPen& pen2 = GetPen(band + 1);
2418
2419        Double interval = z_ext / (GetNumColourBands() - 1);
2420        Double into_band = z / interval - band;
2421
2422//      printf("%g z_offset=%g interval=%g band=%d\n", into_band,
2423//             z_offset, interval, band);
2424        // FIXME: why do we need to clamp here?  Is it because the walls can
2425        // extend further up/down than the centre-line?
2426        if (into_band < 0.0) into_band = 0.0;
2427        if (into_band > 1.0) into_band = 1.0;
2428        assert(into_band >= 0.0);
2429        assert(into_band <= 1.0);
2430
2431        pen1.Interpolate(pen2, into_band);
2432    }
2433    SetColour(pen1, factor);
2434}
2435
2436void GfxCore::PlaceVertexWithDepthColour(const Vector3 &v, Double factor)
2437{
2438    SetDepthColour(v.GetZ(), factor);
2439    PlaceVertex(v);
2440}
2441
2442void GfxCore::PlaceVertexWithDepthColour(const Vector3 &v,
2443                                         glaTexCoord tex_x, glaTexCoord tex_y,
2444                                         Double factor)
2445{
2446    SetDepthColour(v.GetZ(), factor);
2447    PlaceVertex(v, tex_x, tex_y);
2448}
2449
2450void GfxCore::SplitLineAcrossBands(int band, int band2,
2451                                   const Vector3 &p, const Vector3 &q,
2452                                   Double factor)
2453{
2454    const int step = (band < band2) ? 1 : -1;
2455    for (int i = band; i != band2; i += step) {
2456        const Double z = GetDepthBoundaryBetweenBands(i, i + step);
2457
2458        // Find the intersection point of the line p -> q
2459        // with the plane parallel to the xy-plane with z-axis intersection z.
2460        assert(q.GetZ() - p.GetZ() != 0.0);
2461
2462        const Double t = (z - p.GetZ()) / (q.GetZ() - p.GetZ());
2463//      assert(0.0 <= t && t <= 1.0);           FIXME: rounding problems!
2464
2465        const Double x = p.GetX() + t * (q.GetX() - p.GetX());
2466        const Double y = p.GetY() + t * (q.GetY() - p.GetY());
2467
2468        PlaceVertexWithDepthColour(Vector3(x, y, z), factor);
2469    }
2470}
2471
2472int GfxCore::GetDepthColour(Double z) const
2473{
2474    // Return the (0-based) depth colour band index for a z-coordinate.
2475    Double z_ext = m_Parent->GetDepthExtent();
2476    z -= m_Parent->GetDepthMin();
2477    // We seem to get rounding differences causing z to sometimes be slightly
2478    // less than GetDepthMin() here, and it can certainly be true for passage
2479    // tubes, so just clamp the value to 0.
2480    if (z <= 0) return 0;
2481    // We seem to get rounding differences causing z to sometimes exceed z_ext
2482    // by a small amount here (see: http://trac.survex.com/ticket/26) and it
2483    // can certainly be true for passage tubes, so just clamp the value.
2484    if (z >= z_ext) return GetNumColourBands() - 1;
2485    return int(z / z_ext * (GetNumColourBands() - 1));
2486}
2487
2488Double GfxCore::GetDepthBoundaryBetweenBands(int a, int b) const
2489{
2490    // Return the z-coordinate of the depth colour boundary between
2491    // two adjacent depth colour bands (specified by 0-based indices).
2492
2493    assert((a == b - 1) || (a == b + 1));
2494    if (GetNumColourBands() == 1) return 0;
2495
2496    int band = (a > b) ? a : b; // boundary N lies on the bottom of band N.
2497    Double z_ext = m_Parent->GetDepthExtent();
2498    return (z_ext * band / (GetNumColourBands() - 1)) + m_Parent->GetDepthMin();
2499}
2500
2501void GfxCore::AddPolyline(const traverse & centreline)
2502{
2503    BeginPolyline();
2504    SetColour(col_WHITE);
2505    vector<PointInfo>::const_iterator i = centreline.begin();
2506    PlaceVertex(*i);
2507    ++i;
2508    while (i != centreline.end()) {
2509        PlaceVertex(*i);
2510        ++i;
2511    }
2512    EndPolyline();
2513}
2514
2515void GfxCore::AddPolylineShadow(const traverse & centreline)
2516{
2517    BeginPolyline();
2518    const double z = -0.5 * m_Parent->GetZExtent();
2519    vector<PointInfo>::const_iterator i = centreline.begin();
2520    PlaceVertex(i->GetX(), i->GetY(), z);
2521    ++i;
2522    while (i != centreline.end()) {
2523        PlaceVertex(i->GetX(), i->GetY(), z);
2524        ++i;
2525    }
2526    EndPolyline();
2527}
2528
2529void GfxCore::AddPolylineDepth(const traverse & centreline)
2530{
2531    BeginPolyline();
2532    vector<PointInfo>::const_iterator i, prev_i;
2533    i = centreline.begin();
2534    int band0 = GetDepthColour(i->GetZ());
2535    PlaceVertexWithDepthColour(*i);
2536    prev_i = i;
2537    ++i;
2538    while (i != centreline.end()) {
2539        int band = GetDepthColour(i->GetZ());
2540        if (band != band0) {
2541            SplitLineAcrossBands(band0, band, *prev_i, *i);
2542            band0 = band;
2543        }
2544        PlaceVertexWithDepthColour(*i);
2545        prev_i = i;
2546        ++i;
2547    }
2548    EndPolyline();
2549}
2550
2551void GfxCore::AddQuadrilateral(const Vector3 &a, const Vector3 &b,
2552                               const Vector3 &c, const Vector3 &d)
2553{
2554    Vector3 normal = (a - c) * (d - b);
2555    normal.normalise();
2556    Double factor = dot(normal, light) * .3 + .7;
2557    glaTexCoord w(ceil(((b - a).magnitude() + (d - c).magnitude()) * .5));
2558    glaTexCoord h(ceil(((b - c).magnitude() + (d - a).magnitude()) * .5));
2559    // FIXME: should plot triangles instead to avoid rendering glitches.
2560    BeginQuadrilaterals();
2561    PlaceVertexWithColour(a, 0, 0, factor);
2562    PlaceVertexWithColour(b, w, 0, factor);
2563    PlaceVertexWithColour(c, w, h, factor);
2564    PlaceVertexWithColour(d, 0, h, factor);
2565    EndQuadrilaterals();
2566}
2567
2568void GfxCore::AddQuadrilateralDepth(const Vector3 &a, const Vector3 &b,
2569                                    const Vector3 &c, const Vector3 &d)
2570{
2571    Vector3 normal = (a - c) * (d - b);
2572    normal.normalise();
2573    Double factor = dot(normal, light) * .3 + .7;
2574    int a_band, b_band, c_band, d_band;
2575    a_band = GetDepthColour(a.GetZ());
2576    a_band = min(max(a_band, 0), GetNumColourBands());
2577    b_band = GetDepthColour(b.GetZ());
2578    b_band = min(max(b_band, 0), GetNumColourBands());
2579    c_band = GetDepthColour(c.GetZ());
2580    c_band = min(max(c_band, 0), GetNumColourBands());
2581    d_band = GetDepthColour(d.GetZ());
2582    d_band = min(max(d_band, 0), GetNumColourBands());
2583    // All this splitting is incorrect - we need to make a separate polygon
2584    // for each depth band...
2585    glaTexCoord w(ceil(((b - a).magnitude() + (d - c).magnitude()) * .5));
2586    glaTexCoord h(ceil(((b - c).magnitude() + (d - a).magnitude()) * .5));
2587    BeginPolygon();
2588////    PlaceNormal(normal);
2589    PlaceVertexWithDepthColour(a, 0, 0, factor);
2590    if (a_band != b_band) {
2591        SplitLineAcrossBands(a_band, b_band, a, b, factor);
2592    }
2593    PlaceVertexWithDepthColour(b, w, 0, factor);
2594    if (b_band != c_band) {
2595        SplitLineAcrossBands(b_band, c_band, b, c, factor);
2596    }
2597    PlaceVertexWithDepthColour(c, w, h, factor);
2598    if (c_band != d_band) {
2599        SplitLineAcrossBands(c_band, d_band, c, d, factor);
2600    }
2601    PlaceVertexWithDepthColour(d, 0, h, factor);
2602    if (d_band != a_band) {
2603        SplitLineAcrossBands(d_band, a_band, d, a, factor);
2604    }
2605    EndPolygon();
2606}
2607
2608void GfxCore::SetColourFromDate(int date, Double factor)
2609{
2610    // Set the drawing colour based on a date.
2611
2612    if (date == -1) {
2613        // Undated.
2614        SetColour(col_WHITE, factor);
2615        return;
2616    }
2617
2618    int date_offset = date - m_Parent->GetDateMin();
2619    if (date_offset == 0) {
2620        // Earliest date - handle as a special case for the single date case.
2621        SetColour(GetPen(0), factor);
2622        return;
2623    }
2624
2625    int date_ext = m_Parent->GetDateExtent();
2626    Double how_far = (Double)date_offset / date_ext;
2627    assert(how_far >= 0.0);
2628    assert(how_far <= 1.0);
2629
2630    int band = int(floor(how_far * (GetNumColourBands() - 1)));
2631    GLAPen pen1 = GetPen(band);
2632    if (band < GetNumColourBands() - 1) {
2633        const GLAPen& pen2 = GetPen(band + 1);
2634
2635        Double interval = date_ext / (GetNumColourBands() - 1);
2636        Double into_band = date_offset / interval - band;
2637
2638//      printf("%g z_offset=%g interval=%g band=%d\n", into_band,
2639//             z_offset, interval, band);
2640        // FIXME: why do we need to clamp here?  Is it because the walls can
2641        // extend further up/down than the centre-line?
2642        if (into_band < 0.0) into_band = 0.0;
2643        if (into_band > 1.0) into_band = 1.0;
2644        assert(into_band >= 0.0);
2645        assert(into_band <= 1.0);
2646
2647        pen1.Interpolate(pen2, into_band);
2648    }
2649    SetColour(pen1, factor);
2650}
2651
2652void GfxCore::AddPolylineDate(const traverse & centreline)
2653{
2654    BeginPolyline();
2655    vector<PointInfo>::const_iterator i, prev_i;
2656    i = centreline.begin();
2657    int date = i->GetDate();
2658    SetColourFromDate(date, 1.0);
2659    PlaceVertex(*i);
2660    prev_i = i;
2661    while (++i != centreline.end()) {
2662        int newdate = i->GetDate();
2663        if (newdate != date) {
2664            EndPolyline();
2665            BeginPolyline();
2666            date = newdate;
2667            SetColourFromDate(date, 1.0);
2668            PlaceVertex(*prev_i);
2669        }
2670        PlaceVertex(*i);
2671        prev_i = i;
2672    }
2673    EndPolyline();
2674}
2675
2676static int static_date_hack; // FIXME
2677
2678void GfxCore::AddQuadrilateralDate(const Vector3 &a, const Vector3 &b,
2679                                   const Vector3 &c, const Vector3 &d)
2680{
2681    Vector3 normal = (a - c) * (d - b);
2682    normal.normalise();
2683    Double factor = dot(normal, light) * .3 + .7;
2684    int w = int(ceil(((b - a).magnitude() + (d - c).magnitude()) / 2));
2685    int h = int(ceil(((b - c).magnitude() + (d - a).magnitude()) / 2));
2686    // FIXME: should plot triangles instead to avoid rendering glitches.
2687    BeginQuadrilaterals();
2688////    PlaceNormal(normal);
2689    SetColourFromDate(static_date_hack, factor);
2690    PlaceVertex(a, 0, 0);
2691    PlaceVertex(b, w, 0);
2692    PlaceVertex(c, w, h);
2693    PlaceVertex(d, 0, h);
2694    EndQuadrilaterals();
2695}
2696
2697static double static_E_hack; // FIXME
2698
2699void GfxCore::SetColourFromError(double E, Double factor)
2700{
2701    // Set the drawing colour based on an error value.
2702
2703    if (E < 0) {
2704        SetColour(col_WHITE, factor);
2705        return;
2706    }
2707
2708    Double how_far = E / MAX_ERROR;
2709    assert(how_far >= 0.0);
2710    if (how_far > 1.0) how_far = 1.0;
2711
2712    int band = int(floor(how_far * (GetNumColourBands() - 1)));
2713    GLAPen pen1 = GetPen(band);
2714    if (band < GetNumColourBands() - 1) {
2715        const GLAPen& pen2 = GetPen(band + 1);
2716
2717        Double interval = MAX_ERROR / (GetNumColourBands() - 1);
2718        Double into_band = E / interval - band;
2719
2720//      printf("%g z_offset=%g interval=%g band=%d\n", into_band,
2721//             z_offset, interval, band);
2722        // FIXME: why do we need to clamp here?  Is it because the walls can
2723        // extend further up/down than the centre-line?
2724        if (into_band < 0.0) into_band = 0.0;
2725        if (into_band > 1.0) into_band = 1.0;
2726        assert(into_band >= 0.0);
2727        assert(into_band <= 1.0);
2728
2729        pen1.Interpolate(pen2, into_band);
2730    }
2731    SetColour(pen1, factor);
2732}
2733
2734void GfxCore::AddQuadrilateralError(const Vector3 &a, const Vector3 &b,
2735                                    const Vector3 &c, const Vector3 &d)
2736{
2737    Vector3 normal = (a - c) * (d - b);
2738    normal.normalise();
2739    Double factor = dot(normal, light) * .3 + .7;
2740    int w = int(ceil(((b - a).magnitude() + (d - c).magnitude()) / 2));
2741    int h = int(ceil(((b - c).magnitude() + (d - a).magnitude()) / 2));
2742    // FIXME: should plot triangles instead to avoid rendering glitches.
2743    BeginQuadrilaterals();
2744////    PlaceNormal(normal);
2745    SetColourFromError(static_E_hack, factor);
2746    PlaceVertex(a, 0, 0);
2747    PlaceVertex(b, w, 0);
2748    PlaceVertex(c, w, h);
2749    PlaceVertex(d, 0, h);
2750    EndQuadrilaterals();
2751}
2752
2753void GfxCore::AddPolylineError(const traverse & centreline)
2754{
2755    BeginPolyline();
2756    SetColourFromError(centreline.E, 1.0);
2757    vector<PointInfo>::const_iterator i;
2758    for(i = centreline.begin(); i != centreline.end(); ++i) {
2759        PlaceVertex(*i);
2760    }
2761    EndPolyline();
2762}
2763
2764void
2765GfxCore::SkinPassage(vector<XSect> & centreline, bool draw)
2766{
2767    assert(centreline.size() > 1);
2768    Vector3 U[4];
2769    XSect prev_pt_v;
2770    Vector3 last_right(1.0, 0.0, 0.0);
2771
2772//  FIXME: it's not simple to set the colour of a tube based on error...
2773//    static_E_hack = something...
2774    vector<XSect>::iterator i = centreline.begin();
2775    vector<XSect>::size_type segment = 0;
2776    while (i != centreline.end()) {
2777        // get the coordinates of this vertex
2778        XSect & pt_v = *i++;
2779
2780        double z_pitch_adjust = 0.0;
2781        bool cover_end = false;
2782
2783        Vector3 right, up;
2784
2785        const Vector3 up_v(0.0, 0.0, 1.0);
2786
2787        if (segment == 0) {
2788            assert(i != centreline.end());
2789            // first segment
2790
2791            // get the coordinates of the next vertex
2792            const XSect & next_pt_v = *i;
2793
2794            // calculate vector from this pt to the next one
2795            Vector3 leg_v = next_pt_v - pt_v;
2796
2797            // obtain a vector in the LRUD plane
2798            right = leg_v * up_v;
2799            if (right.magnitude() == 0) {
2800                right = last_right;
2801                // Obtain a second vector in the LRUD plane,
2802                // perpendicular to the first.
2803                //up = right * leg_v;
2804                up = up_v;
2805            } else {
2806                last_right = right;
2807                up = up_v;
2808            }
2809
2810            cover_end = true;
2811            static_date_hack = next_pt_v.GetDate();
2812        } else if (segment + 1 == centreline.size()) {
2813            // last segment
2814
2815            // Calculate vector from the previous pt to this one.
2816            Vector3 leg_v = pt_v - prev_pt_v;
2817
2818            // Obtain a horizontal vector in the LRUD plane.
2819            right = leg_v * up_v;
2820            if (right.magnitude() == 0) {
2821                right = Vector3(last_right.GetX(), last_right.GetY(), 0.0);
2822                // Obtain a second vector in the LRUD plane,
2823                // perpendicular to the first.
2824                //up = right * leg_v;
2825                up = up_v;
2826            } else {
2827                last_right = right;
2828                up = up_v;
2829            }
2830
2831            cover_end = true;
2832            static_date_hack = pt_v.GetDate();
2833        } else {
2834            assert(i != centreline.end());
2835            // Intermediate segment.
2836
2837            // Get the coordinates of the next vertex.
2838            const XSect & next_pt_v = *i;
2839
2840            // Calculate vectors from this vertex to the
2841            // next vertex, and from the previous vertex to
2842            // this one.
2843            Vector3 leg1_v = pt_v - prev_pt_v;
2844            Vector3 leg2_v = next_pt_v - pt_v;
2845
2846            // Obtain horizontal vectors perpendicular to
2847            // both legs, then normalise and average to get
2848            // a horizontal bisector.
2849            Vector3 r1 = leg1_v * up_v;
2850            Vector3 r2 = leg2_v * up_v;
2851            r1.normalise();
2852            r2.normalise();
2853            right = r1 + r2;
2854            if (right.magnitude() == 0) {
2855                // This is the "mid-pitch" case...
2856                right = last_right;
2857            }
2858            if (r1.magnitude() == 0) {
2859                Vector3 n = leg1_v;
2860                n.normalise();
2861                z_pitch_adjust = n.GetZ();
2862                //up = Vector3(0, 0, leg1_v.GetZ());
2863                //up = right * up;
2864                up = up_v;
2865
2866                // Rotate pitch section to minimise the
2867                // "tortional stress" - FIXME: use
2868                // triangles instead of rectangles?
2869                int shift = 0;
2870                Double maxdotp = 0;
2871
2872                // Scale to unit vectors in the LRUD plane.
2873                right.normalise();
2874                up.normalise();
2875                Vector3 vec = up - right;
2876                for (int orient = 0; orient <= 3; ++orient) {
2877                    Vector3 tmp = U[orient] - prev_pt_v;
2878                    tmp.normalise();
2879                    Double dotp = dot(vec, tmp);
2880                    if (dotp > maxdotp) {
2881                        maxdotp = dotp;
2882                        shift = orient;
2883                    }
2884                }
2885                if (shift) {
2886                    if (shift != 2) {
2887                        Vector3 temp(U[0]);
2888                        U[0] = U[shift];
2889                        U[shift] = U[2];
2890                        U[2] = U[shift ^ 2];
2891                        U[shift ^ 2] = temp;
2892                    } else {
2893                        swap(U[0], U[2]);
2894                        swap(U[1], U[3]);
2895                    }
2896                }
2897#if 0
2898                // Check that the above code actually permuted
2899                // the vertices correctly.
2900                shift = 0;
2901                maxdotp = 0;
2902                for (int j = 0; j <= 3; ++j) {
2903                    Vector3 tmp = U[j] - prev_pt_v;
2904                    tmp.normalise();
2905                    Double dotp = dot(vec, tmp);
2906                    if (dotp > maxdotp) {
2907                        maxdotp = dotp + 1e-6; // Add small tolerance to stop 45 degree offset cases being flagged...
2908                        shift = j;
2909                    }
2910                }
2911                if (shift) {
2912                    printf("New shift = %d!\n", shift);
2913                    shift = 0;
2914                    maxdotp = 0;
2915                    for (int j = 0; j <= 3; ++j) {
2916                        Vector3 tmp = U[j] - prev_pt_v;
2917                        tmp.normalise();
2918                        Double dotp = dot(vec, tmp);
2919                        printf("    %d : %.8f\n", j, dotp);
2920                    }
2921                }
2922#endif
2923            } else if (r2.magnitude() == 0) {
2924                Vector3 n = leg2_v;
2925                n.normalise();
2926                z_pitch_adjust = n.GetZ();
2927                //up = Vector3(0, 0, leg2_v.GetZ());
2928                //up = right * up;
2929                up = up_v;
2930            } else {
2931                up = up_v;
2932            }
2933            last_right = right;
2934            static_date_hack = pt_v.GetDate();
2935        }
2936
2937        // Scale to unit vectors in the LRUD plane.
2938        right.normalise();
2939        up.normalise();
2940
2941        if (z_pitch_adjust != 0) up += Vector3(0, 0, fabs(z_pitch_adjust));
2942
2943        Double l = fabs(pt_v.GetL());
2944        Double r = fabs(pt_v.GetR());
2945        Double u = fabs(pt_v.GetU());
2946        Double d = fabs(pt_v.GetD());
2947
2948        // Produce coordinates of the corners of the LRUD "plane".
2949        Vector3 v[4];
2950        v[0] = pt_v - right * l + up * u;
2951        v[1] = pt_v + right * r + up * u;
2952        v[2] = pt_v + right * r - up * d;
2953        v[3] = pt_v - right * l - up * d;
2954
2955        if (draw) {
2956            if (segment > 0) {
2957                (this->*AddQuad)(v[0], v[1], U[1], U[0]);
2958                (this->*AddQuad)(v[2], v[3], U[3], U[2]);
2959                (this->*AddQuad)(v[1], v[2], U[2], U[1]);
2960                (this->*AddQuad)(v[3], v[0], U[0], U[3]);
2961            }
2962
2963            if (cover_end) {
2964                (this->*AddQuad)(v[3], v[2], v[1], v[0]);
2965            }
2966        }
2967
2968        prev_pt_v = pt_v;
2969        U[0] = v[0];
2970        U[1] = v[1];
2971        U[2] = v[2];
2972        U[3] = v[3];
2973
2974        pt_v.set_right_bearing(deg(atan2(right.GetY(), right.GetX())));
2975
2976        ++segment;
2977    }
2978}
2979
2980void GfxCore::FullScreenMode()
2981{
2982    m_Parent->ViewFullScreen();
2983}
2984
2985bool GfxCore::IsFullScreen() const
2986{
2987    return m_Parent->IsFullScreen();
2988}
2989
2990bool GfxCore::FullScreenModeShowingMenus() const
2991{
2992    return m_Parent->FullScreenModeShowingMenus();
2993}
2994
2995void GfxCore::FullScreenModeShowMenus(bool show)
2996{
2997    m_Parent->FullScreenModeShowMenus(show);
2998}
2999
3000void
3001GfxCore::MoveViewer(double forward, double up, double right)
3002{
3003    double cT = cos(rad(m_TiltAngle));
3004    double sT = sin(rad(m_TiltAngle));
3005    double cP = cos(rad(m_PanAngle));
3006    double sP = sin(rad(m_PanAngle));
3007    Vector3 v_forward(cT * sP, cT * cP, sT);
3008    Vector3 v_up(sT * sP, sT * cP, -cT);
3009    Vector3 v_right(-cP, sP, 0);
3010    assert(fabs(dot(v_forward, v_up)) < 1e-6);
3011    assert(fabs(dot(v_forward, v_right)) < 1e-6);
3012    assert(fabs(dot(v_right, v_up)) < 1e-6);
3013    Vector3 move = v_forward * forward + v_up * up + v_right * right;
3014    AddTranslation(-move);
3015    // Show current position.
3016    m_Parent->SetCoords(m_Parent->GetOffset() - GetTranslation());
3017    ForceRefresh();
3018}
3019
3020PresentationMark GfxCore::GetView() const
3021{
3022    return PresentationMark(GetTranslation() + m_Parent->GetOffset(),
3023                            m_PanAngle, -m_TiltAngle, m_Scale);
3024}
3025
3026void GfxCore::SetView(const PresentationMark & p)
3027{
3028    m_SwitchingTo = 0;
3029    SetTranslation(p - m_Parent->GetOffset());
3030    m_PanAngle = p.angle;
3031    m_TiltAngle = -p.tilt_angle; // FIXME: nasty reversed sense (and above)
3032    SetRotation(m_PanAngle, m_TiltAngle);
3033    SetScale(p.scale);
3034    ForceRefresh();
3035}
3036
3037void GfxCore::PlayPres(double speed, bool change_speed) {
3038    if (!change_speed || presentation_mode == 0) {
3039        if (speed == 0.0) {
3040            presentation_mode = 0;
3041            return;
3042        }
3043        presentation_mode = PLAYING;
3044        next_mark = m_Parent->GetPresMark(MARK_FIRST);
3045        SetView(next_mark);
3046        next_mark_time = 0; // There already!
3047        this_mark_total = 0;
3048        pres_reverse = (speed < 0);
3049    }
3050
3051    if (change_speed) pres_speed = speed;
3052
3053    if (speed != 0.0) {
3054        bool new_pres_reverse = (speed < 0);
3055        if (new_pres_reverse != pres_reverse) {
3056            pres_reverse = new_pres_reverse;
3057            if (pres_reverse) {
3058                next_mark = m_Parent->GetPresMark(MARK_PREV);
3059            } else {
3060                next_mark = m_Parent->GetPresMark(MARK_NEXT);
3061            }
3062            swap(this_mark_total, next_mark_time);
3063        }
3064    }
3065}
3066
3067void GfxCore::SetColourBy(int colour_by) {
3068    m_ColourBy = colour_by;
3069    switch (colour_by) {
3070        case COLOUR_BY_DEPTH:
3071            AddQuad = &GfxCore::AddQuadrilateralDepth;
3072            AddPoly = &GfxCore::AddPolylineDepth;
3073            break;
3074        case COLOUR_BY_DATE:
3075            AddQuad = &GfxCore::AddQuadrilateralDate;
3076            AddPoly = &GfxCore::AddPolylineDate;
3077            break;
3078        case COLOUR_BY_ERROR:
3079            AddQuad = &GfxCore::AddQuadrilateralError;
3080            AddPoly = &GfxCore::AddPolylineError;
3081            break;
3082        default: // case COLOUR_BY_NONE:
3083            AddQuad = &GfxCore::AddQuadrilateral;
3084            AddPoly = &GfxCore::AddPolyline;
3085            break;
3086    }
3087
3088    InvalidateList(LIST_UNDERGROUND_LEGS);
3089    InvalidateList(LIST_SURFACE_LEGS);
3090    InvalidateList(LIST_TUBES);
3091
3092    ForceRefresh();
3093}
3094
3095bool GfxCore::ExportMovie(const wxString & fnm)
3096{
3097    int width;
3098    int height;
3099    GetSize(&width, &height);
3100    // Round up to next multiple of 2 (required by ffmpeg).
3101    width += (width & 1);
3102    height += (height & 1);
3103
3104    movie = new MovieMaker();
3105
3106    // FIXME: This should really use fn_str() - currently we probably can't
3107    // save to a Unicode path on wxmsw.
3108    if (!movie->Open(fnm.mb_str(), width, height)) {
3109        wxGetApp().ReportError(wxString(movie->get_error_string(), wxConvUTF8));
3110        delete movie;
3111        movie = NULL;
3112        return false;
3113    }
3114
3115    PlayPres(1);
3116    return true;
3117}
3118
3119void
3120GfxCore::OnPrint(const wxString &filename, const wxString &title,
3121                 const wxString &datestamp, time_t datestamp_numeric,
3122                 const wxString &cs_proj,
3123                 bool close_after_print)
3124{
3125    svxPrintDlg * p;
3126    p = new svxPrintDlg(m_Parent, filename, title, cs_proj,
3127                        datestamp, datestamp_numeric,
3128                        m_PanAngle, m_TiltAngle,
3129                        m_Names, m_Crosses, m_Legs, m_Surface, m_Tubes,
3130                        m_Entrances, m_FixedPts, m_ExportedPts,
3131                        true, close_after_print);
3132    p->Show(true);
3133}
3134
3135void
3136GfxCore::OnExport(const wxString &filename, const wxString &title,
3137                  const wxString &datestamp, time_t datestamp_numeric,
3138                  const wxString &cs_proj)
3139{
3140    // Fill in "right_bearing" for each cross-section.
3141    list<vector<XSect> >::iterator trav = m_Parent->tubes_begin();
3142    list<vector<XSect> >::iterator tend = m_Parent->tubes_end();
3143    while (trav != tend) {
3144        SkinPassage(*trav, false);
3145        ++trav;
3146    }
3147
3148    svxPrintDlg * p;
3149    p = new svxPrintDlg(m_Parent, filename, title, cs_proj,
3150                        datestamp, datestamp_numeric,
3151                        m_PanAngle, m_TiltAngle,
3152                        m_Names, m_Crosses, m_Legs, m_Surface, m_Tubes,
3153                        m_Entrances, m_FixedPts, m_ExportedPts,
3154                        false);
3155    p->Show(true);
3156}
3157
3158static wxCursor
3159make_cursor(const unsigned char * bits, const unsigned char * mask,
3160            int hotx, int hoty)
3161{
3162#if defined __WXMSW__ || defined __WXMAC__
3163# ifdef __WXMAC__
3164    // The default Mac cursor is black with a white edge, so
3165    // invert our custom cursors to match.
3166    char b[128];
3167    for (int i = 0; i < 128; ++i)
3168        b[i] = bits[i] ^ 0xff;
3169# else
3170    const char * b = reinterpret_cast<const char *>(bits);
3171# endif
3172    wxBitmap cursor_bitmap(b, 32, 32);
3173    wxBitmap mask_bitmap(reinterpret_cast<const char *>(mask), 32, 32);
3174    cursor_bitmap.SetMask(new wxMask(mask_bitmap, *wxWHITE));
3175    wxImage cursor_image = cursor_bitmap.ConvertToImage();
3176    cursor_image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotx);
3177    cursor_image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hoty);
3178    return wxCursor(cursor_image);
3179#else
3180    return wxCursor((const char *)bits, 32, 32, hotx, hoty,
3181                    (const char *)mask, wxBLACK, wxWHITE);
3182#endif
3183}
3184
3185const
3186#include "hand.xbm"
3187const
3188#include "handmask.xbm"
3189
3190const
3191#include "brotate.xbm"
3192const
3193#include "brotatemask.xbm"
3194
3195const
3196#include "vrotate.xbm"
3197const
3198#include "vrotatemask.xbm"
3199
3200const
3201#include "rotate.xbm"
3202const
3203#include "rotatemask.xbm"
3204
3205const
3206#include "rotatezoom.xbm"
3207const
3208#include "rotatezoommask.xbm"
3209
3210void
3211GfxCore::UpdateCursor(GfxCore::cursor new_cursor)
3212{
3213    // Check if we're already showing that cursor.
3214    if (current_cursor == new_cursor) return;
3215
3216    current_cursor = new_cursor;
3217    switch (current_cursor) {
3218        case GfxCore::CURSOR_DEFAULT:
3219            GLACanvas::SetCursor(wxNullCursor);
3220            break;
3221        case GfxCore::CURSOR_POINTING_HAND:
3222            GLACanvas::SetCursor(wxCursor(wxCURSOR_HAND));
3223            break;
3224        case GfxCore::CURSOR_DRAGGING_HAND:
3225            GLACanvas::SetCursor(make_cursor(hand_bits, handmask_bits, 12, 18));
3226            break;
3227        case GfxCore::CURSOR_HORIZONTAL_RESIZE:
3228            GLACanvas::SetCursor(wxCursor(wxCURSOR_SIZEWE));
3229            break;
3230        case GfxCore::CURSOR_ROTATE_HORIZONTALLY:
3231            GLACanvas::SetCursor(make_cursor(rotate_bits, rotatemask_bits, 15, 15));
3232            break;
3233        case GfxCore::CURSOR_ROTATE_VERTICALLY:
3234            GLACanvas::SetCursor(make_cursor(vrotate_bits, vrotatemask_bits, 15, 15));
3235            break;
3236        case GfxCore::CURSOR_ROTATE_EITHER_WAY:
3237            GLACanvas::SetCursor(make_cursor(brotate_bits, brotatemask_bits, 15, 15));
3238            break;
3239        case GfxCore::CURSOR_ZOOM:
3240            GLACanvas::SetCursor(wxCursor(wxCURSOR_MAGNIFIER));
3241            break;
3242        case GfxCore::CURSOR_ZOOM_ROTATE:
3243            GLACanvas::SetCursor(make_cursor(rotatezoom_bits, rotatezoommask_bits, 15, 15));
3244            break;
3245    }
3246}
3247
3248bool GfxCore::MeasuringLineActive() const
3249{
3250    if (Animating()) return false;
3251    return HereIsReal() || m_there;
3252}
3253
3254bool GfxCore::HandleRClick(wxPoint point)
3255{
3256    if (PointWithinCompass(point)) {
3257        // Pop up menu.
3258        wxMenu menu;
3259        /* TRANSLATORS: View *looking* North */
3260        menu.Append(menu_ORIENT_MOVE_NORTH, wmsg(/*View &North*/240));
3261        /* TRANSLATORS: View *looking* East */
3262        menu.Append(menu_ORIENT_MOVE_EAST, wmsg(/*View &East*/241));
3263        /* TRANSLATORS: View *looking* South */
3264        menu.Append(menu_ORIENT_MOVE_SOUTH, wmsg(/*View &South*/242));
3265        /* TRANSLATORS: View *looking* West */
3266        menu.Append(menu_ORIENT_MOVE_WEST, wmsg(/*View &West*/243));
3267        menu.AppendSeparator();
3268        /* TRANSLATORS: Menu item which turns off the "north arrow" in aven. */
3269        menu.AppendCheckItem(menu_IND_COMPASS, wmsg(/*&Hide Compass*/387));
3270        /* TRANSLATORS: tickable menu item in View menu */
3271        menu.AppendCheckItem(menu_CTL_DEGREES, wmsg(/*&Degrees*/343));
3272        menu.Connect(wxEVT_COMMAND_MENU_SELECTED, (wxObjectEventFunction)&wxEvtHandler::ProcessEvent, NULL, m_Parent->GetEventHandler());
3273        PopupMenu(&menu);
3274        return true;
3275    }
3276
3277    if (PointWithinClino(point)) {
3278        // Pop up menu.
3279        wxMenu menu;
3280        menu.Append(menu_ORIENT_PLAN, wmsg(/*&Plan View*/248));
3281        menu.Append(menu_ORIENT_ELEVATION, wmsg(/*Ele&vation*/249));
3282        menu.AppendSeparator();
3283        /* TRANSLATORS: Menu item which turns off the tilt indicator in aven. */
3284        menu.AppendCheckItem(menu_IND_CLINO, wmsg(/*&Hide Clino*/384));
3285        /* TRANSLATORS: tickable menu item in View menu.
3286         *
3287         * Degrees are the angular measurement where there are 360 in a full
3288         * circle. */
3289        menu.AppendCheckItem(menu_CTL_DEGREES, wmsg(/*&Degrees*/343));
3290        /* TRANSLATORS: tickable menu item in View menu.
3291         *
3292         * Show the tilt of the survey as a percentage gradient (100% = 45
3293         * degrees = 50 grad). */
3294        menu.AppendCheckItem(menu_CTL_PERCENT, wmsg(/*&Percent*/430));
3295        menu.Connect(wxEVT_COMMAND_MENU_SELECTED, (wxObjectEventFunction)&wxEvtHandler::ProcessEvent, NULL, m_Parent->GetEventHandler());
3296        PopupMenu(&menu);
3297        return true;
3298    }
3299
3300    if (PointWithinScaleBar(point)) {
3301        // Pop up menu.
3302        wxMenu menu;
3303        /* TRANSLATORS: Menu item which turns off the scale bar in aven. */
3304        menu.AppendCheckItem(menu_IND_SCALE_BAR, wmsg(/*&Hide scale bar*/385));
3305        /* TRANSLATORS: tickable menu item in View menu */
3306        menu.AppendCheckItem(menu_CTL_METRIC, wmsg(/*&Metric*/342));
3307        menu.Connect(wxEVT_COMMAND_MENU_SELECTED, (wxObjectEventFunction)&wxEvtHandler::ProcessEvent, NULL, m_Parent->GetEventHandler());
3308        PopupMenu(&menu);
3309        return true;
3310    }
3311
3312    if (PointWithinColourKey(point)) {
3313        // Pop up menu.
3314        wxMenu menu;
3315        menu.AppendCheckItem(menu_VIEW_COLOUR_BY_DEPTH, wmsg(/*Colour by &Depth*/292));
3316        menu.AppendCheckItem(menu_VIEW_COLOUR_BY_DATE, wmsg(/*Colour by D&ate*/293));
3317        menu.AppendCheckItem(menu_VIEW_COLOUR_BY_ERROR, wmsg(/*Colour by E&rror*/289));
3318        menu.AppendSeparator();
3319        /* TRANSLATORS: Menu item which turns off the colour key.
3320         * The "Colour Key" is the thing in aven showing which colour
3321         * corresponds to which depth, date, survey closure error, etc. */
3322        menu.AppendCheckItem(menu_IND_COLOUR_KEY, wmsg(/*&Hide colour key*/386));
3323        if (m_ColourBy == COLOUR_BY_DEPTH)
3324            menu.AppendCheckItem(menu_CTL_METRIC, wmsg(/*&Metric*/342));
3325        menu.Connect(wxEVT_COMMAND_MENU_SELECTED, (wxObjectEventFunction)&wxEvtHandler::ProcessEvent, NULL, m_Parent->GetEventHandler());
3326        PopupMenu(&menu);
3327        return true;
3328    }
3329
3330    return false;
3331}
3332
3333void GfxCore::SetZoomBox(wxPoint p1, wxPoint p2, bool centred, bool aspect)
3334{
3335    if (centred) {
3336        p1.x = p2.x + (p1.x - p2.x) * 2;
3337        p1.y = p2.y + (p1.y - p2.y) * 2;
3338    }
3339    if (aspect) {
3340#if 0 // FIXME: This needs more work.
3341        int sx = GetXSize();
3342        int sy = GetYSize();
3343        int dx = p1.x - p2.x;
3344        int dy = p1.y - p2.y;
3345        int dy_new = dx * sy / sx;
3346        if (abs(dy_new) >= abs(dy)) {
3347            p1.y += (dy_new - dy) / 2;
3348            p2.y -= (dy_new - dy) / 2;
3349        } else {
3350            int dx_new = dy * sx / sy;
3351            p1.x += (dx_new - dx) / 2;
3352            p2.x -= (dx_new - dx) / 2;
3353        }
3354#endif
3355    }
3356    zoombox.set(p1, p2);
3357    ForceRefresh();
3358}
3359
3360void GfxCore::ZoomBoxGo()
3361{
3362    if (!zoombox.active()) return;
3363
3364    int width = GetXSize();
3365    int height = GetYSize();
3366
3367    TranslateCave(-0.5 * (zoombox.x1 + zoombox.x2 - width),
3368                  -0.5 * (zoombox.y1 + zoombox.y2 - height));
3369    int box_w = abs(zoombox.x1 - zoombox.x2);
3370    int box_h = abs(zoombox.y1 - zoombox.y2);
3371
3372    double factor = min(double(width) / box_w, double(height) / box_h);
3373
3374    zoombox.unset();
3375
3376    SetScale(GetScale() * factor);
3377}
Note: See TracBrowser for help on using the repository browser.