Rabbit Remote Control 0.1.0-bate8
Loading...
Searching...
No Matches
mainwindow.cpp
1// Author: Kang Lin <kl222@126.com>
2
3#include <QFontMetrics>
4#include <QGridLayout>
5#include <QMessageBox>
6#include <QCheckBox>
7#include <QScreen>
8#include <QApplication>
9#include <QDebug>
10#include <QDesktopServices>
11#include <QWidgetAction>
12#include <QMouseEvent>
13#include <QDrag>
14#include <QMimeData>
15#include <QKeySequence>
16#include <QPushButton>
17#include <QDateTime>
18#include <QFileDialog>
19#include <QLoggingCategory>
20#include <QThread>
21#include <QInputMethod>
22#include <QGuiApplication>
23
24#include "mainwindow.h"
25#include "ui_mainwindow.h"
26#ifdef HAVE_UPDATE
27 #include "FrmUpdater.h"
28#endif
29#include "RabbitCommonDir.h"
30#include "RabbitCommonTools.h"
31
32#ifdef HAVE_ABOUT
33 #include "DlgAbout.h"
34#endif
35#ifdef BUILD_QUIWidget
36 #include "QUIWidget/QUIWidget.h"
37#endif
38
39#include "Operate.h"
40#include "FrmFullScreenToolBar.h"
41#include "ParameterDlgSettings.h"
42
43#include "ViewTable.h"
44#include "ViewSplitter.h"
45
46#ifdef HAVE_ICE
47 #include "Ice.h"
48#endif
49
50static Q_LOGGING_CATEGORY(log, "App.MainWindow")
51static Q_LOGGING_CATEGORY(logRecord, "App.MainWindow.Record")
52
53MainWindow::MainWindow(QWidget *parent)
54 : QMainWindow(parent)
55 , m_pToolBarMenuAction(nullptr)
56 , m_pMenuActivityGroup(nullptr)
57 , m_ptbMenuActivity(nullptr)
58 , m_pActionOperateMenu(nullptr)
59 , m_pTBOperate(nullptr)
60 , m_pActionTBOperate(nullptr)
61 , m_pDockRecent(nullptr)
62 , m_pRecent(nullptr)
63 , m_pDockActive(nullptr)
64 , m_pFrmActive(nullptr)
65 , m_pSecureLevel(nullptr)
66 , m_pSignalStatus(nullptr)
67 , ui(new Ui::MainWindow)
68 , m_pView(nullptr)
69 , m_pFullScreenToolBar(nullptr)
70 , m_pRecentMenu(nullptr)
71 , m_pDockFavorite(nullptr)
72 , m_pFavoriteView(nullptr)
73 , m_StatusBarMessage(this)
74{
75 bool check = false;
76
77 ui->setupUi(this);
78 ui->menubar->show();
79
80 ui->actionKeyboard->setVisible(false);
81#if ANDROID
82 bool bVisible = (nullptr != QGuiApplication::inputMethod());
83 ui->actionKeyboard->setVisible(bVisible);
84 ui->actionKeyboard->setEnabled(bVisible);
85#endif
86
87 check = connect(&m_Manager, &CManager::sigNewOperate,
88 this, [&](COperate* pOperate, bool bOpenSettingsDialog) {
89 Start(pOperate, bOpenSettingsDialog);
90 });
91 Q_ASSERT(check);
92
93#if defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID) && !defined(Q_OS_MACOS)
94 // gnome icon isn't support svg
95 setWindowIcon(QIcon(":/images/app"));
96#endif
97
98 /*
99 QSize screenSize;
100 if(QApplication::primaryScreen()) {
101 screenSize = QApplication::primaryScreen()->availableSize();
102 //TODO: 当支持多屏幕时，修改此处
103 //screenSize = QApplication::primaryScreen()->availableVirtualSize();
104 }
105 if(!screenSize.isEmpty())
106 setMaximumSize(screenSize);
107 //*/
108
109 //m_StatusBarMessage.setSizePolicy(QSizePolicy::Policy::Expanding,
110 // QSizePolicy::Policy::Fixed);
111 //m_StatusBarMessage.setWordWrap(true);
112 this->statusBar()->addPermanentWidget(&m_StatusBarMessage);
113
114 m_SendRate.setToolTip(tr("Send rate"));
115 m_SendRate.setStatusTip(tr("Send rate"));
116 // m_SendRate.setSizePolicy(QSizePolicy::Policy::Preferred,
117 // QSizePolicy::Policy::Fixed);
118 this->statusBar()->addPermanentWidget(&m_SendRate);
119 m_ReceivesRate.setToolTip(tr("Receives rate"));
120 m_ReceivesRate.setStatusTip(tr("Receives rate"));
121 // m_ReceivesRate.setSizePolicy(QSizePolicy::Policy::Preferred,
122 // QSizePolicy::Policy::Fixed);
123 this->statusBar()->addPermanentWidget(&m_ReceivesRate);
124 m_TotalSends.setToolTip(tr("Total sends"));
125 m_TotalSends.setStatusTip(tr("Total sends"));
126 // m_TotalSends.setSizePolicy(QSizePolicy::Policy::Preferred,
127 // QSizePolicy::Policy::Fixed);
128 this->statusBar()->addPermanentWidget(&m_TotalSends);
129 m_TotalReceives.setToolTip(tr("Total receives"));
130 m_TotalReceives.setStatusTip(tr("Total receives"));
131 // m_TotalReceives.setSizePolicy(QSizePolicy::Policy::Preferred,
132 // QSizePolicy::Policy::Fixed);
133 this->statusBar()->addPermanentWidget(&m_TotalReceives);
134
135 check = connect(&m_Timer, SIGNAL(timeout()), this, SLOT(slotTimeOut()));
136 Q_ASSERT(check);
137
138 m_pSecureLevel = new QLabel(statusBar());
139 // QIcon icon = QIcon::fromTheme("network-wired");
140 // QPixmap pixmap = icon.pixmap(icon.actualSize(QSize(64, 64)));
141 // m_pSecureLevel->setPixmap(pixmap);
142 m_pSecureLevel->hide();
143 statusBar()->addPermanentWidget(m_pSecureLevel);
144
145 //setFocusPolicy(Qt::NoFocus);
146 //addToolBar(Qt::LeftToolBarArea, ui->toolBar);
147 setAcceptDrops(true);
148
149 RabbitCommon::CTools::AddStyleMenu(ui->menuTools);
150 ui->menuTools->addMenu(RabbitCommon::CTools::GetLogMenu(this));
151
152 m_pRecentMenu = new RabbitCommon::CRecentMenu(
153 tr("Recently"), QIcon::fromTheme("document-open-recent"), false, this);
154 check = connect(m_pRecentMenu, SIGNAL(recentFileTriggered(const QString&)),
155 this, SLOT(slotOpenFile(const QString&)));
156 Q_ASSERT(check);
157 check = connect(&m_Parameter, SIGNAL(sigRecentMenuMaxCountChanged(int)),
158 m_pRecentMenu, SLOT(setMaxCount(int)));
159 Q_ASSERT(check);
160 QAction* pRecentAction = ui->menuOperate->insertMenu(
161 ui->actionOpenListRecent, m_pRecentMenu);
162 pRecentAction->setStatusTip(pRecentAction->text());
163 QToolButton* tbRecent = new QToolButton(ui->toolBar);
164 tbRecent->setFocusPolicy(Qt::NoFocus);
165 tbRecent->setPopupMode(QToolButton::InstantPopup);
166 tbRecent->setMenu(m_pRecentMenu);
167 tbRecent->setIcon(pRecentAction->icon());
168 tbRecent->setText(pRecentAction->text());
169 tbRecent->setToolTip(pRecentAction->toolTip());
170 tbRecent->setStatusTip(pRecentAction->statusTip());
171 ui->toolBar->insertWidget(ui->actionOpenListRecent, tbRecent);
172
173#ifdef HAVE_UPDATE
174 CFrmUpdater updater;
175 ui->actionUpdate->setIcon(updater.windowIcon());
176#endif
177
178 QToolButton* tbStart = new QToolButton(ui->toolBar);
179 tbStart->setFocusPolicy(Qt::NoFocus);
180 tbStart->setPopupMode(QToolButton::InstantPopup);
181 //tbStart->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
182 tbStart->setMenu(ui->menuStart);
183 tbStart->setIcon(QIcon::fromTheme("media-playback-start"));
184 tbStart->setText(tr("Start"));
185 tbStart->setToolTip(tr("Start"));
186 tbStart->setStatusTip(tr("Start"));
187 ui->toolBar->insertWidget(ui->actionStop, tbStart);
188
189 m_Parameter.Load();
190
191 check = connect(&m_Parameter, SIGNAL(sigReceiveShortCutChanged()),
192 this, SLOT(slotShortCut()));
193 Q_ASSERT(check);
194 slotSystemTrayIconTypeChanged();
195 check = connect(&m_Parameter, SIGNAL(sigSystemTrayIconTypeChanged()),
196 this,
197 SLOT(slotSystemTrayIconTypeChanged()));
198 Q_ASSERT(check);
199 check = connect(&m_Parameter, SIGNAL(sigEnableSystemTrayIcon()),
200 this, SLOT(slotEnableSystemTrayIcon()));
201 Q_ASSERT(check);
202 check = connect(&m_Parameter, SIGNAL(sigEnableTabToolTipChanged()),
203 this, SLOT(slotUpdateName()));
204 Q_ASSERT(check);
205 check = connect(&m_Parameter, SIGNAL(sigEnableTabIconChanged()),
206 this, SLOT(slotUpdateName()));
207 Q_ASSERT(check);
208
209 auto pTbMenu = new QToolButton(ui->toolBar);
210 pTbMenu->setFocusPolicy(Qt::NoFocus);
211 pTbMenu->setPopupMode(QToolButton::InstantPopup);
212 //m_pTbMenu->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
213 pTbMenu->setText(ui->actionMain_menu_bar_M->text());
214 pTbMenu->setIcon(ui->actionMain_menu_bar_M->icon());
215 pTbMenu->setToolTip(ui->actionMain_menu_bar_M->toolTip());
216 pTbMenu->setStatusTip(ui->actionMain_menu_bar_M->statusTip());
217 QMenu *pMenu = new QMenu(pTbMenu);
218 pMenu->addActions(this->menuBar()->actions());
219 pTbMenu->setMenu(pMenu);
220 m_pToolBarMenuAction = ui->toolBar->insertWidget(ui->actionTabBar_B, pTbMenu);
221#if defined(Q_OS_ANDROID)
222 m_pToolBarMenuAction->setVisible(true);
223#else
224 m_pToolBarMenuAction->setVisible(false);
225#endif
226
227 check = connect(&m_Parameter, SIGNAL(sigStartByTypeChanged()),
228 this, SLOT(slotStartByType()));
229 Q_ASSERT(check);
230
231 m_pDockFavorite = new QDockWidget(this);
232 if(m_pDockFavorite)
233 {
234 m_pFavoriteView = new CFavoriteView(&m_Parameter, m_pDockFavorite);
235 if(m_pFavoriteView)
236 {
237 if(m_pFavoriteView->m_pDockTitleBar)
238 m_pDockFavorite->setTitleBarWidget(m_pFavoriteView->m_pDockTitleBar);
239 check = connect(m_pFavoriteView, SIGNAL(sigStart(const QString&, bool)),
240 this, SLOT(slotOpenFile(const QString&, bool)));
241 Q_ASSERT(check);
242 check = connect(m_pFavoriteView, SIGNAL(sigFavorite()),
243 this, SLOT(on_actionAdd_to_favorite_triggered()));
244 Q_ASSERT(check);
245 check = connect(m_pFavoriteView, &CFavoriteView::sigShowMessageBox,
246 this, &MainWindow::slotShowMessageBox);
247 Q_ASSERT(check);
248 check = connect(&m_Parameter, SIGNAL(sigFavoriteEditChanged(bool)),
249 m_pFavoriteView, SLOT(slotDoubleEditNode(bool)));
250 Q_ASSERT(check);
251 emit m_Parameter.sigFavoriteEditChanged(m_Parameter.GetFavoriteEdit());
252 m_pDockFavorite->setWidget(m_pFavoriteView);
253 m_pDockFavorite->setWindowTitle(m_pFavoriteView->windowTitle());
254 }
255 // Must set ObjectName then restore it. See: saveState help document
256 m_pDockFavorite->setObjectName("dockFavorite");
257#if defined(Q_OS_ANDROID)
258 m_pDockFavorite->hide();
259#endif
260 ui->menuView->addAction(m_pDockFavorite->toggleViewAction());
261 m_pDockFavorite->toggleViewAction()->setIcon(QIcon::fromTheme("emblem-favorite"));
262 addDockWidget(Qt::DockWidgetArea::LeftDockWidgetArea, m_pDockFavorite);
263 }
264
265 m_pDockRecent = new QDockWidget(this);
266 if(m_pDockRecent)
267 {
268 m_pRecent
269 = new CFrmRecent(this, &m_Manager, m_Parameter, true,
270 m_pDockRecent);
271 if(m_pRecent) {
272 if(m_pRecent->m_pDockTitleBar)
273 m_pDockRecent->setTitleBarWidget(
274 m_pRecent->m_pDockTitleBar);
275 check = connect(m_pRecent,
276 SIGNAL(sigStart(const QString&, bool)),
277 this, SLOT(slotOpenFile(const QString&, bool)));
278 Q_ASSERT(check);
279 check = connect(m_pRecent, &CFrmRecent::sigAddToFavorite,
280 m_pFavoriteView, &CFavoriteView::slotAddToFavorite);
281 Q_ASSERT(check);
282 check = connect(m_pRecent, &CFrmRecent::sigShowMessageBox,
283 this, &MainWindow::slotShowMessageBox);
284 Q_ASSERT(check);
285 m_pDockRecent->setWidget(m_pRecent);
286 m_pDockRecent->setWindowTitle(
287 m_pRecent->windowTitle());
288 }
289 // Must set ObjectName then restore it. See: saveState help document
290 m_pDockRecent->setObjectName("dockRecent");
291#if defined(Q_OS_ANDROID)
292 m_pDockRecent->hide();
293#endif
294 ui->menuView->addAction(m_pDockRecent->toggleViewAction());
295 m_pDockRecent->toggleViewAction()->setIcon(QIcon::fromTheme("document-open-recent"));
296 tabifyDockWidget(m_pDockFavorite, m_pDockRecent);
297 }
298
299 m_pDockActive = new QDockWidget(this);
300 if(m_pDockActive)
301 {
302 m_pFrmActive = new CFrmActive(
303 m_Operates, m_Parameter,
304 ui->menuStart, ui->actionStop,
305 m_pRecentMenu, m_pDockActive);
306 if(m_pFrmActive) {
307 m_pDockActive->setWidget(m_pFrmActive);
308 if(m_pFrmActive->m_pDockTitleBar)
309 m_pDockActive->setTitleBarWidget(
310 m_pFrmActive->m_pDockTitleBar);
311 m_pDockActive->setWindowTitle(m_pFrmActive->windowTitle());
312 check = connect(m_pFrmActive, SIGNAL(sigChanged(COperate*)),
313 this, SLOT(slotOperateChanged(COperate*)));
314 Q_ASSERT(check);
315 check = connect(m_pFrmActive, &CFrmActive::sigAddToFavorite,
316 m_pFavoriteView, &CFavoriteView::slotAddToFavorite);
317 Q_ASSERT(check);
318 }
319 m_pDockActive->setObjectName("dockListActive");
320#if defined(Q_OS_ANDROID)
321 m_pDockActive->hide();
322#endif
323 ui->menuView->addAction(m_pDockActive->toggleViewAction());
324 m_pDockActive->toggleViewAction()->setIcon(QIcon::fromTheme("network-wired"));
325 tabifyDockWidget(m_pDockFavorite, m_pDockActive);
326 }
327
328 QActionGroup* pGBView = new QActionGroup(this);
329 if(pGBView) {
330 pGBView->addAction(ui->actionViewTab);
331 pGBView->addAction(ui->actionViewSplit);
332 }
333 qDebug(log) << "View type:" << m_Parameter.GetViewType();
334 if(CParameterApp::ViewType::Tab == m_Parameter.GetViewType()) {
335 ui->actionViewTab->setChecked(true);
336 on_actionViewTab_triggered();
337 }
338 if(CParameterApp::ViewType::Splitter == m_Parameter.GetViewType()) {
339 ui->actionViewSplit->setChecked(true);
340 on_actionViewSplit_triggered();
341 }
342 check = connect(&m_Parameter, &CParameterApp::sigViewTypeChanged,
343 this, [&](){
344 m_Parameter.Save();
345 });
346 Q_ASSERT(check);
347
348 m_pMenuActivityGroup = new QActionGroup(ui->menuActivity);
349 m_ptbMenuActivity = new QToolButton(ui->toolBar);
350 m_ptbMenuActivity->setFocusPolicy(Qt::NoFocus);
351 m_ptbMenuActivity->setPopupMode(QToolButton::InstantPopup);
352 m_ptbMenuActivity->setMenu(ui->menuActivity);
353 m_ptbMenuActivity->setIcon(ui->menuActivity->icon());
354 m_ptbMenuActivity->setText(ui->menuActivity->title());
355 m_ptbMenuActivity->setToolTip(ui->menuActivity->toolTip());
356 m_ptbMenuActivity->setStatusTip(ui->menuActivity->statusTip());
357 ui->toolBar->insertWidget(ui->actionTabBar_B, m_ptbMenuActivity);
358
359 EnableMenu(false);
360 slotShortCut();
361
362#ifdef HAVE_ICE
363 if(CICE::Instance()->GetSignal())
364 {
365 check = connect(CICE::Instance()->GetSignal().data(),
366 SIGNAL(sigConnected()),
367 this, SLOT(slotSignalConnected()));
368 Q_ASSERT(check);
369 check = connect(CICE::Instance()->GetSignal().data(),
370 SIGNAL(sigDisconnected()),
371 this, SLOT(slotSignalDisconnected()));
372 Q_ASSERT(check);
373 check = connect(CICE::Instance()->GetSignal().data(),
374 SIGNAL(sigError(const int, const QString&)),
375 this, SLOT(slotSignalError(const int, const QString&)));
376 Q_ASSERT(check);
377 }
378 CICE::Instance()->slotStart(statusBar());
379 m_pSignalStatus = new QPushButton();
380 m_pSignalStatus->setToolTip(tr("ICE signal status"));
381 m_pSignalStatus->setStatusTip(m_pSignalStatus->toolTip());
382 m_pSignalStatus->setWhatsThis(m_pSignalStatus->toolTip());
383 slotSignalDisconnected();
384 statusBar()->addPermanentWidget(m_pSignalStatus);
385#endif
386
387 if(m_Parameter.GetSaveMainWindowStatus())
388 {
389 QSettings set(RabbitCommon::CDir::Instance()->GetFileUserConfigure(),
390 QSettings::IniFormat);
391 QByteArray geometry
392 = set.value("MainWindow/Status/Geometry").toByteArray();
393 if(!geometry.isEmpty())
394 restoreGeometry(geometry);
395 // Restores the state of this mainwindow's toolbars and dockwidgets
396 QByteArray state = set.value("MainWindow/Status/State").toByteArray();
397 if(!state.isEmpty())
398 restoreState(state);
399
400 ui->actionTabBar_B->setChecked(m_Parameter.GetTabBar());
401 on_actionTabBar_B_toggled(m_Parameter.GetTabBar());
402 ui->actionStatus_bar_S->setChecked(m_Parameter.GetStatusBar());
403 statusBar()->setVisible(m_Parameter.GetStatusBar());
404 ui->actionMain_menu_bar_M->setChecked(m_Parameter.GetMenuBar());
405 menuBar()->setVisible(m_Parameter.GetMenuBar());
406 ui->actionToolBar_T->setChecked(!ui->toolBar->isHidden());
407 // macOS: Hide 'Main menu bar' on macOS since it's always visible
408 #ifdef Q_OS_MACOS
409 // Hide 'Main menu bar' on View menu
410 ui->actionMain_menu_bar_M->setVisible(false);
411 #else
412 // Show 'Main menu bar' toolbar icon
413 if(!m_Parameter.GetMenuBar()) {
414 m_pToolBarMenuAction->setVisible(true);
415 }
416 #endif
417 }
418}
419
420MainWindow::~MainWindow()
421{
422 qDebug(log) << "MainWindow::~MainWindow()";
423 if(m_pFullScreenToolBar) m_pFullScreenToolBar->close();
424 delete ui;
425}
426
428int MainWindow::Initial()
429{
430 qDebug(log) << Q_FUNC_INFO;
431
432 int nRet = 0;
433 QString szErr;
434
435 setEnabled(false);
436 do {
437 QMessageBox initMsgBox(QMessageBox::Information, tr("Load"), tr("Load ......"));
438 initMsgBox.showNormal();
439 qApp->processEvents();
440
441 QString szMsg;
442 szMsg = tr("Load plugins ......");
443 initMsgBox.setText(szMsg);
444 slotInformation(szMsg);
445 qApp->processEvents();
446 nRet = m_Manager.Initial();
447 if(nRet) {
448 szErr = tr("Initial manage error");
449 break;
450 }
451 m_Manager.EnumPlugins(this);
452
453 auto pg = m_Manager.GetGlobalParameters();
454 if(pg) {
455 //m_Parameter.SetGlobalParameters(pg);
456 bool bRet = QMetaObject::invokeMethod(
457 &m_Parameter,
458 "SetGlobalParameters",
459 Qt::DirectConnection,
460 Q_ARG(CParameterGlobal*, pg));
461 if(!bRet) {
462 szErr = tr("Failed to set global parameters");
463 qCritical(log) << szErr;
464 nRet = -1;
465 break;
466 }
467 }
468
469 if(m_pRecent) {
470 szMsg = tr("Load list recent dock ......");
471 initMsgBox.setText(szMsg);
472 slotInformation(szMsg);
473 qApp->processEvents();
474 nRet = m_pRecent->Initial();
475 if(nRet) {
476 szErr = tr("Initial recent dock error");
477 break;
478 }
479 }
480
481 if(m_pRecentMenu) {
482 szMsg = tr("Load recent menu ......");
483 initMsgBox.setText(szMsg);
484 slotInformation(szMsg);
485 qApp->processEvents();
486 if(m_pRecent) {
487 auto recents = m_pRecent->GetRecents(m_Parameter.GetRecentMenuMaxCount());
488 //qDebug(log) << "recents totaol:" << recents.size() << m_Parameter.GetRecentMenuMaxCount();
489 for(auto it = recents.rbegin(); it != recents.rend(); it++) {
490 m_pRecentMenu->addRecentFile(it->GetFile(), it->szName, it->icon);
491 }
492 m_pRecentMenu->slotShowFileEixst(
493 m_Parameter.GetGlobalParameters()->GetSaveSettingsType() == CParameterGlobal::Local);
494 bool check = connect(
495 m_Parameter.GetGlobalParameters(),
496 &CParameterGlobal::sigSaveSettingsTypeChanged,
497 m_pRecentMenu, [this]() {
498 if(!(m_pRecentMenu && m_Parameter.GetGlobalParameters()))
499 return;
500 m_pRecentMenu->slotShowFileEixst(
501 m_Parameter.GetGlobalParameters()->GetSaveSettingsType() == CParameterGlobal::Local);
502 });
503 Q_ASSERT(check);
504 }
505 }
506
507 if(m_pFavoriteView) {
508 szMsg = tr("Load favorite ......");
509 initMsgBox.setText(szMsg);
510 slotInformation(szMsg);
511 qApp->processEvents();
512 nRet = m_pFavoriteView->Initial();
513 if(nRet) {
514 szErr = tr("Initial favorite error");
515 break;
516 }
517 }
518
519 slotEnableSystemTrayIcon();
520
521 setEnabled(true);
522
523 szMsg = tr("Load laster operate ......");
524 initMsgBox.setText(szMsg);
525 slotInformation(szMsg);
526 qApp->processEvents();
527 nRet = LoadOperateLasterClose();
528 if(nRet) {
529 szErr = tr("Initial load laster close operate error");
530 break;
531 }
532
533 slotInformation(tr("Ready"));
534
535 return nRet;
536 } while(false);
537
538 setEnabled(true);
539
540 slotError(nRet, szErr);
541 QMessageBox errMsgBox;
542 errMsgBox.setWindowTitle(QObject::tr("Error"));
543 errMsgBox.setText(QObject::tr("Initial error:") + szErr);
544 errMsgBox.setIcon(QMessageBox::Critical);
545
546 auto logMenu = RabbitCommon::CTools::GetLogMenu();
547 QPushButton *pbLog = new QPushButton(logMenu->title());
548 pbLog->setMenu(logMenu);
549
550 QPushButton *pbettings = new QPushButton(ui->actionSettings->text());
551 QMenu* pSettings = new QMenu(pbettings);
552 pSettings->addAction(ui->actionSettings);
553 pbettings->setMenu(pSettings);
554 errMsgBox.addButton(pbettings, QMessageBox::ActionRole);
555 errMsgBox.addButton(pbLog, QMessageBox::ActionRole);
556 errMsgBox.addButton(QMessageBox::Cancel);
557
558 errMsgBox.exec();
559
560 return nRet;
561}
562
563void MainWindow::SetView(CView* pView)
564{
565 qDebug(log) << Q_FUNC_INFO;
566 if(!pView)
567 return;
568 if(m_pView)
569 m_pView->disconnect();
570
571 m_pView = pView;
572 setCentralWidget(m_pView);
573
574 bool check = false;
575 //m_pView->setFocusPolicy(Qt::NoFocus);
576 check = connect(m_pView, SIGNAL(sigCloseView(const QWidget*)),
577 this, SLOT(slotCloseView(const QWidget*)));
578 Q_ASSERT(check);
579 check = connect(m_pView, SIGNAL(sigCurrentChanged(const QWidget*)),
580 this, SLOT(slotCurrentViewChanged(const QWidget*)));
581 Q_ASSERT(check);
582 if(m_pFrmActive) {
583 check = connect(m_pView, SIGNAL(sigCurrentChanged(const QWidget*)),
584 m_pFrmActive, SLOT(slotViewChanged(const QWidget*)));
585 Q_ASSERT(check);
586 }
587 check = connect(m_pView, SIGNAL(customContextMenuRequested(const QPoint&)),
588 this, SLOT(slotCustomContextMenuRequested(const QPoint&)));
589 Q_ASSERT(check);
590
591 foreach (auto c, m_Operates) {
592 m_pView->AddView(c->GetViewer());
593 m_pView->SetWidowsTitle(
594 c->GetViewer(), c->Name(), c->Icon(), c->Description());
595 }
596 m_pView->SetVisibleTab(m_Parameter.GetTabBar());
597}
598
599void MainWindow::on_actionViewTab_triggered()
600{
601 qDebug(log) << Q_FUNC_INFO;
602 if(!ui->actionViewTab->isChecked()) return;
603 m_Parameter.SetViewType(CParameterApp::ViewType::Tab);
604 SetView(new CViewTable(&m_Parameter, this));
605}
606
607void MainWindow::on_actionViewSplit_triggered()
608{
609 qDebug(log) << Q_FUNC_INFO;
610 if(!ui->actionViewSplit->isChecked()) return;
611 m_Parameter.SetViewType(CParameterApp::ViewType::Splitter);
612 SetView(new CViewSplitter(&m_Parameter, this));
613}
614
615void MainWindow::on_actionAbout_triggered()
616{
617#ifdef HAVE_ABOUT
618 CDlgAbout *about = new CDlgAbout(this);
619 QIcon icon = QIcon::fromTheme("app");
620 if(!icon.isNull()) {
621 auto sizeList = icon.availableSizes();
622 if(!sizeList.isEmpty()) {
623 QPixmap p = icon.pixmap(*sizeList.begin());
624 about->m_AppIcon = p.toImage();
625 }
626 }
627 about->m_szBuildTime = QString("%1/%2").arg(__DATE__, __TIME__);
628 about->m_szCopyrightStartTime = "2020";
629 about->m_szVersionRevision = RabbitRemoteControl_REVISION;
630 about->m_szDetails = m_Manager.Details();
631 RC_SHOW_WINDOW(about);
632#endif
633}
634
635void MainWindow::on_actionUpdate_triggered()
636{
637 if(!qEnvironmentVariable("SNAP").isEmpty()) {
638 QDesktopServices::openUrl(QUrl("https://snapcraft.io/rabbitremotecontrol"));
639 } else if(!qEnvironmentVariable("FLATPAK_ID").isEmpty()) {
640 QDesktopServices::openUrl(QUrl("https://flathub.org/apps/io.github.KangLin.RabbitRemoteControl"));
641 } else {
642#ifdef HAVE_UPDATE
643 CFrmUpdater* m_pfrmUpdater = new CFrmUpdater();
644 QIcon icon = QIcon::fromTheme("app");
645 if(!icon.isNull()) {
646 auto sizeList = icon.availableSizes();
647 if(!sizeList.isEmpty()) {
648 QPixmap p = icon.pixmap(*sizeList.begin());
649 m_pfrmUpdater->SetTitle(p.toImage());
650 }
651 }
652 m_pfrmUpdater->SetInstallAutoStartup();
653 RC_SHOW_WINDOW(m_pfrmUpdater);
654#endif
655 }
656}
657
658void MainWindow::on_actionFull_screen_F_triggered()
659{
660 CView* pView = qobject_cast<CView*>(this->centralWidget());
661 if(pView)
662 {
663 pView->SetFullScreen(!isFullScreen());
664 }
665
666 if(isFullScreen())
667 {
668 qDebug(log) << "Exit full screen";
669 ui->actionFull_screen_F->setIcon(QIcon::fromTheme("view-fullscreen"));
670 ui->actionFull_screen_F->setText(tr("Full screen"));
671 ui->actionFull_screen_F->setToolTip(tr("Full screen"));
672 ui->actionFull_screen_F->setStatusTip(tr("Full screen"));
673 ui->actionFull_screen_F->setWhatsThis(tr("Full screen"));
674
675 ui->toolBar->setVisible(m_FullState.toolBar);
676 ui->statusbar->setVisible(m_FullState.statusbar);
677 ui->menubar->setVisible(m_FullState.menubar);
678
679 m_pDockActive->setVisible(m_FullState.dockListActive);
680 m_pDockRecent->setVisible(m_FullState.dockListRecent);
681 m_pDockFavorite->setVisible(m_FullState.dockFavorite);
682 // TODO: This is hade code. it is in RabbitCommon
683 QDockWidget* pDockDebugLog = findChild<QDockWidget*>("dockDebugLog");
684 if(pDockDebugLog)
685 {
686 pDockDebugLog->setVisible(m_FullState.dockDebugLog);
687 }
688
689 if(m_pFullScreenToolBar)
690 {
691 // Delete it when the widget is close
692 m_pFullScreenToolBar->close();
693 m_pFullScreenToolBar = nullptr;
694 }
695
696 emit sigShowNormal();
697 this->showNormal();
698 this->activateWindow();
699
700 emit sigFullScreen(false);
701 return;
702 }
703
704 qDebug(log) << "Entry full screen";
705
706 //setWindowFlags(Qt::FramelessWindowHint | windowFlags());
707 this->showFullScreen();
708 emit sigFullScreen(true);
709
710 ui->actionFull_screen_F->setIcon(QIcon::fromTheme("view-restore"));
711 ui->actionFull_screen_F->setText(tr("Exit full screen"));
712 ui->actionFull_screen_F->setToolTip(tr("Exit full screen"));
713 ui->actionFull_screen_F->setStatusTip(tr("Exit full screen"));
714 ui->actionFull_screen_F->setWhatsThis(tr("Exit full screen"));
715
716 m_FullState.toolBar = ui->toolBar->isVisible();
717 ui->toolBar->setVisible(false);
718 m_FullState.statusbar = ui->statusbar->isVisible();
719 ui->statusbar->setVisible(false);
720 m_FullState.menubar = ui->menubar->isVisible();
721 ui->menubar->setVisible(false);
722
723 m_FullState.dockListActive = m_pDockActive->isVisible();
724 m_pDockActive->setVisible(false);
725 m_FullState.dockListRecent = m_pDockRecent->isVisible();
726 m_pDockRecent->setVisible(false);
727 m_FullState.dockFavorite = m_pDockFavorite->isVisible();
728 m_pDockFavorite->setVisible(false);
729 // This is hade code. it is in RabbitCommon
730 QDockWidget* pDockDebugLog = findChild<QDockWidget*>("dockDebugLog");
731 if(pDockDebugLog)
732 {
733 m_FullState.dockDebugLog = pDockDebugLog->isVisible();
734 pDockDebugLog->setVisible(false);
735 }
736
737 if(m_pFullScreenToolBar) m_pFullScreenToolBar->close();
738 // Delete it when the widget is close
739 m_pFullScreenToolBar = new CFrmFullScreenToolBar(this);
740 QScreen* pScreen = qApp->primaryScreen();
741 if(pScreen) {
742 QPoint pos(pScreen->geometry().left()
743 + (pScreen->geometry().width()
744 - m_pFullScreenToolBar->frameGeometry().width()) / 2,
745 pScreen->geometry().top());
746 qDebug(log) << "Primary screen geometry:" << pScreen->geometry()
747 << "availableGeometry:" << pScreen->availableGeometry()
748 << pos << mapToGlobal(pos);
749 m_pFullScreenToolBar->move(pos);
750 }
751 bool check = connect(m_pFullScreenToolBar, SIGNAL(sigExitFullScreen()),
752 this, SLOT(on_actionFull_screen_F_triggered()));
753 Q_ASSERT(check);
754 check = connect(m_pFullScreenToolBar, SIGNAL(sigExit()),
755 this, SLOT(on_actionExit_E_triggered()));
756 Q_ASSERT(check);
757 Q_ASSERT(check);
758 check = connect(this, SIGNAL(sigOperateMenuChanged(QAction*)),
759 m_pFullScreenToolBar,
760 SLOT(slotOperateMenuChanged(QAction*)));
761 Q_ASSERT(check);
762
763 m_pFullScreenToolBar->show();
764}
765
766void MainWindow::slotViewerFocusIn(QWidget *pView)
767{
768 COperate* c = qobject_cast<COperate*>(sender());
769 qDebug(log) << Q_FUNC_INFO << "Focus:" << c << pView;
770 if(c && m_pView) {
771 m_pView->SetCurrentView(c->GetViewer());
772 }
773}
774
775void MainWindow::slotOperateChanged(COperate *o)
776{
777 if(o && m_pView) {
778 m_pView->SetCurrentView(o->GetViewer());
779 }
780}
781
782void MainWindow::slotCurrentViewChanged(const QWidget* pView)
783{
784 qDebug(log) << Q_FUNC_INFO;
785 if(m_pView && pView)
786 EnableMenu(true);
787 else
788 EnableMenu(false);
789
790 foreach(auto o, m_Operates) {
791 if(o->GetViewer() == pView) {
792 SetSecureLevel(o);
793 foreach (auto a, ui->menuActivity->actions()) {
794 if(a->data().value<COperate*>() == o)
795 a->setChecked(true);
796 }
797 ui->actionStop_other->setText(
798 tr("Stop other except the current \"%1\"").arg(o->Name()));
799 }
800 }
801
802 QTimer::singleShot(0, this, SLOT(slotTimeOut()));
803}
804
805void MainWindow::EnableMenu(bool bEnable)
806{
807 qDebug(log) << Q_FUNC_INFO << bEnable;
808 ui->actionClone->setEnabled(bEnable);
809 ui->actionAdd_to_favorite->setEnabled(bEnable);
810 ui->actionStop->setEnabled(bEnable);
811 ui->actionStop_All->setEnabled(bEnable);
812 ui->actionStop_other->setEnabled(bEnable);
813 if(bEnable) {
814 if(m_Operates.size() > 1)
815 ui->actionStop_other->setEnabled(true);
816 else
817 ui->actionStop_other->setEnabled(false);
818 } else {
819 ui->actionStop_other->setText(tr("Stop other"));
820 }
821 ui->actionTabBar_B->setEnabled(bEnable);
822 ui->menuActivity->setEnabled(bEnable);
823 m_ptbMenuActivity->setEnabled(bEnable);
824 slotLoadOperateMenu();
825}
826
827void MainWindow::slotMenuActivity()
828{
829 QAction* pAction = qobject_cast<QAction*>(sender());
830 Q_ASSERT(pAction);
831 if(!pAction) return;
832 COperate* p = pAction->data().value<COperate*>();
833 if(p)
834 slotOperateChanged(p);
835}
836
837void MainWindow::slotLoadOperateMenu()
838{
839 qDebug(log) << Q_FUNC_INFO;
840
841 if(m_pActionOperateMenu) {
842 ui->menuOperate->removeAction(m_pActionOperateMenu);
843 m_pActionOperateMenu = nullptr;
844 }
845 ui->toolBar->removeAction(m_pActionTBOperate);
846
847 if(!m_pView)
848 return;
849 auto pWin = m_pView->GetCurrentView();
850 if(!pWin) {
851 qDebug(log) << "The current view is empty";
852 return;
853 }
854 foreach(auto op, m_Operates)
855 {
856 if(op->GetViewer() == pWin)
857 {
858 qDebug(log) << "Load plugin menu";
859 auto m = op->GetMenu(ui->menuTools);
860 if(!m) return;
861 // Menu tool bar
862 m_pActionOperateMenu = ui->menuOperate->insertMenu(ui->actionAdd_to_favorite, m);
863 // ToolBar
864 if(!m_pTBOperate)
865 m_pTBOperate = new QToolButton(ui->toolBar);
866 if(m_pTBOperate) {
867 m_pTBOperate->setFocusPolicy(Qt::NoFocus);
868 m_pTBOperate->setPopupMode(QToolButton::InstantPopup);
869 m_pTBOperate->setMenu(m);
870 m_pTBOperate->setIcon(m->icon());
871 m_pTBOperate->setText(m->title());
872 m_pTBOperate->setToolTip(m->toolTip());
873 m_pTBOperate->setStatusTip(m->statusTip());
874 m_pTBOperate->show();
875 m_pActionTBOperate = ui->toolBar->insertWidget(ui->actionAdd_to_favorite, m_pTBOperate);
876 }
877 emit sigOperateMenuChanged(m_pActionOperateMenu);
878 }
879 }
880}
881
888void MainWindow::slotCustomContextMenuRequested(const QPoint &pos)
889{
890 if(!m_pView)
891 return;
892 auto pWin = m_pView->GetCurrentView();
893 if(!pWin) {
894 qDebug(log) << "The current view is empty";
895 return;
896 }
897 foreach(auto p, m_Operates)
898 {
899 if(p->GetViewer() == pWin)
900 {
901 qDebug(log) << "Load plugin menu";
902 auto m = p->GetMenu(ui->menuTools);
903 if(!m) return;
904 // Note: The view is converted to global coordinates
905 m->exec(pos);
906 }
907 }
908}
909
910void MainWindow::on_actionExit_E_triggered()
911{
912 close();
913}
914
915void MainWindow::keyReleaseEvent(QKeyEvent *event)
916{
917 switch(event->key())
918 {
919 case Qt::Key_Escape:
920 if(isFullScreen())
921 on_actionFull_screen_F_triggered();
922 break;
923 }
924 QMainWindow::keyReleaseEvent(event);
925}
926
927void MainWindow::slotUpdateParameters(COperate *pOperate)
928{
929 m_Manager.SaveOperate(pOperate);
930}
931
932void MainWindow::on_actionClone_triggered()
933{
934 if(!m_pView) return;
935 QWidget* p = m_pView->GetCurrentView();
936 foreach(auto pOperate, m_Operates)
937 {
938 if(pOperate->GetViewer() == p)
939 {
940 QString szFile = pOperate->GetSettingsFile();
941 auto pOperate = m_Manager.LoadOperate(szFile);
942 if(!pOperate) return;
943 Start(pOperate, false, szFile);
944 return;
945 }
946 }
947}
948
949void MainWindow::slotOpenFile(const QString& szFile, bool bOpenSettings)
950{
951 if(szFile.isEmpty()) return;
952 COperate* p = m_Manager.LoadOperate(szFile);
953 if(nullptr == p)
954 {
955 slotStatusMessage(tr("Load file fail: ") + szFile, MessageLevel::Error);
956 return;
957 }
958
959 Start(p, bOpenSettings, szFile);
960}
961
962void MainWindow::on_actionOpenRRCFile_triggered()
963{
964 QString szFile = QFileDialog::getOpenFileName(
965 this,
966 tr("Open rabbit remote control file"),
967 RabbitCommon::CDir::Instance()->GetDirUserData(),
968 tr("Rabbit remote control Files (*.rrc);;All files(*.*)"));
969 if(szFile.isEmpty()) return;
970
971 COperate* p = m_Manager.LoadOperate(szFile);
972 if(nullptr == p)
973 {
974 slotStatusMessage(tr("Load file fail: ") + szFile, MessageLevel::Error);
975 return;
976 }
977
978 Start(p, true);
979}
980
981void MainWindow::slotStart()
982{
983 if(nullptr == m_pView)
984 {
985 Q_ASSERT(false);
986 return;
987 }
988 QAction* pAction = qobject_cast<QAction*>(this->sender());
989 Q_ASSERT(pAction);
990 COperate* p = m_Manager.CreateOperate(pAction->data().toString());
991 if(nullptr == p) return;
992 Start(p, true);
993}
994
1005int MainWindow::Start(COperate *pOperate, bool set, QString szFile)
1006{
1007 qDebug(log) << "MainWindow::Start: set:" << set << "; File:" << szFile;
1008 bool bSave = false; //whether is save configure file
1009 Q_ASSERT(pOperate);
1010 bool check = connect(pOperate, SIGNAL(sigRunning()),
1011 this, SLOT(slotRunning()));
1012 Q_ASSERT(check);
1013 check = connect(pOperate, SIGNAL(sigStop()),
1014 this, SLOT(slotStop()));
1015 Q_ASSERT(check);
1016 check = connect(pOperate, SIGNAL(sigFinished()),
1017 this, SLOT(slotFinished()));
1018 Q_ASSERT(check);
1019 check = connect(pOperate, SIGNAL(sigError(const int, const QString &)),
1020 this, SLOT(slotError(const int, const QString&)));
1021 Q_ASSERT(check);
1022 check = connect(pOperate, SIGNAL(sigShowMessageBox(const QString&, const QString&,
1023 const QMessageBox::Icon&)),
1024 this, SLOT(slotShowMessageBox(const QString&, const QString&,
1025 const QMessageBox::Icon&)));
1026 Q_ASSERT(check);
1027 check = connect(pOperate, SIGNAL(sigInformation(const QString&)),
1028 this, SLOT(slotInformation(const QString&)));
1029 Q_ASSERT(check);
1030 check = connect(pOperate, SIGNAL(sigUpdateName(const QString&)),
1031 this, SLOT(slotUpdateName(const QString&)));
1032 Q_ASSERT(check);
1033 check = connect(pOperate, SIGNAL(sigUpdateParameters(COperate*)),
1034 this, SLOT(slotUpdateParameters(COperate*)));
1035 Q_ASSERT(check);
1036 check = connect(pOperate, &COperate::sigFullScreen,
1037 this, [this, pOperate](bool bFull) {
1038 if(m_pView && m_pView->GetCurrentView() == pOperate->GetViewer()) {
1039 if((bFull && !isFullScreen()) || (!bFull && isFullScreen()))
1040 on_actionFull_screen_F_triggered();
1041 }
1042 });
1043 Q_ASSERT(check);
1044 check = connect(pOperate, &COperate::sigSecurityLevel,
1045 this, [this, pOperate]() {
1046 if(m_pView && pOperate) {
1047 if(m_pView->GetCurrentView() == pOperate->GetViewer())
1048 slotCurrentViewChanged(pOperate->GetViewer());
1049 }
1050 });
1051 Q_ASSERT(check);
1052
1053 if(set)
1054 {
1055 int nRet = pOperate->OpenDialogSettings(this);
1056 switch(nRet)
1057 {
1058 case QDialog::Rejected:
1059 m_Manager.DeleteOperate(pOperate);
1060 return 0;
1061 case QDialog::Accepted:
1062 bSave = true;
1063 break;
1064 }
1065 }
1066
1067 if(szFile.isEmpty())
1068 szFile = pOperate->GetSettingsFile();
1069 else
1070 pOperate->SetSettingsFile(szFile);
1071
1072 int nRet = 0;
1073 if(bSave)
1074 nRet = m_Manager.SaveOperate(pOperate);
1075 if(0 == nRet) {
1076 m_pRecentMenu->addRecentFile(szFile, pOperate->Name(), pOperate->Icon());
1077 CRecentDatabase::RecentItem item;
1078 item.szOperateId = pOperate->Id();
1079 item.icon = pOperate->Icon();
1080 item.szName = pOperate->Name();
1081 item.szProtocol = pOperate->Protocol();
1082 item.szType = pOperate->GetTypeName();
1083 item.szDescription = pOperate->Description();
1084 item.SetFile(szFile);
1085 item.time = QDateTime::currentDateTime();
1086 m_pRecent->AddRecent(item);
1087 }
1088
1089 if(!pOperate->Name().isEmpty())
1090 slotInformation(tr("Starting: ") + pOperate->Name());
1091
1092 //* Show view. \see: slotRunning()
1093 if(m_Operates.contains(pOperate)) {
1094 if(m_pView)
1095 m_pView->SetCurrentView(pOperate->GetViewer());
1096 return 0;
1097 }
1098 if(m_pView)
1099 {
1100 m_pView->AddView(pOperate->GetViewer());
1101 m_pView->SetWidowsTitle(pOperate->GetViewer(), pOperate->Name(),
1102 pOperate->Icon(), pOperate->Description());
1103 //qDebug(log) << "View:" << p->GetViewer();
1104 check = connect(pOperate, SIGNAL(sigViewerFocusIn(QWidget*)),
1105 this, SLOT(slotViewerFocusIn(QWidget*)));
1106 Q_ASSERT(check);
1107 }
1108 m_Operates.insert(pOperate);
1109 StartTimer();
1110
1111 m_pFrmActive->slotLoad();
1112 m_pFrmActive->slotViewChanged(m_pView->GetCurrentView());
1113
1114 QVariant vOperate;
1115 vOperate.setValue(pOperate);
1116 QAction* m_pActionmenuActivity = ui->menuActivity->addAction(
1117 pOperate->Icon(), pOperate->Name(), this, SLOT(slotMenuActivity()));
1118 m_pActionmenuActivity->setData(vOperate);
1119 m_pActionmenuActivity->setCheckable(true);
1120 m_pMenuActivityGroup->addAction(m_pActionmenuActivity);
1121 m_pActionmenuActivity->setChecked(true);
1122 //*/
1123
1124 nRet = pOperate->Start();
1125 if(nRet)
1126 pOperate->Stop();
1127 return nRet;
1128}
1129
1131
1134void MainWindow::slotRunning()
1135{
1136 COperate* p = qobject_cast<COperate*>(sender());
1137 if(!p) return;
1138
1139 /* If you put it here, when running, the view is not displayed.
1140 So put it in the Start() display view.
1141 See: Start(COperate *p, bool set, QString szFile)
1142 */
1143 /*
1144 if(-1 == m_Operates.indexOf(p)) {
1145 m_Operates.push_back(p);
1146 if(m_pView)
1147 {
1148 m_pView->AddView(p->GetViewer());
1149 m_pView->SetWidowsTitle(p->GetViewer(), p->Name(), p->Icon(), p->Description());
1150 }
1151 } else {
1152 m_pView->SetCurrentView(p->GetViewer());
1153 }
1154 //*/
1155
1156 slotCurrentViewChanged(p->GetViewer());
1157
1158 auto m = p->GetMenu();
1159 if(m) {
1160 m->addSeparator();
1161 m->addAction(ui->actionClone);
1162 m->addAction(ui->actionStop_All);
1163 m->addAction(ui->actionStop_other);
1164 }
1165
1166 slotInformation(tr("Connected to ") + "\"" + p->Name() + "\"");
1167 qDebug(log) << Q_FUNC_INFO << p->Name();
1168}
1170
1171void MainWindow::slotCloseView(const QWidget* pView)
1172{
1173 qDebug(log) << "MainWindow::slotCloseView" << pView;
1174 if(!pView) return;
1175 foreach(auto p, m_Operates)
1176 {
1177 if(p->GetViewer() == pView)
1178 {
1179 //TODO: Whether to save the setting
1180 emit p->sigUpdateParameters(p);
1181 p->Stop();
1182 }
1183 }
1184}
1185
1186void MainWindow::on_actionStop_other_triggered()
1187{
1188 if(!m_pView) return;
1189 foreach(auto p, m_Operates)
1190 {
1191 if(p->GetViewer() != m_pView->GetCurrentView())
1192 {
1193 //TODO: Whether to save the setting
1194 emit p->sigUpdateParameters(p);
1195 p->Stop();
1196 }
1197 }
1198}
1199
1200void MainWindow::on_actionStop_All_triggered()
1201{
1202 foreach(auto p, m_Operates)
1203 {
1204 //TODO: Whether to save the setting
1205 emit p->sigUpdateParameters(p);
1206 p->Stop();
1207 }
1208}
1209
1210void MainWindow::on_actionStop_triggered()
1211{
1212 qDebug(log) << Q_FUNC_INFO;
1213 if(!m_pView) return;
1214
1215 QWidget* pView = m_pView->GetCurrentView();
1216 slotCloseView(pView);
1217}
1218
1219void MainWindow::slotStop()
1220{
1221 COperate* pOperate = qobject_cast<COperate*>(sender());
1222 if(!pOperate) return;
1223 qDebug(log) << Q_FUNC_INFO << pOperate->Name();
1224 //TODO: Whether to save the setting
1225 emit pOperate->sigUpdateParameters(pOperate);
1226 pOperate->Stop();
1227}
1228
1229void MainWindow::slotFinished()
1230{
1231 COperate* pOperate = qobject_cast<COperate*>(sender());
1232 if(!pOperate) return;
1233
1234 qDebug(log) << Q_FUNC_INFO << pOperate->Name();
1235 foreach(auto a, ui->menuActivity->actions()) {
1236 COperate* o = a->data().value<COperate*>();
1237 if(o == pOperate) {
1238 ui->menuActivity->removeAction(a);
1239 m_pMenuActivityGroup->removeAction(a);
1240 }
1241 }
1242 foreach(auto p, m_Operates)
1243 {
1244 if(p == pOperate)
1245 {
1246 m_pView->RemoveView(p->GetViewer());
1247 m_Operates.remove(p);
1248 m_Manager.DeleteOperate(p);
1249 m_pFrmActive->slotLoad();
1250 m_pFrmActive->slotViewChanged(m_pView->GetCurrentView());
1251 break;
1252 }
1253 }
1254 if(m_Operates.isEmpty())
1255 if(m_pActionOperateMenu) {
1256 ui->menuTools->removeAction(m_pActionOperateMenu);
1257 ui->toolBar->removeAction(m_pActionOperateMenu);
1258 m_pActionOperateMenu = nullptr;
1259 }
1260
1261 StartTimer();
1262}
1263
1264// 该函数将label控件变成一个圆形指示灯，需要指定颜色color以及直径size
1265// size 单位是像素
1266void SetIndicator(QLabel* label, QColor color, int size)
1267{
1268 QString min_width = QString("min-width: %1px;").arg(size); // 最小宽度：size
1269 QString min_height = QString("min-height: %1px;").arg(size); // 最小高度：size
1270 QString max_width = QString("max-width: %1px;").arg(size); // 最小宽度：size
1271 QString max_height = QString("max-height: %1px;").arg(size); // 最小高度：size
1272 // 再设置边界形状及边框
1273 QString border_radius = QString("border-radius: %1px;").arg(size / 2); // 边框是圆角，半径为size/2
1274 QString border = QString("border:1px solid ") + color.name() + ";"; // 边框为1px
1275 // 最后设置背景颜色
1276 QString background = "background-color: ";
1277 background += color.name() + ";";
1278 QString SheetStyle = min_width + min_height + max_width + max_height + border_radius + border + background;
1279 label->setStyleSheet(SheetStyle);
1280}
1281
1282void MainWindow::SetSecureLevel(COperate* o)
1283{
1284 if(!m_pSecureLevel) return;
1285 if(o) {
1286 QString szLevel = CSecurityLevel::GetUnicodeIcon(o->GetSecurityLevel());
1287 if(szLevel.isEmpty()) {
1288 m_pSecureLevel->hide();
1289 return;
1290 }
1291 m_pSecureLevel->setText(szLevel);
1292 m_pSecureLevel->setToolTip(CSecurityLevel::GetString(o->GetSecurityLevel()));
1293 m_pSecureLevel->show();
1294 } else
1295 m_pSecureLevel->hide();
1296}
1297
1298void MainWindow::slotSignalConnected()
1299{
1300 m_pSignalStatus->setToolTip(tr("ICE signal status: Connected"));
1301 m_pSignalStatus->setStatusTip(m_pSignalStatus->toolTip());
1302 m_pSignalStatus->setWhatsThis(m_pSignalStatus->toolTip());
1303 //m_pSignalStatus->setText(tr("Connected"));
1304 m_pSignalStatus->setIcon(QIcon::fromTheme("network-wired"));
1305}
1306
1307void MainWindow::slotSignalDisconnected()
1308{
1309 m_pSignalStatus->setToolTip(tr("ICE signal status: Disconnected"));
1310 m_pSignalStatus->setStatusTip(m_pSignalStatus->toolTip());
1311 m_pSignalStatus->setWhatsThis(m_pSignalStatus->toolTip());
1312 //m_pSignalStatus->setText(tr("Disconnected"));
1313 m_pSignalStatus->setIcon(QIcon::fromTheme("network-wireless"));
1314}
1315
1316void MainWindow::slotSignalError(const int nError, const QString &szInfo)
1317{
1318 slotSignalDisconnected();
1319 slotError(nError, szInfo);
1320}
1321
1322void MainWindow::slotSignalPushButtonClicked(bool checked)
1323{
1324#ifdef HAVE_ICE
1325 if(checked)
1326 CICE::Instance()->slotStart();
1327 else
1328 CICE::Instance()->slotStop();
1329#endif
1330}
1331
1332void MainWindow::slotError(const int nError, const QString &szInfo)
1333{
1334 Q_UNUSED(nError);
1335 slotStatusMessage(szInfo, MessageLevel::Error);
1336}
1337
1338void MainWindow::slotShowMessageBox(
1339 const QString &title, const QString &message,
1340 const QMessageBox::Icon &icon)
1341{
1342 slotInformation(message);
1343 if(!m_Parameter.GetMessageBoxDisplayInformation())
1344 return;
1345
1346 QMessageBox msg(icon, title, message, QMessageBox::Ok, this);
1347 QCheckBox* cb = new QCheckBox(
1348 tr("Use message box to display information"), this);
1349 cb->setChecked(true);
1350 msg.setCheckBox(cb);
1351 RC_SHOW_WINDOW(&msg);
1352 if(!cb->isChecked())
1353 {
1354 m_Parameter.SetMessageBoxDisplayInformation(false);
1355 m_Parameter.Save();
1356 }
1357}
1358
1359void MainWindow::slotInformation(const QString& szInfo)
1360{
1361 slotStatusMessage(szInfo, MessageLevel::Normal);
1362 //statusBar()->showMessage(szInfo);
1363}
1364
1365void MainWindow::slotStatusMessage(QString szMessage, MessageLevel level)
1366{
1367 QString szLevel;
1368 QPalette pe;
1369 switch ((MessageLevel)level) {
1370 case MessageLevel::Error:
1371 pe.setColor(QPalette::WindowText, Qt::red);
1372 szLevel = "X";
1373 break;
1374 case MessageLevel::Warning:
1375 pe.setColor(QPalette::WindowText, Qt::yellow);
1376 szLevel = "!";
1377 break;
1378 default:
1379 break;
1380 }
1381 m_StatusBarMessage.setPalette(pe);
1382 m_StatusBarMessage.setToolTip(szMessage);
1383
1384 //QFontMetrics metrics(m_StatusBarMessage.font());
1385 //szMessage = metrics.elidedText(szMessage, Qt::ElideRight, m_StatusBarMessage.width());
1386
1387 m_StatusBarMessage.setText(szLevel);//*/
1388 statusBar()->showMessage(szMessage);
1389}
1390
1391void MainWindow::slotUpdateName()
1392{
1393 foreach (auto p, m_Operates)
1394 {
1395 m_pView->SetWidowsTitle(p->GetViewer(),
1396 p->Name(),
1397 p->Icon(),
1398 p->Description());
1399 }
1400}
1401
1402void MainWindow::slotUpdateName(const QString& szName)
1403{
1404 COperate* p = qobject_cast<COperate*>(sender());
1405 if(!p) return;
1406 // Update view
1407 m_pView->SetWidowsTitle(p->GetViewer(), szName,
1408 p->Icon(), p->Description());
1409
1410 // Update recent menu
1411 if(m_pRecentMenu)
1412 m_pRecentMenu->updateRecentFile(p->GetSettingsFile(), szName, p->Icon());
1413
1414 CRecentDatabase::RecentItem item;
1415 item.SetFile(p->GetSettingsFile());
1416 item.szName = p->Name();
1417 item.szDescription = p->Description();
1418 // Update recent list view dock widget
1419 m_pRecent->UpdateRecent(item);
1420
1421 // Update activity menu
1422 foreach(auto a, ui->menuActivity->actions()) {
1423 if(a->data().value<COperate*>() == p) {
1424 a->setText(szName);
1425 a->setIcon(p->Icon());
1426 break;
1427 }
1428 }
1429
1430 // Update favorite
1431 m_pFavoriteView->slotUpdateFavorite(
1432 p->GetSettingsFile(), szName, p->Description(), p->Icon());
1433
1434 //Update activity list view dock widget
1435 m_pFrmActive->slotLoad();
1436}
1437
1438QAction* MainWindow::GetStartAction(QMenu* pMenu, CPlugin *pPlug)
1439{
1440 QString szTitle;
1441 if(!pPlug->Protocol().isEmpty())
1442 szTitle = pPlug->Protocol() + ": ";
1443 szTitle += pPlug->DisplayName();
1444 QAction* p = pMenu->addAction(szTitle);
1445 p->setToolTip(pPlug->Description());
1446 p->setStatusTip(pPlug->Description());
1447 p->setData(pPlug->Id());
1448 p->setIcon(pPlug->Icon());
1449 return p;
1450}
1451
1452void MainWindow::slotStartByType()
1453{
1454 qDebug(log) << Q_FUNC_INFO;
1455 auto m = ui->menuStart->actions();
1456 foreach(auto a, m) {
1457 a->deleteLater();
1458 }
1459 foreach (auto a, m_MenuStartByType) {
1460 a->deleteLater();
1461 }
1462 ui->menuStart->clear();
1463 m_MenuStartByType.clear();
1464 m_Manager.EnumPlugins(this);
1465}
1466
1467int MainWindow::onProcess(const QString &id, CPlugin *pPlugin)
1468{
1469 Q_UNUSED(id);
1470 QMenu* m = ui->menuStart;
1471 if(m_Parameter.GetStartByType()) {
1472 auto it = m_MenuStartByType.find(pPlugin->Type());
1473 if(it == m_MenuStartByType.end()) {
1474 m = new QMenu(pPlugin->TypeName(pPlugin->Type()), ui->menuStart);
1475 m_MenuStartByType[pPlugin->Type()] = m;
1476 ui->menuStart->addMenu(m);
1477 } else
1478 m = *it;
1479 }
1480 // Start menu and toolbar
1481 QAction* p = GetStartAction(m, pPlugin);
1482 bool check = false;
1483 check = connect(p, SIGNAL(triggered()), this, SLOT(slotStart()));
1484 Q_ASSERT(check);
1485 return 0;
1486}
1487
1488void MainWindow::closeEvent(QCloseEvent *event)
1489{
1490 qDebug(log) << "MainWindow::closeEvent()";
1491
1492 if(m_Parameter.GetSaveMainWindowStatus())
1493 if(isFullScreen())
1494 on_actionFull_screen_F_triggered();
1495
1496 SaveOperateLasterClose();
1497
1498 foreach (auto it, m_Operates)
1499 {
1500 //TODO: Whether to save the setting
1501 emit it->sigUpdateParameters(it);
1502 it->Stop();
1503 }
1504
1505 QSettings set(RabbitCommon::CDir::Instance()->GetFileUserConfigure(),
1506 QSettings::IniFormat);
1507 if(m_Parameter.GetSaveMainWindowStatus())
1508 {
1509 set.setValue("MainWindow/Status/Geometry", saveGeometry());
1510 set.setValue("MainWindow/Status/State", saveState());
1511
1512 m_Parameter.SetTabBar(ui->actionTabBar_B->isChecked());
1513 m_Parameter.SetMenuBar(menuBar()->isVisible());
1514 m_Parameter.SetStatusBar(statusBar()->isVisible());
1515 } else {
1516 set.remove("MainWindow/Status/Geometry");
1517 set.remove("MainWindow/Status/State");
1518 }
1519
1520 m_Manager.SaveSettings();
1521 m_Parameter.Save();
1522
1523 QMainWindow::closeEvent(event);
1524
1525 //TODO: Wait for the background thread to exit
1526 QThread::sleep(1);
1527}
1528
1529int MainWindow::LoadOperateLasterClose()
1530{
1531 if(!m_Parameter.GetOpenLasterClose())
1532 return 0;
1533
1534 QFile f(RabbitCommon::CDir::Instance()->GetDirUserConfig()
1535 + QDir::separator() + "LasterClose.dat");
1536 if(f.open(QFile::ReadOnly))
1537 {
1538 QDataStream d(&f);
1539 while(1){
1540 QString szFile;
1541 d >> szFile;
1542 if(szFile.isEmpty())
1543 break;
1544 slotOpenFile(szFile);
1545 }
1546 f.close();
1547 }
1548 return 0;
1549}
1550
1551int MainWindow::SaveOperateLasterClose()
1552{
1553 QFile f(RabbitCommon::CDir::Instance()->GetDirUserConfig()
1554 + QDir::separator() + "LasterClose.dat");
1555 bool bRet = f.open(QFile::WriteOnly);
1556 if(bRet && m_Parameter.GetOpenLasterClose())
1557 {
1558 QDataStream d(&f);
1559 foreach(auto it, m_Operates)
1560 {
1561 d << it->GetSettingsFile();
1562 }
1563 }
1564 f.close();
1565 return 0;
1566}
1567
1568void MainWindow::on_actionTabBar_B_toggled(bool bShow)
1569{
1570 if(m_pView)
1571 {
1572 m_pView->SetVisibleTab(bShow);
1573 m_Parameter.SetTabBar(bShow);
1574 } else {
1575 if(m_pDockActive)
1576 m_pDockActive->setVisible(bShow);
1577 }
1578}
1579
1580void MainWindow::on_actionMain_menu_bar_M_toggled(bool checked)
1581{
1582 qDebug(log) << Q_FUNC_INFO << checked;
1583 if(ui->toolBar->isHidden() && !checked)
1584 {
1585 if( QMessageBox::StandardButton::Yes
1586 == QMessageBox::information(this, tr("Hide menu bar"),
1587 tr("The menu bar will be hidden, the tool bar must be showed."),
1588 QMessageBox::StandardButton::Yes
1589 | QMessageBox::StandardButton::No))
1590 {
1591 ui->actionToolBar_T->setChecked(true);
1592 if(m_pToolBarMenuAction)
1593 m_pToolBarMenuAction->setVisible(true);
1594 } else {
1595 ui->actionMain_menu_bar_M->setChecked(true);
1596#if !defined(Q_OS_ANDROID)
1597 if(m_pToolBarMenuAction)
1598 m_pToolBarMenuAction->setVisible(false);
1599#endif
1600 return;
1601 }
1602 }
1603
1604 menuBar()->setVisible(checked);
1605 m_Parameter.SetMenuBar(checked);
1606#if !defined(Q_OS_ANDROID)
1607 if(m_pToolBarMenuAction)
1608 m_pToolBarMenuAction->setVisible(!checked);
1609#endif
1610}
1611
1612void MainWindow::on_actionToolBar_T_toggled(bool checked)
1613{
1614 qDebug(log) << Q_FUNC_INFO << checked;
1615 if(menuBar()->isHidden() && !checked)
1616 {
1617 if( QMessageBox::StandardButton::Yes
1618 == QMessageBox::information(this, tr("Hide tool bar"),
1619 tr("The tool bar will be hidden, the menu bar must be showed."),
1620 QMessageBox::StandardButton::Yes
1621 | QMessageBox::StandardButton::No))
1622 {
1623 ui->actionMain_menu_bar_M->setChecked(true);
1624 } else {
1625 ui->actionToolBar_T->setChecked(true);
1626 return;
1627 }
1628 }
1629 ui->toolBar->setVisible(checked);
1630}
1631
1632void MainWindow::on_actionStatus_bar_S_toggled(bool checked)
1633{
1634 statusBar()->setVisible(checked);
1635 m_Parameter.SetStatusBar(checked);
1636}
1637
1638void MainWindow::on_actionKeyboard_triggered()
1639{
1640 auto inputMethod = QGuiApplication::inputMethod();
1641 if(inputMethod) {
1642 // QObject *focusObject = QGuiApplication::focusObject();
1643 // if(m_pView && m_pView->GetCurrentView())
1644 // focusObject = m_pView->GetCurrentView();
1645 // if (focusObject) {
1646 // // 可选：强制焦点对象发送输入法请求
1647 // QInputMethodEvent event;
1648 // QCoreApplication::sendEvent(focusObject, &event);
1649 // }
1650 inputMethod->show();
1651 }
1652}
1653
1654// [Get the widget that settings plugin parameters]
1655void MainWindow::on_actionSettings_triggered()
1656{
1657 CParameterDlgSettings set(&m_Parameter, this);
1658 auto viewers = m_Manager.GetSettingsWidgets(&set);
1659 set.AddViewers(viewers);
1660 if(CParameterDlgSettings::Accepted == RC_SHOW_WINDOW(&set))
1661 {
1662 m_Manager.SaveSettings();
1663 m_Parameter.Save();
1664 }
1665 foreach(auto v, viewers) {
1666 v->deleteLater();
1667 }
1668}
1669// [Get the widget that settings plugin parameters]
1670
1671void MainWindow::slotShortCut()
1672{
1673 if(m_Parameter.GetReceiveShortCut())
1674 {
1675 setFocusPolicy(Qt::WheelFocus);
1676 ui->actionFull_screen_F->setShortcuts(QKeySequence::FullScreen);
1677 } else {
1678 setFocusPolicy(Qt::NoFocus);
1679 ui->actionFull_screen_F->setShortcut(QKeySequence());
1680 }
1681}
1682
1683void MainWindow::on_actionOpenListRecent_triggered()
1684{
1685 CFrmRecent* p = new CFrmRecent(this, &m_Manager, m_Parameter, false);
1686 if(!p) return;
1687 bool check = connect(p, SIGNAL(sigStart(const QString&, bool)),
1688 this, SLOT(slotOpenFile(const QString&, bool)));
1689 Q_ASSERT(check);
1690 check = connect(p, SIGNAL(sigAddToFavorite(QString,QString,QString,QIcon)),
1691 m_pFavoriteView, SLOT(slotAddToFavorite(QString,QString,QString,QIcon)));
1692 Q_ASSERT(check);
1693
1694 int nRet = p->Initial();
1695 if(nRet) return;
1696
1697 QDialog d;
1698 d.resize(540, 400);
1699 d.setWindowIcon(windowIcon());
1700 d.setWindowTitle(p->windowTitle());
1701 QGridLayout* pLayout = new QGridLayout(&d);
1702 if(pLayout){
1703 pLayout->addWidget(p);
1704 check = connect(p, SIGNAL(destroyed()), &d, SLOT(reject()));
1705 d.setLayout(pLayout);
1706 }
1707 RC_SHOW_WINDOW(&d);
1708}
1709
1710void MainWindow::on_actionAdd_to_favorite_triggered()
1711{
1712 if(!m_pView || !m_pFavoriteView) return;
1713 QWidget* p = m_pView->GetCurrentView();
1714 foreach(auto c, m_Operates)
1715 {
1716 if(c->GetViewer() == p)
1717 {
1718 m_pFavoriteView->slotAddToFavorite(
1719 c->GetSettingsFile(), c->Name(), c->Description(), c->Icon());
1720 }
1721 }
1722}
1723
1724void MainWindow::dragEnterEvent(QDragEnterEvent *event)
1725{
1726 qDebug(log) << "dragEnterEvent";
1727
1728 if(event->mimeData()->hasUrls())
1729 {
1730 //qDebug(log) << event->mimeData()->urls();
1731 event->acceptProposedAction();
1732 }
1733}
1734
1735void MainWindow::dragMoveEvent(QDragMoveEvent *event)
1736{
1737 //qDebug(log) << "dragMoveEvent";
1738}
1739
1740void MainWindow::dropEvent(QDropEvent *event)
1741{
1742 qDebug(log) << "dropEvent";
1743 bool bRet = false;
1744 if(!event->mimeData()->hasUrls())
1745 return;
1746 auto urls = event->mimeData()->urls();
1747 foreach(auto url, urls)
1748 {
1749 if(url.isLocalFile())
1750 slotOpenFile(url.toLocalFile());
1751 bRet = true;
1752 }
1753 if(bRet)
1754 event->accept();
1755 else
1756 event->ignore();
1757}
1758
1759void MainWindow::slotSystemTrayIconActivated(QSystemTrayIcon::ActivationReason reason)
1760{
1761 //qDebug(log) << "MainWindow::slotSystemTrayIconActivated";
1762
1763 Q_UNUSED(reason)
1764#if defined(Q_OS_ANDROID)
1765 showMaximized();
1766#else
1767 switch(reason)
1768 {
1769 case QSystemTrayIcon::Trigger:
1770 {
1771 showNormal();
1772 activateWindow();
1773 break;
1774 }
1775 default:
1776 break;
1777 }
1778#endif
1779}
1780
1781void MainWindow::slotSystemTrayIconTypeChanged()
1782{
1783 //qDebug(log) << "MainWindow::slotSystemTrayIconTypeChanged:" << m_Parameter.GetEnableSystemTrayIcon();
1784 if(!QSystemTrayIcon::isSystemTrayAvailable())
1785 {
1786 qWarning(log) << "System tray is not available";
1787 return;
1788 }
1789
1790 if(!m_Parameter.GetEnableSystemTrayIcon())
1791 {
1792 qDebug(log) << "Disable system tray icon";
1793 return;
1794 }
1795
1796 if(m_TrayIcon)
1797 m_TrayIcon.reset();
1798
1799 m_TrayIcon = QSharedPointer<QSystemTrayIcon>(new QSystemTrayIcon(this));
1800 if(QSystemTrayIcon::isSystemTrayAvailable())
1801 {
1802 bool check = connect(
1803 m_TrayIcon.data(),
1804 SIGNAL(activated(QSystemTrayIcon::ActivationReason)),
1805 this,
1806 SLOT(slotSystemTrayIconActivated(QSystemTrayIcon::ActivationReason)));
1807 Q_ASSERT(check);
1808 m_TrayIcon->setIcon(this->windowIcon());
1809 m_TrayIcon->setToolTip(windowTitle());
1810 m_TrayIcon->show();
1811 } else
1812 qWarning(log) << "System tray is not available";
1813
1814 switch (m_Parameter.GetSystemTrayIconMenuType())
1815 {
1816 case CParameterApp::SystemTrayIconMenuType::MenuBar:
1817 {
1818 QMenu* pMenu = new QMenu(this);
1819 pMenu->addMenu(ui->menuOperate);
1820 pMenu->addMenu(ui->menuView);
1821 pMenu->addMenu(ui->menuTools);
1822 m_TrayIcon->setContextMenu(pMenu);
1823 break;
1824 }
1825 case CParameterApp::SystemTrayIconMenuType::Operate:
1826 m_TrayIcon->setContextMenu(ui->menuOperate);
1827 break;
1828 case CParameterApp::SystemTrayIconMenuType::RecentOpen:
1829 m_TrayIcon->setContextMenu(m_pRecentMenu);
1830 break;
1831 case CParameterApp::SystemTrayIconMenuType::View:
1832 m_TrayIcon->setContextMenu(ui->menuView);
1833 break;
1834 case CParameterApp::SystemTrayIconMenuType::Tools:
1835 m_TrayIcon->setContextMenu(ui->menuTools);
1836 break;
1837 case CParameterApp::SystemTrayIconMenuType::No:
1838 m_TrayIcon->setContextMenu(nullptr);
1839 break;
1840 }
1841}
1842
1843void MainWindow::slotEnableSystemTrayIcon()
1844{
1845 //qDebug(log) << "MainWindow::slotEnableSystemTryIcon()";
1846 if(m_TrayIcon)
1847 {
1848 if(!m_Parameter.GetEnableSystemTrayIcon())
1849 m_TrayIcon.reset();
1850 } else
1851 slotSystemTrayIconTypeChanged();
1852}
1853
1854void MainWindow::SetStatsVisible(bool visible)
1855{
1856 if(m_SendRate.isVisible() == visible)
1857 return;
1858 m_SendRate.setVisible(visible);
1859 m_ReceivesRate.setVisible(visible);
1860 m_TotalSends.setVisible(visible);
1861 m_TotalReceives.setVisible(visible);
1862}
1863
1864void MainWindow::StartTimer()
1865{
1866 bool bStart = false;
1867 int nMinInterval = 1;
1868 foreach(auto o, m_Operates) {
1869 if(o && o->GetStats()) {
1870 nMinInterval = qMin(nMinInterval, o->GetStats()->GetInterval());
1871 bStart = true;
1872 }
1873 }
1874 if(bStart) {
1875 m_Timer.start(nMinInterval * 1000);
1876 //qDebug(log) << "Time interval:" << nMinInterval;
1877 } else {
1878 m_Timer.stop();
1879 SetStatsVisible(false);
1880 }
1881}
1882
1883void MainWindow::slotTimeOut()
1884{
1885 //qDebug(log) << Q_FUNC_INFO;
1886 auto pWin = m_pView->GetCurrentView();
1887 if(!pWin) {
1888 qDebug(log) << "The current view is empty";
1889 return;
1890 }
1891 foreach(auto p, m_Operates)
1892 {
1893 if(p->GetViewer() == pWin)
1894 {
1895 auto pStats = p->GetStats();
1896 if(!pStats) {
1897 SetStatsVisible(false);
1898 break;
1899 }
1900 SetStatsVisible(true);
1901 pStats->slotCalculating();
1902 m_TotalSends.setText("⇈ " + pStats->TotalSends());
1903 m_TotalReceives.setText("⇊ " + pStats->TotalReceives());
1904 m_SendRate.setText("↑ " + pStats->SendRate());
1905 m_ReceivesRate.setText("↓ " + pStats->ReceiveRate());
1906 break;
1907 }
1908 }
1909}
1910
1911void MainWindow::on_actionUser_manual_triggered()
1912{
1913 QString szUrl = "https://github.com/KangLin/RabbitRemoteControl/wiki/UserManual";
1914 if(RabbitCommon::CTools::GetLanguage() == "zh_CN"
1915 || RabbitCommon::CTools::GetLanguage() == "zh_TW")
1916 szUrl += "_zh_CN";
1917}
1918
1919void MainWindow::on_actionLayoutDefault_triggered()
1920{
1921 qDebug(log) << Q_FUNC_INFO;
1922 if(!m_pDockActive->toggleViewAction()->isChecked())
1923 m_pDockActive->toggleViewAction()->trigger();
1924 if(!m_pDockFavorite->toggleViewAction()->isChecked())
1925 m_pDockFavorite->toggleViewAction()->trigger();
1926 if(!m_pDockRecent->toggleViewAction()->isChecked())
1927 m_pDockRecent->toggleViewAction()->trigger();
1928 m_Parameter.SetTabPosition(QTabWidget::North);
1929 if(!ui->actionTabBar_B->isChecked())
1930 ui->actionTabBar_B->trigger();
1931 if(!ui->actionMain_menu_bar_M->isChecked()) {
1932 ui->actionMain_menu_bar_M->trigger();
1933#if !defined(Q_OS_ANDROID)
1934 m_pToolBarMenuAction->setVisible(false);
1935#endif
1936 }
1937 if(!ui->actionToolBar_T->isChecked())
1938 ui->actionToolBar_T->trigger();
1939 addToolBar(Qt::TopToolBarArea, ui->toolBar);
1940 if(!ui->actionStatus_bar_S->isChecked())
1941 ui->actionStatus_bar_S->trigger();
1942}
1943
1944void MainWindow::on_actionLayoutSimple_triggered()
1945{
1946 qDebug(log) << Q_FUNC_INFO;
1947 if(m_pDockActive->toggleViewAction()->isChecked())
1948 m_pDockActive->toggleViewAction()->trigger();
1949 if(m_pDockFavorite->toggleViewAction()->isChecked())
1950 m_pDockFavorite->toggleViewAction()->trigger();
1951 if(m_pDockRecent->toggleViewAction()->isChecked())
1952 m_pDockRecent->toggleViewAction()->trigger();
1953 m_Parameter.SetTabPosition(QTabWidget::East);
1954 if(!ui->actionTabBar_B->isChecked())
1955 ui->actionTabBar_B->trigger();
1956 if(!ui->actionMain_menu_bar_M->isChecked()) {
1957 ui->actionMain_menu_bar_M->trigger();
1958#if !defined(Q_OS_ANDROID)
1959 m_pToolBarMenuAction->setVisible(false);
1960#endif
1961 }
1962 if(!ui->actionToolBar_T->isChecked())
1963 ui->actionToolBar_T->trigger();
1964 addToolBar(Qt::LeftToolBarArea, ui->toolBar);
1965 if(!ui->actionStatus_bar_S->isChecked())
1966 ui->actionStatus_bar_S->trigger();
1967}
1968
1969void MainWindow::on_actionLayoutMinimalism_triggered()
1970{
1971 qDebug(log) << Q_FUNC_INFO;
1972 if(m_pDockActive->toggleViewAction()->isChecked())
1973 m_pDockActive->toggleViewAction()->trigger();
1974 if(m_pDockFavorite->toggleViewAction()->isChecked())
1975 m_pDockFavorite->toggleViewAction()->trigger();
1976 if(m_pDockRecent->toggleViewAction()->isChecked())
1977 m_pDockRecent->toggleViewAction()->trigger();
1978 m_Parameter.SetTabPosition(QTabWidget::East);
1979 if(ui->actionTabBar_B->isChecked())
1980 ui->actionTabBar_B->trigger();
1981#if !defined(Q_OS_MACOS)
1982 if(ui->actionMain_menu_bar_M->isChecked()) {
1983 ui->actionMain_menu_bar_M->trigger();
1984 m_pToolBarMenuAction->setVisible(true);
1985 }
1986#endif
1987 if(!ui->actionToolBar_T->isChecked())
1988 ui->actionToolBar_T->trigger();
1989#if defined(Q_OS_LINUX)
1990 addToolBar(Qt::RightToolBarArea, ui->toolBar);
1991#else
1992 addToolBar(Qt::LeftToolBarArea, ui->toolBar);
1993#endif
1994 if(ui->actionStatus_bar_S->isChecked())
1995 ui->actionStatus_bar_S->trigger();
1996}
CFavoriteView
The CFavoriteView class.
Definition FavoriteView.h:20
CFavoriteView::sigShowMessageBox
virtual void sigShowMessageBox(const QString &title, const QString &message, const QMessageBox::Icon &icon)
Use message box display information.
CFrmRecent
List the connect of be existed.
Definition FrmRecent.h:23
CFrmRecent::sigShowMessageBox
virtual void sigShowMessageBox(const QString &title, const QString &message, const QMessageBox::Icon &icon)
Use message box display information.
CICE::Instance
static CICE * Instance()
Single instance.
Definition Ice.cpp:55
CManager::GetSettingsWidgets
virtual QList< QWidget * > GetSettingsWidgets(QWidget *parent)
Get parameter settings widget.
Definition Manager.cpp:565
CManager::EnumPlugins
virtual int EnumPlugins(Handle *handle)
Enum plugins.
Definition Manager.cpp:636
CManager::CreateOperate
virtual COperate * CreateOperate(const QString &id)
New COperate pointer, the owner is caller.
Definition Manager.cpp:364
CManager::LoadOperate
virtual COperate * LoadOperate(const QString &szFile)
New COperate pointer from file, the owner is caller.
Definition Manager.cpp:425
CManager::DeleteOperate
virtual int DeleteOperate(COperate *p)
Delete COperate.
Definition Manager.cpp:392
CManager::SaveOperate
virtual int SaveOperate(COperate *pOperate)
Accept Operate parameters to file.
Definition Manager.cpp:476
CManager::Initial
int Initial(QString szFile=QString())
Initial.
Definition Manager.cpp:82
CManager::SaveSettings
virtual int SaveSettings(const QString szFile=QString())
Save Client parameters to file.
Definition Manager.cpp:544
CManager::GetGlobalParameters
CParameterGlobal * GetGlobalParameters()
Get Global Parameters.
Definition Manager.cpp:558
CManager::sigNewOperate
void sigNewOperate(COperate *pOperate, bool bOpenSettingsDialog)
This signal is triggered when a new operate is created in the plugin.
COperate
Operate interface.
Definition Operate.h:51
COperate::OpenDialogSettings
virtual int OpenDialogSettings(QWidget *parent=nullptr)
Open settings dialog.
Definition Operate.cpp:97
COperate::GetSecurityLevel
virtual CSecurityLevel::Levels GetSecurityLevel() const
Get Security Level.
Definition Operate.cpp:129
COperate::GetStats
virtual CStats * GetStats()
Get statistics.
Definition Operate.cpp:124
COperate::Start
virtual int Start()=0
Start.
COperate::sigFullScreen
void sigFullScreen(bool bFullScreen)
Full screen.
COperate::GetViewer
virtual QWidget * GetViewer()=0
Get Viewer.
COperate::Name
virtual const QString Name()
Name.
Definition Operate.cpp:46
COperate::Stop
virtual int Stop()=0
Stop.
COperate::Description
virtual const QString Description()
Description.
Definition Operate.cpp:51
COperate::sigUpdateParameters
void sigUpdateParameters(COperate *pOperate)
Update parameters, notify application to save or show parameters.
COperate::sigSecurityLevel
void sigSecurityLevel()
Triggered when the security level changes.
COperate::GetMenu
virtual QMenu * GetMenu(QWidget *parent=nullptr)
Get menu.
Definition Operate.cpp:117
CParameterGlobal
Global parameters.
Definition ParameterGlobal.h:32
CParameter::Save
virtual int Save(QString szFile=QString(), bool bForce=true)
Save to file.
Definition Parameter.cpp:47
CPlugin
Plugin interface.
Definition Plugin.h:15
CPlugin::DisplayName
virtual const QString DisplayName() const
The plugin display name.
Definition Plugin.cpp:76
CPlugin::Protocol
virtual const QString Protocol() const =0
Plugin Protocol.
CPlugin::Id
virtual const QString Id() const
ID. Default: Type() + ":" + Protocol() + ":" + Name()
Definition Plugin.cpp:71
CPlugin::Description
virtual const QString Description() const =0
Plugin description.
CStats::GetInterval
int GetInterval()
Get interval.
Definition Stats.cpp:84
CViewSplitter
The split view class.
Definition ViewSplitter.h:15
CViewTable
The CViewTable class.
Definition ViewTable.h:16
CView
The CView class.
Definition View.h:25
CView::AddView
virtual int AddView(QWidget *pView)=0
CView::GetCurrentView
virtual QWidget * GetCurrentView()=0
CView::RemoveView
virtual int RemoveView(QWidget *pView)=0
MainWindow
The MainWindow class.
Definition mainwindow.h:36
MainWindow::Start
Q_INVOKABLE int Start(COperate *pOperate, bool set, QString szFile=QString())
Start.
Definition mainwindow.cpp:1005
MainWindow::onProcess
virtual int onProcess(const QString &id, CPlugin *pPlugin) override
Process plugins.
Definition mainwindow.cpp:1467
MainWindow::slotInformation
void slotInformation(const QString &szInfo)
Show information.
Definition mainwindow.cpp:1359
MainWindow::slotShowMessageBox
virtual void slotShowMessageBox(const QString &title, const QString &message, const QMessageBox::Icon &icon)
Use message box display information.
Definition mainwindow.cpp:1338
MainWindow::slotRunning
void slotRunning()
[MainWindow slotRunning]
Definition mainwindow.cpp:1134
MainWindow::slotCloseView
void slotCloseView(const QWidget *pView)
[MainWindow slotRunning]
Definition mainwindow.cpp:1171
MainWindow::slotCustomContextMenuRequested
void slotCustomContextMenuRequested(const QPoint &pos)
MainWindow::slotCustomContextMenuRequested.
Definition mainwindow.cpp:888
MainWindow::Initial
int Initial()
For time-consuming operations.
Definition mainwindow.cpp:428
Author: Kang Lin (kl222@126.com)

Copyright (c) Kang Lin Studios All Rights Reserved