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

Copyright (c) Kang Lin Studios All Rights Reserved