qquickscreen.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include <QtQuick/private/qquickscreen_p.h>
#include <QtQuick/qquickwindow.h>
 
#include <QtQuick/private/qquickitem_p.h>
 
#include <QtGui/qguiapplication.h>
#include <QtGui/qscreen.h>
 
QT_BEGIN_NAMESPACE
 
QQuickScreenInfo::QQuickScreenInfo(QObject *parent, QScreen *wrappedScreen)
    : QObject(parent)
    , m_screen(wrappedScreen)
{
}
 
QString QQuickScreenInfo::name() const
{
    if (!m_screen)
        return QString();
    return m_screen->name();
}
 
QString QQuickScreenInfo::manufacturer() const
{
    if (!m_screen)
        return QString();
    return m_screen->manufacturer();
}
 
QString QQuickScreenInfo::model() const
{
    if (!m_screen)
        return QString();
    return m_screen->model();
}
 
QString QQuickScreenInfo::serialNumber() const
{
    if (!m_screen)
        return QString();
    return m_screen->serialNumber();
}
 
int QQuickScreenInfo::width() const
{
    if (!m_screen)
        return 0;
    return m_screen->size().width();
}
 
int QQuickScreenInfo::height() const
{
    if (!m_screen)
        return 0;
    return m_screen->size().height();
}
 
int QQuickScreenInfo::desktopAvailableWidth() const
{
    if (!m_screen)
        return 0;
    return m_screen->availableVirtualSize().width();
}
 
int QQuickScreenInfo::desktopAvailableHeight() const
{
    if (!m_screen)
        return 0;
    return m_screen->availableVirtualSize().height();
}
 
qreal QQuickScreenInfo::logicalPixelDensity() const
{
    if (!m_screen)
        return 0.0;
    return m_screen->logicalDotsPerInch() / 25.4;
}
 
qreal QQuickScreenInfo::pixelDensity() const
{
    if (!m_screen)
        return 0.0;
    return m_screen->physicalDotsPerInch() / 25.4;
}
 
qreal QQuickScreenInfo::devicePixelRatio() const
{
    if (!m_screen)
        return 1.0;
    return m_screen->devicePixelRatio();
}
 
Qt::ScreenOrientation QQuickScreenInfo::primaryOrientation() const
{
    if (!m_screen)
        return Qt::PrimaryOrientation;
    return m_screen->primaryOrientation();
}
 
Qt::ScreenOrientation QQuickScreenInfo::orientation() const
{
    if (!m_screen)
        return Qt::PrimaryOrientation;
    return m_screen->orientation();
}
 
int QQuickScreenInfo::virtualX() const
{
    if (!m_screen)
        return 0;
    return m_screen->geometry().topLeft().x();
}
 
int QQuickScreenInfo::virtualY() const
{
    if (!m_screen)
        return 0;
    return m_screen->geometry().topLeft().y();
}
 
void QQuickScreenInfo::setWrappedScreen(QScreen *screen)
{
    if (screen == m_screen)
        return;
 
    QScreen *oldScreen = m_screen;
    m_screen = screen;
 
    if (oldScreen)
        oldScreen->disconnect(this);
 
    if (!screen) //Don't bother emitting signals, because the new values are garbage anyways
        return;
 
    if (!oldScreen || screen->geometry() != oldScreen->geometry()) {
        emit virtualXChanged();
        emit virtualYChanged();
    }
    if (!oldScreen || screen->size() != oldScreen->size()) {
        emit widthChanged();
        emit heightChanged();
    }
    if (!oldScreen || screen->name() != oldScreen->name())
        emit nameChanged();
    if (!oldScreen || screen->manufacturer() != oldScreen->manufacturer())
        emit manufacturerChanged();
    if (!oldScreen || screen->model() != oldScreen->model())
        emit modelChanged();
    if (!oldScreen || screen->serialNumber() != oldScreen->serialNumber())
        emit serialNumberChanged();
    if (!oldScreen || screen->orientation() != oldScreen->orientation())
        emit orientationChanged();
    if (!oldScreen || screen->primaryOrientation() != oldScreen->primaryOrientation())
        emit primaryOrientationChanged();
    if (!oldScreen || screen->availableVirtualGeometry() != oldScreen->availableVirtualGeometry())
        emit desktopGeometryChanged();
    if (!oldScreen || screen->logicalDotsPerInch() != oldScreen->logicalDotsPerInch())
        emit logicalPixelDensityChanged();
    if (!oldScreen || screen->physicalDotsPerInch() != oldScreen->physicalDotsPerInch())
        emit pixelDensityChanged();
    if (!oldScreen || screen->devicePixelRatio() != oldScreen->devicePixelRatio())
        emit devicePixelRatioChanged();
 
    qmlobject_connect(screen, QScreen, SIGNAL(geometryChanged(QRect)),
            this, QQuickScreenInfo, SIGNAL(widthChanged()));
    qmlobject_connect(screen, QScreen, SIGNAL(geometryChanged(QRect)),
            this, QQuickScreenInfo, SIGNAL(heightChanged()));
    qmlobject_connect(screen, QScreen, SIGNAL(geometryChanged(QRect)),
            this, QQuickScreenInfo, SIGNAL(virtualXChanged()));
    qmlobject_connect(screen, QScreen, SIGNAL(geometryChanged(QRect)),
            this, QQuickScreenInfo, SIGNAL(virtualYChanged()));
    qmlobject_connect(screen, QScreen, SIGNAL(orientationChanged(Qt::ScreenOrientation)),
            this, QQuickScreenInfo, SIGNAL(orientationChanged()));
    qmlobject_connect(screen, QScreen, SIGNAL(primaryOrientationChanged(Qt::ScreenOrientation)),
            this, QQuickScreenInfo, SIGNAL(primaryOrientationChanged()));
    qmlobject_connect(screen, QScreen, SIGNAL(virtualGeometryChanged(QRect)),
            this, QQuickScreenInfo, SIGNAL(desktopGeometryChanged()));
    qmlobject_connect(screen, QScreen, SIGNAL(logicalDotsPerInchChanged(qreal)),
            this, QQuickScreenInfo, SIGNAL(logicalPixelDensityChanged()));
    qmlobject_connect(screen, QScreen, SIGNAL(physicalDotsPerInchChanged(qreal)),
            this, QQuickScreenInfo, SIGNAL(pixelDensityChanged()));
}
 
QScreen *QQuickScreenInfo::wrappedScreen() const
{
    return m_screen;
}
 
QQuickScreenAttached::QQuickScreenAttached(QObject* attachee)
    : QQuickScreenInfo(attachee)
{
    m_attachee = qobject_cast<QQuickItem*>(attachee);
 
    if (m_attachee) {
        QQuickItemPrivate::get(m_attachee)->extra.value().screenAttached = this;
 
        if (m_attachee->window()) //It might not be assigned to a window yet
            windowChanged(m_attachee->window());
    } else {
        QQuickWindow *window = qobject_cast<QQuickWindow*>(attachee);
        if (window)
            windowChanged(window);
    }
 
    if (!m_screen)
        screenChanged(QGuiApplication::primaryScreen());
}
 
int QQuickScreenAttached::angleBetween(int a, int b)
{
    if (!m_screen)
        return Qt::PrimaryOrientation;
    return m_screen->angleBetween((Qt::ScreenOrientation)a,(Qt::ScreenOrientation)b);
}
 
void QQuickScreenAttached::windowChanged(QQuickWindow* c)
{
    if (m_window)
        qmlobject_disconnect(m_window, QQuickWindow, SIGNAL(screenChanged(QScreen*)), this, QQuickScreenAttached, SLOT(screenChanged(QScreen*)));
    m_window = c;
    screenChanged(c ? c->screen() : nullptr);
    if (c)
        qmlobject_connect(c, QQuickWindow, SIGNAL(screenChanged(QScreen*)), this, QQuickScreenAttached, SLOT(screenChanged(QScreen*)));
}
 
void QQuickScreenAttached::screenChanged(QScreen *screen)
{
    //qDebug() << "QQuickScreenAttached::screenChanged" << (screen ? screen->name() : QString::fromLatin1("null"));
    if (screen != m_screen)
        setWrappedScreen(screen);
}
 
QT_END_NAMESPACE
 
#include "moc_qquickscreen_p.cpp"