OpenCPN Partial API docs
Loading...
Searching...
No Matches
connection_edit.cpp
Go to the documentation of this file.
1/**************************************************************************
2 * Copyright (C) 2022 by David S. Register *
3 * Copyright (C) 2062 Alec Leamas *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, see <https://www.gnu.org/licenses/>. *
17 **************************************************************************/
18
24
25#include <functional>
26#include <memory>
27#include <set>
28#include <stdexcept>
29#include <string>
30#include <utility>
31#include <vector>
32
33#ifndef WX_PRECOMP
34#include <wx/wx.h>
35#endif
36
37#include <wx/arrstr.h>
38#include <wx/button.h>
39#include <wx/checkbox.h>
40#include <wx/combobox.h>
41#include <wx/choice.h>
42#include <wx/event.h>
43#include <wx/log.h>
44#include <wx/panel.h>
45#include <wx/platinfo.h>
46#include <wx/radiobut.h>
47#include <wx/sizer.h>
48#include <wx/statline.h>
49#include <wx/stattext.h>
50#include <wx/string.h>
51#include <wx/textctrl.h>
52#include <wx/timer.h>
53#include <wx/weakref.h>
54#include <wx/window.h>
55#include <wx/wrapsizer.h>
56
57#if defined(__linux__) && !defined(__ANDROID__)
58#include <linux/can.h>
59#include <net/if.h>
60#include <sys/ioctl.h>
61#include <sys/socket.h>
62#include "dnet.h"
63#endif
64
65#ifdef __ANDROID__
66#include "androidUTIL.h"
67#include "qdebug.h"
68#endif
69
70#include "connection_edit.h"
71#include "conn_edit_commons.h"
72
73#include "libgui/expand_panel.h"
74
75#include "model/conn_params.h"
76
77#include "conn_params_panel.h"
78#include "filter_sentence_dlg.h"
79#include "ocpn_platform.h"
80#include "options.h"
81#include "udev_rule_mgr.h"
82
83// Make _() return std::string instead of wxString;
84#undef _
85#if wxCHECK_VERSION(3, 2, 0)
86#define _(s) wxGetTranslation(wxASCII_STR(s)).ToStdString()
87#else
88#define _(s) wxGetTranslation((s)).ToStdString()
89#endif
90
91#ifdef __ANDROID__
92static bool IsAndroid() { return true; }
93#else
94static bool IsAndroid() { return false; }
95#endif
96
97static bool IsWindows() {
98 return wxPlatformInfo::Get().GetOperatingSystemId() & wxOS_WINDOWS;
99}
100
101static bool IsApple() {
102 return wxPlatformInfo::Get().GetOperatingSystemId() & wxOS_MAC_OS;
103}
104
105static bool IsLinux() {
106 return wxPlatformInfo::Get().GetOperatingSystemId() & wxOS_UNIX_LINUX;
107}
108
109/*--------------------------------------*/
110namespace conn_edit {
111
112// CanConfigPanel global scope support
113#if defined(__linux__) && !defined(__ANDROID__)
114intf_t* intf;
115std::vector<std::string> can_if_candidates;
116#endif
117
119class GarminCheckBoxImpl : public wxCheckBox, public Reloadable<wxCheckBox> {
120public:
121 GarminCheckBoxImpl(wxWindow* parent, ConnectionParams& params)
122 : wxCheckBox(parent, wxID_ANY, _("Use Garmin (GRMN) mode for input")),
123 m_params(params) {
125 Bind(wxEVT_CHECKBOX, [&](wxCommandEvent& ev) {
126 m_params.is_garmin = GetValue();
127 ev.Skip();
128 });
129 }
130
131 void Reload() override { SetValue(m_params.is_garmin); }
132
133private:
134 ConnectionParams& m_params;
135};
136
138class CommentText : public wxTextCtrl, public Reloadable<wxTextCtrl> {
139public:
140 CommentText(wxWindow* parent, wxString& comment)
141 : wxTextCtrl(parent, wxID_ANY), m_comment(comment) {
143 Bind(wxEVT_TEXT, [&](wxCommandEvent& e) { m_comment = GetValue(); });
144 }
145
146 void Reload() override { SetValue(m_comment); }
147
148private:
149 wxString& m_comment;
150};
151
156class TypeButtons : public wxPanel, public Reloadable<wxPanel> {
157public:
158 TypeButtons(wxWindow* parent, std::function<void(ConnectionType)> on_click,
159 ConnectionParams& params)
160 : wxPanel(parent, wxID_ANY),
161 m_serial_btn(new wxRadioButton(this, wxID_ANY, _("Serial"))),
162 m_net_btn(new wxRadioButton(this, wxID_ANY, _("Network"))),
163 m_can_btn(nullptr),
164 m_canable_btn(nullptr),
165 m_internal_gps_btn(nullptr),
166 m_internal_bt_btn(nullptr),
167 m_on_click(std::move(on_click)),
168 m_params(params) {
169
170#ifdef _MSC_VER
171 // Wrapsizer seems broken on win64/wxw 3.3.4
172 auto wbox = new wxBoxSizer(wxHORIZONTAL);
173#else
174 auto wbox = new wxWrapSizer(wxHORIZONTAL);
175#endif
176 auto on_clicked = [&](wxCommandEvent& e) { OnClick(e); };
177 m_serial_btn->Bind(wxEVT_RADIOBUTTON, on_clicked);
178 wbox->Add(m_serial_btn, wxSizerFlags().Border());
179
180 m_net_btn->Bind(wxEVT_RADIOBUTTON, on_clicked);
181 wbox->Add(m_net_btn, wxSizerFlags().Border());
182
183 if (IsLinux()) {
184 m_can_btn = new wxRadioButton(this, wxID_ANY, _("socketCAN"));
185 m_can_btn->Bind(wxEVT_RADIOBUTTON, on_clicked);
186 wbox->Add(m_can_btn, wxSizerFlags().Border());
187 }
188 if (IsWindows()) {
189 m_canable_btn = new wxRadioButton(this, wxID_ANY, _("Canable (SLCAN)"));
190 m_canable_btn->Bind(wxEVT_RADIOBUTTON, on_clicked);
191 wbox->Add(m_canable_btn, wxSizerFlags().Border());
192 }
193 if (OCPNPlatform::hasInternalGPS()) {
194 m_internal_gps_btn = new wxRadioButton(this, wxID_ANY, _("Internal GPS"));
195 m_internal_gps_btn->Bind(wxEVT_RADIOBUTTON, on_clicked);
196 wbox->Add(m_internal_gps_btn, wxSizerFlags().Border());
197 }
198 if (OCPNPlatform::hasInternalBT()) {
199 m_internal_bt_btn =
200 new wxRadioButton(this, wxID_ANY, _("Internal Bluetooth"));
201 m_internal_bt_btn->Bind(wxEVT_RADIOBUTTON, on_clicked);
202 wbox->Add(m_internal_bt_btn, wxSizerFlags().Border());
203 }
204 SetSelectedType(ConnectionType::SERIAL);
205
206 SetSizer(wbox);
207 wbox->Layout();
208 }
209
210 void Reload() override { SetSelectedType(m_params.type); }
211
212 void SetSelectedType(ConnectionType type) {
213 switch (type) {
214 case ConnectionType::NETWORK:
215 m_net_btn->SetValue(true);
216 break;
217 case ConnectionType::SERIAL:
218 m_serial_btn->SetValue(true);
219 break;
220 case ConnectionType::SOCKETCAN:
221 m_can_btn->SetValue(true);
222 break;
223 case ConnectionType::CANABLE:
224 if (m_canable_btn) m_canable_btn->SetValue(true);
225 break;
226 case ConnectionType::INTERNAL_GPS:
227 if (m_internal_gps_btn) m_internal_gps_btn->SetValue(true);
228 break;
229 case ConnectionType::INTERNAL_BT:
230 if (m_internal_bt_btn) m_internal_bt_btn->SetValue(true);
231 break;
232 default:
233 assert(false && "Illegal connection type");
234 }
235 }
236
237private:
238 wxRadioButton* m_serial_btn;
239 wxRadioButton* m_net_btn;
240 wxRadioButton* m_can_btn;
241 wxRadioButton* m_canable_btn;
242 wxRadioButton* m_internal_gps_btn;
243 wxRadioButton* m_internal_bt_btn;
244 std::function<void(ConnectionType)> m_on_click;
245 ConnectionParams& m_params;
246
247 [[nodiscard]] ConnectionType GetSelectedType() const {
248 if (m_serial_btn->GetValue()) return ConnectionType::SERIAL;
249 if (m_net_btn->GetValue()) return ConnectionType::NETWORK;
250 if (m_can_btn && m_can_btn->GetValue()) return ConnectionType::SOCKETCAN;
251 if (m_canable_btn && m_canable_btn->GetValue())
252 return ConnectionType::CANABLE;
253 if (m_internal_gps_btn && m_internal_gps_btn->GetValue())
254 return ConnectionType::INTERNAL_GPS;
255 if (m_internal_bt_btn && m_internal_bt_btn->GetValue())
256 return ConnectionType::INTERNAL_BT;
257 assert(false && "No connection type radiobutton active(!)");
258 return ConnectionType::UNKNOWN;
259 }
260
261 void OnClick(wxCommandEvent& e) {
262 auto type = GetSelectedType();
263 m_params.type = type;
264 m_on_click(type);
265 e.Skip();
266 }
267};
268
270class InternalBtConfigPanel : public wxPanel, public Reloadable<wxPanel> {
271 class ScanTimer : public wxTimer {
272 public:
273 ScanTimer() : m_owner(nullptr) {}
274
275 void SetOwner(InternalBtConfigPanel* owner) { m_owner = owner; }
276
277 void Notify() override {
278 if (m_owner.get()) m_owner->OnTimer();
279 }
280
281 private:
282 wxWeakRef<InternalBtConfigPanel> m_owner;
283 };
284
285 class AdvancedPanel : public wxPanel {
286 public:
287 AdvancedPanel(wxWindow* parent, ConnectionParams& params)
288 : wxPanel(parent, wxID_ANY), m_params(params) {
289 auto vbox = new wxBoxSizer(wxVERTICAL);
290 auto flags = wxSizerFlags();
291 vbox->Add(new GarminCheckBoxImpl(this, m_params), flags);
292 vbox->Add(FilterConfigPanel::Create(this, m_params), flags);
293 SetSizer(vbox);
294 wxWindowBase::Layout();
295 }
296
297 private:
298 ConnectionParams& m_params;
299 };
300
301public:
302 InternalBtConfigPanel(wxWindow* parent, ConnectionParams& params)
303 : wxPanel(parent, wxID_ANY),
304 m_params(params),
305 m_bt_scanning(0),
306 m_bt_no_change_counter(0),
307 m_bt_last_result_count(0) {
308 auto vbox = new wxBoxSizer(wxVERTICAL);
309 auto flags = wxSizerFlags().Border();
310
311 vbox->Add(new wxStaticText(this, wxID_ANY, _("Bluetooth Data Sources")),
312 flags);
313
314 auto src_box = new wxBoxSizer(wxHORIZONTAL);
315 m_src_choice = new wxChoice(this, wxID_ANY);
316 m_src_choice->Append("unscanned");
317 m_src_choice->SetSelection(0);
318 m_scan_btn = new wxButton(this, wxID_ANY, _("Scan"));
319 m_scan_btn->Bind(wxEVT_BUTTON, [&](wxCommandEvent& e) { OnClick(e); });
320 src_box->Add(m_src_choice, flags);
321 src_box->Add(m_scan_btn, flags);
322 vbox->Add(src_box, flags);
323 vbox->Add(conn_edit::InputOutputPanel::Create(this, m_params));
324
325 auto advanced_panel = new AdvancedPanel(this, m_params);
326 auto adv_box = new wxBoxSizer(wxHORIZONTAL);
327 // if (IsWindows()) flags = flags.ReserveSpaceEvenIfHidden();
328 adv_box->Add(new wxStaticText(this, wxID_ANY, _("Advanced")), flags);
329 auto on_expand_click = [&] {
330 Layout();
331 FitInside();
332 };
333 adv_box->Add(new ExpandablePanel(this, advanced_panel, on_expand_click),
334 flags);
335 vbox->Add(adv_box, flags);
336 vbox->Add(advanced_panel, flags);
337
338 SetSizer(vbox);
339 m_scan_timer.SetOwner(this);
340 }
341
342 ~InternalBtConfigPanel() override { m_scan_timer.Stop(); }
343
344 void Reload() override {
345 if (m_params.type == ConnectionType::INTERNAL_BT) SetFixedParams();
346 }
347
348private:
349 ScanTimer m_scan_timer;
350 ConnectionParams& m_params;
351 wxButton* m_scan_btn;
352 wxChoice* m_src_choice;
353 int m_bt_scanning;
354 int m_bt_no_change_counter;
355 wxArrayString m_bt_scan_results;
356 int m_bt_last_result_count;
357
359 void SetFixedParams() {
360 m_params.direction = PortDirection::kInOut;
361 m_params.network_address = "";
362 m_params.network_port = 0;
363 m_params.net_protocol = PROTO_UNDEFINED;
364 m_params.baudrate = 0;
365 }
366
367 void OnClick(wxCommandEvent&) {
368 if (m_bt_scanning)
369 StopScan();
370 else {
371 m_bt_no_change_counter = 0;
372 m_bt_last_result_count = 0;
373 m_scan_timer.Start(1000, wxTIMER_CONTINUOUS);
374 g_Platform->startBluetoothScan();
375 m_bt_scanning = 1;
376 if (m_scan_btn) {
377 m_scan_btn->SetLabel(_("Stop Scan"));
378 }
379 }
380 }
381
382 void OnTimer() {
383 if (!m_bt_scanning) return;
384 m_bt_scanning++;
385 m_bt_scan_results = g_Platform->getBluetoothScanResults();
386
387 m_src_choice->Clear();
388 m_src_choice->Append(m_bt_scan_results[0]); // scan status
389
390 unsigned i = 1;
391 while ((i + 1) < m_bt_scan_results.GetCount()) {
392 wxString item1 = m_bt_scan_results[i] + ";";
393 wxString item2 = m_bt_scan_results.Item(i + 1);
394 m_src_choice->Append(item1 + item2);
395 i += 2;
396 }
397
398 if (m_bt_scan_results.GetCount() > 1) {
399 m_src_choice->SetSelection(1);
400 }
401
402 // Watch for changes. When no changes occur after n seconds, stop the
403 // scan
404 if (m_bt_no_change_counter > 5) StopScan();
405 int count = static_cast<int>(m_bt_scan_results.GetCount());
406 if (count == m_bt_last_result_count)
407 m_bt_no_change_counter++;
408 else
409 m_bt_no_change_counter = 0;
410 m_bt_last_result_count = static_cast<int>(m_bt_scan_results.GetCount());
411
412 // Absolute fallback
413 if (m_bt_scanning >= 15) {
414 StopScan();
415 }
416 }
417
418 void StopScan() {
419 m_scan_timer.Stop();
420 g_Platform->stopBluetoothScan();
421 m_bt_scanning = 0;
422 if (m_scan_btn) {
423 m_scan_btn->SetLabel(_("BT Scan"));
424 m_scan_btn->Enable();
425 }
426 }
427};
428
430class InternalGpsConfigPanel : public wxPanel, public Reloadable<wxPanel> {
431public:
432 InternalGpsConfigPanel(wxWindow* parent, ConnectionParams& params)
433 : wxPanel(parent, wxID_ANY), m_params(params) {
434 auto checkbox = new wxCheckBox(this, wxID_ANY, _("Use internal GPS"));
435 checkbox->SetValue(true);
436 checkbox->Disable();
437
438 auto vbox = new wxBoxSizer(wxVERTICAL);
439 vbox->Add(checkbox);
440 auto top_box = new wxBoxSizer(wxVERTICAL);
441 top_box->Add(vbox, wxSizerFlags().Border());
442 SetSizer(top_box);
443 wxWindowBase::Layout();
444 SetParams();
445 }
446
447 void Reload() override {
448 if (m_params.type == ConnectionType ::INTERNAL_GPS) SetParams();
449 }
450
451private:
452 ConnectionParams& m_params;
453
454 void SetParams() {
455 m_params.network_address = "";
456 m_params.network_port = 0;
457 m_params.net_protocol = PROTO_UNDEFINED;
458 m_params.baudrate = 0;
459 m_params.serial_port = "Internal GPS";
460 }
461}; // InternalGpsConfigPanel
462
464class CanableConfigPanel : public wxPanel, public Reloadable<wxPanel> {
465
467 static void SetFixedParams(ConnectionParams& params) {
468 params.data_protocol = PROTO_NMEA2000;
469 params.direction = PortDirection::kInOut;
470 params.network_address = "";
471 params.network_port = 0;
472 params.net_protocol = PROTO_UNDEFINED;
473 params.baudrate = 0;
474 }
475
476public:
477 CanableConfigPanel(wxWindow* parent, ConnectionParams& params)
478 : wxPanel(parent, wxID_ANY), m_params(params) {
479 auto* grid_sizer = new wxFlexGridSizer(2, wxWindow::GetCharHeight() / 2, 0);
480 auto label_flags = wxSizerFlags().Border();
481#if wxCHECK_VERSION(3, 2, 0)
482 label_flags = label_flags.CentreVertical();
483#endif
484 auto ctrl_flags = wxSizerFlags(1).Expand();
485 grid_sizer->Add(new wxStaticText(this, wxID_ANY, _("Data source")),
486 label_flags);
487 auto port_text_ctrl = PortCombo::Create(this, m_params.serial_port);
488 port_text_ctrl->SetMinSize(wxSize(50 * wxWindow::GetCharWidth(), -1));
489 grid_sizer->Add(port_text_ctrl, ctrl_flags);
490 grid_sizer->Add(new wxStaticText(this, wxID_ANY, "User comment"),
491 label_flags);
492 grid_sizer->Add(new CommentText(this, m_params.user_comment), ctrl_flags);
493
494 auto vbox = new wxBoxSizer(wxVERTICAL);
495 vbox->Add(grid_sizer, wxSizerFlags().Border());
496 SetSizer(vbox);
497
498 wxWindowBase::Layout();
499 }
500
501 void Reload() override {
502 if (m_params.type == ConnectionType::CANABLE) SetFixedParams(m_params);
503 }
504
505private:
506 ConnectionParams& m_params;
507
508}; // CanableConfigPanel
509
511class SerialConfigPanel : public wxPanel, public Reloadable<wxPanel> {
512
514 class BaudChoice : public wxComboBox, public Reloadable {
515 public:
516 BaudChoice(wxWindow* parent, int& baudrate)
517 : wxComboBox(parent, wxID_ANY), m_baudrate(baudrate) {
519 Bind(wxEVT_COMBOBOX, [&](wxCommandEvent& e) { OnChange(e); });
520 };
521
522 void Reload() override { LoadBaudrates(); }
523
524 private:
525 int& m_baudrate;
526
527 void LoadBaudrates() {
528 static const std::vector<std::string> speeds = {
529 "150", "300", "600", "1200", "2400", "4800", "9600",
530 "19200", "38400", "57600", "115200", "230400", "460800", "921600"};
531 Clear();
532 for (const auto& speed : speeds) Append(speed);
533 auto found = FindString(std::to_string(m_baudrate));
534 if (found != wxNOT_FOUND)
535 SetSelection(found);
536 else
537 SetSelection(5); // 4800
538 }
539
540 void OnChange(wxCommandEvent& e) {
541 std::string speed = GetStringSelection().ToStdString();
542 try {
543 m_baudrate = std::stoi(speed);
544 } catch (std::logic_error&) {
545 assert(false && "Cannot parse preconfigured baudrate");
546 }
547 e.Skip();
548 }
549 }; // BaudChoice
550
551 class SerialParamsGrid : public wxFlexGridSizer {
552 public:
553 SerialParamsGrid(wxWindow* parent, ConnectionParams& params)
554 : wxFlexGridSizer(2), m_params(params) {
555 AddGrowableCol(1);
556 auto flags = wxSizerFlags().Border();
557 auto text_flags = wxSizerFlags().Border();
558#if wxCHECK_VERSION(3, 2, 0)
559 text_flags = text_flags.CentreVertical();
560#endif
561 Add(new wxStaticText(parent, wxID_ANY, _("Data port")), text_flags);
562 Add(PortCombo::Create(parent, m_params.serial_port), flags);
563 Add(new wxStaticText(parent, wxID_ANY, _("Baudrate")), text_flags);
564 Add(new BaudChoice(parent, m_params.baudrate), flags);
565 Add(new wxStaticText(parent, wxID_ANY, _("Protocol")), text_flags);
566 Add(ProtocolChoice::Create(parent, m_params), flags);
567 Add(new wxStaticText(parent, wxID_ANY, _("User Comment")), text_flags);
568 Add(new CommentText(parent, m_params.user_comment),
569 wxSizerFlags(1).Border().Expand());
570 }
571
572 private:
573 ConnectionParams& m_params;
574 }; // SerialParamsGrid
575
576 class GridPanel : public wxPanel {
577 public:
578 GridPanel(wxWindow* parent, ConnectionParams& params)
579 : wxPanel(parent, wxID_ANY),
580 m_params(params),
581 m_grid(new SerialParamsGrid(this, m_params)) {
582 SetSizer(m_grid);
583 wxWindow::Layout();
584 }
585
586 private:
587 ConnectionParams& m_params;
588 SerialParamsGrid* m_grid;
589 };
590
592 class AdvancedPanel : public wxPanel {
593 public:
594 AdvancedPanel(wxWindow* parent, ConnectionParams& params)
595 : wxPanel(parent, wxID_ANY), m_params(params) {
596 auto vbox = new wxBoxSizer(wxVERTICAL);
597 auto flags = wxSizerFlags().Border();
598 vbox->Add(new GarminCheckBoxImpl(this, m_params), flags);
599 vbox->Add(FilterConfigPanel::Create(this, m_params), flags);
600 SetSizer(vbox);
601 wxWindowBase::Layout();
602 }
603
604 private:
605 ConnectionParams& m_params;
606 };
607
608public:
609 SerialConfigPanel(wxWindow* parent, ConnectionParams& params)
610 : wxPanel(parent), m_params(params) {
611 auto flags = wxSizerFlags().Border();
612 m_grid = new GridPanel(this, params);
613
614 m_advanced_panel = new AdvancedPanel(this, params);
615 auto advanced_ctrl = new ExpandablePanel(this, m_advanced_panel, [&] {
616 GetParent()->Layout();
617 FitInside();
618 });
619 auto hbox = new wxBoxSizer(wxHORIZONTAL);
620 // if (IsWindows()) flags = flags.ReserveSpaceEvenIfHidden();
621 hbox->Add(new wxStaticText(this, wxID_ANY, _("Advanced")), flags);
622 hbox->Add(advanced_ctrl, flags);
623
624 auto vbox = new wxBoxSizer(wxVERTICAL);
625 vbox->Add(m_grid, wxSizerFlags().Border().Expand());
626 vbox->Add(InputOutputPanel::Create(this, params), flags);
627 vbox->Add(hbox, flags);
628 vbox->Add(m_advanced_panel, flags);
629 SetSizer(vbox);
630 wxWindow::Layout();
631 wxWindow::Show();
632 }
633
634 void Reload() override {
635 if (m_params.type != ConnectionType::SERIAL) return;
636 if (m_params.net_protocol != NetworkProtocol::PROTO_UNDEFINED) return;
637
638 m_params.net_protocol = NetworkProtocol::TCP;
639 m_params.data_protocol = PROTO_NMEA0183;
640 m_params.direction = PortDirection::kInput;
641 m_params.network_address = "";
642 m_params.network_port = 0;
643 }
644
650 [[nodiscard]] bool CheckStatus() {
651 return CheckSerialAccess(this, m_params.serial_port.ToStdString());
652 }
653
654private:
655 ConnectionParams& m_params;
656 wxWindow* m_advanced_panel;
657 GridPanel* m_grid;
658}; // SerialConfigPanel
659
661class CanConfigPanel : public wxPanel {
662 class CanChoice : public wxChoice, public Reloadable<wxChoice> {
663 public:
664 CanChoice(wxWindow* parent, ConnectionParams& params)
665 : wxChoice(parent, wxID_ANY), m_params(params) {
667 Bind(wxEVT_CHOICE, [&](wxCommandEvent& e) {
668 m_params.socket_can_port = GetStringSelection();
669 e.Skip();
670 });
671 };
672
673 void Reload() override {
674 Clear();
675 Enable();
676 for (const auto& port : GetAvailableSocketCanInterfaces()) Append(port);
677 if (GetCount() == 0) {
678 Append("No source available");
679 SetSelection(0);
680 Disable();
681 } else {
682 int found = FindString(m_params.socket_can_port);
683 SetSelection(found != wxNOT_FOUND ? found : 0);
684 }
685 }
686
687 private:
688 ConnectionParams& m_params;
689
690 // Check available SocketCAN interfaces, empty list if not linux
691#if !defined(__linux__) || defined(__ANDROID__)
692 std::vector<std::string> GetAvailableSocketCanInterfaces() {
693 return {{}};
694 }
695#else
696 static int print_intf(const struct intf_entry* entry, void*) {
697 std::string iface = entry->intf_name;
698 if (entry->intf_type == 1 && iface.find("can") != std::string::npos) {
699 can_if_candidates.emplace_back(entry->intf_name);
700 }
701 return 0;
702 }
703
704 static std::vector<std::string> GetAvailableSocketCanInterfaces() {
705 std::vector<std::string> rv;
706 can_if_candidates.clear();
707
708 if ((intf = intf_open()) == nullptr) {
709 wxLogWarning("Error opening interface list");
710 return rv;
711 }
712 if (intf_loop(intf, print_intf, nullptr) < 0) {
713 wxLogWarning("Error looping over interface list");
714 }
715 intf_close(intf);
716
717 for (const auto& iface : can_if_candidates) {
718 int sock = socket(PF_CAN, SOCK_RAW, CAN_RAW);
719 if (sock < 0) continue;
720
721 // Get the interface index
722 ifreq if_request = {{0}};
723 strcpy(if_request.ifr_name, iface.c_str());
724 if (ioctl(sock, SIOCGIFINDEX, &if_request) < 0) continue;
725
726 // Check if interface is UP.
727 sockaddr_can can_address = {0};
728 can_address.can_family = AF_CAN;
729 can_address.can_ifindex = if_request.ifr_ifindex;
730 if (ioctl(sock, SIOCGIFFLAGS, &if_request) < 0) continue;
731
732 if (if_request.ifr_flags & IFF_UP) rv.push_back(iface);
733 }
734 return rv;
735 }
736#endif // !defined(__linux__) || defined(__ANDROID__)
737 };
738
739public:
740 CanConfigPanel(wxWindow* parent, ConnectionParams& params)
741 : wxPanel(parent), m_params(params) {
742 auto hbox = new wxBoxSizer(wxHORIZONTAL);
743 auto flags = wxSizerFlags().Border();
744 hbox->Add(new wxStaticText(this, wxID_ANY, "Socketcan source"), flags);
745 m_choice = new CanChoice(this, m_params);
746 m_choice->Append("foobar");
747 hbox->Add(m_choice, wxSizerFlags().Border());
748 SetSizer(hbox);
749 wxWindow::Layout();
750 wxWindow::Show();
751 }
752
753private:
754 ConnectionParams& m_params;
755 wxChoice* m_choice;
756}; // CanConfigPanel
757
758class ConfigPanel : public wxScrolledWindow {
759public:
760 ConfigPanel(wxWindow* parent, ConnectionParams& params)
761 : wxScrolledWindow(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize,
762 wxVSCROLL | wxHSCROLL),
763 m_params(params) {
764 auto flags = wxSizerFlags(0).Expand();
765 auto vbox = new wxBoxSizer(wxVERTICAL);
766 m_serial_config_panel = new SerialConfigPanel(this, m_params);
767 vbox->Add(m_serial_config_panel, flags);
768 m_net_config_panel = conn_edit::NetConfigPanel::Create(this, m_params);
769 vbox->Add(m_net_config_panel, flags);
770 m_can_config_panel = new CanConfigPanel(this, m_params);
771 vbox->Add(m_can_config_panel, flags);
772 m_canable_config_panel = new CanableConfigPanel(this, m_params);
773 vbox->Add(m_canable_config_panel, flags);
774 m_internal_gps_config_panel = new InternalGpsConfigPanel(this, m_params);
775 vbox->Add(m_internal_gps_config_panel, flags);
776 m_internal_bt_config_panel = new InternalBtConfigPanel(this, m_params);
777 vbox->Add(m_internal_bt_config_panel, flags);
778
779 vbox->Show(m_serial_config_panel, false);
780 vbox->Show(m_net_config_panel, false);
781 vbox->Show(m_can_config_panel, false);
782 vbox->Show(m_canable_config_panel, false);
783 vbox->Show(m_internal_gps_config_panel, false);
784 vbox->Show(m_internal_bt_config_panel, false);
785
786 SetSizer(vbox);
787 SetScrollRate(10, 10);
788 SetActivePanel(ConnectionType::SERIAL);
789 wxScrolled<wxPanel>::Layout();
790 wxWindowBase::FitInside();
791 }
792
793 ~ConfigPanel() override = default;
794
795 void SetActivePanel(ConnectionType type) {
796 m_net_config_panel->Show(type == ConnectionType::NETWORK);
797 m_can_config_panel->Show(type == ConnectionType::SOCKETCAN);
798 m_serial_config_panel->Show(type == ConnectionType::SERIAL);
799 m_canable_config_panel->Show(type == ConnectionType::CANABLE);
800 m_internal_gps_config_panel->Show(type == ConnectionType::INTERNAL_GPS);
801 m_internal_bt_config_panel->Show(type == ConnectionType::INTERNAL_BT);
802 Layout();
803 FitInside();
804 }
805
806 bool CheckStatus() {
807 if (m_serial_config_panel->IsShown())
808 return m_serial_config_panel->CheckStatus();
809 if (m_net_config_panel->IsShown()) return m_net_config_panel->CheckStatus();
810 return true;
811 }
812
813private:
814 ConnectionParams& m_params;
815 NetConfigPanel* m_net_config_panel;
816 CanConfigPanel* m_can_config_panel;
817 CanableConfigPanel* m_canable_config_panel;
818 InternalGpsConfigPanel* m_internal_gps_config_panel;
819 InternalBtConfigPanel* m_internal_bt_config_panel;
820 SerialConfigPanel* m_serial_config_panel;
821};
822
823} // namespace conn_edit
824
825class ConnectionEditDlg : public AbstractConnectionEditDlg {
826 class ButtonSizer : public wxStdDialogButtonSizer {
827 public:
828 ButtonSizer(wxWindow* parent, std::function<void(wxCommandEvent&)> on_ok,
829 std::function<void(wxCommandEvent&)> on_cancel)
830 : wxStdDialogButtonSizer(),
831 m_on_ok(std::move(on_ok)),
832 m_on_cancel(std::move(on_cancel)) {
833 auto ok_btn = new wxButton(parent, wxID_OK);
834 ok_btn->Bind(wxEVT_BUTTON, [&](wxCommandEvent& ev) { m_on_ok(ev); });
835 AddButton(ok_btn);
836 auto cancel_btn = new wxButton(parent, wxID_CANCEL);
837 cancel_btn->Bind(wxEVT_BUTTON,
838 [&](wxCommandEvent& ev) { m_on_cancel(ev); });
839 AddButton(cancel_btn);
840 SetAffirmativeButton(ok_btn);
841 Realize();
842 }
843
844 private:
845 std::function<void(wxCommandEvent&)> m_on_ok;
846 std::function<void(wxCommandEvent&)> m_on_cancel;
847 };
848
849public:
850 explicit ConnectionEditDlg(wxWindow* parent, std::function<void()> on_cancel,
851 ConnEditCallback on_ok)
852 : AbstractConnectionEditDlg(parent),
853 m_on_ok(std::move(on_ok)),
854 m_on_cancel(std::move(on_cancel)),
855 m_params(GetDefaultParams()),
856 m_is_new(true) {
857 auto vbox = new wxBoxSizer(wxVERTICAL);
858 auto statbox = new wxStaticBoxSizer(wxVERTICAL, this, _("Edit connection"));
859 auto on_type_btn_click = [&](ConnectionType ct) { OnTypeBtnClick(ct); };
860 auto flags = wxSizerFlags().Border();
861 m_type_buttons =
862 new conn_edit::TypeButtons(this, on_type_btn_click, m_params);
863 statbox->Add(m_type_buttons, wxSizerFlags().Border());
864 statbox->Add(new wxStaticLine(this), wxSizerFlags().Expand());
865 m_config_panel = new conn_edit::ConfigPanel(this, m_params);
866 statbox->Add(m_config_panel, wxSizerFlags(1).Expand());
867 vbox->Add(statbox, wxSizerFlags(1).Expand());
868
869 auto on_ok_ = [&](wxCommandEvent& ev) { OnOkCancel(ev, true); };
870 auto on_cancel_ = [&](wxCommandEvent& ev) { OnOkCancel(ev, false); };
871 auto button_sizer = new ButtonSizer(this, on_ok_, on_cancel_);
872 vbox->Add(button_sizer, flags.Expand());
873 m_type_buttons->SetSelectedType(ConnectionType::NETWORK);
874 OnTypeBtnClick(ConnectionType::NETWORK);
875
876 SetSizer(vbox);
877 wxWindow::Layout();
878 }
879
880 void Scroll(int hscroll, int vscroll) override {
881 m_config_panel->Scroll(hscroll, vscroll);
882 }
883
884 void SetParams(std::unique_ptr<ConnectionParams> p) override {
885 m_is_new = !static_cast<bool>(p);
886 m_params = p ? *p : GetDefaultParams();
887 OnTypeBtnClick(m_params.type);
888 Reload();
889 }
890
891 ConnectionParams GetEditedParams() override { return m_params; }
892
893private:
894 ConnEditCallback m_on_ok;
895 std::function<void()> m_on_cancel;
896 ConnectionParams m_params;
897
898 conn_edit::TypeButtons* m_type_buttons;
899 conn_edit::ConfigPanel* m_config_panel;
900 bool m_is_new;
901
902 static void DoReload(wxWindow* root) {
903 for (wxWindow* child : root->GetChildren()) {
904 if (auto widget = dynamic_cast<conn_edit::Reloadable<wxWindow>*>(child))
905 widget->Reload();
906 DoReload(child);
907 }
908 }
909
910 void Reload() { DoReload(this); }
911
912 void OnTypeBtnClick(ConnectionType ct) {
913 m_params.type = ct;
914 m_config_panel->SetActivePanel(ct);
915 Reload();
916 Layout();
917 }
918
919 void OnOkCancel(wxCommandEvent&, bool ok) {
920 if (!ok) {
921 m_on_cancel();
922 } else if (m_config_panel->CheckStatus()) {
923 m_on_ok(std::make_unique<ConnectionParams>(m_params), m_is_new);
924 }
925 }
926
927 static ConnectionParams GetDefaultParams() {
928 ConnectionParams cp;
929 cp.type = ConnectionType::NETWORK;
930 return cp;
931 }
932};
933
934AbstractConnectionEditDlg* AbstractConnectionEditDlg::Create(
935 wxWindow* parent, std::function<void()> on_cancel, ConnEditCallback on_ok) {
936 return new ConnectionEditDlg(parent, std::move(on_cancel), std::move(on_ok));
937}
Dialog editing existing or new connection parameters.
void SetParams(std::unique_ptr< ConnectionParams > p) override
Set parameters to use and reset dialog.
ConnectionParams GetEditedParams() override
Return edited parameters.
Connection data container close to a POD struct.
Definition conn_params.h:76
An ExpandIcon together with a child window.
Configure Linux socketcan connection.
Configure windows-only SLcan connection.
void Reload() override
Synchronize widget value(s) with parameter(s).
User comment text entry.
void Reload() override
Synchronize widget value(s) with parameter(s).
void Reload() override
Synchronize widget value(s) with parameter(s).
Configure internal bluetooth serial connection.
void Reload() override
Synchronize widget value(s) with parameter(s).
Configure internal GPS usage, usually on Android.
void Reload() override
Synchronize widget value(s) with parameter(s).
Main network configuration: TCP/UDP, client/server, etc.
Interface implemented by widgets reflecting a ConnectionParams parameter.
virtual void Reload()=0
Synchronize widget value(s) with parameter(s).
Configure serial connection port, baudrate, etc.
bool CheckStatus()
Check that user data is sane, possibly run dialogs for missing or bad input.
void Reload() override
Synchronize widget value(s) with parameter(s).
The radio buttons selecting serial, network, socketcan, etc.
void Reload() override
Synchronize widget value(s) with parameter(s).
connection_edit.cpp internal support.
Connection parameters.
Panel for editing a connection.
Dialog and support code for editing a connection.
std::function< void(std::unique_ptr< ConnectionParams >, bool editing)> ConnEditCallback
Callback invoked when user clicks OK button in dialog.
OCPNPlatform * g_Platform
Global instance.
OpenCPN Platform specific support utilities.
Options dialog.
bool CheckSerialAccess(wxWindow *parent, const std::string device)
Run checks and possible dialogs to ensure device is accessible.
Access checks for comm devices and dongle.