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

line_contentsstereotravis-osx
Last change on this file since 7b9b700 was 7b9b700, checked in by Olly Betts <olly@…>, 5 years ago

src/gfxcore.cc,src/guicontrol.cc,src/mainfrm.cc: More tweaks to
compile with a unicode build of wx2.8.

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