LogViewer.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 "LogViewer.h"
 
#include <ArmarXCore/interface/core/ManagedIceObjectDefinitions.h>
 
#include <ArmarXGui/gui-plugins/LoggingPlugin/ui_FilterDialog.h>
 
#include "FilterDialog.h"
#include "LogTable.h"
#include "LogTableModel.h"
 
// C++ includes
#include <sstream>
 
// Qt includes
#include <boost/algorithm/string/regex.hpp>
 
#include <QColorDialog>
#include <QComboBox>
#include <QInputDialog>
#include <QListWidget>
#include <QMainWindow>
#include <QMenu>
#include <QPixmap>
#include <QScrollBar>
#include <QShortcut>
#include <QStatusBar>
#include <QTimer>
#include <QToolBar>
 
 
#define USERROLE_LOGTABLEID Qt::UserRole + 1
#define USERROLE_LOGTABLEPTR Qt::UserRole + 2
#define USERROLE_BASENAME Qt::UserRole + 3
#define REGEX_COLORS "\033\\[(\\d|\\w?)[;]?(\\d+)m"
#define ALL_MESSAGES_FILTER "All Messages"
 
namespace armarx
{
    LogViewer::LogViewer() :
        logTable(NULL), loggingPaused(false), verbosityLevel(1), customToolbar(0)
 
    {
        qRegisterMetaType<Qt::Orientation>("Qt::Orientation");
        qRegisterMetaType<std::string>("std::string");
        ui.setupUi(getWidget());
 
        for (int i = 0; i < eLogLevelCount; i++)
        {
            ui.cbVerbosityLevel->addItem(LogSender::levelToString((MessageTypeT)i).c_str());
        }
 
        ui.cbVerbosityLevel->setCurrentIndex(1);
        // Keep the atomic mirror of the verbosity level in sync so the Ice-thread
        // writeLog can read it without touching the QComboBox.
        verbosityLevel = ui.cbVerbosityLevel->currentIndex();
        connect(ui.cbVerbosityLevel,
                QOverload<int>::of(&QComboBox::currentIndexChanged),
                this,
                [this](int index) { verbosityLevel = index; });
        logTable = addEmptyFilter();
        ui.lvFilters->setCurrentItem(ui.lvFilters->invisibleRootItem()->child(0));
        ui.lvFilters->setSortingEnabled(true);
        ui.lvFilters->sortByColumn(0, Qt::AscendingOrder);
        pendingEntriesTimer = new QTimer(getWidget());
        pendingEntriesTimer->setInterval(50);
 
        connect(pendingEntriesTimer, SIGNAL(timeout()), this, SLOT(insertPendingEntries()));
        connect(this, SIGNAL(componentConnected()), pendingEntriesTimer, SLOT(start()));
 
 
        QList<int> sizes;
        sizes.push_back(80);
        sizes.push_back(400);
        ui.splitter->setSizes(sizes);
        addFilter(
            "Warning+",
            "Warning+",
            "",
            "",
            "",
            eWARN,
            "",
            "",
            ""); // add additional filters after splitter->setSizes-> otherwise they have a width of NULL
 
 
        qRegisterMetaType<LogMessage>("LogMessage");
 
        // SIGNALS AND SLOTS CONNECTIONS
        connect(
            ui.edtLiveFilter, SIGNAL(textChanged(QString)), this, SLOT(performLiveFilter(QString)));
        connect(
            ui.edtLiveSearch, SIGNAL(textChanged(QString)), this, SLOT(performLiveSearch(QString)));
        connect(ui.btnAddFilter, SIGNAL(clicked()), this, SLOT(addFilter()));
        connect(ui.btnRemoveFilter, SIGNAL(clicked()), this, SLOT(removeSelectedFilter()));
        connect(ui.btnPause, SIGNAL(toggled(bool)), this, SLOT(pauseLogging(bool)));
        connect(ui.btnClearLog, SIGNAL(clicked()), this, SLOT(clearSelectedLog()));
        connect(ui.btnClearAllLogs, SIGNAL(clicked()), this, SLOT(clearAllLogs()));
        connect(ui.lvFilters,
                SIGNAL(currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)),
                this,
                SLOT(filterSelectionChanged(QTreeWidgetItem*, QTreeWidgetItem*)));
        connect(ui.lvFilters,
                SIGNAL(itemDoubleClicked(QTreeWidgetItem*, int)),
                this,
                SLOT(editFilter(QTreeWidgetItem*, int)));
        connect(
            ui.cbSearchType, SIGNAL(currentIndexChanged(int)), this, SLOT(searchTypeChanged(int)));
        connect(this, SIGNAL(updateFilterListSignal()), this, SLOT(updateFilterList()));
        connect(ui.btnNextItem, SIGNAL(clicked()), this, SLOT(selectNextSearchResult()));
        connect(ui.btnPreviousItem, SIGNAL(clicked()), this, SLOT(selectPreviousSearchResult()));
 
        // Labels panel: mirror the pin registry, navigate on click, edit via context menu.
        connect(&markerRegistry, &LogMarkerRegistry::markersChanged, this, &LogViewer::refreshLabelsPanel);
        connect(ui.lvLabels, &QListWidget::itemClicked, this, &LogViewer::labelClicked);
        connect(ui.lvLabels,
                &QWidget::customContextMenuRequested,
                this,
                &LogViewer::showLabelsContextMenu);
        QShortcut* deleteLabelShortcut = new QShortcut(QKeySequence::Delete, ui.lvLabels);
        deleteLabelShortcut->setContext(Qt::WidgetShortcut);
        connect(deleteLabelShortcut, &QShortcut::activated, this, &LogViewer::removeSelectedLabel);
        refreshLabelsPanel();
 
        ui.edtLiveFilter->hide();
        ui.edtLiveSearch->setFocus();
    }
 
    LogViewer::~LogViewer()
    {
        //    ARMARX_VERBOSE << "~LogViewer";
    }
 
    void
    armarx::LogViewer::loadSettings(QSettings* settings)
    {
        ui.cbVerbosityLevel->setCurrentIndex(settings->value("verbosityLevel", 2).toInt());
        ui.cbAutoComponentFilters->setChecked(settings->value("autoFilterAdding", true).toBool());
    }
 
    void
    armarx::LogViewer::saveSettings(QSettings* settings)
    {
 
        settings->setValue("verbosityLevel", ui.cbVerbosityLevel->currentIndex());
 
        settings->setValue("autoFilterAdding", ui.cbAutoComponentFilters->isChecked());
 
 
        //    // saving filters
 
        //    QString filterName = ui.lvFilters->items()->data(USERROLE_LOGTABLEID).toString();
        //    for(unsigned int i= 0; i< logTable->getModel()->getFilters().size(); i++)
        //    {
        //        std::string columnName = logTable->getModel()->getFilters()[i].first;
        //        std::string filter = logTable->getModel()->getFilters()[i].second;
        //        if(columnName == ARMARX_LOG_COMPONENTSTR)
        //            filterDialog.ui->editComponent->setText(filter.c_str());
        //        else if(columnName == ARMARX_LOG_TAGSTR)
        //            filterDialog.ui->edtTag->setText(filter.c_str());
        //        else if(columnName == ARMARX_LOG_VERBOSITYSTR){
 
        //            filterDialog.ui->cbVerbosity->setCurrentIndex(QString(filter.c_str()).toInt());
        //        }
        //        else if(columnName == ARMARX_LOG_MESSAGESTR)
        //            filterDialog.ui->edtMessage->setText(filter.c_str());
        //        else if(columnName == ARMARX_LOG_FILESTR)
        //            filterDialog.ui->edtFile->setText(filter.c_str());
        //        else if(columnName == ARMARX_LOG_FUNCTIONSTR)
        //            filterDialog.ui->edtFunction->setText(filter.c_str());
        //    }
    }
 
    void
    armarx::LogViewer::onInitComponent()
    {
        usingTopic("Log");
    }
 
    void
    armarx::LogViewer::onConnectComponent()
    {
        emit componentConnected();
    }
 
    bool
    LogViewer::onClose()
    {
        //    QInputDialog dialog;
        //    if(dialog.exec() == QDialog::Rejected)
        //        return false;
 
        return ArmarXComponentWidgetController::onClose();
    }
 
    QString
    LogViewer::loggingGroupNameToFilterName(const QString& loggingGroupName) const
    {
        return loggingGroupName.isEmpty() ? "" : ("#" + loggingGroupName);
    }
 
    void
    LogViewer::onExitComponent()
    {
    }
 
    void
    LogViewer::write(const std::string& who,
                     Ice::Long time,
                     const std::string& tag,
                     MessageType severity,
                     const std::string& message,
                     const std::string& file,
                     Ice::Int line,
                     const std::string& function,
                     const Ice::Current&)
    {
        LogMessage msg;
        msg.who = who;
        msg.time = time;
        msg.tag = tag;
        msg.type = severity;
        msg.what = message;
        msg.file = file;
        msg.line = line;
        msg.function = function;
 
        writeLog(msg);
    }
 
    void
    LogViewer::writeLog(const LogMessage& msg, const Ice::Current&)
    {
        if (loggingPaused)
        {
            return;
        }
 
        // Runs on an Ice dispatch thread: use the mirrored verbosity level instead of
        // reading the (GUI-thread-only) QComboBox. insertPendingEntries re-checks the
        // level on the GUI thread anyway.
        if (verbosityLevel.load() <= msg.type)
        {
            std::unique_lock lock(pendingEntriesMutex);
            pendingEntries.push_back(msg);
        }
    }
 
    void
    LogViewer::performLiveFilter(QString filterStr, int startRow)
    {
        //    if((IceUtil::Time::now() - lastLiveSearchEditChangeTime).toSeconds() <  1)
        //        return;
        if (filterStr.length() == 0)
        {
            logTable->resetLiveFilter();
        }
        else if (filterStr.length() < 3)
        {
            return;
        }
 
        //    LogSearch search(logTable);
        //    search.search(searchStr);
        logTable->liveFilter(filterStr, startRow);
        lastLiveSearchEditChangeTime = IceUtil::Time::now();
    }
 
    void
    LogViewer::performLiveSearch(QString searchStr)
    {
        if (searchStr.length() == 0)
        {
            logTable->resetLiveSearch();
            ui.btnNextItem->setEnabled(false);
            ui.btnPreviousItem->setEnabled(false);
        }
        //    else if(searchStr.length() < 3)
        //        return;
        else
        {
            if (!logTable->liveSearch(searchStr))
            {
                getMainWindow()->statusBar()->showMessage(
                    "Could not find '" + logTable->getModel()->getCurrentSearchStr() +
                        "' in the log!",
                    5000);
                ui.btnNextItem->setEnabled(false);
                ui.btnPreviousItem->setEnabled(false);
            }
            else
            {
                ui.btnNextItem->setEnabled(true);
                ui.btnPreviousItem->setEnabled(true);
            }
        }
    }
 
    void
    LogViewer::clearSelectedLog()
    {
        if (logTable)
        {
            logTable->getModel()->clearData();
            // The cleared line may have been a pin's last native home.
            expireOrphanedMarkers();
        }
    }
 
    void
    LogViewer::clearAllLogs()
    {
        std::map<QString, LogTable*>::iterator it = filterMap.begin();
 
        for (; it != filterMap.end(); it++)
        {
            it->second->getModel()->clearData();
        }
 
        // Pins are log-scoped: clearing all logs drops them all.
        markerRegistry.clear();
 
        emit updateFilterListSignal();
    }
 
    void
    LogViewer::expireOrphanedMarkers()
    {
        // markers() returns a copy, so removing while iterating is safe.
        for (const LogMarker& marker : markerRegistry.markers())
        {
            bool nativeSomewhere = false;
            for (const auto& [filterId, table] : filterMap)
            {
                if (table->getModel()->containsNativeLine(marker.snapshot))
                {
                    nativeSomewhere = true;
                    break;
                }
            }
            if (!nativeSomewhere)
            {
                markerRegistry.remove(marker.id);
            }
        }
    }
 
    void
    LogViewer::pauseLogging(bool pause)
    {
        loggingPaused = pause;
    }
 
    void
    LogViewer::setupLogTable(LogTable* logTable)
    {
        // Share the pin registry so this filter's model injects/colors pinned lines and
        // stays in sync as pins are added or removed anywhere.
        logTable->getModel()->setMarkerRegistry(&markerRegistry);
 
        // Route the table's context-menu actions to the shared registry.
        connect(logTable,
                &LogTable::addLabelRequested,
                this,
                [this](const LogMessage& message) { markerRegistry.add(message); });
        connect(logTable,
                &LogTable::removeLabelRequested,
                this,
                [this](const LogMessage& message)
                {
                    if (const LogMarker* marker = markerRegistry.markerForMessage(message))
                    {
                        markerRegistry.remove(marker->id);
                    }
                });
    }
 
    LogTable*
    LogViewer::addEmptyFilter()
    {
        LogTable* newLogTable = new LogTable();
        setupLogTable(newLogTable);
        //    newLogTable->setColumns(standardColumns);
        QTreeWidgetItem* item = new QTreeWidgetItem(ui.lvFilters);
        QString standardFilterStr = ALL_MESSAGES_FILTER;
        item->setText(0, standardFilterStr);
        item->setData(0, USERROLE_LOGTABLEID, standardFilterStr);
        item->setData(0, USERROLE_BASENAME, standardFilterStr);
        //    item->setData(USERROLE_LOGTABLEPTR, qVariantFromValue((void*)newLogTable));
        //    ui.lvFilters->addItem(item);
        filterMap[standardFilterStr] = newLogTable;
        ui.splitter->addWidget(newLogTable);
 
        return newLogTable;
    }
 
    LogTable*
    LogViewer::addFilter(QString filterId,
                         QString filterName,
                         QString loggingGroup,
                         QString componentFilter,
                         QString tagFilter,
                         MessageType minimumVerbosity,
                         QString messageFilter,
                         QString fileFilter,
                         QString functionFilter)
    {
 
        if (filterMap.find(filterId) != filterMap.end())
        {
            QString msg = "A filter with the id " + filterId + " exists already";
            showMessageBox(msg);
            return NULL;
        }
 
        LogTable* newLogTable = new LogTable();
        setupLogTable(newLogTable);
        newLogTable->hide();
 
        // This helper builds the auto-generated per-group / per-component filters, which
        // must isolate exactly one group/component -- so match the group and component
        // values exactly rather than as substrings (otherwise "bar" would also collect
        // "foo_bar").
        if (loggingGroup.length())
        {
            newLogTable->getModel()->addFilter(
                ARMARX_LOG_LOGGINGGROUPSTR, loggingGroup.toStdString(), MatchMode::Exact);
        }
 
        //    newLogTable->setColumns(standardColumns);
        if (componentFilter.length())
        {
            newLogTable->getModel()->addFilter(
                ARMARX_LOG_COMPONENTSTR, componentFilter.toStdString(), MatchMode::Exact);
        }
 
        if (tagFilter.length())
        {
            newLogTable->getModel()->addFilter(ARMARX_LOG_TAGSTR, tagFilter.toStdString());
        }
 
        if (messageFilter.length())
        {
            newLogTable->getModel()->addFilter(ARMARX_LOG_MESSAGESTR, messageFilter.toStdString());
        }
 
        if (fileFilter.length())
        {
            newLogTable->getModel()->addFilter(ARMARX_LOG_FILESTR, fileFilter.toStdString());
        }
 
        if (functionFilter.length())
        {
            newLogTable->getModel()->addFilter(ARMARX_LOG_FUNCTIONSTR,
                                               functionFilter.toStdString());
        }
 
        newLogTable->getModel()->addFilter(ARMARX_LOG_VERBOSITYSTR,
                                           QString::number(minimumVerbosity).toStdString());
 
        QTreeWidgetItem* item = new QTreeWidgetItem();
        item->setText(0, filterName);
        //    item->setData(USERROLE_LOGTABLEPTR, qVariantFromValue((void*)newLogTable));
        item->setData(0, USERROLE_LOGTABLEID, filterId);
        item->setData(0, USERROLE_BASENAME, filterName);
        filterMap[filterId] = newLogTable;
        Ice::StringSeq children;
        for (int i = 0; i < ui.lvFilters->invisibleRootItem()->childCount(); i++)
        {
            children.push_back(ui.lvFilters->invisibleRootItem()->child(i)->text(0).toStdString());
        }
 
        QTreeWidgetItem* grpItem = NULL;
        auto grpFilterId = loggingGroupNameToFilterName(loggingGroup);
        for (int i = 0; i < ui.lvFilters->invisibleRootItem()->childCount(); i++)
        {
            if (ui.lvFilters->invisibleRootItem()
                    ->child(i)
                    ->data(0, USERROLE_BASENAME)
                    .toString() == grpFilterId)
            {
                grpItem = ui.lvFilters->invisibleRootItem()->child(i);
                break;
            }
        }
        if (grpItem)
        {
            grpItem->addChild(item);
            //        items.at(0)->sortChildren(0, Qt::AscendingOrder);
        }
        else
        {
            //        ARMARX_INFO << loggingGroup.toStdString() << " group not found - adding " <<  filterId.toStdString() << " as toplevel\n" << children;
            ui.lvFilters->insertTopLevelItem(0, item);
            //        ui.lvFilters->invisibleRootItem()->sortChildren(0, Qt::AscendingOrder);
        }
 
        ui.splitter->addWidget(newLogTable);
        return newLogTable;
    }
 
    bool
    LogViewer::checkAndAddNewFilter(const QString& loggingGroupName, const QString& componentName)
    {
        if (componentName.length() == 0 && loggingGroupName.length() == 0)
        {
            return false;
        }
 
        if (!ui.cbAutoComponentFilters->isChecked())
        {
            return false;
        }
        QString filler = (loggingGroupName.length() > 0 && componentName.length() > 0) ? "_" : "";
        auto filterId = loggingGroupNameToFilterName(loggingGroupName) + filler + componentName;
        auto filterName = componentName.length() > 0
                              ? componentName
                              : loggingGroupNameToFilterName(loggingGroupName);
        ARMARX_CHECK_EXPRESSION(!filterName.isEmpty());
        if (filterMap.count(filterId))
        {
            return false;
        }
 
        addFilter(filterId, filterName, loggingGroupName, componentName, "", eDEBUG, "", "", "");
        return true;
    }
 
    void
    LogViewer::addFilter()
    {
        FilterDialog filterDialog;
 
        if (!filterDialog.exec())
        {
            return;
        }
 
        QString filterName = filterDialog.ui->edtFilterName->text();
 
        if (filterMap.find(filterName) != filterMap.end())
        {
            QString msg = "A filter with this name already exists";
            showMessageBox(msg);
            return;
        }
 
        LogTable* newLogTable = new LogTable();
        setupLogTable(newLogTable);
        newLogTable->hide();
 
        //    newLogTable->setColumns(standardColumns);
        if (filterDialog.ui->editComponent->text().length())
        {
            newLogTable->getModel()->addFilter(
                ARMARX_LOG_COMPONENTSTR, filterDialog.ui->editComponent->text().toStdString());
        }
 
        if (filterDialog.ui->edtTag->text().length())
        {
            newLogTable->getModel()->addFilter(ARMARX_LOG_TAGSTR,
                                               filterDialog.ui->edtTag->text().toStdString());
        }
 
        if (filterDialog.ui->edtMessage->text().length())
        {
            newLogTable->getModel()->addFilter(ARMARX_LOG_MESSAGESTR,
                                               filterDialog.ui->edtMessage->text().toStdString());
        }
 
        if (filterDialog.ui->edtFile->text().length())
        {
            newLogTable->getModel()->addFilter(ARMARX_LOG_FILESTR,
                                               filterDialog.ui->edtFile->text().toStdString());
        }
 
        if (filterDialog.ui->edtFunction->text().length())
        {
            newLogTable->getModel()->addFilter(ARMARX_LOG_FUNCTIONSTR,
                                               filterDialog.ui->edtFunction->text().toStdString());
        }
 
        if (filterDialog.ui->cbVerbosity->currentIndex() != -1)
        {
            newLogTable->getModel()->addFilter(
                ARMARX_LOG_VERBOSITYSTR,
                QString::number(filterDialog.ui->cbVerbosity->currentIndex()).toStdString());
        }
 
        QTreeWidgetItem* item = new QTreeWidgetItem();
        item->setText(0, filterName);
        //    item->setData(USERROLE_LOGTABLEPTR, qVariantFromValue((void*)newLogTable));
        item->setData(0, USERROLE_LOGTABLEID, filterName);
        item->setData(0, USERROLE_BASENAME, filterName);
        filterMap[filterName] = newLogTable;
        ui.lvFilters->insertTopLevelItem(ui.lvFilters->invisibleRootItem()->childCount(), item);
        //    ui.lvFilters->invisibleRootItem()->sortChildren(0, Qt::AscendingOrder);
        ui.splitter->addWidget(newLogTable);
    }
 
    void
    LogViewer::editFilter(QTreeWidgetItem* item, int column)
    {
        QString filterId = item->data(0, USERROLE_LOGTABLEID).toString();
        FilterDialog filterDialog;
        filterDialog.ui->edtFilterName->setText(item->data(0, USERROLE_BASENAME).toString());
 
        if (filterMap.find(filterId) == filterMap.end())
        {
            ARMARX_WARNING << "filter " << filterId.toStdString() << " does not exist" << flush;
            return;
        }
 
        LogTable* logTable = filterMap.find(filterId)->second;
 
        if (!logTable)
        {
            ARMARX_WARNING << "logtable ptr is NULL " << flush;
            return;
        }
 
        for (const LogFilter& activeFilter : logTable->getModel()->getFilters())
        {
            const QString value = QString::fromStdString(activeFilter.value);
 
            switch (activeFilter.column)
            {
                case LogColumn::Component:
                    filterDialog.ui->editComponent->setText(value);
                    break;
                case LogColumn::Tag:
                    filterDialog.ui->edtTag->setText(value);
                    break;
                case LogColumn::Verbosity:
                    filterDialog.ui->cbVerbosity->setCurrentIndex(value.toInt());
                    break;
                case LogColumn::Message:
                    filterDialog.ui->edtMessage->setText(value);
                    break;
                case LogColumn::File:
                    filterDialog.ui->edtFile->setText(value);
                    break;
                case LogColumn::Function:
                    filterDialog.ui->edtFunction->setText(value);
                    break;
                default:
                    break;
            }
        }
 
 
        if (!filterDialog.exec())
        {
            return;
        }
        item->setText(0, filterDialog.ui->edtFilterName->text());
        item->setData(0, USERROLE_BASENAME, filterDialog.ui->edtFilterName->text());
        logTable->getModel()->resetFilters();
 
        if (filterDialog.ui->editComponent->text().length())
        {
            logTable->getModel()->addFilter(ARMARX_LOG_COMPONENTSTR,
                                            filterDialog.ui->editComponent->text().toStdString());
        }
 
        if (filterDialog.ui->edtTag->text().length())
        {
            logTable->getModel()->addFilter(ARMARX_LOG_TAGSTR,
                                            filterDialog.ui->edtTag->text().toStdString());
        }
 
        if (filterDialog.ui->edtMessage->text().length())
        {
            logTable->getModel()->addFilter(ARMARX_LOG_MESSAGESTR,
                                            filterDialog.ui->edtMessage->text().toStdString());
        }
 
        if (filterDialog.ui->edtFile->text().length())
        {
            logTable->getModel()->addFilter(ARMARX_LOG_FILESTR,
                                            filterDialog.ui->edtFile->text().toStdString());
        }
 
        if (filterDialog.ui->edtFunction->text().length())
        {
            logTable->getModel()->addFilter(ARMARX_LOG_FUNCTIONSTR,
                                            filterDialog.ui->edtFunction->text().toStdString());
        }
 
        if (filterDialog.ui->cbVerbosity->currentIndex() != -1)
        {
            logTable->getModel()->addFilter(
                ARMARX_LOG_VERBOSITYSTR,
                QString::number(filterDialog.ui->cbVerbosity->currentIndex()).toStdString());
        }
 
        logTable->getModel()->reapplyAllFilters();
        logTable->update();
    }
 
    void
    LogViewer::removeSelectedFilter()
    {
        if (ui.lvFilters->invisibleRootItem()->childCount() == 1)
        {
            return;
        }
 
        auto item = ui.lvFilters->currentItem();
        removeFilter(item);
    }
 
    void
    LogViewer::removeFilter(QTreeWidgetItem* item)
    {
        if (!item)
        {
            return;
        }
 
        std::map<QString, LogTable*>::iterator it =
            filterMap.find(item->data(0, USERROLE_LOGTABLEID).toString());
 
        if (it == filterMap.end())
        {
            return;
        }
        QList<QTreeWidgetItem*> itemsToDelete, iterationList({item});
        while (!iterationList.isEmpty())
        {
            auto curItem = iterationList.front();
            itemsToDelete << curItem;
            iterationList.pop_front();
            iterationList << curItem->takeChildren();
        }
        ui.lvFilters->setCurrentItem(ui.lvFilters->invisibleRootItem()->child(0));
        for (auto& item : itemsToDelete)
        {
            auto parent = item->parent();
            if (parent)
            {
                parent->removeChild(item);
            }
            else
            {
                ui.lvFilters->invisibleRootItem()->removeChild(item);
            }
            std::map<QString, LogTable*>::iterator it =
                filterMap.find(item->data(0, USERROLE_LOGTABLEID).toString());
            delete item;
 
            if (it == filterMap.end())
            {
                continue;
            }
            LogTable* logTable = it->second;
            delete logTable;
            filterMap.erase(it);
        }
    }
 
    void
    LogViewer::filterSelectionChanged(QTreeWidgetItem* item, QTreeWidgetItem* previous)
    {
        if (!item)
        {
            return;
        }
        LogTable* oldLogTable = logTable;
        QString filterId = item->data(0, USERROLE_LOGTABLEID).toString();
        //    item->setText(0, filterId); Why?
        QFont font;
        font.setBold(false);
        item->setFont(0, font);
 
        if (filterMap.find(filterId) == filterMap.end())
        {
            showMessageBox("Filtername " + filterId + " not found.");
            return;
        }
 
        logTable = filterMap[filterId];
 
        if (!logTable)
        {
            ARMARX_ERROR << "logTable ptr is NULL" << flush;
            return;
        }
 
 
        if (oldLogTable)
        {
            oldLogTable->hide();
        }
 
        logTable->show();
        ui.edtLiveFilter->setText(logTable->getLiveFilterStr());
        ui.edtLiveSearch->setText(logTable->getModel()->getCurrentSearchStr());
    }
 
    void
    LogViewer::updateFilterList()
    {
        static QFont font;
        QList<QTreeWidgetItem*> itemsToUpdate, iterationList({ui.lvFilters->invisibleRootItem()});
        while (!iterationList.isEmpty())
        {
            auto curItem = iterationList.front();
            itemsToUpdate << curItem;
            iterationList.pop_front();
            for (int i = 0; i < curItem->childCount(); ++i)
            {
                iterationList << curItem->child(i);
            }
        }
        // Update new message count in filter list box
        for (auto item : itemsToUpdate)
        {
            auto filterId = item->data(0, USERROLE_LOGTABLEID).toString();
            auto filterIt = filterMap.find(filterId);
            if (filterIt == filterMap.end())
            {
                // e.g. the invisible root item, whose id is empty and not in filterMap
                continue;
            }
            LogTable* curLogtable = filterIt->second;
            if (!curLogtable)
            {
                continue;
            }
            QString newContent;
 
            if (curLogtable == logTable || curLogtable->getNewMessageCount() == 0)
            {
                font.setBold(false);
                item->setFont(0, font);
                newContent = item->data(0, USERROLE_BASENAME).toString();
                item->setBackgroundColor(0, ui.lvFilters->palette().base().color());
            }
            else
            {
                font.setBold(true);
                item->setFont(0, font);
                newContent = item->data(0, USERROLE_BASENAME).toString() + "(" +
                             QString::number(curLogtable->getNewMessageCount()) + ")";
 
                if (curLogtable->getMaxNewLogLevelType() == eWARN)
                {
                    item->setBackgroundColor(0, QColor(216, 120, 50));
                }
                else if (curLogtable->getMaxNewLogLevelType() == eERROR)
                {
                    item->setBackgroundColor(0, QColor(255, 90, 80));
                }
                else if (curLogtable->getMaxNewLogLevelType() == eFATAL)
                {
                    item->setBackgroundColor(0, QColor(255, 60, 50));
                }
                else
                {
                    item->setBackgroundColor(0, ui.lvFilters->palette().base().color());
                }
            }
 
            item->setText(0, newContent);
            item->setToolTip(0, newContent);
        }
    }
 
    void
    LogViewer::OpenConfigureDialog()
    {
        throw LocalException() << "Not yet implemented";
    }
 
    void
    LogViewer::refreshLabelsPanel()
    {
        ui.lvLabels->clear();
        for (const LogMarker& marker : markerRegistry.markers())
        {
            // Color swatch.
            QPixmap swatch(12, 12);
            swatch.fill(marker.color);
 
            // Short, single-line description: time . component . message.
            IceUtil::Time time = IceUtil::Time::microSeconds(marker.snapshot.time);
            std::string timeStr = time.toDateTime();
            const auto spacePos = timeStr.find(' ');
            if (spacePos != std::string::npos)
            {
                timeStr = timeStr.substr(spacePos + 1);
            }
 
            QString what = QString::fromStdString(marker.snapshot.what);
            const int newlinePos = what.indexOf('\n');
            if (newlinePos >= 0)
            {
                what.truncate(newlinePos);
            }
            constexpr int maxWhatLength = 60;
            if (what.length() > maxWhatLength)
            {
                what.truncate(maxWhatLength);
                what += "...";
            }
 
            const QString text = QString::fromStdString(timeStr) + "  " +
                                 QString::fromStdString(marker.snapshot.who) + "  " + what;
 
            QListWidgetItem* item = new QListWidgetItem(QIcon(swatch), text, ui.lvLabels);
            item->setData(Qt::UserRole, static_cast<qulonglong>(marker.id));
            item->setToolTip(text);
        }
    }
 
    void
    LogViewer::labelClicked(QListWidgetItem* item)
    {
        if (!item || !logTable)
        {
            return;
        }
        const LogMarkerId id = static_cast<LogMarkerId>(item->data(Qt::UserRole).toULongLong());
 
        for (const LogMarker& marker : markerRegistry.markers())
        {
            if (marker.id != id)
            {
                continue;
            }
            // The pinned line is present (native or injected) in every filter, so it resolves
            // in whichever table is currently shown.
            const int row = logTable->getModel()->rowForMessage(marker.snapshot);
            if (row >= 0)
            {
                const QModelIndex index = logTable->getModel()->index(row, 0);
                logTable->scrollTo(index, QAbstractItemView::PositionAtCenter);
                logTable->selectRow(row);
                logTable->setFocus();
            }
            break;
        }
    }
 
    void
    LogViewer::showLabelsContextMenu(const QPoint& pos)
    {
        QListWidgetItem* item = ui.lvLabels->itemAt(pos);
        if (!item)
        {
            return;
        }
        const LogMarkerId id = static_cast<LogMarkerId>(item->data(Qt::UserRole).toULongLong());
 
        QMenu menu;
        QAction* recolorAction = menu.addAction(tr("Change color..."));
        QAction* removeAction = menu.addAction(tr("Remove label"));
        QAction* chosen = menu.exec(ui.lvLabels->viewport()->mapToGlobal(pos));
 
        if (chosen == removeAction)
        {
            markerRegistry.remove(id);
        }
        else if (chosen == recolorAction)
        {
            QColor initial;
            for (const LogMarker& marker : markerRegistry.markers())
            {
                if (marker.id == id)
                {
                    initial = marker.color;
                    break;
                }
            }
            const QColor color =
                QColorDialog::getColor(initial, getWidget(), tr("Choose label color"));
            if (color.isValid())
            {
                markerRegistry.recolor(id, color);
            }
        }
    }
 
    void
    LogViewer::removeSelectedLabel()
    {
        QListWidgetItem* item = ui.lvLabels->currentItem();
        if (!item)
        {
            return;
        }
        const LogMarkerId id = static_cast<LogMarkerId>(item->data(Qt::UserRole).toULongLong());
        markerRegistry.remove(id);
    }
 
    void
    LogViewer::insertPendingEntries()
    {
 
        if (getState() >= eManagedIceObjectExiting)
        {
            return;
        }
 
        std::vector<LogMessage> pendingEntriesTemp;
        {
            std::unique_lock lock(pendingEntriesMutex);
            pendingEntriesTemp.swap(pendingEntries);
        }
 
 
        unsigned int size = pendingEntriesTemp.size();
        // Compile the ANSI-color regex once, not on every timer tick.
        static const boost::regex re(REGEX_COLORS);
        // check for new components, that are sending log messages and perform auto scroll
        for (unsigned int i = 0; i < size; i++)
        {
            LogMessage& msg = pendingEntriesTemp[i];
            // Only run the regex if an escape character is actually present.
            if (msg.what.find('\033') != std::string::npos)
            {
                msg.what = boost::regex_replace(msg.what, re, "");
            }
 
            if (!getWidget() || ui.cbVerbosityLevel->currentIndex() > msg.type)
            {
                continue;
            }
            checkAndAddNewFilter(msg.group.c_str(), "");
            checkAndAddNewFilter(msg.group.c_str(), msg.who.c_str());
        }
 
        bool autoScroll = false;
 
        if (logTable->verticalScrollBar()->value() == logTable->verticalScrollBar()->maximum())
        {
            autoScroll = true;
        }
 
        std::map<QString, LogTable*>::iterator it = filterMap.begin();
 
        for (; it != filterMap.end(); ++it)
        {
            LogTable* log = it->second;
            int row = log->getModel()->rowCount();
            int rowsAdded =
                log->getModel()->addEntries(pendingEntriesTemp, log->getCurrentLiveFilter());
            if (rowsAdded > 0)
            {
                int count = log->getModel()->rowCount();
                int r;
                for (r = row; r < count; r++)
                {
                    log->liveFilterRow(log->getCurrentLiveFilter(), r);
                }
            }
            bool autoScroll = false;
 
            if (log->verticalScrollBar()->value() == log->verticalScrollBar()->maximum())
            {
                autoScroll = true;
            }
 
 
            if (autoScroll)
            {
                log->scrollToBottom();
            }
        }
 
 
        if (autoScroll)
        {
            logTable->scrollToBottom();
        }
 
        // Buffer trimming (enforceMaxEntries) may have dropped a pinned line's last native
        // row; expire such pins so they stay bound to the live log.
        expireOrphanedMarkers();
 
        updateFilterList();
    }
 
    void
    LogViewer::searchTypeChanged(int index)
    {
        if (index == 0)
        {
            ui.edtLiveSearch->show();
            ui.btnPreviousItem->show();
            ui.btnNextItem->show();
            ui.edtLiveFilter->hide();
        }
        else
        {
            ui.edtLiveSearch->hide();
            ui.btnPreviousItem->hide();
            ui.btnNextItem->hide();
            ui.edtLiveFilter->show();
        }
    }
 
    void
    LogViewer::selectNextSearchResult()
    {
 
        if (logTable)
        {
            if (!logTable->selectNextSearchResult(false))
            {
                getMainWindow()->statusBar()->showMessage(
                    "Could not find '" + logTable->getModel()->getCurrentSearchStr() +
                        "' in the log!",
                    5000);
            }
        }
    }
 
    void
    LogViewer::selectPreviousSearchResult()
    {
        if (logTable)
            if (!logTable->selectNextSearchResult(true))
            {
                getMainWindow()->statusBar()->showMessage(
                    "Could not find '" + logTable->getModel()->getCurrentSearchStr() +
                        "' in the log!",
                    5000);
            }
    }
 
    QPointer<QWidget>
    LogViewer::getCustomTitlebarWidget(QWidget* parent)
    {
        if (customToolbar)
        {
            if (parent != customToolbar->parent())
            {
                customToolbar->setParent(parent);
            }
 
            return customToolbar;
        }
 
        customToolbar = new QToolBar(parent);
        customToolbar->setIconSize(QSize(16, 16));
        customToolbar->addAction(
            QIcon(":/icons/configure-3.png"), "Configure", this, SLOT(OpenConfigureDialog()));
 
        return customToolbar;
    }
} // namespace armarx