void Keyboard::handleRecordMode(Led *ledRecord, const int keyRecord) {
bool isRecordMode = true;
/* record LED solid light */
ledRecord->on();
while (isRecordMode) {
struct KeyData keyData = pollDevice(1);
if (keyData.type == KeyData::KeyType::Unknown
|| !keyData.index) {
/* skip iteration if event is unknown or index is 0 */
continue;
} else if (keyData.type == KeyData::KeyType::Macro) {
/* record LED should blink */
ledRecord->blink();
isRecordMode = false;
Key key(&keyData);
recordMacro(key.getMacroPath(profile_), ledRecord, keyRecord);
} else if (keyData.type == KeyData::KeyType::Extra) {
/* deactivate Record LED */
ledRecord->off();
isRecordMode = false;
if (keyData.index != keyRecord) {
handleKey(&keyData);
}
}
}
}
void DirectInputRegistry::updateState( osgGA::EventQueue* eventQueue )
{
HRESULT hr;
if ( !_supportDirectInput || !eventQueue ) return;
if ( _keyboard )
{
pollDevice( _keyboard );
char buffer[256] = {0};
hr = _keyboard->GetDeviceState( sizeof(buffer), &buffer );
if ( SUCCEEDED(hr) )
{
for ( KeyMap::iterator itr=g_keyMap.begin(); itr!=g_keyMap.end(); ++itr )
{
KeyValue& key = itr->second;
char value = buffer[itr->first];
if ( key.second==value ) continue;
key.second = value;
if ( value&0x80 )
eventQueue->keyPress( key.first );
else
eventQueue->keyRelease( key.first );
}
}
}
if ( _mouse )
{
pollDevice( _mouse );
DIMOUSESTATE2 mouseState;
hr = _mouse->GetDeviceState( sizeof(DIMOUSESTATE2), &mouseState );
// TODO: add mouse handlers
}
if ( _joystick )
{
pollDevice( _joystick );
osg::ref_ptr<JoystickEvent> event = new JoystickEvent;
hr = _joystick->GetDeviceState( sizeof(DIJOYSTATE2), &(event->_js) );
if ( SUCCEEDED(hr) ) eventQueue->userEvent( event.get() );
}
}
/*
* Macro recording captures delays by default. Use the configuration to disable
* capturing delays.
*/
void Keyboard::recordMacro(std::string path, Led *ledRecord, const int keyRecord) {
struct timeval prev;
struct KeyData keyData;
prev.tv_usec = 0;
prev.tv_sec = 0;
std::cout << "Start Macro Recording on " << devNode_.inputEvent << std::endl;
process_->privilege();
evfd_ = open(devNode_.inputEvent.c_str(), O_RDONLY | O_NONBLOCK);
process_->unprivilege();
if (evfd_ < 0) {
std::cout << "Can't open input event file" << std::endl;
}
/* additionally monitor /dev/input/event* with poll */
fds[1].fd = evfd_;
tinyxml2::XMLDocument doc;
tinyxml2::XMLNode* root = doc.NewElement("Macro");
/* start root element "Macro" */
doc.InsertFirstChild(root);
bool isRecordMode = true;
while (isRecordMode) {
keyData = pollDevice(2);
if (keyData.index == keyRecord && keyData.type == KeyData::KeyType::Extra) {
ledRecord->off();
isRecordMode = false;
}
struct input_event inev;
read(evfd_, &inev, sizeof(struct input_event));
if (inev.type == EV_KEY && inev.value != 2) {
/* only capturing delays, if capture_delays is set to true */
if (prev.tv_usec && config_->lookup("capture_delays")) {
auto diff = (inev.time.tv_usec + 1000000 * inev.time.tv_sec) - (prev.tv_usec + 1000000 * prev.tv_sec);
auto delay = diff / 1000;
/* start element "DelayEvent" */
tinyxml2::XMLElement* DelayEvent = doc.NewElement("DelayEvent");
DelayEvent->SetText(static_cast<int>(delay));
root->InsertEndChild(DelayEvent);
}
/* start element "KeyBoardEvent" */
tinyxml2::XMLElement* KeyBoardEvent = doc.NewElement("KeyBoardEvent");
if (inev.value) {
KeyBoardEvent->SetAttribute("Down", true);
} else {
KeyBoardEvent->SetAttribute("Down", false);
}
KeyBoardEvent->SetText(inev.code);
root->InsertEndChild(KeyBoardEvent);
prev = inev.time;
}
}
/* write XML document */
if (doc.SaveFile(path.c_str())) {
std::cout << "Error XML SaveFile" << std::endl;
}
std::cout << "Exit Macro Recording" << std::endl;
/* remove event file from poll fds */
fds[1].fd = -1;
close(evfd_);
}
void Keyboard::listen() {
while (process_->isActive() && isConnected()) {
struct KeyData keyData = pollDevice(1);
handleKey(&keyData);
}
}
