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
|
#define _XOPEN_SOURCE 700
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <strings.h>
#include <poll.h>
#include <time.h>
#include "swaybar/event_loop.h"
#include "list.h"
struct event_item {
void (*cb)(int fd, short mask, void *data);
void *data;
};
struct timer_item {
timer_t timer;
void (*cb)(timer_t timer, void *data);
void *data;
};
static struct {
// The order of each must be kept consistent
struct { /* pollfd array */
struct pollfd *items;
int capacity;
int length;
} fds;
list_t *items; /* event_item list */
// Timer list
list_t *timers;
} event_loop;
void add_timer(timer_t timer,
void(*cb)(timer_t timer, void *data),
void *data) {
struct timer_item *item = malloc(sizeof(struct timer_item));
item->timer = timer;
item->cb = cb;
item->data = data;
list_add(event_loop.timers, item);
}
void add_event(int fd, short mask,
void(*cb)(int fd, short mask, void *data), void *data) {
struct pollfd pollfd = {
fd,
mask,
0,
};
// Resize
if (event_loop.fds.length == event_loop.fds.capacity) {
event_loop.fds.capacity += 10;
event_loop.fds.items = realloc(event_loop.fds.items,
sizeof(struct pollfd) * event_loop.fds.capacity);
}
event_loop.fds.items[event_loop.fds.length++] = pollfd;
struct event_item *item = malloc(sizeof(struct event_item));
item->cb = cb;
item->data = data;
list_add(event_loop.items, item);
return;
}
bool remove_event(int fd) {
int index = -1;
for (int i = 0; i < event_loop.fds.length; ++i) {
if (event_loop.fds.items[i].fd == fd) {
index = i;
}
}
if (index != -1) {
free(event_loop.items->items[index]);
--event_loop.fds.length;
memmove(&event_loop.fds.items[index], &event_loop.fds.items[index + 1],
sizeof(struct pollfd) * event_loop.fds.length - index);
list_del(event_loop.items, index);
return true;
} else {
return false;
}
}
static int timer_item_timer_cmp(const void *_timer_item, const void *_timer) {
const struct timer_item *timer_item = _timer_item;
const timer_t *timer = _timer;
if (timer_item->timer == *timer) {
return 0;
} else {
return -1;
}
}
bool remove_timer(timer_t timer) {
int index = list_seq_find(event_loop.timers, timer_item_timer_cmp, &timer);
if (index != -1) {
free(event_loop.timers->items[index]);
list_del(event_loop.timers, index);
return true;
}
return false;
}
void event_loop_poll() {
poll(event_loop.fds.items, event_loop.fds.length, -1);
for (int i = 0; i < event_loop.fds.length; ++i) {
struct pollfd pfd = event_loop.fds.items[i];
struct event_item *item = (struct event_item *)event_loop.items->items[i];
if (pfd.revents & pfd.events) {
item->cb(pfd.fd, pfd.revents, item->data);
}
}
// check timers
// not tested, but seems to work
for (int i = 0; i < event_loop.timers->length; ++i) {
struct timer_item *item = event_loop.timers->items[i];
int overrun = timer_getoverrun(item->timer);
if (overrun && overrun != -1) {
item->cb(item->timer, item->data);
}
}
}
void init_event_loop() {
event_loop.fds.length = 0;
event_loop.fds.capacity = 10;
event_loop.fds.items = malloc(
event_loop.fds.capacity * sizeof(struct pollfd));
event_loop.items = create_list();
event_loop.timers = create_list();
}
|
