source: titan/titan/mainbouquets.h @ 24222

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

[titan] add funktion to del empty favorites

File size: 12.3 KB
Line 
1#ifndef MAINBOUQUETS_H
2#define MAINBOUQUETS_H
3
4struct mainbouquet* screenmainbouquet()
5{
6        int rcret = 0;
7        struct skin* bouquetlist = getscreen("bouquetlist");
8        struct skin* listbox = getscreennode(bouquetlist, "listbox");
9        struct skin* tmp = NULL;
10        struct mainbouquet* node = mainbouquet;
11        struct mainbouquet* ret = NULL;
12
13        while(node != NULL)
14        {
15                if(node->type == status.servicetype)
16                {
17                        tmp = addlistbox(bouquetlist, listbox, tmp, 1);
18                        if(tmp != NULL)
19                        {
20                                changetext(tmp, node->name);
21                                tmp->handle = (char*)node;
22                                tmp->del = 1;
23                        }
24                }
25                node = node->next;
26        }
27
28        drawscreen(bouquetlist, 0, 0);
29        addscreenrc(bouquetlist, listbox);
30
31        while(1)
32        {
33                rcret = waitrc(bouquetlist, 0, 0);
34
35                if(rcret == getrcconfigint("rcexit", NULL)) break;
36                if(rcret == getrcconfigint("rcok", NULL))
37                {
38                        if(listbox->select != NULL)
39                                ret = (struct mainbouquet*)listbox->select->handle;
40                        break;
41                }
42        }
43
44        delmarkedscreennodes(bouquetlist, 1);
45        delownerrc(bouquetlist);
46        clearscreen(bouquetlist);
47        return ret;
48}
49
50void debugmainbouquet()
51{
52        struct mainbouquet* node = mainbouquet;
53
54        while(node != NULL)
55        {
56                printf("mainbouquet = %s\n", node->name);       
57                node = node->next;
58        }
59}
60
61struct mainbouquet* getlastmainbouquet(struct mainbouquet* node)
62{
63        struct mainbouquet *prev = NULL;
64
65        while(node != NULL)
66        {
67                prev = node;
68                node = node->next;
69        }
70
71        return prev;
72}
73
74struct mainbouquet* getprevmainbouquetbyservicetype(struct mainbouquet* node)
75{
76        struct mainbouquet* prev = NULL;
77
78        if(node == NULL) node = mainbouquet;
79        if(node == NULL) return NULL;
80
81        prev = node->prev;
82        while(prev != NULL && prev->type != status.servicetype)
83                prev = prev->prev;
84        if(prev == NULL)
85        {
86                prev = getlastmainbouquet(mainbouquet);
87                while(prev != NULL && prev->type != status.servicetype)
88                        prev = prev->prev;
89        }
90
91        return prev;
92}
93
94struct mainbouquet* getnextmainbouquetbyservicetype(struct mainbouquet* node)
95{
96        struct mainbouquet* next = NULL;
97
98        if(node == NULL) node = mainbouquet;
99        if(node == NULL) return NULL;
100
101        next = node->next;
102
103        while(next != NULL && next->type != status.servicetype)
104                next = next->next;
105        if(next == NULL)
106        {
107                next = mainbouquet;
108                while(next != NULL && next->type != status.servicetype)
109                        next = next->next;
110        }
111
112        return next;
113}
114
115int movemainbouquetblockdown(struct mainbouquet* node)
116{
117        int i = 0, ret = 0;
118        struct mainbouquet* prev = NULL;
119
120        if(node == NULL || mainbouquet == NULL)
121        {
122                err("NULL detect");
123                return 1;
124        }
125
126        for(i = 0; i < status.moveblockcount; i++)
127        {
128                if(node == NULL) break;
129                node = node->next;
130                while(node != NULL && node->type != status.servicetype)
131                        node = node->next;
132        }
133
134        for(i = 0; i < status.moveblockcount + 1; i++)
135        {
136                if(node == NULL) break;
137                prev = getprevmainbouquetbyservicetype(node);
138                ret = movemainbouquetdown(node);
139
140                while(node->prev != NULL && node->prev->type != status.servicetype)
141                        ret = movemainbouquetdown(node);
142
143                node = prev;
144        }
145
146        return ret;
147}
148
149int movemainbouquetdown(struct mainbouquet* node)
150{
151        struct mainbouquet* prev = NULL, *next = NULL;
152
153        if(node == NULL || mainbouquet == NULL)
154        {
155                err("NULL detect");
156                return 1;
157        }
158       
159        //only one node
160        if(node->prev == NULL && node->next == NULL)
161                return 0;
162
163        //last node
164        if(node->next == NULL)
165        {
166                if(node->prev != NULL)
167                        node->prev->next = NULL;
168                node->prev = NULL;
169                node->next = mainbouquet;
170                mainbouquet->prev = node;
171                mainbouquet = node;
172                return 99;
173        }
174
175        //haenge node aus
176        if(node->prev != NULL)
177                node->prev->next = node->next;
178        else
179                mainbouquet = node->next;
180        node->next->prev = node->prev;
181
182        //save nodes next and prev
183        next = node->next;
184        prev = node->prev;
185
186        //haenge es eine pos nacher ein
187        node->next = next->next;
188        node->prev = next;
189       
190        if(next->next != NULL)
191                next->next->prev = node;
192        next->next = node;
193
194        status.writemainbouquet = 1;
195        return 0;
196}
197
198int movemainbouquetblockup(struct mainbouquet* node)
199{
200        int i = 0, ret = 0;
201        struct mainbouquet* next = NULL;
202
203        if(node == NULL || mainbouquet == NULL)
204        {
205                err("NULL detect");
206                return 1;
207        }
208
209        for(i = 0; i < status.moveblockcount + 1; i++)
210        {
211                if(node == NULL) break;
212                next = getnextmainbouquetbyservicetype(node);
213                ret = movemainbouquetup(node);
214
215                while(node->next != NULL && node->next->type != status.servicetype)
216                        ret = movemainbouquetup(node);
217
218                node = next;
219        }
220
221        return ret;
222}
223
224int movemainbouquetup(struct mainbouquet* node)
225{
226        struct mainbouquet* prev = NULL, *next = NULL, *last = NULL;
227
228        if(node == NULL || mainbouquet == NULL)
229        {
230                err("NULL detect");
231                return 1;
232        }
233       
234        //only one node
235        if(node->prev == NULL && node->next == NULL)
236                return 0;
237
238        //first node
239        if(node->prev == NULL)
240        {
241                last = getlastmainbouquet(mainbouquet);
242
243                if(node->next != NULL)
244                        node->next->prev = NULL;
245                mainbouquet = node->next;
246                node->next = NULL;
247                last->next = node;
248                node->prev = last;
249                return 99;
250        }
251
252        //haenge node aus
253        node->prev->next = node->next;
254        if(node->next != NULL)
255                node->next->prev = node->prev;
256
257        //save nodes next and prev
258        next = node->next;
259        prev = node->prev;
260
261        //haenge es eine pos voher ein
262        node->next = prev;
263        node->prev = prev->prev;
264       
265        if(prev->prev != NULL)
266                prev->prev->next = node;
267        else
268                mainbouquet = node;
269        prev->prev = node;
270
271        status.writemainbouquet = 1;
272        return 0;
273}
274
275struct mainbouquet* addmainbouquet(char *line, int count, struct mainbouquet* last)
276{
277        struct mainbouquet *newnode = NULL, *prev = NULL, *node = mainbouquet;
278        char *name = NULL, *filename = NULL;
279        int ret = 0;
280
281        newnode = (struct mainbouquet*)calloc(1, sizeof(struct mainbouquet));
282        if(newnode == NULL)
283        {
284                err("no memory");
285                return NULL;
286        }
287
288        name = malloc(MINMALLOC);
289        if(name == NULL)
290        {
291                err("no memory");
292                free(newnode);
293                return NULL;
294        }
295
296        filename = malloc(MINMALLOC);
297        if(filename == NULL)
298        {
299                err("no memory");
300                free(newnode);
301                free(name);
302                return NULL;
303        }
304
305        status.writemainbouquet = 1;
306
307        ret = sscanf(line, "%[^#]#%d#%[^#]", name, &newnode->type, filename);
308        if(ret != 3)
309        {
310                if(count > 0)
311                {
312                        err("mainbouquet line %d not ok", count);
313                }
314                else
315                {
316                        err("add mainbouquet");
317                }
318                free(name);
319                free(filename);
320                free(newnode);
321                return NULL;
322        }
323
324        newnode->name = ostrcat(name, NULL, 1, 0);
325        newnode->filename = ostrcat(filename, NULL, 1, 0);
326
327        if(last == NULL)
328        {
329                while(node != NULL)
330                {
331                        prev = node;
332                        node = node->next;
333                }
334        }
335        else
336        {
337                prev = last;
338                node = last->next;
339        }
340
341        if(prev == NULL)
342                mainbouquet = newnode;
343        else
344        {
345                prev->next = newnode;
346                newnode->prev = prev;
347        }
348        newnode->next = node;
349        if(node != NULL) node->prev = newnode;
350
351        return newnode;
352}
353
354int readmainbouquet(char* filename)
355{
356        FILE *fd = NULL;
357        char *fileline = NULL, *tmpstr = NULL, *tmpstr0 = NULL, *tmpstr1 = NULL;
358        int linecount = 0, treffer0 = 1, treffer1 = 1, len = 0;
359        struct mainbouquet* last = NULL, *tmplast = NULL;
360       
361        tmpstr0 = getconfig("channellist", NULL);
362        tmpstr1 = getconfig("rchannellist", NULL);
363        if(ostrncmp("(BOUQUET)-", tmpstr0, 10) == 0) treffer0 = 0;
364        if(ostrncmp("(BOUQUET)-", tmpstr1, 10) == 0) treffer1 = 0;
365
366        fileline = malloc(MINMALLOC);
367        if(fileline == NULL)
368        {
369                err("no memory");
370                return 1;
371        }
372
373        fd = fopen(filename, "r");
374        if(fd == NULL)
375        {
376                perr("can't open %s", filename);
377                free(fileline);
378                return 1;
379        }
380
381        while(fgets(fileline, MINMALLOC, fd) != NULL)
382        {
383                if(fileline[0] == '#' || fileline[0] == '\n')
384                        continue;
385                len = strlen(fileline) - 1;
386                if(len >= 0 && fileline[len] == '\n')
387                        fileline[len] = '\0';
388                len--;
389                if(len >= 0 && fileline[len] == '\r')
390                        fileline[len] = '\0';
391
392                linecount++;
393
394                if(last == NULL) last = tmplast;
395                last = addmainbouquet(fileline, linecount, last);
396                if(last != NULL)
397                {
398                        tmplast = last;
399                        tmpstr = ostrcat("(BOUQUET)-", last->name, 0, 0);
400
401                        if(treffer0 == 0 && last->type == 0 && ostrcmp(tmpstr, tmpstr0) == 0)
402                                treffer0 = 1;
403                        if(treffer1 == 0 && last->type == 1 && ostrcmp(tmpstr, tmpstr1) == 0)
404                                treffer1 = 1;
405                        free(tmpstr); tmpstr = NULL;
406                }
407        }
408
409        if(treffer0 == 0) delconfig("channellist");
410        if(treffer1 == 0) delconfig("rchannellist");
411
412        status.writemainbouquet = 0;
413        free(fileline);
414        fclose(fd);
415        return 0;
416}
417
418int readallbouquet()
419{
420        int ret = 0;
421        struct mainbouquet* node = mainbouquet;
422
423        while(node != NULL)
424        {
425                if(ostrcmp(node->filename, "0") != 0)
426                {
427                        if(readbouquet(node->filename, &node->bouquet, node->type) != 0)
428                                ret = 1;
429                }
430                node = node->next;
431        }
432       
433        return ret;
434}
435
436struct mainbouquet* getmainbouquetbybouquetpointer(struct bouquet* bouquetnode)
437{
438        struct mainbouquet *node = mainbouquet;
439        struct bouquet *bnode = NULL;
440
441        while(node != NULL)
442        {
443                bnode = node->bouquet;
444                while(bnode != NULL)
445                {
446                        if(bnode == bouquetnode)
447                                return node;
448
449                        bnode = bnode->next;
450                }
451                node = node->next;
452        }
453        debug(100, "mainbouquet not found (%p)", bouquetnode);
454        return NULL;
455}
456
457struct mainbouquet* getmainbouquetbyfilename(char *filename)
458{
459        struct mainbouquet *node = mainbouquet;
460
461        while(node != NULL)
462        {
463                if(ostrcmp(node->filename, filename) == 0)
464                        return node;
465
466                node = node->next;
467        }
468        debug(100, "mainbouquet not found (%s)", filename);
469        return NULL;
470}
471
472struct mainbouquet* getmainbouquet(char *name)
473{
474        struct mainbouquet *node = mainbouquet;
475
476        while(node != NULL)
477        {
478                if(ostrcmp(node->name, name) == 0)
479                        return node;
480
481                node = node->next;
482        }
483        debug(100, "mainbouquet not found (%s)", name);
484        return NULL;
485}
486
487//flag 0: don't unlink bouquet
488//flag 1: unlink bouquet
489void delmainbouquet(char *name, int flag)
490{
491        struct mainbouquet *node = mainbouquet, *prev = mainbouquet;
492
493        while(node != NULL)
494        {
495                if(ostrcmp(node->name, name) == 0)
496                {
497                        status.writemainbouquet = 1;
498                        if(node == mainbouquet)
499                        {
500                                mainbouquet = node->next;
501                                if(mainbouquet != NULL)
502                                        mainbouquet->prev = NULL;
503                        }
504                        else
505                        {
506                                prev->next = node->next;
507                                if(node->next != NULL)
508                                        node->next->prev = prev;
509                        }
510
511                        free(node->name);
512                        node->name = NULL;
513
514                        freebouquet(&node->bouquet);
515                        if(flag == 1) unlink(node->filename);
516
517                        free(node->filename);
518                        node->filename = NULL;
519
520                        free(node);
521                        node = NULL;
522                        break;
523                }
524
525                prev = node;
526                node = node->next;
527        }
528}
529
530//flag 0: don't unlink bouquet
531//flag 1: unlink bouquet
532void freemainbouquet(int flag)
533{
534        struct mainbouquet *node = mainbouquet, *prev = mainbouquet;
535
536        while(node != NULL)
537        {
538                prev = node;
539                node = node->next;
540                if(prev != NULL)
541                        delmainbouquet(prev->name, flag);
542        }
543}
544
545//flag 0: don't unlink bouquet
546//flag 1: unlink bouquet
547void delemptymainbouquet(int flag)
548{
549        struct mainbouquet *node = mainbouquet, *prev = mainbouquet;
550
551        while(node != NULL)
552        {
553                prev = node;
554                node = node->next;
555                if(prev != NULL && prev->bouquet == NULL)
556                        delmainbouquet(prev->name, flag);
557        }
558}
559
560void freeallbouquet()
561{
562        struct mainbouquet* node = mainbouquet;
563
564        while(node != NULL)
565        {
566                freebouquet(&node->bouquet);
567                node = node->next;
568        }
569}
570
571int writemainbouquet(const char *filename)
572{
573        FILE *fd = NULL;
574        struct mainbouquet *node = mainbouquet;
575        int ret = 0;
576
577        fd = fopen(filename, "w");
578        if(fd == NULL)
579        {
580                perr("can't open %s", filename);
581                return 1;
582        }
583
584        while(node != NULL)
585        {
586                ret = fprintf(fd, "%s#%d#%s\n", node->name, node->type, node->filename);
587                if(ret < 0)
588                {
589                        perr("writting file %s", filename);
590                }
591                node = node->next;
592        }
593
594        fclose(fd);
595        return 0;
596}
597
598int mainbouquet2channelslot(struct mainbouquet* mnode, int slot)
599{
600        struct bouquet* bnode = NULL;
601        char* tmpstr = NULL;
602
603        if(mnode != NULL)
604        {
605                bnode = mnode->bouquet;
606                while(bnode != NULL)
607                {
608                        if(getchannelslot(bnode->serviceid, bnode->transponderid) == NULL)
609                        {
610                                tmpstr = ostrcat(tmpstr, ollutoa(bnode->transponderid), 1, 1);
611                                tmpstr = ostrcat(tmpstr, "#", 1, 0);
612                                tmpstr = ostrcat(tmpstr, oitoa(bnode->serviceid), 1, 1);
613                                tmpstr = ostrcat(tmpstr, "#", 1, 0);
614                                tmpstr = ostrcat(tmpstr, oitoa(slot), 1, 1);
615                               
616                                addchannelslot(tmpstr, 1, NULL);
617                                free(tmpstr); tmpstr = NULL;
618                        }
619                        bnode = bnode->next;
620                }
621        }
622
623        return 0;
624}
625
626int mainbouquet2epgscanlist(struct mainbouquet* mnode)
627{
628        struct bouquet* bnode = NULL;
629        char* tmpstr = NULL;
630
631        if(mnode != NULL)
632        {
633                bnode = mnode->bouquet;
634                while(bnode != NULL)
635                {
636                        if(getepgscanlist(bnode->serviceid, bnode->transponderid) == NULL)
637                        {
638                                tmpstr = ostrcat(tmpstr, oitoa(bnode->serviceid), 1, 1);
639                                tmpstr = ostrcat(tmpstr, "#", 1, 0);
640                                tmpstr = ostrcat(tmpstr, ollutoa(bnode->transponderid), 1, 1);
641                               
642                                addepgscanlist(tmpstr, 1, NULL);
643                                free(tmpstr); tmpstr = NULL;
644                        }
645                        bnode = bnode->next;
646                }
647        }
648
649        return 0;
650}
651
652int writeallbouquet()
653{
654        struct mainbouquet* node = mainbouquet;
655        int ret = 0;
656
657        while(node != NULL)
658        {
659                if(ostrcmp(node->filename, "0") != 0)
660                {
661                        if(writebouquet(node->filename, node->bouquet) != 0)
662                                ret = 1;
663                }
664                node = node->next;
665        }
666
667        return ret;
668}
669
670#endif
Note: See TracBrowser for help on using the repository browser.