SLInputManager Class Reference

SLInputManager. manages system input and custom input devices. More...

#include <SLInputManager.h>

Public Member Functions
	SLInputManager ()
SLbool	pollAndProcessEvents (SLSceneView *sv)
void	queueEvent (const SLInputEvent *e)
SLVInputDevice &	devices ()

Private Member Functions
SLbool	processQueuedEvents (SLSceneView *sv)

Private Attributes
SLQInputEvent	_systemEvents
	queue for known system events More...
SLVInputDevice	_devices
	list of activated SLInputDevices More...

Friends
class	SLInputDevice

Detailed Description

SLInputManager. manages system input and custom input devices.

One static instance of SLInputManager is used in AppCommon. Every user input has to go through the SLInputManager. System event's like touch, mouse, character input will be encapsulated in SLInputEvent subclasses and will be queued up before being sent to the relevant SLSceneView. Custom SLInputDevices can also be created. The SLInputDevices are guaranteed to receive a call to their poll() function whenever the SLInputManager requires them to send out new events. The method pollAndProcessEvents is called every frame in SLScene::onUpdate.

Definition at line 22 of file SLInputManager.h.

Constructor & Destructor Documentation

SLInputManager()

SLInputManager::SLInputManager ( )

inline

Definition at line 27 of file SLInputManager.h.

{ ; }

Member Function Documentation

devices()

SLVInputDevice& SLInputManager::devices ( )

inline

Definition at line 31 of file SLInputManager.h.

{ return _devices; }

pollAndProcessEvents()

SLbool SLInputManager::pollAndProcessEvents

(

SLSceneView *

sv

)

Sends any queued up system event's to their correct receiver and polls all activated SLInputDevices.

Note

The event queue is similar to how Qt manages it's events. The main difference is, that we don't use the SLInputEvent class outside of the SLInputManager. The SLInputManager calls the correct SLSceneView input handler functions directly. Also we don't allow for custom SLInputEvents. This is the other main difference to the Qt event system. The decision to go this route is simplicity for now. It is totally sufficient for our use cases to provide the user with the SLInputDevice interface to realize custom input. However it has to be considered, that Qt also has many GUI related events like MouseEnter, MouseLeave, Drag etc. For a sophisticated GUI implementation the whole input management in SL would have to be reviewed.

Definition at line 29 of file SLInputManager.cpp.

{
    // process system events first
    SLbool consumedEvents = processQueuedEvents(sv);
 
    // process custom input devices
    for (auto device : _devices)
        consumedEvents |= device->poll();
 
    return consumedEvents;
}

processQueuedEvents()

SLbool SLInputManager::processQueuedEvents ( SLSceneView *  sv )

private

Work off any queued up input event's and notify the correct receiver.

Note

this is similar to the Qt QObject::event function.

Definition at line 52 of file SLInputManager.cpp.

{
    SLQInputEvent& q = _systemEvents;
 
    // flag if an event has been consumed by a receiver
    SLbool eventConsumed = false;
 
    while (!q.empty())
    {
        const SLInputEvent* e;
        {
            e = q.front();
            q.pop();
        }
 
        if (sv)
        {
            switch (e->type)
            {
                case SLInputEvent::MouseMove:
                {
                    const SLMouseEvent* me = (const SLMouseEvent*)e;
                    eventConsumed |= sv->onMouseMove(me->x, me->y);
                }
                break;
                case SLInputEvent::MouseDown:
                {
                    const SLMouseEvent* me = (const SLMouseEvent*)e;
                    eventConsumed |= sv->onMouseDown(me->button, me->x, me->y, me->modifier);
                }
                break;
                case SLInputEvent::MouseUp:
                {
                    const SLMouseEvent* me = (const SLMouseEvent*)e;
                    eventConsumed |= sv->onMouseUp(me->button, me->x, me->y, me->modifier);
                }
                break;
                case SLInputEvent::MouseDoubleClick:
                {
                    const SLMouseEvent* me = (const SLMouseEvent*)e;
                    eventConsumed |= sv->onDoubleClick(me->button, me->x, me->y, me->modifier);
                }
                break;
                case SLInputEvent::MouseWheel:
                {
                    const SLMouseEvent* me = (const SLMouseEvent*)e;
                    eventConsumed |= sv->onMouseWheel(me->y, me->modifier);
                }
                break;
 
                case SLInputEvent::Touch2Move:
                {
                    const SLTouchEvent* te = (const SLTouchEvent*)e;
                    eventConsumed |= sv->onTouch2Move(te->x1, te->y1, te->x2, te->y2);
                }
                break;
                case SLInputEvent::Touch2Down:
                {
                    const SLTouchEvent* te = (const SLTouchEvent*)e;
                    eventConsumed |= sv->onTouch2Down(te->x1, te->y1, te->x2, te->y2);
                }
                break;
                case SLInputEvent::Touch2Up:
                {
                    const SLTouchEvent* te = (const SLTouchEvent*)e;
                    eventConsumed |= sv->onTouch2Up(te->x1, te->y1, te->x2, te->y2);
                }
                break;
 
                case SLInputEvent::KeyDown:
                {
                    const SLKeyEvent* ke = (const SLKeyEvent*)e;
                    eventConsumed |= sv->onKeyPress(ke->key, ke->modifier);
                }
                break;
                case SLInputEvent::KeyUp:
                {
                    const SLKeyEvent* ke = (const SLKeyEvent*)e;
                    eventConsumed |= sv->onKeyRelease(ke->key, ke->modifier);
                }
                break;
                case SLInputEvent::CharInput:
                {
                    const SLCharInputEvent* ce = (const SLCharInputEvent*)e;
                    eventConsumed |= sv->onCharInput(ce->character);
                }
                break;
 
                case SLInputEvent::Resize:
                {
                    const SLResizeEvent* re = (const SLResizeEvent*)e;
                    sv->onResize(re->width, re->height);
                }
                break;
 
                case SLInputEvent::ScrCapture:
                {
                    const SLScrCaptureRequestEvent* re   = (const SLScrCaptureRequestEvent*)e;
                    SLstring                        path = re->path;
 
                    if (!Utils::dirExists(path))
                        Utils::makeDirRecurse(path);
                    SLstring filename     = "Screenshot_" + Utils::getDateTime2String() + ".png";
                    SLstring pathFilename = path + filename;
                    sv->saveFrameBufferAsImage(pathFilename, cv::Size(sv->scrW(), sv->scrH()));
                }
                break;
 
                default: break;
            }
        }
 
        delete e;
    }
 
    return eventConsumed;
}

queueEvent()

void SLInputManager::queueEvent

(

const SLInputEvent *

e

)

Add a new SLInputEvent to the event queue. The queue will be emtied when a call to SLInputManager::pollEvents is made. The passed in SLInputEvents have to be dynamically allocated by the user, the deallocation is handled by the SLInputManager

Definition at line 45 of file SLInputManager.cpp.

{
    _systemEvents.push(e);
}

Friends And Related Function Documentation

SLInputDevice

friend class SLInputDevice

friend

Definition at line 24 of file SLInputManager.h.

Member Data Documentation

_devices

SLVInputDevice SLInputManager::_devices

private

list of activated SLInputDevices

Definition at line 35 of file SLInputManager.h.

_systemEvents

SLQInputEvent SLInputManager::_systemEvents

private

queue for known system events

Definition at line 34 of file SLInputManager.h.

---

The documentation for this class was generated from the following files:

• SLInputManager.h
• SLInputManager.cpp