void MainWindow::createDockWidgets()
{
setDockOptions(QMainWindow::AnimatedDocks);
QDockWidget::DockWidgetFeatures features =
QDockWidget::DockWidgetMovable|
QDockWidget::DockWidgetFloatable;
transformWidget = new TransformWidget;
QDockWidget *transformDockWidget = new QDockWidget(
tr("Transform"), this);
transformDockWidget->setFeatures(features);
transformDockWidget->setWidget(transformWidget);
addDockWidget(Qt::RightDockWidgetArea, transformDockWidget);
brushWidget = new BrushWidget;
QDockWidget *brushDockWidget = new QDockWidget(tr("Brush (Fill)"),
this);
brushDockWidget->setFeatures(features);
brushDockWidget->setWidget(brushWidget);
addDockWidget(Qt::RightDockWidgetArea, brushDockWidget);
penWidget = new PenWidget;
QDockWidget *penDockWidget = new QDockWidget(tr("Pen (Outline)"),
this);
penDockWidget->setFeatures(features);
penDockWidget->setWidget(penWidget);
addDockWidget(Qt::RightDockWidgetArea, penDockWidget);
}
void CSVSettings::UserSettingsDialog::buildPages()
{
//craete central widget with it's layout and immediate children
QWidget *centralWidget = new QWidget (this);
mListWidget = new QListWidget (centralWidget);
mStackedWidget = new QStackedWidget (centralWidget);
QGridLayout* dialogLayout = new QGridLayout();
mListWidget->setMinimumWidth(0);
mListWidget->setSizePolicy (QSizePolicy::Preferred, QSizePolicy::Expanding);
mStackedWidget->setSizePolicy (QSizePolicy::Fixed, QSizePolicy::Fixed);
dialogLayout->addWidget (mListWidget,0,0);
dialogLayout->addWidget (mStackedWidget,0,1, Qt::AlignTop);
centralWidget->setLayout (dialogLayout);
setCentralWidget (centralWidget);
setDockOptions (QMainWindow::AllowNestedDocks);
createPage<WindowPage>();
createPage<DataDisplayFormatPage>();
}
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
{
setSizePolicy(
QSizePolicy(
QSizePolicy::MinimumExpanding,
QSizePolicy::MinimumExpanding));
setMinimumSize(100, 100);
setContentsMargins(0, 0, 0, 5);
setWindowTitle("Qt VirtManager");
QIcon::setThemeName("QtVirtManager");
setWindowIcon(QIcon::fromTheme("virtual-engineering"));
setMouseTracking(true);
setDockOptions(
QMainWindow::AnimatedDocks |
QMainWindow::ForceTabbedDocks);
restoreGeometry(settings.value("Geometry").toByteArray());
initTaskWareHouse();
initDomainStateMonitor();
initTrayIcon();
initConnListWidget();
initToolBar();
initDockWidgets();
restoreState(settings.value("State").toByteArray());
this->setVisible(!settings.value("Visible", false).toBool());
changeVisibility();
waitAtClose = settings.value("WaitAtClose", 180).toInt();
closeProgress = new QProgressBar(this);
closeProgress->setRange(0, waitAtClose*1000);
closeProgress->setToolTip("Progress for waiting the connection close");
statusBar()->addPermanentWidget(closeProgress);
statusBar()->hide();
initVirEventloop();
}
ToolWindow::ToolWindow(QWidget* parent) :
QMainWindow(parent),
_selfHidden(false),
_hasShown(false),
_lastGeometry() {
setDockOptions(QMainWindow::ForceTabbedDocks);
Application::getInstance()->installEventFilter(this);
}
int QMainWindow::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 4)
qt_static_metacall(this, _c, _id, _a);
_id -= 4;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< QSize*>(_v) = iconSize(); break;
case 1: *reinterpret_cast< Qt::ToolButtonStyle*>(_v) = toolButtonStyle(); break;
case 2: *reinterpret_cast< bool*>(_v) = isAnimated(); break;
case 3: *reinterpret_cast< bool*>(_v) = documentMode(); break;
case 4: *reinterpret_cast< QTabWidget::TabShape*>(_v) = tabShape(); break;
case 5: *reinterpret_cast< bool*>(_v) = isDockNestingEnabled(); break;
case 6: *reinterpret_cast<int*>(_v) = QFlag(dockOptions()); break;
case 7: *reinterpret_cast< bool*>(_v) = unifiedTitleAndToolBarOnMac(); break;
}
_id -= 8;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: setIconSize(*reinterpret_cast< QSize*>(_v)); break;
case 1: setToolButtonStyle(*reinterpret_cast< Qt::ToolButtonStyle*>(_v)); break;
case 2: setAnimated(*reinterpret_cast< bool*>(_v)); break;
case 3: setDocumentMode(*reinterpret_cast< bool*>(_v)); break;
case 4: setTabShape(*reinterpret_cast< QTabWidget::TabShape*>(_v)); break;
case 5: setDockNestingEnabled(*reinterpret_cast< bool*>(_v)); break;
case 6: setDockOptions(QFlag(*reinterpret_cast<int*>(_v))); break;
case 7: setUnifiedTitleAndToolBarOnMac(*reinterpret_cast< bool*>(_v)); break;
}
_id -= 8;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 8;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 8;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 8;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 8;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 8;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 8;
}
#endif // QT_NO_PROPERTIES
return _id;
}
MainWindow::MainWindow(Controller *controller, Qt::WindowFlags flags)
: KParts::MainWindow(0, flags), d(new MainWindowPrivate(this, controller))
{
connect(this, SIGNAL(destroyed()), controller, SLOT(areaReleased()));
loadGeometry(KGlobal::config()->group("Main Window"));
d->areaSwitcher = new AreaTabWidget(menuBar());
menuBar()->setCornerWidget(d->areaSwitcher, Qt::TopRightCorner);
// don't allow AllowTabbedDocks - that doesn't make sense for "ideal" UI
setDockOptions(QMainWindow::AnimatedDocks);
}
AS_NAMESPACE_START
Ide::Ide(QWidget *parent)
: QMainWindow(parent), _progressDialog(nullptr)
{
addToolBar(Qt::TopToolBarArea, new ToolBar(this));
setCentralWidget(new EditorTabs(this));
setDockOptions(AllowTabbedDocks | AnimatedDocks);
setMenuBar(new MenuBar(this));
setMinimumSize(800, 600);
setStatusBar(_statusBar = new StatusBar(this));
setWindowTitle(Qrc::text("ide.title"));
}
void CSVSettings::Dialog::setupDialog()
{
//create central widget with it's layout and immediate children
QWidget *centralWidget = new QGroupBox (this);
centralWidget->setLayout (new QHBoxLayout());
centralWidget->setSizePolicy (QSizePolicy::Expanding, QSizePolicy::Preferred);
setCentralWidget (centralWidget);
setDockOptions (QMainWindow::AllowNestedDocks);
buildPageListWidget (centralWidget);
buildStackedWidget (centralWidget);
}
EditorMainWindow::EditorMainWindow(EditorApplication* app, QWidget* parent)
: QMainWindow(parent)
, mApplication(app)
, mEntityTreeDock(NULL)
, mSpawnersDock(NULL)
, mPropertyEditorDock(NULL)
{
mUpdateTimer = new QTimer(this);
connect(mUpdateTimer, SIGNAL(timeout()), this, SLOT(EmitQueuedMessages()));
mUpdateTimer->start(100);
// register local message pump to receive messages from game message pump
dtEntity::MessageFunctor functor(&mMessagePump, &dtEntity::MessagePump::EnqueueMessage);
dtEntity::EntityManager& em = mApplication->GetEntityManager();
em.RegisterForMessages(dtEntity::ToolsUpdatedMessage::TYPE, functor);
em.RegisterForMessages(dtEntity::SceneLoadedMessage::TYPE, functor);
em.RegisterForMessages(dtEntity::SceneUnloadedMessage::TYPE, functor);
em.RegisterForMessages(dtEntity::MapLoadedMessage::TYPE, functor);
em.RegisterForMessages(dtEntity::MapUnloadedMessage::TYPE, functor);
mMessagePump.RegisterForMessages(dtEntity::ToolsUpdatedMessage::TYPE, dtEntity::MessageFunctor(this, &EditorMainWindow::OnToolsUpdated));
mMessagePump.RegisterForMessages(dtEntity::SceneLoadedMessage::TYPE, dtEntity::MessageFunctor(this, &EditorMainWindow::OnSceneLoaded));
mMessagePump.RegisterForMessages(dtEntity::SceneUnloadedMessage::TYPE, dtEntity::MessageFunctor(this, &EditorMainWindow::OnSceneUnloaded));
mMessagePump.RegisterForMessages(dtEntity::MapLoadedMessage::TYPE, dtEntity::MessageFunctor(this, &EditorMainWindow::OnMapLoaded));
mMessagePump.RegisterForMessages(dtEntity::MapUnloadedMessage::TYPE, dtEntity::MessageFunctor(this, &EditorMainWindow::OnMapUnloaded));
setMinimumSize(800, 600);
layout()->setContentsMargins(0, 0, 0, 0);
setDockOptions(QMainWindow::AnimatedDocks | QMainWindow::AllowTabbedDocks |
QMainWindow::VerticalTabs);
setWindowTitle("dtEntity Editor");
createActions();
createMenus();
createToolBars();
CreateDockWidgets();
connect(this, SIGNAL(LoadScene(const QString&)), app, SLOT(LoadScene(const QString&)));
connect(this, SIGNAL(NewScene()), app, SLOT(NewScene()));
connect(this, SIGNAL(SaveScene(QString)), app, SLOT(SaveScene(QString)));
}
Tab::Tab(QWidget *parent) :
QMainWindow(parent)
{
//Setting code field
code = new CodeEditor;
setCentralWidget(code);
//Setting input and output fields
input = new RuQTextEdit;
output = new RuQTextEdit;
output->setReadOnly(true);
inputLayout = new QVBoxLayout;
outputLayout = new QVBoxLayout;
inputLayout->addWidget(input);
outputLayout->addWidget(output);
setDockOptions(QMainWindow::AllowNestedDocks | QMainWindow::AnimatedDocks);
QDockWidget *inputDock = new QDockWidget(tr("Input"), this);
inputDock->setAllowedAreas(Qt::AllDockWidgetAreas);
inputWidget = new QWidget(inputDock);
inputWidget->setLayout(inputLayout);
inputDock->setWidget(inputWidget);
inputDock->setFeatures(QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetMovable);
addDockWidget(Qt::RightDockWidgetArea, inputDock);
inputDock->setObjectName("inputDock");
QDockWidget *outputDock = new QDockWidget(tr("Output"), this);
outputDock->setAllowedAreas(Qt::AllDockWidgetAreas);
outputWidget = new QWidget(outputDock);
outputWidget->setLayout(outputLayout);
outputDock->setWidget(outputWidget);
outputDock->setFeatures(QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetMovable);
addDockWidget(Qt::RightDockWidgetArea, outputDock);
outputDock->setObjectName("outputDock");
//Setting io and code fonts
setFonts();
//restore state
QSettings settings("SASM Project", "SASM");
restoreGeometry(settings.value("tabgeometry").toByteArray());
restoreState(settings.value("tabwindowstate").toByteArray());
}
MilkMainWindow::MilkMainWindow(QWidget *parent)
: QMainWindow(parent)
{
setObjectName("MilkMainWindow");
setWindowTitle("Milk");
setWindowIcon(QIcon(":/ui/app.ico"));
setDockOptions(QMainWindow::AllowNestedDocks|QMainWindow::AllowTabbedDocks);
setMinimumSize(320, 240);
createCentralView();
createAction();
createMenu();
createToolBar();
createStatusBar();
createDockPanel();
}
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 mainWindow::createDocks()
{
Monitor = new monitor();
setCentralWidget(Monitor);
setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::BottomLeftCorner, Qt::BottomDockWidgetArea);
setCorner(Qt::TopRightCorner, Qt::RightDockWidgetArea);
setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);
setDockOptions(QMainWindow::ForceTabbedDocks|QMainWindow::VerticalTabs);
/////////
/// Create and dock the Log window
///////////////////////////
log = new logWindow();
showStartupMessage();
QDockWidget *log_dock = new QDockWidget(tr("FoldWatcher Log"), this);
log_dock->setWidget(log);
log_dock->setAllowedAreas(Qt::BottomDockWidgetArea);
addDockWidget(Qt::BottomDockWidgetArea, log_dock);
/////////
/// Create and dock the FAHLog window
///////////////////////////
fahlog_log = new logWindow();
QDockWidget *fahlog_dock = new QDockWidget(tr("FAHlog.txt"), this);
fahlog_dock->setWidget(fahlog_log);
fahlog_dock->setAllowedAreas(Qt::BottomDockWidgetArea);
addDockWidget(Qt::BottomDockWidgetArea, fahlog_dock);
/////////
/// Create and dock the Clients' List window
///////////////////////////
clients = new clientList();
QDockWidget *clients_dock = new QDockWidget(tr("Clients"), this);
clients_dock->setWidget(clients);
clients_dock->setAllowedAreas(Qt::BottomDockWidgetArea);
addDockWidget(Qt::BottomDockWidgetArea, clients_dock);
tabifyDockWidget(clients_dock, log_dock);
/////////
/// Create and dock the Information window
///////////////////////////
info = new proteinInfo();
QDockWidget *info_dock = new QDockWidget(tr("Protein information"), this);
info_dock->setWidget(info);
info_dock->setAllowedAreas(Qt::RightDockWidgetArea);
addDockWidget(Qt::RightDockWidgetArea, info_dock);
/////////
/// Create and dock the Team Stats window
///////////////////////////
TeamStats = new teamStats();
QDockWidget *team_dock = new QDockWidget(tr("Team Statistics"), this);
team_dock->setWidget(TeamStats);
team_dock->setAllowedAreas(Qt::RightDockWidgetArea);
addDockWidget(Qt::RightDockWidgetArea, team_dock);
/////////
/// Create and dock the Personal Stats window
///////////////////////////
PersonalStats = new personalStats();
QDockWidget *personal_dock = new QDockWidget(tr("Personal Statistics"), this);
personal_dock->setWidget(PersonalStats);
personal_dock->setAllowedAreas(Qt::RightDockWidgetArea);
addDockWidget(Qt::RightDockWidgetArea, personal_dock);
/////////
/// Create and dock the Analog Clock window
///////////////////////////
analogClock = new AnalogClock();
QDockWidget *clock_dock = new QDockWidget(tr("Clock"), this);
clock_dock->setWidget(analogClock);
clock_dock->setAllowedAreas(Qt::LeftDockWidgetArea);
addDockWidget(Qt::LeftDockWidgetArea, clock_dock);
////////
/// Tabify those docks! (at last...)
////////////////////////////
// Right widget area
tabifyDockWidget(info_dock, personal_dock);
tabifyDockWidget(personal_dock, team_dock);
// Bottom widget area
tabifyDockWidget(clients_dock, fahlog_dock);
tabifyDockWidget(fahlog_dock, log_dock);
/////////
/// Create the "View" Menu
///////////////////////////
QMenu *logsMenu = new QMenu(tr("Logs"));
QMenu *statsMenu = new QMenu(tr("Stats"));
QMenu *widgetsMenu = new QMenu(tr("Widgets"));
logsMenu->addAction(log_dock->toggleViewAction());
logsMenu->addAction(fahlog_dock->toggleViewAction());
statsMenu->addAction(personal_dock->toggleViewAction());
statsMenu->addAction(team_dock->toggleViewAction());
widgetsMenu->addAction(clock_dock->toggleViewAction());
menuView->addMenu(logsMenu);
menuView->addMenu(statsMenu);
menuView->addMenu(widgetsMenu);
menuView->addSeparator();
menuView->addAction(clients_dock->toggleViewAction());
menuView->addAction(info_dock->toggleViewAction());
/////////
/// Create the Toggle-View Toolbar
///////////////////////////
toolbarLogs->addAction(clients_dock->toggleViewAction());
toolbarLogs->addSeparator();
toolbarLogs->addAction(log_dock->toggleViewAction());
toolbarLogs->addAction(fahlog_dock->toggleViewAction());
toolbarLogs->addSeparator();
toolbarLogs->addAction(info_dock->toggleViewAction());
toolbarLogs->addAction(personal_dock->toggleViewAction());
toolbarLogs->addAction(team_dock->toggleViewAction());
show();
}
void MainWindow::initObjects()
{
m_ui.stateTreeWidget->sortByColumn(0, Qt::AscendingOrder);
m_ui.uniformsTreeWidget->sortByColumn(0, Qt::AscendingOrder);
m_sourcesWidget = new ShadersSourceWidget(m_ui.shadersTab);
QVBoxLayout *layout = new QVBoxLayout;
layout->addWidget(m_sourcesWidget);
m_ui.shadersTab->setLayout(layout);
m_trace = new ApiTrace();
m_retracer = new Retracer(this);
m_vdataInterpreter = new VertexDataInterpreter(this);
m_vdataInterpreter->setListWidget(m_ui.vertexDataListWidget);
m_vdataInterpreter->setStride(
m_ui.vertexStrideSB->value());
m_vdataInterpreter->setComponents(
m_ui.vertexComponentsSB->value());
m_vdataInterpreter->setStartingOffset(
m_ui.startingOffsetSB->value());
m_vdataInterpreter->setTypeFromString(
m_ui.vertexTypeCB->currentText());
m_model = new ApiTraceModel();
m_model->setApiTrace(m_trace);
m_proxyModel = new ApiTraceFilter();
m_proxyModel->setSourceModel(m_model);
m_ui.callView->setModel(m_proxyModel);
m_ui.callView->setItemDelegate(
new ApiCallDelegate(m_ui.callView));
m_ui.callView->resizeColumnToContents(0);
m_ui.callView->header()->swapSections(0, 1);
m_ui.callView->setColumnWidth(1, 42);
m_ui.callView->setContextMenuPolicy(Qt::CustomContextMenu);
m_progressBar = new QProgressBar();
m_progressBar->setRange(0, 100);
statusBar()->addPermanentWidget(m_progressBar);
m_progressBar->hide();
m_argsEditor = new ArgumentsEditor(this);
m_ui.detailsDock->hide();
m_ui.backtraceDock->hide();
m_ui.errorsDock->hide();
m_ui.vertexDataDock->hide();
m_ui.stateDock->hide();
setDockOptions(dockOptions() | QMainWindow::ForceTabbedDocks);
tabifyDockWidget(m_ui.stateDock, m_ui.vertexDataDock);
tabifyDockWidget(m_ui.detailsDock, m_ui.errorsDock);
tabifyDockWidget(m_ui.detailsDock, m_ui.backtraceDock);
m_ui.surfacesTreeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
m_ui.detailsWebView->page()->setLinkDelegationPolicy(
QWebPage::DelegateExternalLinks);
m_jumpWidget = new JumpWidget(this);
m_ui.centralLayout->addWidget(m_jumpWidget);
m_jumpWidget->hide();
m_searchWidget = new SearchWidget(this);
m_ui.centralLayout->addWidget(m_searchWidget);
m_searchWidget->hide();
m_traceProcess = new TraceProcess(this);
m_trimProcess = new TrimProcess(this);
m_profileDialog = new ProfileDialog();
}
Window::Window(testApp * _app)
{
QWidget * content = new QWidget();
ofApp = _app;
// tab = new QTabWidget;
viewCombo = new QComboBox();
glWidget = new GLWidget(ofApp);
glWidget->setFixedWidth(500);
glWidget->setFixedHeight(500);
// content->setFixedWidth(500);
// content->setFixedHeight(500);
glWidget->viewCombo = viewCombo;
QTimer *timer = new QTimer(this);
timer->setInterval(20);
QObject::connect(timer, SIGNAL(timeout()), glWidget, SLOT(update()));
QObject::connect(timer, SIGNAL(timeout()), glWidget, SLOT(updateGL()));
timer->start();
setWindowTitle(tr("Illutron Robot"));
QTimer *settingsTimer = new QTimer(this);
settingsTimer->setInterval(1000);
QObject::connect(settingsTimer, SIGNAL(timeout()), this, SLOT(saveSettings()));
settingsTimer->start();
//GENERAL SETTINGS TAB
QLabel *fpsLabel = new QLabel(tr("FPS"));
QWidget *settingsGroupBox = new QWidget();
QGridLayout *settingsGrid = new QGridLayout;
settingsGrid->setAlignment(Qt::AlignTop);
settingsGrid->addWidget(new QLabel(tr("FPS:")), 0, 0);
settingsGrid->addWidget(fpsLabel, 0,1);
settingsGrid->setColumnStretch(1,20);
settingsGroupBox->setLayout(settingsGrid);
//tab->addTab(settingsGroupBox, "General");
/*
QDockWidget *dockWidget = new QDockWidget(tr("General"), this);
dockWidget->setAllowedAreas(Qt::LeftDockWidgetArea |
Qt::RightDockWidgetArea);
dockWidget->setWidget(settingsGroupBox);*/
//addDockWidget(Qt::RightDockWidgetArea, dockWidget);
setTabPosition(Qt::RightDockWidgetArea,QTabWidget::East);
//SETUP MAIN LAYOUT
QHBoxLayout *mainLayout = new QHBoxLayout;
QWidget *glGroupBox = new QWidget();
QVBoxLayout *glLayout = new QVBoxLayout;
glGroupBox->setLayout(glLayout);
glLayout->addWidget(viewCombo);
glLayout->addWidget(glWidget);
glLayout->setAlignment(Qt::AlignTop);
mainLayout->addWidget(glGroupBox);
// mainLayout->addWidget(tab);
content->setLayout(mainLayout);
setCentralWidget(content);
//GENERAL EVENT CONNECTIONS
//connect(xSlider, SIGNAL(valueChanged(int)), glWidget, SLOT(setXRotation(int))); //This line connects the x slider to the testApp
// connect(rotateSlider, SIGNAL(valueChanged(int)), glWidget, SLOT(setRotateSlider(int)));
connect(glWidget, SIGNAL(frameRateChanged(double)), fpsLabel, SLOT(setNum(double)));
//connect(tabLayout, SIGNAL(valueChanged(int)), glWidget, SLOT(setXRotation(int)));
settings = new QSettings("BrandtsRobot", "Illutron");
setUnifiedTitleAndToolBarOnMac(true);
lock = new QAction(QIcon(QString(ofToDataPath("lock.png", true).c_str())), tr("Lock"),this);
lock->setShortcut( QKeySequence(Qt::ControlModifier + Qt::Key_L));
QObject::connect(lock, SIGNAL(triggered()), this, SLOT(toggleLock()));
toolbar = addToolBar(tr("Toolbar"));
setIconSize(QSize(20,20));
toolbar->addAction(lock);
statusBar()->showMessage(tr("Locked"));
setDockOptions(QMainWindow::AnimatedDocks | QMainWindow::AllowTabbedDocks | QMainWindow::AllowNestedDocks);
}
QgsLayoutDesignerDialog::QgsLayoutDesignerDialog( QWidget *parent, Qt::WindowFlags flags )
: QMainWindow( parent, flags )
, mInterface( new QgsAppLayoutDesignerInterface( this ) )
, mToolsActionGroup( new QActionGroup( this ) )
{
if ( !sInitializedRegistry )
{
initializeRegistry();
}
QgsSettings settings;
int size = settings.value( QStringLiteral( "IconSize" ), QGIS_ICON_SIZE ).toInt();
setIconSize( QSize( size, size ) );
setStyleSheet( QgisApp::instance()->styleSheet() );
setupUi( this );
setWindowTitle( tr( "QGIS Layout Designer" ) );
setAttribute( Qt::WA_DeleteOnClose );
#if QT_VERSION >= 0x050600
setDockOptions( dockOptions() | QMainWindow::GroupedDragging );
#endif
//create layout view
QGridLayout *viewLayout = new QGridLayout();
viewLayout->setSpacing( 0 );
viewLayout->setMargin( 0 );
viewLayout->setContentsMargins( 0, 0, 0, 0 );
centralWidget()->layout()->setSpacing( 0 );
centralWidget()->layout()->setMargin( 0 );
centralWidget()->layout()->setContentsMargins( 0, 0, 0, 0 );
mHorizontalRuler = new QgsLayoutRuler( nullptr, Qt::Horizontal );
mVerticalRuler = new QgsLayoutRuler( nullptr, Qt::Vertical );
mRulerLayoutFix = new QWidget();
mRulerLayoutFix->setAttribute( Qt::WA_NoMousePropagation );
mRulerLayoutFix->setBackgroundRole( QPalette::Window );
mRulerLayoutFix->setFixedSize( mVerticalRuler->rulerSize(), mHorizontalRuler->rulerSize() );
viewLayout->addWidget( mRulerLayoutFix, 0, 0 );
viewLayout->addWidget( mHorizontalRuler, 0, 1 );
viewLayout->addWidget( mVerticalRuler, 1, 0 );
//initial state of rulers
bool showRulers = settings.value( QStringLiteral( "LayoutDesigner/showRulers" ), true ).toBool();
mActionShowRulers->setChecked( showRulers );
mHorizontalRuler->setVisible( showRulers );
mVerticalRuler->setVisible( showRulers );
mRulerLayoutFix->setVisible( showRulers );
mActionShowRulers->blockSignals( false );
connect( mActionShowRulers, &QAction::triggered, this, &QgsLayoutDesignerDialog::showRulers );
QMenu *rulerMenu = new QMenu( this );
rulerMenu->addAction( mActionShowGuides );
rulerMenu->addAction( mActionSnapGuides );
rulerMenu->addAction( mActionManageGuides );
rulerMenu->addAction( mActionClearGuides );
rulerMenu->addSeparator();
rulerMenu->addAction( mActionShowRulers );
mHorizontalRuler->setContextMenu( rulerMenu );
mVerticalRuler->setContextMenu( rulerMenu );
connect( mActionRefreshView, &QAction::triggered, this, &QgsLayoutDesignerDialog::refreshLayout );
connect( mActionShowGrid, &QAction::triggered, this, &QgsLayoutDesignerDialog::showGrid );
connect( mActionSnapGrid, &QAction::triggered, this, &QgsLayoutDesignerDialog::snapToGrid );
connect( mActionShowGuides, &QAction::triggered, this, &QgsLayoutDesignerDialog::showGuides );
connect( mActionSnapGuides, &QAction::triggered, this, &QgsLayoutDesignerDialog::snapToGuides );
connect( mActionSmartGuides, &QAction::triggered, this, &QgsLayoutDesignerDialog::snapToItems );
connect( mActionShowBoxes, &QAction::triggered, this, &QgsLayoutDesignerDialog::showBoxes );
connect( mActionShowPage, &QAction::triggered, this, &QgsLayoutDesignerDialog::showPages );
mView = new QgsLayoutView();
//mView->setMapCanvas( mQgis->mapCanvas() );
mView->setContentsMargins( 0, 0, 0, 0 );
mView->setHorizontalRuler( mHorizontalRuler );
mView->setVerticalRuler( mVerticalRuler );
viewLayout->addWidget( mView, 1, 1 );
//view does not accept focus via tab
mView->setFocusPolicy( Qt::ClickFocus );
mViewFrame->setLayout( viewLayout );
mViewFrame->setContentsMargins( 0, 0, 0, 1 ); // 1 is deliberate!
mView->setFrameShape( QFrame::NoFrame );
connect( mActionClose, &QAction::triggered, this, &QWidget::close );
// populate with initial items...
const QList< int > itemMetadataIds = QgsGui::layoutItemGuiRegistry()->itemMetadataIds();
for ( int id : itemMetadataIds )
{
itemTypeAdded( id );
}
//..and listen out for new item types
connect( QgsGui::layoutItemGuiRegistry(), &QgsLayoutItemGuiRegistry::typeAdded, this, &QgsLayoutDesignerDialog::itemTypeAdded );
QToolButton *orderingToolButton = new QToolButton( this );
orderingToolButton->setPopupMode( QToolButton::InstantPopup );
orderingToolButton->setAutoRaise( true );
orderingToolButton->setToolButtonStyle( Qt::ToolButtonIconOnly );
orderingToolButton->addAction( mActionRaiseItems );
orderingToolButton->addAction( mActionLowerItems );
orderingToolButton->addAction( mActionMoveItemsToTop );
orderingToolButton->addAction( mActionMoveItemsToBottom );
orderingToolButton->setDefaultAction( mActionRaiseItems );
mActionsToolbar->addWidget( orderingToolButton );
QToolButton *alignToolButton = new QToolButton( this );
alignToolButton->setPopupMode( QToolButton::InstantPopup );
alignToolButton->setAutoRaise( true );
alignToolButton->setToolButtonStyle( Qt::ToolButtonIconOnly );
alignToolButton->addAction( mActionAlignLeft );
alignToolButton->addAction( mActionAlignHCenter );
alignToolButton->addAction( mActionAlignRight );
alignToolButton->addAction( mActionAlignTop );
alignToolButton->addAction( mActionAlignVCenter );
alignToolButton->addAction( mActionAlignBottom );
alignToolButton->setDefaultAction( mActionAlignLeft );
mActionsToolbar->addWidget( alignToolButton );
QToolButton *distributeToolButton = new QToolButton( this );
distributeToolButton->setPopupMode( QToolButton::InstantPopup );
distributeToolButton->setAutoRaise( true );
distributeToolButton->setToolButtonStyle( Qt::ToolButtonIconOnly );
distributeToolButton->addAction( mActionDistributeLeft );
distributeToolButton->addAction( mActionDistributeHCenter );
distributeToolButton->addAction( mActionDistributeRight );
distributeToolButton->addAction( mActionDistributeTop );
distributeToolButton->addAction( mActionDistributeVCenter );
distributeToolButton->addAction( mActionDistributeBottom );
distributeToolButton->setDefaultAction( mActionDistributeLeft );
mActionsToolbar->addWidget( distributeToolButton );
QToolButton *resizeToolButton = new QToolButton( this );
resizeToolButton->setPopupMode( QToolButton::InstantPopup );
resizeToolButton->setAutoRaise( true );
resizeToolButton->setToolButtonStyle( Qt::ToolButtonIconOnly );
resizeToolButton->addAction( mActionResizeNarrowest );
resizeToolButton->addAction( mActionResizeWidest );
resizeToolButton->addAction( mActionResizeShortest );
resizeToolButton->addAction( mActionResizeTallest );
resizeToolButton->addAction( mActionResizeToSquare );
resizeToolButton->setDefaultAction( mActionResizeNarrowest );
mActionsToolbar->addWidget( resizeToolButton );
mAddItemTool = new QgsLayoutViewToolAddItem( mView );
mAddNodeItemTool = new QgsLayoutViewToolAddNodeItem( mView );
mPanTool = new QgsLayoutViewToolPan( mView );
mPanTool->setAction( mActionPan );
mToolsActionGroup->addAction( mActionPan );
connect( mActionPan, &QAction::triggered, mPanTool, [ = ] { mView->setTool( mPanTool ); } );
mZoomTool = new QgsLayoutViewToolZoom( mView );
mZoomTool->setAction( mActionZoomTool );
mToolsActionGroup->addAction( mActionZoomTool );
connect( mActionZoomTool, &QAction::triggered, mZoomTool, [ = ] { mView->setTool( mZoomTool ); } );
mSelectTool = new QgsLayoutViewToolSelect( mView );
mSelectTool->setAction( mActionSelectMoveItem );
mToolsActionGroup->addAction( mActionSelectMoveItem );
connect( mActionSelectMoveItem, &QAction::triggered, mSelectTool, [ = ] { mView->setTool( mSelectTool ); } );
// after creating an item with the add item tool, switch immediately to select tool
connect( mAddItemTool, &QgsLayoutViewToolAddItem::createdItem, this, [ = ] { mView->setTool( mSelectTool ); } );
connect( mAddNodeItemTool, &QgsLayoutViewToolAddNodeItem::createdItem, this, [ = ] { mView->setTool( mSelectTool ); } );
mNodesTool = new QgsLayoutViewToolEditNodes( mView );
mNodesTool->setAction( mActionEditNodesItem );
mToolsActionGroup->addAction( mActionEditNodesItem );
connect( mActionEditNodesItem, &QAction::triggered, mNodesTool, [ = ] { mView->setTool( mNodesTool ); } );
mMoveContentTool = new QgsLayoutViewToolMoveItemContent( mView );
mMoveContentTool->setAction( mActionMoveItemContent );
mToolsActionGroup->addAction( mActionMoveItemContent );
connect( mActionMoveItemContent, &QAction::triggered, mMoveContentTool, [ = ] { mView->setTool( mMoveContentTool ); } );
//Ctrl+= should also trigger zoom in
QShortcut *ctrlEquals = new QShortcut( QKeySequence( QStringLiteral( "Ctrl+=" ) ), this );
connect( ctrlEquals, &QShortcut::activated, mActionZoomIn, &QAction::trigger );
//Backspace should also trigger delete selection
QShortcut *backSpace = new QShortcut( QKeySequence( QStringLiteral( "Backspace" ) ), this );
connect( backSpace, &QShortcut::activated, mActionDeleteSelection, &QAction::trigger );
mActionPreviewModeOff->setChecked( true );
connect( mActionPreviewModeOff, &QAction::triggered, this, [ = ]
{
mView->setPreviewModeEnabled( false );
} );
connect( mActionPreviewModeGrayscale, &QAction::triggered, this, [ = ]
{
mView->setPreviewMode( QgsPreviewEffect::PreviewGrayscale );
mView->setPreviewModeEnabled( true );
} );
connect( mActionPreviewModeMono, &QAction::triggered, this, [ = ]
{
mView->setPreviewMode( QgsPreviewEffect::PreviewMono );
mView->setPreviewModeEnabled( true );
} );
connect( mActionPreviewProtanope, &QAction::triggered, this, [ = ]
{
mView->setPreviewMode( QgsPreviewEffect::PreviewProtanope );
mView->setPreviewModeEnabled( true );
} );
connect( mActionPreviewDeuteranope, &QAction::triggered, this, [ = ]
{
mView->setPreviewMode( QgsPreviewEffect::PreviewDeuteranope );
mView->setPreviewModeEnabled( true );
} );
QActionGroup *previewGroup = new QActionGroup( this );
previewGroup->setExclusive( true );
mActionPreviewModeOff->setActionGroup( previewGroup );
mActionPreviewModeGrayscale->setActionGroup( previewGroup );
mActionPreviewModeMono->setActionGroup( previewGroup );
mActionPreviewProtanope->setActionGroup( previewGroup );
mActionPreviewDeuteranope->setActionGroup( previewGroup );
connect( mActionZoomIn, &QAction::triggered, mView, &QgsLayoutView::zoomIn );
connect( mActionZoomOut, &QAction::triggered, mView, &QgsLayoutView::zoomOut );
connect( mActionZoomAll, &QAction::triggered, mView, &QgsLayoutView::zoomFull );
connect( mActionZoomActual, &QAction::triggered, mView, &QgsLayoutView::zoomActual );
connect( mActionZoomToWidth, &QAction::triggered, mView, &QgsLayoutView::zoomWidth );
connect( mActionSelectAll, &QAction::triggered, mView, &QgsLayoutView::selectAll );
connect( mActionDeselectAll, &QAction::triggered, mView, &QgsLayoutView::deselectAll );
connect( mActionInvertSelection, &QAction::triggered, mView, &QgsLayoutView::invertSelection );
connect( mActionSelectNextAbove, &QAction::triggered, mView, &QgsLayoutView::selectNextItemAbove );
connect( mActionSelectNextBelow, &QAction::triggered, mView, &QgsLayoutView::selectNextItemBelow );
connect( mActionRaiseItems, &QAction::triggered, this, &QgsLayoutDesignerDialog::raiseSelectedItems );
connect( mActionLowerItems, &QAction::triggered, this, &QgsLayoutDesignerDialog::lowerSelectedItems );
connect( mActionMoveItemsToTop, &QAction::triggered, this, &QgsLayoutDesignerDialog::moveSelectedItemsToTop );
connect( mActionMoveItemsToBottom, &QAction::triggered, this, &QgsLayoutDesignerDialog::moveSelectedItemsToBottom );
connect( mActionAlignLeft, &QAction::triggered, this, [ = ]
{
mView->alignSelectedItems( QgsLayoutAligner::AlignLeft );
} );
connect( mActionAlignHCenter, &QAction::triggered, this, [ = ]
{
mView->alignSelectedItems( QgsLayoutAligner::AlignHCenter );
} );
connect( mActionAlignRight, &QAction::triggered, this, [ = ]
{
mView->alignSelectedItems( QgsLayoutAligner::AlignRight );
} );
connect( mActionAlignTop, &QAction::triggered, this, [ = ]
{
mView->alignSelectedItems( QgsLayoutAligner::AlignTop );
} );
connect( mActionAlignVCenter, &QAction::triggered, this, [ = ]
{
mView->alignSelectedItems( QgsLayoutAligner::AlignVCenter );
} );
connect( mActionAlignBottom, &QAction::triggered, this, [ = ]
{
mView->alignSelectedItems( QgsLayoutAligner::AlignBottom );
} );
connect( mActionDistributeLeft, &QAction::triggered, this, [ = ]
{
mView->distributeSelectedItems( QgsLayoutAligner::DistributeLeft );
} );
connect( mActionDistributeHCenter, &QAction::triggered, this, [ = ]
{
mView->distributeSelectedItems( QgsLayoutAligner::DistributeHCenter );
} );
connect( mActionDistributeRight, &QAction::triggered, this, [ = ]
{
mView->distributeSelectedItems( QgsLayoutAligner::DistributeRight );
} );
connect( mActionDistributeTop, &QAction::triggered, this, [ = ]
{
mView->distributeSelectedItems( QgsLayoutAligner::DistributeTop );
} );
connect( mActionDistributeVCenter, &QAction::triggered, this, [ = ]
{
mView->distributeSelectedItems( QgsLayoutAligner::DistributeVCenter );
} );
connect( mActionDistributeBottom, &QAction::triggered, this, [ = ]
{
mView->distributeSelectedItems( QgsLayoutAligner::DistributeBottom );
} );
connect( mActionResizeNarrowest, &QAction::triggered, this, [ = ]
{
mView->resizeSelectedItems( QgsLayoutAligner::ResizeNarrowest );
} );
connect( mActionResizeWidest, &QAction::triggered, this, [ = ]
{
mView->resizeSelectedItems( QgsLayoutAligner::ResizeWidest );
} );
connect( mActionResizeShortest, &QAction::triggered, this, [ = ]
{
mView->resizeSelectedItems( QgsLayoutAligner::ResizeShortest );
} );
connect( mActionResizeTallest, &QAction::triggered, this, [ = ]
{
mView->resizeSelectedItems( QgsLayoutAligner::ResizeTallest );
} );
connect( mActionResizeToSquare, &QAction::triggered, this, [ = ]
{
mView->resizeSelectedItems( QgsLayoutAligner::ResizeToSquare );
} );
connect( mActionAddPages, &QAction::triggered, this, &QgsLayoutDesignerDialog::addPages );
connect( mActionUnlockAll, &QAction::triggered, this, &QgsLayoutDesignerDialog::unlockAllItems );
connect( mActionLockItems, &QAction::triggered, this, &QgsLayoutDesignerDialog::lockSelectedItems );
connect( mActionHidePanels, &QAction::toggled, this, &QgsLayoutDesignerDialog::setPanelVisibility );
connect( mActionDeleteSelection, &QAction::triggered, this, [ = ]
{
if ( mView->tool() == mNodesTool )
mNodesTool->deleteSelectedNode();
else
mView->deleteSelectedItems();
} );
connect( mActionGroupItems, &QAction::triggered, this, [ = ]
{
mView->groupSelectedItems();
} );
connect( mActionUngroupItems, &QAction::triggered, this, [ = ]
{
mView->ungroupSelectedItems();
} );
//create status bar labels
mStatusCursorXLabel = new QLabel( mStatusBar );
mStatusCursorXLabel->setMinimumWidth( 100 );
mStatusCursorYLabel = new QLabel( mStatusBar );
mStatusCursorYLabel->setMinimumWidth( 100 );
mStatusCursorPageLabel = new QLabel( mStatusBar );
mStatusCursorPageLabel->setMinimumWidth( 100 );
mStatusBar->addPermanentWidget( mStatusCursorXLabel );
mStatusBar->addPermanentWidget( mStatusCursorXLabel );
mStatusBar->addPermanentWidget( mStatusCursorYLabel );
mStatusBar->addPermanentWidget( mStatusCursorPageLabel );
mStatusZoomCombo = new QComboBox();
mStatusZoomCombo->setEditable( true );
mStatusZoomCombo->setInsertPolicy( QComboBox::NoInsert );
mStatusZoomCombo->setCompleter( nullptr );
mStatusZoomCombo->setMinimumWidth( 100 );
//zoom combo box accepts decimals in the range 1-9999, with an optional decimal point and "%" sign
QRegularExpression zoomRx( QStringLiteral( "\\s*\\d{1,4}(\\.\\d?)?\\s*%?" ) );
QValidator *zoomValidator = new QRegularExpressionValidator( zoomRx, mStatusZoomCombo );
mStatusZoomCombo->lineEdit()->setValidator( zoomValidator );
Q_FOREACH ( double level, sStatusZoomLevelsList )
{
mStatusZoomCombo->insertItem( 0, tr( "%1%" ).arg( level * 100.0, 0, 'f', 1 ), level );
}