/******************************************************************************\
Initializes a widget name field with a unique name that includes the
widget's class.
\******************************************************************************/
void I_widget_init(i_widget_t *widget, const char *class_name)
{
C_assert(widget);
C_zero(widget);
snprintf(widget->name, sizeof (widget->name),
"widget #%u (%s)", widgets++, class_name);
if (c_mem_check.value.n && i_debug.value.n)
C_trace("Initialized %s", widget->name);
widget->shown = TRUE;
}
/******************************************************************************\
Checks if a texture is non-power-of-two. Prints warnings if it is and NPOT
textures are not supported.
\******************************************************************************/
static void texture_check_npot(r_texture_t *pt)
{
if (!pt || !pt->surface ||
(C_is_pow2(pt->surface->w) && C_is_pow2(pt->surface->h))) {
pt->not_pow2 = FALSE;
return;
}
pt->not_pow2 = TRUE;
pt->pow2_w = C_next_pow2(pt->surface->w);
pt->pow2_h = C_next_pow2(pt->surface->h);
pt->uv_scale = C_vec2((float)pt->surface->w / pt->pow2_w,
(float)pt->surface->h / pt->pow2_h);
if (r_ext.npot_textures)
return;
C_trace("Texture '%s' not power-of-two: %dx%d",
pt->ref.name, pt->surface->w, pt->surface->h);
}
/******************************************************************************\
Handle an SDL event. Does not allow multiple keys or mouse buttons to be
pressed at the same time.
\******************************************************************************/
void I_dispatch(const SDL_Event *ev)
{
SDLMod mod;
i_event_t event;
/* Update modifiers */
mod = SDL_GetModState();
i_key_shift = mod & KMOD_SHIFT;
i_key_alt = mod & KMOD_ALT;
i_key_ctrl = mod & KMOD_CTRL;
/* Before dispatch */
switch (ev->type) {
case SDL_ACTIVEEVENT:
/* If the mouse focus was lost, reset the cursor position */
if (!ev->active.gain &&
(ev->active.state & SDL_APPMOUSEFOCUS))
i_mouse = C_vec2(-1.f, -1.f);
return;
case SDL_KEYDOWN:
event = I_EV_KEY_DOWN;
i_key = ev->key.keysym.sym;
i_key_unicode = ev->key.keysym.unicode;
if (i_debug.value.n > 0)
C_trace("SDL_KEYDOWN (%s%s)",
(i_key_shift ? "shift + " : ""),
I_key_string(i_key_unicode));
if (!i_key) {
C_warning("SDL sent zero keysym");
return;
}
break;
case SDL_KEYUP:
event = I_EV_KEY_UP;
i_key = ev->key.keysym.sym;
if (i_debug.value.n > 0)
C_trace("SDL_KEYUP (%s%s)",
(i_key_shift ? "shift + " : ""),
I_key_string(i_key_unicode));
break;
case SDL_MOUSEMOTION:
event = I_EV_MOUSE_MOVE;
i_mouse.x = ev->motion.x / r_scale_2d;
i_mouse.y = ev->motion.y / r_scale_2d;
find_focus();
break;
case SDL_MOUSEBUTTONDOWN:
event = I_EV_MOUSE_DOWN;
i_mouse_button = ev->button.button;
if (i_debug.value.n > 0)
C_trace("SDL_MOUSEBUTTONDOWN (%d)", i_mouse_button);
check_mouse_focus(mouse_focus);
break;
case SDL_MOUSEBUTTONUP:
event = I_EV_MOUSE_UP;
i_mouse_button = ev->button.button;
if (i_debug.value.n > 0)
C_trace("SDL_MOUSEBUTTONUP (%d)", i_mouse_button);
check_mouse_focus(mouse_focus);
break;
default:
return;
}
/* Update focus widgets for this event */
i_key_focus = key_focus;
i_mouse_focus = mouse_focus;
/* Key and mouse down events are propagated back from the focused
widget up the hierarchy */
if (event == I_EV_KEY_DOWN) {
I_global_key();
if (i_key_focus) {
i_key_focus->event_func(i_key_focus, event);
propagate_up(i_key_focus->parent, event);
}
} else if (event == I_EV_MOUSE_DOWN || event == I_EV_MOUSE_MOVE)
propagate_up(mouse_focus, event);
/* Normal event propagation up from the root widget */
else
I_widget_event(&i_root, event);
/* After dispatch */
switch (ev->type) {
case SDL_MOUSEBUTTONUP:
i_mouse_button = 0;
break;
case SDL_KEYUP:
i_key = 0;
break;
default:
break;
}
}
/******************************************************************************\
Dispatches basic widget events and does some checks to see if the event
applies to this widget. Cleans up resources on I_EV_CLEANUP and propagates
the event to all child widgets.
Key focus follows the mouse. Only one widget can have keyboard focus at any
time and that is the last widget that the mouse cursor passed over that
could take keyboard input.
Events filter down through containers to child widgets. The ordering will call
all of a widget's parent containers before calling the widget and will call
all of the children of a widget before calling a sibling.
Always call this function instead of a widget's class event function in order
to ensure correct event filtering and propagation.
\******************************************************************************/
void I_widget_event(i_widget_t *widget, i_event_t event)
{
if (!widget)
return;
if (!widget->name[0] || !widget->event_func) {
if (event == I_EV_CLEANUP)
return;
C_error("Propagated %s to uninitialized widget, parent is %s",
I_event_to_string(event),
widget->parent ? widget->parent->name : "NULL");
}
/* The only event an unconfigured widget can handle is I_EV_CONFIGURE */
if (!widget->configured && event != I_EV_CONFIGURE) {
if (widget->auto_configure)
I_widget_event(widget, I_EV_CONFIGURE);
if (!widget->configured)
C_error("Propagated %s to unconfigured %s",
I_event_to_string(event), widget->name);
}
/* Print out the event in debug mode */
if (i_debug.value.n >= 2)
switch (event) {
default:
C_trace("%s --> %s", I_event_to_string(event),
widget->name);
case I_EV_RENDER:
case I_EV_MOUSE_MOVE:
case I_EV_MOUSE_FOCUS:
case I_EV_GRAB_FOCUS:
case I_EV_KEY_UP:
case I_EV_MOUSE_UP:
break;
}
/* Before handling and propagating event to children */
switch (event) {
case I_EV_CLEANUP:
if (c_mem_check.value.n)
C_trace("Freeing %s", widget->name);
break;
case I_EV_CONFIGURE:
if (c_mem_check.value.n)
C_trace("Configuring %s", widget->name);
break;
case I_EV_GRAB_FOCUS:
if (widget->entry && widget->shown &&
widget->state != I_WS_DISABLED)
key_focus = widget;
break;
case I_EV_HIDE:
if (!widget->shown)
return;
widget->shown = FALSE;
widget->event_func(widget, event);
focus_parent(widget);
return;
case I_EV_KEY_DOWN:
if (widget->steal_keys &&
widget->state != I_WS_DISABLED && widget->shown &&
widget->state != I_WS_NO_FOCUS)
widget->event_func(widget, event);
return;
case I_EV_MOUSE_IN:
if (widget->state == I_WS_READY)
widget->state = I_WS_HOVER;
widget->event_func(widget, event);
return;
case I_EV_MOUSE_OUT:
if (widget->state == I_WS_HOVER || widget->state == I_WS_ACTIVE)
widget->state = I_WS_READY;
widget->event_func(widget, event);
return;
case I_EV_MOUSE_DOWN:
widget->event_func(widget, event);
return;
case I_EV_MOUSE_FOCUS:
if (!check_mouse_focus(widget))
return;
break;
case I_EV_MOUSE_MOVE:
if (widget->state == I_WS_READY)
I_widget_event(widget, I_EV_MOUSE_IN);
widget->event_func(widget, event);
return;
case I_EV_KEY_FOCUS:
key_focus = mouse_focus;
widget->event_func(widget, event);
return;
case I_EV_MOVED:
C_error("I_EV_MOVED should only be generated by "
"I_widget_move()");
case I_EV_RENDER:
if (!i_debug.value.n && widget->parent &&
!C_rect_intersect(widget->origin, widget->size,
widget->parent->origin,
widget->parent->size))
return;
if (i_fade.value.f > 0.f) {
float target, rate;
target = 0.f;
/* Widgets inherit the parent widget's fade */
if (widget->shown) {
target = 1.f;
if (widget->parent)
target = widget->parent->fade;
}
rate = i_fade.value.f * c_frame_sec;
if (widget->state == I_WS_DISABLED) {
target *= 0.25f;
if (widget->fade <= 0.25f)
rate *= 0.25f;
}
if (widget->fade < target) {
widget->fade += rate;
if (widget->fade > target)
widget->fade = target;
} else if (widget->fade > target) {
widget->fade -= rate;
if (widget->fade < target)
widget->fade = target;
}
/* Widget should never be less faded than its parent */
if (widget->parent &&
widget->parent->fade < widget->fade)
widget->fade = widget->parent->fade;
if (widget->fade <= 0.f)
return;
} else if (!widget->shown)
return;
break;
case I_EV_SHOW:
if (widget->shown)
return;
widget->shown = TRUE;
widget->event_func(widget, event);
find_focus();
return;
default:
break;
}
/* Call widget-specific event handler and propagate event down */
if (widget->event_func(widget, event))
I_widget_propagate(widget, event);
/* After handling and propagation to children */
switch (event) {
case I_EV_CONFIGURE:
widget->configured = TRUE;
break;
case I_EV_CLEANUP:
focus_parent(widget);
if (i_mouse_focus == widget)
i_mouse_focus = NULL;
if (i_key_focus == widget)
i_key_focus = NULL;
if (widget->heap)
C_free(widget);
else
C_zero(widget);
break;
case I_EV_MOUSE_DOWN:
case I_EV_MOUSE_UP:
if (mouse_focus == widget && widget->state == I_WS_READY)
widget->state = I_WS_HOVER;
break;
default:
break;
}
}
/******************************************************************************\
Called from within the network namespace when a network event arrives for the
server from one of the clients (including the server's client).
\******************************************************************************/
static void server_callback(int client, n_event_t event)
{
g_client_msg_t token;
/* Special client events */
if (event == N_EV_CONNECTED) {
N_broadcast_except(N_HOST_CLIENT_ID, "11",
G_SM_CONNECTED, client);
init_client(client);
return;
} else if (event == N_EV_DISCONNECTED) {
client_disconnected(client);
return;
}
/* Handle messages */
if (event != N_EV_MESSAGE)
return;
token = (g_client_msg_t)N_receive_char();
/* Debug messages */
if (g_debug_net.value.n)
C_trace("%s from client %d", cm_to_string(token), client);
/* Only certain messages allowed when the game is over */
if (g_game_over)
switch (token) {
case G_CM_CHAT:
case G_CM_NAME:
break;
default:
return;
}
switch (token) {
case G_CM_AFFILIATE:
cm_affiliate(client);
break;
case G_CM_CHAT:
cm_chat(client);
break;
case G_CM_NAME:
cm_name(client);
break;
case G_CM_SHIP_BUY:
cm_ship_buy(client);
break;
case G_CM_SHIP_DROP:
cm_ship_drop(client);
break;
case G_CM_SHIP_NAME:
cm_ship_name(client);
break;
case G_CM_SHIP_MOVE:
cm_ship_move(client);
break;
case G_CM_SHIP_PRICES:
cm_ship_prices(client);
break;
case G_CM_SHIP_RING:
cm_ship_ring(client);
break;
case G_CM_TILE_RING:
cm_tile_ring(client);
break;
default:
break;
}
}
