mythuibuttontree.cpp

Go to the documentation of this file.

// Own header
#include "mythuibuttontree.h"

// Qt headers
#include <QDomDocument>

// Mythdb headers
#include "mythlogging.h"

// Mythui Headers
#include "mythmainwindow.h"

MythUIButtonTree::MythUIButtonTree(MythUIType *parent, const QString &name)
    : MythUIType(parent, name)
{
    m_initialized = false;

    m_numLists = 1;
    m_visibleLists = 0;
    m_currentDepth = m_oldDepth = m_depthOffset = 0;
    m_rootNode = m_currentNode = NULL;
    m_listSpacing = 0;
    m_activeList = NULL;
    m_activeListID = 0;

    m_active = true;

    m_listTemplate = NULL;
    SetCanTakeFocus(true);

    connect(this, SIGNAL(TakingFocus()), this, SLOT(Select()));
    connect(this, SIGNAL(LosingFocus()), this, SLOT(Deselect()));
}

MythUIButtonTree::~MythUIButtonTree()
{
}

void MythUIButtonTree::Init()
{
    if (!m_listTemplate)
        m_listTemplate = dynamic_cast<MythUIButtonList *>
                         (GetChild("listtemplate"));

    if (!m_listTemplate)
    {
        LOG(VB_GENERAL, LOG_ERR, QString("(%1) MythUIButtonList listtemplate "
                                         "is required in mythuibuttonlist: %2")
            .arg(GetXMLLocation().arg(objectName())));
        return;
    }

    m_listTemplate->SetVisible(false);

    int width = (m_Area.width() - (m_listSpacing * (m_numLists - 1))) / m_numLists;
    int height = m_Area.height();

    int i = 0;

    while (i < (int)m_numLists)
    {
        QString listname = QString("buttontree list %1").arg(i);
        MythUIButtonList *list = new MythUIButtonList(this, listname);
        list->CopyFrom(m_listTemplate);
        list->SetVisible(false);
        list->SetActive(false);
        list->SetCanTakeFocus(false);
        int x = i * (width + m_listSpacing);
        MythRect listArea = MythRect(x, 0, width, height);
        list->SetArea(listArea);
        m_buttonlists.append(list);
        i++;
    }

    m_initialized = true;
}

void MythUIButtonTree::SetTreeState(bool refreshAll)
{
    if (!m_initialized)
        Init();

    if (!m_rootNode)
        return;

    if (!m_currentNode)
        DoSetCurrentNode(m_rootNode->getSelectedChild());

    QList<MythGenericTree *> route = m_currentNode->getRoute();

    // Sanity Checks
    if (m_depthOffset >= route.size())
        m_depthOffset = 0;

    if (((int)m_currentDepth + m_depthOffset) >= route.size())
        m_currentDepth = 0;

    MythGenericTree *node = route.at(m_currentDepth + m_depthOffset);

    if (m_currentDepth != m_oldDepth)
        refreshAll = true;

    m_oldDepth = m_currentDepth;

    m_visibleLists = 0;
    uint listid = 0;

    while (listid < (uint)m_buttonlists.count())
    {
        MythUIButtonList *list = m_buttonlists.at(listid);

        list->SetVisible(false);
        list->SetActive(false);

        MythGenericTree *selectedNode = NULL;

        if (node)
            selectedNode = node->getSelectedChild(true);

        if (refreshAll || m_activeListID < listid)
        {
            if (!UpdateList(list, node))
            {
                listid++;
                continue;
            }
        }

        if (m_active && (listid == m_activeListID))
        {
            m_activeList = list;
            list->SetActive(true);
            DoSetCurrentNode(selectedNode);
            emit itemSelected(list->GetItemCurrent());
        }

        listid++;

        list->SetVisible(true);
        m_visibleLists++;

        node = selectedNode;
    }
}

bool MythUIButtonTree::UpdateList(MythUIButtonList *list, MythGenericTree *node)
{
    disconnect(list, 0, 0, 0);

    list->Reset();

    QList<MythGenericTree *> *nodelist = NULL;

    if (node)
        nodelist = node->getAllChildren();

    if (!nodelist || nodelist->isEmpty())
        return false;

    MythGenericTree *selectedNode = node->getSelectedChild(true);

    MythUIButtonListItem *selectedItem = NULL;
    QList<MythGenericTree *>::iterator it;

    for (it = nodelist->begin(); it != nodelist->end(); ++it)
    {
        MythGenericTree *childnode = *it;

        if (!childnode->IsVisible())
            continue;

        MythUIButtonListItem *item = childnode->CreateListButton(list);

        if (childnode == selectedNode)
            selectedItem = item;
    }

    if (list->IsEmpty())
        return false;

    if (selectedItem)
        list->SetItemCurrent(selectedItem);

    connect(list, SIGNAL(itemSelected(MythUIButtonListItem *)),
            SLOT(handleSelect(MythUIButtonListItem *)));
    connect(list, SIGNAL(itemClicked(MythUIButtonListItem *)),
            SLOT(handleClick(MythUIButtonListItem *)));
    connect(list, SIGNAL(itemVisible(MythUIButtonListItem *)),
            SLOT(handleVisible(MythUIButtonListItem *)));

    return true;
}

bool MythUIButtonTree::AssignTree(MythGenericTree *tree)
{
    if (!tree || !tree->visibleChildCount())
        return false;

    if (m_rootNode)
        Reset();

    m_rootNode = tree;
    m_currentNode = m_rootNode->getSelectedChild();
    // The node we are given may not be the root node of that tree, we need
    // to keep track of our depth in the tree so that we can navigate
    // as though the parent nodes do not exist
    m_depthOffset = m_rootNode->currentDepth();
    SetTreeState(true);
    emit rootChanged(m_rootNode);

    return true;
}

void MythUIButtonTree::Reset(void)
{
    m_rootNode = m_currentNode = NULL;
    m_visibleLists = 0;
    m_currentDepth = m_oldDepth = 0;
    m_activeList = NULL;
    m_activeListID = 0;
    m_active = true;

    SetTreeState(true);
    emit rootChanged(m_rootNode);

    MythUIType::Reset();
}

bool MythUIButtonTree::SetNodeById(QList<int> route)
{
    MythGenericTree *node = m_rootNode->findNode(route);

    if (node && node->isSelectable())
    {
        DoSetCurrentNode(node);
        SetTreeState();
        return true;
    }

    return false;
}

bool MythUIButtonTree::SetNodeByString(QStringList route)
{
    if (!m_rootNode)
    {
        DoSetCurrentNode(NULL);
        return false;
    }

    MythGenericTree *foundNode = m_rootNode;

    bool foundit = false;

    if (!route.isEmpty())
    {
        if (route[0] == m_rootNode->getString())
        {
            if (route.size() > 1)
            {
                for (int i = 1; i < route.size(); i ++)
                {
                    MythGenericTree *node = foundNode->getChildByName(route[i]);

                    if (node)
                    {
                        node->becomeSelectedChild();
                        foundNode = node;
                        foundit = true;
                    }
                    else
                    {
                        node = foundNode->getChildAt(0);

                        if (node)
                        {
                            node->becomeSelectedChild();
                            foundNode = node;
                        }

                        break;
                    }
                }
            }
            else
                foundit = true;
        }
    }

    DoSetCurrentNode(foundNode);

    m_currentDepth = qMax(0, (int)(foundNode->currentDepth() - m_depthOffset - m_numLists));
    m_activeListID = qMin(foundNode->currentDepth() - m_depthOffset - 1, (int)(m_numLists - 1));

    SetTreeState(true);

    return foundit;
}

bool MythUIButtonTree::SetCurrentNode(MythGenericTree *node)
{
    if (!node)
        return false;

    if (node == m_currentNode)
        return true;

    QStringList route = node->getRouteByString();

    return SetNodeByString(route);
}

void MythUIButtonTree::ShowSearchDialog(void)
{
    if (m_activeList)
        m_activeList->ShowSearchDialog();
}

bool MythUIButtonTree::DoSetCurrentNode(MythGenericTree *node)
{
    if (node)
    {
        if (node == m_currentNode)
            return true;

        m_currentNode = node;
        node->becomeSelectedChild();
        emit nodeChanged(m_currentNode);
        return true;
    }

    return false;
}

void MythUIButtonTree::RemoveItem(MythUIButtonListItem *item, bool deleteNode)
{
    if (!item || !m_rootNode)
        return;

    MythGenericTree *node = qVariantValue<MythGenericTree *>(item->GetData());

    if (node && node->getParent())
    {
        DoSetCurrentNode(node->getParent());

        if (deleteNode)
            node->getParent()->deleteNode(node);
        else
            node->SetVisible(false);
    }

    MythUIButtonList *list = item->parent();

    list->RemoveItem(item);

    if (list->IsEmpty())
    {
        if (m_currentDepth > 0)
            m_currentDepth--;
        else if (m_activeListID > 1)
            m_activeListID--;

        SetTreeState(true);
    }
}

void MythUIButtonTree::RemoveCurrentItem(bool deleteNode)
{
    RemoveItem(GetItemCurrent(), deleteNode);
}

void MythUIButtonTree::SetActive(bool active)
{
    m_active = active;

    if (m_initialized)
        SetTreeState();
}

void MythUIButtonTree::Select()
{
    SetActive(true);
}

void MythUIButtonTree::Deselect()
{
    SetActive(false);
}


void MythUIButtonTree::SwitchList(bool right)
{
    bool doUpdate = false;

    if (right)
    {
        if ((m_activeListID + 1 < m_visibleLists) &&
            (m_activeListID + 1 < (uint)m_buttonlists.count()))
            m_activeListID++;
        else if (m_currentNode && m_currentNode->visibleChildCount() > 0)
        {
            m_currentDepth++;
            doUpdate = true;
        }
        else
            return;
    }
    else if (!right)
    {
        if (m_activeListID > 0)
            m_activeListID--;
        else if (m_currentDepth > 0)
        {
            m_currentDepth--;
            doUpdate = true;
        }
        else
            return;
    }

    if (doUpdate)
        SetTreeState();
    else
    {
        if (m_activeList)
            m_activeList->Deselect();

        if (m_activeListID < (uint)m_buttonlists.count())
        {
            m_activeList = m_buttonlists[m_activeListID];
            m_activeList->Select();
        }
    }
}

void MythUIButtonTree::handleSelect(MythUIButtonListItem *item)
{
    if (!item)
        return;

    MythUIButtonList *list = item->parent();
    QString name = list->objectName();

    // New list is automatically selected so we just need to deselect the old
    // list
    if (m_activeList)
        m_activeList->Deselect();

    m_activeListID = name.section(' ', 2, 2).toInt();
    m_activeList = list;


    MythGenericTree *node = qVariantValue<MythGenericTree *> (item->GetData());
    DoSetCurrentNode(node);
    SetTreeState();
}

void MythUIButtonTree::handleClick(MythUIButtonListItem *item)
{
    if (!item)
        return;

    MythGenericTree *node = qVariantValue<MythGenericTree *> (item->GetData());

    if (DoSetCurrentNode(node))
        emit itemClicked(item);
}

MythUIButtonListItem *MythUIButtonTree::GetItemCurrent() const
{
    if (m_activeList)
        return m_activeList->GetItemCurrent();

    return NULL;
}

void MythUIButtonTree::handleVisible(MythUIButtonListItem *item)
{
    if (!item)
        return;

    emit itemVisible(item);
}

bool MythUIButtonTree::keyPressEvent(QKeyEvent *event)
{
    QStringList actions;
    bool handled = false;
    handled = GetMythMainWindow()->TranslateKeyPress("Global", event, actions);

    for (int i = 0; i < actions.size() && !handled; i++)
    {
        QString action = actions[i];
        handled = true;

        if (m_activeList && m_activeList->m_layout == MythUIButtonList::LayoutGrid)
        {
            if (action == "SELECT" && m_currentNode->visibleChildCount() > 0)
            {
                SwitchList(true);
            }
            else if (action == "ESCAPE" && m_currentDepth > 0)
            {
                SwitchList(false);
            }
            else
                handled = false;
        }
        else
        {
            if (action == "RIGHT" && m_currentNode->visibleChildCount() > 0)
            {
                SwitchList(true);
            }
            else if (action == "LEFT" && !(m_currentDepth == 0 && m_activeListID == 0))
            {
                SwitchList(false);
            }
            else
                handled = false;
        }
    }

    if (!handled && m_activeList)
        handled = m_activeList->keyPressEvent(event);

    return handled;
}

bool MythUIButtonTree::ParseElement(
    const QString &filename, QDomElement &element, bool showWarnings)
{
    if (element.tagName() == "spacing")
    {
        m_listSpacing = NormX(getFirstText(element).toInt());
    }
    else if (element.tagName() == "numlists")
    {
        m_numLists = getFirstText(element).toInt();
    }
    else
    {
        return MythUIType::ParseElement(filename, element, showWarnings);
    }

    return true;
}

void MythUIButtonTree::CreateCopy(MythUIType *parent)
{
    MythUIButtonTree *bt = new MythUIButtonTree(parent, objectName());
    bt->CopyFrom(this);
}

void MythUIButtonTree::CopyFrom(MythUIType *base)
{
    MythUIButtonTree *bt = dynamic_cast<MythUIButtonTree *>(base);

    if (!bt)
        return;

    m_numLists = bt->m_numLists;
    m_listSpacing = bt->m_listSpacing;
    m_active = bt->m_active;

    MythUIType::CopyFrom(base);

    m_listTemplate = dynamic_cast<MythUIButtonList *>(GetChild("listtemplate"));

    m_initialized = false;
}

---