LogTable.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 "LogTable.h"
 
#include <algorithm>
#include <filesystem>
 
#include <QApplication>
#include <QHeaderView>
#include <QMenu>
#include <QScrollBar>
#include <QTimer>
 
#include "LogMessageDelegate.h"
#include "LogTableModel.h"
 
namespace armarx
{
    LogTable::LogTable(QWidget* parent) :
        QTableView(parent), newMessageCount(0), maxNewLogLevelType(eUNDEFINED)
    {
        autoscrollActive = true;
        selectedSearchIndex = -1;
 
        this->setVerticalScrollMode(ScrollMode::ScrollPerPixel);
 
        setObjectName(QString::fromUtf8("tableLog"));
        QSizePolicy sizePolicy2(QSizePolicy::Expanding, QSizePolicy::Expanding);
        sizePolicy2.setHorizontalStretch(10);
        sizePolicy2.setVerticalStretch(10);
        sizePolicy2.setHeightForWidth(sizePolicy().hasHeightForWidth());
        setSizePolicy(sizePolicy2);
        setSizeIncrement(QSize(1, 0));
        setEditTriggers(QAbstractItemView::DoubleClicked); //QAbstractItemView::NoEditTriggers
        setAlternatingRowColors(true);
        setShowGrid(true);
        setGridStyle(Qt::SolidLine);
        setSortingEnabled(false);
        setWordWrap(true);
        setCornerButtonEnabled(true);
 
        setSelectionMode(QAbstractItemView::SingleSelection);
        setSelectionBehavior(QAbstractItemView::SelectRows);
 
        horizontalHeader()->setVisible(true);
        horizontalHeader()->setCascadingSectionResizes(true);
        horizontalHeader()->setDefaultSectionSize(100);
        horizontalHeader()->setMinimumSectionSize(20);
        horizontalHeader()->setStretchLastSection(true);
        verticalHeader()->setVisible(false);
        verticalHeader()->setDefaultSectionSize(20);
 
        //    verticalHeader()->setResizeMode(QHeaderView::ResizeToContents);
 
        setModel(new LogTableModel(this));
        //connect(model(), SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(dataChanged(QModelIndex,QModelIndex)));
        setColumnWidth(0, 90);
        setColumnWidth(1, 90);
        setColumnWidth(2, 90);
        setColumnWidth(3, 60);
        setColumnWidth(4, 700);
        setColumnWidth(5, 150);
        setColumnWidth(6, 200);
        hideColumn(7);
 
        QFont font;
        font.setPointSize(8);
        setFont(font);
 
 
        setItemDelegateForColumn(getModel()->getColumn(ARMARX_LOG_MESSAGESTR),
                                 new LogMessageDelegate());
 
        QAbstractItemModel* absmodel = qobject_cast<QAbstractItemModel*>(model());
        connect(absmodel,
                SIGNAL(rowsAboutToBeInserted(QModelIndex, int, int)),
                this,
                SLOT(checkAutoScroll(QModelIndex, int, int)));
        connect(
            this, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(doubleClickOnCell(QModelIndex)));
 
        setContextMenuPolicy(Qt::CustomContextMenu);
        connect(this,
                SIGNAL(customContextMenuRequested(QPoint)),
                this,
                SLOT(showContextMenu(QPoint)));
        connect(absmodel,
                SIGNAL(dataChanged(QModelIndex, QModelIndex)),
                this,
                SLOT(itemsAdded(QModelIndex, QModelIndex)));
        connect(verticalScrollBar(), SIGNAL(valueChanged(int)), this, SLOT(checkAutoScroll()));
 
        //    connect(this, SIGNAL(scrollToEnd()), this, SLOT(scrollToBottom()));
    }
 
    LogTable::~LogTable()
    {
    }
 
    void
    LogTable::showContextMenu(const QPoint& pos)
    {
        const QModelIndex index = indexAt(pos);
        if (!index.isValid())
        {
            return;
        }
 
        const int row = index.row();
        // Capture the sequence number, not the row: rows shift as the log grows and trims,
        // the sequence number does not.
        const LogSeq seq = getModel()->seqAt(row);
 
        QMenu menu(this);
        if (getModel()->isRowMarked(row))
        {
            QAction* removeAction = menu.addAction(tr("Remove label"));
            connect(removeAction,
                    &QAction::triggered,
                    this,
                    [this, seq] { emit removeLabelRequested(seq); });
        }
        else
        {
            QAction* addAction = menu.addAction(tr("Add label"));
            connect(
                addAction, &QAction::triggered, this, [this, seq] { emit addLabelRequested(seq); });
        }
        menu.exec(viewport()->mapToGlobal(pos));
    }
 
    void
    LogTable::notifyNewMessages(int count, MessageType maxLevel)
    {
        newMessageCount += count;
        if (maxLevel > maxNewLogLevelType)
        {
            maxNewLogLevelType = maxLevel;
        }
    }
 
    QString
    LogTable::getCurrentLiveFilter() const
    {
        return currentLiveFilter;
    }
 
    void
    LogTable::liveFilterRow(const QString& filterStr, int row)
    {
        LogTableModel* logModel = getModel();
        bool contains = logModel->rowContainsString(row, filterStr);
        if (!isRowHidden(row) && !contains)
        {
            setRowHidden(row, true);
        }
        else if (isRowHidden(row) && contains)
        {
            setRowHidden(row, false);
        }
    }
 
    void
    LogTable::liveFilter(const QString& filterStr, int startRow)
    {
        LogTableModel* logModel = getModel();
        currentLiveFilter = filterStr;
        if (filterStr.length() && filterStr.contains(lastLiveFilter))
        {
            // incremental filter - Only remove not fitting entries
            int rowCount = model()->rowCount();
 
            for (int i = startRow; i < rowCount; i++)
            {
                if (!isRowHidden(i) && !logModel->rowContainsString(i, filterStr))
                {
                    setRowHidden(i, true);
                }
                if (i % 1000 == 0)
                {
                    qApp->processEvents();
                }
                if (filterStr != currentLiveFilter)
                {
                    break; // filterstring already changed again -> cancel
                }
            }
        }
        else
        {
            // filter from scratch
            //        clear();
            //        setRowCount(0);
            //        QList<QTableWidgetItem*>results = findItems(filterStr,Qt::MatchContains);
            //        foreach(QTableWidgetItem*item, results)
            //        {
            //            if(applyFilters(item))
            //                item->
            //        }
            int rowCount = model()->rowCount();
 
            for (int i = startRow; i < rowCount; i++)
            {
                if (isRowHidden(i))
                {
                    if (logModel->rowContainsString(i, filterStr))
                    {
                        setRowHidden(i, false);
                    }
                }
                else if (!logModel->rowContainsString(i, filterStr))
                {
                    setRowHidden(i, true);
                }
                if (i % 1000 == 0)
                {
                    qApp->processEvents();
                }
                if (filterStr != currentLiveFilter)
                {
                    break; // filterstring already changed again -> cancel
                }
            }
 
            //        std::cout << "logBuffer: " << logBuffer.size() <<   std::endl;
            //        for(unsigned int i=0; i < logBuffer.size(); i++)
            //        {
            //            if(msgContainsString(logBuffer[i], filterStr) && applyFilters(logBuffer[i]) )
            //                addEntry(logBuffer[i], true);
            //        }
        }
 
        lastLiveFilter = filterStr;
    }
 
    bool
    LogTable::liveSearch(const QString& search)
    {
        getModel()->search(search);
        //    scrollToBottom();
        clearSelection();
        return selectNextSearchResult(true, true);
    }
 
    void
    LogTable::resetLiveFilter()
    {
        //    ARMARX_WARNING_S << "LiveFilterReseted";
        selectedSearchIndex = -1;
        lastLiveFilter = "";
        liveFilter("");
    }
 
    void
    LogTable::resetLiveSearch()
    {
        getModel()->search("");
        //    repaint();
    }
 
    LogTableModel*
    LogTable::getModel()
    {
        return dynamic_cast<LogTableModel*>(model());
    }
 
    bool
    LogTable::checkAutoScroll(const QModelIndex& parent, int start, int end)
    {
        return checkAutoScroll();
    }
 
    bool
    LogTable::checkAutoScroll(int dummy)
    {
        if (verticalScrollBar()->value() == verticalScrollBar()->maximum())
        {
            autoscrollActive = true;
        }
        else
        {
            autoscrollActive = false;
        }
 
 
        return autoscrollActive;
    }
 
    void
    LogTable::itemsAdded(QModelIndex leftTop, QModelIndex bottomRight)
    {
    }
 
    void
    LogTable::showEvent(QShowEvent* event)
    {
        QTableView::showEvent(event);
        resetNewMessageCount();
 
        // Materialise: while hidden the model keeps no rows at all, only a count of what
        // it accepted. Rebuilding them from the shared store is what makes ingestion
        // independent of the number of filters.
        getModel()->setMaterialised(true);
        applyRowHeights(0, getModel()->rowCount() - 1);
 
        if (autoscrollActive)
        {
            QTimer::singleShot(
                50,
                this,
                SLOT(
                    scrollToBottom())); // delayed because something is inserting one line after this function or something
        }
    }
 
    void
    LogTable::hideEvent(QHideEvent*)
    {
        if (verticalScrollBar()->value() == verticalScrollBar()->maximum())
        {
            autoscrollActive = true;
        }
        else
        {
            autoscrollActive = false;
        }
 
        // Release the rows; they are rebuilt from the shared store on the next showEvent.
        getModel()->setMaterialised(false);
    }
 
    void
    LogTable::applyRowHeights(int start, int end)
    {
        LogTableModel* logModel = getModel();
        const int fontHeight = QFontMetrics(font()).height();
        const int rowCount = logModel->rowCount();
        for (int i = std::max(0, start); i <= end && i < rowCount; ++i)
        {
            // Use the precomputed line count instead of re-fetching and splitting the
            // message string (which the model already built once at insert time).
            const int stringRows = logModel->lineCountAt(i);
            if (stringRows > 1)
            {
                setRowHeight(i, fontHeight * stringRows + 1);
            }
        }
    }
 
    void
    LogTable::rowsInserted(const QModelIndex& parent, int start, int end)
    {
        // The base implementation keeps the view's geometries, scroll ranges and editor
        // positions in sync. It was previously skipped entirely.
        QTableView::rowsInserted(parent, start, end);
 
        // Only a materialised (i.e. visible) model inserts rows at all -- a hidden one
        // just counts, and feeds that count in via notifyNewMessages().
        applyRowHeights(start, end);
 
        // Autoscrolling is done once per batch by LogViewer::insertPendingEntries, rather
        // than once per inserted row here.
    }
 
    void
    LogTable::rowsAboutToBeRemoved(const QModelIndex& parent, int start, int end)
    {
        // The base implementation drops selections and persistent indexes for the rows
        // that are about to disappear. It was previously skipped entirely, which only
        // began to matter once the model gained a bounded history and actually started
        // removing rows at runtime.
        QTableView::rowsAboutToBeRemoved(parent, start, end);
 
        if (end - start >= model()->rowCount() - 1)
        {
            resetNewMessageCount();
        }
    }
 
    bool
    LogTable::selectNextSearchResult(bool backwards, bool keepSelectionIfPossible)
    {
 
        int checkCounter = 0; // just a counter for avoiding inifite loops
        int tempSelectedSearchIndex = indexAt(QPoint(10, 10)).row();
 
        if (selectedIndexes().size() > 0)
        {
            tempSelectedSearchIndex = selectedIndexes()[0].row();
        }
 
        int oldSelectedSearchIndex = tempSelectedSearchIndex;
 
        do // search until we reach old line again
        {
 
            if ((tempSelectedSearchIndex != oldSelectedSearchIndex || keepSelectionIfPossible) &&
                getModel()->rowContainsString(tempSelectedSearchIndex,
                                              getModel()->getCurrentSearchStr()))
            {
                selectRow(tempSelectedSearchIndex);
                return true;
            }
 
            if (backwards)
            {
                tempSelectedSearchIndex--;
            }
            else
            {
                tempSelectedSearchIndex++;
            }
 
            if (tempSelectedSearchIndex >= model()->rowCount())
            {
                tempSelectedSearchIndex = 0;
            }
 
            if (tempSelectedSearchIndex < 0)
            {
                tempSelectedSearchIndex = model()->rowCount() - 1;
            }
 
 
            checkCounter++;
 
            if (checkCounter > model()->rowCount())
            {
                break;
            }
        } while (tempSelectedSearchIndex != oldSelectedSearchIndex);
 
        return false;
    }
 
    void
    LogTable::doubleClickOnCell(const QModelIndex& index)
    {
        if (index.column() != getModel()->getColumn(ARMARX_LOG_FILESTR))
        {
            return;
        }
 
        std::string fileWithLineNumber = model()->data(index).toString().toStdString();
        const auto colonPos = fileWithLineNumber.rfind(':');
        if (colonPos == std::string::npos)
        {
            // No "file:line" content (e.g. an entry without a source location).
            return;
        }
        std::string file = fileWithLineNumber.substr(0, colonPos);
        std::string line = fileWithLineNumber.substr(colonPos + 1);
 
        if (!std::filesystem::exists(file))
        {
            ARMARX_INFO << "File '" << file << "' does not exists - cannot open it.";
            return;
        }
 
        fileOpener.openFileWithDefaultEditor(file, atoi(line.c_str()));
        //    std::string command = "qtcreator -client " + fileWithLineNumber.toStdString() + "&";
        //    if(system(command.c_str())){}
    }
} // namespace armarx