source: git/src/gfxcore.cc @ 11c7eb6

RELEASE/1.2debug-cidebug-ci-sanitisersstereowalls-datawalls-data-hanging-as-warning
Last change on this file since 11c7eb6 was 11c7eb6, checked in by Olly Betts <olly@…>, 10 years ago

src/gfxcore.cc,src/gfxcore.h: No need to dynamically allocate
m_Pens.

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