source: titan/titan/mainbouquets.h @ 16380

Last change on this file since 16380 was 16380, checked in by nit, 12 years ago

[titan] optimize (change malloc/memset to calloc)

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