source: git/src/gfxcore.cc @ fc43dda

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

Allow colouring by horizontal or vertical error

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