LogMessageDelegate.cpp

Go to the documentation of this file.

/*
* This file is part of ArmarX.
*
* ArmarX is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* ArmarX 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, see <http://www.gnu.org/licenses/>.
*
* @package    ArmarX::
* @author     Mirko Waechter ( mirko.waechter at kit dot edu)
* @date       2012
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
#include "LogMessageDelegate.h"
 
#include <algorithm>
#include <iostream>
 
#include <QFontMetrics>
#include <QPainter>
#include <QPalette>
#include <QStringList>
#include <QTableView>
#include <QTextEdit>
#include <QtGlobal>
 
#include "LogTableModel.h"
 
namespace armarx
{
    namespace
    {
        //! Width of \p text in pixels.
        //!
        //! QFontMetrics::horizontalAdvance() was added in Qt 5.11; width() is the older
        //! spelling of the same thing and is only deprecated from 5.11 onwards. Ubuntu
        //! 18.04 ships Qt 5.9, so each version has to use its own spelling: width() does
        //! not compile away the deprecation warning on new Qt, and horizontalAdvance()
        //! does not exist on old Qt.
        int
        advanceWidth(const QFontMetrics& metrics, const QString& text)
        {
#if QT_VERSION >= QT_VERSION_CHECK(5, 11, 0)
            return metrics.horizontalAdvance(text);
#else
            return metrics.width(text);
#endif
        }
    } // namespace
 
    LogMessageDelegate::LogMessageDelegate(QObject* parent) : QStyledItemDelegate(parent)
    {
        //    _lineEdit = new QLabel();
        //    _lineEdit->setWordWrap(true);
    }
 
    LogMessageDelegate::~LogMessageDelegate()
    {
        //    delete _lineEdit;
    }
 
    //void LogMessageDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
    //{
 
    //    QString logMessageStr = index.data().toString();
    //    _lineEdit->setText(logMessageStr);
    //    int lines = std::count(logMessageStr.begin(), logMessageStr.end(), '\n')+1;
    //    if(lines > 5)
    //        lines = 5;
    //    QRect rect = option.rect;
 
    //    rect.setHeight(15*lines);
    //    _lineEdit->resize(rect.size());
    //    std::cout << "lines:" << lines << "old height: " << option.rect.height() << " new: " << rect.height() << " lineedit height: " << _lineEdit->height() << std::endl;
    //    // Change background color if the item is selected
    //    QPalette pal;
    //    if ((option.state & QStyle::State_Selected) == QStyle::State_Selected)
    //    {
    //      pal.setBrush(QPalette::Window, QBrush(QColor(Qt::lightGray)));
    //    }
    //    else
    //    {
    //      pal.setBrush(QPalette::Window, QBrush(QColor(Qt::transparent)));
    //    }
    //    _lineEdit->setPalette(pal);
 
    //    // Paint the widget now.
    //    painter->save();
    //    painter->translate(option.rect.topLeft());
    //    _lineEdit->render(painter);
    //    painter->restore();
    //}
 
    //QSize LogMessageDelegate::sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const
    //{
    //    const int width = 350;
 
    //    const int height = 200;
    //    std::cout << "height: " << _lineEdit->height() << std::endl;
    //    return QSize(width, _lineEdit->height());
    //}
 
    QWidget*
    LogMessageDelegate::createEditor(QWidget* parent,
                                     const QStyleOptionViewItem& option,
                                     const QModelIndex& index) const
    {
        if (index.column() == 4)
        {
            //        QTableView* tableView = qobject_cast<QTableView*>(parent);
            QTextEdit* editor = new QTextEdit(parent);
            //        editor->resize(100,100);
            editor->adjustSize();
            editor->setReadOnly(true);
            //        connect(this, SIGNAL(resizeRow(int)),
            //                tableView, SLOT(resizeRowToContents(int)));
            //        emit resizeRow(index.column());
            //        tableView->resizeRowToContents(index.column());
            return editor;
        }
        else
        {
            return QStyledItemDelegate::createEditor(parent, option, index);
        }
    }
 
    void
    LogMessageDelegate::setEditorData(QWidget* editor, const QModelIndex& index) const
    {
        QTextEdit* textEdit = qobject_cast<QTextEdit*>(editor);
        if (!textEdit)
        {
            QStyledItemDelegate::setEditorData(editor, index);
            return;
        }
        textEdit->setText(index.data((int)LogTableModel::UserRoles::FullMsgRole).toString());
    }
 
    void
    LogMessageDelegate::updateEditorGeometry(QWidget* editor,
                                             const QStyleOptionViewItem& option,
                                             const QModelIndex& index) const
    {
        QTextEdit* textEdit = qobject_cast<QTextEdit*>(editor);
        if (!textEdit)
        {
            QStyledItemDelegate::updateEditorGeometry(editor, option, index);
            return;
        }
 
        // Anchor the overlay at the cell and size it to the message content, clamped to the
        // parent viewport so it never overflows the widget.
        //
        // The size is derived from the message *text*, never from the editor's current
        // document layout: document()->size() reports the layout at the editor's present
        // width, so using it here would add the padding below on top of the width set by
        // the previous call. Since this runs on every updateEditorGeometries() -- i.e.
        // whenever rows are appended -- that made the overlay creep to the right as new
        // messages arrived. Everything below depends only on the text, the font and the
        // cell rect, so repeated calls produce the same geometry.
        const QString text =
            index.data(static_cast<int>(LogTableModel::UserRoles::FullMsgRole)).toString();
        const QStringList lines = text.split('\n');
        const QFontMetrics metrics(textEdit->document()->defaultFont());
 
        QRect r = option.rect;
        const QWidget* parent = editor->parentWidget();
        // Anything past the parent's width is clamped away below, so stop measuring there:
        // a backtrace can run to well over a hundred lines.
        const int maxUsefulWidth = parent ? parent->width() : r.width() * 4;
 
        int textWidth = 0;
        for (const QString& line : lines)
        {
            textWidth = std::max(textWidth, advanceWidth(metrics, line));
            if (textWidth >= maxUsefulWidth)
            {
                break;
            }
        }
 
        // Frame and document margin are independent of the editor's width.
        const int padding = 2 * textEdit->frameWidth() +
                            2 * static_cast<int>(textEdit->document()->documentMargin());
 
        int width = std::max(r.width(), textWidth + padding);
        int height = std::max(r.height(), lines.size() * metrics.lineSpacing() + padding);
 
        if (parent)
        {
            width = std::min(width, parent->width() - r.x());
            height = std::min(height, parent->height() - r.y());
        }
        r.setSize(QSize(width, height));
        editor->setGeometry(r);
    }
 
    void
    LogMessageDelegate::commitAndCloseEditor()
    {
        emit closeEditor(qobject_cast<QWidget*>(sender()));
    }
} // namespace armarx