void MoveToCenter(QMainWindow& w)
{
// move window to center.
if (QApplication::desktop()->screenCount() <= 1)
{
w.move((QApplication::desktop()->width() - w.width())/2,
(QApplication::desktop()->height() - w.height())/2);
}
else
{
QRect rect = QApplication::desktop()->screenGeometry(0);
w.move((rect.width()-w.width())/2,
(rect.height()-w.height())/2);
}
}
/** Main application
*
* @param argc :: ignored
* @param argv :: ignored
* @return return code
*/
int main( int argc, char ** argv )
{
double min=0;
double max=100;
QApplication app(argc, argv);
app.setOrganizationName("MantidProject");
app.setApplicationName("Color Bar Widget Example");
QMainWindow * mainWin = new QMainWindow();
QFrame * frame = new QFrame(mainWin);
mainWin->setCentralWidget(frame);
QLayout * layout = new QVBoxLayout(frame);
frame->setLayout(layout);
ColorBarWidget * widget = new ColorBarWidget(frame);
widget->setViewRange(min, max);
widget->setLog(false);
layout->addWidget(widget);
mainWin->move(100, 100);
mainWin->resize(40, 500);
mainWin->show();
app.exec();
mainWin->close();
delete mainWin;
return 0;
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QStringList args = app.arguments();
(void) args.takeFirst();
QWidget *widget = 0;
QString title;
bool usePlainTextEdit = args.size() < 2;
if (usePlainTextEdit) {
widget = new QPlainTextEdit;
title = "PlainTextEdit";
} else {
widget = new QTextEdit;
title = "TextEdit";
}
widget->resize(450, 350);
widget->setFocus();
FakeVimHandler fakeVim;
QMainWindow mw;
mw.setWindowTitle("Fakevim (" + title + ")");
mw.setCentralWidget(widget);
mw.resize(500, 650);
mw.move(0, 0);
mw.show();
QFont font = widget->font();
//: -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1
//font.setFamily("Misc");
font.setFamily("Monospace");
//font.setStretch(QFont::SemiCondensed);
widget->setFont(font);
mw.statusBar()->setFont(font);
QObject::connect(&fakeVim, SIGNAL(commandBufferChanged(QString)),
mw.statusBar(), SLOT(showMessage(QString)));
QObject::connect(&fakeVim, SIGNAL(quitRequested(QWidget *)),
&app, SLOT(quit()));
fakeVim.addWidget(widget);
if (args.size() >= 1)
fakeVim.handleCommand(widget, "r " + args.at(0));
return app.exec();
}
void tst_QDockWidget::setFloating()
{
const QRect deskRect = QApplication::desktop()->availableGeometry();
QMainWindow mw;
mw.move(deskRect.left() + deskRect.width() * 2 / 3, deskRect.top() + deskRect.height() / 3);
QDockWidget dw;
mw.addDockWidget(Qt::LeftDockWidgetArea, &dw);
mw.show();
QVERIFY(QTest::qWaitForWindowExposed(&mw));
QVERIFY(!dw.isFloating());
const QPoint dockedPosition = dw.mapToGlobal(dw.pos());
QSignalSpy spy(&dw, SIGNAL(topLevelChanged(bool)));
dw.setFloating(true);
const QPoint floatingPosition = dw.pos();
// QTBUG-31044, show approximately at old position, give or take window frame.
QVERIFY((dockedPosition - floatingPosition).manhattanLength() < 50);
QVERIFY(dw.isFloating());
QCOMPARE(spy.count(), 1);
QCOMPARE(spy.at(0).value(0).toBool(), dw.isFloating());
spy.clear();
dw.setFloating(dw.isFloating());
QCOMPARE(spy.count(), 0);
spy.clear();
dw.setFloating(false);
QVERIFY(!dw.isFloating());
QCOMPARE(spy.count(), 1);
QCOMPARE(spy.at(0).value(0).toBool(), dw.isFloating());
spy.clear();
dw.setFloating(dw.isFloating());
QCOMPARE(spy.count(), 0);
spy.clear();
}
void centerApp(QMainWindow& window)
{
QSize appSize(800, 600);
window.resize(appSize);
QDesktopWidget* desktop = QApplication::desktop();
int desktopArea = desktop->width() * desktop->height();
int appArea = appSize.width() * appSize.height();
if (((float)appArea / (float)desktopArea) > 0.75f) {
// Just maximize it if the desktop isn't significantly
// bigger than our app's area.
window.showMaximized();
} else {
// Center the app on the primary monitor.
QPoint windowLocation = desktop->screenGeometry(desktop->primaryScreen()).center();
windowLocation.setX(windowLocation.x() - appSize.width() / 2);
windowLocation.setY(windowLocation.y() - appSize.height() / 2);
window.move(windowLocation);
window.show();
}
}
//-----------------------------------------------------------------------------
void ctkSettings::restoreState(const QString& key, QMainWindow& window)
{
this->beginGroup(key);
if(this->contains("Size"))
{
window.resize(this->value("Size").toSize());
}
if(this->contains("Position"))
{
QPoint windowTopLeft = this->value("Position").toPoint();
QRect mwRect(windowTopLeft, window.size());
QDesktopWidget desktop;
QRect desktopRect = desktop.availableGeometry( desktop.primaryScreen() );
// try moving it to keep size
if(!desktopRect.contains(mwRect))
{
mwRect = QRect(desktopRect.topLeft(), window.size());
}
// still doesn't fit, resize it
if(!desktopRect.contains(mwRect))
{
mwRect = QRect(desktopRect.topLeft(), window.size());
window.resize(desktopRect.size());
}
window.move(mwRect.topLeft());
}
if(this->contains("Layout"))
{
window.restoreState(this->value("Layout").toByteArray());
}
this->endGroup();
}
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;
}
/** Main application
*
* @param argc :: ignored
* @param argv :: ignored
* @return return code
*/
int main( int argc, char ** argv )
{
QApplication app(argc, argv);
app.setApplicationName("PropertyWidgets demo");
QMainWindow * mainWin = new QMainWindow();
QFrame * frame = new QFrame(mainWin);
mainWin->setCentralWidget(frame);
QHBoxLayout * layout = new QHBoxLayout(frame);
frame->setLayout(layout);
QFrame * frame1 = new QFrame(mainWin);
frame1->setFrameStyle(QFrame::Box);
QFrame * frame2 = new QFrame(mainWin);
frame2->setFrameStyle(QFrame::Box);
layout->addWidget(frame1);
layout->addWidget(frame2);
QVBoxLayout * layout1 = new QVBoxLayout(frame1);
QGridLayout * grid = new QGridLayout(frame2);
std::vector<Property*> props;
props.push_back(new PropertyWithValue<bool>("BooleanProp", true));
props.push_back(new PropertyWithValue<std::string>("StringProperty", "default value"));
std::vector<std::string> exts;
exts.push_back(".txt");
exts.push_back(".nxs");
props.push_back(new FileProperty("SaveFileProperty", "default.file.txt", FileProperty::Save, exts));
props.push_back(new FileProperty("LoadFileProperty", "default.file.txt", FileProperty::Load, exts));
props.push_back(new FileProperty("DirectoryFileProperty", "default.file.txt", FileProperty::Directory, exts));
props.push_back(new MultipleFileProperty("MultipleFileProperty", exts));
props.push_back(new WorkspaceProperty<>("InputWorkspaceProp", "", Direction::Input));
props.push_back(new WorkspaceProperty<>("InOutWorkspaceProp", "", Direction::InOut));
props.push_back(new WorkspaceProperty<>("OutputWorkspaceProp", "", Direction::Output));
props.push_back(new WorkspaceProperty<>("OutputWorkspaceProp2", "", Direction::Output));
std::vector<std::string> propOptions;
propOptions.push_back("OptionA");
propOptions.push_back("OptionTwo");
propOptions.push_back("Yet Another Option");
props.push_back(new PropertyWithValue<std::string>("OptionsProperty", "OptionTwo", new ListValidator(propOptions)));
for (size_t i=0; i<props.size(); i++)
{
props[i]->setDocumentation("Tooltip for " + props[i]->name());
PropertyWidget * widget1 = PropertyWidgetFactory::createWidget(props[i], frame1, NULL);
layout1->addWidget(widget1);
PropertyWidget * widget2 = PropertyWidgetFactory::createWidget(props[i], frame2, grid, int(i));
UNUSED_ARG(widget2);
}
mainWin->move(100, 100);
mainWin->resize(700, 700);
mainWin->show();
app.exec();
mainWin->close();
delete mainWin;
return 0;
}
