OpenCPN Partial API docs
Loading...
Searching...
No Matches
ocpn_frame.cpp
1/***************************************************************************
2 *
3 * Project: OpenCPN
4 * Purpose: OpenCPN Main wxWidgets Program
5 * Author: David Register
6 *
7 ***************************************************************************
8 * Copyright (C) 2010 by David S. Register *
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 *
22 * Free Software Foundation, Inc., *
23 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
24 **************************************************************************/
25#include "config.h"
26
27#ifdef __MINGW32__
28#undef IPV6STRICT // mingw FTBS fix: missing struct ip_mreq
29#include <windows.h>
30#endif
31
32#include <wx/wxprec.h>
33
34#ifndef WX_PRECOMP
35#include <wx/wx.h>
36#endif // precompiled headers
37
38#ifdef __WXMSW__
39// #include "c:\\Program Files\\visual leak detector\\include\\vld.h"
40#endif
41
42#ifdef __WXMSW__
43#include <math.h>
44#include <psapi.h>
45#include <stdlib.h>
46#include <time.h>
47#endif
48
49#ifdef OCPN_HAVE_X11
50#include <X11/Xatom.h>
51#include <X11/Xlib.h>
52#endif
53
54#include <wx/stdpaths.h>
55#include <wx/tokenzr.h>
56#include <wx/display.h>
57#include <wx/jsonreader.h>
58
59#include "model/ais_decoder.h"
60#include "model/ais_state_vars.h"
61#include "model/ais_target_data.h"
62#include "model/cmdline.h"
63#include "model/comm_drv_factory.h" //FIXME(dave) this one goes away
64#include "model/comm_drv_registry.h"
65#include "model/comm_n0183_output.h"
66#include "model/comm_navmsg_bus.h"
67#include "model/comm_vars.h"
68#include "model/config_vars.h"
69#include "model/cutil.h"
70#include "model/georef.h"
71#include "model/gui.h"
72#include "model/idents.h"
73#include "model/local_api.h"
74#include "model/logger.h"
75#include "model/multiplexer.h"
76#include "model/nav_object_database.h"
77#include "model/navutil_base.h"
78#include "model/own_ship.h"
79#include "model/plugin_comm.h"
80#include "model/plugin_loader.h"
81#include "model/routeman.h"
82#include "model/select.h"
83#include "model/sys_events.h"
84#include "model/track.h"
85
86#include "dialog_alert.h"
87#include "AboutFrameImpl.h"
88#include "about.h"
89#include "ais.h"
90#include "ais_info_gui.h"
91#include "AISTargetAlertDialog.h"
92#include "AISTargetListDialog.h"
93#include "AISTargetQueryDialog.h"
94#include "CanvasConfig.h"
95#include "chartbase.h"
96#include "chart_ctx_factory.h"
97#include "chartdb.h"
98#include "chcanv.h"
99#include "cm93.h"
100#include "color_handler.h"
101#include "compass.h"
102#include "concanv.h"
103#include "connections_dlg.h"
104#include "ConfigMgr.h"
105#include "displays.h"
106#include "dychart.h"
107#include "FontMgr.h"
108#include "glChartCanvas.h"
109#include "GoToPositionDialog.h"
110#include "gui_lib.h"
111#include "iENCToolbar.h"
112#include "Layer.h"
113#include "load_errors_dlg.h"
114#include "MarkInfo.h"
115#include "MUIBar.h"
116#include "N2KParser.h"
117#include "navutil.h"
118#include "NMEALogWindow.h"
119#include "ocpn_app.h"
120#include "ocpn_plugin.h"
121#include "OCPN_AUIManager.h"
122#include "ocpn_frame.h"
123#include "OCPNPlatform.h"
124#include "OCPN_Sound.h"
125#include "options.h"
126#include "pluginmanager.h"
127#include "print_dialog.h"
128#include "printout_chart.h"
129#include "routemanagerdialog.h"
130#include "routeman_gui.h"
131#include "route_point_gui.h"
132#include "RoutePropDlgImpl.h"
133#include "s52plib.h"
134#include "s57chart.h"
135#include "S57QueryDialog.h"
136#include "SystemCmdSound.h"
137#include "tcmgr.h"
138#include "timers.h"
139#include "toolbar.h"
140#include "TrackPropDlg.h"
141#include "waypointman_gui.h"
142#include "CanvasOptions.h"
143#include "udev_rule_mgr.h"
144
145#ifdef __ANDROID__
146#include "androidUTIL.h"
147#endif
148
149//------------------------------------------------------------------------------
150// Fwd Declarations
151//------------------------------------------------------------------------------
152WX_DEFINE_ARRAY_PTR(ChartCanvas *, arrayofCanvasPtr);
153
154//------------------------------------------------------------------------------
155// Static variable definition
156//------------------------------------------------------------------------------
157//
158extern OCPN_AUIManager *g_pauimgr;
159extern MyConfig *pConfig;
160extern arrayofCanvasPtr g_canvasArray;
161extern MyFrame *gFrame;
162extern AISTargetListDialog *g_pAISTargetList;
163extern AISTargetQueryDialog *g_pais_query_dialog_active;
164extern ConsoleCanvas *console;
165extern RouteManagerDialog *pRouteManagerDialog;
166extern Routeman *g_pRouteMan;
167extern MarkInfoDlg *g_pMarkInfoDialog;
168extern RoutePropDlgImpl *pRoutePropDialog;
169extern TrackPropDlg *pTrackPropDialog;
170extern GoToPositionDialog *pGoToPositionDialog;
171extern CM93OffsetDialog *g_pCM93OffsetDialog;
172extern S57QueryDialog *g_pObjectQueryDialog;
173extern about *g_pAboutDlgLegacy;
174extern AboutFrameImpl *g_pAboutDlg;
175
176extern double vLat, vLon;
177extern wxString g_locale;
178extern ColorScheme global_color_scheme;
179extern options *g_pOptions;
180extern options *g_options;
181
182#ifdef ocpnUSE_GL
183GLenum g_texture_rectangle_format;
184#endif
185
186#if wxUSE_XLOCALE || !wxCHECK_VERSION(3, 0, 0)
187extern wxLocale *plocale_def_lang;
188#endif
189
190extern OCPNPlatform *g_Platform;
191extern BasePlatform
192 *g_BasePlatform; // points to g_platform, handles brain-dead MS linker.
193
194extern s52plib *ps52plib;
195extern ocpnFloatingToolbarDialog *g_MainToolbar;
196extern PlugInManager *g_pi_manager;
197
198extern bool g_b_legacy_input_filter_behaviour;
199extern bool g_bTrackActive;
200extern ocpnStyle::StyleManager *g_StyleManager;
201extern bool g_bmasterToolbarFull;
202extern int g_nAutoHideToolbar;
203extern bool g_bAutoHideToolbar;
204extern bool g_bshowToolbar;
205extern int g_maintoolbar_x;
206extern int g_maintoolbar_y;
207extern wxString g_toolbarConfig;
208extern float g_toolbar_scalefactor;
209extern float g_compass_scalefactor;
210extern bool g_bShowMenuBar;
211extern bool g_bShowCompassWin;
212
213extern bool g_benable_rotate;
214extern int g_GUIScaleFactor;
215extern int g_ChartScaleFactor;
216extern int g_last_ChartScaleFactor;
217extern int g_ShipScaleFactor;
218extern float g_ShipScaleFactorExp;
219extern int g_ENCTextScaleFactor;
220
221extern bool g_bShowTide;
222extern bool g_bShowCurrent;
223extern bool g_bUIexpert;
224extern RouteList *pRouteList;
225extern wxString g_default_wp_icon;
226extern std::vector<std::string> TideCurrentDataSet;
227extern wxString g_TCData_Dir;
228extern TCMgr *ptcmgr;
229extern char nmea_tick_chars[];
230extern double AnchorPointMinDist;
231extern bool AnchorAlertOn1, AnchorAlertOn2;
232extern wxString g_AW1GUID;
233extern wxString g_AW2GUID;
234extern bool g_bCruising;
235extern double g_COGAvg;
236extern int g_COGAvgSec;
237extern ActiveTrack *g_pActiveTrack;
238extern std::vector<Track *> g_TrackList;
239extern double gQueryVar;
240extern int g_ChartUpdatePeriod;
241extern int g_SkewCompUpdatePeriod;
242extern bool g_bCourseUp;
243extern bool g_bLookAhead;
244extern bool g_bskew_comp;
245extern bool g_bPauseTest;
246extern bool g_bSleep;
247extern bool g_bPlayShipsBells;
248extern wxDateTime g_loglast_time;
249extern int g_nAWDefault;
250extern int g_nAWMax;
251extern bool g_bDeferredStartTrack;
252extern bool bDBUpdateInProgress;
253extern int quitflag;
254extern int g_tick;
255extern ChartDB *ChartData;
256extern bool g_bDeferredInitDone;
257extern int options_lastPage;
258extern int options_subpage;
259extern bool b_reloadForPlugins;
260extern ChartCanvas *g_focusCanvas;
261extern int g_NeedDBUpdate;
262extern bool g_bFullscreen;
263extern wxString gWorldMapLocation, gDefaultWorldMapLocation;
264extern ChartGroupArray *g_pGroupArray;
265extern bool g_bEnableZoomToCursor;
266extern double g_display_size_mm;
267extern std::vector<size_t> g_config_display_size_mm;
268extern wxString ChartListFileName;
269extern bool g_bFullscreenToolbar;
270extern arrayofCanvasPtr g_canvasArray;
271extern wxString g_lastAppliedTemplateGUID;
272extern wxPoint options_lastWindowPos;
273extern wxSize options_lastWindowSize;
274extern unsigned int g_canvasConfig;
275extern bool g_bFullScreenQuilt;
276extern bool g_bQuiltEnable;
277extern wxString *pInit_Chart_Dir;
278extern bool g_bShowOutlines;
279extern bool g_bTempShowMenuBar;
280extern bool g_bShowStatusBar;
281extern bool g_FlushNavobjChanges;
282extern int g_FlushNavobjChangesTimeout;
283extern bool g_bShowChartBar;
284extern double g_plus_minus_zoom_factor;
285extern int g_nframewin_x;
286extern int g_nframewin_y;
287extern int g_nframewin_posx;
288extern int g_nframewin_posy;
289extern bool g_bframemax;
290extern LayerList *pLayerList;
291extern bool g_bAutoAnchorMark;
292extern wxDateTime g_start_time;
293extern bool g_bcompression_wait;
294extern bool g_bquiting;
295extern bool b_inCloseWindow;
296extern bool b_inCompressAllCharts;
297extern long g_maintoolbar_orient;
298extern wxAuiDefaultDockArt *g_pauidockart;
299extern int g_click_stop;
300extern wxString g_CmdSoundString;
301extern std::vector<OcpnSound *> bells_sound;
302extern char bells_sound_file_name[2][12];
303extern int g_sticky_chart;
304extern int g_sticky_projection;
305extern wxArrayPtrVoid *UserColourHashTableArray;
306extern wxColorHashMap *pcurrent_user_color_hash;
307
308// probable move to ocpn_app
309extern bool g_own_ship_sog_cog_calc;
310extern int g_own_ship_sog_cog_calc_damp_sec;
311extern bool g_bHasHwClock;
312extern bool s_bSetSystemTime;
313extern bool bVelocityValid;
314extern int gHDx_Watchdog;
315extern AisInfoGui *g_pAISGUI;
316
317extern bool g_bUseGLL;
318extern int g_MemFootMB;
319extern Multiplexer *g_pMUX;
320extern int g_memUsed;
321extern int g_chart_zoom_modifier_vector;
322extern bool g_config_display_size_manual;
323extern bool g_PrintingInProgress;
324extern bool g_disable_main_toolbar;
325extern bool g_btenhertz;
326
327#ifdef __WXMSW__
328// System color control support
329
330typedef DWORD(WINAPI *SetSysColors_t)(DWORD, DWORD *, DWORD *);
331typedef DWORD(WINAPI *GetSysColor_t)(DWORD);
332
333SetSysColors_t pSetSysColors;
334GetSysColor_t pGetSysColor;
335
336void SaveSystemColors(void);
337void RestoreSystemColors(void);
338
339DWORD color_3dface;
340DWORD color_3dhilite;
341DWORD color_3dshadow;
342DWORD color_3ddkshadow;
343DWORD color_3dlight;
344DWORD color_activecaption;
345DWORD color_gradientactivecaption;
346DWORD color_captiontext;
347DWORD color_windowframe;
348DWORD color_inactiveborder;
349
350#endif
351
352#ifdef __VISUALC__
353#include <wx/msw/msvcrt.h>
354#endif
355
356#if !defined(NAN)
357static const long long lNaN = 0xfff8000000000000;
358#define NAN (*(double *)&lNaN)
359#endif
360
361static wxArrayPtrVoid *UserColorTableArray = 0;
362
363// Latest "ground truth" fix, and auxiliaries
364double gLat_gt, gLon_gt;
365double gLat_gt_m1, gLon_gt_m1;
366uint64_t fix_time_gt;
367uint64_t fix_time_gt_last;
368
369double gSog_gt, gCog_gt, gHdt_gt;
370double gCog_gt_m1, gHdt_gt_m1;
371uint64_t hdt_time_gt;
372double cog_rate_gt, hdt_rate_gt;
373
374// Some static helpers
375void appendOSDirSlash(wxString *pString);
376
377void InitializeUserColors(void);
378void DeInitializeUserColors(void);
379void SetSystemColors(ColorScheme cs);
380
381static bool LoadAllPlugIns(bool load_enabled) {
382 AbstractPlatform::ShowBusySpinner();
383 bool b = PluginLoader::getInstance()->LoadAllPlugIns(load_enabled);
384 AbstractPlatform::HideBusySpinner();
385 return b;
386}
387
388//------------------------------------------------------------------------------
389// PNG Icon resources
390//------------------------------------------------------------------------------
391
392#if defined(__WXGTK__) || defined(__WXQT__)
393#include "bitmaps/opencpn.xpm"
394#endif
395
396//------------------------------------------------------------------------------
397// Local constants
398//------------------------------------------------------------------------------
399// enum {
400// ID_PIANO_DISABLE_QUILT_CHART = 32000, ID_PIANO_ENABLE_QUILT_CHART
401// };
402
403//------------------------------------------------------------------------------
404// Fwd Refs
405//------------------------------------------------------------------------------
406
407iENCToolbar *g_iENCToolbar;
408int g_iENCToolbarPosX;
409int g_iENCToolbarPosY;
410
411void BuildiENCToolbar(bool bnew) {
412 if (g_bInlandEcdis) {
413 if (bnew) {
414 if (g_iENCToolbar) {
415 wxPoint locn = g_iENCToolbar->GetToolbarPosition();
416 wxPoint tbp_incanvas =
417 locn; // gFrame->GetPrimaryCanvas()->ScreenToClient(locn);
418
419 g_iENCToolbarPosY = tbp_incanvas.y;
420 g_iENCToolbarPosX = tbp_incanvas.x;
421
422 delete g_iENCToolbar;
423 g_iENCToolbar = 0;
424 }
425 }
426
427 if (!g_iENCToolbar) {
428 wxPoint posn(g_iENCToolbarPosX, g_iENCToolbarPosY);
429
430 // Overlapping main toolbar?
431 if (g_MainToolbar) {
432 if ((g_iENCToolbarPosY > g_maintoolbar_y) &&
433 (g_iENCToolbarPosY <
434 g_maintoolbar_y + g_MainToolbar->GetToolSize().y))
435 g_iENCToolbarPosY = -1; // force a reposition
436 }
437
438 if ((g_iENCToolbarPosX < 0) || (g_iENCToolbarPosY < 0)) {
439 posn.x = 0;
440 posn.y = 100;
441
442 if (g_MainToolbar)
443 posn =
444 wxPoint(g_maintoolbar_x + g_MainToolbar->GetToolbarSize().x + 4,
445 g_maintoolbar_y);
446 }
447
448 double tool_scale_factor =
449 g_Platform->GetToolbarScaleFactor(g_GUIScaleFactor);
450
451 g_iENCToolbar =
452 new iENCToolbar(gFrame, posn, wxTB_HORIZONTAL, tool_scale_factor);
453 g_iENCToolbar->SetColorScheme(global_color_scheme);
454 g_iENCToolbar->EnableSubmerge(false);
455 }
456 } else {
457 delete g_iENCToolbar;
458 g_iENCToolbar = NULL;
459 }
460}
461
462bool ShowNavWarning() {
463 wxString msg(
464 _("\n\
465OpenCPN is distributed in the hope that it will be useful, \
466but WITHOUT ANY WARRANTY; without even the implied \
467warranty of MERCHANTABILITY or FITNESS FOR A \
468PARTICULAR PURPOSE.\n\n\
469See the GNU General Public License for more details.\n\n\
470OpenCPN must only be used in conjunction with approved \
471paper charts and traditional methods of navigation.\n\n\
472DO NOT rely upon OpenCPN for safety of life or property.\n\n\
473Please click \"Agree\" and proceed, or \"Cancel\" to quit.\n"));
474
475 wxString vs = wxString::Format(wxT(" .. Version %s"), VERSION_FULL);
476
477#ifdef __ANDROID__
478 androidShowDisclaimer(_("OpenCPN for Android") + vs, msg);
479 return true;
480#else
481 msg.Replace("\n", "<br>");
482
483 std::stringstream html;
484 html << "<html><body><p>";
485 html << msg.ToStdString();
486 html << "</p></body></html>";
487
488 std::string title = _("Welcome to OpenCPN").ToStdString();
489 std::string action = _("Agree").ToStdString();
490 AlertDialog info_dlg(gFrame, title, action);
491 info_dlg.SetInitialSize();
492 info_dlg.AddHtmlContent(html);
493 int agreed = info_dlg.ShowModal();
494 return agreed == wxID_OK;
495#endif
496}
497
498bool isSingleChart(ChartBase *chart) {
499 if (chart == nullptr) return false;
500
501 // ..For each canvas...
502 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
503 ChartCanvas *cc = g_canvasArray.Item(i);
504 if (cc && cc->m_singleChart == chart) {
505 return true;
506 }
507 }
508 return false;
509}
510
511#if defined(__WXGTK__) && defined(OCPN_HAVE_X11)
512
513// Note: use XFree to free this pointer. Use unique_ptr in the future.
514static char *get_X11_property(Display *disp, Window win, Atom xa_prop_type,
515 const char *prop_name) {
516 Atom xa_prop_name;
517 Atom xa_ret_type;
518 int ret_format;
519 unsigned long ret_nitems;
520 unsigned long ret_bytes_after;
521 unsigned char *ret_prop;
522
523 xa_prop_name = XInternAtom(disp, prop_name, False);
524
525 // For XGetWindowProperty source see
526 // https://github.com/mirror/libX11/blob/master/src/GetProp.c#L107
527 // it is quite tricky. Some notes.
528 // + Results are already NULL terminated.
529 // + 32 as a ret_format means sizeof(long) in the API...
530 // + but as xlib does the null termination we can just ignore the sizes.
531 if (XGetWindowProperty(disp, win, xa_prop_name, 0, 1024, False, xa_prop_type,
532 &xa_ret_type, &ret_format, &ret_nitems,
533 &ret_bytes_after, &ret_prop) != Success)
534 return NULL;
535
536 if (xa_ret_type != xa_prop_type) {
537 XFree(ret_prop);
538 return NULL;
539 }
540 return (char *)ret_prop;
541}
542#endif
543
544// Determine if a transparent toolbar is possible under linux with opengl
545static bool isTransparentToolbarInOpenGLOK(void) {
546#ifdef __WXOSX__
547 return true;
548#else
549 bool status = false;
550#ifndef __WXQT__
551#ifdef OCPN_HAVE_X11
552 if (!g_bdisable_opengl) {
553 Display *disp = XOpenDisplay(NULL);
554 Window *sup_window;
555 if ((sup_window = (Window *)get_X11_property(disp, DefaultRootWindow(disp),
556 XA_WINDOW,
557 "_NET_SUPPORTING_WM_CHECK")) ||
558 (sup_window = (Window *)get_X11_property(disp, DefaultRootWindow(disp),
559 XA_CARDINAL,
560 "_WIN_SUPPORTING_WM_CHECK"))) {
561 /* WM_NAME */
562 char *wm_name;
563 if ((wm_name = get_X11_property(disp, *sup_window,
564 XInternAtom(disp, "UTF8_STRING", False),
565 "_NET_WM_NAME")) ||
566 (wm_name = get_X11_property(disp, *sup_window, XA_STRING,
567 "_NET_WM_NAME"))) {
568 // we know it works in xfce4, add other checks as we can validate them
569 if (strstr(wm_name, "Xfwm4") || strstr(wm_name, "Compiz"))
570 status = true;
571
572 XFree(wm_name);
573 }
574 XFree(sup_window);
575 }
576 XCloseDisplay(disp);
577 }
578#endif
579#endif
580 return status;
581#endif
582}
583
584//------------------------------------------------------------------------------
585// MyFrame
586//------------------------------------------------------------------------------
587
588// Frame implementation
589// NOLINTBEGIN
590wxDEFINE_EVENT(BELLS_PLAYED_EVTYPE, wxCommandEvent);
591
592BEGIN_EVENT_TABLE(MyFrame, wxFrame)
593EVT_CLOSE(MyFrame::OnCloseWindow)
594EVT_MENU(wxID_EXIT, MyFrame::OnExit)
595EVT_SIZE(MyFrame::OnSize)
596EVT_MOVE(MyFrame::OnMove)
597EVT_ICONIZE(MyFrame::OnIconize)
598EVT_MENU(-1, MyFrame::OnToolLeftClick)
599EVT_TIMER(INIT_TIMER, MyFrame::OnInitTimer)
600EVT_TIMER(FRAME_TIMER_1, MyFrame::OnFrameTimer1)
601EVT_TIMER(FRAME_TC_TIMER, MyFrame::OnFrameTCTimer)
602EVT_TIMER(FRAME_COG_TIMER, MyFrame::OnFrameCOGTimer)
603EVT_TIMER(MEMORY_FOOTPRINT_TIMER, MyFrame::OnMemFootTimer)
604EVT_TIMER(FRANE_TENHZ_TIMER, MyFrame::OnFrameTenHzTimer)
605EVT_MAXIMIZE(MyFrame::OnMaximize)
606EVT_COMMAND(wxID_ANY, wxEVT_COMMAND_TOOL_RCLICKED,
607 MyFrame::RequestNewToolbarArgEvent)
608EVT_ERASE_BACKGROUND(MyFrame::OnEraseBackground)
609// EVT_TIMER(RESIZE_TIMER, MyFrame::OnResizeTimer)
610EVT_TIMER(RECAPTURE_TIMER, MyFrame::OnRecaptureTimer)
611EVT_TIMER(TOOLBAR_ANIMATE_TIMER, MyFrame::OnToolbarAnimateTimer)
612EVT_COMMAND(wxID_ANY, BELLS_PLAYED_EVTYPE, MyFrame::OnBellsFinished)
613
614#ifdef wxHAS_POWER_EVENTS
615EVT_POWER_SUSPENDING(MyFrame::OnSuspending)
616EVT_POWER_SUSPENDED(MyFrame::OnSuspended)
617EVT_POWER_SUSPEND_CANCEL(MyFrame::OnSuspendCancel)
618EVT_POWER_RESUME(MyFrame::OnResume)
619#endif // wxHAS_POWER_EVENTS
620
621END_EVENT_TABLE()
622
623// NOLINTEND
624
625/*
626 * Direct callback from completed sound, possibly in an interrupt
627 * context. Just post an event to be processed in main thread.
628 */
629static void onBellsFinishedCB(void *ptr) {
630 auto framePtr = static_cast<MyFrame *>(ptr);
631 if (framePtr) {
632 wxCommandEvent ev(BELLS_PLAYED_EVTYPE);
633 wxPostEvent(framePtr, ev);
634 }
635}
636
637static void OnDriverMsg(const ObservedEvt &ev) {
638 auto msg = ev.GetString().ToStdString();
639 OCPNMessageBox(GetTopWindow(), msg, _("Communication Error"));
640}
641
642// My frame constructor
643MyFrame::MyFrame(wxFrame *frame, const wxString &title, const wxPoint &pos,
644 const wxSize &size, long style)
645 : wxFrame(frame, -1, title, pos, size, style, kTopLevelWindowName),
646 comm_overflow_dlg(this),
647 m_connections_dlg(nullptr) {
648 g_current_monitor = wxDisplay::GetFromWindow(this);
649#ifdef __WXOSX__
650 // On retina displays there is a difference between the physical size of the
651 // OpenGL canvas and the DIP This is not observed anywhere else so far, so
652 // g_current_monitor_dip_px_ratio cna be kept 1.0 everywhere else
653 if (g_bopengl) {
654 g_current_monitor_dip_px_ratio =
655 g_monitor_info[g_current_monitor].width_px /
656 g_monitor_info[g_current_monitor].width;
657 }
658#endif
659 m_last_track_rotation_ts = 0;
660 m_ulLastNMEATicktime = 0;
661
662 m_pStatusBar = NULL;
663 m_StatusBarFieldCount = g_Platform->GetStatusBarFieldCount();
664
665 m_pMenuBar = NULL;
666 g_options = NULL;
667 m_load_errors_dlg_ctrl = std::make_unique<LoadErrorsDlgCtrl>(this);
668
669 // Redirect the initialization timer to this frame
670 InitTimer.SetOwner(this, INIT_TIMER);
671 m_iInitCount = 0;
672 m_initializing = false;
673
674 // Redirect the global heartbeat timer to this frame
675 FrameTimer1.SetOwner(this, FRAME_TIMER_1);
676
677 // Redirect the Tide/Current update timer to this frame
678 FrameTCTimer.SetOwner(this, FRAME_TC_TIMER);
679
680 // Redirect the COG Averager timer to this frame
681 FrameCOGTimer.SetOwner(this, FRAME_COG_TIMER);
682
683 // Redirect the Memory Footprint Management timer to this frame
684 MemFootTimer.SetOwner(this, MEMORY_FOOTPRINT_TIMER);
685
686 // Direct the Toolbar Animation timer to this frame
687 ToolbarAnimateTimer.SetOwner(this, TOOLBAR_ANIMATE_TIMER);
688
689 FrameTenHzTimer.SetOwner(this, FRANE_TENHZ_TIMER);
690
691#ifdef __ANDROID__
692// m_PrefTimer.SetOwner( this, ANDROID_PREF_TIMER );
693// Connect( m_PrefTimer.GetId(), wxEVT_TIMER, wxTimerEventHandler(
694// MyFrame::OnPreferencesResultTimer ), NULL, this );
695#endif
696
697 // Set up some assorted member variables
698 m_bTimeIsSet = false;
699 nBlinkerTick = 0;
700
701 m_bdefer_resize = false;
702
703 // Clear the NMEA Filter tables
704 for (int i = 0; i < MAX_COGSOG_FILTER_SECONDS; i++) {
705 COGFilterTable[i] = NAN;
706 SOGFilterTable[i] = NAN;
707 }
708 m_last_bGPSValid = false;
709 m_last_bVelocityValid = false;
710
711 gHdt = NAN;
712 gHdm = NAN;
713 gVar = NAN;
714 gSog = NAN;
715 gCog = NAN;
716 gHdt_gt = NAN;
717 gCog_gt = NAN;
718
719 for (int i = 0; i < MAX_COG_AVERAGE_SECONDS; i++) COGTable[i] = NAN;
720
721 m_fixtime = -1;
722
723 double dt = 2.0; // Time interval
724 double process_noise_std = 1.0; // Process noise standard deviation
725 double measurement_noise_std = 0.5; // Measurement noise standard deviation
726
727 m_ChartUpdatePeriod = 1; // set the default (1 sec.) period
728 initIXNetSystem();
729
730 // Establish my children
731 struct MuxLogCallbacks log_callbacks;
732 log_callbacks.log_is_active = []() {
733 return NMEALogWindow::GetInstance().Active();
734 };
735 log_callbacks.log_message = [](const wxString &s) {
736 NMEALogWindow::GetInstance().Add(s);
737 };
738 g_pMUX = new Multiplexer(log_callbacks, g_b_legacy_input_filter_behaviour);
739
740 struct AisDecoderCallbacks ais_callbacks;
741 ais_callbacks.confirm_stop_track = []() {
742 int r = OCPNMessageBox(
743 NULL,
744 _("This AIS target has Persistent tracking selected by MMSI "
745 "properties\n"
746 "A Persistent track recording will therefore be restarted for this "
747 "target.\n\n"
748 "Do you instead want to stop Persistent tracking for this target?"),
749 _("OpenCPN Info"), wxYES_NO | wxCENTER, 60);
750 return r == wxID_YES;
751 };
752 ais_callbacks.get_target_mmsi = []() {
753 auto alert_dlg_active =
754 dynamic_cast<AISTargetAlertDialog *>(g_pais_alert_dialog_active);
755 assert(alert_dlg_active);
756 return alert_dlg_active->Get_Dialog_MMSI();
757 };
758
759 g_pAIS = new AisDecoder(ais_callbacks);
760
761 g_pAISGUI = new AisInfoGui();
762
763 // Create/connect a dynamic event handler slot
764 wxLogMessage(" **** Connect stuff");
765
766 b_autofind = false;
767
768 // Create/connect a dynamic event handler slot for OCPN_MsgEvent(s) coming
769 // from PlugIn system
770 Connect(wxEVT_OCPN_MSG,
771 (wxObjectEventFunction)(wxEventFunction)&MyFrame::OnEvtPlugInMessage);
772
773 // FIXME (dave)
774 // Connect(wxEVT_OCPN_THREADMSG,
775 // (wxObjectEventFunction)(wxEventFunction)&MyFrame::OnEvtTHREADMSG);
776
777 // And from the thread SENC creator
778 Connect(wxEVT_OCPN_BUILDSENCTHREAD,
779 (wxObjectEventFunction)(wxEventFunction)&MyFrame::OnSENCEvtThread);
780 // Establish the system icons for the frame.
781
782#ifdef __WXMSW__
783 SetIcon(wxICON(
784 0)); // this grabs the first icon in the integrated MSW resource file
785#endif
786
787#if defined(__WXGTK__) || defined(__WXQT__)
788 wxIcon app_icon(opencpn); // This comes from opencpn.xpm inclusion above
789 SetIcon(app_icon);
790#endif
791
792#ifdef __WXMSW__
793
794 // Establish the entry points in USER32.DLL for system color control
795
796 wxDynamicLibrary dllUser32(_T("user32.dll"));
797
798 pSetSysColors = (SetSysColors_t)dllUser32.GetSymbol(wxT("SetSysColors"));
799 pGetSysColor = (GetSysColor_t)dllUser32.GetSymbol(wxT("GetSysColor"));
800
801 SaveSystemColors();
802#endif
803
804 m_next_available_plugin_tool_id = ID_PLUGIN_BASE;
805
806 g_sticky_chart = -1;
807 g_sticky_projection = -1;
808 m_BellsToPlay = 0;
809
810 m_resizeTimer.SetOwner(this, RESIZE_TIMER);
811 m_recaptureTimer.SetOwner(this, RECAPTURE_TIMER);
812 m_tick_idx = 0;
813 assert(g_pRouteMan != 0 && "g_pRouteMan not available");
814 m_routes_update_listener.Init(g_pRouteMan->on_routes_update,
815 [&](wxCommandEvent) { Refresh(); });
816 m_evt_drv_msg_listener.Init(CommDriverRegistry::GetInstance().evt_driver_msg,
817 [&](ObservedEvt &ev) { OnDriverMsg(ev); });
818
819#ifdef __WXOSX__
820 // Enable native fullscreen on macOS
821 EnableFullScreenView();
822#endif
823}
824
825MyFrame::~MyFrame() {
826 FrameTimer1.Stop();
827 FrameTenHzTimer.Stop();
828 DestroyDeviceNotFoundDialogs();
829
830 delete ChartData;
831 // delete pCurrentStack;
832
833 // Free the Route List
834 wxRouteListNode *node = pRouteList->GetFirst();
835
836 while (node) {
837 Route *pRouteDelete = node->GetData();
838 delete pRouteDelete;
839
840 node = node->GetNext();
841 }
842 delete pRouteList;
843 pRouteList = NULL;
844
845 Disconnect(
846 wxEVT_OCPN_MSG,
847 (wxObjectEventFunction)(wxEventFunction)&MyFrame::OnEvtPlugInMessage);
848 // FIXME (dave) Was in some datastream file?
849 // Disconnect(wxEVT_OCPN_THREADMSG,
850 // (wxObjectEventFunction)(wxEventFunction)&MyFrame::OnEvtTHREADMSG);
851}
852
853void MyFrame::OnSENCEvtThread(OCPN_BUILDSENC_ThreadEvent &event) {
854 s57chart *chart;
855 switch (event.type) {
856 case SENC_BUILD_STARTED:
857 // printf("Myframe SENC build started\n");
858 break;
859 case SENC_BUILD_DONE_NOERROR:
860 // printf("Myframe SENC build done no error\n");
861 chart = event.m_ticket->m_chart;
862 if (chart) {
863 chart->PostInit(FULL_INIT, global_color_scheme);
864 // ..For each canvas, force an S52PLIB reconfig...
865 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
866 ChartCanvas *cc = g_canvasArray.Item(i);
867 if (cc) cc->ClearS52PLIBStateHash(); // Force a S52 PLIB re-configure
868 }
869 }
870
871 ReloadAllVP();
872 delete event.m_ticket;
873 break;
874 case SENC_BUILD_DONE_ERROR:
875 // printf("Myframe SENC build done ERROR\n");
876 break;
877 default:
878 break;
879 }
880}
881
882void MyFrame::RebuildChartDatabase() {
883 bool b_SetInitialPoint = false;
884
885 // Build the initial chart dir array
886 ArrayOfCDI ChartDirArray;
887 pConfig->LoadChartDirArray(ChartDirArray);
888
889 if (ChartDirArray.GetCount()) {
890 // Create and Save a new Chart Database based on the hints
891 // given in the config file
892 if (g_NeedDBUpdate == 1) {
893 wxString msg1(
894 _("OpenCPN needs to update the chart database from config file "
895 "entries...."));
896
897 OCPNMessageDialog mdlg(gFrame, msg1, wxString(_("OpenCPN Info")),
898 wxICON_INFORMATION | wxOK);
899 mdlg.ShowModal();
900 }
901
902 delete ChartData;
903 ChartData = new ChartDB();
904
905 wxString line(
906 _("Rebuilding chart database from configuration file entries..."));
907 /* The following 3 strings are embeded in wxProgressDialog but must be
908 * included by xgettext to be localized properly. See
909 * {wxWidgets}src/generic/progdlgg.cpp:190 */
910 wxString dummy1 = _("Elapsed time : ");
911 wxString dummy2 = _("Estimated time : ");
912 wxString dummy3 = _("Remaining time : ");
913 wxGenericProgressDialog *pprog = new wxGenericProgressDialog(
914 _("OpenCPN Chart Update"), line, 100, NULL,
915 wxPD_SMOOTH | wxPD_ELAPSED_TIME | wxPD_ESTIMATED_TIME |
916 wxPD_REMAINING_TIME);
917
918 ChartData->Create(ChartDirArray, pprog);
919 ChartData->SaveBinary(ChartListFileName);
920
921 delete pprog;
922
923 // Apply the inital Group Array structure to the chart database
924 ChartData->ApplyGroupArray(g_pGroupArray);
925 }
926}
927
928// play an arbitrary number of bells by using 1 and 2 bell sounds
929void MyFrame::OnBellsFinished(wxCommandEvent &event) {
930 int bells = wxMin(m_BellsToPlay, 2);
931 if (bells <= 0) return;
932
933 wxString soundfile = _T("sounds");
934 appendOSDirSlash(&soundfile);
935 soundfile += wxString(bells_sound_file_name[bells - 1], wxConvUTF8);
936 soundfile.Prepend(g_Platform->GetSharedDataDir());
937 wxLogMessage(_T("Using bells sound file: ") + soundfile);
938
939 OcpnSound *sound = bells_sound[bells - 1];
940 sound->SetFinishedCallback(onBellsFinishedCB, this);
941 auto cmd_sound = dynamic_cast<SystemCmdSound *>(sound);
942 if (cmd_sound) cmd_sound->SetCmd(g_CmdSoundString.mb_str(wxConvUTF8));
943 sound->Load(soundfile);
944 if (!sound->IsOk()) {
945 wxLogMessage(_T("Failed to load bells sound file: ") + soundfile);
946 return;
947 }
948 sound->Play();
949 m_BellsToPlay -= bells;
950}
951
952void MyFrame::OnEraseBackground(wxEraseEvent &event) {}
953
954void MyFrame::OnMaximize(wxMaximizeEvent &event) {
955 g_click_stop = 0;
956#ifdef __WXOSX__
957 event.Skip();
958#endif
959}
960
961ColorScheme GetColorScheme() { return global_color_scheme; }
962
963ColorScheme MyFrame::GetColorScheme() { return global_color_scheme; }
964
965void MyFrame::ReloadAllVP() {
966 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
967 ChartCanvas *cc = g_canvasArray.Item(i);
968 if (cc) cc->ReloadVP();
969 }
970}
971
972void MyFrame::SetAndApplyColorScheme(ColorScheme cs) {
973 global_color_scheme = cs;
974
975 wxString SchemeName;
976 switch (cs) {
977 case GLOBAL_COLOR_SCHEME_DAY:
978 SchemeName = _T("DAY");
979 break;
980 case GLOBAL_COLOR_SCHEME_DUSK:
981 SchemeName = _T("DUSK");
982 break;
983 case GLOBAL_COLOR_SCHEME_NIGHT:
984 SchemeName = _T("NIGHT");
985 break;
986 default:
987 SchemeName = _T("DAY");
988 break;
989 }
990
991 g_pauidockart->SetMetric(wxAUI_DOCKART_GRADIENT_TYPE, wxAUI_GRADIENT_NONE);
992
993 g_pauidockart->SetColour(wxAUI_DOCKART_BORDER_COLOUR, wxColour(0, 0, 0));
994 g_pauidockart->SetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE, 1);
995 g_pauidockart->SetColour(wxAUI_DOCKART_SASH_COLOUR, wxColour(0, 0, 0));
996 g_pauidockart->SetMetric(wxAUI_DOCKART_SASH_SIZE, 0);
997 g_pauidockart->SetColour(wxAUI_DOCKART_INACTIVE_CAPTION_COLOUR,
998 wxColour(0, 0, 0));
999 g_pauidockart->SetColour(wxAUI_DOCKART_BACKGROUND_COLOUR, wxColour(0, 0, 0));
1000
1001 // if( cs == GLOBAL_COLOR_SCHEME_DUSK || cs == GLOBAL_COLOR_SCHEME_NIGHT )
1002 // {
1003 // g_pauidockart->SetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE, 0);
1004 // g_pauidockart->SetColour(wxAUI_DOCKART_BACKGROUND_COLOUR,
1005 // wxColour(0,0,0));
1006 // g_pauidockart->SetColour(wxAUI_DOCKART_BORDER_COLOUR,
1007 // wxColour(0,0,0));
1008 // }
1009
1010 // else{
1011 // g_pauidockart->SetMetric(wxAUI_DOCKART_GRADIENT_TYPE,
1012 // g_grad_default);
1013 // g_pauidockart->SetColour(wxAUI_DOCKART_BORDER_COLOUR,
1014 // g_border_color_default);
1015 // g_pauidockart->SetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE,
1016 // g_border_size_default);
1017 // g_pauidockart->SetColour(wxAUI_DOCKART_SASH_COLOUR,
1018 // g_sash_color_default);
1019 // g_pauidockart->SetMetric(wxAUI_DOCKART_SASH_SIZE,
1020 // g_sash_size_default);
1021 // g_pauidockart->SetColour(wxAUI_DOCKART_INACTIVE_CAPTION_COLOUR,
1022 // g_caption_color_default);
1023 // g_pauidockart->SetColour(wxAUI_DOCKART_BACKGROUND_COLOUR,
1024 // g_background_color_default);
1025 //
1026 // }
1027
1028 g_pauidockart->SetColour(wxAUI_DOCKART_SASH_COLOUR, wxColour(0, 0, 0));
1029 g_pauidockart->SetMetric(wxAUI_DOCKART_SASH_SIZE, 6);
1030
1031 g_pauimgr->Update();
1032
1033 g_StyleManager->GetCurrentStyle()->SetColorScheme(cs);
1034
1035 // Search the user color table array to find the proper hash table
1036 unsigned Usercolortable_index = 0;
1037 for (unsigned int i = 0; i < UserColorTableArray->GetCount(); i++) {
1038 colTable *ct = (colTable *)UserColorTableArray->Item(i);
1039 if (SchemeName.IsSameAs(*ct->tableName)) {
1040 Usercolortable_index = i;
1041 break;
1042 }
1043 }
1044
1045 if (ps52plib) ps52plib->SetPLIBColorScheme(SchemeName, ChartCtxFactory());
1046
1047 // Set up a pointer to the proper hash table
1048 pcurrent_user_color_hash =
1049 (wxColorHashMap *)UserColourHashTableArray->Item(Usercolortable_index);
1050
1051 SetSystemColors(cs);
1052
1053 // ..For each canvas...
1054 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
1055 ChartCanvas *cc = g_canvasArray.Item(i);
1056 if (cc) {
1057 cc->SetColorScheme(cs);
1058 cc->GetWorldBackgroundChart()->SetColorScheme(cs);
1059 cc->HideChartInfoWindow();
1060 cc->SetQuiltChartHiLiteIndex(-1);
1061 }
1062 }
1063
1064 if (pWayPointMan)
1065 WayPointmanGui(*pWayPointMan)
1066 .SetColorScheme(cs, g_Platform->GetDisplayDPmm());
1067 if (ChartData) ChartData->ApplyColorSchemeToCachedCharts(cs);
1068
1069 if (g_options) {
1070 g_options->SetColorScheme(cs);
1071 }
1072
1073 if (console) {
1074 console->SetColorScheme(cs);
1075 }
1076
1077 if (g_pRouteMan) {
1078 g_pRouteMan->SetColorScheme(cs, g_Platform->GetDisplayDPmm());
1079 }
1080
1081 if (g_pMarkInfoDialog) {
1082 g_pMarkInfoDialog->SetColorScheme(cs);
1083 }
1084
1085 if (pRoutePropDialog) {
1086 pRoutePropDialog->SetColorScheme(cs);
1087 }
1088
1089 // For the AIS target query dialog, we must rebuild it to incorporate the
1090 // style desired for the colorscheme selected
1091 if (g_pais_query_dialog_active) {
1092 bool b_isshown = g_pais_query_dialog_active->IsShown();
1093 int n_mmsi = g_pais_query_dialog_active->GetMMSI();
1094 if (b_isshown) g_pais_query_dialog_active->Show(false); // dismiss it
1095
1096 g_pais_query_dialog_active->Close();
1097
1098 g_pais_query_dialog_active = new AISTargetQueryDialog();
1099 g_pais_query_dialog_active->Create(
1100 this, -1, _("AIS Target Query"),
1101 wxPoint(g_ais_query_dialog_x, g_ais_query_dialog_y));
1102 g_pais_query_dialog_active->SetMMSI(n_mmsi);
1103 g_pais_query_dialog_active->UpdateText();
1104 if (b_isshown) g_pais_query_dialog_active->Show();
1105 }
1106
1107 if (pRouteManagerDialog) pRouteManagerDialog->SetColorScheme();
1108
1109 if (g_pAISTargetList) g_pAISTargetList->SetColorScheme();
1110
1111 if (g_pObjectQueryDialog) g_pObjectQueryDialog->SetColorScheme();
1112
1113 ApplyGlobalColorSchemetoStatusBar();
1114
1115 UpdateAllToolbars(cs);
1116
1117 if (g_MainToolbar) {
1118 if (g_MainToolbar->GetColorScheme() != cs) {
1119 // capture the current toolbar collapse state
1120 bool btoolbarFull = g_bmasterToolbarFull;
1121
1122 g_MainToolbar->SetColorScheme(cs);
1123 // g_MainToolbar->DestroyToolBar();
1124 // CreateMasterToolbar();
1125
1126 if (!btoolbarFull) {
1127 // g_MainToolbar->Hide();
1128 RequestNewMasterToolbar();
1129 g_MainToolbar->SetColorScheme(cs);
1130 CollapseGlobalToolbar();
1131 // g_MainToolbar->Show();
1132 } else {
1133 RequestNewMasterToolbar();
1134 g_MainToolbar->SetColorScheme(cs);
1135 }
1136 }
1137 }
1138
1139 if (g_pi_manager) g_pi_manager->SetColorSchemeForAllPlugIns(cs);
1140}
1141
1142void MyFrame::ApplyGlobalColorSchemetoStatusBar(void) {
1143 if (m_pStatusBar != NULL) {
1144 m_pStatusBar->SetBackgroundColour(GetGlobalColor(_T("UIBDR"))); // UINFF
1145 m_pStatusBar->ClearBackground();
1146 }
1147}
1148
1149ChartCanvas *MyFrame::GetPrimaryCanvas() {
1150 if (g_canvasArray.GetCount() > 0)
1151 return g_canvasArray.Item(0);
1152 else
1153 return NULL;
1154}
1155void MyFrame::CancelAllMouseRoute() {
1156 // ..For each canvas...
1157 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
1158 ChartCanvas *cc = g_canvasArray.Item(i);
1159 if (cc) cc->CancelMouseRoute();
1160 }
1161}
1162
1163void MyFrame::NotifyChildrenResize() {}
1164
1165void MyFrame::CreateCanvasLayout(bool b_useStoredSize) {
1166 // Clear the cache, and thus close all charts to avoid memory leaks
1167 if (ChartData) ChartData->PurgeCache();
1168
1169 // Detach all canvases from AUI manager
1170 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
1171 ChartCanvas *cc = g_canvasArray[i];
1172 if (cc) {
1173 g_pauimgr->DetachPane(cc);
1174 }
1175 }
1176
1177 // Destroy any existing canvases, except for Primary canvas
1178 for (unsigned int i = 1; i < g_canvasArray.GetCount(); i++) {
1179 ChartCanvas *cc = g_canvasArray.Item(i);
1180 if (cc) {
1181 // pthumbwin = NULL; // TODO
1182 // cc->DestroyToolbar();
1183 cc->Destroy();
1184 }
1185 }
1186
1187 auto &config_array = ConfigMgr::Get().GetCanvasConfigArray();
1188
1189 // Canvas pointers in config array are now invalid
1190 for (unsigned int i = 1; i < config_array.GetCount(); i++) {
1191 config_array.Item(i)->canvas = NULL;
1192 }
1193
1194 // g_canvasArray.Clear();
1195
1196 // Clear the canvas Array, except for Primary canvas
1197 for (unsigned int i = 1; i < g_canvasArray.GetCount(); i++) {
1198 g_canvasArray.RemoveAt(i);
1199 }
1200
1201 ChartCanvas *cc = NULL;
1202 switch (g_canvasConfig) {
1203 default:
1204 case 0: // a single canvas
1205 if (!g_canvasArray.GetCount() || !config_array.Item(0)) {
1206 cc = new ChartCanvas(this, 0); // the chart display canvas
1207 g_canvasArray.Add(cc);
1208 } else {
1209 cc = g_canvasArray[0];
1210 }
1211
1212#ifdef ocpnUSE_GL
1213 // Verify that glCanvas is ready, if necessary
1214 if (g_bopengl) {
1215 if (!cc->GetglCanvas()) cc->SetupGlCanvas();
1216 cc->GetglCanvas()->Show();
1217 }
1218#endif
1219 config_array.Item(0)->canvas = cc;
1220
1221 cc->SetDisplaySizeMM(g_display_size_mm);
1222
1223 cc->ApplyCanvasConfig(config_array.Item(0));
1224
1225 // cc->SetToolbarPosition(wxPoint( g_maintoolbar_x,
1226 // g_maintoolbar_y ));
1227 cc->ConfigureChartBar();
1228 cc->SetColorScheme(global_color_scheme);
1229 cc->GetCompass()->SetScaleFactor(g_compass_scalefactor);
1230 cc->SetShowGPS(true);
1231
1232 g_pauimgr->AddPane(cc);
1233 g_pauimgr->GetPane(cc).Name(_T("ChartCanvas"));
1234 g_pauimgr->GetPane(cc).Fixed();
1235 g_pauimgr->GetPane(cc).CaptionVisible(false);
1236 g_pauimgr->GetPane(cc).CenterPane();
1237
1238 break;
1239
1240 case 1: { // two canvas, horizontal
1241 if (!g_canvasArray.GetCount() || !g_canvasArray[0]) {
1242 cc = new ChartCanvas(this, 0); // the chart display canvas
1243 g_canvasArray.Add(cc);
1244 } else {
1245 cc = g_canvasArray[0];
1246 }
1247
1248 // Verify that glCanvas is ready, if not already built
1249#ifdef ocpnUSE_GL
1250 if (g_bopengl) {
1251 if (!cc->GetglCanvas()) cc->SetupGlCanvas();
1252 }
1253#endif
1254 config_array.Item(0)->canvas = cc;
1255
1256 cc->ApplyCanvasConfig(config_array.Item(0));
1257
1258 cc->SetDisplaySizeMM(g_display_size_mm);
1259 cc->ConfigureChartBar();
1260 cc->SetColorScheme(global_color_scheme);
1261 cc->GetCompass()->SetScaleFactor(g_compass_scalefactor);
1262 cc->SetShowGPS(false);
1263
1264 g_pauimgr->AddPane(cc);
1265 g_pauimgr->GetPane(cc).Name(_T("ChartCanvas"));
1266 g_pauimgr->GetPane(cc)
1267 .CaptionVisible(false)
1268 .PaneBorder(false)
1269 .CloseButton(false);
1270
1271 g_pauimgr->GetPane(cc).CenterPane();
1272
1273 cc = new ChartCanvas(this, 1); // the chart display canvas
1274 g_canvasArray.Add(cc);
1275
1276 // There is not yet a config descriptor for canvas 2, so create one by
1277 // copy ctor from canvas {0}.
1278 if (config_array.GetCount() < 2) {
1279 canvasConfig *pcc = new canvasConfig(*config_array.Item(0));
1280 pcc->configIndex = 1;
1281
1282 // Arbitrarily establish the initial size of the new canvas to be
1283 // half the screen width.
1284 pcc->canvasSize = wxSize(GetClientSize().x / 2, GetClientSize().y);
1285 config_array.Add(pcc);
1286 }
1287
1288 config_array.Item(1)->canvas = cc;
1289
1290 cc->ApplyCanvasConfig(config_array.Item(1));
1291
1292 cc->SetDisplaySizeMM(g_display_size_mm);
1293 cc->ConfigureChartBar();
1294 cc->SetColorScheme(global_color_scheme);
1295 cc->SetShowGPS(true);
1296 cc->CreateMUIBar();
1297
1298 g_pauimgr->AddPane(cc);
1299 g_pauimgr->GetPane(cc).Name(_T("ChartCanvas2"));
1300 g_pauimgr->GetPane(cc)
1301 .CaptionVisible(false)
1302 .PaneBorder(false)
1303 .CloseButton(false);
1304 g_pauimgr->GetPane(cc).RightDockable(true);
1305 g_pauimgr->GetPane(cc).Right();
1306
1307#ifdef __ANDROID__
1308 config_array.Item(1)->canvasSize =
1309 wxSize(GetClientSize().x / 2, GetClientSize().y);
1310 g_pauimgr->GetPane(cc).BestSize(GetClientSize().x / 2, GetClientSize().y);
1311#endif
1312
1313 // If switching fromsingle canvas to 2-canvas mode dynamically,
1314 // try to use the latest persisted size for the new second canvas.
1315 if (b_useStoredSize) {
1316 int ccw = config_array.Item(1)->canvasSize.x;
1317 int cch = config_array.Item(1)->canvasSize.y;
1318
1319 // Check for undefined size, and set a nice default size if necessary.
1320 if (ccw < GetClientSize().x / 10) {
1321 ccw = GetClientSize().x / 2;
1322 cch = GetClientSize().y;
1323 }
1324
1325 g_pauimgr->GetPane(cc).BestSize(ccw, cch);
1326 cc->SetSize(ccw, cch);
1327 }
1328
1329 break;
1330 }
1331
1332 case 2: // two canvas, vertical
1333
1334 break;
1335 }
1336
1337 g_focusCanvas = GetPrimaryCanvas();
1338}
1339
1340void MyFrame::RequestNewToolbars(bool bforcenew) {
1341 if (b_inCloseWindow) {
1342 return;
1343 }
1344
1345 BuildiENCToolbar(bforcenew);
1346 PositionIENCToolbar();
1347
1348#ifdef __ANDROID__
1349 DoChartUpdate();
1350#endif
1351}
1352
1353// Update inplace the various controls with bitmaps corresponding to the
1354// current color scheme
1355void MyFrame::UpdateAllToolbars(ColorScheme cs) {
1356 if (g_iENCToolbar) g_iENCToolbar->SetColorScheme(cs);
1357
1358 return;
1359}
1360
1361void MyFrame::SetAllToolbarScale() {
1362 g_toolbar_scalefactor = g_Platform->GetToolbarScaleFactor(g_GUIScaleFactor);
1363}
1364
1365void MyFrame::SetGPSCompassScale() {
1366 g_compass_scalefactor = g_Platform->GetCompassScaleFactor(g_GUIScaleFactor);
1367}
1368
1369ChartCanvas *MyFrame::GetCanvasUnderMouse() {
1370 wxPoint screenPoint = ::wxGetMousePosition();
1371 canvasConfig *cc;
1372
1373 switch (g_canvasConfig) {
1374 case 1:
1375 cc = ConfigMgr::Get().GetCanvasConfigArray().Item(0);
1376 if (cc) {
1377 ChartCanvas *canvas = cc->canvas;
1378 if (canvas->GetScreenRect().Contains(
1379 /*canvas->ScreenToClient*/ (screenPoint)))
1380 return canvas;
1381 }
1382 cc = ConfigMgr::Get().GetCanvasConfigArray().Item(1);
1383 if (cc) {
1384 ChartCanvas *canvas = cc->canvas;
1385 if (canvas->GetScreenRect().Contains(
1386 /*canvas->ScreenToClient*/ (screenPoint)))
1387 return canvas;
1388 }
1389 break;
1390
1391 default:
1392 cc = ConfigMgr::Get().GetCanvasConfigArray().Item(0);
1393 if (cc) {
1394 ChartCanvas *canvas = cc->canvas;
1395 if (canvas->GetScreenRect().Contains(
1396 canvas->ScreenToClient(screenPoint)))
1397 return canvas;
1398 }
1399 }
1400
1401 return NULL;
1402}
1403
1404int MyFrame::GetCanvasIndexUnderMouse() {
1405 wxPoint screenPoint = ::wxGetMousePosition();
1406 canvasConfig *cc;
1407
1408 switch (g_canvasConfig) {
1409 case 1:
1410 cc = ConfigMgr::Get().GetCanvasConfigArray().Item(0);
1411 if (cc) {
1412 ChartCanvas *canvas = cc->canvas;
1413 if (canvas->GetScreenRect().Contains(
1414 /*canvas->ScreenToClient*/ (screenPoint)))
1415 return 0;
1416 }
1417 cc = ConfigMgr::Get().GetCanvasConfigArray().Item(1);
1418 if (cc) {
1419 ChartCanvas *canvas = cc->canvas;
1420 if (canvas->GetScreenRect().Contains(
1421 /*canvas->ScreenToClient*/ (screenPoint)))
1422 return 1;
1423 }
1424 break;
1425
1426 default:
1427 cc = ConfigMgr::Get().GetCanvasConfigArray().Item(0);
1428 if (cc) {
1429 ChartCanvas *canvas = cc->canvas;
1430 if (canvas->GetScreenRect().Contains(
1431 canvas->ScreenToClient(screenPoint)))
1432 return 0;
1433 }
1434 }
1435
1436 return -1;
1437}
1438
1439bool MyFrame::DropMarker(bool atOwnShip) {
1440 double lat, lon;
1441 ChartCanvas *canvas = GetCanvasUnderMouse();
1442 if (atOwnShip) {
1443 lat = gLat;
1444 lon = gLon;
1445 } else {
1446 if (!canvas) return false;
1447
1448 lat = canvas->m_cursor_lat;
1449 lon = canvas->m_cursor_lon;
1450 }
1451
1452 RoutePoint *pWP =
1453 new RoutePoint(lat, lon, g_default_wp_icon, wxEmptyString, wxEmptyString);
1454 pWP->m_bIsolatedMark = true; // This is an isolated mark
1455 pSelect->AddSelectableRoutePoint(lat, lon, pWP);
1456 pConfig->AddNewWayPoint(pWP, -1); // use auto next num
1457 if (canvas)
1458 if (!RoutePointGui(*pWP).IsVisibleSelectable(canvas))
1459 RoutePointGui(*pWP).ShowScaleWarningMessage(canvas);
1460 if (pRouteManagerDialog && pRouteManagerDialog->IsShown())
1461 pRouteManagerDialog->UpdateWptListCtrl();
1462 // undo->BeforeUndoableAction( Undo_CreateWaypoint, pWP, Undo_HasParent,
1463 // NULL ); undo->AfterUndoableAction( NULL );
1464
1465 InvalidateAllGL();
1466 RefreshAllCanvas(false);
1467
1468 return true;
1469}
1470
1471void MyFrame::SwitchKBFocus(ChartCanvas *pCanvas) {
1472 if (g_canvasConfig != 0) { // multi-canvas?
1473 canvasConfig *cc;
1474 int nTarget = -1;
1475 int nTargetGTK = -1;
1476 ChartCanvas *target;
1477 wxWindow *source = FindFocus();
1478 auto test = dynamic_cast<ChartCanvas *>(source);
1479 if (!test) return;
1480
1481 // On linux(GTK), the TAB key causes a loss of focus immediately
1482 // So the logic needs a switch
1483 switch (g_canvasConfig) {
1484 case 1:
1485 cc = ConfigMgr::Get().GetCanvasConfigArray().Item(0);
1486 if (cc) {
1487 ChartCanvas *canvas = cc->canvas;
1488 if (canvas && (canvas == test)) {
1489 nTarget = 1;
1490 nTargetGTK = 0;
1491 }
1492 }
1493 cc = ConfigMgr::Get().GetCanvasConfigArray().Item(1);
1494 if (cc) {
1495 ChartCanvas *canvas = cc->canvas;
1496 if (canvas && (canvas == test)) {
1497 nTarget = 0;
1498 nTargetGTK = 1;
1499 }
1500 }
1501
1502 if (nTarget >= 0) {
1503 // printf("sw %d\n", nTarget);
1504 int nfinalTarget = nTarget;
1505#ifdef __WXGTK__
1506 nfinalTarget = nTargetGTK;
1507#endif
1508 target = ConfigMgr::Get()
1509 .GetCanvasConfigArray()
1510 .Item(nfinalTarget)
1511 ->canvas;
1512 if (target) {
1513 target->SetFocus();
1514 target->Refresh(true);
1515 }
1516 }
1517 break;
1518
1519 default:
1520 break;
1521 }
1522 }
1523}
1524
1525void MyFrame::FastClose() {
1526 FrameTimer1.Stop();
1527 FrameTenHzTimer.Stop();
1528 quitflag++; // signal to the timer loop
1529 FrameTimer1.Start(1); // real quick now...
1530}
1531
1532// Intercept menu commands
1533void MyFrame::OnExit(wxCommandEvent &event) {
1534 quitflag++; // signal to the timer loop
1535}
1536
1537void MyFrame::OnCloseWindow(wxCloseEvent &event) {
1538 // It is possible that double clicks on application exit box could cause
1539 // re-entrance here Not good, and don't need it anyway, so simply return.
1540 if (b_inCloseWindow) {
1541 // wxLogMessage(_T("opencpn::MyFrame re-entering
1542 // OnCloseWindow"));
1543 return;
1544 }
1545
1546 // The Options dialog, and other deferred init items, are not fully
1547 // initialized. Best to just cancel the close request. This is probably only
1548 // reachable on slow hardware, or on Android life-cycle events...
1549#ifndef __ANDROID__
1550 if (!g_bDeferredInitDone) return;
1551#endif
1552
1553#ifndef __WXOSX__
1554 if (g_options) {
1555 delete g_options;
1556 g_options = NULL;
1557 g_pOptions = NULL;
1558 }
1559#endif
1560
1561 // If the multithread chart compressor engine is running, cancel the close
1562 // command
1563 if (b_inCompressAllCharts) {
1564 return;
1565 }
1566
1567 if (bDBUpdateInProgress) return;
1568
1569 b_inCloseWindow = true;
1570
1571 ::wxSetCursor(wxCURSOR_WAIT);
1572
1573 // If we happen to have the measure tool open on Ctrl-Q quit
1574 // ..For each canvas...
1575 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
1576 ChartCanvas *cc = g_canvasArray.Item(i);
1577 if (cc && cc->IsMeasureActive()) {
1578 cc->CancelMeasureRoute();
1579 }
1580 }
1581
1582 // Give any requesting plugins a PreShutdownHook call
1583 SendPreShutdownHookToPlugins();
1584
1585 // We save perspective before closing to restore position next time
1586 // Pane is not closed so the child is not notified (OnPaneClose)
1587 if (g_pAISTargetList) {
1588 wxAuiPaneInfo &pane = g_pauimgr->GetPane(g_pAISTargetList);
1589 g_AisTargetList_perspective = g_pauimgr->SavePaneInfo(pane);
1590 g_pauimgr->DetachPane(g_pAISTargetList);
1591 }
1592
1593 // Make sure the saved perspective minimum canvas sizes are essentially
1594 // undefined
1595 // for(unsigned int i=0 ; i < g_canvasArray.GetCount() ; i++){
1596 // ChartCanvas *cc = g_canvasArray.Item(i);
1597 // if(cc)
1598 // g_pauimgr->GetPane( cc ).MinSize(10,10);
1599 // }
1600
1601 pConfig->SetPath(_T ( "/AUI" ));
1602 pConfig->Write(_T ( "AUIPerspective" ), g_pauimgr->SavePerspective());
1603
1604 g_bquiting = true;
1605
1606#ifdef ocpnUSE_GL
1607 // cancel compression jobs
1608 if (g_bopengl) {
1609 if (g_glTextureManager) {
1610 g_glTextureManager->PurgeJobList();
1611
1612 if (g_glTextureManager->GetRunningJobCount()) g_bcompression_wait = true;
1613 }
1614 }
1615#endif
1616
1617 SetCursor(wxCURSOR_WAIT);
1618
1619 RefreshAllCanvas(true);
1620
1621 // This yield is not necessary, since the Update() proceeds syncronously...
1622 // wxYield();
1623
1624 // Save the saved Screen Brightness
1625 RestoreScreenBrightness();
1626
1627 // Persist the toolbar locations
1628 // if (g_MainToolbar) {
1629 // g_MainToolbar->GetFrameRelativePosition(&g_maintoolbar_x,
1630 // &g_maintoolbar_y);
1631 // }
1632
1633#if 0
1634 if (g_iENCToolbar) {
1635 wxPoint locn = g_iENCToolbar->GetPosition();
1636 wxPoint tbp_incanvas = GetPrimaryCanvas()->ScreenToClient(locn);
1637 g_iENCToolbarPosY = tbp_incanvas.y;
1638 g_iENCToolbarPosX = tbp_incanvas.x;
1639 }
1640#endif
1641
1642 g_bframemax = IsMaximized();
1643
1644 FrameTimer1.Stop();
1645 FrameTenHzTimer.Stop();
1646
1647 FrameCOGTimer.Stop();
1648
1649 TrackOff();
1650
1651 /*
1652 Automatically drop an anchorage waypoint, if enabled
1653 On following conditions:
1654 1. In "Cruising" mode, meaning that speed has at some point exceeded 3.0 kts.
1655 2. Current speed is less than 0.5 kts.
1656 3. Opencpn has been up at least 30 minutes
1657 4. And, of course, opencpn is going down now.
1658 5. And if there is no anchor watch set on "anchor..." icon mark //
1659 pjotrc 2010.02.15
1660 */
1661 if (g_bAutoAnchorMark) {
1662 bool watching_anchor = false; // pjotrc 2010.02.15
1663 if (pAnchorWatchPoint1) // pjotrc 2010.02.15
1664 watching_anchor = (pAnchorWatchPoint1->GetIconName().StartsWith(
1665 _T("anchor"))); // pjotrc 2010.02.15
1666 if (pAnchorWatchPoint2) // pjotrc 2010.02.15
1667 watching_anchor |= (pAnchorWatchPoint2->GetIconName().StartsWith(
1668 _T("anchor"))); // pjotrc 2010.02.15
1669
1670 wxDateTime now = wxDateTime::Now();
1671 wxTimeSpan uptime = now.Subtract(g_start_time);
1672
1673 if (!watching_anchor && (g_bCruising) && (gSog < 0.5) &&
1674 (uptime.IsLongerThan(wxTimeSpan(0, 30, 0, 0)))) // pjotrc 2010.02.15
1675 {
1676 // First, delete any single anchorage waypoint closer than 0.25 NM from
1677 // this point This will prevent clutter and database congestion....
1678
1679 wxRoutePointListNode *node = pWayPointMan->GetWaypointList()->GetFirst();
1680 while (node) {
1681 RoutePoint *pr = node->GetData();
1682 if (pr->GetName().StartsWith(_T("Anchorage"))) {
1683 double a = gLat - pr->m_lat;
1684 double b = gLon - pr->m_lon;
1685 double l = sqrt((a * a) + (b * b));
1686
1687 // caveat: this is accurate only on the Equator
1688 if ((l * 60. * 1852.) < (.25 * 1852.)) {
1689 pConfig->DeleteWayPoint(pr);
1690 pSelect->DeleteSelectablePoint(pr, SELTYPE_ROUTEPOINT);
1691 delete pr;
1692 break;
1693 }
1694 }
1695
1696 node = node->GetNext();
1697 }
1698
1699 wxString name = now.Format();
1700 name.Prepend(_("Anchorage created "));
1701 RoutePoint *pWP =
1702 new RoutePoint(gLat, gLon, _T("anchorage"), name, wxEmptyString);
1703 pWP->m_bShowName = false;
1704 pWP->m_bIsolatedMark = true;
1705
1706 pConfig->AddNewWayPoint(pWP, -1); // use auto next num
1707 }
1708 }
1709
1710 // Provisionally save all settings before deactivating plugins
1711 pConfig->UpdateSettings();
1712
1713 // Deactivate the PlugIns
1714 auto plugin_loader = PluginLoader::getInstance();
1715 if (plugin_loader) {
1716 plugin_loader->DeactivateAllPlugIns();
1717 }
1718
1719 wxLogMessage(_T("opencpn::MyFrame exiting cleanly."));
1720
1721 quitflag++;
1722
1723 pConfig->UpdateNavObj();
1724
1725 pConfig->m_pNavObjectChangesSet->reset();
1726
1727 // Remove any leftover Routes and Waypoints from config file as they were
1728 // saved to navobj before
1729 pConfig->DeleteGroup(_T ( "/Routes" ));
1730 pConfig->DeleteGroup(_T ( "/Marks" ));
1731 pConfig->Flush();
1732
1733 if (g_pAboutDlg) g_pAboutDlg->Destroy();
1734 if (g_pAboutDlgLegacy) g_pAboutDlgLegacy->Destroy();
1735
1736 // Explicitely Close some children, especially the ones with event
1737 // handlers or that call GUI methods
1738
1739 if (g_pCM93OffsetDialog) {
1740 g_pCM93OffsetDialog->Destroy();
1741 g_pCM93OffsetDialog = NULL;
1742 }
1743
1744#ifndef __ANDROID__
1745 // if (g_MainToolbar) g_MainToolbar->Destroy();
1746 // g_MainToolbar = NULL;
1747#endif
1748
1749 if (g_iENCToolbar) {
1750 // wxPoint locn = g_iENCToolbar->GetPosition();
1751 // g_iENCToolbarPosY = locn.y;
1752 // g_iENCToolbarPosX = locn.x;
1753 // g_iENCToolbar->Destroy();
1754 }
1755
1756 if (g_pAISTargetList) {
1757 g_pAISTargetList->Disconnect_decoder();
1758 g_pAISTargetList->Destroy();
1759 }
1760
1761#ifndef __WXQT__
1762 SetStatusBar(NULL);
1763#endif
1764
1765 if (RouteManagerDialog::getInstanceFlag()) {
1766 if (pRouteManagerDialog) {
1767 pRouteManagerDialog->Destroy();
1768 pRouteManagerDialog = NULL;
1769 }
1770 }
1771
1772 // Clear the cache, and thus close all charts to avoid memory leaks
1773 if (ChartData) ChartData->PurgeCache();
1774
1775 // pthumbwin is a canvas child
1776 // pthumbwin = NULL;
1777
1778 // Finally ready to destroy the canvases
1779 g_focusCanvas = NULL;
1780
1781 // ..For each canvas...
1782 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
1783 ChartCanvas *cc = g_canvasArray.Item(i);
1784 if (cc) cc->Destroy();
1785 }
1786
1787 g_canvasArray.Clear();
1788
1789 g_pauimgr->UnInit();
1790 delete g_pauimgr;
1791 g_pauimgr = NULL;
1792
1793 // Unload the PlugIns
1794 // Note that we are waiting until after the canvas is destroyed,
1795 // since some PlugIns may have created children of canvas.
1796 // Such a PlugIn must stay intact for the canvas dtor to call
1797 // DestoryChildren()
1798
1799 if (ChartData) ChartData->PurgeCachePlugins();
1800
1801 if (PluginLoader::getInstance())
1802 PluginLoader::getInstance()->UnLoadAllPlugIns();
1803
1804 if (g_pi_manager) {
1805 delete g_pi_manager;
1806 g_pi_manager = NULL;
1807 }
1808
1809 MyApp &app = wxGetApp();
1810 app.m_comm_bridge.SaveConfig();
1811
1812 delete pConfig; // All done
1813 pConfig = NULL;
1814 InitBaseConfig(0);
1815
1816 if (g_pAIS) {
1817 delete g_pAIS;
1818 g_pAIS = NULL;
1819 }
1820
1821 if (g_pAISGUI) {
1822 delete g_pAISGUI;
1823 g_pAISGUI = NULL;
1824 }
1825
1826 delete g_pMUX;
1827 g_pMUX = NULL;
1828
1829 // Close and delete all comm drivers
1830 auto &registry = CommDriverRegistry::GetInstance();
1831 registry.CloseAllDrivers();
1832
1833 // Clear some global arrays, lists, and hash maps...
1834 for (auto *cp : TheConnectionParams()) {
1835 delete cp;
1836 }
1837
1838 if (pLayerList) {
1839 LayerList::iterator it;
1840 while (pLayerList->GetCount()) {
1841 Layer *lay = pLayerList->GetFirst()->GetData();
1842 delete lay; // automatically removes the layer from list, see Layer dtor
1843 }
1844 }
1845
1846 NMEALogWindow::Shutdown();
1847
1848 ReleaseApiListeners();
1849
1850 g_MainToolbar = NULL;
1851 g_bTempShowMenuBar = false;
1852
1853#define THREAD_WAIT_SECONDS 5
1854#ifdef ocpnUSE_GL
1855 // The last thing we do is finish the compression threads.
1856 // This way the main window is already invisible and to the user
1857 // it appears to have finished rather than hanging for several seconds
1858 // while the compression threads exit
1859 if (g_bopengl && g_glTextureManager &&
1860 g_glTextureManager->GetRunningJobCount()) {
1861 g_glTextureManager->ClearAllRasterTextures();
1862
1863 wxLogMessage(_T("Starting compressor pool drain"));
1864 wxDateTime now = wxDateTime::Now();
1865 time_t stall = now.GetTicks();
1866 time_t end = stall + THREAD_WAIT_SECONDS;
1867
1868 int n_comploop = 0;
1869 while (stall < end) {
1870 wxDateTime later = wxDateTime::Now();
1871 stall = later.GetTicks();
1872
1873 wxString msg;
1874 msg.Printf(_T("Time: %d Job Count: %d"), n_comploop,
1875 g_glTextureManager->GetRunningJobCount());
1876 wxLogMessage(msg);
1877 if (!g_glTextureManager->GetRunningJobCount()) break;
1878 wxYield();
1879 wxSleep(1);
1880 }
1881
1882 wxString fmsg;
1883 fmsg.Printf(_T("Finished compressor pool drain..Time: %d Job Count: %d"),
1884 n_comploop, g_glTextureManager->GetRunningJobCount());
1885 wxLogMessage(fmsg);
1886 }
1887 delete g_glTextureManager;
1888#endif
1889 uninitIXNetSystem();
1890 this->Destroy();
1891 gFrame = NULL;
1892
1893 wxLogMessage(_T("gFrame destroyed."));
1894
1895#ifdef __ANDROID__
1896#ifndef USE_ANDROID_GLES2
1897 qDebug() << "Calling OnExit()";
1898 wxTheApp->OnExit();
1899#endif
1900#endif
1901 wxTheApp->ExitMainLoop();
1902}
1903
1904void MyFrame::OnMove(wxMoveEvent &event) {
1905 auto idx = wxDisplay::GetFromWindow(this);
1906 if (idx != wxNOT_FOUND && g_current_monitor != static_cast<size_t>(idx) &&
1907 static_cast<size_t>(idx) < g_monitor_info.size()) {
1908 g_current_monitor = idx;
1909#ifdef __WXOSX__
1910 // On retina displays there is a difference between the physical size of the
1911 // OpenGL canvas and the DIP This is not observed anywhere else so far, so
1912 // g_current_monitor_dip_px_ratio cna be kept 1.0 everywhere else
1913 if (g_bopengl) {
1914 g_current_monitor_dip_px_ratio =
1915 g_monitor_info[idx].width_px / g_monitor_info[idx].width;
1916 }
1917#endif
1918 DEBUG_LOG << "Moved to " << idx
1919#if wxCHECK_VERSION(3, 1, 6)
1920 << " PPI: " << wxDisplay(idx).GetPPI().GetX() << "x"
1921 << wxDisplay(idx).GetPPI().GetY()
1922 << " SF wxDisplay: " << wxDisplay(idx).GetScaleFactor()
1923#endif
1924 << " Size wxDisplay: " << wxDisplay(idx).GetGeometry().GetWidth()
1925 << "x" << wxDisplay(idx).GetGeometry().GetHeight()
1926 << " MM wxDisplay: " << wxGetDisplaySizeMM().GetX() << "x"
1927 << wxGetDisplaySizeMM().GetY()
1928 << " Name wxDisplay: " << wxDisplay(idx).GetName().c_str()
1929 << " Real: " << g_monitor_info[idx].width_mm << "x"
1930 << g_monitor_info[idx].height_mm << "mm "
1931 << g_monitor_info[idx].width_mm << "x"
1932 << g_monitor_info[idx].height_mm << "mm "
1933 << g_monitor_info[idx].width << "x" << g_monitor_info[idx].height
1934 << "DIP " << g_monitor_info[idx].width_px << "x"
1935 << g_monitor_info[idx].height_px << "px"
1936 << g_monitor_info[idx].scale << "%";
1937 if (g_config_display_size_manual) {
1938 if (g_config_display_size_mm.size() > static_cast<size_t>(idx)) {
1939 g_display_size_mm = g_config_display_size_mm[idx];
1940 } // Do nothing if the user did not set any value for this monitor
1941 } else {
1942 g_display_size_mm = g_monitor_info[idx].width_mm;
1943 }
1944 }
1945 // ..For each canvas...
1946 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
1947 ChartCanvas *cc = g_canvasArray.Item(i);
1948 if (cc) {
1949 cc->SetMUIBarPosition();
1950 cc->SetDisplaySizeMM(g_display_size_mm);
1951 }
1952 }
1953
1954#ifdef __WXOSX__
1955 SendSizeEvent();
1956#endif
1957
1958 UpdateGPSCompassStatusBoxes();
1959
1960 if (console && console->IsShown()) PositionConsole();
1961
1962 // If global toolbar is shown, reposition it...
1963 // if (g_MainToolbar) {
1964 // g_MainToolbar->RestoreRelativePosition(g_maintoolbar_x, g_maintoolbar_y);
1965 // g_MainToolbar->Realize();
1966 //}
1967
1968 PositionIENCToolbar();
1969
1970 // Somehow, this method does not work right on Windows....
1971 // g_nframewin_posx = event.GetPosition().x;
1972 // g_nframewin_posy = event.GetPosition().y;
1973
1974 g_nframewin_posx = GetPosition().x;
1975 g_nframewin_posy = GetPosition().y;
1976}
1977
1978void MyFrame::ProcessCanvasResize(void) {
1979 UpdateGPSCompassStatusBoxes(true);
1980
1981 if (console && console->IsShown()) PositionConsole();
1982
1983 PositionIENCToolbar();
1984
1985#ifndef __ANDROID__
1986 TriggerRecaptureTimer();
1987#endif
1988}
1989
1990void MyFrame::TriggerRecaptureTimer() {
1991 m_recaptureTimer.Start(
1992 1000, wxTIMER_ONE_SHOT); // One second seems enough, on average
1993}
1994
1995void MyFrame::OnRecaptureTimer(wxTimerEvent &event) { Raise(); }
1996
1997void MyFrame::SetCanvasSizes(wxSize frameSize) {
1998 if (!g_canvasArray.GetCount()) return;
1999
2000#if 0
2001 int cccw = frameSize.x;
2002 int ccch = frameSize.y;
2003#endif
2004
2005 // .. for each canvas...
2006 switch (g_canvasConfig) {
2007 default:
2008 case 0:
2009#if 0
2010 cc = g_canvasArray.Item(0);
2011 if( cc ) {
2012 cc->GetSize( &cur_width, &cur_height );
2013 if( ( cur_width != cccw ) || ( cur_height != ccch ) ) {
2014 if( g_pauimgr->GetPane( cc ).IsOk() )
2015 g_pauimgr->GetPane( cc ).BestSize( cccw, ccch );
2016 else
2017 cc->SetSize( 0, 0, cccw, ccch );
2018 }
2019 }
2020#endif
2021 break;
2022
2023 case 1:
2024#if 0
2025 cc = g_canvasArray.Item(1);
2026 if( cc ) {
2027 int ccw = g_canvasConfigArray.Item(1)->canvasSize.x;
2028 int cch = g_canvasConfigArray.Item(1)->canvasSize.y;
2029
2030 ccw = wxMin(ccw, cccw * 8 / 10);
2031 ccw = wxMax(ccw, cccw * 2 / 10);
2032 if(cccw < 100)
2033 ccw = 20;
2034
2035 g_canvasConfigArray.Item(1)->canvasSize = wxSize(ccw, cch);
2036// g_pauimgr->GetPane(cc).MinSize(cccw * 2 / 10, ccch);
2037
2038#if 1 // ndef __WXMSW__
2039 // wxAUI hack: This is needed to explicietly set a docked pane size
2040 // Set MinSize to desired value, then call wxAuiPaneInfo::Fixed() to
2041 // apply it
2042 g_pauimgr->GetPane(cc).MinSize(ccw, cch);
2043 g_pauimgr->GetPane(cc).Fixed();
2044 g_pauimgr->Update();
2045
2046 //now make resizable again
2047 g_pauimgr->GetPane(cc).Resizable();
2049 //g_pauimgr->Update(); //Deferred
2050 //g_pauimgr->GetPane( cc ).BestSize( ccw, cch );
2051#endif
2052 }
2053#endif
2054
2055 break;
2056 }
2057}
2058
2059void MyFrame::OnIconize(wxIconizeEvent &event) {
2060#if 0
2061 if (g_MainToolbar) {
2062 g_MainToolbar->Show(!event.IsIconized());
2063 }
2064 if (g_iENCToolbar) {
2065 g_iENCToolbar->Show(!event.IsIconized());
2066 }
2067
2068 // .. for each canvas...
2069 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
2070 ChartCanvas *cc = g_canvasArray.Item(i);
2071 if (cc && cc->GetMUIBar()) {
2072 if (cc->GetMUIBar()->GetCanvasOptions()) {
2073 if (cc->GetMUIBar()->GetCanvasOptions()->IsShown()) {
2074 cc->GetMUIBar()->PushCanvasOptions(); // hide it
2075 }
2076 }
2077 }
2078 }
2079
2080#endif
2081}
2082
2083void MyFrame::OnSize(wxSizeEvent &event) { ODoSetSize(); }
2084
2085void MyFrame::ODoSetSize(void) {
2086 int x, y;
2087 GetClientSize(&x, &y);
2088 // Resize the children
2089
2090 if (m_pStatusBar != NULL) {
2091 m_StatusBarFieldCount = g_Platform->GetStatusBarFieldCount();
2092 int currentCount = m_pStatusBar->GetFieldsCount();
2093 if (currentCount != m_StatusBarFieldCount) {
2094 if ((currentCount > 0) && (currentCount < 7)) {
2095 // reset the widths very small to avoid auto-resizing of the frame
2096 // The sizes will be reset later in this method
2097 int widths[] = {2, 2, 2, 2, 2, 2};
2098 m_pStatusBar->SetStatusWidths(currentCount, widths);
2099 }
2100
2101 m_pStatusBar->SetFieldsCount(m_StatusBarFieldCount);
2102 }
2103
2104 if (m_StatusBarFieldCount) {
2105 // If the status bar layout is "complex", meaning more than two columns,
2106 // then use custom crafted relative widths for the fields.
2107 // Otherwise, just split the frame client width into equal spaces
2108
2109 if (m_StatusBarFieldCount > 2) {
2110 int widths[] = {-6, -5, -5, -6, -4};
2111 m_pStatusBar->SetStatusWidths(m_StatusBarFieldCount, widths);
2112 } else if (m_StatusBarFieldCount == 2) {
2113 int cwidth = x * 90 / 100;
2114 int widths[] = {100, 100};
2115 widths[0] = cwidth * 6.4 / 10.0;
2116 widths[1] = cwidth * 3.6 / 10.0;
2117 m_pStatusBar->SetStatusWidths(m_StatusBarFieldCount, widths);
2118 } else {
2119 int widths[] = {100, 100};
2120 widths[0] = x * 90 / 100;
2121 m_pStatusBar->SetStatusWidths(m_StatusBarFieldCount, widths);
2122 }
2123
2124 int styles[] = {wxSB_FLAT, wxSB_FLAT, wxSB_FLAT,
2125 wxSB_FLAT, wxSB_FLAT, wxSB_FLAT};
2126 m_pStatusBar->SetStatusStyles(m_StatusBarFieldCount, styles);
2127
2128 wxString sogcog(_T("SOG --- ") + getUsrSpeedUnit() + +_T(" ") +
2129 _T(" COG ---\u00B0"));
2130 m_pStatusBar->SetStatusText(sogcog, STAT_FIELD_SOGCOG);
2131 }
2132 }
2133
2134 if (m_pStatusBar) {
2135 // Maybe resize the font so the text fits in the boxes
2136
2137 wxRect stat_box;
2138 m_pStatusBar->GetFieldRect(0, stat_box);
2139 // maximum size is 1/28 of the box width, or the box height - whicever is
2140 // less
2141 int max_font_size = wxMin((stat_box.width / 28), (stat_box.height));
2142
2143 wxFont sys_font = *wxNORMAL_FONT;
2144 int try_font_size = sys_font.GetPointSize();
2145
2146#ifdef __WXOSX__
2147 int min_font_size = 10; // much less than 10pt is unreadably small on OS X
2148 try_font_size += 1; // default to 1pt larger than system UI font
2149#else
2150 int min_font_size =
2151 7; // on Win/Linux the text does not shrink quite so fast
2152 try_font_size += 2; // default to 2pt larger than system UI font
2153#endif
2154
2155 // get the user's preferred font, or if none set then the system default
2156 // with the size overridden
2157 wxFont *statusBarFont =
2158 FontMgr::Get().GetFont(_("StatusBar"), try_font_size);
2159 int font_size = statusBarFont->GetPointSize();
2160
2161 font_size = wxMin(font_size,
2162 max_font_size); // maximum to fit in the statusbar boxes
2163 font_size =
2164 wxMax(font_size, min_font_size); // minimum to stop it being unreadable
2165
2166#ifdef __ANDROID__
2167 font_size = statusBarFont->GetPointSize();
2168#endif
2169
2170 // Accomodate HDPI displays
2171 font_size /= OCPN_GetDisplayContentScaleFactor();
2172
2173 wxFont *pstat_font = FontMgr::Get().FindOrCreateFont(
2174 font_size, statusBarFont->GetFamily(), statusBarFont->GetStyle(),
2175 statusBarFont->GetWeight(), false, statusBarFont->GetFaceName());
2176
2177 int min_height = stat_box.height;
2178
2179 m_pStatusBar->SetFont(*pstat_font);
2180 m_pStatusBar->SetForegroundColour(
2181 FontMgr::Get().GetFontColor(_("StatusBar")));
2182#ifdef __ANDROID__
2183 min_height = (pstat_font->GetPointSize() * getAndroidDisplayDensity()) + 10;
2184 min_height =
2185 (min_height >> 1) * 2; // force even number, makes GLCanvas happier...
2186 m_pStatusBar->SetMinHeight(min_height);
2187// qDebug() <<"StatusBar min height:" << min_height << "StatusBar font
2188// points:" << pstat_font->GetPointSize();
2189#endif
2190 // wxString msg;
2191 // msg.Printf(_T("StatusBar min height: %d StatusBar font points:
2192 // %d"), min_height, pstat_font->GetPointSize()); wxLogMessage(msg);
2193 }
2194
2195 SetCanvasSizes(GetClientSize());
2196
2197 UpdateGPSCompassStatusBoxes(true);
2198
2199 if (console) PositionConsole();
2200
2201 // .. for each canvas...
2202 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
2203 ChartCanvas *cc = g_canvasArray.Item(i);
2204 if (cc) cc->FormatPianoKeys();
2205 }
2206
2207 // If global toolbar is shown, resize it...
2208 if (g_MainToolbar) {
2209 wxSize szBefore = g_MainToolbar->GetToolbarSize();
2210 g_MainToolbar->SetGeometry(GetPrimaryCanvas()->GetCompass()->IsShown(),
2211 GetPrimaryCanvas()->GetCompass()->GetRect());
2212 g_MainToolbar->Realize();
2213
2214 if (szBefore != g_MainToolbar->GetToolbarSize())
2215 g_MainToolbar->RefreshToolbar();
2216 }
2217
2218 // Update the stored window size
2219 GetSize(&x, &y);
2220 g_nframewin_x = x;
2221 g_nframewin_y = y;
2222
2223 // Inform the PlugIns
2224 if (g_pi_manager) g_pi_manager->SendResizeEventToAllPlugIns(x, y);
2225
2226 // Force redraw if in lookahead mode
2227 // TODO is this all right?
2228 // if( g_bLookAhead ) {
2229 // DoCOGSet();
2230 // DoChartUpdate();
2231 // }
2232
2233 // FIXME (dave) Thumbwins are gone...
2234 // if (pthumbwin) pthumbwin->SetMaxSize(GetClientSize());
2235
2236 // Reset the options dialog size logic
2237 options_lastWindowSize = wxSize(0, 0);
2238 options_lastWindowPos = wxPoint(0, 0);
2239
2240#ifdef __ANDROID__
2241 // If the options dialog is displayed, this will have the effect of
2242 // raising the dialog above the main and canvas-GUI toolbars.
2243 // If the dialog is not shown, no harm done
2244
2245 if (!b_inCloseWindow) {
2246 if (g_options) g_options->Raise();
2247
2248 resizeAndroidPersistents();
2249 }
2250
2251#endif
2252
2253 if (g_pauimgr) g_pauimgr->Update();
2254}
2255
2256void MyFrame::PositionConsole(void) {
2257 if (NULL == GetPrimaryCanvas()) return;
2258 // Reposition console based on its size and chartcanvas size
2259 int ccx, ccy, ccsx, ccsy, consx, consy;
2260 ChartCanvas *consoleHost = GetPrimaryCanvas();
2261 if (g_canvasConfig > 0) consoleHost = g_canvasArray[1];
2262
2263 if (consoleHost) {
2264 consoleHost->GetSize(&ccsx, &ccsy);
2265 consoleHost->GetPosition(&ccx, &ccy);
2266 } else {
2267 GetPrimaryCanvas()->GetSize(&ccsx, &ccsy);
2268 GetPrimaryCanvas()->GetPosition(&ccx, &ccy);
2269 consoleHost = GetPrimaryCanvas();
2270 }
2271
2272 int yOffset = 60;
2273 if (consoleHost) {
2274 if (consoleHost->GetCompass()) {
2275 wxRect compass_rect = consoleHost->GetCompass()->GetRect();
2276 // Compass is normal upper right position.
2277 if (compass_rect.y < 100)
2278 yOffset = compass_rect.y + compass_rect.height + 45;
2279 }
2280 }
2281
2282 console->GetSize(&consx, &consy);
2283
2284 wxPoint screen_pos =
2285 ClientToScreen(wxPoint(ccx + ccsx - consx - 2, ccy + yOffset));
2286 console->Move(screen_pos);
2287}
2288
2289void MyFrame::UpdateAllFonts() {
2290 if (console) {
2291 console->UpdateFonts();
2292 // Reposition console
2293 PositionConsole();
2294 }
2295
2296 // Close and destroy any persistent dialogs, so that new fonts will be
2297 // utilized
2298 DestroyPersistentDialogs();
2299
2300 if (pWayPointMan) pWayPointMan->ClearRoutePointFonts();
2301
2302 RefreshAllCanvas();
2303}
2304
2305void MyFrame::DestroyPersistentDialogs() {
2306 if (g_pais_query_dialog_active) {
2307 g_pais_query_dialog_active->Hide();
2308 g_pais_query_dialog_active->Destroy();
2309 g_pais_query_dialog_active = NULL;
2310 }
2311
2312 if (RoutePropDlgImpl::getInstanceFlag() && pRoutePropDialog) {
2313 pRoutePropDialog->Hide();
2314 pRoutePropDialog->Destroy();
2315 pRoutePropDialog = NULL;
2316 }
2317
2318 if (TrackPropDlg::getInstanceFlag() && pTrackPropDialog) {
2319 pTrackPropDialog->Hide();
2320 pTrackPropDialog->Destroy();
2321 pTrackPropDialog = NULL;
2322 }
2323
2324 if (g_pMarkInfoDialog) {
2325 g_pMarkInfoDialog->Hide();
2326 g_pMarkInfoDialog->Destroy();
2327 g_pMarkInfoDialog = NULL;
2328 }
2329
2330 if (g_pObjectQueryDialog) {
2331 g_pObjectQueryDialog->Hide();
2332 g_pObjectQueryDialog->Destroy();
2333 g_pObjectQueryDialog = NULL;
2334 }
2335}
2336
2337void MyFrame::RefreshGroupIndices(void) {
2338 // ..For each canvas...
2339 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
2340 ChartCanvas *cc = g_canvasArray.Item(i);
2341 if (cc) cc->canvasRefreshGroupIndex();
2342 }
2343}
2344
2345void MyFrame::OnToolLeftClick(wxCommandEvent &event) {
2346 if (g_MainToolbar) g_MainToolbar->HideTooltip();
2347
2348 switch (event.GetId()) {
2349 case ID_MENU_SCALE_OUT:
2350 DoStackDelta(GetPrimaryCanvas(), 1);
2351 DoChartUpdate();
2352 break;
2353
2354 case ID_MENU_SCALE_IN:
2355 DoStackDelta(GetPrimaryCanvas(), -1);
2356 DoChartUpdate();
2357 break;
2358
2359 case ID_MENU_ZOOM_IN: {
2360 if (GetFocusCanvas()) {
2361 GetFocusCanvas()->ZoomCanvas(g_plus_minus_zoom_factor, false);
2362 }
2363 break;
2364 }
2365
2366 case ID_MENU_ZOOM_OUT: {
2367 if (GetFocusCanvas()) {
2368 GetFocusCanvas()->ZoomCanvas(1.0 / g_plus_minus_zoom_factor, false);
2369 }
2370 break;
2371 }
2372
2373 case ID_MENU_ROUTE_NEW: {
2374 if (GetFocusCanvas()) {
2375 if (0 == GetFocusCanvas()->m_routeState) {
2376 GetFocusCanvas()->StartRoute();
2377 } else {
2378 GetFocusCanvas()->FinishRoute();
2379 }
2380 }
2381 break;
2382 }
2383
2384 case ID_MENU_TOOL_MEASURE: {
2385 GetPrimaryCanvas()->StartMeasureRoute();
2386 break;
2387 }
2388
2389 case ID_MENU_TOOL_NMEA_DBG_LOG:
2390 if (!wxWindow::FindWindowByName("NmeaDebugWindow")) {
2391 auto top_window = wxWindow::FindWindowByName(kTopLevelWindowName);
2392 NMEALogWindow::GetInstance().Create(top_window, 35);
2393 }
2394 wxWindow::FindWindowByName("NmeaDebugWindow")->Show();
2395 break;
2396
2397 case ID_MENU_MARK_BOAT: {
2398 DropMarker(true);
2399 break;
2400 }
2401
2402 case ID_MENU_MARK_CURSOR: {
2403 DropMarker(false);
2404 break;
2405 }
2406
2407 case ID_MENU_NAV_FOLLOW: {
2408 if (gFrame->GetPrimaryCanvas())
2409 gFrame->GetPrimaryCanvas()->TogglebFollow();
2410 break;
2411 }
2412
2413 case ID_MENU_CHART_OUTLINES: {
2414 ToggleChartOutlines(GetFocusCanvas());
2415 break;
2416 }
2417
2418 case ID_MENU_CHART_QUILTING: {
2419 ToggleQuiltMode(GetFocusCanvas());
2420 break;
2421 }
2422
2423 case ID_MENU_UI_CHARTBAR: {
2424 ToggleChartBar(GetFocusCanvas());
2425 break;
2426 }
2427
2428 case ID_MENU_ENC_TEXT:
2429 case ID_ENC_TEXT: {
2430 ToggleENCText(GetFocusCanvas());
2431 break;
2432 }
2433 case ID_MENU_ENC_LIGHTS: {
2434 ToggleLights(GetFocusCanvas());
2435 break;
2436 }
2437 case ID_MENU_ENC_SOUNDINGS: {
2438 ToggleSoundings(GetFocusCanvas());
2439 break;
2440 }
2441 case ID_MENU_ENC_ANCHOR: {
2442 ToggleAnchor(GetFocusCanvas());
2443 break;
2444 }
2445 case ID_MENU_ENC_DATA_QUALITY: {
2446 ToggleDataQuality(GetFocusCanvas());
2447 break;
2448 }
2449 case ID_MENU_SHOW_NAVOBJECTS: {
2450 ToggleNavobjects(GetFocusCanvas());
2451 break;
2452 }
2453
2454 case ID_MENU_AIS_TARGETS: {
2455 ToggleAISDisplay(GetFocusCanvas());
2456 break;
2457 }
2458 case ID_MENU_AIS_MOORED_TARGETS: {
2459 g_bHideMoored = !g_bHideMoored;
2460 break;
2461 }
2462 case ID_MENU_AIS_SCALED_TARGETS: {
2463 ToggleAISMinimizeTargets(GetFocusCanvas());
2464 break;
2465 }
2466
2467 case ID_MENU_AIS_TARGETLIST: {
2468 if (GetPrimaryCanvas()) GetPrimaryCanvas()->ShowAISTargetList();
2469 break;
2470 }
2471
2472 case ID_MENU_AIS_TRACKS: {
2473 g_bAISShowTracks = !g_bAISShowTracks;
2474 SetMenubarItemState(ID_MENU_AIS_TRACKS, g_bAISShowTracks);
2475 break;
2476 }
2477
2478 case ID_MENU_AIS_CPADIALOG: {
2479 g_bAIS_CPA_Alert = !g_bAIS_CPA_Alert;
2480 SetMenubarItemState(ID_MENU_AIS_CPADIALOG, g_bAIS_CPA_Alert);
2481 m_pMenuBar->Enable(ID_MENU_AIS_CPASOUND, g_bAIS_CPA_Alert);
2482 if (g_bAIS_CPA_Alert) {
2483 SetMenubarItemState(ID_MENU_AIS_CPASOUND, g_bAIS_CPA_Alert_Audio);
2484 }
2485 break;
2486 }
2487
2488 case ID_MENU_AIS_CPASOUND: {
2489 g_bAIS_CPA_Alert_Audio = !g_bAIS_CPA_Alert_Audio;
2490 SetMenubarItemState(ID_MENU_AIS_CPASOUND, g_bAIS_CPA_Alert_Audio);
2491 break;
2492 }
2493
2494 case ID_MENU_AIS_CPAWARNING: {
2495 if (GetPrimaryCanvas()) GetPrimaryCanvas()->ToggleCPAWarn();
2496 SetMenubarItemState(ID_MENU_AIS_CPAWARNING, g_bCPAWarn);
2497 break;
2498 }
2499
2500 case wxID_PREFERENCES:
2501 case ID_SETTINGS: {
2502 g_MainToolbar->HideTooltip();
2503 DoSettings();
2504 break;
2505 }
2506
2507 case ID_SETTINGS_NEW: {
2508 DoSettingsNew();
2509 break;
2510 }
2511
2512 case ID_SETTINGS_DELETE: {
2513 delete g_options;
2514 g_options = nullptr;
2515 break;
2516 }
2517
2518 case ID_MENU_SETTINGS_BASIC: {
2519#ifdef __ANDROID__
2521 androidDisableFullScreen();
2522 g_MainToolbar->HideTooltip();
2523 DoAndroidPreferences();
2524#else
2525 DoSettings();
2526#endif
2527 break;
2528 }
2529
2530 case ID_MENU_UI_FULLSCREEN: {
2531 ToggleFullScreen();
2532 break;
2533 }
2534
2535 case ID_MENU_SHOW_CURRENTS: {
2536 GetFocusCanvas()->ShowCurrents(!GetFocusCanvas()->GetbShowCurrent());
2537 GetFocusCanvas()->ReloadVP();
2538 GetFocusCanvas()->Refresh(false);
2539 break;
2540 }
2541
2542 case ID_MENU_SHOW_TIDES: {
2543 GetFocusCanvas()->ShowTides(!GetFocusCanvas()->GetbShowTide());
2544 GetFocusCanvas()->ReloadVP();
2545 GetFocusCanvas()->Refresh(false);
2546 break;
2547 }
2548
2549 case wxID_ABOUT:
2550 case ID_ABOUT: {
2551 g_Platform->DoHelpDialog();
2552 break;
2553 }
2554
2555 case wxID_HELP: {
2556 g_Platform->LaunchLocalHelp();
2557 break;
2558 }
2559
2560 case ID_PRINT: {
2561 DoPrint();
2562 break;
2563 }
2564
2565 case ID_MENU_UI_COLSCHEME:
2566 case ID_COLSCHEME: {
2567 ToggleColorScheme();
2568 break;
2569 }
2570
2571 case ID_TBEXIT: {
2572 Close();
2573 break;
2574 }
2575
2576 case ID_MENU_OQUIT: {
2577 Close();
2578 break;
2579 }
2580
2581 case ID_MENU_ROUTE_MANAGER:
2582 case ID_ROUTEMANAGER: {
2583 pRouteManagerDialog = RouteManagerDialog::getInstance(
2584 this); // There is one global instance of the Dialog
2585
2586 if (pRouteManagerDialog->IsShown())
2587 pRouteManagerDialog->Hide();
2588 else {
2589 pRouteManagerDialog->UpdateRouteListCtrl();
2590 pRouteManagerDialog->UpdateTrkListCtrl();
2591 pRouteManagerDialog->UpdateWptListCtrl();
2592 pRouteManagerDialog->UpdateLayListCtrl();
2593
2594 pRouteManagerDialog->Show();
2595
2596 // Required if RMDialog is not STAY_ON_TOP
2597#ifdef __WXOSX__
2598 pRouteManagerDialog->Centre();
2599 pRouteManagerDialog->Raise();
2600#endif
2601 }
2602 break;
2603 }
2604
2605 case ID_MENU_NAV_TRACK:
2606 case ID_TRACK: {
2607 if (!g_bTrackActive) {
2608 TrackOn();
2609 g_bTrackCarryOver = true;
2610 } else {
2611 TrackOff(true); // catch the last point
2612 if (pConfig && pConfig->IsChangesFileDirty()) {
2613 pConfig->UpdateNavObj(true);
2614 }
2615 g_bTrackCarryOver = false;
2616 RefreshAllCanvas(true);
2617 }
2618 break;
2619 }
2620
2621 case ID_MENU_CHART_NORTHUP: {
2622 SetUpMode(GetPrimaryCanvas(), NORTH_UP_MODE);
2623 break;
2624 }
2625 case ID_MENU_CHART_COGUP: {
2626 SetUpMode(GetPrimaryCanvas(), COURSE_UP_MODE);
2627 break;
2628 }
2629 case ID_MENU_CHART_HEADUP: {
2630 SetUpMode(GetPrimaryCanvas(), HEAD_UP_MODE);
2631 break;
2632 }
2633
2634 case ID_MENU_MARK_MOB:
2635 case ID_MOB: {
2636 ActivateMOB();
2637 break;
2638 }
2639
2640 case ID_MASTERTOGGLE: {
2641 if (g_MainToolbar) {
2642 wxString tip = _("Show Toolbar");
2643 if (!g_bmasterToolbarFull) tip = _("Hide Toolbar");
2644 if (g_MainToolbar->GetToolbar())
2645 g_MainToolbar->GetToolbar()->SetToolShortHelp(ID_MASTERTOGGLE, tip);
2646
2647 g_bmasterToolbarFull = !g_bmasterToolbarFull;
2648
2649#ifdef __WXOSX__
2650 if (g_bmasterToolbarFull)
2651 m_nMasterToolCountShown =
2652 g_MainToolbar->GetToolCount() -
2653 1; // TODO disable animation on OSX. Maybe use fade effect?
2654 else
2655 m_nMasterToolCountShown = 2;
2656#else
2657 m_nMasterToolCountShown =
2658 g_MainToolbar->GetToolShowCount(); // Current state
2659#endif
2660 ToolbarAnimateTimer.Start(10, wxTIMER_ONE_SHOT);
2661 }
2662 break;
2663 }
2664
2665 // Various command events coming from (usually) other threads,
2666 // used to control OCPN modes in a thread-safe way.
2667
2668 case ID_CMD_SELECT_CHART_TYPE: {
2669 selectChartDisplay(event.GetExtraLong(), -1);
2670 break;
2671 }
2672
2673 case ID_CMD_SELECT_CHART_FAMILY: {
2674 selectChartDisplay(-1, event.GetExtraLong());
2675 break;
2676 }
2677
2678 case ID_CMD_APPLY_SETTINGS: {
2679 applySettingsString(event.GetString());
2680#ifdef __ANDROID__
2681 androidRestoreFullScreen();
2682#endif
2683
2684 break;
2685 }
2686
2687 case ID_CMD_NULL_REFRESH: {
2688 Refresh(true);
2689 break;
2690 }
2691
2692 case ID_CMD_SETVP: {
2693 setStringVP(event.GetString());
2694 break;
2695 }
2696
2697 case ID_CMD_INVALIDATE: {
2698 InvalidateAllGL();
2699 Refresh(true);
2700 break;
2701 }
2702
2703 case ID_CMD_POST_JSON_TO_PLUGINS: {
2704 // Extract the Message ID which is embedded in the JSON string passed in
2705 // the event
2706 wxJSONValue root;
2707 wxJSONReader reader;
2708
2709 int numErrors = reader.Parse(event.GetString(), &root);
2710 if (numErrors == 0) {
2711 if (root[_T("MessageID")].IsString()) {
2712 wxString MsgID = root[_T("MessageID")].AsString();
2713 SendPluginMessage(MsgID, event.GetString()); // Send to all PlugIns
2714 }
2715 }
2716
2717 break;
2718 }
2719
2720 case ID_DENSITY:
2721 case ID_RMINUS:
2722 case ID_RPLUS: {
2723 if (g_iENCToolbar) {
2724 g_iENCToolbar->OnToolLeftClick(event);
2725 }
2726 break;
2727 }
2728
2729 default: {
2730 // Look for PlugIn tools
2731 // If found, make the callback.
2732 // TODO Modify this to allow multiple tools per plugin
2733 if (g_pi_manager) {
2734 g_MainToolbar->HideTooltip();
2735
2736 ArrayOfPlugInToolbarTools tool_array =
2737 g_pi_manager->GetPluginToolbarToolArray();
2738 for (unsigned int i = 0; i < tool_array.size(); i++) {
2739 PlugInToolbarToolContainer *pttc = tool_array[i];
2740 if (event.GetId() == pttc->id) {
2741 if (pttc->m_pplugin)
2742 pttc->m_pplugin->OnToolbarToolCallback(pttc->id);
2743 return; // required to prevent event.Skip() being called
2744 }
2745 }
2746 }
2747
2748 // If we didn't handle the event, allow it to bubble up to other handlers.
2749 // This is required for the system menu items (Hide, etc.) on OS X to
2750 // work. This must only be called if we did NOT handle the event,
2751 // otherwise it stops the menu items from working on Windows.
2752 event.Skip();
2753
2754 break;
2755 }
2756
2757 } // switch
2758
2759 // Finally, force a refresh of the main toolbar
2760 if (g_MainToolbar) g_MainToolbar->Realize();
2761}
2762
2763bool MyFrame::SetGlobalToolbarViz(bool viz) {
2764 bool viz_now = g_bmasterToolbarFull;
2765
2766 g_MainToolbar->HideTooltip();
2767 wxString tip = _("Show Toolbar");
2768 if (viz) {
2769 tip = _("Hide Toolbar");
2770 if (g_MainToolbar->GetToolbar())
2771 g_MainToolbar->GetToolbar()->SetToolShortHelp(ID_MASTERTOGGLE, tip);
2772 }
2773
2774 bool toggle = false;
2775 if (viz && !g_bmasterToolbarFull)
2776 toggle = true;
2777
2778 else if (!viz && g_bmasterToolbarFull)
2779 toggle = true;
2780
2781 if (toggle) {
2782 g_bmasterToolbarFull = !g_bmasterToolbarFull;
2783
2784#ifdef __WXOSX__
2785 if (g_bmasterToolbarFull)
2786 m_nMasterToolCountShown =
2787 g_MainToolbar->GetToolCount() -
2788 1; // TODO disable animation on OSX. Maybe use fade effect?
2789 else
2790 m_nMasterToolCountShown = 2;
2791#else
2792 m_nMasterToolCountShown =
2793 g_MainToolbar->GetToolShowCount(); // Current state
2794#endif
2795 ToolbarAnimateTimer.Start(10, wxTIMER_ONE_SHOT);
2796 }
2797
2798 return viz_now;
2799}
2800
2801void MyFrame::ScheduleDeleteSettingsDialog() {
2802 wxCommandEvent evt(wxEVT_COMMAND_MENU_SELECTED);
2803 evt.SetId(ID_SETTINGS_DELETE);
2804 GetEventHandler()->AddPendingEvent(evt);
2805}
2806
2807void MyFrame::ScheduleSettingsDialog() {
2808 wxCommandEvent evt(wxEVT_COMMAND_MENU_SELECTED);
2809 evt.SetId(ID_SETTINGS);
2810 GetEventHandler()->AddPendingEvent(evt);
2811}
2812
2813void MyFrame::ScheduleSettingsDialogNew() {
2814 wxCommandEvent evt(wxEVT_COMMAND_MENU_SELECTED);
2815 evt.SetId(ID_SETTINGS_NEW);
2816 GetEventHandler()->AddPendingEvent(evt);
2817}
2818
2819void MyFrame::ScheduleReconfigAndSettingsReload(bool reload, bool new_dialog) {
2820 UpdateCanvasConfigDescriptors();
2821
2822 if ((g_canvasConfig > 0) && (last_canvasConfig == 0))
2823 CreateCanvasLayout(true);
2824 else
2825 CreateCanvasLayout();
2826 SendSizeEvent();
2827 g_pauimgr->Update();
2828
2829 ConfigureStatusBar();
2830 wxSize lastOptSize = options_lastWindowSize;
2831 SendSizeEvent();
2832
2833 BuildMenuBar();
2834 SendSizeEvent();
2835 options_lastWindowSize = lastOptSize;
2836
2837 if (reload) {
2838 if (new_dialog)
2839 ScheduleSettingsDialogNew();
2840 else
2841 ScheduleSettingsDialog();
2842 }
2843}
2844
2845ChartCanvas *MyFrame::GetFocusCanvas() {
2846 if ((g_canvasConfig != 0) && g_focusCanvas) // multi-canvas?
2847 return g_focusCanvas;
2848 else
2849 return GetPrimaryCanvas();
2850}
2851
2852void MyFrame::OnToolbarAnimateTimer(wxTimerEvent &event) {
2853 if (g_bmasterToolbarFull) {
2854#ifndef OCPN_TOOLBAR_ANIMATE
2855 m_nMasterToolCountShown = (int)g_MainToolbar->GetToolCount();
2856#endif
2857
2858 if (m_nMasterToolCountShown < (int)g_MainToolbar->GetToolCount()) {
2859 m_nMasterToolCountShown++;
2860 g_MainToolbar->SetToolShowCount(m_nMasterToolCountShown);
2861 g_MainToolbar->Realize();
2862 g_MainToolbar->RefreshToolbar();
2863
2864 ToolbarAnimateTimer.Start(20, wxTIMER_ONE_SHOT);
2865 } else {
2866 g_MainToolbar->SetToolShowCount(m_nMasterToolCountShown);
2867 g_MainToolbar->GetToolbar()->InvalidateBitmaps();
2868 g_MainToolbar->Realize();
2869 g_MainToolbar->RefreshToolbar();
2870 }
2871 } else {
2872#ifndef OCPN_TOOLBAR_ANIMATE
2873 m_nMasterToolCountShown = 1;
2874#endif
2875 if (m_nMasterToolCountShown > 1) {
2876 m_nMasterToolCountShown--;
2877 g_MainToolbar->SetToolShowCount(m_nMasterToolCountShown);
2878 g_MainToolbar->Realize();
2879 g_MainToolbar->RefreshToolbar();
2880 ToolbarAnimateTimer.Start(10, wxTIMER_ONE_SHOT);
2881 } else {
2882 g_MainToolbar->SetToolShowCount(m_nMasterToolCountShown);
2883 g_MainToolbar->GetToolbar()->InvalidateBitmaps();
2884 g_MainToolbar->Realize();
2885 g_MainToolbar->RefreshToolbar();
2886 }
2887 }
2888}
2889
2890void MyFrame::InvalidateAllGL() {
2891#ifdef ocpnUSE_GL
2892 // For each canvas
2893 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
2894 ChartCanvas *cc = g_canvasArray.Item(i);
2895 if (cc) {
2896 cc->InvalidateGL();
2897 cc->Refresh();
2898 }
2899 }
2900#endif
2901}
2902
2903void MyFrame::RefreshAllCanvas(bool bErase) {
2904 // For each canvas
2905 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
2906 ChartCanvas *cc = g_canvasArray.Item(i);
2907 if (cc) {
2908 cc->Refresh(bErase);
2909 }
2910 }
2911}
2912
2913void MyFrame::setStringVP(wxString VPS) {
2914 ChartCanvas *cc = GetPrimaryCanvas();
2915
2916 if (!cc) return;
2917
2918 wxStringTokenizer tkz(VPS, _T(";"));
2919
2920 wxString token = tkz.GetNextToken();
2921 double lat = gLat;
2922 token.ToDouble(&lat);
2923
2924 token = tkz.GetNextToken();
2925 double lon = gLon;
2926 token.ToDouble(&lon);
2927
2928 token = tkz.GetNextToken();
2929 double scale_ppm = cc->GetVP().view_scale_ppm;
2930 token.ToDouble(&scale_ppm);
2931
2932 cc->SetViewPoint(lat, lon, scale_ppm, 0, cc->GetVPRotation());
2933}
2934
2935void MyFrame::DoSettingsNew() {
2936 delete g_options;
2937 g_options = nullptr;
2938
2939 DoSettings();
2940}
2941
2942void MyFrame::DoSettings() {
2943 DoOptionsDialog();
2944
2945 // Apply various system settings
2946 ApplyGlobalSettings(true);
2947
2948 // ..For each canvas...
2949 bool b_loadHarmonics = false;
2950 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
2951 ChartCanvas *cc = g_canvasArray.Item(i);
2952 if (cc) {
2953 if (cc->GetbShowCurrent() || cc->GetbShowTide()) b_loadHarmonics = true;
2954 }
2955 }
2956 if (b_loadHarmonics) LoadHarmonics();
2957
2958 // The chart display options may have changed, especially on S57 ENC,
2959 // So, flush the cache and redraw
2960 ReloadAllVP();
2961}
2962
2963void MyFrame::ToggleChartBar(ChartCanvas *cc) {
2964 g_bShowChartBar = !g_bShowChartBar;
2965
2966 if (g_bShowChartBar) cc->m_brepaint_piano = true;
2967
2968 cc->ReloadVP(); // needed to set VP.pix_height
2969 Refresh();
2970
2971 if (g_bShowChartBar) {
2972 DoChartUpdate();
2973 UpdateControlBar(cc);
2974 }
2975
2976 SetMenubarItemState(ID_MENU_UI_CHARTBAR, g_bShowChartBar);
2977}
2978
2979void MyFrame::ToggleColorScheme() {
2980 static bool lastIsNight;
2981 ColorScheme s = GetColorScheme();
2982 int is = (int)s;
2983 is++;
2984 if (lastIsNight && is == 3) // Back from step 3
2985 {
2986 is = 1;
2987 lastIsNight = false;
2988 } // Goto to Day
2989 if (lastIsNight) is = 2; // Back to Dusk on step 3
2990 if (is == 3) lastIsNight = true; // Step 2 Night
2991 s = (ColorScheme)is;
2992 if (s == N_COLOR_SCHEMES) s = GLOBAL_COLOR_SCHEME_RGB;
2993
2994 SetAndApplyColorScheme(s);
2995}
2996
2997void MyFrame::ToggleFullScreen() {
2998 bool to = !IsFullScreen();
2999
3000#ifdef __WXOSX__
3001 ShowFullScreen(to);
3002#else
3003 long style = wxFULLSCREEN_NOBORDER | wxFULLSCREEN_NOCAPTION;
3004 ; // | wxFULLSCREEN_NOMENUBAR;
3005 ShowFullScreen(to, style);
3006#endif
3007
3008 UpdateAllToolbars(global_color_scheme);
3009 // SurfaceAllCanvasToolbars();
3010 UpdateControlBar(GetPrimaryCanvas());
3011 Layout();
3012 TriggerRecaptureTimer();
3013}
3014
3015void MyFrame::ActivateMOB(void) {
3016 // The MOB point
3017 wxDateTime mob_time = wxDateTime::Now();
3018 wxString mob_label(_("MAN OVERBOARD"));
3019 mob_label += _(" on ");
3020 mob_label += ocpn::toUsrDateTimeFormat(mob_time);
3021
3022 RoutePoint *pWP_MOB =
3023 new RoutePoint(gLat, gLon, _T ( "mob" ), mob_label, wxEmptyString);
3024 pWP_MOB->SetShared(true);
3025 pWP_MOB->m_bIsolatedMark = true;
3026 pWP_MOB->SetWaypointArrivalRadius(
3027 -1.0); // Negative distance is code to signal "Never Arrive"
3028 pWP_MOB->SetUseSca(false); // Do not use scaled hiding for MOB
3029 pSelect->AddSelectableRoutePoint(gLat, gLon, pWP_MOB);
3030 pConfig->AddNewWayPoint(pWP_MOB, -1); // use auto next num
3031
3032 if (bGPSValid && !std::isnan(gCog) && !std::isnan(gSog)) {
3033 // Create a point that is one mile along the present course
3034 double zlat, zlon;
3035 ll_gc_ll(gLat, gLon, gCog, 1.0, &zlat, &zlon);
3036
3037 RoutePoint *pWP_src =
3038 new RoutePoint(zlat, zlon, g_default_wp_icon,
3039 wxString(_("1.0 NM along COG")), wxEmptyString);
3040 pSelect->AddSelectableRoutePoint(zlat, zlon, pWP_src);
3041
3042 Route *temp_route = new Route();
3043 pRouteList->Append(temp_route);
3044
3045 temp_route->AddPoint(pWP_src);
3046 temp_route->AddPoint(pWP_MOB);
3047
3048 pSelect->AddSelectableRouteSegment(gLat, gLon, zlat, zlon, pWP_src, pWP_MOB,
3049 temp_route);
3050
3051 temp_route->m_RouteNameString = _("Temporary MOB Route");
3052 temp_route->m_RouteStartString = _("Assumed 1 Mile Point");
3053 ;
3054 temp_route->m_RouteEndString = mob_label;
3055
3056 temp_route->m_bDeleteOnArrival = false;
3057
3058 temp_route->SetRouteArrivalRadius(-1.0); // never arrives
3059
3060 if (g_pRouteMan->GetpActiveRoute()) g_pRouteMan->DeactivateRoute();
3061 g_pRouteMan->ActivateRoute(temp_route, pWP_MOB);
3062
3063 wxJSONValue v;
3064 v[_T("GUID")] = temp_route->m_GUID;
3065 wxString msg_id(_T("OCPN_MAN_OVERBOARD"));
3066 SendJSONMessageToAllPlugins(msg_id, v);
3067 }
3068
3069 if (RouteManagerDialog::getInstanceFlag()) {
3070 if (pRouteManagerDialog && pRouteManagerDialog->IsShown()) {
3071 pRouteManagerDialog->UpdateRouteListCtrl();
3072 pRouteManagerDialog->UpdateWptListCtrl();
3073 }
3074 }
3075
3076 InvalidateAllGL();
3077 RefreshAllCanvas(false);
3078
3079 wxString mob_message(_("MAN OVERBOARD"));
3080 mob_message += _(" Time: ");
3081 mob_message += ocpn::toUsrDateTimeFormat(mob_time);
3082 mob_message += _(" Position: ");
3083 mob_message += toSDMM(1, gLat);
3084 mob_message += _T(" ");
3085 mob_message += toSDMM(2, gLon);
3086 wxLogMessage(mob_message);
3087}
3088void MyFrame::TrackOn(void) {
3089 g_bTrackActive = true;
3090 g_pActiveTrack = new ActiveTrack();
3091
3092 g_TrackList.push_back(g_pActiveTrack);
3093 if (pConfig) pConfig->AddNewTrack(g_pActiveTrack);
3094
3095 g_pActiveTrack->Start();
3096
3097 // The main toolbar may still be NULL here, and we will do nothing...
3098 SetMasterToolbarItemState(ID_TRACK, g_bTrackActive);
3099 if (g_MainToolbar)
3100 g_MainToolbar->SetToolShortHelp(ID_TRACK, _("Disable Tracking"));
3101
3102 SetMenubarItemState(ID_MENU_NAV_TRACK, g_bTrackActive);
3103
3104#ifdef __ANDROID__
3105 androidSetTrackTool(true);
3106#endif
3107
3108 if (RouteManagerDialog::getInstanceFlag()) {
3109 if (pRouteManagerDialog && pRouteManagerDialog->IsShown()) {
3110 pRouteManagerDialog->UpdateTrkListCtrl();
3111 pRouteManagerDialog->UpdateRouteListCtrl();
3112 }
3113 }
3114
3115 wxJSONValue v;
3116 wxDateTime now;
3117 now = now.Now().ToUTC();
3118 wxString name = g_pActiveTrack->GetName();
3119 if (name.IsEmpty()) {
3120 TrackPoint *tp = g_pActiveTrack->GetPoint(0);
3121 if (tp->GetCreateTime().IsValid())
3122 name = tp->GetCreateTime().FormatISODate() + _T(" ") +
3123 tp->GetCreateTime().FormatISOTime();
3124 else
3125 name = _("(Unnamed Track)");
3126 }
3127 v[_T("Name")] = name;
3128 v[_T("GUID")] = g_pActiveTrack->m_GUID;
3129 wxString msg_id(_T("OCPN_TRK_ACTIVATED"));
3130 SendJSONMessageToAllPlugins(msg_id, v);
3131 g_FlushNavobjChangesTimeout =
3132 30; // Every thirty seconds, consider flushing navob changes
3133}
3134
3135Track *MyFrame::TrackOff(bool do_add_point) {
3136 Track *return_val = g_pActiveTrack;
3137
3138 if (g_pActiveTrack) {
3139 wxJSONValue v;
3140 wxString msg_id(_T("OCPN_TRK_DEACTIVATED"));
3141 v[_T("GUID")] = g_pActiveTrack->m_GUID;
3142 SendJSONMessageToAllPlugins(msg_id, v);
3143
3144 g_pActiveTrack->Stop(do_add_point);
3145
3146 if (g_pActiveTrack->GetnPoints() < 2) {
3147 RoutemanGui(*g_pRouteMan).DeleteTrack(g_pActiveTrack);
3148 return_val = NULL;
3149 } else {
3150 if (g_bTrackDaily) {
3151 Track *pExtendTrack = g_pActiveTrack->DoExtendDaily();
3152 if (pExtendTrack) {
3153 RoutemanGui(*g_pRouteMan).DeleteTrack(g_pActiveTrack);
3154 return_val = pExtendTrack;
3155 }
3156 }
3157 }
3158 g_pActiveTrack = NULL;
3159 }
3160
3161 g_bTrackActive = false;
3162
3163 if (RouteManagerDialog::getInstanceFlag()) {
3164 if (pRouteManagerDialog && pRouteManagerDialog->IsShown()) {
3165 pRouteManagerDialog->UpdateTrkListCtrl();
3166 pRouteManagerDialog->UpdateRouteListCtrl();
3167 }
3168 }
3169
3170 SetMasterToolbarItemState(ID_TRACK, g_bTrackActive);
3171 if (g_MainToolbar)
3172 g_MainToolbar->SetToolShortHelp(ID_TRACK, _("Enable Tracking"));
3173 SetMenubarItemState(ID_MENU_NAV_TRACK, g_bTrackActive);
3174
3175#ifdef __ANDROID__
3176 androidSetTrackTool(false);
3177#endif
3178
3179 g_FlushNavobjChangesTimeout =
3180 600; // Revert to checking/flushing navob changes every 5 minutes
3181
3182 return return_val;
3183}
3184
3185bool MyFrame::ShouldRestartTrack(void) {
3186 if (!g_pActiveTrack || !g_bTrackDaily) return false;
3187 time_t now = wxDateTime::Now().GetTicks();
3188 time_t today = wxDateTime::Today().GetTicks();
3189 int rotate_at = 0;
3190 switch (g_track_rotate_time_type) {
3191 case TIME_TYPE_LMT:
3192 rotate_at = g_track_rotate_time + wxRound(gLon * 3600. / 15.);
3193 break;
3194 case TIME_TYPE_COMPUTER:
3195 rotate_at = g_track_rotate_time;
3196 break;
3197 case TIME_TYPE_UTC:
3198 int utc_offset =
3199 wxDateTime::Now().GetTicks() - wxDateTime::Now().ToUTC().GetTicks();
3200 rotate_at = g_track_rotate_time + utc_offset;
3201 break;
3202 }
3203 if (rotate_at > 86400)
3204 rotate_at -= 86400;
3205 else if (rotate_at < 0)
3206 rotate_at += 86400;
3207 if (now >= m_last_track_rotation_ts + 86400 - 3600 &&
3208 now - today >= rotate_at) {
3209 if (m_last_track_rotation_ts == 0) {
3210 if (now - today > rotate_at)
3211 m_last_track_rotation_ts = today + rotate_at;
3212 else
3213 m_last_track_rotation_ts = today + rotate_at - 86400;
3214 return false;
3215 }
3216 m_last_track_rotation_ts = now;
3217 return true;
3218 }
3219 return false;
3220}
3221
3222void MyFrame::TrackDailyRestart(void) {
3223 if (!g_pActiveTrack) return;
3224
3225 Track *pPreviousTrack = TrackOff(true);
3226 if (pConfig && pConfig->IsChangesFileDirty()) {
3227 pConfig->UpdateNavObj(true);
3228 }
3229
3230 TrackOn();
3231
3232 // Set the restarted track's current state such that the current track
3233 // point's attributes match the attributes of the last point of the track
3234 // that was just stopped at midnight.
3235
3236 if (pPreviousTrack) {
3237 TrackPoint *pMidnightPoint = pPreviousTrack->GetLastPoint();
3238 g_pActiveTrack->AdjustCurrentTrackPoint(pMidnightPoint);
3239 }
3240
3241 if (RouteManagerDialog::getInstanceFlag()) {
3242 if (pRouteManagerDialog && pRouteManagerDialog->IsShown()) {
3243 pRouteManagerDialog->UpdateTrkListCtrl();
3244 pRouteManagerDialog->UpdateRouteListCtrl();
3245 }
3246 }
3247}
3248
3249void MyFrame::SetUpMode(ChartCanvas *cc, int mode) {
3250 if (cc) {
3251 cc->SetUpMode(mode);
3252
3253 SetMenubarItemState(ID_MENU_CHART_COGUP, mode == COURSE_UP_MODE);
3254 SetMenubarItemState(ID_MENU_CHART_NORTHUP, mode == NORTH_UP_MODE);
3255 SetMenubarItemState(ID_MENU_CHART_HEADUP, mode == HEAD_UP_MODE);
3256
3257 if (m_pMenuBar)
3258 m_pMenuBar->SetLabel(ID_MENU_CHART_NORTHUP, _("North Up Mode"));
3259 }
3260}
3261
3262void MyFrame::ToggleENCText(ChartCanvas *cc) {
3263 cc->SetShowENCText(!cc->GetShowENCText());
3264
3265 SetMenubarItemState(ID_MENU_ENC_TEXT, cc->GetShowENCText());
3266
3267 // if(g_pi_manager)
3268 // g_pi_manager->SendConfigToAllPlugIns();
3269
3270 ReloadAllVP();
3271}
3272
3273void MyFrame::SetENCDisplayCategory(ChartCanvas *cc, enum _DisCat nset) {
3274 if (ps52plib) {
3275 if (cc) {
3276 cc->SetENCDisplayCategory(nset);
3277
3278 UpdateGlobalMenuItems();
3279
3280 /* if(g_pi_manager)
3281 g_pi_manager->SendConfigToAllPlugIns();
3282 */
3283 ReloadAllVP();
3284 }
3285 }
3286}
3287
3288void MyFrame::ToggleSoundings(ChartCanvas *cc) {
3289 cc->SetShowENCDepth(!cc->GetShowENCDepth());
3290
3291 SetMenubarItemState(ID_MENU_ENC_SOUNDINGS, cc->GetShowENCDepth());
3292
3293 // if(g_pi_manager)
3294 // g_pi_manager->SendConfigToAllPlugIns();
3295
3296 ReloadAllVP();
3297}
3298
3299bool MyFrame::ToggleLights(ChartCanvas *cc) {
3300 cc->SetShowENCLights(!cc->GetShowENCLights());
3301
3302 SetMenubarItemState(ID_MENU_ENC_LIGHTS, cc->GetShowENCLights());
3303
3304 if (g_pi_manager) g_pi_manager->SendS52ConfigToAllPlugIns(true);
3305
3306 ReloadAllVP();
3307
3308 return true;
3309}
3310
3311#if 0
3312void MyFrame::ToggleRocks( void )
3313{
3314 if( ps52plib ) {
3315 int vis = 0;
3316 // Need to loop once for UWTROC, which is our "master", then for
3317 // other categories, since order is unknown?
3318 for( unsigned int iPtr = 0; iPtr < ps52plib->pOBJLArray->GetCount(); iPtr++ ) {
3319 OBJLElement *pOLE = (OBJLElement *) ( ps52plib->pOBJLArray->Item( iPtr ) );
3320 if( !strncmp( pOLE->OBJLName, "UWTROC", 6 ) ) {
3321 pOLE->nViz = !pOLE->nViz;
3322 vis = pOLE->nViz;
3323 }
3324 }
3325 for( unsigned int iPtr = 0; iPtr < ps52plib->pOBJLArray->GetCount(); iPtr++ ) {
3326 OBJLElement *pOLE = (OBJLElement *) ( ps52plib->pOBJLArray->Item( iPtr ) );
3327 if( !strncmp( pOLE->OBJLName, "OBSTRN", 6 ) ) {
3328 pOLE->nViz = vis;
3329 }
3330 if( !strncmp( pOLE->OBJLName, "WRECKS", 6 ) ) {
3331 pOLE->nViz = vis;
3332 }
3333 }
3334 ps52plib->GenerateStateHash();
3335 ReloadAllVP();
3336 }
3337}
3338#endif
3339
3340void MyFrame::ToggleAnchor(ChartCanvas *cc) {
3341 cc->SetShowENCAnchor(!cc->GetShowENCAnchor());
3342
3343 SetMenubarItemState(ID_MENU_ENC_ANCHOR, cc->GetShowENCAnchor());
3344
3345 if (g_pi_manager) g_pi_manager->SendS52ConfigToAllPlugIns();
3346
3347 ReloadAllVP();
3348}
3349
3350void MyFrame::ToggleDataQuality(ChartCanvas *cc) {
3351 cc->SetShowENCDataQual(!cc->GetShowENCDataQual());
3352
3353 SetMenubarItemState(ID_MENU_ENC_DATA_QUALITY, cc->GetShowENCDataQual());
3354
3355 if (g_pi_manager) g_pi_manager->SendS52ConfigToAllPlugIns();
3356
3357 ReloadAllVP();
3358}
3359
3360void MyFrame::TogglebFollow(ChartCanvas *cc) {
3361 if (!cc->m_bFollow)
3362 SetbFollow(cc);
3363 else
3364 ClearbFollow(cc);
3365}
3366
3367void MyFrame::ToggleNavobjects(ChartCanvas *cc) {
3368 cc->m_bShowNavobjects = !cc->m_bShowNavobjects;
3369 SetMenubarItemState(ID_MENU_SHOW_NAVOBJECTS, cc->m_bShowNavobjects);
3370 cc->Refresh();
3371}
3372
3373void MyFrame::ToggleAISDisplay(ChartCanvas *cc) {
3374 cc->SetShowAIS(!cc->GetShowAIS());
3375 SetMenubarItemState(ID_MENU_AIS_TARGETS, cc->GetShowAIS());
3376 cc->Refresh();
3377}
3378
3379void MyFrame::ToggleAISMinimizeTargets(ChartCanvas *cc) {
3380 cc->SetAttenAIS(!cc->GetAttenAIS());
3381 SetMenubarItemState(ID_MENU_AIS_SCALED_TARGETS, cc->GetAttenAIS());
3382 cc->Refresh();
3383}
3384
3385void MyFrame::SetbFollow(ChartCanvas *cc) {
3386 JumpToPosition(cc, gLat, gLon, cc->GetVPScale());
3387 cc->m_bFollow = true;
3388
3389 // cc->SetCanvasToolbarItemState(ID_FOLLOW, true);
3390 SetMenubarItemState(ID_MENU_NAV_FOLLOW, true);
3391
3392 DoChartUpdate();
3393 cc->ReloadVP();
3394 SetChartUpdatePeriod();
3395}
3396
3397void MyFrame::ClearbFollow(ChartCanvas *cc) {
3398 // Center the screen on the GPS position, for lack of a better place
3399 vLat = gLat;
3400 vLon = gLon;
3401
3402 cc->m_bFollow = false;
3403 // cc->SetCanvasToolbarItemState(ID_FOLLOW, false);
3404 SetMenubarItemState(ID_MENU_NAV_FOLLOW, false);
3405
3406 DoChartUpdate();
3407 cc->ReloadVP();
3408 SetChartUpdatePeriod();
3409}
3410
3411void MyFrame::ToggleChartOutlines(ChartCanvas *cc) {
3412 cc->SetShowOutlines(!cc->GetShowOutlines());
3413
3414 RefreshAllCanvas(false);
3415
3416#ifdef ocpnUSE_GL // opengl renders chart outlines as part of the chart this
3417 // needs a full refresh
3418 if (g_bopengl) InvalidateAllGL();
3419#endif
3420
3421 SetMenubarItemState(ID_MENU_CHART_OUTLINES, cc->GetShowOutlines());
3422}
3423
3424void MyFrame::ToggleTestPause(void) { g_bPauseTest = !g_bPauseTest; }
3425
3426void MyFrame::SetMenubarItemState(int item_id, bool state) {
3427 if (m_pMenuBar) {
3428 bool enabled = m_pMenuBar->IsEnabled(item_id);
3429 m_pMenuBar->Enable(item_id, false);
3430 m_pMenuBar->Check(item_id, state);
3431 m_pMenuBar->Enable(item_id, enabled);
3432 }
3433}
3434
3435void MyFrame::SetMasterToolbarItemState(int tool_id, bool state) {
3436 if (g_MainToolbar && g_MainToolbar->GetToolbar()) {
3437 g_MainToolbar->GetToolbar()->ToggleTool(tool_id, state);
3438 g_MainToolbar->Realize();
3439 }
3440}
3441
3442void MyFrame::SetToolbarItemBitmaps(int tool_id, wxBitmap *bmp,
3443 wxBitmap *bmpRollover) {
3444 if (g_MainToolbar && g_MainToolbar->GetToolbar()) {
3445 g_MainToolbar->GetToolbar()->SetToolBitmaps(tool_id, bmp, bmpRollover);
3446 g_MainToolbar->Realize();
3447 }
3448}
3449
3450void MyFrame::SetToolbarItemSVG(int tool_id, wxString normalSVGfile,
3451 wxString rolloverSVGfile,
3452 wxString toggledSVGfile) {
3453 if (g_MainToolbar && g_MainToolbar->GetToolbar()) {
3454 g_MainToolbar->GetToolbar()->SetToolBitmapsSVG(
3455 tool_id, normalSVGfile, rolloverSVGfile, toggledSVGfile);
3456 }
3457}
3458
3459void MyFrame::ConfigureStatusBar() {
3460 // ShowDebugWindow as a wxStatusBar
3461 m_StatusBarFieldCount = g_Platform->GetStatusBarFieldCount();
3462
3463#ifdef __WXMSW__
3464 UseNativeStatusBar(false); // better for MSW, undocumented in frame.cpp
3465#endif
3466
3467 if (g_bShowStatusBar) {
3468 if (!m_pStatusBar) {
3469 m_pStatusBar =
3470 CreateStatusBar(m_StatusBarFieldCount, 0); // No wxST_SIZEGRIP needed
3471 ApplyGlobalColorSchemetoStatusBar();
3472 }
3473
3474 } else {
3475 if (m_pStatusBar) {
3476 m_pStatusBar->Destroy();
3477 m_pStatusBar = NULL;
3478 SetStatusBar(NULL);
3479 }
3480 }
3481}
3482
3483void MyFrame::ApplyGlobalSettings(bool bnewtoolbar) {
3484 ConfigureStatusBar();
3485
3486 wxSize lastOptSize = options_lastWindowSize;
3487 SendSizeEvent();
3488
3489 BuildMenuBar();
3490
3491 SendSizeEvent();
3492 options_lastWindowSize = lastOptSize;
3493
3494 if (bnewtoolbar) UpdateAllToolbars(global_color_scheme);
3495}
3496
3497wxString _menuText(wxString name, wxString shortcut) {
3498 wxString menutext;
3499 menutext << name;
3500#ifndef __ANDROID__
3501 menutext << _T("\t") << shortcut;
3502#endif
3503 return menutext;
3504}
3505
3506void MyFrame::BuildMenuBar(void) {
3507 /*
3508 * Menu Bar - add or remove it if necessary, and update the state of the menu
3509 * items
3510 */
3511#ifdef __WXOSX__
3512 bool showMenuBar = true; // the menu bar is always visible in OS X
3513#else
3514 bool showMenuBar = g_bShowMenuBar; // get visibility from options
3515
3516 if (!showMenuBar &&
3517 g_bTempShowMenuBar) // allows pressing alt to temporarily show
3518 showMenuBar = true;
3519#endif
3520
3521 if (showMenuBar) {
3522 // Menu bar has some dependencies on S52 PLIB, so be sure it is loaded.
3523 LoadS57();
3524
3525 if (!m_pMenuBar) { // add the menu bar if it is enabled
3526 m_pMenuBar = new wxMenuBar();
3527 RegisterGlobalMenuItems();
3528 SetMenuBar(m_pMenuBar); // must be after RegisterGlobalMenuItems for wx
3529 // to populate the OS X App Menu correctly
3530 }
3531
3532 UpdateGlobalMenuItems(); // update the state of the menu items (checkmarks
3533 // etc.)
3534 } else {
3535 if (m_pMenuBar) { // remove the menu bar if it is disabled
3536 SetMenuBar(NULL);
3537 m_pMenuBar->Destroy();
3538 m_pMenuBar = NULL;
3539 }
3540 }
3541}
3542
3543void MyFrame::RegisterGlobalMenuItems() {
3544 if (!m_pMenuBar) return; // if there isn't a menu bar
3545
3546 wxMenu *nav_menu = new wxMenu();
3547 nav_menu->AppendCheckItem(ID_MENU_NAV_FOLLOW,
3548 _menuText(_("Auto Follow"), _T("Ctrl-A")));
3549 nav_menu->AppendCheckItem(ID_MENU_NAV_TRACK, _("Enable Tracking"));
3550 nav_menu->AppendSeparator();
3551 nav_menu->AppendRadioItem(ID_MENU_CHART_NORTHUP, _("North Up Mode"));
3552 nav_menu->AppendRadioItem(ID_MENU_CHART_COGUP, _("Course Up Mode"));
3553 nav_menu->AppendRadioItem(ID_MENU_CHART_HEADUP, _("Head Up Mode"));
3554 nav_menu->AppendSeparator();
3555#ifndef __WXOSX__
3556 nav_menu->Append(ID_MENU_ZOOM_IN, _menuText(_("Zoom In"), _T("+")));
3557 nav_menu->Append(ID_MENU_ZOOM_OUT, _menuText(_("Zoom Out"), _T("-")));
3558#else
3559 nav_menu->Append(ID_MENU_ZOOM_IN, _menuText(_("Zoom In"), _T("Alt-+")));
3560 nav_menu->Append(ID_MENU_ZOOM_OUT, _menuText(_("Zoom Out"), _T("Alt--")));
3561#endif
3562 nav_menu->AppendSeparator();
3563 nav_menu->Append(ID_MENU_SCALE_IN,
3564 _menuText(_("Larger Scale Chart"), _T("Ctrl-Left")));
3565 nav_menu->Append(ID_MENU_SCALE_OUT,
3566 _menuText(_("Smaller Scale Chart"), _T("Ctrl-Right")));
3567#ifndef __WXOSX__
3568 nav_menu->AppendSeparator();
3569 nav_menu->Append(ID_MENU_OQUIT, _menuText(_("Exit OpenCPN"), _T("Ctrl-Q")));
3570#endif
3571 m_pMenuBar->Append(nav_menu, _("&Navigate"));
3572
3573 wxMenu *view_menu = new wxMenu();
3574#ifndef __WXOSX__
3575 view_menu->AppendCheckItem(ID_MENU_CHART_QUILTING,
3576 _menuText(_("Enable Chart Quilting"), _T("Q")));
3577 view_menu->AppendCheckItem(ID_MENU_CHART_OUTLINES,
3578 _menuText(_("Show Chart Outlines"), _T("O")));
3579#else
3580 view_menu->AppendCheckItem(
3581 ID_MENU_CHART_QUILTING,
3582 _menuText(_("Enable Chart Quilting"), _T("Alt-Q")));
3583 view_menu->AppendCheckItem(ID_MENU_CHART_OUTLINES,
3584 _menuText(_("Show Chart Outlines"), _T("Alt-O")));
3585#endif
3586 view_menu->AppendCheckItem(ID_MENU_UI_CHARTBAR,
3587 _menuText(_("Show Chart Bar"), _T("Ctrl-B")));
3588
3589 view_menu->AppendSeparator();
3590#ifndef __WXOSX__
3591 view_menu->AppendCheckItem(ID_MENU_ENC_TEXT,
3592 _menuText(_("Show ENC text"), _T("T")));
3593 view_menu->AppendCheckItem(ID_MENU_ENC_LIGHTS,
3594 _menuText(_("Show ENC Lights"), _T("L")));
3595 view_menu->AppendCheckItem(ID_MENU_ENC_SOUNDINGS,
3596 _menuText(_("Show ENC Soundings"), _T("S")));
3597 view_menu->AppendCheckItem(ID_MENU_ENC_ANCHOR,
3598 _menuText(_("Show ENC Anchoring Info"), _T("A")));
3599 view_menu->AppendCheckItem(ID_MENU_ENC_DATA_QUALITY,
3600 _menuText(_("Show ENC Data Quality"), _T("U")));
3601 view_menu->AppendCheckItem(ID_MENU_SHOW_NAVOBJECTS,
3602 _menuText(_("Show Navobjects"), _T("V")));
3603#else
3604 view_menu->AppendCheckItem(ID_MENU_ENC_TEXT,
3605 _menuText(_("Show ENC text"), _T("Alt-T")));
3606 view_menu->AppendCheckItem(ID_MENU_ENC_LIGHTS,
3607 _menuText(_("Show ENC Lights"), _T("Alt-L")));
3608 view_menu->AppendCheckItem(ID_MENU_ENC_SOUNDINGS,
3609 _menuText(_("Show ENC Soundings"), _T("Alt-S")));
3610 view_menu->AppendCheckItem(
3611 ID_MENU_ENC_ANCHOR, _menuText(_("Show ENC Anchoring Info"), _T("Alt-A")));
3612 view_menu->AppendCheckItem(
3613 ID_MENU_ENC_DATA_QUALITY,
3614 _menuText(_("Show ENC Data Quality"), _T("Alt-U")));
3615 view_menu->AppendCheckItem(ID_MENU_SHOW_NAVOBJECTS,
3616 _menuText(_("Show Navobjects"), _T("Alt-V")));
3617#endif
3618 view_menu->AppendSeparator();
3619 view_menu->AppendCheckItem(ID_MENU_SHOW_TIDES, _("Show Tides"));
3620 view_menu->AppendCheckItem(ID_MENU_SHOW_CURRENTS, _("Show Currents"));
3621 view_menu->AppendSeparator();
3622#ifndef __WXOSX__
3623 view_menu->Append(ID_MENU_UI_COLSCHEME,
3624 _menuText(_("Change Color Scheme"), _T("C")));
3625#else
3626 view_menu->Append(ID_MENU_UI_COLSCHEME,
3627 _menuText(_("Change Color Scheme"), _T("Alt-C")));
3628#endif
3629
3630 view_menu->AppendSeparator();
3631#ifndef __WXOSX__
3632 view_menu->Append(ID_MENU_UI_FULLSCREEN,
3633 _menuText(_("Toggle Full Screen"), _T("F11")));
3634#endif
3635 m_pMenuBar->Append(view_menu, _("&View"));
3636
3637 wxMenu *ais_menu = new wxMenu();
3638 ais_menu->AppendCheckItem(ID_MENU_AIS_TARGETS, _("Show AIS Targets"));
3639 ais_menu->AppendCheckItem(ID_MENU_AIS_SCALED_TARGETS,
3640 _("Attenuate less critical AIS targets"));
3641 ais_menu->AppendSeparator();
3642 ais_menu->AppendCheckItem(ID_MENU_AIS_MOORED_TARGETS,
3643 _("Hide Moored AIS Targets"));
3644 ais_menu->AppendCheckItem(ID_MENU_AIS_TRACKS, _("Show AIS Target Tracks"));
3645 ais_menu->AppendCheckItem(ID_MENU_AIS_CPADIALOG, _("Show CPA Alert Dialogs"));
3646 ais_menu->AppendCheckItem(ID_MENU_AIS_CPASOUND, _("Sound CPA Alarms"));
3647
3648#ifndef __WXOSX__
3649 ais_menu->AppendCheckItem(ID_MENU_AIS_CPAWARNING,
3650 _menuText(_("Show CPA Warnings"), _T("W")));
3651#else
3652 ais_menu->AppendCheckItem(ID_MENU_AIS_CPAWARNING,
3653 _menuText(_("Show CPA Warnings"), _T("Alt-W")));
3654#endif
3655
3656 ais_menu->AppendSeparator();
3657 ais_menu->Append(ID_MENU_AIS_TARGETLIST, _("AIS target list") + _T("..."));
3658 m_pMenuBar->Append(ais_menu, _("&AIS"));
3659
3660 wxMenu *tools_menu = new wxMenu();
3661 tools_menu->Append(ID_MENU_TOOL_NMEA_DBG_LOG,
3662 _menuText(_("NMEA Debugger"), "Alt-C"));
3663#ifndef __WXOSX__
3664 tools_menu->Append(ID_MENU_TOOL_MEASURE,
3665 _menuText(_("Measure Distance"), _T("M")));
3666#else
3667 tools_menu->Append(ID_MENU_TOOL_MEASURE,
3668 _menuText(_("Measure Distance"), _T("Alt-M")));
3669#endif
3670
3671 tools_menu->AppendSeparator();
3672 tools_menu->Append(ID_MENU_ROUTE_MANAGER, _("Route && Mark Manager..."));
3673 tools_menu->Append(ID_MENU_ROUTE_NEW,
3674 _menuText(_("Create Route"), _T("Ctrl-R")));
3675 tools_menu->AppendSeparator();
3676 tools_menu->Append(ID_MENU_MARK_BOAT,
3677 _menuText(_("Drop Mark at Boat"), _T("Ctrl-O")));
3678 tools_menu->Append(ID_MENU_MARK_CURSOR,
3679 _menuText(_("Drop Mark at Cursor"), _T("Ctrl-M")));
3680 tools_menu->AppendSeparator();
3681#ifdef __WXOSX__
3682 tools_menu->Append(
3683 ID_MENU_MARK_MOB,
3684 _menuText(
3685 _("Drop MOB Marker"),
3686 _T("RawCtrl-Space"))); // NOTE Cmd+Space is reserved for Spotlight
3687 tools_menu->AppendSeparator();
3688 tools_menu->Append(wxID_PREFERENCES,
3689 _menuText(_("Preferences") + _T("..."), _T("Ctrl-,")));
3690#else
3691 tools_menu->Append(ID_MENU_MARK_MOB,
3692 _menuText(_("Drop MOB Marker"), _T("Ctrl-Space")));
3693 tools_menu->AppendSeparator();
3694 tools_menu->Append(wxID_PREFERENCES,
3695 _menuText(_("Options") + _T("..."), _T("Ctrl-,")));
3696#endif
3697 m_pMenuBar->Append(tools_menu, _("&Tools"));
3698
3699#ifdef __WXOSX__
3700 wxMenu *window_menu = new wxMenu();
3701 m_pMenuBar->Append(window_menu, _("&Window"));
3702#endif
3703
3704 wxMenu *help_menu = new wxMenu();
3705 help_menu->Append(wxID_ABOUT, _("About OpenCPN"));
3706 help_menu->Append(wxID_HELP, _("OpenCPN Help"));
3707 m_pMenuBar->Append(help_menu, _("&Help"));
3708
3709 // Set initial values for menu check items and radio items
3710 UpdateGlobalMenuItems();
3711}
3712
3713void MyFrame::UpdateGlobalMenuItems() {
3714 if (!m_pMenuBar) return; // if there isn't a menu bar
3715
3716 m_pMenuBar->FindItem(ID_MENU_NAV_FOLLOW)
3717 ->Check(GetPrimaryCanvas()->m_bFollow);
3718 m_pMenuBar->FindItem(ID_MENU_CHART_NORTHUP)
3719 ->Check(GetPrimaryCanvas()->GetUpMode() == NORTH_UP_MODE);
3720 m_pMenuBar->FindItem(ID_MENU_CHART_COGUP)
3721 ->Check(GetPrimaryCanvas()->GetUpMode() == COURSE_UP_MODE);
3722 m_pMenuBar->FindItem(ID_MENU_CHART_HEADUP)
3723 ->Check(GetPrimaryCanvas()->GetUpMode() == HEAD_UP_MODE);
3724 m_pMenuBar->FindItem(ID_MENU_NAV_TRACK)->Check(g_bTrackActive);
3725 m_pMenuBar->FindItem(ID_MENU_CHART_OUTLINES)->Check(g_bShowOutlines);
3726 m_pMenuBar->FindItem(ID_MENU_CHART_QUILTING)->Check(g_bQuiltEnable);
3727 m_pMenuBar->FindItem(ID_MENU_UI_CHARTBAR)->Check(g_bShowChartBar);
3728 m_pMenuBar->FindItem(ID_MENU_AIS_TARGETS)->Check(g_bShowAIS);
3729 m_pMenuBar->FindItem(ID_MENU_AIS_MOORED_TARGETS)->Check(g_bHideMoored);
3730 m_pMenuBar->FindItem(ID_MENU_AIS_SCALED_TARGETS)->Check(g_bShowScaled);
3731 m_pMenuBar->FindItem(ID_MENU_AIS_SCALED_TARGETS)->Enable(g_bAllowShowScaled);
3732 m_pMenuBar->FindItem(ID_MENU_AIS_TRACKS)->Check(g_bAISShowTracks);
3733 m_pMenuBar->FindItem(ID_MENU_AIS_CPADIALOG)->Check(g_bAIS_CPA_Alert);
3734 if (g_bAIS_CPA_Alert) {
3735 m_pMenuBar->FindItem(ID_MENU_AIS_CPASOUND)->Check(g_bAIS_CPA_Alert_Audio);
3736 m_pMenuBar->Enable(ID_MENU_AIS_CPASOUND, true);
3737 } else {
3738 m_pMenuBar->FindItem(ID_MENU_AIS_CPASOUND)->Check(false);
3739 m_pMenuBar->Enable(ID_MENU_AIS_CPASOUND, false);
3740 }
3741
3742 m_pMenuBar->FindItem(ID_MENU_AIS_CPAWARNING)->Check(g_bCPAWarn);
3743 m_pMenuBar->FindItem(ID_MENU_SHOW_NAVOBJECTS)
3744 ->Check(GetPrimaryCanvas()->m_bShowNavobjects);
3745
3746 if (ps52plib) {
3747 m_pMenuBar->FindItem(ID_MENU_ENC_TEXT)->Check(ps52plib->GetShowS57Text());
3748 m_pMenuBar->FindItem(ID_MENU_ENC_SOUNDINGS)
3749 ->Check(ps52plib->GetShowSoundings());
3750
3751 bool light_state = false;
3752 if (ps52plib) {
3753 for (unsigned int iPtr = 0; iPtr < ps52plib->pOBJLArray->GetCount();
3754 iPtr++) {
3755 OBJLElement *pOLE = (OBJLElement *)(ps52plib->pOBJLArray->Item(iPtr));
3756 if (!strncmp(pOLE->OBJLName, "LIGHTS", 6)) {
3757 light_state = (pOLE->nViz == 1);
3758 break;
3759 }
3760 }
3761 }
3762 m_pMenuBar->FindItem(ID_MENU_ENC_LIGHTS)
3763 ->Check((!ps52plib->IsObjNoshow("LIGHTS")) && light_state);
3764
3765 // Menu "Anchor Info" entry is only accessible in "All" or "User Standard"
3766 // categories
3767 DisCat nset = ps52plib->GetDisplayCategory();
3768 if ((nset == MARINERS_STANDARD) || (nset == OTHER)) {
3769 m_pMenuBar->FindItem(ID_MENU_ENC_ANCHOR)
3770 ->Check(!ps52plib->IsObjNoshow("SBDARE"));
3771 m_pMenuBar->Enable(ID_MENU_ENC_ANCHOR, true);
3772 m_pMenuBar->FindItem(ID_MENU_ENC_DATA_QUALITY)
3773 ->Check(!ps52plib->IsObjNoshow("M_QUAL"));
3774 m_pMenuBar->Enable(ID_MENU_ENC_DATA_QUALITY, true);
3775 } else {
3776 m_pMenuBar->FindItem(ID_MENU_ENC_ANCHOR)->Check(false);
3777 m_pMenuBar->Enable(ID_MENU_ENC_ANCHOR, false);
3778 m_pMenuBar->Enable(ID_MENU_ENC_DATA_QUALITY, false);
3779 }
3780 }
3781}
3782
3783void MyFrame::UpdateGlobalMenuItems(ChartCanvas *cc) {
3784 if (!m_pMenuBar) return; // if there isn't a menu bar
3785
3786 m_pMenuBar->FindItem(ID_MENU_NAV_FOLLOW)->Check(cc->m_bFollow);
3787
3788 if (cc->GetUpMode() == NORTH_UP_MODE)
3789 m_pMenuBar->FindItem(ID_MENU_CHART_NORTHUP)->Check(true);
3790 else if (cc->GetUpMode() == COURSE_UP_MODE)
3791 m_pMenuBar->FindItem(ID_MENU_CHART_COGUP)->Check(true);
3792 else
3793 m_pMenuBar->FindItem(ID_MENU_CHART_HEADUP)->Check(true);
3794
3795 m_pMenuBar->FindItem(ID_MENU_NAV_TRACK)->Check(g_bTrackActive);
3796 m_pMenuBar->FindItem(ID_MENU_CHART_OUTLINES)->Check(cc->GetShowOutlines());
3797 m_pMenuBar->FindItem(ID_MENU_CHART_QUILTING)->Check(cc->GetQuiltMode());
3798 m_pMenuBar->FindItem(ID_MENU_UI_CHARTBAR)->Check(cc->GetShowChartbar());
3799 m_pMenuBar->FindItem(ID_MENU_AIS_TARGETS)->Check(cc->GetShowAIS());
3800 m_pMenuBar->FindItem(ID_MENU_AIS_MOORED_TARGETS)->Check(g_bHideMoored);
3801 m_pMenuBar->FindItem(ID_MENU_AIS_SCALED_TARGETS)->Check(cc->GetAttenAIS());
3802 m_pMenuBar->FindItem(ID_MENU_AIS_SCALED_TARGETS)->Enable(g_bAllowShowScaled);
3803 m_pMenuBar->FindItem(ID_MENU_AIS_TRACKS)->Check(g_bAISShowTracks);
3804 m_pMenuBar->FindItem(ID_MENU_AIS_CPADIALOG)->Check(g_bAIS_CPA_Alert);
3805 m_pMenuBar->FindItem(ID_MENU_AIS_CPASOUND)->Check(g_bAIS_CPA_Alert_Audio);
3806 m_pMenuBar->FindItem(ID_MENU_AIS_CPAWARNING)->Check(g_bCPAWarn);
3807 m_pMenuBar->FindItem(ID_MENU_SHOW_NAVOBJECTS)->Check(cc->m_bShowNavobjects);
3808 m_pMenuBar->FindItem(ID_MENU_SHOW_TIDES)->Check(cc->GetbShowTide());
3809 m_pMenuBar->FindItem(ID_MENU_SHOW_CURRENTS)->Check(cc->GetbShowCurrent());
3810
3811 if (ps52plib) {
3812 m_pMenuBar->FindItem(ID_MENU_ENC_TEXT)->Check(cc->GetShowENCText());
3813 m_pMenuBar->FindItem(ID_MENU_ENC_SOUNDINGS)->Check(cc->GetShowENCDepth());
3814
3815 if (ps52plib) {
3816 for (unsigned int iPtr = 0; iPtr < ps52plib->pOBJLArray->GetCount();
3817 iPtr++) {
3818 OBJLElement *pOLE = (OBJLElement *)(ps52plib->pOBJLArray->Item(iPtr));
3819 if (!strncmp(pOLE->OBJLName, "LIGHTS", 6)) {
3820 break;
3821 }
3822 }
3823 }
3824 m_pMenuBar->FindItem(ID_MENU_ENC_LIGHTS)->Check(cc->GetShowENCLights());
3825
3826 // Menu "Anchor Info" entry is only accessible in "All" or "UserStandard"
3827 // categories
3828 DisCat nset = (DisCat)cc->GetENCDisplayCategory();
3829 if ((nset == MARINERS_STANDARD) || (nset == OTHER)) {
3830 m_pMenuBar->FindItem(ID_MENU_ENC_ANCHOR)->Check(cc->GetShowENCAnchor());
3831 m_pMenuBar->Enable(ID_MENU_ENC_ANCHOR, true);
3832 m_pMenuBar->FindItem(ID_MENU_ENC_DATA_QUALITY)
3833 ->Check(cc->GetShowENCDataQual());
3834 m_pMenuBar->Enable(ID_MENU_ENC_DATA_QUALITY, true);
3835 } else {
3836 m_pMenuBar->FindItem(ID_MENU_ENC_ANCHOR)->Check(false);
3837 m_pMenuBar->Enable(ID_MENU_ENC_ANCHOR, false);
3838 m_pMenuBar->Enable(ID_MENU_ENC_DATA_QUALITY, false);
3839 }
3840 }
3841}
3842
3843void MyFrame::InvalidateAllCanvasUndo() {
3844 // .. for each canvas...
3845 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
3846 ChartCanvas *cc = g_canvasArray.Item(i);
3847 if (cc) cc->undo->InvalidateUndo();
3848 }
3849}
3850#if 0
3851void MyFrame::SubmergeAllCanvasToolbars(void) {
3852 // .. for each canvas...
3853 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
3854 ChartCanvas *cc = g_canvasArray.Item(i);
3855 if (cc) cc->SubmergeToolbar();
3856 }
3857}
3858
3859void MyFrame::SurfaceAllCanvasToolbars(void) {
3860 if (g_bshowToolbar) {
3861 // .. for each canvas...
3862 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
3863 ChartCanvas *cc = g_canvasArray.Item(i);
3864 if (cc && cc->GetToolbarEnable()) cc->SurfaceToolbar();
3865 }
3866 }
3867
3868}
3869#endif
3870
3871void MyFrame::JumpToPosition(ChartCanvas *cc, double lat, double lon,
3872 double scale) {
3873 if (lon > 180.0) lon -= 360.0;
3874 // XXX is vLat/vLon always equal to cc m_vLat, m_vLon after SetViewPoint? Does
3875 // it matter?
3876 vLat = lat;
3877 vLon = lon;
3878 cc->JumpToPosition(lat, lon, scale);
3879
3880 if (g_pi_manager) {
3881 g_pi_manager->SendViewPortToRequestingPlugIns(cc->GetVP());
3882 }
3883}
3884
3885void MyFrame::UpdateCanvasConfigDescriptors() {
3886 // ..For each canvas...
3887 for (unsigned int i = 0;
3888 i < ConfigMgr::Get().GetCanvasConfigArray().GetCount(); i++) {
3889 canvasConfig *cc = ConfigMgr::Get().GetCanvasConfigArray().Item(i);
3890 if (cc) {
3891 ChartCanvas *chart = cc->canvas;
3892 if (chart) {
3893 cc->iLat = chart->GetVP().clat;
3894 cc->iLon = chart->GetVP().clon;
3895 cc->iRotation = chart->GetVP().rotation;
3896 cc->iScale = chart->GetVP().view_scale_ppm;
3897 cc->DBindex = chart->GetQuiltReferenceChartIndex();
3898 cc->GroupID = chart->m_groupIndex;
3899 cc->canvasSize = chart->GetSize();
3900
3901 cc->bQuilt = chart->GetQuiltMode();
3902 cc->bShowTides = chart->GetbShowTide();
3903 cc->bShowCurrents = chart->GetbShowCurrent();
3904 cc->bShowGrid = chart->GetShowGrid();
3905 cc->bShowOutlines = chart->GetShowOutlines();
3906 cc->bShowDepthUnits = chart->GetShowDepthUnits();
3907
3908 cc->bFollow = chart->m_bFollow;
3909 cc->bLookahead = chart->m_bLookAhead;
3910 cc->bCourseUp = false;
3911 cc->bHeadUp = false;
3912 ;
3913 int upmode = chart->GetUpMode();
3914 if (upmode == COURSE_UP_MODE)
3915 cc->bCourseUp = true;
3916 else if (upmode == HEAD_UP_MODE)
3917 cc->bHeadUp = true;
3918 }
3919 }
3920 }
3921}
3922
3923void MyFrame::CenterView(ChartCanvas *cc, const LLBBox &RBBox) {
3924 if (!RBBox.GetValid()) return;
3925 // Calculate bbox center
3926 double clat = (RBBox.GetMinLat() + RBBox.GetMaxLat()) / 2;
3927 double clon = (RBBox.GetMinLon() + RBBox.GetMaxLon()) / 2;
3928 double ppm; // final ppm scale to use
3929
3930 if (RBBox.GetMinLat() == RBBox.GetMaxLat() &&
3931 RBBox.GetMinLon() == RBBox.GetMaxLon()) {
3932 // only one point, (should be a box?)
3933 ppm = cc->GetVPScale();
3934 } else {
3935 // Calculate ppm
3936 double rw, rh; // route width, height
3937 int ww, wh; // chart window width, height
3938 // route bbox width in nm
3939 DistanceBearingMercator(RBBox.GetMinLat(), RBBox.GetMinLon(),
3940 RBBox.GetMinLat(), RBBox.GetMaxLon(), NULL, &rw);
3941 // route bbox height in nm
3942 DistanceBearingMercator(RBBox.GetMinLat(), RBBox.GetMinLon(),
3943 RBBox.GetMaxLat(), RBBox.GetMinLon(), NULL, &rh);
3944
3945 cc->GetSize(&ww, &wh);
3946
3947 ppm = wxMin(ww / (rw * 1852), wh / (rh * 1852)) * (100 - fabs(clat)) / 90;
3948
3949 ppm = wxMin(ppm, 1.0);
3950 }
3951
3952 JumpToPosition(cc, clat, clon, ppm);
3953}
3954
3955void MyFrame::PrepareOptionsClose(options *settings,
3956 int settings_return_value) {
3957 // Capture som values from options dialog before closure
3958 options_lastPage = settings->lastPage;
3959#ifdef __ANDROID__
3960 // This is necessary to force a manual change to charts page,
3961 // in order to properly refresh the chart directory list.
3962 // Root cause: In Android, trouble with clearing the wxScrolledWindow
3963 if (options_lastPage == 1) options_lastPage = 0;
3964#endif
3965 options_subpage = settings->lastSubPage;
3966 options_lastWindowPos = settings->lastWindowPos;
3967 options_lastWindowSize = settings->lastWindowSize;
3968
3969#ifdef __ANDROID__
3970 androidEnableBackButton(true);
3971 androidEnableOptionsMenu(true);
3972 androidRestoreFullScreen();
3973 androidEnableRotation();
3974#endif
3975
3976#if 0 // Maybe, TODO
3977 // If needed, refresh each canvas,
3978 // trying to reload the previously displayed chart by name as saved in
3979 // pathArray Also, restoring the previous chart VPScale, if possible
3980 if (b_refresh) {
3981 // ..For each canvas...
3982 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
3983 ChartCanvas *cc = g_canvasArray.Item(i);
3984 if (cc) {
3985 int index_hint = -1;
3986 if (i < pathArray.GetCount())
3987 index_hint = ChartData->FinddbIndex(pathArray.Item(i));
3988 cc->canvasChartsRefresh(index_hint);
3989 if (index_hint != -1) cc->SetVPScale(restoreScale[i]);
3990 }
3991 }
3992 }
3993#endif
3994}
3995
3996void MyFrame::DoOptionsDialog() {
3997 if (NULL == g_options) {
3998 AbstractPlatform::ShowBusySpinner();
3999
4000 int sx, sy;
4001 pConfig->SetPath("/Settings");
4002 pConfig->Read("OptionsSizeX", &sx, -1);
4003 pConfig->Read("OptionsSizeY", &sy, -1);
4004
4005 wxWindow *optionsParent = this;
4006#ifdef __WXOSX__
4007 optionsParent = GetPrimaryCanvas();
4008#endif
4009 g_options = new options(optionsParent, -1, _("Options"), wxPoint(-1, -1),
4010 wxSize(sx, sy));
4011
4012 AbstractPlatform::HideBusySpinner();
4013 }
4014
4015 // Set initial Chart Dir
4016 g_options->SetInitChartDir(*pInit_Chart_Dir);
4017
4018 // Pass two working pointers for Chart Dir Dialog
4019 g_options->SetCurrentDirList(ChartData->GetChartDirArray());
4020 ArrayOfCDI *pWorkDirArray = new ArrayOfCDI;
4021 g_options->SetWorkDirListPtr(pWorkDirArray);
4022
4023 // Pass a ptr to MyConfig, for updates
4024 g_options->SetConfigPtr(pConfig);
4025 g_options->SetInitialSettings();
4026
4027 prev_locale = g_locale;
4028 g_options->SetInitialPage(options_lastPage, options_subpage);
4029
4030#ifndef __ANDROID__ // if(!g_bresponsive){
4031 g_options->lastWindowPos = options_lastWindowPos;
4032 if (options_lastWindowPos != wxPoint(0, 0)) {
4033 g_options->Move(options_lastWindowPos);
4034 g_options->SetSize(options_lastWindowSize);
4035 } else {
4036 g_options->CenterOnScreen();
4037 }
4038 if (options_lastWindowSize != wxSize(0, 0)) {
4039 g_options->SetSize(options_lastWindowSize);
4040 }
4041#endif
4042
4043#ifdef __ANDROID__
4044 androidEnableBackButton(false);
4045 androidEnableOptionsMenu(false);
4046 androidDisableFullScreen();
4047#endif
4048
4049 // Capture the full path names and VPScale of charts currently shown in all
4050 // canvases
4051 pathArray.Clear();
4052 // ..For each canvas...
4053 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
4054 ChartCanvas *cc = g_canvasArray.Item(i);
4055 if (cc) {
4056 wxString chart_file_name;
4057 if (cc->GetQuiltMode()) {
4058 int dbi = cc->GetQuiltRefChartdbIndex();
4059 chart_file_name = ChartData->GetDBChartFileName(dbi);
4060 } else {
4061 if (cc->m_singleChart)
4062 chart_file_name = cc->m_singleChart->GetFullPath();
4063 }
4064
4065 pathArray.Add(chart_file_name);
4066 restoreScale[i] = cc->GetVPScale();
4067 }
4068 }
4069
4070 // Record current canvas config
4071 last_canvasConfig = g_canvasConfig;
4072
4073 // Record current chart scale factor
4074 g_last_ChartScaleFactor = g_ChartScaleFactor;
4075
4076 g_options->Show();
4077 return;
4078}
4079
4080void MyFrame::ProcessOptionsDialog(int rr, ArrayOfCDI *pNewDirArray) {
4081 bool b_need_refresh = false; // Do we need a full reload?
4082
4083 if ((rr & VISIT_CHARTS) &&
4084 ((rr & CHANGE_CHARTS) || (rr & FORCE_UPDATE) || (rr & SCAN_UPDATE))) {
4085 if (pNewDirArray) {
4086 UpdateChartDatabaseInplace(*pNewDirArray,
4087 ((rr & FORCE_UPDATE) == FORCE_UPDATE), true,
4088 ChartListFileName);
4089
4090 b_need_refresh = true;
4091 }
4092 }
4093
4094 if (rr & STYLE_CHANGED) {
4095 OCPNMessageBox(
4096 NULL,
4097 _("Please restart OpenCPN to activate language or style changes."),
4098 _("OpenCPN Info"), wxOK | wxICON_INFORMATION);
4099 }
4100
4101 bool b_groupchange = false;
4102 if (((rr & VISIT_CHARTS) &&
4103 ((rr & CHANGE_CHARTS) || (rr & FORCE_UPDATE) || (rr & SCAN_UPDATE))) ||
4104 (rr & GROUPS_CHANGED)) {
4105 b_groupchange = ScrubGroupArray();
4106 ChartData->ApplyGroupArray(g_pGroupArray);
4107 RefreshGroupIndices();
4108 }
4109
4110 if (rr & GROUPS_CHANGED || b_groupchange) {
4111 pConfig->DestroyConfigGroups();
4112 pConfig->CreateConfigGroups(g_pGroupArray);
4113 }
4114
4115 if (rr & TIDES_CHANGED) {
4116 LoadHarmonics();
4117 }
4118
4119 // S52_CHANGED is a byproduct of a change in the chart object render scale
4120 // So, applies to RoutePoint icons also
4121 if (rr & S52_CHANGED) {
4122 WayPointmanGui(*pWayPointMan).ReloadAllIcons(g_Platform->GetDisplayDPmm());
4123 }
4124
4125 pConfig->UpdateSettings();
4126
4127 if (g_pActiveTrack) {
4128 g_pActiveTrack->SetPrecision(g_nTrackPrecision);
4129 }
4130
4131 // reload pens and brushes
4132 g_pRouteMan->SetColorScheme(global_color_scheme,
4133 g_Platform->GetDisplayDPmm());
4134
4135 // Stuff the Filter tables
4136 double stuffcog = NAN;
4137 double stuffsog = NAN;
4138 if (!std::isnan(gCog)) stuffcog = gCog;
4139 if (!std::isnan(gSog)) stuffsog = gSog;
4140
4141 for (int i = 0; i < MAX_COGSOG_FILTER_SECONDS; i++) {
4142 COGFilterTable[i] = stuffcog;
4143 SOGFilterTable[i] = stuffsog;
4144 }
4145
4146 SetChartUpdatePeriod(); // Pick up changes to skew compensator
4147
4148 if (rr & GL_CHANGED) {
4149 // Refresh the chart display, after flushing cache.
4150 // This will allow all charts to recognise new OpenGL configuration, if
4151 // any
4152 b_need_refresh = true;
4153 }
4154
4155 if (rr & S52_CHANGED) {
4156 b_need_refresh = true;
4157 }
4158
4159#ifdef ocpnUSE_GL
4160 if (rr & REBUILD_RASTER_CACHE) {
4161 if (g_glTextureManager) {
4162 GetPrimaryCanvas()->Disable();
4163 g_glTextureManager->BuildCompressedCache();
4164 GetPrimaryCanvas()->Enable();
4165 }
4166 }
4167#endif
4168
4169 if (g_config_display_size_manual &&
4170 g_config_display_size_mm.size() > g_current_monitor &&
4171 g_config_display_size_mm[g_current_monitor] > 0) {
4172 g_display_size_mm = g_config_display_size_mm[g_current_monitor];
4173 } else {
4174 g_display_size_mm = wxMax(50, g_Platform->GetDisplaySizeMM());
4175 }
4176
4177 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
4178 ChartCanvas *cc = g_canvasArray.Item(i);
4179 if (cc) cc->SetDisplaySizeMM(g_display_size_mm);
4180 }
4181
4182 if (g_pi_manager) {
4183 g_pi_manager->SendBaseConfigToAllPlugIns();
4184 int rrt = rr & S52_CHANGED;
4185 g_pi_manager->SendS52ConfigToAllPlugIns(
4186 (rrt == S52_CHANGED) ||
4187 (g_last_ChartScaleFactor != g_ChartScaleFactor));
4188 }
4189
4190 if (g_MainToolbar) {
4191 g_MainToolbar->SetAutoHide(g_bAutoHideToolbar);
4192 g_MainToolbar->SetAutoHideTimer(g_nAutoHideToolbar);
4193 }
4194
4195 // update S52 PLIB scale factors
4196 if (ps52plib) {
4197 ps52plib->SetScaleFactorExp(
4198 g_Platform->GetChartScaleFactorExp(g_ChartScaleFactor));
4199 ps52plib->SetScaleFactorZoomMod(g_chart_zoom_modifier_vector);
4200 }
4201
4202 // Apply any needed updates to each canvas
4203 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
4204 ChartCanvas *cc = g_canvasArray.Item(i);
4205 if (cc) cc->ApplyGlobalSettings();
4206 }
4207
4208 // Do a full Refresh, trying to open the last open chart
4209// TODO This got move up a level. FIX ANDROID codepath
4210#if 0
4211 if(b_need_refresh){
4212 int index_hint = ChartData->FinddbIndex( chart_file_name );
4213 if( -1 == index_hint )
4214 b_autofind = true;
4215 ChartsRefresh( );
4216 }
4217#endif
4218
4219 // The zoom-scale factor may have changed
4220 // so, trigger a recalculation of the reference chart
4221 bool ztc = g_bEnableZoomToCursor; // record the present state
4222 g_bEnableZoomToCursor =
4223 false; // since we don't want to pan to an unknown cursor position
4224
4225 // This is needed to recognise changes in zoom-scale factors
4226 GetPrimaryCanvas()->DoZoomCanvas(1.0001);
4227 g_bEnableZoomToCursor = ztc;
4228
4229 // Pick up chart object icon size changes (g_ChartScaleFactorExp)
4230 if (g_last_ChartScaleFactor != g_ChartScaleFactor) {
4231 if (g_pMarkInfoDialog) {
4232 g_pMarkInfoDialog->Hide();
4233 g_pMarkInfoDialog->Destroy();
4234 g_pMarkInfoDialog = NULL;
4235 }
4236 }
4237
4238 // We set the compass size
4239 SetGPSCompassScale();
4240 // ..For each canvas...
4241 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
4242 ChartCanvas *cc = g_canvasArray.Item(i);
4243 if (cc) {
4244 cc->GetCompass()->SetScaleFactor(g_compass_scalefactor);
4245 cc->UpdateCanvasControlBar();
4246 }
4247 }
4248 UpdateGPSCompassStatusBoxes();
4249
4250 SetAllToolbarScale();
4251 RequestNewToolbars();
4252
4253 // Rebuild cursors
4254 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
4255 ChartCanvas *cc = g_canvasArray.Item(i);
4256 if (cc) {
4257 cc->RebuildCursors();
4258 }
4259 }
4260
4261 // Change of master toolbar scale?
4262 bool b_masterScaleChange = false;
4263 if (fabs(g_MainToolbar->GetScaleFactor() - g_toolbar_scalefactor) > 0.01f)
4264 b_masterScaleChange = true;
4265
4266 if ((rr & TOOLBAR_CHANGED) || b_masterScaleChange)
4267 RequestNewMasterToolbar(true);
4268
4269 bool bMuiChange = false;
4270#ifdef __ANDROID__
4271 bMuiChange = true; // to pick up possible "zoom" button visibility change
4272#endif
4273
4274 // Inform the canvases
4275 if (b_masterScaleChange || bMuiChange) {
4276 // ..For each canvas...
4277 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
4278 ChartCanvas *cc = g_canvasArray.Item(i);
4279 if (cc) {
4280 cc->ProcessNewGUIScale();
4281 }
4282 }
4283 }
4284
4285#if wxUSE_XLOCALE
4286 if (rr & LOCALE_CHANGED) {
4287 g_Platform->ChangeLocale(g_locale, plocale_def_lang, &plocale_def_lang);
4288 ApplyLocale();
4289 rr |= NEED_NEW_OPTIONS;
4290 }
4291#endif
4292
4293#ifdef __ANDROID__
4294 if (g_pi_manager) g_pi_manager->NotifyAuiPlugIns();
4295#endif
4296
4297 // Reset chart scale factor trigger
4298 g_last_ChartScaleFactor = g_ChartScaleFactor;
4299
4300 return;
4301}
4302
4303bool MyFrame::CheckGroup(int igroup) {
4304 if (igroup == 0) return true; // "all charts" is always OK
4305
4306 ChartGroup *pGroup = g_pGroupArray->Item(igroup - 1);
4307
4308 if (!pGroup->m_element_array.size()) // truly empty group is OK
4309 return true;
4310
4311 for (const auto &elem : pGroup->m_element_array) {
4312 for (unsigned int ic = 0;
4313 ic < (unsigned int)ChartData->GetChartTableEntries(); ic++) {
4314 ChartTableEntry *pcte = ChartData->GetpChartTableEntry(ic);
4315 wxString chart_full_path(pcte->GetpFullPath(), wxConvUTF8);
4316
4317 if (chart_full_path.StartsWith(elem.m_element_name)) return true;
4318 }
4319 }
4320
4321 return false; // this group is empty
4322}
4323
4324bool MyFrame::ScrubGroupArray() {
4325 // For each group,
4326 // make sure that each group element (dir or chart) references at least
4327 // oneitem in the database. If not, remove the element.
4328
4329 bool b_change = false;
4330 unsigned int igroup = 0;
4331 while (igroup < g_pGroupArray->GetCount()) {
4332 bool b_chart_in_element = false;
4333 ChartGroup *pGroup = g_pGroupArray->Item(igroup);
4334
4335 for (unsigned int j = 0; j < pGroup->m_element_array.size(); j++) {
4336 const wxString &element_root = pGroup->m_element_array[j].m_element_name;
4337
4338 for (unsigned int ic = 0;
4339 ic < (unsigned int)ChartData->GetChartTableEntries(); ic++) {
4340 ChartTableEntry *pcte = ChartData->GetpChartTableEntry(ic);
4341 wxString chart_full_path = pcte->GetFullSystemPath();
4342
4343 if (chart_full_path.StartsWith(element_root)) {
4344 b_chart_in_element = true;
4345 break;
4346 }
4347 }
4348
4349 // Explicit check to avoid removing a group containing only GSHHS
4350 if (!b_chart_in_element) {
4351 wxString test_string = _T("GSHH");
4352 if (element_root.Upper().Contains(test_string))
4353 b_chart_in_element = true;
4354 }
4355
4356 if (!b_chart_in_element) // delete the element
4357 {
4358 pGroup->m_element_array.erase(pGroup->m_element_array.begin() + j);
4359 j--;
4360 b_change = true;
4361 }
4362 }
4363
4364 igroup++; // next group
4365 }
4366
4367 return b_change;
4368}
4369
4370void MyFrame::RefreshCanvasOther(ChartCanvas *ccThis) {
4371 // ..For each canvas...
4372 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
4373 ChartCanvas *cc = g_canvasArray.Item(i);
4374 if (cc && (cc != ccThis)) cc->Refresh();
4375 }
4376}
4377
4378// Flav: This method reloads all charts for convenience
4379void MyFrame::ChartsRefresh() {
4380 if (!ChartData) return;
4381
4382 AbstractPlatform::ShowBusySpinner();
4383
4384 bool b_run = FrameTimer1.IsRunning();
4385
4386 FrameTimer1.Stop(); // stop other asynchronous activity
4387 FrameTenHzTimer.Stop();
4388
4389 // ..For each canvas...
4390 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
4391 ChartCanvas *cc = g_canvasArray.Item(i);
4392 if (cc) {
4393 int currentIndex = cc->GetpCurrentStack()->GetCurrentEntrydbIndex();
4394 if (cc->GetQuiltMode()) {
4395 currentIndex = cc->GetQuiltReferenceChartIndex();
4396 }
4397 cc->canvasChartsRefresh(currentIndex);
4398 }
4399 }
4400
4401 if (b_run) FrameTimer1.Start(TIMER_GFRAME_1, wxTIMER_CONTINUOUS);
4402 if (b_run) FrameTenHzTimer.Start(100, wxTIMER_CONTINUOUS);
4403
4404 AbstractPlatform::HideBusySpinner();
4405}
4406
4407void MyFrame::InvalidateAllQuilts() {
4408 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
4409 ChartCanvas *cc = g_canvasArray.Item(i);
4410 if (cc) {
4411 cc->InvalidateQuilt();
4412 cc->SetQuiltRefChart(-1);
4413 cc->m_singleChart = NULL;
4414 }
4415 }
4416}
4417
4418bool MyFrame::UpdateChartDatabaseInplace(ArrayOfCDI &DirArray, bool b_force,
4419 bool b_prog,
4420 const wxString &ChartListFileName) {
4421 bool b_run = FrameTimer1.IsRunning();
4422 FrameTimer1.Stop(); // stop other asynchronous activity
4423 FrameTenHzTimer.Stop();
4424
4425 bool b_runCOGTimer = FrameCOGTimer.IsRunning();
4426 FrameCOGTimer.Stop();
4427
4428 // ..For each canvas...
4429 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
4430 ChartCanvas *cc = g_canvasArray.Item(i);
4431 if (cc) {
4432 cc->InvalidateQuilt();
4433 cc->SetQuiltRefChart(-1);
4434 cc->m_singleChart = NULL;
4435 }
4436 }
4437
4438 ChartData->PurgeCache();
4439
4440 // TODO
4441 // delete pCurrentStack;
4442 // pCurrentStack = NULL;
4443
4444 AbstractPlatform::ShowBusySpinner();
4445
4446 wxGenericProgressDialog *pprog = nullptr;
4447 if (b_prog) {
4448 wxString longmsg = _("OpenCPN Chart Update");
4449 longmsg +=
4450 _T("..................................................................")
4451 _T("........");
4452
4453 pprog = new wxGenericProgressDialog();
4454
4455 wxFont *qFont = GetOCPNScaledFont(_("Dialog"));
4456 pprog->SetFont(*qFont);
4457
4458 pprog->Create(_("OpenCPN Chart Update"), longmsg, 100, gFrame,
4459 wxPD_SMOOTH | wxPD_ELAPSED_TIME | wxPD_ESTIMATED_TIME |
4460 wxPD_REMAINING_TIME);
4461
4462 DimeControl(pprog);
4463 pprog->Show();
4464 }
4465
4466 wxLogMessage(_T(" "));
4467 wxLogMessage(_T("Starting chart database Update..."));
4468 wxString gshhg_chart_loc = gWorldMapLocation;
4469 gWorldMapLocation = wxEmptyString;
4470 // The Update() function may set gWorldMapLocation if at least one of the
4471 // directories contains GSHHS files.
4472 ChartData->Update(DirArray, b_force, pprog);
4473 ChartData->SaveBinary(ChartListFileName);
4474 wxLogMessage(_T("Finished chart database Update"));
4475 wxLogMessage(_T(" "));
4476 if (gWorldMapLocation.empty()) { // Last resort. User might have deleted all
4477 // GSHHG data, but we still might have the
4478 // default dataset distributed with OpenCPN
4479 // or from the package repository...
4480 gWorldMapLocation = gDefaultWorldMapLocation;
4481 gshhg_chart_loc = wxEmptyString;
4482 }
4483
4484 if (gWorldMapLocation != gshhg_chart_loc) {
4485 // ..For each canvas...
4486 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
4487 ChartCanvas *cc = g_canvasArray.Item(i);
4488 if (cc) cc->ResetWorldBackgroundChart();
4489 }
4490 // Reset the GSHHS singleton which is used to detect land crossing.
4491 gshhsCrossesLandReset();
4492 }
4493
4494 delete pprog;
4495
4496 AbstractPlatform::HideBusySpinner();
4497
4498 pConfig->UpdateChartDirs(DirArray);
4499
4500 // Restart timers, if necessary
4501 if (b_run) FrameTimer1.Start(TIMER_GFRAME_1, wxTIMER_CONTINUOUS);
4502 if (b_run) FrameTenHzTimer.Start(100, wxTIMER_CONTINUOUS);
4503
4504 if (b_runCOGTimer) {
4505 // Restart the COG rotation timer, max frequency is 10 hz.
4506 int period_ms = 100;
4507 if (g_COGAvgSec > 0) period_ms = g_COGAvgSec * 1000;
4508 FrameCOGTimer.Start(period_ms, wxTIMER_CONTINUOUS);
4509 }
4510 return true;
4511}
4512
4513void MyFrame::ToggleQuiltMode(ChartCanvas *cc) {
4514 if (cc) {
4515 cc->ToggleCanvasQuiltMode();
4516#if 0
4517 bool cur_mode = cc->GetQuiltMode();
4518
4519 if( !cc->GetQuiltMode() )
4520 cc->SetQuiltMode( true );
4521 else
4522 if( cc->GetQuiltMode() ) {
4523 cc->SetQuiltMode( false );
4524 g_sticky_chart = cc->GetQuiltReferenceChartIndex();
4525 }
4526
4527
4528 if( cur_mode != cc->GetQuiltMode() ){
4529 //TODO >>SetupQuiltMode();
4530 DoChartUpdate();
4531 cc->InvalidateGL();
4532 Refresh();
4533 }
4534 g_bQuiltEnable = cc->GetQuiltMode();
4535
4536 // Recycle the S52 PLIB so that vector charts will flush caches and re-render
4537 if(ps52plib)
4538 ps52plib->GenerateStateHash();
4539#endif
4540 }
4541}
4542
4543void MyFrame::DoStackDown(ChartCanvas *cc) { DoStackDelta(cc, -1); }
4544
4545void MyFrame::DoStackUp(ChartCanvas *cc) { DoStackDelta(cc, 1); }
4546
4547void MyFrame::DoStackDelta(ChartCanvas *cc, int direction) {
4548 if (cc) {
4549 cc->DoCanvasStackDelta(direction);
4550 }
4551}
4552
4553void MyFrame::PositionIENCToolbar() {
4554#if 0
4555 if (g_iENCToolbar) {
4556 wxPoint posn;
4557 posn.x = (GetPrimaryCanvas()->GetSize().x - g_iENCToolbar->GetSize().x) / 2;
4558 posn.y = 4;
4559 g_iENCToolbar->Move(GetPrimaryCanvas()->ClientToScreen(posn));
4560 }
4561#endif
4562}
4563
4564// Defered initialization for anything that is not required to render the
4565// initial frame and takes a while to initialize. This gets opencpn up and
4566// running much faster.
4567void MyFrame::OnInitTimer(wxTimerEvent &event) {
4568 InitTimer.Stop();
4569 wxString msg;
4570 msg.Printf(_T("OnInitTimer...%d"), m_iInitCount);
4571 wxLogMessage(msg);
4572
4573 wxLog::FlushActive();
4574
4575 switch (m_iInitCount++) {
4576 case 0: {
4577 if (g_MainToolbar) g_MainToolbar->EnableTool(ID_SETTINGS, false);
4578
4579 if (g_bInlandEcdis) {
4580 double range = GetPrimaryCanvas()->GetCanvasRangeMeters();
4581 double range_set = 500.;
4582
4583 range = wxRound(range * 10) / 10.;
4584
4585 if (range > 4000.)
4586 range_set = 4000.;
4587 else if (range > 2000.)
4588 range_set = 2000.;
4589 else if (range > 1600.)
4590 range_set = 1600.;
4591 else if (range > 1200.)
4592 range_set = 1200.;
4593 else if (range > 800.)
4594 range_set = 800.;
4595 else
4596 range_set = 500.;
4597
4598 GetPrimaryCanvas()->SetCanvasRangeMeters(range_set);
4599 }
4600
4601 // Set persistent Fullscreen mode
4602 g_Platform->SetFullscreen(g_bFullscreen);
4603
4604 // Rebuild chart database, if necessary
4605 if (g_NeedDBUpdate > 0) {
4606 RebuildChartDatabase();
4607 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
4608 ChartCanvas *cc = g_canvasArray.Item(i);
4609 if (cc) {
4610 cc->SetGroupIndex(0, false); // all charts
4611 }
4612 }
4613
4614 // As a favor to new users, poll the database and
4615 // move the initial viewport so that a chart will come up.
4616
4617 double clat, clon;
4618 if (ChartData->GetCentroidOfLargestScaleChart(&clat, &clon,
4619 CHART_FAMILY_RASTER)) {
4620 gLat = clat;
4621 gLon = clon;
4622 gFrame->ClearbFollow(gFrame->GetPrimaryCanvas());
4623 } else {
4624 if (ChartData->GetCentroidOfLargestScaleChart(&clat, &clon,
4625 CHART_FAMILY_VECTOR)) {
4626 gLat = clat;
4627 gLon = clon;
4628 gFrame->ClearbFollow(gFrame->GetPrimaryCanvas());
4629 }
4630 }
4631
4632 g_NeedDBUpdate = 0;
4633 }
4634
4635 // Load the waypoints. Both of these routines are very slow to execute
4636 // which is why they have been to defered until here
4637 auto colour_func = [](wxString c) { return GetGlobalColor(c); };
4638 pWayPointMan = new WayPointman(colour_func);
4639 WayPointmanGui(*pWayPointMan)
4640 .SetColorScheme(global_color_scheme, g_Platform->GetDisplayDPmm());
4641 // Reload the ownship icon from UserIcons, if present
4642 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
4643 ChartCanvas *cc = g_canvasArray.Item(i);
4644 if (cc) {
4645 if (cc->SetUserOwnship()) cc->SetColorScheme(global_color_scheme);
4646 }
4647 }
4648
4649 pConfig->LoadNavObjects();
4650 // Re-enable anchor watches if set in config file
4651 if (!g_AW1GUID.IsEmpty()) {
4652 pAnchorWatchPoint1 = pWayPointMan->FindRoutePointByGUID(g_AW1GUID);
4653 }
4654 if (!g_AW2GUID.IsEmpty()) {
4655 pAnchorWatchPoint2 = pWayPointMan->FindRoutePointByGUID(g_AW2GUID);
4656 }
4657
4658 // Import Layer-wise any .gpx files from /layers directory
4659 wxString layerdir = g_Platform->GetPrivateDataDir();
4660 appendOSDirSlash(&layerdir);
4661 layerdir.Append(_T("layers"));
4662
4663 if (wxDir::Exists(layerdir)) {
4664 wxString laymsg;
4665 laymsg.Printf(wxT("Getting .gpx layer files from: %s"),
4666 layerdir.c_str());
4667 wxLogMessage(laymsg);
4668 pConfig->LoadLayers(layerdir);
4669 }
4670
4671 break;
4672 }
4673 case 1:
4674 // Connect Datastreams
4675
4676 for (auto *cp : TheConnectionParams()) {
4677 if (cp->bEnabled) {
4678 MakeCommDriver(cp);
4679 cp->b_IsSetup = TRUE;
4680 }
4681 }
4682
4683 console = new ConsoleCanvas(gFrame); // the console
4684 console->SetColorScheme(global_color_scheme);
4685
4686 // Draw console if persisted route is active
4687 if (g_pRouteMan) {
4688 if (g_pRouteMan->IsAnyRouteActive()) {
4689 g_pRouteMan->GetDlgContext().show_with_fresh_fonts();
4690 }
4691 }
4692
4693 break;
4694
4695 case 2: {
4696 if (m_initializing) break;
4697 m_initializing = true;
4698 AbstractPlatform::ShowBusySpinner();
4699 PluginLoader::getInstance()->LoadAllPlugIns(true);
4700 AbstractPlatform::HideBusySpinner();
4701 // RequestNewToolbars();
4702 RequestNewMasterToolbar();
4703 // A Plugin (e.g. Squiddio) may have redefined some routepoint icons...
4704 // Reload all icons, to be sure.
4705 if (pWayPointMan) WayPointmanGui(*pWayPointMan).ReloadRoutepointIcons();
4706
4707 if (g_MainToolbar) g_MainToolbar->EnableTool(ID_SETTINGS, false);
4708
4709 wxString perspective;
4710 pConfig->SetPath(_T ( "/AUI" ));
4711 pConfig->Read(_T ( "AUIPerspective" ), &perspective);
4712
4713 // Make sure the perspective saved in the config file is "reasonable"
4714 // In particular, the perspective should have an entry for every
4715 // windows added to the AUI manager so far.
4716 // If any are not found, then use the default layout
4717
4718 bool bno_load = false;
4719
4720 wxArrayString name_array;
4721 wxStringTokenizer st(perspective, _T("|;"));
4722 while (st.HasMoreTokens()) {
4723 wxString s1 = st.GetNextToken();
4724 if (s1.StartsWith(_T("name="))) {
4725 wxString sc = s1.AfterFirst('=');
4726 name_array.Add(sc);
4727 }
4728 }
4729
4730 wxAuiPaneInfoArray pane_array_val = g_pauimgr->GetAllPanes();
4731 for (unsigned int i = 0; i < pane_array_val.GetCount(); i++) {
4732 wxAuiPaneInfo pane = pane_array_val.Item(i);
4733
4734 // If we find a pane that is not in the perspective,
4735 // then we should not load the perspective at all
4736 if (name_array.Index(pane.name) == wxNOT_FOUND) {
4737 bno_load = true;
4738 break;
4739 }
4740 }
4741
4742 if (!bno_load) g_pauimgr->LoadPerspective(perspective, false);
4743
4744#if 0
4745 // Undefine the canvas sizes as expressed by the loaded perspective
4746 for(unsigned int i=0 ; i < g_canvasArray.GetCount() ; i++){
4747 ChartCanvas *cc = g_canvasArray.Item(i);
4748 if(cc)
4749 g_pauimgr->GetPane(cc).MinSize(10,10);
4750 }
4751
4752#endif
4753
4754 // Touch up the AUI manager
4755 // Make sure that any pane width is reasonable default value
4756 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
4757 ChartCanvas *cc = g_canvasArray.Item(i);
4758 if (cc) {
4759 wxSize frameSize = GetClientSize();
4760 wxSize minSize = g_pauimgr->GetPane(cc).min_size;
4761 int width = wxMax(minSize.x, frameSize.x / 10);
4762 g_pauimgr->GetPane(cc).MinSize(frameSize.x * 1 / 5, frameSize.y);
4763 }
4764 }
4765 g_pauimgr->Update();
4766
4767 // Notify all the AUI PlugIns so that they may syncronize with the
4768 // Perspective
4769 g_pi_manager->NotifyAuiPlugIns();
4770
4771 // Give the user dialog on any blacklisted PlugIns
4772 g_pi_manager->ShowDeferredBlacklistMessages();
4773
4774 g_pi_manager->CallLateInit();
4775
4776 // If any PlugIn implements PlugIn Charts, we need to re-run the initial
4777 // chart load logic to select the correct chart as saved from the last
4778 // run of the app. This will be triggered at the next DoChartUpdate()
4779 if (g_pi_manager->IsAnyPlugInChartEnabled()) {
4780 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
4781 ChartCanvas *cc = g_canvasArray.Item(i);
4782 if (cc) cc->SetFirstAuto(true);
4783 }
4784
4785 b_reloadForPlugins = true;
4786 }
4787
4788 break;
4789 }
4790
4791 case 3: {
4792 if (g_MainToolbar) {
4793 g_MainToolbar->SetAutoHide(g_bAutoHideToolbar);
4794 g_MainToolbar->SetAutoHideTimer(g_nAutoHideToolbar);
4795 }
4796
4797#if 0 // per-canvas toolbars deprecated in MUI
4798
4799 // .. for each canvas...
4800 for(unsigned int i=0 ; i < g_canvasArray.GetCount() ; i++){
4801 ChartCanvas *cc = g_canvasArray.Item(i);
4802 cc->RequestNewCanvasToolbar( true );
4803
4804 if(cc && cc->GetToolbarEnable()){
4805 cc->GetToolbar()->SetAutoHide(g_bAutoHideToolbar);
4806 cc->GetToolbar()->SetAutoHideTimer(g_nAutoHideToolbar);
4807 }
4808 }
4809#endif
4810
4811 break;
4812 }
4813
4814 case 4: {
4815 int sx, sy;
4816 pConfig->SetPath("/Settings");
4817 pConfig->Read("OptionsSizeX", &sx, -1);
4818 pConfig->Read("OptionsSizeY", &sy, -1);
4819
4820 wxWindow *optionsParent = this;
4821#ifdef __WXOSX__
4822 optionsParent = GetPrimaryCanvas();
4823#endif
4824 g_options = new options(optionsParent, -1, _("Options"), wxPoint(-1, -1),
4825 wxSize(sx, sy));
4826
4827 BuildiENCToolbar(true);
4828
4829 break;
4830 }
4831
4832 case 5: {
4833 // FIXME (leamas) Remove, delegate to CmdlineClient ctor
4834 if (!g_params.empty()) {
4835 for (size_t n = 0; n < g_params.size(); n++) {
4836 wxString path = g_params[n];
4837 if (::wxFileExists(path)) {
4838 NavObjectCollection1 *pSet = new NavObjectCollection1;
4839 pSet->load_file(path.fn_str());
4840 int wpt_dups;
4841
4842 pSet->LoadAllGPXObjects(
4843 !pSet->IsOpenCPN(), wpt_dups,
4844 true); // Import with full vizibility of names and objects
4845 LLBBox box = pSet->GetBBox();
4846 if (box.GetValid()) {
4847 CenterView(GetPrimaryCanvas(), box);
4848 }
4849 delete pSet;
4850 }
4851 }
4852 }
4853 break;
4854 }
4855 case 6: {
4856 InitAppMsgBusListener();
4857 InitApiListeners();
4858
4859 break;
4860 }
4861
4862 default: {
4863 // Last call....
4864 wxLogMessage(_T("OnInitTimer...Last Call"));
4865
4866 PositionIENCToolbar();
4867
4868 g_bDeferredInitDone = true;
4869
4870 GetPrimaryCanvas()->SetFocus();
4871 g_focusCanvas = GetPrimaryCanvas();
4872
4873#ifndef __ANDROID__
4874 gFrame->Raise();
4875#endif
4876
4877 if (b_reloadForPlugins) {
4878 DoChartUpdate();
4879 ChartsRefresh();
4880 }
4881
4882 wxLogMessage(_T("OnInitTimer...Finalize Canvases"));
4883
4884 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
4885 ChartCanvas *cc = g_canvasArray.Item(i);
4886 if (cc) {
4887 cc->CreateMUIBar();
4888 cc->CheckGroupValid();
4889 }
4890 }
4891
4892#ifdef __ANDROID__
4893 androidEnableBackButton(true);
4894 androidEnableRotation();
4895 androidEnableOptionItems(true);
4896 androidLastCall();
4897#endif
4898
4899 if (g_MainToolbar) g_MainToolbar->EnableTool(ID_SETTINGS, true);
4900
4901 UpdateStatusBar();
4902
4903 SendSizeEvent();
4904 break;
4905 }
4906 } // switch
4907
4908 if (!g_bDeferredInitDone) InitTimer.Start(100, wxTIMER_ONE_SHOT);
4909
4910 wxLog::FlushActive();
4911
4912 RefreshAllCanvas(true);
4913 wxGetApp().m_usb_watcher.Start();
4914}
4915
4916wxDEFINE_EVENT(EVT_BASIC_NAV_DATA, ObservedEvt);
4917wxDEFINE_EVENT(EVT_GPS_WATCHDOG, ObservedEvt);
4918
4919void MyFrame::InitAppMsgBusListener() {
4920 auto &msgbus = AppMsgBus::GetInstance();
4921
4922 // BasicNavData
4923 AppMsg msg_basic(AppMsg::Type::BasicNavData);
4924 listener_basic_navdata.Listen(msg_basic, this, EVT_BASIC_NAV_DATA);
4925
4926 Bind(EVT_BASIC_NAV_DATA, [&](ObservedEvt ev) {
4927 auto ptr = ev.GetSharedPtr();
4928 auto basicnav_msg = std::static_pointer_cast<const BasicNavDataMsg>(ptr);
4929 HandleBasicNavMsg(basicnav_msg);
4930 });
4931
4932 // GPS Watchdog expiry status
4933 AppMsg msg_watchdog(AppMsg::Type::GPSWatchdog);
4934 listener_gps_watchdog.Listen(msg_watchdog, this, EVT_GPS_WATCHDOG);
4935
4936 Bind(EVT_GPS_WATCHDOG, [&](ObservedEvt ev) {
4937 auto ptr = ev.GetSharedPtr();
4938 auto msg = std::static_pointer_cast<const GPSWatchdogMsg>(ptr);
4939 HandleGPSWatchdogMsg(msg);
4940 });
4941}
4942
4944#ifdef __ANDROID__
4945void MyFrame::InitApiListeners() {}
4946void MyFrame::ReleaseApiListeners() {}
4947
4948#else
4949void MyFrame::InitApiListeners() {
4950 auto &server = LocalServerApi::GetInstance();
4951 m_on_raise_listener.Init(server.on_raise, [&](ObservedEvt) { Raise(); });
4952 m_on_quit_listener.Init(server.on_quit, [&](ObservedEvt) { FastClose(); });
4953 server.SetGetRestApiEndpointCb(
4954 [&] { return wxGetApp().m_rest_server.GetEndpoint(); });
4955 server.open_file_cb = [](const std::string &path) {
4956 return wxGetApp().OpenFile(path);
4957 };
4958}
4959
4960void MyFrame::ReleaseApiListeners() { LocalServerApi::ReleaseInstance(); }
4961#endif
4962
4963void MyFrame::HandleGPSWatchdogMsg(std::shared_ptr<const GPSWatchdogMsg> msg) {
4964 if (msg->gps_watchdog <= 0) {
4965 if (msg->wd_source == GPSWatchdogMsg::WDSource::position) {
4966 bool last_bGPSValid = bGPSValid;
4967 bGPSValid = false;
4968 m_fixtime = 0; // Invalidate fix time
4969 if (last_bGPSValid != bGPSValid) UpdateGPSCompassStatusBoxes(true);
4970 } else if (msg->wd_source == GPSWatchdogMsg::WDSource::velocity) {
4971 bool last_bVelocityValid = bVelocityValid;
4972 bVelocityValid = false;
4973 }
4974
4975 UpdateStatusBar();
4976 }
4977}
4978
4979void MyFrame::CalculateCOGAverage() {
4980 // Maintain average COG for Course Up Mode
4981 if (!std::isnan(gCog)) {
4982 if (g_COGAvgSec > 0) {
4983 // Make a hole
4984 for (int i = g_COGAvgSec - 1; i > 0; i--) COGTable[i] = COGTable[i - 1];
4985 COGTable[0] = gCog;
4986
4987 double sum = 0., count = 0;
4988 for (int i = 0; i < g_COGAvgSec; i++) {
4989 double adder = COGTable[i];
4990 if (std::isnan(adder)) continue;
4991
4992 if (fabs(adder - g_COGAvg) > 180.) {
4993 if ((adder - g_COGAvg) > 0.)
4994 adder -= 360.;
4995 else
4996 adder += 360.;
4997 }
4998
4999 sum += adder;
5000 count++;
5001 }
5002 sum /= count;
5003
5004 if (sum < 0.)
5005 sum += 360.;
5006 else if (sum >= 360.)
5007 sum -= 360.;
5008
5009 g_COGAvg = sum;
5010 } else
5011 g_COGAvg = gCog;
5012 }
5013}
5014
5015void MyFrame::HandleBasicNavMsg(std::shared_ptr<const BasicNavDataMsg> msg) {
5016 m_fixtime = msg->time;
5017 double hdt_data_interval = 0;
5018 double fix_time_interval = 0;
5019
5020 double msgtime = msg->set_time.tv_sec;
5021 double m1 = msg->set_time.tv_nsec / 1e9;
5022 msgtime += m1;
5023
5024 if (((msg->vflag & POS_UPDATE) == POS_UPDATE) &&
5025 ((msg->vflag & POS_VALID) == POS_VALID)) {
5026 // Check the position change, looking for a valid new fix.
5027 double dist, brg;
5028 DistanceBearingMercator(gLat, gLon, gLat_gt, gLon_gt, &brg, &dist);
5029
5030 if (dist > .0001) { // Avoid duplicate position report
5031 fix_time_gt_last = fix_time_gt;
5032 uint64_t fix_time_gt_now =
5033 msg->set_time.tv_sec * 1e9 + msg->set_time.tv_nsec;
5034 fix_time_interval = (fix_time_gt_now - fix_time_gt_last) / (double)1e9;
5035 // printf("interval: %g\n", fix_time_interval);
5036
5037 // Calculate an implied SOG from the position change and time interval
5038 double implied_sog = dist / (fix_time_interval / 3600);
5039
5040 // printf ("Fix Interval: %g\n", fix_time_interval);
5041 // printf("SOG est: %g %g\n", gSog, implied_sog);
5042 // shuffle history data
5043 gLat_gt_m1 = gLat_gt;
5044 gLon_gt_m1 = gLon_gt;
5045 gLat_gt = gLat;
5046 gLon_gt = gLon;
5047
5048 fix_time_gt = fix_time_gt_now;
5049 }
5050 }
5051
5052 if (((msg->vflag & COG_UPDATE) == COG_UPDATE) &&
5053 ((msg->vflag & SOG_UPDATE) == SOG_UPDATE)) {
5054 gCog_gt_m1 = gCog_gt;
5055 gCog_gt = gCog;
5056 gSog_gt = gSog;
5057
5058 // In every case, if SOG is too slow, the COG is undefined.
5059 if (gSog < 0.1) {
5060 gCog_gt = NAN;
5061 gCog_gt_m1 = NAN;
5062 }
5063
5064 if (!std::isnan(gCog_gt_m1)) { // Startup
5065#if 0
5066 if ((fabs(gSog - implied_sog) / gSog) > 0.5) {
5067 // Probably a synthetic data stream, with multiple position sources.
5068 // Do not try to interpolate position at 10 Hz.
5069 gSog_gt = 0;
5070 cog_rate_gt = 0;
5071 } else
5072#endif
5073 if ((fix_time_gt - fix_time_gt_last) > .08) {
5074 // Calculate an estimated Rate-of-turn
5075 int dir = 0;
5076 double diff = 0;
5077 double difft = 0;
5078 if (gCog_gt > gCog_gt_m1) {
5079 if ((gCog_gt - gCog_gt_m1) > 180.)
5080 dir = 1; // left
5081 else
5082 dir = 2; // right
5083 } else {
5084 if ((gCog_gt_m1 - gCog_gt) > 180.)
5085 dir = 2; // right
5086 else
5087 dir = 1; // left
5088 }
5089 difft = fabs(gCog_gt - gCog_gt_m1);
5090 if (fabs(difft > 180.)) difft = fabs(difft - 360.);
5091 if (dir == 1)
5092 diff = -difft;
5093 else
5094 diff = difft;
5095
5096 // double diff = gCog_gt - gCog_gt_m1;
5097 // printf("diff %g %d\n", diff, dir);
5098 double tentative_cog_rate_gt = diff / (fix_time_gt - fix_time_gt_last);
5099 tentative_cog_rate_gt *= 1e9; // degrees / sec
5100 cog_rate_gt = tentative_cog_rate_gt;
5101 }
5102
5103 gCog = gCog_gt_m1;
5104 }
5105 // printf("cog_rate_gt %g %g\n", gCog, cog_rate_gt);
5106 }
5107
5108 if ((msg->vflag & HDT_UPDATE) == HDT_UPDATE) {
5109#if 0
5110// Lowpass filter, 10 samples
5111static double hdt_avg;
5112 double hdt_norm = gHdt;
5113 if(gHdt > 180) hdt_norm -= 360;
5114
5115 hdt_avg *= 0.9;
5116 hdt_avg += hdt_norm * 0.1;
5117 gHdt = hdt_avg;
5118 if( gHdt < 0) gHdt += 360.;
5119#endif
5120
5121 if (!std::isnan(gHdt)) {
5122 // Prepare to estimate the gHdt from prior ground truth measurements
5123 uint64_t hdt_time_gt_last = hdt_time_gt;
5124 hdt_time_gt = msg->set_time.tv_sec * 1e9 + msg->set_time.tv_nsec;
5125 hdt_data_interval = (hdt_time_gt - hdt_time_gt_last) / 1e9;
5126
5127 // Skip data reports that come too frequently
5128 if (hdt_data_interval > .09) {
5129 // shuffle points
5130 gHdt_gt_m1 = gHdt_gt;
5131 gHdt_gt = gHdt;
5132
5133 if (!std::isnan(gHdt_gt_m1)) { // startup
5134 // Calculate an estimated Rate-of-change of gHdt
5135 double tentative_hdt_rate_gt =
5136 (gHdt_gt - gHdt_gt_m1) / (hdt_time_gt - hdt_time_gt_last);
5137 tentative_hdt_rate_gt *= 1e9; // degrees / sec
5138 // Sanity check, and resolve the "phase" problem at +/- North
5139 if (fabs(tentative_hdt_rate_gt - hdt_rate_gt) < 180.)
5140 hdt_rate_gt = tentative_hdt_rate_gt;
5141
5142 gHdt = gHdt_gt_m1;
5143 }
5144 }
5145 }
5146 }
5147
5148 if (std::isnan(gHdt)) gHdt_gt = NAN; // Handle loss of signal
5149
5150 // Some housekeeping
5151 CalculateCOGAverage();
5152 FilterCogSog();
5153
5154 // Maintain the GPS position validity flag
5155 // Determined by source validity of RMC, GGA, GLL (N0183)
5156 // or PGNs 129029, 129025 (N2K)
5157 // Positions by sK and AIVDO are assumed valid
5158 bool last_bGPSValid = bGPSValid;
5159 if ((msg->vflag & POS_UPDATE) == POS_UPDATE) {
5160 if ((msg->vflag & POS_VALID) == POS_VALID)
5161 bGPSValid = true;
5162 else
5163 bGPSValid = false;
5164 }
5165 if (last_bGPSValid != bGPSValid) UpdateGPSCompassStatusBoxes(true);
5166
5167 bVelocityValid = true;
5168 UpdateStatusBar();
5169}
5170
5171void MyFrame::UpdateStatusBar() {
5172 // Show a little heartbeat tick in StatusWindow0 on NMEA events
5173 // But no faster than 10 hz.
5174 unsigned long uiCurrentTickCount;
5175 m_MMEAeventTime.SetToCurrent();
5176 uiCurrentTickCount =
5177 m_MMEAeventTime.GetMillisecond() / 100; // tenths of a second
5178 uiCurrentTickCount += m_MMEAeventTime.GetTicks() * 10;
5179 if (uiCurrentTickCount > m_ulLastNMEATicktime + 1) {
5180 m_ulLastNMEATicktime = uiCurrentTickCount;
5181
5182 if (m_tick_idx++ > 6) m_tick_idx = 0;
5183 }
5184
5185 // Show gLat/gLon in StatusWindow0
5186
5187 if (NULL != GetStatusBar()) {
5188 if (1 /*pos_valid*/) {
5189 char tick_buf[2];
5190 tick_buf[0] = nmea_tick_chars[m_tick_idx];
5191 tick_buf[1] = 0;
5192
5193 wxString s1(tick_buf, wxConvUTF8);
5194 s1 += _(" Ship ");
5195 s1 += toSDMM(1, gLat);
5196 s1 += _T(" ");
5197 s1 += toSDMM(2, gLon);
5198
5199 if (STAT_FIELD_TICK >= 0) SetStatusText(s1, STAT_FIELD_TICK);
5200 }
5201
5202 wxString sogcog;
5203 if (!std::isnan(gSog))
5204 sogcog.Printf(_T("SOG %2.2f ") + getUsrSpeedUnit() + _T(" "),
5205 toUsrSpeed(gSog));
5206 else
5207 sogcog.Printf(_T("SOG --- "));
5208
5209 wxString cogs;
5210 // We show COG only if SOG is > 0.05
5211 if (!std::isnan(gCog) && !std::isnan(gSog) && (gSog > 0.05)) {
5212 if (g_bShowTrue)
5213 cogs << wxString::Format(wxString("COG %03d%c "), (int)gCog, 0x00B0);
5214 if (g_bShowMag)
5215 cogs << wxString::Format(wxString("COG %03d%c(M) "),
5216 (int)toMagnetic(gCog), 0x00B0);
5217 } else
5218 cogs.Printf(("COG ---%c"), 0x00B0);
5219
5220 sogcog.Append(cogs);
5221 SetStatusText(sogcog, STAT_FIELD_SOGCOG);
5222 }
5223}
5224
5225// Manage the application memory footprint on a periodic schedule
5226void MyFrame::OnMemFootTimer(wxTimerEvent &event) {
5227 MemFootTimer.Stop();
5228
5229 int memsize = GetApplicationMemoryUse();
5230
5231 g_MemFootMB = 100;
5232 printf("Memsize: %d \n", memsize);
5233 // The application memory usage has exceeded the target, so try to manage it
5234 // down....
5235 if (memsize > (g_MemFootMB * 1000)) {
5236 ChartCanvas *cc = GetPrimaryCanvas();
5237 if (ChartData && cc) {
5238 // Get a local copy of the cache info
5239 wxArrayPtrVoid *pCache = ChartData->GetChartCache();
5240 unsigned int nCache = pCache->GetCount();
5241 CacheEntry *pcea = new CacheEntry[nCache];
5242
5243 for (unsigned int i = 0; i < nCache; i++) {
5244 CacheEntry *pce = (CacheEntry *)(pCache->Item(i));
5245 pcea[i] = *pce; // ChartBase *Ch = (ChartBase *)pce->pChart;
5246 }
5247
5248 if (nCache > 1) {
5249 // Bubble Sort the local cache entry array
5250 bool b_cont = true;
5251 while (b_cont) {
5252 b_cont = false;
5253 for (unsigned int i = 0; i < nCache - 1; i++) {
5254 if (pcea[i].RecentTime > pcea[i + 1].RecentTime) {
5255 CacheEntry tmp = pcea[i];
5256 pcea[i] = pcea[i + 1];
5257 pcea[i + 1] = tmp;
5258 b_cont = true;
5259 break;
5260 }
5261 }
5262 }
5263
5264 // Free up some chart cache entries until the memory footprint target
5265 // is realized
5266
5267 unsigned int idelete = 0; // starting at top. which is oldest
5268 unsigned int idelete_max = pCache->GetCount();
5269
5270 // How many can be deleted?
5271 unsigned int minimum_cache = 1;
5272 if (cc->GetQuiltMode()) minimum_cache = cc->GetQuiltChartCount();
5273
5274 while ((memsize > (g_MemFootMB * 1000)) &&
5275 (pCache->GetCount() > minimum_cache) &&
5276 (idelete < idelete_max)) {
5277 int memsizeb = memsize;
5278
5279 ChartData->DeleteCacheChart((ChartBase *)pcea[idelete].pChart);
5280 idelete++;
5281 memsize = GetApplicationMemoryUse();
5282 printf("delete, before: %d after: %d\n", memsizeb, memsize);
5283 }
5284 }
5285
5286 delete[] pcea;
5287 }
5288 }
5289
5290 MemFootTimer.Start(9000, wxTIMER_CONTINUOUS);
5291}
5292
5293int ut_index;
5294
5295void MyFrame::CheckToolbarPosition() {
5296#ifdef __WXMAC__
5297 // Manage Full Screen mode on Mac Mojave 10.14
5298 static bool bMaximized;
5299
5300 if (IsMaximized() && !bMaximized) {
5301 bMaximized = true;
5302 if (g_MainToolbar) {
5303 g_MainToolbar->SetYAuxOffset(g_MainToolbar->GetToolSize().y * 15 / 10);
5304 g_MainToolbar->SetDefaultPosition();
5305 g_MainToolbar->Realize();
5306 }
5307 PositionIENCToolbar();
5308 } else if (!IsMaximized() && bMaximized) {
5309 bMaximized = false;
5310 if (g_MainToolbar) {
5311 g_MainToolbar->SetYAuxOffset(0);
5312 g_MainToolbar->SetDockY(-1);
5313 g_MainToolbar->SetDefaultPosition();
5314 g_MainToolbar->Realize();
5315 }
5316 PositionIENCToolbar();
5317 }
5318#endif
5319}
5320
5321void MyFrame::ProcessUnitTest() {
5322 if (!g_bPauseTest && (g_unit_test_1 || g_unit_test_2)) {
5323 // if((0 == ut_index) && GetQuiltMode())
5324 // ToggleQuiltMode();
5325
5326 // We use only one canvas for the unit tests, so far...
5327 ChartCanvas *cc = GetPrimaryCanvas();
5328
5329 cc->m_bFollow = false;
5330 if (g_MainToolbar && g_MainToolbar->GetToolbar())
5331 g_MainToolbar->GetToolbar()->ToggleTool(ID_FOLLOW, cc->m_bFollow);
5332 int ut_index_max = ((g_unit_test_1 > 0) ? (g_unit_test_1 - 1) : INT_MAX);
5333
5334 if (ChartData) {
5335 if (cc->m_groupIndex > 0) {
5336 while (ut_index < ChartData->GetChartTableEntries() &&
5337 !ChartData->IsChartInGroup(ut_index, cc->m_groupIndex)) {
5338 ut_index++;
5339 }
5340 }
5341 if (ut_index < ChartData->GetChartTableEntries()) {
5342 // printf("%d / %d\n", ut_index, ChartData->GetChartTableEntries());
5343 const ChartTableEntry *cte = &ChartData->GetChartTableEntry(ut_index);
5344
5345 double clat = (cte->GetLatMax() + cte->GetLatMin()) / 2;
5346 double clon = (cte->GetLonMax() + cte->GetLonMin()) / 2;
5347
5348 vLat = clat;
5349 vLon = clon;
5350
5351 cc->SetViewPoint(clat, clon);
5352
5353 if (cc->GetQuiltMode()) {
5354 if (cc->IsChartQuiltableRef(ut_index))
5355 cc->SelectQuiltRefdbChart(ut_index);
5356 } else
5357 cc->SelectdbChart(ut_index);
5358
5359 double ppm; // final ppm scale to use
5360 if (g_unit_test_1) {
5361 ppm = cc->GetCanvasScaleFactor() / cte->GetScale();
5362 ppm /= 2;
5363 } else {
5364 double rw, rh; // width, height
5365 int ww, wh; // chart window width, height
5366
5367 // width in nm
5368 DistanceBearingMercator(cte->GetLatMin(), cte->GetLonMin(),
5369 cte->GetLatMin(), cte->GetLonMax(), NULL,
5370 &rw);
5371
5372 // height in nm
5373 DistanceBearingMercator(cte->GetLatMin(), cte->GetLonMin(),
5374 cte->GetLatMax(), cte->GetLonMin(), NULL,
5375 &rh);
5376
5377 cc->GetSize(&ww, &wh);
5378 ppm = wxMin(ww / (rw * 1852), wh / (rh * 1852)) * (100 - fabs(clat)) /
5379 90;
5380 ppm = wxMin(ppm, 1.0);
5381 }
5382 cc->SetVPScale(ppm);
5383
5384 cc->ReloadVP();
5385
5386 ut_index++;
5387 if (ut_index > ut_index_max) exit(0);
5388 } else {
5389 _exit(0);
5390 }
5391 }
5392 }
5393}
5394double gCog_last;
5395
5396void MyFrame::OnFrameTenHzTimer(wxTimerEvent &event) {
5397 // Check to see if in non-North-Up mode
5398 bool b_rotate = false;
5399 for (ChartCanvas *cc : g_canvasArray) {
5400 if (cc) b_rotate |= (cc->GetUpMode() != NORTH_UP_MODE);
5401 }
5402
5403 if (!b_rotate && !g_btenhertz) return; // Nothing to do
5404
5405 bool b_update = false;
5406 if (g_btenhertz) {
5407 if (!std::isnan(gCog) && !std::isnan(gSog)) {
5408 // Estimate current state by extrapolating from last "ground truth" state
5409
5410 struct timespec now;
5411 clock_gettime(CLOCK_MONOTONIC, &now);
5412 uint64_t diff = 1e9 * (now.tv_sec) + now.tv_nsec - fix_time_gt;
5413 double diffc = diff / 1e9; // sec
5414
5415 // Set gCog as estimated from last two ground truth fixes
5416 double gCog_tentative = gCog_gt_m1 + (cog_rate_gt * diffc);
5417 if (gCog_tentative >= 360.) gCog_tentative -= 360.;
5418 if (gCog_tentative < 0.) gCog_tentative += 360.;
5419 gCog = gCog_tentative;
5420
5421 // printf(" cog: %g\n", gCog);
5422 // And the same for gHdt
5423 if (!std::isnan(gHdt_gt) && !std::isnan(gHdt_gt_m1)) {
5424 uint64_t diff = 1e9 * (now.tv_sec) + now.tv_nsec - hdt_time_gt;
5425 double diffc = diff / 1e9; // sec
5426 gHdt = gHdt_gt_m1 + (hdt_rate_gt * diffc);
5427 }
5428
5429 // Estimate lat/lon position
5430 if (gSog_gt && !std::isnan(gCog_gt)) {
5431 double delta_t = diffc / 3600; // hours
5432 double distance = gSog_gt * delta_t; // NMi
5433
5434 // spherical (close enough)
5435 double angr = gCog_gt / 180 * M_PI;
5436 double latr = gLat_gt * M_PI / 180;
5437 double D = distance / 3443; // earth radius in nm
5438 double sD = sin(D), cD = cos(D);
5439 double sy = sin(latr), cy = cos(latr);
5440 double sa = sin(angr), ca = cos(angr);
5441
5442 gLon = gLon_gt + asin(sa * sD / cy) * 180 / M_PI;
5443 gLat = asin(sy * cD + cy * sD * ca) * 180 / M_PI;
5444 }
5445 }
5446
5447 b_update = true;
5448 }
5449
5450 // In a valid rotation mode ?
5451 if (b_rotate) {
5452 for (ChartCanvas *cc : g_canvasArray) {
5453 if (cc) cc->DoCanvasCOGSet();
5454 }
5455 b_update = true;
5456 }
5457
5458 if (b_update) {
5459 // printf(" gCog: %g %g\n", gCog, gCog - gCog_last);
5460
5461 for (ChartCanvas *cc : g_canvasArray) {
5462 if (cc) {
5463 if (g_bopengl) {
5464 if (b_rotate || cc->m_bFollow) {
5465 cc->DoCanvasUpdate();
5466 } else
5467 cc->Refresh();
5468 }
5469 }
5470 }
5471 }
5472
5473 gCog_last = gCog;
5474 FrameTenHzTimer.Start(100, wxTIMER_CONTINUOUS);
5475}
5476
5477void MyFrame::ProcessQuitFlag() {
5478 // Listen for quitflag to be set, requesting application close
5479 if (quitflag) {
5480 wxLogMessage(_T("Got quitflag from SIGNAL"));
5481 FrameTimer1.Stop();
5482 FrameTenHzTimer.Stop();
5483
5484 Close();
5485 return;
5486 }
5487}
5488
5489void MyFrame::ProcessDeferredTrackOn() {
5490 // If tracking carryover was found in config file, enable tracking as soon as
5491 // GPS become valid
5492 if (g_bDeferredStartTrack) {
5493 if (!g_bTrackActive) {
5494 if (bGPSValid) {
5495 gFrame->TrackOn();
5496 g_bDeferredStartTrack = false;
5497 }
5498 } else { // tracking has been manually activated
5499 g_bDeferredStartTrack = false;
5500 }
5501 }
5502}
5503
5504void MyFrame::ProcessAnchorWatch() {
5505 // Check for anchorwatch alarms // pjotrc
5506 // 2010.02.15
5507 if (pAnchorWatchPoint1) {
5508 double dist;
5509 double brg;
5510 DistanceBearingMercator(pAnchorWatchPoint1->m_lat,
5511 pAnchorWatchPoint1->m_lon, gLat, gLon, &brg, &dist);
5512 double d = g_nAWMax;
5513 (pAnchorWatchPoint1->GetName()).ToDouble(&d);
5514 d = AnchorDistFix(d, AnchorPointMinDist, g_nAWMax);
5515 bool toofar = false;
5516 bool tooclose = false;
5517 if (d >= 0.0) toofar = (dist * 1852. > d);
5518 if (d < 0.0) tooclose = (dist * 1852 < -d);
5519
5520 if (tooclose || toofar)
5521 AnchorAlertOn1 = true;
5522 else
5523 AnchorAlertOn1 = false;
5524 } else
5525 AnchorAlertOn1 = false;
5526
5527 if (pAnchorWatchPoint2) {
5528 double dist;
5529 double brg;
5530 DistanceBearingMercator(pAnchorWatchPoint2->m_lat,
5531 pAnchorWatchPoint2->m_lon, gLat, gLon, &brg, &dist);
5532
5533 double d = g_nAWMax;
5534 (pAnchorWatchPoint2->GetName()).ToDouble(&d);
5535 d = AnchorDistFix(d, AnchorPointMinDist, g_nAWMax);
5536 bool toofar = false;
5537 bool tooclose = false;
5538 if (d >= 0) toofar = (dist * 1852. > d);
5539 if (d < 0) tooclose = (dist * 1852 < -d);
5540
5541 if (tooclose || toofar)
5542 AnchorAlertOn2 = true;
5543 else
5544 AnchorAlertOn2 = false;
5545 } else
5546 AnchorAlertOn2 = false;
5547
5548 if ((pAnchorWatchPoint1 || pAnchorWatchPoint2) && !bGPSValid)
5549 AnchorAlertOn1 = true;
5550}
5551
5552void MyFrame::SendFixToPlugins() {
5553 // Build and send a Position Fix event to PlugIns
5554 if (g_pi_manager) {
5555 GenericPosDatEx GPSData;
5556 GPSData.kLat = gLat;
5557 GPSData.kLon = gLon;
5558 GPSData.kCog = gCog;
5559 GPSData.kSog = gSog;
5560 GPSData.kVar = gVar;
5561 GPSData.kHdm = gHdm;
5562 GPSData.kHdt = gHdt;
5563 GPSData.nSats = g_SatsInView;
5564
5565 wxDateTime tCheck((time_t)m_fixtime);
5566 if (tCheck.IsValid()) {
5567 // As a special case, when no GNSS data is available, m_fixtime is set to
5568 // zero. Note wxDateTime(0) is valid, so the zero value is passed to the
5569 // plugins. The plugins should check for zero and not use the time in that
5570 // case.
5571 GPSData.FixTime = m_fixtime;
5572 } else {
5573 // Note: I don't think this is ever reached, as m_fixtime can never be set
5574 // to wxLongLong(wxINT64_MIN), which is the only way to get here.
5575 GPSData.FixTime = wxDateTime::Now().GetTicks();
5576 }
5577
5578 SendPositionFixToAllPlugIns(&GPSData);
5579 }
5580}
5581
5582void MyFrame::ProcessLogAndBells() {
5583 // Send current nav status data to log file on every half hour // pjotrc
5584 // 2010.02.09
5585 wxDateTime lognow = wxDateTime::Now(); // pjotrc 2010.02.09
5586 int hourLOC = lognow.GetHour();
5587 int minuteLOC = lognow.GetMinute();
5588 lognow.MakeGMT();
5589 int minuteUTC = lognow.GetMinute();
5590 int second = lognow.GetSecond();
5591
5592 wxTimeSpan logspan = lognow.Subtract(g_loglast_time);
5593 if ((logspan.IsLongerThan(wxTimeSpan(0, 30, 0, 0))) || (minuteUTC == 0) ||
5594 (minuteUTC == 30)) {
5595 if (logspan.IsLongerThan(wxTimeSpan(0, 1, 0, 0))) {
5596 wxString day = lognow.FormatISODate();
5597 wxString utc = lognow.FormatISOTime();
5598 wxString navmsg = _T("LOGBOOK: ");
5599 navmsg += day;
5600 navmsg += _T(" ");
5601 navmsg += utc;
5602 navmsg += _T(" UTC ");
5603
5604 if (bGPSValid) {
5605 wxString data;
5606 data.Printf(_T(" GPS Lat %10.5f Lon %10.5f "), gLat, gLon);
5607 navmsg += data;
5608
5609 wxString cog;
5610 if (std::isnan(gCog))
5611 cog.Printf(_T("COG ----- "));
5612 else
5613 cog.Printf(_T("COG %10.5f "), gCog);
5614
5615 wxString sog;
5616 if (std::isnan(gSog))
5617 sog.Printf(_T("SOG ----- "));
5618 else
5619 sog.Printf(_T("SOG %6.2f ") + getUsrSpeedUnit(), toUsrSpeed(gSog));
5620
5621 navmsg += cog;
5622 navmsg += sog;
5623 } else {
5624 wxString data;
5625 data.Printf(_T(" DR Lat %10.5f Lon %10.5f"), gLat, gLon);
5626 navmsg += data;
5627 }
5628 wxLogMessage(navmsg);
5629 g_loglast_time = lognow;
5630
5631 int bells = (hourLOC % 4) * 2; // 2 bells each hour
5632 if (minuteLOC != 0) bells++; // + 1 bell on 30 minutes
5633 if (!bells) bells = 8; // 0 is 8 bells
5634
5635 if (g_bPlayShipsBells && ((minuteLOC == 0) || (minuteLOC == 30))) {
5636 m_BellsToPlay = bells;
5637 wxCommandEvent ev(BELLS_PLAYED_EVTYPE);
5638 wxPostEvent(this, ev);
5639 }
5640 }
5641 }
5642}
5643
5644void MyFrame::OnFrameTimer1(wxTimerEvent &event) {
5645 CheckToolbarPosition();
5646
5647 ProcessUnitTest();
5648 g_tick++;
5649 ProcessQuitFlag();
5650
5651 if (bDBUpdateInProgress) return;
5652
5653 FrameTimer1.Stop();
5654 FrameTenHzTimer.Stop();
5655
5656 ProcessDeferredTrackOn();
5657 SendFixToPlugins();
5658 ProcessAnchorWatch();
5659 ProcessLogAndBells();
5660
5661 if (ShouldRestartTrack()) TrackDailyRestart();
5662
5663 // If no alerts are on, then safe to resume sleeping
5664 if (g_bSleep && !AnchorAlertOn1 && !AnchorAlertOn2) {
5665 FrameTimer1.Start(TIMER_GFRAME_1, wxTIMER_CONTINUOUS);
5666 FrameTenHzTimer.Start(100, wxTIMER_CONTINUOUS);
5667 return;
5668 }
5669
5670 // If gSog is greater than some threshold,
5671 // we determine that we are"cruising"
5672 if (gSog > 3.0) g_bCruising = true;
5673
5674 // Update the Toolbar Status windows and lower status bar
5675 // just after start of ticks.
5676
5677 if (g_tick == 2) {
5678 wxString sogcog(_T("SOG --- ") + getUsrSpeedUnit() + +_T(" ") +
5679 _T(" COG ---\u00B0"));
5680 if (GetStatusBar()) SetStatusText(sogcog, STAT_FIELD_SOGCOG);
5681
5682 gCog = 0.0; // say speed is zero to kill ownship predictor
5683 }
5684
5685 // Update the chart database and displayed chart
5686 bool bnew_view = false;
5687 if (!g_btenhertz) bnew_view = DoChartUpdate();
5688
5689 nBlinkerTick++;
5690
5691 // This call sends autopilot output strings to output ports.
5692 bool bactiveRouteUpdate = RoutemanGui(*g_pRouteMan).UpdateProgress();
5693
5694 // For each canvas....
5695 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
5696 ChartCanvas *cc = g_canvasArray.Item(i);
5697 if (cc) {
5698 cc->DrawBlinkObjects();
5699
5700 // Update the active route, if any, as determined above
5701 if (bactiveRouteUpdate) {
5702 // This RefreshRect will cause any active routepoint to blink
5703 if (g_pRouteMan->GetpActiveRoute())
5704 cc->RefreshRect(g_blink_rect, false);
5705 }
5706
5707 // Force own-ship drawing parameters
5708 cc->SetOwnShipState(SHIP_NORMAL);
5709
5710 if (cc->GetQuiltMode()) {
5711 double erf = cc->GetQuiltMaxErrorFactor();
5712 if (erf > 0.02) cc->SetOwnShipState(SHIP_LOWACCURACY);
5713 } else {
5714 if (cc->m_singleChart) {
5715 if (cc->m_singleChart->GetChart_Error_Factor() > 0.02)
5716 cc->SetOwnShipState(SHIP_LOWACCURACY);
5717 }
5718 }
5719
5720 if (!bGPSValid) cc->SetOwnShipState(SHIP_INVALID);
5721
5722 if ((bGPSValid != m_last_bGPSValid) ||
5723 (bVelocityValid != m_last_bVelocityValid) ||
5724 (!isnan(gHdt) && (gHdt != m_last_hdt))) {
5725 if (!g_bopengl) cc->UpdateShips();
5726
5727 bnew_view = true; // force a full Refresh()
5728 }
5729 }
5730 }
5731
5732 m_last_bGPSValid = bGPSValid;
5733 m_last_bVelocityValid = bVelocityValid;
5734 m_last_hdt = gHdt;
5735
5736 // If any PlugIn requested dynamic overlay callbacks, force a full canvas
5737 // refresh thus, ensuring at least 1 Hz. callback.
5738 bool brq_dynamic = false;
5739 if (g_pi_manager) {
5740 auto *pplugin_array = PluginLoader::getInstance()->GetPlugInArray();
5741 for (unsigned int i = 0; i < pplugin_array->GetCount(); i++) {
5742 PlugInContainer *pic = pplugin_array->Item(i);
5743 if (pic->m_enabled && pic->m_init_state) {
5744 if (pic->m_cap_flag & WANTS_DYNAMIC_OPENGL_OVERLAY_CALLBACK) {
5745 brq_dynamic = true;
5746 break;
5747 }
5748 }
5749 }
5750
5751 if (brq_dynamic) bnew_view = true;
5752 }
5753
5754 // Make sure we get a redraw and alert sound on AnchorWatch excursions.
5755 if (AnchorAlertOn1 || AnchorAlertOn2) bnew_view = true;
5756
5757 // For each canvas....
5758 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
5759 ChartCanvas *cc = g_canvasArray.Item(i);
5760 if (cc) {
5761 if (g_bopengl) {
5762#ifdef ocpnUSE_GL
5763 if (cc->GetglCanvas()) {
5764 // Rotation is handled by 10Hz timer, do not duplicate here
5765 bool b_rotate = cc->GetUpMode() != NORTH_UP_MODE;
5766 if (!b_rotate) {
5767 if (!g_btenhertz) {
5768 if (cc->m_bFollow) {
5769 cc->DoCanvasUpdate();
5770 if (bnew_view)
5771 cc->Refresh(false); // honor ownship state update
5772 } else
5773 cc->Refresh(false);
5774 } else {
5775 // Pick up SOG=0, COG=NAN report at 10Hz.
5776 if (std::isnan(gCog)) cc->Refresh(false);
5777 }
5778 }
5779 }
5780#endif
5781 } else {
5782 // Invalidate the ChartCanvas window appropriately
5783 // In non-follow mode, invalidate the rectangles containing the AIS
5784 // targets and the ownship, etc... In follow mode, if there has
5785 // already been a full screen refresh, there is no need to check
5786 // ownship or AIS,
5787 // since they will be always drawn on the full screen paint.
5788
5789 if ((!cc->m_bFollow) || (cc->GetUpMode() != NORTH_UP_MODE)) {
5790 cc->UpdateShips();
5791 cc->UpdateAIS();
5792 cc->UpdateAlerts();
5793 } else {
5794 if (!bnew_view) { // There has not been a Refresh() yet.....
5795 cc->UpdateAIS();
5796 cc->UpdateAlerts();
5797 }
5798 }
5799 }
5800 }
5801 }
5802
5803 if (g_pais_query_dialog_active && g_pais_query_dialog_active->IsShown())
5804 g_pais_query_dialog_active->UpdateText();
5805
5806 // Refresh AIS target list every 5 seconds to avoid blinking
5807 if (g_pAISTargetList && (0 == (g_tick % (5))))
5808 g_pAISTargetList->UpdateAISTargetList();
5809
5810 // Pick up any change Toolbar status displays
5811 UpdateGPSCompassStatusBoxes();
5812 UpdateAISTool();
5813
5814 if (console && console->IsShown()) {
5815 // console->Raise();
5816 console->RefreshConsoleData();
5817 }
5818
5819 // This little hack fixes a problem seen with some UniChrome OpenGL drivers
5820 // We need a deferred resize to get glDrawPixels() to work right.
5821 // So we set a trigger to generate a resize after 5 seconds....
5822 // See the "UniChrome" hack elsewhere
5823 if (m_bdefer_resize) {
5824 if (0 == (g_tick % (5))) {
5825 printf("___RESIZE\n");
5826 SetSize(m_defer_size);
5827 g_pauimgr->Update();
5828 m_bdefer_resize = false;
5829 }
5830 }
5831
5832#ifdef __ANDROID__
5833
5834 // Update the navobj file on a fixed schedule (5 minutes)
5835 // This will do nothing if the navobj.changes file is empty and clean
5836 if (((g_tick % g_FlushNavobjChangesTimeout) == 0) || g_FlushNavobjChanges) {
5837 if (pConfig && pConfig->IsChangesFileDirty()) {
5838 androidShowBusyIcon();
5839 wxStopWatch update_sw;
5840 pConfig->UpdateNavObj(true);
5841 wxString msg = wxString::Format(
5842 _T("OpenCPN periodic navobj update took %ld ms."), update_sw.Time());
5843 wxLogMessage(msg);
5844 qDebug() << msg.mb_str();
5845 g_FlushNavobjChanges = false;
5846 androidHideBusyIcon();
5847 }
5848 }
5849
5850#endif
5851
5852 // Reset pending next AppMsgBus notification
5853
5854 if (g_unit_test_2)
5855 FrameTimer1.Start(TIMER_GFRAME_1 * 3, wxTIMER_CONTINUOUS);
5856 else {
5857 FrameTimer1.Start(TIMER_GFRAME_1, wxTIMER_CONTINUOUS);
5858 FrameTenHzTimer.Start(100, wxTIMER_CONTINUOUS);
5859 }
5860}
5861
5862double MyFrame::GetMag(double a, double lat, double lon) {
5863 double Variance = std::isnan(gVar) ? g_UserVar : gVar;
5864 auto loader = PluginLoader::getInstance();
5865 if (loader && loader->IsPlugInAvailable(_T("WMM"))) {
5866 // Request variation at a specific lat/lon
5867
5868 // Note that the requested value is returned sometime later in the event
5869 // stream, so there may be invalid data returned on the first call to this
5870 // method. In the case of rollover windows, the value is requested
5871 // continuously, so will be correct very soon.
5872 wxDateTime now = wxDateTime::Now();
5873 SendJSON_WMM_Var_Request(lat, lon, now);
5874 if (fabs(gQueryVar) < 360.0) // Don't use WMM variance if not updated yet
5875 Variance = gQueryVar;
5876 }
5877 return toMagnetic(a, Variance);
5878}
5879
5880bool MyFrame::SendJSON_WMM_Var_Request(double lat, double lon,
5881 wxDateTime date) {
5882 if (g_pi_manager) {
5883 wxJSONValue v;
5884 v[_T("Lat")] = lat;
5885 v[_T("Lon")] = lon;
5886 v[_T("Year")] = date.GetYear();
5887 v[_T("Month")] = date.GetMonth();
5888 v[_T("Day")] = date.GetDay();
5889
5890 SendJSONMessageToAllPlugins(_T("WMM_VARIATION_REQUEST"), v);
5891 return true;
5892 } else
5893 return false;
5894}
5895
5896void MyFrame::TouchAISActive(void) {
5897 // .. for each canvas...
5898 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
5899 ChartCanvas *cc = g_canvasArray.Item(i);
5900 if (cc) cc->TouchAISToolActive();
5901 }
5902}
5903
5904void MyFrame::UpdateAISTool(void) {
5905 if (!g_pAIS) return;
5906
5907 // .. for each canvas...
5908 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
5909 ChartCanvas *cc = g_canvasArray.Item(i);
5910 if (cc) cc->UpdateAISTBTool();
5911 }
5912}
5913
5914// Cause refresh of active Tide/Current data, if displayed
5915void MyFrame::OnFrameTCTimer(wxTimerEvent &event) {
5916 // ..For each canvas...
5917 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
5918 ChartCanvas *cc = g_canvasArray.Item(i);
5919 if (cc) cc->SetbTCUpdate(true);
5920 }
5921
5922 RefreshAllCanvas(false);
5923}
5924
5925// Keep and update the Viewport rotation angle according to average COG for
5926// COGUP mode
5927void MyFrame::OnFrameCOGTimer(wxTimerEvent &event) {
5928 return;
5929
5930 // ..For each canvas...
5931 bool b_rotate = false;
5932 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
5933 ChartCanvas *cc = g_canvasArray.Item(i);
5934 if (cc) b_rotate |= (cc->GetUpMode() != NORTH_UP_MODE);
5935 }
5936
5937 if (!b_rotate) {
5938 FrameCOGTimer.Stop();
5939 return;
5940 }
5941
5942 DoCOGSet();
5943
5944 // Restart the timer, max frequency is 10 hz.
5945 int period_ms = 100;
5946 // if (g_COGAvgSec > 0) period_ms = g_COGAvgSec * 1000;
5947 FrameCOGTimer.Start(period_ms, wxTIMER_CONTINUOUS);
5948}
5949
5950void MyFrame::DoCOGSet(void) {
5951 // ..For each canvas...
5952 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
5953 ChartCanvas *cc = g_canvasArray.Item(i);
5954 if (cc) cc->DoCanvasCOGSet();
5955 }
5956}
5957
5958void RenderShadowText(wxDC *pdc, wxFont *pFont, wxString &str, int x, int y) {
5959#ifdef DrawText
5960#undef DrawText
5961#define FIXIT
5962#endif
5963
5964 wxFont oldfont = pdc->GetFont(); // save current font
5965
5966 pdc->SetFont(*pFont);
5967 pdc->SetTextForeground(GetGlobalColor(_T("CHGRF")));
5968 pdc->SetBackgroundMode(wxTRANSPARENT);
5969
5970 pdc->DrawText(str, x, y + 1);
5971 pdc->DrawText(str, x, y - 1);
5972 pdc->DrawText(str, x + 1, y);
5973 pdc->DrawText(str, x - 1, y);
5974
5975 pdc->SetTextForeground(GetGlobalColor(_T("CHBLK")));
5976
5977 pdc->DrawText(str, x, y);
5978
5979 pdc->SetFont(oldfont); // restore last font
5980}
5981
5982// TODO How does this relate to per-canvas rotation?
5983void MyFrame::UpdateRotationState(double rotation) {
5984 // If rotated manually, we switch to NORTHUP
5985 g_bCourseUp = false;
5986
5987 if (fabs(rotation) > .001) {
5988 SetMenubarItemState(ID_MENU_CHART_COGUP, false);
5989 SetMenubarItemState(ID_MENU_CHART_NORTHUP, true);
5990 if (m_pMenuBar) {
5991 m_pMenuBar->SetLabel(ID_MENU_CHART_NORTHUP, _("Rotated Mode"));
5992 }
5993 } else {
5994 SetMenubarItemState(ID_MENU_CHART_COGUP, g_bCourseUp);
5995 SetMenubarItemState(ID_MENU_CHART_NORTHUP, !g_bCourseUp);
5996 if (m_pMenuBar) {
5997 m_pMenuBar->SetLabel(ID_MENU_CHART_NORTHUP, _("North Up Mode"));
5998 }
5999 }
6000
6001 UpdateGPSCompassStatusBoxes(true);
6002 DoChartUpdate();
6003}
6004
6005void MyFrame::UpdateGPSCompassStatusBoxes(bool b_force_new) {
6006 // ..For each canvas...
6007 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
6008 ChartCanvas *cc = g_canvasArray.Item(i);
6009 if (cc) cc->UpdateGPSCompassStatusBox(b_force_new);
6010 }
6011}
6012
6013// Application memory footprint management
6014
6015int MyFrame::GetApplicationMemoryUse(void) {
6016 int memsize = -1;
6017#ifdef __linux__
6018
6019 // Use a contrived ps command to get the virtual memory size associated
6020 // with this process
6021 wxWindow *fWin = wxWindow::FindFocus();
6022
6023 wxArrayString outputArray;
6024 wxString cmd(_T("ps --no-headers -o vsize "));
6025 unsigned long pid = wxGetProcessId();
6026 wxString cmd1;
6027 cmd1.Printf(_T("%ld"), pid);
6028 cmd += cmd1;
6029 wxExecute(cmd, outputArray);
6030
6031 if (outputArray.GetCount()) {
6032 wxString s = outputArray.Item(0);
6033 long vtmp;
6034 if (s.ToLong(&vtmp)) memsize = vtmp;
6035 }
6036
6037 if (fWin) fWin->SetFocus();
6038
6039#endif
6040
6041#ifdef __WXMSW__
6042 HANDLE hProcess;
6043 PROCESS_MEMORY_COUNTERS pmc;
6044
6045 unsigned long processID = wxGetProcessId();
6046
6047 hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE,
6048 processID);
6049 if (NULL == hProcess) return 0;
6050
6051 if (GetProcessMemoryInfo(hProcess, &pmc, sizeof(pmc))) {
6052 /*
6053 printf( "\tPageFaultCount: 0x%08X\n", pmc.PageFaultCount );
6054 printf( "\tPeakWorkingSetSize: 0x%08X\n",
6055 pmc.PeakWorkingSetSize );
6056 printf( "\tWorkingSetSize: 0x%08X\n", pmc.WorkingSetSize );
6057 printf( "\tQuotaPeakPagedPoolUsage: 0x%08X\n",
6058 pmc.QuotaPeakPagedPoolUsage );
6059 printf( "\tQuotaPagedPoolUsage: 0x%08X\n",
6060 pmc.QuotaPagedPoolUsage );
6061 printf( "\tQuotaPeakNonPagedPoolUsage: 0x%08X\n",
6062 pmc.QuotaPeakNonPagedPoolUsage );
6063 printf( "\tQuotaNonPagedPoolUsage: 0x%08X\n",
6064 pmc.QuotaNonPagedPoolUsage );
6065 printf( "\tPagefileUsage: 0x%08X\n", pmc.PagefileUsage );
6066 printf( "\tPeakPagefileUsage: 0x%08X\n",
6067 pmc.PeakPagefileUsage );
6068 */
6069 memsize = pmc.WorkingSetSize / 1024;
6070 }
6071
6072 CloseHandle(hProcess);
6073
6074#endif
6075
6076 return memsize;
6077}
6078
6079double MyFrame::GetBestVPScale(ChartBase *pchart) {
6080 return GetPrimaryCanvas()->GetBestVPScale(pchart);
6081}
6082
6083void MyFrame::SetChartUpdatePeriod() {
6084 // Set the chart update period based upon chart skew and skew compensator
6085
6086 g_ChartUpdatePeriod = 0; // General default
6087
6088 // In non-GL, singlele-chart mode, rotation of skewed charts is very slow
6089 // So we need to use a slower update time constant to preserve adequate UI
6090 // performance
6091 bool bskewdc = false;
6092 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
6093 ChartCanvas *cc = g_canvasArray.Item(i);
6094 if (cc) {
6095 if (!g_bopengl && !cc->GetVP().b_quilt) {
6096 if (fabs(cc->GetVP().skew) > 0.0001) bskewdc = true;
6097 }
6098 if (cc->m_bFollow) g_ChartUpdatePeriod = 1;
6099 }
6100 }
6101
6102 if (bskewdc) g_ChartUpdatePeriod = g_SkewCompUpdatePeriod;
6103
6104 m_ChartUpdatePeriod = g_ChartUpdatePeriod;
6105}
6106
6107void MyFrame::UpdateControlBar(ChartCanvas *cc) {
6108 if (!cc) return;
6109 cc->UpdateCanvasControlBar();
6110}
6111
6112void MyFrame::selectChartDisplay(int type, int family) {
6113 // ..For each canvas...
6114 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
6115 ChartCanvas *cc = g_canvasArray.Item(i);
6116 if (cc) cc->selectCanvasChartDisplay(type, family);
6117 }
6118
6119 UpdateGlobalMenuItems(); // update the state of the menu items (checkmarks
6120 // etc.)
6121}
6122
6123//----------------------------------------------------------------------------------
6124// DoChartUpdate
6125// Create a chartstack based on current lat/lon.
6126// Return true if a Refresh(false) was called within.
6127//----------------------------------------------------------------------------------
6128bool MyFrame::DoChartUpdate(void) {
6129 bool return_val = false;
6130
6131 // ..For each canvas...
6132 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
6133 ChartCanvas *cc = g_canvasArray.Item(i);
6134 if (cc) return_val |= cc->DoCanvasUpdate();
6135 }
6136
6137 return return_val;
6138}
6139
6140void MyFrame::MouseEvent(wxMouseEvent &event) {
6141 int x, y;
6142 event.GetPosition(&x, &y);
6143}
6144
6145// Memory monitor support
6146#ifdef __WXMAC__
6147#include <mach/mach.h>
6148#include <mach/message.h> // for mach_msg_type_number_t
6149#include <mach/kern_return.h> // for kern_return_t
6150#include <mach/task_info.h>
6151#include <stdio.h>
6152#include <malloc/malloc.h>
6153#endif
6154
6155#ifdef __WXGTK__
6156#include <malloc.h>
6157#endif
6158
6159#if defined(__linux__)
6160#include "sys/types.h"
6161#include "sys/sysinfo.h"
6162#endif /* __linux__ */
6163
6164int g_lastMemTick = -1;
6165
6166/* Return total system RAM and size of program */
6167/* Values returned are in kilobytes */
6168bool GetMemoryStatus(int *mem_total, int *mem_used) {
6169#ifdef __ANDROID__
6170 return androidGetMemoryStatus(mem_total, mem_used);
6171#endif
6172
6173#if defined(__linux__)
6174 // Use sysinfo to obtain total RAM
6175 if (mem_total) {
6176 *mem_total = 0;
6177 struct sysinfo sys_info;
6178 if (sysinfo(&sys_info) != -1)
6179 *mem_total = ((uint64_t)sys_info.totalram * sys_info.mem_unit) / 1024;
6180 }
6181 // Use filesystem /proc/self/statm to determine memory status
6182 // Provides information about memory usage, measured in pages. The columns
6183 // are: size total program size (same as VmSize in /proc/[pid]/status)
6184 // resident resident set size (same as VmRSS in /proc/[pid]/status)
6185 // share shared pages (from shared mappings)
6186 // text text (code)
6187 // lib library (unused in Linux 2.6)
6188 // data data + stack
6189 // dt dirty pages (unused in Linux 2.6)
6190
6191 if (mem_used) {
6192 *mem_used = 0;
6193 FILE *file = fopen("/proc/self/statm", "r");
6194 if (file) {
6195 if (fscanf(file, "%d", mem_used) != 1) {
6196 wxLogWarning("Cannot parse /proc/self/statm (!)");
6197 }
6198 *mem_used *= 4; // XXX assume 4K page
6199 fclose(file);
6200 }
6201 }
6202
6203 return true;
6204
6205#endif /* __linux__ */
6206
6207#ifdef __WXMSW__
6208 HANDLE hProcess;
6209 PROCESS_MEMORY_COUNTERS pmc;
6210
6211 unsigned long processID = wxGetProcessId();
6212
6213 if (mem_used) {
6214 hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE,
6215 processID);
6216
6217 if (hProcess && GetProcessMemoryInfo(hProcess, &pmc, sizeof(pmc))) {
6218 /*
6219 printf( "\tPageFaultCount: 0x%08X\n", pmc.PageFaultCount );
6220 printf( "\tPeakWorkingSetSize: 0x%08X\n",
6221 pmc.PeakWorkingSetSize );
6222 printf( "\tWorkingSetSize: 0x%08X\n", pmc.WorkingSetSize );
6223 printf( "\tQuotaPeakPagedPoolUsage: 0x%08X\n",
6224 pmc.QuotaPeakPagedPoolUsage );
6225 printf( "\tQuotaPagedPoolUsage: 0x%08X\n",
6226 pmc.QuotaPagedPoolUsage );
6227 printf( "\tQuotaPeakNonPagedPoolUsage: 0x%08X\n",
6228 pmc.QuotaPeakNonPagedPoolUsage );
6229 printf( "\tQuotaNonPagedPoolUsage: 0x%08X\n",
6230 pmc.QuotaNonPagedPoolUsage );
6231 printf( "\tPagefileUsage: 0x%08X\n", pmc.PagefileUsage );
6232 printf( "\tPeakPagefileUsage: 0x%08X\n",
6233 pmc.PeakPagefileUsage );
6234 */
6235 *mem_used = pmc.WorkingSetSize / 1024;
6236 }
6237
6238 CloseHandle(hProcess);
6239 }
6240
6241 if (mem_total) {
6242 MEMORYSTATUSEX statex;
6243
6244 statex.dwLength = sizeof(statex);
6245
6246 GlobalMemoryStatusEx(&statex);
6247 /*
6248 _tprintf (TEXT("There is %*ld percent of memory in use.\n"),
6249 WIDTH, statex.dwMemoryLoad);
6250 _tprintf (TEXT("There are %*I64d total Kbytes of physical memory.\n"),
6251 WIDTH, statex.ullTotalPhys/DIV);
6252 _tprintf (TEXT("There are %*I64d free Kbytes of physical memory.\n"),
6253 WIDTH, statex.ullAvailPhys/DIV);
6254 _tprintf (TEXT("There are %*I64d total Kbytes of paging file.\n"),
6255 WIDTH, statex.ullTotalPageFile/DIV);
6256 _tprintf (TEXT("There are %*I64d free Kbytes of paging file.\n"),
6257 WIDTH, statex.ullAvailPageFile/DIV);
6258 _tprintf (TEXT("There are %*I64d total Kbytes of virtual memory.\n"),
6259 WIDTH, statex.ullTotalVirtual/DIV);
6260 _tprintf (TEXT("There are %*I64d free Kbytes of virtual memory.\n"),
6261 WIDTH, statex.ullAvailVirtual/DIV);
6262 */
6263
6264 *mem_total = statex.ullTotalPhys / 1024;
6265 }
6266 return true;
6267#endif
6268
6269#ifdef __WXMAC__
6270
6271 if (g_tick != g_lastMemTick) {
6272 malloc_zone_pressure_relief(NULL, 0);
6273
6274 int bytesInUse = 0;
6275 int blocksInUse = 0;
6276 int sizeAllocated = 0;
6277
6278 malloc_statistics_t stats;
6279 stats.blocks_in_use = 0;
6280 stats.size_in_use = 0;
6281 stats.max_size_in_use = 0;
6282 stats.size_allocated = 0;
6283 malloc_zone_statistics(NULL, &stats);
6284 bytesInUse += stats.size_in_use;
6285 blocksInUse += stats.blocks_in_use;
6286 sizeAllocated += stats.size_allocated;
6287
6288 g_memUsed = sizeAllocated >> 10;
6289
6290 // printf("mem_used (Mb): %d %d \n", g_tick, g_memUsed / 1024);
6291 g_lastMemTick = g_tick;
6292 }
6293
6294 if (mem_used) *mem_used = g_memUsed;
6295 if (mem_total) {
6296 *mem_total = 4000;
6297 FILE *fpIn = popen("sysctl -n hw.memsize", "r");
6298 if (fpIn) {
6299 double pagesUsed = 0.0, totalPages = 0.0;
6300 char buf[64];
6301 if (fgets(buf, sizeof(buf), fpIn) != NULL) {
6302 *mem_total = atol(buf) >> 10;
6303 }
6304 }
6305 }
6306
6307 return true;
6308#endif
6309
6310 if (mem_used) *mem_used = 0;
6311 if (mem_total) *mem_total = 0;
6312 return false;
6313}
6314
6315void MyFrame::DoPrint(void) {
6316 // avoid toolbars being printed
6317 g_PrintingInProgress = true;
6318#ifdef ocpnUSE_GL
6319 if (g_bopengl) {
6320 GetPrimaryCanvas()->GetglCanvas()->Render();
6321 GetPrimaryCanvas()->GetglCanvas()->SwapBuffers();
6322 } else
6323#endif
6324 Refresh();
6325
6326 ChartPrintout printout;
6327 if (g_bopengl) {
6328 printout.GenerateGLbmp();
6329 }
6330 auto &printer = PrintDialog::GetInstance();
6331 printer.Initialize(wxLANDSCAPE);
6332 printer.EnablePageNumbers(false);
6333 printer.Print(this, &printout);
6334
6335 // Pass two printout objects: for preview, and possible printing.
6336 /*
6337 wxPrintDialogData printDialogData(* g_printData);
6338 wxPrintPreview *preview = new wxPrintPreview(new MyPrintout, new
6339 MyPrintout, & printDialogData); if (!preview->Ok())
6340 {
6341 delete preview;
6342 OCPNMessageBox(_T("There was a problem previewing.\nPerhaps your current
6343 printer is not set correctly?"), _T("Previewing"), wxOK); return;
6344 }
6345
6346 wxPreviewFrame *frame = new wxPreviewFrame(preview, this, _T("Demo Print
6347 Preview"), wxPoint(100, 100), wxSize(600, 650)); frame->Centre(wxBOTH);
6348 frame->Initialize();
6349 frame->Show();
6350 */
6351 g_PrintingInProgress = false;
6352 Refresh();
6353#ifdef __WXGTK__
6354 GetPrimaryCanvas()->SetFocus();
6355 Raise(); // I dunno why...
6356#endif
6357}
6358
6359wxDateTime gTimeSource;
6360
6361void MyFrame::OnEvtPlugInMessage(OCPN_MsgEvent &event) {
6362 wxString message_ID = event.GetID();
6363 wxString message_JSONText = event.GetJSONText();
6364
6365 // We are free to use or ignore any or all of the PlugIn messages flying
6366 // through this pipe tee.
6367
6368 // We can possibly use the estimated magnetic variation if WMM_pi is
6369 // present, active, and we have no other source of Variation
6370 if (!g_bVAR_Rx) {
6371 if (message_ID == _T("WMM_VARIATION_BOAT")) {
6372 // construct the JSON root object
6373 wxJSONValue root;
6374 // construct a JSON parser
6375 wxJSONReader reader;
6376
6377 // now read the JSON text and store it in the 'root' structure
6378 // check for errors before retreiving values...
6379 int numErrors = reader.Parse(message_JSONText, &root);
6380 if (numErrors > 0) {
6381 // const wxArrayString& errors = reader.GetErrors();
6382 return;
6383 }
6384
6385 // get the DECL value from the JSON message
6386 wxString decl = root[_T("Decl")].AsString();
6387 double decl_val;
6388 decl.ToDouble(&decl_val);
6389
6390 gVar = decl_val;
6391 }
6392 }
6393
6394 if (message_ID == _T("WMM_VARIATION")) {
6395 // construct the JSON root object
6396 wxJSONValue root;
6397 // construct a JSON parser
6398 wxJSONReader reader;
6399
6400 // now read the JSON text and store it in the 'root' structure
6401 // check for errors before retreiving values...
6402 int numErrors = reader.Parse(message_JSONText, &root);
6403 if (numErrors > 0) {
6404 // const wxArrayString& errors = reader.GetErrors();
6405 return;
6406 }
6407
6408 // get the DECL value from the JSON message
6409 wxString decl = root[_T("Decl")].AsString();
6410 double decl_val;
6411 decl.ToDouble(&decl_val);
6412
6413 gQueryVar = decl_val;
6414 }
6415
6416 if (message_ID == _T("GRIB_TIMELINE")) {
6417 wxJSONReader r;
6418 wxJSONValue v;
6419 r.Parse(message_JSONText, &v);
6420 if (v[_T("Day")].AsInt() == -1)
6421 gTimeSource = wxInvalidDateTime;
6422 else
6423 gTimeSource.Set(v[_T("Day")].AsInt(),
6424 (wxDateTime::Month)v[_T("Month")].AsInt(),
6425 v[_T("Year")].AsInt(), v[_T("Hour")].AsInt(),
6426 v[_T("Minute")].AsInt(), v[_T("Second")].AsInt());
6427 }
6428 if (message_ID == _T("OCPN_TRACK_REQUEST")) {
6429 wxJSONValue root;
6430 wxJSONReader reader;
6431 wxString trk_id = wxEmptyString;
6432
6433 int numErrors = reader.Parse(message_JSONText, &root);
6434 if (numErrors > 0) return;
6435
6436 if (root.HasMember(_T("Track_ID")))
6437 trk_id = root[_T("Track_ID")].AsString();
6438
6439 wxJSONValue v;
6440 v[_T("Track_ID")] = trk_id;
6441 for (Track *ptrack : g_TrackList) {
6442 wxString name = wxEmptyString;
6443 if (ptrack->m_GUID == trk_id) {
6444 name = ptrack->GetName();
6445 if (name.IsEmpty()) {
6446 TrackPoint *rp = ptrack->GetPoint(0);
6447 if (rp && rp->GetCreateTime().IsValid())
6448 name = rp->GetCreateTime().FormatISODate() + _T(" ") +
6449 rp->GetCreateTime().FormatISOTime();
6450 else
6451 name = _("(Unnamed Track)");
6452 }
6453
6454 /* To avoid memory problems send a single trackpoint.
6455 * It's up to the plugin to collect the data. */
6456 int i = 1;
6457 v[_T("error")] = false;
6458 v[_T("TotalNodes")] = ptrack->GetnPoints();
6459 for (int j = 0; j < ptrack->GetnPoints(); j++) {
6460 TrackPoint *tp = ptrack->GetPoint(j);
6461 v[_T("lat")] = tp->m_lat;
6462 v[_T("lon")] = tp->m_lon;
6463 v[_T("NodeNr")] = i;
6464 i++;
6465 wxString msg_id(_T("OCPN_TRACKPOINTS_COORDS"));
6466 SendJSONMessageToAllPlugins(msg_id, v);
6467 }
6468 return;
6469 }
6470 v[_T("error")] = true;
6471
6472 wxString msg_id(_T("OCPN_TRACKPOINTS_COORDS"));
6473 SendJSONMessageToAllPlugins(msg_id, v);
6474 }
6475 } else if (message_ID == _T("OCPN_ROUTE_REQUEST")) {
6476 wxJSONValue root;
6477 wxJSONReader reader;
6478 wxString guid = wxEmptyString;
6479
6480 int numErrors = reader.Parse(message_JSONText, &root);
6481 if (numErrors > 0) {
6482 return;
6483 }
6484
6485 if (root.HasMember(_T("GUID"))) guid = root[_T("GUID")].AsString();
6486
6487 wxJSONValue v;
6488 v[_T("GUID")] = guid;
6489 for (RouteList::iterator it = pRouteList->begin(); it != pRouteList->end();
6490 it++) {
6491 wxString name = wxEmptyString;
6492
6493 if ((*it)->m_GUID == guid) {
6494 name = (*it)->m_RouteNameString;
6495 if (name.IsEmpty()) name = _("(Unnamed Route)");
6496
6497 v[_T("Name")] = name;
6498 v[_T("error")] = false;
6499 wxJSONValue w;
6500 int i = 0;
6501 for (RoutePointList::iterator itp = (*it)->pRoutePointList->begin();
6502 itp != (*it)->pRoutePointList->end(); itp++) {
6503 w[i][_T("lat")] = (*itp)->m_lat;
6504 w[i][_T("lon")] = (*itp)->m_lon;
6505 w[i][_T("Name")] = (*itp)->GetName();
6506 w[i][_T("Description")] = (*itp)->GetDescription();
6507 w[i][_T("GUID")] = (*itp)->m_GUID;
6508 w[i][_T("ArrivalRadius")] = (*itp)->GetWaypointArrivalRadius();
6509 wxHyperlinkListNode *node = (*itp)->m_HyperlinkList->GetFirst();
6510 if (node) {
6511 int n = 1;
6512 while (node) {
6513 Hyperlink *httpLink = node->GetData();
6514 v[i][_T("WPLink") + wxString::Format(_T("%d"), n)] =
6515 httpLink->Link;
6516 v[i][_T("WPLinkDesciption") + wxString::Format(_T("%d"), n++)] =
6517 httpLink->DescrText;
6518 node = node->GetNext();
6519 }
6520 }
6521 i++;
6522 }
6523 v[_T("waypoints")] = w;
6524 wxString msg_id(_T("OCPN_ROUTE_RESPONSE"));
6525 SendJSONMessageToAllPlugins(msg_id, v);
6526 return;
6527 }
6528 }
6529
6530 v[_T("error")] = true;
6531
6532 wxString msg_id(_T("OCPN_ROUTE_RESPONSE"));
6533 SendJSONMessageToAllPlugins(msg_id, v);
6534 } else if (message_ID == _T("OCPN_ROUTELIST_REQUEST")) {
6535 wxJSONValue root;
6536 wxJSONReader reader;
6537 bool route = true;
6538
6539 int numErrors = reader.Parse(message_JSONText, &root);
6540 if (numErrors > 0) return;
6541
6542 if (root.HasMember(_T("mode"))) {
6543 wxString str = root[_T("mode")].AsString();
6544 if (str == _T("Track")) route = false;
6545
6546 wxJSONValue v;
6547 int i = 1;
6548 if (route) {
6549 for (RouteList::iterator it = pRouteList->begin();
6550 it != pRouteList->end(); it++) {
6551 wxString name = (*it)->m_RouteNameString;
6552 if (name.IsEmpty()) name = _("(Unnamed Route)");
6553
6554 v[i][_T("error")] = false;
6555 v[i][_T("name")] = name;
6556 v[i][_T("GUID")] = (*it)->m_GUID;
6557 v[i][_T("active")] = (*it)->IsActive();
6558 i++;
6559 }
6560 } else { // track
6561 for (Track *ptrack : g_TrackList) {
6562 wxString name = ptrack->GetName();
6563 if (name.IsEmpty()) {
6564 TrackPoint *tp = ptrack->GetPoint(0);
6565 if (tp && tp->GetCreateTime().IsValid())
6566 name = tp->GetCreateTime().FormatISODate() + _T(" ") +
6567 tp->GetCreateTime().FormatISOTime();
6568 else
6569 name = _("(Unnamed Track)");
6570 }
6571 v[i][_T("error")] = false;
6572 v[i][_T("name")] = name;
6573 v[i][_T("GUID")] = ptrack->m_GUID;
6574 v[i][_T("active")] = g_pActiveTrack == ptrack;
6575 i++;
6576 }
6577 }
6578 wxString msg_id(_T("OCPN_ROUTELIST_RESPONSE"));
6579 SendJSONMessageToAllPlugins(msg_id, v);
6580 } else {
6581 wxJSONValue v;
6582 v[0][_T("error")] = true;
6583 wxString msg_id(_T("OCPN_ROUTELIST_RESPONSE"));
6584 SendJSONMessageToAllPlugins(msg_id, v);
6585 }
6586 } else if (message_ID == _T("OCPN_ACTIVE_ROUTELEG_REQUEST")) {
6587 wxJSONValue v;
6588 v[0][_T("error")] = true;
6589 if (g_pRouteMan->GetpActiveRoute()) {
6590 if (g_pRouteMan->m_bDataValid) {
6591 v[0][_T("error")] = false;
6592 v[0][_T("range")] = g_pRouteMan->GetCurrentRngToActivePoint();
6593 v[0][_T("bearing")] = g_pRouteMan->GetCurrentBrgToActivePoint();
6594 v[0][_T("XTE")] = g_pRouteMan->GetCurrentXTEToActivePoint();
6595 v[0][_T("active_route_GUID")] =
6596 g_pRouteMan->GetpActiveRoute()->GetGUID();
6597 v[0][_T("active_waypoint_lat")] =
6598 g_pRouteMan->GetpActiveRoute()->m_pRouteActivePoint->GetLatitude();
6599 v[0][_T("active_waypoint_lon")] =
6600 g_pRouteMan->GetpActiveRoute()->m_pRouteActivePoint->GetLongitude();
6601 }
6602 }
6603 wxString msg_id(_T("OCPN_ACTIVE_ROUTELEG_RESPONSE"));
6604 SendJSONMessageToAllPlugins(msg_id, v);
6605 }
6606}
6607
6608void MyFrame::FilterCogSog(void) {
6609 if (g_bfilter_cogsog && !g_own_ship_sog_cog_calc) {
6610 // Simple averaging filter for COG
6611 double cog_last = gCog; // most recent reported value
6612
6613 // Make a hole in array
6614 for (int i = g_COGFilterSec - 1; i > 0; i--)
6615 COGFilterTable[i] = COGFilterTable[i - 1];
6616 COGFilterTable[0] = cog_last;
6617
6618 // If the lastest data is undefined, leave it
6619 if (!std::isnan(cog_last)) {
6620 //
6621 double sum = 0., count = 0;
6622 for (int i = 0; i < g_COGFilterSec; i++) {
6623 double adder = COGFilterTable[i];
6624 if (std::isnan(adder)) continue;
6625
6626 if (fabs(adder - cog_last) > 180.) {
6627 if ((adder - cog_last) > 0.)
6628 adder -= 360.;
6629 else
6630 adder += 360.;
6631 }
6632
6633 sum += adder;
6634 count++;
6635 }
6636 sum /= count;
6637
6638 if (sum < 0.)
6639 sum += 360.;
6640 else if (sum >= 360.)
6641 sum -= 360.;
6642
6643 gCog = sum;
6644 }
6645
6646 // Simple averaging filter for SOG
6647 double sog_last = gSog; // most recent reported value
6648
6649 // Make a hole in array
6650 for (int i = g_SOGFilterSec - 1; i > 0; i--)
6651 SOGFilterTable[i] = SOGFilterTable[i - 1];
6652 SOGFilterTable[0] = sog_last;
6653
6654 // If the data are undefined, leave the array intact
6655 if (!std::isnan(gSog)) {
6656 double sum = 0., count = 0;
6657 for (int i = 0; i < g_SOGFilterSec; i++) {
6658 if (std::isnan(SOGFilterTable[i])) continue;
6659
6660 sum += SOGFilterTable[i];
6661 count++;
6662 }
6663 sum /= count;
6664
6665 gSog = sum;
6666 }
6667 }
6668}
6669
6670void MyFrame::LoadHarmonics() {
6671 if (!ptcmgr) {
6672 ptcmgr = new TCMgr;
6673 ptcmgr->LoadDataSources(TideCurrentDataSet);
6674 } else {
6675 bool b_newdataset = false;
6676
6677 // Test both ways
6678 for (auto a : ptcmgr->GetDataSet()) {
6679 bool b_foundi = false;
6680 for (auto b : TideCurrentDataSet) {
6681 if (a == b) {
6682 b_foundi = true;
6683 break; // j loop
6684 }
6685 }
6686 if (!b_foundi) {
6687 b_newdataset = true;
6688 break; // i loop
6689 }
6690 }
6691
6692 for (auto a : TideCurrentDataSet) {
6693 bool b_foundi = false;
6694 for (auto b : ptcmgr->GetDataSet()) {
6695 if (a == b) {
6696 b_foundi = true;
6697 break; // j loop
6698 }
6699 }
6700 if (!b_foundi) {
6701 b_newdataset = true;
6702 break; // i loop
6703 }
6704 }
6705
6706 if (b_newdataset) ptcmgr->LoadDataSources(TideCurrentDataSet);
6707 }
6708}
6709
6710void MyFrame::ActivateAISMOBRoute(const AisTargetData *ptarget) {
6711 if (!ptarget) return;
6712
6713 // The MOB point
6714 wxDateTime mob_time = wxDateTime::Now();
6715 wxString mob_label(_("AIS MAN OVERBOARD"));
6716 mob_label += _(" on ");
6717 mob_label += ocpn::toUsrDateTimeFormat(mob_time);
6718
6719 RoutePoint *pWP_MOB = new RoutePoint(ptarget->Lat, ptarget->Lon, _T ( "mob" ),
6720 mob_label, wxEmptyString);
6721 pWP_MOB->SetShared(true);
6722 pWP_MOB->m_bIsolatedMark = true;
6723 pSelect->AddSelectableRoutePoint(ptarget->Lat, ptarget->Lon, pWP_MOB);
6724 pConfig->AddNewWayPoint(pWP_MOB, -1); // use auto next num
6725 pWP_MOB->SetUseSca(false); // Do not use scaled hiding for MOB
6726
6727 /* We want to start tracking any MOB in range (Which will trigger false alarms
6728 with messages received over the network etc., but will a) not discard nearby
6729 event even in case our GPS is momentarily unavailable and b) work even when
6730 the boat is stationary, in which case some GPS units do not provide COG) if(
6731 bGPSValid && !std::isnan(gCog) && !std::isnan(gSog) ) { */
6732 RoutePoint *pWP_src = new RoutePoint(gLat, gLon, g_default_wp_icon,
6733 wxString(_("Own ship")), wxEmptyString);
6734 pSelect->AddSelectableRoutePoint(gLat, gLon, pWP_src);
6735 pWP_MOB->SetUseSca(false); // Do not use scaled hiding for MOB
6736 pAISMOBRoute = new Route();
6737 pRouteList->Append(pAISMOBRoute);
6738
6739 pAISMOBRoute->AddPoint(pWP_src);
6740 pAISMOBRoute->AddPoint(pWP_MOB);
6741
6742 pSelect->AddSelectableRouteSegment(ptarget->Lat, ptarget->Lon, gLat, gLon,
6743 pWP_src, pWP_MOB, pAISMOBRoute);
6744
6745 pAISMOBRoute->m_RouteNameString = _("Temporary AISMOB Route");
6746 pAISMOBRoute->m_RouteStartString = _("Present own ship");
6747 pAISMOBRoute->m_RouteEndString = mob_label;
6748
6749 pAISMOBRoute->m_bDeleteOnArrival = false;
6750
6751 pAISMOBRoute->SetRouteArrivalRadius(-1.0); // never arrives
6752
6753 if (g_pRouteMan->GetpActiveRoute()) g_pRouteMan->DeactivateRoute();
6754 // g_pRouteMan->ActivateRoute( pAISMOBRoute, pWP_MOB );
6755
6756 wxJSONValue v;
6757 v[_T("GUID")] = pAISMOBRoute->m_GUID;
6758 wxString msg_id(_T("OCPN_MAN_OVERBOARD"));
6759 SendJSONMessageToAllPlugins(msg_id, v);
6760 //}
6761
6762 if (RouteManagerDialog::getInstanceFlag()) {
6763 if (pRouteManagerDialog && pRouteManagerDialog->IsShown()) {
6764 pRouteManagerDialog->UpdateRouteListCtrl();
6765 pRouteManagerDialog->UpdateWptListCtrl();
6766 }
6767 }
6768
6769 RefreshAllCanvas(false);
6770
6771 wxString mob_message(_("AIS MAN OVERBOARD"));
6772 mob_message += _(" Time: ");
6773 mob_message += ocpn::toUsrDateTimeFormat(mob_time);
6774 mob_message += _(" Ownship Position: ");
6775 mob_message += toSDMM(1, gLat);
6776 mob_message += _T(" ");
6777 mob_message += toSDMM(2, gLon);
6778 mob_message += _(" MOB Position: ");
6779 mob_message += toSDMM(1, ptarget->Lat);
6780 mob_message += _T(" ");
6781 mob_message += toSDMM(2, ptarget->Lon);
6782 wxLogMessage(mob_message);
6783}
6784
6785void MyFrame::UpdateAISMOBRoute(const AisTargetData *ptarget) {
6786 if (pAISMOBRoute && ptarget) {
6787 // Update Current Ownship point
6788 RoutePoint *OwnPoint = pAISMOBRoute->GetPoint(1);
6789 OwnPoint->m_lat = gLat;
6790 OwnPoint->m_lon = gLon;
6791
6792 pSelect->DeleteSelectableRoutePoint(OwnPoint);
6793 pSelect->AddSelectableRoutePoint(gLat, gLon, OwnPoint);
6794
6795 // Update Current MOB point
6796 RoutePoint *MOB_Point = pAISMOBRoute->GetPoint(2);
6797 MOB_Point->m_lat = ptarget->Lat;
6798 MOB_Point->m_lon = ptarget->Lon;
6799
6800 pSelect->DeleteSelectableRoutePoint(MOB_Point);
6801 pSelect->AddSelectableRoutePoint(ptarget->Lat, ptarget->Lon, MOB_Point);
6802
6803 pSelect->UpdateSelectableRouteSegments(OwnPoint);
6804 pSelect->UpdateSelectableRouteSegments(MOB_Point);
6805 }
6806
6807 RefreshAllCanvas(false);
6808
6809 if (ptarget) {
6810 wxDateTime mob_time = wxDateTime::Now();
6811
6812 wxString mob_message(_("AIS MAN OVERBOARD UPDATE"));
6813 mob_message += _(" Time: ");
6814 mob_message += ocpn::toUsrDateTimeFormat(mob_time);
6815 mob_message += _(" Ownship Position: ");
6816 mob_message += toSDMM(1, gLat);
6817 mob_message += _T(" ");
6818 mob_message += toSDMM(2, gLon);
6819 mob_message += _(" MOB Position: ");
6820 mob_message += toSDMM(1, ptarget->Lat);
6821 mob_message += _T(" ");
6822 mob_message += toSDMM(2, ptarget->Lon);
6823
6824 wxLogMessage(mob_message);
6825 }
6826}
6827
6828void MyFrame::applySettingsString(wxString settings) {
6829 // Save some present values
6830 int last_UIScaleFactor = g_GUIScaleFactor;
6831 bool previous_expert = g_bUIexpert;
6832 g_last_ChartScaleFactor = g_ChartScaleFactor;
6833 ArrayOfCDI *pNewDirArray = new ArrayOfCDI;
6834
6835 int rr =
6836 g_Platform->platformApplyPrivateSettingsString(settings, pNewDirArray);
6837
6838 // And apply the changes
6839 pConfig->UpdateSettings();
6840
6841 // Might need to rebuild symbols
6842 if (g_last_ChartScaleFactor != g_ChartScaleFactor) rr |= S52_CHANGED;
6843
6844 if (rr & S52_CHANGED) {
6845 if (ps52plib) {
6846 ps52plib->FlushSymbolCaches(ChartCtxFactory());
6847 ps52plib
6848 ->ClearCNSYLUPArray(); // some CNSY depends on renderer (e.g. CARC)
6849 ps52plib->GenerateStateHash();
6850 }
6851 }
6852
6853 ProcessOptionsDialog(rr, pNewDirArray);
6854
6855 // Try to detect if the toolbar is changing, to avoid a rebuild if not
6856 // necessary.
6857
6858 bool b_newToolbar = false;
6859
6860 if (g_GUIScaleFactor != last_UIScaleFactor) b_newToolbar = true;
6861
6862 if (previous_expert != g_bUIexpert) b_newToolbar = true;
6863
6864 if (rr & TOOLBAR_CHANGED) {
6865 b_newToolbar = true;
6866 }
6867
6868 // We do this is one case only to remove an orphan recovery window
6869#ifdef __ANDROID__
6870 if (previous_expert && !g_bUIexpert) {
6871 androidForceFullRepaint();
6872 }
6873#endif
6874
6875 if (previous_expert != g_bUIexpert) g_Platform->applyExpertMode(g_bUIexpert);
6876
6877 // We set the compass size first, since that establishes the available space
6878 // for the toolbar.
6879 SetGPSCompassScale();
6880 // ..For each canvas...
6881 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
6882 ChartCanvas *cc = g_canvasArray.Item(i);
6883 if (cc) cc->GetCompass()->SetScaleFactor(g_compass_scalefactor);
6884 }
6885 UpdateGPSCompassStatusBoxes(true);
6886
6887 if (b_newToolbar) {
6888 AbstractPlatform::ShowBusySpinner();
6889
6890 SetAllToolbarScale();
6891 RequestNewToolbars(
6892 true); // Force rebuild, to pick up bGUIexpert and scale settings.
6893
6894 AbstractPlatform::HideBusySpinner();
6895
6896 RequestNewMasterToolbar(true);
6897 }
6898
6899 gFrame->Raise();
6900
6901 InvalidateAllGL();
6902 DoChartUpdate();
6903 UpdateControlBar(GetPrimaryCanvas());
6904 Refresh();
6905
6906 if (console) console->Raise();
6907
6908 Refresh(false);
6909
6910 if (NMEALogWindow::GetInstance().Active())
6911 NMEALogWindow::GetInstance().GetTTYWindow()->Raise();
6912}
6913
6914#ifdef wxHAS_POWER_EVENTS
6915void MyFrame::OnSuspending(wxPowerEvent &event) {
6916 // wxDateTime now = wxDateTime::Now();
6917 // printf("OnSuspending...%d\n", now.GetTicks());
6918
6919 wxLogMessage(_T("System suspend starting..."));
6920}
6921
6922void MyFrame::OnSuspended(wxPowerEvent &WXUNUSED(event)) {
6923 // wxDateTime now = wxDateTime::Now();
6924 // printf("OnSuspended...%d\n", now.GetTicks());
6925 wxLogMessage(_T("System is going to suspend."));
6926}
6927
6928void MyFrame::OnSuspendCancel(wxPowerEvent &WXUNUSED(event)) {
6929 // wxDateTime now = wxDateTime::Now();
6930 // printf("OnSuspendCancel...%d\n", now.GetTicks());
6931 wxLogMessage(_T("System suspend was cancelled."));
6932}
6933
6934int g_last_resume_ticks;
6935void MyFrame::OnResume(wxPowerEvent &WXUNUSED(event)) {
6936 wxDateTime now = wxDateTime::Now();
6937 wxLogMessage(_T("System resumed from suspend."));
6938
6939 if ((now.GetTicks() - g_last_resume_ticks) > 5) {
6940 SystemEvents::GetInstance().evt_resume.Notify();
6941
6942 wxLogMessage("Restarting streams.");
6943 g_last_resume_ticks = now.GetTicks();
6944// FIXME (dave)
6945#if 0
6946 if (g_pMUX) {
6947 g_pMUX->ClearStreams();
6948
6949 g_pMUX->StartAllStreams();
6950 }
6951#endif
6952 }
6953
6954 // If OpenGL is enabled, Windows Resume does not properly refresh the
6955 // application GL context. We need to force a Resize event that actually does
6956 // something.
6957 if (g_bopengl) {
6958 if (IsMaximized()) { // This is not real pretty on-screen, but works
6959 Maximize(false);
6960 wxYield();
6961 Maximize(true);
6962 } else {
6963 wxSize sz = GetSize();
6964 SetSize(wxSize(sz.x - 1, sz.y));
6965 wxYield();
6966 SetSize(sz);
6967 }
6968 }
6969}
6970#endif // wxHAS_POWER_EVENTS
6971
6972//----------------------------------------------------------------------------------------------------------
6973// Master Toolbar support
6974//----------------------------------------------------------------------------------------------------------
6975
6976void MyFrame::RequestNewMasterToolbar(bool bforcenew) {
6977 bool btbRebuild = false;
6978
6979 bool b_reshow = true;
6980 if (g_MainToolbar) {
6981 b_reshow = true; // g_MainToolbar->IsShown();
6982 float ff = fabs(g_MainToolbar->GetScaleFactor() - g_toolbar_scalefactor);
6983 if ((ff > 0.01f) || bforcenew) {
6984 g_MainToolbar->DestroyToolBar();
6985 delete g_MainToolbar;
6986 g_MainToolbar = NULL;
6987 }
6988
6989 btbRebuild = true;
6990 }
6991
6992 if (!g_MainToolbar) {
6993 long orient = g_Platform->GetDefaultToolbarOrientation();
6994 wxWindow *toolbarParent = this;
6995#ifdef __WXOSX__
6996 toolbarParent = GetPrimaryCanvas();
6997#endif
6998 g_MainToolbar = new ocpnFloatingToolbarDialog(
6999 toolbarParent, wxPoint(-1, -1), orient, g_toolbar_scalefactor);
7000 g_MainToolbar->SetBackGroundColorString(_T("GREY3"));
7001 g_MainToolbar->SetToolbarHideMethod(TOOLBAR_HIDE_TO_FIRST_TOOL);
7002 g_MainToolbar->SetToolConfigString(g_toolbarConfig);
7003 g_MainToolbar->EnableRolloverBitmaps(false);
7004
7005 g_MainToolbar->CreateConfigMenu();
7006 g_MainToolbar->SetDefaultPosition();
7007
7008 g_bmasterToolbarFull = true;
7009 }
7010
7011 if (g_MainToolbar) {
7012 CreateMasterToolbar();
7013 {
7014 // g_MainToolbar->RestoreRelativePosition(g_maintoolbar_x,
7015 // g_maintoolbar_y);
7016 g_MainToolbar->SetColorScheme(global_color_scheme);
7017 // g_MainToolbar->Show(b_reshow && g_bshowToolbar);
7018 }
7019 }
7020
7021 if (btbRebuild) {
7022 g_MainToolbar->SetAutoHide(g_bAutoHideToolbar);
7023 g_MainToolbar->SetAutoHideTimer(g_nAutoHideToolbar);
7024 }
7025}
7026
7027bool MyFrame::CollapseGlobalToolbar() {
7028 if (g_MainToolbar) {
7029 m_nMasterToolCountShown = 1;
7030 g_MainToolbar->SetToolShowCount(m_nMasterToolCountShown);
7031 g_MainToolbar->GetToolbar()->InvalidateBitmaps();
7032 g_MainToolbar->Realize();
7033 g_bmasterToolbarFull = false;
7034 return true;
7035 } else
7036 return false;
7037}
7038
7039ocpnToolBarSimple *MyFrame::CreateMasterToolbar() {
7040 ocpnToolBarSimple *tb = NULL;
7041
7042 if (g_MainToolbar) tb = g_MainToolbar->GetToolbar();
7043
7044 if (!tb) return 0;
7045
7046 ocpnStyle::Style *style = g_StyleManager->GetCurrentStyle();
7047
7048 ToolbarItemContainer *tic = new ToolbarItemContainer(
7049 ID_MASTERTOGGLE, style->GetToolIcon(_T("MUI_menu"), TOOLICON_NORMAL),
7050 wxITEM_NORMAL, _("Hide Toolbar"), _T("MUI_menu"));
7051 tic->m_bRequired = true;
7052
7053 g_MainToolbar->AddToolItem(tic);
7054
7055 tic = new ToolbarItemContainer(
7056 ID_SETTINGS, style->GetToolIcon(_T("MUI_settings"), TOOLICON_NORMAL),
7057 wxITEM_NORMAL, _("Options"), _T("MUI_settings"));
7058 g_MainToolbar->AddToolItem(tic);
7059
7060 tic = new ToolbarItemContainer(
7061 ID_MENU_ROUTE_NEW, style->GetToolIcon(_T("MUI_route"), TOOLICON_NORMAL),
7062 style->GetToolIcon(_T("MUI_route"), TOOLICON_TOGGLED), wxITEM_CHECK,
7063 wxString(_("Create Route")) << _T(" (Ctrl-R)"), _T("MUI_route"));
7064
7065 g_MainToolbar->AddToolItem(tic);
7066
7067 tic = new ToolbarItemContainer(
7068 ID_ROUTEMANAGER, style->GetToolIcon(_T("MUI_RMD"), TOOLICON_NORMAL),
7069 wxITEM_NORMAL, _("Route & Mark Manager"), _T("MUI_RMD"));
7070 g_MainToolbar->AddToolItem(tic);
7071
7072 tic = new ToolbarItemContainer(
7073 ID_TRACK, style->GetToolIcon(_T("MUI_track"), TOOLICON_NORMAL),
7074 style->GetToolIcon(_T("MUI_track"), TOOLICON_TOGGLED), wxITEM_CHECK,
7075 _("Enable Tracking"), _T("MUI_track"));
7076 g_MainToolbar->AddToolItem(tic);
7077
7078 tic = new ToolbarItemContainer(
7079 ID_COLSCHEME, style->GetToolIcon(_T("MUI_colorscheme"), TOOLICON_NORMAL),
7080 wxITEM_NORMAL, _("Change Color Scheme"), _T("MUI_colorscheme"));
7081 g_MainToolbar->AddToolItem(tic);
7082 // if( GetMasterToolItemShow(ID_COLSCHEME) ){
7083 // tb->AddTool( ID_COLSCHEME, _T("MUI_colorscheme"), style->GetToolIcon(
7084 // _T("MUI_colorscheme"), TOOLICON_NORMAL ),
7085 // tipString, wxITEM_NORMAL );
7086 // tb->SetToolTooltipHiViz( ID_COLSCHEME, true ); // cause the Tooltip to
7087 // always be visible, whatever
7088 // the colorscheme
7089 //}
7090
7091 tic = new ToolbarItemContainer(
7092 ID_PRINT, style->GetToolIcon(_T("MUI_print"), TOOLICON_NORMAL),
7093 wxITEM_NORMAL, _("Print Chart"), _T("MUI_print"));
7094 g_MainToolbar->AddToolItem(tic);
7095
7096 tic = new ToolbarItemContainer(
7097 ID_ABOUT, style->GetToolIcon(_T("MUI_help"), TOOLICON_NORMAL),
7098 wxITEM_NORMAL, _("About OpenCPN"), _T("MUI_help"));
7099 g_MainToolbar->AddToolItem(tic);
7100
7101 // Add any PlugIn toolbar tools that request default positioning
7102 AddDefaultPositionPlugInTools();
7103
7104 // And finally add the MOB tool
7105 tic = new ToolbarItemContainer(
7106 ID_MOB, style->GetToolIcon(_T("mob_btn"), TOOLICON_NORMAL), wxITEM_NORMAL,
7107 wxString(_("Drop MOB Marker")) << _(" (Ctrl-Space)"), _T("mob_btn"));
7108 g_MainToolbar->AddToolItem(tic);
7109
7110 // Build the toolbar
7111 g_MainToolbar->RebuildToolbar();
7112
7113 // Realize() the toolbar for current geometry
7114 style->Unload();
7115 g_MainToolbar->Realize();
7116
7117 // Set PlugIn tool toggle states
7118 ArrayOfPlugInToolbarTools tool_array =
7119 g_pi_manager->GetPluginToolbarToolArray();
7120 for (unsigned int i = 0; i < tool_array.GetCount(); i++) {
7121 PlugInToolbarToolContainer *pttc = tool_array.Item(i);
7122 if (!pttc->b_viz) continue;
7123
7124 if (pttc->kind == wxITEM_CHECK) tb->ToggleTool(pttc->id, pttc->b_toggle);
7125 }
7126
7127 SetMasterToolbarItemState(ID_TRACK, g_bTrackActive);
7128 if (g_bTrackActive) {
7129 g_MainToolbar->SetToolShortHelp(ID_TRACK, _("Disable Tracking"));
7130 }
7131 g_MainToolbar->Realize();
7132
7133 return tb;
7134}
7135
7136bool MyFrame::CheckAndAddPlugInTool() {
7137 if (!g_pi_manager) return false;
7138
7139 bool bret = false;
7140 ocpnToolBarSimple *tb = NULL;
7141
7142 if (g_MainToolbar) tb = g_MainToolbar->GetToolbar();
7143
7144 if (!tb) return false;
7145
7146 int n_tools = tb->GetToolsCount();
7147
7148 // Walk the PlugIn tool spec array, checking the requested position
7149 // If a tool has been requested by a plugin at this position, add it
7150 ArrayOfPlugInToolbarTools tool_array =
7151 g_pi_manager->GetPluginToolbarToolArray();
7152
7153 for (unsigned int i = 0; i < tool_array.GetCount(); i++) {
7154 PlugInToolbarToolContainer *pttc = tool_array.Item(i);
7155 if (pttc->position == n_tools) {
7156 wxBitmap *ptool_bmp;
7157
7158 switch (global_color_scheme) {
7159 case GLOBAL_COLOR_SCHEME_DAY:
7160 ptool_bmp = pttc->bitmap_day;
7161 ;
7162 break;
7163 case GLOBAL_COLOR_SCHEME_DUSK:
7164 ptool_bmp = pttc->bitmap_dusk;
7165 break;
7166 case GLOBAL_COLOR_SCHEME_NIGHT:
7167 ptool_bmp = pttc->bitmap_night;
7168 break;
7169 default:
7170 ptool_bmp = pttc->bitmap_day;
7171 break;
7172 }
7173
7174 ToolbarItemContainer *tic = new ToolbarItemContainer(
7175 pttc->id, *(ptool_bmp), pttc->kind, pttc->shortHelp, _T(""));
7176
7177 tic->m_NormalIconSVG = pttc->pluginNormalIconSVG;
7178 tic->m_RolloverIconSVG = pttc->pluginRolloverIconSVG;
7179 tic->m_ToggledIconSVG = pttc->pluginToggledIconSVG;
7180 tic->m_bPlugin = true;
7181
7182 bret = true;
7183 }
7184 }
7185
7186 // If we added a tool, call again (recursively) to allow for adding
7187 // adjacent tools
7188 if (bret)
7189 while (CheckAndAddPlugInTool()) { /* nothing to do */
7190 }
7191
7192 return bret;
7193}
7194
7195bool MyFrame::AddDefaultPositionPlugInTools() {
7196 if (!g_pi_manager) return false;
7197
7198 bool bret = false;
7199
7200 // Walk the PlugIn tool spec array, checking the requested position
7201 // If a tool has been requested by a plugin at this position, add it
7202 ArrayOfPlugInToolbarTools tool_array =
7203 g_pi_manager->GetPluginToolbarToolArray();
7204
7205 for (unsigned int i = 0; i < tool_array.GetCount(); i++) {
7206 PlugInToolbarToolContainer *pttc = tool_array.Item(i);
7207
7208 // Tool is currently tagged as invisible
7209 if (!pttc->b_viz) continue;
7210
7211 if (pttc->position == -1) // PlugIn has requested default positioning
7212 {
7213 wxBitmap *ptool_bmp;
7214
7215 switch (global_color_scheme) {
7216 case GLOBAL_COLOR_SCHEME_DAY:
7217 ptool_bmp = pttc->bitmap_day;
7218 break;
7219 case GLOBAL_COLOR_SCHEME_DUSK:
7220 ptool_bmp = pttc->bitmap_dusk;
7221 break;
7222 case GLOBAL_COLOR_SCHEME_NIGHT:
7223 ptool_bmp = pttc->bitmap_night;
7224 break;
7225 default:
7226 ptool_bmp = pttc->bitmap_day;
7227 break;
7228 }
7229
7230 ToolbarItemContainer *tic = new ToolbarItemContainer(
7231 pttc->id, *(ptool_bmp), pttc->kind, pttc->shortHelp, _T(""));
7232
7233 tic->m_NormalIconSVG = pttc->pluginNormalIconSVG;
7234 tic->m_RolloverIconSVG = pttc->pluginRolloverIconSVG;
7235 tic->m_ToggledIconSVG = pttc->pluginToggledIconSVG;
7236 tic->m_bPlugin = true;
7237
7238 g_MainToolbar->AddToolItem(tic);
7239
7240 bret = true;
7241 }
7242 }
7243 return bret;
7244}
7245
7246/*************************************************************************
7247 * Global color management routines
7248 *
7249 *************************************************************************/
7250
7251wxColour GetGlobalColor(wxString colorName); // -> color_handler
7252
7253static const char *usercolors[] = {
7254 "Table:DAY", "GREEN1;120;255;120;", "GREEN2; 45;150; 45;",
7255 "GREEN3;200;220;200;", "GREEN4; 0;255; 0;", "BLUE1; 170;170;255;",
7256 "BLUE2; 45; 45;170;", "BLUE3; 0; 0;255;", "GREY1; 200;200;200;",
7257 "GREY2; 230;230;230;", "RED1; 220;200;200;", "UBLCK; 0; 0; 0;",
7258 "UWHIT; 255;255;255;", "URED; 255; 0; 0;", "UGREN; 0;255; 0;",
7259 "YELO1; 243;229; 47;", "YELO2; 128; 80; 0;", "TEAL1; 0;128;128;",
7260 "GREEN5;170;254; 0;", "COMPT; 245;247;244",
7261#ifdef __WXOSX__
7262 "DILG0; 255;255;255;", // Dialog Background white
7263#else
7264 "DILG0; 238;239;242;", // Dialog Background white
7265#endif
7266 "DILG1; 212;208;200;", // Dialog Background
7267 "DILG2; 255;255;255;", // Control Background
7268 "DILG3; 0; 0; 0;", // Text
7269 "UITX1; 0; 0; 0;", // Menu Text, derived from UINFF
7270
7271 "CHGRF; 163; 180; 183;", "UINFM; 197; 69; 195;", "UINFG; 104; 228; 86;",
7272 "UINFF; 125; 137; 140;", "UINFR; 241; 84; 105;", "SHIPS; 7; 7; 7;",
7273 "CHYLW; 244; 218; 72;", "CHWHT; 212; 234; 238;",
7274
7275 "UDKRD; 124; 16; 0;",
7276 "UARTE; 200; 0; 0;", // Active Route, Grey on Dusk/Night
7277
7278 "NODTA; 163; 180; 183;", "CHBLK; 7; 7; 7;", "SNDG1; 125; 137; 140;",
7279 "SNDG2; 7; 7; 7;", "SCLBR; 235; 125; 54;", "UIBDR; 125; 137; 140;",
7280 "UINFB; 58; 120; 240;", "UINFD; 7; 7; 7;", "UINFO; 235; 125; 54;",
7281 "PLRTE; 220; 64; 37;", "CHMGD; 197; 69; 195;", "UIBCK; 212; 234; 238;",
7282
7283 "DASHB; 255;255;255;", // Dashboard Instr background
7284 "DASHL; 175;175;175;", // Dashboard Instr Label
7285 "DASHF; 50; 50; 50;", // Dashboard Foreground
7286 "DASHR; 200; 0; 0;", // Dashboard Red
7287 "DASHG; 0;200; 0;", // Dashboard Green
7288 "DASHN; 200;120; 0;", // Dashboard Needle
7289 "DASH1; 204;204;255;", // Dashboard Illustrations
7290 "DASH2; 122;131;172;", // Dashboard Illustrations
7291 "COMP1; 211;211;211;", // Compass Window Background
7292
7293 "GREY3; 40; 40; 40;", // MUIBar/TB background
7294 "BLUE4; 100;100;200;", // Canvas Focus Bar
7295 "VIO01; 171; 33;141;", "VIO02; 209;115;213;",
7296 "BLUEBACK; 212;234;238;", // DEPDW, looks like deep ocean
7297 "LANDBACK; 201;185;122;",
7298 //<color name="LANDA" r="201" g="185" b="122"/>
7299
7300 "Table:DUSK", "GREEN1; 60;128; 60;", "GREEN2; 22; 75; 22;",
7301 "GREEN3; 80;100; 80;", "GREEN4; 0;128; 0;", "BLUE1; 80; 80;160;",
7302 "BLUE2; 30; 30;120;", "BLUE3; 0; 0;128;", "GREY1; 100;100;100;",
7303 "GREY2; 128;128;128;", "RED1; 150;100;100;", "UBLCK; 0; 0; 0;",
7304 "UWHIT; 255;255;255;", "URED; 120; 54; 11;", "UGREN; 35;110; 20;",
7305 "YELO1; 120;115; 24;", "YELO2; 64; 40; 0;", "TEAL1; 0; 64; 64;",
7306 "GREEN5; 85;128; 0;", "COMPT; 124;126;121",
7307
7308 "CHGRF; 41; 46; 46;", "UINFM; 58; 20; 57;", "UINFG; 35; 76; 29;",
7309 "UINFF; 41; 46; 46;", "UINFR; 80; 28; 35;", "SHIPS; 71; 78; 79;",
7310 "CHYLW; 81; 73; 24;", "CHWHT; 71; 78; 79;",
7311
7312 "DILG0; 110;110;110;", // Dialog Background
7313 "DILG1; 110;110;110;", // Dialog Background
7314 "DILG2; 0; 0; 0;", // Control Background
7315 "DILG3; 130;130;130;", // Text
7316 "UITX1; 41; 46; 46;", // Menu Text, derived from UINFF
7317 "UDKRD; 80; 0; 0;",
7318 "UARTE; 64; 64; 64;", // Active Route, Grey on Dusk/Night
7319
7320 "NODTA; 41; 46; 46;", "CHBLK; 54; 60; 61;", "SNDG1; 41; 46; 46;",
7321 "SNDG2; 71; 78; 79;", "SCLBR; 75; 38; 19;", "UIBDR; 54; 60; 61;",
7322 "UINFB; 19; 40; 80;", "UINFD; 71; 78; 79;", "UINFO; 75; 38; 19;",
7323 "PLRTE; 73; 21; 12;", "CHMGD; 74; 58; 81;", "UIBCK; 7; 7; 7;",
7324
7325 "DASHB; 77; 77; 77;", // Dashboard Instr background
7326 "DASHL; 54; 54; 54;", // Dashboard Instr Label
7327 "DASHF; 0; 0; 0;", // Dashboard Foreground
7328 "DASHR; 58; 21; 21;", // Dashboard Red
7329 "DASHG; 21; 58; 21;", // Dashboard Green
7330 "DASHN; 100; 50; 0;", // Dashboard Needle
7331 "DASH1; 76; 76;113;", // Dashboard Illustrations
7332 "DASH2; 48; 52; 72;", // Dashboard Illustrations
7333 "COMP1; 107;107;107;", // Compass Window Background
7334
7335 "GREY3; 20; 20; 20;", // MUIBar/TB background
7336 "BLUE4; 80; 80;160;", // Canvas Focus Bar
7337 "VIO01; 128; 25;108;", "VIO02; 171; 33;141;", "BLUEBACK; 186;213;235;",
7338 "LANDBACK; 201;185;122;",
7339
7340 "Table:NIGHT", "GREEN1; 30; 80; 30;", "GREEN2; 15; 60; 15;",
7341 "GREEN3; 12; 23; 9;", "GREEN4; 0; 64; 0;", "BLUE1; 60; 60;100;",
7342 "BLUE2; 22; 22; 85;", "BLUE3; 0; 0; 40;", "GREY1; 48; 48; 48;",
7343 "GREY2; 32; 32; 32;", "RED1; 100; 50; 50;", "UWHIT; 255;255;255;",
7344 "UBLCK; 0; 0; 0;", "URED; 60; 27; 5;", "UGREN; 17; 55; 10;",
7345 "YELO1; 60; 65; 12;", "YELO2; 32; 20; 0;", "TEAL1; 0; 32; 32;",
7346 "GREEN5; 44; 64; 0;", "COMPT; 48; 49; 51",
7347 "DILG0; 80; 80; 80;", // Dialog Background
7348 "DILG1; 80; 80; 80;", // Dialog Background
7349 "DILG2; 0; 0; 0;", // Control Background
7350 "DILG3; 65; 65; 65;", // Text
7351 "UITX1; 31; 34; 35;", // Menu Text, derived from UINFF
7352 "UDKRD; 50; 0; 0;",
7353 "UARTE; 64; 64; 64;", // Active Route, Grey on Dusk/Night
7354
7355 "CHGRF; 16; 18; 18;", "UINFM; 52; 18; 52;", "UINFG; 22; 24; 7;",
7356 "UINFF; 31; 34; 35;", "UINFR; 59; 17; 10;", "SHIPS; 37; 41; 41;",
7357 "CHYLW; 31; 33; 10;", "CHWHT; 37; 41; 41;",
7358
7359 "NODTA; 7; 7; 7;", "CHBLK; 31; 34; 35;", "SNDG1; 31; 34; 35;",
7360 "SNDG2; 43; 48; 48;", "SCLBR; 52; 28; 12;", "UIBDR; 31; 34; 35;",
7361 "UINFB; 21; 29; 69;", "UINFD; 43; 48; 58;", "UINFO; 52; 28; 12;",
7362 "PLRTE; 66; 19; 11;", "CHMGD; 52; 18; 52;", "UIBCK; 7; 7; 7;",
7363
7364 "DASHB; 0; 0; 0;", // Dashboard Instr background
7365 "DASHL; 20; 20; 20;", // Dashboard Instr Label
7366 "DASHF; 64; 64; 64;", // Dashboard Foreground
7367 "DASHR; 70; 15; 15;", // Dashboard Red
7368 "DASHG; 15; 70; 15;", // Dashboard Green
7369 "DASHN; 17; 80; 56;", // Dashboard Needle
7370 "DASH1; 48; 52; 72;", // Dashboard Illustrations
7371 "DASH2; 36; 36; 53;", // Dashboard Illustrations
7372 "COMP1; 24; 24; 24;", // Compass Window Background
7373
7374 "GREY3; 10; 10; 10;", // MUIBar/TB background
7375 "BLUE4; 70; 70;140;", // Canvas Focus Bar
7376 "VIO01; 85; 16; 72;", "VIO02; 128; 25;108;", "BLUEBACK; 186;213;235;",
7377 "LANDBACK; 201;185;122;",
7378
7379 "*****"};
7380
7381int get_static_line(char *d, const char **p, int index, int n) {
7382 if (!strcmp(p[index], "*****")) return 0;
7383
7384 strncpy(d, p[index], n);
7385 return strlen(d);
7386}
7387
7388void InitializeUserColors(void) {
7389 const char **p = usercolors;
7390 char buf[81];
7391 int index = 0;
7392 char TableName[20];
7393 colTable *ctp;
7394 colTable *ct;
7395 int R, G, B;
7396
7397 UserColorTableArray = new wxArrayPtrVoid;
7398 UserColourHashTableArray = new wxArrayPtrVoid;
7399
7400 // Create 3 color table entries
7401 ct = new colTable;
7402 ct->tableName = new wxString(_T("DAY"));
7403 ct->color = new wxArrayPtrVoid;
7404 UserColorTableArray->Add((void *)ct);
7405
7406 ct = new colTable;
7407 ct->tableName = new wxString(_T("DUSK"));
7408 ct->color = new wxArrayPtrVoid;
7409 UserColorTableArray->Add((void *)ct);
7410
7411 ct = new colTable;
7412 ct->tableName = new wxString(_T("NIGHT"));
7413 ct->color = new wxArrayPtrVoid;
7414 UserColorTableArray->Add((void *)ct);
7415
7416 while ((get_static_line(buf, p, index, sizeof(buf) - 1))) {
7417 if (!strncmp(buf, "Table", 5)) {
7418 sscanf(buf, "Table:%s", TableName);
7419
7420 for (unsigned int it = 0; it < UserColorTableArray->GetCount(); it++) {
7421 ctp = (colTable *)(UserColorTableArray->Item(it));
7422 if (!strcmp(TableName, ctp->tableName->mb_str())) {
7423 ct = ctp;
7424 break;
7425 }
7426 }
7427
7428 } else {
7429 char name[21];
7430 int j = 0;
7431 while (buf[j] != ';' && j < 20) {
7432 name[j] = buf[j];
7433 j++;
7434 }
7435 name[j] = 0;
7436
7437 S52color *c = new S52color;
7438 strcpy(c->colName, name);
7439
7440 sscanf(&buf[j], ";%i;%i;%i", &R, &G, &B);
7441 c->R = (char)R;
7442 c->G = (char)G;
7443 c->B = (char)B;
7444
7445 ct->color->Add(c);
7446 }
7447
7448 index++;
7449 }
7450
7451 // Now create the Hash tables
7452
7453 for (unsigned int its = 0; its < UserColorTableArray->GetCount(); its++) {
7454 wxColorHashMap *phash = new wxColorHashMap;
7455 UserColourHashTableArray->Add((void *)phash);
7456
7457 colTable *ctp = (colTable *)(UserColorTableArray->Item(its));
7458
7459 for (unsigned int ic = 0; ic < ctp->color->GetCount(); ic++) {
7460 S52color *c2 = (S52color *)(ctp->color->Item(ic));
7461
7462 wxColour c(c2->R, c2->G, c2->B);
7463 wxString key(c2->colName, wxConvUTF8);
7464 (*phash)[key] = c;
7465 }
7466 }
7467
7468 // Establish a default hash table pointer
7469 // in case a color is needed before ColorScheme is set
7470 pcurrent_user_color_hash =
7471 (wxColorHashMap *)UserColourHashTableArray->Item(0);
7472}
7473
7474void DeInitializeUserColors(void) {
7475 if (!UserColorTableArray) return;
7476 for (unsigned i = 0; i < UserColorTableArray->GetCount(); i++) {
7477 colTable *ct = (colTable *)UserColorTableArray->Item(i);
7478
7479 for (unsigned int j = 0; j < ct->color->GetCount(); j++) {
7480 S52color *c = (S52color *)ct->color->Item(j);
7481 delete c; // color
7482 }
7483
7484 delete ct->tableName; // wxString
7485 delete ct->color; // wxArrayPtrVoid
7486
7487 delete ct; // colTable
7488 }
7489
7490 delete UserColorTableArray;
7491
7492 for (unsigned i = 0; i < UserColourHashTableArray->GetCount(); i++) {
7493 wxColorHashMap *phash = (wxColorHashMap *)UserColourHashTableArray->Item(i);
7494 delete phash;
7495 }
7496
7497 delete UserColourHashTableArray;
7498}
7499
7500#ifdef __WXMSW__
7501
7502#define NCOLORS 40
7503
7504typedef struct _MSW_COLOR_SPEC {
7505 int COLOR_NAME;
7506 wxString S52_RGB_COLOR;
7507 int SysRGB_COLOR;
7508} MSW_COLOR_SPEC;
7509
7510MSW_COLOR_SPEC color_spec[] = {{COLOR_MENU, _T("UIBCK"), 0},
7511 {COLOR_MENUTEXT, _T("UITX1"), 0},
7512 {COLOR_BTNSHADOW, _T("UIBCK"), 0}, // Menu Frame
7513 {-1, _T(""), 0}};
7514
7515void SaveSystemColors() {
7516 /*
7517 color_3dface = pGetSysColor(COLOR_3DFACE);
7518 color_3dhilite = pGetSysColor(COLOR_3DHILIGHT);
7519 color_3dshadow = pGetSysColor(COLOR_3DSHADOW);
7520 color_3ddkshadow = pGetSysColor(COLOR_3DDKSHADOW);
7521 color_3dlight = pGetSysColor(COLOR_3DLIGHT);
7522 color_activecaption = pGetSysColor(COLOR_ACTIVECAPTION);
7523 color_gradientactivecaption = pGetSysColor(27); //COLOR_3DLIGHT);
7524 color_captiontext = pGetSysColor(COLOR_CAPTIONTEXT);
7525 color_windowframe = pGetSysColor(COLOR_WINDOWFRAME);
7526 color_inactiveborder = pGetSysColor(COLOR_INACTIVEBORDER);
7527 */
7528 // Record the default system color in my substitution structure
7529 MSW_COLOR_SPEC *pcspec = &color_spec[0];
7530 while (pcspec->COLOR_NAME != -1) {
7531 pcspec->SysRGB_COLOR = pGetSysColor(pcspec->COLOR_NAME);
7532 pcspec++;
7533 }
7534}
7535
7536void RestoreSystemColors() {
7537 int element[NCOLORS];
7538 int rgbcolor[NCOLORS];
7539 int i = 0;
7540
7541 MSW_COLOR_SPEC *pcspec = &color_spec[0];
7542 while (pcspec->COLOR_NAME != -1) {
7543 element[i] = pcspec->COLOR_NAME;
7544 rgbcolor[i] = pcspec->SysRGB_COLOR;
7545
7546 pcspec++;
7547 i++;
7548 }
7549
7550 pSetSysColors(i, (unsigned long *)&element[0], (unsigned long *)&rgbcolor[0]);
7551}
7552
7553#endif
7554
7555void SetSystemColors(ColorScheme cs) { //---------------
7556#ifdef __WXMSW__
7557 int element[NCOLORS];
7558 int rgbcolor[NCOLORS];
7559 int i = 0;
7560 if ((GLOBAL_COLOR_SCHEME_DUSK == cs) || (GLOBAL_COLOR_SCHEME_NIGHT == cs)) {
7561 MSW_COLOR_SPEC *pcspec = &color_spec[0];
7562 while (pcspec->COLOR_NAME != -1) {
7563 wxColour color = GetGlobalColor(pcspec->S52_RGB_COLOR);
7564 rgbcolor[i] = (color.Red() << 16) + (color.Green() << 8) + color.Blue();
7565 element[i] = pcspec->COLOR_NAME;
7566
7567 i++;
7568 pcspec++;
7569 }
7570
7571 pSetSysColors(i, (unsigned long *)&element[0],
7572 (unsigned long *)&rgbcolor[0]);
7573
7574 } else { // for daylight colors, use default windows colors as saved....
7575
7576 RestoreSystemColors();
7577 }
7578#endif
7579}
7580
7581wxColor GetDimColor(wxColor c) {
7582 if ((global_color_scheme == GLOBAL_COLOR_SCHEME_DAY) ||
7583 (global_color_scheme == GLOBAL_COLOR_SCHEME_RGB))
7584 return c;
7585
7586 float factor = 1.0;
7587 if (global_color_scheme == GLOBAL_COLOR_SCHEME_DUSK) factor = 0.5;
7588 if (global_color_scheme == GLOBAL_COLOR_SCHEME_NIGHT) factor = 0.25;
7589
7590 wxImage::RGBValue rgb(c.Red(), c.Green(), c.Blue());
7591 wxImage::HSVValue hsv = wxImage::RGBtoHSV(rgb);
7592 hsv.value = hsv.value * factor;
7593 wxImage::RGBValue nrgb = wxImage::HSVtoRGB(hsv);
7594
7595 return wxColor(nrgb.red, nrgb.green, nrgb.blue);
7596}
7597
7598// A helper function to check for proper parameters of anchor
7599// watch
7600//
7601double AnchorDistFix(double const d, double const AnchorPointMinDist,
7602 double const AnchorPointMaxDist) // pjotrc 2010.02.22
7603{
7604 if (d >= 0.0)
7605 if (d < AnchorPointMinDist)
7606 return AnchorPointMinDist;
7607 else if (d > AnchorPointMaxDist)
7608 return AnchorPointMaxDist;
7609 else
7610 return d;
7611
7612 else
7613 // if ( d < 0.0 )
7614 if (d > -AnchorPointMinDist)
7615 return -AnchorPointMinDist;
7616 else if (d < -AnchorPointMaxDist)
7617 return -AnchorPointMaxDist;
7618 else
7619 return d;
7620}
7621// Console supporting printf functionality for Windows GUI app
7622
7623#ifdef __WXMSW__
7624static const WORD MAX_CONSOLE_LINES =
7625 500; // maximum mumber of lines the output console should have
7626
7627// #ifdef _DEBUG
7628
7629void RedirectIOToConsole()
7630
7631{
7632 int hConHandle;
7633
7634 wxIntPtr lStdHandle;
7635
7636 CONSOLE_SCREEN_BUFFER_INFO coninfo;
7637
7638 FILE *fp;
7639
7640 // allocate a console for this app
7641
7642 AllocConsole();
7643
7644 // set the screen buffer to be big enough to let us scroll text
7645
7646 GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &coninfo);
7647 coninfo.dwSize.Y = MAX_CONSOLE_LINES;
7648 SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), coninfo.dwSize);
7649
7650 // redirect unbuffered STDOUT to the console
7651
7652 lStdHandle = (wxIntPtr)GetStdHandle(STD_OUTPUT_HANDLE);
7653 hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
7654 fp = _fdopen(hConHandle, "w");
7655 *stdout = *fp;
7656 setvbuf(stdout, NULL, _IONBF, 0);
7657
7658 // redirect unbuffered STDIN to the console
7659
7660 lStdHandle = (wxIntPtr)GetStdHandle(STD_INPUT_HANDLE);
7661 hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
7662 fp = _fdopen(hConHandle, "r");
7663 *stdin = *fp;
7664 setvbuf(stdin, NULL, _IONBF, 0);
7665
7666 // redirect unbuffered STDERR to the console
7667
7668 lStdHandle = (wxIntPtr)GetStdHandle(STD_ERROR_HANDLE);
7669 hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
7670 fp = _fdopen(hConHandle, "w");
7671 *stderr = *fp;
7672 setvbuf(stderr, NULL, _IONBF, 0);
7673
7674 // make cout, wcout, cin, wcin, wcerr, cerr, wclog and clog point to console
7675 // as well
7676
7677 // ios::sync_with_stdio();
7678}
7679
7680// #endif
7681#endif
7682
7683#ifdef __WXMSW__
7684bool TestGLCanvas(wxString prog_dir) {
7685#ifdef __MSVC__
7686 wxString test_app = prog_dir;
7687 test_app += _T("ocpn_gltest1.exe");
7688
7689 if (::wxFileExists(test_app)) {
7690 long proc_return = ::wxExecute(test_app, wxEXEC_SYNC);
7691 printf("OpenGL Test Process returned %0X\n", proc_return);
7692 if (proc_return == 0)
7693 printf("GLCanvas OK\n");
7694 else
7695 printf("GLCanvas failed to start, disabling OpenGL.\n");
7696
7697 return (proc_return == 0);
7698 } else
7699 return true;
7700#else
7701 /* until we can get the source to ocpn_gltest1 assume true for mingw */
7702 return true;
7703#endif
7704}
7705#endif
7706
7707bool ReloadLocale() {
7708 bool ret = false;
7709
7710#if wxUSE_XLOCALE
7711 ret =
7712 (!g_Platform->ChangeLocale(g_locale, plocale_def_lang, &plocale_def_lang)
7713 .IsEmpty());
7714#endif
7715 return ret;
7716}
7717
7718void ApplyLocale() {
7719 FontMgr::Get().SetLocale(g_locale);
7720 FontMgr::Get().ScrubList();
7721
7722 // Close and re-init various objects to allow new locale to show.
7723 // delete g_options;
7724 // g_options = NULL;
7725 // g_pOptions = NULL;
7726
7727 if (pRoutePropDialog) {
7728 pRoutePropDialog->Hide();
7729 pRoutePropDialog->Destroy();
7730 pRoutePropDialog = NULL;
7731 }
7732
7733 if (pRouteManagerDialog) {
7734 pRouteManagerDialog->Hide();
7735 pRouteManagerDialog->Destroy();
7736 pRouteManagerDialog = NULL;
7737 }
7738
7739 if (console) console->SetColorScheme(global_color_scheme);
7740 if (g_pais_query_dialog_active) {
7741 g_pais_query_dialog_active->Destroy();
7742 g_pais_query_dialog_active = NULL;
7743 }
7744
7745 auto alert_dlg_active =
7746 dynamic_cast<AISTargetAlertDialog *>(g_pais_alert_dialog_active);
7747 if (alert_dlg_active) {
7748 alert_dlg_active->Destroy();
7749 g_pais_alert_dialog_active = nullptr;
7750 }
7751
7752 if (g_pAISTargetList) {
7753 if (g_pauimgr) g_pauimgr->DetachPane(g_pAISTargetList);
7754 g_pAISTargetList->Disconnect_decoder();
7755 g_pAISTargetList->Destroy();
7756 g_pAISTargetList = NULL;
7757 }
7758
7759 // Process the menubar, if present.
7760 if (gFrame->m_pMenuBar) { // remove the menu bar if it is presently enabled
7761 gFrame->SetMenuBar(NULL);
7762 gFrame->m_pMenuBar->Destroy();
7763 gFrame->m_pMenuBar = NULL;
7764 }
7765 gFrame->BuildMenuBar();
7766
7767 // Give all canvas a chance to update, if needed
7768 for (unsigned int i = 0; i < g_canvasArray.GetCount(); i++) {
7769 ChartCanvas *cc = g_canvasArray.Item(i);
7770 if (cc) cc->CanvasApplyLocale();
7771 }
7772
7773 // Capture a copy of the current perspective
7774 // So that we may restore PlugIn window sizes, position, visibility, etc.
7775 wxString perspective;
7776 pConfig->SetPath(_T ( "/AUI" ));
7777 pConfig->Read(_T ( "AUIPerspective" ), &perspective);
7778
7779 // Compliant Plugins will reload their locale message catalog during the
7780 // Init() method. So it is sufficient to simply deactivate, and then
7781 // re-activate, all "active" plugins.
7782 PluginLoader::getInstance()->DeactivateAllPlugIns();
7783 PluginLoader::getInstance()->UpdatePlugIns();
7784
7785 // // Make sure the perspective saved in the config file is
7786 // "reasonable"
7787 // // In particular, the perspective should have an entry for every
7788 // // windows added to the AUI manager so far.
7789 // // If any are not found, then use the default layout
7790 //
7791 bool bno_load = false;
7792 wxAuiPaneInfoArray pane_array_val = g_pauimgr->GetAllPanes();
7793
7794 for (unsigned int i = 0; i < pane_array_val.GetCount(); i++) {
7795 wxAuiPaneInfo pane = pane_array_val[i];
7796 if (perspective.Find(pane.name) == wxNOT_FOUND) {
7797 bno_load = true;
7798 break;
7799 }
7800 }
7801
7802 if (!bno_load) g_pauimgr->LoadPerspective(perspective, false);
7803
7804 g_pauimgr->Update();
7805
7806 if (gFrame) {
7807 gFrame->RequestNewToolbars(true);
7808 gFrame->RequestNewMasterToolbar(true);
7809 }
7810}
7811
7812extern s57RegistrarMgr *m_pRegistrarMan;
7813extern wxString g_UserPresLibData;
7814extern wxString g_SENCPrefix;
7815extern wxString g_csv_locn;
7816extern SENCThreadManager *g_SencThreadManager;
7817
7818void LoadS57() {
7819 if (ps52plib) // already loaded?
7820 return;
7821
7822 // Start a SENC Thread manager
7823 g_SencThreadManager = new SENCThreadManager();
7824
7825 // Set up a useable CPL library error handler for S57 stuff
7826 // FIXME (dave) Verify after moving LoadS57
7827 // CPLSetErrorHandler(MyCPLErrorHandler);
7828
7829 // Init the s57 chart object, specifying the location of the required csv
7830 // files
7831 g_csv_locn = g_Platform->GetSharedDataDir();
7832 g_csv_locn.Append(_T("s57data"));
7833
7834 if (g_bportable) {
7835 g_csv_locn = _T(".");
7836 appendOSDirSlash(&g_csv_locn);
7837 g_csv_locn.Append(_T("s57data"));
7838 }
7839
7840 // If the config file contains an entry for SENC file prefix, use it.
7841 // Otherwise, default to PrivateDataDir
7842 if (g_SENCPrefix.IsEmpty()) {
7843 g_SENCPrefix = g_Platform->GetPrivateDataDir();
7844 appendOSDirSlash(&g_SENCPrefix);
7845 g_SENCPrefix.Append(_T("SENC"));
7846 }
7847
7848 if (g_bportable) {
7849 wxFileName f(g_SENCPrefix);
7850 if (f.MakeRelativeTo(g_Platform->GetPrivateDataDir()))
7851 g_SENCPrefix = f.GetFullPath();
7852 else
7853 g_SENCPrefix = _T("SENC");
7854 }
7855
7856 // If the config file contains an entry for PresentationLibraryData, use
7857 // it. Otherwise, default to conditionally set spot under g_pcsv_locn
7858 wxString plib_data;
7859 bool b_force_legacy = false;
7860
7861 if (g_UserPresLibData.IsEmpty()) {
7862 plib_data = g_csv_locn;
7863 appendOSDirSlash(&plib_data);
7864 plib_data.Append(_T("S52RAZDS.RLE"));
7865 } else {
7866 plib_data = g_UserPresLibData;
7867 b_force_legacy = true;
7868 }
7869
7870 ps52plib = new s52plib(plib_data, b_force_legacy);
7871
7872 // If the library load failed, try looking for the s57 data elsewhere
7873
7874 // First, look in UserDataDir
7875 /* From wxWidgets documentation
7876
7877 wxStandardPaths::GetUserDataDir
7878 wxString GetUserDataDir() const
7879 Return the directory for the user-dependent application data files:
7880 * Unix: ~/.appname
7881 * Windows: C:\Documents and Settings\username\Application Data\appname
7882 * Mac: ~/Library/Application Support/appname
7883 */
7884
7885 if (!ps52plib->m_bOK) {
7886 delete ps52plib;
7887
7888 wxStandardPaths &std_path = g_Platform->GetStdPaths();
7889
7890 wxString look_data_dir;
7891 look_data_dir.Append(std_path.GetUserDataDir());
7892 appendOSDirSlash(&look_data_dir);
7893 wxString tentative_SData_Locn = look_data_dir;
7894 look_data_dir.Append(_T("s57data"));
7895
7896 plib_data = look_data_dir;
7897 appendOSDirSlash(&plib_data);
7898 plib_data.Append(_T("S52RAZDS.RLE"));
7899
7900 wxLogMessage(_T("Looking for s57data in ") + look_data_dir);
7901 ps52plib = new s52plib(plib_data);
7902
7903 if (ps52plib->m_bOK) {
7904 g_csv_locn = look_data_dir;
7906 }
7907 }
7908
7909 // And if that doesn't work, look again in the original SData Location
7910 // This will cover the case in which the .ini file entry is corrupted or
7911 // moved
7912
7913 if (!ps52plib->m_bOK) {
7914 delete ps52plib;
7915
7916 wxString look_data_dir;
7917 look_data_dir = g_Platform->GetSharedDataDir();
7918 look_data_dir.Append(_T("s57data"));
7919
7920 plib_data = look_data_dir;
7921 appendOSDirSlash(&plib_data);
7922 plib_data.Append(_T("S52RAZDS.RLE"));
7923
7924 wxLogMessage(_T("Looking for s57data in ") + look_data_dir);
7925 ps52plib = new s52plib(plib_data);
7926
7927 if (ps52plib->m_bOK) g_csv_locn = look_data_dir;
7928 }
7929
7930 if (ps52plib->m_bOK) {
7931 wxLogMessage(_T("Using s57data in ") + g_csv_locn);
7932 m_pRegistrarMan =
7933 new s57RegistrarMgr(g_csv_locn, g_Platform->GetLogFilePtr());
7934
7935 // Preset some object class visibilites for "User Standard" disply
7936 // category
7937 // They may be overridden in LoadS57Config
7938 for (unsigned int iPtr = 0; iPtr < ps52plib->pOBJLArray->GetCount();
7939 iPtr++) {
7940 OBJLElement *pOLE = (OBJLElement *)(ps52plib->pOBJLArray->Item(iPtr));
7941 if (!strncmp(pOLE->OBJLName, "DEPARE", 6)) pOLE->nViz = 1;
7942 if (!strncmp(pOLE->OBJLName, "LNDARE", 6)) pOLE->nViz = 1;
7943 if (!strncmp(pOLE->OBJLName, "COALNE", 6)) pOLE->nViz = 1;
7944 }
7945
7946 pConfig->LoadS57Config();
7947 ps52plib->SetPLIBColorScheme(global_color_scheme, ChartCtxFactory());
7948
7949 if (gFrame) {
7950 ps52plib->SetDisplayWidth(g_monitor_info[g_current_monitor].width);
7951 ps52plib->SetPPMM(g_BasePlatform->GetDisplayDPmm());
7952 double dip_factor = g_BasePlatform->GetDisplayDIPMult(gFrame);
7953 ps52plib->SetDIPFactor(dip_factor);
7954 ps52plib->SetContentScaleFactor(OCPN_GetDisplayContentScaleFactor());
7955 }
7956
7957 // preset S52 PLIB scale factors
7958 ps52plib->SetScaleFactorExp(
7959 g_Platform->GetChartScaleFactorExp(g_ChartScaleFactor));
7960 ps52plib->SetScaleFactorZoomMod(g_chart_zoom_modifier_vector);
7961
7962#ifdef ocpnUSE_GL
7963
7964 // Setup PLIB OpenGL options, if enabled
7965 extern bool g_b_EnableVBO;
7966 extern GLenum g_texture_rectangle_format;
7967 extern OCPN_GLCaps *GL_Caps;
7968
7969 if (g_bopengl) {
7970 if (GL_Caps) {
7971 wxString renderer = wxString(GL_Caps->Renderer.c_str());
7972 ps52plib->SetGLRendererString(renderer);
7973 }
7974
7975 ps52plib->SetGLOptions(
7976 glChartCanvas::s_b_useStencil, glChartCanvas::s_b_useStencilAP,
7977 glChartCanvas::s_b_useScissorTest, glChartCanvas::s_b_useFBO,
7978 g_b_EnableVBO, g_texture_rectangle_format, 1, 1);
7979 }
7980#endif
7981
7982 } else {
7983 wxLogMessage(
7984 _T(" S52PLIB Initialization failed, disabling Vector charts."));
7985 delete ps52plib;
7986 ps52plib = NULL;
7987 }
7988}
7989
7990class ParseENCWorkerThread : public wxThread {
7991public:
7992 ParseENCWorkerThread(wxString filename, Extent &ext, int scale)
7993 : wxThread(wxTHREAD_JOINABLE) {
7994 m_filename = filename;
7995 m_ext = ext;
7996 m_scale = scale;
7997 Create();
7998 }
7999
8000 void *Entry() {
8001 // ChartBase *pchart = ChartData->OpenChartFromDB(m_filename,
8002 // FULL_INIT); ChartData->DeleteCacheChart(pchart);
8003 s57chart *newChart = new s57chart;
8004
8005 newChart->SetNativeScale(m_scale);
8006 newChart->SetFullExtent(m_ext);
8007
8008 newChart->FindOrCreateSenc(m_filename);
8009 delete newChart;
8010 return 0;
8011 }
8012
8013 wxString m_filename;
8014 Extent m_ext;
8015 int m_scale;
8016};
8017
8018// begin duplicated code
8019static double chart_dist(int index) {
8020 double d;
8021 float clon;
8022 float clat;
8023 const ChartTableEntry &cte = ChartData->GetChartTableEntry(index);
8024 // if the chart contains ownship position set the distance to 0
8025 if (cte.GetBBox().Contains(gLat, gLon))
8026 d = 0.;
8027 else {
8028 // find the nearest edge
8029 double t;
8030 clon = (cte.GetLonMax() + cte.GetLonMin()) / 2;
8031 d = DistGreatCircle(cte.GetLatMax(), clon, gLat, gLon);
8032 t = DistGreatCircle(cte.GetLatMin(), clon, gLat, gLon);
8033 if (t < d) d = t;
8034
8035 clat = (cte.GetLatMax() + cte.GetLatMin()) / 2;
8036 t = DistGreatCircle(clat, cte.GetLonMin(), gLat, gLon);
8037 if (t < d) d = t;
8038 t = DistGreatCircle(clat, cte.GetLonMax(), gLat, gLon);
8039 if (t < d) d = t;
8040 }
8041 return d;
8042}
8043
8044WX_DEFINE_SORTED_ARRAY_INT(int, MySortedArrayInt);
8045static int CompareInts(int n1, int n2) {
8046 double d1 = chart_dist(n1);
8047 double d2 = chart_dist(n2);
8048 return (int)(d1 - d2);
8049}
8050
8051class compress_target {
8052public:
8053 wxString chart_path;
8054 double distance;
8055};
8056
8057WX_DECLARE_OBJARRAY(compress_target, ArrayOfCompressTargets);
8058WX_DEFINE_OBJARRAY(ArrayOfCompressTargets);
8059
8060#include <wx/arrimpl.cpp>
8061// end duplicated code
8062
8063void ParseAllENC(wxWindow *parent) {
8064 MySortedArrayInt idx_sorted_by_distance(CompareInts);
8065
8066 // Building the cache may take a long time....
8067 // Be a little smarter.
8068 // Build a sorted array of chart database indices, sorted on distance from the
8069 // ownship currently. This way, a user may build a few chart SENCs for
8070 // immediate use, then "skip" or "cancel"out on the rest until later.
8071 int count = 0;
8072 for (int i = 0; i < ChartData->GetChartTableEntries(); i++) {
8073 /* skip if not ENC */
8074 const ChartTableEntry &cte = ChartData->GetChartTableEntry(i);
8075 if (CHART_TYPE_S57 != cte.GetChartType()) continue;
8076
8077 idx_sorted_by_distance.Add(i);
8078 count++;
8079 }
8080
8081 if (count == 0) return;
8082
8083 wxLogMessage(wxString::Format(_T("ParseAllENC() count = %d"), count));
8084
8085 // Build another array of sorted compression targets.
8086 // We need to do this, as the chart table will not be invariant
8087 // after the compression threads start, so our index array will be invalid.
8088
8089 ArrayOfCompressTargets ct_array;
8090 for (unsigned int j = 0; j < idx_sorted_by_distance.GetCount(); j++) {
8091 int i = idx_sorted_by_distance[j];
8092
8093 const ChartTableEntry &cte = ChartData->GetChartTableEntry(i);
8094 double distance = chart_dist(i);
8095
8096 wxString filename(cte.GetpFullPath(), wxConvUTF8);
8097
8098 compress_target *pct = new compress_target;
8099 pct->distance = distance;
8100 pct->chart_path = filename;
8101
8102 ct_array.push_back(pct);
8103 }
8104
8105 int thread_count = 0;
8106 ParseENCWorkerThread **workers = NULL;
8107
8108 extern int g_nCPUCount;
8109 if (g_nCPUCount > 0)
8110 thread_count = g_nCPUCount;
8111 else
8112 thread_count = wxThread::GetCPUCount();
8113
8114 if (thread_count < 1) {
8115 // obviously there's at least one CPU!
8116 thread_count = 1;
8117 }
8118
8119 // thread_count = 1; // for now because there is a problem with more than 1
8120
8121#if 0
8122 workers = new ParseENCWorkerThread*[thread_count];
8123 for(int t = 0; t < thread_count; t++)
8124 workers[t] = NULL;
8125#endif
8126
8127 wxGenericProgressDialog *prog = nullptr;
8128 wxSize csz = GetOCPNCanvasWindow()->GetClientSize();
8129
8130 if (1) {
8131 long style = wxPD_SMOOTH | wxPD_ELAPSED_TIME | wxPD_ESTIMATED_TIME |
8132 wxPD_REMAINING_TIME | wxPD_CAN_SKIP;
8133
8134 prog = new wxGenericProgressDialog();
8135 wxFont *qFont = GetOCPNScaledFont(_("Dialog"));
8136 prog->SetFont(*qFont);
8137
8138 prog->Create(_("OpenCPN ENC Prepare"),
8139 _T("Longgggggggggggggggggggggggggggg"), count + 1, parent,
8140 style);
8141
8142 // make wider to show long filenames
8143 // wxSize sz = prog->GetSize();
8144 // sz.x = csz.x * 8 / 10;
8145 // prog->SetSize( sz );
8146
8147 DimeControl(prog);
8148#ifdef __WXOSX__
8149 prog->ShowWindowModal();
8150#else
8151 prog->Show();
8152#endif
8153 }
8154
8155 // parse targets
8156 bool skip = false;
8157 count = 0;
8158 for (unsigned int j = 0; j < ct_array.size(); j++) {
8159 wxString filename = ct_array[j].chart_path;
8160 double distance = ct_array[j].distance;
8161 int index = ChartData->FinddbIndex(filename);
8162 if (index < 0) continue;
8163 const ChartTableEntry &cte = ChartData->GetChartTableEntry(index);
8164 Extent ext;
8165 ext.NLAT = cte.GetLatMax();
8166 ext.SLAT = cte.GetLatMin();
8167 ext.WLON = cte.GetLonMin();
8168 ext.ELON = cte.GetLonMax();
8169
8170 int scale = cte.GetScale();
8171
8172 wxString msg;
8173 msg.Printf(_("Distance from Ownship: %4.0f NMi"), distance);
8174
8175 count++;
8176 if (wxThread::IsMain()) {
8177 if (prog) {
8178 wxSize sz = prog->GetSize();
8179 if (sz.x > 600) {
8180 msg += _T(" Chart:");
8181 msg += filename;
8182 }
8183 prog->Update(count, msg, &skip);
8184#ifndef __WXMSW__
8185 prog->Raise();
8186#endif
8187 }
8188 if (skip) break;
8189 }
8190
8191#if 1
8192 if (ps52plib) {
8193 s57chart *newChart = new s57chart;
8194
8195 newChart->SetNativeScale(scale);
8196 newChart->SetFullExtent(ext);
8197 newChart->DisableBackgroundSENC();
8198
8199 newChart->FindOrCreateSenc(filename,
8200 false); // no progress dialog required
8201 delete newChart;
8202
8203 if (wxThread::IsMain()) {
8204 msg.Printf(_("ENC Completed."));
8205 if (prog) {
8206 prog->Update(count, msg, &skip);
8207#ifndef __WXMSW__
8208 prog->Raise();
8209#endif
8210 }
8211 if (skip) break;
8212 }
8213 }
8214
8215#else
8216 for (int t = 0;; t = (t + 1) % thread_count) {
8217 if (!workers[t]) {
8218 workers[t] = new ParseENCWorkerThread(filename);
8219 workers[t]->Run();
8220 break;
8221 }
8222
8223 if (!workers[t]->IsAlive()) {
8224 workers[t]->Wait();
8225 delete workers[t];
8226 workers[t] = NULL;
8227 }
8228 if (t == 0) {
8229 // ::wxYield(); // allow ChartCanvas main
8230 // message loop to run
8231 wxThread::Sleep(1); /* wait for a worker to finish */
8232 }
8233 }
8234#endif
8235
8236#if defined(__WXMSW__) || defined(__WXOSX__)
8237 ::wxSafeYield();
8238#endif
8239 }
8240
8241#if 0
8242 /* wait for workers to finish, and clean up after then */
8243 for(int t = 0; t<thread_count; t++) {
8244 if(workers[t]) {
8245 workers[t]->Wait();
8246 delete workers[t];
8247 }
8248 }
8249 delete [] workers;
8250#endif
8251
8252 delete prog;
8253}
ais_state_vars.h
Global state for AIS decoder.
AISTargetAlertDialog
Dialog for displaying AIS target alerts.
Definition AISTargetAlertDialog.h:62
AISTargetListDialog
Dialog for displaying a list of AIS targets.
Definition AISTargetListDialog.h:55
AISTargetQueryDialog
Dialog for querying detailed information about an AIS target.
Definition AISTargetQueryDialog.h:42
AISTargetQueryDialog::Create
bool Create(wxWindow *parent, wxWindowID id=wxID_ANY, const wxString &caption=_("Object Query"), const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=AIS_TARGET_QUERY_STYLE)
Creation.
Definition AISTargetQueryDialog.cpp:188
AboutFrameImpl
Implements the AboutFrame class with additional functionality.
Definition AboutFrameImpl.h:35
AbstractPlatform::GetDisplayDIPMult
double GetDisplayDIPMult(wxWindow *win)
Get the display scaling factor for DPI-aware rendering.
Definition base_platform.cpp:820
AbstractPlatform::GetPrivateDataDir
wxString & GetPrivateDataDir()
Return dir path for opencpn.log, etc., respecting -c cli option.
Definition base_platform.cpp:296
ActiveTrack
Represents an active track that is currently being recorded.
Definition track.h:194
AisInfoGui
Handles the AIS information GUI and sound alerts.
Definition ais_info_gui.h:32
AlertDialog
A modal message dialog with a cancel and confirmation button.
Definition dialog_alert.h:47
CM93OffsetDialog
Dialog for managing CM93 chart offsets.
Definition cm93.h:547
ChartBase
Base class for all chart types.
Definition chartbase.h:119
ChartCanvas
ChartCanvas - Main chart display and interaction component.
Definition chcanv.h:148
ChartCanvas::m_cursor_lat
double m_cursor_lat
The latitude in degrees corresponding to the most recently processed cursor position.
Definition chcanv.h:742
ChartCanvas::GetCanvasScaleFactor
double GetCanvasScaleFactor()
Return the number of logical pixels per meter for the screen.
Definition chcanv.h:458
ChartCanvas::SetDisplaySizeMM
void SetDisplaySizeMM(double size)
Set the width of the screen in millimeters.
Definition chcanv.cpp:2378
ChartCanvas::GetVPScale
float GetVPScale()
Return the ViewPort scale factor, in physical pixels per meter.
Definition chcanv.h:447
ChartCanvas::DoZoomCanvas
void DoZoomCanvas(double factor, bool can_zoom_to_cursor=true)
Internal function that implements the actual zoom operation.
Definition chcanv.cpp:4641
ChartCanvas::SetVPScale
bool SetVPScale(double sc, bool b_refresh=true)
Sets the viewport scale while maintaining the center point.
Definition chcanv.cpp:5310
ChartCanvas::m_cursor_lon
double m_cursor_lon
The longitude in degrees corresponding to the most recently processed cursor position.
Definition chcanv.h:726
ChartCanvas::ZoomCanvas
void ZoomCanvas(double factor, bool can_zoom_to_cursor=true, bool stoptimer=true)
Perform a smooth zoom operation on the chart canvas by the specified factor.
Definition chcanv.cpp:4621
ChartCanvas::SetViewPoint
bool SetViewPoint(double lat, double lon)
Set the viewport center point.
Definition chcanv.cpp:5329
ChartDB
Manages the chart database and provides access to chart data.
Definition chartdb.h:95
ChartDatabase::Create
bool Create(ArrayOfCDI &dir_array, wxGenericProgressDialog *pprog)
Creates a new chart database from a list of directories.
Definition chartdbs.cpp:1455
ChartGroup
Represents a user-defined collection of logically related charts.
Definition chartdbs.h:464
ChartPrintout::GenerateGLbmp
void GenerateGLbmp()
In OperGL mode, make the bitmap capture of the screen before the print method starts as to be sure th...
Definition printout_chart.cpp:102
ConsoleCanvas
Primary navigation console display for route and vessel tracking.
Definition concanv.h:127
EventVar::Notify
const void Notify()
Notify all listeners, no data supplied.
Definition observable_evtvar.h:76
FontMgr::FindOrCreateFont
wxFont * FindOrCreateFont(int point_size, wxFontFamily family, wxFontStyle style, wxFontWeight weight, bool underline=false, const wxString &facename=wxEmptyString, wxFontEncoding encoding=wxFONTENCODING_DEFAULT)
Creates or finds a matching font in the font cache.
Definition FontMgr.cpp:450
FontMgr::ScrubList
void ScrubList()
Cleans up stale font entries after a locale change.
Definition FontMgr.cpp:565
FontMgr::GetFont
wxFont * GetFont(const wxString &TextElement, int requested_font_size=0)
Gets a font object for a UI element.
Definition FontMgr.cpp:186
Layer
Represents a layer of chart objects in OpenCPN.
Definition Layer.h:38
LocalServerApi::ReleaseInstance
static void ReleaseInstance()
Release Instance.
Definition ipc_factories.cpp:94
LocalServerApi::GetInstance
static LocalServerApi & GetInstance()
Definition ipc_factories.cpp:90
MarkInfoDlg
Dialog for displaying and editing waypoint properties.
Definition MarkInfo.h:212
MyFrame
Main application frame.
Definition ocpn_frame.h:135
MyFrame::InitApiListeners
void InitApiListeners()
Setup handling of events from the local ipc/dbus API.
Definition ocpn_frame.cpp:4949
NMEALogWindow::Active
bool Active() const
Return true if log is visible i.
Definition NMEALogWindow.cpp:54
NMEALogWindow::Add
void Add(const wxString &s)
Add an formatted string to log output.
Definition NMEALogWindow.cpp:70
OCPNPlatform
Provides platform-specific support utilities for OpenCPN.
Definition OCPNPlatform.h:76
OCPNPlatform::GetDisplaySizeMM
double GetDisplaySizeMM()
Get the width of the screen in millimeters.
Definition OCPNPlatform.cpp:1786
OCPN_AUIManager
Definition OCPN_AUIManager.h:32
OCPN_BUILDSENC_ThreadEvent
Definition SencManager.h:86
OCPN_GLCaps
Definition glChartCanvas.h:82
OCPN_MsgEvent
Definition pluginmanager.h:79
ObsListener::Init
void Init(const KeyProvider &kp, std::function< void(ObservedEvt &ev)> action)
Initiate an object yet not listening.
Definition observable.h:255
ObservableListener::Listen
void Listen(const std::string &key, wxEvtHandler *listener, wxEventType evt)
Set object to send wxEventType ev to listener on changes in key.
Definition observable.cpp:98
ObservedEvt
Custom event class for OpenCPN's notification system.
Definition ocpn_plugin.h:5435
ObservedEvt::GetSharedPtr
std::shared_ptr< const void > GetSharedPtr() const
Gets the event's payload data.
Definition ocpn_plugin.h:5461
PlugInContainer
Data for a loaded plugin, including dl-loaded library.
Definition plugin_loader.h:100
PlugInData::m_cap_flag
int m_cap_flag
PlugIn Capabilities descriptor.
Definition plugin_loader.h:76
PluginLoader::LoadAllPlugIns
bool LoadAllPlugIns(bool enabled_plugins, bool keep_orphans=false)
Update catalog with imported metadata and load all plugin library files.
Definition plugin_loader.cpp:425
PrintDialog::GetInstance
static PrintDialog & GetInstance()
Get instance to handle the print process,.
Definition print_dialog.cpp:29
RoutePoint
Represents a waypoint or mark within the navigation system.
Definition route_point.h:68
RoutePoint::m_bIsolatedMark
bool m_bIsolatedMark
Flag indicating if the waypoint is a standalone mark.
Definition route_point.h:192
Route
Represents a navigational route in the navigation system.
Definition route.h:96
Routeman::on_routes_update
EventVar on_routes_update
Notified when list of routes is updated (no data in event)
Definition routeman.h:198
S57QueryDialog
Dialog for displaying query results of S57 objects.
Definition S57QueryDialog.h:39
SENCThreadManager
Manager for S57 chart SENC creation threads.
Definition SencManager.h:104
SystemEvents::evt_resume
EventVar evt_resume
Notified when resuming from hibernate.
Definition sys_events.h:40
TCMgr
Definition tcmgr.h:86
ToolbarItemContainer
Container for toolbar item properties.
Definition toolbar.h:40
TrackPoint
Represents a single point in a track.
Definition track.h:53
TrackPropDlg
Class TrackPropDlg.
Definition TrackPropDlg.h:93
Track
Represents a track, which is a series of connected track points.
Definition track.h:79
ViewPort::view_scale_ppm
double view_scale_ppm
Requested view scale in physical pixels per meter (ppm), before applying projections.
Definition viewport.h:229
ViewPort::rotation
double rotation
Rotation angle of the viewport in radians.
Definition viewport.h:239
ViewPort::skew
double skew
Angular distortion (shear transform) applied to the viewport in radians.
Definition viewport.h:237
ViewPort::clon
double clon
Center longitude of the viewport in degrees.
Definition viewport.h:224
ViewPort::clat
double clat
Center latitude of the viewport in degrees.
Definition viewport.h:222
about
Represents the About dialog for OpenCPN.
Definition about.h:52
canvasConfig
Encapsulates persistent canvas configuration.
Definition CanvasConfig.h:45
canvasConfig::iLat
double iLat
Latitude of the center of the chart, in degrees.
Definition CanvasConfig.h:62
canvasConfig::bShowOutlines
bool bShowOutlines
Display chart outlines.
Definition CanvasConfig.h:74
canvasConfig::canvasSize
wxSize canvasSize
Canvas dimensions.
Definition CanvasConfig.h:72
canvasConfig::bShowDepthUnits
bool bShowDepthUnits
Display depth unit indicators.
Definition CanvasConfig.h:75
canvasConfig::iLon
double iLon
Longitude of the center of the chart, in degrees.
Definition CanvasConfig.h:63
canvasConfig::iRotation
double iRotation
Initial rotation angle in radians.
Definition CanvasConfig.h:65
canvasConfig::bCourseUp
bool bCourseUp
Orient display to course up.
Definition CanvasConfig.h:76
canvasConfig::bQuilt
bool bQuilt
Enable chart quilting.
Definition CanvasConfig.h:69
canvasConfig::bFollow
bool bFollow
Enable vessel following mode.
Definition CanvasConfig.h:68
canvasConfig::iScale
double iScale
Initial chart scale factor.
Definition CanvasConfig.h:64
canvasConfig::bShowGrid
bool bShowGrid
Display coordinate grid.
Definition CanvasConfig.h:73
canvasConfig::canvas
ChartCanvas * canvas
Pointer to associated chart canvas.
Definition CanvasConfig.h:61
canvasConfig::bShowCurrents
bool bShowCurrents
Display current information.
Definition CanvasConfig.h:71
canvasConfig::bShowTides
bool bShowTides
Display tide information.
Definition CanvasConfig.h:70
canvasConfig::bLookahead
bool bLookahead
Enable lookahead mode.
Definition CanvasConfig.h:78
canvasConfig::bHeadUp
bool bHeadUp
Orient display to heading up.
Definition CanvasConfig.h:77
compress_target
Definition glTextureManager.cpp:180
iENCToolbar
Floating toolbar for iENC (International Electronic Navigational Chart) functionality.
Definition iENCToolbar.h:43
ocpnCompass::GetRect
wxRect GetRect(void) const
Return the coordinates of the compass widget, in physical pixels relative to the canvas window.
Definition compass.h:61
ocpnFloatingToolbarDialog
Floating toolbar dialog for OpenCPN.
Definition toolbar.h:386
ocpnToolBarSimple
Generic toolbar implementation in pure wxWidgets adapted from wxToolBarSimple (deprecated).
Definition toolbar.h:103
opencpn_plugin::OnToolbarToolCallback
virtual void OnToolbarToolCallback(int id)
Handles toolbar tool clicks.
Definition ocpn_plugin.cpp:123
s57chart
Represents an S57 format electronic navigational chart in OpenCPN.
Definition s57chart.h:120
wxJSONReader
The JSON parser.
Definition jsonreader.h:50
wxJSONReader::Parse
int Parse(const wxString &doc, wxJSONValue *val)
Parse the JSON document.
Definition jsonreader.cpp:302
wxJSONValue
The JSON value class implementation.
Definition jsonval.h:84
wxJSONValue::HasMember
bool HasMember(unsigned index) const
Return TRUE if the object contains an element at the specified index.
Definition jsonval.cpp:1298
wxJSONValue::AsString
wxString AsString() const
Return the stored value as a wxWidget's string.
Definition jsonval.cpp:872
cmdline.h
Global variables reflecting command line options and arguments.
comm_drv_registry.h
Driver registration container, a singleton.
comm_navmsg_bus.h
Raw messages layer, supports sending and recieving navmsg messages.
GetTopWindow
wxWindow * GetTopWindow()
Return the top level window a k a gFrame.
Definition gui.cpp:29
gui.h
Hooks into gui available in model.
GetOCPNScaledFont
wxFont * GetOCPNScaledFont(wxString item, int default_size)
Retrieves a font from FontMgr, optionally scaled for physical readability.
Definition gui_lib.cpp:54
gui_lib.h
General purpose GUI support.
local_api.h
The local API has a server side handling commands and a client part issuing commands.
logger.h
Enhanced logging interface on top of wx/log.h.
ocpn_plugin.h
PlugIn Object Definition/API.
GetOCPNCanvasWindow
wxWindow * GetOCPNCanvasWindow()
Gets OpenCPN's main canvas window.
Definition ocpn_plugin_gui.cpp:234
OCPN_GetDisplayContentScaleFactor
double OCPN_GetDisplayContentScaleFactor()
Gets content scaling factor for current display.
Definition ocpn_plugin_gui.cpp:2279
JumpToPosition
void JumpToPosition(double lat, double lon, double scale)
Centers chart display on specified position at given scale.
Definition ocpn_plugin_gui.cpp:410
GetCanvasUnderMouse
wxWindow * GetCanvasUnderMouse(void)
Gets canvas window under mouse cursor.
Definition ocpn_plugin_gui.cpp:1665
SendPluginMessage
void SendPluginMessage(wxString message_id, wxString message_body)
Sends message to other plugins.
Definition ocpn_plugin_gui.cpp:394
plugin_comm.h
Tools to send data to plugins.
ChartTableEntry
Represents an entry in the chart table, containing information about a single chart.
Definition chartdbs.h:181
GenericPosDatEx
A generic position and navigation data structure.
Definition ocpn_types.h:74
GenericPosDatEx::kCog
double kCog
Course over ground in degrees.
Definition ocpn_types.h:92
GenericPosDatEx::kHdt
double kHdt
True heading in degrees.
Definition ocpn_types.h:117
GenericPosDatEx::nSats
int nSats
Number of satellites used in the fix.
Definition ocpn_types.h:132
GenericPosDatEx::kHdm
double kHdm
Magnetic heading in degrees.
Definition ocpn_types.h:110
GenericPosDatEx::FixTime
time_t FixTime
UTC time of fix.
Definition ocpn_types.h:124
GenericPosDatEx::kLat
double kLat
Latitude in decimal degrees.
Definition ocpn_types.h:81
GenericPosDatEx::kSog
double kSog
Speed over ground in knots.
Definition ocpn_types.h:98
GenericPosDatEx::kVar
double kVar
Magnetic variation in degrees.
Definition ocpn_types.h:104
GenericPosDatEx::kLon
double kLon
Longitude in decimal degrees.
Definition ocpn_types.h:89
_Extent
Definition chartbase.h:78
sys_events.h
Suspend/resume and new devices events exchange point.
DestroyDeviceNotFoundDialogs
void DestroyDeviceNotFoundDialogs()
Destroy all open "Device not found" dialog windows.
Definition udev_rule_mgr.cpp:60
udev_rule_mgr.h
Access checks for comm devices and dongle.