source: git/src/gfxcore.cc @ 7cdb1c3

RELEASE/1.2debug-cidebug-ci-sanitisersfaster-cavernloglog-selectstereostereo-2025walls-datawalls-data-hanging-as-warningwarn-only-for-hanging-survey
Last change on this file since 7cdb1c3 was 7cdb1c3, checked in by Olly Betts <olly@…>, 14 years ago

src/gfxcore.cc,src/gfxcore.h: Factor out the code to draw the colour
key into DrawColourKey?().

git-svn-id: file:///home/survex-svn/survex/trunk@3782 4b37db11-9a0c-4f06-9ece-9ab7cdaee568

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