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

Copyright (c) Kang Lin Studios All Rights Reserved