QEglFSIntegration::QEglFSIntegration()
: mSfc(NULL)
, mEventDispatcher(createUnixEventDispatcher())
, mFontDb(new QGenericUnixFontDatabase())
{
mSfc = new SurfaceFlingerContext();
EGLint major, minor;
if (!eglBindAPI(EGL_OPENGL_ES_API)) {
qWarning("Could not bind GL_ES API\n");
qFatal("EGL error");
}
mDisplay = eglGetDisplay(mSfc->platformDisplay());
if (mDisplay == EGL_NO_DISPLAY) {
qWarning("Could not open egl display\n");
qFatal("EGL error");
}
if (!eglInitialize(mDisplay, &major, &minor)) {
qWarning("Could not initialize egl display\n");
qFatal("EGL error");
}
mScreen = new QEglFSScreen(mSfc, mDisplay);
screenAdded(mScreen);
mInputContext = QPlatformInputContextFactory::create();
}
QNitpickerIntegration::QNitpickerIntegration()
: _nitpicker_screen(new QNitpickerScreen()),
_event_dispatcher(createUnixEventDispatcher())
{
QGuiApplicationPrivate::instance()->setEventDispatcher(_event_dispatcher);
screenAdded(_nitpicker_screen);
}
void FakeScreenBackend::acquireConfiguration()
{
Q_FOREACH (ScreenOutput *output, m_config->outputs())
screenAdded(output);
Q_EMIT configurationAcquired();
}
QEglFSIntegration::QEglFSIntegration()
: mHwc(NULL)
, mEventDispatcher(createUnixEventDispatcher())
, mFontDb(new QGenericUnixFontDatabase())
{
#if QT_VERSION < QT_VERSION_CHECK(5, 2, 0)
QGuiApplicationPrivate::instance()->setEventDispatcher(mEventDispatcher);
#endif
mHwc = new HwComposerContext();
EGLint major, minor;
if (!eglBindAPI(EGL_OPENGL_ES_API)) {
qWarning("Could not bind GL_ES API\n");
qFatal("EGL error");
}
mDisplay = eglGetDisplay(mHwc->platformDisplay());
if (mDisplay == EGL_NO_DISPLAY) {
qWarning("Could not open egl display\n");
qFatal("EGL error");
}
if (!eglInitialize(mDisplay, &major, &minor)) {
qWarning("Could not initialize egl display\n");
qFatal("EGL error");
}
mScreen = new QEglFSScreen(mHwc, mDisplay);
screenAdded(mScreen);
mInputContext = QPlatformInputContextFactory::create();
}
QWindowsIntegration::QWindowsIntegration() :
d(new QWindowsIntegrationPrivate)
{
QGuiApplicationPrivate::instance()->setEventDispatcher(d->m_eventDispatcher);
d->m_clipboard.registerViewer();
foreach (QPlatformScreen *pscr, QWindowsScreen::screens())
screenAdded(pscr);
}
QHaikuIntegration::QHaikuIntegration(const QStringList ¶meters, int &argc, char **argv)
: QPlatformIntegration()
, m_clipboard(0)
, m_drag(new QSimpleDrag())
, m_services(new QHaikuServices)
{
m_fontDatabase.reset(new QHaikuPlatformFontDatabase());
screenAdded(new QHaikuScreen);
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QList<QScreen *> screens = QGuiApplication::screens();
foreach (QScreen *screen, screens)
screenAdded(screen);
QObject::connect((const QGuiApplication*)QGuiApplication::instance(), &QGuiApplication::screenAdded, &screenAdded);
return a.exec();
}
QMinimal_i2cIntegration::QMinimal_i2cIntegration(const QStringList &)
: m_fontDb(new QGenericUnixFontDatabase()) {
if (qEnvironmentVariableIsSet(debugBackingStoreEnvironmentVariable)
&& qgetenv(debugBackingStoreEnvironmentVariable).toInt() > 0) {
m_options |= DebugBackingStore;
}
mPrimaryScreen = new QMinimal_i2cScreen();
screenAdded(mPrimaryScreen);
}
QT_BEGIN_NAMESPACE
QMinimalEglIntegration::QMinimalEglIntegration()
: mFontDb(new QGenericUnixFontDatabase()), mScreen(new QMinimalEglScreen(EGL_DEFAULT_DISPLAY))
{
screenAdded(mScreen);
#ifdef QEGL_EXTRA_DEBUG
qWarning("QMinimalEglIntegration\n");
#endif
}
void QLinuxFbIntegration::initialize()
{
if (m_primaryScreen->initialize())
screenAdded(m_primaryScreen);
else
qWarning("linuxfb: Failed to initialize screen");
m_inputContext = QPlatformInputContextFactory::create();
m_nativeInterface.reset(new QPlatformNativeInterface);
m_vtHandler.reset(new QFbVtHandler);
}
QT_BEGIN_NAMESPACE
HeadlessIntegration::HeadlessIntegration(const QStringList ¶meters)
{
Q_UNUSED(parameters);
HeadlessScreen *mPrimaryScreen = new HeadlessScreen();
mPrimaryScreen->mGeometry = QRect(0, 0, 240, 320);
mPrimaryScreen->mDepth = 32;
mPrimaryScreen->mFormat = QImage::Format_ARGB32_Premultiplied;
screenAdded(mPrimaryScreen);
m_fontDatabase.reset(new QFontconfigDatabase());
}
void QBsdFbIntegration::initialize()
{
if (m_primaryScreen->initialize())
screenAdded(m_primaryScreen.data());
else
qWarning("bsdfb: Failed to initialize screen");
m_inputContext.reset(QPlatformInputContextFactory::create());
m_nativeInterface.reset(new QPlatformNativeInterface);
m_vtHandler.reset(new QFbVtHandler);
if (!qEnvironmentVariableIntValue("QT_QPA_FB_DISABLE_INPUT"))
createInputHandlers();
}
void QQnxIntegration::createDisplay(screen_display_t display, bool isPrimary)
{
QQnxScreen *screen = new QQnxScreen(m_screenContext, display, isPrimary);
m_screens.append(screen);
screenAdded(screen);
QObject::connect(m_screenEventHandler, SIGNAL(newWindowCreated(void*)),
screen, SLOT(newWindowCreated(void*)));
QObject::connect(m_screenEventHandler, SIGNAL(windowClosed(void*)),
screen, SLOT(windowClosed(void*)));
QObject::connect(m_navigatorEventHandler, SIGNAL(rotationChanged(int)), screen, SLOT(setRotation(int)));
QObject::connect(m_navigatorEventHandler, SIGNAL(windowGroupActivated(QByteArray)), screen, SLOT(activateWindowGroup(QByteArray)));
QObject::connect(m_navigatorEventHandler, SIGNAL(windowGroupDeactivated(QByteArray)), screen, SLOT(deactivateWindowGroup(QByteArray)));
}
QT_BEGIN_NAMESPACE
QEglFSIntegration::QEglFSIntegration()
: mEventDispatcher(createUnixEventDispatcher()), mFontDb(new QGenericUnixFontDatabase())
{
QGuiApplicationPrivate::instance()->setEventDispatcher(mEventDispatcher);
#if !defined(QT_NO_EVDEV) && (!defined(Q_OS_ANDROID) || defined(Q_OS_ANDROID_NO_SDK))
new QEvdevKeyboardManager(QLatin1String("EvdevKeyboard"), QString() /* spec */, this);
new QEvdevMouseManager(QLatin1String("EvdevMouse"), QString() /* spec */, this);
new QEvdevTouchScreenHandlerThread(QString() /* spec */, this);
#endif
QEglFSHooks::hooks()->platformInit();
EGLint major, minor;
if (!eglBindAPI(EGL_OPENGL_ES_API)) {
qWarning("Could not bind GL_ES API\n");
qFatal("EGL error");
}
mDisplay = eglGetDisplay(QEglFSHooks::hooks() ? QEglFSHooks::hooks()->platformDisplay() : EGL_DEFAULT_DISPLAY);
if (mDisplay == EGL_NO_DISPLAY) {
qWarning("Could not open egl display\n");
qFatal("EGL error");
}
if (!eglInitialize(mDisplay, &major, &minor)) {
qWarning("Could not initialize egl display\n");
qFatal("EGL error");
}
int swapInterval = 1;
QByteArray swapIntervalString = qgetenv("QT_QPA_EGLFS_SWAPINTERVAL");
if (!swapIntervalString.isEmpty()) {
bool ok;
swapInterval = swapIntervalString.toInt(&ok);
if (!ok)
swapInterval = 1;
}
eglSwapInterval(mDisplay, swapInterval);
mScreen = new QEglFSScreen(mDisplay);
screenAdded(mScreen);
mInputContext = QPlatformInputContextFactory::create();
}
QT_BEGIN_NAMESPACE
QFreeRdpIntegration::QFreeRdpIntegration(const QStringList& paramList)
: mFontDb(new QGenericUnixFontDatabase())
, mEventDispatcher(createUnixEventDispatcher())
{
QGuiApplicationPrivate::instance()->setEventDispatcher(mEventDispatcher);
//Disable desktop settings for now (or themes crash)
QGuiApplicationPrivate::obey_desktop_settings = false;
mPlatform = new QFreeRdpPlatform(paramList, mEventDispatcher);
screenAdded(mPlatform->getScreen());
mFontDb = new QGenericUnixFontDatabase();
}
QMirClientClientIntegration::QMirClientClientIntegration()
: QPlatformIntegration()
, mNativeInterface(new QMirClientNativeInterface)
, mFontDb(new QGenericUnixFontDatabase)
, mServices(new QMirClientPlatformServices)
, mClipboard(new QMirClientClipboard)
, mScaleFactor(1.0)
{
setupOptions();
setupDescription();
// Create new application instance
mInstance = u_application_instance_new_from_description_with_options(mDesc, mOptions);
if (mInstance == nullptr)
qFatal("QMirClientClientIntegration: connection to Mir server failed. Check that a Mir server is\n"
"running, and the correct socket is being used and is accessible. The shell may have\n"
"rejected the incoming connection, so check its log file");
mNativeInterface->setMirConnection(u_application_instance_get_mir_connection(mInstance));
// Create default screen.
mScreen = new QMirClientScreen(u_application_instance_get_mir_connection(mInstance));
screenAdded(mScreen);
// Initialize input.
if (qEnvironmentVariableIsEmpty("QTUBUNTU_NO_INPUT")) {
mInput = new QMirClientInput(this);
mInputContext = QPlatformInputContextFactory::create();
} else {
mInput = nullptr;
mInputContext = nullptr;
}
// compute the scale factor
const int defaultGridUnit = 8;
int gridUnit = defaultGridUnit;
QByteArray gridUnitString = qgetenv("GRID_UNIT_PX");
if (!gridUnitString.isEmpty()) {
bool ok;
gridUnit = gridUnitString.toInt(&ok);
if (!ok) {
gridUnit = defaultGridUnit;
}
}
mScaleFactor = static_cast<qreal>(gridUnit) / defaultGridUnit;
}
void QEGLPlatformIntegration::initialize()
{
m_display = eglGetDisplay(nativeDisplay());
if (m_display == EGL_NO_DISPLAY)
qFatal("Could not open egl display");
EGLint major, minor;
if (!eglInitialize(m_display, &major, &minor))
qFatal("Could not initialize egl display");
m_screen = createScreen();
screenAdded(m_screen);
m_inputContext = QPlatformInputContextFactory::create();
m_vtHandler.reset(new QFbVtHandler);
}
QMinimalIntegration::QMinimalIntegration(const QStringList ¶meters)
: m_dummyFontDatabase(0)
, m_options(parseOptions(parameters))
{
if (qEnvironmentVariableIsSet(debugBackingStoreEnvironmentVariable)
&& qgetenv(debugBackingStoreEnvironmentVariable).toInt() > 0) {
m_options |= DebugBackingStore | EnableFonts;
}
QMinimalScreen *mPrimaryScreen = new QMinimalScreen();
mPrimaryScreen->mGeometry = QRect(0, 0, 240, 320);
mPrimaryScreen->mDepth = 32;
mPrimaryScreen->mFormat = QImage::Format_ARGB32_Premultiplied;
screenAdded(mPrimaryScreen);
}
QOffscreenIntegration::QOffscreenIntegration()
{
#if defined(Q_OS_UNIX)
#if defined(Q_OS_MAC)
m_fontDatabase.reset(new QPlatformFontDatabase());
#else
m_fontDatabase.reset(new QGenericUnixFontDatabase());
#endif
#elif defined(Q_OS_WIN)
m_fontDatabase.reset(new QBasicFontDatabase());
#endif
#ifndef QT_NO_DRAGANDDROP
m_drag.reset(new QOffscreenDrag);
#endif
m_services.reset(new QPlatformServices);
screenAdded(new QOffscreenScreen);
}
QHaikuIntegration::QHaikuIntegration(const QStringList ¶meters)
: m_clipboard(new QHaikuClipboard)
{
Q_UNUSED(parameters);
const QString signature = QStringLiteral("application/x-vnd.Qt.%1").arg(QFileInfo(QCoreApplication::applicationFilePath()).fileName());
QHaikuApplication *app = new QHaikuApplication(signature.toLocal8Bit());
be_app = app;
const thread_id applicationThreadId = spawn_thread(startApplicationThread, "app_thread", 1, static_cast<void*>(app));
resume_thread(applicationThreadId);
app->UnlockLooper();
m_screen = new QHaikuScreen;
m_services = new QHaikuServices;
// notify system about available screen
screenAdded(m_screen);
}
QOffscreenIntegration::QOffscreenIntegration()
{
#if defined(Q_OS_UNIX)
m_eventDispatcher = createUnixEventDispatcher();
#if defined(Q_OS_MAC)
m_fontDatabase.reset(new QPlatformFontDatabase());
#else
m_fontDatabase.reset(new QGenericUnixFontDatabase());
#endif
#elif defined(Q_OS_WIN)
m_eventDispatcher = new QOffscreenEventDispatcher<QEventDispatcherWin32>();
m_fontDatabase.reset(new QBasicFontDatabase());
#endif
#ifndef QT_NO_DRAGANDDROP
m_drag.reset(new QOffscreenDrag);
#endif
m_services.reset(new QPlatformServices);
QGuiApplicationPrivate::instance()->setEventDispatcher(m_eventDispatcher);
screenAdded(new QOffscreenScreen);
}
HeadlessIntegration::HeadlessIntegration(const QStringList ¶meters)
{
Q_UNUSED(parameters);
HeadlessScreen *mPrimaryScreen = new HeadlessScreen();
mPrimaryScreen->mGeometry = QRect(0, 0, 240, 320);
mPrimaryScreen->mDepth = 32;
mPrimaryScreen->mFormat = QImage::Format_ARGB32_Premultiplied;
screenAdded(mPrimaryScreen);
#ifdef __APPLE__
m_fontDatabase.reset(new QCoreTextFontDatabase());
#else
m_fontDatabase.reset(new QFontconfigDatabase());
#endif
#ifdef __APPLE__
platform_services.reset(new QPlatformServices());
#else
platform_services.reset(new GenericUnixServices());
#endif
}
QT_USE_NAMESPACE
QWaylandIntegration::QWaylandIntegration()
: mFontDb(new QGenericUnixFontDatabase())
, mEventDispatcher(createUnixEventDispatcher())
, mNativeInterface(new QWaylandNativeInterface(this))
#ifndef QT_NO_ACCESSIBILITY
, mAccessibility(new QPlatformAccessibility())
#else
, mAccessibility(0)
#endif
{
QGuiApplicationPrivate::instance()->setEventDispatcher(mEventDispatcher);
QGuiApplication::setDesktopSettingsAware(false);
mDisplay = new QWaylandDisplay();
mClipboard = new QWaylandClipboard(mDisplay);
mDrag = new QWaylandDrag(mDisplay);
foreach (QPlatformScreen *screen, mDisplay->screens())
screenAdded(screen);
mInputContext = QPlatformInputContextFactory::create();
}
QT_BEGIN_NAMESPACE
QMinimalIntegration::QMinimalIntegration() :
m_fontDb(new QGenericUnixFontDatabase()),
#ifdef Q_OS_WIN
m_eventDispatcher(new QEventDispatcherWin32())
#else
m_eventDispatcher(createUnixEventDispatcher())
#endif
{
QGuiApplicationPrivate::instance()->setEventDispatcher(m_eventDispatcher);
QMinimalScreen *mPrimaryScreen = new QMinimalScreen();
mPrimaryScreen->mGeometry = QRect(0, 0, 240, 320);
mPrimaryScreen->mDepth = 32;
mPrimaryScreen->mFormat = QImage::Format_ARGB32_Premultiplied;
screenAdded(mPrimaryScreen);
}
bool QMinimalIntegration::hasCapability(QPlatformIntegration::Capability cap) const
{
switch (cap) {
case ThreadedPixmaps: return true;
case MultipleWindows: return true;
default: return QPlatformIntegration::hasCapability(cap);
}
}
QPlatformWindow *QMinimalIntegration::createPlatformWindow(QWindow *window) const
{
Q_UNUSED(window);
QPlatformWindow *w = new QPlatformWindow(window);
w->requestActivateWindow();
return w;
}
void QOpenWFDIntegration::addScreen(QOpenWFDScreen *screen)
{
screenAdded(screen);
}
QAndroidPlatformIntegration::QAndroidPlatformIntegration(const QStringList ¶mList)
: m_touchDevice(0)
#ifndef QT_NO_ACCESSIBILITY
, m_accessibility(0)
#endif
{
Q_UNUSED(paramList);
m_androidPlatformNativeInterface = new QAndroidPlatformNativeInterface();
m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (m_eglDisplay == EGL_NO_DISPLAY)
qFatal("Could not open egl display");
EGLint major, minor;
if (!eglInitialize(m_eglDisplay, &major, &minor))
qFatal("Could not initialize egl display");
if (!eglBindAPI(EGL_OPENGL_ES_API))
qFatal("Could not bind GL_ES API");
m_primaryScreen = new QAndroidPlatformScreen();
screenAdded(m_primaryScreen);
m_primaryScreen->setPhysicalSize(QSize(m_defaultPhysicalSizeWidth, m_defaultPhysicalSizeHeight));
m_primaryScreen->setSize(QSize(m_defaultScreenWidth, m_defaultScreenHeight));
m_primaryScreen->setAvailableGeometry(QRect(0, 0, m_defaultGeometryWidth, m_defaultGeometryHeight));
m_mainThread = QThread::currentThread();
QtAndroid::setAndroidPlatformIntegration(this);
m_androidFDB = new QAndroidPlatformFontDatabase();
m_androidPlatformServices = new QAndroidPlatformServices();
#ifndef QT_NO_CLIPBOARD
m_androidPlatformClipboard = new QAndroidPlatformClipboard();
#endif
m_androidSystemLocale = new QAndroidSystemLocale;
QJNIObjectPrivate javaActivity(QtAndroid::activity());
if (javaActivity.isValid()) {
QJNIObjectPrivate resources = javaActivity.callObjectMethod("getResources", "()Landroid/content/res/Resources;");
QJNIObjectPrivate configuration = resources.callObjectMethod("getConfiguration", "()Landroid/content/res/Configuration;");
int touchScreen = configuration.getField<jint>("touchscreen");
if (touchScreen == QJNIObjectPrivate::getStaticField<jint>("android/content/res/Configuration", "TOUCHSCREEN_FINGER")
|| touchScreen == QJNIObjectPrivate::getStaticField<jint>("android/content/res/Configuration", "TOUCHSCREEN_STYLUS"))
{
m_touchDevice = new QTouchDevice;
m_touchDevice->setType(QTouchDevice::TouchScreen);
m_touchDevice->setCapabilities(QTouchDevice::Position
| QTouchDevice::Area
| QTouchDevice::Pressure
| QTouchDevice::NormalizedPosition);
QJNIObjectPrivate pm = javaActivity.callObjectMethod("getPackageManager", "()Landroid/content/pm/PackageManager;");
Q_ASSERT(pm.isValid());
if (pm.callMethod<jboolean>("hasSystemFeature","(Ljava/lang/String;)Z",
QJNIObjectPrivate::getStaticObjectField("android/content/pm/PackageManager", "FEATURE_TOUCHSCREEN_MULTITOUCH_JAZZHAND", "Ljava/lang/String;").object())) {
m_touchDevice->setMaximumTouchPoints(10);
} else if (pm.callMethod<jboolean>("hasSystemFeature","(Ljava/lang/String;)Z",
QJNIObjectPrivate::getStaticObjectField("android/content/pm/PackageManager", "FEATURE_TOUCHSCREEN_MULTITOUCH_DISTINCT", "Ljava/lang/String;").object())) {
m_touchDevice->setMaximumTouchPoints(4);
} else if (pm.callMethod<jboolean>("hasSystemFeature","(Ljava/lang/String;)Z",
QJNIObjectPrivate::getStaticObjectField("android/content/pm/PackageManager", "FEATURE_TOUCHSCREEN_MULTITOUCH", "Ljava/lang/String;").object())) {
m_touchDevice->setMaximumTouchPoints(2);
}
QWindowSystemInterface::registerTouchDevice(m_touchDevice);
}
}
}
void EglFSIntegration::addScreen(QPlatformScreen *screen)
{
screenAdded(screen);
}
void QDirectFbIntegrationEGL::initializeScreen()
{
m_primaryScreen.reset(new QDirectFbScreenEGL(0));
screenAdded(m_primaryScreen.data());
}
void FakeScreenBackend::acquireConfiguration()
{
qCDebug(gLcFakeScreenBackend) << "Load configuration from" << m_fileName;
QFile file(m_fileName);
if (!file.open(QFile::ReadOnly)) {
qCWarning(gLcFakeScreenBackend) << "Could not open configuration file"
<< m_fileName << "for reading";
return;
}
QByteArray data = file.readAll();
file.close();
const QJsonDocument doc = QJsonDocument::fromJson(data);
if (!doc.isObject()) {
qCWarning(gLcFakeScreenBackend) << "Invalid configuration file, no top-level JSON object";
return;
}
bool primarySet = false;
const QJsonObject object = doc.object();
const QJsonArray outputs = object.value(QStringLiteral("outputs")).toArray();
for (int i = 0; i < outputs.size(); i++) {
const QVariantMap outputSettings = outputs.at(i).toObject().toVariantMap();
qCDebug(gLcFakeScreenBackend) << "Output settings:" << outputSettings;
QString name = outputSettings.value(QStringLiteral("name")).toString();
qCDebug(gLcFakeScreenBackend) << "Output name:" << name;
bool primary = outputSettings.value(QStringLiteral("primary")).toBool();
qCDebug(gLcFakeScreenBackend) << "Output primary:" << primary;
int scale = outputSettings.value(QStringLiteral("scale")).toInt();
if (scale <= 0)
scale = 1;
qCDebug(gLcFakeScreenBackend) << "Scale:" << scale;
const QVariantMap posValue = outputSettings.value(QStringLiteral("position")).toMap();
int x = posValue.value(QStringLiteral("x")).toInt();
int y = posValue.value(QStringLiteral("y")).toInt();
QPoint pos(x, y);
qCDebug(gLcFakeScreenBackend) << "Output position:" << pos;
const QVariantMap modeValue = outputSettings.value(QStringLiteral("mode")).toMap();
const QVariantMap sizeValue = modeValue.value(QStringLiteral("size")).toMap();
int w = sizeValue.value(QStringLiteral("width")).toInt();
int h = sizeValue.value(QStringLiteral("height")).toInt();
QSize size = QSize(w, h);
int refreshRate = modeValue.value(QStringLiteral("refreshRate")).toInt();
qCDebug(gLcFakeScreenBackend) << "Output size:" << size;
qCDebug(gLcFakeScreenBackend) << "Output refresh rate:" << refreshRate;
const QVariantMap physicalSizeValue = outputSettings.value(QStringLiteral("physicalSize")).toMap();
QSize physicalSize;
physicalSize.setWidth(physicalSizeValue.value(QStringLiteral("width"), -1).toInt());
physicalSize.setHeight(physicalSizeValue.value(QStringLiteral("height"), -1).toInt());
if (!physicalSize.isValid()) {
physicalSize.setWidth(qFloor(w * 0.26458));
physicalSize.setHeight(qFloor(h * 0.26458));
}
qCDebug(gLcFakeScreenBackend) << "Physical size millimiters:" << size;
Qt::ScreenOrientation orientation =
static_cast<Qt::ScreenOrientation>(outputSettings.value(QStringLiteral("orientation")).toInt());
qCDebug(gLcFakeScreenBackend) << "Output orientation:" << orientation;
Screen *screen = new Screen(this);
ScreenPrivate *screenPrivate = Screen::get(screen);
screenPrivate->m_manufacturer = QStringLiteral("Green Island");
screenPrivate->m_model = name;
if (physicalSize.isValid())
screenPrivate->setPhysicalSize(physicalSize);
screenPrivate->setPosition(pos);
screenPrivate->setSize(size);
screenPrivate->setRefreshRate(refreshRate);
screenPrivate->setScaleFactor(scale);
switch (orientation) {
case Qt::PortraitOrientation:
screenPrivate->setTransform(Screen::Transform90);
break;
case Qt::InvertedLandscapeOrientation:
screenPrivate->setTransform(Screen::Transform180);
break;
case Qt::InvertedPortraitOrientation:
screenPrivate->setTransform(Screen::Transform270);
break;
default:
break;
}
ScreenBackend::get(this)->screens.append(screen);
Q_EMIT screenAdded(screen);
if (primary) {
primarySet = true;
Q_EMIT primaryScreenChanged(screen);
}
}
// Automatically promote to primary the first screen if the configuration
// doesn't explicitely assign one
if (!primarySet)
Q_EMIT primaryScreenChanged(ScreenBackend::get(this)->screens.at(0));
}