dialogutils.cpp

Go to the documentation of this file.

#include "./dialogutils.h"
 
#include "../misc/desktoputils.h"
 
#include <QCoreApplication>
#include <QDir>
#include <QFileInfo>
 
#if defined(QT_UTILITIES_GUI_QTWIDGETS) || defined(QT_UTILITIES_GUI_QTQUICK)
#include <QGuiApplication>
#include <QPalette>
#endif
 
#if defined(QT_UTILITIES_GUI_QTWIDGETS)
#include <QApplication>
#include <QCursor>
#if (QT_VERSION < QT_VERSION_CHECK(5, 10, 0))
#include <QDesktopWidget>
#endif
#include <QScreen>
#include <QStyle>
#include <QWidget>
#endif
 
namespace QtUtilities {

QString generateWindowTitle(DocumentStatus documentStatus, const QString &documentPath)
{
    switch (documentStatus) {
    case DocumentStatus::Saved:
        if (documentPath.isEmpty()) {
            return QCoreApplication::translate("Utilities::windowTitle", "Unsaved - %1").arg(QCoreApplication::applicationName());
        } else {
            const QFileInfo file(documentPath);
            return QCoreApplication::translate("Utilities::windowTitle", "%1 - %2 - %3")
                .arg(file.fileName(), file.dir().path(), QCoreApplication::applicationName());
        }
    case DocumentStatus::Unsaved:
        if (documentPath.isEmpty()) {
            return QCoreApplication::translate("Utilities::windowTitle", "*Unsaved - %1").arg(QCoreApplication::applicationName());
        } else {
            const QFileInfo file(documentPath);
            return QCoreApplication::translate("Utilities::windowTitle", "*%1 - %2 - %3")
                .arg(file.fileName(), file.dir().path(), QCoreApplication::applicationName());
        }
    case DocumentStatus::NoDocument:
        return QCoreApplication::applicationName();
    default:
        return QString(); // to suppress warning: "control reaches end of non-void
        // function"
    }
}
 
#if defined(QT_UTILITIES_GUI_QTWIDGETS) || defined(QT_UTILITIES_GUI_QTQUICK)
 
#ifdef Q_OS_WIN32
QColor windowFrameColorForPalette(const QPalette &palette)
{
    return palette.window().color().darker(108);
}

QColor windowFrameColor()
{
    return windowFrameColorForPalette(QGuiApplication::palette());
}

QColor instructionTextColorForPalette(const QPalette &palette)
{
    return isPaletteDark(palette) ? palette.text().color() :
#if QT_VERSION >= QT_VERSION_CHECK(6, 6, 0)
                                  palette.accent().color()
#else
                                  QColor(0x00, 0x33, 0x99)
#endif
        ;
}

QColor instructionTextColor()
{
    return instructionTextColorForPalette(QGuiApplication::palette());
}
#endif

QString dialogStyleForPalette(const QPalette &palette)
{
#ifdef Q_OS_WINDOWS
    return QStringLiteral("#mainWidget { color: palette(text); background-color: "
                          "palette(base); border: none; }"
                          "#bottomWidget { background-color: palette(window); "
                          "color: palette(window-text); border-top: 1px solid %1; }"
                          "*[classNames~=\"heading\"] { font-size: 12pt; color: %2; }"
                          "*[classNames~=\"input-invalid\"] { color: red; }")
        .arg(windowFrameColorForPalette(palette).name(), instructionTextColorForPalette(palette).name());
#else
    Q_UNUSED(palette)
    return QStringLiteral("*[classNames~=\"heading\"] { font-weight: bold; }"
                          "*[classNames~=\"input-invalid\"] { color: red; }");
#endif
}

const QString &dialogStyle()
{
    static const auto style = dialogStyleForPalette(QGuiApplication::palette());
    return style;
}
 
#ifdef QT_UTILITIES_GUI_QTWIDGETS
 
QRect availableScreenGeometryAtPoint(const QPoint &point)
{
#if (QT_VERSION >= QT_VERSION_CHECK(5, 10, 0))
    QScreen *const screen = QGuiApplication::screenAt(point);
    if (!screen) {
        return QRect();
    }
    return screen->availableGeometry();
#else
    return QApplication::desktop()->availableGeometry(point);
#endif
}

static QRect shrinkRectByMargins(QRect rect, const QMargins &margins)
{
    rect.setLeft(rect.left() + margins.left());
    rect.setTop(rect.top() + margins.top());
    rect.setRight(rect.right() - margins.right());
    rect.setBottom(rect.bottom() - margins.bottom());
    return rect;
}
 
static QRect limitRect(QRect rect, const QRect &bounds)
{
    if (rect.left() < bounds.left()) {
        rect.setLeft(bounds.left());
    }
    if (rect.top() < bounds.top()) {
        rect.setTop(bounds.top());
    }
    if (rect.right() > bounds.right()) {
        rect.setRight(bounds.right());
    }
    if (rect.bottom() > bounds.bottom()) {
        rect.setBottom(bounds.bottom());
    }
    return rect;
}
 
static QMargins widgetFrame(QWidget *widget, const QMargins &defaultAssumption = QMargins(10, 25, 10, 10))
{
    if (!widget->isWindow()) {
        return QMargins();
    }
    const auto widgetGeometry = widget->geometry();
    const auto frameGeometry = widget->frameGeometry();
    const auto frame = QMargins(widgetGeometry.left() - frameGeometry.left(), widgetGeometry.top() - frameGeometry.top(),
        frameGeometry.right() - widgetGeometry.right(), frameGeometry.bottom() - widgetGeometry.bottom());
    return frame.isNull() ? defaultAssumption : frame;
}
 
static bool centerWidgetInternal(QWidget *widget, const QWidget *parent, const QPoint *position, bool avoidOverflow)
{
    const auto availableGeometry = parent ? parent->geometry() : availableScreenGeometryAtPoint(position ? *position : QCursor::pos());
    const auto alignedRect = QStyle::alignedRect(Qt::LeftToRight, Qt::AlignCenter, widget->size(), availableGeometry);
    if (!avoidOverflow) {
        widget->setGeometry(alignedRect);
        return false;
    }
    const auto limitedRect = limitRect(alignedRect, shrinkRectByMargins(availableGeometry, widgetFrame(widget)));
    widget->setGeometry(limitedRect);
    return alignedRect != limitedRect;
}

void centerWidget(QWidget *widget, const QWidget *parent, const QPoint *position)
{
    centerWidgetInternal(widget, parent, position, false);
}

bool centerWidgetAvoidingOverflow(QWidget *widget, const QWidget *parent, const QPoint *position)
{
    return centerWidgetInternal(widget, parent, position, true);
}

void cornerWidget(QWidget *widget, const QPoint *position)
{
    const QPoint cursorPos(position ? *position : QCursor::pos());
    const QRect availableGeometry(availableScreenGeometryAtPoint(cursorPos));
    const Qt::Alignment alignment
        = (cursorPos.x() - availableGeometry.left() < availableGeometry.right() - cursorPos.x() ? Qt::AlignLeft : Qt::AlignRight)
        | (cursorPos.y() - availableGeometry.top() < availableGeometry.bottom() - cursorPos.y() ? Qt::AlignTop : Qt::AlignBottom);
    widget->setGeometry(QStyle::alignedRect(Qt::LeftToRight, alignment, widget->size(), availableGeometry));
}

void makeHeading(QWidget *widget)
{
    widget->setProperty("classNames", widget->property("classNames").toStringList() << QStringLiteral("heading"));
}

void updateStyle(QWidget *widget)
{
    widget->style()->unpolish(widget);
    widget->style()->polish(widget);
    widget->update();
}
 
#endif
 
#endif
 
} // namespace QtUtilities