OpenCPN Partial API docs
Loading...
Searching...
No Matches
canvasMenu.cpp
1/***************************************************************************
2 *
3 * Project: OpenCPN
4 * Purpose: CanvasMenuHandler
5 * Author: David Register
6 *
7 ***************************************************************************
8 * Copyright (C) 2015 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
26// For compilers that support precompilation, includes "wx.h".
27#include <wx/wxprec.h>
28
29#include <wx/aui/aui.h>
30#include <wx/clipbrd.h>
31#include <wx/dynarray.h>
32#include <wx/event.h>
33#include <wx/font.h>
34#include <wx/gdicmn.h>
35#include <wx/graphics.h>
36#include <wx/image.h>
37#include <wx/listbook.h>
38#include <wx/listimpl.cpp>
39#include <wx/menu.h>
40
41#include "model/ais_decoder.h"
42#include "model/ais_state_vars.h"
43#include "model/ais_target_data.h"
44#include "model/config_vars.h"
45#include "model/cutil.h"
46#include "model/georef.h"
47#include "model/gui.h"
48#include "model/mdns_cache.h"
49#include "model/mdns_query.h"
50#include "model/nav_object_database.h"
51#include "model/own_ship.h"
52#include "model/own_ship.h"
53#include "model/plugin_comm.h"
54#include "model/route.h"
55#include "model/routeman.h"
56#include "model/select.h"
57#include "model/track.h"
58
59#include "ais.h"
60#include "canvasMenu.h"
61#include "chartdb.h"
62#include "chcanv.h"
63#include "cm93.h" // for chart outline draw
64#include "config.h"
65#include "FontMgr.h"
66#include "kml.h"
67#include "MarkInfo.h"
68#include "navutil.h"
69#include "ocpn_frame.h"
70#include "OCPNPlatform.h"
71#include "NMEALogWindow.h"
72#include "peer_client_dlg.h"
73#include "pluginmanager.h"
74#include "Quilt.h"
75#include "route_gui.h"
76#include "routemanagerdialog.h"
77#include "routeman_gui.h"
78#include "route_point_gui.h"
79#include "RoutePropDlgImpl.h"
80#include "s52plib.h"
81#include "s52s57.h"
82#include "s57chart.h" // for ArrayOfS57Obj
83#include "SendToGpsDlg.h"
84#include "SendToPeerDlg.h"
85#include "styles.h"
86#include "tcmgr.h"
87#include "TCWin.h"
88#include "tide_time.h"
89#include "track_gui.h"
90#include "TrackPropDlg.h"
91#include "undo.h"
92
93#ifdef __ANDROID__
94#include "androidUTIL.h"
95#endif
96
97// ----------------------------------------------------------------------------
98// Useful Prototypes
99// ----------------------------------------------------------------------------
100extern void pupHandler_PasteRoute();
101extern void pupHandler_PasteTrack();
102extern void pupHandler_PasteWaypoint();
103
104extern Routeman *g_pRouteMan;
105extern bool g_bskew_comp;
106extern double vLat, vLon;
107extern MyFrame *gFrame;
108extern ChartGroupArray *g_pGroupArray;
109extern PlugInManager *g_pi_manager;
110extern int g_nAWMax;
111extern int g_nAWDefault;
112extern wxString g_AW1GUID;
113extern wxString g_AW2GUID;
114extern int g_click_stop;
115extern RouteManagerDialog *pRouteManagerDialog;
116extern MarkInfoDlg *g_pMarkInfoDialog;
117extern RoutePropDlgImpl *pRoutePropDialog;
118extern ActiveTrack *g_pActiveTrack;
119extern bool g_bConfirmObjectDelete;
120extern MyConfig *pConfig;
121extern OCPNPlatform *g_Platform;
122
123extern CM93OffsetDialog *g_pCM93OffsetDialog;
124
125extern GoToPositionDialog *pGoToPositionDialog;
126extern RouteList *pRouteList;
127extern wxString g_default_wp_icon;
128extern bool g_bBasicMenus;
129extern TrackPropDlg *pTrackPropDialog;
130extern bool g_FlushNavobjChanges;
131extern ColorScheme global_color_scheme;
132
133// Constants for right click menus
134enum {
135 ID_DEF_MENU_MAX_DETAIL = 1,
136 ID_DEF_MENU_SCALE_IN,
137 ID_DEF_MENU_SCALE_OUT,
138 ID_DEF_MENU_DROP_WP,
139 ID_DEF_MENU_NEW_RT,
140 ID_DEF_MENU_QUERY,
141 ID_DEF_MENU_MOVE_BOAT_HERE,
142 ID_DEF_MENU_GOTO_HERE,
143 ID_DEF_MENU_GOTOPOSITION,
144
145 ID_WP_MENU_GOTO,
146 ID_WP_MENU_DELPOINT,
147 ID_WP_MENU_PROPERTIES,
148 ID_RT_MENU_ACTIVATE,
149 ID_RT_MENU_DEACTIVATE,
150 ID_RT_MENU_INSERT,
151 ID_RT_MENU_APPEND,
152 ID_RT_MENU_COPY,
153 ID_RT_MENU_SPLIT_LEG,
154 ID_RT_MENU_SPLIT_WPT,
155 ID_TK_MENU_COPY,
156 ID_WPT_MENU_COPY,
157 ID_WPT_MENU_SENDTOGPS,
158 ID_WPT_MENU_SENDTONEWGPS,
159 ID_WPT_MENU_SENDTOPEER,
160 ID_PASTE_WAYPOINT,
161 ID_PASTE_ROUTE,
162 ID_PASTE_TRACK,
163 ID_RT_MENU_DELETE,
164 ID_RT_MENU_REVERSE,
165 ID_RT_MENU_DELPOINT,
166 ID_RT_MENU_ACTPOINT,
167 ID_RT_MENU_DEACTPOINT,
168 ID_RT_MENU_ACTNXTPOINT,
169 ID_RT_MENU_REMPOINT,
170 ID_RT_MENU_PROPERTIES,
171 ID_RT_MENU_SENDTOGPS,
172 ID_RT_MENU_SENDTONEWGPS,
173 ID_RT_MENU_SHOWNAMES,
174 ID_RT_MENU_RESEQUENCE,
175 ID_RT_MENU_SENDTOPEER,
176 ID_WP_MENU_SET_ANCHORWATCH,
177 ID_WP_MENU_CLEAR_ANCHORWATCH,
178 ID_DEF_MENU_AISTARGETLIST,
179 ID_DEF_MENU_AIS_CPAWARNING,
180
181 ID_RC_MENU_SCALE_IN,
182 ID_RC_MENU_SCALE_OUT,
183 ID_RC_MENU_ZOOM_IN,
184 ID_RC_MENU_ZOOM_OUT,
185 ID_RC_MENU_FINISH,
186 ID_DEF_MENU_AIS_QUERY,
187 ID_DEF_MENU_AIS_CPA,
188 ID_DEF_MENU_AISSHOWTRACK,
189 ID_DEF_MENU_ACTIVATE_MEASURE,
190 ID_DEF_MENU_DEACTIVATE_MEASURE,
191 ID_DEF_MENU_COPY_MMSI,
192
193 ID_UNDO,
194 ID_REDO,
195
196 ID_DEF_MENU_CM93OFFSET_DIALOG,
197
198 ID_TK_MENU_PROPERTIES,
199 ID_TK_MENU_DELETE,
200 ID_TK_MENU_SENDTOPEER,
201 ID_WP_MENU_ADDITIONAL_INFO,
202
203 ID_DEF_MENU_QUILTREMOVE,
204 ID_DEF_MENU_COGUP,
205 ID_DEF_MENU_NORTHUP,
206 ID_DEF_MENU_HEADUP,
207 ID_DEF_MENU_TOGGLE_FULL,
208 ID_DEF_MENU_TIDEINFO,
209 ID_DEF_MENU_CURRENTINFO,
210 ID_DEF_ZERO_XTE,
211
212 ID_DEF_MENU_DEBUG,
213 ID_DGB_MENU_NMEA_WINDOW,
214
215 ID_DEF_MENU_GROUPBASE, // Must be last entry, as chart group identifiers are
216 // created dynamically
217
218 ID_DEF_MENU_LAST
219};
220
221//------------------------------------------------------------------------------
222// CanvasMenuHandler Implementation
223//------------------------------------------------------------------------------
224int CanvasMenuHandler::GetNextContextMenuId() {
225 return ID_DEF_MENU_LAST +
226 100; // Allowing for 100 dynamic menu item identifiers
227}
228
229wxFont CanvasMenuHandler::m_scaledFont;
230
231// Define a constructor for my canvas
232CanvasMenuHandler::CanvasMenuHandler(ChartCanvas *parentCanvas,
233 Route *selectedRoute, Track *selectedTrack,
234 RoutePoint *selectedPoint,
235 int selectedAIS_MMSI,
236 void *selectedTCIndex)
237
238{
239 parent = parentCanvas;
240 m_pSelectedRoute = selectedRoute;
241 m_pSelectedTrack = selectedTrack;
242 m_pFoundRoutePoint = selectedPoint;
243 m_FoundAIS_MMSI = selectedAIS_MMSI;
244 m_pIDXCandidate = selectedTCIndex;
245 if (!m_scaledFont.IsOk()) {
246 wxFont *qFont = GetOCPNScaledFont(_("Menu"));
247 m_scaledFont = *qFont;
248 }
249
250 m_DIPFactor = g_Platform->GetDisplayDIPMult(gFrame);
251}
252
253CanvasMenuHandler::~CanvasMenuHandler() {}
254
255//-------------------------------------------------------------------------------
256// Popup Menu Handling
257//-------------------------------------------------------------------------------
258
259void CanvasMenuHandler::PrepareMenuItem(wxMenuItem *item) {
260#if defined(__WXMSW__)
261 wxColour ctrl_back_color = GetGlobalColor(_T("DILG1")); // Control Background
262 item->SetBackgroundColour(ctrl_back_color);
263 wxColour menu_text_color = GetGlobalColor(_T ( "UITX1" ));
264 item->SetTextColour(menu_text_color);
265#endif
266}
267
268void CanvasMenuHandler::MenuPrepend1(wxMenu *menu, int id, wxString label) {
269 wxMenuItem *item = new wxMenuItem(menu, id, label);
270#if defined(__WXMSW__)
271 item->SetFont(m_scaledFont);
272#endif
273
274#ifdef __ANDROID__
275 wxFont sFont = GetOCPNGUIScaledFont(_("Menu"));
276 item->SetFont(sFont);
277#endif
278
279 PrepareMenuItem(item);
280
281 if (g_btouch) menu->InsertSeparator(0);
282 menu->Prepend(item);
283}
284
285void CanvasMenuHandler::MenuAppend1(wxMenu *menu, int id, wxString label) {
286 wxMenuItem *item = new wxMenuItem(menu, id, label);
287#if defined(__WXMSW__)
288 item->SetFont(m_scaledFont);
289#endif
290
291#ifdef __ANDROID__
292 wxFont sFont = GetOCPNGUIScaledFont(_("Menu"));
293 item->SetFont(sFont);
294#endif
295
296 PrepareMenuItem(item);
297
298 menu->Append(item);
299 if (g_btouch) menu->AppendSeparator();
300}
301
302void CanvasMenuHandler::SetMenuItemFont1(wxMenuItem *item) {
303#if defined(__WXMSW__)
304 item->SetFont(m_scaledFont);
305#endif
306
307#if defined(__ANDROID__)
308 wxFont *qFont = GetOCPNScaledFont(_("Menu"));
309 item->SetFont(*qFont);
310#endif
311
312 PrepareMenuItem(item);
313}
314
315void CanvasMenuHandler::CanvasPopupMenu(int x, int y, int seltype) {
316 wxMenu *contextMenu = new wxMenu;
317 wxMenu *menuWaypoint = NULL;
318 wxMenu *menuRoute = NULL;
319 wxMenu *menuTrack = NULL;
320 wxMenu *menuAIS = NULL;
321
322 wxMenu *subMenuChart = new wxMenu;
323 wxMenu *subMenuUndo = new wxMenu("Undo...Ctrl-Z");
324
325#ifdef __WXOSX__
326 wxMenu *subMenuRedo = new wxMenu("Redo...Shift-Ctrl-Z");
327#else
328 wxMenu *subMenuRedo = new wxMenu("Redo...Ctrl-Y");
329#endif
330 wxMenu *subMenuDebug = new wxMenu("");
331 MenuAppend1(subMenuDebug, ID_DGB_MENU_NMEA_WINDOW, "Show NMEA log window");
332
333 wxMenu *menuFocus = contextMenu; // This is the one that will be shown
334
335 popx = x;
336 popy = y;
337
338 if (!g_bBasicMenus || (seltype != SELTYPE_ROUTECREATE)) {
339 bool bsubMenus = false;
340
341 if (bsubMenus) {
342 if (parent->undo->AnythingToUndo()) {
343 // Undo SubMenu
344 wxMenuItem *subMenuItemundo =
345 contextMenu->AppendSubMenu(subMenuUndo, _("Undo"));
346
347 wxString undoItem;
348 undoItem << _("Undo") << _T(" ")
349 << parent->undo->GetNextUndoableAction()->Description();
350 MenuAppend1(subMenuUndo, ID_UNDO, undoItem);
351 }
352 if (parent->undo->AnythingToRedo()) {
353 // Redo SubMenu
354 wxMenuItem *subMenuItemRedo =
355 contextMenu->AppendSubMenu(subMenuRedo, _("Redo"));
356
357 wxString redoItem;
358 redoItem << _("Redo") << _T(" ")
359 << parent->undo->GetNextRedoableAction()->Description();
360 MenuAppend1(subMenuRedo, ID_REDO, redoItem);
361 }
362 } else {
363 if (parent->undo->AnythingToUndo()) {
364 wxString undoItem;
365 undoItem << _("Undo") << _T(" ")
366 << parent->undo->GetNextUndoableAction()->Description();
367 MenuAppend1(contextMenu, ID_UNDO, _menuText(undoItem, _T("Ctrl-Z")));
368 }
369
370 if (parent->undo->AnythingToRedo()) {
371 wxString redoItem;
372 redoItem << _("Redo") << _T(" ")
373 << parent->undo->GetNextRedoableAction()->Description();
374#ifdef __WXOSX__
375 MenuAppend1(contextMenu, ID_REDO,
376 _menuText(redoItem, _T("Shift-Ctrl-Z")));
377#else
378 MenuAppend1(contextMenu, ID_REDO, _menuText(redoItem, _T("Ctrl-Y")));
379#endif
380 }
381 }
382 }
383
384 if (seltype == SELTYPE_ROUTECREATE) {
385 MenuAppend1(contextMenu, ID_RC_MENU_FINISH,
386 _menuText(_("End Route"), _T("Esc")));
387 }
388
389 if (!parent->m_pMouseRoute) {
390 if (parent->m_bMeasure_Active)
391 MenuAppend1(contextMenu, ID_DEF_MENU_DEACTIVATE_MEASURE,
392 _menuText(_("Measure Off"), _T("Esc")));
393 else
394 MenuAppend1(contextMenu, ID_DEF_MENU_ACTIVATE_MEASURE,
395 _menuText(_("Measure"), _T("M")));
396 }
397
398 bool ais_areanotice = false;
399 if (g_pAIS && parent->GetShowAIS() && g_bShowAreaNotices) {
400 float vp_scale = parent->GetVPScale();
401
402 for (const auto &target : g_pAIS->GetAreaNoticeSourcesList()) {
403 auto target_data = target.second;
404 if (!target_data->area_notices.empty()) {
405 for (auto &ani : target_data->area_notices) {
406 Ais8_001_22 &area_notice = ani.second;
407 BoundingBox bbox;
408
409 for (Ais8_001_22_SubAreaList::iterator sa =
410 area_notice.sub_areas.begin();
411 sa != area_notice.sub_areas.end(); ++sa) {
412 switch (sa->shape) {
413 case AIS8_001_22_SHAPE_CIRCLE: {
414 wxPoint target_point;
415 parent->GetCanvasPointPix(sa->latitude, sa->longitude,
416 &target_point);
417 bbox.Expand(target_point);
418 if (sa->radius_m > 0.0) bbox.EnLarge(sa->radius_m * vp_scale);
419 break;
420 }
421 case AIS8_001_22_SHAPE_RECT:
422 case AIS8_001_22_SHAPE_POLYGON:
423 case AIS8_001_22_SHAPE_POLYLINE: {
424 double lat = sa->latitude;
425 double lon = sa->longitude;
426 for (int i = 0; i < 4; ++i) {
427 ll_gc_ll(lat, lon, sa->angles[i], sa->dists_m[i] / 1852.0,
428 &lat, &lon);
429 wxPoint target_point;
430 parent->GetCanvasPointPix(lat, lon, &target_point);
431 bbox.Expand(target_point);
432 }
433 break;
434 }
435 case AIS8_001_22_SHAPE_SECTOR: {
436 double lat1 = sa->latitude;
437 double lon1 = sa->longitude;
438 double lat, lon;
439 wxPoint target_point;
440 parent->GetCanvasPointPix(lat1, lon1, &target_point);
441 bbox.Expand(target_point);
442 for (int i = 0; i < 18; ++i) {
443 ll_gc_ll(
444 lat1, lon1,
445 sa->left_bound_deg +
446 i * (sa->right_bound_deg - sa->left_bound_deg) / 18,
447 sa->radius_m / 1852.0, &lat, &lon);
448 parent->GetCanvasPointPix(lat, lon, &target_point);
449 bbox.Expand(target_point);
450 }
451 ll_gc_ll(lat1, lon1, sa->right_bound_deg, sa->radius_m / 1852.0,
452 &lat, &lon);
453 parent->GetCanvasPointPix(lat, lon, &target_point);
454 bbox.Expand(target_point);
455 break;
456 }
457 }
458 }
459
460 if (bbox.GetValid() && bbox.PointInBox(x, y)) {
461 ais_areanotice = true;
462 break;
463 }
464 }
465 }
466 }
467 }
468
469 int nChartStack = 0;
470 if (parent->GetpCurrentStack())
471 nChartStack = parent->GetpCurrentStack()->nEntry;
472
473 if (!parent->GetVP().b_quilt) {
474 if (nChartStack > 1) {
475 MenuAppend1(contextMenu, ID_DEF_MENU_MAX_DETAIL, _("Max Detail Here"));
476 MenuAppend1(contextMenu, ID_DEF_MENU_SCALE_IN,
477 _menuText(_("Scale In"), _T("Ctrl-Left")));
478 MenuAppend1(contextMenu, ID_DEF_MENU_SCALE_OUT,
479 _menuText(_("Scale Out"), _T("Ctrl-Right")));
480 }
481
482 if ((parent->m_singleChart &&
483 (parent->m_singleChart->GetChartFamily() == CHART_FAMILY_VECTOR)) ||
484 ais_areanotice) {
485 MenuAppend1(contextMenu, ID_DEF_MENU_QUERY,
486 _("Object Query") + _T( "..." ));
487 }
488
489 } else {
490 ChartBase *pChartTest =
491 parent->m_pQuilt->GetChartAtPix(parent->GetVP(), wxPoint(x, y));
492 if ((pChartTest && (pChartTest->GetChartFamily() == CHART_FAMILY_VECTOR)) ||
493 ais_areanotice) {
494 MenuAppend1(contextMenu, ID_DEF_MENU_QUERY,
495 _("Object Query") + _T( "..." ));
496 } else {
497#ifndef __ANDROID__
498 if (!g_bBasicMenus && (nChartStack > 1)) {
499 MenuAppend1(contextMenu, ID_DEF_MENU_SCALE_IN,
500 _menuText(_("Scale In"), _T("Ctrl-Left")));
501 MenuAppend1(contextMenu, ID_DEF_MENU_SCALE_OUT,
502 _menuText(_("Scale Out"), _T("Ctrl-Right")));
503 }
504#endif
505 }
506 }
507
508 if (!g_bBasicMenus || (seltype != SELTYPE_ROUTECREATE)) {
509 bool b_dm_add = true;
510 if (g_btouch && parent->IsMeasureActive()) b_dm_add = false;
511
512 if (b_dm_add) {
513 MenuAppend1(contextMenu, ID_DEF_MENU_DROP_WP,
514 _menuText(_("Drop Mark"), _T("Ctrl-M")));
515 MenuAppend1(contextMenu, ID_DEF_MENU_NEW_RT,
516 _menuText(_("New Route..."), _T("Ctrl-R")));
517 }
518
519 if (!bGPSValid)
520 MenuAppend1(contextMenu, ID_DEF_MENU_MOVE_BOAT_HERE, _("Move Boat Here"));
521 }
522
523 if (!g_bBasicMenus &&
524 (!(g_pRouteMan->GetpActiveRoute() || (seltype & SELTYPE_MARKPOINT))))
525 MenuAppend1(contextMenu, ID_DEF_MENU_GOTO_HERE, _("Navigate To Here"));
526
527 if (!g_bBasicMenus)
528 MenuAppend1(contextMenu, ID_DEF_MENU_GOTOPOSITION,
529 _("Center view") + _T("..."));
530
531 if (!g_bBasicMenus) {
532 if (parent->GetVP().b_quilt) {
533 if (parent->GetUpMode() == NORTH_UP_MODE) {
534 MenuAppend1(contextMenu, ID_DEF_MENU_COGUP, _("Course Up Mode"));
535 if (!std::isnan(gHdt))
536 MenuAppend1(contextMenu, ID_DEF_MENU_HEADUP, _("Heading Up Mode"));
537 } else {
538 MenuAppend1(contextMenu, ID_DEF_MENU_NORTHUP, _("North Up Mode"));
539 }
540 } else {
541 if (parent->m_singleChart &&
542 (fabs(parent->m_singleChart->GetChartSkew()) > .01) && !g_bskew_comp)
543 MenuAppend1(contextMenu, ID_DEF_MENU_NORTHUP, _("Chart Up Mode"));
544 else
545 MenuAppend1(contextMenu, ID_DEF_MENU_NORTHUP, _("North Up Mode"));
546 }
547 }
548
549 if (!g_bBasicMenus) {
550 bool full_toggle_added = false;
551#ifndef __ANDROID__
552 if (g_btouch) {
553 MenuAppend1(contextMenu, ID_DEF_MENU_TOGGLE_FULL,
554 _("Toggle Full Screen"));
555 full_toggle_added = true;
556 }
557
558 if (!full_toggle_added) {
559 // if(gFrame->IsFullScreen())
560 MenuAppend1(contextMenu, ID_DEF_MENU_TOGGLE_FULL,
561 _("Toggle Full Screen"));
562 }
563#endif
564
565 if (g_pRouteMan->IsAnyRouteActive() &&
566 g_pRouteMan->GetCurrentXTEToActivePoint() > 0.)
567 MenuAppend1(contextMenu, ID_DEF_ZERO_XTE, _("Zero XTE"));
568
569 Kml *kml = new Kml;
570 int pasteBuffer = kml->ParsePasteBuffer();
571 if (pasteBuffer != KML_PASTE_INVALID) {
572 switch (pasteBuffer) {
573 case KML_PASTE_WAYPOINT: {
574 MenuAppend1(contextMenu, ID_PASTE_WAYPOINT, _("Paste Waypoint"));
575 break;
576 }
577 case KML_PASTE_ROUTE: {
578 MenuAppend1(contextMenu, ID_PASTE_ROUTE, _("Paste Route"));
579 break;
580 }
581 case KML_PASTE_TRACK: {
582 MenuAppend1(contextMenu, ID_PASTE_TRACK, _("Paste Track"));
583 break;
584 }
585 case KML_PASTE_ROUTE_TRACK: {
586 MenuAppend1(contextMenu, ID_PASTE_ROUTE, _("Paste Route"));
587 MenuAppend1(contextMenu, ID_PASTE_TRACK, _("Paste Track"));
588 break;
589 }
590 }
591 }
592 delete kml;
593
594 if (!parent->GetVP().b_quilt && parent->m_singleChart &&
595 (parent->m_singleChart->GetChartType() == CHART_TYPE_CM93COMP)) {
596 MenuAppend1(contextMenu, ID_DEF_MENU_CM93OFFSET_DIALOG,
597 _("CM93 Offset Dialog..."));
598 }
599
600 } // if( !g_bBasicMenus){
601
602#ifndef __ANDROID__
603// TODO stack
604// if( ( parent->GetVP().b_quilt ) && ( pCurrentStack &&
605// pCurrentStack->b_valid ) ) {
606// int dbIndex = parent->m_pQuilt->GetChartdbIndexAtPix(
607// parent->GetVP(), wxPoint( popx, popy ) ); if( dbIndex != -1 )
608// MenuAppend1( contextMenu, ID_DEF_MENU_QUILTREMOVE, _( "Hide This
609// Chart" ) );
610// }
611#endif
612
613#ifdef __WXMSW__
614 // If we dismiss the context menu without action, we need to discard some
615 // mouse events.... Eat the next 2 button events, which happen as down-up on
616 // MSW XP
617 g_click_stop = 2;
618#endif
619
620 // ChartGroup SubMenu
621 wxMenuItem *subItemChart =
622 contextMenu->AppendSubMenu(subMenuChart, _("Chart Groups"));
623 if (g_btouch) contextMenu->AppendSeparator();
624
625 SetMenuItemFont1(subItemChart);
626
627 if (g_pGroupArray->GetCount()) {
628#ifdef __WXMSW__
629 MenuAppend1(subMenuChart, wxID_CANCEL, _("temporary"));
630#endif
631 wxMenuItem *subItem0 = subMenuChart->AppendRadioItem(
632 ID_DEF_MENU_GROUPBASE, _("All Active Charts"));
633
634 SetMenuItemFont1(subItem0);
635
636 for (unsigned int i = 0; i < g_pGroupArray->GetCount(); i++) {
637 subItem0 = subMenuChart->AppendRadioItem(
638 ID_DEF_MENU_GROUPBASE + i + 1, g_pGroupArray->Item(i)->m_group_name);
639 SetMenuItemFont1(subItem0);
640 }
641
642#ifdef __WXMSW__
643 subMenuChart->Remove(wxID_CANCEL);
644#endif
645 subMenuChart->Check(ID_DEF_MENU_GROUPBASE + parent->m_groupIndex, true);
646 }
647
648 // This is the default context menu
649 menuFocus = contextMenu;
650
651 wxString name;
652 if (!g_bBasicMenus || (seltype != SELTYPE_ROUTECREATE)) {
653 if (g_pAIS) {
654 if (parent->GetShowAIS() && (seltype & SELTYPE_AISTARGET)) {
655 auto myptarget = g_pAIS->Get_Target_Data_From_MMSI(m_FoundAIS_MMSI);
656 if (!g_bBasicMenus && myptarget) {
657 name = myptarget->GetFullName();
658 if (name.IsEmpty()) name.Printf(_T("%d"), m_FoundAIS_MMSI);
659 name.Prepend(_T(" ( ")).Append(_T(" )"));
660 } else
661 name = wxEmptyString;
662 menuAIS = new wxMenu(_("AIS") + name);
663 MenuAppend1(menuAIS, ID_DEF_MENU_AIS_QUERY, _("Target Query..."));
664 if (myptarget && myptarget->bCPA_Valid &&
665 (myptarget->n_alert_state != AIS_ALERT_SET)) {
666 if (myptarget->b_show_AIS_CPA)
667 MenuAppend1(menuAIS, ID_DEF_MENU_AIS_CPA, _("Hide Target CPA"));
668 else
669 MenuAppend1(menuAIS, ID_DEF_MENU_AIS_CPA, _("Show Target CPA"));
670 }
671 MenuAppend1(menuAIS, ID_DEF_MENU_AISTARGETLIST, _("Target List..."));
672 if (myptarget->Class != AIS_METEO /*g_bAISShowTracks*/) {
673 if (myptarget && !myptarget->b_PersistTrack) {
674 if (myptarget->b_show_track)
675 MenuAppend1(menuAIS, ID_DEF_MENU_AISSHOWTRACK,
676 _("Hide Target Track"));
677 else
678 MenuAppend1(menuAIS, ID_DEF_MENU_AISSHOWTRACK,
679 _("Show Target Track"));
680 }
681 }
682
683 MenuAppend1(menuAIS, ID_DEF_MENU_COPY_MMSI, _("Copy Target MMSI"));
684 menuAIS->AppendSeparator();
685
686 if (!parent->GetVP().b_quilt) {
687 if ((parent->m_singleChart &&
688 (parent->m_singleChart->GetChartFamily() ==
689 CHART_FAMILY_VECTOR))) {
690 MenuAppend1(menuAIS, ID_DEF_MENU_QUERY, _("Object Query..."));
691 }
692
693 } else {
694 ChartBase *pChartTest =
695 parent->m_pQuilt->GetChartAtPix(parent->GetVP(), wxPoint(x, y));
696 if ((pChartTest &&
697 (pChartTest->GetChartFamily() == CHART_FAMILY_VECTOR))) {
698 MenuAppend1(menuAIS, ID_DEF_MENU_QUERY, _("Object Query..."));
699 }
700 }
701
702 menuFocus = menuAIS;
703 } else {
704 MenuAppend1(contextMenu, ID_DEF_MENU_AISTARGETLIST,
705 _("AIS target list") + _T("..."));
706
707 wxString nextCPAstatus = g_bCPAWarn ? _("Hide") : _("Show");
708 MenuAppend1(contextMenu, ID_DEF_MENU_AIS_CPAWARNING,
709 _menuText(nextCPAstatus + " " + _("CPA alarm "), "W"));
710 }
711 }
712 }
713 if (g_enable_root_menu_debug)
714 contextMenu->AppendSubMenu(subMenuDebug, _("Debug"));
715
716 if (seltype & SELTYPE_ROUTESEGMENT) {
717 if (!g_bBasicMenus && m_pSelectedRoute) {
718 name = m_pSelectedRoute->m_RouteNameString;
719 if (name.IsEmpty()) name = _("Unnamed Route");
720 name.Prepend(_T(" ( ")).Append(_T(" )"));
721 } else
722 name = wxEmptyString;
723 bool blay = false;
724 if (m_pSelectedRoute && m_pSelectedRoute->m_bIsInLayer) blay = true;
725
726 if (blay) {
727 menuRoute = new wxMenu(_("Layer Route") + name);
728 MenuAppend1(menuRoute, ID_RT_MENU_PROPERTIES,
729 _("Properties") + _T( "..." ));
730 if (m_pSelectedRoute) {
731 if (m_pSelectedRoute->IsActive()) {
732 int indexActive = m_pSelectedRoute->GetIndexOf(
733 m_pSelectedRoute->m_pRouteActivePoint);
734 if ((indexActive + 1) <= m_pSelectedRoute->GetnPoints()) {
735 MenuAppend1(menuRoute, ID_RT_MENU_ACTNXTPOINT,
736 _("Activate Next Waypoint"));
737 }
738 MenuAppend1(menuRoute, ID_RT_MENU_DEACTIVATE, _("Deactivate"));
739 MenuAppend1(menuRoute, ID_DEF_ZERO_XTE, _("Zero XTE"));
740 } else {
741 MenuAppend1(menuRoute, ID_RT_MENU_ACTIVATE, _("Activate"));
742 }
743 }
744 } else {
745 menuRoute = new wxMenu(_("Route") + name);
746 MenuAppend1(menuRoute, ID_RT_MENU_PROPERTIES,
747 _("Properties") + _T( "..." ));
748 if (m_pSelectedRoute) {
749 if (m_pSelectedRoute->IsActive()) {
750 int indexActive = m_pSelectedRoute->GetIndexOf(
751 m_pSelectedRoute->m_pRouteActivePoint);
752 if ((indexActive + 1) <= m_pSelectedRoute->GetnPoints()) {
753 MenuAppend1(menuRoute, ID_RT_MENU_ACTNXTPOINT,
754 _("Activate Next Waypoint"));
755 }
756 MenuAppend1(menuRoute, ID_RT_MENU_DEACTIVATE, _("Deactivate"));
757 MenuAppend1(menuRoute, ID_DEF_ZERO_XTE, _("Zero XTE"));
758 } else {
759 MenuAppend1(menuRoute, ID_RT_MENU_ACTIVATE, _("Activate"));
760 }
761 }
762 MenuAppend1(menuRoute, ID_RT_MENU_INSERT, _("Insert Waypoint"));
763 MenuAppend1(menuRoute, ID_RT_MENU_APPEND, _("Append Waypoint"));
764 if (!(seltype & SELTYPE_ROUTEPOINT) && m_pSelectedRoute) {
765 m_SelectedIdx = m_pSelectedRoute->GetIndexOf(m_pFoundRoutePoint);
766 if (m_SelectedIdx > 1 &&
767 m_SelectedIdx < m_pSelectedRoute->GetnPoints() - 1)
768 MenuAppend1(menuRoute, ID_RT_MENU_SPLIT_LEG, _("Split around Leg"));
769 }
770 MenuAppend1(menuRoute, ID_RT_MENU_COPY, _("Copy as KML") + _T( "..." ));
771 MenuAppend1(menuRoute, ID_RT_MENU_DELETE, _("Delete") + _T( "..." ));
772 MenuAppend1(menuRoute, ID_RT_MENU_REVERSE, _("Reverse..."));
773 if (m_pSelectedRoute) {
774 if (m_pSelectedRoute->AreWaypointNamesVisible())
775 MenuAppend1(menuRoute, ID_RT_MENU_SHOWNAMES,
776 _("Hide Waypoint Names"));
777 else
778 MenuAppend1(menuRoute, ID_RT_MENU_SHOWNAMES,
779 _("Show Waypoint Names"));
780 }
781 MenuAppend1(menuRoute, ID_RT_MENU_RESEQUENCE,
782 _("Resequence Waypoints..."));
783
784 // #ifndef __ANDROID__
785 wxString port = parent->FindValidUploadPort();
786 parent->m_active_upload_port = port;
787 wxString item = _("Send to GPS");
788 if (!port.IsEmpty()) {
789 item.Append(_T(" ( "));
790 item.Append(port);
791 item.Append(_T(" )"));
792 }
793 MenuAppend1(menuRoute, ID_RT_MENU_SENDTOGPS, item);
794
795 if (!port.IsEmpty()) {
796 wxString item = _("Send to new GPS");
797 MenuAppend1(menuRoute, ID_RT_MENU_SENDTONEWGPS, item);
798 }
799 // #endif
800 wxString itemstp = SYMBOL_STP_TITLE; // Send to Peer
801 MenuAppend1(menuRoute, ID_RT_MENU_SENDTOPEER, itemstp);
802 }
803 // Eventually set this menu as the "focused context menu"
804 if (menuFocus != menuAIS) menuFocus = menuRoute;
805 }
806
807 if (seltype & SELTYPE_TRACKSEGMENT) {
808 name = wxEmptyString;
809 if (!g_bBasicMenus && m_pSelectedTrack)
810 name = _T(" ( ") + m_pSelectedTrack->GetName(true) + _T(" )");
811 else
812 name = wxEmptyString;
813 bool blay = false;
814 if (m_pSelectedTrack && m_pSelectedTrack->m_bIsInLayer) blay = true;
815
816 if (blay) {
817 menuTrack = new wxMenu(_("Layer Track") + name);
818 MenuAppend1(menuTrack, ID_TK_MENU_PROPERTIES,
819 _("Properties") + _T( "..." ));
820 } else {
821 menuTrack = new wxMenu(_("Track") + name);
822 MenuAppend1(menuTrack, ID_TK_MENU_PROPERTIES,
823 _("Properties") + _T( "..." ));
824 MenuAppend1(menuTrack, ID_TK_MENU_COPY, _("Copy as KML"));
825 MenuAppend1(menuTrack, ID_TK_MENU_DELETE, _("Delete") + _T( "..." ));
826 }
827
828 wxString itemstp = SYMBOL_STP_TITLE; // Send to Peer
829 MenuAppend1(menuTrack, ID_TK_MENU_SENDTOPEER, itemstp);
830
831 // Eventually set this menu as the "focused context menu"
832 if (menuFocus != menuAIS) menuFocus = menuTrack;
833 }
834
835 if (seltype & SELTYPE_ROUTEPOINT) {
836 if (!g_bBasicMenus && m_pFoundRoutePoint) {
837 name = m_pFoundRoutePoint->GetName();
838 if (name.IsEmpty()) name = _("Unnamed Waypoint");
839 name.Prepend(_T(" ( ")).Append(_T(" )"));
840 } else
841 name = wxEmptyString;
842 bool blay = false;
843 if (m_pFoundRoutePoint && m_pFoundRoutePoint->m_bIsInLayer) blay = true;
844
845 if (blay) {
846 menuWaypoint = new wxMenu(_("Layer Waypoint") + name);
847 MenuAppend1(menuWaypoint, ID_WP_MENU_PROPERTIES,
848 _("Properties") + _T( "..." ));
849
850 if (m_pSelectedRoute && m_pSelectedRoute->IsActive())
851 MenuAppend1(menuWaypoint, ID_RT_MENU_ACTPOINT, _("Activate"));
852 } else {
853 menuWaypoint = new wxMenu(_("Waypoint") + name);
854 MenuAppend1(menuWaypoint, ID_WP_MENU_PROPERTIES,
855 _("Properties") + _T( "..." ));
856 if (m_pSelectedRoute && m_pSelectedRoute->IsActive()) {
857 if (m_pSelectedRoute->m_pRouteActivePoint != m_pFoundRoutePoint)
858 MenuAppend1(menuWaypoint, ID_RT_MENU_ACTPOINT, _("Activate"));
859 }
860
861 if (m_pSelectedRoute && m_pSelectedRoute->IsActive()) {
862 if (m_pSelectedRoute->m_pRouteActivePoint == m_pFoundRoutePoint) {
863 int indexActive = m_pSelectedRoute->GetIndexOf(
864 m_pSelectedRoute->m_pRouteActivePoint);
865 if ((indexActive + 1) <= m_pSelectedRoute->GetnPoints())
866 MenuAppend1(menuWaypoint, ID_RT_MENU_ACTNXTPOINT,
867 _("Activate Next Waypoint"));
868 }
869 }
870 if (m_pSelectedRoute && m_pSelectedRoute->GetnPoints() > 2) {
871 MenuAppend1(menuWaypoint, ID_RT_MENU_REMPOINT, _("Remove from Route"));
872
873 m_SelectedIdx = m_pSelectedRoute->GetIndexOf(m_pFoundRoutePoint);
874 if (m_SelectedIdx > 1 && m_SelectedIdx < m_pSelectedRoute->GetnPoints())
875 MenuAppend1(menuWaypoint, ID_RT_MENU_SPLIT_WPT,
876 _("Split Route at Waypoint"));
877 }
878
879 MenuAppend1(menuWaypoint, ID_WPT_MENU_COPY, _("Copy as KML"));
880
881 if (m_pFoundRoutePoint && m_pFoundRoutePoint->GetIconName() != _T("mob"))
882 MenuAppend1(menuWaypoint, ID_RT_MENU_DELPOINT, _("Delete"));
883
884 // #ifndef __ANDROID__
885 wxString port = parent->FindValidUploadPort();
886 parent->m_active_upload_port = port;
887 wxString item = _("Send to GPS");
888 if (!port.IsEmpty()) {
889 item.Append(_T(" ( "));
890 item.Append(port);
891 item.Append(_T(" )"));
892 }
893 MenuAppend1(menuWaypoint, ID_WPT_MENU_SENDTOGPS, item);
894
895 if (!port.IsEmpty()) {
896 wxString item = _("Send to new GPS");
897 MenuAppend1(menuWaypoint, ID_WPT_MENU_SENDTONEWGPS, item);
898 }
899
900 MenuAppend1(menuWaypoint, ID_WPT_MENU_SENDTOPEER,
901 SYMBOL_STP_TITLE); // Send to Peer
902 }
903
904 // Eventually set this menu as the "focused context menu"
905 if (menuFocus != menuAIS) menuFocus = menuWaypoint;
906 }
907
908 if (seltype & SELTYPE_MARKPOINT) {
909 if (!g_bBasicMenus && m_pFoundRoutePoint) {
910 name = m_pFoundRoutePoint->GetName();
911 if (name.IsEmpty()) name = _("Unnamed Mark");
912 name.Prepend(_T(" ( ")).Append(_T(" )"));
913 } else
914 name = wxEmptyString;
915 bool blay = false;
916 if (m_pFoundRoutePoint && m_pFoundRoutePoint->m_bIsInLayer) blay = true;
917
918 if (blay) {
919 menuWaypoint = new wxMenu(_("Layer Waypoint") + name);
920 MenuAppend1(menuWaypoint, ID_WP_MENU_PROPERTIES,
921 _("Properties") + _T( "..." ));
922 } else {
923 menuWaypoint = new wxMenu(_("Mark") + name);
924 MenuAppend1(menuWaypoint, ID_WP_MENU_PROPERTIES,
925 _("Properties") + _T( "..." ));
926
927 if (!g_pRouteMan->GetpActiveRoute())
928 MenuAppend1(menuWaypoint, ID_WP_MENU_GOTO, _("Navigate To This"));
929
930 MenuAppend1(menuWaypoint, ID_WPT_MENU_COPY, _("Copy as KML"));
931
932 if (m_pFoundRoutePoint && m_pFoundRoutePoint->GetIconName() != _T("mob"))
933 MenuAppend1(menuWaypoint, ID_WP_MENU_DELPOINT, _("Delete"));
934
935 // #ifndef __ANDROID__
936 wxString port = parent->FindValidUploadPort();
937 parent->m_active_upload_port = port;
938 wxString item = _("Send to GPS");
939 if (!port.IsEmpty()) {
940 item.Append(_T(" ( "));
941 item.Append(port);
942 item.Append(_T(" )"));
943 }
944 MenuAppend1(menuWaypoint, ID_WPT_MENU_SENDTOGPS, item);
945
946 MenuAppend1(menuWaypoint, ID_WPT_MENU_SENDTOPEER,
947 SYMBOL_STP_TITLE); // Send to Peer
948 // #endif
949
950 if ((m_pFoundRoutePoint == pAnchorWatchPoint1) ||
951 (m_pFoundRoutePoint == pAnchorWatchPoint2))
952 MenuAppend1(menuWaypoint, ID_WP_MENU_CLEAR_ANCHORWATCH,
953 _("Clear Anchor Watch"));
954 else {
955 if (m_pFoundRoutePoint && !(m_pFoundRoutePoint->m_bIsInLayer) &&
956 ((NULL == pAnchorWatchPoint1) || (NULL == pAnchorWatchPoint2))) {
957 double dist;
958 double brg;
959 DistanceBearingMercator(m_pFoundRoutePoint->m_lat,
960 m_pFoundRoutePoint->m_lon, gLat, gLon, &brg,
961 &dist);
962 if (dist * 1852. <= g_nAWMax)
963 MenuAppend1(menuWaypoint, ID_WP_MENU_SET_ANCHORWATCH,
964 _("Set Anchor Watch"));
965 }
966 }
967 }
968 // Eventually set this menu as the "focused context menu"
969 if (menuFocus != menuAIS) menuFocus = menuWaypoint;
970 }
971 /*add the relevant submenus*/
972 enum { WPMENU = 1, TKMENU = 2, RTMENU = 4, MMMENU = 8 };
973 int sub_menu = 0;
974 if (!g_bBasicMenus && menuFocus != contextMenu) {
975 if (global_color_scheme != GLOBAL_COLOR_SCHEME_DUSK &&
976 global_color_scheme != GLOBAL_COLOR_SCHEME_NIGHT) {
977 menuFocus->AppendSeparator();
978 }
979 wxMenuItem *subMenu1;
980 if (menuWaypoint && menuFocus != menuWaypoint) {
981 subMenu1 =
982 menuFocus->AppendSubMenu(menuWaypoint, menuWaypoint->GetTitle());
983 SetMenuItemFont1(subMenu1);
984 sub_menu |= WPMENU;
985#ifdef __WXMSW__
986 menuWaypoint->SetTitle(wxEmptyString);
987#endif
988 }
989 if (menuTrack && menuFocus != menuTrack) {
990 subMenu1 = menuFocus->AppendSubMenu(menuTrack, menuTrack->GetTitle());
991 SetMenuItemFont1(subMenu1);
992 sub_menu |= TKMENU;
993#ifdef __WXMSW__
994 menuTrack->SetTitle(wxEmptyString);
995#endif
996 }
997 if (menuRoute && menuFocus != menuRoute) {
998 subMenu1 = menuFocus->AppendSubMenu(menuRoute, menuRoute->GetTitle());
999 SetMenuItemFont1(subMenu1);
1000 sub_menu |= RTMENU;
1001#ifdef __WXMSW__
1002 menuRoute->SetTitle(wxEmptyString);
1003#endif
1004 }
1005 subMenu1 = menuFocus->AppendSubMenu(contextMenu, _("Main Menu"));
1006 SetMenuItemFont1(subMenu1);
1007 sub_menu |= MMMENU;
1008 }
1009
1010 if (!subMenuChart->GetMenuItemCount()) contextMenu->Destroy(subItemChart);
1011
1012 // Add the Tide/Current selections if the item was not activated by shortcut
1013 // in right-click handlers
1014 bool bsep = false;
1015 if (seltype & SELTYPE_TIDEPOINT) {
1016 menuFocus->AppendSeparator();
1017 bsep = true;
1018 MenuAppend1(menuFocus, ID_DEF_MENU_TIDEINFO, _("Show Tide Information"));
1019 }
1020
1021 if (seltype & SELTYPE_CURRENTPOINT) {
1022 if (!bsep) menuFocus->AppendSeparator();
1023 MenuAppend1(menuFocus, ID_DEF_MENU_CURRENTINFO,
1024 _("Show Current Information"));
1025 }
1026
1027 // Give the plugins a chance to update their menu items
1028 g_pi_manager->PrepareAllPluginContextMenus();
1029
1030 // Add PlugIn Context Menu items
1031 ArrayOfPlugInMenuItems item_array =
1032 g_pi_manager->GetPluginContextMenuItemArray();
1033
1034 for (unsigned int i = 0; i < item_array.GetCount(); i++) {
1035 PlugInMenuItemContainer *pimis = item_array[i];
1036 if (!pimis->b_viz) continue;
1037
1038 wxMenu *submenu = NULL;
1039 if (pimis->pmenu_item->GetSubMenu()) {
1040 submenu = new wxMenu();
1041 const wxMenuItemList &items =
1042 pimis->pmenu_item->GetSubMenu()->GetMenuItems();
1043 for (wxMenuItemList::const_iterator it = items.begin(); it != items.end();
1044 ++it) {
1045 int id = -1;
1046 for (unsigned int j = 0; j < item_array.GetCount(); j++) {
1047 PlugInMenuItemContainer *pimis = item_array[j];
1048 if (pimis->pmenu_item == *it) id = pimis->id;
1049 }
1050
1051 wxMenuItem *pmi = new wxMenuItem(submenu, id,
1052#if wxCHECK_VERSION(3, 0, 0)
1053 (*it)->GetItemLabelText(),
1054#else
1055 (*it)->GetLabel(),
1056#endif
1057 (*it)->GetHelp(), (*it)->GetKind());
1058
1059#ifdef __WXMSW__
1060 pmi->SetFont(m_scaledFont);
1061#endif
1062
1063#ifdef __ANDROID__
1064 wxFont sFont = GetOCPNGUIScaledFont(_("Menu"));
1065 pmi->SetFont(sFont);
1066#endif
1067
1068 PrepareMenuItem(pmi);
1069 submenu->Append(pmi);
1070 pmi->Check((*it)->IsChecked());
1071 }
1072 }
1073
1074 wxMenuItem *pmi = new wxMenuItem(contextMenu, pimis->id,
1075#if wxCHECK_VERSION(3, 0, 0)
1076 pimis->pmenu_item->GetItemLabelText(),
1077#else
1078 pimis->pmenu_item->GetLabel(),
1079#endif
1080 pimis->pmenu_item->GetHelp(),
1081 pimis->pmenu_item->GetKind(), submenu);
1082#ifdef __WXMSW__
1083 pmi->SetFont(m_scaledFont);
1084#endif
1085
1086#ifdef __ANDROID__
1087 wxFont sFont = GetOCPNGUIScaledFont(_("Menu"));
1088 pmi->SetFont(sFont);
1089#endif
1090
1091 PrepareMenuItem(pmi);
1092
1093 wxMenu *dst = contextMenu;
1094 if (pimis->m_in_menu == "Waypoint")
1095 dst = menuWaypoint;
1096 else if (pimis->m_in_menu == "Route")
1097 dst = menuRoute;
1098 else if (pimis->m_in_menu == "Track")
1099 dst = menuTrack;
1100 else if (pimis->m_in_menu == "AIS")
1101 dst = menuAIS;
1102
1103 if (dst != NULL) {
1104 dst->Append(pmi);
1105 dst->Enable(pimis->id, !pimis->b_grey);
1106 }
1107 }
1108
1109 // Invoke the correct focused drop-down menu
1110
1111#ifdef __ANDROID__
1112 androidEnableBackButton(false);
1113 androidEnableOptionsMenu(false);
1114
1115 setMenuStyleSheet(menuRoute, GetOCPNGUIScaledFont(_("Menu")));
1116 setMenuStyleSheet(menuWaypoint, GetOCPNGUIScaledFont(_("Menu")));
1117 setMenuStyleSheet(menuTrack, GetOCPNGUIScaledFont(_("Menu")));
1118 setMenuStyleSheet(menuAIS, GetOCPNGUIScaledFont(_("Menu")));
1119#endif
1120
1121 parent->PopupMenu(menuFocus, x, y);
1122
1123#ifdef __ANDROID__
1124 androidEnableBackButton(true);
1125 androidEnableOptionsMenu(true);
1126#endif
1127
1128 /* Cleanup if necessary.
1129 Do not delete menus witch are submenu as they will be deleted by their parent
1130 menu. This could create a crash*/
1131 delete menuAIS;
1132 if (!(sub_menu & MMMENU)) delete contextMenu;
1133 if (!(sub_menu & RTMENU)) delete menuRoute;
1134 if (!(sub_menu & TKMENU)) delete menuTrack;
1135 if (!(sub_menu & WPMENU)) delete menuWaypoint;
1136}
1137
1138void CanvasMenuHandler::PopupMenuHandler(wxCommandEvent &event) {
1139 RoutePoint *pLast;
1140
1141 wxPoint r;
1142 double zlat, zlon;
1143
1144 int splitMode = 0; // variables for split
1145 bool dupFirstWpt = true, showRPD;
1146
1147 parent->GetCanvasPixPoint(popx * parent->GetDisplayScale(),
1148 popy * parent->GetDisplayScale(), zlat, zlon);
1149
1150 switch (event.GetId()) {
1151 case ID_DEF_MENU_MAX_DETAIL:
1152 vLat = zlat;
1153 vLon = zlon;
1154 parent->ClearbFollow();
1155
1156 parent->parent_frame->DoChartUpdate();
1157
1158 parent->SelectChartFromStack(0, false, CHART_TYPE_DONTCARE,
1159 CHART_FAMILY_RASTER);
1160 break;
1161
1162 case ID_DEF_MENU_SCALE_IN:
1163 parent->DoCanvasStackDelta(-1);
1164 break;
1165
1166 case ID_DEF_MENU_SCALE_OUT:
1167 parent->DoCanvasStackDelta(1);
1168 break;
1169
1170 case ID_UNDO:
1171 parent->undo->UndoLastAction();
1172 parent->InvalidateGL();
1173 parent->Refresh(false);
1174 break;
1175
1176 case ID_REDO:
1177 parent->undo->RedoNextAction();
1178 parent->InvalidateGL();
1179 parent->Refresh(false);
1180 break;
1181
1182 case ID_DEF_MENU_MOVE_BOAT_HERE:
1183 gLat = zlat;
1184 gLon = zlon;
1185 gFrame->UpdateStatusBar();
1186 break;
1187
1188 case ID_DEF_MENU_GOTO_HERE: {
1189 RoutePoint *pWP_dest = new RoutePoint(zlat, zlon, g_default_wp_icon,
1190 wxEmptyString, wxEmptyString);
1191 pSelect->AddSelectableRoutePoint(zlat, zlon, pWP_dest);
1192
1193 RoutePoint *pWP_src = new RoutePoint(gLat, gLon, g_default_wp_icon,
1194 wxEmptyString, wxEmptyString);
1195 pSelect->AddSelectableRoutePoint(gLat, gLon, pWP_src);
1196
1197 Route *temp_route = new Route();
1198 pRouteList->Append(temp_route);
1199
1200 temp_route->AddPoint(pWP_src);
1201 temp_route->AddPoint(pWP_dest);
1202
1203 pSelect->AddSelectableRouteSegment(gLat, gLon, zlat, zlon, pWP_src,
1204 pWP_dest, temp_route);
1205
1206 temp_route->m_RouteNameString = _("Temporary GOTO Route");
1207 temp_route->m_RouteStartString = _("Here");
1208 ;
1209 temp_route->m_RouteEndString = _("There");
1210
1211 temp_route->m_bDeleteOnArrival = true;
1212
1213 if (g_pRouteMan->GetpActiveRoute()) g_pRouteMan->DeactivateRoute();
1214
1215 g_pRouteMan->ActivateRoute(temp_route, pWP_dest);
1216
1217 break;
1218 }
1219
1220 case ID_DEF_MENU_DROP_WP: {
1221 RoutePoint *pWP = new RoutePoint(zlat, zlon, g_default_wp_icon,
1222 wxEmptyString, wxEmptyString);
1223 pWP->m_bIsolatedMark = true; // This is an isolated mark
1224 pSelect->AddSelectableRoutePoint(zlat, zlon, pWP);
1225 pConfig->AddNewWayPoint(pWP, -1); // use auto next num
1226 if (!RoutePointGui(*pWP).IsVisibleSelectable(this->parent))
1227 RoutePointGui(*pWP).ShowScaleWarningMessage(parent);
1228
1229 if (RouteManagerDialog::getInstanceFlag()) {
1230 if (pRouteManagerDialog && pRouteManagerDialog->IsShown()) {
1231 pRouteManagerDialog->UpdateWptListCtrl();
1232 }
1233 }
1234
1235 parent->undo->BeforeUndoableAction(Undo_CreateWaypoint, pWP,
1236 Undo_HasParent, NULL);
1237 parent->undo->AfterUndoableAction(NULL);
1238 gFrame->RefreshAllCanvas(false);
1239 gFrame->InvalidateAllGL();
1240 g_FlushNavobjChanges = true;
1241 break;
1242 }
1243
1244 case ID_DEF_MENU_NEW_RT: {
1245 parent->StartRoute();
1246 break;
1247 }
1248
1249 case ID_DEF_MENU_AISTARGETLIST:
1250 parent->ShowAISTargetList();
1251 break;
1252
1253 case ID_DEF_MENU_AIS_CPAWARNING:
1254 parent->ToggleCPAWarn();
1255 break;
1256
1257 case ID_WP_MENU_GOTO: {
1258 RoutePoint *pWP_src = new RoutePoint(gLat, gLon, g_default_wp_icon,
1259 wxEmptyString, wxEmptyString);
1260 pSelect->AddSelectableRoutePoint(gLat, gLon, pWP_src);
1261
1262 Route *temp_route = new Route();
1263 pRouteList->Append(temp_route);
1264
1265 temp_route->AddPoint(pWP_src);
1266 temp_route->AddPoint(m_pFoundRoutePoint);
1267 m_pFoundRoutePoint->SetShared(true);
1268
1269 pSelect->AddSelectableRouteSegment(gLat, gLon, m_pFoundRoutePoint->m_lat,
1270 m_pFoundRoutePoint->m_lon, pWP_src,
1271 m_pFoundRoutePoint, temp_route);
1272
1273 wxString name = m_pFoundRoutePoint->GetName();
1274 if (name.IsEmpty()) name = _("(Unnamed Waypoint)");
1275 wxString rteName = _("Go to ");
1276 rteName.Append(name);
1277 temp_route->m_RouteNameString = rteName;
1278 temp_route->m_RouteStartString = _("Here");
1279 ;
1280 temp_route->m_RouteEndString = name;
1281 temp_route->m_bDeleteOnArrival = true;
1282
1283 if (g_pRouteMan->GetpActiveRoute()) g_pRouteMan->DeactivateRoute();
1284
1285 g_pRouteMan->ActivateRoute(temp_route, m_pFoundRoutePoint);
1286
1287 break;
1288 }
1289
1290 case ID_DEF_MENU_COGUP:
1291 parent->SetUpMode(COURSE_UP_MODE);
1292 break;
1293
1294 case ID_DEF_MENU_HEADUP:
1295 parent->SetUpMode(HEAD_UP_MODE);
1296 break;
1297
1298 case ID_DEF_MENU_NORTHUP:
1299 parent->SetUpMode(NORTH_UP_MODE);
1300 break;
1301
1302 case ID_DEF_MENU_TOGGLE_FULL:
1303 gFrame->ToggleFullScreen();
1304 break;
1305
1306 case ID_DEF_MENU_GOTOPOSITION:
1307 if (NULL == pGoToPositionDialog) // There is one global instance of the
1308 // Go To Position Dialog
1309 pGoToPositionDialog = new GoToPositionDialog(parent);
1310 pGoToPositionDialog->SetCanvas(parent);
1311 pGoToPositionDialog->CheckPasteBufferForPosition();
1312 pGoToPositionDialog->Show();
1313 break;
1314
1315 case ID_WP_MENU_DELPOINT: {
1316 if (m_pFoundRoutePoint == pAnchorWatchPoint1) {
1317 pAnchorWatchPoint1 = NULL;
1318 g_AW1GUID.Clear();
1319 } else if (m_pFoundRoutePoint == pAnchorWatchPoint2) {
1320 pAnchorWatchPoint2 = NULL;
1321 g_AW2GUID.Clear();
1322 }
1323
1324 if (m_pFoundRoutePoint && !(m_pFoundRoutePoint->m_bIsInLayer) &&
1325 (m_pFoundRoutePoint->GetIconName() != _T("mob"))) {
1326 // If the WP belongs to an invisible route, we come here instead of to
1327 // ID_RT_MENU_DELPOINT
1328 // Check it, and if so then remove the point from its routes
1329 wxArrayPtrVoid *proute_array =
1330 g_pRouteMan->GetRouteArrayContaining(m_pFoundRoutePoint);
1331 if (proute_array) {
1332 pWayPointMan->DestroyWaypoint(m_pFoundRoutePoint);
1333 } else {
1334 parent->undo->BeforeUndoableAction(
1335 Undo_DeleteWaypoint, m_pFoundRoutePoint, Undo_IsOrphanded,
1336 NULL /*m_pFoundPoint*/);
1337 pConfig->DeleteWayPoint(m_pFoundRoutePoint);
1338 pSelect->DeleteSelectablePoint(m_pFoundRoutePoint,
1339 SELTYPE_ROUTEPOINT);
1340 if (NULL != pWayPointMan)
1341 pWayPointMan->RemoveRoutePoint(m_pFoundRoutePoint);
1342 parent->undo->AfterUndoableAction(NULL);
1343 }
1344
1345 if (g_pMarkInfoDialog) {
1346 g_pMarkInfoDialog->ClearData();
1347 }
1348
1349 if (RouteManagerDialog::getInstanceFlag()) {
1350 if (pRouteManagerDialog) {
1351 if (pRouteManagerDialog->IsShown())
1352 pRouteManagerDialog->UpdateWptListCtrl();
1353 }
1354 }
1355
1356 gFrame->RefreshAllCanvas(false);
1357 gFrame->InvalidateAllGL();
1358 }
1359 break;
1360 }
1361 case ID_WP_MENU_PROPERTIES:
1362 parent->ShowMarkPropertiesDialog(m_pFoundRoutePoint);
1363 break;
1364
1365 case ID_WP_MENU_CLEAR_ANCHORWATCH: {
1366 wxString guid = wxEmptyString;
1367 if (pAnchorWatchPoint1 == m_pFoundRoutePoint) {
1368 pAnchorWatchPoint1 = NULL;
1369 guid = g_AW1GUID;
1370 g_AW1GUID.Clear();
1371 } else if (pAnchorWatchPoint2 == m_pFoundRoutePoint) {
1372 pAnchorWatchPoint2 = NULL;
1373 guid = g_AW2GUID;
1374 g_AW2GUID.Clear();
1375 }
1376 if (!guid.IsEmpty()) {
1377 wxJSONValue v;
1378 v[_T("GUID")] = guid;
1379 wxString msg_id(_T("OCPN_ANCHOR_WATCH_CLEARED"));
1380 SendJSONMessageToAllPlugins(msg_id, v);
1381 }
1382 break;
1383 }
1384
1385 case ID_WP_MENU_SET_ANCHORWATCH: {
1386 wxString guid = wxEmptyString;
1387 if (pAnchorWatchPoint1 == NULL) {
1388 pAnchorWatchPoint1 = m_pFoundRoutePoint;
1389 g_AW1GUID = pAnchorWatchPoint1->m_GUID;
1390 guid = g_AW1GUID;
1391 wxString nn;
1392 nn = m_pFoundRoutePoint->GetName();
1393 if (nn.IsNull()) {
1394 nn.Printf(_T("%d m"), g_nAWDefault);
1395 m_pFoundRoutePoint->SetName(nn);
1396 }
1397 } else if (pAnchorWatchPoint2 == NULL) {
1398 pAnchorWatchPoint2 = m_pFoundRoutePoint;
1399 g_AW2GUID = pAnchorWatchPoint2->m_GUID;
1400 guid = g_AW2GUID;
1401 wxString nn;
1402 nn = m_pFoundRoutePoint->GetName();
1403 if (nn.IsNull()) {
1404 nn.Printf(_T("%d m"), g_nAWDefault);
1405 m_pFoundRoutePoint->SetName(nn);
1406 }
1407 }
1408 if (!guid.IsEmpty()) {
1409 wxJSONValue v;
1410 v[_T("GUID")] = guid;
1411 wxString msg_id(_T("OCPN_ANCHOR_WATCH_SET"));
1412 SendJSONMessageToAllPlugins(msg_id, v);
1413 }
1414 break;
1415 }
1416
1417 case ID_DEF_MENU_ACTIVATE_MEASURE:
1418 parent->StartMeasureRoute();
1419 break;
1420
1421 case ID_DEF_MENU_DEACTIVATE_MEASURE:
1422 parent->CancelMeasureRoute();
1423 // gFrame->SurfaceAllCanvasToolbars();
1424 parent->InvalidateGL();
1425 parent->Refresh(false);
1426 break;
1427
1428 case ID_DEF_MENU_CM93OFFSET_DIALOG: {
1429 if (NULL == g_pCM93OffsetDialog) {
1430 g_pCM93OffsetDialog = new CM93OffsetDialog(parent->parent_frame);
1431 }
1432
1433 cm93compchart *pch = NULL;
1434 if (!parent->GetVP().b_quilt && parent->m_singleChart &&
1435 (parent->m_singleChart->GetChartType() == CHART_TYPE_CM93COMP)) {
1436 pch = (cm93compchart *)parent->m_singleChart;
1437 }
1438
1439 if (g_pCM93OffsetDialog) {
1440 g_pCM93OffsetDialog->SetCM93Chart(pch);
1441 g_pCM93OffsetDialog->Show();
1442 g_pCM93OffsetDialog->UpdateMCOVRList(parent->GetVP());
1443 }
1444
1445 break;
1446 }
1447 case ID_DEF_MENU_QUERY: {
1448 parent->ShowObjectQueryWindow(popx, popy, zlat, zlon);
1449 break;
1450 }
1451 case ID_DEF_MENU_AIS_QUERY: {
1452 ShowAISTargetQueryDialog(parent, m_FoundAIS_MMSI);
1453 break;
1454 }
1455
1456 case ID_DEF_MENU_AIS_CPA: {
1457 auto myptarget = g_pAIS->Get_Target_Data_From_MMSI(m_FoundAIS_MMSI);
1458 if (myptarget) myptarget->Toggle_AIS_CPA();
1459 break;
1460 }
1461
1462 case ID_DEF_MENU_AISSHOWTRACK: {
1463 auto myptarget = g_pAIS->Get_Target_Data_From_MMSI(m_FoundAIS_MMSI);
1464 if (myptarget) myptarget->ToggleShowTrack();
1465 break;
1466 }
1467
1468 case ID_DEF_MENU_COPY_MMSI: {
1469 // Write MMSI # as text to the clipboard
1470 if (wxTheClipboard->Open()) {
1471 wxTheClipboard->SetData(new wxTextDataObject(
1472 wxString::Format(wxT("%09d"), m_FoundAIS_MMSI)));
1473 wxTheClipboard->Close();
1474 }
1475 break;
1476 }
1477
1478 case ID_DEF_MENU_QUILTREMOVE: {
1479 if (parent->GetVP().b_quilt) {
1480 int dbIndex = parent->m_pQuilt->GetChartdbIndexAtPix(
1481 parent->GetVP(), wxPoint(popx, popy));
1482 parent->RemoveChartFromQuilt(dbIndex);
1483
1484 parent->ReloadVP();
1485 }
1486
1487 break;
1488 }
1489
1490 case ID_DEF_MENU_CURRENTINFO: {
1491 parent->DrawTCWindow(popx, popy, (void *)m_pIDXCandidate);
1492 parent->Refresh(false);
1493
1494 break;
1495 }
1496
1497 case ID_DEF_MENU_TIDEINFO: {
1498 parent->DrawTCWindow(popx, popy, (void *)m_pIDXCandidate);
1499 parent->Refresh(false);
1500
1501 break;
1502 }
1503
1504 case ID_DGB_MENU_NMEA_WINDOW: {
1505 if (!wxWindow::FindWindowByName("NmeaDebugWindow")) {
1506 auto top_window = wxWindow::FindWindowByName(kTopLevelWindowName);
1507 NMEALogWindow::GetInstance().Create(top_window, 35);
1508 }
1509 wxWindow::FindWindowByName("NmeaDebugWindow")->Show();
1510 } break;
1511
1512 case ID_RT_MENU_REVERSE: {
1513 if (m_pSelectedRoute->m_bIsInLayer) break;
1514
1515 int ask_return =
1516 OCPNMessageBox(parent, g_pRouteMan->GetRouteReverseMessage(),
1517 _("Rename Waypoints?"), wxYES_NO | wxCANCEL);
1518
1519 if (ask_return != wxID_CANCEL) {
1520 pSelect->DeleteAllSelectableRouteSegments(m_pSelectedRoute);
1521 m_pSelectedRoute->Reverse(ask_return == wxID_YES);
1522 pSelect->AddAllSelectableRouteSegments(m_pSelectedRoute);
1523
1524 pConfig->UpdateRoute(m_pSelectedRoute);
1525
1526 if (pRoutePropDialog && (pRoutePropDialog->IsShown())) {
1527 pRoutePropDialog->SetRouteAndUpdate(m_pSelectedRoute);
1528 // pNew->UpdateProperties();
1529 }
1530 gFrame->InvalidateAllGL();
1531 gFrame->RefreshAllCanvas();
1532 }
1533 break;
1534 }
1535
1536 case ID_RT_MENU_SHOWNAMES: {
1537 if (m_pSelectedRoute) {
1538 m_pSelectedRoute->ShowWaypointNames(
1539 !m_pSelectedRoute->AreWaypointNamesVisible());
1540 }
1541
1542 break;
1543 }
1544
1545 case ID_RT_MENU_RESEQUENCE: {
1546 if (m_pSelectedRoute) {
1547 if (m_pSelectedRoute->m_bIsInLayer) break;
1548
1549 int ask_return =
1550 OCPNMessageBox(parent, g_pRouteMan->GetRouteResequenceMessage(),
1551 _("Rename Waypoints?"), wxYES_NO | wxCANCEL);
1552
1553 if (ask_return != wxID_CANCEL) {
1554 m_pSelectedRoute->RenameRoutePoints();
1555 }
1556
1557 gFrame->InvalidateAllGL();
1558 gFrame->RefreshAllCanvas();
1559 }
1560
1561 break;
1562 }
1563
1564 case ID_RT_MENU_DELETE: {
1565 bool confirmed = RouteGui::OnDelete(parent);
1566
1567 if (confirmed) {
1568 if (g_pRouteMan->GetpActiveRoute() == m_pSelectedRoute)
1569 g_pRouteMan->DeactivateRoute();
1570
1571 if (m_pSelectedRoute->m_bIsInLayer) break;
1572
1573 if (!g_pRouteMan->DeleteRoute(m_pSelectedRoute,
1574 NavObjectChanges::getInstance()))
1575 break;
1576
1577 if (RouteManagerDialog::getInstanceFlag()) {
1578 if (pRouteManagerDialog && pRouteManagerDialog->IsShown())
1579 pRouteManagerDialog->UpdateRouteListCtrl();
1580 }
1581
1582 if (g_pMarkInfoDialog && g_pMarkInfoDialog->IsShown()) {
1583 g_pMarkInfoDialog->ValidateMark();
1584 g_pMarkInfoDialog->UpdateProperties();
1585 }
1586
1587 parent->undo->InvalidateUndo();
1588
1589 gFrame->InvalidateAllGL();
1590 gFrame->RefreshAllCanvas();
1591 }
1592 break;
1593 }
1594
1595 case ID_RT_MENU_ACTIVATE: {
1596 if (g_pRouteMan->GetpActiveRoute()) g_pRouteMan->DeactivateRoute();
1597
1598 // If this is an auto-created MOB route, always select the second point
1599 // (the MOB)
1600 // as the destination.
1601 RoutePoint *best_point;
1602 if (m_pSelectedRoute) {
1603 if (wxNOT_FOUND ==
1604 m_pSelectedRoute->m_RouteNameString.Find(_T("MOB"))) {
1605 best_point = g_pRouteMan->FindBestActivatePoint(
1606 m_pSelectedRoute, gLat, gLon, gCog, gSog);
1607 } else
1608 best_point = m_pSelectedRoute->GetPoint(2);
1609
1610 g_pRouteMan->ActivateRoute(m_pSelectedRoute, best_point);
1611 m_pSelectedRoute->m_bRtIsSelected = false;
1612 }
1613
1614 break;
1615 }
1616
1617 case ID_RT_MENU_DEACTIVATE:
1618 g_pRouteMan->DeactivateRoute();
1619 m_pSelectedRoute->m_bRtIsSelected = false;
1620
1621 break;
1622
1623 case ID_RT_MENU_INSERT: {
1624 if (m_pSelectedRoute->m_bIsInLayer) break;
1625 bool rename = false;
1626 m_pSelectedRoute->InsertPointAfter(m_pFoundRoutePoint, zlat, zlon,
1627 rename);
1628
1629 pSelect->DeleteAllSelectableRoutePoints(m_pSelectedRoute);
1630 pSelect->DeleteAllSelectableRouteSegments(m_pSelectedRoute);
1631
1632 pSelect->AddAllSelectableRouteSegments(m_pSelectedRoute);
1633 pSelect->AddAllSelectableRoutePoints(m_pSelectedRoute);
1634
1635 // As a special case (which comes up often)...
1636 // If the inserted waypoint is on the active leg of an active route
1637 /* if(m_pSelectedRoute->m_bRtIsActive)
1638 {
1639 if(m_pSelectedRoute->m_nRouteActivePoint == np + 1)
1640 {
1641 pNew_Point = m_pSelectedRoute->GetPoint(np + 2);
1642 pRouteMan->ActivateRoutePoint(m_pSelectedRoute, pNew_Point);
1643 }
1644 }
1645 */
1646 pConfig->UpdateRoute(m_pSelectedRoute);
1647
1648 if (pRoutePropDialog && (pRoutePropDialog->IsShown())) {
1649 pRoutePropDialog->SetRouteAndUpdate(m_pSelectedRoute, true);
1650 }
1651
1652 break;
1653 }
1654
1655 case ID_RT_MENU_APPEND:
1656
1657 if (m_pSelectedRoute->m_bIsInLayer) break;
1658
1659 parent->m_pMouseRoute = m_pSelectedRoute;
1660 parent->m_routeState = m_pSelectedRoute->GetnPoints() + 1;
1661 parent->m_pMouseRoute->m_lastMousePointIndex =
1662 m_pSelectedRoute->GetnPoints();
1663 parent->m_pMouseRoute->SetHiLite(50);
1664
1665 pLast = m_pSelectedRoute->GetLastPoint();
1666
1667 parent->m_prev_rlat = pLast->m_lat;
1668 parent->m_prev_rlon = pLast->m_lon;
1669 parent->m_prev_pMousePoint = pLast;
1670
1671 parent->m_bAppendingRoute = true;
1672
1673 parent->SetCursor(*parent->pCursorPencil);
1674#ifdef __ANDROID__
1675 androidSetRouteAnnunciator(true);
1676#endif
1677
1678 parent->HideGlobalToolbar();
1679
1680 break;
1681
1682 case ID_RT_MENU_SPLIT_LEG: // split route around a leg
1683 splitMode++;
1684 dupFirstWpt = false;
1685 case ID_RT_MENU_SPLIT_WPT: // split route at a wpt
1686
1687 showRPD = (pRoutePropDialog && pRoutePropDialog->IsShown());
1688
1689 if (g_pRouteMan->GetpActiveRoute() == m_pSelectedRoute)
1690 g_pRouteMan->DeactivateRoute();
1691
1692 m_pHead = new Route();
1693 m_pTail = new Route();
1694 m_pHead->CloneRoute(m_pSelectedRoute, 1, m_SelectedIdx, _("_A"));
1695 m_pTail->CloneRoute(m_pSelectedRoute, m_SelectedIdx + splitMode,
1696 m_pSelectedRoute->GetnPoints(), _("_B"), dupFirstWpt);
1697 pRouteList->Append(m_pHead);
1698 pConfig->AddNewRoute(m_pHead);
1699
1700 pRouteList->Append(m_pTail);
1701 pConfig->AddNewRoute(m_pTail);
1702
1703 pConfig->DeleteConfigRoute(m_pSelectedRoute);
1704
1705 pSelect->DeleteAllSelectableRoutePoints(m_pSelectedRoute);
1706 pSelect->DeleteAllSelectableRouteSegments(m_pSelectedRoute);
1707 g_pRouteMan->DeleteRoute(m_pSelectedRoute,
1708 NavObjectChanges::getInstance());
1709 pSelect->AddAllSelectableRouteSegments(m_pTail);
1710 pSelect->AddAllSelectableRoutePoints(m_pTail);
1711 pSelect->AddAllSelectableRouteSegments(m_pHead);
1712 pSelect->AddAllSelectableRoutePoints(m_pHead);
1713
1714 if (showRPD) {
1715 pRoutePropDialog->SetRouteAndUpdate(m_pHead);
1716 pRoutePropDialog->Show();
1717 }
1718 if (RouteManagerDialog::getInstanceFlag() && pRouteManagerDialog &&
1719 (pRouteManagerDialog->IsShown()))
1720 pRouteManagerDialog->UpdateRouteListCtrl();
1721 break;
1722
1723 case ID_RT_MENU_COPY:
1724 if (m_pSelectedRoute) Kml::CopyRouteToClipboard(m_pSelectedRoute);
1725 break;
1726
1727 case ID_TK_MENU_COPY:
1728 if (m_pSelectedTrack) Kml::CopyTrackToClipboard(m_pSelectedTrack);
1729 break;
1730
1731 case ID_WPT_MENU_COPY:
1732 if (m_pFoundRoutePoint) Kml::CopyWaypointToClipboard(m_pFoundRoutePoint);
1733 break;
1734
1735 case ID_WPT_MENU_SENDTOGPS:
1736 if (m_pFoundRoutePoint) {
1737 if (parent->m_active_upload_port.Length())
1738 RoutePointGui(*m_pFoundRoutePoint)
1739 .SendToGPS(parent->m_active_upload_port.BeforeFirst(' '), NULL);
1740 else {
1741 SendToGpsDlg dlg;
1742 dlg.SetWaypoint(m_pFoundRoutePoint);
1743 wxFont fo = GetOCPNGUIScaledFont(_("Dialog"));
1744 dlg.SetFont(fo);
1745
1746 dlg.Create(NULL, -1, _("Send to GPS") + _T( "..." ), _T(""));
1747 dlg.ShowModal();
1748 }
1749 }
1750 break;
1751
1752 case ID_WPT_MENU_SENDTONEWGPS:
1753 if (m_pFoundRoutePoint) {
1754 SendToGpsDlg dlg;
1755 dlg.SetWaypoint(m_pFoundRoutePoint);
1756
1757 dlg.Create(NULL, -1, _("Send to GPS") + _T( "..." ), _T(""));
1758 dlg.ShowModal();
1759 }
1760 break;
1761
1762 case ID_WPT_MENU_SENDTOPEER:
1763 if (m_pFoundRoutePoint) {
1764 SendToPeerDlg dlg;
1765 dlg.SetWaypoint(m_pFoundRoutePoint);
1766
1767 // Perform initial scan, if necessary
1768
1769 // Check for stale cache...
1770 MdnsCache::GetInstance().Validate();
1771 if (MdnsCache::GetInstance().GetCache().empty())
1772 dlg.SetScanOnCreate(true);
1773
1774 dlg.SetScanTime(5); // seconds
1775 dlg.Create(NULL, -1, _("Send Waypoint to OpenCPN Peer") + _T( "..." ),
1776 _T(""));
1777 dlg.ShowModal();
1778 }
1779 break;
1780
1781 case ID_RT_MENU_SENDTOGPS:
1782 if (m_pSelectedRoute) {
1783 if (parent->m_active_upload_port.Length())
1784 RouteGui(*m_pSelectedRoute)
1785 .SendToGPS(parent->m_active_upload_port.BeforeFirst(' '), true,
1786 NULL);
1787 else {
1788 SendToGpsDlg dlg;
1789 dlg.SetRoute(m_pSelectedRoute);
1790
1791 dlg.Create(NULL, -1, _("Send to GPS") + _T( "..." ), _T(""));
1792 dlg.ShowModal();
1793 }
1794 }
1795 break;
1796
1797 case ID_RT_MENU_SENDTONEWGPS:
1798 if (m_pSelectedRoute) {
1799 SendToGpsDlg dlg;
1800 dlg.SetRoute(m_pSelectedRoute);
1801
1802 dlg.Create(NULL, -1, _("Send to GPS") + _T( "..." ), _T(""));
1803 dlg.ShowModal();
1804 }
1805 break;
1806
1807 case ID_RT_MENU_SENDTOPEER:
1808 if (m_pSelectedRoute) {
1809 SendToPeerDlg dlg;
1810 dlg.SetRoute(m_pSelectedRoute);
1811
1812 // Perform initial scan, if necessary
1813
1814 // Check for stale cache...
1815 MdnsCache::GetInstance().Validate();
1816 if (MdnsCache::GetInstance().GetCache().empty())
1817 dlg.SetScanOnCreate(true);
1818
1819 dlg.SetScanTime(5); // seconds
1820 dlg.Create(NULL, -1, _("Send Route to OpenCPN Peer") + _T( "..." ),
1821 _T(""));
1822 dlg.ShowModal();
1823 }
1824 break;
1825
1826 case ID_PASTE_WAYPOINT:
1827 pupHandler_PasteWaypoint();
1828 break;
1829
1830 case ID_PASTE_ROUTE:
1831 pupHandler_PasteRoute();
1832 break;
1833
1834 case ID_PASTE_TRACK:
1835 pupHandler_PasteTrack();
1836 break;
1837
1838 case ID_RT_MENU_DELPOINT:
1839 if (m_pSelectedRoute) {
1840 if (m_pSelectedRoute->m_bIsInLayer) break;
1841
1842 pWayPointMan->DestroyWaypoint(m_pFoundRoutePoint);
1843
1844 if (pRoutePropDialog && (pRoutePropDialog->IsShown())) {
1845 // Selected route may have been deleted as one-point route, so
1846 // check it
1847 if (g_pRouteMan->IsRouteValid(m_pSelectedRoute)) {
1848 pRoutePropDialog->SetRouteAndUpdate(m_pSelectedRoute, true);
1849 } else
1850 pRoutePropDialog->Hide();
1851 }
1852
1853 if (RouteManagerDialog::getInstanceFlag()) {
1854 if (pRouteManagerDialog && pRouteManagerDialog->IsShown()) {
1855 pRouteManagerDialog->UpdateWptListCtrl();
1856 pRouteManagerDialog->UpdateRouteListCtrl();
1857 }
1858 }
1859
1860 gFrame->InvalidateAllGL();
1861 gFrame->RefreshAllCanvas(true);
1862 }
1863
1864 break;
1865
1866 case ID_RT_MENU_REMPOINT:
1867 if (m_pSelectedRoute) {
1868 if (m_pSelectedRoute->m_bIsInLayer) break;
1869 g_pRouteMan->RemovePointFromRoute(m_pFoundRoutePoint, m_pSelectedRoute,
1870 parent->m_routeState);
1871 gFrame->InvalidateAllGL();
1872 gFrame->RefreshAllCanvas();
1873 }
1874 break;
1875
1876 case ID_RT_MENU_ACTPOINT:
1877 if (g_pRouteMan->GetpActiveRoute() == m_pSelectedRoute) {
1878 g_pRouteMan->ActivateRoutePoint(m_pSelectedRoute, m_pFoundRoutePoint);
1879 m_pSelectedRoute->m_bRtIsSelected = false;
1880 }
1881
1882 break;
1883
1884 case ID_RT_MENU_DEACTPOINT:
1885 break;
1886
1887 case ID_RT_MENU_ACTNXTPOINT:
1888 if (g_pRouteMan->GetpActiveRoute() == m_pSelectedRoute) {
1889 g_pRouteMan->ActivateNextPoint(m_pSelectedRoute, true);
1890 m_pSelectedRoute->m_bRtIsSelected = false;
1891 }
1892
1893 break;
1894
1895 case ID_RT_MENU_PROPERTIES: {
1896 parent->ShowRoutePropertiesDialog(_("Route Properties"),
1897 m_pSelectedRoute);
1898 break;
1899 }
1900
1901 case ID_TK_MENU_PROPERTIES: {
1902 parent->ShowTrackPropertiesDialog(m_pSelectedTrack);
1903 break;
1904 }
1905
1906 case ID_TK_MENU_DELETE: {
1907 int dlg_return = wxID_YES;
1908 if (g_bConfirmObjectDelete) {
1909 dlg_return = OCPNMessageBox(
1910 parent, _("Are you sure you want to delete this track?"),
1911 _("OpenCPN Track Delete"),
1912 (long)wxYES_NO | wxCANCEL | wxYES_DEFAULT);
1913 }
1914
1915 if (dlg_return == wxID_YES) {
1916 if (m_pSelectedTrack == g_pActiveTrack)
1917 m_pSelectedTrack = parent->parent_frame->TrackOff();
1918 g_pAIS->DeletePersistentTrack(m_pSelectedTrack);
1919 pConfig->DeleteConfigTrack(m_pSelectedTrack);
1920
1921 RoutemanGui(*g_pRouteMan).DeleteTrack(m_pSelectedTrack);
1922
1923 if (TrackPropDlg::getInstanceFlag() && pTrackPropDialog &&
1924 (pTrackPropDialog->IsShown()) &&
1925 (m_pSelectedTrack == pTrackPropDialog->GetTrack())) {
1926 pTrackPropDialog->Hide();
1927 }
1928
1929 if (RoutePropDlgImpl::getInstanceFlag() && pRouteManagerDialog &&
1930 pRouteManagerDialog->IsShown()) {
1931 pRouteManagerDialog->UpdateTrkListCtrl();
1932 pRouteManagerDialog->UpdateRouteListCtrl();
1933 }
1934 gFrame->InvalidateAllGL();
1935 gFrame->RefreshAllCanvas();
1936 }
1937 break;
1938 }
1939
1940 case ID_TK_MENU_SENDTOPEER:
1941 if (m_pSelectedTrack) {
1942 SendToPeerDlg dlg;
1943 dlg.SetTrack(m_pSelectedTrack);
1944
1945 // Perform initial scan, if necessary
1946
1947 // Check for stale cache...
1948 MdnsCache::GetInstance().Validate();
1949 if (MdnsCache::GetInstance().GetCache().empty())
1950 dlg.SetScanOnCreate(true);
1951
1952 dlg.SetScanTime(5); // seconds
1953 dlg.Create(NULL, -1, _("Send Track to OpenCPN Peer") + _T( "..." ),
1954 _T(""));
1955 dlg.ShowModal();
1956 }
1957 break;
1958
1959 case ID_RC_MENU_SCALE_IN:
1960 parent->parent_frame->DoStackDown(parent);
1961 parent->GetCanvasPointPix(zlat, zlon, &r);
1962 parent->WarpPointer(r.x, r.y);
1963 break;
1964
1965 case ID_RC_MENU_SCALE_OUT:
1966 parent->parent_frame->DoStackUp(parent);
1967 parent->GetCanvasPointPix(zlat, zlon, &r);
1968 parent->WarpPointer(r.x, r.y);
1969 break;
1970
1971 case ID_RC_MENU_ZOOM_IN:
1972 parent->SetVPScale(parent->GetVPScale() * 2);
1973 parent->GetCanvasPointPix(zlat, zlon, &r);
1974 parent->WarpPointer(r.x, r.y);
1975 break;
1976
1977 case ID_RC_MENU_ZOOM_OUT:
1978 parent->SetVPScale(parent->GetVPScale() / 2);
1979 parent->GetCanvasPointPix(zlat, zlon, &r);
1980 parent->WarpPointer(r.x, r.y);
1981 break;
1982
1983 case ID_RC_MENU_FINISH:
1984 parent->FinishRoute();
1985 // gFrame->SurfaceAllCanvasToolbars();
1986 parent->Refresh(false);
1987 g_FlushNavobjChanges = true;
1988 break;
1989
1990 case ID_DEF_ZERO_XTE:
1991 g_pRouteMan->ZeroCurrentXTEToActivePoint();
1992 break;
1993
1994 default: {
1995 // Look for PlugIn Context Menu selections
1996 // If found, make the callback
1997 ArrayOfPlugInMenuItems item_array =
1998 g_pi_manager->GetPluginContextMenuItemArray();
1999
2000 for (unsigned int i = 0; i < item_array.GetCount(); i++) {
2001 PlugInMenuItemContainer *pimis = item_array[i];
2002 {
2003 if (pimis->id == event.GetId()) {
2004 if (pimis->m_pplugin)
2005 pimis->m_pplugin->OnContextMenuItemCallback(pimis->id);
2006 }
2007 }
2008 }
2009
2010 break;
2011 }
2012 } // switch
2013
2014 // Chart Groups....
2015 if ((event.GetId() >= ID_DEF_MENU_GROUPBASE) &&
2016 (event.GetId() <=
2017 ID_DEF_MENU_GROUPBASE + (int)g_pGroupArray->GetCount())) {
2018 parent->SetGroupIndex(event.GetId() - ID_DEF_MENU_GROUPBASE);
2019 }
2020
2021 parent->InvalidateGL();
2022
2023 g_click_stop = 0; // Context menu was processed, all is well
2024}
ais_state_vars.h
Global state for AIS decoder.
AbstractPlatform::GetDisplayDIPMult
double GetDisplayDIPMult(wxWindow *win)
Get the display scaling factor for DPI-aware rendering.
Definition base_platform.cpp:820
ActiveTrack
Represents an active track that is currently being recorded.
Definition track.h:194
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::GetCanvasPointPix
bool GetCanvasPointPix(double rlat, double rlon, wxPoint *r)
Convert latitude/longitude to canvas pixel coordinates (physical pixels) rounded to nearest integer.
Definition chcanv.cpp:4535
ChartCanvas::GetDisplayScale
double GetDisplayScale()
Get the ratio of physical to logical pixel for the display.
Definition chcanv.h:821
ChartCanvas::GetVPScale
float GetVPScale()
Return the ViewPort scale factor, in physical pixels per meter.
Definition chcanv.h:447
ChartCanvas::SetVPScale
bool SetVPScale(double sc, bool b_refresh=true)
Sets the viewport scale while maintaining the center point.
Definition chcanv.cpp:5310
ChartCanvas::GetCanvasPixPoint
void GetCanvasPixPoint(double x, double y, double &lat, double &lon)
Convert canvas pixel coordinates (physical pixels) to latitude/longitude.
Definition chcanv.cpp:4560
Kml
Definition kml.h:54
MarkInfoDlg
Dialog for displaying and editing waypoint properties.
Definition MarkInfo.h:212
MdnsCache::Validate
void Validate()
Check that all entries are accessible, remove stale ones.
Definition mdns_cache.cpp:74
MyFrame
Main application frame.
Definition ocpn_frame.h:135
OCPNPlatform
Provides platform-specific support utilities for OpenCPN.
Definition OCPNPlatform.h:76
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::ActivateRoutePoint
bool ActivateRoutePoint(Route *pA, RoutePoint *pRP)
Definition routeman.cpp:320
Routeman::ActivateNextPoint
bool ActivateNextPoint(Route *pr, bool skipped)
Definition routeman.cpp:395
Routeman::DeleteRoute
bool DeleteRoute(Route *pRoute, NavObjectChanges *nav_obj_changes)
Definition routeman.cpp:835
SendToGpsDlg
Dialog for sending routes/waypoints to a GPS device.
Definition SendToGpsDlg.h:53
SendToPeerDlg
Dialog for sending navigation objects to peer devices.
Definition SendToPeerDlg.h:73
TrackPropDlg
Class TrackPropDlg.
Definition TrackPropDlg.h:93
Track
Represents a track, which is a series of connected track points.
Definition track.h:79
WayPointman::RemoveRoutePoint
bool RemoveRoutePoint(RoutePoint *prp)
Remove a routepoint from list if present, deallocate it all cases.
Definition routeman.cpp:1097
cm93compchart
Represents a composite CM93 chart covering multiple scales.
Definition cm93.h:424
opencpn_plugin::OnContextMenuItemCallback
virtual void OnContextMenuItemCallback(int id)
Handles context menu item selection.
Definition ocpn_plugin.cpp:125
wxJSONValue
The JSON value class implementation.
Definition jsonval.h:84
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
GetOCPNGUIScaledFont
wxFont GetOCPNGUIScaledFont(wxString item)
Retrieves a font optimized for touch and high-resolution interfaces.
Definition gui_lib.cpp:83
mdns_cache.h
MdnsCache mDNS host lookups cache.
mdns_query.h
mDNS lookup wrappers.
plugin_comm.h
Tools to send data to plugins.
Ais8_001_22
Definition ais_target_data.h:134