void ProtobufTree::contextMenuEvent(QContextMenuEvent* e) { QMenu menu; QAction* expandItemAction = nullptr, * collapseItemAction = nullptr; QTreeWidgetItem* item = itemAt(e->pos()); if (item) { expandItemAction = menu.addAction("Expand"); collapseItemAction = menu.addAction("Collapse"); menu.addSeparator(); } QAction* expandMessagesAction = menu.addAction("Expand Only Messages"); menu.addSeparator(); QAction* expandAction = menu.addAction("Expand All"); QAction* collapseAction = menu.addAction("Collapse All"); menu.addSeparator(); QAction* showTags = menu.addAction("Show tags"); showTags->setCheckable(true); showTags->setChecked(!isColumnHidden(Column_Tag)); menu.addSeparator(); QAction* chartAction = nullptr; QAction* exportAction = nullptr; QList<QAction*> chartMenuActions; QList<QDockWidget*> dockWidgets; const FieldDescriptor* field = nullptr; if (mainWindow && item) { field = item->data(Column_Tag, FieldDescriptorRole) .value<const FieldDescriptor*>(); if (field) { int t = field->type(); if (t == FieldDescriptor::TYPE_FLOAT || t == FieldDescriptor::TYPE_DOUBLE || (t == FieldDescriptor::TYPE_MESSAGE && field->message_type()->name() == "Point")) { dockWidgets = mainWindow->findChildren<QDockWidget*>(); if (!dockWidgets.isEmpty()) { QMenu* chartMenu = menu.addMenu("Chart"); chartAction = chartMenu->addAction("New Chart"); exportAction = chartMenu->addAction("Export Chart"); chartMenu->addSeparator(); for (int i = 0; i < dockWidgets.size(); ++i) { chartMenuActions.append(chartMenu->addAction( QString("Add to '%1'") .arg(dockWidgets[0]->windowTitle()))); } } else { chartAction = menu.addAction("New Chart"); } } } } QAction* act = menu.exec(mapToGlobal(e->pos())); if (act == expandMessagesAction) { collapseAll(); expandMessages(); } else if (act == expandAction) { expandAll(); } else if (act == collapseAction) { collapseAll(); } else if (act == showTags) { setColumnHidden(Column_Tag, !showTags->isChecked()); } else if (expandItemAction && act == expandItemAction) { expandSubtree(item); } else if (collapseItemAction && act == collapseItemAction) { collapseSubtree(item); } else if (chartAction && act == chartAction) { // Find the path from LogFrame to the chosen item QVector<int> path; QStringList names; for (QTreeWidgetItem* i = item; i; i = i->parent()) { int tag = i->data(Column_Tag, Qt::DisplayRole).toInt(); path.push_back(tag); names.append(i->text(Column_Field)); } reverse(path.begin(), path.end()); reverse(names.begin(), names.end()); QDockWidget* dock = new QDockWidget(names.join("."), mainWindow); StripChart* chart = new StripChart(dock); chart->history(_history); if (field->type() == FieldDescriptor::TYPE_MESSAGE) { Chart::PointMagnitude* f = new Chart::PointMagnitude; f->path = path; f->name = names.join("."); chart->function(f); } else { Chart::NumericField* f = new Chart::NumericField; f->path = path; f->name = names.join("."); chart->function(f); } dock->setAttribute(Qt::WA_DeleteOnClose); dock->setWidget(chart); mainWindow->addDockWidget(Qt::BottomDockWidgetArea, dock); if (updateTimer) { connect(updateTimer, SIGNAL(timeout()), chart, SLOT(update())); } } else if (exportAction && act == exportAction) { // If export button was pressed StripChart* chart = new StripChart(); chart->history(_history); // Loop through all open charts and add their data to one chart for (int i = 0; i < dockWidgets.size(); i++) { StripChart* cChart = (StripChart*)dockWidgets[i]->widget(); QList<Chart::Function*> functions = cChart->getFunctions(); for (int j = 0; j < functions.size(); j++) { chart->function(functions[j]); } } // export that chart chart->exportChart(); } else if (chartMenuActions.size() > 0) { int i = chartMenuActions.indexOf(act); if (i != -1) { StripChart* chart = (StripChart*)dockWidgets[i]->widget(); QVector<int> path; QStringList names; for (QTreeWidgetItem* i = item; i; i = i->parent()) { int tag = i->data(Column_Tag, Qt::DisplayRole).toInt(); path.push_back(tag); names.append(i->text(Column_Field)); } reverse(path.begin(), path.end()); reverse(names.begin(), names.end()); dockWidgets[i]->setWindowTitle(dockWidgets[i]->windowTitle() + ", " + names.join(".")); chart->history(_history); if (field->type() == FieldDescriptor::TYPE_MESSAGE) { Chart::PointMagnitude* f = new Chart::PointMagnitude; f->path = path; f->name = names.join("."); chart->function(f); } else { Chart::NumericField* f = new Chart::NumericField; f->path = path; f->name = names.join("."); chart->function(f); } if (updateTimer) { connect(updateTimer, SIGNAL(timeout()), chart, SLOT(update())); } } } }
DSPWindow::DSPWindow(QWidget *parent) : QMainWindow(parent) { owDate = new QDate; *owDate = QDate::currentDate(); // Меню - Файл --------------------------------------------------------------- QToolBar *tb = new QToolBar(this); tb->setWindowTitle(tr("File Actions")); addToolBar(tb); QMenu *menu = new QMenu(tr("&File"), this); menuBar()->addMenu(menu); QAction *a; a = new QAction(QIcon(rsrcPath + "/filenew.png"), tr("&New"), this); a->setShortcut(Qt::CTRL + Qt::Key_N); //connect(a, SIGNAL(triggered()), this, SLOT(fileNew())); tb->addAction(a); menu->addAction(a); a = new QAction(QIcon(rsrcPath + "/fileopen.png"), tr("&Open..."), this); a->setShortcut(Qt::CTRL + Qt::Key_O); //connect(a, SIGNAL(triggered()), this, SLOT(fileOpen())); tb->addAction(a); menu->addAction(a); menu->addSeparator(); actionSave = a = new QAction(QIcon(rsrcPath + "/filesave.png"), tr("&Save"), this); a->setShortcut(Qt::CTRL + Qt::Key_S); //connect(a, SIGNAL(triggered()), this, SLOT(fileSave())); a->setEnabled(false); tb->addAction(a); menu->addAction(a); a = new QAction(tr("Save &As..."), this); //connect(a, SIGNAL(triggered()), this, SLOT(fileSaveAs())); menu->addAction(a); menu->addSeparator(); a = new QAction(QIcon(rsrcPath + "/fileprint.png"), tr("&Print..."), this); a->setShortcut(Qt::CTRL + Qt::Key_P); //connect(a, SIGNAL(triggered()), this, SLOT(filePrint())); tb->addAction(a); menu->addAction(a); a = new QAction(QIcon(rsrcPath + "/exportpdf.png"), tr("&Export PDF..."), this); a->setShortcut(Qt::CTRL + Qt::Key_D); //connect(a, SIGNAL(triggered()), this, SLOT(filePrintPdf())); tb->addAction(a); menu->addAction(a); menu->addSeparator(); a = new QAction(tr("&Quit"), this); a->setShortcut(Qt::CTRL + Qt::Key_Q); connect(a, SIGNAL(triggered()), this, SLOT(close())); menu->addAction(a); // Меню - Файл .............................................................. // Навигатор ---------------------------------------------------------------- //QPalette palette( Qt::gray ); //palette.setColor( QPalette::Button , QColor(Qt::white)); navigator = new QDockWidget(tr("Навигатор"), this); navigator->setFeatures( navigator->features() ^ QDockWidget::DockWidgetClosable ); navigator->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea); navigator->setMaximumSize(QSize( NButtonWidth + 40 , 16777215)); // <- Задаем фиксированный размер navigator->setMinimumSize(QSize( NButtonWidth + 40 , 0)); // <----------| addDockWidget(Qt::LeftDockWidgetArea, navigator ); navigatorBox = new QToolBox( navigator ); navigatorBox->setFrameShape( QFrame::Panel ); navigatorBox->setFrameShadow( QFrame::Plain ); navigatorBox->setLineWidth(1); //navigatorBox->setPalette( palette ); navigator->setWidget( navigatorBox ); navigatorButtonGroup = new QButtonGroup; navigatorButtonGroup->setExclusive ( true ); connect( navigatorButtonGroup , SIGNAL(buttonClicked ( int )), this, SLOT(selectPageInMainLayout( int ))); NavigatorButton *navigatorButton; NavigatorLabel *navigatorLabel; // Оперативная работа --- QWidget *pageOpWork = new QWidget(); QVBoxLayout *pageOpWorkVboxLayout = new QVBoxLayout( pageOpWork ); pageOpWorkVboxLayout->setSpacing(6); pageOpWorkVboxLayout->setMargin(9); navigatorBox->addItem( pageOpWork , tr( "Оперативная работа" )); navigatorBox->setItemIcon ( 0 , QIcon( piconPath + "/32/ow.png") ); // ее кнопки navigatorLabel = new NavigatorLabel( tr( "Производство:")); pageOpWorkVboxLayout->addWidget( navigatorLabel ); navigatorButton = new NavigatorButton( tr( "Производство фосфора") , QIcon( piconPath + "/32/Factor.png") ); pageOpWorkVboxLayout->addWidget( navigatorButton ); navigatorButtonGroup->addButton ( navigatorButton , 21 ); navigatorButton = new NavigatorButton( tr( "Выработка") , QIcon( piconPath + "/32/vyr.png") ); pageOpWorkVboxLayout->addWidget( navigatorButton ); navigatorButtonGroup->addButton ( navigatorButton , 22 ); // Разделитель >-------< QFrame *line = new QFrame; // -------------------------- line->setFrameShape(QFrame::HLine); pageOpWorkVboxLayout->addWidget( line ); navigatorLabel = new NavigatorLabel( tr( "Сырье:")); pageOpWorkVboxLayout->addWidget( navigatorLabel ); navigatorButton = new NavigatorButton( tr( "Приход сырья") , QIcon( piconPath + "/22/add.png") ); pageOpWorkVboxLayout->addWidget( navigatorButton ); navigatorButtonGroup->addButton ( navigatorButton , 23 ); navigatorButton = new NavigatorButton( tr( "Остатки сырья") , QIcon( piconPath + "/32/ost.png") ); pageOpWorkVboxLayout->addWidget( navigatorButton ); navigatorButtonGroup->addButton ( navigatorButton , 24 ); // Разделитель >-------< line = new QFrame; // -------------------------- line->setFrameShape(QFrame::HLine); pageOpWorkVboxLayout->addWidget( line ); navigatorLabel = new NavigatorLabel( tr( "Продукция:")); pageOpWorkVboxLayout->addWidget( navigatorLabel ); navigatorButton = new NavigatorButton( tr( "Приход со стороны") , QIcon( piconPath + "/22/add.png") ); pageOpWorkVboxLayout->addWidget( navigatorButton ); navigatorButtonGroup->addButton ( navigatorButton , 25 ); navigatorButton = new NavigatorButton( tr( "Отгрузка продукции") , QIcon( piconPath + "/22/remove.png") ); pageOpWorkVboxLayout->addWidget( navigatorButton ); navigatorButtonGroup->addButton ( navigatorButton , 26 ); navigatorButton = new NavigatorButton( tr( "Остатки продукции") , QIcon( piconPath + "/32/ost.png") ); pageOpWorkVboxLayout->addWidget( navigatorButton ); navigatorButtonGroup->addButton ( navigatorButton , 27 ); // Разделитель >-------< line = new QFrame; // -------------------------- line->setFrameShape(QFrame::HLine); pageOpWorkVboxLayout->addWidget( line ); navigatorButton = new NavigatorButton( tr( "Простои") , QIcon( piconPath + "/32/potP4.png") ); pageOpWorkVboxLayout->addWidget( navigatorButton ); navigatorButtonGroup->addButton ( navigatorButton , 26 ); QSpacerItem *spacerItem = new QSpacerItem(20, 40, QSizePolicy::Minimum, QSizePolicy::Expanding); pageOpWorkVboxLayout->addItem( spacerItem ); // Оперативная работа ... // Отчеты --- QWidget *pageRaports = new QWidget(); QVBoxLayout *pageRaportsVboxLayout = new QVBoxLayout( pageRaports ); pageRaportsVboxLayout->setSpacing(6); pageRaportsVboxLayout->setMargin(9); navigatorBox->addItem( pageRaports , tr( "Отчеты" )); navigatorBox->setItemIcon ( 1 , QIcon( piconPath + "/16/fileopen.png") ); navigatorButton = new NavigatorButton( tr( "Информация о работе") , QIcon( radiantPath + "/docs_16.png") ); pageRaportsVboxLayout->addWidget( navigatorButton ); navigatorButtonGroup->addButton ( navigatorButton , 41 ); // Разделитель >-------< line = new QFrame; // -------------------------- line->setFrameShape(QFrame::HLine); pageRaportsVboxLayout->addWidget( line ); navigatorLabel = new NavigatorLabel( tr( "Баланс общий:")); pageRaportsVboxLayout->addWidget( navigatorLabel ); navigatorButton = new NavigatorButton( tr( "Нарастающий") , QIcon( radiantPath + "/docs_16.png") ); pageRaportsVboxLayout->addWidget( navigatorButton ); navigatorButtonGroup->addButton ( navigatorButton , 42 ); navigatorButton = new NavigatorButton( tr( "Текущий") , QIcon( radiantPath + "/docs_16.png") ); pageRaportsVboxLayout->addWidget( navigatorButton ); navigatorButtonGroup->addButton ( navigatorButton , 43 ); spacerItem = new QSpacerItem(20, 40, QSizePolicy::Minimum, QSizePolicy::Expanding); pageRaportsVboxLayout->addItem( spacerItem ); spacerItem = new QSpacerItem(20, 40, QSizePolicy::Minimum, QSizePolicy::Expanding); pageRaportsVboxLayout->addItem( spacerItem ); // Отчеты .. // Справочники --- QWidget *pageHandbooks = new QWidget(); QVBoxLayout *pageHandbooksVboxLayout = new QVBoxLayout( pageHandbooks ); pageHandbooksVboxLayout->setSpacing(6); pageHandbooksVboxLayout->setMargin(9); navigatorBox->addItem( pageHandbooks , tr( "Справочники" )); navigatorBox->setItemIcon ( 2 , QIcon( piconPath + "/48/s.png") ); navigatorButton = new NavigatorButton( tr( "Баланс фосфора") , QIcon( piconPath + "/22/s_s22.png") ); pageHandbooksVboxLayout->addWidget( navigatorButton ); navigatorButtonGroup->addButton ( navigatorButton , 51 ); navigatorButton = new NavigatorButton( tr( "Выработка") , QIcon( piconPath + "/22/s_s22.png") ); pageHandbooksVboxLayout->addWidget( navigatorButton ); navigatorButtonGroup->addButton ( navigatorButton , 52 ); navigatorButton = new NavigatorButton( tr( "Продукция") , QIcon( piconPath + "/22/s_s22.png") ); pageHandbooksVboxLayout->addWidget( navigatorButton ); navigatorButtonGroup->addButton ( navigatorButton , 53 ); navigatorButton = new NavigatorButton( tr( "Сырье") , QIcon( piconPath + "/22/s_s22.png") ); pageHandbooksVboxLayout->addWidget( navigatorButton ); navigatorButtonGroup->addButton ( navigatorButton , 54 ); navigatorButton = new NavigatorButton( tr( "Причины простоев") , QIcon( piconPath + "/22/s_s22.png") ); pageHandbooksVboxLayout->addWidget( navigatorButton ); navigatorButtonGroup->addButton ( navigatorButton , 55 ); navigatorButton = new NavigatorButton( tr( "Оборудование") , QIcon( piconPath + "/22/s_s22.png") ); pageHandbooksVboxLayout->addWidget( navigatorButton ); navigatorButtonGroup->addButton ( navigatorButton , 56 ); navigatorButton = new NavigatorButton( tr( "Поставщики") , QIcon( piconPath + "/22/s_s22.png") ); pageHandbooksVboxLayout->addWidget( navigatorButton ); navigatorButtonGroup->addButton ( navigatorButton , 57 ); navigatorButton = new NavigatorButton( tr( "Потребители") , QIcon( piconPath + "/22/s_s22.png") ); pageHandbooksVboxLayout->addWidget( navigatorButton ); navigatorButtonGroup->addButton ( navigatorButton , 58 ); // Разделитель >-------< line = new QFrame; // -------------------------- line->setFrameShape(QFrame::HLine); pageHandbooksVboxLayout->addWidget( line ); navigatorButton = new NavigatorButton( tr( "Единицы измерения массы") , QIcon( piconPath + "/22/s_s22.png") ); pageHandbooksVboxLayout->addWidget( navigatorButton ); navigatorButtonGroup->addButton ( navigatorButton , 59 ); navigatorButton = new NavigatorButton( tr( "Цеха") , QIcon( piconPath + "/22/s_s22.png") ); pageHandbooksVboxLayout->addWidget( navigatorButton ); navigatorButtonGroup->addButton ( navigatorButton , 60 ); spacerItem = new QSpacerItem(20, 40, QSizePolicy::Minimum, QSizePolicy::Expanding); pageHandbooksVboxLayout->addItem( spacerItem ); // Справочники .. // Навигатор ................................................................ // Док календарь - все остальное для работы с датами ---- QDockWidget * dateTimeBrowser = new QDockWidget(tr("Дата"), this); dateTimeBrowser->setFeatures( dateTimeBrowser->features() ^ QDockWidget::DockWidgetClosable); dateTimeBrowser->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea); dateTimeBrowser->setMaximumSize(QSize( NButtonWidth + 42 , 210 )); // <- Задаем фиксированный размер dateTimeBrowser->setMinimumSize(QSize( NButtonWidth + 42 , 0)); // <----------| addDockWidget(Qt::LeftDockWidgetArea , dateTimeBrowser ); QWidget *pDatePickerWidget = new QWidget; QVBoxLayout *pDatePickerWidgetLayout = new QVBoxLayout; pDatePickerWidgetLayout->setMargin(1); pDatePickerWidgetLayout->setAlignment( Qt::AlignHCenter | Qt::AlignVCenter ); pDatePickerWidget->setLayout( pDatePickerWidgetLayout ); PDatePicker *pDatePicker = new PDatePicker( 19 , 28 ); pDatePicker->setFrameStyle( QFrame::Box | QFrame::Plain ); //pDatePicker->setFocusPolicy( Qt::NoFocus ); pDatePickerWidgetLayout->addWidget( pDatePicker ); dateTimeBrowser->setWidget( pDatePickerWidget ); // .. // ************************************************************************* // Рабочая область --------------------------------------------------------- mainWidget = new QWidget; mainWidget->setMinimumSize(QSize(400, 0)); // >|----------|< setCentralWidget ( mainWidget ); mainLayout = new QStackedLayout( mainWidget ); // Оперативная работа ........................ // Производство фосфора ow_prod_phos = new OW_Prod_Phos; mainLayout->addWidget( ow_prod_phos ); // .. // Выработка ow_producing = new OW_Producing; mainLayout->addWidget( ow_producing ); // .. // Приход со стороны ow_income = new OW_Income; mainLayout->addWidget( ow_income ); // .. // Отгрузка ow_outcome = new OW_Outcome; mainLayout->addWidget( ow_outcome ); // .. // Отгрузка ow_depot = new OW_Depot; mainLayout->addWidget( ow_depot ); // .. //Отчеты ------------------------------------- // Общая информация по работе предприятия r_infoforday = new R_InfoForDay; mainLayout->addWidget( r_infoforday ); // .. // Баланс общий r_allproductionbalance = new R_AllProductionBalance; mainLayout->addWidget( r_allproductionbalance ); // .. // Справочники ------------------------------- // Справочник Баланс фосфора -- s_bal_dbtable = new S_BAL_DBTable; mainLayout->addWidget( s_bal_dbtable ); // .. // Выработка -- s_vyr_dbtable = new S_VYR_DBTable; mainLayout->addWidget( s_vyr_dbtable ); // .. // Продукция -- s_prod_dbtable = new S_PROD_DBTable; mainLayout->addWidget( s_prod_dbtable ); // .. // Сырье -- s_syr_dbtable = new S_SYR_DBTable; mainLayout->addWidget( s_syr_dbtable ); // .. // Причины простоев -- s_pprost_dbtable = new S_PPROST_DBTable; mainLayout->addWidget( s_pprost_dbtable ); // .. // Оборудование -- s_ob_dbtable = new S_OB_DBTable; mainLayout->addWidget( s_ob_dbtable ); // .. // Поставщики -- s_post_dbtable = new S_POST_DBTable; mainLayout->addWidget( s_post_dbtable ); // .. // Поставщики -- s_potr_dbtable = new S_POTR_DBTable; mainLayout->addWidget( s_potr_dbtable ); // .. // Цеха -- s_dep_dbtable = new S_DEP_DBTable; mainLayout->addWidget( s_dep_dbtable ); // .. // Справочник единиц измерения -- s_ed_mass_dbtable = new S_ED_MASS_DBTable; mainLayout->addWidget( s_ed_mass_dbtable ); // .. // Справочники ............................... // Рабочая область ......................................................... resize( 800, 576); // Сигналы и слоты для функций этого класса *--> >>--| connect( pDatePicker , SIGNAL( dateChanged( const QDate & )), this , SLOT( setOWDate( const QDate & ))); }
void KoDockWidgetTitleBar::resizeEvent(QResizeEvent*) { QDockWidget *q = qobject_cast<QDockWidget*>(parentWidget()); int fw = q->isFloating() ? q->style()->pixelMetric(QStyle::PM_DockWidgetFrameWidth, 0, q) : 0; QStyleOptionDockWidgetV2 opt; opt.initFrom(q); opt.rect = QRect(QPoint(fw, fw), QSize(geometry().width() - (fw * 2), geometry().height() - (fw * 2))); opt.title = q->windowTitle(); opt.closable = hasFeature(q, QDockWidget::DockWidgetClosable); opt.floatable = hasFeature(q, QDockWidget::DockWidgetFloatable); QRect floatRect = q->style()->subElementRect(QStyle::SE_DockWidgetFloatButton, &opt, q); if (!floatRect.isNull()) d->floatButton->setGeometry(floatRect); QRect closeRect = q->style()->subElementRect(QStyle::SE_DockWidgetCloseButton, &opt, q); if (!closeRect.isNull()) d->closeButton->setGeometry(closeRect); int top = fw; if (!floatRect.isNull()) top = floatRect.y(); else if (!closeRect.isNull()) top = closeRect.y(); QSize size = d->collapseButton->size(); if (!closeRect.isNull()) { size = d->closeButton->size(); } else if (!floatRect.isNull()) { size = d->floatButton->size(); } QRect collapseRect = QRect(QPoint(fw, top), size); d->collapseButton->setGeometry(collapseRect); size = d->lockButton->size(); if (!closeRect.isNull()) { size = d->closeButton->size(); } else if (!floatRect.isNull()) { size = d->floatButton->size(); } int offset = 0; if (d->collapsable) { offset = collapseRect.width(); } QRect lockRect = QRect(QPoint(fw + 2 + offset, top), size); d->lockButton->setGeometry(lockRect); if (width() < (closeRect.width() + lockRect.width()) + 50) { d->collapsable = false; d->collapseButton->setVisible(false); d->lockButton->setVisible(false); d->lockable = false; } else { d->collapsable = d->collapsableSet; d->collapseButton->setVisible(d->collapsableSet); d->lockButton->setVisible(true); d->lockable = true; } }
void KoDockWidgetTitleBar::Private::toggleFloating() { QDockWidget *q = qobject_cast<QDockWidget*>(thePublic->parentWidget()); q->setFloating(!q->isFloating()); }
QDockWidget* MainWindow::createDockWidget(KoDockFactoryBase* factory) { QDockWidget* dockWidget = 0; if(!m_dockWidgetMap.contains(factory->id())) { dockWidget = factory->createDockWidget(); // It is quite possible that a dock factory cannot create the dock; don't // do anything in that case. if(!dockWidget) return 0; m_dockWidgets.push_back(dockWidget); dockWidget->setObjectName(factory->id()); dockWidget->setParent(this); if(dockWidget->widget() && dockWidget->widget()->layout()) dockWidget->widget()->layout()->setContentsMargins(1, 1, 1, 1); Qt::DockWidgetArea side = Qt::RightDockWidgetArea; bool visible = true; switch(factory->defaultDockPosition()) { case KoDockFactoryBase::DockTornOff: dockWidget->setFloating(true); // position nicely? break; case KoDockFactoryBase::DockTop: side = Qt::TopDockWidgetArea; break; case KoDockFactoryBase::DockLeft: side = Qt::LeftDockWidgetArea; break; case KoDockFactoryBase::DockBottom: side = Qt::BottomDockWidgetArea; break; case KoDockFactoryBase::DockRight: side = Qt::RightDockWidgetArea; break; case KoDockFactoryBase::DockMinimized: visible = false; break; default:; } addDockWidget(side, dockWidget); if(dockWidget->features() & QDockWidget::DockWidgetClosable) { m_dockWidgetMenu->addAction(dockWidget->toggleViewAction()); if(!visible) dockWidget->hide(); } m_dockWidgetMap.insert(factory->id(), dockWidget); } else { dockWidget = m_dockWidgetMap[ factory->id()]; } KConfigGroup group(KGlobal::config(), "GUI"); QFont dockWidgetFont = KGlobalSettings::generalFont(); qreal pointSize = group.readEntry("palettefontsize", dockWidgetFont.pointSize() * 0.75); pointSize = qMax(pointSize, KGlobalSettings::smallestReadableFont().pointSizeF()); dockWidgetFont.setPointSizeF(pointSize); #ifdef Q_WS_MAC dockWidget->setAttribute(Qt::WA_MacSmallSize, true); #endif dockWidget->setFont(dockWidgetFont); connect(dockWidget, SIGNAL(dockLocationChanged(Qt::DockWidgetArea)), this, SLOT(forceDockTabFonts())); return dockWidget; }
PointViewerMainWindow::PointViewerMainWindow(const QGLFormat& format) : m_progressBar(0), m_pointView(0), m_shaderEditor(0), m_helpDialog(0), m_logTextView(0), m_maxPointCount(200*1000*1000), // 200 million m_geometries(0), m_ipcServer(0), m_hookManager(0) { #ifndef _WIN32 setWindowIcon(QIcon(":resource/icons/hicolor/256x256/apps/displaz.png")); #else // On windows, application icon is set via windows resource file #endif setWindowTitle("Displaz"); setAcceptDrops(true); m_helpDialog = new HelpDialog(this); m_geometries = new GeometryCollection(this); connect(m_geometries, SIGNAL(layoutChanged()), this, SLOT(updateTitle())); connect(m_geometries, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(updateTitle())); connect(m_geometries, SIGNAL(rowsInserted(QModelIndex,int,int)), this, SLOT(updateTitle())); connect(m_geometries, SIGNAL(rowsRemoved(QModelIndex,int,int)), this, SLOT(updateTitle())); //-------------------------------------------------- // Set up file loader in a separate thread // // Some subtleties regarding qt thread usage are discussed here: // http://mayaposch.wordpress.com/2011/11/01/how-to-really-truly-use-qthreads-the-full-explanation // // Main point: each QObject has a thread affinity which determines which // thread its slots will execute on, when called via a connected signal. QThread* loaderThread = new QThread(); m_fileLoader = new FileLoader(m_maxPointCount); m_fileLoader->moveToThread(loaderThread); connect(loaderThread, SIGNAL(finished()), m_fileLoader, SLOT(deleteLater())); connect(loaderThread, SIGNAL(finished()), loaderThread, SLOT(deleteLater())); //connect(m_fileLoader, SIGNAL(finished()), this, SIGNAL(fileLoadFinished())); connect(m_fileLoader, SIGNAL(geometryLoaded(std::shared_ptr<Geometry>, bool, bool)), m_geometries, SLOT(addGeometry(std::shared_ptr<Geometry>, bool, bool))); connect(m_fileLoader, SIGNAL(geometryMutatorLoaded(std::shared_ptr<GeometryMutator>)), m_geometries, SLOT(mutateGeometry(std::shared_ptr<GeometryMutator>))); loaderThread->start(); //-------------------------------------------------- // Menus menuBar()->setNativeMenuBar(false); // OS X doesn't activate the native menu bar under Qt5 // File menu QMenu* fileMenu = menuBar()->addMenu(tr("&File")); QAction* openAct = fileMenu->addAction(tr("&Open")); openAct->setToolTip(tr("Open a data set")); openAct->setShortcuts(QKeySequence::Open); connect(openAct, SIGNAL(triggered()), this, SLOT(openFiles())); QAction* addAct = fileMenu->addAction(tr("&Add")); addAct->setToolTip(tr("Add a data set")); connect(addAct, SIGNAL(triggered()), this, SLOT(addFiles())); QAction* reloadAct = fileMenu->addAction(tr("&Reload")); reloadAct->setStatusTip(tr("Reload point files from disk")); reloadAct->setShortcut(Qt::Key_F5); connect(reloadAct, SIGNAL(triggered()), this, SLOT(reloadFiles())); fileMenu->addSeparator(); QAction* screenShotAct = fileMenu->addAction(tr("Scree&nshot")); screenShotAct->setStatusTip(tr("Save screen shot of 3D window")); screenShotAct->setShortcut(Qt::Key_F9); connect(screenShotAct, SIGNAL(triggered()), this, SLOT(screenShot())); fileMenu->addSeparator(); QAction* quitAct = fileMenu->addAction(tr("&Quit")); quitAct->setStatusTip(tr("Exit the application")); quitAct->setShortcuts(QKeySequence::Quit); connect(quitAct, SIGNAL(triggered()), this, SLOT(close())); // View menu QMenu* viewMenu = menuBar()->addMenu(tr("&View")); QAction* trackballMode = viewMenu->addAction(tr("Use &Trackball camera")); trackballMode->setCheckable(true); trackballMode->setChecked(false); // Background sub-menu QMenu* backMenu = viewMenu->addMenu(tr("Set &Background")); QSignalMapper* mapper = new QSignalMapper(this); // Selectable backgrounds (svg_names from SVG standard - see QColor docs) const char* backgroundNames[] = {/* "Display Name", "svg_name", */ "Default", "#3C3232", "Black", "black", "Dark Grey", "dimgrey", "Slate Grey", "#858C93", "Light Grey", "lightgrey", "White", "white" }; for(size_t i = 0; i < sizeof(backgroundNames)/sizeof(const char*); i+=2) { QAction* backgroundAct = backMenu->addAction(tr(backgroundNames[i])); QPixmap pixmap(50,50); QString colName = backgroundNames[i+1]; pixmap.fill(QColor(colName)); QIcon icon(pixmap); backgroundAct->setIcon(icon); mapper->setMapping(backgroundAct, colName); connect(backgroundAct, SIGNAL(triggered()), mapper, SLOT(map())); } connect(mapper, SIGNAL(mapped(QString)), this, SLOT(setBackground(QString))); backMenu->addSeparator(); QAction* backgroundCustom = backMenu->addAction(tr("&Custom")); connect(backgroundCustom, SIGNAL(triggered()), this, SLOT(chooseBackground())); // Check boxes for drawing various scene elements by category viewMenu->addSeparator(); QAction* drawBoundingBoxes = viewMenu->addAction(tr("Draw Bounding bo&xes")); drawBoundingBoxes->setCheckable(true); drawBoundingBoxes->setChecked(false); QAction* drawCursor = viewMenu->addAction(tr("Draw 3D &Cursor")); drawCursor->setCheckable(true); drawCursor->setChecked(true); QAction* drawAxes = viewMenu->addAction(tr("Draw &Axes")); drawAxes->setCheckable(true); drawAxes->setChecked(true); QAction* drawGrid = viewMenu->addAction(tr("Draw &Grid")); drawGrid->setCheckable(true); drawGrid->setChecked(false); QAction* drawAnnotations = viewMenu->addAction(tr("Draw A&nnotations")); drawAnnotations->setCheckable(true); drawAnnotations->setChecked(true); // Shader menu QMenu* shaderMenu = menuBar()->addMenu(tr("&Shader")); QAction* openShaderAct = shaderMenu->addAction(tr("&Open")); openShaderAct->setToolTip(tr("Open a shader file")); connect(openShaderAct, SIGNAL(triggered()), this, SLOT(openShaderFile())); QAction* editShaderAct = shaderMenu->addAction(tr("&Edit")); editShaderAct->setToolTip(tr("Open shader editor window")); QAction* saveShaderAct = shaderMenu->addAction(tr("&Save")); saveShaderAct->setToolTip(tr("Save current shader file")); connect(saveShaderAct, SIGNAL(triggered()), this, SLOT(saveShaderFile())); shaderMenu->addSeparator(); // Help menu QMenu* helpMenu = menuBar()->addMenu(tr("&Help")); QAction* helpAct = helpMenu->addAction(tr("User &Guide")); connect(helpAct, SIGNAL(triggered()), this, SLOT(helpDialog())); helpMenu->addSeparator(); QAction* aboutAct = helpMenu->addAction(tr("&About")); connect(aboutAct, SIGNAL(triggered()), this, SLOT(aboutDialog())); //-------------------------------------------------- // Point viewer m_pointView = new View3D(m_geometries, format, this); setCentralWidget(m_pointView); connect(drawBoundingBoxes, SIGNAL(triggered()), m_pointView, SLOT(toggleDrawBoundingBoxes())); connect(drawCursor, SIGNAL(triggered()), m_pointView, SLOT(toggleDrawCursor())); connect(drawAxes, SIGNAL(triggered()), m_pointView, SLOT(toggleDrawAxes())); connect(drawGrid, SIGNAL(triggered()), m_pointView, SLOT(toggleDrawGrid())); connect(drawAnnotations, SIGNAL(triggered()), m_pointView, SLOT(toggleDrawAnnotations())); connect(trackballMode, SIGNAL(triggered()), m_pointView, SLOT(toggleCameraMode())); connect(m_geometries, SIGNAL(rowsInserted(QModelIndex,int,int)), this, SLOT(geometryRowsInserted(QModelIndex,int,int))); //-------------------------------------------------- // Docked widgets // Shader parameters UI QDockWidget* shaderParamsDock = new QDockWidget(tr("Shader Parameters"), this); shaderParamsDock->setFeatures(QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetClosable); QWidget* shaderParamsUI = new QWidget(shaderParamsDock); shaderParamsDock->setWidget(shaderParamsUI); m_pointView->setShaderParamsUIWidget(shaderParamsUI); // Shader editor UI QDockWidget* shaderEditorDock = new QDockWidget(tr("Shader Editor"), this); shaderEditorDock->setFeatures(QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetClosable | QDockWidget::DockWidgetFloatable); QWidget* shaderEditorUI = new QWidget(shaderEditorDock); m_shaderEditor = new ShaderEditor(shaderEditorUI); QGridLayout* shaderEditorLayout = new QGridLayout(shaderEditorUI); shaderEditorLayout->setContentsMargins(2,2,2,2); shaderEditorLayout->addWidget(m_shaderEditor, 0, 0, 1, 1); connect(editShaderAct, SIGNAL(triggered()), shaderEditorDock, SLOT(show())); shaderEditorDock->setWidget(shaderEditorUI); shaderMenu->addAction(m_shaderEditor->compileAction()); connect(m_shaderEditor->compileAction(), SIGNAL(triggered()), this, SLOT(compileShaderFile())); // TODO: check if this is needed - test shader update functionality //connect(m_shaderEditor, SIGNAL(sendShader(QString)), // &m_pointView->shaderProgram(), SLOT(setShader(QString))); // Log viewer UI QDockWidget* logDock = new QDockWidget(tr("Log"), this); logDock->setFeatures(QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetClosable); QWidget* logUI = new QWidget(logDock); m_logTextView = new LogViewer(logUI); m_logTextView->setReadOnly(true); m_logTextView->setTextInteractionFlags(Qt::TextSelectableByKeyboard | Qt::TextSelectableByMouse); m_logTextView->connectLogger(&g_logger); // connect to global logger m_progressBar = new QProgressBar(logUI); m_progressBar->setRange(0,100); m_progressBar->setValue(0); m_progressBar->hide(); connect(m_fileLoader, SIGNAL(loadStepStarted(QString)), this, SLOT(setProgressBarText(QString))); connect(m_fileLoader, SIGNAL(loadProgress(int)), m_progressBar, SLOT(setValue(int))); connect(m_fileLoader, SIGNAL(resetProgress()), m_progressBar, SLOT(hide())); QVBoxLayout* logUILayout = new QVBoxLayout(logUI); //logUILayout->setContentsMargins(2,2,2,2); logUILayout->addWidget(m_logTextView); logUILayout->addWidget(m_progressBar); //m_logTextView->setLineWrapMode(QPlainTextEdit::NoWrap); logDock->setWidget(logUI); // Data set list UI QDockWidget* dataSetDock = new QDockWidget(tr("Data Sets"), this); dataSetDock->setFeatures(QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetClosable | QDockWidget::DockWidgetFloatable); DataSetUI* dataSetUI = new DataSetUI(this); dataSetDock->setWidget(dataSetUI); QAbstractItemView* dataSetOverview = dataSetUI->view(); dataSetOverview->setModel(m_geometries); connect(dataSetOverview, SIGNAL(doubleClicked(const QModelIndex&)), m_pointView, SLOT(centerOnGeometry(const QModelIndex&))); m_pointView->setSelectionModel(dataSetOverview->selectionModel()); // Set up docked widgets addDockWidget(Qt::RightDockWidgetArea, shaderParamsDock); addDockWidget(Qt::LeftDockWidgetArea, shaderEditorDock); addDockWidget(Qt::RightDockWidgetArea, logDock); addDockWidget(Qt::RightDockWidgetArea, dataSetDock); tabifyDockWidget(logDock, dataSetDock); logDock->raise(); shaderEditorDock->setVisible(false); // Add dock widget toggles to view menu viewMenu->addSeparator(); viewMenu->addAction(shaderParamsDock->toggleViewAction()); viewMenu->addAction(logDock->toggleViewAction()); viewMenu->addAction(dataSetDock->toggleViewAction()); // Create custom hook events from CLI at runtime m_hookManager = new HookManager(this); }
QDockWidget *Customizer::produceDockWidget(QString const &title, QWidget *content) const { QDockWidget *dock = new QDockWidget(title); dock->setWidget(content); return dock; }
MainWindow::MainWindow(QString projectPath, QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow), m_progressDialog(NULL), m_renderProgressDialog(NULL), m_flowExaminer(NULL), m_cs(this) { ui->setupUi(this); restoreGeometry(m_settings.value("geometry").toByteArray()); restoreState(m_settings.value("windowState").toByteArray()); m_project = new Project_sV(); m_wCanvas = new Canvas(m_project, this); setCentralWidget(m_wCanvas); m_wInputMonitor = new FrameMonitor(this); m_wInputMonitorDock = new QDockWidget(tr("Input monitor"), this); m_wInputMonitorDock->setWidget(m_wInputMonitor); m_wInputMonitorDock->setObjectName("inputMonitor"); addDockWidget(Qt::TopDockWidgetArea, m_wInputMonitorDock); m_wCurveMonitor = new FrameMonitor(this); m_wCurveMonitorDock = new QDockWidget(tr("Curve monitor"), this); m_wCurveMonitorDock->setWidget(m_wCurveMonitor); m_wCurveMonitorDock->setObjectName("curveMonitor"); addDockWidget(Qt::TopDockWidgetArea, m_wCurveMonitorDock); m_wRenderPreview = new RenderPreview(m_project, this); m_wRenderPreviewDock = new QDockWidget(tr("Render preview"), this); m_wRenderPreviewDock->setWidget(m_wRenderPreview); m_wRenderPreviewDock->setObjectName("renderPreview"); addDockWidget(Qt::TopDockWidgetArea, m_wRenderPreviewDock); // Fill the view menu that allows (de)activating widgets QObjectList windowChildren = children(); QDockWidget *w; for (int i = 0; i < windowChildren.size(); i++) { if ((w = dynamic_cast<QDockWidget*>(windowChildren.at(i))) != NULL) { qDebug() << "Adding " << w->windowTitle() << " to the menu's widget list"; QAction *a = new QAction("&" + w->objectName(), this); a->setCheckable(true); bool b = true; b &= connect(a, SIGNAL(toggled(bool)), w, SLOT(setVisible(bool))); // This does not work since it is also emitted e.g. when the window is minimized // (with «Show Desktop» on KDE4), therefore an event filter is required. (below.) // Thanks ArGGu^^ for the tip! // b &= connect(w, SIGNAL(visibilityChanged(bool)), a, SLOT(setChecked(bool))); Q_ASSERT(b); a->setChecked(true); // To uncheck the menu entry when the widget is closed via the (x) w->installEventFilter(this); ui->menuView->addAction(a); m_widgetActions << a; } }
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) { ui->setupUi(this); this->resize(800,680); this->setWindowState(Qt::WindowMaximized); ImageItem *image = new ImageItem(); //create ColorSelection ColorSelection *CS1 = new ColorSelection(Qt::black); ColorSelection *CS2 = new ColorSelection(Qt::white); QObject::connect(CS1,SIGNAL(changeColor(QColor)),image,SLOT(setColor1(QColor))); QObject::connect(image->getPipette(),SIGNAL(changeColor1(QColor)),CS1,SLOT(setColor(QColor))); QObject::connect(CS2,SIGNAL(changeColor(QColor)),image,SLOT(setColor2(QColor))); QObject::connect(image->getPipette(),SIGNAL(changeColor2(QColor)),CS2,SLOT(setColor(QColor))); QHBoxLayout *Hlayout = new QHBoxLayout(); Hlayout->addStretch(5); Hlayout->addWidget(CS1); Hlayout->addWidget(CS2); Hlayout->addStretch(5); //Create slider QSlider *slider = new QSlider(Qt::Horizontal); slider->setMaximum(100); slider->setMinimum(1); slider->setValue(10); QObject::connect(slider,SIGNAL(valueChanged(int)),image,SLOT(setSize(int))); QVBoxLayout *Blayout = new QVBoxLayout(); Blayout->addWidget(slider); Blayout->addLayout(Hlayout); QWidget *wdg = new QWidget(); wdg->setLayout(Blayout); // Create Dock // // QDockWidget *dock = new QDockWidget(tr("Настройка"),this); dock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea); dock->setFeatures(QDockWidget::NoDockWidgetFeatures); wdg->setFixedSize(200,100); dock->setWidget(wdg); dock->setMaximumHeight(300); dock->setMaximumWidth(300); addDockWidget(Qt::RightDockWidgetArea,dock); QActionGroup *GP = new QActionGroup(this); GP->addAction(ui->actionPencil); GP->addAction(ui->actionEraser); GP->addAction(ui->actionEllipse); GP->addAction(ui->actionRectangle); GP->addAction(ui->actionLine); GP->addAction(ui->actionCurveLine); GP->addAction(ui->actionFill); GP->addAction(ui->actionPipette); GP->addAction(ui->actionSelection); GP->setExclusive(true); //create tool bar QToolBar *TB = new QToolBar(); TB->setAllowedAreas(Qt::TopToolBarArea | Qt::LeftToolBarArea); TB->setFloatable(false); TB->setMovable(true); TB->insertAction(0,ui->actionSaveAs); TB->insertAction(ui->actionSaveAs,ui->actionSave); TB->insertAction(ui->actionSave,ui->actionOpen); TB->insertAction(ui->actionOpen,ui->actionCreate); TB->addSeparator(); TB->insertAction(0,ui->actionSelection); TB->insertAction(ui->actionSelection,ui->actionPipette); TB->insertAction(ui->actionPipette,ui->actionFill); TB->insertAction(ui->actionFill,ui->actionCurveLine); TB->insertAction(ui->actionCurveLine,ui->actionLine); TB->insertAction(ui->actionLine,ui->actionRectangle); TB->insertAction(ui->actionRectangle,ui->actionEllipse); TB->insertAction(ui->actionEllipse,ui->actionEraser); TB->insertAction(ui->actionEraser,ui->actionPencil); addToolBar(Qt::TopToolBarArea, TB); // create action connecting QObject::connect(ui->actionOpen,SIGNAL(triggered(bool)),image,SLOT(open())); QObject::connect(ui->actionSaveAs,SIGNAL(triggered(bool)),image,SLOT(saveAs())); QObject::connect(ui->actionSave,SIGNAL(triggered(bool)),image,SLOT(save())); QObject::connect(ui->actionPencil,SIGNAL(toggled(bool)),image,SLOT(setPencil(bool))); QObject::connect(ui->actionEraser,SIGNAL(toggled(bool)),image,SLOT(setEraser(bool))); QObject::connect(ui->actionEllipse,SIGNAL(toggled(bool)),image,SLOT(setEllipse(bool))); QObject::connect(ui->actionRectangle,SIGNAL(toggled(bool)),image,SLOT(setRectangle(bool))); QObject::connect(ui->actionLine,SIGNAL(toggled(bool)),image,SLOT(setLine(bool))); QObject::connect(ui->actionCurveLine,SIGNAL(toggled(bool)),image,SLOT(setCurveLine(bool))); QObject::connect(ui->actionFill,SIGNAL(toggled(bool)),image,SLOT(setFill(bool))); QObject::connect(ui->actionPipette,SIGNAL(toggled(bool)),image,SLOT(setPipette(bool))); QObject::connect(ui->actionSelection,SIGNAL(toggled(bool)),image,SLOT(setSelection(bool))); //undo and redo ui->actionUndo->setEnabled(false); ui->actionRedo->setEnabled(false); QObject::connect(image->getUndoStack(),SIGNAL(canUndo(bool)),ui->actionUndo,SLOT(setEnabled(bool))); QObject::connect(ui->actionUndo,SIGNAL(triggered(bool)),image->getUndoStack(),SLOT(undo())); QObject::connect(image->getUndoStack(),SIGNAL(canRedo(bool)),ui->actionRedo,SLOT(setEnabled(bool))); QObject::connect(image->getUndoStack(),SIGNAL(canRedo(bool)),image,SLOT(setNewCurve(bool))); QObject::connect(ui->actionRedo,SIGNAL(triggered(bool)),image->getUndoStack(),SLOT(redo())); //copy and cut and put ui->actionCopy->setEnabled(false); ui->actionCut->setEnabled(false); ui->actionPut->setEnabled(false); QObject::connect(image->getSelection(),SIGNAL(canCopy(bool)),ui->actionCopy,SLOT(setEnabled(bool))); QObject::connect(ui->actionCopy,SIGNAL(triggered(bool)),image,SLOT(makeCopy())); QObject::connect(image->getSelection(),SIGNAL(canCopy(bool)),ui->actionCut,SLOT(setEnabled(bool))); QObject::connect(ui->actionCut,SIGNAL(triggered(bool)),image,SLOT(makeCut())); QObject::connect(image->getSelection(),SIGNAL(canPut(bool)),ui->actionPut,SLOT(setEnabled(bool))); QObject::connect(ui->actionPut,SIGNAL(triggered(bool)),image,SLOT(makePut())); QObject::connect(ui->actionSelection,SIGNAL(changed()),image,SLOT(clearSelection())); ui->scrollArea->setBackgroundRole(QPalette :: Dark); ui->scrollArea->setWidget(image); }
MainWindow::MainWindow(running_machine* machine, QWidget* parent) : WindowQt(machine, NULL), m_historyIndex(0), m_inputHistory() { setGeometry(300, 300, 1000, 600); // // The main frame and its input and log widgets // QFrame* mainWindowFrame = new QFrame(this); // The input line m_inputEdit = new QLineEdit(mainWindowFrame); connect(m_inputEdit, &QLineEdit::returnPressed, this, &MainWindow::executeCommandSlot); m_inputEdit->installEventFilter(this); // The log view m_consoleView = new DebuggerView(DVT_CONSOLE, m_machine, mainWindowFrame); m_consoleView->setFocusPolicy(Qt::NoFocus); m_consoleView->setPreferBottom(true); QVBoxLayout* vLayout = new QVBoxLayout(mainWindowFrame); vLayout->addWidget(m_consoleView); vLayout->addWidget(m_inputEdit); vLayout->setSpacing(3); vLayout->setContentsMargins(4,0,4,2); setCentralWidget(mainWindowFrame); // // Options Menu // // Create three commands m_breakpointToggleAct = new QAction("Toggle Breakpoint at Cursor", this); m_breakpointEnableAct = new QAction("Disable Breakpoint at Cursor", this); m_runToCursorAct = new QAction("Run to Cursor", this); m_breakpointToggleAct->setShortcut(Qt::Key_F9); m_breakpointEnableAct->setShortcut(Qt::SHIFT + Qt::Key_F9); m_runToCursorAct->setShortcut(Qt::Key_F4); connect(m_breakpointToggleAct, &QAction::triggered, this, &MainWindow::toggleBreakpointAtCursor); connect(m_breakpointEnableAct, &QAction::triggered, this, &MainWindow::enableBreakpointAtCursor); connect(m_runToCursorAct, &QAction::triggered, this, &MainWindow::runToCursor); // Right bar options QActionGroup* rightBarGroup = new QActionGroup(this); rightBarGroup->setObjectName("rightbargroup"); QAction* rightActRaw = new QAction("Raw Opcodes", this); QAction* rightActEncrypted = new QAction("Encrypted Opcodes", this); QAction* rightActComments = new QAction("Comments", this); rightActRaw->setCheckable(true); rightActEncrypted->setCheckable(true); rightActComments->setCheckable(true); rightActRaw->setActionGroup(rightBarGroup); rightActEncrypted->setActionGroup(rightBarGroup); rightActComments->setActionGroup(rightBarGroup); rightActRaw->setShortcut(QKeySequence("Ctrl+R")); rightActEncrypted->setShortcut(QKeySequence("Ctrl+E")); rightActComments->setShortcut(QKeySequence("Ctrl+C")); rightActRaw->setChecked(true); connect(rightBarGroup, &QActionGroup::triggered, this, &MainWindow::rightBarChanged); // Assemble the options menu QMenu* optionsMenu = menuBar()->addMenu("&Options"); optionsMenu->addAction(m_breakpointToggleAct); optionsMenu->addAction(m_breakpointEnableAct); optionsMenu->addAction(m_runToCursorAct); optionsMenu->addSeparator(); optionsMenu->addActions(rightBarGroup->actions()); // // Images menu // image_interface_iterator imageIterTest(m_machine->root_device()); if (imageIterTest.first() != NULL) { createImagesMenu(); } // // Dock window menu // QMenu* dockMenu = menuBar()->addMenu("Doc&ks"); setCorner(Qt::TopRightCorner, Qt::TopDockWidgetArea); setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea); // The processor dock QDockWidget* cpuDock = new QDockWidget("processor", this); cpuDock->setObjectName("cpudock"); cpuDock->setAllowedAreas(Qt::LeftDockWidgetArea); m_procFrame = new ProcessorDockWidget(m_machine, cpuDock); cpuDock->setWidget(dynamic_cast<QWidget*>(m_procFrame)); addDockWidget(Qt::LeftDockWidgetArea, cpuDock); dockMenu->addAction(cpuDock->toggleViewAction()); // The disassembly dock QDockWidget* dasmDock = new QDockWidget("dasm", this); dasmDock->setObjectName("dasmdock"); dasmDock->setAllowedAreas(Qt::TopDockWidgetArea); m_dasmFrame = new DasmDockWidget(m_machine, dasmDock); dasmDock->setWidget(m_dasmFrame); connect(m_dasmFrame->view(), &DebuggerView::updated, this, &MainWindow::dasmViewUpdated); addDockWidget(Qt::TopDockWidgetArea, dasmDock); dockMenu->addAction(dasmDock->toggleViewAction()); }
MainWindow::MainWindow() { // defaults time_ = 0; // create menus in menu bar QMenu * fileMenu = menuBar()->addMenu("&File"); // create tool bars QToolBar * toolbar = addToolBar("toolbar"); QToolBar * toolbarBottom = new QToolBar("bottom toolbar", this); addToolBar(Qt::BottomToolBarArea, toolbarBottom); // new simulation action QAction * newSimulationAction = new QAction("New Simulation", this); newSimulationAction->setStatusTip("New simulation"); connect(newSimulationAction, SIGNAL(triggered()), this, SLOT(newSimulation())); // open data set action /*QAction * openDataSetAction = new QAction("Open Data Set", this); openDataSetAction->setStatusTip("Open data set"); connect(openDataSetAction, SIGNAL(triggered()), this, SLOT(openDataSet()));*/ // new chart action QAction * newChartAction = new QAction("New Chart", this); newChartAction->setStatusTip("New chart"); connect(newChartAction, SIGNAL(triggered()), this, SLOT(newChart())); #if USE_DISPLAYCLUSTER // connect to DisplayCluster action QAction * connectToDisplayClusterAction = new QAction("Connect to DisplayCluster", this); connectToDisplayClusterAction->setStatusTip("Connect to DisplayCluster"); connect(connectToDisplayClusterAction, SIGNAL(triggered()), this, SLOT(connectToDisplayCluster())); // disconnect from DisplayCluster action QAction * disconnectFromDisplayClusterAction = new QAction("Disconnect from DisplayCluster", this); disconnectFromDisplayClusterAction->setStatusTip("Disconnect from DisplayCluster"); connect(disconnectFromDisplayClusterAction, SIGNAL(triggered()), this, SLOT(disconnectFromDisplayCluster())); #endif // add actions to menus fileMenu->addAction(newSimulationAction); // fileMenu->addAction(openDataSetAction); fileMenu->addAction(newChartAction); #if USE_DISPLAYCLUSTER fileMenu->addAction(connectToDisplayClusterAction); fileMenu->addAction(disconnectFromDisplayClusterAction); #endif // add actions to toolbar toolbar->addAction(newSimulationAction); // toolbar->addAction(openDataSetAction); toolbar->addAction(newChartAction); // make map widgets the main view QTabWidget * tabWidget = new QTabWidget(); IliMapWidget * iliMapWidget = new IliMapWidget(); tabWidget->addTab(iliMapWidget, "ILI View"); EpidemicMapWidget * epidemicMapWidget = new EpidemicMapWidget(); tabWidget->addTab(epidemicMapWidget, "Infected"); StockpileMapWidget * antiviralsStockpileMapWidget = new StockpileMapWidget(); antiviralsStockpileMapWidget->setType(STOCKPILE_ANTIVIRALS); tabWidget->addTab(antiviralsStockpileMapWidget, "Antivirals Stockpile"); StockpileMapWidget * vaccinesStockpileMapWidget = new StockpileMapWidget(); vaccinesStockpileMapWidget->setType(STOCKPILE_VACCINES); tabWidget->addTab(vaccinesStockpileMapWidget, "Vaccines Stockpile"); setCentralWidget(tabWidget); // create event monitor and widget EventMonitor * eventMonitor = new EventMonitor(this); QDockWidget * eventMonitorDockWidget = new QDockWidget("Event Monitor", this); eventMonitorDockWidget->setWidget(new EventMonitorWidget(eventMonitor)); addDockWidget(Qt::TopDockWidgetArea, eventMonitorDockWidget); QDockWidget * timelineDockWidget = new QDockWidget("Timeline", this); timelineDockWidget->setWidget(new TimelineWidget(this, eventMonitor)); addDockWidget(Qt::TopDockWidgetArea, timelineDockWidget); // tabify event monitor and timeline widgets tabifyDockWidget(eventMonitorDockWidget, timelineDockWidget); // setup time slider and add it to bottom toolbar with label timeSlider_ = new QSlider(Qt::Horizontal, this); connect(timeSlider_, SIGNAL(valueChanged(int)), this, SLOT(setTime(int))); toolbarBottom->addWidget(new QLabel("Time")); toolbarBottom->addWidget(timeSlider_); // previous timestep button QAction * previousTimestepAction = new QAction(QIcon::fromTheme("media-seek-backward"), "Back", this); previousTimestepAction->setStatusTip(tr("Move backward one day")); connect(previousTimestepAction, SIGNAL(triggered()), this, SLOT(previousTimestep())); toolbarBottom->addAction(previousTimestepAction); // play timesteps button playTimestepsAction_ = new QAction(QIcon::fromTheme("media-seek-play"), "Run", this); playTimestepsAction_->setStatusTip(tr("Run simulation")); playTimestepsAction_->setCheckable(true); connect(playTimestepsAction_, SIGNAL(toggled(bool)), this, SLOT(playTimesteps(bool))); toolbarBottom->addAction(playTimestepsAction_); // next timestep button QAction * nextTimestepAction = new QAction(QIcon::fromTheme("media-seek-forward"), "Forward", this); nextTimestepAction->setStatusTip(tr("Move forward one day")); connect(nextTimestepAction, SIGNAL(triggered()), this, SLOT(nextTimestep())); toolbarBottom->addAction(nextTimestepAction); // parameters dock QDockWidget * parametersDockWidget = new QDockWidget("Parameters", this); parametersDockWidget->setWidget(new ParametersWidget()); addDockWidget(Qt::LeftDockWidgetArea, parametersDockWidget); // initial cases dock initialCasesWidget_ = new EpidemicInitialCasesWidget(this); QDockWidget * initialCasesDockWidget = new QDockWidget("Initial Cases", this); initialCasesDockWidget->setWidget(initialCasesWidget_); addDockWidget(Qt::LeftDockWidgetArea, initialCasesDockWidget); // stockpile network dock QDockWidget * stockpileNetworkDockWidget = new QDockWidget("Stockpile", this); stockpileNetworkDockWidget->setWidget(new StockpileNetworkWidget(this)); addDockWidget(Qt::LeftDockWidgetArea, stockpileNetworkDockWidget); // stockpile consumption dock QDockWidget * stockpileConsumptionDockWidget = new QDockWidget("Stockpile Priorities", this); stockpileConsumptionDockWidget->setWidget(new StockpileConsumptionWidget()); addDockWidget(Qt::LeftDockWidgetArea, stockpileConsumptionDockWidget); // priority group definition dock QDockWidget * priorityGroupDefinitionDockWidget = new QDockWidget("Priority Groups", this); priorityGroupDefinitionDockWidget->setWidget(new PriorityGroupDefinitionWidget()); addDockWidget(Qt::LeftDockWidgetArea, priorityGroupDefinitionDockWidget); // NPI definition dock QDockWidget * npiDefinitionDockWidget = new QDockWidget("NPI", this); npiDefinitionDockWidget->setWidget(new NpiDefinitionWidget(this)); addDockWidget(Qt::LeftDockWidgetArea, npiDefinitionDockWidget); // info dock QDockWidget * infoDockWidget = new QDockWidget("Info", this); infoDockWidget->setWidget(new EpidemicInfoWidget(this)); addDockWidget(Qt::LeftDockWidgetArea, infoDockWidget); // tabify parameters, initial cases, stockpile network, and info docks tabifyDockWidget(parametersDockWidget, initialCasesDockWidget); tabifyDockWidget(parametersDockWidget, stockpileNetworkDockWidget); tabifyDockWidget(parametersDockWidget, stockpileConsumptionDockWidget); tabifyDockWidget(parametersDockWidget, priorityGroupDefinitionDockWidget); tabifyDockWidget(parametersDockWidget, npiDefinitionDockWidget); tabifyDockWidget(parametersDockWidget, infoDockWidget); // chart docks // an epidemic chart QDockWidget * chartDockWidget = new QDockWidget("Chart", this); chartDockWidget->setWidget(new EpidemicChartWidget(this)); addDockWidget(Qt::BottomDockWidgetArea, chartDockWidget); // and a stockpile chart chartDockWidget = new QDockWidget("Chart", this); chartDockWidget->setWidget(new StockpileChartWidget(this)); addDockWidget(Qt::BottomDockWidgetArea, chartDockWidget); // make other signal / slot connections connect(this, SIGNAL(dataSetChanged(boost::shared_ptr<EpidemicDataSet>)), iliMapWidget, SLOT(setDataSet(boost::shared_ptr<EpidemicDataSet>))); connect(this, SIGNAL(dataSetChanged(boost::shared_ptr<EpidemicDataSet>)), epidemicMapWidget, SLOT(setDataSet(boost::shared_ptr<EpidemicDataSet>))); connect(this, SIGNAL(dataSetChanged(boost::shared_ptr<EpidemicDataSet>)), antiviralsStockpileMapWidget, SLOT(setDataSet(boost::shared_ptr<EpidemicDataSet>))); connect(this, SIGNAL(dataSetChanged(boost::shared_ptr<EpidemicDataSet>)), vaccinesStockpileMapWidget, SLOT(setDataSet(boost::shared_ptr<EpidemicDataSet>))); connect(this, SIGNAL(dataSetChanged()), this, SLOT(resetTimeSlider())); connect(this, SIGNAL(numberOfTimestepsChanged()), this, SLOT(resetTimeSlider())); connect(this, SIGNAL(timeChanged(int)), iliMapWidget, SLOT(setTime(int))); connect(this, SIGNAL(timeChanged(int)), epidemicMapWidget, SLOT(setTime(int))); connect(this, SIGNAL(timeChanged(int)), antiviralsStockpileMapWidget, SLOT(setTime(int))); connect(this, SIGNAL(timeChanged(int)), vaccinesStockpileMapWidget, SLOT(setTime(int))); connect(&playTimestepsTimer_, SIGNAL(timeout()), this, SLOT(playTimesteps())); // show the window show(); }
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(); }
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), bonjourResolver(0) { qDebug() << "NUview is starting in: MainWindow.cpp"; debug.open("debug.log"); errorlog.open("error.log"); m_platform = new NUPlatform(); // you could make the arguement that NUView should have its own platform, for now we just use a 'blank' one m_blackboard = new NUBlackboard(); m_blackboard->add(new NUSensorsData()); m_blackboard->add(new NUActionatorsData()); m_blackboard->add(new FieldObjects()); m_blackboard->add(new JobList()); m_blackboard->add(new GameInformation(0, 0)); m_blackboard->add(new TeamInformation(0, 0)); m_nuview_io = new NUviewIO(); // create mdi workspace mdiArea = new QMdiArea(this); mdiArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded); mdiArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded); createActions(); createMenus(); createContextMenu(); createToolBars(); createStatusBar(); sensorDisplay = new SensorDisplayWidget(this); QDockWidget* sensorDock = new QDockWidget("Sensor Values"); sensorDock->setObjectName("Sensor Values"); sensorDock->setWidget(sensorDisplay); sensorDock->setShown(false); addDockWidget(Qt::RightDockWidgetArea,sensorDock); // Add localisation widget localisation = new LocalisationWidget(this); addDockWidget(Qt::BottomDockWidgetArea,localisation); localisation->setVisible(false); // Add Vision Widgets to Tab then Dock them on Screen visionTabs = new QTabWidget(this); layerSelection = new LayerSelectionWidget(mdiArea,this); visionTabs->addTab(layerSelection,layerSelection->objectName()); classification = new ClassificationWidget(this); visionTabs->addTab(classification,classification->objectName()); visionTabDock = new QDockWidget("Vision"); visionTabDock->setWidget(visionTabs); visionTabDock->setObjectName(tr("visionTab")); addDockWidget(Qt::RightDockWidgetArea, visionTabDock); // Add Network widgets to Tabs then dock them on Screen networkTabs = new QTabWidget(this); connection = new ConnectionWidget(this); networkTabs->addTab(connection, connection->objectName()); walkParameter = new WalkParameterWidget(mdiArea, this); kick = new KickWidget(mdiArea, this); networkTabs->addTab(walkParameter, walkParameter->objectName()); networkTabs->addTab(kick, kick->objectName()); VisionStreamer = new visionStreamWidget(mdiArea, this); LocWmStreamer = new locwmStreamWidget(mdiArea, this); networkTabs->addTab(VisionStreamer, VisionStreamer->objectName()); networkTabs->addTab(LocWmStreamer, LocWmStreamer->objectName()); cameraSetting = new cameraSettingsWidget(mdiArea, this); networkTabs->addTab(cameraSetting, cameraSetting->objectName()); //networkTabs->addTab(kick, kick->objectName()); networkTabDock = new QDockWidget("Network"); networkTabDock->setWidget(networkTabs); networkTabDock->setObjectName(tr("networkTab")); addDockWidget(Qt::RightDockWidgetArea, networkTabDock); frameInfo = new frameInformationWidget(this); QDockWidget* temp = new QDockWidget(this); temp->setWidget(frameInfo); temp->setObjectName("Frame Information Dock"); temp->setWindowTitle(frameInfo->windowTitle()); addDockWidget(Qt::RightDockWidgetArea,temp); createConnections(); setCentralWidget(mdiArea); qDebug() << "Main Window Starting"; setWindowTitle(QString("NUview")); glManager.clearAllDisplays(); qDebug() << "Display Cleared"; readSettings(); qDebug() << "Main Window Started"; //glManager.writeWMBallToDisplay(100,100,30,GLDisplay::CalGrid); glManager.writeCalGridToDisplay(GLDisplay::CalGrid); // //glManager.writeCalGridToDisplay(GLDisplay::CalGrid); // }
/** * @brief * Selects the given object */ void DockWidgetObject::SelectObject(Object *pObject) { // State change? if (m_pObject != pObject) { // Disconnect event handler if (m_pObject) m_pObject->SignalDestroyed.Disconnect(SlotOnDestroyed); // Backup the given object pointer m_pObject = pObject; // Connect event handler if (m_pObject) m_pObject->SignalDestroyed.Connect(SlotOnDestroyed); // Is there a PL introspection model instance? if (m_pPLIntrospectionModel) { // Set object m_pPLIntrospectionModel->SetObject(m_pObject); { // Usability: Resize the first tree view column given to the size of its contents // No need to backup current expanded state and restore it after we're done because we set new content above resulting in that all is collapsed when we're in here m_pQTreeView->expandAll(); m_pQTreeView->resizeColumnToContents(0); m_pQTreeView->collapseAll(); } // Get encapsulated Qt dock widget and set a decent window title QDockWidget *pQDockWidget = GetQDockWidget(); if (pQDockWidget) { // Set window title QString sQStringWindowTitle = pQDockWidget->tr(GetClass()->GetProperties().Get("Title")); if (m_pObject) { // Append class name sQStringWindowTitle += ": "; sQStringWindowTitle += QtStringAdapter::PLToQt('\"' + m_pObject->GetClass()->GetClassName() + '\"'); // Put it into quotes to make it possible to see e.g. trailing spaces // An "PLCore::Object" itself has no "name", we could show the memory address but this wouldn't be that useful to the user // -> Try "GetAbsoluteName()"-method to get an absolute name // -> In case there's no name, check whether there's an name attribute // -> In case there's still no name, check whether or not there's an filename attribute String sName; { // Try "GetAbsoluteName()"-method to get an absolute name // Get the typed dynamic parameters Params<String> cParams; // Call the RTTI method m_pObject->CallMethod("GetAbsoluteName", cParams); // Get the result sName = cParams.Return; if (sName.GetLength()) sName = "Name = \"" + sName + '\"'; // Put it into quotes to make it possible to see e.g. trailing spaces } // Do we already have a name? if (!sName.GetLength()) { // Check whether there's an name attribute DynVar *pDynVar = m_pObject->GetAttribute("Name"); if (pDynVar) sName = "Name = \"" + pDynVar->GetString() + '\"'; // Put it into quotes to make it possible to see e.g. trailing spaces // In case there's still no name, check whether or not there's an filename attribute if (!sName.GetLength()) { DynVar *pDynVar = m_pObject->GetAttribute("Filename"); if (pDynVar) sName = "Filename = \"" + pDynVar->GetString() + '\"'; // Put it into quotes to make it possible to see e.g. trailing spaces } } // Use the name, if we have one if (sName.GetLength()) { // We have a representable name, show it to the user sQStringWindowTitle += ": "; sQStringWindowTitle += QtStringAdapter::PLToQt(sName); } } pQDockWidget->setWindowTitle(sQStringWindowTitle); } } } }
void QDockWidgetLayout::setGeometry(const QRect &geometry) { QDockWidget *q = qobject_cast<QDockWidget*>(parentWidget()); bool nativeDeco = nativeWindowDeco(); int fw = q->isFloating() && !nativeDeco ? q->style()->pixelMetric(QStyle::PM_DockWidgetFrameWidth, 0, q) : 0; if (nativeDeco) { if (QLayoutItem *item = item_list[Content]) item->setGeometry(geometry); } else { int titleHeight = this->titleHeight(); if (verticalTitleBar) { _titleArea = QRect(QPoint(fw, fw), QSize(titleHeight, geometry.height() - (fw * 2))); } else { _titleArea = QRect(QPoint(fw, fw), QSize(geometry.width() - (fw * 2), titleHeight)); } if (QLayoutItem *item = item_list[TitleBar]) { item->setGeometry(_titleArea); } else { QStyleOptionDockWidgetV2 opt; q->initStyleOption(&opt); if (QLayoutItem *item = item_list[CloseButton]) { if (!item->isEmpty()) { QRect r = q->style() ->subElementRect(QStyle::SE_DockWidgetCloseButton, &opt, q); if (!r.isNull()) item->setGeometry(r); } } if (QLayoutItem *item = item_list[FloatButton]) { if (!item->isEmpty()) { QRect r = q->style() ->subElementRect(QStyle::SE_DockWidgetFloatButton, &opt, q); if (!r.isNull()) item->setGeometry(r); } } } if (QLayoutItem *item = item_list[Content]) { QRect r = geometry; if (verticalTitleBar) { r.setLeft(_titleArea.right() + 1); r.adjust(0, fw, -fw, -fw); } else { r.setTop(_titleArea.bottom() + 1); r.adjust(fw, 0, -fw, -fw); } item->setGeometry(r); } } }
void ResourceBrowser::setupDockWidgets() { QDockWidget* dock = new QDockWidget(i18n("Recommendation"),this); dock->setAllowedAreas(Qt::RightDockWidgetArea); m_recommendationView = new QListView(dock); m_recommendationView->setContextMenuPolicy(Qt::CustomContextMenu); connect(m_recommendationView,SIGNAL(customContextMenuRequested(QPoint)),this,SLOT(slotRecommendedResourceContextMenu(QPoint))); dock->setWidget(m_recommendationView); addDockWidget(Qt::RightDockWidgetArea,dock); //TODO::if locked -> do this //dock->setFeatures(QDockWidget::NoDockWidgetFeatures); dock = new QDockWidget(i18n("Linked Resources"),this); dock->setAllowedAreas(Qt::RightDockWidgetArea); m_linkedResourceView = new QListView(dock); m_linkedResourceView->setContextMenuPolicy(Qt::CustomContextMenu); connect(m_linkedResourceView,SIGNAL(customContextMenuRequested(QPoint)),this,SLOT(slotLinkedResourceContextMenu(QPoint))); dock->setWidget(m_linkedResourceView); addDockWidget(Qt::RightDockWidgetArea,dock); dock = new QDockWidget("",this); dock->setAllowedAreas(Qt::LeftDockWidgetArea); QWidget* buttonWidget = new QWidget(dock); QVBoxLayout* buttonLayout = new QVBoxLayout(buttonWidget); m_manualLinkResourceButton = new QPushButton(buttonWidget); m_manualLinkResourceButton->setIcon(KIcon("insert-link")); m_manualLinkResourceButton->setText(i18n("Link resources manually")); m_manualLinkResourceButton->setEnabled(false); m_manualLinkResourceButton->setFlat(true); connect(m_manualLinkResourceButton,SIGNAL(clicked()),this,SLOT(slotManualLinkResources())); m_removeDuplicateButton = new QPushButton(buttonWidget); m_removeDuplicateButton->setIcon(KIcon("archive-remove")); m_removeDuplicateButton->setText(i18n("Remove Duplicates")); m_removeDuplicateButton->setFlat(true); connect(m_removeDuplicateButton, SIGNAL(clicked()), this, SLOT(slotRemoveDuplicates())); m_autoTopicButton = new QPushButton(buttonWidget); m_autoTopicButton->setIcon(KIcon("nepomuk")); m_autoTopicButton->setText(i18n("Automatic Topic")); m_autoTopicButton->setFlat(true); connect(m_autoTopicButton, SIGNAL(clicked()), this, SLOT(slotAutomaticTopic())); buttonLayout->addWidget(m_manualLinkResourceButton); buttonLayout->addWidget(m_removeDuplicateButton); buttonLayout->addWidget(m_autoTopicButton); dock->setWidget(buttonWidget); dock->setFeatures(QDockWidget::NoDockWidgetFeatures); addDockWidget(Qt::LeftDockWidgetArea,dock); dock = new QDockWidget(i18n("Resource Search "),this); Nepomuk::Utils::FacetWidget *searchWidget = new Nepomuk::Utils::FacetWidget(dock); searchWidget->addFacet(Nepomuk::Utils::Facet::createDateFacet(searchWidget)); searchWidget->addFacet(Nepomuk::Utils::Facet::createTypeFacet(searchWidget)); searchWidget->addFacet(Nepomuk::Utils::Facet::createRatingFacet(searchWidget)); searchWidget->addFacet(Nepomuk::Utils::Facet::createPriorityFacet(searchWidget)); searchWidget->addFacet(Nepomuk::Utils::Facet::createTagFacet(searchWidget)); connect(searchWidget,SIGNAL(queryTermChanged(Nepomuk::Query::Term)),this,SLOT(slotFilterApplied(Nepomuk::Query::Term))); dock->setWidget(searchWidget); addDockWidget(Qt::LeftDockWidgetArea,dock); dock->setFeatures(QDockWidget::NoDockWidgetFeatures); connect (this, SIGNAL( sigShowProperties(KUrl) ), this, SLOT( slotShowProperties(KUrl))); }
void CockpitWindow::constructLayout() { // Setup an MDI application. m_cockpitArea = new QMdiArea(this); m_fileMenu = menuBar()->addMenu(tr("&File")); m_fileMenu->addSeparator(); QAction *closeAction = new QAction(tr("&Close"), this); closeAction->setShortcut(tr("Ctrl+Q")); closeAction->setToolTip("Close the application."); connect(closeAction, SIGNAL(triggered()), this, SLOT(close())); m_fileMenu->addAction(closeAction); m_windowMenu = menuBar()->addMenu(tr("&Window")); QAction* cascadeSWAct = new QAction(tr("C&ascade"), this); cascadeSWAct->setShortcut(tr("Ctrl+F9")); cascadeSWAct->setToolTip(tr("Cascade all open monitors.")); connect(cascadeSWAct, SIGNAL(triggered()), m_cockpitArea, SLOT(cascadeSubWindows())); m_windowMenu->addAction(cascadeSWAct); QAction* tileSWAct = new QAction(tr("&Tile"), this); tileSWAct->setShortcut(tr("Ctrl+F10")); tileSWAct->setToolTip(tr("Tile all open monitors.")); connect(tileSWAct, SIGNAL(triggered()), m_cockpitArea, SLOT(tileSubWindows())); m_windowMenu->addAction(tileSWAct); m_windowMenu->addSeparator(); QAction* maxSWAction = new QAction(tr("Ma&ximize"), this); maxSWAction->setShortcut(tr("Ctrl+F11")); maxSWAction->setToolTip(tr("Maximize current monitor.")); connect(maxSWAction, SIGNAL(triggered()), SLOT(maximizeActiveSubWindow())); m_windowMenu->addAction(maxSWAction); QAction* minSWAction = new QAction(tr("M&inimize"), this); minSWAction->setShortcut(tr("Ctrl+F12")); minSWAction->setToolTip(tr("Minimize current monitor.")); connect(minSWAction, SIGNAL(triggered()), SLOT(minimizeActiveSubWindow())); m_windowMenu->addAction(minSWAction); QAction* resetSWAction = new QAction(tr("&Reset"), this); resetSWAction->setShortcut(tr("Ctrl+Shift+F12")); resetSWAction->setToolTip(tr("Reset current monitor.")); connect(resetSWAction, SIGNAL(triggered()), SLOT(resetActiveSubWindow())); m_windowMenu->addAction(resetSWAction); QAction* closeSWAction = new QAction(tr("&Close"), this); closeSWAction->setShortcut(tr("Ctrl+C")); closeSWAction->setToolTip(tr("Close current monitor.")); connect(closeSWAction, SIGNAL(triggered()), m_cockpitArea , SLOT(closeActiveSubWindow())); m_windowMenu->addAction(closeSWAction); QAction* closeAllSWAction = new QAction(tr("Close &all"), this); closeAllSWAction->setShortcut(tr("Ctrl+Shift+C")); closeAllSWAction->setToolTip(tr("Close all monitors.")); connect(closeAllSWAction, SIGNAL(triggered()), m_cockpitArea, SLOT(closeAllSubWindows())); m_windowMenu->addAction(closeAllSWAction); // Load available plugins. m_availablePlugInsList = new QListWidget(this); m_availablePlugInsList->setMaximumWidth(200); m_availablePlugInsList->setMinimumWidth(200); connect(m_availablePlugInsList, SIGNAL(itemDoubleClicked(QListWidgetItem*)), SLOT(showPlugIn(QListWidgetItem*))); // Query PlugInProvider for available plugins. vector<string> listOfAvailablePlugins = m_plugInProvider.getListOfAvailablePlugIns(); vector<string>::iterator it = listOfAvailablePlugins.begin(); while (it != listOfAvailablePlugins.end()) { QListWidgetItem *item = new QListWidgetItem(m_availablePlugInsList); item->setText((*it).c_str()); item->setToolTip(m_plugInProvider.getDescriptionForPlugin((*it)).c_str()); it++; } QDockWidget *dockWidget = new QDockWidget(tr("Plugins"), this); dockWidget->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea); dockWidget->setWidget(m_availablePlugInsList); addDockWidget(Qt::LeftDockWidgetArea, dockWidget); setCentralWidget(m_cockpitArea); m_multiplexer->start(); }
QWidget* WidgetStyle::createWidget(const QString& name) { if(name == "CheckBox") { QCheckBox* box = new QCheckBox("CheckBox"); box->setObjectName("CheckBox"); return setLayoutWidget({ box }, { 100, 30 }); } else if(name == "ComboBox") { QComboBox* box = new QComboBox; box->addItem("Item1"); box->addItem("Item3"); box->addItem("Item3"); box->setObjectName("ComboBox"); return setLayoutWidget({ box }, { 70, 30 }); } else if(name == "DateEdit") { QDateEdit* date = new QDateEdit; date->setObjectName("DateEdit"); return setLayoutWidget({ date }, { 110, 40 }); } else if(name == "DateTimeEdit") { QDateTimeEdit* date = new QDateTimeEdit; date->setObjectName("DateTimeEdit"); return setLayoutWidget({ date }, { 160, 30 }); } else if(name == "Dialog") { QDialog* dialog = new QDialog; dialog->setObjectName("Dialog"); return setLayoutWidget({ dialog }, { 160, 110 }); } else if(name == "DockWidget") //? { QDockWidget* widget = new QDockWidget; widget->setObjectName("DockWidget"); widget->resize(61, 22); return widget; } else if(name == "DoubleSpinBox") { QDoubleSpinBox* box = new QDoubleSpinBox; box->setObjectName("DoubleSpinBox"); return setLayoutWidget({ box }, { 90, 40 }); } else if(name == "Frame") //?? { QFrame* frame = new QFrame; frame->setObjectName("Frame"); frame->resize(150, 100); return frame; } else if(name == "GroupBox") { QGroupBox* box = new QGroupBox("GroupBox"); box->setObjectName("GroupBox"); return setLayoutWidget({ box }, { 160, 110 }); } else if(name == "Label") { QLabel* label = new QLabel("Label"); label->setObjectName("Label"); return setLayoutWidget({ label }, { 40, 20}); } else if(name == "LineEdit") { QLineEdit* line = new QLineEdit; line->setObjectName("LineEdit"); return setLayoutWidget({ line }, { 30, 30 }); } else if(name == "ListView") //?? { QListView* view = new QListView; view->setObjectName("ListView"); view->resize(71, 71); return view; } else if(name == "ListWidget") { QListWidget* list = new QListWidget; list->setObjectName("ListWidget"); for(int i = 0; i < 20; i++) list->addItem(QString("Item %1").arg(i)); return setLayoutWidget({ list }, { 80, 80 }); } else if(name == "MainWindow") { QMainWindow* window = new QMainWindow; window->setObjectName("MainWindow"); return setLayoutWidget({ window }, { 160, 110 }); } else if(name == "Menu") { QMenu* parentMenu = new QMenu; parentMenu->setObjectName("Menu"); parentMenu->addMenu("Menu1"); QMenu* menu1 = parentMenu->addMenu("Menu2"); menu1->addMenu("Menu1"); menu1->addMenu("Menu2"); parentMenu->addSeparator(); parentMenu->addMenu("Menu3"); return setLayoutWidget({ parentMenu }, { 160, 110 }); } else if(name == "MenuBar") { QMenuBar* bar = new QMenuBar; bar->setObjectName("QMenuBar"); QMenu* menu1 = bar->addMenu("MenuBar1"); menu1->addMenu("Menu1"); menu1->addSeparator(); menu1->addMenu("Menu2"); QMenu* menu2 = bar->addMenu("MenuBar2"); menu2->addMenu("Menu1"); menu2->addSeparator(); menu2->addMenu("Menu2"); QMenu* menu3 = bar->addMenu("MenuBar3"); menu3->addMenu("Menu1"); menu3->addSeparator(); menu3->addMenu("Menu2"); return setLayoutWidget({ bar }, { 280, 60 }); } else if(name == "ProgressBar") { QProgressBar* bar = new QProgressBar; bar->setObjectName("ProgressBar"); bar->setRange(0, 100); bar->setValue(0); QTimer* timer = new QTimer(bar); this->connect(timer, &QTimer::timeout, this, [bar]() { if(bar->value() == 100) bar->setValue(0); else bar->setValue(bar->value() + 1); }); timer->start(100); return setLayoutWidget({ bar }, { 110, 30 }); } else if(name == "PushButton") { QPushButton* button = new QPushButton("PushButton"); button->setObjectName("PushButton"); return setLayoutWidget({ button }, { 125, 30 }); } else if(name == "RadioButton") { QRadioButton* button = new QRadioButton("RadioButton"); button->setObjectName("RadioButton"); return setLayoutWidget({ button }, { 125, 30 }); } else if(name == "ScrollBar") { QScrollBar* barH = new QScrollBar(Qt::Horizontal); QScrollBar* barV = new QScrollBar(Qt::Vertical); barH->setObjectName("ScrollBarH"); barV->setObjectName("ScrollBarV"); return setLayoutWidget({ barH, barV }, { 200, 100 }); } else if(name == "Slider") { QSlider* sliderH = new QSlider(Qt::Horizontal); QSlider* sliderV = new QSlider(Qt::Vertical); sliderH->setObjectName("SliderH"); sliderV->setObjectName("SliderV"); return setLayoutWidget({ sliderH, sliderV }, { 200, 100 }); } else if(name == "SpinBox") { QSpinBox* spinBox = new QSpinBox; spinBox->setObjectName("SpinBox"); return setLayoutWidget({ spinBox }, { 60, 35 }); } else if(name == "Splitter") { QSplitter* splitterV = new QSplitter(Qt::Vertical); QSplitter* splitterH = new QSplitter(Qt::Horizontal); splitterV->setObjectName("SplitterV"); splitterH->setObjectName("SplitterH"); splitterV->addWidget(new QPushButton("PushButton1")); splitterV->addWidget(new QPushButton("PushButton2")); splitterH->addWidget(splitterV); splitterH->addWidget(new QPushButton("PushButton3")); return setLayoutWidget({ splitterH }, { 250, 110 }); } else if(name == "TabWidget") { QTabWidget* tab = new QTabWidget; tab->addTab(new QWidget, "Widget1"); tab->addTab(new QWidget, "Widget2"); tab->addTab(new QWidget, "Widget3"); tab->setObjectName("TabWidget"); return setLayoutWidget({ tab }, { 210, 110 }); } else if(name == "TableView") //? { QTableView* view = new QTableView; view->setObjectName("TableView"); view->resize(200, 100); return view; } else if(name == "TableWidget") { const int n = 100; QStringList list = { "one", "two", "three" }; QTableWidget* table = new QTableWidget(n, n); table->setObjectName("TableWidget"); table->setHorizontalHeaderLabels(list); table->setVerticalHeaderLabels(list); for(int i = 0; i < n; i++) for(int j = 0; j < n; j++) table->setItem(i, j, new QTableWidgetItem(QString("%1, %2").arg(i).arg(j))); return setLayoutWidget({ table }, { 210, 110 }); } else if(name == "TextEdit") { QTextEdit* text = new QTextEdit; text->setObjectName("TextEdit"); return setLayoutWidget({ text }, { 80, 80 }); } else if(name == "TimeEdit") { QTimeEdit* time = new QTimeEdit; time->setObjectName("TimeEdit"); return setLayoutWidget({ time }, { 80, 80 }); } else if(name == "ToolButton") { QToolButton* button = new QToolButton; button->setText("ToolButton"); button->setObjectName("ToolButton"); return setLayoutWidget({ button }, { 95, 25 }); } else if(name == "ToolBox") { QToolBox* box = new QToolBox; box->addItem(new QWidget, "Widget1"); box->addItem(new QWidget, "Widget2"); box->addItem(new QWidget, "Widget3"); box->setObjectName("ToolBox"); return setLayoutWidget({ box }, { 110, 180 }); } else if(name == "TreeView") //? { QTreeView* tree = new QTreeView; tree->setObjectName("TreeView"); tree->resize(200, 100); return tree; } else if(name == "TreeWidget") { QTreeWidget* tree = new QTreeWidget; tree->setObjectName("TreeWidget"); tree->setHeaderLabels({ "Folders", "Used Space" }); QTreeWidgetItem* item = new QTreeWidgetItem(tree); item->setText(0, "Local Disk"); for(int i = 1; i < 20; i++) { QTreeWidgetItem* dir = new QTreeWidgetItem(item); dir->setText(0, "Directory" + QString::number(i)); dir->setText(1, QString::number(i) + "MB"); } tree->setItemExpanded(item, true); return setLayoutWidget({ tree }, { 210, 110 }); } else if(name == "Widget") { QWidget* widget = new QWidget; widget->setObjectName("Widget"); return setLayoutWidget({ widget }, { 210, 110 }); } return nullptr; }
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent) { QMenu *editMenu = menuBar()->addMenu(tr("Edit")); QMenu *newObjectMenu = editMenu->addMenu(tr("New Object")); QAction *newRectangleAction = new QAction(tr("Rectangle"), this); connect(newRectangleAction, SIGNAL(triggered(bool)), this, SLOT(newRectangle())); newObjectMenu->addAction(newRectangleAction); QAction *newLineAction = new QAction(tr("Line"), this); connect(newLineAction, SIGNAL(triggered(bool)), this, SLOT(newLine())); newObjectMenu->addAction(newLineAction); QAction *newEllipseAction = new QAction(tr("Ellipse"), this); connect(newEllipseAction, SIGNAL(triggered(bool)), this, SLOT(newEllipse())); newObjectMenu->addAction(newEllipseAction); QAction *newTextAction = new QAction(tr("Text"), this); connect(newTextAction, SIGNAL(triggered(bool)), this, SLOT(newText())); newObjectMenu->addAction(newTextAction); deleteAction = new QAction(tr("Delete Object"), this); connect(deleteAction, SIGNAL(triggered(bool)), this, SLOT(deleteObject())); editMenu->addAction(deleteAction); QAction *clearAction = new QAction(tr("Clear All"), this); connect(clearAction, SIGNAL(triggered(bool)), this, SLOT(clearAll())); editMenu->addAction(clearAction); QAction *fillAction = new QAction(tr("Fill View"), this); connect(fillAction, SIGNAL(triggered(bool)), this, SLOT(fillView())); editMenu->addAction(fillAction); doubleManager = new QtDoublePropertyManager(this); stringManager = new QtStringPropertyManager(this); colorManager = new QtColorPropertyManager(this); fontManager = new QtFontPropertyManager(this); pointManager = new QtPointPropertyManager(this); sizeManager = new QtSizePropertyManager(this); connect(doubleManager, SIGNAL(valueChanged(QtProperty *, double)), this, SLOT(valueChanged(QtProperty *, double))); connect(stringManager, SIGNAL(valueChanged(QtProperty *, const QString &)), this, SLOT(valueChanged(QtProperty *, const QString &))); connect(colorManager, SIGNAL(valueChanged(QtProperty *, const QColor &)), this, SLOT(valueChanged(QtProperty *, const QColor &))); connect(fontManager, SIGNAL(valueChanged(QtProperty *, const QFont &)), this, SLOT(valueChanged(QtProperty *, const QFont &))); connect(pointManager, SIGNAL(valueChanged(QtProperty *, const QPoint &)), this, SLOT(valueChanged(QtProperty *, const QPoint &))); connect(sizeManager, SIGNAL(valueChanged(QtProperty *, const QSize &)), this, SLOT(valueChanged(QtProperty *, const QSize &))); QtDoubleSpinBoxFactory *doubleSpinBoxFactory = new QtDoubleSpinBoxFactory(this); QtCheckBoxFactory *checkBoxFactory = new QtCheckBoxFactory(this); QtSpinBoxFactory *spinBoxFactory = new QtSpinBoxFactory(this); QtLineEditFactory *lineEditFactory = new QtLineEditFactory(this); QtEnumEditorFactory *comboBoxFactory = new QtEnumEditorFactory(this); canvas = new QtCanvas(800, 600); canvasView = new CanvasView(canvas, this); setCentralWidget(canvasView); QDockWidget *dock = new QDockWidget(this); addDockWidget(Qt::RightDockWidgetArea, dock); propertyEditor = new QtTreePropertyBrowser(dock); propertyEditor->setFactoryForManager(doubleManager, doubleSpinBoxFactory); propertyEditor->setFactoryForManager(stringManager, lineEditFactory); propertyEditor->setFactoryForManager(colorManager->subIntPropertyManager(), spinBoxFactory); propertyEditor->setFactoryForManager(fontManager->subIntPropertyManager(), spinBoxFactory); propertyEditor->setFactoryForManager(fontManager->subBoolPropertyManager(), checkBoxFactory); propertyEditor->setFactoryForManager(fontManager->subEnumPropertyManager(), comboBoxFactory); propertyEditor->setFactoryForManager(pointManager->subIntPropertyManager(), spinBoxFactory); propertyEditor->setFactoryForManager(sizeManager->subIntPropertyManager(), spinBoxFactory); dock->setWidget(propertyEditor); currentItem = 0; connect(canvasView, SIGNAL(itemClicked(QtCanvasItem *)), this, SLOT(itemClicked(QtCanvasItem *))); connect(canvasView, SIGNAL(itemMoved(QtCanvasItem *)), this, SLOT(itemMoved(QtCanvasItem *))); fillView(); itemClicked(0); }
MainWindow::MainWindow(QWidget* parent) : CGAL::Qt::DemosMainWindow(parent) { ui = new Ui::MainWindow; ui->setupUi(this); // remove the Load Script menu entry, when the demo has not been compiled with QT_SCRIPT_LIB #if !defined(QT_SCRIPT_LIB) ui->menuBar->removeAction(ui->actionLoad_Script); #endif // Save some pointers from ui, for latter use. sceneView = ui->sceneView; viewer = ui->viewer; // do not save the state of the viewer (anoying) viewer->setStateFileName(QString::null); // setup scene scene = new Scene(this); viewer->setScene(scene); { QShortcut* shortcut = new QShortcut(QKeySequence(Qt::ALT+Qt::Key_Q), this); connect(shortcut, SIGNAL(activated()), this, SLOT(setFocusToQuickSearch())); } proxyModel = new QSortFilterProxyModel(this); proxyModel->setSourceModel(scene); connect(ui->searchEdit, SIGNAL(textChanged(QString)), proxyModel, SLOT(setFilterFixedString(QString))); sceneView->setModel(proxyModel); // setup the sceneview: delegation and columns sizing... sceneView->setItemDelegate(new SceneDelegate(this)); sceneView->header()->setStretchLastSection(false); sceneView->header()->setSectionResizeMode(Scene::NameColumn, QHeaderView::Stretch); sceneView->header()->setSectionResizeMode(Scene::NameColumn, QHeaderView::Stretch); sceneView->header()->setSectionResizeMode(Scene::ColorColumn, QHeaderView::ResizeToContents); sceneView->header()->setSectionResizeMode(Scene::RenderingModeColumn, QHeaderView::Fixed); sceneView->header()->setSectionResizeMode(Scene::ABColumn, QHeaderView::Fixed); sceneView->header()->setSectionResizeMode(Scene::VisibleColumn, QHeaderView::Fixed); sceneView->resizeColumnToContents(Scene::ColorColumn); sceneView->resizeColumnToContents(Scene::RenderingModeColumn); sceneView->resizeColumnToContents(Scene::ABColumn); sceneView->resizeColumnToContents(Scene::VisibleColumn); // setup connections connect(scene, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex & )), this, SLOT(updateInfo())); connect(scene, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex & )), this, SLOT(updateDisplayInfo())); connect(scene, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex & )), viewer, SLOT(updateGL())); connect(scene, SIGNAL(updated()), viewer, SLOT(updateGL())); connect(scene, SIGNAL(updated()), this, SLOT(selectionChanged())); connect(scene, SIGNAL(itemAboutToBeDestroyed(Scene_item*)), this, SLOT(removeManipulatedFrame(Scene_item*))); connect(scene, SIGNAL(updated_bbox()), this, SLOT(updateViewerBBox())); connect(sceneView->selectionModel(), SIGNAL(selectionChanged ( const QItemSelection & , const QItemSelection & ) ), this, SLOT(updateInfo())); connect(sceneView->selectionModel(), SIGNAL(selectionChanged ( const QItemSelection & , const QItemSelection & ) ), this, SLOT(updateDisplayInfo())); connect(sceneView->selectionModel(), SIGNAL(selectionChanged ( const QItemSelection & , const QItemSelection & ) ), this, SLOT(selectionChanged())); sceneView->setContextMenuPolicy(Qt::CustomContextMenu); connect(sceneView, SIGNAL(customContextMenuRequested(const QPoint & )), this, SLOT(showSceneContextMenu(const QPoint &))); connect(viewer, SIGNAL(selected(int)), this, SLOT(selectSceneItem(int))); connect(viewer, SIGNAL(selectedPoint(double, double, double)), this, SLOT(showSelectedPoint(double, double, double))); connect(viewer, SIGNAL(selectionRay(double, double, double, double, double, double)), scene, SIGNAL(selectionRay(double, double, double, double, double, double))); connect(viewer, SIGNAL(requestContextMenu(QPoint)), this, SLOT(contextMenuRequested(QPoint))); // The contextMenuPolicy of infoLabel is now the default one, so that one // can easily copy-paste its text. // connect(ui->infoLabel, SIGNAL(customContextMenuRequested(const QPoint & )), // this, SLOT(showSceneContextMenu(const QPoint &))); connect(ui->actionRecenterScene, SIGNAL(triggered()), viewer, SLOT(update())); connect(ui->actionAntiAliasing, SIGNAL(toggled(bool)), viewer, SLOT(setAntiAliasing(bool))); connect(ui->actionDraw_two_sides, SIGNAL(toggled(bool)), viewer, SLOT(setTwoSides(bool))); // add the "About CGAL..." and "About demo..." entries this->addAboutCGAL(); this->addAboutDemo(":/cgal/Polyhedron_3/about.html"); // Connect the button "addButton" with actionLoad ui->addButton->setDefaultAction(ui->actionLoad); // Same with "removeButton" and "duplicateButton" ui->removeButton->setDefaultAction(ui->actionErase); ui->duplicateButton->setDefaultAction(ui->actionDuplicate); // Connect actionQuit (Ctrl+Q) and qApp->quit() connect(ui->actionQuit, SIGNAL(triggered()), this, SLOT(quit())); // Connect "Select all items" connect(ui->actionSelect_all_items, SIGNAL(triggered()), this, SLOT(selectAll())); // Recent files menu this->addRecentFiles(ui->menuFile, ui->actionQuit); connect(this, SIGNAL(openRecentFile(QString)), this, SLOT(open(QString))); // Reset the "Operation menu" clearMenu(ui->menuOperations); #ifdef QT_SCRIPT_LIB std::cerr << "Enable scripts.\n"; script_engine = new QScriptEngine(this); qScriptRegisterMetaType<Scene_item*>(script_engine, myScene_itemToScriptValue, myScene_itemFromScriptValue); # ifdef QT_SCRIPTTOOLS_LIB QScriptEngineDebugger* debugger = new QScriptEngineDebugger(this); debugger->setObjectName("qt script debugger"); QAction* debuggerMenuAction = menuBar()->addMenu(debugger->createStandardMenu()); debuggerMenuAction->setText(tr("Qt Script &debug")); for(unsigned int i = 0; i < 9; ++i) { QDockWidget* dock = new QDockWidget(debug_widgets_names[i], this); dock->setObjectName(debug_widgets_names[i]); dock->setWidget(debugger->widget(debug_widgets[i])); this->addDockWidget(Qt::BottomDockWidgetArea, dock); dock->hide(); } debugger->setAutoShowStandardWindow(false); debugger->attachTo(script_engine); # endif // QT_SCRIPTTOOLS_LIB QScriptValue fun = script_engine->newFunction(myPrintFunction); script_engine->globalObject().setProperty("print", fun); // evaluate_script("print('hello', 'world', 'from QtScript!')"); QScriptValue mainWindowObjectValue = script_engine->newQObject(this); script_engine->globalObject().setProperty("main_window", mainWindowObjectValue); QScriptValue sceneObjectValue = script_engine->newQObject(scene); mainWindowObjectValue.setProperty("scene", sceneObjectValue); script_engine->globalObject().setProperty("scene", sceneObjectValue); QScriptValue viewerObjectValue = script_engine->newQObject(viewer); mainWindowObjectValue.setProperty("viewer", viewerObjectValue); script_engine->globalObject().setProperty("viewer", viewerObjectValue); QScriptValue cameraObjectValue = script_engine->newQObject(viewer->camera()); viewerObjectValue.setProperty("camera", cameraObjectValue); script_engine->globalObject().setProperty("camera", cameraObjectValue); evaluate_script("var plugins = new Array();"); # ifdef QT_SCRIPTTOOLS_LIB QScriptValue debuggerObjectValue = script_engine->newQObject(debugger); script_engine->globalObject().setProperty("debugger", debuggerObjectValue); # endif #endif readSettings(); // Among other things, the column widths are stored. // Load plugins, and re-enable actions that need it. loadPlugins(); // Setup the submenu of the View menu that can toggle the dockwidgets Q_FOREACH(QDockWidget* widget, findChildren<QDockWidget*>()) { ui->menuDockWindows->addAction(widget->toggleViewAction()); }
int main(int argc, char** argv) { osg::ArgumentParser arguments(&argc,argv); osg::DisplaySettings::instance()->setMinimumNumStencilBits(8); std::string stylesheet; bool styled = arguments.read("--stylesheet", stylesheet); bool on_demand = arguments.read("--run-on-demand"); bool trackData = arguments.read("--tracks"); bool testUseExistingViewer = arguments.read("--use-existing"); // load the .earth file from the command line. osg::Node* earthNode = osgDB::readNodeFiles( arguments ); if (!earthNode) return usage( "Unable to load earth model." ); osg::Group* root = new osg::Group(); root->addChild( earthNode ); s_annoGroup = new osg::Group(); root->addChild( s_annoGroup ); #ifdef Q_WS_X11 XInitThreads(); #endif QApplication app(argc, argv); osg::ref_ptr<osgEarth::MapNode> mapNode = osgEarth::MapNode::findMapNode( earthNode ); osg::ref_ptr<osgEarth::QtGui::DataManager> dataManager = new osgEarth::QtGui::DataManager(mapNode.get()); DemoMainWindow appWin(dataManager.get(), mapNode.get(), s_annoGroup); // install an event handler for picking and selection AnnotationEventCallback* cb = new AnnotationEventCallback(); cb->addHandler(new MyAnnoEventHandler(dataManager.get())); s_annoGroup->addEventCallback(cb); osgEarth::QtGui::ViewVector views; osg::ref_ptr<osgViewer::ViewerBase> viewer; osgEarth::QtGui::ViewerWidget* viewerWidget = 0L; if ( testUseExistingViewer ) { // tests: create a pre-existing viewer and install that in the widget. osgViewer::Viewer* v = new osgViewer::Viewer(); v->setSceneData(root); v->setThreadingModel(osgViewer::Viewer::DrawThreadPerContext); v->setCameraManipulator(new osgEarth::Util::EarthManipulator()); viewerWidget = new osgEarth::QtGui::ViewerWidget(v); } else { // tests: implicity creating a viewer. viewerWidget = new osgEarth::QtGui::ViewerWidget( root ); } //osgEarth::QtGui::ViewerWidget* viewerWidget = new osgEarth::QtGui::ViewerWidget(root); //viewerWidget->setGeometry(50, 50, 1024, 768); viewerWidget->getViews( views ); for(osgEarth::QtGui::ViewVector::iterator i = views.begin(); i != views.end(); ++i ) { i->get()->getCamera()->addCullCallback(new osgEarth::Util::AutoClipPlaneCullCallback(mapNode)); } appWin.setViewerWidget(viewerWidget); if (mapNode.valid()) { const Config& externals = mapNode->externalConfig(); if (mapNode->getMap()->isGeocentric()) { // Sky model. Config skyConf = externals.child("sky"); double hours = skyConf.value("hours", 12.0); s_sky = osgEarth::Util::SkyNode::create(mapNode); s_sky->setDateTime( DateTime(2011, 3, 6, hours) ); for(osgEarth::QtGui::ViewVector::iterator i = views.begin(); i != views.end(); ++i ) s_sky->attach( *i, 0 ); root->addChild(s_sky); // Ocean surface. if (externals.hasChild("ocean")) { s_ocean = osgEarth::Util::OceanNode::create( osgEarth::Util::OceanOptions(externals.child("ocean")), mapNode.get()); if (s_ocean) root->addChild(s_ocean); } } } viewer = viewerWidget->getViewer(); // activate "on demand" rendering if requested: if ( on_demand ) { viewer->setRunFrameScheme( osgViewer::ViewerBase::ON_DEMAND ); OE_NOTICE << "On-demand rendering activated" << std::endl; } TrackSimVector trackSims; if ( trackData ) { // create demo tracks osg::ref_ptr<osg::Image> srcImage = osgDB::readImageFile(TRACK_ICON_URL); osg::ref_ptr<osg::Image> image; ImageUtils::resizeImage(srcImage.get(), TRACK_ICON_SIZE, TRACK_ICON_SIZE, image); TrackNodeFieldSchema schema; createTrackSchema(schema); dataManager->addAnnotation(createTrack(schema, image, "Plane 1", mapNode.get(), osg::Vec3d(-121.463, 46.3548, 1500.71), 10000, 24, trackSims), s_annoGroup); dataManager->addAnnotation(createTrack(schema, image, "Plane 2", mapNode.get(), osg::Vec3d(-121.656, 46.0935, 4133.06), 10000, 8, trackSims), s_annoGroup); dataManager->addAnnotation(createTrack(schema, image, "Plane 3", mapNode.get(), osg::Vec3d(-121.321, 46.2589, 1390.09), 10000, 12, trackSims), s_annoGroup); viewer->addUpdateOperation(new TrackSimUpdate(trackSims)); } if(viewer.valid()) viewer->setThreadingModel(osgViewer::ViewerBase::SingleThreaded); // create catalog widget and add as a docked widget to the main window QDockWidget *catalogDock = new QDockWidget(QWidget::tr("Layers")); catalogDock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea); osgEarth::QtGui::MapCatalogWidget* layerCatalog = new osgEarth::QtGui::MapCatalogWidget(dataManager.get(), osgEarth::QtGui::MapCatalogWidget::ALL_LAYERS); layerCatalog->setActiveViews(views); layerCatalog->setHideEmptyGroups(true); catalogDock->setWidget(layerCatalog); appWin.addDockWidget(Qt::LeftDockWidgetArea, catalogDock); // create and dock an annotation list widget QDockWidget *annoDock = new QDockWidget; annoDock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea); osgEarth::QtGui::AnnotationListWidget* annoList = new osgEarth::QtGui::AnnotationListWidget(dataManager.get()); annoList->setActiveViews(views); annoDock->setWidget(annoList); appWin.addDockWidget(Qt::LeftDockWidgetArea, annoDock); // create a second catalog widget for viewpoints QDockWidget *vpDock = new QDockWidget; vpDock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea); osgEarth::QtGui::MapCatalogWidget* vpCatalog = new osgEarth::QtGui::MapCatalogWidget(dataManager.get(), osgEarth::QtGui::MapCatalogWidget::VIEWPOINTS); vpCatalog->setActiveViews(views); vpDock->setWidget(vpCatalog); appWin.addDockWidget(Qt::LeftDockWidgetArea, vpDock); // create layer manager widget and add as a docked widget on the right QDockWidget *layersDock = new QDockWidget(QWidget::tr("Image Layers")); layersDock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea); osgEarth::QtGui::LayerManagerWidget* layerManager = new osgEarth::QtGui::LayerManagerWidget(dataManager.get(), osgEarth::QtGui::LayerManagerWidget::IMAGE_LAYERS); layerManager->setActiveViews(views); layersDock->setWidget(layerManager); appWin.addDockWidget(Qt::RightDockWidgetArea, layersDock); // create and dock a LOSControlWidget QDockWidget *losDock = new QDockWidget; losDock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea); osgEarth::QtGui::LOSControlWidget* losControl = new osgEarth::QtGui::LOSControlWidget(root, mapNode.get(), dataManager.get()); losControl->setActiveViews(views); losDock->setWidget(losControl); appWin.addDockWidget(Qt::RightDockWidgetArea, losDock); // create terrain profile widget osgEarth::QtGui::TerrainProfileWidget* terrainProfiler = new osgEarth::QtGui::TerrainProfileWidget(root, mapNode.get()); terrainProfiler->setActiveViews(views); appWin.setTerrainProfileWidget(terrainProfiler); // attempt to load .qss stylesheet if one was provided if (styled) { QFile file(QString(stylesheet.c_str())); if (file.exists()) { file.open(QFile::ReadOnly); QString qstylesheet = QLatin1String(file.readAll()); app.setStyleSheet(qstylesheet); layerManager->setStyleSheet(qstylesheet); annoList->setStyleSheet(qstylesheet); losControl->setStyleSheet(qstylesheet); } } appWin.setGeometry(100, 100, 1280, 800); appWin.show(); return app.exec(); }
GaussianBeamWindow::GaussianBeamWindow(const QString& fileName) : QMainWindow() , OpticsBenchNotify(m_globalBench) { m_currentFile = QString(); setupUi(this); initSaveVariables(); // Table m_tableConfigWidget = new TablePropertySelector(this); m_tableConfigWidget->setWindowFlags(Qt::Window); m_tableCornerWidget = new CornerWidget(Qt::transparent, ":/images/preferences-system.png", m_tableConfigWidget, this); m_model = new GaussianBeamModel(m_bench, m_tableConfigWidget, this); m_table = new QTableView(this); m_table->setModel(m_model); m_table->setSelectionBehavior(QAbstractItemView::SelectRows); m_table->setSelectionMode(QAbstractItemView::ExtendedSelection); //m_table->setShowGrid(false); m_table->verticalHeader()->hide(); m_table->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn); m_table->setAlternatingRowColors(true); m_selectionModel = new QItemSelectionModel(m_model); m_table->setSelectionModel(m_selectionModel); m_table->resizeColumnsToContents(); GaussianBeamDelegate* delegate = new GaussianBeamDelegate(this, m_model, m_bench); m_table->setItemDelegate(delegate); m_table->setCornerWidget(m_tableCornerWidget); connect(m_model, SIGNAL(modelReset()), m_table, SLOT(resizeColumnsToContents())); for (int i = 0; i < 2; i++) m_bench.addOptics(LensType, m_bench.nOptics()); // View m_opticsScene = new OpticsScene(m_bench, this); m_opticsView = new OpticsView(m_opticsScene); m_opticsView->setHorizontalRange(0.60); m_opticsView->setVerticalRange(0.002); // Widget m_widget = new GaussianBeamWidget(m_bench, m_opticsScene, this); // Wavelength widget QWidget* wavelengthWidget = new QWidget(this); QVBoxLayout* wavelengthLayout = new QVBoxLayout(wavelengthWidget); QLabel* wavelengthLabel = new QLabel(tr("Wavelength"), wavelengthWidget); wavelengthSpinBox = new QDoubleSpinBox(wavelengthWidget); wavelengthSpinBox->setDecimals(0); wavelengthSpinBox->setSuffix(" nm"); wavelengthSpinBox->setRange(1., 9999.); wavelengthSpinBox->setValue(532.); wavelengthSpinBox->setSingleStep(10.); wavelengthLayout->addWidget(wavelengthSpinBox); wavelengthLayout->addWidget(wavelengthLabel); wavelengthWidget->setLayout(wavelengthLayout); connect(wavelengthSpinBox, SIGNAL(valueChanged(double)), this, SLOT(on_WavelengthSpinBox_valueChanged(double))); // Bars m_fileToolBar = addToolBar(tr("File")); m_fileToolBar->setToolButtonStyle(Qt::ToolButtonTextUnderIcon); m_fileToolBar->addAction(action_Open); m_fileToolBar->addAction(action_Save); m_fileToolBar->addAction(action_SaveAs); m_fileToolBar->addSeparator(); m_fileToolBar->addAction(action_AddOptics); m_fileToolBar->addAction(action_RemoveOptics); m_fileToolBar->addSeparator(); m_fileToolBar->addWidget(wavelengthWidget); StatusWidget* statusWidget = new StatusWidget(statusBar()); statusBar()->addWidget(statusWidget, 1); m_opticsView->setStatusWidget(statusWidget); // Layouts QSplitter *splitter = new QSplitter(Qt::Vertical, this); splitter->addWidget(m_table); splitter->addWidget(m_opticsView); QList<int> sizes; sizes << 10 << 10; splitter->setSizes(sizes); QDockWidget* dock = new QDockWidget(this); dock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea); dock->setFeatures(QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetFloatable); dock->setWidget(m_widget); addDockWidget(Qt::LeftDockWidgetArea, dock); setCentralWidget(splitter); // Connect signal and slots connect(m_model, SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)), this, SLOT(updateWidget(const QModelIndex&, const QModelIndex&))); m_bench.registerNotify(this); if (!fileName.isEmpty()) openFile(fileName); readSettings(); }
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()); }
void MainWindow::setupDockWidgets(void) { /* TODO: Do not create new dockWidgets if we already have them. */ /* TODO: Kill any old dockWidgets before creating new ones? */ for (int i = 0; i < getNumChannels(); ++i) { channelForms[i] = new ChannelForm(this); channelForms[i]->setChannelNumber(i); dockWidgets[i] = new QDockWidget(this); dockWidgets[i]->setAllowedAreas(Qt::BottomDockWidgetArea); QDockWidget::DockWidgetFeatures f; f = QDockWidget::DockWidgetClosable | QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetFloatable; if (configChannelTitleBarLayout == DOCK_VERTICAL) f |= QDockWidget::DockWidgetVerticalTitleBar; dockWidgets[i]->setFeatures(f); dockWidgets[i]->setWidget(channelForms[i]); addDockWidget(Qt::BottomDockWidgetArea, dockWidgets[i], Qt::Vertical); /* Update labels upon changes. */ QObject::connect(channelForms[i], SIGNAL(sampleStartChanged(QString)), ui->labelSampleStart, SLOT(setText(QString))); QObject::connect(channelForms[i], SIGNAL(sampleEndChanged(QString)), ui->labelSampleEnd, SLOT(setText(QString))); QObject::connect(channelForms[i], SIGNAL(scaleFactorChanged(QString)), ui->labelScaleFactor, SLOT(setText(QString))); /* Redraw channels upon changes. */ QObject::connect(channelForms[i], SIGNAL(sampleStartChanged(QString)), channelForms[i], SLOT(generatePainterPath())); QObject::connect(channelForms[i], SIGNAL(sampleEndChanged(QString)), channelForms[i], SLOT(generatePainterPath())); QObject::connect(channelForms[i], SIGNAL(scaleFactorChanged(QString)), channelForms[i], SLOT(generatePainterPath())); // dockWidgets[i]->show(); #if 0 /* If the user renames a channel, adapt the dock title. */ QObject::connect(lineEdits[i], SIGNAL(textChanged(QString)), dockWidgets[i], SLOT(setWindowTitle(QString))); #endif } /* For now, display only one scrollbar which scrolls all channels. */ QDockWidget* scrollWidget = new QDockWidget(this); scrollWidget->setAllowedAreas(Qt::BottomDockWidgetArea); horizontalScrollBar = new QScrollBar(this); horizontalScrollBar->setOrientation(Qt::Horizontal); QDockWidget::DockWidgetFeatures f; if (configChannelTitleBarLayout == DOCK_VERTICAL) f |= QDockWidget::DockWidgetVerticalTitleBar; scrollWidget->setFeatures(f); scrollWidget->setWidget(horizontalScrollBar); addDockWidget(Qt::BottomDockWidgetArea, scrollWidget, Qt::Vertical); for (int i = 0; i < getNumChannels(); ++i) { /* The scrollbar scrolls all channels. */ connect(horizontalScrollBar, SIGNAL(valueChanged(int)), channelForms[i], SLOT(setScrollBarValue(int))); } }
void ControlSingleton::showDialog(Gui::TaskView::TaskDialog *dlg) { // only one dialog at a time assert(!ActiveDialog || ActiveDialog==dlg); Gui::DockWnd::CombiView* pcCombiView = qobject_cast<Gui::DockWnd::CombiView*> (Gui::DockWindowManager::instance()->getDockWindow("Combo View")); // should return the pointer to combo view if (pcCombiView) { pcCombiView->showDialog(dlg); // make sure that the combo view is shown QDockWidget* dw = qobject_cast<QDockWidget*>(pcCombiView->parentWidget()); if (dw) { dw->setVisible(true); dw->toggleViewAction()->setVisible(true); } if (ActiveDialog == dlg) return; // dialog is already defined ActiveDialog = dlg; connect(dlg, SIGNAL(destroyed()), this, SLOT(closedDialog())); } // not all workbenches have the combo view enabled else if (!_taskPanel) { QDockWidget* dw = new QDockWidget(); dw->setWindowTitle(tr("Task panel")); dw->setFeatures(QDockWidget::DockWidgetMovable); _taskPanel = new Gui::TaskView::TaskView(dw); dw->setWidget(_taskPanel); _taskPanel->showDialog(dlg); getMainWindow()->addDockWidget(Qt::LeftDockWidgetArea, dw); connect(dlg, SIGNAL(destroyed()), dw, SLOT(deleteLater())); // if we have the normal tree view available then just tabify with it QWidget* treeView = Gui::DockWindowManager::instance()->getDockWindow("Tree view"); QDockWidget* par = treeView ? qobject_cast<QDockWidget*>(treeView->parent()) : 0; if (par && par->isVisible()) { getMainWindow()->tabifyDockWidget(par, dw); qApp->processEvents(); // make sure that the task panel is tabified now dw->show(); dw->raise(); } } }
KGraphEditor::KGraphEditor() : KXmlGuiWindow(), m_rfa(0), m_currentPart(0) { // set the shell's ui resource file setXMLFile("kgrapheditorui.rc"); m_widget = new KTabWidget(this); m_widget->setHoverCloseButton(true); connect(m_widget, SIGNAL(closeRequest(QWidget*)), this, SLOT(close(QWidget*))); connect(m_widget, SIGNAL(currentChanged(QWidget*)), this, SLOT(newTabSelectedSlot(QWidget*))); setCentralWidget(m_widget); QDockWidget* topLeftDockWidget = new QDockWidget(this); m_treeWidget = new KGraphEditorNodesTreeWidget(topLeftDockWidget); connect(m_treeWidget,SIGNAL(itemChanged(QTreeWidgetItem*,int)), this,SLOT(slotItemChanged(QTreeWidgetItem*,int))); connect(m_treeWidget,SIGNAL(itemClicked(QTreeWidgetItem*,int)), this,SLOT(slotItemClicked(QTreeWidgetItem*,int))); connect(m_treeWidget, SIGNAL(removeNode(QString)), this, SLOT(slotRemoveNode(QString))); connect(m_treeWidget, SIGNAL(addAttribute(QString)), this, SLOT(slotAddAttribute(QString))); connect(m_treeWidget, SIGNAL(removeAttribute(QString,QString)), this, SLOT(slotRemoveAttribute(QString,QString))); // m_treeWidget->setItemDelegate(new VariantDelegate(m_treeWidget)); m_treeWidget->setColumnCount(2); topLeftDockWidget->setWidget(m_treeWidget); addDockWidget ( Qt::LeftDockWidgetArea, topLeftDockWidget ); QDockWidget* bottomLeftDockWidget = new QDockWidget(this); m_newElementAttributesWidget = new KGraphEditorElementTreeWidget(bottomLeftDockWidget); connect(m_newElementAttributesWidget,SIGNAL(itemChanged(QTreeWidgetItem*,int)), this,SLOT(slotNewElementItemChanged(QTreeWidgetItem*,int))); connect(m_newElementAttributesWidget, SIGNAL(addAttribute(QString)), this, SLOT(slotAddNewElementAttribute(QString))); connect(m_newElementAttributesWidget, SIGNAL(removeAttribute(QString)), this, SLOT(slotRemoveNewElementAttribute(QString))); m_newElementAttributesWidget->setColumnCount(2); bottomLeftDockWidget->setWidget(m_newElementAttributesWidget); addDockWidget ( Qt::LeftDockWidgetArea, bottomLeftDockWidget ); if (QDBusConnection::sessionBus().registerService( "org.kde.kgrapheditor" )) { kDebug() << "Service Registered successfully"; QDBusConnection::sessionBus().registerObject("/", this, QDBusConnection::ExportAllSlots); } else { kDebug() << "Failed to register service..."; } // then, setup our actions setupActions(); // and a status bar statusBar()->show(); createStandardStatusBarAction(); // this routine will find and load our Part. it finds the Part by // name which is a bad idea usually.. but it's alright in this // case since our Part is made for this Shell // Creates the GUI with a null part to make appear the main app menus and tools createGUI(0); setupGUI(); // apply the saved mainwindow settings, if any, and ask the mainwindow // to automatically save settings if changed: window size, toolbar // position, icon size, etc. setAutoSaveSettings(); }
QSize KoDockWidgetTitleBar::sizeHint() const { if (isHidden()) { return QSize(0, 0); } QDockWidget *q = qobject_cast<QDockWidget*>(parentWidget()); int mw = q->style()->pixelMetric(QStyle::PM_DockWidgetTitleMargin, 0, q); int fw = q->style()->pixelMetric(QStyle::PM_DockWidgetFrameWidth, 0, q); // get size of buttons... QSize closeSize(0, 0); if (d->closeButton && hasFeature(q, QDockWidget::DockWidgetClosable)) { closeSize = d->closeButton->sizeHint(); } QSize floatSize(0, 0); if (d->floatButton && hasFeature(q, QDockWidget::DockWidgetFloatable)) { floatSize = d->floatButton->sizeHint(); } QSize hideSize(0, 0); if (d->collapseButton && d->collapsable) { hideSize = d->collapseButton->sizeHint(); } QSize lockSize(0, 0); if (d->lockButton && d->lockable) { lockSize = d->lockButton->sizeHint(); } int buttonHeight = qMax(qMax(qMax(closeSize.height(), floatSize.height()), hideSize.height()), lockSize.height()) + 2; int buttonWidth = closeSize.width() + floatSize.width() + hideSize.width() + lockSize.width(); int height = buttonHeight; if (d->textVisibilityMode == FullTextAlwaysVisible) { // get font size QFontMetrics titleFontMetrics = q->fontMetrics(); int fontHeight = titleFontMetrics.lineSpacing() + 2 * mw; height = qMax(height, fontHeight); } /* * Calculate the width of title and add to the total width of the docker window when collapsed. */ const int titleWidth = (d->textVisibilityMode == FullTextAlwaysVisible) ? (q->fontMetrics().width(q->windowTitle()) + 2*mw) : 0; if (d->preCollapsedWidth > 0) { return QSize(d->preCollapsedWidth, height); } else { if (d->textVisibilityMode == FullTextAlwaysVisible) { return QSize(buttonWidth /*+ height*/ + 2*mw + 2*fw + titleWidth, height); } else { if (q->widget()) { return QSize(qMin(q->widget()->sizeHint().width(), buttonWidth), height); } else { return QSize(buttonWidth, height); } } } }
QSize QDockWidgetLayout::sizeFromContent(const QSize &content, bool floating) const { QSize result = content; if (verticalTitleBar) { result.setHeight(qMax(result.height(), minimumTitleWidth())); result.setWidth(qMax(content.width(), 0)); } else { result.setHeight(qMax(result.height(), 0)); result.setWidth(qMax(content.width(), minimumTitleWidth())); } QDockWidget *w = qobject_cast<QDockWidget*>(parentWidget()); const bool nativeDeco = nativeWindowDeco(floating); int fw = floating && !nativeDeco ? w->style()->pixelMetric(QStyle::PM_DockWidgetFrameWidth, 0, w) : 0; const int th = titleHeight(); if (!nativeDeco) { if (verticalTitleBar) result += QSize(th + 2*fw, 2*fw); else result += QSize(2*fw, th + 2*fw); } result.setHeight(qMin(result.height(), (int) QWIDGETSIZE_MAX)); result.setWidth(qMin(result.width(), (int) QWIDGETSIZE_MAX)); if (content.width() < 0) result.setWidth(-1); if (content.height() < 0) result.setHeight(-1); int left, top, right, bottom; w->getContentsMargins(&left, &top, &right, &bottom); //we need to substract the contents margin (it will be added by the caller) QSize min = w->minimumSize() - QSize(left + right, top + bottom); QSize max = w->maximumSize() - QSize(left + right, top + bottom); /* A floating dockwidget will automatically get its minimumSize set to the layout's minimum size + deco. We're *not* interested in this, we only take minimumSize() into account if the user set it herself. Otherwise we end up expanding the result of a calculation for a non-floating dock widget to a floating dock widget's minimum size + window decorations. */ uint explicitMin = 0; uint explicitMax = 0; if (w->d_func()->extra != 0) { explicitMin = w->d_func()->extra->explicitMinSize; explicitMax = w->d_func()->extra->explicitMaxSize; } if (!(explicitMin & Qt::Horizontal) || min.width() == 0) min.setWidth(-1); if (!(explicitMin & Qt::Vertical) || min.height() == 0) min.setHeight(-1); if (!(explicitMax & Qt::Horizontal)) max.setWidth(QWIDGETSIZE_MAX); if (!(explicitMax & Qt::Vertical)) max.setHeight(QWIDGETSIZE_MAX); return result.boundedTo(max).expandedTo(min); }
void KoDockWidgetTitleBar::setCollapsed(bool collapsed) { QDockWidget *q = qobject_cast<QDockWidget*>(parentWidget()); if (q && q->widget() && q->widget()->isHidden() != collapsed) d->toggleCollapsed(); }
HelpWindow::HelpWindow(QWidget *parent) : QMainWindow(parent), mActionGoMainPage(new QAction(tr("Home"), this)), mActionBackward(new QAction(tr("Backward"), this)), mActionForward(new QAction(tr("Forward"), this)), mHelpEngine(new QHelpEngine(settingsObj.getPath(MSUSettings::PATH_SHARE_HELP) + "msuproj-qt.qhc", this)), mPageWidget(new HelpBrowser(mHelpEngine, this)) { QByteArray geom(settingsObj.getGeometry(MSUSettings::HELPWINDOW)); if (geom.size() > 0) { this->restoreGeometry(geom); this->restoreState(settingsObj.getState(MSUSettings::HELPWINDOW)); } else this->resize(900, 600); this->setContentsMargins(5, 0, 5, 5); this->setCentralWidget(mPageWidget); bool errorLoadingHelp = true; if (mHelpEngine->setupData()) { locale = settingsObj.getLocale(); if (!mHelpEngine->filterAttributes().contains(locale) || !QFile(mHelpEngine->documentationFileName("amigos.msuproj-qt." + locale)).exists()) locale = "en"; if(QFile(mHelpEngine->documentationFileName("amigos.msuproj-qt." + locale)).exists()) { errorLoadingHelp = false; mHelpEngine->setCurrentFilter(locale); QToolBar *navigationBar = new QToolBar(tr("Navigation"), this); navigationBar->setObjectName("HelpWindowNavBar"); navigationBar->addActions({mActionGoMainPage, mActionBackward, mActionForward}); this->addToolBar(navigationBar); QDockWidget *contentsDockWidget = new QDockWidget(tr("Contents"), this); contentsDockWidget->setObjectName("HelpWindowContentsDock"); contentsDockWidget->setFeatures(QDockWidget::NoDockWidgetFeatures); this->addDockWidget(Qt::LeftDockWidgetArea, contentsDockWidget); QHelpContentWidget *contentWidget = mHelpEngine->contentWidget(); contentsDockWidget->setWidget(contentWidget); connect(contentWidget, &QHelpContentWidget::clicked, this, &HelpWindow::setPage); connect(this, &HelpWindow::contentChange, mPageWidget, &HelpBrowser::setSource); connect(mPageWidget, &HelpBrowser::backwardAvailable, mActionBackward, &QAction::setEnabled); connect(mActionBackward, &QAction::triggered, mPageWidget, &HelpBrowser::backward); connect(mPageWidget, &HelpBrowser::forwardAvailable, mActionForward, &QAction::setEnabled); connect(mActionForward, &QAction::triggered, mPageWidget, &HelpBrowser::forward); connect(mActionGoMainPage, &QAction::triggered, this, &HelpWindow::goMainPage); connect(mPageWidget, &HelpBrowser::anchorClicked, this, &HelpWindow::setCurrentContentIndex); connect(mActionBackward, &QAction::triggered, this, &HelpWindow::setCurrentContentIndex); connect(mActionForward, &QAction::triggered, this, &HelpWindow::setCurrentContentIndex); this->goMainPage(); } } if (errorLoadingHelp) mPageWidget->setHtml(QString("<html><head/><body><p align=\"center\"><span style=\" font-size:16pt; font-weight:600;\">%1</span></p>" "<p align=\"center\">%2</p></body></html>") .arg(tr("Error loading help files."), tr("Could not load help files. Have You installed the MSUProj-Qt Help package?"))); }