1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
|
#include <string.h>
#include <stdbool.h>
#include <ctype.h>
#include "input_state.h"
#define KEY_STATE_MAX_LENGTH 64
static keycode key_state_array[KEY_STATE_MAX_LENGTH];
void input_init(void) {
int i;
for (i = 0; i < KEY_STATE_MAX_LENGTH; ++i) {
key_state_array[i] = 0;
}
}
static uint8_t find_key(keycode key) {
int i;
for (i = 0; i < KEY_STATE_MAX_LENGTH; ++i) {
if (key_state_array[i] == key) {
break;
}
}
return i;
}
bool check_key(keycode key) {
return find_key(key) < KEY_STATE_MAX_LENGTH;
}
void press_key(keycode key) {
// Check if key exists
if (!check_key(key)) {
// Check that we dont exceed buffer length
int insert = find_key(0);
if (insert < KEY_STATE_MAX_LENGTH) {
key_state_array[insert] = key;
}
}
}
void release_key(keycode key) {
uint8_t index = find_key(key);
if (index < KEY_STATE_MAX_LENGTH) {
// shift it over and remove key
key_state_array[index] = 0;
}
}
struct pointer_state pointer_state;
// Pointer mode values
static struct mode_state {
// Initial view state
struct {
double x, y, w, h;
swayc_t *ptr;
} view;
// Initial pointer state
struct {
int x, y;
} coor;
} initial;
static struct {
enum { LEFT=1, RIGHT=0 } lr;
enum { TOP=1, BOTTOM=0 } tb;
} lock;
// Floating set/unset
static void pointer_mode_set_floating(void) {
initial.view.x = initial.view.ptr->x;
initial.view.y = initial.view.ptr->y;
initial.view.w = initial.view.ptr->width;
initial.view.h = initial.view.ptr->height;
// setup initial cooridinates
initial.coor.x = pointer_state.origin.x;
initial.coor.y = pointer_state.origin.y;
}
static void pointer_mode_reset_floating(void) {
initial.view.ptr->x = initial.view.x;
initial.view.ptr->y = initial.view.y;
initial.view.ptr->width = initial.view.w;
initial.view.ptr->height = initial.view.h;
arrange_windows(initial.view.ptr, -1, -1);
pointer_state.mode = 0;
}
// Mode set left/right click
static void pointer_mode_set_left(void) {
swayc_t *view = pointer_state.view;
initial.view.ptr = view;
if (view->is_floating) {
pointer_state.mode = M_DRAGGING | M_FLOATING;
pointer_mode_set_floating();
} else {
pointer_state.mode = M_DRAGGING | M_TILING;
}
}
static void pointer_mode_set_right(void) {
swayc_t *view = pointer_state.view;
initial.view.ptr = view;
// Setup locking information
int midway_x = view->x + view->width/2;
int midway_y = view->y + view->height/2;
lock.lr = pointer_state.origin.x > midway_x;
lock.tb = pointer_state.origin.y > midway_y;
if (view->is_floating) {
pointer_state.mode = M_RESIZING | M_FLOATING;
pointer_mode_set_floating();
} else {
pointer_state.mode = M_RESIZING | M_TILING;
}
}
// Mode set/update/reset
void pointer_mode_set(uint32_t button, bool condition) {
// switch on drag/resize mode
switch (pointer_state.mode & (M_DRAGGING | M_RESIZING)) {
case M_DRAGGING:
// end drag mode when left click is unpressed
if (!pointer_state.l_held) {
pointer_state.mode = 0;
}
break;
case M_RESIZING:
// end resize mode when right click is unpressed
if (!pointer_state.r_held) {
pointer_state.mode = 0;
}
break;
// No mode case
default:
// return if failed condition, or no view
if (!condition || !pointer_state.view) {
break;
}
// Set mode depending on current button press
switch (button) {
// Start dragging mode
case M_LEFT_CLICK:
// if button release dont do anything
if (pointer_state.l_held) {
pointer_mode_set_left();
}
break;
// Start resize mode
case M_RIGHT_CLICK:
// if button release dont do anyhting
if (pointer_state.r_held) {
pointer_mode_set_right();
}
break;
case M_SCROLL_UP:
case M_SCROLL_DOWN:
//TODO add scrolling behavior here
;
}
}
}
void pointer_mode_update(void) {
swayc_t *view = initial.view.ptr;
if (view->type != C_VIEW) {
pointer_state.mode = 0;
return;
}
int dx = pointer_state.origin.x - initial.coor.x;
int dy = pointer_state.origin.y - initial.coor.y;
bool changed = false;
switch (pointer_state.mode) {
case M_FLOATING | M_DRAGGING:
// Update position
if (initial.view.x + dx != view->x) {
view->x = initial.view.x + dx;
changed = true;
}
if (initial.view.y + dy != view->y) {
view->y = initial.view.y + dy;
changed = true;
}
break;
case M_FLOATING | M_RESIZING:
if (lock.lr) {
if (initial.view.w + dx > min_sane_w) {
if (initial.view.w + dx != view->width) {
view->width = initial.view.w + dx;
changed = true;
}
}
} else { //lock.right
if (initial.view.w - dx > min_sane_w) {
if (initial.view.w - dx != view->width) {
view->width = initial.view.w - dx;
view->x = initial.view.x + dx;
changed = true;
}
}
}
if (lock.tb) {
if (initial.view.h + dy > min_sane_h) {
if (initial.view.y - dy != view->height) {
view->height = initial.view.h + dy;
changed = true;
}
}
} else { //lock.bottom
if (initial.view.h - dy > min_sane_h) {
if (initial.view.h - dy != view->height) {
view->height = initial.view.h - dy;
view->y = initial.view.y + dy;
changed = true;
}
}
}
break;
case M_TILING | M_DRAGGING:
// swap current view under pointer with dragged view
if (pointer_state.view && pointer_state.view != initial.view.ptr) {
// Swap them around
swap_container(pointer_state.view, initial.view.ptr);
update_geometry(pointer_state.view);
update_geometry(initial.view.ptr);
// Set focus back to initial view
set_focused_container(initial.view.ptr);
}
break;
case M_TILING | M_RESIZING:
default:
return;
}
if (changed) {
update_geometry(view);
}
}
void pointer_mode_reset(void) {
switch (pointer_state.mode) {
case M_FLOATING | M_DRAGGING:
case M_FLOATING | M_RESIZING:
pointer_mode_reset_floating();
break;
case M_TILING | M_DRAGGING:
case M_TILING | M_RESIZING:
default:
return;
}
}
static struct wlc_geometry saved_floating;
void start_floating(swayc_t *view) {
if (view->is_floating) {
saved_floating.origin.x = view->x;
saved_floating.origin.y = view->y;
saved_floating.size.w = view->width;
saved_floating.size.h = view->height;
}
}
void reset_floating(swayc_t *view) {
if (view->is_floating) {
view->x = saved_floating.origin.x;
view->y = saved_floating.origin.y;
view->width = saved_floating.size.w;
view->height = saved_floating.size.h;
arrange_windows(view->parent, -1, -1);
}
pointer_state.floating = (struct pointer_floating){0, 0};
pointer_state.lock = (struct pointer_lock){0, 0, 0, 0, 0, 0, 0, 0};
}
|