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 <algorithm>
#include <iterator>
#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));
        // Sorting stays off here: with it enabled, every setText() on an item -- i.e.
        // every new-message badge update -- re-sorts the entire tree. The filter set only
        // changes when a filter is added, so sortFilterList() is called explicitly there.
        ui.lvFilters->setSortingEnabled(false);
        sortFilterList();
        pendingEntriesTimer = new QTimer(getWidget());
        pendingEntriesTimer->setInterval(50);
 
        connect(pendingEntriesTimer, SIGNAL(timeout()), this, SLOT(insertPendingEntries()));
        connect(this, SIGNAL(componentConnected()), pendingEntriesTimer, SLOT(start()));
 
        // The new-message badges do not need the ingest rate; refreshing them relayouts
        // and repaints the filter tree.
        filterBadgeTimer = new QTimer(getWidget());
        filterBadgeTimer->setInterval(250);
        connect(filterBadgeTimer, SIGNAL(timeout()), this, SLOT(updateFilterList()));
        connect(this, SIGNAL(componentConnected()), filterBadgeTimer, 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::sortFilterList()
    {
        ui.lvFilters->sortItems(0, Qt::AscendingOrder);
    }
 
    QString
    LogViewer::autoFilterId(const QString& loggingGroupName, const QString& componentName) const
    {
        const QString filler =
            (loggingGroupName.length() > 0 && componentName.length() > 0) ? "_" : "";
        return loggingGroupNameToFilterName(loggingGroupName) + filler + componentName;
    }
 
    LogTable*
    LogViewer::ensureAutoFilter(const QString& filterId,
                                const QString& loggingGroupName,
                                const QString& componentName,
                                bool mayCreate)
    {
        if (filterId.isEmpty())
        {
            return nullptr;
        }
 
        const auto it = autoFilterMap.find(filterId);
        if (it != autoFilterMap.end())
        {
            return it.value();
        }
 
        if (!mayCreate || !ui.cbAutoComponentFilters->isChecked() || filterMap.count(filterId))
        {
            // Auto filters are switched off, or the id is already taken by a user-created
            // filter -- which is a general filter and therefore already sees this message.
            return nullptr;
        }
 
        const QString filterName = componentName.length() > 0
                                       ? componentName
                                       : loggingGroupNameToFilterName(loggingGroupName);
        ARMARX_CHECK_EXPRESSION(!filterName.isEmpty());
 
        LogTable* table = addFilter(
            filterId, filterName, loggingGroupName, componentName, "", eDEBUG, "", "", "");
        if (table)
        {
            // addFilter registers every new table as a general filter; this one can be
            // routed to, so move it into the dispatch map.
            generalFilters.erase(std::remove(generalFilters.begin(), generalFilters.end(), table),
                                 generalFilters.end());
            autoFilterMap.insert(filterId, table);
        }
        return table;
    }
 
    void
    LogViewer::ingestBatch(LogTable* table, const std::vector<LogSeq>& seqs)
    {
        if (!table || seqs.empty())
        {
            return;
        }
 
        const QString liveFilter = table->getCurrentLiveFilter();
        MessageType batchMaxLevel = eUNDEFINED;
        const int rowsAdded = table->getModel()->addEntries(seqs, &batchMaxLevel);
 
        if (!table->getModel()->isMaterialised())
        {
            // A hidden table builds no rows, so its rowsInserted never fires; feed the
            // new-message badge from here instead.
            table->notifyNewMessages(rowsAdded, batchMaxLevel);
            return;
        }
 
        if (rowsAdded > 0 && !liveFilter.isEmpty())
        {
            // The new rows are always the last rowsAdded ones. The row count is re-read
            // here because addEntries() may have trimmed the buffer, which shifts every
            // index down.
            const int count = table->getModel()->rowCount();
            for (int r = std::max(0, count - rowsAdded); r < count; r++)
            {
                table->liveFilterRow(liveFilter, r);
            }
        }
    }
 
    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);
            if (pendingEntries.size() >= maxPendingEntries)
            {
                // The GUI thread cannot keep up. Drop rather than let the backlog grow
                // without bound, which would only make the next tick slower still. The
                // count is surfaced in the status bar by updateFilterList().
                ++droppedEntryCount;
                return;
            }
            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()
    {
        // Drop the shared history first, so that clearData() below records a watermark past
        // everything and no filter can bring old lines back when it is next materialised.
        store.clear();
 
        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()
    {
        // A pin lives exactly as long as the store keeps the line it refers to. With a
        // shared store that is a single range check per marker, instead of searching every
        // filter's buffer for a matching message.
        markerRegistry.expireBefore(store.firstSeq());
    }
 
    void
    LogViewer::pauseLogging(bool pause)
    {
        loggingPaused = pause;
    }
 
    void
    LogViewer::setupLogTable(LogTable* logTable)
    {
        // Every filter is a view onto the one shared buffer; it keeps sequence numbers into
        // it rather than its own copies of the messages.
        logTable->getModel()->setStore(&store);
 
        // 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](LogSeq seq) { markerRegistry.add(seq); });
        connect(logTable,
                &LogTable::removeLabelRequested,
                this,
                [this](LogSeq seq)
                {
                    if (const LogMarkerId id = markerRegistry.markerIdForSeq(seq))
                    {
                        markerRegistry.remove(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;
        // "All Messages" has no filters at all, so it can never be routed on.
        generalFilters.push_back(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;
        // Register as a general filter by default, so that any caller gets a table that
        // actually receives messages. ensureAutoFilter() promotes the auto-generated ones
        // into the dispatch map afterwards.
        generalFilters.push_back(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);
        }
        // The tree's own sorting is off, so re-sort explicitly now that the set changed.
        sortFilterList();
 
        ui.splitter->addWidget(newLogTable);
        return newLogTable;
    }
 
    bool
    LogViewer::checkAndAddNewFilter(const QString& loggingGroupName, const QString& componentName)
    {
        if (componentName.length() == 0 && loggingGroupName.length() == 0)
        {
            return false;
        }
 
        const QString filterId = autoFilterId(loggingGroupName, componentName);
        const bool existedBefore = autoFilterMap.contains(filterId);
        return ensureAutoFilter(filterId, loggingGroupName, componentName, true) != nullptr &&
               !existedBefore;
    }
 
    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;
        // User-created filters use arbitrary substring criteria, so they cannot be routed
        // on and have to see every message.
        generalFilters.push_back(newLogTable);
        ui.lvFilters->insertTopLevelItem(ui.lvFilters->invisibleRootItem()->childCount(), item);
        // The tree's own sorting is off, so re-sort explicitly now that the set changed.
        sortFilterList();
        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());
        }
 
        // An edited filter no longer matches the (group, component) pair that its id
        // encodes, so it must not be routed on any more -- otherwise it would only ever be
        // offered the messages of the component it was originally generated for, and its
        // new criteria would silently never see anything else.
        if (autoFilterMap.remove(filterId) > 0)
        {
            generalFilters.push_back(logTable);
        }
 
        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;
            // Drop every routing reference before the table is destroyed.
            generalFilters.erase(
                std::remove(generalFilters.begin(), generalFilters.end(), logTable),
                generalFilters.end());
            autoFilterMap.remove(it->first);
            delete logTable;
            filterBadgeCache.erase(it->first);
            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;
            }
 
            // Skip items whose badge has not changed. Every setText() / setFont() /
            // setBackgroundColor() on the tree costs a relayout and a repaint, and in
            // steady state almost every item is unchanged.
            const int newCount =
                (curLogtable == logTable) ? 0 : curLogtable->getNewMessageCount();
            const MessageType newLevel = curLogtable->getMaxNewLogLevelType();
            const auto cached = filterBadgeCache.find(filterId);
            if (cached != filterBadgeCache.end() && cached->second.count == newCount &&
                cached->second.level == newLevel)
            {
                continue;
            }
            filterBadgeCache[filterId] = FilterBadge{newCount, newLevel};
 
            QString newContent;
 
            if (newCount == 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(newCount) + ")";
 
                if (newLevel == eWARN)
                {
                    item->setBackgroundColor(0, QColor(216, 120, 50));
                }
                else if (newLevel == eERROR)
                {
                    item->setBackgroundColor(0, QColor(255, 90, 80));
                }
                else if (newLevel == 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);
        }
 
        // Surface ingest overload: writeLog drops messages once the staging queue is
        // saturated, and silently losing log lines would be worse than a slow GUI.
        const unsigned long long dropped = droppedEntryCount.load();
        if (dropped != lastReportedDropCount)
        {
            lastReportedDropCount = dropped;
            if (getMainWindow() && getMainWindow()->statusBar())
            {
                getMainWindow()->statusBar()->showMessage(
                    QString("LogViewer: dropped %1 log messages (ingest overloaded)")
                        .arg(dropped),
                    5000);
            }
        }
    }
 
    void
    LogViewer::OpenConfigureDialog()
    {
        throw LocalException() << "Not yet implemented";
    }
 
    void
    LogViewer::refreshLabelsPanel()
    {
        ui.lvLabels->clear();
        for (const LogMarker& marker : markerRegistry.markers())
        {
            if (!store.contains(marker.seq))
            {
                continue;
            }
            const LogMessage& snapshot = store.at(marker.seq).message;
 
            // Color swatch.
            QPixmap swatch(12, 12);
            swatch.fill(marker.color);
 
            // Short, single-line description: time . component . message.
            IceUtil::Time time = IceUtil::Time::microSeconds(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(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(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 (matched or injected) in every filter, so it
            // resolves in whichever table is currently shown.
            const int row = logTable->getModel()->rowForSeq(marker.seq);
            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);
            if (pendingEntries.size() <= maxEntriesPerTick)
            {
                pendingEntriesTemp.swap(pendingEntries);
            }
            else
            {
                // Carry the remainder over to the next tick instead of letting a single
                // burst hold the GUI thread for an unbounded time.
                const auto batchEnd = pendingEntries.begin() + maxEntriesPerTick;
                pendingEntriesTemp.assign(std::make_move_iterator(pendingEntries.begin()),
                                          std::make_move_iterator(batchEnd));
                pendingEntries.erase(pendingEntries.begin(), batchEnd);
            }
        }
 
 
        // One pass over the batch: strip ANSI colours, create any missing auto-filter for
        // this group/component, and bucket the message by the auto-filters it can reach.
        // Bucketing here is what makes ingestion independent of the number of filters: a
        // message is afterwards only offered to the general filters plus the (at most two)
        // tables that can accept it, instead of to every table in filterMap.
        std::vector<LogSeq> wholeBatch;
        wholeBatch.reserve(pendingEntriesTemp.size());
        QHash<LogTable*, std::vector<LogSeq>> autoBuckets;
 
        // Compile the ANSI-color regex once, not on every timer tick.
        static const boost::regex re(REGEX_COLORS);
        for (LogMessage& msg : pendingEntriesTemp)
        {
            // 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, "");
            }
 
            // The message is stored exactly once here; every filter that accepts it only
            // keeps this sequence number.
            const LogSeq seq = store.append(msg);
            wholeBatch.push_back(seq);
 
            if (!getWidget())
            {
                continue;
            }
 
            const QString group = QString::fromStdString(msg.group);
            const QString component = QString::fromStdString(msg.who);
            // Creating a filter stays gated on the selected verbosity, as before. Routing
            // is deliberately not gated: a message below the current level still reaches an
            // already existing filter, which is what testing it against every filter did.
            const bool mayCreate = ui.cbVerbosityLevel->currentIndex() <= msg.type;
 
            const QString groupKey = autoFilterId(group, QString());
            const QString componentKey = autoFilterId(group, component);
 
            if (LogTable* groupTable = ensureAutoFilter(groupKey, group, QString(), mayCreate))
            {
                autoBuckets[groupTable].push_back(seq);
            }
            if (componentKey != groupKey)
            {
                if (LogTable* componentTable =
                        ensureAutoFilter(componentKey, group, component, mayCreate))
                {
                    autoBuckets[componentTable].push_back(seq);
                }
            }
        }
 
        // Sampled before inserting, because inserting rows moves the scrollbar maximum away
        // from the current value.
        const bool autoScroll =
            logTable &&
            logTable->verticalScrollBar()->value() == logTable->verticalScrollBar()->maximum();
 
        for (LogTable* log : generalFilters)
        {
            ingestBatch(log, wholeBatch);
        }
        for (auto it = autoBuckets.begin(); it != autoBuckets.end(); ++it)
        {
            ingestBatch(it.key(), it.value());
        }
 
        // Only the visible table is painted, so it is the only one that has to follow the
        // tail here; hidden tables scroll to the bottom in their showEvent.
        if (autoScroll && logTable)
        {
            logTable->scrollToBottom();
        }
 
        // Bound the shared history, then let every filter discard the rows whose entry has
        // just been dropped. This has to happen after ingestion, so the sequence numbers of
        // the batch stay valid while the models consume them.
        if (store.trim())
        {
            const LogSeq firstSeq = store.firstSeq();
            for (auto& filterEntry : filterMap)
            {
                filterEntry.second->getModel()->dropRowsBefore(firstSeq);
            }
            // A pin whose line has just left the store is now orphaned.
            expireOrphanedMarkers();
        }
    }
 
    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