HotkeyHandler.cc

// Copyright (c) 2013 by István Váradi
 
// This file is part of XPLRA, a remote-access plugin for X-Plane
 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
 
// 1. Redistributions of source code must retain the above copyright notice, this
//    list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
// The views and conclusions contained in the software and documentation are those
// of the authors and should not be interpreted as representing official policies,
// either expressed or implied, of the FreeBSD Project.
 
//------------------------------------------------------------------------------
 
#include "HotkeyHandler.h"
 
#include "Protocol.h"
 
#include <hu/varadiistvan/xplcommon/Util.h>
 
#include <hu/varadiistvan/scpl/io/DataStream.h>
 
#include <XPLMDisplay.h>
 
//------------------------------------------------------------------------------
 
using xplra::HotkeyHandler;
 
using hu::varadiistvan::xplcommon::Util;
 
using hu::varadiistvan::scpl::io::DataStream;
 
//------------------------------------------------------------------------------
 
HotkeyHandler::Hotkeys::Hotkeys(size_t numHotkeys, DataStream& stream) :
    numHotkeys(numHotkeys),
    hotkeys(new uint16_t[numHotkeys]),
    pressed(0)
{
    if (stream.read(hotkeys, sizeof(uint16_t)*numHotkeys)) {
        pressed = new uint8_t[numHotkeys];
        memset(pressed, 0, sizeof(uint8_t)*numHotkeys);
    } else {
        delete hotkeys; hotkeys = 0;
    }
}
 
//------------------------------------------------------------------------------
 
HotkeyHandler::Hotkeys::~Hotkeys()
{
    delete [] pressed;
    delete [] hotkeys;
}
 
//------------------------------------------------------------------------------
 
bool HotkeyHandler::Hotkeys::handleKey(uint16_t code)
{
    for(size_t i = 0; i<numHotkeys; ++i) {
        if (hotkeys[i]==code) {
            pressed[i] = 1;
            return true;
        }
    }
    return false;
}
 
//------------------------------------------------------------------------------
 
void HotkeyHandler::Hotkeys::writePressed(DataStream& stream)
{
    uint8_t pressed1[numHotkeys];
 
    for(size_t i = 0; i<numHotkeys; ++i) {
        pressed1[i] = __sync_val_compare_and_swap(pressed + i, 1, 0);
    }
 
    stream.writeU32(numHotkeys);
    stream.write(pressed1, sizeof(pressed1));
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
int HotkeyHandler::keyCallback(char c, XPLMKeyFlags flags, char virtualKey,
                               void* refCon)
{
    HotkeyHandler* hotkeyHandler = reinterpret_cast<HotkeyHandler*>(refCon);
    return hotkeyHandler->handleKey(c, flags, virtualKey) ? 0 : 1;
}
 
//------------------------------------------------------------------------------
 
HotkeyHandler::HotkeyHandler()
{
    XPLMRegisterKeySniffer(&keyCallback, 0, this);
}
 
//------------------------------------------------------------------------------
 
void HotkeyHandler::registerHotkeys(Hotkeys* hotkeys)
{
    mutex.lock();
    hotkeySets.push_back(hotkeys);
    mutex.unlock();
}
 
//------------------------------------------------------------------------------
 
void HotkeyHandler::unregisterHotkeys(Hotkeys* hotkeys)
{
    mutex.lock();
    hotkeySets.remove(hotkeys);
    mutex.unlock();
}
 
//------------------------------------------------------------------------------
 
bool HotkeyHandler::handleKey(char /*c*/, XPLMKeyFlags flags, char virtualKey)
{
    if ( (flags&xplm_DownFlag)==0 ) return false;
 
    uint16_t code = static_cast<uint16_t>(virtualKey);
    if ( (flags&xplm_ShiftFlag)!=0 ) code |= Protocol::HOTKEY_MODIFIER_SHIFT;
    if ( (flags&xplm_ControlFlag)!=0 ) code |= Protocol::HOTKEY_MODIFIER_CONTROL;
 
    bool handled = false;
 
    mutex.lock();
    for(hotkeySets_t::iterator i = hotkeySets.begin(); i!=hotkeySets.end();
        ++i)
    {
        Hotkeys* hotkeys = *i;
        if (hotkeys->handleKey(code)) {
            handled = true;
        }
    }
    mutex.unlock();
 
    return handled;
}
 
//------------------------------------------------------------------------------
 
// Local Variables:
// mode: C++
// c-basic-offset: 4
// indent-tabs-mode: nil
// End: