ttkdesktopscreen.cpp

Go to the documentation of this file.

#include "ttkdesktopscreen.h"
#include "ttklibrary.h"

#include <QScreen>
#include <QApplication>
#ifdef Q_OS_WIN
#  define WIN32_LEAN_AND_MEAN
#  include <qt_windows.h>
#endif
#if !TTK_QT_VERSION_CHECK(5,0,0)
#  include <QDesktopWidget>
#endif
#if defined Q_OS_LINUX
#  include <X11/Xlib.h>
#  include "ttkregularexpression.h"
#endif

TTKDesktopScreen::TaskbarInfo TTKDesktopScreen::screenTaskbar(int index)
{
    const QRect &sr = screenGeometry(index);
    const QRect &dr = availableGeometry(index);

    TaskbarInfo info;
    if(sr.left() != dr.left())
    {
        info.m_size = std::abs(sr.left() - dr.left());
        info.m_direction = TTK::Direction::Left;
    }
    else if(sr.right() != dr.right())
    {
        info.m_size = std::abs(sr.right() - dr.right());
        info.m_direction = TTK::Direction::Right;
    }
    else if(sr.top() != dr.top())
    {
        info.m_size = std::abs(sr.top() - dr.top());
        info.m_direction = TTK::Direction::Top;
    }
    else if(sr.bottom() != dr.bottom())
    {
        info.m_size = std::abs(sr.bottom() - dr.bottom());
        info.m_direction = TTK::Direction::Bottom;
    }
    else
    {
        info.m_size = 0;
        info.m_direction = TTK::Direction::No;
    }
    return info;
}

QRect TTKDesktopScreen::geometry()
{
#if TTK_QT_VERSION_CHECK(5,0,0)
    const QList<QScreen*> &screens = QApplication::screens();
    QRegion virtualGeometry;
    for(QScreen *screen : screens)
    {
        virtualGeometry += screen->geometry();
    }
    return virtualGeometry.boundingRect();
#else
    QDesktopWidget *widget = QApplication::desktop();
    return widget ? widget->geometry() : QRect();
#endif
}

QRect TTKDesktopScreen::screenGeometry(int index)
{
#if TTK_QT_VERSION_CHECK(5,0,0)
    const QList<QScreen*> &screens = QApplication::screens();
    return (index < 0 || index >= screens.count()) ? QRect() : screens[index]->geometry();
#else
    QDesktopWidget *widget = QApplication::desktop();
    return widget ? widget->screenGeometry(index) : QRect();
#endif
}

QRect TTKDesktopScreen::availableGeometry(int index)
{
#if TTK_QT_VERSION_CHECK(5,0,0)
    const QList<QScreen*> &screens = QApplication::screens();
    return (index < 0 || index >= screens.count()) ? QRect() : screens[index]->availableGeometry();
#else
    QDesktopWidget *widget = QApplication::desktop();
    return widget ? widget->availableGeometry(index) : QRect();
#endif
}

int TTKDesktopScreen::count()
{
#if TTK_QT_VERSION_CHECK(5,0,0)
    return QApplication::screens().count();
#else
    return QApplication::desktop()->screenCount();
#endif
}

int TTKDesktopScreen::currentIndex()
{
    int index = 0;
    const int count = TTKDesktopScreen::count();
    if(count > 1)
    {
        const QPoint &pos = QCursor::pos();
        for(int i = 0; i < count; ++i)
        {
#if TTK_QT_VERSION_CHECK(5,0,0)
            if(QApplication::screens().at(i)->geometry().contains(pos))
#else
            if(QApplication::desktop()->screenGeometry(i).contains(pos))
#endif
            {
                index = i;
                break;
            }
        }
    }
    return index;
}

QRect TTKDesktopScreen::currentGeometry()
{
    const int index = currentIndex();
    return screenGeometry(index);
}

void TTKDesktopScreen::centerWidget(QWidget *widget)
{
    const QRect &rect = currentGeometry();
    widget->move(rect.x() + (rect.width() - widget->width()) / 2, rect.y() + (rect.height() - widget->height()) / 2);
}

QPixmap TTKDesktopScreen::grabWidget(QWidget *widget, const QRect &rect)
{
#if TTK_QT_VERSION_CHECK(5,0,0)
    return widget->grab(rect);
#else
    return QPixmap::grabWidget(widget, rect);
#endif
}

QPixmap TTKDesktopScreen::grabWindow(int x, int y, int w, int h)
{
    QWidget widget(nullptr, Qt::Desktop);
    widget.setVisible(false);
    widget.setGeometry(geometry());
#if TTK_QT_VERSION_CHECK(5,0,0)
    QScreen *screen = QApplication::primaryScreen();
    return screen ? screen->grabWindow(widget.winId(), x, y, w, h) : QPixmap();
#else
    return QPixmap::grabWindow(widget.winId(), x, y, w, h);
#endif
}

static constexpr int DEFAULT_DPI = 96;

static QSize generateDPIValue()
{
    QSize dpiSize(DEFAULT_DPI, DEFAULT_DPI);
#ifdef Q_OS_WIN
    HDC screen = GetDC(GetDesktopWindow());
    dpiSize.setWidth(GetDeviceCaps(screen, LOGPIXELSX));
    dpiSize.setHeight(GetDeviceCaps(screen, LOGPIXELSY));
    ReleaseDC(GetDesktopWindow(), screen);
#elif defined Q_OS_LINUX
    Display *dp = XOpenDisplay(nullptr);
    if(!dp)
    {
        return dpiSize;
    }

    double dpi = DEFAULT_DPI;
    const char *resource = XResourceManagerString(dp);
    if(resource)
    {
        const QString data(resource);
        static TTKRegularExpression regx("Xft.dpi:\t(\\d+)");
        if(regx.match(data) != -1)
        {
            dpi = regx.captured(1).toDouble();
        }
    }

    const int screen = 0; /* Screen number */
    const double x = (DisplayWidth(dp, screen) * 25.4) / DisplayWidthMM(dp, screen);
    const double y = (DisplayHeight(dp, screen) * 25.4) / DisplayHeightMM(dp, screen);

    if(x < dpi && x != DEFAULT_DPI && TTKStaticCast(int, x) % DEFAULT_DPI != 0 &&
       y < dpi && y != DEFAULT_DPI && TTKStaticCast(int, y) % DEFAULT_DPI != 0)
    {
        dpiSize.setWidth(x + 0.5);
        dpiSize.setHeight(y + 0.5);
    }
    else
    {
        dpiSize.setWidth(dpi + 0.5);
        dpiSize.setHeight(dpi + 0.5);
    }

    XCloseDisplay(dp);
#elif defined Q_OS_MAC
    if(!qApp)
    {
        int count = 0;
        QApplication(count, nullptr);
    }

#  if TTK_QT_VERSION_CHECK(5,0,0)
    QScreen *screen = QApplication::primaryScreen();
    if(screen)
    {
        dpiSize.setWidth(screen->logicalDotsPerInchX());
        dpiSize.setHeight(screen->logicalDotsPerInchY());
    }
    // fallback below if no screen
#  else
    QDesktopWidget* desktop = QApplication::desktop();
    if(desktop)
    {
        dpiSize.setWidth(desktop->logicalDpiX());
        dpiSize.setHeight(desktop->logicalDpiY());
    }
#  endif
#endif
    return dpiSize;
}

int TTKDesktopScreen::deviceDotsPerInch(int index)
{
    return devicePixelRatio(index) * DEFAULT_DPI;
}

qreal TTKDesktopScreen::devicePixelRatio(int index)
{
#if TTK_QT_VERSION_CHECK(5,5,0)
    const QList<QScreen*> &screens = QApplication::screens();
    return (index < 0 || index >= screens.count()) ? 1.0 : screens[index]->devicePixelRatio();
#else
    Q_UNUSED(index);
    const QSize &size = generateDPIValue();
    return 1.0 * (size.width() + size.height()) / 2 / DEFAULT_DPI;
#endif
}

qreal TTKDesktopScreen::currentPixelRatio()
{
    const int index = currentIndex();
    return devicePixelRatio(index);
}