source: titan/titan/rectimer.h @ 30724

Last change on this file since 30724 was 30724, checked in by gost, 9 years ago

schubs

File size: 40.1 KB
Line 
1#ifndef RECTIMER_H
2#define RECTIMER_H
3
4void debugrectimer()
5{
6        struct rectimer* node = rectimer;
7
8        while(node != NULL)
9        {
10                printf("--------------------------------\n");
11                printf("name: %s\n", node->name);
12                printf("start: %lu end: %lu\n", node->begin, node->end);
13                printf("currently time: %ld\n", time(NULL));
14                printf("channellist: %s\n", node->channellist);
15                printf("serviceid: %d transponderid: %llu\n", node->serviceid, node->transponderid);
16                printf("--------------------------------\n");
17                node = node->next;
18        }
19}
20
21void sortrectimer()
22{
23        struct rectimer *nodea = NULL, *nodeb = NULL, *nodec = NULL, *noded = NULL;
24        struct rectimer *nodetmp = NULL, *node = rectimer;
25
26        if(node != NULL)
27        {
28                while (noded != node->next)
29                {
30                        nodec = node;
31                        nodea = node;
32                        nodeb = nodea->next;
33
34                        while (nodea != noded)
35                        {
36                                if (nodea->begin >= nodeb->begin)
37                                {
38                                        if (nodea == node)
39                                        {
40                                                nodetmp = nodeb->next;
41                                                nodeb->next = nodea;
42                                                nodea->next = nodetmp;
43                                                node = nodeb;
44                                                nodec = nodeb;
45                                        }
46                                        else
47                                        {
48                                                nodetmp = nodeb->next;
49                                                nodeb->next = nodea;
50                                                nodea->next = nodetmp;
51                                                nodec->next = nodeb;
52                                                nodec = nodeb;
53                                        }
54                                }
55                                else
56                                {
57                                        nodec = nodea;
58                                        nodea = nodea->next;
59                                }
60                                nodeb = nodea->next;
61                                if (nodeb == noded)
62                                        noded = nodea;
63                        }
64                }
65        }
66
67        struct rectimer* prev = NULL;
68        nodetmp = node;
69        while(nodetmp != NULL)
70        {
71                nodetmp->prev = prev;
72                prev = nodetmp;
73
74                nodetmp = nodetmp->next;
75        }
76
77        rectimer = node;
78}
79
80int checkrectimerconflict(struct rectimer* recnode)
81{
82        struct dvbdev* dvbnode = dvbdev;
83        struct transponder* tpnode = NULL;
84        struct rectimer* node = rectimer;
85
86        if(recnode == NULL) return 0;
87
88        while(dvbnode != NULL)
89        {
90                if(dvbnode->type == FRONTENDDEV)
91                {
92                        adddvbdev(ostrcat(dvbnode->dev, NULL, 0, 0), dvbnode->adapter, dvbnode->devnr, dvbnode->fd, FRONTENDDEV, dvbnode->feinfo, NULL, dvbnode->fehyprid, 1);
93                }
94                dvbnode = dvbnode->next;
95        }
96        dvbnode = NULL;
97
98        if(dvbdevsim == NULL) return 0;
99
100        tpnode = gettransponder(recnode->transponderid);
101        dvbnode = fegetfree(tpnode, 3, dvbdevsim);
102        if(dvbnode != NULL)
103                dvbnode->felock = 1;
104
105        while(node != NULL)
106        {
107                if(recnode != node && node->status < 2)
108                {
109                        if((recnode->begin >= node->begin && recnode->begin < node->end) || (recnode->end >= node->begin && recnode->end < node->end))
110                        {
111                                tpnode = gettransponder(node->transponderid);
112                                dvbnode = fegetfree(tpnode, 3, dvbdevsim);
113                                if(dvbnode == NULL)
114                                {
115                                        freedvbdev(1);
116                                        dvbdevsim = NULL;
117                                        return 2;
118                                }
119                                else
120                                        dvbnode->felock = 1;
121                        }
122                }
123                node = node->next;
124        }
125
126        freedvbdev(1);
127        dvbdevsim = NULL;
128        return 0;
129}
130
131int checkrectimeradd(struct rectimer* recnode, char** ret)
132{
133        if(recnode == NULL)
134        {
135                *ret = _("undefined error");
136                return 1;
137        }
138        if(recnode->begin == 0 || recnode->end == 0)
139        {
140                *ret = _("Timer starttime or endtime not ok");
141                return 1;
142        }
143        if(recnode->end <= time(NULL))
144        {
145                *ret = _("Timer endtime shorter than aktual time");
146                return 1;
147        }
148        if(recnode->end <= recnode->begin)
149        {
150                *ret = _("Timer endtime shorter than start time");
151                return 1;
152        }
153        if(recnode->serviceid < 1)
154        {
155                *ret = _("Timer service ID not ok");
156                return 1;
157        }
158        if(recnode->transponderid < 1)
159        {
160                *ret = _("Timer transponder ID not ok");
161                return 1;
162        }
163
164        if(checkrectimerconflict(recnode) != 0)
165        {
166                *ret = _("Timer conflicts with other timer\nWould you add the timer?");
167                return 2;
168        }
169
170        return 0;
171}
172
173void recrepeatecalc(struct rectimer* node)
174{
175        time_t daysec = 24 * 60 * 60;
176        struct tm* loctime = NULL;
177        int rectimerday = -1, rep = 0, i = 0, daylight = 0;
178
179        if(node->repeate == 0) return;
180        status.writerectimer = 1;
181
182        //get rectimer start day
183        loctime = olocaltime(&node->begin);
184        if(loctime != NULL)
185        {
186                rectimerday = loctime->tm_wday - 1;
187                daylight = loctime->tm_isdst;
188        }
189        free(loctime); loctime = NULL;
190        if(rectimerday == -1) rectimerday = 6;
191
192        rep = (node->repeate & 0xff) | ((node->repeate  & 0xff) << 7);
193
194        for(i = 0; i < 7; i++)
195        {
196                node->begin = node->begin + daysec;
197                node->end = node->end + daysec;
198                rectimerday++;
199                if(rectimerday > 6) rectimerday = 0;
200                if(checkbit(rep, rectimerday) == 1)
201                        break;
202        }
203
204        //check if begin > akttime
205        while(node->begin < time(NULL))
206        {
207                for(i = 0; i < 7; i++)
208                {
209                        node->begin = node->begin + daysec;
210                        node->end = node->end + daysec;
211                        rectimerday++;
212                        if(rectimerday > 6) rectimerday = 0;
213                        if(checkbit(rep, rectimerday) == 1)
214                                break;
215                }
216        }
217
218        //calc daylight
219        loctime = olocaltime(&node->begin);
220        if(loctime != NULL)
221        {
222                if(loctime->tm_isdst > daylight)
223                {
224                        node->begin = node->begin - 3600;
225                        node->end = node->end - 3600;
226                }
227                else if(loctime->tm_isdst < daylight)
228                {
229                        node->begin = node->begin + 3600;
230                        node->end = node->end + 3600;
231                }
232        }
233}
234
235int checkrectimertime(struct rectimer* node)
236{
237        //don't load old timers
238        if(time(NULL) - node->end > 604800 && (node->status == 2 || node->status == 3 || node->status == 5))
239                return 1;
240
241        if(time(NULL) > node->end && node->repeate == 0 && node->status == 0)
242                return 1;
243
244        //recalc old repeat timer
245        if(time(NULL) > node->end && node->repeate != 0 && node->status == 0)
246                recrepeatecalc(node);
247
248        return 0;
249}
250
251void copyrectimer(struct rectimer* src, struct rectimer* dst)
252{
253        dst->timestamp = ostrcat(src->timestamp, NULL, 0, 0);
254        dst->name = ostrcat(src->name, NULL, 0, 0);
255        dst->begin = src->begin;
256        dst->end = src->end;
257        dst->repeate = src->repeate;
258        dst->afterevent = src->afterevent;
259        dst->disabled = src->disabled;
260        dst->justplay = src->justplay;
261        dst->recpath = ostrcat(src->recpath, NULL, 0, 0);
262        dst->servicetype = src->servicetype;
263        dst->channellist = ostrcat(src->channellist, NULL, 0, 0);
264        dst->serviceid = src->serviceid;
265        dst->transponderid = src->transponderid;
266}
267
268struct rectimer* addrectimernode(char* line, struct rectimer* last)
269{
270        char *ret = NULL;
271        struct rectimer *newnode = NULL, *prev = NULL, *node = rectimer;
272       
273        newnode = (struct rectimer*)calloc(1, sizeof(struct rectimer));
274        if(newnode == NULL)
275        {
276                err("no memory");
277                return NULL;
278        }
279
280        status.writerectimer = 1;
281        newnode->timestamp = NULL;
282
283        if(line != NULL)
284        {
285                ret = getxmlentry(line, " begin=");
286                if(ret != NULL)
287                {
288                        newnode->begin = atol(ret);
289                        free(ret);
290                }
291                ret = getxmlentry(line, " end=");
292                if(ret != NULL)
293                {
294                        newnode->end = atol(ret);
295                        free(ret);
296                }
297                ret = getxmlentry(line, " repeated=");
298                if(ret != NULL)
299                {
300                        newnode->repeate = atoi(ret);
301                        free(ret);
302                }
303                ret = getxmlentry(line, " afterevent=");
304                if(ret != NULL)
305                {
306                        newnode->afterevent = atoi(ret);
307                        free(ret);
308                }
309                ret = getxmlentry(line, " pincode=");
310                if(ret != NULL)
311                        newnode->pincode = ret;
312                ret = getxmlentry(line, " disabled=");
313                if(ret != NULL)
314                {
315                        newnode->disabled = atoi(ret);
316                        free(ret);
317                }
318                ret = getxmlentry(line, " justplay=");
319                if(ret != NULL)
320                {
321                        newnode->justplay = atoi(ret);
322                        free(ret);
323                }
324                ret = getxmlentry(line, " serviceid=");
325                if(ret != NULL)
326                {
327                        newnode->serviceid = atoi(ret);
328                        free(ret);
329                }
330                ret = getxmlentry(line, " transponderid=");
331                if(ret != NULL)
332                {
333                        newnode->transponderid = strtoull(ret, NULL, 10);
334                        free(ret);
335                }
336                ret = getxmlentry(line, " status=");
337                if(ret != NULL)
338                {
339                        newnode->status = atol(ret);
340                        if(newnode->status == 1) newnode->status = 0;
341                        free(ret);
342                }
343                ret = getxmlentry(line, " timestamp=");
344                if(ret != NULL)
345                {
346                        newnode->timestamp = ret;
347                }
348                ret = getxmlentry(line, " name=");
349                if(ret != NULL)
350                        newnode->name = ret;
351                ret = getxmlentry(line, " recpath=");
352                if(ret != NULL)
353                        newnode->recpath = ret;
354                ret = getxmlentry(line, " channellist=");
355                if(ret != NULL)
356                        newnode->channellist = ret;
357                ret = getxmlentry(line, " errstr=");
358                if(ret != NULL)
359                        newnode->errstr = ret;
360
361                if(checkrectimertime(newnode) == 1)
362                {
363                        free(newnode);
364                        return NULL;
365                }
366        }
367        else
368        {
369                newnode->disabled = 1;
370                newnode->afterevent = getconfigint("def_rectimer_after", NULL);
371        }
372       
373        if(newnode->timestamp == NULL)
374                newnode->timestamp = gettimestamp();
375       
376        if(last == NULL)
377        {
378                while(node != NULL && newnode->begin >= node->begin)
379                {
380                        prev = node;
381                        node = node->next;
382                }
383        }
384        else
385        {
386                prev = last;
387                node = last->next;
388        }
389
390        if(prev == NULL)
391                rectimer = newnode;
392        else
393        {
394                prev->next = newnode;
395                newnode->prev = prev;
396        }
397        newnode->next = node;
398        if(node != NULL) node->prev = newnode;
399
400        return newnode;
401}
402
403struct rectimer* getrectimerbytimediff(time_t timediff)
404{
405        struct rectimer* node = rectimer;       
406        time_t akttime = time(NULL);
407
408        while(node != NULL)
409        {
410                if(node->begin > akttime && node->begin <= akttime + timediff)
411                        return node;
412
413                node = node->next;
414        }
415
416        return NULL;
417}
418
419struct rectimer* getrectimerbytimestamp(char* timestamp)
420{
421        struct rectimer* node = rectimer;       
422
423        while(node != NULL)
424        {
425                if(ostrcmp(node->timestamp, timestamp) == 0)
426                        return node;
427
428                node = node->next;
429        }
430
431        return NULL;
432}
433
434struct rectimer* getrectimerbyservice(struct service* servicenode)
435{
436        struct rectimer* node = rectimer;       
437
438        while(node != NULL)
439        {
440                if(node->servicenode == servicenode)
441                        return node;
442
443                node = node->next;
444        }
445
446        return NULL;
447}
448
449void checkrectimer(struct stimerthread* self)
450{
451        int ret = 0;
452        struct rectimer* node = NULL, *newnode = NULL;
453        struct channel* chnode = NULL;
454        time_t t = 0, begin = 0, end = 0;
455
456        if(self == NULL) return;
457
458        //wait for right time
459        while(self->aktion != STOP && time(NULL) < 1072224000) // 01.01.2004
460                usleep(1 * 1000000);
461       
462        //on first start read rectimer and set cec
463        if(self->delay == 1000)
464        {
465                ret = 5;
466                while(self->aktion != STOP && ret != 0)
467                {
468                        usleep(1 * 1000000);
469                        ret = ret - 1;
470                }
471                ret = 0;
472                readrectimer(getconfig("rectimerfile", NULL));
473                checkboxstart();
474        }
475               
476        //wait for start all programs
477        ret = 30;
478        while(self->aktion != STOP && ret != 0)
479        {
480                usleep(1 * 1000000);
481                ret = ret - 1;
482        }
483        ret = 0;
484       
485        //on first start read rectimer
486        if(self->delay == 1000)
487        {
488                self->delay = 10000;
489                //readrectimer(getconfig("rectimerfile", NULL));
490                epgscancreatetimer();
491                //checkboxstart();
492        }
493
494        m_lock(&status.rectimermutex, 1);
495        t = time(NULL);
496        node = rectimer;
497       
498        while(node != NULL)
499        {
500                if(node->disabled != 0)
501                {
502                        node = node->next;
503                        continue;
504                }
505               
506                if(node->justplay == 1)
507                {
508                        begin = node->begin;
509                        end = node->end + 180;
510                }
511                else
512                {
513                        begin = node->begin;
514                        end = node->end;
515                }
516
517                if(t >= begin && t < end && node->disabled == 0 && node->status == 0)
518                {
519                        if(node->repeate != 0)
520                        {
521                                //copy repeate timer
522                                newnode = addrectimernode(NULL, NULL);
523                                if(newnode != NULL)
524                                {
525                                        copyrectimer(node, newnode);
526                                        recrepeatecalc(newnode);
527                                }
528                                node->repeate = 0;
529                                status.writerectimer = 1;
530                        }
531                        chnode = getchannel(node->serviceid, node->transponderid);
532                        if(node->justplay == 1)
533                        {
534                                //ret = servicestart(chnode, NULL, node->channellist, 0);
535                                ret = servicestart(chnode, node->channellist, NULL, 0);
536                                if(ret == 20 || ret == 22) ret = 0;
537                        }
538                        else
539                        {
540                                ret = recordstart(chnode, -1, 0, RECTIMER, node->end, node);
541                                if(ret == 14) ret = 0;
542                        }
543
544                        if(ret != 0)
545                        {
546                                node->status = 3;
547                                status.writerectimer = 1;
548                                break;
549                        }
550                        else
551                        {
552                                if(node->justplay == 1)
553                                        node->status = 2;
554                                else
555                                        node->status = 1;
556                                status.writerectimer = 1;
557                        }
558                }
559                if(t > node->end && (node->status == 0 || node->status == 4) && node->end != 0)
560                {
561                        if(node->status == 4)
562                                node->status = 5;
563                        else
564                                node->status = 3;
565                        free(node->errstr);
566                        node->errstr = ostrcat(_("not started akttime higher than timer endtime"), NULL, 0, 0);
567                        status.writerectimer = 1;
568                }
569                //for epgscan
570                if(t >= begin && t < end && node->disabled == 0 && node->status == 4)
571                {
572                        node->status = 5;
573                        status.writerectimer = 1;
574
575                        if(status.standby == 0)
576                        {
577                                int tret = textbox(_("Message"), _("EPG Scan activate standby?"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 20, 0);
578
579                                if(tret == 0 || tret == 1)
580                                {
581                                        status.standby = 2;
582                                        addtimer(&screenstandby, START, 1000, 1, NULL, NULL, NULL);
583                                }
584                        }
585                }
586                node = node->next;
587        }
588
589        m_unlock(&status.rectimermutex, 1);
590
591        if(node != NULL && node->disabled == 0 && node->status < 4)
592        {
593                if(node->justplay == 1)
594                {
595                        char* retstr = servicecheckret(ret, 1);
596                        free(node->errstr);
597                        node->errstr = ostrcat(retstr, NULL, 0, 0);
598                        stringreplacecharonce(node->errstr, '\n', '\0');
599                        free(retstr); retstr = NULL;
600                }
601                else
602                {
603                        char* retstr = recordcheckret(NULL, ret, 15);
604                        free(node->errstr);
605                        node->errstr = ostrcat(retstr, NULL, 0, 0);
606                        stringreplacecharonce(node->errstr, '\n', '\0');
607                        free(retstr); retstr = NULL;
608                }
609                status.writerectimer = 1;
610        }
611
612        writerectimer(getconfig("rectimerfile", NULL), 0);
613}
614
615int addrectimer(char *buf)
616{
617        struct rectimer* node = NULL;
618        char* buf1 = buf;
619        char* line = NULL;
620
621        line = malloc(MINMALLOC);
622        if(line == NULL)
623        {
624                err("no memory");
625                return 1;
626        }
627
628        while(*buf != '\0')
629        {
630                buf++;
631                if(*buf == '\n' || *buf == '\0')
632                {
633                        if(*buf == '\n')
634                        {
635                                buf++;
636                                snprintf(line, buf - buf1, "%s", buf1);
637                        }
638                        else
639                                snprintf(line, buf - buf1 + 1, "%s", buf1);
640                        buf1 = buf;
641
642                        if(ostrstr(line, "<timer ") != NULL || ostrstr(line, "<log ") != NULL || ostrstr(line, "<epgscan ") != NULL)
643                                node = addrectimernode(line, node);
644                }
645        }
646        free(line);
647        return 0;
648}
649
650int readrectimer(char *filename)
651{
652        char *buf = NULL;
653
654        buf = readfiletomem(filename, 1);
655
656        if(buf != NULL)
657        {
658                addrectimer(buf);
659                //timers can change on load, so we save it
660                writerectimer(getconfig("rectimerfile", NULL), 0);
661                free(buf);
662        }
663        return 0;
664}
665
666//flag 0 = set mutex
667//flag 1 = don't set mutex
668void delrectimer(struct rectimer* rectimernode, int write, int flag)
669{
670        if(flag == 0) m_lock(&status.rectimermutex, 1);
671        struct rectimer *node = rectimer, *prev = rectimer;
672
673        while(node != NULL)
674        {
675                if(node == rectimernode)
676                {
677                        status.writerectimer = 1;
678
679                        //record is aktiv (del from stopservice)
680                        if(node->servicenode != NULL)
681                        {
682                                node->status = 2;
683                                free(node->errstr);
684                                node->errstr = ostrcat(_("stopped from user"), NULL, 0, 0);
685                                //stop recording
686                                node->servicenode->recendtime = 2;
687                                if(flag == 0)
688                                        m_unlock(&status.rectimermutex, 1);
689                                return;
690                        }
691
692                        if(node == rectimer)
693                        {
694                                rectimer = node->next;
695                                if(rectimer != NULL)
696                                        rectimer->prev = NULL;
697                        }
698                        else
699                        {
700                                prev->next = node->next;
701                                if(node->next != NULL)
702                                        node->next->prev = prev;
703                        }
704
705                        free(node->name);
706                        node->name = NULL;
707                       
708                        free(node->timestamp);
709                        node->timestamp = NULL;
710
711                        free(node->recpath);
712                        node->recpath = NULL;
713
714                        free(node->channellist);
715                        node->channellist = NULL;
716
717                        free(node->errstr);
718                        node->errstr = NULL;
719                       
720                        free(node->pincode);
721                        node->pincode = NULL;
722
723                        free(node);
724                        node = NULL;
725                        break;
726                }
727
728                prev = node;
729                node = node->next;
730        }
731
732        if(write == 1)
733                writerectimer(getconfig("rectimerfile", NULL), 1);
734
735        if(flag == 0)
736                m_unlock(&status.rectimermutex, 1);
737}
738
739void deloldrectimer()
740{
741        struct rectimer *node = rectimer, *prev = rectimer;
742
743        while(node != NULL)
744        {
745                prev = node;
746                node = node->next;
747                if(prev != NULL && checkrectimertime(prev) == 1)
748                        delrectimer(prev, 1, 0);
749        }
750}
751
752void freerectimer()
753{
754        struct rectimer *node = rectimer, *prev = rectimer;
755
756        while(node != NULL)
757        {
758                prev = node;
759                node = node->next;
760                if(prev != NULL)
761                        delrectimer(prev, 0, 0);
762        }
763}
764
765//flag 0: lock
766//flag 1: don't lock
767int writerectimer(const char *filename, int flag)
768{
769        FILE *fd = NULL;
770        struct rectimer *node = NULL;
771        int ret = 0;
772        char* type = NULL;
773        time_t curtime = time(NULL), rectime = 0x7FFFFFFF;
774
775        if(status.writerectimer == 0) return 0;
776
777        //check if rectimer loadet
778        if(status.rectimerthread == NULL || (status.rectimerthread != NULL && status.rectimerthread->delay == 1000))
779        {
780                err("can't write rectimer, not loaded yet");
781                return 1;
782        }
783
784        if(flag == 0) m_lock(&status.rectimermutex, 1);
785        sortrectimer();
786        node = rectimer;
787
788        fd = fopen(filename, "w");
789        if(fd == NULL)
790        {
791                if(flag == 0) m_unlock(&status.rectimermutex, 1);
792                status.writerectimer = 0;
793                perr("can't open %s", filename);
794                return 1;
795        }
796
797        while(node != NULL)
798        {
799                //don't write for del marked or old timers
800                if(checkrectimertime(node) == 1)
801                {
802                        node = node->next;
803                        continue;
804                }
805
806                if(node->name == NULL) node->name = ostrcat(node->name, NULL, 1, 0);
807                if(node->channellist == NULL) node->channellist = ostrcat(node->channellist, NULL, 1, 0);
808                if(node->errstr == NULL) node->errstr = ostrcat(node->errstr, NULL, 1, 0);
809                if(node->pincode == NULL) node->pincode = ostrcat(node->pincode, "0000", 1, 0);
810                if(node->recpath == NULL) node->recpath = ostrcat(node->recpath, NULL, 1, 0);
811                if(node->status == 0 || node->status == 1)
812                        type = "timer";
813                else if(node->status == 4 || node->status == 5)
814                        type = "epgscan";
815                else
816                        type = "log";
817
818                ret = fprintf(fd, "<%s begin=\"%lu\" end=\"%lu\" serviceid=\"%d\" transponderid=\"%llu\" channellist=\"%s\" repeated=\"%d\" name=\"%s\" afterevent=\"%d\" pincode=\"%s\" disabled=\"%d\" justplay=\"%d\", recpath=\"%s\", timestamp=\"%s\", status=\"%d\" errstr=\"%s\">\n</%s>\n", type, node->begin, node->end, node->serviceid, node->transponderid, node->channellist, node->repeate, node->name, node->afterevent, node->pincode, node->disabled, node->justplay, node->recpath, node->timestamp, node->status, node->errstr, type);
819
820                if(ret < 0)
821                {
822                        perr("writting file %s", filename);
823                }
824
825                //get wakeup time
826                if(node->status == 0 || node->status == 1 || node->status == 4)
827                {
828                        if(node->begin < rectime && node->begin > curtime)
829                                rectime = node->begin;
830                }
831                node = node->next;
832        }
833
834        fclose(fd);
835        //write wakeup time to proc
836        setwakeuptimerdev(rectime);
837        debugrectimer();
838
839        if(flag == 0) m_unlock(&status.rectimermutex, 1);
840
841        status.writerectimer = 0;
842        return 0;
843}
844
845int recrepeateget(int newnode, struct skin* repeate, struct skin* repeatetype, struct skin* day, struct skin* mon, struct skin* tue, struct skin* wed, struct skin* thur, struct skin* fri, struct skin* sat, struct skin* sun)
846{
847        unsigned char ret = 0;
848        int aktday = rectimergetaktday();
849
850        if(repeate == NULL) return 0;
851        if(repeatetype == NULL) return 0;
852
853        if(ostrcmp(repeate->ret, "0") == 0) return 0;
854
855        if(ostrcmp(repeatetype->ret, "0") == 0) return 127;
856        if(ostrcmp(repeatetype->ret, "1") == 0)
857        {
858                if(day->ret == NULL) return aktday;
859                if(ostrcmp(day->ret, "0") == 0)
860                {
861                        if(newnode == 1)
862                                return aktday;
863                        else
864                                return 1;
865                }
866                if(ostrcmp(day->ret, "1") == 0) return 2;
867                if(ostrcmp(day->ret, "2") == 0) return 4;
868                if(ostrcmp(day->ret, "3") == 0) return 8;
869                if(ostrcmp(day->ret, "4") == 0) return 16;
870                if(ostrcmp(day->ret, "5") == 0) return 32;
871                if(ostrcmp(day->ret, "6") == 0) return 64;
872        }
873        if(ostrcmp(repeatetype->ret, "2") == 0) return 31;
874        if(ostrcmp(repeatetype->ret, "3") == 0)
875        {
876                if(mon == NULL || tue == NULL || wed == NULL || thur == NULL || fri == NULL || sat == NULL || sun == NULL) return aktday;
877                if(ostrcmp(mon->ret, "1") == 0) ret = setbit(ret, 0);
878                if(ostrcmp(tue->ret, "1") == 0) ret = setbit(ret, 1);
879                if(ostrcmp(wed->ret, "1") == 0) ret = setbit(ret, 2);
880                if(ostrcmp(thur->ret, "1") == 0) ret = setbit(ret, 3);
881                if(ostrcmp(fri->ret, "1") == 0) ret = setbit(ret, 4);
882                if(ostrcmp(sat->ret, "1") == 0) ret = setbit(ret, 5);
883                if(ostrcmp(sun->ret, "1") == 0) ret = setbit(ret, 6);
884                if(ret == 0) ret = aktday;
885                return ret;
886        }
887
888        return 127;
889}
890
891void recjustplayhidden(int justplay, struct skin* end, struct skin* path, struct skin* after)
892{
893        if(justplay == 0)
894        {
895                end->hidden = NO;
896                path->hidden = NO;
897                after->hidden = NO;
898        }
899        else
900        {
901                end->hidden = YES;
902                path->hidden = YES;
903                after->hidden = YES;
904        }
905}
906
907int rectimergetaktday()
908{
909        int ret = 1;
910        struct tm* loctime = NULL;
911
912        time_t akttime = time(NULL);
913        loctime = olocaltime(&akttime);
914        if(loctime != NULL)
915        {
916                if(loctime->tm_wday == 0) ret = 64;
917                if(loctime->tm_wday == 1) ret = 1;
918                if(loctime->tm_wday == 2) ret = 2;
919                if(loctime->tm_wday == 3) ret = 4;
920                if(loctime->tm_wday == 4) ret = 8;
921                if(loctime->tm_wday == 5) ret = 16;
922                if(loctime->tm_wday == 6) ret = 32;
923        }
924        free(loctime); loctime = NULL;
925
926        return ret;
927}
928
929void recrepeatehidden(int repeate, struct skin* repeatetype, struct skin* day, struct skin* mon, struct skin* tue, struct skin* wed, struct skin* thur, struct skin* fri, struct skin* sat, struct skin* sun)
930{
931        repeatetype->hidden = YES;
932        day->hidden = YES;
933        mon->hidden = YES;
934        tue->hidden = YES;
935        wed->hidden = YES;
936        thur->hidden = YES;
937        fri->hidden = YES;
938        sat->hidden = YES;
939        sun->hidden = YES;
940
941        if(repeate == 0) return;
942
943        if(repeate == 127 && ostrcmp(repeatetype->ret, "3") != 0) //dayly
944        {
945                repeatetype->hidden = NO;
946                setchoiceboxselection(repeatetype, "0");
947                return;
948        }
949        if(repeate == 31 && ostrcmp(repeatetype->ret, "3") != 0) //workday
950        {
951                repeatetype->hidden = NO;
952                setchoiceboxselection(repeatetype, "2");
953                return;
954        }
955        if((repeate == 1 || repeate == 2 || repeate == 4 || repeate == 8 || repeate == 16 || repeate == 32 || repeate == 64) && ostrcmp(repeatetype->ret, "3") != 0) //weekly
956        {
957                repeatetype->hidden = NO;
958                setchoiceboxselection(repeatetype, "1");
959                day->hidden = NO;
960                if(repeate == 1) setchoiceboxselection(day, "0");
961                else if(repeate == 2) setchoiceboxselection(day, "1");
962                else if(repeate == 4) setchoiceboxselection(day, "2");
963                else if(repeate == 8) setchoiceboxselection(day, "3");
964                else if(repeate == 16) setchoiceboxselection(day, "4");
965                else if(repeate == 32) setchoiceboxselection(day, "5");
966                else if(repeate == 64) setchoiceboxselection(day, "6");
967                return;
968        }
969
970        //user defined
971        repeatetype->hidden = NO;
972        setchoiceboxselection(repeatetype, "3");
973        mon->hidden = NO;
974        tue->hidden = NO;
975        wed->hidden = NO;
976        thur->hidden = NO;
977        fri->hidden = NO;
978        sat->hidden = NO;
979        sun->hidden = NO;
980        if(checkbit(repeate, 0) == 1) setchoiceboxselection(mon, "1");
981        if(checkbit(repeate, 1) == 1) setchoiceboxselection(tue, "1");
982        if(checkbit(repeate, 2) == 1) setchoiceboxselection(wed, "1");
983        if(checkbit(repeate, 3) == 1) setchoiceboxselection(thur, "1");
984        if(checkbit(repeate, 4) == 1) setchoiceboxselection(fri, "1");
985        if(checkbit(repeate, 5) == 1) setchoiceboxselection(sat, "1");
986        if(checkbit(repeate, 6) == 1) setchoiceboxselection(sun, "1");
987}
988
989//flag 0: called from menu (manuel timer)
990//flag 1: call from epg timer
991void screenrectimerext(struct rectimer* node, int flag)
992{
993        int ret = 0, rcret = 0, edaylight = 0, bdaylight = 0, newnode = 0, tmpservicetype = 0, tmprepeate = 0;
994        struct skin* rectimerext = getscreen("rectimerext");
995        struct skin* listbox = getscreennode(rectimerext, "listbox");
996        struct skin* name = getscreennode(rectimerext, "name");
997        struct skin* justplay = getscreennode(rectimerext, "justplay");
998        struct skin* repeate = getscreennode(rectimerext, "repeate");
999        struct skin* repeatetype = getscreennode(rectimerext, "repeatetype");
1000        struct skin* day = getscreennode(rectimerext, "day");
1001        struct skin* mon = getscreennode(rectimerext, "mon");
1002        struct skin* tue = getscreennode(rectimerext, "tue");
1003        struct skin* wed = getscreennode(rectimerext, "wed");
1004        struct skin* thur = getscreennode(rectimerext, "thur");
1005        struct skin* fri = getscreennode(rectimerext, "fri");
1006        struct skin* sat = getscreennode(rectimerext, "sat");
1007        struct skin* sun = getscreennode(rectimerext, "sun");
1008        struct skin* begin = getscreennode(rectimerext, "begin");
1009        struct skin* end = getscreennode(rectimerext, "end");
1010        struct skin* recchannel = getscreennode(rectimerext, "channel");
1011        struct skin* path = getscreennode(rectimerext, "path");
1012        struct skin* after = getscreennode(rectimerext, "after");
1013        struct skin* pincode = getscreennode(rectimerext, "pincode");
1014        struct skin* tmp = NULL;
1015        char* tmpstr = NULL, *buf = NULL, *buf1 = NULL, *tmpchannellist = NULL;
1016        struct tm* loctime = NULL;
1017        time_t akttime = time(NULL);
1018
1019        if(node == NULL)
1020        {
1021                newnode = 1;
1022                node = addrectimernode(NULL, NULL);
1023                tmpservicetype = status.servicetype;
1024                if(tmpservicetype == 0)
1025                        tmpchannellist = ostrcat(getconfig("channellist", NULL), NULL, 0, 0);
1026                else
1027                        tmpchannellist = ostrcat(getconfig("rchannellist", NULL), NULL, 0, 0);
1028        }
1029        else
1030        {
1031                tmpservicetype = node->servicetype;
1032                tmpchannellist = ostrcat(node->channellist, NULL, 0, 0);
1033        }
1034
1035        if(node == NULL)
1036        {
1037                err("NULL detect");
1038                return;
1039        }
1040
1041        listbox->aktline = 1;
1042        listbox->aktpage = -1;
1043        begin->aktpage = 0;
1044        end->aktpage = 0;
1045        name->aktpage = 0;
1046       
1047        changeinput(name, node->name);
1048
1049        addchoicebox(justplay, "0", _("record"));
1050        addchoicebox(justplay, "1", _("switch channel"));
1051        if(newnode == 0)
1052        {
1053                tmpstr = oitoa(node->justplay);
1054                setchoiceboxselection(justplay, tmpstr);
1055                free(tmpstr); tmpstr = NULL;
1056        }
1057        else
1058                setchoiceboxselection(justplay, "0");
1059
1060        addchoicebox(repeate, "0", _("once"));
1061        addchoicebox(repeate, "1", _("repeate"));
1062        if(newnode == 0)
1063        {
1064                tmprepeate = node->repeate;
1065                if(node->repeate == 0)
1066                        setchoiceboxselection(repeate, "0");
1067                else
1068                        setchoiceboxselection(repeate, "1");
1069        }
1070        else
1071                setchoiceboxselection(repeate, "0");
1072
1073        addchoicebox(repeatetype, "0", _("daily"));
1074        addchoicebox(repeatetype, "1", _("weekly"));
1075        addchoicebox(repeatetype, "2", _("workdays"));
1076        addchoicebox(repeatetype, "3", _("user defined"));
1077        changeret(repeatetype, NULL);
1078        setchoiceboxselection(repeatetype, "0");
1079
1080        addchoicebox(day, "0", _("Monday"));
1081        addchoicebox(day, "1", _("Tuesday"));
1082        addchoicebox(day, "2", _("Wednesday"));
1083        addchoicebox(day, "3", _("Thursday"));
1084        addchoicebox(day, "4", _("Friday"));
1085        addchoicebox(day, "5", _("Saturday"));
1086        addchoicebox(day, "6", _("Sunday"));
1087        changeret(day, NULL);
1088        setchoiceboxselection(day, "0");
1089
1090        addchoicebox(mon, "0", _("no"));
1091        addchoicebox(mon, "1", _("yes"));
1092        changeret(mon, NULL);
1093        setchoiceboxselection(mon, "0");
1094
1095        addchoicebox(tue, "0", _("no"));
1096        addchoicebox(tue, "1", _("yes"));
1097        changeret(tue, NULL);
1098        setchoiceboxselection(tue, "0");
1099
1100        addchoicebox(wed, "0", _("no"));
1101        addchoicebox(wed, "1", _("yes"));
1102        changeret(wed, NULL);
1103        setchoiceboxselection(wed, "0");
1104
1105        addchoicebox(thur, "0", _("no"));
1106        addchoicebox(thur, "1", _("yes"));
1107        changeret(thur, NULL);
1108        setchoiceboxselection(thur, "0");
1109
1110        addchoicebox(fri, "0", _("no"));
1111        addchoicebox(fri, "1", _("yes"));
1112        changeret(fri, NULL);
1113        setchoiceboxselection(fri, "0");
1114
1115        addchoicebox(sat, "0", _("no"));
1116        addchoicebox(sat, "1", _("yes"));
1117        changeret(sat, NULL);
1118        setchoiceboxselection(sat, "0");
1119
1120        addchoicebox(sun, "0", _("no"));
1121        addchoicebox(sun, "1", _("yes"));
1122        changeret(sun, NULL);
1123        setchoiceboxselection(sun, "0");
1124
1125        recrepeatehidden(node->repeate, repeatetype, day, mon, tue, wed, thur, fri, sat, sun);
1126        recjustplayhidden(node->justplay, end, path, after);
1127
1128        buf = malloc(MINMALLOC);
1129        if(buf == NULL)
1130        {
1131                err("no memory");
1132                return;
1133        }
1134
1135        changemask(begin, "00:00 00-00-0000");
1136        if(newnode == 0)
1137                loctime = localtime(&node->begin);
1138        else
1139                loctime = localtime(&akttime);
1140        bdaylight = loctime->tm_isdst;
1141        strftime(buf, MINMALLOC, "%H:%M %d-%m-%Y", loctime);
1142        buf1 = ostrcat(buf, NULL, 0, 0);
1143        changeinput(begin, buf1);
1144        free(buf1); buf1 = NULL;
1145
1146        changemask(end, "00:00 00-00-0000");
1147        if(newnode == 0)
1148                loctime = localtime(&node->end);
1149        else
1150        {
1151                akttime += 300;
1152                loctime = localtime(&akttime);
1153        }
1154        edaylight = loctime->tm_isdst;
1155        strftime(buf, MINMALLOC, "%H:%M %d-%m-%Y", loctime);
1156        buf1 = ostrcat(buf, NULL, 1, 0);
1157        changeinput(end, buf1);
1158        free(buf1); buf1 = NULL;
1159
1160        if(flag == 1)
1161                recchannel->hidden = YES;
1162        else
1163                recchannel->hidden = NO;
1164
1165        changeinput(recchannel, NULL);
1166        if(newnode == 0)
1167        {
1168                recchannel->handle = (char*)getchannel(node->serviceid, node->transponderid);
1169                if(recchannel->handle != NULL)
1170                        addchoicebox(recchannel, ((struct channel*)recchannel->handle)->name, ((struct channel*)recchannel->handle)->name);
1171        }
1172        else
1173        {
1174                if(status.aktservice->channel != NULL)
1175                {
1176                        addchoicebox(recchannel, status.aktservice->channel->name, status.aktservice->channel->name);
1177                        recchannel->handle = (char*)status.aktservice->channel;
1178                }
1179        }
1180
1181        if(newnode == 0)
1182                changeinput(path, node->recpath);
1183        else
1184                changeinput(path, getconfig("rec_path", NULL));
1185
1186        addchoicebox(after, "0", _("auto"));
1187        addchoicebox(after, "1", _("nothing"));
1188        addchoicebox(after, "2", _("standby"));
1189        addchoicebox(after, "3", _("power off"));
1190        if(newnode == 0)
1191        {
1192                tmpstr = oitoa(node->afterevent);
1193                setchoiceboxselection(after, tmpstr);
1194                free(tmpstr); tmpstr = NULL;
1195        }
1196               
1197        changemask(pincode, "0000");
1198        if(newnode == 0)
1199                changeinput(pincode, node->pincode);
1200        else
1201                changeinput(pincode, "0000");
1202
1203        drawscreen(rectimerext, 0, 0);
1204        addscreenrc(rectimerext, listbox);
1205
1206        tmp = listbox->select;
1207        while(1)
1208        {
1209                addscreenrc(rectimerext, tmp);
1210                rcret = waitrc(rectimerext, 0, 2);
1211                tmp = listbox->select;
1212               
1213                if(rcret == getrcconfigint("rcred", NULL))
1214                {
1215                        if(name->ret != NULL && strlen(name->ret) > 0)
1216                        {
1217                                char* tmppath = NULL;
1218                               
1219                                tmppath = ostrcat(tmppath, name->ret, 1, 0);
1220                                tmppath = strstrip(tmppath);
1221                                delspezchar(tmppath, 2);
1222                                tmppath = ostrcat("/", tmppath, 0, 1);                         
1223                                tmppath = ostrcat(getconfig("rec_path", NULL), tmppath, 0, 1);
1224                               
1225                                if(tmppath != NULL && mkdir(tmppath, 0777) == 0)
1226                                {
1227                                        changeinput(path, tmppath);
1228                                        changetext(path, tmppath);
1229                                }
1230                                else
1231                                        textbox(_("Message"), "Can't create Path", _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 0, 0);
1232                               
1233                                drawscreen(rectimerext, 0, 0);
1234                                free(tmppath); tmppath = NULL;
1235                        }
1236                        continue;
1237                }
1238
1239                if(listbox->select != NULL && listbox->select->ret != NULL && ostrcmp(listbox->select->name, "justplay") == 0)
1240                {
1241                        recjustplayhidden(atoi(listbox->select->ret), end, path, after);
1242                }
1243
1244                tmprepeate = recrepeateget(newnode, repeate, repeatetype, day, mon, tue, wed, thur, fri, sat, sun);
1245                if(listbox->select != NULL && (ostrcmp(listbox->select->name, "repeate") == 0 || ostrcmp(listbox->select->name, "repeatetype") == 0))
1246                {
1247                        recrepeatehidden(tmprepeate, repeatetype, day, mon, tue, wed, thur, fri, sat, sun);
1248                }
1249                drawscreen(rectimerext, 0, 0);
1250
1251                if(rcret == getrcconfigint("rcexit", NULL))
1252                {
1253                        if(newnode == 1 || flag == 1) delrectimer(node, 1, 0);
1254                        break;
1255                }
1256                if(rcret == getrcconfigint("rcok", NULL))
1257                {
1258                        if(listbox->select != NULL && ostrcmp(listbox->select->name, "path") == 0)
1259                        {
1260                                clearscreen(rectimerext);
1261                                tmpstr = screendir(listbox->select->ret, "", NULL, NULL, NULL, NULL, 0, "SELECT", 0, NULL, 0, NULL, 0, 700, 0, 650, 0, 0);
1262                                if(tmpstr != NULL)
1263                                        changeinput(listbox->select, tmpstr);
1264                                free(tmpstr); tmpstr = NULL;
1265
1266                                drawscreen(rectimerext, 0, 0);
1267                                continue;
1268                        }
1269                        if(listbox->select != NULL && ostrcmp(listbox->select->name, "channel") == 0)
1270                        {
1271                                clearscreen(rectimerext);
1272                                int saveservicetype = status.servicetype;
1273                                struct channel* tmpchnode = (struct channel*)recchannel->handle;
1274
1275                                status.servicetype = tmpservicetype;
1276                                if(tmpservicetype == 0)
1277                                {
1278                                        addconfigtmp("channellist", tmpchannellist);
1279                                        if(tmpchnode != NULL)
1280                                        {
1281                                                addconfiginttmp("serviceid", tmpchnode->serviceid);
1282                                                addconfigllutmp("transponderid", tmpchnode->transponderid);
1283                                        }
1284                                }
1285                                else
1286                                {
1287                                        addconfigtmp("rchannellist", tmpchannellist);
1288                                        if(tmpchnode != NULL)
1289                                        {
1290                                                addconfiginttmp("rserviceid", tmpchnode->serviceid);
1291                                                addconfigllutmp("rtransponderid", tmpchnode->transponderid);
1292                                        }
1293                                }
1294
1295                                screenchannellist(&tmpchnode, &tmpchannellist, 1);
1296
1297                                recchannel->handle = (char*)tmpchnode;
1298
1299                                status.servicetype = saveservicetype;
1300                                delconfigtmp("channellist");
1301                                delconfigtmp("rchannellist");
1302                                delconfigtmp("serviceid");
1303                                delconfigtmp("rserviceid");
1304                                delconfigtmp("transponderid");
1305                                delconfigtmp("rtransponderid");
1306
1307                                if((struct channel*)recchannel->handle != NULL)
1308                                {
1309                                        changeinput(listbox->select, ((struct channel*)recchannel->handle)->name);
1310                                }
1311
1312                                drawscreen(rectimerext, 0, 0);
1313                                continue;
1314                        }
1315
1316                        free(node->name); node->name = NULL;
1317                        node->name = ostrcat(name->ret, NULL, 0, 0);
1318                        if(justplay->ret != NULL)
1319                                node->justplay = atoi(justplay->ret);
1320                        if(begin->ret != NULL)
1321                        {
1322                                loctime->tm_isdst = bdaylight;
1323                                tmpstr = strptime(begin->ret, "%H:%M %d-%m-%Y", loctime);
1324                                if(tmpstr != NULL)
1325                                        node->begin = mktime(loctime);
1326
1327                                if((flag == 1 || newnode == 1) && node->justplay == 0)
1328                                        node->begin -= getconfigint("recforerun", NULL) * 60;
1329
1330                                node->begin -= (node->begin % 60);
1331
1332                                if(node->justplay == 1)
1333                                        node->end = node->begin + 1;
1334                        }
1335                        if(end->ret != NULL && node->justplay == 0)
1336                        {
1337                                loctime->tm_isdst = edaylight;
1338                                tmpstr = strptime(end->ret, "%H:%M %d-%m-%Y", loctime);
1339                                if(tmpstr != NULL)
1340                                        node->end = mktime(loctime);
1341
1342                                if((flag == 1 || newnode == 1) && node->justplay == 0)
1343                                        node->end += getconfigint("recoverrun", NULL) * 60;
1344                                node->end -= (node->end % 60);
1345                        }
1346                        if(after->ret != NULL)
1347                                node->afterevent = atoi(after->ret);
1348                               
1349                        if(pincode->ret != NULL)
1350                                node->pincode = ostrcat(pincode->ret, NULL, 0, 0);
1351                        else
1352                                node->pincode = ostrcat("0000", NULL, 0, 0);
1353
1354                        if(tmprepeate > 127) tmprepeate = 0;
1355                        node->repeate = tmprepeate;
1356
1357                        free(node->recpath); node->recpath = NULL;
1358                        node->recpath = ostrcat(path->ret, NULL, 0, 0);
1359
1360                        free(node->channellist); node->channellist = NULL;
1361                        node->channellist = tmpchannellist;
1362
1363                        node->servicetype = tmpservicetype;
1364
1365                        if(recchannel->handle != NULL)
1366                        {
1367                                node->serviceid = ((struct channel*)recchannel->handle)->serviceid;
1368                                node->transponderid = ((struct channel*)recchannel->handle)->transponderid;
1369                        }
1370
1371                        char* checkret = NULL;
1372                        ret = checkrectimeradd(node, &checkret);
1373                        if(ret != 0)
1374                        {
1375                                if(ret == 2)
1376                                {
1377                                        ret = textbox(_("Message"), checkret, _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 0, 0);
1378                                        if(ret == 2)
1379                                                ret = 99;
1380                                        else
1381                                                ret = 0;
1382                                }
1383                                if(ret == 1 || ret == 99)
1384                                {
1385                                        node->status = 3;
1386                                        free(node->errstr); node->errstr = NULL;
1387                                        node->errstr = ostrcat(checkret, NULL, 0, 0);
1388                                        stringreplacecharonce(node->errstr, '\n', '\0');
1389                                        if(ret == 1) textbox(_("Message"), checkret, _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 0, 0);
1390                                }
1391                        }
1392
1393                        //check if record is running and change endtime
1394                        m_lock(&status.servicemutex, 2);
1395                        struct service* tmpservice = getservicebyrectimestamp(node->timestamp, 1);
1396                        if(tmpservice != NULL)
1397                                tmpservice->recendtime = node->end;
1398                        m_unlock(&status.servicemutex, 2);
1399                               
1400                        if(newnode == 1 || flag == 1) node->disabled = 0;
1401                        status.writerectimer = 1;
1402                        writerectimer(getconfig("rectimerfile", NULL), 0);
1403                        break;
1404                }
1405        }
1406
1407        if(flag == 1) resettvpic();
1408
1409        delownerrc(rectimerext);
1410        clearscreen(rectimerext);
1411}
1412
1413//flag 0: show normal
1414//flag 1: show log
1415void screenrectimer()
1416{
1417        int rcret = 0, flag = 0;
1418        struct skin* recordtimer = getscreen("rectimer");
1419        struct skin* listbox = getscreennode(recordtimer, "listbox");
1420        struct skin* b1 = getscreennode(recordtimer, "b1");
1421        struct skin* b2 = getscreennode(recordtimer, "b2");
1422        struct skin* b3 = getscreennode(recordtimer, "b3");
1423        struct skin* b4 = getscreennode(recordtimer, "b4");
1424        struct skin* tmp = NULL;
1425        struct rectimer* rectimernode = NULL;
1426        struct tm *loctime = NULL;
1427        struct channel* chnode = NULL;
1428        char* buf = NULL, *tmpstr = NULL;
1429
1430        buf = malloc(MINMALLOC);
1431        if(buf == NULL)
1432        {
1433                err("no memory");
1434                return;
1435        }
1436
1437start:
1438        deloldrectimer();
1439
1440        tmp = NULL;
1441        listbox->aktpage = -1;
1442        listbox->select = NULL;
1443        rectimernode = rectimer;
1444
1445        while(rectimernode != NULL)
1446        {
1447                if((flag == 0 && (rectimernode->status == 2 || rectimernode->status == 3)) || (flag == 1 && (rectimernode->status == 0 || rectimernode->status == 1)) || rectimernode->status == 4 || rectimernode->status == 5)
1448                {
1449                        rectimernode = rectimernode->next;
1450                        continue;
1451                }
1452
1453                tmp = addlistbox(recordtimer, listbox, tmp, 1);
1454                if(tmp != NULL)
1455                {
1456                        loctime = localtime(&rectimernode->begin);
1457                        strftime(buf, MINMALLOC, "%d-%m-%Y %H:%M", loctime);
1458                        tmpstr = ostrcat(tmpstr, buf, 1, 0);
1459                        if(rectimernode->justplay == 0)
1460                        {
1461                                tmpstr = ostrcat(tmpstr, " - ", 1, 0);
1462                                loctime = localtime(&rectimernode->end);
1463                                strftime(buf, MINMALLOC, "%d-%m-%Y %H:%M", loctime);
1464                                tmpstr = ostrcat(tmpstr, buf, 1, 0);
1465                                tmpstr = ostrcat(tmpstr, " (", 1, 0);
1466                                tmpstr = ostrcat(tmpstr, _("rec"), 1, 0);
1467                                tmpstr = ostrcat(tmpstr, " - ", 1, 0);
1468                                if(rectimernode->repeate == 0)
1469                                        tmpstr = ostrcat(tmpstr, _("once"), 1, 0);
1470                                else
1471                                        tmpstr = ostrcat(tmpstr, _("repeate"), 1, 0);
1472                                tmpstr = ostrcat(tmpstr, ")", 1, 0);
1473                        }
1474                        else
1475                        {
1476                                tmpstr = ostrcat(tmpstr, " (", 1, 0);
1477                                tmpstr = ostrcat(tmpstr, _("switch"), 1, 0);
1478                                tmpstr = ostrcat(tmpstr, " - ", 1, 0);
1479                                if(rectimernode->repeate == 0)
1480                                        tmpstr = ostrcat(tmpstr, _("once"), 1, 0);
1481                                else
1482                                        tmpstr = ostrcat(tmpstr, _("repeate"), 1, 0);
1483                                tmpstr = ostrcat(tmpstr, ")", 1, 0);
1484                        }
1485
1486                        tmpstr = ostrcat(tmpstr, "\n", 1, 0);
1487                        if(rectimernode->name != NULL)
1488                        {
1489                                if(rectimernode->name == NULL || strlen(rectimernode->name) == 0)
1490                                        tmpstr = ostrcat(tmpstr, "---", 1, 0);
1491                                else
1492                                        tmpstr = ostrcat(tmpstr, rectimernode->name, 1, 0);
1493                        }
1494                        chnode = getchannel(rectimernode->serviceid, rectimernode->transponderid);
1495                        if(chnode != NULL && chnode->name != NULL && strlen(chnode->name) > 0)
1496                        {
1497                                tmpstr = ostrcat(tmpstr, " (", 1, 0);
1498                                tmpstr = ostrcat(tmpstr, chnode->name, 1, 0);
1499                                tmpstr = ostrcat(tmpstr, ")", 1, 0);
1500                        }
1501
1502                        tmpstr = ostrcat(tmpstr, "\n", 1, 0);
1503                        if(rectimernode->status == 0)
1504                                tmpstr = ostrcat(tmpstr, _("waiting"), 1, 0);
1505                        else if(rectimernode->status == 1)
1506                                tmpstr = ostrcat(tmpstr, _("running"), 1, 0);
1507                        else if(rectimernode->status == 2)
1508                                tmpstr = ostrcat(tmpstr, _("success"), 1, 0);
1509                        else if(rectimernode->status == 3)
1510                                tmpstr = ostrcat(tmpstr, _("error"), 1, 0);
1511
1512                        if(flag == 1 && rectimernode->errstr != NULL && strlen(rectimernode->errstr) != 0)
1513                        {
1514                                tmpstr = ostrcat(tmpstr, " (", 1, 0);
1515                                tmpstr = ostrcat(tmpstr, rectimernode->errstr, 1, 0);
1516                                tmpstr = ostrcat(tmpstr, ")", 1, 0);
1517                        }
1518                       
1519                        changetext(tmp, tmpstr);
1520                        free(tmpstr); tmpstr = NULL;
1521                        tmp->handle = (char*)rectimernode;
1522                        tmp->height = 110;
1523                        tmp->type = TEXTBOX;
1524
1525                        if(rectimernode->disabled == 1)
1526                                tmp->fontcol = convertcol("deaktivcol");
1527                }
1528                rectimernode = rectimernode->next;
1529        }
1530
1531        if(flag == 0)
1532        {
1533                b1->hidden = NO;
1534                b2->hidden = NO;
1535                b3->hidden = NO;
1536                b4->hidden = NO;
1537        }
1538        else
1539        {
1540                b1->hidden = YES;
1541                b2->hidden = YES;
1542                b3->hidden = YES;
1543                b4->hidden = YES;
1544        }
1545
1546        drawscreen(recordtimer, 0, 0);
1547        addscreenrc(recordtimer, listbox);
1548
1549        while(1)
1550        {
1551                rcret = waitrc(recordtimer, 5000, 0);
1552
1553                if(flag == 0 && rcret == getrcconfigint("rcblue", NULL))
1554                {
1555                        flag = 1;
1556                        delmarkedscreennodes(recordtimer, 1);
1557                        goto start;
1558                }
1559                if(rcret == getrcconfigint("rcexit", NULL))
1560                {
1561                        if(flag == 0)
1562                                break;
1563                        else
1564                        {
1565                                flag = 0;
1566                                delmarkedscreennodes(recordtimer, 1);
1567                                goto start;
1568                        }
1569                }
1570                if(flag == 0 && rcret == getrcconfigint("rcgreen", NULL))
1571                {
1572                        clearscreen(recordtimer);
1573                        screenrectimerext(NULL, 0);
1574                        delmarkedscreennodes(recordtimer, 1);
1575                        goto start;
1576                }
1577                if(flag == 0 && listbox->select != NULL)
1578                {
1579                        if(rcret == getrcconfigint("rcok", NULL))
1580                        {
1581                                clearscreen(recordtimer);
1582                                screenrectimerext((struct rectimer*)listbox->select->handle, 0);
1583                                delmarkedscreennodes(recordtimer, 1);
1584                                goto start;
1585                        }
1586                        if(rcret == getrcconfigint("rcred", NULL))
1587                        {
1588                                delrectimer((struct rectimer*)listbox->select->handle, 1, 0);
1589                               
1590                                delmarkedscreennodes(recordtimer, 1);
1591                                goto start;
1592                        }
1593                        if(rcret == getrcconfigint("rcyellow", NULL))
1594                        {
1595                                if(((struct rectimer*)listbox->select->handle)->disabled == 1)
1596                                        ((struct rectimer*)listbox->select->handle)->disabled = 0;
1597                                else
1598                                        ((struct rectimer*)listbox->select->handle)->disabled = 1;
1599
1600                                delmarkedscreennodes(recordtimer, 1);
1601                                goto start;
1602                        }
1603                        if(rcret == RCTIMEOUT)
1604                        {
1605                                delmarkedscreennodes(recordtimer, 1);
1606                                goto start;
1607                        }
1608                }
1609        }
1610
1611        free(buf); buf = NULL;
1612        delmarkedscreennodes(recordtimer, 1);
1613        delownerrc(recordtimer);
1614        clearscreen(recordtimer);
1615}
1616
1617int addrecepg(struct channel* chnode, struct epg* epgnode, char* channellist)
1618{
1619        struct rectimer* node = NULL;
1620
1621        deloldrectimer();
1622
1623        if(chnode == NULL || epgnode == NULL)
1624                return 1;
1625
1626        node = addrectimernode(NULL, NULL);
1627        if(node != NULL)
1628        {
1629                node->name = ostrcat(epgnode->title, NULL, 0, 0);
1630                node->begin = epgnode->starttime;
1631                node->end = epgnode->endtime;
1632
1633                node->repeate = 0;
1634
1635                node->recpath = ostrcat(getconfig("rec_path", NULL), NULL, 0, 0);
1636                node->servicetype = status.servicetype;
1637                if(node->servicetype == 0)
1638                {
1639                        if(channellist == NULL)
1640                                node->channellist = ostrcat(getconfig("channellist", NULL), NULL, 0, 0);
1641                        else
1642                                node->channellist = ostrcat(channellist, NULL, 0, 0);
1643                }
1644                else
1645                {
1646                        if(channellist == NULL)
1647                                node->channellist = ostrcat(getconfig("rchannellist", NULL), NULL, 0, 0);
1648                        else
1649                                node->channellist = ostrcat(channellist, NULL, 0, 0);
1650                }
1651                node->serviceid = chnode->serviceid;
1652                node->transponderid = chnode->transponderid;
1653                screenrectimerext(node, 1);
1654        }
1655
1656        return 0;
1657}
1658
1659#endif
Note: See TracBrowser for help on using the repository browser.