KisAndroidScaling Class Reference

#include <KisAndroidScaling.h>

Inheritance diagram for KisAndroidScaling:

Signals
void	sigInterfaceScaleChanged ()
void	sigJniSaveInterfaceScale (bool askOnStartup)
void	sigJniScalingDialogActive (bool active)
void	sigJniSetPrimaryScreenScale (qreal scale)

Public Member Functions
bool	isSupported () const
	KisAndroidScaling (KisConfig &cfg, KisApplication *app)
void	showDialog ()

Static Public Member Functions
static KisAndroidScaling *	instance ()

Private Slots
void	slotJniSaveInterfaceScale (bool askOnStartup)
void	slotJniScalingDialogActive (bool active)
void	slotJniSetPrimaryScreenScale (qreal scale)
void	slotSplashDialogDismissed ()

Private Member Functions
qreal	getValidInitialScale (KisConfig &cfg) const
void	maybeShowDialog (bool startup)
void	setPrimaryScreenScale (qreal scale)

Static Private Member Functions
static bool	isHighDpiScalingEnabled ()

Private Attributes
QPointer< QScreen >	m_initialPrimaryScreen
qreal	m_initialPrimaryScreenDevicePixelRatio = 0.0
bool	m_scalingDialogActive = false

Detailed Description

Definition at line 16 of file KisAndroidScaling.h.

Constructor & Destructor Documentation

KisAndroidScaling()

KisAndroidScaling::KisAndroidScaling ( KisConfig & cfg, KisApplication * app )

explicit

Definition at line 22 of file KisAndroidScaling.cpp.

    : QObject(app)
{
    KIS_ASSERT(app);
 
    if (isHighDpiScalingEnabled()) {
        QScreen *screen = QGuiApplication::primaryScreen();
        if (screen) {
            m_initialPrimaryScreen = screen;
            m_initialPrimaryScreenDevicePixelRatio = screen->devicePixelRatio();
        }
    }
 
    qreal scale = getValidInitialScale(cfg);
    if (scale >= 1.0) {
        setPrimaryScreenScale(scale);
    } else {
        // Reset the configuration, it wasn't valid or the screen changed.
        cfg.setAndroidScalingLastInitialScale(cfg.androidScalingLastInitialScale(true));
        cfg.setAndroidScalingTargetScale(cfg.androidScalingTargetScale(true));
        cfg.setAndroidScalingAskOnStartup(cfg.androidScalingAskOnStartup(true));
    }
 
    // Queued connections are used in the following to make sure they run on
    // the main thread. The signals may come from the Android UI thread.
    connect(this,
            &KisAndroidScaling::sigJniSetPrimaryScreenScale,
            this,
            &KisAndroidScaling::slotJniSetPrimaryScreenScale,
            Qt::QueuedConnection);
    connect(this,
            &KisAndroidScaling::sigJniSaveInterfaceScale,
            this,
            &KisAndroidScaling::slotJniSaveInterfaceScale,
            Qt::QueuedConnection);
    connect(this,
            &KisAndroidScaling::sigJniScalingDialogActive,
            this,
            &KisAndroidScaling::slotJniScalingDialogActive,
            Qt::QueuedConnection);
 
    KisAndroidDonations *androidDonations = app->androidDonations();
    KIS_SAFE_ASSERT_RECOVER_NOOP(androidDonations);
    if (androidDonations) {
        connect(androidDonations,
                &KisAndroidDonations::sigSplashDialogDismissed,
                this,
                &KisAndroidScaling::slotSplashDialogDismissed,
                Qt::QueuedConnection);
    }
}

References getValidInitialScale(), isHighDpiScalingEnabled(), KIS_ASSERT, KIS_SAFE_ASSERT_RECOVER_NOOP, m_initialPrimaryScreen, m_initialPrimaryScreenDevicePixelRatio, setPrimaryScreenScale(), sigJniSaveInterfaceScale(), sigJniScalingDialogActive(), sigJniSetPrimaryScreenScale(), KisAndroidDonations::sigSplashDialogDismissed(), slotJniSaveInterfaceScale(), slotJniScalingDialogActive(), slotJniSetPrimaryScreenScale(), and slotSplashDialogDismissed().

Member Function Documentation

getValidInitialScale()

qreal KisAndroidScaling::getValidInitialScale ( KisConfig & cfg ) const

private

Definition at line 128 of file KisAndroidScaling.cpp.

{
    if (m_initialPrimaryScreen.isNull()) {
        return 0.0;
    }
 
    // If we don't have a previous screen scale or the default screen scale
    // changed, the configuration is invalid and we fall back to the default.
    qreal lastInitialScale = cfg.androidScalingLastInitialScale();
    if (lastInitialScale < 1.0 || !qFuzzyCompare(lastInitialScale, m_initialPrimaryScreenDevicePixelRatio)) {
        return 0.0;
    }
 
    return cfg.androidScalingTargetScale();
}

References m_initialPrimaryScreen, m_initialPrimaryScreenDevicePixelRatio, and qFuzzyCompare().

instance()

KisAndroidScaling * KisAndroidScaling::instance ( )

static

Definition at line 74 of file KisAndroidScaling.cpp.

{
    KisApplication *app = qobject_cast<KisApplication *>(KisApplication::instance());
    if (app) {
        return app->androidScaling();
    } else {
        return nullptr;
    }
}

isHighDpiScalingEnabled()

bool KisAndroidScaling::isHighDpiScalingEnabled ( )

staticprivate

Definition at line 114 of file KisAndroidScaling.cpp.

{
    // Detects whether we have scaling available in this session. Compare
    // with the startup handling of the scaling setting in main.cc. We do
    // *not* check the config value here, it only applies after a restart.
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    return !qEnvironmentVariableIsSet("QT_ENABLE_HIGHDPI_SCALING")
        && qgetenv("QT_ENABLE_HIGHDPI_SCALING") != QByteArrayLiteral("0");
#else
    return QCoreApplication::testAttribute(Qt::AA_EnableHighDpiScaling)
        && !QCoreApplication::testAttribute(Qt::AA_DisableHighDpiScaling);
#endif
}

isSupported()

bool KisAndroidScaling::isSupported ( ) const

inline

Definition at line 25 of file KisAndroidScaling.h.

    {
        return !m_initialPrimaryScreen.isNull();
    }

maybeShowDialog()

void KisAndroidScaling::maybeShowDialog ( bool startup )

private

Definition at line 162 of file KisAndroidScaling.cpp.

{
    // We want to see the dialog if scaling is supported, the dialog isn't
    // already up and either the user manually summoned it or they want to
    // see the dialog on startup. The user can only decide to remember the
    // scaling setting after they decided on a target scale at least once
    // before. This is to make sure that they actually used the application
    // at that scale and can make an informed decision about not wanting to
    // see the dialog again instead of despairing at choosing a wrong scale
    // and being unable to find the dialog again.
    if (m_scalingDialogActive) {
        return;
    }
 
    QScreen *screen = m_initialPrimaryScreen.data();
    if (!screen) {
        return;
    }
 
    KisConfig cfg(true);
    bool haveTargetScale = cfg.androidScalingTargetScale() >= 1.0;
    bool askOnStartup = cfg.androidScalingAskOnStartup();
    if (!startup || askOnStartup) {
        QJniObject activity = QJniObject::callStaticObjectMethod("org/qtproject/qt5/android/QtNative",
                                                                 "activity",
                                                                 "()Landroid/app/Activity;");
        KisAndroidUtils::clearJniException(QStringLiteral("getting activity in KisAndroidScalingDialog"));
 
        if (activity.isValid()) {
            activity.callMethod<void>("showScalingDialog",
                                      "(DDZZ)V",
                                      jdouble(m_initialPrimaryScreen->devicePixelRatio()),
                                      jdouble(m_initialPrimaryScreenDevicePixelRatio),
                                      jboolean(askOnStartup),
                                      jboolean(!startup || haveTargetScale));
            KisAndroidUtils::clearJniException(QStringLiteral("showing scaling dialog in KisAndroidScalingDialog"));
        }
    }
}

References KisAndroidUtils::clearJniException(), m_initialPrimaryScreen, m_initialPrimaryScreenDevicePixelRatio, and m_scalingDialogActive.

setPrimaryScreenScale()

void KisAndroidScaling::setPrimaryScreenScale ( qreal scale )

private

Definition at line 144 of file KisAndroidScaling.cpp.

{
    if (m_initialPrimaryScreenDevicePixelRatio > 0.0) {
        QScreen *screen = m_initialPrimaryScreen.data();
        if (screen) {
            QPlatformScreen *platformScreen = screen->handle();
            if (platformScreen) {
                qreal actualScale = qMax(1.0, scale);
                qreal densityAdjustment = actualScale / m_initialPrimaryScreenDevicePixelRatio;
                if (!qFuzzyCompare(densityAdjustment, platformScreen->densityAdjustment())) {
                    platformScreen->setDensityAdjustment(densityAdjustment);
                    Q_EMIT sigInterfaceScaleChanged();
                }
            }
        }
    }
}

References m_initialPrimaryScreen, m_initialPrimaryScreenDevicePixelRatio, qFuzzyCompare(), and sigInterfaceScaleChanged().

showDialog()

void KisAndroidScaling::showDialog ( )

inline

Definition at line 30 of file KisAndroidScaling.h.

    {
        maybeShowDialog(false);
    }

sigInterfaceScaleChanged

void KisAndroidScaling::sigInterfaceScaleChanged ( )

signal

sigJniSaveInterfaceScale

void KisAndroidScaling::sigJniSaveInterfaceScale ( bool askOnStartup )

signal

sigJniScalingDialogActive

void KisAndroidScaling::sigJniScalingDialogActive ( bool active )

signal

sigJniSetPrimaryScreenScale

void KisAndroidScaling::sigJniSetPrimaryScreenScale ( qreal scale )

signal

slotJniSaveInterfaceScale

void KisAndroidScaling::slotJniSaveInterfaceScale ( bool askOnStartup )

privateslot

Definition at line 96 of file KisAndroidScaling.cpp.

{
    KisConfig cfg(false);
    if (m_scalingDialogActive && m_initialPrimaryScreenDevicePixelRatio > 0.0) {
        QScreen *screen = m_initialPrimaryScreen.data();
        if (screen) {
            cfg.setAndroidScalingLastInitialScale(m_initialPrimaryScreenDevicePixelRatio);
            cfg.setAndroidScalingTargetScale(screen->devicePixelRatio());
            cfg.setAndroidScalingAskOnStartup(askOnStartup);
        }
    }
}

References m_initialPrimaryScreen, m_initialPrimaryScreenDevicePixelRatio, and m_scalingDialogActive.

slotJniScalingDialogActive

void KisAndroidScaling::slotJniScalingDialogActive ( bool active )

privateslot

Definition at line 109 of file KisAndroidScaling.cpp.

{
    m_scalingDialogActive = active;
}

References m_scalingDialogActive.

slotJniSetPrimaryScreenScale

void KisAndroidScaling::slotJniSetPrimaryScreenScale ( qreal scale )

privateslot

Definition at line 89 of file KisAndroidScaling.cpp.

{
    if (m_scalingDialogActive) {
        setPrimaryScreenScale(scale);
    }
}

References m_scalingDialogActive, and setPrimaryScreenScale().

slotSplashDialogDismissed

void KisAndroidScaling::slotSplashDialogDismissed ( )

privateslot

Definition at line 84 of file KisAndroidScaling.cpp.

{
    maybeShowDialog(true);
}

References maybeShowDialog().

Member Data Documentation

m_initialPrimaryScreen

QPointer<QScreen> KisAndroidScaling::m_initialPrimaryScreen

private

Definition at line 56 of file KisAndroidScaling.h.

m_initialPrimaryScreenDevicePixelRatio

qreal KisAndroidScaling::m_initialPrimaryScreenDevicePixelRatio = 0.0

private

Definition at line 57 of file KisAndroidScaling.h.

m_scalingDialogActive

bool KisAndroidScaling::m_scalingDialogActive = false

private

Definition at line 58 of file KisAndroidScaling.h.

---

The documentation for this class was generated from the following files:

• libs/ui/KisAndroidScaling.h
• libs/ui/KisAndroidScaling.cpp