source: titan/titan/rectimer.h @ 15272

Last change on this file since 15272 was 14253, checked in by nit, 10 years ago

[titan] hide channel select in timer menu if timer comes from epg

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