source: git/src/gfxcore.cc @ 9260793

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

Improve .hdr file parsing

Use documented defaults for more values. And where we only support
a subset of values (or a particular value) check for files which
don't fall in the support subset in more cases.

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