void widgetBlurImpl(widget *self)
{
widget *current;
eventMisc evt;
// Make sure we have focus
if (!self->hasFocus)
{
// TODO: We should log this eventuality
return;
}
// First blur any focused child widgets
while ((current = widgetGetCurrentlyFocused(self)) != self)
{
widgetBlur(current);
}
// Blur ourself
self->hasFocus = false;
// Fire off the on-blur callbacks
evt.event = widgetCreateEvent(EVT_BLUR);
widgetFireCallbacks(self, (event *) &evt);
}
void widgetRemoveEventHandlerImpl(widget *self, int id)
{
int i;
// Search for the handler with the id
for (i = 0; i < vectorSize(self->eventVtbl); i++)
{
eventTableEntry *handler = vectorAt(self->eventVtbl, i);
// If the handler matches, remove it
if (handler->id == id)
{
// If there is a destructor; call it
if (handler->destructor)
{
// Generate an EVT_DESTRUCT event
eventMisc evtDestruct;
evtDestruct.event = widgetCreateEvent(EVT_DESTRUCT);
handler->destructor(self, (event *) &evtDestruct, handler->id,
handler->userData);
}
// Release the handler
free(handler);
// Finally, remove the event handler from the table
vectorRemoveAt(self->eventVtbl, i);
break;
}
}
}
void widgetDisableImpl(widget *self)
{
int i;
eventMisc evt;
// If we are currently disabled, return
if (!self->isEnabled)
{
return;
}
// Disable ourself
self->isEnabled = false;
// Fire any on-disable callbacks
evt.event = widgetCreateEvent(EVT_DISABLE);
widgetFireCallbacks(self, (event *) &evt);
// Disable our children
for (i = 0; i < vectorSize(self->children); i++)
{
widgetDisable(vectorAt(self->children, i));
}
}
void widgetFireTimers()
{
// Create the generic timer event
eventTimer evtTimer;
evtTimer.event = widgetCreateEvent(EVT_TIMER);
// Dispatch
windowHandleEventForWindowVector((event *) &evtTimer);
}
void widgetHideToolTip(widget *self)
{
// Create the event
eventToolTip evt;
evt.event = widgetCreateEvent(EVT_TOOL_TIP_HIDE);
evt.target = self;
// Dispatch the event to the root widget
widgetHandleEvent(widgetGetRoot(self), (event *) &evt);
// Note that the tool-tip is now hidden
self->toolTipVisible = false;
}
void widgetShowToolTip(widget *self)
{
// Create the event
eventToolTip evt;
evt.event = widgetCreateEvent(EVT_TOOL_TIP_SHOW);
evt.target = self;
// Dispatch the event to the root widget
widgetHandleEvent(widgetGetRoot(self), (event *) &evt);
// Note that the tool-tip is visible
self->toolTipVisible = true;
}
void widgetResizeImpl(widget *self, int w, int h)
{
const size minSize = widgetGetMinSize(self);
const size maxSize = widgetGetMaxSize(self);
// Create an event
eventResize evtResize;
evtResize.event = widgetCreateEvent(EVT_RESIZE);
// Save the current size in the event
evtResize.oldSize = self->size;
assert(minSize.x <= w);
assert(minSize.y <= h);
assert(w <= maxSize.x);
assert(h <= maxSize.y);
self->size.x = w;
self->size.y = h;
// Re-create the cairo context at this new size
widgetCairoCreate(&self->cr, CAIRO_FORMAT_ARGB32, w, h);
// If a mask is enabled; re-create it also
if (self->maskEnabled)
{
widgetCairoCreate(&self->maskCr, CAIRO_FORMAT_A1, w, h);
// Re-draw the mask (only done on resize)
widgetDrawMask(self);
}
// If OpenGL is enabled disable and re-enable it
if (self->openGLEnabled)
{
widgetDisableGL(self);
widgetEnableGL(self);
}
// Set the needs redraw flag
self->needsRedraw = true;
// If we have any children, we need to redo their layout
if (vectorSize(self->children))
{
widgetDoLayout(self);
}
// Fire any EVT_RESIZE callbacks
widgetFireCallbacks(self, (event *) &evtResize);
}
void widgetRepositionImpl(widget *self, int x, int y)
{
// Generate a reposition event
eventReposition evtReposition;
evtReposition.event = widgetCreateEvent(EVT_REPOSITION);
// Save the current position in the event
evtReposition.oldPosition = self->offset;
evtReposition.oldAbsolutePosition = widgetAbsolutePosition(self);
// Update our position
self->offset.x = x;
self->offset.y = y;
// Fire any callbacks for EVT_REPOSITION
widgetFireCallbacks(self, (event *) &evtReposition);
}
void widgetFocusImpl(widget *self)
{
eventMisc evt;
// Check that we are not currently focused
if (self->hasFocus)
{
int i;
// Blur any of our currently focused child widgets
for (i = 0; i < vectorSize(self->children); i++)
{
widget *child = vectorAt(self->children, i);
if (child->hasFocus)
{
widgetBlur(child);
}
}
return;
}
// If we have a parent, focus it
if (self->parent)
{
widgetFocus(self->parent);
}
// Focus ourself
self->hasFocus = true;
// Fire our on-focus callbacks
evt.event = widgetCreateEvent(EVT_FOCUS);
widgetFireCallbacks(self, (event *) &evt);
}
void widgetEnableImpl(widget *self)
{
int i;
eventMisc evt;
// First make sure our parent is enabled
if (self->parent && !self->parent->isEnabled)
{
return;
}
// Enable ourself
self->isEnabled = true;
// Fire any on-enable callbacks
evt.event = widgetCreateEvent(EVT_ENABLE);
widgetFireCallbacks(self, (event *) &evt);
// Enable all of our children
for (i = 0; i < vectorSize(self->children); i++)
{
widgetEnable(vectorAt(self->children, i));
}
}
void widgetHandleSDLEvent(const SDL_Event *sdlEvt)
{
// Last known location of the mouse
static point previousMouseLoc = { -1, -1 };
switch (sdlEvt->type)
{
case SDL_MOUSEMOTION:
{
eventMouse evtMouse;
evtMouse.event = widgetCreateEvent(EVT_MOUSE_MOVE);
// Location
evtMouse.loc.x = sdlEvt->motion.x;
evtMouse.loc.y = sdlEvt->motion.y;
// Previous location
evtMouse.previousLoc = previousMouseLoc;
// Update the previous location
previousMouseLoc = evtMouse.loc;
windowHandleEventForWindowVector((event *) &evtMouse);
break;
}
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
{
eventMouseBtn evtMouseBtn;
evtMouseBtn.event = widgetCreateEvent(sdlEvt->button.state == SDL_PRESSED ?
EVT_MOUSE_DOWN : EVT_MOUSE_UP);
// Location
evtMouseBtn.loc.x = sdlEvt->button.x;
evtMouseBtn.loc.y = sdlEvt->button.y;
// Update the previous location
previousMouseLoc = evtMouseBtn.loc;
// Button pressed/released
evtMouseBtn.button = SDLButtonToMouseButton(sdlEvt->button.button);
windowHandleEventForWindowVector((event *) &evtMouseBtn);
break;
}
case SDL_KEYDOWN:
case SDL_KEYUP:
{
eventKey evtKey;
evtKey.event = widgetCreateEvent(sdlEvt->key.type == SDL_KEYDOWN ?
EVT_KEY_DOWN : EVT_KEY_UP);
// Key pressed/released
evtKey.keycode = SDLKeyToEventKeycode(sdlEvt->key.keysym.sym);
// Modifier keys
if (sdlEvt->key.keysym.mod & KMOD_CTRL)
{
evtKey.ctrl = true;
}
if (sdlEvt->key.keysym.mod & KMOD_ALT)
{
evtKey.alt = true;
}
if (sdlEvt->key.keysym.mod & KMOD_SHIFT)
{
evtKey.shift = true;
}
// Only needed/works on SDL 1.2!
if (sdlEvt->key.keysym.unicode)
{
const uint16_t utf16[2] = { sdlEvt->key.keysym.unicode, 0 };
char *utf8;
// Create the text event
eventText evtText;
evtText.event = widgetCreateEvent(EVT_TEXT);
// Convert the UTF-16 string to UTF-8
utf8 = UTF16toUTF8(utf16, NULL);
// Set the text of the event to UTF-8 string
evtText.utf8 = utf8;
// Dispatch the event
windowHandleEventForWindowVector((event *) &evtText);
// Free the memory allocated by UTF16toUTF8
free(utf8);
}
windowHandleEventForWindowVector((event *) &evtKey);
break;
}
}
}
