NodeInfo.cpp

#include "ErrorHandler/Components/NodeInfo.h"
#include <sstream>

#include <QtGui/QPainter>

using namespace novadaq::errorhandler;

NodeInfo::NodeInfo(node_type_t type, std::string const& key, QListWidget* parent, bool aow, bool aoe)
    : msgs_ptr(new msgs_t)
    , highest_sev(SDEBUG)
    , item_ptr()
    , node_type(type)
    , key_str(key)
    , alarm_warning(aow)
    , alarm_error(aoe)
{
    QString cap = get_caption(key);

    // icon
    int icon_w = 0;
    int icon_h = 0;
    get_icon_geometry(icon_w, icon_h);

    QPixmap pm(icon_w, icon_h);
    QIcon icon(pm);

    // list widget item
    item_ptr = new QListWidgetItem(icon, cap, parent);

    // node size
    int node_w = 0;
    int node_h = 0;
    get_node_geometry(node_w, node_h);
    QSize sz(node_w, node_h);
    item_ptr->setSizeHint(sz);

    // user data
    QVariant v = qVariantFromValue((void*)this);
    item_ptr->setData(Qt::UserRole, v);

    //item_ptr->setData(Qt::UserRole, QVariant(key.c_str()));
    //item_ptr->setData(Qt::UserRole, QVariant::fromValue<msgs_ptr_t>(msgs_ptr));
}

node_status NodeInfo::push_msg(qt_mf_msg const& msg)
{
    sev_code_t sev = msg.sev();

    node_status status = NORMAL;

    if (sev >= highest_sev)
    {
        // push the message into the queue
        if (msgs_ptr->size() > MAX_QUEUE) msgs_ptr->pop_front();
        msgs_ptr->push_back(msg);

        // update icon
        if (sev > highest_sev)
        {
            if (sev == SWARNING && alarm_warning)
                status = FIRST_WARNING;
            else if (sev == SERROR && alarm_error)
                status = FIRST_ERROR;

            update_icon(sev);
        }

        // update hightest severity lvl
        highest_sev = sev;
    }

    return status;
}

void NodeInfo::reset()
{
    highest_sev = SDEBUG;
    update_icon(highest_sev);
}

QString NodeInfo::msgs_to_string() const
{
    QString txt;

    msgs_t::const_iterator it = msgs_ptr->begin();
    while (it != msgs_ptr->end())
    {
        txt += (*it).text(false);
        ++it;
    }

    return txt;
}

void NodeInfo::update_icon(sev_code_t sev)
{
    int icon_w = 0;
    int icon_h = 0;
    get_icon_geometry(icon_w, icon_h);

    QPixmap pm(icon_w, icon_h);
    pm.fill(Qt::transparent);

    QColor background;

    switch (sev)
    {
        case SERROR:
            background = QColor(255, 0, 0, 255);
            break;

        case SWARNING:
            background = QColor(224, 128, 0, 255);
            break;

        case SINFO:
            background = QColor(0, 128, 0, 255);
            break;

        case SDEBUG:
            background = QColor(80, 80, 80, 255);
            break;

        default:
            background = QColor(200, 200, 200);
    }

    QPainter painter(&pm);

    QRect rect(2, 2, icon_w - 4, icon_h - 4);
    painter.setPen(Qt::NoPen);
    painter.fillRect(rect, background);

    QPen pen(Qt::black);
    painter.setPen(pen);

    QBrush brush(Qt::yellow);

    if (alarm_warning)
    {
        int off = alarm_error ? 22 : 11;
        QBrush brush(Qt::yellow);
        painter.setBrush(brush);
        painter.drawEllipse(icon_w - off, icon_h - 11, 10, 10);
    }

    if (alarm_error)
    {
        QBrush brush(Qt::red);
        painter.setBrush(brush);
        painter.drawEllipse(icon_w - 11, icon_h - 11, 10, 10);
    }

    QIcon icon(pm);

    item_ptr->setIcon(icon);
}

void NodeInfo::get_icon_geometry(int& icon_w, int& icon_h) const
{
    switch (node_type)
    {
        case External:
            icon_w = BUFFERNODE_ICON_WIDTH;
            icon_h = BUFFERNODE_ICON_HEIGHT;
            break;
        case UserCode:
            icon_w = DCM_ICON_WIDTH;
            icon_h = DCM_ICON_HEIGHT;
            break;
        case Framework:
        default:
            icon_w = MAINCOMPONENT_ICON_WIDTH;
            icon_h = MAINCOMPONENT_ICON_HEIGHT;
    }
}

void NodeInfo::get_node_geometry(int& node_w, int& node_h) const
{
    switch (node_type)
    {
        case External:
            node_w = BUFFERNODE_NODE_WIDTH;
            node_h = BUFFERNODE_NODE_HEIGHT;
            break;
        case UserCode:
            node_w = DCM_NODE_WIDTH;
            node_h = DCM_NODE_HEIGHT;
            break;
        case Framework:
        default:
            node_w = MAINCOMPONENT_NODE_WIDTH;
            node_h = MAINCOMPONENT_NODE_HEIGHT;
    }
}

QString NodeInfo::get_caption(std::string const& key) const
{
    //if (node_type==BufferNode)  return key.substr(18).c_str();
    //if (node_type==DCM)         return key.substr(4 ).c_str();

    return key.c_str();
}