//-----------------------------------------------------------------------------
void swftParaViewMenuBuilders::buildToolbars(QMainWindow& mainWindow)
{
QToolBar* mainToolBar = new swftMainControlsToolbar(&mainWindow)
<< pqSetName("MainControlsToolbar");
mainToolBar->layout()->setSpacing(0);
mainWindow.addToolBar(Qt::TopToolBarArea, mainToolBar);
QToolBar* colorToolbar = new pqColorToolbar(&mainWindow)
<< pqSetName("variableToolbar");
colorToolbar->layout()->setSpacing(0);
mainWindow.addToolBar(Qt::TopToolBarArea, colorToolbar);
mainWindow.insertToolBarBreak(colorToolbar);
QToolBar* reprToolbar = new pqRepresentationToolbar(&mainWindow)
<< pqSetName("representationToolbar");
reprToolbar->layout()->setSpacing(0);
mainWindow.addToolBar(Qt::TopToolBarArea, reprToolbar);
QToolBar* vcrToolbar = new pqVCRToolbar(&mainWindow)
<< pqSetName("VCRToolbar");
vcrToolbar->layout()->setSpacing(0);
mainWindow.addToolBar(Qt::TopToolBarArea, vcrToolbar);
QToolBar* timeToolbar = new pqAnimationTimeToolbar(&mainWindow)
<< pqSetName("currentTimeToolbar");
timeToolbar->layout()->setSpacing(0);
mainWindow.addToolBar(Qt::TopToolBarArea, timeToolbar);
}
int main(int argc, char **argv)
{
BrowserApplication application(argc, argv);
QCoreApplication::setApplicationName(QLatin1String("urllineeditexample"));
QMainWindow w;
QWidget *window = new QWidget;
QComboBox *comboBox = new QComboBox(window);
comboBox->setEditable(true);
QLineEdit *lineEdit = new QLineEdit(window);
LocationBar *s1 = new LocationBar(window);
LocationBar *s2 = new LocationBar(window);
WebView *view = new WebView(window);
view->setUrl(QUrl("http://www.google.com"));
s2->setWebView(view);
QVBoxLayout *layout = new QVBoxLayout;
layout->addWidget(comboBox);
layout->addWidget(lineEdit);
layout->addWidget(s1);
layout->addWidget(s2);
layout->addWidget(view);
window->setLayout(layout);
w.show();
w.setCentralWidget(window);
QToolBar *bar = w.addToolBar("foo");
QSplitter *splitter = new QSplitter(window);
splitter->addWidget(new LocationBar);
splitter->addWidget(new QLineEdit);
bar->addWidget(splitter);
return application.exec();
}
int main(int argc, char **argv)
{
QApplication app(argc, argv);
QMainWindow mainWindow;
mainWindow.setCentralWidget(new StaticWidget());
mainWindow.setStatusBar(new QStatusBar());
QDockWidget *dockWidget = new QDockWidget();
dockWidget->setWidget(new StaticWidget());
mainWindow.addDockWidget(Qt::LeftDockWidgetArea, dockWidget);
QToolBar *toolBar = new QToolBar();
toolBar->addWidget(new StaticWidget())->setVisible(true);;
toolBar->addWidget(new QSpinBox())->setVisible(true);;
mainWindow.addToolBar(toolBar);
mainWindow.resize(600, 400);
mainWindow.show();
return app.exec();
}
/*
* Steps to reproduce issue:
* - start application
* - click "add horizontal"
* - click "add horizontal"
* - click "add vertical"
* - click "add horizontal"
* ... the layout will look like this:
* 11 22 44
* 33333 44
* - click "save state"
* - close application
*
* - start application
* - click "add vertical" 5 times
* ... the layout will look like this:
* 11
* 22
* 33
* 44
* 55
* - click "restore state"
* ... the layout will look like this:
* 11 22 44 55
* 33333 44 55
*
* BUT since 5 was not known before I would expect its orientation
* (vertical) to not change by the restoreState invocation
* ... the layout should look like this:
* 11 22 44
* 33333 44
* 55555555
*/
int main(int argc, char** argv)
{
QApplication* app = new QApplication(argc, argv);
QSettings* settings = new QSettings(QSettings::IniFormat, QSettings::UserScope, "qt_restore_state_orientation", "qt_restore_state_orientation");
QMainWindow* mw = new QMainWindow();
mw->resize(800, 600);
mw->setCentralWidget(new QLabel("foo"));
QToolBar* tb = new QToolBar();
tb->setObjectName("toolbar");
mw->addToolBar(tb);
QAction* aha = new AddHorizontalAction("add horizontal", tb);
tb->addAction(aha);
QAction* ava = new AddVerticalAction("add vertical", tb);
tb->addAction(ava);
QAction* ss = new SaveStateAction("save state", tb, settings);
tb->addAction(ss);
QAction* rs = new RestoreStateAction("restore state", tb, settings);
tb->addAction(rs);
mw->show();
app->exec();
}
void tst_QMenu::statusTip()
{
//check that the statustip of actions inserted into the menu are displayed
QMainWindow w;
connect(w.statusBar(), SIGNAL(messageChanged(QString)), SLOT(onStatusMessageChanged(QString)));; //creates the status bar
QToolBar tb;
QAction a("main action", &tb);
a.setStatusTip("main action");
QMenu m(&tb);
QAction subact("sub action", &m);
subact.setStatusTip("sub action");
m.addAction(&subact);
a.setMenu(&m);
tb.addAction(&a);
w.addToolBar(&tb);
w.show();
QVERIFY(QTest::qWaitForWindowExposed(&w));
QRect rect1 = tb.actionGeometry(&a);
QToolButton *btn = qobject_cast<QToolButton*>(tb.childAt(rect1.center()));
QVERIFY(btn != NULL);
//because showMenu calls QMenu::exec, we need to use a singleshot
//to continue the test
QTimer::singleShot(200,this, SLOT(onStatusTipTimer()));
btn->showMenu();
QVERIFY(statustip.isEmpty());
}
void tst_QToolBar::accel()
{
#ifdef Q_WS_MAC
extern void qt_set_sequence_auto_mnemonic(bool b);
qt_set_sequence_auto_mnemonic(true);
#endif
QMainWindow mw;
QToolBar *toolBar = mw.addToolBar("test");
QAction *action = toolBar->addAction("&test");
action->setIconText(action->text()); // we really want that mnemonic in the button!
QSignalSpy spy(action, SIGNAL(triggered(bool)));
mw.show();
QApplication::setActiveWindow(&mw);
QTest::qWait(100);
QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&mw));
QTest::keyClick(&mw, Qt::Key_T, Qt::AltModifier);
QTest::qWait(300);
QTRY_COMPARE(spy.count(), 1);
#ifdef Q_WS_MAC
qt_set_sequence_auto_mnemonic(false);
#endif
}
void tst_QToolBar::toggleViewAction()
{
{
QToolBar tb;
QAction *toggleViewAction = tb.toggleViewAction();
QVERIFY(tb.isHidden());
toggleViewAction->trigger();
QVERIFY(!tb.isHidden());
toggleViewAction->trigger();
QVERIFY(tb.isHidden());
}
{
QMainWindow mw;
QToolBar tb(&mw);
mw.addToolBar(&tb);
mw.show();
QAction *toggleViewAction = tb.toggleViewAction();
QVERIFY(!tb.isHidden());
toggleViewAction->trigger();
QVERIFY(tb.isHidden());
toggleViewAction->trigger();
QVERIFY(!tb.isHidden());
toggleViewAction->trigger();
QVERIFY(tb.isHidden());
}
}
QToolBar * QMainWindowProto::addToolBar ( const QString & title )
{
QMainWindow *item = qscriptvalue_cast<QMainWindow*>(thisObject());
if (item)
return item->addToolBar(title);
return 0;
}
int main(int argc, char *argv[])
{
// make an instance of the QApplication
QApplication a(argc, argv);
// Create a new MainWindow
QMainWindow w;
QToolBar *toolbar= new QToolBar();
QPushButton *back= new QPushButton("back");
QPushButton *fwd= new QPushButton("fwd");
toolbar->addWidget(back);
toolbar->addWidget(fwd);
w.addToolBar(toolbar);
w.addToolBar(toolbar);
QWebEngineView *page = new QWebEngineView();
page->load(QUrl("http://www.google.co.uk"));
QObject::connect(back,SIGNAL(clicked()),page,SLOT(back()));
QObject::connect(fwd,SIGNAL(clicked()),page,SLOT(forward()));
w.setCentralWidget(page);
w.resize(1024,720);
// show it
w.show();
// hand control over to Qt framework
return a.exec();
}
void MainWindow::createSpriteView(SpriteModel* model)
{
QMainWindow* window = new QMainWindow;
QToolBar* bar = new QToolBar( window );
bar->addAction( ui.actionSpritesNewFolder );
bar->addAction( ui.actionSpritesNewSprite );
bar->addAction( ui.actionSpritesMoveSprite );
bar->addAction( ui.actionSpritesRemoveItem );
bar->setMovable( false );
window->addToolBar( bar );
window->setParent( ui.dockWidgetComposition );
spriteView = new SpriteView( this );
spriteView->setModel(model);
spriteView->addAction( ui.actionSpritesNewFolder );
spriteView->addAction( ui.actionSpritesNewSprite );
spriteView->addAction( ui.actionSpritesMoveSprite );
spriteView->addAction( ui.actionSpritesRemoveItem );
spriteView->setContextMenuPolicy( Qt::ActionsContextMenu );
window->setCentralWidget( spriteView );
ui.dockWidgetSprites->setWidget( window );
connect( ui.actionSpritesNewFolder, SIGNAL( triggered() ), this, SLOT( actionSpritesNewFolder() ) );
connect( ui.actionSpritesNewSprite, SIGNAL( triggered() ), this, SLOT( actionSpritesNewSprite() ) );
connect( ui.actionSpritesMoveSprite, SIGNAL( triggered() ), this, SLOT( actionSpritesMoveSprite() ) );
connect( ui.actionSpritesRemoveItem, SIGNAL( triggered() ), this, SLOT( actionSpritesRemoveItem() ) );
}
int main(int argc, char** argv) {
QApplication app(argc, argv);
const QString name("CConf Demo");
app.setApplicationDisplayName(name);
// CConf::Context *ctxt = new CConf::Context();
// ctxt->addFile("example.json");
// ctxt->addFile("example2.json");
// TestModel model;
QStandardItemModel model;
QStandardItem item(QString("my item"));
QList<QStandardItem*> myList;
myList.append(&item);
model.appendRow(myList);
QTreeView* confView = new QTreeView();
confView->setModel(&model);
QMainWindow* win = new QMainWindow();
win->addToolBar(name);
win->setCentralWidget(confView);
win->show();
return app.exec();
}
void specDockWidget::setupWindow(specActionLibrary* actions)
{
// prepare main widget
QMainWindow* widget = new QMainWindow(this) ;
widget->setWindowFlags(Qt::Widget);
setWidget(widget) ;
// // get brushes
// QPalette pal = palette() ;
// QBrush activeWindow = pal.brush(QPalette::Active, QPalette::Window),
// inactiveWindow = pal.brush(QPalette::Inactive, QPalette::Window) ;
// if (activeWindow == inactiveWindow)
// inactiveWindow.setColor(inactiveWindow.color().darker()) ;
//
// pal.setBrush(QPalette::Inactive, QPalette::Window, inactiveWindow) ;
// setPalette(pal) ;
// add inner widgets
QList<QWidget*> innerWidgets = mainWidgets() ;
if(innerWidgets.size() == 1)
widget->setCentralWidget(innerWidgets.first()) ;
else
{
specSplitter* splitter = new specSplitter(Qt::Vertical, this) ;
foreach(QWidget * innerWidget, innerWidgets)
splitter->insertWidget(0, innerWidget);
widget->setCentralWidget(splitter);
}
// add toolbars
if(!actions)
return ;
QList<QWidget*> allWidgets ;
allWidgets << this << innerWidgets ;
foreach(QWidget * w, allWidgets)
{
specView* view = dynamic_cast<specView*>(w);
specPlot* plot = dynamic_cast<specPlot*>(w) ;
if(view && view->model())
{
view->setActionLibrary(actions) ;
actions->addDragDropPartner(view->model());
connect(view->selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)),
this, SLOT(selectionChanged(QItemSelection, QItemSelection))) ;
// connect(view->selectionModel(), SIGNAL(currentChanged(QModelIndex,QModelIndex)),
// this, SLOT(currentChanged(QModelIndex,QModelIndex))) ;
}
if(plot)
{
Plot = plot ;
actions->addPlot(plot) ;
}
QToolBar* toolbar = actions->toolBar(w) ;
if(toolbar->actions().isEmpty())
delete toolbar ;
else
widget->addToolBar(toolbar);
// w->setPalette(pal);
}
void tst_QToolBar::task197996_visibility()
{
QMainWindow mw;
QToolBar *toolBar = new QToolBar(&mw);
mw.addToolBar(toolBar);
toolBar->addAction(new QAction("Foo", &mw));
QAction *pAction = new QAction("Test", &mw);
toolBar->addAction(pAction);
pAction->setVisible(false);
toolBar->setVisible(false);
toolBar->setVisible(true);
pAction->setVisible(true);
mw.show();
QVERIFY(toolBar->widgetForAction(pAction)->isVisible());
toolBar->setVisible(false);
pAction->setVisible(false);
toolBar->setVisible(true);
pAction->setVisible(true);
QTest::qWait(100);
QVERIFY(toolBar->widgetForAction(pAction)->isVisible());
}
void tst_QToolBar::visibilityChanged()
{
QMainWindow mw;
QToolBar tb;
QSignalSpy spy(&tb, SIGNAL(visibilityChanged(bool)));
mw.addToolBar(&tb);
mw.show();
QCOMPARE(spy.count(), 1);
QCOMPARE(spy.at(0).at(0).toBool(), true);
spy.clear();
tb.hide();
QCOMPARE(spy.count(), 1);
QCOMPARE(spy.at(0).at(0).toBool(), false);
spy.clear();
tb.hide();
QCOMPARE(spy.count(), 0);
tb.show();
QCOMPARE(spy.count(), 1);
QCOMPARE(spy.at(0).at(0).toBool(), true);
spy.clear();
tb.show();
QCOMPARE(spy.count(), 0);
}
void QmitkWorkbenchWindowAdvisor::PostWindowCreate()
{
// very bad hack...
berry::IWorkbenchWindow::Pointer window = this->GetWindowConfigurer()->GetWindow();
QMainWindow* mainWindow = static_cast<QMainWindow*>(window->GetShell()->GetControl());
QMenuBar* menuBar = mainWindow->menuBar();
QMenu* fileMenu = menuBar->addMenu("&File");
fileMenu->addAction(new QmitkFileOpenAction(window));
fileMenu->addSeparator();
fileMenu->addAction(new QmitkFileExitAction(window));
berry::IViewRegistry* viewRegistry = berry::PlatformUI::GetWorkbench()->GetViewRegistry();
const std::vector<berry::IViewDescriptor::Pointer>& viewDescriptors = viewRegistry->GetViews();
QMenu* viewMenu = menuBar->addMenu("Show &View");
// sort elements (converting vector to map...)
std::vector<berry::IViewDescriptor::Pointer>::const_iterator iter;
std::map<std::string, berry::IViewDescriptor::Pointer> VDMap;
for (iter = viewDescriptors.begin(); iter != viewDescriptors.end(); ++iter)
{
if ((*iter)->GetId() == "org.blueberry.ui.internal.introview")
continue;
std::pair<std::string, berry::IViewDescriptor::Pointer> p((*iter)->GetLabel(), (*iter));
VDMap.insert(p);
}
QToolBar* qToolbar = new QToolBar;
std::map<std::string, berry::IViewDescriptor::Pointer>::const_iterator MapIter;
for (MapIter = VDMap.begin(); MapIter != VDMap.end(); ++MapIter)
{
berry::QtShowViewAction* viewAction = new berry::QtShowViewAction(window, (*MapIter).second);
//m_ViewActions.push_back(viewAction);
viewMenu->addAction(viewAction);
qToolbar->addAction(viewAction);
}
mainWindow->addToolBar(qToolbar);
QStatusBar* qStatusBar = new QStatusBar();
//creating a QmitkStatusBar for Output on the QStatusBar and connecting it with the MainStatusBar
QmitkStatusBar *statusBar = new QmitkStatusBar(qStatusBar);
//disabling the SizeGrip in the lower right corner
statusBar->SetSizeGripEnabled(false);
QmitkProgressBar *progBar = new QmitkProgressBar();
qStatusBar->addPermanentWidget(progBar, 0);
progBar->hide();
mainWindow->setStatusBar(qStatusBar);
QmitkMemoryUsageIndicatorView* memoryIndicator = new QmitkMemoryUsageIndicatorView();
qStatusBar->addPermanentWidget(memoryIndicator, 0);
}
void IdealController::addView(Qt::DockWidgetArea area, View* view)
{
IdealDockWidget *dock = new IdealDockWidget(this, m_mainWindow);
// dock object name is used to store toolview settings
QString dockObjectName = view->document()->title();
// support different configuration for same docks opened in different areas
if (m_mainWindow->area())
dockObjectName += '_' + m_mainWindow->area()->objectName();
dock->setObjectName(dockObjectName);
KAcceleratorManager::setNoAccel(dock);
QWidget *w = view->widget(dock);
if (w->parent() == 0)
{
/* Could happen when we're moving the widget from
one IdealDockWidget to another. See moveView below.
In this case, we need to reparent the widget. */
w->setParent(dock);
}
QList<QAction *> toolBarActions = view->toolBarActions();
if (toolBarActions.isEmpty()) {
dock->setWidget(w);
} else {
QMainWindow *toolView = new QMainWindow();
QToolBar *toolBar = new QToolBar(toolView);
int iconSize = m_mainWindow->style()->pixelMetric(QStyle::PM_SmallIconSize);
toolBar->setIconSize(QSize(iconSize, iconSize));
toolBar->setToolButtonStyle(Qt::ToolButtonIconOnly);
toolBar->setWindowTitle(i18n("%1 Tool Bar", w->windowTitle()));
toolBar->setFloatable(false);
toolBar->setMovable(false);
toolBar->addActions(toolBarActions);
toolView->setCentralWidget(w);
toolView->addToolBar(toolBar);
dock->setWidget(toolView);
}
dock->setWindowTitle(view->widget()->windowTitle());
dock->setWindowIcon(view->widget()->windowIcon());
dock->setFocusProxy(dock->widget());
if (IdealButtonBarWidget* bar = barForDockArea(area)) {
QAction* action = bar->addWidget(
view->document()->title(), dock,
static_cast<MainWindow*>(parent())->area(), view);
m_dockwidget_to_action[dock] = m_view_to_action[view] = action;
m_docks->addAction(action);
connect(dock, &IdealDockWidget::closeRequested, action, &QAction::toggle);
}
connect(dock, &IdealDockWidget::dockLocationChanged, this, &IdealController::dockLocationChanged);
dock->hide();
docks.insert(dock);
}
void DesignerFormWindowImpl::addToolBar( const QString &text, const QString &name )
{
if ( !::qt_cast<QMainWindow*>(formWindow->mainContainer()) )
return;
QMainWindow *mw = (QMainWindow*)formWindow->mainContainer();
QToolBar *tb = new QDesignerToolBar( mw );
QString n = name;
formWindow->unify( tb, n, TRUE );
tb->setName( n );
mw->addToolBar( tb, text );
}
void ToolBar::place(Qt::ToolBarArea area, bool p)
{
if (!p)
return;
QMainWindow *mainWindow = qobject_cast<QMainWindow *>(parentWidget());
Q_ASSERT(mainWindow != 0);
mainWindow->addToolBar(area, this);
if (allowedAreasActions->isEnabled()) {
allowLeftAction->setEnabled(area != Qt::LeftToolBarArea);
allowRightAction->setEnabled(area != Qt::RightToolBarArea);
allowTopAction->setEnabled(area != Qt::TopToolBarArea);
allowBottomAction->setEnabled(area != Qt::BottomToolBarArea);
}
}
void tst_QToolBar::task191727_layout()
{
QMainWindow mw;
QToolBar *toolBar = mw.addToolBar("test");
toolBar->addAction("one");
QAction *action = toolBar->addAction("two");
QLineEdit *lineedit = new QLineEdit;
lineedit->setMaximumWidth(50);
toolBar->addWidget(lineedit);
mw.resize(400, 400);
mw.show();
QWidget *actionwidget = toolBar->widgetForAction(action);
QVERIFY(qAbs(lineedit->pos().x() - (actionwidget->geometry().right() + 1 + toolBar->layout()->spacing())) < 2);
}
void PatternsBasicWidget::initPatternEditor()
{
QMainWindow* wrapper = new QMainWindow();
QToolBar* buttonBar = new QToolBar(this);
buttonBar->setMovable(false);
buttonBar->setFloatable(false);
compileButton = new QPushButton(tr("Компиляция"),this);
matchButton = new QPushButton(tr("Сопоставление"), this);
clearButton= new QPushButton(tr("Удалить"),this);
addButton = new QPushButton(tr("Добавить"),this);
selectAllButton = new QPushButton(tr("Выбрать всё"),this);
deselectAllButton = new QPushButton(tr("Сбросить всё"),this);
buttonBar->addWidget(compileButton);
buttonBar->addWidget(matchButton);
buttonBar->addWidget(selectAllButton);
buttonBar->addWidget(deselectAllButton);
buttonBar->addWidget(clearButton);
QWidget* container =new QWidget(this);
QVBoxLayout* lay = new QVBoxLayout(container);
lay->setContentsMargins(0,0,0,0);
list = new PatternsList(comp,this);
editor = new PatternEditor(this);
connect(compileButton,SIGNAL(clicked(bool)),list,SLOT(slotCompilePatterns()));
connect(clearButton,SIGNAL(clicked(bool)),this,SLOT(slotDeleteSelected()));
connect(matchButton,SIGNAL(clicked(bool)),this,SLOT(slotMatchClicked()));
connect(addButton,SIGNAL(clicked(bool)),this,SLOT(slotAddPattern()));
connect(selectAllButton,SIGNAL(clicked(bool)),list,SLOT(slotSelectAll()));
connect(deselectAllButton,SIGNAL(clicked(bool)),list,SLOT(slotDeselectAll()));
connect(list,SIGNAL(editPatternSignal(QString)),editor,SLOT(setText(QString)));
QHBoxLayout* line = new QHBoxLayout();
line->addWidget(editor);
line->addWidget(addButton);
lay->addWidget(list);
lay->addLayout(line);
lay->setStretch(0,5);
lay->setStretch(1,1);
container->setLayout(lay);
wrapper->setContentsMargins(10,0,10,10);
wrapper->setCentralWidget(container);
wrapper->addToolBar(buttonBar);
setWidget(wrapper);
}
int main(int argc, char** argv) {
QApplication app(argc, argv);
const QString name("CConf Demo");
app.setApplicationDisplayName(name);
CConf::Context* ctxt = new CConf::Context();
ctxt->addFile("example.json");
// ctxt->addFile("example2.json");
QTreeView* confView = new QTreeView();
confView->setModel(ctxt);
QMainWindow* win = new QMainWindow();
win->addToolBar(name);
win->setCentralWidget(confView);
win->show();
return app.exec();
}
int main(int argc, char **argv) {
QApplication app(argc, argv);
QMainWindow window;
QWidget mainWidget;
QVBoxLayout layout;
DrawWidget drawWidget(QSize(128, 128));
layout.addWidget(&drawWidget, 0, Qt::AlignCenter);
mainWidget.setLayout(&layout);
QAction fillArrayAction("Fill array", &window);
QAction smoothAction("Smooth", &window);
QObject::connect(&fillArrayAction, &QAction::triggered, [&]() {
drawWidget.setEnabled(false);
fillArrayAction.setEnabled(false);
drawWidget.fillArray();
smoothAction.setEnabled(true);
drawWidget.setEnabled(true);
});
smoothAction.setEnabled(false);
QObject::connect(&smoothAction, &QAction::triggered, [&]() {
smoothAction.setEnabled(false);
drawWidget.smooth();
fillArrayAction.setEnabled(true);
});
QToolBar toolBar;
toolBar.addAction(&fillArrayAction);
toolBar.addAction(&smoothAction);
window.addToolBar(&toolBar);
window.setCentralWidget(&mainWidget);
window.resize(320, 240);
window.show();
return app.exec();
}
void MainWindow::createCompositionView(CompositionModel* model)
{
QMainWindow* window = new QMainWindow;
QToolBar* bar = new QToolBar( window );
bar->addAction( ui.actionCompositionOpenPicture );
bar->setMovable( false );
window->addToolBar( bar );
window->setParent( ui.dockWidgetComposition );
compositionView = new CompositionView( this );
compositionView->setModel(model);
compositionView->addAction( ui.actionCompositionOpenPicture );
compositionView->setContextMenuPolicy( Qt::ActionsContextMenu );
window->setCentralWidget( compositionView );
ui.dockWidgetComposition->setWidget( window );
connect( ui.actionCompositionOpenPicture, SIGNAL( triggered() ), this, SLOT( actionCompositionOpenPicture() ) );
}
void tst_QToolBar::isMovable()
{
#define DO_TEST \
do { \
QVERIFY(tb.isMovable()); \
tb.setMovable(false); \
QVERIFY(!tb.isMovable()); \
QCOMPARE(spy.count(), 1); \
QCOMPARE(spy.at(0).value(0).toBool(), tb.isMovable()); \
spy.clear(); \
tb.setMovable(tb.isMovable()); \
QCOMPARE(spy.count(), 0); \
spy.clear(); \
tb.setMovable(true); \
QVERIFY(tb.isMovable()); \
QCOMPARE(spy.count(), 1); \
QCOMPARE(spy.at(0).value(0).toBool(), tb.isMovable()); \
spy.clear(); \
tb.setMovable(tb.isMovable()); \
QCOMPARE(spy.count(), 0); \
spy.clear(); \
} while (false)
QMainWindow mw;
QToolBar tb;
QCOMPARE(tb.isMovable(), (bool)qApp->style()->styleHint(QStyle::SH_ToolBar_Movable));
if (!tb.isMovable())
tb.setMovable(true);
QSignalSpy spy(&tb, SIGNAL(movableChanged(bool)));
DO_TEST;
mw.addToolBar(&tb);
DO_TEST;
mw.removeToolBar(&tb);
DO_TEST;
}
int Dialog::showDialog(const QString& view, QObject* viewModel, int type)
{
QDialog* dialog = NULL;
QMainWindow* mainWindow = NULL;
QWidget* windowWidget = NULL;
QWidget* layoutWidget = NULL;
switch (type)
{
case Dialog::MainWindow:
mainWindow = new QMainWindow();
windowWidget = mainWindow;
layoutWidget = new QWidget(windowWidget);
mainWindow->setCentralWidget(layoutWidget);
break;
case Dialog::ModalDialog:
dialog = new QDialog(QApplication::activeWindow());
windowWidget = dialog;
layoutWidget = dialog;
break;
default:
dialog = new QDialog();
windowWidget = dialog;
layoutWidget = dialog;
break;
}
QGridLayout* layout = new QGridLayout(layoutWidget);
// Create view
QDeclarativeView* v = new QDeclarativeView(layoutWidget);
if (viewModel)
{
int count = viewModel->metaObject()->propertyCount();
for (int i = 0; i < count; ++i)
{
QMetaProperty p = viewModel->metaObject()->property(i);
if (p.isReadable() && p.typeName() == QString("QDeclarativeImageProvider*"))
{
QString name = p.name();
QDeclarativeImageProvider* value = p.read(viewModel).value<QDeclarativeImageProvider*>();
v->engine()->addImageProvider(name.toLatin1(), new ProxyImageProvider(value));
}
}
v->rootContext()->setContextProperty("dataContext", viewModel);
}
QString path;
foreach (path, importPaths)
v->engine()->addImportPath(path);
foreach (path, pluginPaths)
v->engine()->addPluginPath(path);
v->setSource(QUrl(view));
v->setResizeMode(QDeclarativeView::SizeRootObjectToView);
// Initialize dialog
QGraphicsObject* root = v->rootObject();
QVariant property = root->property("dialogTitle");
if (property.isValid())
windowWidget->setWindowTitle(property.toString());
property = root->property("dialogMinWidth");
if (property.isValid())
layoutWidget->setMinimumWidth(property.toInt());
property = root->property("dialogMinHeight");
if (property.isValid())
layoutWidget->setMinimumHeight(property.toInt());
property = root->property("dialogMaxWidth");
if (property.isValid())
layoutWidget->setMaximumWidth(property.toInt());
property = root->property("dialogMaxHeight");
if (property.isValid())
layoutWidget->setMaximumHeight(property.toInt());
property = root->property("dialogResizable");
if (property.isValid() && !property.toBool())
layout->setSizeConstraint(QLayout::SetFixedSize);
Qt::WindowStates states = windowWidget->windowState();
Qt::WindowFlags flags = windowWidget->windowFlags();
property = root->property("dialogMinimizeButton");
if (property.isValid())
flags = property.toBool() ? flags | Qt::WindowMinimizeButtonHint : flags & ~Qt::WindowMinimizeButtonHint;
property = root->property("dialogMaximizeButton");
if (property.isValid())
flags = property.toBool() ? flags | Qt::WindowMaximizeButtonHint : flags & ~Qt::WindowMaximizeButtonHint;
property = root->property("dialogCloseButton");
if (property.isValid())
flags = property.toBool() ? flags | Qt::WindowCloseButtonHint : flags & ~Qt::WindowCloseButtonHint;
property = root->property("dialogFullScreen");
if (property.isValid())
states = property.toBool() ? states | Qt::WindowFullScreen : states & ~Qt::WindowFullScreen;
flags = flags & ~Qt::WindowContextHelpButtonHint;
windowWidget->setWindowFlags(flags);
windowWidget->setWindowState(states);
property = root->property("dialogToolBar");
if (type == Dialog::MainWindow && property.isValid() && property.typeName() == QString("QDeclarativeListProperty<QDeclarativeItem>"))
{
QToolBar* toolbar = new QToolBar(mainWindow);
toolbar->setMovable(false);
toolbar->setFloatable(false);
toolbar->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
toolbar->setAllowedAreas(Qt::TopToolBarArea);
QDeclarativeListProperty<QDeclarativeItem> btnList = property.value< QDeclarativeListProperty<QDeclarativeItem> >();
int btnCount = btnList.count(&btnList);
for (int i = 0; i < btnCount; ++i)
{
QDeclarativeItem* item = btnList.at(&btnList, i);
if (!item->property("text").isValid())
continue;
QString itemText = item->property("text").toString();
QString itemTooltip = item->property("tooltip").isValid() ? item->property("tooltip").toString() : "";
QString itemIconSource = item->property("iconSource").isValid() ? item->property("iconSource").toString() : "";
int itemIconSize = item->property("iconSize").isValid() ? item->property("iconSize").toInt() : -1;
if (itemText == "|")
{
toolbar->addSeparator();
}
else if (itemText == "-")
{
QWidget* spacer = new QWidget();
spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
toolbar->addWidget(spacer);
}
else
{
QAction* action = new QAction(mainWindow);
action->setText(itemText);
action->setToolTip(itemTooltip);
action->setIcon(QIcon(itemIconSource));
QObject::connect(action, SIGNAL(triggered()), item, SLOT(trigger()));
if (item->property("enabled").isValid())
new PropertyBinding(action, "enabled", item, "enabled", PropertyBinding::OneWay, NULL, this);
if (item->property("visible").isValid())
new PropertyBinding(action, "visible", item, "visible", PropertyBinding::OneWay, NULL, this);
toolbar->addAction(action);
}
if (itemIconSize != -1)
toolbar->setIconSize(QSize(itemIconSize, itemIconSize));
}
mainWindow->setUnifiedTitleAndToolBarOnMac(true);
mainWindow->addToolBar(toolbar);
}
property = root->property("dialogMenu");
if (type == Dialog::MainWindow && property.isValid() && property.typeName() == QString("QDeclarativeListProperty<QDeclarativeItem>"))
{
QDeclarativeListProperty<QDeclarativeItem> list = property.value< QDeclarativeListProperty<QDeclarativeItem> >();
int count = list.count(&list);
for (int i = 0; i < count; ++i)
{
QDeclarativeItem* item = list.at(&list, i);
if (!item->property("text").isValid())
continue;
QString itemText = item->property("text").toString();
QMenu * menuItem = mainWindow->menuBar()->addMenu(itemText);
if (!item->property("submenu").isValid() || item->property("submenu").typeName() != QString("QDeclarativeListProperty<QDeclarativeItem>"))
continue;
QDeclarativeListProperty<QDeclarativeItem> innerList = item->property("submenu").value< QDeclarativeListProperty<QDeclarativeItem> >();
int innerCount = innerList.count(&innerList);
for (int j = 0; j < innerCount; ++j)
{
QDeclarativeItem* innerItem = innerList.at(&innerList, j);
if (!innerItem->property("text").isValid())
continue;
QString innerItemText = innerItem->property("text").toString();
QString innerItemShortcut = innerItem->property("shortcut").isValid() ? innerItem->property("shortcut").toString() : "";
QString innerItemIconSource = innerItem->property("iconSource").isValid() ? innerItem->property("iconSource").toString() : "";
if (innerItemText == "-")
{
menuItem->addSeparator();
}
else
{
QAction * action = menuItem->addAction(QIcon(innerItemIconSource), innerItemText);
action->setShortcut(QKeySequence(innerItemShortcut));
QObject::connect(action, SIGNAL(triggered()), innerItem, SLOT(trigger()));
if (innerItem->property("enabled").isValid())
new PropertyBinding(action, "enabled", innerItem, "enabled", PropertyBinding::OneWay, NULL, this);
if (innerItem->property("visible").isValid())
new PropertyBinding(action, "visible", innerItem, "visible", PropertyBinding::OneWay, NULL, this);
}
}
}
}
new DialogCallbacks(windowWidget, v, root);
// Initialize layout
layout->setMargin(0);
layout->addWidget(v, 0, 0);
// Execute
switch (type)
{
case Dialog::ModalDialog:
dialog->exec();
break;
case Dialog::MainWindow:
{
if (mainWindowGeometry.isEmpty())
{
mainWindow->adjustSize();
mainWindow->move(QApplication::desktop()->screen()->rect().center() - mainWindow->rect().center());
}
else
mainWindow->restoreGeometry(mainWindowGeometry);
}
default:
windowWidget->setAttribute(Qt::WA_DeleteOnClose);
windowWidget->show();
break;
}
int result = 0;
property = root->property("dialogResult");
if (property.isValid())
result = property.toInt();
if (type == Dialog::ModalDialog)
delete dialog;
return result;
}
int main(int argc, char * argv[])
{
QList<QWidget*> widgets;
QApplication app(argc, argv);
QMainWindow mainWindow;
mainWindow.setWindowTitle("Test");
QMenu *fileMenu = mainWindow.menuBar()->addMenu("File");
QMenu *editMenu = mainWindow.menuBar()->addMenu("Edit");
QMenu *viewMenu = mainWindow.menuBar()->addMenu("View");
QMenu *toolsMenu = mainWindow.menuBar()->addMenu("Tools");
QMenu *optionsMenu = mainWindow.menuBar()->addMenu("Options");
QMenu *helpMenu = mainWindow.menuBar()->addMenu("Help");
qApp->processEvents();
fileMenu->addAction("Open");
QAction *close = fileMenu->addAction("Close");
fileMenu->addSeparator();
fileMenu->addAction("Exit");
close->setEnabled(false);
editMenu->addAction("Cut");
editMenu->addAction("Pase");
editMenu->addAction("Copy");
editMenu->addSeparator();
editMenu->addAction("Find");
viewMenu->addAction("Hide");
viewMenu->addAction("Show");
viewMenu->addAction("Explore");
QAction *visible = viewMenu->addAction("Visible");
visible->setCheckable(true);
visible->setChecked(true);
toolsMenu->addMenu("Hammer");
toolsMenu->addMenu("Caliper");
toolsMenu->addMenu("Helm");
optionsMenu->addMenu("Settings");
optionsMenu->addMenu("Standard");
optionsMenu->addMenu("Extended");
QMenu *subMenu = helpMenu->addMenu("Help");
subMenu->addAction("Index");
subMenu->addSeparator();
subMenu->addAction("Vodoo Help");
helpMenu->addAction("Contens");
helpMenu->addSeparator();
helpMenu->addAction("About");
QToolBar toolbar;
mainWindow.addToolBar(&toolbar);
toolbar.addAction(QIcon(qApp->style()->standardPixmap(QStyle::SP_FileIcon)), QString("textAction"));
QTextEdit textEdit;
mainWindow.setCentralWidget(&textEdit);
mainWindow.showMaximized();
app.exec();
}
void tst_QToolBar::toolButtonStyle()
{
{
QToolBar tb;
QSignalSpy spy(&tb, SIGNAL(toolButtonStyleChanged(Qt::ToolButtonStyle)));
// no-op
QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonIconOnly);
tb.setToolButtonStyle(Qt::ToolButtonIconOnly);
QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonIconOnly);
QCOMPARE(spy.count(), 0);
tb.setToolButtonStyle(Qt::ToolButtonTextOnly);
QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonTextOnly);
QCOMPARE(spy.count(), 1);
spy.clear();
// no-op
tb.setToolButtonStyle(Qt::ToolButtonTextOnly);
QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonTextOnly);
QCOMPARE(spy.count(), 0);
tb.setToolButtonStyle(Qt::ToolButtonIconOnly);
QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonIconOnly);
QCOMPARE(spy.count(), 1);
spy.clear();
// no-op
tb.setToolButtonStyle(Qt::ToolButtonIconOnly);
QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonIconOnly);
QCOMPARE(spy.count(), 0);
tb.setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonTextBesideIcon);
QCOMPARE(spy.count(), 1);
spy.clear();
// no-op
tb.setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonTextBesideIcon);
QCOMPARE(spy.count(), 0);
tb.setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonTextUnderIcon);
QCOMPARE(spy.count(), 1);
spy.clear();
// no-op
tb.setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonTextUnderIcon);
QCOMPARE(spy.count(), 0);
tb.setToolButtonStyle(Qt::ToolButtonFollowStyle);
QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonFollowStyle);
QCOMPARE(spy.count(), 1);
}
{
QMainWindow mw;
QToolBar tb;
QSignalSpy mwSpy(&mw, SIGNAL(toolButtonStyleChanged(Qt::ToolButtonStyle)));
QSignalSpy tbSpy(&tb, SIGNAL(toolButtonStyleChanged(Qt::ToolButtonStyle)));
mw.setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
// explicitly set the tb to the default
tb.setToolButtonStyle(Qt::ToolButtonIconOnly);
QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonIconOnly);
QCOMPARE(tbSpy.count(), 0);
mw.addToolBar(&tb);
// tb icon size should not change since it has been explicitly set
QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonIconOnly);
QCOMPARE(tbSpy.count(), 0);
mw.setToolButtonStyle(Qt::ToolButtonIconOnly);
QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonIconOnly);
QCOMPARE(tbSpy.count(), 0);
mw.setToolButtonStyle(Qt::ToolButtonTextOnly);
QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonIconOnly);
QCOMPARE(tbSpy.count(), 0);
mw.setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonIconOnly);
QCOMPARE(tbSpy.count(), 0);
// note: there is no way to clear the explicitly set tool
// button style... once you explicitly set it, the toolbar
// will never follow the mainwindow again
}
}
void tst_QToolBar::iconSize()
{
{
QToolBar tb;
QSignalSpy spy(&tb, SIGNAL(iconSizeChanged(QSize)));
// the default is determined by the style
const int metric = tb.style()->pixelMetric(QStyle::PM_ToolBarIconSize);
const QSize defaultIconSize = QSize(metric, metric);
const QSize smallIconSize = QSize(metric / 2, metric / 2);
const QSize largeIconSize = QSize(metric * 2, metric * 2);
QCOMPARE(tb.iconSize(), defaultIconSize);
tb.setIconSize(defaultIconSize);
QCOMPARE(tb.iconSize(), defaultIconSize);
QCOMPARE(spy.count(), 0);
spy.clear();
tb.setIconSize(largeIconSize);
QCOMPARE(tb.iconSize(), largeIconSize);
QCOMPARE(spy.count(), 1);
QCOMPARE(spy.first().first().toSize(), largeIconSize);
// no-op
spy.clear();
tb.setIconSize(largeIconSize);
QCOMPARE(tb.iconSize(), largeIconSize);
QCOMPARE(spy.count(), 0);
spy.clear();
tb.setIconSize(defaultIconSize);
QCOMPARE(tb.iconSize(), defaultIconSize);
QCOMPARE(spy.count(), 1);
QCOMPARE(spy.first().first().toSize(), defaultIconSize);
// no-op
spy.clear();
tb.setIconSize(defaultIconSize);
QCOMPARE(tb.iconSize(), defaultIconSize);
QCOMPARE(spy.count(), 0);
spy.clear();
tb.setIconSize(smallIconSize);
QCOMPARE(tb.iconSize(), smallIconSize);
QCOMPARE(spy.count(), 1);
QCOMPARE(spy.first().first().toSize(), smallIconSize);
// no-op
spy.clear();
tb.setIconSize(smallIconSize);
QCOMPARE(tb.iconSize(), smallIconSize);
QCOMPARE(spy.count(), 0);
// setting the icon size to an invalid QSize will reset the
// iconSize property to the default
tb.setIconSize(QSize());
QCOMPARE(tb.iconSize(), defaultIconSize);
QCOMPARE(spy.size(), 1);
QCOMPARE(spy.first().first().toSize(), defaultIconSize);
spy.clear();
}
{
QMainWindow mw;
QToolBar tb;
QSignalSpy mwSpy(&mw, SIGNAL(iconSizeChanged(QSize)));
QSignalSpy tbSpy(&tb, SIGNAL(iconSizeChanged(QSize)));
// the default is determined by the style
const int metric = tb.style()->pixelMetric(QStyle::PM_ToolBarIconSize);
const QSize defaultIconSize = QSize(metric, metric);
const QSize smallIconSize = QSize(metric / 2, metric / 2);
const QSize largeIconSize = QSize(metric * 2, metric * 2);
mw.setIconSize(smallIconSize);
// explicitly set it to the default
tb.setIconSize(defaultIconSize);
QCOMPARE(tb.iconSize(), defaultIconSize);
QCOMPARE(tbSpy.count(), 0);
mw.addToolBar(&tb);
// tb icon size should not change since it has been explicitly set
QCOMPARE(tb.iconSize(), defaultIconSize);
QCOMPARE(tbSpy.count(), 0);
mw.setIconSize(largeIconSize);
QCOMPARE(tb.iconSize(), defaultIconSize);
QCOMPARE(tbSpy.count(), 0);
mw.setIconSize(defaultIconSize);
QCOMPARE(tb.iconSize(), defaultIconSize);
QCOMPARE(tbSpy.count(), 0);
mw.setIconSize(smallIconSize);
QCOMPARE(tb.iconSize(), defaultIconSize);
QCOMPARE(tbSpy.count(), 0);
// resetting to the default should cause the toolbar to take
// on the mainwindow's icon size
tb.setIconSize(QSize());
QCOMPARE(tb.iconSize(), smallIconSize);
QCOMPARE(tbSpy.size(), 1);
QCOMPARE(tbSpy.first().first().toSize(), smallIconSize);
tbSpy.clear();
}
}
bool EV_QtToolbar::synthesize(void)
{
// create a Qt toolbar from the info provided.
const EV_Toolbar_ActionSet * pToolbarActionSet = m_pQtApp->getToolbarActionSet();
UT_ASSERT(pToolbarActionSet);
XAP_Toolbar_ControlFactory * pFactory = m_pQtApp->getControlFactory();
UT_ASSERT(pFactory);
UT_uint32 nrLabelItemsInLayout = m_pToolbarLayout->getLayoutItemCount();
UT_ASSERT(nrLabelItemsInLayout > 0);
m_wToolbar = new QToolBar();
UT_ASSERT(m_wToolbar);
Qt::ToolButtonStyle style = getStyle();
m_wToolbar->setToolButtonStyle(style);
for (UT_uint32 k=0; (k < nrLabelItemsInLayout); k++)
{
EV_Toolbar_LayoutItem * pLayoutItem = m_pToolbarLayout->getLayoutItem(k);
UT_continue_if_fail(pLayoutItem);
XAP_Toolbar_Id id = pLayoutItem->getToolbarId();
EV_Toolbar_Action * pAction = pToolbarActionSet->getAction(id);
UT_ASSERT(pAction);
EV_Toolbar_Label * pLabel = m_pToolbarLabelSet->getLabel(id);
UT_ASSERT(pLabel);
const char * szToolTip = pLabel->getToolTip();
if (!szToolTip || !*szToolTip)
szToolTip = pLabel->getStatusMsg();
switch (pLayoutItem->getToolbarLayoutFlags())
{
case EV_TLF_Normal:
{
switch (pAction->getItemType())
{
case EV_TBIT_PushButton:
{
UT_ASSERT(g_ascii_strcasecmp(pLabel->getIconName(),"NoIcon")!=0);
if(pAction->getToolbarId() != AP_TOOLBAR_ID_INSERT_TABLE)
{
const char *icon_name = pLabel->getIconName();
QPixmap pixmap;
pixmap = abi_pixmap_from_toolbar_id (icon_name);
if(!pixmap.isNull())
{
QIcon icon(pixmap);
QString str = "";
QPushButton *item = new QPushButton(icon, str);
m_wToolbar->addWidget(item);
}
}
else
{
const char *icon_name = pLabel->getIconName();
QPixmap pixmap;
pixmap = abi_pixmap_from_toolbar_id (icon_name);
if(!pixmap.isNull())
{
QIcon icon(pixmap);
QString str = "";
QPushButton *item = new QPushButton(icon, str);
m_wToolbar->addWidget(item);
}
}
break;
}
case EV_TBIT_ToggleButton:
case EV_TBIT_GroupButton:
{
UT_ASSERT(g_ascii_strcasecmp(pLabel->getIconName(),"NoIcon")!=0);
const char *icon_name = pLabel->getIconName();
QPixmap pixmap;
pixmap = abi_pixmap_from_toolbar_id (icon_name);
if(!pixmap.isNull())
{
QIcon icon(pixmap);
QString str = "";
QPushButton *item = new QPushButton(icon, str);
item->setCheckable(true);
m_wToolbar->addWidget(item);
}
break;
}
case EV_TBIT_EditText:
{
break;
}
case EV_TBIT_DropDown:
{
break;
}
case EV_TBIT_ComboBox:
{
EV_Toolbar_Control * pControl = pFactory->getControl(this, id);
UT_ASSERT(pControl);
QComboBox *combo;
bool isFontCombo = false;
if(id == AP_TOOLBAR_ID_FMT_SIZE)
{
combo = new QComboBox();
}
else if(id == AP_TOOLBAR_ID_FMT_FONT)
{
isFontCombo = true;
combo = new QFontComboBox();
QString str = "AbiFontCombo";
combo->setAccessibleName(str);
}
else if(id == AP_TOOLBAR_ID_ZOOM)
{
combo = new QComboBox();
QString str = "AbiZoomCombo";
combo->setAccessibleName(str);
}
else if(id == AP_TOOLBAR_ID_FMT_STYLE)
{
combo = new QComboBox();
QString str = "AbiStyleCombo";
combo->setAccessibleName(str);
}
else
{
UT_ASSERT(0);
}
// populate it
if (pControl)
{
pControl->populate();
const UT_GenericVector<const char*> * v = pControl->getContents();
UT_ASSERT(v);
gint items = v->getItemCount();
if (isFontCombo)
{
for (gint m=0; m < items; m++)
{
QString str = v->getNthItem(m);
combo->addItem(str);
}
}
else
{
for (gint m=0; m < items; m++)
{
const char * sz = v->getNthItem(m);
std::string sLoc;
if (id == AP_TOOLBAR_ID_FMT_STYLE)
{
pt_PieceTable::s_getLocalisedStyleName(sz, sLoc);
sz = sLoc.c_str();
}
QString str = sz;
combo->addItem(str);
}
}
}
m_wToolbar->addWidget(combo);
// for now, we never repopulate, so can just toss it
DELETEP(pControl);
break;
}
case EV_TBIT_ColorFore:
case EV_TBIT_ColorBack:
{
UT_ASSERT (g_ascii_strcasecmp(pLabel->getIconName(),"NoIcon") != 0);
QComboBox *combo;
if (pAction->getItemType() == EV_TBIT_ColorFore)
{
// TODO Some icon implementation
const XAP_StringSet * pSS = XAP_App::getApp()->getStringSet();
std::string sClear;
pSS->getValueUTF8(XAP_STRING_ID_TB_ClearForeground,sClear);
combo = new QComboBox();
QString str = sClear.c_str();
combo->setAccessibleName(str);
}
else
{
// TODO Some icon implementation
const XAP_StringSet * pSS = XAP_App::getApp()->getStringSet();
std::string sClear;
pSS->getValueUTF8(XAP_STRING_ID_TB_ClearForeground,sClear);
combo = new QComboBox();
QString str = sClear.c_str();
combo->setAccessibleName(str);
}
m_wToolbar->addWidget(combo);
break;
}
case EV_TBIT_StaticLabel:
{
// TODO do these...
break;
}
case EV_TBIT_Spacer:
{
break;
}
#ifdef ENABLE_MENUBUTTON
case EV_TBIT_MenuButton:
{
break;
}
#endif
case EV_TBIT_BOGUS:
default:
{
break;
}
}
break;
}
case EV_TLF_Spacer:
{
m_wToolbar->addSeparator();
break;
}
default:
{
UT_ASSERT(0);
}
}
}
QMainWindow * wTopLevel = static_cast<XAP_QtFrameImpl *>(m_pFrame->getFrameImpl())->getTopLevel();
wTopLevel->addToolBar(m_wToolbar);
wTopLevel->show();
return true;
}
void QmitkExtWorkbenchWindowAdvisor::PostWindowCreate()
{
QmitkCommonWorkbenchWindowAdvisor::PostWindowCreate();
// very bad hack...
berry::IWorkbenchWindow::Pointer window =
this->GetWindowConfigurer()->GetWindow();
QMainWindow* mainWindow =
static_cast<QMainWindow*> (window->GetShell()->GetControl());
if (!windowIcon.empty())
{
mainWindow->setWindowIcon(QIcon(QString::fromStdString(windowIcon)));
}
mainWindow->setContextMenuPolicy(Qt::PreventContextMenu);
/*mainWindow->setStyleSheet("color: white;"
"background-color: #808080;"
"selection-color: #659EC7;"
"selection-background-color: #808080;"
" QMenuBar {"
"background-color: #808080; }");*/
// ==== Application menu ============================
QMenuBar* menuBar = mainWindow->menuBar();
menuBar->setContextMenuPolicy(Qt::PreventContextMenu);
QMenu* fileMenu = menuBar->addMenu("&File");
fileMenu->setObjectName("FileMenu");
QAction* fileOpenAction = new QmitkExtFileOpenAction(QIcon(":/org.mitk.gui.qt.ext/Load_48.png"), window);
fileMenu->addAction(fileOpenAction);
fileSaveProjectAction = new QmitkExtFileSaveProjectAction(window);
fileSaveProjectAction->setIcon(QIcon(":/org.mitk.gui.qt.ext/Save_48.png"));
fileMenu->addAction(fileSaveProjectAction);
closeProjectAction = new QmitkCloseProjectAction(window);
closeProjectAction->setIcon(QIcon(":/org.mitk.gui.qt.ext/Remove_48.png"));
fileMenu->addAction(closeProjectAction);
fileMenu->addSeparator();
QAction* fileExitAction = new QmitkFileExitAction(window);
fileExitAction->setObjectName("QmitkFileExitAction");
fileMenu->addAction(fileExitAction);
berry::IViewRegistry* viewRegistry =
berry::PlatformUI::GetWorkbench()->GetViewRegistry();
const std::vector<berry::IViewDescriptor::Pointer>& viewDescriptors =
viewRegistry->GetViews();
// another bad hack to get an edit/undo menu...
QMenu* editMenu = menuBar->addMenu("&Edit");
undoAction = editMenu->addAction(QIcon(":/org.mitk.gui.qt.ext/Undo_48.png"),
"&Undo",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onUndo()),
QKeySequence("CTRL+Z"));
undoAction->setToolTip("Undo the last action (not supported by all modules)");
redoAction = editMenu->addAction(QIcon(":/org.mitk.gui.qt.ext/Redo_48.png")
, "&Redo",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onRedo()),
QKeySequence("CTRL+Y"));
redoAction->setToolTip("execute the last action that was undone again (not supported by all modules)");
imageNavigatorAction = new QAction(QIcon(":/org.mitk.gui.qt.ext/Slider.png"), "&Image Navigator", NULL);
bool imageNavigatorViewFound = window->GetWorkbench()->GetViewRegistry()->Find("org.mitk.views.imagenavigator");
if (imageNavigatorViewFound)
{
QObject::connect(imageNavigatorAction, SIGNAL(triggered(bool)), QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onImageNavigator()));
imageNavigatorAction->setCheckable(true);
// add part listener for image navigator
imageNavigatorPartListener = new PartListenerForImageNavigator(imageNavigatorAction);
window->GetPartService()->AddPartListener(imageNavigatorPartListener);
berry::IViewPart::Pointer imageNavigatorView =
window->GetActivePage()->FindView("org.mitk.views.imagenavigator");
imageNavigatorAction->setChecked(false);
if (imageNavigatorView)
{
bool isImageNavigatorVisible = window->GetActivePage()->IsPartVisible(imageNavigatorView);
if (isImageNavigatorVisible)
imageNavigatorAction->setChecked(true);
}
imageNavigatorAction->setToolTip("Open image navigator for navigating through image");
}
// toolbar for showing file open, undo, redo and other main actions
QToolBar* mainActionsToolBar = new QToolBar;
mainActionsToolBar->setContextMenuPolicy(Qt::PreventContextMenu);
#ifdef __APPLE__
mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextUnderIcon );
#else
mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextBesideIcon );
#endif
mainActionsToolBar->addAction(fileOpenAction);
mainActionsToolBar->addAction(fileSaveProjectAction);
mainActionsToolBar->addAction(closeProjectAction);
mainActionsToolBar->addAction(undoAction);
mainActionsToolBar->addAction(redoAction);
if (imageNavigatorViewFound)
{
mainActionsToolBar->addAction(imageNavigatorAction);
}
mainWindow->addToolBar(mainActionsToolBar);
#ifdef __APPLE__
mainWindow->setUnifiedTitleAndToolBarOnMac(true);
#endif
// ==== Window Menu ==========================
QMenu* windowMenu = menuBar->addMenu("Window");
if (showNewWindowMenuItem)
{
windowMenu->addAction("&New Window", QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onNewWindow()));
windowMenu->addSeparator();
}
QMenu* perspMenu = windowMenu->addMenu("&Open Perspective");
QMenu* viewMenu;
if (showViewMenuItem)
{
viewMenu = windowMenu->addMenu("Show &View");
viewMenu->setObjectName("Show View");
}
windowMenu->addSeparator();
resetPerspAction = windowMenu->addAction("&Reset Perspective",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onResetPerspective()));
if(showClosePerspectiveMenuItem)
closePerspAction = windowMenu->addAction("&Close Perspective", QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onClosePerspective()));
windowMenu->addSeparator();
windowMenu->addAction("&Preferences...",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onEditPreferences()),
QKeySequence("CTRL+P"));
// fill perspective menu
berry::IPerspectiveRegistry* perspRegistry =
window->GetWorkbench()->GetPerspectiveRegistry();
QActionGroup* perspGroup = new QActionGroup(menuBar);
std::vector<berry::IPerspectiveDescriptor::Pointer> perspectives(
perspRegistry->GetPerspectives());
bool skip = false;
for (std::vector<berry::IPerspectiveDescriptor::Pointer>::iterator perspIt =
perspectives.begin(); perspIt != perspectives.end(); ++perspIt)
{
// if perspectiveExcludeList is set, it contains the id-strings of perspectives, which
// should not appear as an menu-entry in the perspective menu
if (perspectiveExcludeList.size() > 0)
{
for (unsigned int i=0; i<perspectiveExcludeList.size(); i++)
{
if (perspectiveExcludeList.at(i) == (*perspIt)->GetId())
{
skip = true;
break;
}
}
if (skip)
{
skip = false;
continue;
}
}
QAction* perspAction = new berry::QtOpenPerspectiveAction(window,
*perspIt, perspGroup);
mapPerspIdToAction.insert(std::make_pair((*perspIt)->GetId(), perspAction));
}
perspMenu->addActions(perspGroup->actions());
// sort elements (converting vector to map...)
std::vector<berry::IViewDescriptor::Pointer>::const_iterator iter;
std::map<std::string, berry::IViewDescriptor::Pointer> VDMap;
skip = false;
for (iter = viewDescriptors.begin(); iter != viewDescriptors.end(); ++iter)
{
// if viewExcludeList is set, it contains the id-strings of view, which
// should not appear as an menu-entry in the menu
if (viewExcludeList.size() > 0)
{
for (unsigned int i=0; i<viewExcludeList.size(); i++)
{
if (viewExcludeList.at(i) == (*iter)->GetId())
{
skip = true;
break;
}
}
if (skip)
{
skip = false;
continue;
}
}
if ((*iter)->GetId() == "org.blueberry.ui.internal.introview")
continue;
if ((*iter)->GetId() == "org.mitk.views.imagenavigator")
continue;
std::pair<std::string, berry::IViewDescriptor::Pointer> p(
(*iter)->GetLabel(), (*iter));
VDMap.insert(p);
}
// ==================================================
// ==== Perspective Toolbar ==================================
QToolBar* qPerspectiveToolbar = new QToolBar;
if (showPerspectiveToolbar)
{
qPerspectiveToolbar->addActions(perspGroup->actions());
mainWindow->addToolBar(qPerspectiveToolbar);
}
else
delete qPerspectiveToolbar;
// ==== View Toolbar ==================================
QToolBar* qToolbar = new QToolBar;
std::map<std::string, berry::IViewDescriptor::Pointer>::const_iterator
MapIter;
for (MapIter = VDMap.begin(); MapIter != VDMap.end(); ++MapIter)
{
berry::QtShowViewAction* viewAction = new berry::QtShowViewAction(window,
(*MapIter).second);
viewActions.push_back(viewAction);
if(showViewMenuItem)
viewMenu->addAction(viewAction);
if (showViewToolbar)
{
qToolbar->addAction(viewAction);
}
}
if (showViewToolbar)
{
mainWindow->addToolBar(qToolbar);
}
else
delete qToolbar;
QSettings settings(GetQSettingsFile(), QSettings::IniFormat);
mainWindow->restoreState(settings.value("ToolbarPosition").toByteArray());
// ====================================================
// ===== Help menu ====================================
QMenu* helpMenu = menuBar->addMenu("Help");
helpMenu->addAction("&Welcome",this, SLOT(onIntro()));
helpMenu->addAction("&Help Contents",this, SLOT(onHelp()), QKeySequence("F1"));
helpMenu->addAction("&About",this, SLOT(onAbout()));
// =====================================================
QStatusBar* qStatusBar = new QStatusBar();
//creating a QmitkStatusBar for Output on the QStatusBar and connecting it with the MainStatusBar
QmitkStatusBar *statusBar = new QmitkStatusBar(qStatusBar);
//disabling the SizeGrip in the lower right corner
statusBar->SetSizeGripEnabled(false);
QmitkProgressBar *progBar = new QmitkProgressBar();
qStatusBar->addPermanentWidget(progBar, 0);
progBar->hide();
// progBar->AddStepsToDo(2);
// progBar->Progress(1);
mainWindow->setStatusBar(qStatusBar);
QmitkMemoryUsageIndicatorView* memoryIndicator =
new QmitkMemoryUsageIndicatorView();
qStatusBar->addPermanentWidget(memoryIndicator, 0);
}
