Subversion Repositories tpanel

/*

 * Copyright (C) 2023, 2024 by Andreas Theofilu <andreas@theosys.at>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 3 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA

 */

#include <QLineEdit>

#include <QTextEdit>

#include <QLabel>

#include <QHBoxLayout>

#include <QEvent>

#include <QKeyEvent>

#include <QApplication>

#include <QPainter>

#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)

#include <QAnyStringView>

#endif

#include "tqeditline.h"

#include "tqsingleline.h"

#include "tqmultiline.h"

#include "terror.h"

using std::string;

TQEditLine::TQEditLine(QWidget *widget, bool multiline)

    : QWidget(widget),

      mMultiline(multiline)

{

    DECL_TRACER("TQEditLine::TQEditLine(QWidget *widget, bool multiline)");

    init();

}

TQEditLine::TQEditLine(string &text, QWidget *widget, bool multiline)

    : QWidget(widget),

      mText(text),

      mMultiline(multiline)

{

    DECL_TRACER("TQEditLine::TQEditLine(string &text, QWidget *widget, bool multiline)");

    init();

}

TQEditLine::~TQEditLine()

{

    DECL_TRACER("TQEditLine::~TQEditLine()");

    if (mMultiline && mTextArea)

    {

        disconnect(mTextArea, &TQMultiLine::textChanged, this, &TQEditLine::onTextAreaChanged);

        disconnect(mTextArea, &TQMultiLine::focusChanged, this, &TQEditLine::onFocusChanged);

        disconnect(mTextArea, &TQMultiLine::keyPressed, this, &TQEditLine::onKeyPressed);

    }

    else if (!mMultiline && mEdit)

    {

        disconnect(mEdit, &TQSingleLine::textChanged, this, &TQEditLine::onTextChanged);

        disconnect(mEdit, &TQSingleLine::cursorPositionChanged, this, &TQEditLine::onCursorPositionChangedS);

        disconnect(mEdit, &TQSingleLine::editingFinished, this, &TQEditLine::onEditingFinished);

        disconnect(mEdit, &TQSingleLine::focusChanged, this, &TQEditLine::onFocusChanged);

        disconnect(mEdit, &TQSingleLine::keyPressed, this, &TQEditLine::onKeyPressed);

    }

    if (mLayout)

        delete mLayout;

}

void TQEditLine::init()

{

    DECL_TRACER("TQEditLine::init()");

    setAutoFillBackground(false);

    if (!mLayout)

    {

        mLayout = new QHBoxLayout(this);

        mLayout->setSpacing(0);

        mLayout->setContentsMargins(0, 0, 0, 0);

        if (mMultiline)

            mTextArea = new TQMultiLine;

        else

            mEdit = new TQSingleLine;

        QPalette pal(palette());

        pal.setColor(QPalette::Window, Qt::transparent);

        pal.setColor(QPalette::Base, Qt::transparent);

        pal.setColor(QPalette::WindowText, Qt::black);

        pal.setColor(QPalette::Text, Qt::black);

        if (!mText.empty())

        {

            if (mMultiline)

                mTextArea->setText(QString::fromStdString(mText));

            else

                mEdit->setText(QString::fromStdString(mText));

        }

        if (mMultiline)

        {

            mTextArea->setPalette(pal);

            QWidget::connect(mTextArea, &TQMultiLine::textChanged, this, &TQEditLine::onTextAreaChanged);

            QWidget::connect(mTextArea, &TQMultiLine::focusChanged, this, &TQEditLine::onFocusChanged);

            QWidget::connect(mTextArea, &TQMultiLine::keyPressed, this, &TQEditLine::onKeyPressed);

            mLayout->addWidget(mTextArea);

        }

        else

        {

            mEdit->setPalette(pal);

            QWidget::connect(mEdit, &TQSingleLine::textChanged, this, &TQEditLine::onTextChanged);

            QWidget::connect(mEdit, &TQSingleLine::cursorPositionChanged, this, &TQEditLine::onCursorPositionChangedS);

            QWidget::connect(mEdit, &TQSingleLine::editingFinished, this, &TQEditLine::onEditingFinished);

            QWidget::connect(mEdit, &TQSingleLine::focusChanged, this, &TQEditLine::onFocusChanged);

            QWidget::connect(mEdit, &TQSingleLine::keyPressed, this, &TQEditLine::onKeyPressed);

            mLayout->addWidget(mEdit);

        }

        QWidget::setLayout(mLayout);

    }

}

void TQEditLine::setText(string &text)

{

    DECL_TRACER("TQEditLine::setText(string &text)");

    mText = text;

    MSG_DEBUG("Setting text: " << text);

    if (mMultiline && mTextArea)

        mTextArea->setText(QString::fromStdString(text));

    else if (!mMultiline && mEdit)

        mEdit->setText(QString::fromStdString(text));

    mChanged = false;

}

void TQEditLine::setPlaceholderText(string& text)

{

    DECL_TRACER("TQEditLine::setPlaceholderText(string& text)");

    if (mMultiline && mTextArea)

        mTextArea->setPlaceholderText(QString::fromStdString(text));

    else if (!mMultiline && mEdit)

        mEdit->setPlaceholderText(QString::fromStdString(text));

}

void TQEditLine::setObjectName(const string& name)

{

    DECL_TRACER("TQEditLine::setObjectName(const string& name)");

    if (name.empty())

        return;

    QWidget::setObjectName(QString::fromStdString(name));

    QString editName("Edit#");

    editName.append(QString::fromStdString(name));

    if (mMultiline && mTextArea)

        mTextArea->setObjectName(editName);

    else if (!mMultiline && mEdit)

        mEdit->setObjectName(editName);

    if (mLayout)

        mLayout->setObjectName(QString("Layout#%1").arg(QString::fromStdString(name)));

}

void TQEditLine::setPasswordChar(uint c)

{

    DECL_TRACER("TQEditLine::setPasswordChar(uint c)");

    if (!mMultiline && mEdit && c)

    {

        char style[256];

        snprintf(style, sizeof(style), "lineedit-password-character: %d", c);

        mEdit->setStyleSheet(style);

        mEdit->setEchoMode(QLineEdit::Password);

    }

}

void TQEditLine::setFixedSize(int w, int h)

{

    DECL_TRACER("TQEditLine::setFixedSize(int w, int h)");

    if (mLayout && w > 0 && h > 0)

    {

        QWidget::setFixedSize(w, h);

        if (mMultiline)

            mTextArea->setFixedSize(w - 1 - mPadLeft - mPadRight, h - 1 - mPadTop - mPadBottom);

        else

            mEdit->setFixedSize(w - 1 - mPadLeft - mPadRight, h - 1 - mPadTop - mPadBottom);

        mWidth = w;

        mHeight = h;

    }

}

void TQEditLine::setFont(QFont &font)

{

    DECL_TRACER("TQEditLine::setFont(QFont &font)");

    if (!mMultiline && mEdit)

        mEdit->setFont(font);

    else if (mMultiline && mTextArea)

        mTextArea->setFont(font);

}

void TQEditLine::setPalette(QPalette &pal)

{

    DECL_TRACER("TQEditLine::setPalette(QPalette &pal)");

    QWidget::setPalette(pal);

}

void TQEditLine::setTextColor(QColor col)

{

    DECL_TRACER("TQEditLine::setTextColor(QColor col)");

    QPalette pal;

    if (!mMultiline && mEdit)

        pal = mEdit->palette();

    else if (mMultiline && mTextArea)

        pal = mTextArea->palette();

    else

        return;

    pal.setColor(QPalette::WindowText, col);

    pal.setColor(QPalette::Text, col);

    if (!mMultiline)

        mEdit->setPalette(pal);

    else

        mTextArea->setPalette(pal);

}

void TQEditLine::setBgColor(QColor &col)

{

    DECL_TRACER("TQEditLine::setBgColor(QColor &col)");

    mBgColor = col;

}

void TQEditLine::setBackgroundPixmap(QPixmap& pixmap)

{

    DECL_TRACER("TQEditLine::setBackgroundPixmap(QPixmap& pixmap)");

    if (pixmap.isNull())

        return;

    mBackground = pixmap;

    update();

}

void TQEditLine::grabGesture(Qt::GestureType type, Qt::GestureFlags flags)

{

    DECL_TRACER("TQEditLine::grabGesture(Qt::GestureType type, Qt::GestureFlags flags)");

    if (mMultiline && mTextArea)

        mTextArea->grabGesture(type, flags);

    else if (!mMultiline && mEdit)

        mEdit->grabGesture(type, flags);

}

void TQEditLine::setPadding(int left, int top, int right, int bottom)

{

    DECL_TRACER("TQEditLine::setPadding(int left, int top, int right, int bottom)");

    mPadLeft = (left < 0 ? 0 : left);

    mPadTop = (top < 0 ? 0 : top);

    mPadRight = (right < 0 ? 0 : right);

    mPadBottom = (bottom < 0 ? 0 : bottom);

    if (mMultiline && mTextArea)

        mTextArea->setFixedSize(mWidth - 1 - mPadLeft - mPadRight, mHeight - 1 - mPadTop - mPadBottom);

    else if (!mMultiline && mEdit)

        mEdit->setFixedSize(mWidth - 1 - mPadLeft - mPadRight, mHeight - 1 - mPadTop - mPadBottom);

    mLayout->setContentsMargins(mPadLeft, mPadTop, mPadRight, mPadBottom);

}

void TQEditLine::setFrameSize(int s)

{

    DECL_TRACER("TQEditLine::setFrameSize(int s)");

    setPadding(s + mPadLeft, s + mPadTop, s + mPadRight, s + mPadBottom);

}

void TQEditLine::setWordWrapMode(bool mode)

{

    DECL_TRACER("TQEditLine::setWordWrapMode(bool mode)");

    if (!mMultiline || !mTextArea)

        return;

    mTextArea->setWordWrapMode((mode ? QTextOption::WordWrap : QTextOption::NoWrap));

}

void TQEditLine::clear()

{

    DECL_TRACER("TQEditLine::clear()");

    if (mMultiline && mTextArea)

        mTextArea->clear();

    else if (!mMultiline && mEdit)

        mEdit->clear();

    mText.clear();

}

void TQEditLine::setInputMask(const std::string& mask)

{

    DECL_TRACER("TQEditLine::setInputMask(const std::string& mask)");

    if (!mMultiline && mEdit)

        mEdit->setInputMask(QString::fromStdString(mask));

}

void TQEditLine::setNumericInput()

{

    DECL_TRACER("TQEditLine::setNumericInput()");

    if (!mMultiline && mEdit)

        mEdit->setInputMethodHints(mEdit->inputMethodHints() | Qt::ImhDigitsOnly);

}

#ifndef __ANDROID__

void TQEditLine::setClearButtonEnabled(bool state)

{

    DECL_TRACER("TQEditLine::setClearButtonEnabled(bool state)");

    if (!mMultiline && mEdit)

        mEdit->setClearButtonEnabled(state);

}

void TQEditLine::setCursor(const QCursor& qc)

{

    DECL_TRACER("TQEditLine::setCursor(const QCursor& qc)");

    if (mMultiline && mTextArea)

        mTextArea->setCursor(qc);

    else if (!mMultiline && mEdit)

        mEdit->setCursor(qc);

}

#endif

/*

 * Here the signal and callback functions follow.

 */

void TQEditLine::onKeyPressed(int key)

{

    DECL_TRACER("TQEditLine::onKeyPressed(int key)");

    if (key == Qt::Key_Enter || key == Qt::Key_Return)

    {

        string txt;

        if (mMultiline && mTextArea)

            txt = mTextArea->toPlainText().toStdString();

        else if (!mMultiline && mEdit)

            txt = mEdit->text().toStdString();

        if (mChanged || txt != mText)

        {

            mText = txt;

            emit inputChanged(mHandle, mText);

            mChanged = false;

        }

    }

    QApplication::processEvents();

}

void TQEditLine::hideEvent(QHideEvent *event)

{

    DECL_TRACER("TQEditLine::hideEvent(QHideEvent *event)");

    Q_UNUSED(event);

    _end();

}

void TQEditLine::leaveEvent(QEvent *event)

{

    DECL_TRACER("TQEditLine::leaveEvent(QEvent *event)");

    Q_UNUSED(event);

    _end();

}

void TQEditLine::closeEvent(QCloseEvent *event)

{

    DECL_TRACER("TQEditLine::closeEvent(QCloseEvent *event)");

    Q_UNUSED(event);

    _end();

}

void TQEditLine::onFocusChanged(bool in)

{

    DECL_TRACER("TQEditLine::onFocusChanged(bool in)");

    emit focusChanged(mHandle, in);

}

void TQEditLine::_end()

{

    DECL_TRACER("TQEditLine::_end()");

    string text;

    if (mMultiline && mTextArea)

        text = mTextArea->toPlainText().toStdString();

    else if (!mMultiline && mEdit)

        text = mEdit->text().toStdString();

    MSG_DEBUG("Current text: " << text);

    if (mChanged || text != mText)

    {

        mText = text;

        emit inputChanged(mHandle, mText);

        mChanged = false;

    }

}

void TQEditLine::onTextChanged(const QString &text)

{

    DECL_TRACER("TQEditLine::onTextChanged(const QString &text)");

    mText = text.toStdString();

    MSG_DEBUG("Text changed to: " << mText);

    mChanged = true;

}

void TQEditLine::onTextAreaChanged()

{

    DECL_TRACER("TQEditLine::onTextAreaChanged()");

    mText = mTextArea->toPlainText().toStdString();

    MSG_DEBUG("Multiline text changed to: " << mText);

    mChanged = true;

}

void TQEditLine::onCursorPositionChangedS(int oldPos, int newPos)

{

    DECL_TRACER("TQEditLine::onCursorPositionChangedS(int oldPos, int newPos)");

    emit cursorPositionChanged(mHandle, oldPos, newPos);

}

void TQEditLine::onEditingFinished()

{

    DECL_TRACER("TQEditLine::onEditingFinished()");

    _end();

}

void TQEditLine::paintEvent(QPaintEvent* event)

{

    DECL_TRACER("TQEditLine::paintEvent(QPaintEvent* event)");

    Q_UNUSED(event);

    if (mBackground.isNull())

    {

        mBackground = QPixmap(width(), height());

        mBackground.fill(mBgColor);

    }

    QPainter p(this);

    p.drawPixmap(0, 0, mBackground);

}