#include <KisDlgCustomTabletResolution.h>

Inheritance diagram for KisDlgCustomTabletResolution:

Public Types
enum	Mode { USE_WINTAB = 0 , USE_VIRTUAL_SCREEN , USE_CUSTOM }

Public Member Functions
void	accept () override

	KisDlgCustomTabletResolution (QWidget *parent=nullptr)

	~KisDlgCustomTabletResolution () override

Static Public Member Functions
static void	applyConfiguration (Mode mode, const QRect &customRect)

static QRect	calcNativeScreenRect ()

static Mode	getTabletMode (QRect *customRect)

Private Attributes
Ui::KisDlgCustomTabletResolution *	ui

Detailed Description

Definition at line 17 of file KisDlgCustomTabletResolution.h.

Member Enumeration Documentation

◆ Mode

enum KisDlgCustomTabletResolution::Mode

Enumerator
USE_WINTAB
USE_VIRTUAL_SCREEN
USE_CUSTOM

Definition at line 22 of file KisDlgCustomTabletResolution.h.

              {
        USE_WINTAB = 0,
        USE_VIRTUAL_SCREEN,
        USE_CUSTOM
    };

Constructor & Destructor Documentation

◆ KisDlgCustomTabletResolution()

KisDlgCustomTabletResolution::KisDlgCustomTabletResolution ( QWidget * parent = nullptr )

explicit

Definition at line 30 of file KisDlgCustomTabletResolution.cpp.

                                                                          :
    QDialog(parent),
    ui(new Ui::KisDlgCustomTabletResolution)
{
    ui->setupUi(this);
    KGuiItem::assign(ui->btnBox->button(QDialogButtonBox::Ok), KStandardGuiItem::ok());
    KGuiItem::assign(ui->btnBox->button(QDialogButtonBox::Cancel), KStandardGuiItem::cancel());
    connect(ui->btnBox, SIGNAL(rejected()), this, SLOT(reject()));
    connect(ui->btnBox, SIGNAL(accepted()), this, SLOT(accept()));
 
    connect(ui->radioCustomMapping, SIGNAL(toggled(bool)), ui->lblXOffset, SLOT(setEnabled(bool)));
    connect(ui->radioCustomMapping, SIGNAL(toggled(bool)), ui->lblYOffset, SLOT(setEnabled(bool)));
    connect(ui->radioCustomMapping, SIGNAL(toggled(bool)), ui->lblWidth, SLOT(setEnabled(bool)));
    connect(ui->radioCustomMapping, SIGNAL(toggled(bool)), ui->lblHeight, SLOT(setEnabled(bool)));
 
    connect(ui->radioCustomMapping, SIGNAL(toggled(bool)), ui->intXOffset, SLOT(setEnabled(bool)));
    connect(ui->radioCustomMapping, SIGNAL(toggled(bool)), ui->intYOffset, SLOT(setEnabled(bool)));
    connect(ui->radioCustomMapping, SIGNAL(toggled(bool)), ui->intWidth, SLOT(setEnabled(bool)));
    connect(ui->radioCustomMapping, SIGNAL(toggled(bool)), ui->intHeight, SLOT(setEnabled(bool)));
 
    const QRect virtualScreenRect = calcNativeScreenRect();
 
    ui->radioMapToEntireScreen->setText(i18nc("@option:radio", "Map to entire virtual screen (%1)", rectToString(virtualScreenRect)));
 
    QRect nativeScreenRect;
    QPlatformScreen *screen = qGuiApp->primaryScreen()->handle();
    Q_FOREACH (QPlatformScreen *scr, screen->virtualSiblings()) {
        nativeScreenRect |= scr->geometry();
    }
 
    QRect customScreenRect = virtualScreenRect;
    Mode mode = getTabletMode(&customScreenRect);
 
    if (mode == USE_CUSTOM) {
        ui->radioCustomMapping->setChecked(true);
    } else if (mode == USE_VIRTUAL_SCREEN) {
        ui->radioMapToEntireScreen->setChecked(true);
    } else {
        ui->radioMapAsWintab->setChecked(true);
    }
 
    ui->intXOffset->setValue(customScreenRect.x());
    ui->intYOffset->setValue(customScreenRect.y());
    ui->intWidth->setValue(customScreenRect.width());
    ui->intHeight->setValue(customScreenRect.height());
}

References accept(), calcNativeScreenRect(), connect(), getTabletMode(), ui, USE_CUSTOM, and USE_VIRTUAL_SCREEN.

◆ ~KisDlgCustomTabletResolution()

KisDlgCustomTabletResolution::~KisDlgCustomTabletResolution ( )

override

Definition at line 105 of file KisDlgCustomTabletResolution.cpp.

{
    delete ui;
}

References ui.

Member Function Documentation

◆ accept()

void KisDlgCustomTabletResolution::accept ( )

override

Definition at line 77 of file KisDlgCustomTabletResolution.cpp.

{
    const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
    QSettings cfg(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
 
    if (ui->radioMapAsWintab->isChecked()) {
        cfg.setValue("wintabResolutionMode", "wintab");
    } else if (ui->radioMapToEntireScreen->isChecked()) {
        cfg.setValue("wintabResolutionMode", "virtual-screen");
    } else if (ui->radioCustomMapping->isChecked()) {
        cfg.setValue("wintabResolutionMode", "custom");
 
        cfg.setValue("wintabCustomResolutionX", ui->intXOffset->value());
        cfg.setValue("wintabCustomResolutionY", ui->intYOffset->value());
        cfg.setValue("wintabCustomResolutionWidth", ui->intWidth->value());
        cfg.setValue("wintabCustomResolutionHeight", ui->intHeight->value());
    }
 
    // apply the mode right now
    {
        QRect customTabletRect;
        const Mode tabletMode = getTabletMode(&customTabletRect);
        applyConfiguration(tabletMode, customTabletRect);
    }
 
    QDialog::accept();
}

References applyConfiguration(), getTabletMode(), and ui.

◆ applyConfiguration()

void KisDlgCustomTabletResolution::applyConfiguration	(	KisDlgCustomTabletResolution::Mode	tabletMode,
		const QRect &	customRect )

static

Definition at line 146 of file KisDlgCustomTabletResolution.cpp.

{
    if (tabletMode == KisDlgCustomTabletResolution::USE_CUSTOM) {
        qputenv("QT_WINTAB_DESKTOP_RECT",
                QString("%1;%2;%3;%4")
                .arg(customTabletRect.x())
                .arg(customTabletRect.y())
                .arg(customTabletRect.width())
                .arg(customTabletRect.height()).toLatin1());
        qunsetenv("QT_IGNORE_WINTAB_MAPPING");
    } else if (tabletMode == KisDlgCustomTabletResolution::USE_VIRTUAL_SCREEN) {
        qputenv("QT_IGNORE_WINTAB_MAPPING", "1");
        qunsetenv("QT_WINTAB_DESKTOP_RECT");
    } else {
        qunsetenv("QT_WINTAB_DESKTOP_RECT");
        qunsetenv("QT_IGNORE_WINTAB_MAPPING");
    }
}

References USE_CUSTOM, and USE_VIRTUAL_SCREEN.

◆ calcNativeScreenRect()

QRect KisDlgCustomTabletResolution::calcNativeScreenRect ( )

static

Definition at line 110 of file KisDlgCustomTabletResolution.cpp.

{
    QRect nativeScreenRect;
    QPlatformScreen *screen = qGuiApp->primaryScreen()->handle();
    Q_FOREACH (QPlatformScreen *scr, screen->virtualSiblings()) {
        nativeScreenRect |= scr->geometry();
    }
    return nativeScreenRect;
}

◆ getTabletMode()

KisDlgCustomTabletResolution::Mode KisDlgCustomTabletResolution::getTabletMode ( QRect * customRect )

static

Definition at line 120 of file KisDlgCustomTabletResolution.cpp.

{
    const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
    QSettings cfg(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
 
    const QString mode = cfg.value("wintabResolutionMode", QString("wintab")).toString();
    Mode modeValue = USE_WINTAB;
 
    if (mode == "custom") {
        modeValue = USE_CUSTOM;
    } else if (mode == "virtual-screen") {
        modeValue = USE_VIRTUAL_SCREEN;
    } else {
        modeValue = USE_WINTAB;
    }
 
    if (mode == "custom") {
        customRect->setX(cfg.value("wintabCustomResolutionX", customRect->x()).toInt());
        customRect->setY(cfg.value("wintabCustomResolutionY", customRect->y()).toInt());
        customRect->setWidth(cfg.value("wintabCustomResolutionWidth", customRect->width()).toInt());
        customRect->setHeight(cfg.value("wintabCustomResolutionHeight", customRect->height()).toInt());
    }
 
    return modeValue;
}