keybindings.cpp

Go to the documentation of this file.

/* -*- myth -*- */
// MythTV headers
#include "libmythbase/mythdb.h"
#include "libmythui/mythmainwindow.h"
 
// MythControls headers
#include "keybindings.h"
 
KeyBindings::KeyBindings(QString hostname, Filter Filters)
    : m_hostname(std::move(hostname)),
      m_filter(Filters)
{
    LoadMandatoryBindings();
    LoadContexts();
    LoadJumppoints();
}
 
QStringList KeyBindings::GetKeys(void) const
{
    return m_actionSet.GetAllKeys();
}
 
QStringList KeyBindings::GetContexts(void) const
{
    QStringList ctxts = m_actionSet.GetContextStrings();
    ctxts.sort();
    return ctxts;
}
 
QStringList KeyBindings::GetActions(const QString &context) const
{
    return m_actionSet.GetActionStrings(context);
}
 
void KeyBindings::GetKeyActions(const QString &key, ActionList &list) const
{
    list = m_actionSet.GetActions(key);
}
 
QStringList KeyBindings::GetActionKeys(const QString &context_name,
                                       const QString &action_name) const
{
    return m_actionSet.GetKeys(ActionID(context_name, action_name));
}
 
QStringList KeyBindings::GetContextKeys(const QString &context) const
{
    return m_actionSet.GetContextKeys(context);
}
 
QStringList KeyBindings::GetKeyContexts(const QString &key) const
{
    ActionList actions = m_actionSet.GetActions(key);
    QStringList contexts;
 
    for (const auto & action : std::as_const(actions))
    {
        QString context = action.GetContext();
        if (!contexts.contains(context))
            contexts.push_back(context);
    }
 
    return contexts;
}
 
QString KeyBindings::GetActionDescription(const QString &context_name,
                                          const QString &action_name) const
{
    ActionID id(context_name, action_name);
    return m_actionSet.GetDescription(id);
}
 
bool KeyBindings::AddActionKey(const QString &context_name,
                               const QString &action_name,
                               const QString &key)
{
    return m_actionSet.Add(ActionID(context_name, action_name), key);
}
 
ActionID *KeyBindings::GetConflict(
    const QString &context_name, const QString &key, int &level) const
{
    const ActionList ids = m_actionSet.GetActions(key);
 
    // trying to bind a jumppoint to an already bound key
    if ((context_name == ActionSet::kJumpContext) && (ids.count() > 0))
        return new ActionID(ids[0]);
 
    // check the contexts of the other bindings
    for (int i = 0; i < ids.count(); i++)
    {
        // jump points, then global, then the same context
        if (ids[i].GetContext() == ActionSet::kJumpContext)
        {
            level = KeyBindings::kKeyBindingError;
            return new ActionID(ids[i]);
        }
        if (ids[i].GetContext() == context_name)
        {
            level = KeyBindings::kKeyBindingError;
            return new ActionID(ids[i]);
        }
        if (ids[i].GetContext() == ActionSet::kGlobalContext)
        {
            level = KeyBindings::kKeyBindingWarning;
            return new ActionID(ids[i]);
        }
    }
 
    return nullptr; // no conflicts
}
 
void KeyBindings::ReplaceActionKey(const QString &context_name,
                                   const QString &action_name,
                                   const QString &newkey,
                                   const QString &oldkey)
{
    m_actionSet.Replace(ActionID(context_name, action_name), newkey, oldkey);
}
 
bool KeyBindings::RemoveActionKey(const QString &context_name,
                                  const QString &action_name,
                                  const QString &key)
{
    ActionID id(context_name, action_name);
 
    // Don't remove the last mandatory binding
    if (m_mandatoryBindings.contains(id) &&
        (m_actionSet.GetKeys(id).count() < 2))
    {
        return false;
    }
 
    return m_actionSet.Remove(id, key);
}
 
 
void KeyBindings::CommitAction(const ActionID &id)
{
    MSqlQuery query(MSqlQuery::InitCon());
    query.prepare(
        "UPDATE keybindings "
        "SET keylist = :KEYLIST "
        "WHERE hostname = :HOSTNAME AND "
        "      action   = :ACTION   AND "
        "      context  = :CONTEXT");
 
    QString keys = m_actionSet.GetKeyString(id);
    query.bindValue(":KEYLIST",  keys);
    query.bindValue(":HOSTNAME", m_hostname);
    query.bindValue(":CONTEXT",  id.GetContext());
    query.bindValue(":ACTION",   id.GetAction());
 
    if (!query.exec() || !query.isActive())
    {
        MythDB::DBError("KeyBindings::CommitAction", query);
        return;
    }
 
    GetMythMainWindow()->ClearKey(id.GetContext(), id.GetAction());
    GetMythMainWindow()->BindKey(id.GetContext(), id.GetAction(), keys);
}
 
void KeyBindings::CommitJumppoint(const ActionID &id)
{
    MSqlQuery query(MSqlQuery::InitCon());
    query.prepare(
        "UPDATE jumppoints "
        "SET keylist = :KEYLIST "
        "WHERE hostname    = :HOSTNAME AND"
        "      destination = :DESTINATION");
 
    QString keys = m_actionSet.GetKeyString(id);
    query.bindValue(":KEYLIST",     keys);
    query.bindValue(":HOSTNAME",    m_hostname);
    query.bindValue(":DESTINATION", id.GetAction());
 
    if (!query.exec() || !query.isActive())
    {
        MythDB::DBError("KeyBindings::CommitJumppoint", query);
        return;
    }
 
    GetMythMainWindow()->ClearJump(id.GetAction());
    GetMythMainWindow()->BindJump(id.GetAction(), keys);
}
 
void KeyBindings::CommitChanges(void)
{
    ActionList modified = m_actionSet.GetModified();
 
    while (!modified.empty())
    {
        ActionID id = modified.front();
 
        // commit either a jumppoint or an action
        if (id.GetContext() == ActionSet::kJumpContext)
            CommitJumppoint(id);
        else
            CommitAction(id);
 
        // tell the action set that the action is no longer modified
        m_actionSet.SetModifiedFlag(id, false);
 
        modified.pop_front();
    }
}
 
void KeyBindings::LoadJumppoints(void)
{
    if (m_filter == JustModifiers)
        return;
 
    MSqlQuery query(MSqlQuery::InitCon());
    query.prepare(
        "SELECT destination, description, keylist "
        "FROM jumppoints "
        "WHERE hostname = :HOSTNAME "
        "ORDER BY destination");
    query.bindValue(":HOSTNAME", m_hostname);
 
    if (!query.exec() || !query.isActive())
    {
        MythDB::DBError("KeyBindings::LoadJumppoint", query);
        return;
    }
 
    while (query.next())
    {
        ActionID id(ActionSet::kJumpContext, query.value(0).toString());
 
        if (query.value(1).toString().isEmpty())
        {
            m_actionSet.AddAction(id, query.value(0).toString(),
                                  query.value(2).toString());
        }
        else
        {
            m_actionSet.AddAction(id, query.value(1).toString(),
                                  query.value(2).toString());
        }
    }
}
 
void KeyBindings::LoadContexts(void)
{
    MSqlQuery query(MSqlQuery::InitCon());
    query.prepare(
        "SELECT context, action, description, keylist "
        "FROM keybindings "
        "WHERE hostname = :HOSTNAME "
        "ORDER BY context, action");
    query.bindValue(":HOSTNAME", m_hostname);
 
    if (!query.exec() || !query.isActive())
    {
        MythDB::DBError("KeyBindings::LoadContexts", query);
        return;
    }
 
    static QStringList kModifierContexts = { "Long Press" };
    while (query.next())
    {
        QString context = query.value(0).toString();
        bool modifier = kModifierContexts.contains(context);
        bool allow = m_filter == AllBindings;
        if (m_filter == JustModifiers)
            allow = modifier;
        else if (m_filter == NoModifiers)
            allow = !modifier;
        if (allow)
        {
            ActionID id(context, query.value(1).toString());
            m_actionSet.AddAction(id, query.value(2).toString(),
                                  query.value(3).toString());
        }
    }
}
 
void KeyBindings::LoadMandatoryBindings(void)
{
    if (!m_mandatoryBindings.empty())
        return;
 
    m_mandatoryBindings.append(ActionID(ActionSet::kGlobalContext, "DOWN"));
    m_defaultKeys.append("Down");
 
    m_mandatoryBindings.append(ActionID(ActionSet::kGlobalContext, "UP"));
    m_defaultKeys.append("Up");
 
    m_mandatoryBindings.append(ActionID(ActionSet::kGlobalContext, "LEFT"));
    m_defaultKeys.append("Left");
 
    m_mandatoryBindings.append(ActionID(ActionSet::kGlobalContext, "RIGHT"));
    m_defaultKeys.append("Right");
 
    m_mandatoryBindings.append(ActionID(ActionSet::kGlobalContext, "ESCAPE"));
    m_defaultKeys.append("Esc");
 
    m_mandatoryBindings.append(ActionID(ActionSet::kGlobalContext, "SELECT"));
    m_defaultKeys.append("Return, Enter, Space");
}
 
bool KeyBindings::HasMandatoryBindings(void) const
{
    const ActionList &manlist = m_mandatoryBindings;
    for (int i = 0; i < manlist.count(); i++)
    {
        if (m_actionSet.GetKeys(manlist[i]).isEmpty())
            return false;
    }
 
    return true; // none are empty...
}