QWidget* ToolAction::createWidget( QWidget *parent )
{
QToolBar *toolBar = qobject_cast< QToolBar * >( parent );
if ( !toolBar )
return 0;
QToolButton *button = new QToolButton( toolBar );
button->setAutoRaise( true );
button->setFocusPolicy( Qt::NoFocus );
button->setIconSize( toolBar->iconSize() );
button->setToolButtonStyle( toolBar->toolButtonStyle() );
button->setPopupMode( QToolButton::DelayedPopup );
button->setMenu( new QMenu( button ) );
button->setCheckable( true );
connect(toolBar, &QToolBar::iconSizeChanged, button, &QToolButton::setIconSize);
connect(toolBar, &QToolBar::toolButtonStyleChanged, button, &QToolButton::setToolButtonStyle);
connect(button, &QToolButton::triggered, toolBar, &QToolBar::actionTriggered);
connect( button->menu(), &QMenu::triggered, this, &ToolAction::slotNewDefaultAction );
m_buttons.append( button );
if ( !m_actions.isEmpty() )
{
button->setDefaultAction( m_actions.first() );
foreach ( QAction *action, m_actions )
{
button->menu()->addAction( action );
if ( action->isChecked() )
button->setDefaultAction( action );
}
void TabDeckEditor::createFiltersDock()
{
filterModel = new FilterTreeModel();
filterModel->setObjectName("filterModel");
databaseDisplayModel->setFilterTree(filterModel->filterTree());
databaseDisplayModel->setObjectName("databaseDisplayModel");
filterView = new QTreeView;
filterView->setObjectName("filterView");
filterView->setModel(filterModel);
filterView->setUniformRowHeights(true);
filterView->setHeaderHidden(true);
filterView->setContextMenuPolicy(Qt::CustomContextMenu);
connect(filterModel, SIGNAL(layoutChanged()), filterView, SLOT(expandAll()));
connect(filterView, SIGNAL(customContextMenuRequested(const QPoint &)),this, SLOT(filterViewCustomContextMenu(const QPoint &)));
FilterBuilder *filterBuilder = new FilterBuilder;
filterBuilder->setObjectName("filterBuilder");
connect(filterBuilder, SIGNAL(add(const CardFilter *)), filterModel, SLOT(addFilter(const CardFilter *)));
QToolButton *filterDelOne = new QToolButton();
filterDelOne->setObjectName("filterDelOne");
filterDelOne->setDefaultAction(aClearFilterOne);
filterDelOne->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
QToolButton *filterDelAll = new QToolButton();
filterDelAll->setObjectName("filterDelAll");
filterDelAll->setDefaultAction(aClearFilterAll);
filterDelAll->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
QGridLayout *filterLayout = new QGridLayout;
filterLayout->setObjectName("filterLayout");
filterLayout->setContentsMargins(0,0,0,0);
filterLayout->addWidget(filterBuilder, 0, 0, 1, 3);
filterLayout->addWidget(filterView, 1, 0, 1, 3);
filterLayout->addWidget(filterDelOne, 2, 0, 1, 1);
filterLayout->addWidget(filterDelAll, 2, 2, 1, 1);
filterBox = new QWidget();
filterBox->setObjectName("filterBox");
filterBox->setLayout(filterLayout);
QVBoxLayout *filterFrame = new QVBoxLayout;
filterFrame->setObjectName("filterFrame");
filterFrame->addWidget(filterBox);
filterDock = new QDockWidget(MainWindow);
filterDock->setObjectName("filterDock");
filterDock->setFeatures(QDockWidget::DockWidgetClosable|QDockWidget::DockWidgetFloatable|QDockWidget::DockWidgetMovable);
QWidget *filterDockContents = new QWidget(MainWindow);
filterDockContents->setObjectName("filterDockContents");
filterDockContents->setLayout(filterFrame);
filterDock->setWidget(filterDockContents);
connect(btnFilter,SIGNAL(toggled(bool)),filterDock,SLOT(setVisible(bool)));
filterDock->installEventFilter(this);
}
QWidget* QgsAttributeTableView::createActionWidget( QgsFeatureId fid )
{
QgsAttributeTableConfig attributeTableConfig = mFilterModel->layer()->attributeTableConfig();
QgsActionManager* actions = mFilterModel->layer()->actions();
QToolButton* toolButton = nullptr;
QWidget* container = nullptr;
if ( attributeTableConfig.actionWidgetStyle() == QgsAttributeTableConfig::DropDown )
{
toolButton = new QToolButton( this );
toolButton->setPopupMode( QToolButton::MenuButtonPopup );
container = toolButton;
}
else
{
container = new QWidget( this );
container->setLayout( new QHBoxLayout() );
container->layout()->setMargin( 0 );
}
for ( int i = 0; i < actions->size(); ++i )
{
const QgsAction& action = actions->at( i );
if ( !action.showInAttributeTable() )
continue;
QAction* act = new QAction( action.icon(), action.shortTitle().isEmpty() ? action.name() : action.shortTitle(), toolButton );
act->setToolTip( action.name() );
act->setData( i );
act->setProperty( "fid", fid );
connect( act, SIGNAL( triggered( bool ) ), this, SLOT( actionTriggered() ) );
if ( attributeTableConfig.actionWidgetStyle() == QgsAttributeTableConfig::DropDown )
{
toolButton->addAction( act );
if ( actions->defaultAction() == i )
toolButton->setDefaultAction( act );
container = toolButton;
}
else
{
QToolButton* btn = new QToolButton;
btn->setDefaultAction( act );
container->layout()->addWidget( btn );
}
}
if ( toolButton && !toolButton->actions().isEmpty() && actions->defaultAction() == -1 )
toolButton->setDefaultAction( toolButton->actions().first() );
return container;
}
NavFichiers::NavFichiers(QWidget *parent) : QMainWindow(parent)
{
QSettings settings(Multiuso::appDirPath() + "/ini/nav_fichiers.ini", QSettings::IniFormat);
if (settings.value("view_type").toString().isEmpty())
settings.setValue("view_type", "Tableau");
selectView = new QComboBox;
selectView->addItems(QStringList() << "Tableau" << "Liste");
selectView->setCurrentIndex(selectView->findText(settings.value("view_type").toString()));
connect(selectView, SIGNAL(currentIndexChanged(QString)), this, SLOT(viewChanged(QString)));
status = statusBar();
status->addPermanentWidget(new QLabel("Vue : "));
status->addPermanentWidget(selectView);
creerActions();
QToolButton *buttonNewTab = new QToolButton;
buttonNewTab->setDefaultAction(actionNouvelOnglet);
buttonNewTab->setAutoRaise(true);
QToolButton *buttonCloseTab = new QToolButton;
buttonCloseTab->setDefaultAction(actionFermerOnglet);
buttonCloseTab->setAutoRaise(true);
onglets = new QTabWidget;
onglets->setMovable(true);
onglets->setDocumentMode(true);
onglets->setCornerWidget(buttonNewTab, Qt::BottomLeftCorner);
onglets->setCornerWidget(buttonCloseTab, Qt::BottomRightCorner);
connect(onglets, SIGNAL(tabCloseRequested(int)), this, SLOT(slotFermerOnglet(int)));
connect(onglets, SIGNAL(currentChanged(int)), this, SLOT(slotOngletChange(int)));
ajouterOnglet();
onglets->setTabsClosable(false);
setCentralWidget(onglets);
QSettings reglages(Multiuso::appDirPath() + "/ini/nav_fichiers.ini", QSettings::IniFormat);
restoreState(reglages.value("etat_fenetre").toByteArray());
QShortcut *shortcutSwitchTab = new QShortcut(QKeySequence("Ctrl+Tab"), this);
connect(shortcutSwitchTab, SIGNAL(activated()), this, SLOT(slotSwitchTab()));
p_fenPrincipale = parent;
p_navigateurWeb = NULL;
m_copyCutObject = new CopyCutObject;
}
EditTools::EditTools(QWidget* parent)
: QDockWidget(parent)
{
setObjectName("edit-tools");
setWindowTitle(tr("Edit Mode Tools"));
setAllowedAreas(Qt::DockWidgetAreas(Qt::TopDockWidgetArea | Qt::BottomDockWidgetArea));
QToolBar* tb = new QToolBar(tr("Edit Mode Tools"));
tb->setIconSize(QSize(preferences.iconWidth, preferences.iconHeight));
QToolButton* b = new QToolButton(this);
QAction* a = getAction("hraster");
a->setCheckable(true);
b->setDefaultAction(a);
b->setContextMenuPolicy(Qt::ActionsContextMenu);
b->addAction(getAction("config-raster"));
tb->addWidget(b);
b = new QToolButton(this);
a = getAction("vraster");
a->setCheckable(true);
b->setDefaultAction(a);
b->setContextMenuPolicy(Qt::ActionsContextMenu);
b->addAction(getAction("config-raster"));
tb->addWidget(b);
_editX = new QDoubleSpinBox(this);
_editX->setSuffix(tr("sp"));
_editX->setRange(-99999, 99999);
_editX->setSingleStep(.1);
_editY = new QDoubleSpinBox(this);
_editY->setSuffix(tr("sp"));
_editY->setRange(-99999, 99999);
_editY->setSingleStep(.1);
xLabel = new QLabel(tr("x:"), this);
yLabel = new QLabel(tr("y:"), this);
_localEdit = false;
tb->addWidget(xLabel);
tb->addWidget(_editX);
tb->addWidget(yLabel);
tb->addWidget(_editY);
connect(_editX, SIGNAL(valueChanged(double)), SLOT(editXChanged(double)));
connect(_editY, SIGNAL(valueChanged(double)), SLOT(editYChanged(double)));
setWidget(tb);
QWidget* w = new QWidget(this);
setTitleBarWidget(w);
titleBarWidget()->hide();
}
QWidget *KToolBarPopupAction::createWidget(QWidget *_parent)
{
QToolBar *parent = qobject_cast<QToolBar *>(_parent);
if (!parent) {
return QWidgetAction::createWidget(_parent);
}
QToolButton *button = new QToolButton(parent);
button->setAutoRaise(true);
button->setFocusPolicy(Qt::NoFocus);
button->setIconSize(parent->iconSize());
button->setToolButtonStyle(parent->toolButtonStyle());
button->setDefaultAction(this);
connect(parent, &QToolBar::iconSizeChanged,
button, &QAbstractButton::setIconSize);
connect(parent, &QToolBar::toolButtonStyleChanged,
button, &QToolButton::setToolButtonStyle);
connect(button, &QToolButton::triggered,
parent, &QToolBar::actionTriggered);
if (d->delayed)
if (d->stickyMenu) {
button->setPopupMode(QToolButton::MenuButtonPopup);
} else {
button->setPopupMode(QToolButton::DelayedPopup);
}
else {
button->setPopupMode(QToolButton::InstantPopup);
}
return button;
}
RotationEdit::RotationEdit( QWidget * parent ) : ValueEdit( parent ), mode( mAuto ), setting( false )
{
actMode = new QAction( this );
connect( actMode, &QAction::triggered, this, &RotationEdit::switchMode );
QToolButton * btMode = new QToolButton( this );
btMode->setDefaultAction( actMode );
QHBoxLayout * lay = new QHBoxLayout( this );
lay->setMargin( 0 );
lay->setSpacing( 0 );
lay->addWidget( btMode, 2 );
// Cast QDoubleSpinBox slot
auto dsbValueChanged = static_cast<void (QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged);
for ( int x = 0; x < 4; x++ ) {
lay->addWidget( l[x] = new CenterLabel, 1 );
lay->addWidget( v[x] = new QDoubleSpinBox, 5 );
connect( v[x], dsbValueChanged, this, &RotationEdit::sltChanged );
}
setFocusProxy( v[0] );
setupMode();
}
/**
* @brief 构造函数
* @param [I] 平台指针
* @param [I] 父指针
* @param [I] 窗口标志
*/
MainWindow::MainWindow(Workbench *wb, QWidget *parent, Qt::WFlags flags)
: QMainWindow(parent, flags)
, ui(new Ui::MainWindowClass)
, m_workbench(wb)
{
ui->setupUi(this);
m_messageWidget = MessageWidget::instance();
m_messageWidget->setParent(this, Qt::Tool);
QStatusBar *statusBar = this->statusBar();
{
QToolButton *button = new QToolButton(statusBar);
button->setIcon(QApplication::style()->standardIcon(QStyle::SP_FileDialogDetailedView));
button->setAutoRaise(true);
connect(button, SIGNAL(clicked()), workbench(), SLOT(showDebugger()));
statusBar->addPermanentWidget(button);
}
// 显示消息按钮
{
QToolButton *button = new QToolButton(statusBar);
button->addAction(m_messageWidget->toggleAction());
button->setDefaultAction(m_messageWidget->toggleAction());
button->setAutoRaise(true);
statusBar->addPermanentWidget(button);
}
}
ConfigDialog::ConfigDialog(QWidget *parent) : QDialog(parent)
{
setWindowTitle(tr("Configure %1").arg(KtikzApplication::applicationName()));
addPage(generalPage(), tr("&General"), "preferences-desktop-theme");
addPage(editorPage(), tr("&Editor"), "accessories-text-editor");
addPage(appearancePage(), tr("&Highlighting"), "preferences-desktop-color");
QDialogButtonBox *buttonBox = new QDialogButtonBox;
QAction *whatsThisAction = QWhatsThis::createAction(this);
whatsThisAction->setIcon(Icon("help-contextual"));
QToolButton *whatsThisButton = new QToolButton(this);
whatsThisButton->setDefaultAction(whatsThisAction);
whatsThisButton->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Ignored);
buttonBox->addButton(whatsThisButton, QDialogButtonBox::HelpRole);
buttonBox->addButton(QDialogButtonBox::Ok);
buttonBox->addButton(QDialogButtonBox::Cancel);
connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
QVBoxLayout *mainLayout = new QVBoxLayout;
mainLayout->addWidget(centerWidget());
mainLayout->addWidget(buttonBox);
setLayout(mainLayout);
}
void PresetWidget::populateButtonLayout()
{
//delete old stuff
if(mButtonLayout)
{
QLayoutItem *child;
while ((child = mButtonLayout->takeAt(0)) != 0)
{
// delete both the layoutitem AND the widget. Not auto done because layoutitem is no QObject.
QWidget* widget = child->widget();
delete child;
delete widget;
}
delete mButtonLayout;
}
//make the new buttons
mButtonLayout = new QHBoxLayout;
mLayout->addLayout(mButtonLayout);
QList<QAction*> actions = mActionGroup->actions();
for (int i=0; i<actions.size(); ++i)
{
QToolButton* button = new QToolButton(this);
button->setDefaultAction(actions[i]);
button->show();
mButtonLayout->addWidget(button);
}
mButtonLayout->addStretch();
}
/*!
\fn OptToolBar::addActionWithoutButtonGroup(QAction* action)
*/
QToolButton* OptToolBar::addActionWithoutButtonGroup(QAction* action)
{
if(!action)
{
return NULL;
}
int id = mRow*mColSize + mCol;
//create new button
QToolButton *button = new QToolButton;
button->setToolTip( action->statusTip() );
button->setDefaultAction(action);
//set the button icon using action's icon
QIcon icon = action->icon();
if( !icon.isNull() )
{
button->setIcon(icon);
//button->setIconSize( QSize(50, 50) );
}
mButtons[ id ]= make_pair(button, action);
mLayout->addWidget(button, mRow, mCol);
//update row and col
if( mCol+1>=mColSize )
{
++mRow;
}
mCol = (mCol+1) % mColSize;
return button;
}
void QCastViewGL::onCameraChangeAction()
{
QAction *pAct = qobject_cast< QAction* >(QObject::sender());
if (!pAct) return;
QVariant v = pAct->data();
void* pc = v.value<void*>();
cogx::display::CDisplayCamera* pCamera = static_cast<cogx::display::CDisplayCamera*>(pc);
//std::cout << pAct << " " << pAct->text().toStdString() << " " << pc << " " << pCamera << std::endl;
if (pCamera) {
// TODO: should check if it is valid -- is it in getCameras()?
selectCamera(pCamera);
}
// Replace the action for the button.
// Parent hierarchy: action -> menu -> button
QMenu *pMenu = qobject_cast< QMenu* >(pAct->parent());
if (pMenu) {
QToolButton* pBut = qobject_cast< QToolButton* >(pMenu->parent());
if (pBut) {
QAction *pOldAct = pBut->defaultAction();
if (pOldAct && pOldAct->parent() == pAct->parent()) {
//std::cout << "Changing default action" << std::endl;
pBut->setDefaultAction(pAct);
}
}
}
}
QToolButton* PackagesDelegate::GetUpdate (const QModelIndex& index) const
{
int row = index.row ();
if (!Row2Update_.contains (row))
{
QAction *action = new QAction (Core::Instance ()
.GetProxy ()->GetIcon ("update"),
tr ("Update"),
Viewport_);
action->setCheckable (true);
action->setProperty ("Role", "Update");
connect (action,
SIGNAL (triggered ()),
this,
SLOT (handleAction ()));
QToolButton *toolButton = new QToolButton ();
toolButton->resize (CActionsSize, CActionsSize);
toolButton->setDefaultAction (action);
Row2Update_ [row] = toolButton;
}
QToolButton *button = Row2Update_ [row];
QAction *action = button->defaultAction ();
bool upgradable = index.data (PackagesModel::PMRUpgradable).toBool ();
action->setEnabled (upgradable);
action->setData (index.data (PackagesModel::PMRPackageID));
WasUpgradable_ [index] = upgradable;
return button;
}
DetailedLabeledComboBoxWidget::DetailedLabeledComboBoxWidget(QWidget* parent, StringPropertyBasePtr adapter, QGridLayout* gridLayout, int row) :
LabeledComboBoxWidget(parent, adapter, gridLayout, row)
{
//Add detailed button
QAction* detailsAction = this->createAction(this,
QIcon(":/icons/open_icon_library/system-run-5.png"),
"Details", "Toggle Details",
SLOT(toggleDetailsSlot()),
NULL);
QToolButton* detailsButton = new QToolButton();
detailsButton->setObjectName("DetailedButton");
detailsButton->setDefaultAction(detailsAction);
if (gridLayout) // add to input gridlayout
{
gridLayout->addWidget(detailsButton, row, 2);
}
else // add directly to this
{
mTopLayout->addWidget(detailsButton, 2);
}
this->setModified();
}
void QgsGuiVectorLayerTools::commitError( QgsVectorLayer* vlayer ) const
{
QgsMessageViewer *mv = new QgsMessageViewer();
mv->setWindowTitle( tr( "Commit errors" ) );
mv->setMessageAsPlainText( tr( "Could not commit changes to layer %1" ).arg( vlayer->name() )
+ "\n\n"
+ tr( "Errors: %1\n" ).arg( vlayer->commitErrors().join( "\n " ) )
);
QToolButton *showMore = new QToolButton();
// store pointer to vlayer in data of QAction
QAction *act = new QAction( showMore );
act->setData( QVariant( QMetaType::QObjectStar, &vlayer ) );
act->setText( tr( "Show more" ) );
showMore->setStyleSheet( "background-color: rgba(255, 255, 255, 0); color: black; text-decoration: underline;" );
showMore->setCursor( Qt::PointingHandCursor );
showMore->setSizePolicy( QSizePolicy::Maximum, QSizePolicy::Preferred );
showMore->addAction( act );
showMore->setDefaultAction( act );
connect( showMore, SIGNAL( triggered( QAction* ) ), mv, SLOT( exec() ) );
connect( showMore, SIGNAL( triggered( QAction* ) ), showMore, SLOT( deleteLater() ) );
// no timeout set, since notice needs attention and is only shown first time layer is labeled
QgsMessageBarItem *errorMsg = new QgsMessageBarItem(
tr( "Commit errors" ),
tr( "Could not commit changes to layer %1" ).arg( vlayer->name() ),
showMore,
QgsMessageBar::WARNING,
0,
QgisApp::instance()->messageBar() );
QgisApp::instance()->messageBar()->pushItem( errorMsg );
}
void MainWindow::createStatusBar()
{
QColor windowColor = palette().window().color();
QColor buttonBgColor = windowColor.lighter(105);
QColor buttonBorderBgColor = windowColor.darker(120);
QColor buttonPressedColor = windowColor.darker(102);
QToolButton *log = new QToolButton(this);
log->setText("Logs");
log->setCheckable(true);
log->setDefaultAction(_logDock->toggleViewAction());
log->setStyleSheet(QString(
"QToolButton {"
" background-color: %1;"
" border-style: outset;"
" border-width: 1px;"
" border-radius: 3px;"
" border-color: %2;"
" padding: 1px 20px 1px 20px;"
"} \n"
""
"QToolButton:checked, QToolButton:pressed {"
" background-color: %3;"
" border-style: inset;"
"}")
.arg(buttonBgColor.name())
.arg(buttonBorderBgColor.name())
.arg(buttonPressedColor.name()));
statusBar()->insertWidget(0, log);
statusBar()->setStyleSheet("QStatusBar::item { border: 0px solid black };");
}
static QToolButton *toolButton(QAction *action)
{
QToolButton *button = new QToolButton;
button->setDefaultAction(action);
button->setPopupMode(QToolButton::DelayedPopup);
return button;
}
static inline QToolButton *createDropDownButton(QAction *defaultAction, QWidget *parent = 0)
{
QToolButton *rc = new QToolButton(parent);
rc->setDefaultAction(defaultAction);
rc->setPopupMode(QToolButton::InstantPopup);
return rc;
}
/*!
\internal
\brief Creates a tool button using given action.
This action will set as the default action instead of adding into its action list.
@return the pointer to a QToolButton instance by "new" operation
*/
QToolButton * Ui::MainWindow::createToolButton(QAction *action, QWidget *parent /* = 0 */)
{
QToolButton *button = new QToolButton(parent);
button->setDefaultAction(action);
button->setAutoRaise(true);
button->setFocusPolicy(Qt::NoFocus);
return button;
}
QToolButton *Command::toolButtonWithAppendedShortcut(QAction *action, Command *cmd)
{
QToolButton *button = new QToolButton;
button->setDefaultAction(action);
if (cmd)
cmd->augmentActionWithShortcutToolTip(action);
return button;
}
// static
QToolButton *
MainWindow::toolButton( QAction * action )
{
QToolButton * button = new QToolButton;
if ( button )
button->setDefaultAction( action );
return button;
}
USAcqusitionWidget::USAcqusitionWidget(AcquisitionServicePtr acquisitionService, VisServicesPtr services, UsReconstructionServicePtr usReconstructionService, QWidget* parent) :
RecordBaseWidget(acquisitionService, parent, settings()->value("Ultrasound/acquisitionName").toString()),
mUsReconstructionService(usReconstructionService)
{
this->setObjectName("org_custusx_acquisition_widgets_acquisition");
this->setWindowTitle("US Acquisition");
this->setToolTip("Record and reconstruct US data");
mServices = services;
connect(mUsReconstructionService.get(), &UsReconstructionService::reconstructAboutToStart, this, &USAcqusitionWidget::reconstructAboutToStartSlot);
connect(mUsReconstructionService.get(), &UsReconstructionService::reconstructStarted, this, &USAcqusitionWidget::reconstructStartedSlot);
connect(mUsReconstructionService.get(), &UsReconstructionService::reconstructFinished, this, &USAcqusitionWidget::reconstructFinishedSlot);
connect(mAcquisitionService.get(), &AcquisitionService::stateChanged, this, &USAcqusitionWidget::acquisitionStateChangedSlot);
connect(mAcquisitionService.get(), &AcquisitionService::started, this, &USAcqusitionWidget::recordStarted);
connect(mAcquisitionService.get(), &AcquisitionService::acquisitionStopped, this, &USAcqusitionWidget::recordStopped, Qt::DirectConnection);
connect(mAcquisitionService.get(), &AcquisitionService::cancelled, this, &USAcqusitionWidget::recordCancelled);
connect(mAcquisitionService.get(), &AcquisitionService::acquisitionDataReady, this, &USAcqusitionWidget::acquisitionDataReadySlot);
connect(mAcquisitionService.get(), &AcquisitionService::saveDataCompleted, mUsReconstructionService.get(), &UsReconstructionService::newDataOnDisk);
mRecordSessionWidget->setDescriptionVisibility(false);
QHBoxLayout* timerLayout = new QHBoxLayout;
mLayout->addLayout(timerLayout);
mDisplayTimerWidget = new DisplayTimerWidget(this);
mDisplayTimerWidget ->setFontSize(10);
timerLayout->addStretch();
timerLayout->addWidget(mDisplayTimerWidget);
timerLayout->addStretch();
QGridLayout* editsLayout = new QGridLayout;
editsLayout->setColumnStretch(0,0);
editsLayout->setColumnStretch(1,1);
RecordBaseWidget::mLayout->addLayout(editsLayout);
new LabeledComboBoxWidget(this, StringPropertyActiveProbeConfiguration::New(mServices->getToolManager()), editsLayout, 0);
sscCreateDataWidget(this, mUsReconstructionService->getParam("Preset"), editsLayout, 1);
QAction* optionsAction = this->createAction(this,
QIcon(":/icons/open_icon_library/system-run-5.png"),
"Details", "Show Details",
SLOT(toggleDetailsSlot()),
NULL);
QToolButton* optionsButton = new QToolButton();
optionsButton->setDefaultAction(optionsAction);
editsLayout->addWidget(optionsButton, 0, 2);
mOptionsWidget = this->createOptionsWidget();
mOptionsWidget->setVisible(settings()->value("acquisition/UsAcqShowDetails").toBool());
mTimedAlgorithmProgressBar = new cx::TimedAlgorithmProgressBar;
mLayout->addWidget(mOptionsWidget);
mLayout->addStretch();
mLayout->addWidget(mTimedAlgorithmProgressBar);
}
QToolButton *ToolBarChanger::insertAction(Action *AAction, int AGroup)
{
QToolButton *button = new QToolButton(FToolBar);
button->setToolButtonStyle(FToolBar->toolButtonStyle());
button->setDefaultAction(AAction);
FButtons.insert(AAction, button);
insertWidget(button, AGroup);
return button;
}
QToolButton* ToolBar::createToolButton(QAction *act)
{
QToolButton *toolButton = new QToolButton();
toolButton->setMinimumSize(QSize(30, 30));
toolButton->setMaximumSize(QSize(30, 30));
toolButton->setDefaultAction(act);
toolButton->setStatusTip(act->text());
return toolButton;
}
void MainWindow::initMenus()
{
menuBar()->clear();
FileOperationsMenu* fileOpMenu = new FileOperationsMenu();
m_menuManager.registerMenus(fileOpMenu);
fileOpMenu->setActive(this);
m_menuManager.addActivation(fileOpMenu);
m_menuables.append(fileOpMenu);
SourceFileMenu* sourceFileMenu = new SourceFileMenu(this);
m_menuManager.registerMenus(sourceFileMenu);
m_menuables.append(sourceFileMenu);
MainWindowMenu* mainWindowMenu = new MainWindowMenu(this);
m_menuManager.registerMenus(mainWindowMenu);
mainWindowMenu->setActive(this);
m_menuManager.addActivation(mainWindowMenu);
m_menuables.append(mainWindowMenu);
TargetMenu* targetMenu = new TargetMenu;
m_menuManager.registerMenus(targetMenu);
m_menuables.append(targetMenu);
ProjectMenu* projectMenu = new ProjectMenu();
m_menuManager.registerMenus(projectMenu);
m_menuables.append(projectMenu);
#ifdef BUILD_WEB_TAB
WebTabMenu* webTabMenu = new WebTabMenu;
m_menuManager.registerMenus(webTabMenu);
m_menuables.append(webTabMenu);
#endif
#ifdef BUILD_DEVELOPER_TOOLS
DeveloperMenu* developerMenu = new DeveloperMenu(this);
m_menuManager.registerMenus(developerMenu);
m_menuManager.addActivation(developerMenu);
m_menuables.append(developerMenu);
#endif
#ifdef BUILD_DOCUMENTATION_TAB
DocumentationMenu* documentationMenu = new DocumentationMenu(this);
m_menuManager.registerMenus(documentationMenu);
m_menuManager.addActivation(documentationMenu);
m_menuables.append(documentationMenu);
#endif
m_menuManager.construct(ui_menubar, ui_toolBar);
/* Sets up the QTabWidget that handles the editor windows */
QToolButton *cornerButton = new QToolButton(ui_tabWidget);
cornerButton->setDefaultAction(mainWindowMenu->closeNode()->rawAction);
cornerButton->setAutoRaise(true);
ui_tabWidget->setCornerWidget(cornerButton);
}
void QCastViewGL::getToolbars(CPtrVector<QToolBar>& toolbars)
{
if (! pView) return;
CPtrVector<cogx::display::CDisplayCamera> cameras;
pView->getCameras(cameras);
if (cameras.size() < 1) return;
// pBar->parent will be reset in QViewContainer
QToolBar *pBar = new QToolBar(QString::fromStdString(pView->m_id), this);
if (pBar) {
unsigned int nc = cameras.size();
if (nc > 3) nc = 3;
cogx::display::CDisplayCamera* pCamera;
for (unsigned int i= 0; i < nc; i++) {
QToolButton *pBut = new QToolButton(pBar);
pCamera = cameras[i];
QString text = QString::fromStdString(pCamera->name);
QAction* pAct = new QAction(QIcon(":/toolButton/camera-photo.png"), text, pBut);
pAct->setToolTip("Select Camera: " + text);
pAct->setData(qVariantFromValue((void*)pCamera));
pBut->setDefaultAction(pAct);
pBar->addWidget(pBut);
pBar->connect(pAct, SIGNAL(triggered()), this, SLOT(onCameraChangeAction()));
// With more than 3 cameras things become complicated...
if (i == 2 && cameras.size() > 2) {
QAction *pPopAct;
QMenu *pMenu = new QMenu(pBut); // parent MUST be button, see onCameraChangeAction
pBut->setMenu(pMenu);
pBut->setPopupMode(QToolButton::MenuButtonPopup);
for (unsigned int j = 0; j < cameras.size(); j++) {
if (i == j) {
pMenu->addAction(pAct);
pAct->setParent(pMenu); // parent MUST be menu, see onCameraChangeAction
}
else {
pCamera = cameras[j];
text = QString::fromStdString(pCamera->name);
pPopAct = pMenu->addAction(QIcon(":/toolButton/camera-photo.png"), text);
pPopAct->setData(qVariantFromValue((void*)pCamera));
pPopAct->setToolTip("Select Camera: " + text);
pBar->connect(pPopAct, SIGNAL(triggered()), this, SLOT(onCameraChangeAction()));
}
}
if (0) {
text = "TODO: Configure camera buttons...";
pPopAct = pMenu->addAction(QIcon(":/toolButton/camera-photo.png"), text);
pBar->connect(pPopAct, SIGNAL(triggered()), this, SLOT(onActConfigureCameras()));
}
}
}
toolbars.push_back(pBar);
}
}
// Most initialization is moved from constructor to allow signals triggered correctly
void ClipartCategoriesList::loadCategories()
{
TimeMeasure t("ClipartCategoriesList::loadCategories()");
// Fetch list of clipart subfolders
QString baseClipartFolder = AppTools::getClipartResourcesFolder();
QDir clipartFolder(baseClipartFolder);
if (!clipartFolder.exists()) // If clipart folder not exists (e.g. on development computers) we try to find clipart directly in "Clipart"
{
baseClipartFolder = CLIPART_DIR;
#ifdef Q_WS_MAC
baseClipartFolder = "../../" + baseClipartFolder;
#endif
clipartFolder = QDir(baseClipartFolder);
}
QStringList folders = clipartFolder.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
// Add a button with action for each subfolder
QHBoxLayout *layout = new QHBoxLayout;
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
for (int i = 0; i < folders.size(); i++)
{
QAction *action = new QAction(this);
action->setToolTip(folders[i]);
QString categoryFolder = AppTools::addPathSeparator(baseClipartFolder) + folders[i];
QString iconFile = categoryFolder + CLIPART_ICON_EXTENSION;
QIcon icon(iconFile);
action->setIcon(icon);
QToolButton *button = new QToolButton(this);
button->setDefaultAction(action);
button->setCheckable(true);
connect(button, SIGNAL(triggered(QAction *)), this, SLOT(on_toolbutton_triggered(QAction *)));
layout->addWidget(button);
buttons << button;
clipartCategories[action] = getClipartFolder(categoryFolder, action);
if (!startAction) startAction = action;
}
layout->addStretch();
this->setLayout(layout);
if (startAction)
sendClipartLoadRequest(startAction);
}
UBToolbarButtonGroup::UBToolbarButtonGroup(QToolBar *toolBar, const QList<QAction*> &actions)
: QWidget(toolBar)
, mActions(actions)
, mCurrentIndex(-1)
, mDisplayLabel(true)
, mActionGroup(0)
{
Q_ASSERT(actions.size() > 0);
mToolButton = qobject_cast<QToolButton*>(toolBar->layout()->itemAt(0)->widget());
Q_ASSERT(mToolButton);
QVBoxLayout *verticalLayout = new QVBoxLayout(this);
QHBoxLayout *horizontalLayout = new QHBoxLayout();
horizontalLayout->setSpacing(0);
verticalLayout->addStretch();
verticalLayout->addLayout(horizontalLayout);
verticalLayout->addStretch();
mActionGroup = new QActionGroup(this);
mActionGroup->setExclusive(true);
QSize buttonSize;
int i = 0;
foreach(QAction *action, actions)
{
mActionGroup->addAction(action);
QToolButton *button = new QToolButton(this);
mButtons.append(button);
button->setDefaultAction(action);
button->setCheckable(true);
if(i == 0)
{
button->setObjectName("ubButtonGroupLeft");
}
else if (i == actions.size() - 1)
{
button->setObjectName("ubButtonGroupRight");
}
else
{
button->setObjectName("ubButtonGroupCenter");
}
connect(button, SIGNAL(triggered(QAction*)), this, SLOT(selected(QAction*)));
horizontalLayout->addWidget(button);
mLabel = action->text();
buttonSize = button->sizeHint();
i++;
}
void LC_DockWidget::add_actions(QList<QAction*> list, int columns, int icon_size)
{
for(auto const& item: list)
{
QToolButton* toolbutton = new QToolButton(this);
toolbutton->setDefaultAction(item);
toolbutton->setIconSize(QSize(icon_size, icon_size));
int const count=grid->count();
grid->addWidget(toolbutton, count/columns, count%columns);
}
}
QToolButton* DiagramToolBox::createButton(QAction* action)
{
int size = 1.8 * QFontMetrics(font()).height();
QToolButton* newButton = new QToolButton();
newButton->setDefaultAction(action);
newButton->setToolTip(action->text());
newButton->setIconSize(QSize(size, size));
return newButton;
}