OpenCPN Partial API docs
Loading...
Searching...
No Matches
connection_edit.cpp
1/******************************************************************************
2 *
3 * Project: OpenCPN
4 * Purpose:
5 * Author: David Register
6 *
7 ***************************************************************************
8 * Copyright (C) 2022 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 *
27 */
28
29#include <set>
30
31#include <wx/wxprec.h>
32
33#ifndef WX_PRECOMP
34#include <wx/wx.h>
35#endif // precompiled headers
36
37#include "config.h"
38
39#include <wx/tokenzr.h>
40#include <wx/regex.h>
41
42#if defined(__linux__) && !defined(__ANDROID__)
43#include <linux/can.h>
44#include <linux/can/raw.h>
45#include <net/if.h>
46#include <serial/serial.h>
47#include <sys/ioctl.h>
48#include <sys/socket.h>
49#include "dnet.h"
50#endif
51
52#ifdef __ANDROID__
53#include "androidUTIL.h"
54#include "qdebug.h"
55#endif
56
57#include "model/comm_drv_factory.h"
58#include "model/config_vars.h"
59#include "model/ocpn_utils.h"
60#include "model/ser_ports.h"
61#include "model/sys_events.h"
62
63#include "connection_edit.h"
64#include "conn_params_panel.h"
65#include "gui_lib.h"
66#include "nmea0183.h"
67#include "OCPNPlatform.h"
68#include "ocpn_plugin.h" // FIXME for GetOCPNScaledFont_PlugIn
69#include "options.h"
70#include "priority_gui.h"
71#include "udev_rule_mgr.h"
72
73extern OCPNPlatform* g_Platform;
74
75static wxString StringArrayToString(const wxArrayString& arr) {
76 wxString ret = wxEmptyString;
77 for (size_t i = 0; i < arr.Count(); i++) {
78 if (i > 0) ret.Append(",");
79 ret.Append(arr[i]);
80 }
81 return ret;
82}
83
84// Check available SocketCAN interfaces
85
86#if defined(__linux__) && !defined(__ANDROID__)
87static intf_t* intf;
88std::vector<std::string> can_if_candidates;
89static int print_intf(const struct intf_entry* entry, void* arg) {
90 std::string iface = entry->intf_name;
91 if (entry->intf_type == 1 && iface.find("can") != std::string::npos) {
92 can_if_candidates.push_back(entry->intf_name);
93 }
94 return 0;
95}
96#endif
97
98static wxArrayString GetAvailableSocketCANInterfaces() {
99 wxArrayString rv;
100
101#if defined(__linux__) && !defined(__ANDROID__)
102 struct intf_entry* entry;
103
104 can_if_candidates.clear();
105
106 if ((intf = intf_open()) == NULL) {
107 wxLogWarning("Error opening interface list");
108 }
109
110 if (intf_loop(intf, print_intf, NULL) < 0) {
111 wxLogWarning("Error looping over interface list");
112 }
113 intf_close(intf);
114
115 for (const auto& iface : can_if_candidates) {
116 int sock = socket(PF_CAN, SOCK_RAW, CAN_RAW);
117 if (sock < 0) {
118 continue;
119 }
120
121 // Get the interface index
122 struct ifreq if_request;
123 strcpy(if_request.ifr_name, iface.c_str());
124 if (ioctl(sock, SIOCGIFINDEX, &if_request) < 0) {
125 continue;
126 }
127
128 // Check if interface is UP
129 struct sockaddr_can can_address;
130 can_address.can_family = AF_CAN;
131 can_address.can_ifindex = if_request.ifr_ifindex;
132 if (ioctl(sock, SIOCGIFFLAGS, &if_request) < 0) {
133 continue;
134 }
135 if (if_request.ifr_flags & IFF_UP) {
136 rv.Add(iface);
137 } else {
138 continue;
139 }
140 }
141#endif
142 return rv;
143}
144
145static void LoadSerialPorts(wxComboBox* box) {
147 class PortSorter {
148 private:
149 std::string GetKey(const std::string& s) const {
150 if (s.find("->") == std::string::npos) return s;
151 return ocpn::trim(ocpn::split(s, "->")[1]) + " link";
152 }
153
154 public:
155 bool operator()(const std::string& lhs, const std::string& rhs) const {
156 return GetKey(lhs) < GetKey(rhs);
157 }
158 } port_sorter;
159
160 std::set<std::string, PortSorter> sorted_ports(port_sorter);
161 std::unique_ptr<wxArrayString> ports(EnumerateSerialPorts());
162 for (size_t i = 0; i < ports->GetCount(); i++)
163 sorted_ports.insert((*ports)[i].ToStdString());
164
165 box->Clear();
166 for (auto& p : sorted_ports) box->Append(p);
167}
168
169//------------------------------------------------------------------------------
170// ConnectionEditDialog Implementation
171//------------------------------------------------------------------------------
172
173// BEGIN_EVENT_TABLE(ConnectionEditDialog, wxDialog)
174// EVT_TIMER(ID_BT_SCANTIMER, ConnectionEditDialog::onBTScanTimer)
175// END_EVENT_TABLE()
176
177// Define constructors
178ConnectionEditDialog::ConnectionEditDialog()
179 : m_expandable_icon(this, [&](bool) { std::cout << "click!\n"; }) {}
180
181ConnectionEditDialog::ConnectionEditDialog(wxWindow* parent)
182 : wxDialog(parent, wxID_ANY, _("Connection Edit"), wxDefaultPosition,
183 wxSize(560, 840)),
184 m_expandable_icon(this, [&](bool) { std::cout << "click!\n"; }) {
185 m_parent = parent;
186
187 Init();
188 // Layout();
189 // Fit();
190 // Show();
191}
192
193ConnectionEditDialog::~ConnectionEditDialog() {}
194
195void ConnectionEditDialog::SetInitialSettings(void) {
196 LoadSerialPorts(m_comboPort);
197}
198
199void ConnectionEditDialog::Init() {
200 // For small displays, skip the "More" text.
201 // if (g_Platform->getDisplaySize().x < 80 * GetCharWidth()) MORE = "";
202
203 // Setup some inital values
204 m_buttonScanBT = 0;
205 m_stBTPairs = 0;
206 m_choiceBTDataSources = 0;
207
208 m_BTScanTimer.SetOwner(this, ID_BT_SCANTIMER);
209 m_BTscanning = 0;
210 wxSize displaySize = wxGetDisplaySize();
211
212 // Create the UI
213
214 wxBoxSizer* mainSizer = new wxBoxSizer(wxVERTICAL);
215
216 wxBoxSizer* boxSizer02 = new wxBoxSizer(wxVERTICAL);
217 mainSizer->Add(boxSizer02, 1, wxEXPAND | wxALL, 2);
218
219 m_scrolledwin =
220 new wxScrolledWindow(this, wxID_ANY, wxDefaultPosition, wxSize(-1, -1),
221 wxTAB_TRAVERSAL | wxVSCROLL);
222 m_scrolledwin->SetScrollRate(0, 5);
223 boxSizer02->Add(m_scrolledwin, 1, wxALL | wxEXPAND, 3);
224
225 auto boxSizerSWin = new wxBoxSizer(wxVERTICAL);
226 m_scrolledwin->SetSizer(boxSizerSWin);
227
228 wxStdDialogButtonSizer* btnSizer = new wxStdDialogButtonSizer();
229 wxButton* btnOK = new wxButton(this, wxID_OK);
230 wxButton* btnCancel = new wxButton(this, wxID_CANCEL, _("Cancel"));
231 btnSizer->AddButton(btnOK);
232 btnSizer->AddButton(btnCancel);
233 btnSizer->Realize();
234 mainSizer->Add(btnSizer, 0, wxALL | wxEXPAND, 5);
235
236 SetSizer(mainSizer);
237
238 int group_item_spacing = 2;
239
240 wxFont* dFont = GetOCPNScaledFont_PlugIn(_("Dialog"));
241 double font_size = dFont->GetPointSize() * 17 / 16;
242 wxFont* bFont = wxTheFontList->FindOrCreateFont(
243 font_size, dFont->GetFamily(), dFont->GetStyle(), wxFONTWEIGHT_BOLD);
244 //
245 // m_stEditCon = new wxStaticText(m_pNMEAForm, wxID_ANY, _("Edit Selected
246 // Connection")); m_stEditCon->SetFont(*bFont); bSizer19->Add(m_stEditCon,
247 // 0, wxALL | wxEXPAND | wxALIGN_CENTER_HORIZONTAL, 5);
248 //
249
250 // Connections Properties
251 m_sbConnEdit =
252 new wxStaticBox(m_scrolledwin, wxID_ANY, _("Edit Selected Connection"));
253 m_sbConnEdit->SetFont(*bFont);
254
255 sbSizerConnectionProps = new wxStaticBoxSizer(m_sbConnEdit, wxVERTICAL);
256 m_scrolledwin->GetSizer()->Add(sbSizerConnectionProps, 1, wxALL | wxEXPAND,
257 5);
258
259 wxBoxSizer* bSizer15;
260 bSizer15 = new wxBoxSizer(wxHORIZONTAL);
261
262 sbSizerConnectionProps->Add(bSizer15, 0, wxTOP | wxEXPAND, 5);
263
264 m_rbTypeSerial =
265 new wxRadioButton(m_scrolledwin, wxID_ANY, _("Serial"), wxDefaultPosition,
266 wxDefaultSize, wxRB_GROUP);
267 m_rbTypeSerial->SetValue(TRUE);
268 bSizer15->Add(m_rbTypeSerial, 0, wxALL, 5);
269
270 m_rbTypeNet = new wxRadioButton(m_scrolledwin, wxID_ANY, _("Network"),
271 wxDefaultPosition, wxDefaultSize, 0);
272 bSizer15->Add(m_rbTypeNet, 0, wxALL, 5);
273
274 m_rbTypeCAN = new wxRadioButton(m_scrolledwin, wxID_ANY, "socketCAN",
275 wxDefaultPosition, wxDefaultSize, 0);
276#if defined(__linux__) && !defined(__ANDROID__) && !defined(__WXOSX__)
277 bSizer15->Add(m_rbTypeCAN, 0, wxALL, 5);
278#else
279 m_rbTypeCAN->Hide();
280#endif
281
282 wxBoxSizer* bSizer15a = new wxBoxSizer(wxHORIZONTAL);
283 sbSizerConnectionProps->Add(bSizer15a, 0, wxEXPAND, 5);
284
285 if (OCPNPlatform::hasInternalGPS()) {
286 m_rbTypeInternalGPS =
287 new wxRadioButton(m_scrolledwin, wxID_ANY, _("Built-in GPS"),
288 wxDefaultPosition, wxDefaultSize, 0);
289 bSizer15a->Add(m_rbTypeInternalGPS, 0, wxALL, 5);
290 } else
291 m_rbTypeInternalGPS = NULL;
292
293 // has built-in Bluetooth
294 if (OCPNPlatform::hasInternalBT()) {
295 m_rbTypeInternalBT =
296 new wxRadioButton(m_scrolledwin, wxID_ANY, _("Built-in Bluetooth SPP"),
297 wxDefaultPosition, wxDefaultSize, 0);
298 bSizer15a->Add(m_rbTypeInternalBT, 0, wxALL, 5);
299
300 m_buttonScanBT = new wxButton(m_scrolledwin, wxID_ANY, _("BT Scan"),
301 wxDefaultPosition, wxDefaultSize);
302 m_buttonScanBT->Hide();
303
304 // wxBoxSizer* bSizer15a = new wxBoxSizer(wxHORIZONTAL);
305 // sbSizerConnectionProps->Add(bSizer15a, 0, wxEXPAND, 5);
306
307 sbSizerConnectionProps->Add(m_buttonScanBT, 0, wxALL, 5);
308
309 m_stBTPairs =
310 new wxStaticText(m_scrolledwin, wxID_ANY, _("Bluetooth Data Sources"),
311 wxDefaultPosition, wxDefaultSize, 0);
312 m_stBTPairs->Wrap(-1);
313 m_stBTPairs->Hide();
314 sbSizerConnectionProps->Add(m_stBTPairs, 0, wxALL, 5);
315
316 wxArrayString mt;
317 mt.Add("unscanned");
318
319 int ref_size = m_scrolledwin->GetCharWidth();
320 m_choiceBTDataSources =
321 new wxChoice(m_scrolledwin, wxID_ANY, wxDefaultPosition,
322 wxSize(40 * ref_size, 2 * ref_size), mt);
323 // m_choiceBTDataSources->Bind(wxEVT_MOUSEWHEEL,
324 // &ConnectionEditDialog::OnWheelChoice, this);
325 m_choiceBTDataSources->SetSelection(0);
326 m_choiceBTDataSources->Hide();
327 sbSizerConnectionProps->Add(m_choiceBTDataSources, 1, wxEXPAND | wxTOP, 5);
328
329 } else
330 m_rbTypeInternalBT = NULL;
331
332 gSizerNetProps = new wxFlexGridSizer(0, 2, 0, 0);
333
334 sbSizerConnectionProps->Add(gSizerNetProps, 0, wxEXPAND, 5);
335
336 m_stNetProto =
337 new wxStaticText(m_scrolledwin, wxID_ANY, _("Network Protocol"),
338 wxDefaultPosition, wxDefaultSize, 0);
339 m_stNetProto->Wrap(-1);
340 gSizerNetProps->Add(m_stNetProto, 0, wxALL, 5);
341
342 wxBoxSizer* bSizer16;
343 bSizer16 = new wxBoxSizer(wxHORIZONTAL);
344 gSizerNetProps->Add(bSizer16, 1, wxEXPAND, 5);
345 gSizerNetProps->AddSpacer(1);
346 gSizerNetProps->AddSpacer(1);
347
348 m_rbNetProtoTCP =
349 new wxRadioButton(m_scrolledwin, wxID_ANY, _("TCP"), wxDefaultPosition,
350 wxDefaultSize, wxRB_GROUP);
351 m_rbNetProtoTCP->Enable(TRUE);
352 m_rbNetProtoTCP->SetValue(TRUE);
353
354 bSizer16->Add(m_rbNetProtoTCP, 0, wxALL, 5);
355
356 m_rbNetProtoUDP = new wxRadioButton(m_scrolledwin, wxID_ANY, _("UDP"),
357 wxDefaultPosition, wxDefaultSize, 0);
358 m_rbNetProtoUDP->Enable(TRUE);
359
360 bSizer16->Add(m_rbNetProtoUDP, 0, wxALL, 5);
361
362 // Optimize for Portrait mode handheld devices
363 if (displaySize.x < displaySize.y) {
364 wxBoxSizer* bSizer16a;
365 bSizer16a = new wxBoxSizer(wxHORIZONTAL);
366 gSizerNetProps->AddSpacer(1);
367 gSizerNetProps->Add(bSizer16a, 1, wxEXPAND, 5);
368 gSizerNetProps->AddSpacer(1);
369 gSizerNetProps->AddSpacer(1);
370 m_rbNetProtoGPSD = new wxRadioButton(m_scrolledwin, wxID_ANY, _("GPSD"),
371 wxDefaultPosition, wxDefaultSize, 0);
372 m_rbNetProtoGPSD->Enable(TRUE);
373 bSizer16a->Add(m_rbNetProtoGPSD, 0, wxALL, 5);
374
375 m_rbNetProtoSignalK =
376 new wxRadioButton(m_scrolledwin, wxID_ANY, _("Signal K"),
377 wxDefaultPosition, wxDefaultSize, 0);
378 m_rbNetProtoSignalK->Enable(TRUE);
379 bSizer16a->Add(m_rbNetProtoSignalK, 0, wxALL, 5);
380 } else {
381 m_rbNetProtoGPSD = new wxRadioButton(m_scrolledwin, wxID_ANY, _("GPSD"),
382 wxDefaultPosition, wxDefaultSize, 0);
383 m_rbNetProtoGPSD->Enable(TRUE);
384 bSizer16->Add(m_rbNetProtoGPSD, 0, wxALL, 5);
385
386 m_rbNetProtoSignalK =
387 new wxRadioButton(m_scrolledwin, wxID_ANY, _("Signal K"),
388 wxDefaultPosition, wxDefaultSize, 0);
389 m_rbNetProtoSignalK->Enable(TRUE);
390 bSizer16->Add(m_rbNetProtoSignalK, 0, wxALL, 5);
391 }
392
393 m_stNetDataProtocol =
394 new wxStaticText(m_scrolledwin, wxID_ANY, _("Data Protocol"),
395 wxDefaultPosition, wxDefaultSize, 0);
396 m_stNetDataProtocol->Wrap(-1);
397
398 gSizerNetProps->Add(m_stNetDataProtocol, 0, wxALL, 5);
399
400 wxString m_choiceNetProtocolChoices[] = {_("NMEA 0183"), _("NMEA 2000")};
401 int m_choiceNetProtocolNChoices =
402 sizeof(m_choiceNetProtocolChoices) / sizeof(wxString);
403 m_choiceNetDataProtocol =
404 new wxChoice(m_scrolledwin, wxID_ANY, wxDefaultPosition, wxDefaultSize,
405 m_choiceNetProtocolNChoices, m_choiceNetProtocolChoices, 0);
406 // m_choiceNetDataProtocol->Bind(wxEVT_MOUSEWHEEL,
407 // &ConnectionEditDialog::OnWheelChoice, this);
408 m_choiceNetDataProtocol->SetSelection(0);
409 m_choiceNetDataProtocol->Enable(TRUE);
410
411 gSizerNetProps->Add(m_choiceNetDataProtocol, 1, wxEXPAND | wxTOP, 5);
412 gSizerNetProps->AddSpacer(1);
413 gSizerNetProps->AddSpacer(1);
414
415 m_stNetAddr = new wxStaticText(m_scrolledwin, wxID_ANY, _("Address"),
416 wxDefaultPosition, wxDefaultSize, 0);
417 m_stNetAddr->Wrap(-1);
418 int column1width = 16 * m_stNetProto->GetCharWidth();
419 m_stNetAddr->SetMinSize(wxSize(column1width, -1));
420 gSizerNetProps->Add(m_stNetAddr, 0, wxALL, 5);
421
422 m_tNetAddress = new wxTextCtrl(m_scrolledwin, wxID_ANY, wxEmptyString,
423 wxDefaultPosition, wxDefaultSize, 0);
424 int column2width = 40 * m_scrolledwin->GetCharWidth();
425 m_tNetAddress->SetMaxSize(wxSize(column2width, -1));
426 m_tNetAddress->SetMinSize(wxSize(column2width, -1));
427
428 gSizerNetProps->Add(m_tNetAddress, 0, wxEXPAND | wxTOP, 5);
429 gSizerNetProps->AddSpacer(1);
430 gSizerNetProps->AddSpacer(1);
431
432 m_stNetPort = new wxStaticText(m_scrolledwin, wxID_ANY, _("DataPort"),
433 wxDefaultPosition, wxDefaultSize, 0);
434 m_stNetPort->Wrap(-1);
435 gSizerNetProps->Add(m_stNetPort, 0, wxALL, 5);
436
437 m_tNetPort = new wxTextCtrl(m_scrolledwin, wxID_ANY, wxEmptyString,
438 wxDefaultPosition, wxDefaultSize, 0);
439 gSizerNetProps->Add(m_tNetPort, 1, wxEXPAND | wxTOP, 5);
440 gSizerNetProps->AddSpacer(1);
441 gSizerNetProps->AddSpacer(1);
442
443 gSizerCanProps = new wxGridSizer(0, 1, 0, 0);
444
445 wxFlexGridSizer* fgSizer1C;
446 fgSizer1C = new wxFlexGridSizer(0, 2, 0, 0);
447 // fgSizer1C->SetFlexibleDirection(wxBOTH);
448 // fgSizer1C->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
449
450 m_stCANSource =
451 new wxStaticText(m_scrolledwin, wxID_ANY, _("socketCAN Source"),
452 wxDefaultPosition, wxDefaultSize, 0);
453 m_stCANSource->Wrap(-1);
454 m_stCANSource->SetMinSize(wxSize(column1width, -1));
455 fgSizer1C->Add(m_stCANSource, 0, wxALL, 5);
456
457 wxArrayString choices = GetAvailableSocketCANInterfaces();
458 m_choiceCANSource = new wxChoice(m_scrolledwin, wxID_ANY, wxDefaultPosition,
459 wxDefaultSize, choices);
460
461 m_choiceCANSource->SetSelection(0);
462 m_choiceCANSource->Enable(TRUE);
463 m_choiceCANSource->SetMaxSize(wxSize(column2width, -1));
464 m_choiceCANSource->SetMinSize(wxSize(column2width, -1));
465 fgSizer1C->Add(m_choiceCANSource, 1, wxEXPAND | wxTOP, 5);
466
467 gSizerCanProps->Add(fgSizer1C, 0, wxEXPAND, 5);
468
469 sbSizerConnectionProps->Add(gSizerCanProps, 0, wxEXPAND, 5);
470
471 gSizerSerProps = new wxGridSizer(0, 1, 0, 0);
472 sbSizerConnectionProps->Add(gSizerSerProps, 0, wxEXPAND, 5);
473
474 wxFlexGridSizer* fgSizer1;
475 fgSizer1 = new wxFlexGridSizer(0, 4, 0, 0);
476 fgSizer1->SetFlexibleDirection(wxBOTH);
477 fgSizer1->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
478
479 m_stSerPort =
480 new wxStaticText(m_scrolledwin, wxID_ANY, _("Data port"),
481 wxDefaultPosition, wxDefaultSize, wxST_ELLIPSIZE_END);
482 m_stSerPort->SetMinSize(wxSize(column1width, -1));
483 m_stSerPort->Wrap(-1);
484
485 fgSizer1->Add(m_stSerPort, 0, wxALL, 5);
486
487 m_comboPort = new wxComboBox(m_scrolledwin, wxID_ANY, wxEmptyString,
488 wxDefaultPosition, wxDefaultSize, 0, NULL, 0);
489
490 m_comboPort->SetMaxSize(wxSize(column2width, -1));
491 m_comboPort->SetMinSize(wxSize(column2width, -1));
492
493 fgSizer1->Add(m_comboPort, 0, wxEXPAND | wxTOP, 5);
494
495 m_stSerBaudrate = new wxStaticText(m_scrolledwin, wxID_ANY, _("Baudrate"),
496 wxDefaultPosition, wxDefaultSize, 0);
497 m_stSerBaudrate->Wrap(-1);
498 fgSizer1->AddSpacer(1);
499 fgSizer1->AddSpacer(1);
500 fgSizer1->Add(m_stSerBaudrate, 0, wxALL, 5);
501
502 wxString m_choiceBaudRateChoices[] = {
503 _("150"), _("300"), _("600"), _("1200"), _("2400"),
504 _("4800"), _("9600"), _("19200"), _("38400"), _("57600"),
505 _("115200"), _("230400"), _("460800"), _("921600")};
506 int m_choiceBaudRateNChoices =
507 sizeof(m_choiceBaudRateChoices) / sizeof(wxString);
508 m_choiceBaudRate =
509 new wxChoice(m_scrolledwin, wxID_ANY, wxDefaultPosition, wxDefaultSize,
510 m_choiceBaudRateNChoices, m_choiceBaudRateChoices, 0);
511 // m_choiceBaudRate->Bind(wxEVT_MOUSEWHEEL,
512 // &ConnectionEditDialog::OnWheelChoice, this);
513
514 m_choiceBaudRate->SetSelection(0);
515
516 fgSizer1->Add(m_choiceBaudRate, 1, wxEXPAND | wxTOP, 5);
517 fgSizer1->AddSpacer(1);
518 fgSizer1->AddSpacer(1);
519
520 m_stSerProtocol = new wxStaticText(m_scrolledwin, wxID_ANY, _("Protocol"),
521 wxDefaultPosition, wxDefaultSize, 0);
522 m_stSerProtocol->Wrap(-1);
523 fgSizer1->Add(m_stSerProtocol, 0, wxALL, 5);
524
525 wxString m_choiceSerialProtocolChoices[] = {_("NMEA 0183"), _("NMEA 2000")};
526 int m_choiceSerialProtocolNChoices =
527 sizeof(m_choiceSerialProtocolChoices) / sizeof(wxString);
528 m_choiceSerialProtocol = new wxChoice(
529 m_scrolledwin, wxID_ANY, wxDefaultPosition, wxDefaultSize,
530 m_choiceSerialProtocolNChoices, m_choiceSerialProtocolChoices, 0);
531 // m_choiceSerialProtocol->Bind(wxEVT_MOUSEWHEEL,
532 // &ConnectionEditDialog::OnWheelChoice, this);
533
534 m_choiceSerialProtocol->SetSelection(0);
535 m_choiceSerialProtocol->Enable(TRUE);
536 fgSizer1->Add(m_choiceSerialProtocol, 1, wxEXPAND | wxTOP, 5);
537
538 gSizerSerProps->Add(fgSizer1, 0, wxEXPAND, 5);
539
540 // User Comments
541
542 wxFlexGridSizer* commentSizer = new wxFlexGridSizer(0, 2, 0, 0);
543 // sbSizerConnectionProps->Add(commentSizer, 0, wxEXPAND, 5);
544
545 // Net User Comments
546 m_stNetComment = new wxStaticText(m_scrolledwin, wxID_ANY, _("Description"),
547 wxDefaultPosition, wxDefaultSize, 0);
548 m_stNetComment->Wrap(-1);
549 m_stNetComment->SetMinSize(wxSize(column1width, -1));
550 commentSizer->Add(m_stNetComment, 0, wxALL, 5);
551
552 m_tNetComment = new wxTextCtrl(m_scrolledwin, wxID_ANY, wxEmptyString,
553 wxDefaultPosition, wxDefaultSize, 0);
554 m_tNetComment->SetMaxSize(wxSize(column2width, -1));
555 m_tNetComment->SetMinSize(wxSize(column2width, -1));
556
557 commentSizer->Add(m_tNetComment, 1, wxEXPAND | wxTOP, 5);
558
559 // Serial User Comments
560 m_stSerialComment =
561 new wxStaticText(m_scrolledwin, wxID_ANY, _("User Comment"),
562 wxDefaultPosition, wxDefaultSize, 0);
563 m_stSerialComment->Wrap(-1);
564 m_stSerialComment->SetMinSize(wxSize(column1width, -1));
565 commentSizer->Add(m_stSerialComment, 0, wxALL, 5);
566
567 m_tSerialComment = new wxTextCtrl(m_scrolledwin, wxID_ANY, wxEmptyString,
568 wxDefaultPosition, wxDefaultSize, 0);
569 m_tSerialComment->SetMaxSize(wxSize(column2width, -1));
570 m_tSerialComment->SetMinSize(wxSize(column2width, -1));
571
572 commentSizer->Add(m_tSerialComment, 1, wxTOP, 5);
573
574 sbSizerConnectionProps->Add(commentSizer, 0, wxEXPAND, 5);
575
576 wxFlexGridSizer* fgSizer5;
577 fgSizer5 = new wxFlexGridSizer(0, 2, 0, 0);
578 fgSizer5->SetFlexibleDirection(wxBOTH);
579 fgSizer5->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
580 sbSizerConnectionProps->Add(fgSizer5, 0, wxEXPAND, 5);
581
582 m_cbInput =
583 new wxCheckBox(m_scrolledwin, wxID_ANY, _("Receive Input on this Port"),
584 wxDefaultPosition, wxDefaultSize, 0);
585 fgSizer5->Add(m_cbInput, 0, wxALL, 2);
586 fgSizer5->AddSpacer(1);
587
588 m_cbOutput =
589 new wxCheckBox(m_scrolledwin, wxID_ANY,
590 wxString::Format("%s (%s)", _("Output on this port"),
591 _("as autopilot or NMEA repeater")),
592 wxDefaultPosition, wxDefaultSize, 0);
593 fgSizer5->Add(m_cbOutput, 0, wxALL, 2);
594 fgSizer5->AddSpacer(1);
595
596 // Authentication token
597
598 auto flags = wxSizerFlags().Border();
599 m_collapse_box = new wxBoxSizer(wxHORIZONTAL);
600
601 m_collapse_box->Add(
602 new wxStaticText(m_scrolledwin, wxID_ANY, _("Advanced: ")), flags);
603 m_collapse_box->Add(
604 new ExpandableIcon(m_scrolledwin,
605 [&](bool collapsed) { OnCollapsedToggle(collapsed); }),
606 flags);
607 fgSizer5->Add(m_collapse_box, wxSizerFlags());
608 fgSizer5->Add(new wxStaticText(m_scrolledwin, wxID_ANY, ""));
609
610 m_stAuthToken = new wxStaticText(m_scrolledwin, wxID_ANY, _("Auth Token"),
611 wxDefaultPosition, wxDefaultSize, 0);
612 m_stAuthToken->SetMinSize(wxSize(column1width, -1));
613 m_stAuthToken->Wrap(-1);
614 fgSizer5->Add(m_stAuthToken, 0, wxALL, 5);
615 m_stAuthToken->Hide();
616
617 m_tAuthToken = new wxTextCtrl(m_scrolledwin, wxID_ANY, wxEmptyString,
618 wxDefaultPosition, wxDefaultSize, 0);
619 m_tAuthToken->SetMinSize(wxSize(column2width, -1));
620 fgSizer5->Add(m_tAuthToken, 1, wxEXPAND | wxTOP, 5);
621
622 m_tAuthToken->Hide();
623
624 m_cbCheckCRC = new wxCheckBox(m_scrolledwin, wxID_ANY, _("Control checksum"),
625 wxDefaultPosition, wxDefaultSize, 0);
626 m_cbCheckCRC->SetValue(TRUE);
627 m_cbCheckCRC->SetToolTip(
628 _("If checked, only the sentences with a valid checksum are passed "
629 "through"));
630 fgSizer5->Add(m_cbCheckCRC, 0, wxALL, 2);
631 fgSizer5->AddSpacer(1);
632
633 m_cbGarminHost = new wxCheckBox(m_scrolledwin, wxID_ANY,
634 _("Use Garmin (GRMN) mode for input"),
635 wxDefaultPosition, wxDefaultSize, 0);
636 m_cbGarminHost->SetValue(FALSE);
637 fgSizer5->Add(m_cbGarminHost, 0, wxALL, 2);
638 fgSizer5->AddSpacer(1);
639
640#ifndef USE_GARMINHOST
641 m_cbGarminHost->Hide();
642#endif
643
644 m_cbMultiCast = new wxCheckBox(m_scrolledwin, wxID_ANY, _(" UDP Multicast"),
645 wxDefaultPosition, wxDefaultSize, 0);
646 m_cbMultiCast->SetValue(FALSE);
647 // m_cbMultiCast->SetToolTip(_("Advanced Use Only. Enable UDP Multicast."));
648
649 fgSizer5->Add(m_cbMultiCast, 0, wxALL, 2);
650 fgSizer5->AddSpacer(1);
651
652 m_stPrecision =
653 new wxStaticText(m_scrolledwin, wxID_ANY, _("APB bearing precision"),
654 wxDefaultPosition, wxDefaultSize, 0);
655
656 m_stPrecision->Wrap(-1);
657 fgSizer5->Add(m_stPrecision, 0, wxALL, 2);
658
659 wxString m_choicePrecisionChoices[] = {_("x"), _("x.x"), _("x.xx"),
660 _("x.xxx"), _("x.xxxx")};
661 int m_choicePrecisionNChoices =
662 sizeof(m_choicePrecisionChoices) / sizeof(wxString);
663 m_choicePrecision =
664 new wxChoice(m_scrolledwin, wxID_ANY, wxDefaultPosition, wxDefaultSize,
665 m_choicePrecisionNChoices, m_choicePrecisionChoices, 0);
666 // m_choicePrecision->Bind(wxEVT_MOUSEWHEEL,
667 // &ConnectionEditDialog::OnWheelChoice, this);
668
669 m_choicePrecision->SetSelection(g_NMEAAPBPrecision);
670 fgSizer5->Add(m_choicePrecision, 0, wxALL, 2);
671
672 // signalK discovery enable
673 m_cbCheckSKDiscover =
674 new wxCheckBox(m_scrolledwin, wxID_ANY, _("Automatic server discovery"),
675 wxDefaultPosition, wxDefaultSize, 0);
676 m_cbCheckSKDiscover->SetValue(TRUE);
677 m_cbCheckSKDiscover->SetToolTip(
678 _("If checked, signal K server will be discovered automatically"));
679
680 fgSizer5->Add(m_cbCheckSKDiscover, 0, wxALL, 2);
681
682 // signal K "Discover now" button
683 m_ButtonSKDiscover =
684 new wxButton(m_scrolledwin, wxID_ANY, _("Discover now..."),
685 wxDefaultPosition, wxDefaultSize, 0);
686 m_ButtonSKDiscover->Hide();
687 fgSizer5->Add(m_ButtonSKDiscover, 0, wxALL, 2);
688
689 // signalK Server Status
690 m_StaticTextSKServerStatus = new wxStaticText(
691 m_scrolledwin, wxID_ANY, "", wxDefaultPosition, wxDefaultSize, 0);
692 fgSizer5->Add(m_StaticTextSKServerStatus, 0, wxALL, 2);
693
694 sbSizerInFilter = new wxStaticBoxSizer(
695 new wxStaticBox(m_scrolledwin, wxID_ANY, _("Input filtering")),
696 wxVERTICAL);
697 sbSizerConnectionProps->Add(sbSizerInFilter,
698 wxSizerFlags().Expand().Border());
699
700 wxBoxSizer* bSizer9;
701 bSizer9 = new wxBoxSizer(wxHORIZONTAL);
702
703 m_rbIAccept =
704 new wxRadioButton(m_scrolledwin, wxID_ANY, _("Accept only sentences"),
705 wxDefaultPosition, wxDefaultSize, wxRB_GROUP);
706 bSizer9->Add(m_rbIAccept, 0, wxALL, 5);
707
708 m_rbIIgnore =
709 new wxRadioButton(m_scrolledwin, wxID_ANY, _("Ignore sentences"),
710 wxDefaultPosition, wxDefaultSize, 0);
711 bSizer9->Add(m_rbIIgnore, 0, wxALL, 5);
712
713 sbSizerInFilter->Add(bSizer9, 0, wxEXPAND, 5);
714
715 wxBoxSizer* bSizer11;
716 bSizer11 = new wxBoxSizer(wxHORIZONTAL);
717 sbSizerInFilter->Add(bSizer11, 0, wxEXPAND, 5);
718
719 m_tcInputStc =
720 new wxTextCtrl(m_scrolledwin, wxID_ANY, wxEmptyString, wxDefaultPosition,
721 wxDefaultSize, wxTE_READONLY);
722 bSizer11->Add(m_tcInputStc, 1, wxALL | wxEXPAND, 5);
723
724 m_btnInputStcList =
725 new wxButton(m_scrolledwin, wxID_ANY, "...", wxDefaultPosition,
726 wxDefaultSize, wxBU_EXACTFIT);
727 bSizer11->Add(m_btnInputStcList, 0, wxALL, 5);
728
729 bSizer11->AddSpacer(GetCharWidth() * 5);
730
731 sbSizerOutFilter = new wxStaticBoxSizer(
732 new wxStaticBox(m_scrolledwin, wxID_ANY, _("Output filtering")),
733 wxVERTICAL);
734 sbSizerConnectionProps->Add(sbSizerOutFilter, 0, wxEXPAND, 5);
735
736 wxBoxSizer* bSizer10;
737 bSizer10 = new wxBoxSizer(wxHORIZONTAL);
738
739 m_rbOAccept =
740 new wxRadioButton(m_scrolledwin, wxID_ANY, _("Transmit sentences"),
741 wxDefaultPosition, wxDefaultSize, wxRB_GROUP);
742 bSizer10->Add(m_rbOAccept, 0, wxALL, 5);
743
744 m_rbOIgnore = new wxRadioButton(m_scrolledwin, wxID_ANY, _("Drop sentences"),
745 wxDefaultPosition, wxDefaultSize, 0);
746 bSizer10->Add(m_rbOIgnore, 0, wxALL, 5);
747
748 sbSizerOutFilter->Add(bSizer10, 0, wxEXPAND, 5);
749
750 wxBoxSizer* bSizer12;
751 bSizer12 = new wxBoxSizer(wxHORIZONTAL);
752 sbSizerOutFilter->Add(bSizer12, 0, wxEXPAND, 5);
753
754 m_tcOutputStc =
755 new wxTextCtrl(m_scrolledwin, wxID_ANY, wxEmptyString, wxDefaultPosition,
756 wxDefaultSize, wxTE_READONLY);
757 bSizer12->Add(m_tcOutputStc, 1, wxALL | wxEXPAND, 5);
758
759 m_btnOutputStcList =
760 new wxButton(m_scrolledwin, wxID_ANY, "...", wxDefaultPosition,
761 wxDefaultSize, wxBU_EXACTFIT);
762 bSizer12->Add(m_btnOutputStcList, 0, wxALL, 5);
763
764 bSizer12->AddSpacer(GetCharWidth() * 5);
765
766 sbSizerConnectionProps->AddSpacer(20);
767
768 ConnectControls();
769
770 SetInitialSettings();
771
772 ShowTypeCommon();
773
774 ShowNMEACommon(true);
775 ShowNMEASerial(true);
776 ShowNMEANet(false);
777 ShowNMEACAN(false);
778 connectionsaved = TRUE;
779
780 GetSizer()->Fit(m_scrolledwin);
781
782 new_device_listener.Init(SystemEvents::GetInstance().evt_dev_change,
783 [&](ObservedEvt&) { LoadSerialPorts(m_comboPort); });
784}
785
786// void ConnectionEditDialog::OnWheelChoice(wxMouseEvent& event) {
787// return;
788// }
789
790void ConnectionEditDialog::SetSelectedConnectionPanel(
791 ConnectionParamsPanel* panel) {
792 // Only one panel can be selected at any time
793 // Clear any selections
794
795 if (mSelectedConnection && mSelectedConnection->m_optionsPanel)
796 mSelectedConnection->m_optionsPanel->SetSelected(false);
797
798 if (panel) {
799 mSelectedConnection = panel->m_pConnectionParams;
800 panel->SetSelected(true);
801 SetConnectionParams(mSelectedConnection);
802 m_buttonRemove->Enable();
803 m_buttonRemove->Show();
804 m_buttonAdd->Disable();
805 m_sbConnEdit->SetLabel(_("Edit Selected Connection"));
806
807 } else {
808 mSelectedConnection = NULL;
809 m_buttonRemove->Disable();
810 m_buttonAdd->Enable();
811 m_buttonAdd->Show();
812 m_sbConnEdit->SetLabel("");
813 ClearNMEAForm();
814 }
815
816 // Scroll the panel to allow the user to see more of the NMEA parameter
817 // settings area
818 // wxPoint buttonPosition = m_buttonAdd->GetPosition();
819 // this->Scroll(-1, buttonPosition.y / m_parent->GetScrollRate());
820}
821
822void ConnectionEditDialog::SetPropsLabel(wxString label) {
823 m_sbConnEdit->SetLabel(label);
824}
825
826void ConnectionEditDialog::EnableConnection(ConnectionParams* conn,
827 bool value) {
828 if (conn) {
829 // conn->bEnabled = value;
830 conn->b_IsSetup = FALSE; // trigger a rebuild/takedown of the connection
831 m_connection_enabled = conn->bEnabled;
832 }
833}
834
835#if 1
836void ConnectionEditDialog::OnValChange(wxCommandEvent& event) { event.Skip(); }
837
838void ConnectionEditDialog::OnScanBTClick(wxCommandEvent& event) {
839 if (m_BTscanning)
840 StopBTScan();
841 else {
842 m_btNoChangeCounter = 0;
843 m_btlastResultCount = 0;
844
845 m_BTScanTimer.Start(1000, wxTIMER_CONTINUOUS);
846 g_Platform->startBluetoothScan();
847 m_BTscanning = 1;
848 if (m_buttonScanBT) {
849 m_buttonScanBT->SetLabel(_("Stop Scan"));
850 }
851 }
852}
853
854void ConnectionEditDialog::onBTScanTimer(wxTimerEvent& event) {
855 if (m_BTscanning) {
856 m_BTscanning++;
857
858 m_BTscan_results = g_Platform->getBluetoothScanResults();
859
860 m_choiceBTDataSources->Clear();
861 m_choiceBTDataSources->Append(m_BTscan_results[0]); // scan status
862
863 unsigned int i = 1;
864 while ((i + 1) < m_BTscan_results.GetCount()) {
865 wxString item1 = m_BTscan_results[i] + ";";
866 wxString item2 = m_BTscan_results.Item(i + 1);
867 m_choiceBTDataSources->Append(item1 + item2);
868
869 i += 2;
870 }
871
872 if (m_BTscan_results.GetCount() > 1) {
873 m_choiceBTDataSources->SetSelection(1);
874 }
875
876 // Watch for changes. When no changes occur after n seconds, stop the scan
877 if (m_btNoChangeCounter > 5) StopBTScan();
878
879 if ((int)m_BTscan_results.GetCount() == m_btlastResultCount)
880 m_btNoChangeCounter++;
881 else
882 m_btNoChangeCounter = 0;
883
884 m_btlastResultCount = m_BTscan_results.GetCount();
885
886 // Absolute fallback
887 if (m_BTscanning >= 15) {
888 StopBTScan();
889 }
890 } else {
891 }
892 return;
893}
894
895void ConnectionEditDialog::StopBTScan(void) {
896 m_BTScanTimer.Stop();
897
898 g_Platform->stopBluetoothScan();
899
900 m_BTscanning = 0;
901
902 if (m_buttonScanBT) {
903 m_buttonScanBT->SetLabel(_("BT Scan"));
904 m_buttonScanBT->Enable();
905 }
906}
907
908void ConnectionEditDialog::OnConnValChange(wxCommandEvent& event) {
909 connectionsaved = FALSE;
910 event.Skip();
911}
912
913void ConnectionEditDialog::OnTypeSerialSelected(wxCommandEvent& event) {
914 OnConnValChange(event);
915 SetNMEAFormToSerial();
916}
917
918void ConnectionEditDialog::OnTypeNetSelected(wxCommandEvent& event) {
919 OnConnValChange(event);
920 SetNMEAFormToNet();
921}
922
923void ConnectionEditDialog::OnTypeCANSelected(wxCommandEvent& event) {
924 OnConnValChange(event);
925 SetNMEAFormToCAN();
926}
927
928void ConnectionEditDialog::OnTypeGPSSelected(wxCommandEvent& event) {
929 OnConnValChange(event);
930 SetNMEAFormToGPS();
931}
932
933void ConnectionEditDialog::OnTypeBTSelected(wxCommandEvent& event) {
934 OnConnValChange(event);
935 SetNMEAFormToBT();
936}
937
938void ConnectionEditDialog::OnUploadFormatChange(wxCommandEvent& event) {
939 if (event.GetEventObject() == m_cbGarminUploadHost && event.IsChecked())
940 m_cbFurunoGP3X->SetValue(FALSE);
941 else if (event.GetEventObject() == m_cbFurunoGP3X && event.IsChecked())
942 m_cbGarminUploadHost->SetValue(FALSE);
943
944 OnConnValChange(event);
945 event.Skip();
946}
947#endif
948
949void ConnectionEditDialog::ShowTypeCommon(bool visible) {
950 m_rbTypeSerial->Show(visible);
951 m_rbTypeNet->Show(visible);
952#if defined(__linux__) && !defined(__ANDROID__) && !defined(__WXOSX__)
953 m_rbTypeCAN->Show(visible);
954#endif
955 if (m_rbTypeInternalGPS) m_rbTypeInternalGPS->Show(visible);
956 if (m_rbTypeInternalBT) m_rbTypeInternalBT->Show(visible);
957}
958
959void ConnectionEditDialog::ShowNMEACommon(bool visible) {
960 bool advanced = m_advanced;
961 m_cbInput->Show(visible);
962 m_cbOutput->Show(visible);
963 m_stPrecision->Show(visible && advanced);
964 m_choicePrecision->Show(visible && advanced);
965 m_stPrecision->Show(visible && advanced);
966 m_cbCheckCRC->Show(visible && advanced);
967 m_stAuthToken->Show(visible && advanced);
968 m_tAuthToken->Show(visible && advanced);
969 if (visible) {
970 const bool bout_enable = (m_cbOutput->IsChecked() && advanced);
971 m_stPrecision->Enable(bout_enable);
972 m_choicePrecision->Enable(bout_enable);
973 } else {
974 sbSizerOutFilter->SetDimension(0, 0, 0, 0);
975 sbSizerInFilter->SetDimension(0, 0, 0, 0);
976 sbSizerConnectionProps->SetDimension(0, 0, 0, 0);
977 m_sbConnEdit->SetLabel("");
978 }
979
980 m_cbCheckSKDiscover->Hide(); // Provisional
981 m_ButtonSKDiscover->Hide();
982
983 const bool bin_enable = (m_cbInput->IsChecked() && advanced);
984 ShowInFilter(visible && bin_enable);
985 const bool bout_enable = (m_cbOutput->IsChecked() && advanced);
986 ShowOutFilter(visible && bout_enable);
987
988 m_bNMEAParams_shown = visible;
989}
990
991void ConnectionEditDialog::ShowNMEANet(bool visible) {
992 bool advanced = m_advanced;
993 m_stNetAddr->Show(visible);
994 m_tNetAddress->Show(visible);
995 m_stNetDataProtocol->Show(visible);
996 m_stNetPort->Show(visible);
997 m_choiceNetDataProtocol->Show(visible);
998 m_tNetPort->Show(visible);
999 m_stNetProto->Show(visible);
1000 m_rbNetProtoSignalK->Show(visible);
1001 m_rbNetProtoGPSD->Show(visible);
1002 m_rbNetProtoTCP->Show(visible);
1003 m_rbNetProtoUDP->Show(visible);
1004 m_stNetComment->Show(visible);
1005 m_tNetComment->Show(visible);
1006 m_stAuthToken->Show(visible);
1007 m_tAuthToken->Show(visible);
1008 m_cbGarminHost->Hide();
1009}
1010
1011void ConnectionEditDialog::ShowNMEASerial(bool visible) {
1012 bool advanced = m_advanced;
1013 m_stSerBaudrate->Show(visible);
1014 m_choiceBaudRate->Show(visible);
1015 m_stSerPort->Show(visible);
1016 m_comboPort->Show(visible);
1017 m_stSerProtocol->Show(visible);
1018 m_choiceSerialProtocol->Show(visible);
1019 m_cbGarminHost->Show(visible && advanced);
1020 m_stSerialComment->Show(visible);
1021 m_tSerialComment->Show(visible);
1022}
1023
1024void ConnectionEditDialog::ShowNMEAGPS(bool visible) {
1025 m_cbCheckSKDiscover->Hide();
1026 m_ButtonSKDiscover->Hide();
1027 m_stAuthToken->Hide();
1028 m_tAuthToken->Hide();
1029 m_cbOutput->Hide();
1030}
1031
1032void ConnectionEditDialog::ShowNMEACAN(bool visible) {
1033 m_stCANSource->Show(visible);
1034 m_choiceCANSource->Show(visible);
1035}
1036
1037void ConnectionEditDialog::ShowNMEABT(bool visible) {
1038 if (visible) {
1039 if (m_buttonScanBT) m_buttonScanBT->Show();
1040 if (m_stBTPairs) m_stBTPairs->Show();
1041 if (m_choiceBTDataSources) {
1042 if (m_choiceBTDataSources->GetCount() > 1)
1043 m_choiceBTDataSources->SetSelection(1);
1044 m_choiceBTDataSources->Show();
1045 }
1046 } else {
1047 if (m_buttonScanBT) m_buttonScanBT->Hide();
1048 if (m_stBTPairs) m_stBTPairs->Hide();
1049 if (m_choiceBTDataSources) m_choiceBTDataSources->Hide();
1050 }
1051 m_cbCheckSKDiscover->Hide();
1052 m_stAuthToken->Hide();
1053 m_tAuthToken->Hide();
1054 m_cbCheckSKDiscover->Hide(); // Provisional
1055 m_ButtonSKDiscover->Hide();
1056 m_tcOutputStc->Show(visible);
1057 m_btnOutputStcList->Show(visible);
1058 m_cbOutput->Show(visible);
1059}
1060
1061void ConnectionEditDialog::SetNMEAFormToSerial(void) {
1062 bool advanced = m_advanced;
1063 ShowNMEACommon(TRUE);
1064 ShowNMEANet(FALSE);
1065 ShowNMEAGPS(FALSE);
1066 ShowNMEABT(FALSE);
1067 ShowNMEASerial(TRUE);
1068 ShowNMEACAN(FALSE);
1069 SetDSFormRWStates();
1070 LayoutDialog();
1071}
1072
1073void ConnectionEditDialog::SetNMEAFormToNet(void) {
1074 bool advanced = m_advanced;
1075 ShowNMEACommon(TRUE);
1076 ShowNMEANet(TRUE);
1077 ShowNMEAGPS(FALSE);
1078 ShowNMEABT(FALSE);
1079 ShowNMEASerial(FALSE);
1080 ShowNMEACAN(FALSE);
1081 SetUDPNetAddressVisiblity();
1082 SetDSFormRWStates();
1083
1084 LayoutDialog();
1085}
1086
1087void ConnectionEditDialog::SetNMEAFormToCAN(void) {
1088 bool advanced = m_advanced;
1089 ShowNMEACommon(FALSE);
1090 ShowNMEANet(FALSE);
1091 ShowNMEAGPS(FALSE);
1092 ShowNMEABT(FALSE);
1093 ShowNMEASerial(FALSE);
1094 ShowNMEACAN(TRUE);
1095 sbSizerInFilter->Show(false);
1096 sbSizerOutFilter->Show(false);
1097 SetDSFormRWStates();
1098
1099 LayoutDialog();
1100}
1101
1102void ConnectionEditDialog::SetNMEAFormToGPS(void) {
1103 ShowNMEACommon(TRUE);
1104 ShowNMEANet(FALSE);
1105 ShowNMEAGPS(TRUE);
1106 ShowNMEABT(FALSE);
1107 ShowNMEASerial(FALSE);
1108 ShowNMEACAN(FALSE);
1109
1110 // m_container->FitInside();
1111 // Fit();
1112 SetDSFormRWStates();
1113 LayoutDialog();
1114}
1115
1116void ConnectionEditDialog::SetNMEAFormToBT(void) {
1117 m_rbNetProtoUDP->SetValue(true);
1118 ShowNMEACommon(TRUE);
1119 ShowNMEANet(FALSE);
1120 ShowNMEAGPS(FALSE);
1121 ShowNMEABT(TRUE);
1122 ShowNMEASerial(FALSE);
1123 ShowNMEACAN(FALSE);
1124
1125 // m_container->FitInside();
1126 // Fit();
1127 SetDSFormRWStates();
1128 LayoutDialog();
1129}
1130
1131void ConnectionEditDialog::ClearNMEAForm(void) {
1132 ShowNMEACommon(FALSE);
1133 ShowNMEANet(FALSE);
1134 ShowNMEAGPS(FALSE);
1135 ShowNMEABT(FALSE);
1136 ShowNMEASerial(FALSE);
1137 ShowNMEACAN(FALSE);
1138
1139 // m_container->FitInside();
1140 // Fit();
1141}
1142
1143void ConnectionEditDialog::SetDSFormOptionVizStates(void) {
1144 bool advanced = m_advanced;
1145 m_collapse_box->ShowItems(true);
1146 m_cbInput->Show();
1147 m_cbOutput->Show();
1148 m_cbCheckCRC->Show(advanced);
1149 m_stPrecision->Show(true);
1150 m_choicePrecision->Show(true);
1151
1152 ShowInFilter(advanced);
1153 ShowOutFilter(advanced);
1154 // Discovery hidden until it works.
1155 // m_cbCheckSKDiscover->Show();
1156 m_stAuthToken->Show(advanced);
1157 m_tAuthToken->Show(advanced);
1158 // m_ButtonSKDiscover->Show();
1159 m_StaticTextSKServerStatus->Show(advanced);
1160
1161 if (m_rbTypeSerial->GetValue()) {
1162 m_cbMultiCast->Hide();
1163 m_cbCheckSKDiscover->Hide();
1164 m_stAuthToken->Hide();
1165 m_tAuthToken->Hide();
1166 m_ButtonSKDiscover->Hide();
1167 m_StaticTextSKServerStatus->Hide();
1168 bool n0183ctlenabled =
1169 (DataProtocol)m_choiceSerialProtocol->GetSelection() ==
1170 DataProtocol::PROTO_NMEA0183;
1171 if (!n0183ctlenabled) {
1172 m_cbInput->Hide();
1173 m_cbOutput->Hide();
1174 ShowOutFilter(false);
1175 ShowInFilter(false);
1176 m_stPrecision->Hide();
1177 m_choicePrecision->Hide();
1178 m_cbCheckCRC->Hide();
1179 m_stNetDataProtocol->Hide();
1180 m_choiceNetDataProtocol->Hide();
1181 } else {
1182 m_cbInput->Show();
1183 m_cbInput->Enable();
1184
1185 ShowInFilter(m_cbInput->IsChecked() && advanced);
1186 ShowOutFilter(m_cbOutput->IsChecked() && advanced);
1187
1188 m_stPrecision->Show(m_cbOutput->IsChecked() && advanced);
1189 m_choicePrecision->Show(m_cbOutput->IsChecked() && advanced);
1190
1191 m_cbGarminHost->Show(m_cbInput->IsChecked() && advanced);
1192 }
1193 }
1194
1195 if (m_rbTypeInternalGPS && m_rbTypeInternalGPS->GetValue()) {
1196 m_cbMultiCast->Hide();
1197 m_cbCheckSKDiscover->Hide();
1198 m_stAuthToken->Hide();
1199 m_tAuthToken->Hide();
1200 m_ButtonSKDiscover->Hide();
1201 m_StaticTextSKServerStatus->Hide();
1202 m_cbOutput->Hide();
1203 m_cbInput->Hide();
1204 ShowOutFilter(false);
1205 ShowInFilter(false);
1206 m_stPrecision->Hide();
1207 m_choicePrecision->Hide();
1208 m_cbCheckCRC->Hide();
1209 m_cbGarminHost->Hide();
1210 m_collapse_box->ShowItems(false);
1211 }
1212
1213 if (m_rbTypeInternalBT && m_rbTypeInternalBT->GetValue()) {
1214 m_cbMultiCast->Hide();
1215 m_cbCheckSKDiscover->Hide();
1216 m_stAuthToken->Hide();
1217 m_tAuthToken->Hide();
1218 m_ButtonSKDiscover->Hide();
1219 m_StaticTextSKServerStatus->Hide();
1220
1221 ShowInFilter(m_cbInput->IsChecked() && advanced);
1222 ShowOutFilter(m_cbOutput->IsChecked() && advanced);
1223
1224 m_stPrecision->Show(m_cbOutput->IsChecked() && advanced);
1225 m_choicePrecision->Show(m_cbOutput->IsChecked() && advanced);
1226 }
1227
1228 if (m_rbTypeCAN->GetValue()) {
1229 m_cbMultiCast->Hide();
1230 m_cbCheckSKDiscover->Hide();
1231 m_stAuthToken->Hide();
1232 m_tAuthToken->Hide();
1233 m_ButtonSKDiscover->Hide();
1234 m_StaticTextSKServerStatus->Hide();
1235 m_cbGarminHost->Hide();
1236 m_cbInput->Hide();
1237 m_cbOutput->Hide();
1238
1239 ShowInFilter(false);
1240 ShowOutFilter(false);
1241
1242 m_stPrecision->Hide();
1243 m_choicePrecision->Hide();
1244 m_cbCheckCRC->Hide();
1245
1246 m_stNetDataProtocol->Hide();
1247 m_choiceNetDataProtocol->Hide();
1248 m_collapse_box->Show(false);
1249 }
1250
1251 if (m_rbTypeNet->GetValue()) {
1252 if (m_rbNetProtoGPSD->GetValue()) {
1253 m_cbMultiCast->Hide();
1254 m_cbCheckSKDiscover->Hide();
1255 m_cbInput->Hide();
1256 m_cbOutput->Hide();
1257 ShowInFilter(false);
1258 ShowOutFilter(false);
1259 m_cbCheckCRC->Hide();
1260 m_stPrecision->Hide();
1261 m_choicePrecision->Hide();
1262 m_ButtonSKDiscover->Hide();
1263 m_StaticTextSKServerStatus->Hide();
1264 m_stAuthToken->Hide();
1265 m_tAuthToken->Hide();
1266 m_stNetDataProtocol->Hide();
1267 m_choiceNetDataProtocol->Hide();
1268 m_cbGarminHost->Hide();
1269 m_collapse_box->Show(false);
1270
1271 } else if (m_rbNetProtoSignalK->GetValue()) {
1272 m_cbMultiCast->Hide();
1273 m_cbInput->Hide();
1274 m_cbOutput->Hide();
1275 ShowInFilter(false);
1276 ShowOutFilter(false);
1277 m_cbCheckCRC->Hide();
1278 m_stPrecision->Hide();
1279 m_choicePrecision->Hide();
1280 m_stNetDataProtocol->Hide();
1281 m_choiceNetDataProtocol->Hide();
1282 m_cbGarminHost->Hide();
1283
1284 } else { // tcp or udp
1285 m_stAuthToken->Hide();
1286 m_tAuthToken->Hide();
1287 m_cbCheckSKDiscover->Hide();
1288 m_ButtonSKDiscover->Hide();
1289 m_StaticTextSKServerStatus->Hide();
1290 m_stNetDataProtocol->Show();
1291 m_choiceNetDataProtocol->Show();
1292 m_cbGarminHost->Hide();
1293
1294 // if (m_rbNetProtoUDP->GetValue()) m_cbMultiCast->Show(advanced);
1295
1296 if ((DataProtocol)m_choiceNetDataProtocol->GetSelection() ==
1297 DataProtocol::PROTO_NMEA2000) {
1298 m_cbCheckCRC->Hide();
1299 m_stPrecision->Hide();
1300 m_choicePrecision->Hide();
1301
1302 ShowInFilter(false);
1303 ShowOutFilter(false);
1304 if (m_rbNetProtoTCP->GetValue()) m_collapse_box->ShowItems(false);
1305 }
1306 if ((DataProtocol)m_choiceNetDataProtocol->GetSelection() ==
1307 DataProtocol::PROTO_NMEA0183) {
1308 m_stPrecision->Show(advanced);
1309 m_choicePrecision->Show(advanced);
1310 m_stPrecision->Enable(m_cbOutput->IsChecked() && advanced);
1311 m_choicePrecision->Enable(m_cbOutput->IsChecked() && advanced);
1312
1313 ShowInFilter(m_cbInput->IsChecked() && advanced);
1314 ShowOutFilter(m_cbOutput->IsChecked() && advanced);
1315 }
1316 }
1317 }
1318}
1319
1320void ConnectionEditDialog::SetDSFormRWStates(void) {
1321 if (m_rbTypeSerial->GetValue()) {
1322 m_cbInput->Enable(FALSE);
1323 m_cbOutput->Enable(TRUE);
1324 ShowInFilter();
1325 ShowOutFilter(m_cbOutput->IsChecked());
1326 } else if (m_rbNetProtoGPSD->GetValue()) {
1327 if (m_tNetPort->GetValue() == wxEmptyString)
1328 m_tNetPort->SetValue(DEFAULT_GPSD_PORT);
1329 m_cbInput->SetValue(TRUE);
1330 m_cbInput->Enable(FALSE);
1331 // m_cbOutput->SetValue(FALSE);
1332 m_cbOutput->Enable(FALSE);
1333 m_rbOAccept->Enable(FALSE);
1334 m_rbOIgnore->Enable(FALSE);
1335 m_btnOutputStcList->Enable(FALSE);
1336 } else if (m_rbNetProtoSignalK->GetValue()) {
1337 if (m_tNetPort->GetValue() == wxEmptyString)
1338 m_tNetPort->SetValue(DEFAULT_SIGNALK_PORT);
1339 m_cbInput->SetValue(TRUE);
1340 m_cbInput->Enable(FALSE);
1341 // m_cbOutput->SetValue(FALSE);
1342 m_cbOutput->Enable(FALSE);
1343 m_rbOAccept->Enable(FALSE);
1344 m_rbOIgnore->Enable(FALSE);
1345 UpdateDiscoverStatus(wxEmptyString);
1346 } else {
1347 if (m_tNetPort->GetValue() == wxEmptyString) {
1348 if (m_rbNetProtoTCP->GetValue()) {
1349 m_tNetPort->SetValue(DEFAULT_TCP_PORT);
1350 } else {
1351 m_tNetPort->SetValue(DEFAULT_UDP_PORT);
1352 }
1353 }
1354 m_cbInput->Enable(TRUE);
1355 m_cbOutput->Enable(TRUE);
1356 m_rbOAccept->Enable(TRUE);
1357 m_rbOIgnore->Enable(TRUE);
1358 m_btnOutputStcList->Enable(TRUE);
1359 }
1360
1361 SetDSFormOptionVizStates();
1362 // m_container->FitInside();
1363}
1364
1365void ConnectionEditDialog::ShowInFilter(bool bshow) {
1366 sbSizerInFilter->GetStaticBox()->Show(bshow);
1367 m_rbIAccept->Show(bshow);
1368 m_rbIIgnore->Show(bshow);
1369 m_tcInputStc->Show(bshow);
1370 m_btnInputStcList->Show(bshow);
1371}
1372
1373void ConnectionEditDialog::ShowOutFilter(bool bshow) {
1374 sbSizerOutFilter->GetStaticBox()->Show(bshow);
1375 m_rbOAccept->Show(bshow);
1376 m_rbOIgnore->Show(bshow);
1377 m_tcOutputStc->Show(bshow);
1378 m_btnOutputStcList->Show(bshow);
1379}
1380
1381void ConnectionEditDialog::PreloadControls(ConnectionParams* cp) {
1382 SetConnectionParams(cp);
1383}
1384
1385void ConnectionEditDialog::SetConnectionParams(ConnectionParams* cp) {
1386 if (wxNOT_FOUND == m_comboPort->FindString(cp->Port))
1387 m_comboPort->Append(cp->Port);
1388
1389 m_comboPort->Select(m_comboPort->FindString(cp->Port));
1390
1391 m_cbCheckCRC->SetValue(cp->ChecksumCheck);
1392 m_cbGarminHost->SetValue(cp->Garmin);
1393 m_cbInput->SetValue(cp->IOSelect != DS_TYPE_OUTPUT);
1394 m_cbOutput->SetValue(cp->IOSelect != DS_TYPE_INPUT);
1395 m_cbCheckSKDiscover->SetValue(cp->AutoSKDiscover);
1396
1397 if (cp->InputSentenceListType == WHITELIST)
1398 m_rbIAccept->SetValue(TRUE);
1399 else
1400 m_rbIIgnore->SetValue(TRUE);
1401 if (cp->OutputSentenceListType == WHITELIST)
1402 m_rbOAccept->SetValue(TRUE);
1403 else
1404 m_rbOIgnore->SetValue(TRUE);
1405 m_tcInputStc->SetValue(StringArrayToString(cp->InputSentenceList));
1406 m_tcOutputStc->SetValue(StringArrayToString(cp->OutputSentenceList));
1407 m_choiceBaudRate->Select(
1408 m_choiceBaudRate->FindString(wxString::Format("%d", cp->Baudrate)));
1409 m_choiceSerialProtocol->Select(cp->Protocol); // TODO
1410 m_tNetAddress->SetValue(cp->NetworkAddress);
1411
1412 m_choiceNetDataProtocol->Select(cp->Protocol); // TODO
1413
1414 m_cbMultiCast->SetValue(IsAddressMultiCast(m_tNetAddress->GetValue()));
1415
1416 if (cp->NetworkPort == 0)
1417 m_tNetPort->SetValue(wxEmptyString);
1418 else
1419 m_tNetPort->SetValue(wxString::Format(wxT("%i"), cp->NetworkPort));
1420
1421 if (cp->NetProtocol == TCP)
1422 m_rbNetProtoTCP->SetValue(TRUE);
1423 else if (cp->NetProtocol == UDP)
1424 m_rbNetProtoUDP->SetValue(TRUE);
1425 else if (cp->NetProtocol == GPSD)
1426 m_rbNetProtoGPSD->SetValue(TRUE);
1427 else if (cp->NetProtocol == SIGNALK)
1428 m_rbNetProtoSignalK->SetValue(TRUE);
1429 else
1430 m_rbNetProtoGPSD->SetValue(TRUE);
1431
1432 if (cp->Type == SERIAL) {
1433 m_rbTypeSerial->SetValue(TRUE);
1434 SetNMEAFormToSerial();
1435 SetNMEAFormForSerialProtocol();
1436 } else if (cp->Type == NETWORK) {
1437 m_rbTypeNet->SetValue(TRUE);
1438 SetNMEAFormToNet();
1439 } else if (cp->Type == SOCKETCAN) {
1440 m_rbTypeCAN->SetValue(TRUE);
1441 SetNMEAFormToCAN();
1442
1443 } else if (cp->Type == INTERNAL_GPS) {
1444 if (m_rbTypeInternalGPS) m_rbTypeInternalGPS->SetValue(TRUE);
1445 SetNMEAFormToGPS();
1446 } else if (cp->Type == INTERNAL_BT) {
1447 if (m_rbTypeInternalBT) m_rbTypeInternalBT->SetValue(TRUE);
1448 SetNMEAFormToBT();
1449
1450 // Preset the source selector
1451 wxString bts = cp->NetworkAddress + ";" + cp->GetPortStr();
1452 m_choiceBTDataSources->Clear();
1453 m_choiceBTDataSources->Append(bts);
1454 m_choiceBTDataSources->SetSelection(0);
1455 } else
1456 ClearNMEAForm();
1457
1458 if (cp->Type == SERIAL)
1459 m_tSerialComment->SetValue(cp->UserComment);
1460 else if (cp->Type == NETWORK)
1461 m_tNetComment->SetValue(cp->UserComment);
1462
1463 m_tAuthToken->SetValue(cp->AuthToken);
1464
1465 m_connection_enabled = cp->bEnabled;
1466
1467 // Reset touch flag
1468 connectionsaved = true;
1469}
1470
1471void ConnectionEditDialog::SetUDPNetAddressVisiblity(void) {
1472 if (m_rbNetProtoUDP->GetValue() && !m_cbMultiCast->IsChecked() &&
1473 !m_cbOutput->IsChecked()) {
1474 // m_stNetAddr->Show(FALSE);
1475 // m_tNetAddress->Show(FALSE);
1476 m_tNetAddress->Enable(TRUE);
1477 } else {
1478 m_stNetAddr->Show(TRUE);
1479 m_tNetAddress->Show(TRUE);
1480 m_tNetAddress->Enable(TRUE);
1481 }
1482 if (!m_rbNetProtoUDP->GetValue()) {
1483 m_stNetAddr->Show(TRUE);
1484 m_tNetAddress->Show(TRUE);
1485 m_tNetAddress->Enable(TRUE);
1486 }
1487 if (m_rbNetProtoUDP->GetValue() && m_advanced) {
1488 // m_cbMultiCast->Show();
1489 } else
1490 m_cbMultiCast->Hide();
1491}
1492
1493void ConnectionEditDialog::SetDefaultConnectionParams(void) {
1494 if (m_comboPort && !m_comboPort->IsListEmpty()) {
1495 m_comboPort->Select(0);
1496 m_comboPort->SetValue(wxEmptyString); // These two broke it
1497 }
1498 m_cbCheckCRC->SetValue(TRUE);
1499 m_cbGarminHost->SetValue(FALSE);
1500 m_cbInput->SetValue(TRUE);
1501 m_cbOutput->SetValue(FALSE);
1502 m_rbIAccept->SetValue(TRUE);
1503 m_rbOAccept->SetValue(TRUE);
1504 m_tcInputStc->SetValue(wxEmptyString);
1505 m_tcOutputStc->SetValue(wxEmptyString);
1506 m_choiceBaudRate->Select(m_choiceBaudRate->FindString("4800"));
1507 // m_choiceSerialProtocol->Select( cp->Protocol ); // TODO
1508
1509 m_tNetAddress->SetValue(DEFAULT_IP_ADDRESS);
1510
1511 m_tNetComment->SetValue(wxEmptyString);
1512 m_tSerialComment->SetValue(wxEmptyString);
1513 m_tAuthToken->SetValue(wxEmptyString);
1514
1515 bool bserial = TRUE;
1516#ifdef __WXGTK__
1517 bserial = FALSE;
1518#endif
1519
1520#ifdef __WXOSX__
1521 bserial = FALSE;
1522#endif
1523
1524#ifdef __ANDROID__
1525 if (m_rbTypeInternalGPS) {
1526 m_rbTypeInternalGPS->SetValue(true);
1527 SetNMEAFormToGPS();
1528 } else {
1529 m_rbTypeNet->SetValue(true);
1530 SetNMEAFormToNet();
1531 }
1532
1533#else
1534 m_rbTypeSerial->SetValue(bserial);
1535 m_rbTypeNet->SetValue(!bserial);
1536 bserial ? SetNMEAFormToSerial() : SetNMEAFormToNet();
1537 m_rbTypeCAN->SetValue(FALSE);
1538#endif
1539
1540 m_connection_enabled = TRUE;
1541
1542 // Reset touch flag
1543 connectionsaved = false;
1544}
1545
1546void ConnectionEditDialog::LayoutDialog() {
1547 gSizerNetProps->Layout();
1548 gSizerSerProps->Layout();
1549 m_scrolledwin->Layout();
1550 m_scrolledwin->Fit();
1551 GetSizer()->Layout();
1552}
1553
1554void ConnectionEditDialog::UpdateSourceList(bool bResort) {
1555 for (auto* cp : TheConnectionParams()) {
1556 ConnectionParamsPanel* panel = cp->m_optionsPanel;
1557 if (panel) panel->Update(cp);
1558 }
1559
1560 m_scrollWinConnections->Layout();
1561}
1562
1563void ConnectionEditDialog::OnSelectDatasource(wxListEvent& event) {
1564 SetConnectionParams(TheConnectionParams()[event.GetData()]);
1565 m_buttonRemove->Enable();
1566 m_buttonRemove->Show();
1567 event.Skip();
1568}
1569
1570void ConnectionEditDialog::OnDiscoverButton(wxCommandEvent& event) {
1571#if 0 // FIXME (dave)
1572 wxString ip;
1573 int port;
1574 std::string serviceIdent =
1575 std::string("_signalk-ws._tcp.local."); // Works for node.js server
1576
1577 g_Platform->ShowBusySpinner();
1578
1579 if (SignalKDataStream::DiscoverSKServer(serviceIdent, ip, port,
1580 1)) // 1 second scan
1581 {
1582 m_tNetAddress->SetValue(ip);
1583 m_tNetPort->SetValue(wxString::Format(wxT("%i"), port));
1584 UpdateDiscoverStatus(_("Signal K server available."));
1585 } else {
1586 UpdateDiscoverStatus(_("Signal K server not found."));
1587 }
1588 g_Platform->HideBusySpinner();
1589#endif
1590 event.Skip();
1591}
1592
1593void ConnectionEditDialog::UpdateDiscoverStatus(wxString stat) {
1594 m_StaticTextSKServerStatus->SetLabel(stat);
1595}
1596
1597void ConnectionEditDialog::OnBtnIStcs(wxCommandEvent& event) {
1598 const ListType type = m_rbIAccept->GetValue() ? WHITELIST : BLACKLIST;
1599 const wxArrayString list = wxStringTokenize(m_tcInputStc->GetValue(), ",");
1600 SentenceListDlg dlg(m_parent, FILTER_INPUT, type, list);
1601
1602 if (dlg.ShowModal() == wxID_OK) m_tcInputStc->SetValue(dlg.GetSentences());
1603}
1604
1605void ConnectionEditDialog::OnBtnOStcs(wxCommandEvent& event) {
1606 const ListType type = m_rbOAccept->GetValue() ? WHITELIST : BLACKLIST;
1607 const wxArrayString list = wxStringTokenize(m_tcOutputStc->GetValue(), ",");
1608 SentenceListDlg dlg(m_parent, FILTER_OUTPUT, type, list);
1609
1610 if (dlg.ShowModal() == wxID_OK) m_tcOutputStc->SetValue(dlg.GetSentences());
1611}
1612
1613void ConnectionEditDialog::OnNetProtocolSelected(wxCommandEvent& event) {
1614 if (m_rbNetProtoGPSD->GetValue()) {
1615 if (IsDefaultPort(m_tNetPort->GetValue())) {
1616 m_tNetPort->SetValue(DEFAULT_GPSD_PORT);
1617 }
1618 m_tNetAddress->SetValue(DEFAULT_IP_ADDRESS);
1619 } else if (m_rbNetProtoUDP->GetValue()) {
1620 if (IsDefaultPort(m_tNetPort->GetValue())) {
1621 m_tNetPort->SetValue(DEFAULT_UDP_PORT);
1622 }
1623 m_tNetAddress->SetValue(DEFAULT_IP_ADDRESS);
1624 if (m_cbInput->GetValue() && !m_cbMultiCast->GetValue() &&
1625 m_rbNetProtoUDP->GetValue())
1626 m_tNetAddress->SetValue(DEFAULT_IP_ADDRESS);
1627 else if (m_cbOutput->GetValue() && !m_cbMultiCast->GetValue())
1628 m_tNetPort->SetValue(DEFAULT_UDP_OUT_ADDRESS);
1629
1630 if (m_cbInput->GetValue() && m_cbOutput->GetValue())
1631 m_cbOutput->SetValue(false);
1632
1633 } else if (m_rbNetProtoSignalK->GetValue()) {
1634 if (IsDefaultPort(m_tNetPort->GetValue())) {
1635 m_tNetPort->SetValue(DEFAULT_SIGNALK_PORT);
1636 }
1637 m_tNetAddress->SetValue(DEFAULT_IP_ADDRESS);
1638 } else if (m_rbNetProtoTCP->GetValue()) {
1639 if (IsDefaultPort(m_tNetPort->GetValue())) {
1640 m_tNetPort->SetValue(DEFAULT_TCP_PORT);
1641 }
1642 m_tNetAddress->SetValue(DEFAULT_IP_ADDRESS);
1643 }
1644
1645 SetUDPNetAddressVisiblity();
1646 SetDSFormRWStates();
1647 LayoutDialog();
1648 OnConnValChange(event);
1649}
1650
1651void ConnectionEditDialog::OnRbAcceptInput(wxCommandEvent& event) {
1652 OnConnValChange(event);
1653}
1654void ConnectionEditDialog::OnRbIgnoreInput(wxCommandEvent& event) {
1655 OnConnValChange(event);
1656}
1657
1658void ConnectionEditDialog::OnRbOutput(wxCommandEvent& event) {
1659 OnConnValChange(event);
1660}
1661
1662void ConnectionEditDialog::OnCbInput(wxCommandEvent& event) {
1663 const bool checked = m_cbInput->IsChecked();
1664 ShowInFilter(checked);
1665 if (checked && m_rbNetProtoUDP->GetValue() && m_rbTypeNet->GetValue()) {
1666 m_cbOutput->SetValue(FALSE);
1667
1668 if (!m_cbMultiCast->GetValue()) m_tNetAddress->SetValue(DEFAULT_IP_ADDRESS);
1669 }
1670 SetDSFormRWStates();
1671 LayoutDialog();
1672 if (m_rbTypeNet->GetValue()) SetUDPNetAddressVisiblity();
1673 OnConnValChange(event);
1674}
1675
1676void ConnectionEditDialog::OnCbOutput(wxCommandEvent& event) {
1677 OnConnValChange(event);
1678 const bool checked = m_cbOutput->IsChecked();
1679 m_stPrecision->Enable(checked);
1680 m_choicePrecision->Enable(checked);
1681 ShowOutFilter(checked);
1682
1683 if (!m_cbMultiCast->IsChecked() && m_rbNetProtoUDP->GetValue()) {
1684 if (checked) {
1685 m_tNetAddress->SetValue(
1686 DEFAULT_UDP_OUT_ADDRESS); // IP address for output
1687 // Check for a UDP input connection on the same port
1688 NetworkProtocol proto = UDP;
1689 for (auto* cp : TheConnectionParams()) {
1690 if (cp->NetProtocol == proto &&
1691 cp->NetworkPort == wxAtoi(m_tNetPort->GetValue()) &&
1692 cp->IOSelect == DS_TYPE_INPUT) {
1693 // More: View the filter handler
1694 m_advanced = true;
1695 SetNMEAFormForNetProtocol();
1696 LayoutDialog();
1697
1698 wxString mes;
1699 bool warn = false;
1700 if (cp->bEnabled) {
1701 mes =
1702 _("There is an enabled UDP input connection that uses the "
1703 "same data port.");
1704 mes << "\n"
1705 << _("Please apply a filter on both connections to avoid a "
1706 "feedback loop.");
1707 warn = true;
1708 } else {
1709 mes =
1710 _("There is a disabled UDP Input connection that uses the "
1711 "same Dataport.");
1712 mes << "\n"
1713 << _("If you enable that input please apply a filter on both "
1714 "connections to avoid a feedback loop.");
1715 }
1716 mes << "\n"
1717 << _("Or consider using a different data port for one of them");
1718 if (warn)
1719 OCPNMessageBox(this, mes, _("OpenCPN Warning"),
1720 wxOK | wxICON_EXCLAMATION, 60);
1721 else
1722 OCPNMessageBox(this, mes, _("OpenCPN info"),
1723 wxOK | wxICON_INFORMATION, 60);
1724 break;
1725 }
1726 }
1727 } else {
1728 m_tNetAddress->SetValue(DEFAULT_IP_ADDRESS); // IP address for input
1729 }
1730 }
1731
1732 if (checked && m_rbNetProtoUDP->GetValue()) {
1733 m_cbInput->SetValue(FALSE);
1734 }
1735
1736 if (m_rbTypeNet->GetValue()) SetUDPNetAddressVisiblity();
1737 SetDSFormRWStates();
1738 LayoutDialog();
1739}
1740
1741void ConnectionEditDialog::OnCbMultiCast(wxCommandEvent& event) {
1742 const bool checked = m_cbMultiCast->IsChecked();
1743 if (checked) {
1744 if (!IsAddressMultiCast(m_tNetAddress->GetValue())) {
1745 m_tNetAddress->SetValue("224.0.2.21");
1746 }
1747 } else if (m_cbOutput->IsChecked()) {
1748 m_tNetAddress->SetValue(DEFAULT_IP_ADDRESS); // IP address for output
1749 } else {
1750 m_tNetAddress->SetValue(DEFAULT_IP_ADDRESS); // IP address for input
1751 }
1752
1753 SetUDPNetAddressVisiblity();
1754 LayoutDialog();
1755}
1756
1757void ConnectionEditDialog::OnCollapsedToggle(bool collapsed) {
1758 m_advanced = !collapsed;
1759 if (m_rbTypeNet->GetValue())
1760 SetNMEAFormForNetProtocol();
1761 else
1762 SetNMEAFormForSerialProtocol();
1763 LayoutDialog();
1764}
1765
1766void ConnectionEditDialog::OnCbAdvanced(wxCommandEvent& event) {
1767 if (m_rbTypeNet->GetValue())
1768 SetNMEAFormForNetProtocol();
1769 else
1770 SetNMEAFormForSerialProtocol();
1771 LayoutDialog();
1772}
1773
1774void ConnectionEditDialog::OnShowGpsWindowCheckboxClick(wxCommandEvent& event) {
1775 // if (!m_cbNMEADebug->GetValue()) {
1776 // NMEALogWindow::GetInstance().DestroyWindow();
1777 // } else {
1778 // NMEALogWindow::GetInstance().Create((wxWindow*)(m_parent->GetParent()),
1779 // 35);
1780 //
1781 // // Try to ensure that the log window is at least a little bit visible
1782 // wxRect logRect(NMEALogWindow::GetInstance().GetPosX(),
1783 // NMEALogWindow::GetInstance().GetPosY(),
1784 // NMEALogWindow::GetInstance().GetSizeW(),
1785 // NMEALogWindow::GetInstance().GetSizeH());
1786 // FIXME (leamas)
1787
1788#if 0
1789 if (m_container->GetRect().Contains(logRect)) {
1790 NMEALogWindow::Get().SetPos(
1791 m_container->GetRect().x / 2,
1792 (m_container->GetRect().y +
1793 (m_container->GetRect().height - logRect.height) / 2));
1794 NMEALogWindow::Get().Move();
1795 }
1796#endif
1797 m_parent->Raise();
1798 // }
1799}
1800void ConnectionEditDialog::SetNMEAFormForSerialProtocol() {
1801 bool n0183ctlenabled = (DataProtocol)m_choiceSerialProtocol->GetSelection() ==
1802 DataProtocol::PROTO_NMEA0183;
1803 bool advanced = m_advanced;
1804 ShowNMEACommon(n0183ctlenabled && advanced);
1805 m_cbGarminHost->Show(n0183ctlenabled && advanced);
1806
1807 SetDSFormRWStates();
1808 LayoutDialog();
1809}
1810
1811void ConnectionEditDialog::SetNMEAFormForNetProtocol() {
1812 bool n0183ctlenabled =
1813 (DataProtocol)m_choiceNetDataProtocol->GetSelection() ==
1814 DataProtocol::PROTO_NMEA0183;
1815 bool advanced = m_advanced;
1816 ShowNMEACommon(n0183ctlenabled && advanced);
1817 m_cbGarminHost->Show(n0183ctlenabled && advanced);
1818
1819 SetDSFormRWStates();
1820
1821 LayoutDialog();
1822}
1823
1824void ConnectionEditDialog::OnProtocolChoice(wxCommandEvent& event) {
1825 if (m_rbTypeNet->GetValue())
1826 SetNMEAFormForNetProtocol();
1827 else
1828 SetNMEAFormForSerialProtocol();
1829
1830 OnConnValChange(event);
1831}
1832
1833void ConnectionEditDialog::ApplySettings() {
1834#if 0
1835 g_bfilter_cogsog = m_cbFilterSogCog->GetValue();
1836
1837 long filter_val = 1;
1838 m_tFilterSec->GetValue().ToLong(&filter_val);
1839 g_COGFilterSec =
1840 wxMin(static_cast<int>(filter_val),
1841 60 /*MAX_COGSOG_FILTER_SECONDS*/); // FIXME (dave) should be
1842 g_COGFilterSec = wxMax(g_COGFilterSec, 1);
1843 g_SOGFilterSec = g_COGFilterSec;
1844
1845 g_bMagneticAPB = m_cbAPBMagnetic->GetValue();
1846 g_NMEAAPBPrecision = m_choicePrecision->GetCurrentSelection();
1847
1848 // NMEA Source
1849 // If the stream selected exists, capture some of its existing parameters
1850 // to facility identification and allow stop and restart of the stream
1851 wxString lastAddr;
1852 int lastPort = 0;
1853 NetworkProtocol lastNetProtocol = PROTO_UNDEFINED;
1854 DataProtocol lastDataProtocol = PROTO_NMEA0183;
1855
1856 if (mSelectedConnection) {
1857 ConnectionParams* cpo = mSelectedConnection;
1858 lastAddr = cpo->NetworkAddress;
1859 lastPort = cpo->NetworkPort;
1860 lastNetProtocol = cpo->NetProtocol;
1861 lastDataProtocol = cpo->Protocol;
1862 }
1863
1864 if (!connectionsaved) {
1865 size_t nCurrentPanelCount = TheConnectionParams()->GetCount();
1866 ConnectionParams* cp = NULL;
1867 int old_priority = -1;
1868 {
1869 if (mSelectedConnection) {
1870 cp = mSelectedConnection;
1871 old_priority = cp->Priority;
1872 UpdateConnectionParamsFromControls(cp);
1873 cp->b_IsSetup = false;
1874 // cp->bEnabled = false;
1875 // if (cp->m_optionsPanel)
1876 // cp->m_optionsPanel->SetEnableCheckbox(false);
1877
1878 // delete TheConnectionParams()->Item(itemIndex)->m_optionsPanel;
1879 // old_priority = TheConnectionParams()->Item(itemIndex)->Priority;
1880 // TheConnectionParams()->RemoveAt(itemIndex);
1881 // TheConnectionParams()->Insert(cp, itemIndex);
1882 // mSelectedConnection = cp;
1883 // cp->m_optionsPanel->SetSelected( true );
1884 } else {
1885 cp = CreateConnectionParamsFromSelectedItem();
1886 if (cp) TheConnectionParams()->Add(cp);
1887 }
1888
1889 // Record the previous parameters, if any
1890 if (cp) {
1891 cp->LastNetProtocol = lastNetProtocol;
1892 cp->LastNetworkAddress = lastAddr;
1893 cp->LastNetworkPort = lastPort;
1894 cp->LastDataProtocol = lastDataProtocol;
1895 }
1896
1897 if (TheConnectionParams()->GetCount() != nCurrentPanelCount)
1898 FillSourceList();
1899 else if (old_priority >= 0) {
1900 if (old_priority != cp->Priority) // need resort
1901 UpdateSourceList(true);
1902 else
1903 UpdateSourceList(false);
1904 }
1905
1906 connectionsaved = TRUE;
1907 }
1908 // else {
1909 // ::wxEndBusyCursor();
1910 // if (m_bNMEAParams_shown) event.SetInt(wxID_STOP);
1911 // }
1912
1913 SetSelectedConnectionPanel(nullptr);
1914 }
1915
1916 // Recreate datastreams that are new, or have been edited
1917 for (size_t i = 0; i < TheConnectionParams()->Count(); i++) {
1918 ConnectionParams* cp = TheConnectionParams()->Item(i);
1919
1920 if (cp->b_IsSetup) continue;
1921
1922 // Connection is new, or edited, or disabled
1923
1924 // Terminate and remove any existing driver, if present in registry
1925 StopAndRemoveCommDriver(cp->GetStrippedDSPort(), cp->GetCommProtocol());
1926
1927 // Stop and remove "previous" port, in case other params have changed.
1928 StopAndRemoveCommDriver(cp->GetLastDSPort(), cp->GetLastCommProtocol());
1929
1930 // Internal BlueTooth driver stacks commonly need a time delay to purge
1931 // their buffers, etc. before restating with new parameters...
1932 if (cp->Type == INTERNAL_BT) wxSleep(1);
1933
1934 // Connection has been disabled
1935 if (!cp->bEnabled) continue;
1936
1937 // Make any new or re-enabled drivers
1938 MakeCommDriver(cp);
1939 cp->b_IsSetup = TRUE;
1940 }
1941
1942 g_bGarminHostUpload = m_cbGarminUploadHost->GetValue();
1943 g_GPS_Ident =
1944 m_cbFurunoGP3X->GetValue() ? "FurunoGP3X" : "Generic";
1945#endif
1946}
1947
1948ConnectionParams*
1949ConnectionEditDialog::CreateConnectionParamsFromSelectedItem() {
1950#if 0
1951 // FIXME (dave) How could this happen?
1952 // if (!m_bNMEAParams_shown) return NULL;
1953
1954 // Special encoding for deleted connection
1955 if (m_rbTypeSerial->GetValue() && m_comboPort->GetValue() == "Deleted")
1956 return NULL;
1957
1958 // We check some values here for consistency.
1959 // If necessary, set defaults so user will see some result, however wrong...
1960
1961 // DataStreams should be Input, Output, or Both
1962 if (!(m_cbInput->GetValue() || m_cbOutput->GetValue())) {
1963 m_cbInput->SetValue(true);
1964 }
1965
1966 if (m_rbTypeSerial->GetValue() && m_comboPort->GetValue() == wxEmptyString) {
1967 m_comboPort->Select(0);
1968 }
1969 // TCP, GPSD and UDP require port field to be set.
1970 // TCP clients, GPSD and UDP output sockets require an address
1971 else if (m_rbTypeNet->GetValue()) {
1972 if (wxAtoi(m_tNetPort->GetValue()) == 0) {
1973 m_tNetPort->SetValue("10110"); // reset to default
1974 }
1975 if (m_tNetAddress->GetValue() == wxEmptyString) {
1976 m_tNetAddress->SetValue("0.0.0.0");
1977 }
1978 } else if (m_rbTypeCAN->GetValue()) {
1979 }
1980
1981 ConnectionParams* pConnectionParams = new ConnectionParams();
1982
1983 UpdateConnectionParamsFromSelectedItem(pConnectionParams);
1984
1985 ConnectionParamsPanel* pPanel = new ConnectionParamsPanel(
1986 m_scrollWinConnections, wxID_ANY, wxDefaultPosition, wxDefaultSize,
1987 pConnectionParams, this);
1988 pPanel->SetSelected(false);
1989 boxSizerConnections->Add(pPanel, 0, wxEXPAND | wxALL, 0);
1990 pConnectionParams->m_optionsPanel = pPanel;
1991
1992 return pConnectionParams;
1993#endif
1994 return NULL;
1995}
1996
1997ConnectionParams* ConnectionEditDialog::GetParamsFromControls() {
1998 ConnectionParams* pConnectionParams = new ConnectionParams();
1999 UpdateConnectionParamsFromControls(pConnectionParams);
2000 return pConnectionParams;
2001}
2002
2003ConnectionParams* ConnectionEditDialog::UpdateConnectionParamsFromControls(
2004 ConnectionParams* pConnectionParams) {
2005 pConnectionParams->Valid = TRUE;
2006 if (m_rbTypeSerial->GetValue())
2007 pConnectionParams->Type = SERIAL;
2008 else if (m_rbTypeNet->GetValue())
2009 pConnectionParams->Type = NETWORK;
2010 else if (m_rbTypeInternalGPS && m_rbTypeInternalGPS->GetValue())
2011 pConnectionParams->Type = INTERNAL_GPS;
2012 else if (m_rbTypeInternalBT && m_rbTypeInternalBT->GetValue())
2013 pConnectionParams->Type = INTERNAL_BT;
2014 else if (m_rbTypeCAN && m_rbTypeCAN->GetValue())
2015 pConnectionParams->Type = SOCKETCAN;
2016
2017 if (m_rbTypeNet->GetValue()) {
2018 // Save the existing addr/port to allow closing of existing port
2019 pConnectionParams->LastNetworkAddress = pConnectionParams->NetworkAddress;
2020 pConnectionParams->LastNetworkPort = pConnectionParams->NetworkPort;
2021 pConnectionParams->LastNetProtocol = pConnectionParams->NetProtocol;
2022 pConnectionParams->LastDataProtocol = pConnectionParams->Protocol;
2023
2024 pConnectionParams->NetworkAddress =
2025 m_tNetAddress->GetValue().Trim(false).Trim(true);
2026 pConnectionParams->NetworkPort =
2027 wxAtoi(m_tNetPort->GetValue().Trim(false).Trim(true));
2028 if (m_rbNetProtoTCP->GetValue()) {
2029 pConnectionParams->NetProtocol = TCP;
2030 pConnectionParams->Protocol =
2031 (DataProtocol)m_choiceNetDataProtocol->GetSelection();
2032 } else if (m_rbNetProtoUDP->GetValue()) {
2033 pConnectionParams->NetProtocol = UDP;
2034 pConnectionParams->Protocol =
2035 (DataProtocol)m_choiceNetDataProtocol->GetSelection();
2036 } else if (m_rbNetProtoGPSD->GetValue())
2037 pConnectionParams->NetProtocol = GPSD;
2038 else if (m_rbNetProtoSignalK->GetValue())
2039 pConnectionParams->NetProtocol = SIGNALK;
2040 else
2041 pConnectionParams->NetProtocol = PROTO_UNDEFINED;
2042 }
2043
2044 if (m_rbTypeSerial->GetValue())
2045 pConnectionParams->Protocol =
2046 (DataProtocol)m_choiceSerialProtocol->GetSelection();
2047 else if (m_rbTypeNet->GetValue())
2048 pConnectionParams->Protocol =
2049 (DataProtocol)m_choiceNetDataProtocol->GetSelection();
2050
2051 pConnectionParams->Baudrate = wxAtoi(m_choiceBaudRate->GetStringSelection());
2052 pConnectionParams->ChecksumCheck = m_cbCheckCRC->GetValue();
2053 pConnectionParams->AutoSKDiscover = m_cbCheckSKDiscover->GetValue();
2054 pConnectionParams->Garmin = m_cbGarminHost->GetValue();
2055 pConnectionParams->InputSentenceList =
2056 wxStringTokenize(m_tcInputStc->GetValue(), ",");
2057 if (m_rbIAccept->GetValue())
2058 pConnectionParams->InputSentenceListType = WHITELIST;
2059 else
2060 pConnectionParams->InputSentenceListType = BLACKLIST;
2061 if (m_cbInput->GetValue()) {
2062 if (m_cbOutput->GetValue()) {
2063 pConnectionParams->IOSelect = DS_TYPE_INPUT_OUTPUT;
2064 } else {
2065 pConnectionParams->IOSelect = DS_TYPE_INPUT;
2066 }
2067 } else
2068 pConnectionParams->IOSelect = DS_TYPE_OUTPUT;
2069
2070 pConnectionParams->OutputSentenceList =
2071 wxStringTokenize(m_tcOutputStc->GetValue(), ",");
2072 if (m_rbOAccept->GetValue())
2073 pConnectionParams->OutputSentenceListType = WHITELIST;
2074 else
2075 pConnectionParams->OutputSentenceListType = BLACKLIST;
2076 pConnectionParams->Port = m_comboPort->GetValue().BeforeFirst(' ');
2077#if defined(__linux__) && !defined(__ANDROID__)
2078 if (pConnectionParams->Type == SERIAL)
2079 CheckSerialAccess(m_parent, pConnectionParams->Port.ToStdString());
2080#endif
2081
2082 if (m_rbTypeCAN && m_rbTypeCAN->GetValue())
2083 pConnectionParams->Protocol = PROTO_NMEA2000;
2084
2085 pConnectionParams->bEnabled = m_connection_enabled;
2086 pConnectionParams->b_IsSetup = FALSE;
2087
2088 if (pConnectionParams->Type == INTERNAL_GPS) {
2089 pConnectionParams->NetworkAddress = "";
2090 pConnectionParams->NetworkPort = 0;
2091 pConnectionParams->NetProtocol = PROTO_UNDEFINED;
2092 pConnectionParams->Baudrate = 0;
2093 }
2094
2095 if (pConnectionParams->Type == INTERNAL_BT) {
2096 wxString parms = m_choiceBTDataSources->GetStringSelection();
2097 wxStringTokenizer tkz(parms, ";");
2098 wxString name = tkz.GetNextToken();
2099 wxString mac = tkz.GetNextToken();
2100
2101 pConnectionParams->NetworkAddress = name;
2102 pConnectionParams->Port = mac;
2103 pConnectionParams->NetworkPort = 0;
2104 pConnectionParams->NetProtocol = PROTO_UNDEFINED;
2105 pConnectionParams->Baudrate = 0;
2106 // pConnectionParams->SetAuxParameterStr(m_choiceBTDataSources->GetStringSelection());
2107 }
2108
2109 if (pConnectionParams->Type == SOCKETCAN) {
2110 pConnectionParams->NetworkAddress = "";
2111 pConnectionParams->NetworkPort = 0;
2112 pConnectionParams->NetProtocol = PROTO_UNDEFINED;
2113 pConnectionParams->Baudrate = 0;
2114 pConnectionParams->socketCAN_port =
2115 m_choiceCANSource->GetString(m_choiceCANSource->GetSelection());
2116 }
2117
2118 if (pConnectionParams->Type == SERIAL) {
2119 pConnectionParams->UserComment = m_tSerialComment->GetValue();
2120 } else if (pConnectionParams->Type == NETWORK) {
2121 pConnectionParams->UserComment = m_tNetComment->GetValue();
2122 }
2123 pConnectionParams->AuthToken = m_tAuthToken->GetValue();
2124
2125 return pConnectionParams;
2126}
2127
2128void ConnectionEditDialog::OnPriorityDialog(wxCommandEvent& event) {
2129 PriorityDlg* pdlg = new PriorityDlg(m_parent);
2130 pdlg->ShowModal();
2131 delete pdlg;
2132}
2133void ConnectionEditDialog::ConnectControls() {
2134 // Connect controls
2135 m_rbTypeSerial->Connect(
2136 wxEVT_COMMAND_RADIOBUTTON_SELECTED,
2137 wxCommandEventHandler(ConnectionEditDialog::OnTypeSerialSelected), NULL,
2138 this);
2139 m_rbTypeNet->Connect(
2140 wxEVT_COMMAND_RADIOBUTTON_SELECTED,
2141 wxCommandEventHandler(ConnectionEditDialog::OnTypeNetSelected), NULL,
2142 this);
2143
2144 m_rbTypeCAN->Connect(
2145 wxEVT_COMMAND_RADIOBUTTON_SELECTED,
2146 wxCommandEventHandler(ConnectionEditDialog::OnTypeCANSelected), NULL,
2147 this);
2148
2149 if (m_rbTypeInternalGPS)
2150 m_rbTypeInternalGPS->Connect(
2151 wxEVT_COMMAND_RADIOBUTTON_SELECTED,
2152 wxCommandEventHandler(ConnectionEditDialog::OnTypeGPSSelected), NULL,
2153 this);
2154 if (m_rbTypeInternalBT)
2155 m_rbTypeInternalBT->Connect(
2156 wxEVT_COMMAND_RADIOBUTTON_SELECTED,
2157 wxCommandEventHandler(ConnectionEditDialog::OnTypeBTSelected), NULL,
2158 this);
2159
2160 // Network connection
2161 m_rbNetProtoTCP->Connect(
2162 wxEVT_COMMAND_RADIOBUTTON_SELECTED,
2163 wxCommandEventHandler(ConnectionEditDialog::OnNetProtocolSelected), NULL,
2164 this);
2165 m_rbNetProtoUDP->Connect(
2166 wxEVT_COMMAND_RADIOBUTTON_SELECTED,
2167 wxCommandEventHandler(ConnectionEditDialog::OnNetProtocolSelected), NULL,
2168 this);
2169 m_rbNetProtoGPSD->Connect(
2170 wxEVT_COMMAND_RADIOBUTTON_SELECTED,
2171 wxCommandEventHandler(ConnectionEditDialog::OnNetProtocolSelected), NULL,
2172 this);
2173 m_rbNetProtoSignalK->Connect(
2174 wxEVT_COMMAND_RADIOBUTTON_SELECTED,
2175 wxCommandEventHandler(ConnectionEditDialog::OnNetProtocolSelected), NULL,
2176 this);
2177 m_choiceNetDataProtocol->Connect(
2178 wxEVT_COMMAND_CHOICE_SELECTED,
2179 wxCommandEventHandler(ConnectionEditDialog::OnProtocolChoice), NULL,
2180 this);
2181 m_choiceSerialProtocol->Connect(
2182 wxEVT_COMMAND_CHOICE_SELECTED,
2183 wxCommandEventHandler(ConnectionEditDialog::OnProtocolChoice), NULL,
2184 this);
2185 m_cbMultiCast->Connect(
2186 wxEVT_COMMAND_CHECKBOX_CLICKED,
2187 wxCommandEventHandler(ConnectionEditDialog::OnCbMultiCast), NULL, this);
2188
2189 // input/output control
2190 m_cbInput->Connect(wxEVT_COMMAND_CHECKBOX_CLICKED,
2191 wxCommandEventHandler(ConnectionEditDialog::OnCbInput),
2192 NULL, this);
2193 m_cbOutput->Connect(wxEVT_COMMAND_CHECKBOX_CLICKED,
2194 wxCommandEventHandler(ConnectionEditDialog::OnCbOutput),
2195 NULL, this);
2196
2197 // Input filtering
2198 // m_rbIAccept->Connect(
2199 // wxEVT_COMMAND_RADIOBUTTON_SELECTED,
2200 // wxCommandEventHandler(ConnectionEditDialog::OnRbAcceptInput), NULL,
2201 // this);
2202 // m_rbIIgnore->Connect(
2203 // wxEVT_COMMAND_RADIOBUTTON_SELECTED,
2204 // wxCommandEventHandler(ConnectionEditDialog::OnRbIgnoreInput), NULL,
2205 // this);
2206 // m_tcInputStc->Connect(
2207 // wxEVT_COMMAND_TEXT_UPDATED,
2208 // wxCommandEventHandler(ConnectionEditDialog::OnConnValChange), NULL,
2209 // this);
2210 m_btnInputStcList->Connect(
2211 wxEVT_COMMAND_BUTTON_CLICKED,
2212 wxCommandEventHandler(ConnectionEditDialog::OnBtnIStcs), NULL, this);
2213
2214 // output filtering
2215 m_btnOutputStcList->Connect(
2216 wxEVT_COMMAND_BUTTON_CLICKED,
2217 wxCommandEventHandler(ConnectionEditDialog::OnBtnOStcs), NULL, this);
2218
2219#if 0
2220 m_tNetAddress->Connect(
2221 wxEVT_COMMAND_TEXT_UPDATED,
2222 wxCommandEventHandler(ConnectionEditDialog::OnConnValChange), NULL, this);
2223 m_tNetPort->Connect(wxEVT_COMMAND_TEXT_UPDATED,
2224 wxCommandEventHandler(ConnectionEditDialog::OnConnValChange),
2225 NULL, this);
2226 m_comboPort->Connect(
2227 wxEVT_COMMAND_COMBOBOX_SELECTED,
2228 wxCommandEventHandler(ConnectionEditDialog::OnConnValChange), NULL, this);
2229 m_comboPort->Connect(
2230 wxEVT_COMMAND_TEXT_UPDATED,
2231 wxCommandEventHandler(ConnectionEditDialog::OnConnValChange), NULL, this);
2232 m_choiceBaudRate->Connect(
2233 wxEVT_COMMAND_CHOICE_SELECTED,
2234 wxCommandEventHandler(ConnectionEditDialog::OnBaudrateChoice), NULL, this);
2235 m_choicePriority->Connect(
2236 wxEVT_COMMAND_CHOICE_SELECTED,
2237 wxCommandEventHandler(ConnectionEditDialog::OnConnValChange), NULL, this);
2238 m_choiceCANSource->Connect(
2239 wxEVT_COMMAND_CHOICE_SELECTED,
2240 wxCommandEventHandler(ConnectionEditDialog::OnConnValChange), NULL, this);
2241 m_cbCheckCRC->Connect(wxEVT_COMMAND_CHECKBOX_CLICKED,
2242 wxCommandEventHandler(ConnectionEditDialog::OnCrcCheck),
2243 NULL, this);
2244 m_cbGarminHost->Connect(
2245 wxEVT_COMMAND_CHECKBOX_CLICKED,
2246 wxCommandEventHandler(ConnectionEditDialog::OnUploadFormatChange), NULL,
2247 this);
2248 m_cbGarminUploadHost->Connect(
2249 wxEVT_COMMAND_CHECKBOX_CLICKED,
2250 wxCommandEventHandler(ConnectionEditDialog::OnUploadFormatChange), NULL,
2251 this);
2252 m_cbFurunoGP3X->Connect(
2253 wxEVT_COMMAND_CHECKBOX_CLICKED,
2254 wxCommandEventHandler(ConnectionEditDialog::OnUploadFormatChange), NULL,
2255 this);
2256 m_cbCheckSKDiscover->Connect(
2257 wxEVT_COMMAND_CHECKBOX_CLICKED,
2258 wxCommandEventHandler(ConnectionEditDialog::OnConnValChange), NULL, this);
2259 m_ButtonSKDiscover->Connect(
2260 wxEVT_COMMAND_BUTTON_CLICKED,
2261 wxCommandEventHandler(ConnectionEditDialog::OnDiscoverButton), NULL, this);
2262
2263 m_rbOAccept->Connect(wxEVT_COMMAND_RADIOBUTTON_SELECTED,
2264 wxCommandEventHandler(ConnectionEditDialog::OnRbOutput),
2265 NULL, this);
2266 m_rbOIgnore->Connect(wxEVT_COMMAND_RADIOBUTTON_SELECTED,
2267 wxCommandEventHandler(ConnectionEditDialog::OnRbOutput),
2268 NULL, this);
2269 m_tcOutputStc->Connect(
2270 wxEVT_COMMAND_TEXT_UPDATED,
2271 wxCommandEventHandler(ConnectionEditDialog::OnConnValChange), NULL, this);
2272 m_cbCheckCRC->Connect(
2273 wxEVT_COMMAND_CHECKBOX_CLICKED,
2274 wxCommandEventHandler(ConnectionEditDialog::OnConnValChange), NULL, this);
2275
2276 m_cbNMEADebug->Connect(
2277 wxEVT_COMMAND_CHECKBOX_CLICKED,
2278 wxCommandEventHandler(ConnectionEditDialog::OnShowGpsWindowCheckboxClick),
2279 NULL, this);
2280 m_cbFilterSogCog->Connect(
2281 wxEVT_COMMAND_CHECKBOX_CLICKED,
2282 wxCommandEventHandler(ConnectionEditDialog::OnValChange), NULL, this);
2283 m_tFilterSec->Connect(wxEVT_COMMAND_TEXT_UPDATED,
2284 wxCommandEventHandler(ConnectionEditDialog::OnValChange),
2285 NULL, this);
2286 m_cbAPBMagnetic->Connect(
2287 wxEVT_COMMAND_CHECKBOX_CLICKED,
2288 wxCommandEventHandler(ConnectionEditDialog::OnValChange), NULL, this);
2289
2290 m_ButtonPriorityDialog->Connect(
2291 wxEVT_COMMAND_BUTTON_CLICKED,
2292 wxCommandEventHandler(ConnectionEditDialog::OnPriorityDialog), NULL, this);
2293
2294 m_tNetComment->Connect(
2295 wxEVT_COMMAND_TEXT_UPDATED,
2296 wxCommandEventHandler(ConnectionEditDialog::OnConnValChange), NULL, this);
2297 m_tSerialComment->Connect(
2298 wxEVT_COMMAND_TEXT_UPDATED,
2299 wxCommandEventHandler(ConnectionEditDialog::OnConnValChange), NULL, this);
2300 m_tAuthToken->Connect(
2301 wxEVT_COMMAND_TEXT_UPDATED,
2302 wxCommandEventHandler(ConnectionEditDialog::OnConnValChange), NULL, this);
2303
2304 if (m_buttonScanBT)
2305 m_buttonScanBT->Connect(
2306 wxEVT_COMMAND_BUTTON_CLICKED,
2307 wxCommandEventHandler(ConnectionEditDialog::OnScanBTClick), NULL, this);
2308#endif
2309}
2310
2311bool ConnectionEditDialog::IsAddressMultiCast(wxString ip) {
2312 wxArrayString bytes = wxSplit(ip, '.');
2313 if (bytes.size() != 4) {
2314 return false;
2315 }
2316 unsigned long ipNum = (wxAtoi(bytes[0]) << 24) + (wxAtoi(bytes[1]) << 16) +
2317 (wxAtoi(bytes[2]) << 8) + wxAtoi(bytes[3]);
2318 unsigned long multicastStart = (224 << 24);
2319 unsigned long multicastEnd = (239 << 24) + (255 << 16) + (255 << 8) + 255;
2320 return ipNum >= multicastStart && ipNum <= multicastEnd;
2321}
2322
2323bool ConnectionEditDialog::IsDefaultPort(wxString address) {
2324 return (address == DEFAULT_TCP_PORT) || (address == DEFAULT_UDP_PORT) ||
2325 (address == DEFAULT_SIGNALK_PORT) || (address == DEFAULT_GPSD_PORT);
2326}
2327
2328bool ConnectionEditDialog::IsAddressBroadcast(wxString ip) {
2329 wxArrayString bytes = wxSplit(ip, '.');
2330 if (bytes.size() != 4) {
2331 std::cerr << "Invalid IP format." << std::endl;
2332 return false;
2333 }
2334 return wxAtoi(bytes[3]) == 255;
2335}
2336
2337SentenceListDlg::SentenceListDlg(wxWindow* parent, FilterDirection dir,
2338 ListType type, const wxArrayString& list)
2339 : wxDialog(parent, wxID_ANY, _("Sentence Filter"), wxDefaultPosition,
2340 wxSize(280, 420)),
2341 m_type(type),
2342 m_dir(dir),
2343 m_sentences(NMEA0183().GetRecognizedArray()) {
2344 m_sentences.Sort();
2345 wxBoxSizer* mainSizer = new wxBoxSizer(wxVERTICAL);
2346 wxBoxSizer* secondSizer = new wxBoxSizer(wxHORIZONTAL);
2347 wxStaticBox* pclbBox = new wxStaticBox(this, wxID_ANY, GetBoxLabel());
2348 wxStaticBoxSizer* stcSizer = new wxStaticBoxSizer(pclbBox, wxVERTICAL);
2349 m_clbSentences = new wxCheckListBox(this, wxID_ANY, wxDefaultPosition,
2350 wxDefaultSize, m_sentences);
2351 wxBoxSizer* btnEntrySizer = new wxBoxSizer(wxVERTICAL);
2352 wxButton* btnCheckAll = new wxButton(this, wxID_ANY, _("Select All"));
2353 wxButton* btnClearAll = new wxButton(this, wxID_ANY, _("Clear All"));
2354 wxButton* btnAdd = new wxButton(this, wxID_ANY, _("Add"));
2355 m_btnDel = new wxButton(this, wxID_ANY, _("Delete"));
2356 m_btnDel->Disable();
2357 wxStdDialogButtonSizer* btnSizer = new wxStdDialogButtonSizer();
2358 wxButton* btnOK = new wxButton(this, wxID_OK);
2359 wxButton* btnCancel = new wxButton(this, wxID_CANCEL, _("Cancel"));
2360
2361 secondSizer->Add(stcSizer, 1, wxALL | wxEXPAND, 5);
2362 stcSizer->Add(m_clbSentences, 1, wxALL | wxEXPAND, 5);
2363 btnEntrySizer->Add(btnCheckAll, 0, wxALL, 5);
2364 btnEntrySizer->Add(btnClearAll, 0, wxALL, 5);
2365 btnEntrySizer->AddSpacer(1);
2366 btnEntrySizer->Add(btnAdd, 0, wxALL, 5);
2367 btnEntrySizer->Add(m_btnDel, 0, wxALL, 5);
2368 secondSizer->Add(btnEntrySizer, 0, wxALL | wxEXPAND, 5);
2369 mainSizer->Add(secondSizer, 1, wxEXPAND, 5);
2370 btnSizer->AddButton(btnOK);
2371 btnSizer->AddButton(btnCancel);
2372 btnSizer->Realize();
2373 mainSizer->Add(btnSizer, 0, wxALL | wxEXPAND, 5);
2374
2375 SetSizer(mainSizer);
2376 mainSizer->SetSizeHints(this);
2377 Centre();
2378
2379 // Connect Events
2380 btnAdd->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
2381 wxCommandEventHandler(SentenceListDlg::OnAddClick), NULL,
2382 this);
2383 m_btnDel->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
2384 wxCommandEventHandler(SentenceListDlg::OnDeleteClick), NULL,
2385 this);
2386 m_clbSentences->Connect(wxEVT_COMMAND_LISTBOX_SELECTED,
2387 wxCommandEventHandler(SentenceListDlg::OnCLBSelect),
2388 NULL, this);
2389 btnCheckAll->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
2390 wxCommandEventHandler(SentenceListDlg::OnCheckAllClick),
2391 NULL, this);
2392 btnClearAll->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
2393 wxCommandEventHandler(SentenceListDlg::OnClearAllClick),
2394 NULL, this);
2395
2396 Populate(list);
2397}
2398
2399wxString SentenceListDlg::GetBoxLabel(void) const {
2400 if (m_dir == FILTER_OUTPUT)
2401 return m_type == WHITELIST ? _("Transmit sentences") : _("Drop sentences");
2402 else
2403 return m_type == WHITELIST ? _("Accept only sentences")
2404 : _("Ignore sentences");
2405}
2406
2407void SentenceListDlg::Populate(const wxArrayString& list) {
2408 if (m_dir == FILTER_OUTPUT) {
2409 wxString s;
2410 m_sentences.Add(g_TalkerIdText + wxString("RMB"));
2411 m_sentences.Add(g_TalkerIdText + wxString("RMC"));
2412 m_sentences.Add(g_TalkerIdText + wxString("APB"));
2413 m_sentences.Add(g_TalkerIdText + wxString("XTE"));
2414 }
2415 m_sentences.Add("AIVDM");
2416 m_sentences.Add("AIVDO");
2417 m_sentences.Add("FRPOS");
2418 m_sentences.Add(g_TalkerIdText);
2419 m_sentences.Add("CD");
2420 m_sentences.Sort();
2421 m_clbSentences->Clear();
2422 m_clbSentences->InsertItems(m_sentences, 0);
2423
2424 wxArrayString new_strings;
2425
2426 if (list.Count() == 0) {
2427 for (size_t i = 0; i < m_clbSentences->GetCount(); ++i)
2428 m_clbSentences->Check(i, m_type == WHITELIST);
2429 } else {
2430 for (size_t i = 0; i < list.Count(); ++i) {
2431 int item = m_clbSentences->FindString(list[i]);
2432 if (item != wxNOT_FOUND)
2433 m_clbSentences->Check(item);
2434 else
2435 new_strings.Add(list[i]);
2436 }
2437 if (new_strings.GetCount()) {
2438 m_clbSentences->InsertItems(new_strings, m_clbSentences->GetCount());
2439 for (size_t i = 0; i < new_strings.GetCount(); ++i) {
2440 int item = m_clbSentences->FindString(new_strings[i]);
2441 if (item != wxNOT_FOUND) m_clbSentences->Check(item);
2442 }
2443 }
2444 }
2445}
2446
2447wxString SentenceListDlg::GetSentences(void) {
2448 wxArrayString retString;
2449 for (size_t i = 0; i < m_clbSentences->GetCount(); i++) {
2450 if (m_clbSentences->IsChecked(i))
2451 retString.Add(m_clbSentences->GetString(i));
2452 }
2453 return StringArrayToString(retString);
2454}
2455
2456void SentenceListDlg::OnCLBSelect(wxCommandEvent& e) {
2457 // Only activate the "Delete" button if the selection is not in the standard
2458 // list
2459 m_btnDel->Enable(m_sentences.Index(e.GetString()) == wxNOT_FOUND);
2460}
2461
2462void SentenceListDlg::OnAddClick(wxCommandEvent& event) {
2463#ifdef __ANDROID__
2464 androidDisableRotation();
2465#endif
2466
2467 wxTextEntryDialog textdlg(
2468 this,
2469 _("Enter the NMEA sentence (2, 3 or 5 characters)\n or a valid REGEX "
2470 "expression (6 characters or longer)"),
2471 _("Enter the NMEA sentence"));
2472
2473 textdlg.SetTextValidator(wxFILTER_ASCII);
2474 int result = textdlg.ShowModal();
2475
2476#ifdef __ANDROID__
2477 androidEnableRotation();
2478#endif
2479
2480 if (result == wxID_CANCEL) return;
2481 wxString stc = textdlg.GetValue();
2482
2483 if (stc.Length() == 2 || stc.Length() == 3 || stc.Length() == 5) {
2484 m_clbSentences->Append(stc);
2485 m_clbSentences->Check(m_clbSentences->FindString(stc));
2486 return;
2487 } else if (stc.Length() < 2) {
2488 OCPNMessageBox(
2489 this,
2490 _("An NMEA sentence is generally 3 characters long (like RMC, GGA etc.)\n \
2491 It can also have a two letter prefix identifying the source, or TALKER, of the message.\n \
2492 The whole sentences then looks like GPGGA or AITXT.\n \
2493 You may filter out all the sentences with certain TALKER prefix (like GP, AI etc.).\n \
2494 The filter also accepts Regular Expressions (REGEX) with 6 or more characters. \n\n"),
2495 _("OpenCPN Info"));
2496 return;
2497 }
2498
2499 else {
2500 // Verify that a longer text entry is a valid RegEx
2501 wxRegEx r(stc);
2502 if (r.IsValid()) {
2503 m_clbSentences->Append(stc);
2504 m_clbSentences->Check(m_clbSentences->FindString(stc));
2505 return;
2506 } else {
2507 OCPNMessageBox(this, _("REGEX syntax error: \n") + stc,
2508 _("OpenCPN Info"));
2509 return;
2510 }
2511 }
2512}
2513
2514void SentenceListDlg::OnDeleteClick(wxCommandEvent& event) {
2515 m_clbSentences->Delete(m_clbSentences->GetSelection());
2516}
2517
2518void SentenceListDlg::OnClearAllClick(wxCommandEvent& event) {
2519 for (size_t i = 0; i < m_clbSentences->GetCount(); i++)
2520 m_clbSentences->Check(i, FALSE);
2521}
2522
2523void SentenceListDlg::OnCheckAllClick(wxCommandEvent& event) {
2524 for (size_t i = 0; i < m_clbSentences->GetCount(); i++)
2525 m_clbSentences->Check(i, TRUE);
2526}
ConnectionParamsPanel
Panel for displaying and editing connection parameters.
Definition conn_params_panel.h:44
ExpandableIcon
Simple panel showing either an "expand" or "collapse" icon, state switches when clicked.
Definition expand_icon.h:35
OCPNPlatform
Provides platform-specific support utilities for OpenCPN.
Definition OCPNPlatform.h:76
ObsListener::Init
void Init(const KeyProvider &kp, std::function< void(ObservedEvt &ev)> action)
Initiate an object yet not listening.
Definition observable.h:255
ObservedEvt
Custom event class for OpenCPN's notification system.
Definition ocpn_plugin.h:5811
connection_edit.h
Dialog and support code for editing a connection.
gui_lib.h
General purpose GUI support.
ocpn::split
std::vector< std::string > split(const char *token_string, const std::string &delimiter)
Return vector of items in s separated by delimiter.
Definition ocpn_utils.cpp:55
ocpn::trim
std::string trim(std::string s)
Strip possibly trailing and/or leading space characters in s.
Definition ocpn_utils.cpp:113
ocpn_plugin.h
PlugIn Object Definition/API.
ocpn_utils.h
Miscellaneous utilities, many of which string related.
sys_events.h
Suspend/resume and new devices events exchange point.
CheckSerialAccess
bool CheckSerialAccess(wxWindow *parent, const std::string device)
Run checks and possible dialogs to ensure device is accessible.
Definition udev_rule_mgr.cpp:59
udev_rule_mgr.h
Access checks for comm devices and dongle.