source: git/src/gfxcore.cc @ a6401ff3

Last change on this file since a6401ff3 was a6401ff3, checked in by Olly Betts <olly@…>, 4 months ago

Improve handling of hidden splay ends

Previously, hidden splay ends still served as "targets" for snapping
the mouse pointer to, and still got crosses when crosses were
enabled.

We don't have a handy flag for "this is the outer end of a splay"
and computing that on demand isn't so easy to do, so for now we
use the "anonymous station" flag so at least these cases now behave
properly for splays to anonymous stations (which is likely to be
what people with huge numbers of splays from disto-x, etc are
using). This does mean that anonymous stations on continuation
passages will incorrectly also be off when splays are hidden, but
that seems an OK trade-off for now.

The snapping of the mouse pointer was reported by Frank Tully in #105.

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