MyLineEdit.cpp

#include "MyLineEdit.h"
#include <QApplication>
#include <QFocusEvent>
#include <QKeyEvent>
#include <QMouseEvent>
#include <QPainter>
#include <QPaintEvent>
#include <QResizeEvent>
#include <QTimer>

MyLineEdit::MyLineEdit(QWidget *parent):
    QLineEdit (parent),
    m_contextSecondary(false),
    m_contextChipWidth(0),
    m_contextAreaWidth(0),
    m_contextCursorTimer(new QTimer(this)),
    m_contextCursorVisible(false)
{
    connect(m_contextCursorTimer, &QTimer::timeout, this, [this]()
    {
        m_contextCursorVisible = !m_contextCursorVisible;
        update();
    });
}

void MyLineEdit::setInputContext(const QString &name, const QString &toolTip, const QIcon &icon)
{
    m_contextName = name;
    m_contextIcon = icon;
    setToolTip(toolTip);
    updateContextLayout();
    startContextCursor();
    update();
}

void MyLineEdit::setInputContextSecondary(bool secondary)
{
    if (m_contextSecondary == secondary)
    {
        return;
    }

    m_contextSecondary = secondary;
    startContextCursor();
    updateContextLayout();
    update();
}

void MyLineEdit::clearInputContext()
{
    if (m_contextName.isEmpty())
    {
        return;
    }

    m_contextName.clear();
    m_contextIcon = QIcon();
    m_contextSecondary = false;
    m_contextChipWidth = 0;
    m_contextAreaWidth = 0;
    m_contextCursorTimer->stop();
    m_contextCursorVisible = false;
    setTextMargins(0, 0, 0, 0);
    setToolTip(QString());
    update();
}

void MyLineEdit::keyPressEvent(QKeyEvent *me)
{
    bool handled = false;

    if (selectionStart() == -1)
    {
        switch (me->key())
        {
        case Qt::Key_Backspace:
            if (isAtEndOfSeparator())
            {
                backspace();
                backspace();
                backspace();
                handled = true;
            }
            break;

        case Qt::Key_Delete:
            if (isAtStartOfSeparator())
            {
                del();
                del();
                del();
                handled = true;
            }
            break;

        case Qt::Key_Left:
            if (isAtEndOfSeparator())
            {
                cursorBackward(false, 3);
                handled = true;
            }
            break;
        case Qt::Key_Right:
            if (isAtStartOfSeparator())
            {
                cursorForward(false,3);
                handled = true;
            }
        }
    }

    if (handled)
    {
        return;
    }
    else
    {
        QLineEdit::keyPressEvent(me);
    }
}

void MyLineEdit::mousePressEvent(QMouseEvent *event)
{
    if (event->button() == Qt::LeftButton &&
        !m_contextName.isEmpty() &&
        contextCloseRect().contains(event->pos()))
    {
        emit sigInputContextRemove();
        event->accept();
        return;
    }

    if (event->button() == Qt::LeftButton)
    {
        emit clicked();
    }

    QLineEdit::mousePressEvent(event);
}

void MyLineEdit::paintEvent(QPaintEvent *event)
{
    QLineEdit::paintEvent(event);

    if (m_contextName.isEmpty())
    {
        return;
    }

    QPainter painter(this);
    painter.setRenderHint(QPainter::Antialiasing);

    QFont contextFont = font();
    if (contextFont.pointSize() > 0)
    {
        contextFont.setPointSize(qMax(10, contextFont.pointSize() - 2));
    }
    contextFont.setWeight(QFont::Medium);
    painter.setFont(contextFont);
    QFontMetrics contextMetrics(contextFont);

    const int chipHeight = qMin(38, height() - 12);
    const int chipTop = (height() - chipHeight) / 2;
    const QRect chipRect(8, chipTop, m_contextChipWidth, chipHeight);

    QPalette currentPalette = palette();
    QColor contextColor = currentPalette.color(QPalette::Text);
    QColor borderColor = contextColor;
    QColor backgroundColor = contextColor;
    borderColor.setAlpha(55);
    backgroundColor.setAlpha(18);
    painter.setPen(borderColor);
    painter.setBrush(backgroundColor);
    painter.drawRoundedRect(chipRect, 6, 6);

    const int iconSize = qMin(24, chipHeight - 10);
    const QRect iconRect(chipRect.left() + 7,
                         chipRect.top() + (chipRect.height() - iconSize) / 2,
                         iconSize,
                         iconSize);
    m_contextIcon.paint(&painter, iconRect);

    const QRect closeRect = contextCloseRect();
    const int textLeft = iconRect.right() + 7;
    const int textRight = closeRect.left() - 6;
    const QRect textRect(textLeft, chipRect.top(), textRight - textLeft, chipRect.height());
    QString contextText = contextMetrics.elidedText(m_contextName, Qt::ElideMiddle, textRect.width());
    painter.setPen(currentPalette.color(QPalette::Text));
    painter.drawText(textRect, Qt::AlignVCenter | Qt::AlignLeft, contextText);

    QColor closeColor = currentPalette.color(QPalette::Text);
    closeColor.setAlpha(150);
    QPen closePen(closeColor);
    closePen.setWidthF(1.5);
    painter.setPen(closePen);
    const QRect closeLineRect = closeRect.adjusted(4, 4, -4, -4);
    painter.drawLine(closeLineRect.topLeft(), closeLineRect.bottomRight());
    painter.drawLine(closeLineRect.topRight(), closeLineRect.bottomLeft());

    if (m_contextSecondary)
    {
        QColor arrowColor = currentPalette.color(QPalette::Text);
        arrowColor.setAlpha(165);
        painter.setPen(arrowColor);
        const QRect arrowRect(chipRect.right() + 8,
                              chipRect.top(),
                              m_contextAreaWidth - m_contextChipWidth - 8,
                              chipRect.height());
        painter.drawText(arrowRect, Qt::AlignCenter, separatorChar());
    }
    else if (hasFocus() && m_contextCursorVisible)
    {
        const int cursorX = chipRect.right() + 8;
        const int cursorHeight = qMin(contextMetrics.height(), chipRect.height() - 8);
        const int cursorTop = (height() - cursorHeight) / 2;
        painter.setPen(currentPalette.color(QPalette::Text));
        painter.drawLine(cursorX, cursorTop, cursorX, cursorTop + cursorHeight);
    }
}

void MyLineEdit::resizeEvent(QResizeEvent *event)
{
    QLineEdit::resizeEvent(event);
    updateContextLayout();
}

void MyLineEdit::focusInEvent(QFocusEvent *event)
{
    QLineEdit::focusInEvent(event);
    startContextCursor();
}

void MyLineEdit::focusOutEvent(QFocusEvent *event)
{
    QLineEdit::focusOutEvent(event);
    m_contextCursorTimer->stop();
    m_contextCursorVisible = false;
    update();
}

QChar MyLineEdit::separatorChar() const
{
    QFontMetrics met = fontMetrics();
    QChar arrow(0x25ba);
    if (met.inFont(arrow))
        return arrow;
    else
        return QChar('|');
}


QString MyLineEdit::separatorText() const
{
    return QString(" ") + separatorChar() + " ";
}


bool MyLineEdit::isAtStartOfSeparator() const
{
    return text().mid(cursorPosition(), 3) == separatorText();
}


bool MyLineEdit::isAtEndOfSeparator() const
{
    return text().mid(cursorPosition() - 3, 3) == separatorText();
}

QRect MyLineEdit::contextCloseRect() const
{
    const int chipHeight = qMin(38, height() - 12);
    const int chipTop = (height() - chipHeight) / 2;
    const QRect chipRect(8, chipTop, m_contextChipWidth, chipHeight);
    const int closeSize = 16;

    return QRect(chipRect.right() - closeSize - 6,
                 chipRect.top() + (chipRect.height() - closeSize) / 2,
                 closeSize,
                 closeSize);
}

void MyLineEdit::startContextCursor()
{
    if (m_contextName.isEmpty() || m_contextSecondary || !hasFocus())
    {
        m_contextCursorTimer->stop();
        m_contextCursorVisible = false;
        return;
    }

    m_contextCursorVisible = true;
    m_contextCursorTimer->start(qMax(200, QApplication::cursorFlashTime() / 2));
}

void MyLineEdit::updateContextLayout()
{
    if (m_contextName.isEmpty())
    {
        return;
    }

    const int iconWidth = 24;
    const int chipPadding = 42;
    QFont contextFont = font();
    if (contextFont.pointSize() > 0)
    {
        contextFont.setPointSize(qMax(10, contextFont.pointSize() - 2));
    }
    contextFont.setWeight(QFont::Medium);
    QFontMetrics contextMetrics(contextFont);

    const int desiredChipWidth = iconWidth + chipPadding + contextMetrics.horizontalAdvance(m_contextName);
    const int maxContextWidth = qMin(280, width() * 40 / 100);
    const int arrowAreaWidth = m_contextSecondary ? 28 : 0;
    const int minChipWidth = iconWidth + chipPadding + contextMetrics.horizontalAdvance(QStringLiteral("..."));

    m_contextChipWidth = qMax(minChipWidth,
                              qMin(desiredChipWidth, maxContextWidth - arrowAreaWidth));
    m_contextAreaWidth = m_contextChipWidth + arrowAreaWidth;
    setTextMargins(m_contextAreaWidth + 8, 0, 0, 0);
}