#define CREATE_AREA_THRESHOLD 10.0
#define RECT_LAYER_GRID_ROWS 3
#define RECT_LAYER_GRID_COLUMNS 4
-#define SNAPPING_THRESHOLD 10.0f
-static int clipboard = 0;
-static Rect clipboard_rect;
-static Color clipboard_color;
+static int rect_clipboard = 0;
+static Rect rect_clipboard_rect;
+static Color rect_clipboard_color;
static Cursor_Style resize_styles[1 << RECT_SIDE_N] = {
0, // [0]
Grid *grid;
Cursor *cursor;
- // this is the initial size of the selected rectangle during a resize.
- // this is updated when the rectangle is clicked.
- Vec2f initial_rectangle_size;
-
- // TODO(#1157): potentially refactor this out to exist game-wide.
- int modifier_flags;
+ int snapping_enabled;
};
-#define MODIFIER_FLAG_CONTROL 0x1
-#define MODIFIER_FLAG_SHIFT 0x2
-#define MODIFIER_FLAG_ALT 0x4
-
-
typedef enum {
- UNDO_ADD,
- UNDO_DELETE,
- UNDO_UPDATE,
- UNDO_SWAP
-} UndoType;
+ RECT_UNDO_ADD,
+ RECT_UNDO_DELETE,
+ RECT_UNDO_UPDATE,
+ RECT_UNDO_SWAP
+} RectUndoType;
// Delete, Update
typedef struct {
- UndoType type;
+ RectUndoType type;
RectLayer *layer;
size_t index;
Rect rect;
// Add
typedef struct {
- UndoType type;
+ RectUndoType type;
RectLayer *layer;
size_t index;
} UndoAddContext;
// Swap
typedef struct {
- UndoType type;
+ RectUndoType type;
RectLayer *layer;
size_t index1;
size_t index2;
} UndoSwapContext;
typedef union {
- UndoType type;
+ RectUndoType type;
UndoAddContext add;
UndoElementContext element;
UndoSwapContext swap;
-} UndoContext;
+} RectUndoContext;
static
-UndoContext create_undo_add_context(RectLayer *layer, size_t index)
+RectUndoContext create_rect_undo_add_context(RectLayer *layer, size_t index)
{
trace_assert(layer);
trace_assert(index < dynarray_count(layer->rects));
- UndoContext undo_context;
- undo_context.add.type = UNDO_ADD;
+ RectUndoContext undo_context;
+ undo_context.add.type = RECT_UNDO_ADD;
undo_context.add.layer = layer;
undo_context.add.index = index;
return undo_context;
}
static
-UndoContext create_undo_element_context(RectLayer *layer)
+RectUndoContext create_rect_undo_element_context(RectLayer *layer)
{
trace_assert(layer);
size_t index = (size_t) layer->selection;
trace_assert(index < dynarray_count(layer->rects));
- UndoContext undo_context;
+ RectUndoContext undo_context;
undo_context.element.layer = layer;
undo_context.element.index = index;
dynarray_copy_to(layer->rects, &undo_context.element.rect, index);
}
static
-UndoContext create_undo_update_context(RectLayer *rect_layer)
+RectUndoContext create_rect_undo_update_context(RectLayer *rect_layer)
{
- UndoContext undo_context = create_undo_element_context(rect_layer);
- undo_context.type = UNDO_UPDATE;
+ RectUndoContext undo_context = create_rect_undo_element_context(rect_layer);
+ undo_context.type = RECT_UNDO_UPDATE;
return undo_context;
}
static
-UndoContext create_undo_delete_context(RectLayer *rect_layer)
+RectUndoContext create_rect_undo_delete_context(RectLayer *rect_layer)
{
- UndoContext undo_context = create_undo_element_context(rect_layer);
- undo_context.type = UNDO_DELETE;
+ RectUndoContext undo_context = create_rect_undo_element_context(rect_layer);
+ undo_context.type = RECT_UNDO_DELETE;
return undo_context;
}
static
-UndoContext create_undo_swap_context(RectLayer *rect_layer, size_t index1, size_t index2)
+RectUndoContext create_rect_undo_swap_context(RectLayer *rect_layer, size_t index1, size_t index2)
{
- UndoContext undo_context;
- undo_context.swap.type = UNDO_SWAP;
+ RectUndoContext undo_context;
+ undo_context.swap.type = RECT_UNDO_SWAP;
undo_context.swap.layer = rect_layer;
undo_context.swap.index1 = index1;
undo_context.swap.index2 = index2;
void rect_layer_undo(void *context, size_t context_size)
{
trace_assert(context);
- trace_assert(sizeof(UndoContext) == context_size);
+ trace_assert(sizeof(RectUndoContext) == context_size);
- UndoContext *undo_context = context;
+ RectUndoContext *undo_context = context;
switch (undo_context->type) {
- case UNDO_ADD: {
+ case RECT_UNDO_ADD: {
RectLayer *layer = undo_context->add.layer;
dynarray_delete_at(layer->rects, undo_context->add.index);
dynarray_delete_at(layer->colors, undo_context->add.index);
layer->selection = -1;
} break;
- case UNDO_DELETE: {
+ case RECT_UNDO_DELETE: {
RectLayer *layer = undo_context->element.layer;
dynarray_insert_before(layer->rects, undo_context->element.index, &undo_context->element.rect);
dynarray_insert_before(layer->colors, undo_context->element.index, &undo_context->element.color);
layer->selection = -1;
} break;
- case UNDO_UPDATE: {
+ case RECT_UNDO_UPDATE: {
RectLayer *layer = undo_context->element.layer;
dynarray_replace_at(layer->rects, undo_context->element.index, &undo_context->element.rect);
dynarray_replace_at(layer->colors, undo_context->element.index, &undo_context->element.color);
dynarray_replace_at(layer->actions, undo_context->element.index, &undo_context->element.action);
} break;
- case UNDO_SWAP: {
+ case RECT_UNDO_SWAP: {
RectLayer *layer = undo_context->element.layer;
dynarray_swap(layer->rects, undo_context->swap.index1, undo_context->swap.index2);
dynarray_swap(layer->colors, undo_context->swap.index1, undo_context->swap.index2);
}
}
-#define UNDO_PUSH(HISTORY, CONTEXT) \
+#define RECT_UNDO_PUSH(HISTORY, CONTEXT) \
do { \
- UndoContext context = (CONTEXT); \
+ RectUndoContext context = (CONTEXT); \
undo_history_push( \
HISTORY, \
rect_layer_undo, \
dynarray_push_empty(layer->actions);
- UNDO_PUSH(
+ RECT_UNDO_PUSH(
undo_history,
- create_undo_add_context(
+ create_rect_undo_add_context(
layer,
dynarray_count(layer->rects) - 1));
dynarray_swap(layer->ids, a, b);
dynarray_swap(layer->actions, a, b);
- UNDO_PUSH(undo_history, create_undo_swap_context(layer, a, b));
+ RECT_UNDO_PUSH(undo_history, create_rect_undo_swap_context(layer, a, b));
}
static int rect_layer_delete_rect_at(RectLayer *layer,
{
trace_assert(layer);
- UNDO_PUSH(undo_history, create_undo_delete_context(layer));
+ RECT_UNDO_PUSH(undo_history, create_rect_undo_delete_context(layer));
dynarray_delete_at(layer->rects, i);
dynarray_delete_at(layer->colors, i);
layer->create_end = position;
}
}
-
- // update the initial size if we selected a rectangle.
- if (layer->selection >= 0) {
- layer->initial_rectangle_size = vec(rects[layer->selection].w,
- rects[layer->selection].h);
- }
} break;
}
} break;
}
} break;
+ case SDLK_q: {
+ // TODO(#1171): there is no UI indication that we are in the snapping mode
+ layer->snapping_enabled = !layer->snapping_enabled;
+ } break;
+
case SDLK_F2: {
if (layer->selection >= 0) {
const char *ids = dynarray_data(layer->ids);
case SDLK_c: {
if ((event->key.keysym.mod & KMOD_LCTRL) && layer->selection >= 0) {
- clipboard = 1;
- dynarray_copy_to(layer->rects, &clipboard_rect, (size_t)layer->selection);
- dynarray_copy_to(layer->colors, &clipboard_color, (size_t)layer->selection);
+ rect_clipboard = 1;
+ dynarray_copy_to(layer->rects, &rect_clipboard_rect, (size_t)layer->selection);
+ dynarray_copy_to(layer->colors, &rect_clipboard_color, (size_t)layer->selection);
}
} break;
case SDLK_v: {
- if ((event->key.keysym.mod & KMOD_LCTRL) && clipboard) {
+ if ((event->key.keysym.mod & KMOD_LCTRL) && rect_clipboard) {
int x, y;
SDL_GetMouseState(&x, &y);
Vec2f position = camera_map_screen(camera, x, y);
rect_layer_add_rect(
layer,
rect(position.x, position.y,
- clipboard_rect.w, clipboard_rect.h),
- clipboard_color,
+ rect_clipboard_rect.w, rect_clipboard_rect.h),
+ rect_clipboard_color,
undo_history);
}
} break;
return 0;
}
-static inline
-int segment_overlap(Vec2f a, Vec2f b)
-{
- trace_assert(a.x <= a.y);
- trace_assert(b.x <= b.y);
- return a.y >= b.x && b.y >= a.x;
-}
-
-static
-void snap_var(float *x, // the value we are snapping
- float y, // the target we are snapping x to
- float xo, // x offset
- float yo, // y offset
- float st) // snap threshold
-{
- if (fabsf((*x + xo) - (y + yo)) < st)
- *x = y + yo - xo;
-}
-
static
-void snap_var2seg(float *x, float y,
- float xo, float yo,
- float st)
+void snap_rect_resize_if_enabled(RectLayer *layer, Rect *a, float snapping_threshold)
{
- snap_var(x, y, xo, 0, st);
- snap_var(x, y, xo, yo, st);
-}
-
-static
-void snap_seg2seg(float *x, float y, float xo, float yo, float st)
-{
- snap_var(x, y, 0, 0, st);
- snap_var(x, y, 0, yo, st);
- snap_var(x, y, xo, 0, st);
- snap_var(x, y, xo, yo, st);
-}
+ trace_assert(layer);
+ trace_assert(layer->selection >= 0);
+ trace_assert(a);
-static
-void maybe_fix_to_ratio(RectLayer *layer,
- float *x, float *y, // the things we can change to fix the ratio
- Vec2f ref_pt) // the (fixed) reference point of the rect
-{
- // if we're not holding down shift, don't bother.
- if (!(layer->modifier_flags & MODIFIER_FLAG_SHIFT))
- return;
+ if (!layer->snapping_enabled) return;
- float ratio = layer->initial_rectangle_size.x / layer->initial_rectangle_size.y;
+ Rect *rects = dynarray_data(layer->rects);
+ size_t rects_size = dynarray_count(layer->rects);
- // if we are holding down control also, then make squares.
- if (layer->modifier_flags & MODIFIER_FLAG_CONTROL)
- ratio = 1.0f;
+ for (size_t i = 0; i < rects_size; ++i) {
+ if (i == (size_t) layer->selection) continue;
- float inv_ratio = 1.0f / ratio;
- float w = *x - ref_pt.x;
- float h = *y - ref_pt.y;
+ const Rect b = rects[i];
- float ab_w = fabsf(w);
- float ab_h = fabsf(h);
+ if (segment_overlap(vec(a->x, a->x + a->w), vec(b.x, b.x + b.w))) {
+ snap_var2seg(&a->y, b.y, 0, b.h, snapping_threshold);
+ }
- // note: copysign takes (magnitude, sign).
- if (ab_w <= ratio * ab_h) { *x = ref_pt.x + (ratio * copysignf(h, w)); printf("*x = %.1f\n", *x); }
- else if (ab_h <= inv_ratio * ab_w) { *y = ref_pt.y + inv_ratio * copysignf(w, h); printf("*y = %.1f\n", *y); }
+ if (segment_overlap(vec(a->y, a->y + a->h), vec(b.y, b.y + b.h))) {
+ snap_var2seg(&a->x, b.x, 0, b.w, snapping_threshold);
+ }
+ }
}
-
static int rect_layer_event_resize(RectLayer *layer,
const SDL_Event *event,
const Camera *camera,
Rect *rects = dynarray_data(layer->rects);
+ float scaled_snap_threshold = SNAPPING_THRESHOLD / camera->scale;
+
switch (event->type) {
case SDL_MOUSEMOTION: {
Vec2f position = camera_map_screen(
switch (layer->resize_mask) {
case 1: { // TOP
- float y = position.y;
- float x = rects[layer->selection].x;
- float w = rects[layer->selection].w;
- for (size_t i = 0; i < dynarray_count(layer->rects); ++i) {
- if (i == (size_t) layer->selection) continue;
-
- const Rect b = rects[i];
- if (segment_overlap(vec(x, x + w), vec(b.x, b.x + b.w))) {
- snap_var2seg(&y, b.y, 0, b.h, SNAPPING_THRESHOLD);
- }
- }
+ Rect a = rect(rects[layer->selection].x,
+ position.y,
+ rects[layer->selection].w,
+ rects[layer->selection].h);
+
+ snap_rect_resize_if_enabled(layer, &a, scaled_snap_threshold);
layer->inter_rect = rect_from_points(
- vec(x, y),
+ vec(a.x, a.y),
rect_position2(rects[layer->selection]));
} break;
case 2: { // LEFT
- float y = rects[layer->selection].y;
- float x = position.x;
- float h = rects[layer->selection].h;
- for (size_t i = 0; i < dynarray_count(layer->rects); ++i) {
- if (i == (size_t) layer->selection) continue;
-
- const Rect b = rects[i];
- if (segment_overlap(vec(y, y + h), vec(b.y, b.y + b.h))) {
- snap_var2seg(&x, b.x, 0, b.w, SNAPPING_THRESHOLD);
- }
- }
+ Rect a = rect(position.x,
+ rects[layer->selection].y,
+ rects[layer->selection].w,
+ rects[layer->selection].h);
+
+ snap_rect_resize_if_enabled(layer, &a, scaled_snap_threshold);
layer->inter_rect = rect_from_points(
- vec(x, y),
+ vec(a.x, a.y),
rect_position2(rects[layer->selection]));
} break;
case 3: { // TOP,LEFT
- float x = position.x;
- float y = position.y;
- float w = rects[layer->selection].w;
- float h = rects[layer->selection].h;
- for (size_t i = 0; i < dynarray_count(layer->rects); ++i) {
- if (i == (size_t) layer->selection) continue;
-
- const Rect b = rects[i];
- if (segment_overlap(vec(y, y + h), vec(b.y, b.y + b.h))) {
- snap_var2seg(&x, b.x, 0, b.w, SNAPPING_THRESHOLD);
- }
+ Rect a = rect(
+ position.x,
+ position.y,
+ rects[layer->selection].w,
+ rects[layer->selection].h);
- if (segment_overlap(vec(x, x + w), vec(b.x, b.x + b.w))) {
- snap_var2seg(&y, b.y, 0, b.h, SNAPPING_THRESHOLD);
- }
- }
-
- // use the bottom-right as reference.
- maybe_fix_to_ratio(layer, &x, &y, vec(rects[layer->selection].x + rects[layer->selection].w,
- rects[layer->selection].y + rects[layer->selection].h));
+ snap_rect_resize_if_enabled(layer, &a, scaled_snap_threshold);
layer->inter_rect = rect_from_points(
- vec(x, y),
+ vec(a.x, a.y),
rect_position2(rects[layer->selection]));
} break;
case 4: { // BOTTOM
- float y = position.y;
- float x = rects[layer->selection].x;
- float w = rects[layer->selection].w;
- for (size_t i = 0; i < dynarray_count(layer->rects); ++i) {
- if (i == (size_t) layer->selection) continue;
-
- const Rect b = rects[i];
- if (segment_overlap(vec(x, x + w), vec(b.x, b.x + b.w))) {
- snap_var2seg(&y, b.y, 0, b.h, SNAPPING_THRESHOLD);
- }
- }
+ Rect a = rect(rects[layer->selection].x,
+ position.y,
+ rects[layer->selection].w,
+ rects[layer->selection].h);
+
+ snap_rect_resize_if_enabled(layer, &a, scaled_snap_threshold);
layer->inter_rect = rect_from_points(
rect_position(rects[layer->selection]),
vec(rects[layer->selection].x + rects[layer->selection].w,
- y));
+ a.y));
} break;
case 6: { // BOTTOM,LEFT
- float x = position.x;
- float y = position.y;
- float w = rects[layer->selection].w;
- float h = rects[layer->selection].h;
- for (size_t i = 0; i < dynarray_count(layer->rects); ++i) {
- if (i == (size_t) layer->selection) continue;
-
- const Rect b = rects[i];
- if (segment_overlap(vec(y, y + h), vec(b.y, b.y + b.h))) {
- snap_var2seg(&x, b.x, 0, b.w, SNAPPING_THRESHOLD);
- }
+ Rect a = rect(
+ position.x,
+ position.y,
+ rects[layer->selection].w,
+ -rects[layer->selection].h);
- if (segment_overlap(vec(x, x + w), vec(b.x, b.x + b.w))) {
- snap_var2seg(&y, b.y, 0, b.h, SNAPPING_THRESHOLD);
- }
- }
-
- // use the top-right as reference.
- maybe_fix_to_ratio(layer, &x, &y, vec(rects[layer->selection].x + rects[layer->selection].w,
- rects[layer->selection].y));
+ snap_rect_resize_if_enabled(layer, &a, scaled_snap_threshold);
layer->inter_rect = rect_from_points(
- vec(x, rects[layer->selection].y),
+ vec(a.x, rects[layer->selection].y),
vec(rects[layer->selection].x + rects[layer->selection].w,
- y));
+ a.y));
} break;
case 8: { // RIGHT
- float y = rects[layer->selection].y;
- float x = position.x;
- float h = rects[layer->selection].h;
- for (size_t i = 0; i < dynarray_count(layer->rects); ++i) {
- if (i == (size_t) layer->selection) continue;
-
- const Rect b = rects[i];
- if (segment_overlap(vec(y, y + h), vec(b.y, b.y + b.h))) {
- snap_var2seg(&x, b.x, 0, b.w, SNAPPING_THRESHOLD);
- }
- }
+ Rect a = rect(position.x,
+ rects[layer->selection].y,
+ rects[layer->selection].w,
+ rects[layer->selection].h);
+
+ snap_rect_resize_if_enabled(layer, &a, scaled_snap_threshold);
layer->inter_rect = rect_from_points(
rect_position(rects[layer->selection]),
- vec(x,
- rects[layer->selection].y + rects[layer->selection].h));
+ vec(a.x, rects[layer->selection].y + rects[layer->selection].h));
} break;
case 9: { // TOP,RIGHT
- float x = position.x;
- float y = position.y;
- float w = rects[layer->selection].w;
- float h = rects[layer->selection].h;
- for (size_t i = 0; i < dynarray_count(layer->rects); ++i) {
- if (i == (size_t) layer->selection) continue;
-
- const Rect b = rects[i];
- if (segment_overlap(vec(y, y + h), vec(b.y, b.y + b.h))) {
- snap_var2seg(&x, b.x, 0, b.w, SNAPPING_THRESHOLD);
- }
-
- if (segment_overlap(vec(x, x + w), vec(b.x, b.x + b.w))) {
- snap_var2seg(&y, b.y, 0, b.h, SNAPPING_THRESHOLD);
- }
- }
+ Rect a = rect(
+ position.x,
+ position.y,
+ -rects[layer->selection].w,
+ rects[layer->selection].h);
- // note: the reference position is always the opposite corner!
- maybe_fix_to_ratio(layer, &x, &y, vec(rects[layer->selection].x,
- rects[layer->selection].y + rects[layer->selection].h));
+ snap_rect_resize_if_enabled(layer, &a, scaled_snap_threshold);
layer->inter_rect = rect_from_points(
- vec(rects[layer->selection].x, y),
- vec(x,
+ vec(rects[layer->selection].x, a.y),
+ vec(a.x,
rects[layer->selection].y + rects[layer->selection].h));
} break;
case 12: { // BOTTOM,RIGHT
- float x = position.x;
- float y = position.y;
- float w = rects[layer->selection].w;
- float h = rects[layer->selection].h;
+ Rect a = rect(
+ position.x,
+ position.y,
+ -rects[layer->selection].w,
+ -rects[layer->selection].h);
- for (size_t i = 0; i < dynarray_count(layer->rects); ++i) {
- if (i == (size_t) layer->selection) continue;
-
- const Rect b = rects[i];
- if (segment_overlap(vec(y, y + h), vec(b.y, b.y + b.h))) {
- snap_var2seg(&x, b.x, 0, b.w, SNAPPING_THRESHOLD);
- }
-
- if (segment_overlap(vec(x, x + w), vec(b.x, b.x + b.w))) {
- snap_var2seg(&y, b.y, 0, b.h, SNAPPING_THRESHOLD);
- }
- }
-
- maybe_fix_to_ratio(layer, &x, &y, rect_position(rects[layer->selection]));
+ snap_rect_resize_if_enabled(layer, &a, scaled_snap_threshold);
layer->inter_rect = rect_from_points(
rect_position(rects[layer->selection]),
- vec(x, y));
+ vec(a.x, a.y));
} break;
}
+
} break;
case SDL_MOUSEBUTTONUP: {
layer->state = RECT_LAYER_IDLE;
- UNDO_PUSH(undo_history, create_undo_update_context(layer));
+ RECT_UNDO_PUSH(undo_history, create_rect_undo_update_context(layer));
dynarray_replace_at(layer->rects, (size_t) layer->selection, &layer->inter_rect);
} break;
}
}
static
-void snap_rects(size_t ignore_index, Rect *a,
- Rect *rects, size_t rects_size,
- float snapping_threshold)
+void snap_rect_move_if_enabled(RectLayer *layer, Rect *a,
+ float snapping_threshold)
{
- trace_assert(rects);
trace_assert(a);
+ trace_assert(layer);
+ trace_assert(layer->selection >= 0);
+
+ if (!layer->snapping_enabled) return;
+
+ Rect *rects = dynarray_data(layer->rects);
+ size_t rects_size = dynarray_count(layer->rects);
for (size_t i = 0; i < rects_size; ++i) {
- if (i == ignore_index) continue;
+ if (i == (size_t) layer->selection) continue;
const Rect b = rects[i];
}
}
- // TODO(#1141): Rect Snapping in Level Editor should be optional
- snap_rects((size_t) layer->selection, &layer->inter_rect,
- rects, dynarray_count(layer->rects),
- SNAPPING_THRESHOLD / camera->scale);
+ snap_rect_move_if_enabled(layer, &layer->inter_rect,
+ SNAPPING_THRESHOLD / camera->scale);
} break;
case SDL_MOUSEBUTTONUP: {
rect_position(rects[layer->selection])));
if (distance > 1e-6) {
- UNDO_PUSH(undo_history, create_undo_update_context(layer));
+ RECT_UNDO_PUSH(undo_history, create_rect_undo_update_context(layer));
dynarray_replace_at(layer->rects, (size_t) layer->selection, &layer->inter_rect);
}
} break;
case SDL_KEYDOWN: {
switch (event->key.keysym.sym) {
case SDLK_RETURN: {
- UNDO_PUSH(undo_history, create_undo_update_context(layer));
+ RECT_UNDO_PUSH(undo_history, create_rect_undo_update_context(layer));
char *id = dynarray_pointer_at(layer->ids, (size_t)layer->selection);
memset(id, 0, ENTITY_MAX_ID_SIZE);
layer->inter_color = color_picker_rgba(&layer->color_picker);
if (!color_picker_drag(&layer->color_picker)) {
- UNDO_PUSH(undo_history, create_undo_update_context(layer));
+ RECT_UNDO_PUSH(undo_history, create_rect_undo_update_context(layer));
dynarray_replace_at(layer->colors, (size_t) layer->selection, &layer->inter_color);
layer->state = RECT_LAYER_IDLE;
}
trace_assert(event);
trace_assert(undo_history);
- // TODO(#1157): we might want to refactor this out to the top-level event loop.
- // right now, this thingy is restricted to the level editor, because I think the
- // rest of the game doesn't care about modifier keys (yet!)
- if (event->type == SDL_KEYUP) {
- if (event->key.keysym.sym == SDLK_LCTRL || event->key.keysym.sym == SDLK_RCTRL)
- layer->modifier_flags &= ~MODIFIER_FLAG_CONTROL;
-
- if (event->key.keysym.sym == SDLK_LSHIFT || event->key.keysym.sym == SDLK_RSHIFT)
- layer->modifier_flags &= ~MODIFIER_FLAG_SHIFT;
-
- if (event->key.keysym.sym == SDLK_LALT || event->key.keysym.sym == SDLK_RALT)
- layer->modifier_flags &= ~MODIFIER_FLAG_ALT;
-
- } else if (event->type == SDL_KEYDOWN) {
- if (event->key.keysym.sym == SDLK_LCTRL || event->key.keysym.sym == SDLK_RCTRL)
- layer->modifier_flags |= MODIFIER_FLAG_CONTROL;
-
- if (event->key.keysym.sym == SDLK_LSHIFT || event->key.keysym.sym == SDLK_RSHIFT)
- layer->modifier_flags |= MODIFIER_FLAG_SHIFT;
-
- if (event->key.keysym.sym == SDLK_LALT || event->key.keysym.sym == SDLK_RALT)
- layer->modifier_flags |= MODIFIER_FLAG_ALT;
- }
-
switch (event->type) {
case SDL_WINDOWEVENT: {
switch (event->window.event) {
- case SDL_WINDOWEVENT_RESIZED: {
+ case SDL_WINDOWEVENT_SIZE_CHANGED: {
grid_relayout(layer->grid, rect(0.0f, 0.0f,
(float) event->window.data1,
(float) event->window.data2));