keybindings.cpp

Go to the documentation of this file.

/* -*- myth -*- */
// MythTV headers
#include "mythdb.h"
#include "mythmainwindow.h"

// MythControls headers
#include "keybindings.h"

KeyBindings::KeyBindings(const QString &hostname)
    : m_hostname(hostname)
{
    m_hostname.detach();
    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 (int i = 0; i < actions.size(); i++)
    {
        QString context = actions[i].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]);
        }
        else if (ids[i].GetContext() == context_name)
        {
            level = KeyBindings::kKeyBindingError;
            return new ActionID(ids[i]);
        }
        else if (ids[i].GetContext() == ActionSet::kGlobalContext)
        {
            level = KeyBindings::kKeyBindingWarning;
            return new ActionID(ids[i]);
        }
    }

    return NULL; // 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.size() > 0)
    {
        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)
{
    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;
    }

    while (query.next())
    {
        ActionID id(query.value(0).toString(), 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...
}

---