void tst_QToolBar::toggleViewAction()
{
{
QToolBar tb;
QAction *toggleViewAction = tb.toggleViewAction();
QVERIFY(tb.isHidden());
toggleViewAction->trigger();
QVERIFY(!tb.isHidden());
toggleViewAction->trigger();
QVERIFY(tb.isHidden());
}
{
QMainWindow mw;
QToolBar tb(&mw);
mw.addToolBar(&tb);
mw.show();
QAction *toggleViewAction = tb.toggleViewAction();
QVERIFY(!tb.isHidden());
toggleViewAction->trigger();
QVERIFY(tb.isHidden());
toggleViewAction->trigger();
QVERIFY(!tb.isHidden());
toggleViewAction->trigger();
QVERIFY(tb.isHidden());
}
}
bool ActionManager::initWithApp(IApplication *app)
{
if (!IActionManager::initWithApp(app)) {
return false;
}
insertMenu(ID_MENU_FILE,tr("&File"));
insertMenu(ID_MENU_RECENT,tr("&Recent"));
insertMenu(ID_MENU_EDIT,tr("&Edit"));
insertMenu(ID_MENU_FIND,tr("F&ind"));
m_viewMenu = insertMenu(ID_MENU_VIEW,tr("&View"));
m_viewMenu->addSeparator();
m_baseToolBarAct = m_viewMenu->addSeparator();
m_baseBrowserAct = m_viewMenu->addSeparator();
m_viewMenu->addSeparator();
insertMenu(ID_MENU_TOOLS,tr("&Tools"));
insertMenu(ID_MENU_BUILD,tr("&Build"));
insertMenu(ID_MENU_DEBUG,tr("&Debug"));
insertMenu(ID_MENU_HELP,tr("&Help"));
QToolBar *stdToolBar = insertToolBar(ID_TOOLBAR_STD,tr("Standard Toolbar"));
insertViewMenu(LiteApi::ViewMenuToolBarPos,stdToolBar->toggleViewAction());
return true;
}
QToolBar *BrowserWindow::createToolBar()
{
QToolBar *navigationBar = new QToolBar(tr("Navigation"));
navigationBar->setAllowedAreas(Qt::TopToolBarArea | Qt::BottomToolBarArea);
navigationBar->toggleViewAction()->setEnabled(false);
m_historyBackAction = new QAction(this);
QList<QKeySequence> backShortcuts = QKeySequence::keyBindings(QKeySequence::Back);
for (auto it = backShortcuts.begin(); it != backShortcuts.end();) {
// Chromium already handles navigate on backspace when appropriate.
if ((*it)[0] == Qt::Key_Backspace)
it = backShortcuts.erase(it);
else
++it;
}
// For some reason Qt doesn't bind the dedicated Back key to Back.
backShortcuts.append(QKeySequence(Qt::Key_Back));
m_historyBackAction->setShortcuts(backShortcuts);
m_historyBackAction->setIconVisibleInMenu(false);
m_historyBackAction->setIcon(QIcon(QStringLiteral(":go-previous.png")));
connect(m_historyBackAction, &QAction::triggered, [this]() {
m_tabWidget->triggerWebPageAction(QWebEnginePage::Back);
});
navigationBar->addAction(m_historyBackAction);
m_historyForwardAction = new QAction(this);
QList<QKeySequence> fwdShortcuts = QKeySequence::keyBindings(QKeySequence::Forward);
for (auto it = fwdShortcuts.begin(); it != fwdShortcuts.end();) {
if (((*it)[0] & Qt::Key_unknown) == Qt::Key_Backspace)
it = fwdShortcuts.erase(it);
else
++it;
}
fwdShortcuts.append(QKeySequence(Qt::Key_Forward));
m_historyForwardAction->setShortcuts(fwdShortcuts);
m_historyForwardAction->setIconVisibleInMenu(false);
m_historyForwardAction->setIcon(QIcon(QStringLiteral(":go-next.png")));
connect(m_historyForwardAction, &QAction::triggered, [this]() {
m_tabWidget->triggerWebPageAction(QWebEnginePage::Forward);
});
navigationBar->addAction(m_historyForwardAction);
m_stopReloadAction = new QAction(this);
connect(m_stopReloadAction, &QAction::triggered, [this]() {
m_tabWidget->triggerWebPageAction(QWebEnginePage::WebAction(m_stopReloadAction->data().toInt()));
});
navigationBar->addAction(m_stopReloadAction);
navigationBar->addWidget(m_urlLineEdit);
int size = m_urlLineEdit->sizeHint().height();
navigationBar->setIconSize(QSize(size, size));
return navigationBar;
}
WebViewWindow::WebViewWindow(QWidget *parent) :
QMainWindow(parent)
{
QAction* reloadAction = new QAction(QApplication::style()->standardIcon(QStyle::SP_BrowserReload), tr("Reload"), this);
reloadAction->setShortcut(QKeySequence(QKeySequence::Refresh));
QToolBar* toolBar = new QToolBar(tr("ToolBar"), this);
mAddressBar = new QLineEdit(toolBar);
mAddressBar->setReadOnly(true);
toolBar->addWidget(mAddressBar);
toolBar->addAction(reloadAction);
toolBar->setMovable(false);
toolBar->hide();
toolBar->installEventFilter(this);
mToolBar = toolBar;
addToolBar(toolBar);
QMenuBar* menuBar = this->menuBar();
QMenu* fileMenu = menuBar->addMenu(tr("&File"));
fileMenu->addAction(reloadAction);
QAction* quitAction = fileMenu->addAction(QIcon(":/media/application_exit.png"), tr("Quit"));
connect(quitAction, SIGNAL(triggered()), this, SLOT(close()));
QMenu* viewMenu = menuBar->addMenu(tr("&View"));
viewMenu->addAction(toolBar->toggleViewAction());
QMenu* debugMenu = menuBar->addMenu(tr("&Debug"));
QAction* inspectAction = debugMenu->addAction(tr("Inspect"));
connect(inspectAction, SIGNAL(triggered()), this, SLOT(showWebInspector()));
mWebView = new QWebView(this);
mWebInspector = 0;
QWebSettings* webSettings = mWebView->settings();
webSettings->setAttribute(QWebSettings::LocalStorageEnabled, true);
webSettings->setAttribute(QWebSettings::DeveloperExtrasEnabled, true);
QWidget* centralWidget = new QWidget(this);
QVBoxLayout* layout = new QVBoxLayout(centralWidget);
layout->setContentsMargins(0, 0, 0, 0);
layout->addWidget(mWebView);
layout->setAlignment(mWebView, Qt::AlignCenter);
setCentralWidget(centralWidget);
setWindowModality(Qt::WindowModal);
connect(reloadAction, SIGNAL(triggered()), mWebView, SLOT(reload()));
loadWebInspector();
}
bool ActionManager::initWithApp(IApplication *app)
{
if (!IActionManager::initWithApp(app)) {
return false;
}
insertMenu("menu/file",tr("&File"));
insertMenu("menu/recent",tr("&Recent"));
insertMenu("menu/edit",tr("&Edit"));
insertMenu("menu/find",tr("F&ind"));
m_viewMenu = insertMenu("menu/view",tr("&View"));
m_viewToolMenu = m_viewMenu->addMenu(tr("Tool Windows"));
m_viewMenu->addSeparator();
m_baseToolBarAct = m_viewMenu->addSeparator();
m_baseBrowserAct = m_viewMenu->addSeparator();
m_viewMenu->addSeparator();
insertMenu("menu/help",tr("&Help"));
QToolBar *stdToolBar = insertToolBar("toolbar/std",tr("Standard Toolbar"));
insertViewMenu(LiteApi::ViewMenuToolBarPos,stdToolBar->toggleViewAction());
return true;
}
QT_BEGIN_NAMESPACE
MainWindow::MainWindow(CmdLineParser *cmdLine, QWidget *parent)
: QMainWindow(parent)
, m_bookmarkWidget(0)
, m_filterCombo(0)
, m_toolBarMenu(0)
, m_cmdLine(cmdLine)
, m_progressWidget(0)
, m_qtDocInstaller(0)
, m_connectedInitSignals(false)
{
TRACE_OBJ
setToolButtonStyle(Qt::ToolButtonFollowStyle);
setDockOptions(dockOptions() | AllowNestedDocks);
QString collectionFile;
if (usesDefaultCollection()) {
MainWindow::collectionFileDirectory(true);
collectionFile = MainWindow::defaultHelpCollectionFileName();
} else {
collectionFile = cmdLine->collectionFile();
}
HelpEngineWrapper &helpEngineWrapper =
HelpEngineWrapper::instance(collectionFile);
BookmarkManager *bookMarkManager = BookmarkManager::instance();
if (!initHelpDB(!cmdLine->collectionFileGiven())) {
qDebug("Fatal error: Help engine initialization failed. "
"Error message was: %s\nAssistant will now exit.",
qPrintable(HelpEngineWrapper::instance().error()));
std::exit(1);
}
m_centralWidget = new CentralWidget(this);
setCentralWidget(m_centralWidget);
m_indexWindow = new IndexWindow(this);
QDockWidget *indexDock = new QDockWidget(tr("Index"), this);
indexDock->setObjectName(QLatin1String("IndexWindow"));
indexDock->setWidget(m_indexWindow);
addDockWidget(Qt::LeftDockWidgetArea, indexDock);
m_contentWindow = new ContentWindow;
QDockWidget *contentDock = new QDockWidget(tr("Contents"), this);
contentDock->setObjectName(QLatin1String("ContentWindow"));
contentDock->setWidget(m_contentWindow);
addDockWidget(Qt::LeftDockWidgetArea, contentDock);
m_searchWindow = new SearchWidget(helpEngineWrapper.searchEngine());
m_searchWindow->setFont(!helpEngineWrapper.usesBrowserFont() ? qApp->font()
: helpEngineWrapper.browserFont());
QDockWidget *searchDock = new QDockWidget(tr("Search"), this);
searchDock->setObjectName(QLatin1String("SearchWindow"));
searchDock->setWidget(m_searchWindow);
addDockWidget(Qt::LeftDockWidgetArea, searchDock);
QDockWidget *bookmarkDock = new QDockWidget(tr("Bookmarks"), this);
bookmarkDock->setObjectName(QLatin1String("BookmarkWindow"));
bookmarkDock->setWidget(m_bookmarkWidget
= bookMarkManager->bookmarkDockWidget());
addDockWidget(Qt::LeftDockWidgetArea, bookmarkDock);
QDockWidget *openPagesDock = new QDockWidget(tr("Open Pages"), this);
openPagesDock->setObjectName(QLatin1String("Open Pages"));
OpenPagesManager *openPagesManager
= OpenPagesManager::createInstance(this, usesDefaultCollection(), m_cmdLine->url());
openPagesDock->setWidget(openPagesManager->openPagesWidget());
addDockWidget(Qt::LeftDockWidgetArea, openPagesDock);
connect(m_centralWidget, SIGNAL(addBookmark(QString, QString)),
bookMarkManager, SLOT(addBookmark(QString, QString)));
connect(bookMarkManager, SIGNAL(escapePressed()), this,
SLOT(activateCurrentCentralWidgetTab()));
connect(bookMarkManager, SIGNAL(setSource(QUrl)), m_centralWidget,
SLOT(setSource(QUrl)));
connect(bookMarkManager, SIGNAL(setSourceInNewTab(QUrl)),
openPagesManager, SLOT(createPage(QUrl)));
QHelpSearchEngine *searchEngine = helpEngineWrapper.searchEngine();
connect(searchEngine, SIGNAL(indexingStarted()), this, SLOT(indexingStarted()));
connect(searchEngine, SIGNAL(indexingFinished()), this, SLOT(indexingFinished()));
QString defWindowTitle = tr("Qt Assistant");
setWindowTitle(defWindowTitle);
setupActions();
statusBar()->show();
m_centralWidget->connectTabBar();
setupFilterToolbar();
setupAddressToolbar();
const QString windowTitle = helpEngineWrapper.windowTitle();
setWindowTitle(windowTitle.isEmpty() ? defWindowTitle : windowTitle);
QByteArray iconArray = helpEngineWrapper.applicationIcon();
if (iconArray.size() > 0) {
QPixmap pix;
pix.loadFromData(iconArray);
QIcon appIcon(pix);
qApp->setWindowIcon(appIcon);
} else {
QIcon appIcon(QLatin1String(":/trolltech/assistant/images/assistant-128.png"));
qApp->setWindowIcon(appIcon);
}
QToolBar *toolBar = addToolBar(tr("Bookmark Toolbar"));
toolBar->setObjectName(QLatin1String("Bookmark Toolbar"));
bookMarkManager->setBookmarksToolbar(toolBar);
// Show the widget here, otherwise the restore geometry and state won't work
// on x11.
show();
toolBar->hide();
toolBarMenu()->addAction(toolBar->toggleViewAction());
QByteArray ba(helpEngineWrapper.mainWindow());
if (!ba.isEmpty())
restoreState(ba);
ba = helpEngineWrapper.mainWindowGeometry();
if (!ba.isEmpty()) {
restoreGeometry(ba);
} else {
tabifyDockWidget(contentDock, indexDock);
tabifyDockWidget(indexDock, bookmarkDock);
tabifyDockWidget(bookmarkDock, searchDock);
contentDock->raise();
const QRect screen = QApplication::desktop()->screenGeometry();
resize(4*screen.width()/5, 4*screen.height()/5);
}
if (!helpEngineWrapper.hasFontSettings()) {
helpEngineWrapper.setUseAppFont(false);
helpEngineWrapper.setUseBrowserFont(false);
helpEngineWrapper.setAppFont(qApp->font());
helpEngineWrapper.setAppWritingSystem(QFontDatabase::Latin);
helpEngineWrapper.setBrowserFont(qApp->font());
helpEngineWrapper.setBrowserWritingSystem(QFontDatabase::Latin);
} else {
updateApplicationFont();
}
updateAboutMenuText();
QTimer::singleShot(0, this, SLOT(insertLastPages()));
if (m_cmdLine->enableRemoteControl())
(void)new RemoteControl(this);
if (m_cmdLine->contents() == CmdLineParser::Show)
showContents();
else if (m_cmdLine->contents() == CmdLineParser::Hide)
hideContents();
if (m_cmdLine->index() == CmdLineParser::Show)
showIndex();
else if (m_cmdLine->index() == CmdLineParser::Hide)
hideIndex();
if (m_cmdLine->bookmarks() == CmdLineParser::Show)
showBookmarksDockWidget();
else if (m_cmdLine->bookmarks() == CmdLineParser::Hide)
hideBookmarksDockWidget();
if (m_cmdLine->search() == CmdLineParser::Show)
showSearch();
else if (m_cmdLine->search() == CmdLineParser::Hide)
hideSearch();
if (m_cmdLine->contents() == CmdLineParser::Activate)
showContents();
else if (m_cmdLine->index() == CmdLineParser::Activate)
showIndex();
else if (m_cmdLine->bookmarks() == CmdLineParser::Activate)
showBookmarksDockWidget();
if (!m_cmdLine->currentFilter().isEmpty()) {
const QString &curFilter = m_cmdLine->currentFilter();
if (helpEngineWrapper.customFilters().contains(curFilter))
helpEngineWrapper.setCurrentFilter(curFilter);
}
if (usesDefaultCollection())
QTimer::singleShot(0, this, SLOT(lookForNewQtDocumentation()));
else
checkInitState();
connect(&helpEngineWrapper, SIGNAL(documentationRemoved(QString)),
this, SLOT(documentationRemoved(QString)));
connect(&helpEngineWrapper, SIGNAL(documentationUpdated(QString)),
this, SLOT(documentationUpdated(QString)));
setTabPosition(Qt::AllDockWidgetAreas, QTabWidget::North);
GlobalActions::instance()->updateActions();
if (helpEngineWrapper.addressBarEnabled())
showNewAddress();
}
void CelestiaAppWindow::init(const QString& qConfigFileName,
const QStringList& qExtrasDirectories)
{
QString celestia_data_dir = QString::fromLocal8Bit(::getenv("CELESTIA_DATA_DIR"));
if (celestia_data_dir.isEmpty()) {
QString celestia_data_dir = CONFIG_DATA_DIR;
QDir::setCurrent(celestia_data_dir);
} else if (QDir(celestia_data_dir).isReadable()) {
QDir::setCurrent(celestia_data_dir);
} else {
QMessageBox::critical(0, "Celestia",
_("Celestia is unable to run because the data directroy was not "
"found, probably due to improper installation."));
exit(1);
}
// Get the config file name
string configFileName;
if (qConfigFileName.isEmpty())
configFileName = DEFAULT_CONFIG_FILE.toUtf8().data();
else
configFileName = qConfigFileName.toUtf8().data();
// Translate extras directories from QString -> std::string
vector<string> extrasDirectories;
for (QStringList::const_iterator iter = qExtrasDirectories.begin();
iter != qExtrasDirectories.end(); iter++)
{
extrasDirectories.push_back(iter->toUtf8().data());
}
#ifdef TARGET_OS_MAC
static short domains[] = { kUserDomain, kLocalDomain, kNetworkDomain };
int domain = 0;
int domainCount = (sizeof domains / sizeof(short));
QString resourceDir = QDir::currentPath();
while (!QDir::setCurrent(resourceDir+"/CelestiaResources") && domain < domainCount)
{
FSRef folder;
CFURLRef url;
UInt8 fullPath[PATH_MAX];
if (noErr == FSFindFolder(domains[domain++], kApplicationSupportFolderType, FALSE, &folder))
{
url = CFURLCreateFromFSRef(nil, &folder);
if (CFURLGetFileSystemRepresentation(url, TRUE, fullPath, PATH_MAX))
resourceDir = (const char *)fullPath;
CFRelease(url);
}
}
if (domain >= domainCount)
{
QMessageBox::critical(0, "Celestia",
_("Celestia is unable to run because the CelestiaResources folder was not "
"found, probably due to improper installation."));
exit(1);
}
#endif
initAppDataDirectory();
m_appCore = new CelestiaCore();
AppProgressNotifier* progress = new AppProgressNotifier(this);
alerter = new AppAlerter(this);
m_appCore->setAlerter(alerter);
setWindowIcon(QIcon(":/icons/celestia.png"));
m_appCore->initSimulation(&configFileName,
&extrasDirectories,
progress);
delete progress;
// Enable antialiasing if requested in the config file.
// TODO: Make this settable via the GUI
QGLFormat glformat = QGLFormat::defaultFormat();
if (m_appCore->getConfig()->aaSamples > 1)
{
glformat.setSampleBuffers(true);
glformat.setSamples(m_appCore->getConfig()->aaSamples);
QGLFormat::setDefaultFormat(glformat);
}
glWidget = new CelestiaGlWidget(NULL, "Celestia", m_appCore);
glWidget->makeCurrent();
GLenum glewErr = glewInit();
if (glewErr != GLEW_OK)
{
QMessageBox::critical(0, "Celestia",
QString(_("Celestia was unable to initialize OpenGL extensions (error %1). Graphics quality will be reduced.")).arg(glewErr));
}
m_appCore->setCursorHandler(glWidget);
m_appCore->setContextMenuCallback(ContextMenu);
MainWindowInstance = this; // TODO: Fix context menu callback
setCentralWidget(glWidget);
setWindowTitle("Celestia");
actions = new CelestiaActions(this, m_appCore);
createMenus();
QTabWidget* tabWidget = new QTabWidget(this);
tabWidget->setObjectName("celestia-tabbed-browser");
toolsDock = new QDockWidget(_("Celestial Browser"), this);
toolsDock->setObjectName("celestia-tools-dock");
toolsDock->setAllowedAreas(Qt::LeftDockWidgetArea |
Qt::RightDockWidgetArea);
// Create the various browser widgets
celestialBrowser = new CelestialBrowser(m_appCore, NULL);
celestialBrowser->setObjectName("celestia-browser");
connect(celestialBrowser,
SIGNAL(selectionContextMenuRequested(const QPoint&, Selection&)),
this,
SLOT(slotShowSelectionContextMenu(const QPoint&, Selection&)));
QWidget* deepSkyBrowser = new DeepSkyBrowser(m_appCore, NULL);
deepSkyBrowser->setObjectName("deepsky-browser");
connect(deepSkyBrowser,
SIGNAL(selectionContextMenuRequested(const QPoint&, Selection&)),
this,
SLOT(slotShowSelectionContextMenu(const QPoint&, Selection&)));
SolarSystemBrowser* solarSystemBrowser = new SolarSystemBrowser(m_appCore, NULL);
solarSystemBrowser->setObjectName("ssys-browser");
connect(solarSystemBrowser,
SIGNAL(selectionContextMenuRequested(const QPoint&, Selection&)),
this,
SLOT(slotShowSelectionContextMenu(const QPoint&, Selection&)));
// Set up the browser tabs
tabWidget->addTab(solarSystemBrowser, _("Solar System"));
tabWidget->addTab(celestialBrowser, _("Stars"));
tabWidget->addTab(deepSkyBrowser, _("Deep Sky Objects"));
toolsDock->setWidget(tabWidget);
addDockWidget(Qt::LeftDockWidgetArea, toolsDock);
infoPanel = new InfoPanel(_("Info Browser"), this);
infoPanel->setObjectName("info-panel");
infoPanel->setAllowedAreas(Qt::LeftDockWidgetArea |
Qt::RightDockWidgetArea);
addDockWidget(Qt::RightDockWidgetArea, infoPanel);
infoPanel->setVisible(false);
eventFinder = new EventFinder(m_appCore, _("Event Finder"), this);
eventFinder->setObjectName("event-finder");
eventFinder->setAllowedAreas(Qt::LeftDockWidgetArea |
Qt::RightDockWidgetArea);
addDockWidget(Qt::LeftDockWidgetArea, eventFinder);
eventFinder->setVisible(false);
//addDockWidget(Qt::DockWidgetArea, eventFinder);
// Create the time toolbar
TimeToolBar* timeToolBar = new TimeToolBar(m_appCore, _("Time"));
timeToolBar->setObjectName("time-toolbar");
timeToolBar->setFloatable(true);
timeToolBar->setMovable(true);
addToolBar(Qt::TopToolBarArea, timeToolBar);
// Create the guides toolbar
QToolBar* guidesToolBar = new QToolBar(_("Guides"));
guidesToolBar->setObjectName("guides-toolbar");
guidesToolBar->setFloatable(true);
guidesToolBar->setMovable(true);
guidesToolBar->setToolButtonStyle(Qt::ToolButtonTextOnly);
guidesToolBar->addAction(actions->equatorialGridAction);
guidesToolBar->addAction(actions->galacticGridAction);
guidesToolBar->addAction(actions->eclipticGridAction);
guidesToolBar->addAction(actions->horizonGridAction);
guidesToolBar->addAction(actions->eclipticAction);
guidesToolBar->addAction(actions->markersAction);
guidesToolBar->addAction(actions->constellationsAction);
guidesToolBar->addAction(actions->boundariesAction);
guidesToolBar->addAction(actions->orbitsAction);
guidesToolBar->addAction(actions->labelsAction);
addToolBar(Qt::TopToolBarArea, guidesToolBar);
// Give keyboard focus to the 3D view
glWidget->setFocus();
m_bookmarkManager = new BookmarkManager(this);
// Load the bookmarks file and nitialize the bookmarks menu
if (!loadBookmarks())
m_bookmarkManager->initializeBookmarks();
populateBookmarkMenu();
connect(m_bookmarkManager, SIGNAL(bookmarkTriggered(const QString&)),
this, SLOT(slotBookmarkTriggered(const QString&)));
m_bookmarkToolBar = new BookmarkToolBar(m_bookmarkManager, this);
m_bookmarkToolBar->setObjectName("bookmark-toolbar");
m_bookmarkToolBar->rebuild();
addToolBar(Qt::TopToolBarArea, m_bookmarkToolBar);
// Read saved window preferences
readSettings();
// Build the view menu
// Add dockable panels and toolbars to the view menu
viewMenu->addAction(timeToolBar->toggleViewAction());
viewMenu->addAction(guidesToolBar->toggleViewAction());
viewMenu->addAction(m_bookmarkToolBar->toggleViewAction());
viewMenu->addSeparator();
viewMenu->addAction(toolsDock->toggleViewAction());
viewMenu->addAction(infoPanel->toggleViewAction());
viewMenu->addAction(eventFinder->toggleViewAction());
viewMenu->addSeparator();
QAction* fullScreenAction = new QAction(_("Full screen"), this);
fullScreenAction->setCheckable(true);
fullScreenAction->setShortcut(QString(_("Shift+F11")));
// Set the full screen check state only after reading settings
fullScreenAction->setChecked(isFullScreen());
connect(fullScreenAction, SIGNAL(triggered()), this, SLOT(slotToggleFullScreen()));
viewMenu->addAction(fullScreenAction);
// We use a timer with a null timeout value
// to add m_appCore->tick to Qt's event loop
QTimer *t = new QTimer(dynamic_cast<QObject *>(this));
QObject::connect(t, SIGNAL(timeout()), SLOT(celestia_tick()));
t->start(0);
}
void Mainframe::show()
{
// prevent multiple inserting of menu entries, by calls of showFullScreen(), ...
if (preferences_action_ != 0)
{
MainControl::show();
return;
}
QToolBar* tb = NULL;
if (UIOperationMode::instance().getMode() <= UIOperationMode::MODE_ADVANCED)
{
tb = new QToolBar("Main Toolbar", this);
tb->setObjectName("Main Toolbar");
tb->setIconSize(QSize(22,22));
addToolBar(Qt::TopToolBarArea, tb);
}
MainControl::show();
QMenu *menu = initPopupMenu(MainControl::WINDOWS, UIOperationMode::MODE_ADVANCED);
if (menu)
{
menu->addSeparator();
menu->addAction(tb->toggleViewAction());
}
// NOTE: this *has* to be run... a null pointer is unproblematic
if (UIOperationMode::instance().getMode() <= UIOperationMode::MODE_ADVANCED)
{
MolecularFileDialog::getInstance(0)->addToolBarEntries(tb);
DownloadPDBFile::getInstance(0)->addToolBarEntries(tb);
DownloadElectronDensity::getInstance(0)->addToolBarEntries(tb);
PubChemDialog::getInstance(0)->addToolBarEntries(tb);
UndoManagerDialog::getInstance(0)->addToolBarEntries(tb);
tb->addAction(fullscreen_action_);
Path path;
IconLoader& loader = IconLoader::instance();
qload_action_ = new QAction(loader.getIcon("actions/quickopen-file"), tr("quickload"), this);
qload_action_->setObjectName("quickload");
connect(qload_action_, SIGNAL(triggered()), this, SLOT(quickLoadConfirm()));
HelpViewer::getInstance("BALLView Docu")->registerForHelpSystem(qload_action_, "tips.html#quickload");
tb->addAction(qload_action_);
qsave_action_ = new QAction(loader.getIcon("actions/quicksave"), tr("quicksave"), this);
qsave_action_->setObjectName("quicksave");
connect(qsave_action_, SIGNAL(triggered()), this, SLOT(quickSave()));
HelpViewer::getInstance("BALLView Docu")->registerForHelpSystem(qsave_action_, "tips.html#quickload");
tb->addAction(qsave_action_);
tb->addSeparator();
DisplayProperties::getInstance(0)->addToolBarEntries(tb);
MolecularStructure::getInstance(0)->addToolBarEntries(tb);
}
scene_->addToolBarEntries(tb);
if (UIOperationMode::instance().getMode() <= UIOperationMode::MODE_ADVANCED)
{
tb->addAction(stop_simulation_action_);
tb->addAction(preferences_action_);
HelpViewer::getInstance("BALLView Docu")->addToolBarEntries(tb);
}
// we have changed the child widgets stored in the maincontrol (e.g. toolbars), so we have
// to restore the window state again!
restoreWindows();
}
SignalFileBrowserWindow::SignalFileBrowserWindow(QWidget* parent) : QMainWindow(parent)
{
setWindowTitle(title);
signalViewer = new SignalViewer(this);
setCentralWidget(signalViewer);
// Construct dock widgets.
setDockNestingEnabled(true);
QDockWidget* trackManagerDockWidget = new QDockWidget("Track Manager", this);
trackManagerDockWidget->setObjectName("Track Manager QDockWidget");
trackManager = new TrackManager(this);
trackManagerDockWidget->setWidget(trackManager);
QDockWidget* eventManagerDockWidget = new QDockWidget("Event Manager", this);
eventManagerDockWidget->setObjectName("Event Manager QDockWidget");
eventManager = new EventManager(this);
eventManager->setReferences(signalViewer->getCanvas());
eventManagerDockWidget->setWidget(eventManager);
QDockWidget* eventTypeDockWidget = new QDockWidget("EventType Manager", this);
eventTypeDockWidget->setObjectName("EventType Manager QDockWidget");
eventTypeManager = new EventTypeManager(this);
eventTypeDockWidget->setWidget(eventTypeManager);
QDockWidget* montageManagerDockWidget = new QDockWidget("Montage Manager", this);
montageManagerDockWidget->setObjectName("Montage Manager QDockWidget");
montageManager = new MontageManager(this);
montageManagerDockWidget->setWidget(montageManager);
addDockWidget(Qt::RightDockWidgetArea, trackManagerDockWidget);
tabifyDockWidget(trackManagerDockWidget, eventManagerDockWidget);
tabifyDockWidget(eventManagerDockWidget, eventTypeDockWidget);
tabifyDockWidget(eventTypeDockWidget, montageManagerDockWidget);
// Construct File actions.
QAction* openFileAction = new QAction("&Open File", this);
openFileAction->setShortcut(QKeySequence::Open);
openFileAction->setToolTip("Open an existing file.");
openFileAction->setStatusTip(openFileAction->toolTip());
connect(openFileAction, SIGNAL(triggered()), this, SLOT(openFile()));
QAction* closeFileAction = new QAction("Close File", this);
closeFileAction->setShortcut(QKeySequence::Close);
closeFileAction->setToolTip("Close the currently opened file.");
closeFileAction->setStatusTip(closeFileAction->toolTip());
connect(closeFileAction, SIGNAL(triggered()), this, SLOT(closeFile()));
QAction* saveFileAction = new QAction("Save File", this);
saveFileAction->setShortcut(QKeySequence::Save);
saveFileAction->setToolTip("Save the currently opened file.");
saveFileAction->setStatusTip(saveFileAction->toolTip());
connect(saveFileAction, SIGNAL(triggered()), this, SLOT(saveFile()));
// Construct Zoom actions.
QAction* horizontalZoomInAction = new QAction("Horizontal Zoom In", this);
horizontalZoomInAction->setShortcut(QKeySequence("Alt++"));
horizontalZoomInAction->setToolTip("Zoom in time line.");
horizontalZoomInAction->setStatusTip(horizontalZoomInAction->toolTip());
connect(horizontalZoomInAction, SIGNAL(triggered()), this, SLOT(horizontalZoomIn()));
QAction* horizontalZoomOutAction = new QAction("Horizontal Zoom Out", this);
horizontalZoomOutAction->setShortcut(QKeySequence("Alt+-"));
horizontalZoomOutAction->setToolTip("Zoom out time line.");
horizontalZoomOutAction->setStatusTip(horizontalZoomOutAction->toolTip());
connect(horizontalZoomOutAction, SIGNAL(triggered()), this, SLOT(horizontalZoomOut()));
QAction* verticalZoomInAction = new QAction("Vertical Zoom In", this);
verticalZoomInAction->setShortcut(QKeySequence("Shift++"));
verticalZoomInAction->setToolTip("Zoom in amplitudes of signals.");
verticalZoomInAction->setStatusTip(verticalZoomInAction->toolTip());
connect(verticalZoomInAction, SIGNAL(triggered()), this, SLOT(verticalZoomIn()));
QAction* verticalZoomOutAction = new QAction("Vertical Zoom Out", this);
verticalZoomOutAction->setShortcut(QKeySequence("Shift+-"));
verticalZoomOutAction->setToolTip("Zoom out amplitudes of signals.");
verticalZoomOutAction->setStatusTip(verticalZoomOutAction->toolTip());
connect(verticalZoomOutAction, SIGNAL(triggered()), this, SLOT(verticalZoomOut()));
// Construct Time Mode action group.
timeModeActionGroup = new QActionGroup(this);
QAction* timeModeAction0 = new QAction("Sample", this);
timeModeAction0->setToolTip("Samples from the start.");
timeModeAction0->setStatusTip(timeModeAction0->toolTip());
connect(timeModeAction0, SIGNAL(triggered()), this, SLOT(timeMode0()));
timeModeAction0->setActionGroup(timeModeActionGroup);
timeModeAction0->setCheckable(true);
QAction* timeModeAction1 = new QAction("Offset", this);
timeModeAction1->setToolTip("Time offset from the start.");
timeModeAction1->setStatusTip(timeModeAction1->toolTip());
connect(timeModeAction1, SIGNAL(triggered()), this, SLOT(timeMode1()));
timeModeAction1->setActionGroup(timeModeActionGroup);
timeModeAction1->setCheckable(true);
QAction* timeModeAction2 = new QAction("Real", this);
timeModeAction2->setToolTip("Real time.");
timeModeAction2->setStatusTip(timeModeAction2->toolTip());
connect(timeModeAction2, SIGNAL(triggered()), this, SLOT(timeMode2()));
timeModeAction2->setActionGroup(timeModeActionGroup);
timeModeAction2->setCheckable(true);
// Construct Time Line Interval action group.
timeLineIntervalActionGroup = new QActionGroup(this);
QAction* timeLineOffAction = new QAction("Off", this);
timeLineOffAction->setToolTip("Turn off the time lines.");
timeLineOffAction->setStatusTip(timeLineOffAction->toolTip());
connect(timeLineOffAction, &QAction::triggered, [this] ()
{
if (file != nullptr)
{
file->getInfoTable()->setTimeLineInterval(0);
}
});
setTimeLineIntervalAction = new QAction("Set", this);
setTimeLineIntervalAction->setActionGroup(timeLineIntervalActionGroup);
connect(setTimeLineIntervalAction, &QAction::triggered, [this] ()
{
if (file != nullptr)
{
double value = file->getInfoTable()->getTimeLineInterval();
if (value == 0)
{
value = 1;
}
bool ok;
value = QInputDialog::getDouble(this, "Set the interval", "Please, enter the value for the time line interval here:", value, 0, 1000*1000*1000, 2, &ok);
if (ok)
{
file->getInfoTable()->setTimeLineInterval(value);
}
}
});
// Tool bars.
const int spacing = 3;
// Construct File tool bar.
QToolBar* fileToolBar = addToolBar("File Tool Bar");
fileToolBar->setObjectName("File QToolBar");
fileToolBar->layout()->setSpacing(spacing);
fileToolBar->addAction(openFileAction);
fileToolBar->addAction(closeFileAction);
fileToolBar->addAction(saveFileAction);
// Construct Filter tool bar.
QToolBar* filterToolBar = addToolBar("Filter Tool Bar");
filterToolBar->setObjectName("Filter QToolBar");
filterToolBar->layout()->setSpacing(spacing);
QLabel* label = new QLabel("LF:", this);
label->setToolTip("Low-pass Filter frequency");
filterToolBar->addWidget(label);
lowpassComboBox = new QComboBox(this);
lowpassComboBox->setSizeAdjustPolicy(QComboBox::AdjustToContents);
lowpassComboBox->setMaximumWidth(150);
lowpassComboBox->setEditable(true);
filterToolBar->addWidget(lowpassComboBox);
label = new QLabel("HF:", this);
label->setToolTip("High-pass Filter frequency");
filterToolBar->addWidget(label);
highpassComboBox = new QComboBox(this);
highpassComboBox->setSizeAdjustPolicy(QComboBox::AdjustToContents);
highpassComboBox->setMaximumWidth(150);
highpassComboBox->setEditable(true);
filterToolBar->addWidget(highpassComboBox);
notchCheckBox = new QCheckBox("Notch:", this);
notchCheckBox->setToolTip("Notch Filter on/off");
notchCheckBox->setLayoutDirection(Qt::RightToLeft);
filterToolBar->addWidget(notchCheckBox);
// Construct Select tool bar.
QToolBar* selectToolBar = addToolBar("Select Tool bar");
selectToolBar->setObjectName("Select QToolBar");
selectToolBar->layout()->setSpacing(spacing);
selectToolBar->addWidget(new QLabel("Montage:", this));
montageComboBox = new QComboBox(this);
montageComboBox->setSizeAdjustPolicy(QComboBox::AdjustToContents);
montageComboBox->setMaximumWidth(200);
selectToolBar->addWidget(montageComboBox);
selectToolBar->addWidget(new QLabel("Event Type:", this));
eventTypeComboBox = new QComboBox(this);
eventTypeComboBox->setSizeAdjustPolicy(QComboBox::AdjustToContents);
eventTypeComboBox->setMaximumWidth(200);
selectToolBar->addWidget(eventTypeComboBox);
// Construct Zoom tool bar.
QToolBar* zoomToolBar = addToolBar("Zoom Tool Bar");
zoomToolBar->setObjectName("Zoom QToolBar");
zoomToolBar->layout()->setSpacing(spacing);
zoomToolBar->addAction(horizontalZoomInAction);
zoomToolBar->addAction(horizontalZoomOutAction);
zoomToolBar->addAction(verticalZoomInAction);
zoomToolBar->addAction(verticalZoomOutAction);
// Construct File menu.
QMenu* fileMenu = menuBar()->addMenu("&File");
fileMenu->addAction(openFileAction);
fileMenu->addAction(closeFileAction);
fileMenu->addAction(saveFileAction);
// Construct View menu.
QMenu* viewMenu = menuBar()->addMenu("&View");
viewMenu->addAction(horizontalZoomInAction);
viewMenu->addAction(horizontalZoomOutAction);
viewMenu->addAction(verticalZoomInAction);
viewMenu->addAction(verticalZoomOutAction);
QMenu* timeModeMenu = new QMenu("Time Mode", this);
timeModeMenu->addAction(timeModeAction0);
timeModeMenu->addAction(timeModeAction1);
timeModeMenu->addAction(timeModeAction2);
viewMenu->addMenu(timeModeMenu);
QMenu* timeLineIntervalMenu = new QMenu("Time Line Interval", this);
timeLineIntervalMenu->addAction(timeLineOffAction);
timeLineIntervalMenu->addAction(setTimeLineIntervalAction);
viewMenu->addMenu(timeLineIntervalMenu);
// Construct Window menu.
QMenu* windowMenu = menuBar()->addMenu("&Window");
windowMenu->addAction(trackManagerDockWidget->toggleViewAction());
windowMenu->addAction(eventManagerDockWidget->toggleViewAction());
windowMenu->addAction(eventTypeDockWidget->toggleViewAction());
windowMenu->addAction(montageManagerDockWidget->toggleViewAction());
windowMenu->addSeparator();
windowMenu->addAction(fileToolBar->toggleViewAction());
windowMenu->addAction(filterToolBar->toggleViewAction());
windowMenu->addAction(selectToolBar->toggleViewAction());
windowMenu->addAction(zoomToolBar->toggleViewAction());
// Construct status bar.
timeModeStatusLabel = new QLabel(this);
timeModeStatusLabel->setContextMenuPolicy(Qt::ActionsContextMenu);
timeModeStatusLabel->addAction(timeModeAction0);
timeModeStatusLabel->addAction(timeModeAction1);
timeModeStatusLabel->addAction(timeModeAction2);
statusBar()->addPermanentWidget(timeModeStatusLabel);
timeStatusLabel = new QLabel(this);
timeStatusLabel->setContextMenuPolicy(Qt::ActionsContextMenu);
timeStatusLabel->addAction(timeModeAction0);
timeStatusLabel->addAction(timeModeAction1);
timeStatusLabel->addAction(timeModeAction2);
statusBar()->addPermanentWidget(timeStatusLabel);
positionStatusLabel = new QLabel(this);
positionStatusLabel->setContextMenuPolicy(Qt::ActionsContextMenu);
positionStatusLabel->addAction(timeModeAction0);
positionStatusLabel->addAction(timeModeAction1);
positionStatusLabel->addAction(timeModeAction2);
statusBar()->addPermanentWidget(positionStatusLabel);
cursorStatusLabel = new QLabel(this);
cursorStatusLabel->setContextMenuPolicy(Qt::ActionsContextMenu);
cursorStatusLabel->addAction(timeModeAction0);
cursorStatusLabel->addAction(timeModeAction1);
cursorStatusLabel->addAction(timeModeAction2);
statusBar()->addPermanentWidget(cursorStatusLabel);
// Restore settings.
restoreGeometry(PROGRAM_OPTIONS.settings("SignalFileBrowserWindow geometry").toByteArray());
restoreState(PROGRAM_OPTIONS.settings("SignalFileBrowserWindow state").toByteArray());
}
