void FoursquareAuthPage::createContent(void)
{
MApplicationPage::createContent();
setStyleName("CommonApplicationPage");
setPannable(false);
MAction *cancelAction = new MAction(tr("Cancel"), this);
cancelAction->setLocation(MAction::ToolBarLocation);
connect(cancelAction, SIGNAL(triggered()),
this, SLOT(dismiss()));
addAction(cancelAction);
QGraphicsAnchorLayout *layout = new QGraphicsAnchorLayout();
layout->setContentsMargins(0, 0, 0, 0);
m_header = new ViewHeader(tr("Foursquare authentication"));
layout->addCornerAnchors(m_header, Qt::TopLeftCorner,
layout, Qt::TopLeftCorner);
layout->addCornerAnchors(m_header, Qt::TopRightCorner,
layout, Qt::TopRightCorner);
QGraphicsGridLayout *subLayout = new QGraphicsGridLayout();
layout->addCornerAnchors(subLayout, Qt::TopLeftCorner,
m_header, Qt::BottomLeftCorner);
layout->addCornerAnchors(subLayout, Qt::BottomRightCorner,
layout, Qt::BottomRightCorner);
m_view = new QGraphicsWebView();
m_view->setResizesToContents(false);
m_view->setSizePolicy(QSizePolicy::Ignored,
QSizePolicy::Ignored);
connect(m_view, SIGNAL(loadStarted()),
this, SLOT(pageLoadStarted()));
connect(m_view, SIGNAL(loadFinished(bool)),
this, SLOT(pageLoadFinished(bool)));
subLayout->addItem(m_view, 0, 0);
m_nam = new FoursquareAuthNetworkAccessManager(m_view->page()->networkAccessManager(),
REDIRECT_URL,
this);
connect(m_nam, SIGNAL(tokenReceived(QString)),
this, SLOT(tokenReceived(QString)));
m_view->page()->setNetworkAccessManager(m_nam);
centralWidget()->setLayout(layout);
Q_EMIT(created());
}
static QGraphicsLayout* createLayouts(int whichLayout)
{
QSizeF min(0, 10);
QSizeF pref(50, 10);
QSizeF max(100, 10);
QGraphicsWidget *a = createItem(min, pref, max, "a");
QGraphicsWidget *b = createItem(min, pref, max, "b");
QGraphicsWidget *c = createItem(min, pref, max, "c");
QGraphicsWidget *d = createItem(min, pref, max, "d");
QGraphicsLayout *l;
if (whichLayout == 0) {
l = new QGraphicsLinearLayout;
QGraphicsLinearLayout *linear = static_cast<QGraphicsLinearLayout *>(l);
linear->setContentsMargins(0, 0, 0, 0);
linear->addItem(a);
linear->addItem(b);
linear->addItem(c);
linear->addItem(d);
} else {
l = new QGraphicsAnchorLayout;
QGraphicsAnchorLayout *anchor = static_cast<QGraphicsAnchorLayout *>(l);
anchor->setContentsMargins(0, 0, 0, 0);
// Horizontal
setAnchor(anchor, anchor, Qt::AnchorLeft, a, Qt::AnchorLeft, 0);
setAnchor(anchor, a, Qt::AnchorRight, b, Qt::AnchorLeft, 0);
setAnchor(anchor, b, Qt::AnchorRight, c, Qt::AnchorLeft, 0);
setAnchor(anchor, c, Qt::AnchorRight, d, Qt::AnchorLeft, 0);
setAnchor(anchor, d, Qt::AnchorRight, anchor, Qt::AnchorRight, 0);
// Vertical
anchor->addAnchors(anchor, a, Qt::Vertical);
anchor->addAnchors(anchor, b, Qt::Vertical);
anchor->addAnchors(anchor, c, Qt::Vertical);
anchor->addAnchors(anchor, d, Qt::Vertical);
}
return l;
}
void MainPage::createContent(void)
{
m_bluez->start();
MApplicationPage::createContent();
setStyleName("CommonApplicationPage");
setPannable(false);
createObjectMenuActions();
createActions();
QGraphicsAnchorLayout *layout = new QGraphicsAnchorLayout();
layout->setContentsMargins(0, 0, 0, 0);
ViewHeader *header = new ViewHeader(tr("Stored tags"));
layout->addCornerAnchors(header, Qt::TopLeftCorner,
layout, Qt::TopLeftCorner);
LabelOrList *list = new LabelOrList(TagStorage::storage(),
_getTagListCellCreator,
tr("You don't have any "
"stored tags currently. "
"Create some or harvest "
"existing ones by touching "
"them."),
false,
false);
list->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
layout->addCornerAnchors(list, Qt::TopLeftCorner,
header, Qt::BottomLeftCorner);
layout->addCornerAnchors(list, Qt::BottomRightCorner,
layout, Qt::BottomRightCorner);
connect(list, SIGNAL(itemClicked(const QModelIndex &)),
this, SLOT(tagSelected(const QModelIndex &)));
connect(list, SIGNAL(itemLongTapped(const QModelIndex &,
const QPointF &)),
this, SLOT(tagLongSelected(const QModelIndex &,
const QPointF &)));
centralWidget()->setLayout(layout);
}
void StatusIndicatorMenuDropDownView::applyStyle()
{
MSceneWindowView::applyStyle();
if (pannableViewport == NULL) {
QGraphicsAnchorLayout *backgroundLayout = new QGraphicsAnchorLayout;
backgroundLayout->setContentsMargins(0, 0, 0, 0);
backgroundLayout->setSpacing(0);
backgroundLayout->addCornerAnchors(backgroundWidget, Qt::TopLeftCorner, backgroundLayout, Qt::TopLeftCorner);
backgroundLayout->setMaximumHeight(0);
// Put all the stuff into the scene window layout
pannableViewport = createPannableArea();
topRowWidget = createTopRow();
QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(Qt::Vertical);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
layout->addItem(topRowWidget);
layout->addItem(backgroundLayout);
layout->addItem(pannableViewport);
controller->setLayout(layout);
}
}
void tst_QGraphicsAnchorLayout::hard_complex()
{
QFETCH(int, whichSizeHint);
// Test for "hard" complex case, taken from wiki
// https://cwiki.nokia.com/S60QTUI/AnchorLayoutComplexCases
QSizeF min(0, 10);
QSizeF pref(50, 10);
QSizeF max(100, 10);
QGraphicsWidget *a = createItem(min, pref, max, "a");
QGraphicsWidget *b = createItem(min, pref, max, "b");
QGraphicsWidget *c = createItem(min, pref, max, "c");
QGraphicsWidget *d = createItem(min, pref, max, "d");
QGraphicsWidget *e = createItem(min, pref, max, "e");
QGraphicsWidget *f = createItem(min, pref, max, "f");
QGraphicsWidget *g = createItem(min, pref, max, "g");
QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
l->setContentsMargins(0, 0, 0, 0);
//<!-- Trunk -->
setAnchor(l, l, Qt::AnchorLeft, a, Qt::AnchorLeft, 10);
setAnchor(l, a, Qt::AnchorRight, b, Qt::AnchorLeft, 10);
setAnchor(l, b, Qt::AnchorRight, c, Qt::AnchorLeft, 10);
setAnchor(l, c, Qt::AnchorRight, d, Qt::AnchorLeft, 10);
setAnchor(l, d, Qt::AnchorRight, l, Qt::AnchorRight, 10);
//<!-- Above trunk -->
setAnchor(l, b, Qt::AnchorLeft, e, Qt::AnchorLeft, 10);
setAnchor(l, e, Qt::AnchorRight, d, Qt::AnchorLeft, 10);
//<!-- Below trunk -->
setAnchor(l, a, Qt::AnchorHorizontalCenter, g, Qt::AnchorLeft, 10);
setAnchor(l, g, Qt::AnchorRight, f, Qt::AnchorHorizontalCenter, 10);
setAnchor(l, c, Qt::AnchorLeft, f, Qt::AnchorLeft, 10);
setAnchor(l, f, Qt::AnchorRight, d, Qt::AnchorRight, 10);
//<!-- vertical is simpler -->
setAnchor(l, l, Qt::AnchorTop, e, Qt::AnchorTop, 0);
setAnchor(l, e, Qt::AnchorBottom, a, Qt::AnchorTop, 0);
setAnchor(l, e, Qt::AnchorBottom, b, Qt::AnchorTop, 0);
setAnchor(l, e, Qt::AnchorBottom, c, Qt::AnchorTop, 0);
setAnchor(l, e, Qt::AnchorBottom, d, Qt::AnchorTop, 0);
setAnchor(l, a, Qt::AnchorBottom, f, Qt::AnchorTop, 0);
setAnchor(l, a, Qt::AnchorBottom, b, Qt::AnchorBottom, 0);
setAnchor(l, a, Qt::AnchorBottom, c, Qt::AnchorBottom, 0);
setAnchor(l, a, Qt::AnchorBottom, d, Qt::AnchorBottom, 0);
setAnchor(l, f, Qt::AnchorBottom, g, Qt::AnchorTop, 0);
setAnchor(l, g, Qt::AnchorBottom, l, Qt::AnchorBottom, 0);
// It won't query the size hint if it already has a size set.
// If only one of the sizes is unset it will query sizeHint only of for that hint type.
l->setMinimumSize(60,40);
l->setPreferredSize(220,40);
l->setMaximumSize(240,40);
switch (whichSizeHint) {
case Qt::MinimumSize:
l->setMinimumSize(-1, -1);
break;
case Qt::PreferredSize:
l->setPreferredSize(-1, -1);
break;
case Qt::MaximumSize:
l->setMaximumSize(-1, -1);
break;
default:
break;
}
QSizeF sizeHint;
// warm up instruction cache
l->invalidate();
sizeHint = l->effectiveSizeHint((Qt::SizeHint)whichSizeHint);
// ...then measure...
QBENCHMARK {
l->invalidate();
sizeHint = l->effectiveSizeHint((Qt::SizeHint)whichSizeHint);
}
}
void CreateEditPage::createContent(void)
{
MApplicationPage::createContent();
setStyleName("CommonApplicationPage");
setPannable(false);
createActions();
QGraphicsAnchorLayout *anchor = new QGraphicsAnchorLayout();
anchor->setContentsMargins(0, 0, 0, 0);
anchor->setSizePolicy(QSizePolicy::Minimum,
QSizePolicy::Minimum);
ViewHeader *header =
new ViewHeader(m_tag == TagStorage::NULL_TAG
? tr("Create tag contents")
: tr("Edit tag contents"));
anchor->addCornerAnchors(header, Qt::TopLeftCorner,
anchor, Qt::TopLeftCorner);
#ifdef LABEL_SIZE
m_size = new MLabel();
m_size->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
m_size->setAlignment(Qt::AlignRight);
anchor->addAnchor(m_size, Qt::AnchorBottom, anchor, Qt::AnchorBottom);
anchor->addAnchor(m_size, Qt::AnchorRight, anchor, Qt::AnchorRight);
#endif
MWidget *layoutContainer = new MWidget();
layoutContainer->setSizePolicy(QSizePolicy::Preferred,
QSizePolicy::Minimum);
m_layout = new QGraphicsLinearLayout(Qt::Vertical, layoutContainer);
m_layout->setSizePolicy(QSizePolicy::Preferred,
QSizePolicy::Minimum);
m_name = new LabeledTextEdit(tr("Ok"),
LabeledTextEdit::SingleLineEditAndLabel);
m_name->setLabel(tr("Tag name"));
m_name->setPrompt(tr("Enter tag name"));
m_name->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
m_layout->addItem(m_name);
m_layout->setAlignment(m_name, Qt::AlignLeft);
connect(m_name, SIGNAL(contentsChanged(void)),
this, SLOT(nameChanged(void)));
MSeparator *sep = new MSeparator;
sep->setStyleName("CommonHorizontalSeparator");
sep->setOrientation(Qt::Horizontal);
layout()->addItem(sep);
createPageSpecificContent();
MPannableViewport *view = new MPannableViewport();
view->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum);
view->setPanDirection(Qt::Vertical);
view->setMinimumSize(100, 100);
view->setWidget(layoutContainer);
anchor->addAnchor(view, Qt::AnchorTop, header, Qt::AnchorBottom);
#ifdef LABEL_SIZE
anchor->addAnchor(view, Qt::AnchorBottom, m_size, Qt::AnchorTop);
#else
anchor->addAnchor(view, Qt::AnchorBottom, anchor, Qt::AnchorBottom);
#endif
anchor->addAnchor(view, Qt::AnchorLeft, anchor, Qt::AnchorLeft);
anchor->addAnchor(view, Qt::AnchorRight, anchor, Qt::AnchorRight);
centralWidget()->setLayout(anchor);
if (m_tag == TagStorage::NULL_TAG) {
setContentValidity(false);
setNameValidity(false);
setupNewData();
} else {
load();
}
}
void StelMainView::init(QSettings* conf)
{
gui = new StelGui();
#if STEL_USE_NEW_OPENGL_WIDGETS
//glWidget->initializeGL(); // protected...
//Q_ASSERT(glWidget->isValid());
#else
Q_ASSERT(glWidget->isValid());
glWidget->makeCurrent();
#endif
// Should be check of requirements disabled?
if (conf->value("main/check_requirements", true).toBool())
{
// Find out lots of debug info about supported version of OpenGL and vendor/renderer.
processOpenGLdiagnosticsAndWarnings(conf, glWidget);
}
stelApp= new StelApp();
stelApp->setGui(gui);
stelApp->init(conf);
StelActionMgr *actionMgr = stelApp->getStelActionManager();
actionMgr->addAction("actionSave_Screenshot_Global", N_("Miscellaneous"), N_("Save screenshot"), this, "saveScreenShot()", "Ctrl+S");
actionMgr->addAction("actionSet_Full_Screen_Global", N_("Display Options"), N_("Full-screen mode"), this, "fullScreen", "F11");
StelPainter::initGLShaders();
skyItem = new StelSkyItem();
guiItem = new StelGuiItem();
QGraphicsAnchorLayout* l = new QGraphicsAnchorLayout(rootItem);
l->setSpacing(0);
l->setContentsMargins(0,0,0,0);
l->addCornerAnchors(skyItem, Qt::TopLeftCorner, l, Qt::TopLeftCorner);
l->addCornerAnchors(skyItem, Qt::BottomRightCorner, l, Qt::BottomRightCorner);
l->addCornerAnchors(guiItem, Qt::BottomLeftCorner, l, Qt::BottomLeftCorner);
l->addCornerAnchors(guiItem, Qt::TopRightCorner, l, Qt::TopRightCorner);
rootItem->setLayout(l);
scene()->addItem(rootItem);
nightModeEffect = new NightModeGraphicsEffect(this);
updateNightModeProperty();
rootItem->setGraphicsEffect(nightModeEffect);
QSize size = glWidget->windowHandle()->screen()->size();
size = QSize(conf->value("video/screen_w", size.width()).toInt(),
conf->value("video/screen_h", size.height()).toInt());
bool fullscreen = conf->value("video/fullscreen", true).toBool();
// Without this, the screen is not shown on a Mac + we should use resize() for correct work of fullscreen/windowed mode switch. --AW WTF???
resize(size);
QDesktopWidget *desktop = QApplication::desktop();
int screen = conf->value("video/screen_number", 0).toInt();
if (screen < 0 || screen >= desktop->screenCount())
{
qWarning() << "WARNING: screen" << screen << "not found";
screen = 0;
}
QRect screenGeom = desktop->screenGeometry(screen);
if (fullscreen)
{
// The "+1" below is to work around Linux/Gnome problem with mouse focus.
move(screenGeom.x()+1, screenGeom.y()+1);
// The fullscreen window appears on screen where is the majority of
// the normal window. Therefore we crop the normal window to the
// screen area to ensure that the majority is not on another screen.
setGeometry(geometry() & screenGeom);
setFullScreen(true);
}
else
{
setFullScreen(false);
int x = conf->value("video/screen_x", 0).toInt();
int y = conf->value("video/screen_y", 0).toInt();
move(x + screenGeom.x(), y + screenGeom.y());
}
flagInvertScreenShotColors = conf->value("main/invert_screenshots_colors", false).toBool();
setFlagCursorTimeout(conf->value("gui/flag_mouse_cursor_timeout", false).toBool());
setCursorTimeout(conf->value("gui/mouse_cursor_timeout", 10.f).toFloat());
maxfps = conf->value("video/maximum_fps",10000.f).toFloat();
minfps = conf->value("video/minimum_fps",10000.f).toFloat();
flagMaxFpsUpdatePending = false;
// XXX: This should be done in StelApp::init(), unfortunately for the moment we need init the gui before the
// plugins, because the gui create the QActions needed by some plugins.
StelApp::getInstance().initPlugIns();
// activate DE430/431
StelApp::getInstance().getCore()->initEphemeridesFunctions();
// The script manager can only be fully initialized after the plugins have loaded.
StelApp::getInstance().initScriptMgr();
// Set the global stylesheet, this is only useful for the tooltips.
StelGui* gui = dynamic_cast<StelGui*>(StelApp::getInstance().getGui());
if (gui!=NULL)
setStyleSheet(gui->getStelStyle().qtStyleSheet);
connect(&StelApp::getInstance(), SIGNAL(visionNightModeChanged(bool)), this, SLOT(updateNightModeProperty()));
QThread::currentThread()->setPriority(QThread::HighestPriority);
startMainLoop();
}
