Window events

Table of Contents

• Polling the window events
• Handling the Events
• Handle the event data
  • Button states
  • Mouse events
  • Keyboard events
  • Gamepad events
  • Window events
• Ignoring the events
• Important Notes

Polling the window events

Call fplPollEvent() in a while-loop inside your actual main-loop with a pointer to a fplEvent argument to poll the next event from the OS event queue.
Each event is translated into the fplEvent argument which you can handle or not. If there are no events left, the function returns false.

fplEvent currentEvent;
while (fplPollEvent(&currentEvent)) {
    // ... Handling the event
}

Handling the Events

Each event has a fplEvent::type field which you can check to read the actual data (Keyboard, Mouse, Window, etc.).

fplEvent currentEvent;
while (fplPollEvent(&currentEvent)) {
    switch (currentEvent.type) {
        case fplEventType_Window:
        {
            // A window event, like resize, lost/got focus, etc.
            switch (currentEvent.window.type) {
                // ...
            }
        } break;
        case fplEventType_Keyboard:
        {
            // A keyboard event, like key down/up, pressed, etc.
            switch (currentEvent.keyboard.type) {
                // ...
            }
        } break;
        case fplEventType_Mouse:
        {
            // A mouse event, like mouse button down/up, mouse move, etc.
            switch (currentEvent.mouse.type) {
                // ...
            }
        } break;
        case fplEventType_Gamepad:
        {
            // A gamepad event, like connected/disconnected, state-updated etc.
            switch (currentEvent.gamepad.type) {
                // ...
            }
        } break;
    }
}

All available event types are stored in the fplEventType enumeration.

Handle the event data

All relevant event data are stored in fields that match the lowercase fplEventType name.
Each event structure has another type field to check for the actual type (Key-Down, Mouse-Move, Window-Resize, etc.).

Button states

All mouse/keyboard or gamepad button states are described as a fplButtonState.

To detect a non-repeatable button press, you simply compare against fplButtonState_Press.
To detect a repeatable button press, you simply compare against fplButtonState_Repeat.
To detect a button release, you simply compare against fplButtonState_Release.

If you just want to know if a key is pressed or held down, just do a greater-or-equal comparison against fplButtonState_Press and you are golden.

Mouse events

Mouse event data are stored in the fplMouseEvent structure.
A mouse event contains either a single button click/release or a mouse wheel change or a position change.

switch (currentEvent.mouse.type) {
    case fplMouseEventType_Button:
    {
        fplMouseButtonType button = currentEvent.mouse.button;
        fplButtonState state = currentEvent.mouse.buttonState;
        bool buttonDown = state >= fplButtonState_Press;
        switch (button) {
            case fplMouseButtonType_Left:
            {
                // Left mouse button down/released
            } break;
            case fplMouseButtonType_Middle:
            {
                // Middle mouse button down/released
            } break;
            case fplMouseButtonType_Right:
            {
                // Right mouse button down/released
            } break;
        }
    } break;
 
    case fplMouseEventType_Wheel:
    {
        float wheelDelta = currentEvent.mouse.wheelDelta;
        if (wheelDelta < 0.0f) {
            // Mouse-wheel down
        } else if (wheelDelta > 0.0f) {
            // Mouse-wheel up
        }
    } break;
 
    case fplMouseEventType_Move:
    {
        int mouseX = currentEvent.mouse.mouseX;
        int mouseY = currentEvent.mouse.mouseY;
        // ... do something with the mouse position
    } break;
}

Note

Any mouse button event contains the position of the click as well.

Keyboard events

Keyboard event data are stored in the fplKeyboardEvent structure.

You can either check for the original fplKeyboardEvent::keyCode or use the fplKeyboardEvent.mappedKey field - which is much easier and less error-prone.

switch (currentEvent.keyboard.type) {
    case fplKeyboardEventType_KeyButton:
    {
        fplButtonState state = currentEvent.keyboard.buttonState;
 
        // ... Handle the key code
        uint64_t keyCode = currentEvent.keyboard.keyCode;
        if (state >= fplButtonState_Pressed) {
            if (keyCode == 65 || keyCode == 97) {
                // Letter A is held down
            }
        }
 
        // or
 
        // ... handle the mapped key
        fplKey mappedKey = currentEvent.keyboard.mappedKey;
        if (state == fplButtonState_Released) {
            if (mappedKey == fplKey_F1) {
                // F1 key pressed
            }
        }
    } break;
 
    case fplKeyboardEventType_CharInput:
    {
        if(currentEvent.keyboard.keyCode > 0 && event.keyboard.keyCode < 0x10000) {
            // Handle character input
        }
    } break;
}

Gamepad events

Gamepad event data are stored in the fplGamepadEvent structure.

switch (currentEvent.gamepad.type) {
    case fplGamepadEventType_Connected:
    {
        // New gamepad device connected
    } break;
 
    case fplGamepadEventType_Disconnected:
    {
        // Lost connection to a gamepad device
    } break;
 
    case fplGamepadEventType_StateChanged:
    {
        // State of one controller updated (Buttons, Movement, etc.)
        if (absf(currentEvent.gamepad.leftStickX) > 0) {
            // ... Handle horizontal movement on left stick
        }
        if (currentEvent.gamepad.actionX.isDown) {
            // ... X-Button is held down
        }
    } break;
}

Window events

Window event data are stored in the fplWindowEvent structure.

switch (currentEvent.window.type) {
    case fplWindowEventType_Resized:
    {
        uint32_t newWidth = currentEvent.window.width;
        uint32_t newHeight = currentEvent.window.height;
        // ... Window was resized, handle it properly
    } break;
 
    case fplWindowEventType_GetFocus:
    case fplWindowEventType_LostFocus:
    {
        // ... Do something when window lost/got focus
    } break;
 
    case fplWindowEventType_Exposed:
    {
        // ... Do something when window was exposed
    } break;
 
    case fplWindowEventType_DropSingleFile:
    {
        const char *filePath = ev.window.dropFiles.single.filePath;
        // ... Do something when window got a single file dropped into it
    } break;
 
    case fplWindowEventType_Minimized:
    case fplWindowEventType_Maximized:
    case fplWindowEventType_Restored:
    {
        // ... Do something when window state was changed
    } break;
}

Ignoring the events

When you don't care about any events you can simply call fplPollEvents() to process the events and be done with them.

while (fplWindowUpdate()) {
    fplPollEvents();
 
    // ... Your code
}

Important Notes

Note

FPL does not cache the events from the previous update. If you don't handle or cache the event - the data is lost!