#include <tools inputstate.h=""></tools>

#include <iomanip></iomanip>

#include <qkeysequence></qkeysequence>

//*****************************************************************************************

//    TKey static members

//*****************************************************************************************

const TKey TKey::shift   ( Qt::Key_Shift   , true );

const TKey TKey::control ( Qt::Key_Control , true );

const TKey TKey::alt     ( Qt::Key_Alt     , true );

const TKey TKey::meta    ( Qt::Key_Meta    , true );

Qt::Key

TKey::mapKey(Qt::Key key) {

  switch(key) {

  case Qt::Key_AltGr: return Qt::Key_Alt;

  default: break;

  }

  return key;

}

bool

TKey::isModifier(Qt::Key key) {

  key = mapKey(key);

  return key == Qt::Key_Shift

      || key == Qt::Key_Control

      || key == Qt::Key_Alt

      || key == Qt::Key_AltGr

      || key == Qt::Key_Meta;

}

bool

TKey::isNumber(Qt::Key key) {

  key = mapKey(key);

  return key >= Qt::Key_0 && key <= Qt::Key_9;

}

//*****************************************************************************************

//    TInputState implementation

//*****************************************************************************************

TInputState::TInputState():

  m_ticks(),

  m_keyHistory(new KeyHistory())

  { }

TInputState::~TInputState()

  { }

void

TInputState::touch(TTimerTicks ticks) {

  if (m_ticks < ticks)

    m_ticks = ticks;

  else

    ++m_ticks;

}

TInputState::ButtonHistory::Pointer

TInputState::buttonHistory(DeviceId device) const {

  ButtonHistory::Pointer &history = m_buttonHistories[device];

  if (!history) history = new ButtonHistory();

  return history;

}

TInputState::ButtonState::Pointer

TInputState::buttonFindAny(Button button, DeviceId &outDevice) {

  for(ButtonHistoryMap::const_iterator i = m_buttonHistories.begin(); i != m_buttonHistories.end(); ++i) {

    ButtonState::Pointer state = i->second->current()->find(button);

    if (state) {

      outDevice = i->first;

      return state;

    }

  }

  outDevice = DeviceId();

  return ButtonState::Pointer();

}

namespace {

template<typename t=""></typename>

void printKey(const T &k, std::ostream &stream)

  { stream << k; }

template<>

void printKey<tkey>(const TKey &k, std::ostream &stream) {</tkey>

  stream << QKeySequence(k.key).toString().toStdString() << "[" << std::hex << k.key << std::dec;

  if (k.generic) stream << "g";

  if (k.numPad) stream << "n";

  stream << "]";

}

template<typename t=""></typename>

class Print {

public:

  typedef T Type;

  typedef TKeyHistoryT<type> History;</type>

  typedef typename History::StatePointer StatePointer;

  typedef typename History::StateMap StateMap;

  typedef typename History::LockSet LockSet;

  static void print(const History &history, std::ostream &stream, const std::string &tab) {

    const StateMap &states = history.getStates();

    stream << tab << "states: " << std::endl;

    for(typename StateMap::const_iterator i = states.begin(); i != states.end(); ++i) {

      stream << tab << "- " << i->first << std::endl;

      for(StatePointer p = i->second; p; p = p->previous) {

        stream << tab << "- - " << p->ticks << ": ";

        printKey(p->value, stream);

        stream << std::endl;

      }

    }

    const LockSet &locks = history.getLocks();

    stream << tab << "locks: ";

    for(typename LockSet::const_iterator i = locks.begin(); i != locks.end(); ++i) {

      if (i != locks.begin()) stream << ", ";

      stream << *i;

    }

    stream << std::endl;

  }

};

}

void TInputState::print(std::ostream &stream, const std::string &tab) const {

  stream << tab << "keys:" << std::endl;

  Print<tkey>::print(*m_keyHistory, stream, tab + "  ");</tkey>

  for(ButtonHistoryMap::const_iterator i = m_buttonHistories.begin(); i != m_buttonHistories.end(); ++i) {

    stream << tab << "buttons[" << i->first << "]:" << std::endl;

    Print<tkey>::print(*m_keyHistory, stream, tab + "  ");</tkey>

  }

}