source: titan/titan/rectimer.h @ 24101

Last change on this file since 24101 was 23721, checked in by nit, 11 years ago

[titan] fix lang

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