mythcontrols.cpp

Go to the documentation of this file.

// -*- Mode: c++ -*-
// Qt headers
#include <QCoreApplication>
#include <QStringList>
 
// MythTV headers
#include "libmythbase/mythcorecontext.h"
#include "libmythbase/mythlogging.h"
#include "libmythui/mythdialogbox.h"
#include "libmythui/mythmainwindow.h"
#include "libmythui/mythuibutton.h"
#include "libmythui/mythuibuttonlist.h"
#include "libmythui/mythuitext.h"
 
// MythControls headers
#include "keygrabber.h"
#include "mythcontrols.h"
 
#define LOC QString("MythControls: ")
#define LOC_ERR QString("MythControls, Error: ")
 
MythControls::~MythControls()
{
    Teardown();
}
 
void MythControls::Teardown(void)
{
    if (m_bindings)
    {
        delete m_bindings;
        m_bindings = nullptr;
    }
 
    m_contexts.clear();
}
 
bool MythControls::Create(void)
{
    // Load the theme for this screen
    bool foundtheme = LoadWindowFromXML("controls-ui.xml", "controls", this);
    if (!foundtheme)
        return false;
 
    m_description = dynamic_cast<MythUIText *>(GetChild("description"));
    m_leftList = dynamic_cast<MythUIButtonList *>(GetChild("leftlist"));
    m_rightList = dynamic_cast<MythUIButtonList *>(GetChild("rightlist"));
    m_leftDescription = dynamic_cast<MythUIText *>(GetChild("leftdesc"));
    m_rightDescription = dynamic_cast<MythUIText *>(GetChild("rightdesc"));
 
    if (!m_description || !m_leftList || !m_rightList ||
            !m_leftDescription || !m_rightDescription)
    {
        LOG(VB_GENERAL, LOG_ERR, "Theme is missing critical theme elements.");
        return false;
    }
 
    connect(m_leftList,  &MythUIButtonList::itemSelected,
            this, &MythControls::LeftSelected);
    connect(m_leftList,  &MythUIButtonList::itemClicked,
            this, &MythControls::LeftPressed);
 
    connect(m_rightList, &MythUIButtonList::itemSelected,
            this, &MythControls::RightSelected);
    connect(m_rightList,  &MythUIButtonList::itemClicked,
            this, &MythControls::RightPressed);
    connect(m_rightList, &MythUIType::TakingFocus,
            this, &MythControls::RefreshKeyInformation);
 
    for (uint i = 0; i < Action::kMaximumNumberOfBindings; i++)
    {
        MythUIButton *button = dynamic_cast<MythUIButton *>
                (GetChild(QString("action_%1").arg(i)));
 
        if (!button)
        {
            LOG(VB_GENERAL, LOG_ERR, LOC +
                QString("Unable to load action button action_%1").arg(i));
 
            return false;
        }
 
        connect(button, &MythUIButton::Clicked, this, &MythControls::ActionButtonPressed);
 
        m_actionButtons.append(button);
    }
 
    BuildFocusList();
 
    LoadData(gCoreContext->GetHostName());
 
    /* start off with the actions by contexts view */
    m_currentView = kActionsByContext;
    SetListContents(m_leftList, m_bindings->GetContexts(), true);
    UpdateRightList();
 
    return true;
}
 
void MythControls::ChangeButtonFocus(int direction)
{
    if ((m_leftListType != kContextList) || (m_rightListType != kActionList))
        return;
 
    if (direction == 0)
        SetFocusWidget(m_actionButtons.at(0));
}
 
void MythControls::LeftPressed([[maybe_unused]] MythUIButtonListItem *item)
{
    NextPrevWidgetFocus(true);
}
 
void MythControls::RightPressed([[maybe_unused]] MythUIButtonListItem *item)
{
    if (m_currentView == kActionsByContext)
        ChangeButtonFocus(0);
}
 
void MythControls::ActionButtonPressed()
{
    QString key = GetCurrentKey();
    if (!key.isEmpty())
    {
        QString label = tr("Modify Action");
 
        MythScreenStack *popupStack =
                                GetMythMainWindow()->GetStack("popup stack");
 
        m_menuPopup =
                new MythDialogBox(label, popupStack, "actionmenu");
 
        if (m_menuPopup->Create())
            popupStack->AddScreen(m_menuPopup);
 
        m_menuPopup->SetReturnEvent(this, "action");
 
        m_menuPopup->AddButton(tr("Set Binding"));
        m_menuPopup->AddButton(tr("Remove Binding"));
    }
    else {
        // for blank keys, no reason to ask what to do
        GrabKey();
    }
}
 
void MythControls::ChangeView(void)
{
    QString label = tr("Change View");
 
    MythScreenStack *popupStack =
                            GetMythMainWindow()->GetStack("popup stack");
 
    m_menuPopup =
            new MythDialogBox(label, popupStack, "mcviewmenu");
 
    if (m_menuPopup->Create())
        popupStack->AddScreen(m_menuPopup);
 
    m_menuPopup->SetReturnEvent(this, "view");
 
    m_menuPopup->AddButton(tr("Actions By Context"));
    m_menuPopup->AddButton(tr("Contexts By Key"));
    m_menuPopup->AddButton(tr("Keys By Context"));
 
}
 
void MythControls::ShowMenu()
{
    QString label = tr("Options");
 
    MythScreenStack *popupStack =
                            GetMythMainWindow()->GetStack("popup stack");
 
    m_menuPopup =
            new MythDialogBox(label, popupStack, "optionmenu");
 
    if (m_menuPopup->Create())
        popupStack->AddScreen(m_menuPopup);
 
    m_menuPopup->SetReturnEvent(this, "option");
 
    m_menuPopup->AddButton(tr("Save"));
    m_menuPopup->AddButton(tr("Change View"));
    m_menuPopup->AddButton(tr("Reset All Keys to Defaults"));
}
 
void MythControls::Close()
{
    if (m_bindings && m_bindings->HasChanges())
    {
        /* prompt user to save changes */
        QString label = tr("Save changes?");
 
        MythScreenStack *popupStack =
                                GetMythMainWindow()->GetStack("popup stack");
 
        auto *confirmPopup = new MythConfirmationDialog(popupStack, label, true);
 
        if (confirmPopup->Create())
            popupStack->AddScreen(confirmPopup);
 
        confirmPopup->SetReturnEvent(this, "exit");
    }
    else
    {
        MythScreenType::Close();
    }
}
 
void MythControls::LeftSelected(MythUIButtonListItem* /*item*/)
{
    UpdateRightList();
}
 
void MythControls::RightSelected(MythUIButtonListItem* /*item*/)
{
    RefreshKeyInformation();
}
 
 
void MythControls::SetListContents(
    MythUIButtonList *uilist, const QStringList &contents, bool arrows)
{
    // remove all strings from the current list
    uilist->Reset();
 
    // add each new string
    for (const auto & content : std::as_const(contents))
    {
        auto *item = new MythUIButtonListItem(uilist, content);
        item->setDrawArrow(arrows);
    }
}
 
void MythControls::UpdateRightList(void)
{
    // get the selected item in the right list.
    MythUIButtonListItem *item = m_leftList->GetItemCurrent();
 
    if (!item)
        return;
 
    QString rtstr = item->GetText();
 
    switch(m_currentView)
    {
    case kActionsByContext:
        SetListContents(m_rightList, m_contexts[rtstr]);
        break;
    case kKeysByContext:
        SetListContents(m_rightList, m_bindings->GetContextKeys(rtstr));
        break;
    case kContextsByKey:
        SetListContents(m_rightList, m_bindings->GetKeyContexts(rtstr));
        break;
    }
}
 
void MythControls::RefreshKeyInformation(void)
{
    for (uint i = 0; i < Action::kMaximumNumberOfBindings; i++)
        m_actionButtons.at(i)->SetText("");
 
    if (GetFocusWidget() == m_leftList)
    {
        m_description->Reset();
        return;
    }
 
    const QString context = GetCurrentContext();
    const QString action  = GetCurrentAction();
 
    QString desc = m_bindings->GetActionDescription(context, action);
    m_description->SetText(tr(desc.toLatin1().constData()));
 
    QStringList keys = m_bindings->GetActionKeys(context, action);
    for (int i = 0; (i < keys.count()) &&
             (i < (int)Action::kMaximumNumberOfBindings); i++)
    {
        m_actionButtons.at(i)->SetText(keys[i]);
    }
}
 
 
QString MythControls::GetCurrentContext(void)
{
    if (m_leftListType == kContextList)
        return m_leftList->GetItemCurrent()->GetText();
 
    if (GetFocusWidget() == m_leftList)
        return {};
 
    QString desc = m_rightList->GetItemCurrent()->GetText();
    int loc = desc.indexOf(" => ");
    if (loc == -1)
        return {}; // Should not happen
 
    if (m_rightListType == kContextList)
        return desc.left(loc);
 
    return desc.mid(loc + 4);
}
 
QString MythControls::GetCurrentAction(void)
{
    if (m_leftListType == kActionList)
    {
        if (m_leftList && m_leftList->GetItemCurrent())
        {
            return m_leftList->GetItemCurrent()->GetText();
        }
        return {};
    }
 
    if (GetFocusWidget() == m_leftList)
        return {};
 
    if (!m_rightList || !m_rightList->GetItemCurrent())
        return {};
 
    QString desc = m_rightList->GetItemCurrent()->GetText();
    if (kContextList == m_leftListType &&
        kActionList  == m_rightListType)
    {
        return desc;
    }
 
    int loc = desc.indexOf(" => ");
    if (loc == -1)
        return {}; // should not happen..
 
    if (m_rightListType == kActionList)
        return desc.left(loc);
 
    QString rv = desc.mid(loc+4);
    if (rv == "<none>")
        return {};
 
    return rv;
}
 
uint MythControls::GetCurrentButton(void)
{
    for (uint i = 0; i < Action::kMaximumNumberOfBindings; i++)
    {
        MythUIButton *button = m_actionButtons.at(i);
        MythUIType *uitype = GetFocusWidget();
        if (uitype == button)
            return i;
    }
 
    return Action::kMaximumNumberOfBindings;
}
 
QString MythControls::GetCurrentKey(void)
{
    MythUIButtonListItem* currentButton = nullptr;
    if (m_leftListType == kKeyList)
    {
        currentButton = m_leftList->GetItemCurrent();
        if (currentButton != nullptr)
            return currentButton->GetText();
    }
 
    if (GetFocusWidget() == m_leftList)
        return {};
 
    if ((m_leftListType == kContextList) && (m_rightListType == kActionList))
    {
        QString context = GetCurrentContext();
        QString action = GetCurrentAction();
        uint b = GetCurrentButton();
        QStringList keys = m_bindings->GetActionKeys(context, action);
 
        if (b < (uint)keys.count())
            return keys[b];
 
        return {};
    }
 
    currentButton = m_rightList->GetItemCurrent();
    QString desc;
    if (currentButton)
        desc = currentButton->GetText();
 
    int loc = desc.indexOf(" => ");
    if (loc == -1)
        return {}; // Should not happen
 
 
    if (m_rightListType == kKeyList)
        return desc.left(loc);
 
    return desc.mid(loc + 4);
}
 
void MythControls::LoadData(const QString &hostname)
{
    /* create the key bindings and the tree */
    m_bindings = new KeyBindings(hostname, m_filters);
    m_sortedContexts = m_bindings->GetContexts();
 
    /* Alphabetic order, but jump and global at the top  */
    m_sortedContexts.sort();
    m_sortedContexts.removeAll(ActionSet::kJumpContext);
    m_sortedContexts.removeAll(ActionSet::kGlobalContext);
    m_sortedContexts.insert(m_sortedContexts.begin(),
                            ActionSet::kGlobalContext);
    m_sortedContexts.insert(m_sortedContexts.begin(),
                            ActionSet::kJumpContext);
 
    for (const auto & ctx_name : std::as_const(m_sortedContexts))
    {
        QStringList actions = m_bindings->GetActions(ctx_name);
        actions.sort();
        m_contexts.insert(ctx_name, actions);
    }
}
 
void MythControls::DeleteKey(void)
{
    QString context = GetCurrentContext();
    QString key     = GetCurrentKey();
    QString action  = GetCurrentAction();
 
    if (context.isEmpty() || key.isEmpty() || action.isEmpty())
    {
        LOG(VB_GENERAL, LOG_ERR,
            "Unable to delete binding, missing information");
        return;
    }
 
    if (m_bindings->RemoveActionKey(context, action, key))
    {
        RefreshKeyInformation();
        return;
    }
 
    QString label = tr("This action is mandatory and needs at least one key "
                       "bound to it. Instead, try rebinding with another key.");
 
    MythScreenStack *popupStack =
                            GetMythMainWindow()->GetStack("popup stack");
 
    auto *confirmPopup = new MythConfirmationDialog(popupStack, label, false);
 
    if (confirmPopup->Create())
    {
        confirmPopup->SetReturnEvent(this, "mandatorydelete");
        popupStack->AddScreen(confirmPopup);
    }
    else
    {
        delete confirmPopup;
    }
}
 
void MythControls::ResolveConflict(ActionID *conflict, int error_level,
                                    const QString &key)
{
    if (!conflict)
        return;
 
    QString label;
 
    bool error = (KeyBindings::kKeyBindingError == error_level);
 
    if (error)
    {
        label = tr("This key binding conflicts with %1 in the %2 context. "
                   "Unable to bind key.")
                    .arg(conflict->GetAction(), conflict->GetContext());
    }
    else
    {
        label = tr("This key binding conflicts with %1 in the %2 context. "
                   "Do you want to bind it anyway?")
                    .arg(conflict->GetAction(), conflict->GetContext());
    }
 
    MythScreenStack *popupStack =
                            GetMythMainWindow()->GetStack("popup stack");
 
    auto *confirmPopup = new MythConfirmationDialog(popupStack, label, !error);
 
    if (!error)
    {
        confirmPopup->SetData(QVariant::fromValue(key));
        confirmPopup->SetReturnEvent(this, "conflict");
    }
 
    if (confirmPopup->Create())
        popupStack->AddScreen(confirmPopup);
 
    delete conflict;
}
 
void MythControls::GrabKey(void) const
{
    /* grab a key from the user */
    MythScreenStack *popupStack =
                            GetMythMainWindow()->GetStack("popup stack");
 
    auto *keyGrabPopup = new KeyGrabPopupBox(popupStack);
 
    if (keyGrabPopup->Create())
        popupStack->AddScreen(keyGrabPopup, false);
 
    connect(keyGrabPopup, &KeyGrabPopupBox::HaveResult,
            this, qOverload<const QString&>(&MythControls::AddKeyToAction),
            Qt::QueuedConnection);
}
 
void MythControls::AddKeyToAction(const QString& key, bool ignoreconflict)
{
    QString     action  = GetCurrentAction();
    QString     context = GetCurrentContext();
    QStringList keys    = m_bindings->GetActionKeys(context, action);
 
    // Don't recreating an existing binding...
    int binding_index = GetCurrentButton();
    if ((binding_index >= (int)Action::kMaximumNumberOfBindings) ||
        ((binding_index < keys.size()) && (keys[binding_index] == key)))
    {
        return;
    }
 
    if (!ignoreconflict)
    {
        // Check for first of the potential conflicts.
        int err_level = 0;
        ActionID *conflict = m_bindings->GetConflict(context, key, err_level);
        if (conflict)
        {
            ResolveConflict(conflict, err_level, key);
 
            return;
        }
    }
 
    if (binding_index < keys.count())
    {
        m_bindings->ReplaceActionKey(context, action, key,
                                     keys[binding_index]);
    }
    else
    {
        m_bindings->AddActionKey(context, action, key);
    }
 
    RefreshKeyInformation();
}
 
void MythControls::AddKeyToAction(const QString& key)
{
    AddKeyToAction(key, false);
}
 
void MythControls::customEvent(QEvent *event)
{
    if (event->type() == DialogCompletionEvent::kEventType)
    {
        auto *dce = (DialogCompletionEvent*)(event);
 
        QString resultid  = dce->GetId();
        int     buttonnum = dce->GetResult();
 
        if (resultid == "action")
        {
            if (buttonnum == 0)
                GrabKey();
            else if (buttonnum == 1)
                DeleteKey();
        }
        else if (resultid == "option")
        {
            if (buttonnum == 0)
                Save();
            else if (buttonnum == 1)
                ChangeView();
            else if (buttonnum == 2)
                GetMythMainWindow()->JumpTo("Reset All Keys");
        }
        else if (resultid == "exit")
        {
            if (buttonnum == 1)
                Save();
            else
                Teardown();
 
            Close();
        }
        else if (resultid == "view")
        {
            QStringList contents;
            QString leftcaption;
            QString rightcaption;
 
            if (buttonnum == 0)
            {
                leftcaption = tr("Contexts");
                rightcaption = tr("Actions");
                m_currentView = kActionsByContext;
                contents = m_bindings->GetContexts();
            }
            else if (buttonnum == 1)
            {
                leftcaption = tr("Contexts");
                rightcaption = tr("Keys");
                m_currentView = kKeysByContext;
                contents = m_bindings->GetContexts();
            }
            else if (buttonnum == 2)
            {
                leftcaption = tr("Keys");
                rightcaption = tr("Contexts");
                m_currentView = kContextsByKey;
                contents = m_bindings->GetKeys();
            }
            else
            {
                return;
            }
 
            m_leftDescription->SetText(leftcaption);
            m_rightDescription->SetText(rightcaption);
 
            SetListContents(m_leftList, contents, true);
            RefreshKeyInformation();
            UpdateRightList();
 
            if (GetFocusWidget() != m_leftList)
                SetFocusWidget(m_leftList);
        }
        else if (resultid == "conflict")
        {
            if (buttonnum == 1)
            {
                QString key = dce->GetData().toString();
                AddKeyToAction(key, true);
            }
        }
 
        if (m_menuPopup)
            m_menuPopup = nullptr;
    }
 
}
 
/* vim: set expandtab tabstop=4 shiftwidth=4: */