source: titan/titan/rc.h @ 23991

Last change on this file since 23991 was 23286, checked in by nit, 11 years ago

[titan] cleanup

File size: 8.4 KB
Line 
1#ifndef RC_H
2#define RC_H
3
4int sendtuxtxt(int code)
5{
6        int rc;
7   
8        if((rc = open("/tmp/block.tmp", O_RDONLY)) >= 0)
9        {
10                close(rc);
11       
12                if(status.fdrctxt <= 0)
13                {
14                        struct sockaddr_un vAddr;
15                        vAddr.sun_family = AF_UNIX;
16                        strcpy(vAddr.sun_path, "/tmp/rc.socket");
17                        status.fdrctxt = socket(PF_UNIX, SOCK_STREAM, 0);
18       
19                        if(status.fdrctxt <= 0)
20                        {
21                                err("open tuxtxt rc socket");
22                                return 1;
23                        };
24
25                        if(connect(status.fdrctxt, (struct sockaddr *)&vAddr, sizeof(vAddr)) !=0)
26                        {
27                                close(status.fdrctxt);
28                                status.fdrctxt = -1;
29                                err("connect to tuxtxt rc socket");
30                                return 1;
31                        }
32                }
33       
34                if(status.fdrctxt > 0)
35                {
36                        char* tmpstr = malloc(8);
37                        if(tmpstr != NULL)
38                        {
39                                sprintf(tmpstr, "%08d", code);
40
41                                if(write(status.fdrctxt, tmpstr, 8) <= 0)
42                                {
43                                        err("forwarding to rc socket");
44                                        close(status.fdrctxt);
45                                        status.fdrctxt = -1;
46                                        free(tmpstr); tmpstr = NULL;
47                                        return 1;
48                                }
49                        }
50                        free(tmpstr); tmpstr = NULL;
51                }
52                else
53                {
54                        err("forwarding to rc socket");
55                }
56                return 0;
57        }
58
59        if(status.fdrctxt != -1)
60        {
61                close(status.fdrctxt);
62                status.fdrctxt = -1;
63        }
64        return 0;
65}
66
67int maprc(int rccode, struct skin* owner)
68{
69        if(owner != NULL)
70        {
71                struct rcmap* rcmapnode = getrcmap(owner->name, rccode);
72                if(rcmapnode != NULL)
73                        rccode = rcmapnode->newkey;
74        }
75
76        return rccode;
77}
78
79struct rc* getrc(int key, struct skin* owner)
80{
81        struct rc *node = rc;
82
83        while(node != NULL)
84        {
85                if(node->key == key && node->owner == owner)
86                        return node;
87
88                node = node->next;
89        }
90
91        node = rc;
92
93        while(node != NULL)
94        {
95                if(node->key == key && node->owner == NULL)
96                        return node;
97
98                node = node->next;
99        }
100        return NULL;
101}
102
103int openrc()
104{
105        char *rcdev = NULL;
106        int i = 0;
107
108        status.fdrc = -1;
109
110        rcdev = getconfig("rcdev", NULL);
111        if(rcdev != NULL)
112        {
113                while(status.fdrc < 0 && i < 3)
114                {
115                        status.fdrc = open(rcdev, O_RDWR);
116                        if(status.fdrc < 0) sleep(1);
117                        i++;
118                }
119
120                if(status.fdrc < 0)
121                {
122                        err("open input device %s", rcdev);
123                        return 1;
124                }
125                closeonexec(status.fdrc);
126        }
127        else
128        {
129                err("input device not found in config");
130                return 1;
131        }
132
133        return 0;
134}
135
136void closerc()
137{
138        if(status.fdrc != -1)
139                close(status.fdrc);
140}
141
142int islongkey(int keycode)
143{
144        int i = 0;
145
146        for(i = 0; i < MAXLONGKEY; i++)
147        {
148                if(status.longkeycode[i] == keycode)
149                        return 1;
150        }
151        return 0;
152}
153
154int writerc(int keycode)
155{
156        struct input_event rcdata;
157        struct timeval akttime;
158
159        gettimeofday(&akttime, 0);
160        sendtuxtxt(keycode);
161
162        rcdata.time = akttime;
163        rcdata.type = EV_KEY;
164        rcdata.code = keycode;
165        rcdata.value = 1;
166        write(status.fdrc, &rcdata, sizeof(rcdata));
167
168        rcdata.time = akttime;
169        rcdata.type = EV_KEY;
170        rcdata.code = keycode;
171        rcdata.value = 0;
172       
173        return  write(status.fdrc, &rcdata, sizeof(rcdata));
174}
175
176int flushrc(unsigned int timeout)
177{
178        fd_set rfds;
179        struct timeval tv;
180        struct input_event rcdata;
181        int rest = 0, count = 0;
182        int ret = 0, len = 0;
183
184        rest = timeout % 1000;
185        timeout = (timeout - rest) / 1000;
186
187        while(count < 10)
188        {
189                count++;
190                tv.tv_sec = timeout;
191                tv.tv_usec = rest * 1000;
192                FD_ZERO(&rfds);
193                FD_SET(status.fdrc, &rfds);
194
195                ret = TEMP_FAILURE_RETRY(select(status.fdrc + 1, &rfds, NULL, NULL, &tv));
196
197                if(ret < 1) break;
198                if(FD_ISSET(status.fdrc, &rfds))
199                {
200                        count = 0;
201                        len = TEMP_FAILURE_RETRY(read(status.fdrc, &rcdata, sizeof(struct input_event)));
202                }
203        }
204
205        return 0;
206}
207
208int waitrcext(struct skin* owner, unsigned int timeout, int screencalc, int filelistview)
209{
210        fd_set rfds;
211        struct timeval tv;
212        struct input_event rcdata;
213        int treffer = 0, rest = 0;
214        int ret = 0, len = 0, fromthread = 0, longpress = 0, longpresscount = 0;
215        struct rc *node;
216
217        if(pthread_self() != status.mainthread)
218                fromthread = 1;
219
220        rest = timeout % 1000;
221        timeout = (timeout - rest) / 1000;
222
223        if(timeout == 0 && rest == 0) timeout = 0x7fffffff;
224
225        while(treffer == 0)
226        {
227                tv.tv_sec = timeout;
228                tv.tv_usec = rest * 1000;
229                FD_ZERO(&rfds);
230                FD_SET(status.fdrc, &rfds);
231
232                if(fromthread == 0) status.sec = 0;
233                if((fromthread == 0 && status.rckey == 0) || fromthread == 1)
234                {
235                        if(fromthread == 0) m_unlock(&status.waitrcmutex, 24);
236                        ret = TEMP_FAILURE_RETRY(select(status.fdrc + 1, &rfds, NULL, NULL, &tv));
237                        if(fromthread == 0) m_lock(&status.waitrcmutex, 24);
238
239                        if((status.rcowner != NULL && status.rcowner != owner) || (status.rcstandby != NULL && status.rcstandby != owner))
240                        {
241                                if(status.rcstandby == NULL || status.rcstandby != owner)
242                                {
243                                        usleep(100000);
244                                        continue;
245                                }
246                        }
247                }
248                if(fromthread == 0) status.sec = time(NULL);
249
250                if((fromthread == 0 && ret > 0 && status.rckey == 0) || (fromthread == 1 && ret > 0))
251                {
252                        if(FD_ISSET(status.fdrc, &rfds))
253                                len = TEMP_FAILURE_RETRY(read(status.fdrc, &rcdata, sizeof(struct input_event)));
254
255                        if(rcdata.type != EV_KEY)
256                        {
257                                usleep(10000);
258                                continue;
259                        }
260                        if(rcdata.value == 0) //release
261                        {
262                                usleep(10000);
263                                continue;
264                        }
265
266                        if(islongkey(rcdata.code))
267                        {
268                                longpress = rcdata.code;
269                                longpresscount++;
270                                timeout = 0;
271                                rest = 500;
272                                usleep(10000);
273                                continue;
274                        }
275
276                        if(time(NULL) - rcdata.time.tv_sec > 1)
277                        {
278                                usleep(10000);
279                                continue;
280                        }
281
282                        debug(100, "key code=%d, type=%d, value=%d", rcdata.code, rcdata.type, rcdata.value);
283                        treffer = 1;
284                        rcdata.code = maprc(rcdata.code, owner);
285
286                        node = getrc(rcdata.code, owner);
287                        if(node != NULL && node->rcfunc != NULL)
288                        {
289                                if(fromthread == 0)
290                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 0);
291                                else
292                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 2);
293                        }
294                       
295                        ret = rcdata.code;
296#ifdef SIMULATE
297                        if(ret == 16) treffer = 0;
298#endif
299                }
300                else if((fromthread == 0 && ret == 0 && status.rckey == 0) || (fromthread == 1 && ret == 0)) //timeout
301                {
302                        rcdata.code = 0;
303                        if(longpress > 0)
304                        {
305                                rcdata.code = longpress;
306                                if(longpresscount > 5) rcdata.code = longpress + 3000;
307                        }
308                        treffer = 1;
309                        rcdata.code = maprc(rcdata.code, owner);
310
311                        node = getrc(rcdata.code, NULL);
312                        if(node != NULL && node->rcfunc != NULL)
313                        {
314                                if(fromthread == 0)
315                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 0);
316                                else
317                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 2);
318                        }
319                        if(longpress > 0)
320                                ret = rcdata.code;
321                        else
322                                ret = RCTIMEOUT;
323                }
324                else if(fromthread == 0 && status.rckey != 0)
325                {
326                        treffer = 1;
327                        rcdata.code = maprc(rcdata.code, owner);
328
329                        node = getrc(status.rckey, owner);
330                        if(node != NULL && node->rcfunc != NULL)
331                        {
332                                if(fromthread == 0)
333                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 0);
334                                else
335                                        node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 2);
336                        }
337                        ret = status.rckey;
338                        status.rckey = 0;
339                }
340                else
341                {
342                        treffer = 1;
343                        perr("select failed");
344                }
345        }
346
347        if(ret != RCTIMEOUT)
348                status.lastrcaction = time(NULL);
349        return ret;
350}
351
352int waitrc(struct skin* owner, unsigned int timeout, int screencalc)
353{
354        return waitrcext(owner, timeout, screencalc, 0);
355}
356
357struct rc* addrc(int key, void *func, struct skin* screen, struct skin *screennode)
358{
359        struct rc *newnode, *node = rc;
360        struct rc **nodeaddr;
361
362        newnode = (struct rc*)malloc(sizeof(struct rc));       
363        if(newnode == NULL)
364        {
365                err("no memory");
366                return NULL;
367        }
368
369        memset(newnode, 0, sizeof(struct rc));
370        newnode->key = key;
371        newnode->rcfunc = func;
372        newnode->screen = screen;
373        newnode->screennode = screennode;
374        newnode->owner = screen;
375
376        if(node != NULL)
377        {
378                while(node != NULL)
379                {
380                        if(node->key == key && node->owner == screen)
381                        {
382                                node->rcfunc = func;
383                                node->screen = screen;
384                                node->screennode = screennode;
385                                free(newnode);
386                                newnode = NULL;
387                                return node;
388                        }
389                        nodeaddr = &node->next;
390                        node = node->next;
391                }
392                *nodeaddr = newnode;
393        }
394        else
395                rc = newnode;
396
397        return newnode;
398}
399
400void delrc(int key, struct skin* owner, struct skin* screennode)
401{
402        struct rc *node = rc, *prev = rc;
403
404        while(node != NULL)
405        {
406                if(node->key == key && node->owner == owner && node->screennode == screennode)
407                {
408                        if(node == rc)
409                                rc = node->next;
410                        else
411                                prev->next = node->next;
412
413                        free(node);
414                        node = NULL;
415                        break;
416                }
417
418                prev = node;
419                node = node->next;
420        }
421}
422
423void delownerrc(struct skin* owner)
424{
425        struct rc *node = rc, *prev = rc;
426
427        while(node != NULL)
428        {
429                prev = node;
430                node = node->next;
431                if(prev != NULL && prev->owner == owner)
432                        delrc(prev->key, prev->owner, prev->screennode);
433        }
434}
435
436void freerc()
437{
438        struct rc *node = rc, *prev = rc;
439
440        while(node != NULL)
441        {
442                prev = node;
443                node = node->next;
444                if(prev != NULL)
445                        delrc(prev->key, prev->owner, prev->screennode);
446        }
447}
448
449#endif
Note: See TracBrowser for help on using the repository browser.