source: git/src/mainfrm.cc @ 70462c8

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

src/: Pass the datestamp from the 3d file to the export code.

  • Property mode set to 100644
File size: 81.0 KB
Line 
1//
2//  mainfrm.cc
3//
4//  Main frame handling for Aven.
5//
6//  Copyright (C) 2000-2002,2005,2006 Mark R. Shinwell
7//  Copyright (C) 2001-2003,2004,2005,2006,2010,2011,2012,2013 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 "cavernlog.h"
30#include "mainfrm.h"
31#include "aven.h"
32#include "aboutdlg.h"
33
34#include "message.h"
35#include "img_hosted.h"
36#include "namecompare.h"
37#include "printwx.h"
38#include "filename.h"
39#include "useful.h"
40
41#include <wx/confbase.h>
42#include <wx/filename.h>
43#include <wx/image.h>
44#include <wx/imaglist.h>
45#include <wx/process.h>
46#include <wx/regex.h>
47
48#include <cstdlib>
49#include <float.h>
50#include <functional>
51#include <map>
52#include <stack>
53#include <vector>
54
55using namespace std;
56
57const static int img2aven_tab[] = {
58#include "img2aven.h"
59};
60
61inline int
62img2aven(int flags)
63{
64    flags &= (sizeof(img2aven_tab) / sizeof(img2aven_tab[0]) - 1);
65    return img2aven_tab[flags];
66}
67
68class AvenSplitterWindow : public wxSplitterWindow {
69    MainFrm *parent;
70
71    public:
72        AvenSplitterWindow(MainFrm *parent_)
73            : wxSplitterWindow(parent_, -1, wxDefaultPosition, wxDefaultSize,
74                               wxSP_3D | wxSP_LIVE_UPDATE),
75              parent(parent_)
76        {
77        }
78
79        void OnSplitterDClick(wxSplitterEvent &) {
80            parent->ToggleSidePanel();
81        }
82
83    private:
84        DECLARE_EVENT_TABLE()
85};
86
87BEGIN_EVENT_TABLE(AvenSplitterWindow, wxSplitterWindow)
88    EVT_SPLITTER_DCLICK(-1, AvenSplitterWindow::OnSplitterDClick)
89END_EVENT_TABLE()
90
91class EditMarkDlg : public wxDialog {
92    wxTextCtrl * easting, * northing, * altitude;
93    wxTextCtrl * angle, * tilt_angle, * scale, * time;
94public:
95    EditMarkDlg(wxWindow* parent, const PresentationMark & p)
96        : wxDialog(parent, 500, wmsg(/*Edit Waypoint*/404))
97    {
98        easting = new wxTextCtrl(this, 601, wxString::Format(wxT("%.3f"), p.GetX()));
99        northing = new wxTextCtrl(this, 602, wxString::Format(wxT("%.3f"), p.GetY()));
100        altitude = new wxTextCtrl(this, 603, wxString::Format(wxT("%.3f"), p.GetZ()));
101        angle = new wxTextCtrl(this, 604, wxString::Format(wxT("%.3f"), p.angle));
102        tilt_angle = new wxTextCtrl(this, 605, wxString::Format(wxT("%.3f"), p.tilt_angle));
103        scale = new wxTextCtrl(this, 606, wxString::Format(wxT("%.3f"), p.scale));
104        if (p.time > 0.0) {
105            time = new wxTextCtrl(this, 607, wxString::Format(wxT("%.3f"), p.time));
106        } else if (p.time < 0.0) {
107            time = new wxTextCtrl(this, 607, wxString::Format(wxT("*%.3f"), -p.time));
108        } else {
109            time = new wxTextCtrl(this, 607, wxT("0"));
110        }
111
112        wxBoxSizer * coords = new wxBoxSizer(wxHORIZONTAL);
113        coords->Add(new wxStaticText(this, 610, wxT("(")), 0, wxALIGN_CENTRE_VERTICAL);
114        coords->Add(easting, 1);
115        coords->Add(new wxStaticText(this, 611, wxT(",")), 0, wxALIGN_CENTRE_VERTICAL);
116        coords->Add(northing, 1);
117        coords->Add(new wxStaticText(this, 612, wxT(",")), 0, wxALIGN_CENTRE_VERTICAL);
118        coords->Add(altitude, 1);
119        coords->Add(new wxStaticText(this, 613, wxT(")")), 0, wxALIGN_CENTRE_VERTICAL);
120        wxBoxSizer* vert = new wxBoxSizer(wxVERTICAL);
121        vert->Add(coords, 0, wxALL, 8);
122        wxBoxSizer * r2 = new wxBoxSizer(wxHORIZONTAL);
123        r2->Add(new wxStaticText(this, 614, wmsg(/*Bearing*/259) + wxT(": ")), 0, wxALIGN_CENTRE_VERTICAL);
124        r2->Add(angle);
125        vert->Add(r2, 0, wxALL, 8);
126        wxBoxSizer * r3 = new wxBoxSizer(wxHORIZONTAL);
127        r3->Add(new wxStaticText(this, 615, wmsg(/*Elevation*/118) + wxT(": ")), 0, wxALIGN_CENTRE_VERTICAL);
128        r3->Add(tilt_angle);
129        vert->Add(r3, 0, wxALL, 8);
130        wxBoxSizer * r4 = new wxBoxSizer(wxHORIZONTAL);
131        r4->Add(new wxStaticText(this, 616, wmsg(/*Scale*/154) + wxT(": ")), 0, wxALIGN_CENTRE_VERTICAL);
132        r4->Add(scale);
133        r4->Add(new wxStaticText(this, 617, wmsg(/* (unused in perspective view)*/278)),
134                0, wxALIGN_CENTRE_VERTICAL);
135        vert->Add(r4, 0, wxALL, 8);
136
137        wxBoxSizer * r5 = new wxBoxSizer(wxHORIZONTAL);
138        r5->Add(new wxStaticText(this, 616, wmsg(/*Time: */279)), 0, wxALIGN_CENTRE_VERTICAL);
139        r5->Add(time);
140        r5->Add(new wxStaticText(this, 617, wmsg(/* secs (0 = auto; *6 = 6 times auto)*/282)),
141                0, wxALIGN_CENTRE_VERTICAL);
142        vert->Add(r5, 0, wxALL, 8);
143
144        wxBoxSizer * buttons = new wxBoxSizer(wxHORIZONTAL);
145        wxButton* cancel = new wxButton(this, wxID_CANCEL);
146        buttons->Add(cancel, 0, wxALL, 8);
147        wxButton* ok = new wxButton(this, wxID_OK);
148        ok->SetDefault();
149        buttons->Add(ok, 0, wxALL, 8);
150        vert->Add(buttons, 0, wxALL|wxALIGN_RIGHT);
151
152        SetAutoLayout(true);
153        SetSizer(vert);
154
155        vert->Fit(this);
156        vert->SetSizeHints(this);
157    }
158    PresentationMark GetMark() const {
159        double a, t, s, T;
160        Vector3 v(atof(easting->GetValue().mb_str()),
161                  atof(northing->GetValue().mb_str()),
162                  atof(altitude->GetValue().mb_str()));
163        a = atof(angle->GetValue().mb_str());
164        t = atof(tilt_angle->GetValue().mb_str());
165        s = atof(scale->GetValue().mb_str());
166        wxString str = time->GetValue();
167        if (!str.empty() && str[0u] == '*') str[0u] = '-';
168        T = atof(str.mb_str());
169        return PresentationMark(v, a, t, s, T);
170    }
171
172private:
173    DECLARE_EVENT_TABLE()
174};
175
176// Write a value without trailing zeros after the decimal point.
177static void write_double(double d, FILE * fh) {
178    char buf[64];
179    sprintf(buf, "%.21f", d);
180    char * p = strchr(buf, ',');
181    if (p) *p = '.';
182    size_t l = strlen(buf);
183    while (l > 1 && buf[l - 1] == '0') --l;
184    if (l > 1 && buf[l - 1] == '.') --l;
185    fwrite(buf, l, 1, fh);
186}
187
188class AvenPresList : public wxListCtrl {
189    MainFrm * mainfrm;
190    GfxCore * gfx;
191    vector<PresentationMark> entries;
192    long current_item;
193    bool modified;
194    bool force_save_as;
195    wxString filename;
196
197    public:
198        AvenPresList(MainFrm * mainfrm_, wxWindow * parent, GfxCore * gfx_)
199            : wxListCtrl(parent, listctrl_PRES, wxDefaultPosition, wxDefaultSize,
200                         wxLC_REPORT|wxLC_VIRTUAL),
201              mainfrm(mainfrm_), gfx(gfx_), current_item(-1), modified(false),
202              force_save_as(true)
203            {
204                InsertColumn(0, wmsg(/*Easting*/378));
205                InsertColumn(1, wmsg(/*Northing*/379));
206                InsertColumn(2, wmsg(/*Altitude*/335));
207            }
208
209        void OnBeginLabelEdit(wxListEvent& event) {
210            event.Veto(); // No editting allowed
211        }
212        void OnDeleteItem(wxListEvent& event) {
213            long item = event.GetIndex();
214            if (current_item == item) {
215                current_item = -1;
216            } else if (current_item > item) {
217                --current_item;
218            }
219            entries.erase(entries.begin() + item);
220            SetItemCount(entries.size());
221            modified = true;
222        }
223        void OnDeleteAllItems(wxListEvent&) {
224            entries.clear();
225            SetItemCount(entries.size());
226            filename = wxString();
227            modified = false;
228            force_save_as = true;
229        }
230        void OnListKeyDown(wxListEvent& event) {
231            switch (event.GetKeyCode()) {
232                case WXK_DELETE: {
233                    long item = GetNextItem(-1, wxLIST_NEXT_ALL,
234                                            wxLIST_STATE_SELECTED);
235                    while (item != -1) {
236                        DeleteItem(item);
237                        // - 1 because the indices were shifted by DeleteItem()
238                        item = GetNextItem(item - 1, wxLIST_NEXT_ALL,
239                                           wxLIST_STATE_SELECTED);
240                    }
241                    break;
242                }
243                default:
244                    //printf("event.GetIndex() = %ld %d\n", event.GetIndex(), event.GetKeyCode());
245                    event.Skip();
246            }
247        }
248        void OnActivated(wxListEvent& event) {
249            // Jump to this view.
250            long item = event.GetIndex();
251            gfx->SetView(entries[item]);
252        }
253        void OnFocused(wxListEvent& event) {
254            current_item = event.GetIndex();
255        }
256        void OnRightClick(wxListEvent& event) {
257            long item = event.GetIndex();
258            if (item < 0) {
259                AddMark(item, gfx->GetView());
260                item = 0;
261            }
262            EditMarkDlg edit(mainfrm, entries[item]);
263            if (edit.ShowModal() == wxID_OK) {
264                entries[item] = edit.GetMark();
265            }
266        }
267        void OnChar(wxKeyEvent& event) {
268            switch (event.GetKeyCode()) {
269                case WXK_INSERT:
270                    if (event.GetModifiers() == wxMOD_CONTROL) {
271                        if (current_item != -1 &&
272                            size_t(current_item) < entries.size()) {
273                            AddMark(current_item, entries[current_item]);
274                        }
275                    } else {
276                        AddMark(current_item);
277                    }
278                    break;
279                case WXK_DELETE:
280                    // Already handled in OnListKeyDown.
281                    break;
282                case WXK_UP: case WXK_DOWN:
283                    event.Skip();
284                    break;
285                default:
286                    gfx->OnKeyPress(event);
287            }
288        }
289        void AddMark(long item = -1) {
290            AddMark(item, gfx->GetView());
291        }
292        void AddMark(long item, const PresentationMark & mark) {
293            if (item == -1) item = entries.size();
294            entries.insert(entries.begin() + item, mark);
295            SetItemCount(entries.size());
296            modified = true;
297        }
298        virtual wxString OnGetItemText(long item, long column) const {
299            if (item < 0 || item >= (long)entries.size()) return wxString();
300            const PresentationMark & p = entries[item];
301            double v;
302            switch (column) {
303                case 0: v = p.GetX(); break;
304                case 1: v = p.GetY(); break;
305                case 2: v = p.GetZ(); break;
306#if 0
307                case 3: v = p.angle; break;
308                case 4: v = p.tilt_angle; break;
309                case 5: v = p.scale; break;
310                case 6: v = p.time; break;
311#endif
312                default: return wxString();
313            }
314            return wxString::Format(wxT("%ld"), (long)v);
315        }
316        void Save(bool use_default_name) {
317            wxString fnm = filename;
318            if (!use_default_name || force_save_as) {
319                AvenAllowOnTop ontop(mainfrm);
320#ifdef __WXMOTIF__
321                wxString ext(wxT("*.fly"));
322#else
323                wxString ext = wmsg(/*Aven presentations*/320);
324                ext += wxT("|*.fly");
325#endif
326                wxFileDialog dlg(this, wmsg(/*Select an output filename*/319),
327                                 wxString(), fnm, ext,
328                                 wxFD_SAVE|wxFD_OVERWRITE_PROMPT);
329                if (dlg.ShowModal() != wxID_OK) return;
330                fnm = dlg.GetPath();
331            }
332
333#ifdef __WXMSW__
334            FILE * fh_pres = _wfopen(fnm.fn_str(), L"w");
335#else
336            FILE * fh_pres = fopen(fnm.mb_str(), "w");
337#endif
338            if (!fh_pres) {
339                wxGetApp().ReportError(wxString::Format(wmsg(/*Error writing to file “%s”*/110), fnm.c_str()));
340                return;
341            }
342            vector<PresentationMark>::const_iterator i;
343            for (i = entries.begin(); i != entries.end(); ++i) {
344                const PresentationMark &p = *i;
345                write_double(p.GetX(), fh_pres);
346                PUTC(' ', fh_pres);
347                write_double(p.GetY(), fh_pres);
348                PUTC(' ', fh_pres);
349                write_double(p.GetZ(), fh_pres);
350                PUTC(' ', fh_pres);
351                write_double(p.angle, fh_pres);
352                PUTC(' ', fh_pres);
353                write_double(p.tilt_angle, fh_pres);
354                PUTC(' ', fh_pres);
355                write_double(p.scale, fh_pres);
356                if (p.time != 0.0) {
357                    PUTC(' ', fh_pres);
358                    write_double(p.time, fh_pres);
359                }
360                PUTC('\n', fh_pres);
361            }
362            fclose(fh_pres);
363            filename = fnm;
364            modified = false;
365            force_save_as = false;
366        }
367        void New(const wxString &fnm) {
368            DeleteAllItems();
369            wxFileName::SplitPath(fnm, NULL, NULL, &filename, NULL, wxPATH_NATIVE);
370            filename += wxT(".fly");
371            force_save_as = true;
372        }
373        bool Load(const wxString &fnm) {
374#ifdef __WXMSW__
375            FILE * fh_pres = _wfopen(fnm.fn_str(), L"r");
376#else
377            FILE * fh_pres = fopen(fnm.mb_str(), "r");
378#endif
379            if (!fh_pres) {
380                wxString m;
381                m.Printf(wmsg(/*Couldn’t open file “%s”*/93), fnm.c_str());
382                wxGetApp().ReportError(m);
383                return false;
384            }
385            DeleteAllItems();
386            long item = 0;
387            while (!feof(fh_pres)) {
388                char buf[4096];
389                size_t i = 0;
390                while (i < sizeof(buf) - 1) {
391                    int ch = GETC(fh_pres);
392                    if (ch == EOF || ch == '\n' || ch == '\r') break;
393                    buf[i++] = ch;
394                }
395                if (i) {
396                    buf[i] = 0;
397                    double x, y, z, a, t, s, T;
398                    int c = sscanf(buf, "%lf %lf %lf %lf %lf %lf %lf", &x, &y, &z, &a, &t, &s, &T);
399                    if (c < 6) {
400                        char *p = buf;
401                        while ((p = strchr(p, '.'))) *p++ = ',';
402                        c = sscanf(buf, "%lf %lf %lf %lf %lf %lf %lf", &x, &y, &z, &a, &t, &s, &T);
403                        if (c < 6) {
404                            DeleteAllItems();
405                            wxGetApp().ReportError(wxString::Format(wmsg(/*Error in format of presentation file “%s”*/323), fnm.c_str()));
406                            return false;
407                        }
408                    }
409                    if (c == 6) T = 0;
410                    AddMark(item, PresentationMark(Vector3(x, y, z), a, t, s, T));
411                    ++item;
412                }
413            }
414            fclose(fh_pres);
415            filename = fnm;
416            modified = false;
417            force_save_as = false;
418            return true;
419        }
420        bool Modified() const { return modified; }
421        bool Empty() const { return entries.empty(); }
422        PresentationMark GetPresMark(int which) {
423            long item = current_item;
424            if (which == MARK_FIRST) {
425                item = 0;
426            } else if (which == MARK_NEXT) {
427                ++item;
428            } else if (which == MARK_PREV) {
429                --item;
430            }
431            if (item == -1 || item == (long)entries.size())
432                return PresentationMark();
433            if (item != current_item) {
434                // Move the focus
435                if (current_item != -1) {
436                    wxListCtrl::SetItemState(current_item, wxLIST_STATE_FOCUSED,
437                                             0);
438                }
439                wxListCtrl::SetItemState(item, wxLIST_STATE_FOCUSED,
440                                         wxLIST_STATE_FOCUSED);
441            }
442            return entries[item];
443        }
444
445    private:
446
447        DECLARE_NO_COPY_CLASS(AvenPresList)
448        DECLARE_EVENT_TABLE()
449};
450
451BEGIN_EVENT_TABLE(EditMarkDlg, wxDialog)
452END_EVENT_TABLE()
453
454BEGIN_EVENT_TABLE(AvenPresList, wxListCtrl)
455    EVT_LIST_BEGIN_LABEL_EDIT(listctrl_PRES, AvenPresList::OnBeginLabelEdit)
456    EVT_LIST_DELETE_ITEM(listctrl_PRES, AvenPresList::OnDeleteItem)
457    EVT_LIST_DELETE_ALL_ITEMS(listctrl_PRES, AvenPresList::OnDeleteAllItems)
458    EVT_LIST_KEY_DOWN(listctrl_PRES, AvenPresList::OnListKeyDown)
459    EVT_LIST_ITEM_ACTIVATED(listctrl_PRES, AvenPresList::OnActivated)
460    EVT_LIST_ITEM_FOCUSED(listctrl_PRES, AvenPresList::OnFocused)
461    EVT_LIST_ITEM_RIGHT_CLICK(listctrl_PRES, AvenPresList::OnRightClick)
462    EVT_CHAR(AvenPresList::OnChar)
463END_EVENT_TABLE()
464
465BEGIN_EVENT_TABLE(MainFrm, wxFrame)
466    EVT_TEXT(textctrl_FIND, MainFrm::OnFind)
467    EVT_TEXT_ENTER(textctrl_FIND, MainFrm::OnGotoFound)
468    EVT_MENU(wxID_FIND, MainFrm::OnGotoFound)
469    EVT_MENU(button_HIDE, MainFrm::OnHide)
470    EVT_UPDATE_UI(button_HIDE, MainFrm::OnHideUpdate)
471    EVT_IDLE(MainFrm::OnIdle)
472
473    EVT_MENU(wxID_OPEN, MainFrm::OnOpen)
474    EVT_MENU(wxID_PRINT, MainFrm::OnPrint)
475    EVT_MENU(menu_FILE_PAGE_SETUP, MainFrm::OnPageSetup)
476    EVT_MENU(menu_FILE_SCREENSHOT, MainFrm::OnScreenshot)
477//    EVT_MENU(wxID_PREFERENCES, MainFrm::OnFilePreferences)
478    EVT_MENU(menu_FILE_EXPORT, MainFrm::OnExport)
479    EVT_MENU(wxID_EXIT, MainFrm::OnQuit)
480    EVT_MENU_RANGE(wxID_FILE1, wxID_FILE9, MainFrm::OnMRUFile)
481
482    EVT_MENU(menu_PRES_NEW, MainFrm::OnPresNew)
483    EVT_MENU(menu_PRES_OPEN, MainFrm::OnPresOpen)
484    EVT_MENU(menu_PRES_SAVE, MainFrm::OnPresSave)
485    EVT_MENU(menu_PRES_SAVE_AS, MainFrm::OnPresSaveAs)
486    EVT_MENU(menu_PRES_MARK, MainFrm::OnPresMark)
487    EVT_MENU(menu_PRES_FREWIND, MainFrm::OnPresFRewind)
488    EVT_MENU(menu_PRES_REWIND, MainFrm::OnPresRewind)
489    EVT_MENU(menu_PRES_REVERSE, MainFrm::OnPresReverse)
490    EVT_MENU(menu_PRES_PLAY, MainFrm::OnPresPlay)
491    EVT_MENU(menu_PRES_FF, MainFrm::OnPresFF)
492    EVT_MENU(menu_PRES_FFF, MainFrm::OnPresFFF)
493    EVT_MENU(menu_PRES_PAUSE, MainFrm::OnPresPause)
494    EVT_MENU(wxID_STOP, MainFrm::OnPresStop)
495    EVT_MENU(menu_PRES_EXPORT_MOVIE, MainFrm::OnPresExportMovie)
496
497    EVT_UPDATE_UI(menu_PRES_NEW, MainFrm::OnPresNewUpdate)
498    EVT_UPDATE_UI(menu_PRES_OPEN, MainFrm::OnPresOpenUpdate)
499    EVT_UPDATE_UI(menu_PRES_SAVE, MainFrm::OnPresSaveUpdate)
500    EVT_UPDATE_UI(menu_PRES_SAVE_AS, MainFrm::OnPresSaveAsUpdate)
501    EVT_UPDATE_UI(menu_PRES_MARK, MainFrm::OnPresMarkUpdate)
502    EVT_UPDATE_UI(menu_PRES_FREWIND, MainFrm::OnPresFRewindUpdate)
503    EVT_UPDATE_UI(menu_PRES_REWIND, MainFrm::OnPresRewindUpdate)
504    EVT_UPDATE_UI(menu_PRES_REVERSE, MainFrm::OnPresReverseUpdate)
505    EVT_UPDATE_UI(menu_PRES_PLAY, MainFrm::OnPresPlayUpdate)
506    EVT_UPDATE_UI(menu_PRES_FF, MainFrm::OnPresFFUpdate)
507    EVT_UPDATE_UI(menu_PRES_FFF, MainFrm::OnPresFFFUpdate)
508    EVT_UPDATE_UI(menu_PRES_PAUSE, MainFrm::OnPresPauseUpdate)
509    EVT_UPDATE_UI(wxID_STOP, MainFrm::OnPresStopUpdate)
510    EVT_UPDATE_UI(menu_PRES_EXPORT_MOVIE, MainFrm::OnPresExportMovieUpdate)
511
512    EVT_CLOSE(MainFrm::OnClose)
513    EVT_SET_FOCUS(MainFrm::OnSetFocus)
514
515    EVT_MENU(menu_ROTATION_TOGGLE, MainFrm::OnToggleRotation)
516    EVT_MENU(menu_ROTATION_SPEED_UP, MainFrm::OnSpeedUp)
517    EVT_MENU(menu_ROTATION_SLOW_DOWN, MainFrm::OnSlowDown)
518    EVT_MENU(menu_ROTATION_REVERSE, MainFrm::OnReverseDirectionOfRotation)
519    EVT_MENU(menu_ROTATION_STEP_CCW, MainFrm::OnStepOnceAnticlockwise)
520    EVT_MENU(menu_ROTATION_STEP_CW, MainFrm::OnStepOnceClockwise)
521    EVT_MENU(menu_ORIENT_MOVE_NORTH, MainFrm::OnMoveNorth)
522    EVT_MENU(menu_ORIENT_MOVE_EAST, MainFrm::OnMoveEast)
523    EVT_MENU(menu_ORIENT_MOVE_SOUTH, MainFrm::OnMoveSouth)
524    EVT_MENU(menu_ORIENT_MOVE_WEST, MainFrm::OnMoveWest)
525    EVT_MENU(menu_ORIENT_SHIFT_LEFT, MainFrm::OnShiftDisplayLeft)
526    EVT_MENU(menu_ORIENT_SHIFT_RIGHT, MainFrm::OnShiftDisplayRight)
527    EVT_MENU(menu_ORIENT_SHIFT_UP, MainFrm::OnShiftDisplayUp)
528    EVT_MENU(menu_ORIENT_SHIFT_DOWN, MainFrm::OnShiftDisplayDown)
529    EVT_MENU(menu_ORIENT_PLAN, MainFrm::OnPlan)
530    EVT_MENU(menu_ORIENT_ELEVATION, MainFrm::OnElevation)
531    EVT_MENU(menu_ORIENT_HIGHER_VP, MainFrm::OnHigherViewpoint)
532    EVT_MENU(menu_ORIENT_LOWER_VP, MainFrm::OnLowerViewpoint)
533    EVT_MENU(wxID_ZOOM_IN, MainFrm::OnZoomIn)
534    EVT_MENU(wxID_ZOOM_OUT, MainFrm::OnZoomOut)
535    EVT_MENU(menu_ORIENT_DEFAULTS, MainFrm::OnDefaults)
536    EVT_MENU(menu_VIEW_SHOW_LEGS, MainFrm::OnShowSurveyLegs)
537    EVT_MENU(menu_SPLAYS_HIDE, MainFrm::OnHideSplays)
538    EVT_MENU(menu_SPLAYS_SHOW_NORMAL, MainFrm::OnShowSplaysNormal)
539    EVT_MENU(menu_SPLAYS_SHOW_FADED, MainFrm::OnShowSplaysFaded)
540    EVT_MENU(menu_VIEW_SHOW_CROSSES, MainFrm::OnShowCrosses)
541    EVT_MENU(menu_VIEW_SHOW_ENTRANCES, MainFrm::OnShowEntrances)
542    EVT_MENU(menu_VIEW_SHOW_FIXED_PTS, MainFrm::OnShowFixedPts)
543    EVT_MENU(menu_VIEW_SHOW_EXPORTED_PTS, MainFrm::OnShowExportedPts)
544    EVT_MENU(menu_VIEW_SHOW_NAMES, MainFrm::OnShowStationNames)
545    EVT_MENU(menu_VIEW_SHOW_OVERLAPPING_NAMES, MainFrm::OnDisplayOverlappingNames)
546    EVT_MENU(menu_VIEW_COLOUR_BY_DEPTH, MainFrm::OnColourByDepth)
547    EVT_MENU(menu_VIEW_COLOUR_BY_DATE, MainFrm::OnColourByDate)
548    EVT_MENU(menu_VIEW_COLOUR_BY_ERROR, MainFrm::OnColourByError)
549    EVT_MENU(menu_VIEW_SHOW_SURFACE, MainFrm::OnShowSurface)
550    EVT_MENU(menu_VIEW_GRID, MainFrm::OnViewGrid)
551    EVT_MENU(menu_VIEW_BOUNDING_BOX, MainFrm::OnViewBoundingBox)
552    EVT_MENU(menu_VIEW_PERSPECTIVE, MainFrm::OnViewPerspective)
553    EVT_MENU(menu_VIEW_SMOOTH_SHADING, MainFrm::OnViewSmoothShading)
554    EVT_MENU(menu_VIEW_TEXTURED, MainFrm::OnViewTextured)
555    EVT_MENU(menu_VIEW_FOG, MainFrm::OnViewFog)
556    EVT_MENU(menu_VIEW_SMOOTH_LINES, MainFrm::OnViewSmoothLines)
557    EVT_MENU(menu_VIEW_FULLSCREEN, MainFrm::OnViewFullScreen)
558    EVT_MENU(menu_VIEW_SHOW_TUBES, MainFrm::OnToggleTubes)
559    EVT_MENU(menu_IND_COMPASS, MainFrm::OnViewCompass)
560    EVT_MENU(menu_IND_CLINO, MainFrm::OnViewClino)
561    EVT_MENU(menu_IND_COLOUR_KEY, MainFrm::OnToggleColourKey)
562    EVT_MENU(menu_IND_SCALE_BAR, MainFrm::OnToggleScalebar)
563    EVT_MENU(menu_CTL_SIDE_PANEL, MainFrm::OnViewSidePanel)
564    EVT_MENU(menu_CTL_METRIC, MainFrm::OnToggleMetric)
565    EVT_MENU(menu_CTL_DEGREES, MainFrm::OnToggleDegrees)
566    EVT_MENU(menu_CTL_REVERSE, MainFrm::OnReverseControls)
567    EVT_MENU(menu_CTL_CANCEL_DIST_LINE, MainFrm::OnCancelDistLine)
568    EVT_MENU(wxID_ABOUT, MainFrm::OnAbout)
569
570    EVT_UPDATE_UI(wxID_PRINT, MainFrm::OnPrintUpdate)
571    EVT_UPDATE_UI(menu_FILE_SCREENSHOT, MainFrm::OnScreenshotUpdate)
572    EVT_UPDATE_UI(menu_FILE_EXPORT, MainFrm::OnExportUpdate)
573    EVT_UPDATE_UI(menu_ROTATION_TOGGLE, MainFrm::OnToggleRotationUpdate)
574    EVT_UPDATE_UI(menu_ROTATION_SPEED_UP, MainFrm::OnSpeedUpUpdate)
575    EVT_UPDATE_UI(menu_ROTATION_SLOW_DOWN, MainFrm::OnSlowDownUpdate)
576    EVT_UPDATE_UI(menu_ROTATION_REVERSE, MainFrm::OnReverseDirectionOfRotationUpdate)
577    EVT_UPDATE_UI(menu_ROTATION_STEP_CCW, MainFrm::OnStepOnceAnticlockwiseUpdate)
578    EVT_UPDATE_UI(menu_ROTATION_STEP_CW, MainFrm::OnStepOnceClockwiseUpdate)
579    EVT_UPDATE_UI(menu_ORIENT_MOVE_NORTH, MainFrm::OnMoveNorthUpdate)
580    EVT_UPDATE_UI(menu_ORIENT_MOVE_EAST, MainFrm::OnMoveEastUpdate)
581    EVT_UPDATE_UI(menu_ORIENT_MOVE_SOUTH, MainFrm::OnMoveSouthUpdate)
582    EVT_UPDATE_UI(menu_ORIENT_MOVE_WEST, MainFrm::OnMoveWestUpdate)
583    EVT_UPDATE_UI(menu_ORIENT_SHIFT_LEFT, MainFrm::OnShiftDisplayLeftUpdate)
584    EVT_UPDATE_UI(menu_ORIENT_SHIFT_RIGHT, MainFrm::OnShiftDisplayRightUpdate)
585    EVT_UPDATE_UI(menu_ORIENT_SHIFT_UP, MainFrm::OnShiftDisplayUpUpdate)
586    EVT_UPDATE_UI(menu_ORIENT_SHIFT_DOWN, MainFrm::OnShiftDisplayDownUpdate)
587    EVT_UPDATE_UI(menu_ORIENT_PLAN, MainFrm::OnPlanUpdate)
588    EVT_UPDATE_UI(menu_ORIENT_ELEVATION, MainFrm::OnElevationUpdate)
589    EVT_UPDATE_UI(menu_ORIENT_HIGHER_VP, MainFrm::OnHigherViewpointUpdate)
590    EVT_UPDATE_UI(menu_ORIENT_LOWER_VP, MainFrm::OnLowerViewpointUpdate)
591    EVT_UPDATE_UI(wxID_ZOOM_IN, MainFrm::OnZoomInUpdate)
592    EVT_UPDATE_UI(wxID_ZOOM_OUT, MainFrm::OnZoomOutUpdate)
593    EVT_UPDATE_UI(menu_ORIENT_DEFAULTS, MainFrm::OnDefaultsUpdate)
594    EVT_UPDATE_UI(menu_VIEW_SHOW_LEGS, MainFrm::OnShowSurveyLegsUpdate)
595    EVT_UPDATE_UI(menu_VIEW_SPLAYS, MainFrm::OnSplaysUpdate)
596    EVT_UPDATE_UI(menu_SPLAYS_HIDE, MainFrm::OnHideSplaysUpdate)
597    EVT_UPDATE_UI(menu_SPLAYS_SHOW_NORMAL, MainFrm::OnShowSplaysNormalUpdate)
598    EVT_UPDATE_UI(menu_SPLAYS_SHOW_FADED, MainFrm::OnShowSplaysFadedUpdate)
599    EVT_UPDATE_UI(menu_VIEW_SHOW_CROSSES, MainFrm::OnShowCrossesUpdate)
600    EVT_UPDATE_UI(menu_VIEW_SHOW_ENTRANCES, MainFrm::OnShowEntrancesUpdate)
601    EVT_UPDATE_UI(menu_VIEW_SHOW_FIXED_PTS, MainFrm::OnShowFixedPtsUpdate)
602    EVT_UPDATE_UI(menu_VIEW_SHOW_EXPORTED_PTS, MainFrm::OnShowExportedPtsUpdate)
603    EVT_UPDATE_UI(menu_VIEW_SHOW_NAMES, MainFrm::OnShowStationNamesUpdate)
604    EVT_UPDATE_UI(menu_VIEW_SHOW_SURFACE, MainFrm::OnShowSurfaceUpdate)
605    EVT_UPDATE_UI(menu_VIEW_SHOW_OVERLAPPING_NAMES, MainFrm::OnDisplayOverlappingNamesUpdate)
606    EVT_UPDATE_UI(menu_VIEW_COLOUR_BY_DEPTH, MainFrm::OnColourByDepthUpdate)
607    EVT_UPDATE_UI(menu_VIEW_COLOUR_BY_DATE, MainFrm::OnColourByDateUpdate)
608    EVT_UPDATE_UI(menu_VIEW_COLOUR_BY_ERROR, MainFrm::OnColourByErrorUpdate)
609    EVT_UPDATE_UI(menu_VIEW_GRID, MainFrm::OnViewGridUpdate)
610    EVT_UPDATE_UI(menu_VIEW_BOUNDING_BOX, MainFrm::OnViewBoundingBoxUpdate)
611    EVT_UPDATE_UI(menu_VIEW_PERSPECTIVE, MainFrm::OnViewPerspectiveUpdate)
612    EVT_UPDATE_UI(menu_VIEW_SMOOTH_SHADING, MainFrm::OnViewSmoothShadingUpdate)
613    EVT_UPDATE_UI(menu_VIEW_TEXTURED, MainFrm::OnViewTexturedUpdate)
614    EVT_UPDATE_UI(menu_VIEW_FOG, MainFrm::OnViewFogUpdate)
615    EVT_UPDATE_UI(menu_VIEW_SMOOTH_LINES, MainFrm::OnViewSmoothLinesUpdate)
616    EVT_UPDATE_UI(menu_VIEW_FULLSCREEN, MainFrm::OnViewFullScreenUpdate)
617    EVT_UPDATE_UI(menu_VIEW_SHOW_TUBES, MainFrm::OnToggleTubesUpdate)
618    EVT_UPDATE_UI(menu_IND_COMPASS, MainFrm::OnViewCompassUpdate)
619    EVT_UPDATE_UI(menu_IND_CLINO, MainFrm::OnViewClinoUpdate)
620    EVT_UPDATE_UI(menu_IND_COLOUR_KEY, MainFrm::OnToggleColourKeyUpdate)
621    EVT_UPDATE_UI(menu_IND_SCALE_BAR, MainFrm::OnToggleScalebarUpdate)
622    EVT_UPDATE_UI(menu_CTL_INDICATORS, MainFrm::OnIndicatorsUpdate)
623    EVT_UPDATE_UI(menu_CTL_SIDE_PANEL, MainFrm::OnViewSidePanelUpdate)
624    EVT_UPDATE_UI(menu_CTL_REVERSE, MainFrm::OnReverseControlsUpdate)
625    EVT_UPDATE_UI(menu_CTL_CANCEL_DIST_LINE, MainFrm::OnCancelDistLineUpdate)
626    EVT_UPDATE_UI(menu_CTL_METRIC, MainFrm::OnToggleMetricUpdate)
627    EVT_UPDATE_UI(menu_CTL_DEGREES, MainFrm::OnToggleDegreesUpdate)
628END_EVENT_TABLE()
629
630class LabelCmp : public greater<const LabelInfo*> {
631    wxChar separator;
632public:
633    LabelCmp(wxChar separator_) : separator(separator_) {}
634    bool operator()(const LabelInfo* pt1, const LabelInfo* pt2) {
635        return name_cmp(pt1->GetText(), pt2->GetText(), separator) < 0;
636    }
637};
638
639class LabelPlotCmp : public greater<const LabelInfo*> {
640    wxChar separator;
641public:
642    LabelPlotCmp(wxChar separator_) : separator(separator_) {}
643    bool operator()(const LabelInfo* pt1, const LabelInfo* pt2) {
644        int n = pt1->get_flags() - pt2->get_flags();
645        if (n) return n > 0;
646        wxString l1 = pt1->GetText().AfterLast(separator);
647        wxString l2 = pt2->GetText().AfterLast(separator);
648        n = name_cmp(l1, l2, separator);
649        if (n) return n < 0;
650        // Prefer non-2-nodes...
651        // FIXME; implement
652        // if leaf names are the same, prefer shorter labels as we can
653        // display more of them
654        n = pt1->GetText().length() - pt2->GetText().length();
655        if (n) return n < 0;
656        // make sure that we don't ever compare different labels as equal
657        return name_cmp(pt1->GetText(), pt2->GetText(), separator) < 0;
658    }
659};
660
661#if wxUSE_DRAG_AND_DROP
662class DnDFile : public wxFileDropTarget {
663    public:
664        DnDFile(MainFrm *parent) : m_Parent(parent) { }
665        virtual bool OnDropFiles(wxCoord, wxCoord,
666                        const wxArrayString &filenames);
667
668    private:
669        MainFrm * m_Parent;
670};
671
672bool
673DnDFile::OnDropFiles(wxCoord, wxCoord, const wxArrayString &filenames)
674{
675    // Load a survey file by drag-and-drop.
676    assert(filenames.GetCount() > 0);
677
678    if (filenames.GetCount() != 1) {
679        wxGetApp().ReportError(wmsg(/*You may only view one 3d file at a time.*/336));
680        return false;
681    }
682
683    m_Parent->OpenFile(filenames[0]);
684    return true;
685}
686#endif
687
688MainFrm::MainFrm(const wxString& title, const wxPoint& pos, const wxSize& size) :
689    wxFrame(NULL, 101, title, pos, size, wxDEFAULT_FRAME_STYLE),
690    m_Gfx(NULL), m_NumEntrances(0), m_NumFixedPts(0), m_NumExportedPts(0),
691    m_NumHighlighted(0),
692    m_HasUndergroundLegs(false), m_HasSplays(false), m_HasSurfaceLegs(false),
693    m_HasErrorInformation(false), m_IsExtendedElevation(false),
694    pending_find(false)
695#ifdef PREFDLG
696    , m_PrefsDlg(NULL)
697#endif
698{
699    icon_path = wxString(wmsg_cfgpth());
700    icon_path += wxCONFIG_PATH_SEPARATOR;
701    icon_path += wxT("icons");
702    icon_path += wxCONFIG_PATH_SEPARATOR;
703
704#ifdef _WIN32
705    // The peculiar name is so that the icon is the first in the file
706    // (required by Microsoft Windows for this type of icon)
707    SetIcon(wxIcon(wxT("aaaaaAven")));
708#else
709    SetIcon(wxIcon(icon_path + APP_IMAGE, wxBITMAP_TYPE_PNG));
710#endif
711
712    CreateMenuBar();
713    CreateToolBar();
714    CreateStatusBar(2, wxST_SIZEGRIP);
715    CreateSidePanel();
716
717    int widths[2] = { -1 /* variable width */, -1 };
718    GetStatusBar()->SetStatusWidths(2, widths);
719
720#ifdef __X__ // wxMotif or wxX11
721    int x;
722    int y;
723    GetSize(&x, &y);
724    // X seems to require a forced resize.
725    SetSize(-1, -1, x, y);
726#endif
727
728#if wxUSE_DRAG_AND_DROP
729    SetDropTarget(new DnDFile(this));
730#endif
731}
732
733void MainFrm::CreateMenuBar()
734{
735    // Create the menus and the menu bar.
736
737    wxMenu* filemenu = new wxMenu;
738    // wxID_OPEN stock label lacks the ellipses
739    filemenu->Append(wxID_OPEN, wmsg(/*&Open…\tCtrl+O*/220));
740    filemenu->AppendSeparator();
741    // wxID_PRINT stock label lacks the ellipses
742    filemenu->Append(wxID_PRINT, wmsg(/*&Print…\tCtrl+P*/380));
743    filemenu->Append(menu_FILE_PAGE_SETUP, wmsg(/*P&age Setup…*/381));
744    filemenu->AppendSeparator();
745    filemenu->Append(menu_FILE_SCREENSHOT, wmsg(/*&Screenshot…*/201));
746    filemenu->Append(menu_FILE_EXPORT, wmsg(/*&Export as…*/382));
747#ifndef __WXMAC__
748    // On wxMac the "Quit" menu item will be moved elsewhere, so we suppress
749    // this separator.
750    filemenu->AppendSeparator();
751#endif
752    filemenu->Append(wxID_EXIT);
753
754    m_history.UseMenu(filemenu);
755    m_history.Load(*wxConfigBase::Get());
756
757    wxMenu* rotmenu = new wxMenu;
758    rotmenu->AppendCheckItem(menu_ROTATION_TOGGLE, wmsg(/*Au&to-Rotate\tSpace*/231));
759    rotmenu->AppendSeparator();
760    rotmenu->Append(menu_ROTATION_SPEED_UP, wmsg(/*Speed &Up*/232));
761    rotmenu->Append(menu_ROTATION_SLOW_DOWN, wmsg(/*Slow &Down*/233));
762    rotmenu->AppendSeparator();
763    rotmenu->Append(menu_ROTATION_REVERSE, wmsg(/*&Reverse Direction*/234));
764    rotmenu->AppendSeparator();
765    rotmenu->Append(menu_ROTATION_STEP_CCW, wmsg(/*Step Once &Anticlockwise*/235));
766    rotmenu->Append(menu_ROTATION_STEP_CW, wmsg(/*Step Once &Clockwise*/236));
767
768    wxMenu* orientmenu = new wxMenu;
769    orientmenu->Append(menu_ORIENT_MOVE_NORTH, wmsg(/*View &North*/240));
770    orientmenu->Append(menu_ORIENT_MOVE_EAST, wmsg(/*View &East*/241));
771    orientmenu->Append(menu_ORIENT_MOVE_SOUTH, wmsg(/*View &South*/242));
772    orientmenu->Append(menu_ORIENT_MOVE_WEST, wmsg(/*View &West*/243));
773    orientmenu->AppendSeparator();
774    orientmenu->Append(menu_ORIENT_SHIFT_LEFT, wmsg(/*Shift Survey &Left*/244));
775    orientmenu->Append(menu_ORIENT_SHIFT_RIGHT, wmsg(/*Shift Survey &Right*/245));
776    orientmenu->Append(menu_ORIENT_SHIFT_UP, wmsg(/*Shift Survey &Up*/246));
777    orientmenu->Append(menu_ORIENT_SHIFT_DOWN, wmsg(/*Shift Survey &Down*/247));
778    orientmenu->AppendSeparator();
779    orientmenu->Append(menu_ORIENT_PLAN, wmsg(/*&Plan View*/248));
780    orientmenu->Append(menu_ORIENT_ELEVATION, wmsg(/*Ele&vation*/249));
781    orientmenu->AppendSeparator();
782    orientmenu->Append(menu_ORIENT_HIGHER_VP, wmsg(/*&Higher Viewpoint*/250));
783    orientmenu->Append(menu_ORIENT_LOWER_VP, wmsg(/*L&ower Viewpoint*/251));
784    orientmenu->AppendSeparator();
785    // Default labels for wxID_ZOOM_IN and wxID_ZOOM_OUT don't have accels.
786    orientmenu->Append(wxID_ZOOM_IN, wmsg(/*&Zoom In\t]*/252));
787    orientmenu->Append(wxID_ZOOM_OUT, wmsg(/*Zoo&m Out\t[*/253));
788    orientmenu->AppendSeparator();
789    orientmenu->Append(menu_ORIENT_DEFAULTS, wmsg(/*Restore De&fault View*/254));
790
791    wxMenu* presmenu = new wxMenu;
792    presmenu->Append(menu_PRES_NEW, wmsg(/*&New Presentation*/311));
793    presmenu->Append(menu_PRES_OPEN, wmsg(/*&Open Presentation…*/312));
794    presmenu->Append(menu_PRES_SAVE, wmsg(/*&Save Presentation*/313));
795    presmenu->Append(menu_PRES_SAVE_AS, wmsg(/*Sa&ve Presentation As…*/314));
796    presmenu->AppendSeparator();
797    presmenu->Append(menu_PRES_MARK, wmsg(/*&Mark*/315));
798    presmenu->AppendCheckItem(menu_PRES_PLAY, wmsg(/*Pla&y*/316));
799    presmenu->Append(menu_PRES_EXPORT_MOVIE, wmsg(/*&Export as Movie…*/317));
800
801    wxMenu* viewmenu = new wxMenu;
802#ifndef PREFDLG
803    viewmenu->AppendCheckItem(menu_VIEW_SHOW_NAMES, wmsg(/*Station &Names\tCtrl+N*/270));
804    viewmenu->AppendCheckItem(menu_VIEW_SHOW_TUBES, wmsg(/*Passage &Tubes\tCtrl+T*/346));
805    viewmenu->AppendCheckItem(menu_VIEW_SHOW_CROSSES, wmsg(/*&Crosses\tCtrl+X*/271));
806    viewmenu->AppendCheckItem(menu_VIEW_GRID, wmsg(/*&Grid\tCtrl+G*/297));
807    viewmenu->AppendCheckItem(menu_VIEW_BOUNDING_BOX, wmsg(/*&Bounding Box\tCtrl+B*/318));
808    viewmenu->AppendSeparator();
809    viewmenu->AppendCheckItem(menu_VIEW_SHOW_LEGS, wmsg(/*&Underground Survey Legs\tCtrl+L*/272));
810    viewmenu->AppendCheckItem(menu_VIEW_SHOW_SURFACE, wmsg(/*&Surface Survey Legs\tCtrl+F*/291));
811
812    wxMenu* splaymenu = new wxMenu;
813    splaymenu->AppendCheckItem(menu_SPLAYS_HIDE, wmsg(/*&Hide*/407));
814    splaymenu->AppendCheckItem(menu_SPLAYS_SHOW_FADED, wmsg(/*&Fade*/408));
815    splaymenu->AppendCheckItem(menu_SPLAYS_SHOW_NORMAL, wmsg(/*&Show*/409));
816    viewmenu->Append(menu_VIEW_SPLAYS, wmsg(/*Spla&y Legs*/406), splaymenu);
817
818    viewmenu->AppendSeparator();
819    viewmenu->AppendCheckItem(menu_VIEW_SHOW_OVERLAPPING_NAMES, wmsg(/*&Overlapping Names*/273));
820    viewmenu->AppendCheckItem(menu_VIEW_COLOUR_BY_DEPTH, wmsg(/*Colour by &Depth*/292));
821    viewmenu->AppendCheckItem(menu_VIEW_COLOUR_BY_DATE, wmsg(/*Colour by D&ate*/293));
822    viewmenu->AppendCheckItem(menu_VIEW_COLOUR_BY_ERROR, wmsg(/*Colour by E&rror*/289));
823    viewmenu->AppendSeparator();
824    viewmenu->AppendCheckItem(menu_VIEW_SHOW_ENTRANCES, wmsg(/*Highlight &Entrances*/294));
825    viewmenu->AppendCheckItem(menu_VIEW_SHOW_FIXED_PTS, wmsg(/*Highlight &Fixed Points*/295));
826    viewmenu->AppendCheckItem(menu_VIEW_SHOW_EXPORTED_PTS, wmsg(/*Highlight E&xported Points*/296));
827    viewmenu->AppendSeparator();
828#else
829    viewmenu-> Append(menu_VIEW_CANCEL_DIST_LINE, wmsg(/*&Cancel Measuring Line\tEscape*/281));
830#endif
831    viewmenu->AppendCheckItem(menu_VIEW_PERSPECTIVE, wmsg(/*&Perspective*/237));
832// FIXME: enable this    viewmenu->AppendCheckItem(menu_VIEW_SMOOTH_SHADING, wmsg(/*&Smooth Shading*/?!?);
833    viewmenu->AppendCheckItem(menu_VIEW_TEXTURED, wmsg(/*Textured &Walls*/238));
834    viewmenu->AppendCheckItem(menu_VIEW_FOG, wmsg(/*Fade Distant Ob&jects*/239));
835    viewmenu->AppendCheckItem(menu_VIEW_SMOOTH_LINES, wmsg(/*Smoot&hed Survey Legs*/298));
836    viewmenu->AppendSeparator();
837#ifdef __WXMAC__
838    // F11 on OS X is used by the desktop (for speaker volume and/or window
839    // navigation).  The standard OS X shortcut for full screen mode is
840    // Shift-Command-F which in wxWidgets terms is Shift+Ctrl+F.
841    wxString wxmac_fullscreen = wmsg(/*Full Screen &Mode\tF11*/356);
842    wxmac_fullscreen.Replace(wxT("\tF11"), wxT("\rShift+Ctrl+F"), false);
843    viewmenu->AppendCheckItem(menu_VIEW_FULLSCREEN, wxmac_fullscreen);
844#else
845    viewmenu->AppendCheckItem(menu_VIEW_FULLSCREEN, wmsg(/*Full Screen &Mode\tF11*/356));
846#endif
847#ifdef PREFDLG
848    viewmenu->AppendSeparator();
849    viewmenu-> Append(wxID_PREFERENCES, wmsg(/*&Preferences…*/347));
850#endif
851
852#ifndef PREFDLG
853    wxMenu* ctlmenu = new wxMenu;
854    ctlmenu->AppendCheckItem(menu_CTL_REVERSE, wmsg(/*&Reverse Sense\tCtrl+R*/280));
855    ctlmenu->AppendSeparator();
856    ctlmenu->Append(menu_CTL_CANCEL_DIST_LINE, wmsg(/*&Cancel Measuring Line\tEscape*/281));
857    ctlmenu->AppendSeparator();
858    wxMenu* indmenu = new wxMenu;
859    indmenu->AppendCheckItem(menu_IND_COMPASS, wmsg(/*&Compass*/274));
860    indmenu->AppendCheckItem(menu_IND_CLINO, wmsg(/*C&linometer*/275));
861    indmenu->AppendCheckItem(menu_IND_COLOUR_KEY, wmsg(/*Colour &Key*/276));
862    indmenu->AppendCheckItem(menu_IND_SCALE_BAR, wmsg(/*&Scale Bar*/277));
863    ctlmenu->Append(menu_CTL_INDICATORS, wmsg(/*&Indicators*/299), indmenu);
864    ctlmenu->AppendCheckItem(menu_CTL_SIDE_PANEL, wmsg(/*&Side Panel*/337));
865    ctlmenu->AppendSeparator();
866    ctlmenu->AppendCheckItem(menu_CTL_METRIC, wmsg(/*&Metric*/342));
867    ctlmenu->AppendCheckItem(menu_CTL_DEGREES, wmsg(/*&Degrees*/343));
868#endif
869
870    wxMenuBar* menubar = new wxMenuBar();
871    menubar->Append(filemenu, wmsg(/*&File*/210));
872    menubar->Append(rotmenu, wmsg(/*&Rotation*/211));
873    menubar->Append(orientmenu, wmsg(/*&Orientation*/212));
874    menubar->Append(viewmenu, wmsg(/*&View*/213));
875#ifndef PREFDLG
876    menubar->Append(ctlmenu, wmsg(/*&Controls*/214));
877#endif
878    menubar->Append(presmenu, wmsg(/*&Presentation*/216));
879#ifndef __WXMAC__
880    // On wxMac the "About" menu item will be moved elsewhere, so we suppress
881    // this menu since it will then be empty.
882    wxMenu* helpmenu = new wxMenu;
883    helpmenu->Append(wxID_ABOUT);
884
885    menubar->Append(helpmenu, wmsg(/*&Help*/215));
886#endif
887    SetMenuBar(menubar);
888}
889
890// ICON must be a literal string.
891#define TOOLBAR_BITMAP(ICON) wxBitmap(icon_path + wxT(ICON".png"), wxBITMAP_TYPE_PNG)
892
893void MainFrm::CreateToolBar()
894{
895    // Create the toolbar.
896
897    wxToolBar* toolbar = wxFrame::CreateToolBar();
898
899#ifndef __WXGTK20__
900    toolbar->SetMargins(5, 5);
901#endif
902
903    // FIXME: TRANSLATE tooltips
904    toolbar->AddTool(wxID_OPEN, wxT("Open"), TOOLBAR_BITMAP("open"), wxT("Open a survey file for viewing"));
905    toolbar->AddTool(menu_PRES_OPEN, wxT("Open presentation"), TOOLBAR_BITMAP("open-pres"), wxT("Open a presentation"));
906    toolbar->AddSeparator();
907    toolbar->AddCheckTool(menu_ROTATION_TOGGLE, wxT("Toggle rotation"), TOOLBAR_BITMAP("rotation"), wxNullBitmap, wxT("Toggle rotation"));
908    toolbar->AddTool(menu_ORIENT_PLAN, wxT("Plan"), TOOLBAR_BITMAP("plan"), wxT("Switch to plan view"));
909    toolbar->AddTool(menu_ORIENT_ELEVATION, wxT("Elevation"), TOOLBAR_BITMAP("elevation"), wxT("Switch to elevation view"));
910    toolbar->AddTool(menu_ORIENT_DEFAULTS, wxT("Default view"), TOOLBAR_BITMAP("defaults"), wxT("Restore default view"));
911    toolbar->AddSeparator();
912    toolbar->AddCheckTool(menu_VIEW_SHOW_NAMES, wxT("Names"), TOOLBAR_BITMAP("names"), wxNullBitmap, wxT("Show station names"));
913    toolbar->AddCheckTool(menu_VIEW_SHOW_CROSSES, wxT("Crosses"), TOOLBAR_BITMAP("crosses"), wxNullBitmap, wxT("Show crosses on stations"));
914    toolbar->AddCheckTool(menu_VIEW_SHOW_ENTRANCES, wxT("Entrances"), TOOLBAR_BITMAP("entrances"), wxNullBitmap, wxT("Highlight entrances"));
915    toolbar->AddCheckTool(menu_VIEW_SHOW_FIXED_PTS, wxT("Fixed points"), TOOLBAR_BITMAP("fixed-pts"), wxNullBitmap, wxT("Highlight fixed points"));
916    toolbar->AddCheckTool(menu_VIEW_SHOW_EXPORTED_PTS, wxT("Exported points"), TOOLBAR_BITMAP("exported-pts"), wxNullBitmap, wxT("Highlight exported stations"));
917    toolbar->AddSeparator();
918    toolbar->AddCheckTool(menu_VIEW_SHOW_LEGS, wxT("Underground legs"), TOOLBAR_BITMAP("ug-legs"), wxNullBitmap, wxT("Show underground surveys"));
919    toolbar->AddCheckTool(menu_VIEW_SHOW_SURFACE, wxT("Surface legs"), TOOLBAR_BITMAP("surface-legs"), wxNullBitmap, wxT("Show surface surveys"));
920    toolbar->AddCheckTool(menu_VIEW_SHOW_TUBES, wxT("Tubes"), TOOLBAR_BITMAP("tubes"), wxNullBitmap, wxT("Show passage tubes"));
921    toolbar->AddSeparator();
922    toolbar->AddCheckTool(menu_PRES_FREWIND, wxT("Fast Rewind"), TOOLBAR_BITMAP("pres-frew"), wxNullBitmap, wxT("Very Fast Rewind"));
923    toolbar->AddCheckTool(menu_PRES_REWIND, wxT("Rewind"), TOOLBAR_BITMAP("pres-rew"), wxNullBitmap, wxT("Fast Rewind"));
924    toolbar->AddCheckTool(menu_PRES_REVERSE, wxT("Backwards"), TOOLBAR_BITMAP("pres-go-back"), wxNullBitmap, wxT("Play Backwards"));
925    toolbar->AddCheckTool(menu_PRES_PAUSE, wxT("Pause"), TOOLBAR_BITMAP("pres-pause"), wxNullBitmap, wxT("Pause"));
926    toolbar->AddCheckTool(menu_PRES_PLAY, wxT("Go"), TOOLBAR_BITMAP("pres-go"), wxNullBitmap, wxT("Play"));
927    toolbar->AddCheckTool(menu_PRES_FF, wxT("FF"), TOOLBAR_BITMAP("pres-ff"), wxNullBitmap, wxT("Fast Forward"));
928    toolbar->AddCheckTool(menu_PRES_FFF, wxT("Very FF"), TOOLBAR_BITMAP("pres-fff"), wxNullBitmap, wxT("Very Fast Forward"));
929    toolbar->AddTool(wxID_STOP, wxT("Stop"), TOOLBAR_BITMAP("pres-stop"), wxT("Stop"));
930
931    toolbar->AddSeparator();
932    m_FindBox = new wxTextCtrl(toolbar, textctrl_FIND, wxString(), wxDefaultPosition,
933                               wxDefaultSize, wxTE_PROCESS_ENTER);
934    toolbar->AddControl(m_FindBox);
935    toolbar->AddTool(wxID_FIND, wmsg(/*Find*/332), TOOLBAR_BITMAP("find")/*, "Search for station name"*/);
936    toolbar->AddTool(button_HIDE, wmsg(/*Hide*/333), TOOLBAR_BITMAP("hideresults")/*, "Hide search results"*/);
937
938    toolbar->Realize();
939}
940
941void MainFrm::CreateSidePanel()
942{
943    m_Splitter = new AvenSplitterWindow(this);
944
945    m_Notebook = new wxNotebook(m_Splitter, 400, wxDefaultPosition,
946                                wxDefaultSize,
947                                wxBK_BOTTOM | wxBK_LEFT);
948    m_Notebook->Show(false);
949
950    wxPanel * panel = new wxPanel(m_Notebook);
951    m_Tree = new AvenTreeCtrl(this, panel);
952
953//    m_RegexpCheckBox = new wxCheckBox(find_panel, -1,
954//                                    msg(/*Regular expression*/));
955
956    wxBoxSizer *panel_sizer = new wxBoxSizer(wxVERTICAL);
957    panel_sizer->Add(m_Tree, 1, wxALL | wxEXPAND, 2);
958    panel->SetAutoLayout(true);
959    panel->SetSizer(panel_sizer);
960//    panel_sizer->Fit(panel);
961//    panel_sizer->SetSizeHints(panel);
962
963    m_Control = new GUIControl();
964    m_Gfx = new GfxCore(this, m_Splitter, m_Control);
965    m_Control->SetView(m_Gfx);
966
967    // Presentation panel:
968    wxPanel * prespanel = new wxPanel(m_Notebook);
969
970    m_PresList = new AvenPresList(this, prespanel, m_Gfx);
971
972    wxBoxSizer *pres_panel_sizer = new wxBoxSizer(wxVERTICAL);
973    pres_panel_sizer->Add(m_PresList, 1, wxALL | wxEXPAND, 2);
974    prespanel->SetAutoLayout(true);
975    prespanel->SetSizer(pres_panel_sizer);
976
977    // Overall tabbed structure:
978    // FIXME: this assumes images are 15x15
979    wxImageList* image_list = new wxImageList(15, 15);
980    wxString path = wxString(wmsg_cfgpth());
981    path += wxCONFIG_PATH_SEPARATOR;
982    path += wxT("icons") ;
983    path += wxCONFIG_PATH_SEPARATOR;
984    image_list->Add(wxBitmap(path + wxT("survey-tree.png"), wxBITMAP_TYPE_PNG));
985    image_list->Add(wxBitmap(path + wxT("pres-tree.png"), wxBITMAP_TYPE_PNG));
986    m_Notebook->SetImageList(image_list);
987    m_Notebook->AddPage(panel, wmsg(/*Surveys*/376), true, 0);
988    m_Notebook->AddPage(prespanel, wmsg(/*Presentation*/377), false, 1);
989
990    m_Splitter->Initialize(m_Gfx);
991}
992
993bool MainFrm::LoadData(const wxString& file, wxString prefix)
994{
995    // Load survey data from file, centre the dataset around the origin,
996    // and prepare the data for drawing.
997
998#if 0
999    wxStopWatch timer;
1000    timer.Start();
1001#endif
1002
1003    // Load the processed survey data.
1004    img* survey = img_open_survey(file.mb_str(), prefix.mb_str());
1005    if (!survey) {
1006        wxString m = wxString::Format(wmsg(img_error2msg(img_error())), file.c_str());
1007        wxGetApp().ReportError(m);
1008        return false;
1009    }
1010
1011    m_IsExtendedElevation = survey->is_extended_elevation;
1012
1013    m_Tree->DeleteAllItems();
1014
1015    // Create a list of all the leg vertices, counting them and finding the
1016    // extent of the survey at the same time.
1017
1018    m_NumFixedPts = 0;
1019    m_NumExportedPts = 0;
1020    m_NumEntrances = 0;
1021    m_HasUndergroundLegs = false;
1022    m_HasSplays = false;
1023    m_HasSurfaceLegs = false;
1024    m_HasErrorInformation = false;
1025
1026    // FIXME: discard existing presentation? ask user about saving if we do!
1027
1028    // Delete any existing list entries.
1029    m_Labels.clear();
1030
1031    Double xmin = DBL_MAX;
1032    Double xmax = -DBL_MAX;
1033    Double ymin = DBL_MAX;
1034    Double ymax = -DBL_MAX;
1035    Double zmin = DBL_MAX;
1036    Double zmax = -DBL_MAX;
1037
1038    m_DepthMin = DBL_MAX;
1039    Double depthmax = -DBL_MAX;
1040
1041    m_DateMin = INT_MAX;
1042    int datemax = -1;
1043    complete_dateinfo = true;
1044
1045    traverses.clear();
1046    surface_traverses.clear();
1047    tubes.clear();
1048
1049    // Ultimately we probably want different types (subclasses perhaps?) for
1050    // underground and surface data, so we don't need to store LRUD for surface
1051    // stuff.
1052    traverse * current_traverse = NULL;
1053    traverse * current_surface_traverse = NULL;
1054    vector<XSect> * current_tube = NULL;
1055
1056    map<wxString, LabelInfo *> labelmap;
1057    list<LabelInfo*>::const_iterator last_mapped_label = m_Labels.begin();
1058
1059    int result;
1060    img_point prev_pt = {0,0,0};
1061    bool current_polyline_is_surface = false;
1062    bool current_polyline_is_splay = false;
1063    bool pending_move = false;
1064    // When a traverse is split between surface and underground, we split it
1065    // into contiguous traverses of each, but we need to track these so we can
1066    // assign the error statistics to all of them.  So we keep counts of how
1067    // many surface_traverses and traverses we've generated for the current
1068    // traverse.
1069    size_t n_traverses = 0;
1070    size_t n_surface_traverses = 0;
1071    do {
1072#if 0
1073        if (++items % 200 == 0) {
1074            long pos = ftell(survey->fh);
1075            int progress = int((double(pos) / double(file_size)) * 100.0);
1076            // SetProgress(progress);
1077        }
1078#endif
1079
1080        img_point pt;
1081        result = img_read_item(survey, &pt);
1082        switch (result) {
1083            case img_MOVE:
1084                n_traverses = n_surface_traverses = 0;
1085                pending_move = true;
1086                prev_pt = pt;
1087                break;
1088
1089            case img_LINE: {
1090                // Update survey extents.
1091                if (pt.x < xmin) xmin = pt.x;
1092                if (pt.x > xmax) xmax = pt.x;
1093                if (pt.y < ymin) ymin = pt.y;
1094                if (pt.y > ymax) ymax = pt.y;
1095                if (pt.z < zmin) zmin = pt.z;
1096                if (pt.z > zmax) zmax = pt.z;
1097
1098                int date = survey->days1;
1099                if (date != -1) {
1100                    date += (survey->days2 - date) / 2;
1101                    if (date < m_DateMin) m_DateMin = date;
1102                    if (date > datemax) datemax = date;
1103                } else {
1104                    complete_dateinfo = false;
1105                }
1106
1107                if (survey->flags & img_FLAG_SPLAY)
1108                    m_HasSplays = true;
1109                bool is_surface = (survey->flags & img_FLAG_SURFACE);
1110                bool is_splay = (survey->flags & img_FLAG_SPLAY);
1111                if (!is_surface) {
1112                    if (pt.z < m_DepthMin) m_DepthMin = pt.z;
1113                    if (pt.z > depthmax) depthmax = pt.z;
1114                }
1115                if (pending_move || current_polyline_is_surface != is_surface || current_polyline_is_splay != is_splay) {
1116                    if (!current_polyline_is_surface && current_traverse) {
1117                        //FixLRUD(*current_traverse);
1118                    }
1119
1120                    // Start new traverse (surface or underground).
1121                    if (is_surface) {
1122                        m_HasSurfaceLegs = true;
1123                        surface_traverses.push_back(traverse());
1124                        current_surface_traverse = &surface_traverses.back();
1125                        ++n_surface_traverses;
1126                    } else {
1127                        m_HasUndergroundLegs = true;
1128                        traverses.push_back(traverse());
1129                        current_traverse = &traverses.back();
1130                        current_traverse->isSplay = is_splay;
1131                        ++n_traverses;
1132                        // The previous point was at a surface->ug transition.
1133                        if (current_polyline_is_surface) {
1134                            if (prev_pt.z < m_DepthMin) m_DepthMin = prev_pt.z;
1135                            if (prev_pt.z > depthmax) depthmax = prev_pt.z;
1136                        }
1137                    }
1138
1139                    current_polyline_is_surface = is_surface;
1140                    current_polyline_is_splay = is_splay;
1141
1142                    if (pending_move) {
1143                        // Update survey extents.  We only need to do this if
1144                        // there's a pending move, since for a surface <->
1145                        // underground transition, we'll already have handled
1146                        // this point.
1147                        if (prev_pt.x < xmin) xmin = prev_pt.x;
1148                        if (prev_pt.x > xmax) xmax = prev_pt.x;
1149                        if (prev_pt.y < ymin) ymin = prev_pt.y;
1150                        if (prev_pt.y > ymax) ymax = prev_pt.y;
1151                        if (prev_pt.z < zmin) zmin = prev_pt.z;
1152                        if (prev_pt.z > zmax) zmax = prev_pt.z;
1153                    }
1154
1155                    if (is_surface) {
1156                        current_surface_traverse->push_back(PointInfo(prev_pt));
1157                    } else {
1158                        current_traverse->push_back(PointInfo(prev_pt));
1159                    }
1160                }
1161
1162                if (is_surface) {
1163                    current_surface_traverse->push_back(PointInfo(pt, date));
1164                } else {
1165                    current_traverse->push_back(PointInfo(pt, date));
1166                }
1167
1168                prev_pt = pt;
1169                pending_move = false;
1170                break;
1171            }
1172
1173            case img_LABEL: {
1174                wxString s(survey->label, wxConvUTF8);
1175                if (s.empty()) {
1176                    // If label isn't valid UTF-8 then this conversion will
1177                    // give an empty string.  In this case, assume that the
1178                    // label is CP1252 (the Microsoft superset of ISO8859-1).
1179                    static wxCSConv ConvCP1252(wxFONTENCODING_CP1252);
1180                    s = wxString(survey->label, ConvCP1252);
1181                    if (s.empty()) {
1182                        // Or if that doesn't work (ConvCP1252 doesn't like
1183                        // strings with some bytes in) let's just go for
1184                        // ISO8859-1.
1185                        s = wxString(survey->label, wxConvISO8859_1);
1186                    }
1187                }
1188                int flags = img2aven(survey->flags);
1189                LabelInfo* label = new LabelInfo(pt, s, flags);
1190                if (label->IsEntrance()) {
1191                    m_NumEntrances++;
1192                }
1193                if (label->IsFixedPt()) {
1194                    m_NumFixedPts++;
1195                }
1196                if (label->IsExportedPt()) {
1197                    m_NumExportedPts++;
1198                }
1199                m_Labels.push_back(label);
1200                break;
1201            }
1202
1203            case img_XSECT: {
1204                if (!current_tube) {
1205                    // Start new current_tube.
1206                    tubes.push_back(vector<XSect>());
1207                    current_tube = &tubes.back();
1208                }
1209
1210                LabelInfo * lab;
1211                wxString label(survey->label, wxConvUTF8);
1212                map<wxString, LabelInfo *>::const_iterator p;
1213                p = labelmap.find(label);
1214                if (p != labelmap.end()) {
1215                    lab = p->second;
1216                } else {
1217                    // Initialise labelmap lazily - we may have no
1218                    // cross-sections.
1219                    list<LabelInfo*>::const_iterator i;
1220                    if (labelmap.empty()) {
1221                        i = m_Labels.begin();
1222                    } else {
1223                        i = last_mapped_label;
1224                        ++i;
1225                    }
1226                    while (i != m_Labels.end() && (*i)->GetText() != label) {
1227                        labelmap[(*i)->GetText()] = *i;
1228                        ++i;
1229                    }
1230                    last_mapped_label = i;
1231                    if (i == m_Labels.end()) {
1232                        // Unattached cross-section - ignore for now.
1233                        printf("unattached cross-section\n");
1234                        if (current_tube->size() <= 1)
1235                            tubes.resize(tubes.size() - 1);
1236                        current_tube = NULL;
1237                        if (!m_Labels.empty())
1238                            --last_mapped_label;
1239                        break;
1240                    }
1241                    lab = *i;
1242                    labelmap[label] = lab;
1243                }
1244
1245                int date = survey->days1;
1246                if (date != -1) {
1247                    date += (survey->days2 - date) / 2;
1248                    if (date < m_DateMin) m_DateMin = date;
1249                    if (date > datemax) datemax = date;
1250                }
1251
1252                current_tube->push_back(XSect(*lab, date, survey->l, survey->r, survey->u, survey->d));
1253                break;
1254            }
1255
1256            case img_XSECT_END:
1257                // Finish off current_tube.
1258                // If there's only one cross-section in the tube, just
1259                // discard it for now.  FIXME: we should handle this
1260                // when we come to skinning the tubes.
1261                if (current_tube && current_tube->size() <= 1)
1262                    tubes.resize(tubes.size() - 1);
1263                current_tube = NULL;
1264                break;
1265
1266            case img_ERROR_INFO: {
1267                if (survey->E == 0.0) {
1268                    // Currently cavern doesn't spot all articulating traverses
1269                    // so we assume that any traverse with no error isn't part
1270                    // of a loop.  FIXME: fix cavern!
1271                    break;
1272                }
1273                m_HasErrorInformation = true;
1274                list<traverse>::reverse_iterator t;
1275                t = surface_traverses.rbegin();
1276                while (n_surface_traverses) {
1277                    assert(t != surface_traverses.rend());
1278                    t->n_legs = survey->n_legs;
1279                    t->length = survey->length;
1280                    t->E = survey->E;
1281                    t->H = survey->H;
1282                    t->V = survey->V;
1283                    --n_surface_traverses;
1284                    ++t;
1285                }
1286                t = traverses.rbegin();
1287                while (n_traverses) {
1288                    assert(t != traverses.rend());
1289                    t->n_legs = survey->n_legs;
1290                    t->length = survey->length;
1291                    t->E = survey->E;
1292                    t->H = survey->H;
1293                    t->V = survey->V;
1294                    --n_traverses;
1295                    ++t;
1296                }
1297                break;
1298            }
1299
1300            case img_BAD: {
1301                m_Labels.clear();
1302
1303                // FIXME: Do we need to reset all these? - Olly
1304                m_NumFixedPts = 0;
1305                m_NumExportedPts = 0;
1306                m_NumEntrances = 0;
1307                m_HasUndergroundLegs = false;
1308                m_HasSplays = false;
1309                m_HasSurfaceLegs = false;
1310
1311                img_close(survey);
1312
1313                wxString m = wxString::Format(wmsg(img_error2msg(img_error())), file.c_str());
1314                wxGetApp().ReportError(m);
1315
1316                return false;
1317            }
1318
1319            default:
1320                break;
1321        }
1322    } while (result != img_STOP);
1323
1324    if (!current_polyline_is_surface && current_traverse) {
1325        //FixLRUD(*current_traverse);
1326    }
1327
1328    // Finish off current_tube.
1329    // If there's only one cross-section in the tube, just
1330    // discard it for now.  FIXME: we should handle this
1331    // when we come to skinning the tubes.
1332    if (current_tube && current_tube->size() <= 1)
1333        tubes.resize(tubes.size() - 1);
1334
1335    separator = survey->separator;
1336    m_Title = wxString(survey->title, wxConvUTF8);
1337    if (strcmp(survey->datestamp, "?") == 0) {
1338        m_DateStamp = wmsg(/*Date and time not available.*/108);
1339    } else if (survey->datestamp[0] == '@') {
1340        char * end;
1341        time_t t = (time_t)strtol(survey->datestamp + 1, &end, 10);
1342        if (*end == '\0') {
1343            const struct tm * tm = localtime(&t);
1344            char buf[256];
1345            strftime(buf, 256, msg(/*%a,%Y.%m.%d %H:%M:%S %Z*/107), tm);
1346            m_DateStamp = wxString(buf, wxConvUTF8);
1347        }
1348    }
1349    if (m_DateStamp.empty()) {
1350        m_DateStamp = wxString(survey->datestamp, wxConvUTF8);
1351    }
1352    img_close(survey);
1353
1354    // Check we've actually loaded some legs or stations!
1355    if (!m_HasUndergroundLegs && !m_HasSurfaceLegs && m_Labels.empty()) {
1356        wxString m = wxString::Format(wmsg(/*No survey data in 3d file “%s”*/202), file.c_str());
1357        wxGetApp().ReportError(m);
1358        return false;
1359    }
1360
1361    if (traverses.empty() && surface_traverses.empty()) {
1362        // No legs, so get survey extents from stations
1363        list<LabelInfo*>::const_iterator i;
1364        for (i = m_Labels.begin(); i != m_Labels.end(); ++i) {
1365            if ((*i)->GetX() < xmin) xmin = (*i)->GetX();
1366            if ((*i)->GetX() > xmax) xmax = (*i)->GetX();
1367            if ((*i)->GetY() < ymin) ymin = (*i)->GetY();
1368            if ((*i)->GetY() > ymax) ymax = (*i)->GetY();
1369            if ((*i)->GetZ() < zmin) zmin = (*i)->GetZ();
1370            if ((*i)->GetZ() > zmax) zmax = (*i)->GetZ();
1371        }
1372    }
1373
1374    m_Ext.assign(xmax - xmin, ymax - ymin, zmax - zmin);
1375
1376    if (datemax < m_DateMin) m_DateMin = datemax;
1377    m_DateExt = datemax - m_DateMin;
1378
1379    // Centre the dataset around the origin.
1380    CentreDataset(Vector3(xmin, ymin, zmin));
1381
1382    if (depthmax < m_DepthMin) {
1383        m_DepthMin = 0;
1384        m_DepthExt = 0;
1385    } else {
1386        m_DepthExt = depthmax - m_DepthMin;
1387        m_DepthMin -= m_Offsets.GetZ();
1388    }
1389
1390#if 0
1391    printf("time to load = %.3f\n", (double)timer.Time());
1392#endif
1393
1394    // Update window title.
1395    SetTitle(m_Title + " - "APP_NAME);
1396
1397    return true;
1398}
1399
1400#if 0
1401// Run along a newly read in traverse and make up plausible LRUD where
1402// it is missing.
1403void
1404MainFrm::FixLRUD(traverse & centreline)
1405{
1406    assert(centreline.size() > 1);
1407
1408    Double last_size = 0;
1409    vector<PointInfo>::iterator i = centreline.begin();
1410    while (i != centreline.end()) {
1411        // Get the coordinates of this vertex.
1412        Point & pt_v = *i++;
1413        Double size;
1414
1415        if (i != centreline.end()) {
1416            Double h = sqrd(i->GetX() - pt_v.GetX()) +
1417                       sqrd(i->GetY() - pt_v.GetY());
1418            Double v = sqrd(i->GetZ() - pt_v.GetZ());
1419            if (h + v > 30.0 * 30.0) {
1420                Double scale = 30.0 / sqrt(h + v);
1421                h *= scale;
1422                v *= scale;
1423            }
1424            size = sqrt(h + v / 9);
1425            size /= 4;
1426            if (i == centreline.begin() + 1) {
1427                // First segment.
1428                last_size = size;
1429            } else {
1430                // Intermediate segment.
1431                swap(size, last_size);
1432                size += last_size;
1433                size /= 2;
1434            }
1435        } else {
1436            // Last segment.
1437            size = last_size;
1438        }
1439
1440        Double & l = pt_v.l;
1441        Double & r = pt_v.r;
1442        Double & u = pt_v.u;
1443        Double & d = pt_v.d;
1444
1445        if (l == 0 && r == 0 && u == 0 && d == 0) {
1446            l = r = u = d = -size;
1447        } else {
1448            if (l < 0 && r < 0) {
1449                l = r = -size;
1450            } else if (l < 0) {
1451                l = -(2 * size - r);
1452                if (l >= 0) l = -0.01;
1453            } else if (r < 0) {
1454                r = -(2 * size - l);
1455                if (r >= 0) r = -0.01;
1456            }
1457            if (u < 0 && d < 0) {
1458                u = d = -size;
1459            } else if (u < 0) {
1460                u = -(2 * size - d);
1461                if (u >= 0) u = -0.01;
1462            } else if (d < 0) {
1463                d = -(2 * size - u);
1464                if (d >= 0) d = -0.01;
1465            }
1466        }
1467    }
1468}
1469#endif
1470
1471void MainFrm::FillTree()
1472{
1473    // Create the root of the tree.
1474    wxTreeItemId treeroot = m_Tree->AddRoot(wxFileNameFromPath(m_File));
1475
1476    // Fill the tree of stations and prefixes.
1477    stack<wxTreeItemId> previous_ids;
1478    wxString current_prefix;
1479    wxTreeItemId current_id = treeroot;
1480
1481    list<LabelInfo*>::iterator pos = m_Labels.begin();
1482    while (pos != m_Labels.end()) {
1483        LabelInfo* label = *pos++;
1484
1485        if (label->IsAnon()) continue;
1486
1487        // Determine the current prefix.
1488        wxString prefix = label->GetText().BeforeLast(separator);
1489
1490        // Determine if we're still on the same prefix.
1491        if (prefix == current_prefix) {
1492            // no need to fiddle with branches...
1493        }
1494        // If not, then see if we've descended to a new prefix.
1495        else if (prefix.length() > current_prefix.length() &&
1496                 prefix.StartsWith(current_prefix) &&
1497                 (prefix[current_prefix.length()] == separator ||
1498                  current_prefix.empty())) {
1499            // We have, so start as many new branches as required.
1500            int current_prefix_length = current_prefix.length();
1501            current_prefix = prefix;
1502            size_t next_dot = current_prefix_length;
1503            if (!next_dot) --next_dot;
1504            do {
1505                size_t prev_dot = next_dot + 1;
1506
1507                // Extract the next bit of prefix.
1508                next_dot = prefix.find(separator, prev_dot + 1);
1509
1510                wxString bit = prefix.substr(prev_dot, next_dot - prev_dot);
1511                assert(!bit.empty());
1512
1513                // Add the current tree ID to the stack.
1514                previous_ids.push(current_id);
1515
1516                // Append the new item to the tree and set this as the current branch.
1517                current_id = m_Tree->AppendItem(current_id, bit);
1518                m_Tree->SetItemData(current_id, new TreeData(prefix.substr(0, next_dot)));
1519            } while (next_dot != wxString::npos);
1520        }
1521        // Otherwise, we must have moved up, and possibly then down again.
1522        else {
1523            size_t count = 0;
1524            bool ascent_only = (prefix.length() < current_prefix.length() &&
1525                                current_prefix.StartsWith(prefix) &&
1526                                (current_prefix[prefix.length()] == separator ||
1527                                 prefix.empty()));
1528            if (!ascent_only) {
1529                // Find out how much of the current prefix and the new prefix
1530                // are the same.
1531                // Note that we require a match of a whole number of parts
1532                // between dots!
1533                size_t n = min(prefix.length(), current_prefix.length());
1534                size_t i;
1535                for (i = 0; i < n && prefix[i] == current_prefix[i]; ++i) {
1536                    if (prefix[i] == separator) count = i + 1;
1537                }
1538            } else {
1539                count = prefix.length() + 1;
1540            }
1541
1542            // Extract the part of the current prefix after the bit (if any)
1543            // which has matched.
1544            // This gives the prefixes to ascend over.
1545            wxString prefixes_ascended = current_prefix.substr(count);
1546
1547            // Count the number of prefixes to ascend over.
1548            int num_prefixes = prefixes_ascended.Freq(separator);
1549
1550            // Reverse up over these prefixes.
1551            for (int i = 1; i <= num_prefixes; i++) {
1552                previous_ids.pop();
1553            }
1554            current_id = previous_ids.top();
1555            previous_ids.pop();
1556
1557            if (!ascent_only) {
1558                // Add branches for this new part.
1559                size_t next_dot = count - 1;
1560                do {
1561                    size_t prev_dot = next_dot + 1;
1562
1563                    // Extract the next bit of prefix.
1564                    next_dot = prefix.find(separator, prev_dot + 1);
1565
1566                    wxString bit = prefix.substr(prev_dot, next_dot - prev_dot);
1567                    assert(!bit.empty());
1568
1569                    // Add the current tree ID to the stack.
1570                    previous_ids.push(current_id);
1571
1572                    // Append the new item to the tree and set this as the current branch.
1573                    current_id = m_Tree->AppendItem(current_id, bit);
1574                    m_Tree->SetItemData(current_id, new TreeData(prefix.substr(0, next_dot)));
1575                } while (next_dot != wxString::npos);
1576            }
1577
1578            current_prefix = prefix;
1579        }
1580
1581        // Now add the leaf.
1582        wxString bit = label->GetText().AfterLast(separator);
1583        assert(!bit.empty());
1584        wxTreeItemId id = m_Tree->AppendItem(current_id, bit);
1585        m_Tree->SetItemData(id, new TreeData(label));
1586        label->tree_id = id;
1587        // Set the colour for an item in the survey tree.
1588        if (label->IsEntrance()) {
1589            // Entrances are green (like entrance blobs).
1590            m_Tree->SetItemTextColour(id, wxColour(0, 255, 40));
1591        } else if (label->IsSurface()) {
1592            // Surface stations are dark green.
1593            m_Tree->SetItemTextColour(id, wxColour(49, 158, 79));
1594        }
1595    }
1596
1597    m_Tree->Expand(treeroot);
1598    m_Tree->SetEnabled();
1599}
1600
1601void MainFrm::SelectTreeItem(LabelInfo* label)
1602{
1603    m_Tree->SelectItem(label->tree_id);
1604}
1605
1606void MainFrm::CentreDataset(const Vector3 & vmin)
1607{
1608    // Centre the dataset around the origin.
1609
1610    m_Offsets = vmin + (m_Ext * 0.5);
1611
1612    list<traverse>::iterator t = traverses.begin();
1613    while (t != traverses.end()) {
1614        assert(t->size() > 1);
1615        vector<PointInfo>::iterator pos = t->begin();
1616        while (pos != t->end()) {
1617            Point & point = *pos++;
1618            point -= m_Offsets;
1619        }
1620        ++t;
1621    }
1622
1623    t = surface_traverses.begin();
1624    while (t != surface_traverses.end()) {
1625        assert(t->size() > 1);
1626        vector<PointInfo>::iterator pos = t->begin();
1627        while (pos != t->end()) {
1628            Point & point = *pos++;
1629            point -= m_Offsets;
1630        }
1631        ++t;
1632    }
1633
1634    list<vector<XSect> >::iterator i = tubes.begin();
1635    while (i != tubes.end()) {
1636        assert(i->size() > 1);
1637        vector<XSect>::iterator pos = i->begin();
1638        while (pos != i->end()) {
1639            Point & point = *pos++;
1640            point -= m_Offsets;
1641        }
1642        ++i;
1643    }
1644
1645    list<LabelInfo*>::iterator lpos = m_Labels.begin();
1646    while (lpos != m_Labels.end()) {
1647        Point & point = **lpos++;
1648        point -= m_Offsets;
1649    }
1650}
1651
1652void MainFrm::OnMRUFile(wxCommandEvent& event)
1653{
1654    wxString f(m_history.GetHistoryFile(event.GetId() - wxID_FILE1));
1655    if (!f.empty()) OpenFile(f);
1656}
1657
1658void MainFrm::AddToFileHistory(const wxString & file)
1659{
1660    if (wxIsAbsolutePath(file)) {
1661        m_history.AddFileToHistory(file);
1662    } else {
1663        wxString abs = wxGetCwd();
1664        abs += wxCONFIG_PATH_SEPARATOR;
1665        abs += file;
1666        m_history.AddFileToHistory(abs);
1667    }
1668    wxConfigBase *b = wxConfigBase::Get();
1669    m_history.Save(*b);
1670    b->Flush();
1671}
1672
1673void MainFrm::OpenFile(const wxString& file, wxString survey)
1674{
1675    wxBusyCursor hourglass;
1676
1677    // Check if this is an unprocessed survey data file.
1678    if (file.length() > 4 && file[file.length() - 4] == '.') {
1679        wxString ext(file, file.length() - 3, 3);
1680        ext.MakeLower();
1681        if (ext == wxT("svx") || ext == wxT("dat") || ext == wxT("mak")) {
1682            CavernLogWindow * log = new CavernLogWindow(this, m_Splitter);
1683            wxWindow * win = m_Splitter->GetWindow1();
1684            m_Splitter->ReplaceWindow(win, log);
1685            if (m_Splitter->GetWindow2() == NULL) {
1686                if (win != m_Gfx) win->Destroy();
1687            } else {
1688                if (m_Splitter->IsSplit()) m_Splitter->Unsplit();
1689            }
1690
1691            int result = log->process(file);
1692            if (result < 0) {
1693                // Error running cavern or processing data.
1694                return;
1695            }
1696
1697            AddToFileHistory(file);
1698            wxString file3d(file, 0, file.length() - 3);
1699            file3d.append(wxT("3d"));
1700            if (!LoadData(file3d, survey))
1701                return;
1702            if (result == 0) {
1703                InitialiseAfterLoad(file);
1704            }
1705            return;
1706        }
1707    }
1708
1709    if (!LoadData(file, survey))
1710        return;
1711    AddToFileHistory(file);
1712    InitialiseAfterLoad(file);
1713}
1714
1715void MainFrm::InitialiseAfterLoad(const wxString & file)
1716{
1717    int x;
1718    int y;
1719    GetClientSize(&x, &y);
1720    if (x < 600)
1721        x /= 3;
1722    else if (x < 1000)
1723        x = 200;
1724    else
1725        x /= 5;
1726
1727    // Do this before we potentially delete the log window which may own the
1728    // wxString which parameter file refers to!
1729    bool same_file = (file == m_File);
1730    if (!same_file)
1731        m_File = file;
1732
1733    // Sort the labels ready for filling the tree.
1734    m_Labels.sort(LabelCmp(separator));
1735
1736    // Fill the tree of stations and prefixes.
1737    FillTree();
1738
1739    // Sort labels so that entrances are displayed in preference,
1740    // then fixed points, then exported points, then other points.
1741    //
1742    // Also sort by leaf name so that we'll tend to choose labels
1743    // from different surveys, rather than labels from surveys which
1744    // are earlier in the list.
1745    m_Labels.sort(LabelPlotCmp(separator));
1746
1747    if (!m_FindBox->GetValue().empty()) {
1748        // Highlight any stations matching the current search.
1749        DoFind();
1750    }
1751
1752    wxWindow * win = NULL;
1753    if (m_Splitter->GetWindow2() == NULL) {
1754        win = m_Splitter->GetWindow1();
1755        if (win == m_Gfx) win = NULL;
1756    }
1757
1758    m_Splitter->SplitVertically(m_Notebook, m_Gfx, x);
1759    m_SashPosition = x; // Save width of panel.
1760
1761    m_Gfx->Initialise(same_file);
1762    m_Notebook->Show(true);
1763
1764    m_Gfx->Show(true);
1765    m_Gfx->SetFocus();
1766
1767    if (win) win->Destroy();
1768}
1769
1770//
1771//  UI event handlers
1772//
1773
1774// For Unix we want "*.svx;*.SVX" while for Windows we only want "*.svx".
1775#ifdef _WIN32
1776# define CASE(X)
1777#else
1778# define CASE(X) ";"X
1779#endif
1780
1781void MainFrm::OnOpen(wxCommandEvent&)
1782{
1783    AvenAllowOnTop ontop(this);
1784#ifdef __WXMOTIF__
1785    wxString filetypes = wxT("*.3d");
1786#else
1787    wxString filetypes;
1788    filetypes.Printf(wxT("%s|*.3d;*.svx;*.plt;*.plf;*.dat;*.mak;*.xyz"
1789                     CASE("*.3D;*.SVX;*.PLT;*.PLF;*.DAT;*.MAK;*.XYZ")
1790                     "|%s|*.3d"CASE("*.3D")
1791                     "|%s|*.svx"CASE("*.SVX")
1792                     "|%s|*.plt;*.plf"CASE("*.PLT;*.PLF")
1793                     "|%s|*.dat;*.mak"CASE("*.DAT;*.MAK")
1794                     "|%s|*.xyz"CASE("*.XYZ")
1795                     "|%s|%s"),
1796                     wmsg(/*All survey files*/229).c_str(),
1797                     wmsg(/*Survex 3d files*/207).c_str(),
1798                     wmsg(/*Survex svx files*/329).c_str(),
1799                     wmsg(/*Compass PLT files*/324).c_str(),
1800                     wmsg(/*Compass DAT and MAK files*/330).c_str(),
1801                     wmsg(/*CMAP XYZ files*/325).c_str(),
1802                     wmsg(/*All files*/208).c_str(),
1803                     wxFileSelectorDefaultWildcardStr);
1804#endif
1805    wxFileDialog dlg(this, wmsg(/*Select a survey file to view*/206),
1806                     wxString(), wxString(),
1807                     filetypes, wxFD_OPEN|wxFD_FILE_MUST_EXIST);
1808    if (dlg.ShowModal() == wxID_OK) {
1809        OpenFile(dlg.GetPath());
1810    }
1811}
1812
1813void MainFrm::OnScreenshot(wxCommandEvent&)
1814{
1815    AvenAllowOnTop ontop(this);
1816    wxString baseleaf;
1817    wxFileName::SplitPath(m_File, NULL, NULL, &baseleaf, NULL, wxPATH_NATIVE);
1818    wxFileDialog dlg(this, wmsg(/*Save Screenshot*/321), wxString(),
1819                     baseleaf + wxT(".png"),
1820                     wxT("*.png"), wxFD_SAVE|wxFD_OVERWRITE_PROMPT);
1821    if (dlg.ShowModal() == wxID_OK) {
1822        static bool png_handled = false;
1823        if (!png_handled) {
1824#if 0 // FIXME : enable this to allow other export formats...
1825            ::wxInitAllImageHandlers();
1826#else
1827            wxImage::AddHandler(new wxPNGHandler);
1828#endif
1829            png_handled = true;
1830        }
1831        if (!m_Gfx->SaveScreenshot(dlg.GetPath(), wxBITMAP_TYPE_PNG)) {
1832            wxGetApp().ReportError(wxString::Format(wmsg(/*Error writing to file “%s”*/110), dlg.GetPath().c_str()));
1833        }
1834    }
1835}
1836
1837void MainFrm::OnScreenshotUpdate(wxUpdateUIEvent& event)
1838{
1839    event.Enable(!m_File.empty());
1840}
1841
1842void MainFrm::OnFilePreferences(wxCommandEvent&)
1843{
1844#ifdef PREFDLG
1845    m_PrefsDlg = new PrefsDlg(m_Gfx, this);
1846    m_PrefsDlg->Show(true);
1847#endif
1848}
1849
1850void MainFrm::OnPrint(wxCommandEvent&)
1851{
1852    m_Gfx->OnPrint(m_File, m_Title, m_DateStamp);
1853}
1854
1855void MainFrm::OnPageSetup(wxCommandEvent&)
1856{
1857    wxPageSetupDialog dlg(this, wxGetApp().GetPageSetupDialogData());
1858    if (dlg.ShowModal() == wxID_OK) {
1859        wxGetApp().SetPageSetupDialogData(dlg.GetPageSetupData());
1860    }
1861}
1862
1863void MainFrm::OnExport(wxCommandEvent&)
1864{
1865    m_Gfx->OnExport(m_File, m_Title, m_DateStamp);
1866}
1867
1868void MainFrm::OnQuit(wxCommandEvent&)
1869{
1870    if (m_PresList->Modified()) {
1871        AvenAllowOnTop ontop(this);
1872        // FIXME: better to ask "Do you want to save your changes?" and offer [Save] [Discard] [Cancel]
1873        if (wxMessageBox(wmsg(/*The current presentation has been modified.  Abandon unsaved changes?*/327),
1874                         wmsg(/*Modified Presentation*/326),
1875                         wxOK|wxCANCEL|wxICON_QUESTION) == wxCANCEL) {
1876            return;
1877        }
1878    }
1879    wxConfigBase *b = wxConfigBase::Get();
1880    if (IsFullScreen()) {
1881        b->Write(wxT("width"), -2);
1882        b->DeleteEntry(wxT("height"));
1883    } else if (IsMaximized()) {
1884        b->Write(wxT("width"), -1);
1885        b->DeleteEntry(wxT("height"));
1886    } else {
1887        int width, height;
1888        GetSize(&width, &height);
1889        b->Write(wxT("width"), width);
1890        b->Write(wxT("height"), height);
1891    }
1892    b->Flush();
1893    exit(0);
1894}
1895
1896void MainFrm::OnClose(wxCloseEvent&)
1897{
1898    wxCommandEvent dummy;
1899    OnQuit(dummy);
1900}
1901
1902void MainFrm::OnAbout(wxCommandEvent&)
1903{
1904    AvenAllowOnTop ontop(this);
1905    AboutDlg dlg(this, icon_path);
1906    dlg.Centre();
1907    dlg.ShowModal();
1908}
1909
1910void MainFrm::UpdateStatusBar()
1911{
1912    if (!here_text.empty()) {
1913        GetStatusBar()->SetStatusText(here_text);
1914        GetStatusBar()->SetStatusText(dist_text, 1);
1915    } else if (!coords_text.empty()) {
1916        GetStatusBar()->SetStatusText(coords_text);
1917        GetStatusBar()->SetStatusText(distfree_text, 1);
1918    } else {
1919        GetStatusBar()->SetStatusText(wxString());
1920        GetStatusBar()->SetStatusText(wxString(), 1);
1921    }
1922}
1923
1924void MainFrm::ClearTreeSelection()
1925{
1926    m_Tree->UnselectAll();
1927    m_Gfx->SetThere();
1928    ShowInfo(NULL);
1929}
1930
1931void MainFrm::ClearCoords()
1932{
1933    if (!coords_text.empty()) {
1934        coords_text = wxString();
1935        UpdateStatusBar();
1936    }
1937}
1938
1939void MainFrm::SetCoords(const Vector3 &v)
1940{
1941    wxString & s = coords_text;
1942    if (m_Gfx->GetMetric()) {
1943        s.Printf(wmsg(/*%.2f E, %.2f N*/338), v.GetX(), v.GetY());
1944        s += wxString::Format(wxT(", %s %.2fm"), wmsg(/*Altitude*/335).c_str(), v.GetZ());
1945    } else {
1946        s.Printf(wmsg(/*%.2f E, %.2f N*/338),
1947                 v.GetX() / METRES_PER_FOOT, v.GetY() / METRES_PER_FOOT);
1948        s += wxString::Format(wxT(", %s %.2fft"), wmsg(/*Altitude*/335).c_str(),
1949                              v.GetZ() / METRES_PER_FOOT);
1950    }
1951    distfree_text = wxString();
1952    UpdateStatusBar();
1953}
1954
1955const LabelInfo * MainFrm::GetTreeSelection() const {
1956    wxTreeItemData* sel_wx;
1957    if (!m_Tree->GetSelectionData(&sel_wx)) return NULL;
1958
1959    const TreeData* data = static_cast<const TreeData*>(sel_wx);
1960    if (!data->IsStation()) return NULL;
1961
1962    return data->GetLabel();
1963}
1964
1965void MainFrm::SetCoords(Double x, Double y)
1966{
1967    wxString & s = coords_text;
1968    if (m_Gfx->GetMetric()) {
1969        s.Printf(wmsg(/*%.2f E, %.2f N*/338), x, y);
1970    } else {
1971        s.Printf(wmsg(/*%.2f E, %.2f N*/338),
1972                 x / METRES_PER_FOOT, y / METRES_PER_FOOT);
1973    }
1974
1975    wxString & t = distfree_text;
1976    t = wxString();
1977    const LabelInfo* label;
1978    if (m_Gfx->ShowingMeasuringLine() && (label = GetTreeSelection())) {
1979        Vector3 delta(x - m_Offsets.GetX() - label->GetX(),
1980                      y - m_Offsets.GetY() - label->GetY(), 0);
1981        Double dh = sqrt(delta.GetX()*delta.GetX() + delta.GetY()*delta.GetY());
1982        Double brg = deg(atan2(delta.GetX(), delta.GetY()));
1983        if (brg < 0) brg += 360;
1984
1985        wxString from_str;
1986        from_str.Printf(wmsg(/*From %s*/339), label->GetText().c_str());
1987
1988        wxString brg_unit;
1989        if (m_Gfx->GetDegrees()) {
1990            brg_unit = wmsg(/*°*/344);
1991        } else {
1992            brg *= 400.0 / 360.0;
1993            brg_unit = wmsg(/*grad*/345);
1994        }
1995
1996        if (m_Gfx->GetMetric()) {
1997            t.Printf(wmsg(/*%s: H %.2f%s, Brg %03d%s*/374),
1998                     from_str.c_str(), dh, wxT("m"), int(brg), brg_unit.c_str());
1999        } else {
2000            t.Printf(wmsg(/*%s: H %.2f%s, Brg %03d%s*/374),
2001                     from_str.c_str(), dh / METRES_PER_FOOT, wxT("ft"), int(brg),
2002                     brg_unit.c_str());
2003        }
2004    }
2005
2006    UpdateStatusBar();
2007}
2008
2009void MainFrm::SetAltitude(Double z)
2010{
2011    wxString & s = coords_text;
2012    if (m_Gfx->GetMetric()) {
2013        s.Printf(wxT("%s %.2fm"), wmsg(/*Altitude*/335).c_str(), double(z));
2014    } else {
2015        s.Printf(wxT("%s %.2fft"), wmsg(/*Altitude*/335).c_str(), double(z / METRES_PER_FOOT));
2016    }
2017
2018    wxString & t = distfree_text;
2019    t = wxString();
2020    const LabelInfo* label;
2021    if (m_Gfx->ShowingMeasuringLine() && (label = GetTreeSelection())) {
2022        Double dz = z - m_Offsets.GetZ() - label->GetZ();
2023
2024        wxString from_str;
2025        from_str.Printf(wmsg(/*From %s*/339), label->GetText().c_str());
2026
2027        if (m_Gfx->GetMetric()) {
2028            t.Printf(wmsg(/*%s: V %.2f%s*/375),
2029                     from_str.c_str(), dz, wxT("m"));
2030        } else {
2031            t.Printf(wmsg(/*%s: V %.2f%s*/375),
2032                     from_str.c_str(), dz / METRES_PER_FOOT, wxT("ft"));
2033        }
2034    }
2035
2036    UpdateStatusBar();
2037}
2038
2039void MainFrm::ShowInfo(const LabelInfo *here)
2040{
2041    assert(m_Gfx);
2042
2043    if (!here) {
2044        m_Gfx->SetHere();
2045        m_Tree->SetHere(wxTreeItemId());
2046        // Don't clear "There" mark here.
2047        if (here_text.empty() && dist_text.empty()) return;
2048        here_text = wxString();
2049        dist_text = wxString();
2050        UpdateStatusBar();
2051        return;
2052    }
2053
2054    Vector3 v = *here + m_Offsets;
2055    wxString & s = here_text;
2056    if (m_Gfx->GetMetric()) {
2057        s.Printf(wmsg(/*%.2f E, %.2f N*/338), v.GetX(), v.GetY());
2058        s += wxString::Format(wxT(", %s %.2fm"), wmsg(/*Altitude*/335).c_str(), v.GetZ());
2059    } else {
2060        s.Printf(wmsg(/*%.2f E, %.2f N*/338),
2061                 v.GetX() / METRES_PER_FOOT, v.GetY() / METRES_PER_FOOT);
2062        s += wxString::Format(wxT(", %s %.2fft"), wmsg(/*Altitude*/335).c_str(),
2063                              v.GetZ() / METRES_PER_FOOT);
2064    }
2065    s += wxT(": ");
2066    s += here->GetText();
2067    m_Gfx->SetHere(*here);
2068    m_Tree->SetHere(here->tree_id);
2069
2070    const LabelInfo* label;
2071    if (m_Gfx->ShowingMeasuringLine() && (label = GetTreeSelection())) {
2072        Vector3 delta = *here - *label;
2073
2074        Double d_horiz = sqrt(delta.GetX()*delta.GetX() + delta.GetY()*delta.GetY());
2075        Double dr = delta.magnitude();
2076
2077        Double brg = deg(atan2(delta.GetX(), delta.GetY()));
2078        if (brg < 0) brg += 360;
2079
2080        wxString from_str;
2081        from_str.Printf(wmsg(/*From %s*/339), label->GetText().c_str());
2082
2083        wxString hv_str;
2084        if (m_Gfx->GetMetric()) {
2085            hv_str.Printf(wmsg(/*H %.2f%s, V %.2f%s*/340),
2086                          d_horiz, wxT("m"), delta.GetZ(), wxT("m"));
2087        } else {
2088            hv_str.Printf(wmsg(/*H %.2f%s, V %.2f%s*/340),
2089                          d_horiz / METRES_PER_FOOT, wxT("ft"),
2090                          delta.GetZ() / METRES_PER_FOOT, wxT("ft"));
2091        }
2092        wxString brg_unit;
2093        if (m_Gfx->GetDegrees()) {
2094            brg_unit = wmsg(/*°*/344);
2095        } else {
2096            brg *= 400.0 / 360.0;
2097            brg_unit = wmsg(/*grad*/345);
2098        }
2099        wxString & d = dist_text;
2100        if (m_Gfx->GetMetric()) {
2101            d.Printf(wmsg(/*%s: %s, Dist %.2f%s, Brg %03d%s*/341),
2102                     from_str.c_str(), hv_str.c_str(),
2103                     dr, wxT("m"), int(brg), brg_unit.c_str());
2104        } else {
2105            d.Printf(wmsg(/*%s: %s, Dist %.2f%s, Brg %03d%s*/341),
2106                     from_str.c_str(), hv_str.c_str(),
2107                     dr / METRES_PER_FOOT, wxT("ft"), int(brg),
2108                     brg_unit.c_str());
2109        }
2110        m_Gfx->SetThere(*label);
2111    } else {
2112        dist_text = wxString();
2113        m_Gfx->SetThere();
2114    }
2115    UpdateStatusBar();
2116}
2117
2118void MainFrm::DisplayTreeInfo(const wxTreeItemData* item)
2119{
2120    const TreeData* data = static_cast<const TreeData*>(item);
2121    if (data && data->IsStation()) {
2122        const LabelInfo * label = data->GetLabel();
2123        ShowInfo(label);
2124        m_Gfx->SetHere(*label);
2125    } else {
2126        ShowInfo(NULL);
2127    }
2128}
2129
2130void MainFrm::TreeItemSelected(const wxTreeItemData* item, bool zoom)
2131{
2132    const TreeData* data = static_cast<const TreeData*>(item);
2133    if (data && data->IsStation()) {
2134        const LabelInfo* label = data->GetLabel();
2135        if (zoom) m_Gfx->CentreOn(*label);
2136        m_Gfx->SetThere(*label);
2137        dist_text = wxString();
2138        // FIXME: Need to update dist_text (From ... etc)
2139        // But we don't currently know where "here" is at this point in the
2140        // code!
2141    } else {
2142        dist_text = wxString();
2143        m_Gfx->SetThere();
2144    }
2145    if (!data) {
2146        // Must be the root.
2147        m_FindBox->SetValue(wxString());
2148        if (zoom) {
2149            wxCommandEvent dummy;
2150            OnDefaults(dummy);
2151        }
2152    } else if (data && !data->IsStation()) {
2153        m_FindBox->SetValue(data->GetSurvey() + wxT(".*"));
2154        if (zoom) {
2155            wxCommandEvent dummy;
2156            OnGotoFound(dummy);
2157        }
2158    }
2159    UpdateStatusBar();
2160}
2161
2162void MainFrm::OnPresNew(wxCommandEvent&)
2163{
2164    if (m_PresList->Modified()) {
2165        AvenAllowOnTop ontop(this);
2166        // FIXME: better to ask "Do you want to save your changes?" and offer [Save] [Discard] [Cancel]
2167        if (wxMessageBox(wmsg(/*The current presentation has been modified.  Abandon unsaved changes?*/327),
2168                         wmsg(/*Modified Presentation*/326),
2169                         wxOK|wxCANCEL|wxICON_QUESTION) == wxCANCEL) {
2170            return;
2171        }
2172    }
2173    m_PresList->New(m_File);
2174    if (!ShowingSidePanel()) ToggleSidePanel();
2175    // Select the presentation page in the notebook.
2176    m_Notebook->SetSelection(1);
2177}
2178
2179void MainFrm::OnPresOpen(wxCommandEvent&)
2180{
2181    AvenAllowOnTop ontop(this);
2182    if (m_PresList->Modified()) {
2183        // FIXME: better to ask "Do you want to save your changes?" and offer [Save] [Discard] [Cancel]
2184        if (wxMessageBox(wmsg(/*The current presentation has been modified.  Abandon unsaved changes?*/327),
2185                         wmsg(/*Modified Presentation*/326),
2186                         wxOK|wxCANCEL|wxICON_QUESTION) == wxCANCEL) {
2187            return;
2188        }
2189    }
2190#ifdef __WXMOTIF__
2191    wxFileDialog dlg(this, wmsg(/*Select a presentation to open*/322), wxString(), wxString(),
2192                     wxT("*.fly"), wxFD_OPEN);
2193#else
2194    wxFileDialog dlg(this, wmsg(/*Select a presentation to open*/322), wxString(), wxString(),
2195                     wxString::Format(wxT("%s|*.fly|%s|%s"),
2196                               wmsg(/*Aven presentations*/320).c_str(),
2197                               wmsg(/*All files*/208).c_str(),
2198                               wxFileSelectorDefaultWildcardStr),
2199                     wxFD_OPEN|wxFD_FILE_MUST_EXIST);
2200#endif
2201    if (dlg.ShowModal() == wxID_OK) {
2202        if (!m_PresList->Load(dlg.GetPath())) {
2203            return;
2204        }
2205        // FIXME : keep a history of loaded/saved presentations, like we do for
2206        // loaded surveys...
2207        // Select the presentation page in the notebook.
2208        m_Notebook->SetSelection(1);
2209    }
2210}
2211
2212void MainFrm::OnPresSave(wxCommandEvent&)
2213{
2214    m_PresList->Save(true);
2215}
2216
2217void MainFrm::OnPresSaveAs(wxCommandEvent&)
2218{
2219    m_PresList->Save(false);
2220}
2221
2222void MainFrm::OnPresMark(wxCommandEvent&)
2223{
2224    m_PresList->AddMark();
2225}
2226
2227void MainFrm::OnPresFRewind(wxCommandEvent&)
2228{
2229    m_Gfx->PlayPres(-100);
2230}
2231
2232void MainFrm::OnPresRewind(wxCommandEvent&)
2233{
2234    m_Gfx->PlayPres(-10);
2235}
2236
2237void MainFrm::OnPresReverse(wxCommandEvent&)
2238{
2239    m_Gfx->PlayPres(-1);
2240}
2241
2242void MainFrm::OnPresPlay(wxCommandEvent&)
2243{
2244    m_Gfx->PlayPres(1);
2245}
2246
2247void MainFrm::OnPresFF(wxCommandEvent&)
2248{
2249    m_Gfx->PlayPres(10);
2250}
2251
2252void MainFrm::OnPresFFF(wxCommandEvent&)
2253{
2254    m_Gfx->PlayPres(100);
2255}
2256
2257void MainFrm::OnPresPause(wxCommandEvent&)
2258{
2259    m_Gfx->PlayPres(0);
2260}
2261
2262void MainFrm::OnPresStop(wxCommandEvent&)
2263{
2264    m_Gfx->PlayPres(0, false);
2265}
2266
2267void MainFrm::OnPresExportMovie(wxCommandEvent&)
2268{
2269    AvenAllowOnTop ontop(this);
2270    // FIXME : Taking the leaf of the currently loaded presentation as the
2271    // default might make more sense?
2272    wxString baseleaf;
2273    wxFileName::SplitPath(m_File, NULL, NULL, &baseleaf, NULL, wxPATH_NATIVE);
2274    wxFileDialog dlg(this, wmsg(/*Export Movie*/331), wxString(),
2275                     baseleaf + wxT(".mpg"),
2276                     wxT("MPEG|*.mpg|AVI|*.avi|QuickTime|*.mov|WMV|*.wmv;*.asf"),
2277                     wxFD_SAVE|wxFD_OVERWRITE_PROMPT);
2278    if (dlg.ShowModal() == wxID_OK) {
2279        // Error is reported by GfxCore.
2280        (void)m_Gfx->ExportMovie(dlg.GetPath());
2281    }
2282}
2283
2284PresentationMark MainFrm::GetPresMark(int which)
2285{
2286    return m_PresList->GetPresMark(which);
2287}
2288
2289//void MainFrm::OnFileOpenTerrainUpdate(wxUpdateUIEvent& event)
2290//{
2291//    event.Enable(!m_File.empty());
2292//}
2293
2294void MainFrm::OnPresNewUpdate(wxUpdateUIEvent& event)
2295{
2296    event.Enable(!m_File.empty());
2297}
2298
2299void MainFrm::OnPresOpenUpdate(wxUpdateUIEvent& event)
2300{
2301    event.Enable(!m_File.empty());
2302}
2303
2304void MainFrm::OnPresSaveUpdate(wxUpdateUIEvent& event)
2305{
2306    event.Enable(!m_PresList->Empty());
2307}
2308
2309void MainFrm::OnPresSaveAsUpdate(wxUpdateUIEvent& event)
2310{
2311    event.Enable(!m_PresList->Empty());
2312}
2313
2314void MainFrm::OnPresMarkUpdate(wxUpdateUIEvent& event)
2315{
2316    event.Enable(!m_File.empty());
2317}
2318
2319void MainFrm::OnPresFRewindUpdate(wxUpdateUIEvent& event)
2320{
2321    event.Enable(m_Gfx && m_Gfx->GetPresentationMode());
2322    event.Check(m_Gfx && m_Gfx->GetPresentationSpeed() < -10);
2323}
2324
2325void MainFrm::OnPresRewindUpdate(wxUpdateUIEvent& event)
2326{
2327    event.Enable(m_Gfx && m_Gfx->GetPresentationMode());
2328    event.Check(m_Gfx && m_Gfx->GetPresentationSpeed() == -10);
2329}
2330
2331void MainFrm::OnPresReverseUpdate(wxUpdateUIEvent& event)
2332{
2333    event.Enable(m_Gfx && m_Gfx->GetPresentationMode());
2334    event.Check(m_Gfx && m_Gfx->GetPresentationSpeed() == -1);
2335}
2336
2337void MainFrm::OnPresPlayUpdate(wxUpdateUIEvent& event)
2338{
2339    event.Enable(!m_PresList->Empty());
2340    event.Check(m_Gfx && m_Gfx->GetPresentationMode() &&
2341                m_Gfx->GetPresentationSpeed() == 1);
2342}
2343
2344void MainFrm::OnPresFFUpdate(wxUpdateUIEvent& event)
2345{
2346    event.Enable(m_Gfx && m_Gfx->GetPresentationMode());
2347    event.Check(m_Gfx && m_Gfx->GetPresentationSpeed() == 10);
2348}
2349
2350void MainFrm::OnPresFFFUpdate(wxUpdateUIEvent& event)
2351{
2352    event.Enable(m_Gfx && m_Gfx->GetPresentationMode());
2353    event.Check(m_Gfx && m_Gfx->GetPresentationSpeed() > 10);
2354}
2355
2356void MainFrm::OnPresPauseUpdate(wxUpdateUIEvent& event)
2357{
2358    event.Enable(m_Gfx && m_Gfx->GetPresentationMode());
2359    event.Check(m_Gfx && m_Gfx->GetPresentationSpeed() == 0);
2360}
2361
2362void MainFrm::OnPresStopUpdate(wxUpdateUIEvent& event)
2363{
2364    event.Enable(m_Gfx && m_Gfx->GetPresentationMode());
2365}
2366
2367void MainFrm::OnPresExportMovieUpdate(wxUpdateUIEvent& event)
2368{
2369    event.Enable(!m_PresList->Empty());
2370}
2371
2372void MainFrm::OnFind(wxCommandEvent&)
2373{
2374    pending_find = true;
2375}
2376
2377void MainFrm::OnIdle(wxIdleEvent&)
2378{
2379    if (pending_find) {
2380        DoFind();
2381    }
2382}
2383
2384void MainFrm::DoFind()
2385{
2386    pending_find = false;
2387    wxBusyCursor hourglass;
2388    // Find stations specified by a string or regular expression pattern.
2389
2390    wxString pattern = m_FindBox->GetValue();
2391    if (pattern.empty()) {
2392        // Hide any search result highlights.
2393        list<LabelInfo*>::iterator pos = m_Labels.begin();
2394        while (pos != m_Labels.end()) {
2395            LabelInfo* label = *pos++;
2396            label->clear_flags(LFLAG_HIGHLIGHTED);
2397        }
2398        m_NumHighlighted = 0;
2399    } else {
2400        int re_flags = wxRE_NOSUB;
2401
2402        if (true /* case insensitive */) {
2403            re_flags |= wxRE_ICASE;
2404        }
2405
2406        bool substring = true;
2407        if (false /*m_RegexpCheckBox->GetValue()*/) {
2408            re_flags |= wxRE_EXTENDED;
2409        } else if (true /* simple glob-style */) {
2410            wxString pat;
2411            for (size_t i = 0; i < pattern.size(); i++) {
2412               wxChar ch = pattern[i];
2413               // ^ only special at start; $ at end.  But this is simpler...
2414               switch (ch) {
2415                case '^': case '$': case '.': case '[': case '\\':
2416                  pat += wxT('\\');
2417                  pat += ch;
2418                  break;
2419                case '*':
2420                  pat += wxT(".*");
2421                  substring = false;
2422                  break;
2423                case '?':
2424                  pat += wxT('.');
2425                  substring = false;
2426                  break;
2427                default:
2428                  pat += ch;
2429               }
2430            }
2431            pattern = pat;
2432            re_flags |= wxRE_BASIC;
2433        } else {
2434            wxString pat;
2435            for (size_t i = 0; i < pattern.size(); i++) {
2436               wxChar ch = pattern[i];
2437               // ^ only special at start; $ at end.  But this is simpler...
2438               switch (ch) {
2439                case '^': case '$': case '*': case '.': case '[': case '\\':
2440                  pat += wxT('\\');
2441               }
2442               pat += ch;
2443            }
2444            pattern = pat;
2445            re_flags |= wxRE_BASIC;
2446        }
2447
2448        if (!substring) {
2449            // FIXME "0u" required to avoid compilation error with g++-3.0
2450            if (pattern.empty() || pattern[0u] != '^') pattern = wxT('^') + pattern;
2451            // FIXME: this fails to cope with "\$" at the end of pattern...
2452            if (pattern[pattern.size() - 1] != '$') pattern += wxT('$');
2453        }
2454
2455        wxRegEx regex;
2456        if (!regex.Compile(pattern, re_flags)) {
2457            wxBell();
2458            return;
2459        }
2460
2461        int found = 0;
2462
2463        list<LabelInfo*>::iterator pos = m_Labels.begin();
2464        while (pos != m_Labels.end()) {
2465            LabelInfo* label = *pos++;
2466
2467            if (regex.Matches(label->GetText())) {
2468                label->set_flags(LFLAG_HIGHLIGHTED);
2469                ++found;
2470            } else {
2471                label->clear_flags(LFLAG_HIGHLIGHTED);
2472            }
2473        }
2474
2475        m_NumHighlighted = found;
2476
2477        // Re-sort so highlighted points get names in preference
2478        if (found) m_Labels.sort(LabelPlotCmp(separator));
2479    }
2480
2481    m_Gfx->UpdateBlobs();
2482    m_Gfx->ForceRefresh();
2483
2484    if (!m_NumHighlighted) {
2485        GetToolBar()->SetToolShortHelp(button_HIDE, wmsg(/*No matches were found.*/328));
2486    } else {
2487        GetToolBar()->SetToolShortHelp(button_HIDE, wxString::Format(wmsg(/*Hide %d found stations*/334).c_str(), m_NumHighlighted));
2488    }
2489}
2490
2491void MainFrm::OnGotoFound(wxCommandEvent&)
2492{
2493    if (!m_NumHighlighted) {
2494        wxGetApp().ReportError(wmsg(/*No matches were found.*/328));
2495        return;
2496    }
2497
2498    Double xmin = DBL_MAX;
2499    Double xmax = -DBL_MAX;
2500    Double ymin = DBL_MAX;
2501    Double ymax = -DBL_MAX;
2502    Double zmin = DBL_MAX;
2503    Double zmax = -DBL_MAX;
2504
2505    list<LabelInfo*>::iterator pos = m_Labels.begin();
2506    while (pos != m_Labels.end()) {
2507        LabelInfo* label = *pos++;
2508
2509        if (label->get_flags() & LFLAG_HIGHLIGHTED) {
2510            if (label->GetX() < xmin) xmin = label->GetX();
2511            if (label->GetX() > xmax) xmax = label->GetX();
2512            if (label->GetY() < ymin) ymin = label->GetY();
2513            if (label->GetY() > ymax) ymax = label->GetY();
2514            if (label->GetZ() < zmin) zmin = label->GetZ();
2515            if (label->GetZ() > zmax) zmax = label->GetZ();
2516        }
2517    }
2518
2519    m_Gfx->SetViewTo(xmin, xmax, ymin, ymax, zmin, zmax);
2520    m_Gfx->SetFocus();
2521}
2522
2523void MainFrm::OnHide(wxCommandEvent&)
2524{
2525    m_FindBox->SetValue(wxString());
2526    GetToolBar()->SetToolShortHelp(button_HIDE, wmsg(/*Hide*/333));
2527}
2528
2529void MainFrm::OnHideUpdate(wxUpdateUIEvent& ui)
2530{
2531    ui.Enable(m_NumHighlighted != 0);
2532}
2533
2534void MainFrm::OnViewSidePanel(wxCommandEvent&)
2535{
2536    ToggleSidePanel();
2537}
2538
2539void MainFrm::ToggleSidePanel()
2540{
2541    // Toggle display of the side panel.
2542
2543    assert(m_Gfx);
2544
2545    if (m_Splitter->IsSplit()) {
2546        m_SashPosition = m_Splitter->GetSashPosition(); // save width of panel
2547        m_Splitter->Unsplit(m_Notebook);
2548    } else {
2549        m_Notebook->Show(true);
2550        m_Gfx->Show(true);
2551        m_Splitter->SplitVertically(m_Notebook, m_Gfx, m_SashPosition);
2552    }
2553}
2554
2555void MainFrm::OnViewSidePanelUpdate(wxUpdateUIEvent& ui)
2556{
2557    ui.Enable(!m_File.empty());
2558    ui.Check(ShowingSidePanel());
2559}
2560
2561bool MainFrm::ShowingSidePanel()
2562{
2563    return m_Splitter->IsSplit();
2564}
2565
2566void MainFrm::ViewFullScreen() {
2567    ShowFullScreen(!IsFullScreen());
2568    static bool sidepanel;
2569    if (IsFullScreen()) sidepanel = ShowingSidePanel();
2570    if (sidepanel) ToggleSidePanel();
2571}
Note: See TracBrowser for help on using the repository browser.