source: git/src/cavernlog.cc @ 4d75d66

stereo-2025
Last change on this file since 4d75d66 was 4d75d66, checked in by Olly Betts <olly@…>, 3 months ago

Remove unused code

This is left over from when CavernLogWindow? was HTML-based.
  • Property mode set to 100644
File size: 18.7 KB
Line 
1/* cavernlog.cc
2 * Run cavern inside an Aven window
3 *
4 * Copyright (C) 2005-2024 Olly Betts
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
19 */
20
21#include <config.h>
22
23#include "aven.h"
24#include "cavernlog.h"
25#include "filename.h"
26#include "mainfrm.h"
27#include "message.h"
28#include "osalloc.h"
29
30#include <algorithm>
31
32#include <errno.h>
33#include <stdio.h>
34#include <stdlib.h>
35
36#include <sys/time.h>
37#include <sys/types.h>
38#include <unistd.h>
39
40#include <wx/process.h>
41
42#define GVIM_COMMAND "gvim +'call cursor($l,$c)' $f"
43#define VIM_COMMAND "x-terminal-emulator -e vim +'call cursor($l,$c)' $f"
44#define NVIM_COMMAND "x-terminal-emulator -e nvim +'call cursor($l,$c)' $f"
45#define GEDIT_COMMAND "gedit $f +$l:$c"
46// Pluma currently ignores the column, but include it assuming some future
47// version will add support.
48#define PLUMA_COMMAND "pluma +$l:$c $f"
49#define EMACS_COMMAND "x-terminal-emulator -e emacs +$l:$c $f"
50#define NANO_COMMAND "x-terminal-emulator -e nano +$l,$c $f"
51#define JED_COMMAND "x-terminal-emulator -e jed $f -g $l"
52#define KATE_COMMAND "kate -l $l -c $c $f"
53
54#ifdef __WXMSW__
55# define DEFAULT_EDITOR_COMMAND "notepad $f"
56#elif defined __WXMAC__
57# define DEFAULT_EDITOR_COMMAND "open -t $f"
58#else
59# define DEFAULT_EDITOR_COMMAND VIM_COMMAND
60#endif
61
62enum { LOG_REPROCESS = 1234, LOG_SAVE = 1235 };
63
64// New event type for signalling cavern output to process.
65wxDEFINE_EVENT(EVT_CAVERN_OUTPUT, wxCommandEvent);
66
67void
68CavernLogWindow::CheckForOutput(bool immediate)
69{
70    timer.Stop();
71    if (cavern_out == NULL) return;
72
73    wxInputStream * in = cavern_out->GetInputStream();
74
75    if (!in->CanRead()) {
76        timer.StartOnce();
77        return;
78    }
79
80    size_t real_size = log_txt.size();
81    size_t allow = 1024;
82    log_txt.resize(real_size + allow);
83    in->Read(&log_txt[real_size], allow);
84    size_t n = in->LastRead();
85    log_txt.resize(real_size + n);
86    if (n) {
87        if (immediate) {
88            ProcessCavernOutput();
89        } else {
90            QueueEvent(new wxCommandEvent(EVT_CAVERN_OUTPUT));
91        }
92    }
93}
94
95int
96CavernLogWindow::OnPaintButton(wxButton* b, int x)
97{
98    if (b) {
99        x -= 4;
100        const wxSize& bsize = b->GetSize();
101        x -= bsize.x;
102        b->SetSize(x, 4, bsize.x, bsize.y);
103        x -= 4;
104    }
105    return x;
106}
107
108void
109CavernLogWindow::OnPaint(wxPaintEvent&)
110{
111    wxPaintDC dc(this);
112    wxFont font = dc.GetFont();
113    wxFont bold_font = font.Bold();
114    wxFont underlined_font = font.Underlined();
115    const wxRegion& region = GetUpdateRegion();
116    const wxRect& rect = region.GetBox();
117    int scroll_x = 0, scroll_y = 0;
118    GetViewStart(&scroll_x, &scroll_y);
119    int fsize = dc.GetFont().GetPixelSize().GetHeight();
120    int limit = min((rect.y + rect.height + fsize - 1) / fsize + scroll_y, int(line_info.size()) - 1);
121    for (int i = max(rect.y / fsize, scroll_y); i <= limit ; ++i) {
122        LineInfo& info = line_info[i];
123        // Leave a small margin to the left.
124        int x = fsize / 2 - scroll_x * fsize;
125        int y = (i - scroll_y) * fsize;
126        unsigned offset = info.start_offset;
127        unsigned len = info.len;
128        if (info.link_len) {
129            dc.SetFont(underlined_font);
130            dc.SetTextForeground(wxColour(192, 0, 192));
131            wxString link = wxString::FromUTF8(&log_txt[offset], info.link_len);
132            offset += info.link_len;
133            len -= info.link_len;
134            dc.DrawText(link, x, y);
135            x += info.link_pixel_width;
136            dc.SetFont(font);
137        }
138        if (info.colour_len) {
139            dc.SetTextForeground(*wxBLACK);
140            {
141                size_t s_len = info.start_offset + info.colour_start - offset;
142                wxString s = wxString::FromUTF8(&log_txt[offset], s_len);
143                offset += s_len;
144                len -= s_len;
145                dc.DrawText(s, x, y);
146                x += dc.GetTextExtent(s).GetWidth();
147            }
148            switch (info.colour) {
149                case LOG_ERROR:
150                    dc.SetTextForeground(*wxRED);
151                    break;
152                case LOG_WARNING:
153                    dc.SetTextForeground(wxColour(0xf2, 0x8C, 0x28));
154                    break;
155                case LOG_INFO:
156                    dc.SetTextForeground(*wxBLUE);
157                    break;
158            }
159            dc.SetFont(bold_font);
160            wxString d = wxString::FromUTF8(&log_txt[offset], info.colour_len);
161            offset += info.colour_len;
162            len -= info.colour_len;
163            dc.DrawText(d, x, y);
164            x += dc.GetTextExtent(d).GetWidth();
165            dc.SetFont(font);
166        }
167        dc.SetTextForeground(*wxBLACK);
168        dc.DrawText(wxString::FromUTF8(&log_txt[offset], len), x, y);
169    }
170    int x = GetClientSize().x;
171    x = OnPaintButton(ok_button, x);
172    x = OnPaintButton(reprocess_button, x);
173    OnPaintButton(save_button, x);
174}
175
176BEGIN_EVENT_TABLE(CavernLogWindow, wxScrolledWindow)
177    EVT_BUTTON(LOG_REPROCESS, CavernLogWindow::OnReprocess)
178    EVT_BUTTON(LOG_SAVE, CavernLogWindow::OnSave)
179    EVT_BUTTON(wxID_OK, CavernLogWindow::OnOK)
180    EVT_COMMAND(wxID_ANY, EVT_CAVERN_OUTPUT, CavernLogWindow::OnCavernOutput)
181    EVT_IDLE(CavernLogWindow::OnIdle)
182    EVT_TIMER(wxID_ANY, CavernLogWindow::OnTimer)
183    EVT_PAINT(CavernLogWindow::OnPaint)
184    EVT_MOTION(CavernLogWindow::OnMouseMove)
185    EVT_LEFT_UP(CavernLogWindow::OnLinkClicked)
186    EVT_END_PROCESS(wxID_ANY, CavernLogWindow::OnEndProcess)
187END_EVENT_TABLE()
188
189wxString escape_for_shell(wxString s, bool protect_dash)
190{
191#ifdef __WXMSW__
192    // Correct quoting rules are insane:
193    //
194    // http://blogs.msdn.com/b/twistylittlepassagesallalike/archive/2011/04/23/everyone-quotes-arguments-the-wrong-way.aspx
195    //
196    // Thankfully wxExecute passes the command string to CreateProcess(), so
197    // at least we don't need to quote for cmd.exe too.
198    if (protect_dash && !s.empty() && s[0u] == '-') {
199        // If the filename starts with a '-', protect it from being
200        // treated as an option by prepending ".\".
201        s.insert(0, wxT(".\\"));
202    }
203    if (s.empty() || s.find_first_of(wxT(" \"\t\n\v")) != s.npos) {
204        // Need to quote.
205        s.insert(0, wxT('"'));
206        for (size_t p = 1; p < s.size(); ++p) {
207            size_t backslashes = 0;
208            while (s[p] == wxT('\\')) {
209                ++backslashes;
210                if (++p == s.size()) {
211                    // Escape all the backslashes, since they're before
212                    // the closing quote we add below.
213                    s.append(backslashes, wxT('\\'));
214                    goto done;
215                }
216            }
217
218            if (s[p] == wxT('"')) {
219                // Escape any preceding backslashes and this quote.
220                s.insert(p, backslashes + 1, wxT('\\'));
221                p += backslashes + 1;
222            }
223        }
224done:
225        s.append(wxT('"'));
226    }
227#else
228    size_t p = 0;
229    if (protect_dash && !s.empty() && s[0u] == '-') {
230        // If the filename starts with a '-', protect it from being
231        // treated as an option by prepending "./".
232        s.insert(0, wxT("./"));
233        p = 2;
234    }
235    while (p < s.size()) {
236        // Exclude a few safe characters which are common in filenames
237        if (!isalnum((unsigned char)s[p]) && strchr("/._-", s[p]) == NULL) {
238            s.insert(p, 1, wxT('\\'));
239            ++p;
240        }
241        ++p;
242    }
243#endif
244    return s;
245}
246
247wxString get_command_path(const wxChar * command_name)
248{
249#ifdef __WXMSW__
250    wxString cmd;
251    {
252        DWORD len = 256;
253        wchar_t *buf = NULL;
254        while (1) {
255            DWORD got;
256            buf = (wchar_t*)osrealloc(buf, len * 2);
257            got = GetModuleFileNameW(NULL, buf, len);
258            if (got < len) break;
259            len += len;
260        }
261        /* Strange Win32 nastiness - strip prefix "\\?\" if present */
262        wchar_t *start = buf;
263        if (wcsncmp(start, L"\\\\?\\", 4) == 0) start += 4;
264        wchar_t * slash = wcsrchr(start, L'\\');
265        if (slash) {
266            cmd.assign(start, slash - start + 1);
267        }
268        free(buf);
269    }
270#else
271    wxString cmd = wxString::FromUTF8(msg_exepth());
272#endif
273    cmd += command_name;
274    return cmd;
275}
276
277CavernLogWindow::CavernLogWindow(MainFrm * mainfrm_, const wxString & survey_, wxWindow * parent)
278    : wxScrolledWindow(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize,
279                       wxFULL_REPAINT_ON_RESIZE),
280      mainfrm(mainfrm_),
281      survey(survey_),
282      timer(this)
283{
284}
285
286CavernLogWindow::~CavernLogWindow()
287{
288    timer.Stop();
289    if (cavern_out) {
290        wxEndBusyCursor();
291        cavern_out->Detach();
292    }
293}
294
295void
296CavernLogWindow::OnMouseMove(wxMouseEvent& e)
297{
298    const auto& pos = e.GetPosition();
299    int fsize = GetFont().GetPixelSize().GetHeight();
300    int scroll_x = 0, scroll_y = 0;
301    GetViewStart(&scroll_x, &scroll_y);
302    unsigned line = pos.y / fsize + scroll_y;
303    unsigned x = pos.x + scroll_x * fsize - fsize / 2;
304    if (line < line_info.size() && x <= line_info[line].link_pixel_width) {
305        SetCursor(wxCursor(wxCURSOR_HAND));
306    } else {
307        SetCursor(wxNullCursor);
308    }
309}
310
311void
312CavernLogWindow::OnLinkClicked(wxMouseEvent& e)
313{
314    const auto& pos = e.GetPosition();
315    int fsize = GetFont().GetPixelSize().GetHeight();
316    int scroll_x = 0, scroll_y = 0;
317    GetViewStart(&scroll_x, &scroll_y);
318    unsigned line = pos.y / fsize + scroll_y;
319    unsigned x = pos.x + scroll_x * fsize - fsize / 2;
320    if (!(line < line_info.size() && x <= line_info[line].link_pixel_width))
321        return;
322
323    const char* cur = &log_txt[line_info[line].start_offset];
324    size_t link_len = line_info[line].link_len;
325    size_t colon = link_len;
326    while (colon > 1 && (unsigned)(cur[--colon] - '0') <= 9) { }
327    size_t colon2 = colon;
328    while (colon > 1 && (unsigned)(cur[--colon] - '0') <= 9) { }
329    if (cur[colon] != ':') {
330        colon = colon2;
331        colon2 = link_len;
332    }
333
334    wxString cmd;
335    wxChar * p = wxGetenv(wxT("SURVEXEDITOR"));
336    if (p) {
337        cmd = p;
338        if (!cmd.find(wxT("$f"))) {
339            cmd += wxT(" $f");
340        }
341    } else {
342        p = wxGetenv(wxT("VISUAL"));
343        if (!p) p = wxGetenv(wxT("EDITOR"));
344        if (!p) {
345            cmd = wxT(DEFAULT_EDITOR_COMMAND);
346        } else {
347            cmd = p;
348            if (cmd == "gvim") {
349                cmd = wxT(GVIM_COMMAND);
350            } else if (cmd == "vim") {
351                cmd = wxT(VIM_COMMAND);
352            } else if (cmd == "nvim") {
353                cmd = wxT(NVIM_COMMAND);
354            } else if (cmd == "gedit") {
355                cmd = wxT(GEDIT_COMMAND);
356            } else if (cmd == "pluma") {
357                cmd = wxT(PLUMA_COMMAND);
358            } else if (cmd == "emacs") {
359                cmd = wxT(EMACS_COMMAND);
360            } else if (cmd == "nano") {
361                cmd = wxT(NANO_COMMAND);
362            } else if (cmd == "jed") {
363                cmd = wxT(JED_COMMAND);
364            } else if (cmd == "kate") {
365                cmd = wxT(KATE_COMMAND);
366            } else {
367                // Escape any $.
368                cmd.Replace(wxT("$"), wxT("$$"));
369                cmd += wxT(" $f");
370            }
371        }
372    }
373    size_t i = 0;
374    while ((i = cmd.find(wxT('$'), i)) != wxString::npos) {
375        if (++i >= cmd.size()) break;
376        switch ((int)cmd[i]) {
377            case wxT('$'):
378                cmd.erase(i, 1);
379                break;
380            case wxT('f'): {
381                wxString f = escape_for_shell(wxString(cur, colon), true);
382                cmd.replace(i - 1, 2, f);
383                i += f.size() - 1;
384                break;
385            }
386            case wxT('l'): {
387                wxString l = escape_for_shell(wxString(cur + colon + 1, colon2 - colon - 1));
388                cmd.replace(i - 1, 2, l);
389                i += l.size() - 1;
390                break;
391            }
392            case wxT('c'): {
393                wxString l;
394                if (colon2 == link_len)
395                    l = wxT("0");
396                else
397                    l = escape_for_shell(wxString(cur + colon2 + 1, link_len - colon2 - 1));
398                cmd.replace(i - 1, 2, l);
399                i += l.size() - 1;
400                break;
401            }
402            default:
403                ++i;
404        }
405    }
406
407    if (wxExecute(cmd, wxEXEC_ASYNC|wxEXEC_MAKE_GROUP_LEADER) >= 0)
408        return;
409
410    wxString m;
411    // TRANSLATORS: %s is replaced by the command we attempted to run.
412    m.Printf(wmsg(/*Couldn’t run external command: “%s”*/17), cmd.c_str());
413    m += wxT(" (");
414    m += wxString::FromUTF8(strerror(errno));
415    m += wxT(')');
416    wxGetApp().ReportError(m);
417}
418
419void
420CavernLogWindow::process(const wxString &file)
421{
422    timer.Stop();
423    if (cavern_out) {
424        cavern_out->Detach();
425        cavern_out = NULL;
426    } else {
427        wxBeginBusyCursor();
428    }
429
430    SetFocus();
431    filename = file;
432
433    info_count = 0;
434    link_count = 0;
435    log_txt.resize(0);
436    line_info.resize(0);
437    // Reserve enough that we won't need to grow the allocations in normal cases.
438    log_txt.reserve(16384);
439    line_info.reserve(256);
440    ptr = 0;
441    save_button = nullptr;
442    reprocess_button = nullptr;
443    ok_button = nullptr;
444    DestroyChildren();
445    SetVirtualSize(0, 0);
446
447#ifdef __WXMSW__
448    SetEnvironmentVariable(wxT("SURVEX_UTF8"), wxT("1"));
449#else
450    setenv("SURVEX_UTF8", "1", 1);
451#endif
452
453    wxString escaped_file = escape_for_shell(file, true);
454    wxString cmd = get_command_path(L"cavern");
455    cmd = escape_for_shell(cmd, false);
456    cmd += wxT(" -o ");
457    cmd += escaped_file;
458    cmd += wxT(' ');
459    cmd += escaped_file;
460
461    cavern_out = wxProcess::Open(cmd);
462    if (!cavern_out) {
463        wxString m;
464        m.Printf(wmsg(/*Couldn’t run external command: “%s”*/17), cmd.c_str());
465        m += wxT(" (");
466        m += wxString::FromUTF8(strerror(errno));
467        m += wxT(')');
468        wxGetApp().ReportError(m);
469        return;
470    }
471
472    // We want to receive the wxProcessEvent when cavern exits.
473    cavern_out->SetNextHandler(this);
474
475    // Check for output after 500ms if we don't get an idle event sooner.
476    timer.StartOnce(500);
477}
478
479void
480CavernLogWindow::ProcessCavernOutput()
481{
482    // ptr gives the start of the first line we've not yet processed.
483
484    size_t nl;
485    while ((nl = log_txt.find('\n', ptr)) != std::string::npos) {
486        if (nl == ptr || (nl - ptr == 1 && log_txt[ptr] == '\r')) {
487            // Don't show empty lines in the window.
488            ptr = nl + 1;
489            continue;
490        }
491        size_t line_len = nl - ptr - (log_txt[nl - 1] == '\r');
492        // FIXME: Avoid copy, use string_view?
493        string cur(log_txt, ptr, line_len);
494        if (log_txt[ptr] == ' ') {
495            if (expecting_caret_line) {
496                // FIXME: Check the line is only space, `^` and `~`?
497                // Otherwise an error without caret info followed
498                // by an error which contains a '^' gets
499                // mishandled...
500                size_t caret = cur.rfind('^');
501                if (caret != wxString::npos) {
502                    size_t tilde = cur.rfind('~');
503                    if (tilde == wxString::npos || tilde < caret) {
504                        tilde = caret;
505                    }
506                    line_info.back().colour = line_info[line_info.size() - 2].colour;
507                    line_info.back().colour_start = caret;
508                    line_info.back().colour_len = tilde - caret + 1;
509                    expecting_caret_line = false;
510                    ptr = nl + 1;
511                    continue;
512                }
513            }
514            expecting_caret_line = true;
515        }
516        line_info.emplace_back(ptr);
517        line_info.back().len = line_len;
518        size_t colon = cur.find(": ");
519        if (colon != wxString::npos) {
520            size_t link_len = colon;
521            while (colon > 1 && (unsigned)(cur[--colon] - '0') <= 9) { }
522            if (cur[colon] == ':') {
523                line_info.back().link_len = link_len;
524
525                static string info_marker = string(msg(/*info*/485)) + ':';
526                static string warning_marker = string(msg(/*warning*/106)) + ':';
527                static string error_marker = string(msg(/*error*/93)) + ':';
528
529                size_t offset = link_len + 2;
530                if (cur.compare(offset, info_marker.size(), info_marker) == 0) {
531                    // Show "info" marker in blue.
532                    ++info_count;
533                    line_info.back().colour = LOG_INFO;
534                    line_info.back().colour_start = offset;
535                    line_info.back().colour_len = info_marker.size() - 1;
536                } else if (cur.compare(offset, warning_marker.size(), warning_marker) == 0) {
537                    // Show "warning" marker in orange.
538                    line_info.back().colour = LOG_WARNING;
539                    line_info.back().colour_start = offset;
540                    line_info.back().colour_len = warning_marker.size() - 1;
541                } else if (cur.compare(offset, error_marker.size(), error_marker) == 0) {
542                    // Show "error" marker in red.
543                    line_info.back().colour = LOG_ERROR;
544                    line_info.back().colour_start = offset;
545                    line_info.back().colour_len = error_marker.size() - 1;
546                }
547                ++link_count;
548            }
549        }
550
551        int fsize = GetFont().GetPixelSize().GetHeight();
552        SetScrollRate(fsize, fsize);
553
554        auto& info = line_info.back();
555        info.link_pixel_width = GetTextExtent(wxString(&log_txt[ptr], info.link_len)).GetWidth();
556        auto rest_pixel_width = GetTextExtent(wxString(&log_txt[ptr + info.link_len], info.len - info.link_len)).GetWidth();
557        int width = max(GetVirtualSize().GetWidth(),
558                        int(fsize + info.link_pixel_width + rest_pixel_width));
559        int height = line_info.size();
560        SetVirtualSize(width, height * fsize);
561        if (!link_count) {
562            // Auto-scroll until the first diagnostic.
563            int scroll_x = 0, scroll_y = 0;
564            GetViewStart(&scroll_x, &scroll_y);
565            int xs, ys;
566            GetClientSize(&xs, &ys);
567            Scroll(scroll_x, line_info.size() * fsize - ys);
568        }
569        ptr = nl + 1;
570    }
571}
572
573void
574CavernLogWindow::OnEndProcess(wxProcessEvent & evt)
575{
576    bool cavern_success = evt.GetExitCode() == 0;
577
578    // Read and process any remaining buffered output.
579    wxInputStream* in = cavern_out->GetInputStream();
580    while (!in->Eof()) {
581        CheckForOutput(true);
582    }
583
584    wxEndBusyCursor();
585
586    delete cavern_out;
587    cavern_out = NULL;
588
589    // Initially place buttons off the right of the window - they get moved to
590    // the desired position by OnPaintButton().
591    wxPoint off_right(GetSize().x, 0);
592    /* TRANSLATORS: Label for button in aven’s cavern log window which
593     * allows the user to save the log to a file. */
594    save_button = new wxButton(this, LOG_SAVE, wmsg(/*&Save Log*/446), off_right);
595
596    /* TRANSLATORS: Label for button in aven’s cavern log window which
597     * causes the survey data to be reprocessed. */
598    reprocess_button = new wxButton(this, LOG_REPROCESS, wmsg(/*&Reprocess*/184), off_right);
599
600    if (cavern_success) {
601        ok_button = new wxButton(this, wxID_OK, wxString(), off_right);
602        ok_button->SetDefault();
603    }
604
605    Refresh();
606    if (!cavern_success) {
607        return;
608    }
609
610    init_done = false;
611
612    {
613        wxString file3d(filename, 0, filename.length() - 3);
614        file3d.append(wxT("3d"));
615        if (!mainfrm->LoadData(file3d, survey)) {
616            return;
617        }
618    }
619
620    // Don't stay on log if there there are only "info" diagnostics.
621    if (link_count == info_count) {
622        wxCommandEvent dummy;
623        OnOK(dummy);
624    }
625}
626
627void
628CavernLogWindow::OnReprocess(wxCommandEvent &)
629{
630    process(filename);
631}
632
633void
634CavernLogWindow::OnSave(wxCommandEvent &)
635{
636    wxString filelog(filename, 0, filename.length() - 3);
637#ifdef __WXMSW__
638    // We need to consistently use `\` here.
639    filelog.Replace("/", "\\");
640#endif
641    filelog += wxT("log");
642#ifdef __WXMOTIF__
643    wxString ext(wxT("*.log"));
644#else
645    /* TRANSLATORS: Log files from running cavern (extension .log) */
646    wxString ext = wmsg(/*Log files*/447);
647    ext += wxT("|*.log");
648#endif
649    wxFileDialog dlg(this, wmsg(/*Select an output filename*/319),
650                     wxString(), filelog, ext,
651                     wxFD_SAVE|wxFD_OVERWRITE_PROMPT);
652    if (dlg.ShowModal() != wxID_OK) return;
653    filelog = dlg.GetPath();
654    FILE * fh_log = wxFopen(filelog, wxT("w"));
655    if (!fh_log) {
656        wxGetApp().ReportError(wxString::Format(wmsg(/*Error writing to file “%s”*/7), filelog.c_str()));
657        return;
658    }
659    FWRITE_(log_txt.data(), log_txt.size(), 1, fh_log);
660    fclose(fh_log);
661}
662
663void
664CavernLogWindow::OnOK(wxCommandEvent &)
665{
666    if (init_done) {
667        mainfrm->HideLog(this);
668    } else {
669        mainfrm->InitialiseAfterLoad(filename, survey);
670        init_done = true;
671    }
672}
Note: See TracBrowser for help on using the repository browser.