source: titan/titan/rcfunc.h @ 15272

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

[titan] add gridview to filelist

File size: 29.3 KB
Line 
1#ifndef RCFUNC_H
2#define RCFUNC_H
3
4void progressbarright(struct skin* screen, struct skin* progressbar, int flag)
5{
6        debug(1000, "in");
7
8        if(progressbar != NULL)
9        {
10                if(progressbar->progresssize <= 100)
11                {
12                        progressbar->progresssize++;
13                        drawscreen(screen, flag);
14                }
15                else
16                        progressbar->progresssize = 100;
17        }
18
19        debug(1000, "out");
20}
21
22void progressbarleft(struct skin* screen, struct skin* progressbar, int flag)
23{
24        debug(1000, "in");
25
26        if(progressbar != NULL)
27        {
28                if(progressbar->progresssize > 0)
29                {
30                        progressbar->progresssize--;
31                        drawscreen(screen, flag);
32                }
33                else
34                        progressbar->progresssize = 0;
35        }
36
37        debug(1000, "out");
38}
39
40void filelistok(struct skin* screen, struct skin* filelist, int flag)
41{
42        debug(1000, "in");
43        struct skin* path = NULL;
44        char* tmp = NULL, *lastdir = NULL, *plastdir = NULL;
45        int inplen = 0;
46
47        if(filelist != NULL)
48        {
49                if(filelist->select != NULL && filelist->select->input != NULL)
50                {
51                        inplen = strlen(filelist->select->input);
52                        if(inplen >= 3 && filelist->select->input[inplen - 1] == '.' && filelist->select->input[inplen - 2] == '.' && filelist->select->input[inplen - 3] == '/')
53                        {
54                                lastdir = ostrcat(lastdir, filelist->select->input, 1, 0);
55                                lastdir[inplen - 3] = '\0';
56                                plastdir = strrchr(lastdir, '/');
57                                if(plastdir == NULL)
58                                        plastdir = lastdir;
59                                else
60                                        plastdir++;
61                        }
62
63                        filelist->aktline = 0;
64                        filelist->aktpage = 0;
65                        tmp = createpath(filelist->select->input, "");
66                        changeinput(filelist, tmp);
67                        free(tmp); tmp = NULL;
68
69                        tmp = malloc(strlen(filelist->name) + 5);
70                        if(tmp != NULL)
71                        {
72                                sprintf(tmp, "%s%s", filelist->name, "path");
73                                path = getscreennode(screen, tmp);
74                                free(tmp);
75                                if(path != status.skinerr)
76                                        changetext(path, filelist->input);
77                                delmarkedscreennodes(screen, FILELISTDELMARK);
78                                if(filelist->type & GRID)
79                                        createfilelist(screen, filelist, 1);
80                                else
81                                        createfilelist(screen, filelist, 0);
82                                setlistboxselection(filelist, plastdir);
83                                free(lastdir); lastdir = NULL;
84                                drawscreen(screen, flag);
85                        }
86                        else
87                                err("no memory");
88                }
89        }
90        debug(1000, "out");
91}
92
93void helpbox(struct skin* screen, struct skin* node, int flag)
94{
95        if(node != NULL && flag == 0)
96        {
97                screenhelp(screen);
98                drawscreen(screen, flag);
99        }
100}
101
102void inputboxhelp(struct skin* screen, struct skin* inputbox, int flag)
103{
104        char* tmpstr = NULL;
105
106        if(inputbox != NULL && (inputbox->type & INPUTBOX) && flag == 0)
107        {
108                tmpstr = screeninputhelp(inputbox->input, flag);
109                changeinput(inputbox, tmpstr);
110                free(tmpstr); tmpstr = NULL;
111                drawscreen(screen, flag);
112        }
113}
114
115void inputboxchar(struct skin* screen, struct skin* inputbox, char zeichen, int flag)
116{
117        debug(1000, "in");
118        if(inputbox != NULL && inputbox->input != NULL)
119        {
120                if(strlen(inputbox->input) > 0)
121                {
122                        inputbox->input[inputbox->aktpage - 1] = zeichen;
123                        if(flag != 1)
124                                drawscreen(screen, flag);
125                }
126        }
127        debug(1000, "out");
128}
129
130void inputboxff(struct skin* screen, struct skin* inputbox, int flag)
131{
132        debug(1000, "in");
133        if(inputbox != NULL)
134        {
135                if(inputbox->input == NULL)
136                        changeinput(inputbox, "");
137                inputbox->aktpage = insertchar(&inputbox->input, '_', inputbox->aktpage);
138                drawscreen(screen, flag);
139        }
140        debug(1000, "out");
141}
142
143void inputboxfr(struct skin* screen, struct skin* inputbox, int flag)
144{
145        debug(1000, "in");
146        if(inputbox != NULL && inputbox->input != NULL)
147        {
148                inputbox->aktpage = delchar(&inputbox->input, inputbox->aktpage);
149                drawscreen(screen, flag);
150        }
151        debug(1000, "out");
152}
153
154void checkinputboxnumright(struct skin* inputbox)
155{
156        debug(1000, "in");
157        int count = 0;
158
159        if(inputbox != NULL && inputbox->input != NULL && (inputbox->type & INPUTBOXNUM))
160        {
161                while(isdigit(inputbox->input[inputbox->aktpage - 1]) == 0)
162                {
163                        inputbox->aktpage++;
164                        if(inputbox->input[inputbox->aktpage - 1] == '\0')
165                        {
166                                count++;
167                                inputbox->aktpage = 0;
168                        }
169                        if(count > 1)
170                        {
171                                inputbox->aktpage = strlen(inputbox->input) + 1;
172                                break;
173                        }
174                }
175        }
176        debug(1000, "out");
177}
178
179void checkinputboxnumleft(struct skin* inputbox)
180{
181        debug(1000, "in");
182        int count = 0;
183
184        if(inputbox != NULL && inputbox->input != NULL && (inputbox->type & INPUTBOXNUM))
185        {
186                while(isdigit(inputbox->input[inputbox->aktpage - 1]) == 0)
187                {
188                        inputbox->aktpage--;
189                        if(inputbox->aktpage < 0)
190                        {
191                                count++;
192                                inputbox->aktpage = strlen(inputbox->input);
193                        }
194                        if(count > 1)
195                        {
196                                inputbox->aktpage = strlen(inputbox->input) + 1;
197                                break;
198                        }
199                }
200        }
201        debug(1000, "out");
202}
203
204void inputboxright(struct skin* screen, struct skin* inputbox, int flag)
205{
206        debug(1000, "in");
207
208        if(inputbox != NULL && inputbox->input != NULL)
209        {
210                inputbox->aktpage++;
211                if(inputbox->aktpage >= strlen(inputbox->input) + 1) inputbox->aktpage = 1;
212
213                checkinputboxnumright(inputbox);
214                drawscreen(screen, flag);
215        }
216        debug(1000, "out");
217}
218
219void inputboxleft(struct skin* screen, struct skin* inputbox, int flag)
220{
221        debug(1000, "in");
222
223        if(inputbox != NULL && inputbox->input != NULL)
224        {
225                inputbox->aktpage--;
226                if(inputbox->aktpage < 1) inputbox->aktpage = strlen(inputbox->input);
227
228                checkinputboxnumleft(inputbox);
229                drawscreen(screen, flag);
230        }
231        debug(1000, "out");
232}
233
234void inputbox0(struct skin* screen, struct skin* inputbox, int flag)
235{
236        if(inputbox != NULL && inputbox->input != NULL)
237        {
238                int aktpage = inputbox->aktpage - 1;
239
240                if(inputbox->type & INPUTBOX)
241                {
242                        if(inputbox->input[aktpage] == '0')
243                                inputboxchar(screen, inputbox, ' ', flag);
244                        else if(inputbox->input[aktpage] == ' ')
245                                inputboxchar(screen, inputbox, '#', flag);
246                        else if(inputbox->input[aktpage] == '#')
247                                inputboxchar(screen, inputbox, '*', flag);
248                        else if(inputbox->input[aktpage] == '*')
249                                inputboxchar(screen, inputbox, '_', flag);
250                        else
251                                inputboxchar(screen, inputbox, '0', flag);
252                }
253                else
254                {
255                        inputboxchar(screen, inputbox, '0', 1);
256                        inputboxright(screen, inputbox, flag);
257                }
258        }
259}
260
261void inputbox1(struct skin* screen, struct skin* inputbox, int flag)
262{
263        if(inputbox != NULL && inputbox->input != NULL)
264        {
265                int aktpage = inputbox->aktpage - 1;
266
267                if(inputbox->type & INPUTBOX)
268                {
269                        if(inputbox->input[aktpage] == '1')
270                                inputboxchar(screen, inputbox, '.', flag);
271                        else if(inputbox->input[aktpage] == '.')
272                                inputboxchar(screen, inputbox, ',', flag);
273                        else if(inputbox->input[aktpage] == ',')
274                                inputboxchar(screen, inputbox, '?', flag);
275                        else if(inputbox->input[aktpage] == '?')
276                                inputboxchar(screen, inputbox, '!', flag);
277                        else if(inputbox->input[aktpage] == '!')
278                                inputboxchar(screen, inputbox, '\'', flag);
279                        else if(inputbox->input[aktpage] == '\'')
280                                inputboxchar(screen, inputbox, '-', flag);
281                        else if(inputbox->input[aktpage] == '-')
282                                inputboxchar(screen, inputbox, '(', flag);
283                        else if(inputbox->input[aktpage] == '(')
284                                inputboxchar(screen, inputbox, ')', flag);
285                        else if(inputbox->input[aktpage] == ')')
286                                inputboxchar(screen, inputbox, '@', flag);
287                        else if(inputbox->input[aktpage] == '@')
288                                inputboxchar(screen, inputbox, '/', flag);
289                        else if(inputbox->input[aktpage] == '/')
290                                inputboxchar(screen, inputbox, ':', flag);
291                        else
292                                inputboxchar(screen, inputbox, '1', flag);
293                }
294                else
295                {
296                        inputboxchar(screen, inputbox, '1', 1);
297                        inputboxright(screen, inputbox, flag);
298                }
299        }
300}
301
302void inputbox2(struct skin* screen, struct skin* inputbox, int flag)
303{
304        if(inputbox != NULL && inputbox->input != NULL)
305        {
306                int aktpage = inputbox->aktpage - 1;
307
308                if(inputbox->type & INPUTBOX)
309                {
310                        if(inputbox->input[aktpage] == '2')
311                                inputboxchar(screen, inputbox, 'a', flag);
312                        else if(inputbox->input[aktpage] == 'a')
313                                inputboxchar(screen, inputbox, 'b', flag);
314                        else if(inputbox->input[aktpage] == 'b')
315                                inputboxchar(screen, inputbox, 'c', flag);
316                        else if(inputbox->input[aktpage] == 'c')
317                                inputboxchar(screen, inputbox, 'A', flag);
318                        else if(inputbox->input[aktpage] == 'A')
319                                inputboxchar(screen, inputbox, 'B', flag);
320                        else if(inputbox->input[aktpage] == 'B')
321                                inputboxchar(screen, inputbox, 'C', flag);
322                        else
323                                inputboxchar(screen, inputbox, '2', flag);
324                }
325                else
326                {
327                        inputboxchar(screen, inputbox, '2', 1);
328                        inputboxright(screen, inputbox, flag);
329                }
330        }
331}
332
333void inputbox3(struct skin* screen, struct skin* inputbox, int flag)
334{
335        if(inputbox != NULL && inputbox->input != NULL)
336        {
337                int aktpage = inputbox->aktpage - 1;
338
339                if(inputbox->type & INPUTBOX)
340                {
341                        if(inputbox->input[aktpage] == '3')
342                                inputboxchar(screen, inputbox, 'd', flag);
343                        else if(inputbox->input[aktpage] == 'd')
344                                inputboxchar(screen, inputbox, 'e', flag);
345                        else if(inputbox->input[aktpage] == 'e')
346                                inputboxchar(screen, inputbox, 'f', flag);
347                        else if(inputbox->input[aktpage] == 'f')
348                                inputboxchar(screen, inputbox, 'D', flag);
349                        else if(inputbox->input[aktpage] == 'D')
350                                inputboxchar(screen, inputbox, 'E', flag);
351                        else if(inputbox->input[aktpage] == 'E')
352                                inputboxchar(screen, inputbox, 'F', flag);
353                        else
354                                inputboxchar(screen, inputbox, '3', flag);
355                }
356                else
357                {
358                        inputboxchar(screen, inputbox, '3', 1);
359                        inputboxright(screen, inputbox, flag);
360                }
361        }
362}
363
364void inputbox4(struct skin* screen, struct skin* inputbox, int flag)
365{
366        if(inputbox != NULL && inputbox->input != NULL)
367        {
368                int aktpage = inputbox->aktpage - 1;
369
370                if(inputbox->type & INPUTBOX)
371                {
372                        if(inputbox->input[aktpage] == '4')
373                                inputboxchar(screen, inputbox, 'g', flag);
374                        else if(inputbox->input[aktpage] == 'g')
375                                inputboxchar(screen, inputbox, 'h', flag);
376                        else if(inputbox->input[aktpage] == 'h')
377                                inputboxchar(screen, inputbox, 'i', flag);
378                        else if(inputbox->input[aktpage] == 'i')
379                                inputboxchar(screen, inputbox, 'G', flag);
380                        else if(inputbox->input[aktpage] == 'G')
381                                inputboxchar(screen, inputbox, 'H', flag);
382                        else if(inputbox->input[aktpage] == 'H')
383                                inputboxchar(screen, inputbox, 'I', flag);
384                        else
385                                inputboxchar(screen, inputbox, '4', flag);
386                }
387                else
388                {
389                        inputboxchar(screen, inputbox, '4', 1);
390                        inputboxright(screen, inputbox, flag);
391                }
392        }
393}
394
395void inputbox5(struct skin* screen, struct skin* inputbox, int flag)
396{
397        if(inputbox != NULL && inputbox->input != NULL)
398        {
399                int aktpage = inputbox->aktpage - 1;
400
401                if(inputbox->type & INPUTBOX)
402                {
403                        if(inputbox->input[aktpage] == '5')
404                                inputboxchar(screen, inputbox, 'j', flag);
405                        else if(inputbox->input[aktpage] == 'j')
406                                inputboxchar(screen, inputbox, 'k', flag);
407                        else if(inputbox->input[aktpage] == 'k')
408                                inputboxchar(screen, inputbox, 'l', flag);
409                        else if(inputbox->input[aktpage] == 'l')
410                                inputboxchar(screen, inputbox, 'J', flag);
411                        else if(inputbox->input[aktpage] == 'J')
412                                inputboxchar(screen, inputbox, 'K', flag);
413                        else if(inputbox->input[aktpage] == 'K')
414                                inputboxchar(screen, inputbox, 'L', flag);
415                        else
416                                inputboxchar(screen, inputbox, '5', flag);
417                }
418                else
419                {
420                        inputboxchar(screen, inputbox, '5', 1);
421                        inputboxright(screen, inputbox, flag);
422                }
423
424        }
425}
426
427void inputbox6(struct skin* screen, struct skin* inputbox, int flag)
428{
429        if(inputbox != NULL && inputbox->input != NULL)
430        {
431                int aktpage = inputbox->aktpage - 1;
432
433                if(inputbox->type & INPUTBOX)
434                {
435                        if(inputbox->input[aktpage] == '6')
436                                inputboxchar(screen, inputbox, 'm', flag);
437                        else if(inputbox->input[aktpage] == 'm')
438                                inputboxchar(screen, inputbox, 'n', flag);
439                        else if(inputbox->input[aktpage] == 'n')
440                                inputboxchar(screen, inputbox, 'o', flag);
441                        else if(inputbox->input[aktpage] == 'o')
442                                inputboxchar(screen, inputbox, 'M', flag);
443                        else if(inputbox->input[aktpage] == 'M')
444                                inputboxchar(screen, inputbox, 'N', flag);
445                        else if(inputbox->input[aktpage] == 'N')
446                                inputboxchar(screen, inputbox, 'O', flag);
447                        else
448                                inputboxchar(screen, inputbox, '6', flag);
449                }
450                else
451                {
452                        inputboxchar(screen, inputbox, '6', 1);
453                        inputboxright(screen, inputbox, flag);
454                }
455        }
456}
457
458void inputbox7(struct skin* screen, struct skin* inputbox, int flag)
459{
460        if(inputbox != NULL && inputbox->input != NULL)
461        {
462                int aktpage = inputbox->aktpage - 1;
463
464                if(inputbox->type & INPUTBOX)
465                {
466                        if(inputbox->input[aktpage] == '7')
467                                inputboxchar(screen, inputbox, 'p', flag);
468                        else if(inputbox->input[aktpage] == 'p')
469                                inputboxchar(screen, inputbox, 'q', flag);
470                        else if(inputbox->input[aktpage] == 'q')
471                                inputboxchar(screen, inputbox, 'r', flag);
472                        else if(inputbox->input[aktpage] == 'r')
473                                inputboxchar(screen, inputbox, 's', flag);
474                        else if(inputbox->input[aktpage] == 's')
475                                inputboxchar(screen, inputbox, 'P', flag);
476                        else if(inputbox->input[aktpage] == 'P')
477                                inputboxchar(screen, inputbox, 'Q', flag);
478                        else if(inputbox->input[aktpage] == 'Q')
479                                inputboxchar(screen, inputbox, 'R', flag);
480                        else if(inputbox->input[aktpage] == 'R')
481                                inputboxchar(screen, inputbox, 'S', flag);
482                        else
483                                inputboxchar(screen, inputbox, '7', flag);
484                }
485                else
486                {
487                        inputboxchar(screen, inputbox, '7', 1);
488                        inputboxright(screen, inputbox, flag);
489                }
490        }
491}
492
493void inputbox8(struct skin* screen, struct skin* inputbox, int flag)
494{
495        if(inputbox != NULL && inputbox->input != NULL)
496        {
497                int aktpage = inputbox->aktpage - 1;
498
499                if(inputbox->type & INPUTBOX)
500                {
501                        if(inputbox->input[aktpage] == '8')
502                                inputboxchar(screen, inputbox, 't', flag);
503                        else if(inputbox->input[aktpage] == 't')
504                                inputboxchar(screen, inputbox, 'u', flag);
505                        else if(inputbox->input[aktpage] == 'u')
506                                inputboxchar(screen, inputbox, 'v', flag);
507                        else if(inputbox->input[aktpage] == 'v')
508                                inputboxchar(screen, inputbox, 'T', flag);
509                        else if(inputbox->input[aktpage] == 'T')
510                                inputboxchar(screen, inputbox, 'U', flag);
511                        else if(inputbox->input[aktpage] == 'U')
512                                inputboxchar(screen, inputbox, 'V', flag);
513                        else
514                                inputboxchar(screen, inputbox, '8', flag);
515                }
516                else
517                {
518                        inputboxchar(screen, inputbox, '8', 1);
519                        inputboxright(screen, inputbox, flag);
520                }
521        }
522}
523
524void inputbox9(struct skin* screen, struct skin* inputbox, int flag)
525{
526        if(inputbox != NULL && inputbox->input != NULL)
527        {
528                int aktpage = inputbox->aktpage - 1;
529
530                if(inputbox->type & INPUTBOX)
531                {
532                        if(inputbox->input[aktpage] == '9')
533                                inputboxchar(screen, inputbox, 'w', flag);
534                        else if(inputbox->input[aktpage] == 'w')
535                                inputboxchar(screen, inputbox, 'x', flag);
536                        else if(inputbox->input[aktpage] == 'x')
537                                inputboxchar(screen, inputbox, 'y', flag);
538                        else if(inputbox->input[aktpage] == 'y')
539                                inputboxchar(screen, inputbox, 'z', flag);
540                        else if(inputbox->input[aktpage] == 'z')
541                                inputboxchar(screen, inputbox, 'W', flag);
542                        else if(inputbox->input[aktpage] == 'W')
543                                inputboxchar(screen, inputbox, 'X', flag);
544                        else if(inputbox->input[aktpage] == 'X')
545                                inputboxchar(screen, inputbox, 'Y', flag);
546                        else if(inputbox->input[aktpage] == 'Y')
547                                inputboxchar(screen, inputbox, 'Z', flag);
548                        else
549                                inputboxchar(screen, inputbox, '9', flag);
550                }
551                else
552                {
553                        inputboxchar(screen, inputbox, '9', 1);
554                        inputboxright(screen, inputbox, flag);
555                }
556        }
557}
558
559void choiceboxleft(struct skin* screen, struct skin* choicebox, int flag)
560{
561        debug(1000, "in");
562        if(choicebox != NULL)
563        {
564                if(choicebox->aktpage <= 1)
565                        choicebox->aktpage = choicebox->linecount;
566                else
567                        choicebox->aktpage--;
568                drawscreen(screen, flag);
569        }
570        debug(1000, "out");
571}
572
573void choiceboxright(struct skin* screen, struct skin* choicebox, int flag)
574{
575        debug(1000, "in");
576        if(choicebox != NULL)
577        {
578                if(choicebox->aktpage >= choicebox->linecount)
579                        choicebox->aktpage = 1;
580                else
581                {
582                        if(choicebox->aktpage < 1) choicebox->aktpage = 1;
583                        choicebox->aktpage++;
584                }
585                drawscreen(screen, flag);
586        }
587        debug(1000, "out");
588}
589
590void griddown(struct skin* screen, struct skin* grid, int flag)
591{
592        debug(1000, "in");
593        int end = 0, br = 0, mark = 0;
594        struct skin* node = NULL;
595
596        if(grid != NULL)
597        {
598                if(grid->select != NULL && grid->gridcol == 0)
599                        grid->gridcol = grid->select->posx + (grid->select->width / 2);
600
601                node = grid->select;
602                while(node != NULL)
603                {
604                        if(node->next == NULL && node != grid->select && ((node->type & GRIDBR))) break;
605                        if(node->next == NULL || node->deaktivcol != -1 || node->hidden == YES || (node->parentpointer != grid && ostrcmp(node->parent, grid->name) != 0))
606                        {
607                                node = node->next;
608                                if(node == NULL && mark == 0)
609                                {
610                                        //go to the first cell
611                                        node = grid->next;
612                                        mark = 1;
613                                        grid->aktline = 1;
614                                }
615                                continue;
616                        }
617
618                        if((node->type & GRIDBR) && node != grid->select) br++;
619                        if(br > 1)
620                        {
621                                grid->aktline--;
622                                break;
623                        }
624
625                        if(br > 0)
626                        {
627                                end = node->posx + node->width;
628                                if(end <= grid->gridcol)
629                                {
630                                        grid->aktline++;
631                                        node = node->next;
632                                        continue;
633                                }
634                                break;
635                        }
636
637                        grid->aktline++;
638                        node = node->next;
639                }
640
641                grid->aktpage = -1;
642                if(grid->aktline > grid->linecount || grid->aktline < 1)
643                        grid->aktline = grid->linecount;
644
645                if(grid->select != NULL) delscreenrc(screen, grid->select);
646                drawscreen(screen, flag);
647        }
648
649        debug(1000, "out");
650}
651
652void gridup(struct skin* screen, struct skin* grid, int flag)
653{
654        debug(1000, "in");
655        int start = 0, br = 0, mark = 0;
656        struct skin* node = NULL, *tmpnode = NULL;;
657
658        if(grid != NULL)
659        {
660                if(grid->select != NULL && grid->gridcol == 0)
661                        grid->gridcol = grid->select->posx + (grid->select->width / 2);
662
663                node = grid->select;
664                while(node != NULL)
665                {
666               
667                        if(node->prev == NULL || node->prev == grid || node->deaktivcol != -1 || node->hidden == YES || (node->prev->parentpointer != grid && ostrcmp(node->prev->parent, grid->name) != 0))
668                        {
669                                if(br > 0 && (node->type & GRIDBR) && !(node->deaktivcol != -1 || node->hidden == YES)) break;
670
671                                node = node->prev;
672                                if(node == grid && mark == 0)
673                                {
674                                        while(node != NULL)
675                                        {
676                                                if(node->parentpointer == grid || ostrcmp(node->parent, grid->name) == 0)
677                                                        tmpnode = node;
678                                                node = node->next;
679                                        }
680                                        if(tmpnode == NULL) break;
681                                        node = tmpnode;
682                                        grid->aktline = grid->linecount;
683                                        if(br == 0) br++;
684                                }
685                                continue;
686                        }
687
688                        if(br > 1)
689                        {
690                                grid->aktline++;
691                                break;
692                        }
693
694                        if(br > 0)
695                        {
696                                start = node->posx;
697                                if(start > grid->gridcol)
698                                {
699                                        grid->aktline--;
700                                        node = node->prev;
701                                        continue;
702                                }
703                                break;
704                        }
705
706                        if(node->type & GRIDBR) br++;
707
708                        grid->aktline--;
709                        node = node->prev;
710                }
711
712                grid->aktpage = -1;
713                if(grid->aktline < 1 || grid->aktline > grid->linecount)
714                        grid->aktline = 1;
715
716                if(grid->select != NULL) delscreenrc(screen, grid->select);
717                drawscreen(screen, flag);
718        }
719
720        debug(1000, "out");
721}
722
723void gridleft(struct skin* screen, struct skin* grid, int flag)
724{
725        debug(1000, "in");
726        struct skin* node = NULL;
727
728        if(grid != NULL)
729        {
730                node = grid->select;
731                if(node != NULL && (node->type & GRIDBR))
732                {
733                        grid->aktpage = -1;
734                        while(node != NULL)
735                        {
736                                if(node->parentpointer == grid || ostrcmp(node->parent, grid->name) == 0)
737                                {
738                                        if(node->next == NULL || (node->next->type & GRIDBR))
739                                                break;
740                                        else
741                                                grid->aktline++;
742                                }
743                                node = node->next;
744                        }
745                }
746                else
747                {
748                        grid->aktpage = -1;
749                        grid->aktline--;
750                        if(grid->aktline < 1) grid->aktline = 1;
751                }
752
753                if(grid->select != NULL) delscreenrc(screen, grid->select);
754                drawscreen(screen, flag);
755                if(grid->select != NULL)
756                        grid->gridcol = grid->select->posx + (grid->select->width / 2);
757        }
758        debug(1000, "out");
759}
760
761void gridright(struct skin* screen, struct skin* grid, int flag)
762{
763        debug(1000, "in");
764        struct skin* node = NULL;
765
766        if(grid != NULL)
767        {
768                node = grid->select;
769                if((node != NULL && node->next != NULL && (node->next->type & GRIDBR)) || grid->aktline == grid->linecount)
770                {
771                        grid->aktpage = -1;
772                        while(node != NULL)
773                        {
774                                if(node->parentpointer == grid || ostrcmp(node->parent, grid->name) == 0)
775                                {
776                                        if(node == NULL || (node->type & GRIDBR))
777                                                break;
778                                        else
779                                                grid->aktline--;
780                                }
781                                node = node->prev;
782                        }
783                }
784                else
785                {
786                        grid->aktpage = -1;
787                        if(grid->aktline <= grid->linecount)
788                                grid->aktline++;
789                        if(grid->aktline > grid->linecount)
790                                grid->aktline = grid->linecount;
791                }
792
793                if(grid->select != NULL) delscreenrc(screen, grid->select);
794                drawscreen(screen, flag);
795                if(grid->select != NULL)
796                        grid->gridcol = grid->select->posx + (grid->select->width / 2);
797        }
798        debug(1000, "out");
799}
800
801void gridchup(struct skin* screen, struct skin* grid, int flag)
802{
803        debug(1000, "in");
804
805        if(grid != NULL)
806        {
807                grid->aktline = -1;
808                grid->aktpage--;
809                if(grid->aktpage < 1)
810                        grid->aktpage = 1;
811
812                drawscreen(screen, flag);
813                if(grid->select != NULL)
814                        grid->gridcol = grid->select->posx + (grid->select->width / 2);
815        }
816
817        debug(1000, "out");
818}
819
820void gridchdown(struct skin* screen, struct skin* grid, int flag)
821{
822        debug(1000, "in");
823
824        if(grid != NULL)
825        {
826                grid->aktline = -1;
827                grid->aktpage++;
828                if(grid->aktpage > grid->pagecount)
829                {
830                        grid->aktpage = grid->pagecount;
831                        grid->aktline = -2;
832                }
833
834                drawscreen(screen, flag);
835                if(grid->select != NULL)
836                        grid->gridcol = grid->select->posx + (grid->select->width / 2);
837        }
838
839        debug(1000, "out");
840}
841
842
843void listboxleft(struct skin* screen, struct skin* listbox, int flag)
844{
845        debug(1000, "in");
846
847        if(listbox != NULL)
848        {
849                listbox->aktline = -1;
850                listbox->aktpage--;
851                if(listbox->aktpage < 1)
852                        listbox->aktpage = 1;
853
854                if(listbox->select != NULL) delscreenrc(screen, listbox->select);
855                drawscreen(screen, flag);
856        }
857
858        debug(1000, "out");
859}
860
861void listboxright(struct skin* screen, struct skin* listbox, int flag)
862{
863        debug(1000, "in");
864
865        if(listbox != NULL)
866        {
867                listbox->aktline = -1;
868                listbox->aktpage++;
869                if(listbox->aktpage > listbox->pagecount)
870                {
871                        listbox->aktpage = listbox->pagecount;
872                        listbox->aktline = -2;
873                }
874
875                if(listbox->select != NULL) delscreenrc(screen, listbox->select);
876                drawscreen(screen, flag);
877        }
878
879        debug(1000, "out");
880}
881
882void listboxup(struct skin* screen, struct skin* listbox, int flag)
883{
884        debug(1000, "in");
885
886        if(listbox != NULL)
887        {
888                listbox->aktpage = -1;
889                listbox->aktline--;
890                if(listbox->aktline < 1)
891                        listbox->aktline = listbox->linecount;
892
893                if(listbox->select != NULL) delscreenrc(screen, listbox->select);
894                drawscreen(screen, flag);
895        }
896        debug(1000, "out");
897}
898
899void listboxdown(struct skin* screen, struct skin* listbox, int flag)
900{
901        debug(1000, "in");
902
903        if(listbox != NULL)
904        {
905                listbox->aktpage = -1;
906                if(listbox->aktline <= listbox->linecount)
907                        listbox->aktline++;
908                if(listbox->aktline > listbox->linecount)
909                        listbox->aktline = 1;
910
911                if(listbox->select != NULL) delscreenrc(screen, listbox->select);
912                drawscreen(screen, flag);
913        }
914        debug(1000, "out");
915}
916
917void textboxup(struct skin* screen, struct skin* textbox, int flag)
918{
919        debug(1000, "in");
920        if(textbox != NULL)
921        {
922                if(textbox->aktpage > 1)
923                {
924                        textbox->aktpage--;
925                        drawscreen(screen, flag);
926                }
927        }
928        debug(1000, "out");
929}
930
931void textboxdown(struct skin* screen, struct skin* textbox, int flag)
932{
933        debug(1000, "in");
934        if(textbox != NULL)
935        {
936                if(textbox->aktpage < textbox->pagecount)
937                {
938                        textbox->aktpage++;
939                        drawscreen(screen, flag);
940                }
941        }
942        debug(1000, "out");
943}
944
945int addscreenrc(struct skin* screen, struct skin* node)
946{
947        debug(1000, "in");
948
949        if(node == NULL)
950        {
951                debug(1000, "out -> NULL detect");
952                return 1;
953        }
954
955        if(node->type & GRID)
956        {
957                addrc(getrcconfigint("rcright", NULL), gridright, screen, node);
958                addrc(getrcconfigint("rcleft", NULL), gridleft, screen, node);
959                addrc(getrcconfigint("rcup", NULL), gridup, screen, node);
960                addrc(getrcconfigint("rcdown", NULL), griddown, screen, node);
961                addrc(getrcconfigint("rcchup", NULL), gridchup, screen, node);
962                addrc(getrcconfigint("rcchdown", NULL), gridchdown, screen, node);
963                addrc(getrcconfigint("rchelp", NULL), helpbox, screen, node);
964                if(node->type & FILELIST)
965                        addrc(getrcconfigint("rcok", NULL), filelistok, screen, node);
966        }
967        else if(node->type & LISTBOX)
968        {
969                addrc(getrcconfigint("rcup", NULL), listboxup, screen, node);
970                addrc(getrcconfigint("rcdown", NULL), listboxdown, screen, node);
971                addrc(getrcconfigint("rcright", NULL), listboxright, screen, node);
972                addrc(getrcconfigint("rcleft", NULL), listboxleft, screen, node);
973                addrc(getrcconfigint("rcchup", NULL), listboxright, screen, node);
974                addrc(getrcconfigint("rcchdown", NULL), listboxleft, screen, node);
975                addrc(getrcconfigint("rchelp", NULL), helpbox, screen, node);
976        }
977        else if(node->type & CHOICEBOX)
978        {
979                addrc(getrcconfigint("rcleft", NULL), choiceboxleft, screen, node);
980                addrc(getrcconfigint("rcright", NULL), choiceboxright, screen, node);
981                addrc(getrcconfigint("rchelp", NULL), helpbox, screen, node);
982        }
983        else if((node->type & INPUTBOX) || (node->type & INPUTBOXNUM))
984        {
985                addrc(getrcconfigint("rc0", NULL), inputbox0, screen, node);
986                addrc(getrcconfigint("rc1", NULL), inputbox1, screen, node);
987                addrc(getrcconfigint("rc2", NULL), inputbox2, screen, node);
988                addrc(getrcconfigint("rc3", NULL), inputbox3, screen, node);
989                addrc(getrcconfigint("rc4", NULL), inputbox4, screen, node);
990                addrc(getrcconfigint("rc5", NULL), inputbox5, screen, node);
991                addrc(getrcconfigint("rc6", NULL), inputbox6, screen, node);
992                addrc(getrcconfigint("rc7", NULL), inputbox7, screen, node);
993                addrc(getrcconfigint("rc8", NULL), inputbox8, screen, node);
994                addrc(getrcconfigint("rc9", NULL), inputbox9, screen, node);
995                addrc(getrcconfigint("rcright", NULL), inputboxright, screen, node);
996                addrc(getrcconfigint("rcleft", NULL), inputboxleft, screen, node);
997                addrc(getrcconfigint("rchelp", NULL), helpbox, screen, node);
998                if(node->type & INPUTBOX) addrc(getrcconfigint("rcff", NULL), inputboxff, screen, node);
999                if(node->type & INPUTBOX) addrc(getrcconfigint("rcfr", NULL), inputboxfr, screen, node);
1000                if(node->type & INPUTBOX) addrc(getrcconfigint("rctext", NULL), inputboxhelp, screen, node);
1001        }
1002        else if(node->type & TEXTBOX)
1003        {
1004                addrc(getrcconfigint("rcup", NULL), textboxup, screen, node);
1005                addrc(getrcconfigint("rcdown", NULL), textboxdown, screen, node);
1006                addrc(getrcconfigint("rcchup", NULL), textboxup, screen, node);
1007                addrc(getrcconfigint("rcchdown", NULL), textboxdown, screen, node);
1008                addrc(getrcconfigint("rchelp", NULL), helpbox, screen, node);
1009        }
1010        else if(node->type & FILELIST)
1011        {
1012                addrc(getrcconfigint("rcup", NULL), listboxup, screen, node);
1013                addrc(getrcconfigint("rcdown", NULL), listboxdown, screen, node);
1014                addrc(getrcconfigint("rcright", NULL), listboxright, screen, node);
1015                addrc(getrcconfigint("rcleft", NULL), listboxleft, screen, node);
1016                addrc(getrcconfigint("rcok", NULL), filelistok, screen, node);
1017                addrc(getrcconfigint("rcchup", NULL), listboxright, screen, node);
1018                addrc(getrcconfigint("rcchdown", NULL), listboxleft, screen, node);
1019                addrc(getrcconfigint("rchelp", NULL), helpbox, screen, node);
1020        }
1021        else if(node->type & PROGRESSBAR)
1022        {
1023                addrc(getrcconfigint("rcleft", NULL), progressbarleft, screen, node);
1024                addrc(getrcconfigint("rcright", NULL), progressbarright, screen, node);
1025                addrc(getrcconfigint("rchelp", NULL), helpbox, screen, node);
1026        }
1027
1028        debug(1000, "out");
1029        return 0;
1030}
1031
1032int delscreenrc(struct skin* screen, struct skin* node)
1033{
1034        debug(1000, "in");
1035
1036        if(node == NULL)
1037        {
1038                debug(1000, "out -> NULL detect");
1039                return 1;
1040        }
1041
1042        if(node->type & GRID)
1043        {
1044                delrc(getrcconfigint("rcright", NULL), screen, node);
1045                delrc(getrcconfigint("rcleft", NULL), screen, node);
1046                delrc(getrcconfigint("rcup", NULL), screen, node);
1047                delrc(getrcconfigint("rcdown", NULL), screen, node);
1048                delrc(getrcconfigint("rcchup", NULL), screen, node);
1049                delrc(getrcconfigint("rcchdown", NULL), screen, node);
1050                delrc(getrcconfigint("rchelp", NULL), screen, node);
1051                if(node->type & FILELIST)
1052                        delrc(getrcconfigint("rcok", NULL), screen, node);
1053        }
1054        else if(node->type & LISTBOX)
1055        {
1056                delrc(getrcconfigint("rcup", NULL), screen, node);
1057                delrc(getrcconfigint("rcdown", NULL), screen, node);
1058                delrc(getrcconfigint("rcright", NULL), screen, node);
1059                delrc(getrcconfigint("rcleft", NULL), screen, node);
1060                delrc(getrcconfigint("rcchup", NULL), screen, node);
1061                delrc(getrcconfigint("rcchdown", NULL), screen, node);
1062                delrc(getrcconfigint("rchelp", NULL), screen, node);
1063        }
1064        else if(node->type & CHOICEBOX)
1065        {
1066                delrc(getrcconfigint("rcleft", NULL), screen, node);
1067                delrc(getrcconfigint("rcright", NULL), screen, node);
1068                delrc(getrcconfigint("rchelp", NULL), screen, node);
1069        }
1070        else if((node->type & INPUTBOX) || (node->type & INPUTBOXNUM))
1071        {
1072                delrc(getrcconfigint("rc0", NULL), screen, node);
1073                delrc(getrcconfigint("rc1", NULL), screen, node);
1074                delrc(getrcconfigint("rc2", NULL), screen, node);
1075                delrc(getrcconfigint("rc3", NULL), screen, node);
1076                delrc(getrcconfigint("rc4", NULL), screen, node);
1077                delrc(getrcconfigint("rc5", NULL), screen, node);
1078                delrc(getrcconfigint("rc6", NULL), screen, node);
1079                delrc(getrcconfigint("rc7", NULL), screen, node);
1080                delrc(getrcconfigint("rc8", NULL), screen, node);
1081                delrc(getrcconfigint("rc9", NULL), screen, node);
1082                delrc(getrcconfigint("rcright", NULL), screen, node);
1083                delrc(getrcconfigint("rcleft", NULL), screen, node);
1084                delrc(getrcconfigint("rchelp", NULL), screen, node);
1085                if(node->type & INPUTBOX) delrc(getrcconfigint("rcff", NULL), screen, node);
1086                if(node->type & INPUTBOX) delrc(getrcconfigint("rcfr", NULL), screen, node);
1087                if(node->type & INPUTBOX) delrc(getrcconfigint("rchelp", NULL), screen, node);
1088        }
1089        else if(node->type & TEXTBOX)
1090        {
1091                delrc(getrcconfigint("rcup", NULL), screen, node);
1092                delrc(getrcconfigint("rcdown", NULL), screen, node);
1093                delrc(getrcconfigint("rcchup", NULL), screen, node);
1094                delrc(getrcconfigint("rcchdown", NULL), screen, node);
1095                delrc(getrcconfigint("rchelp", NULL), screen, node);
1096        }
1097        else if(node->type & FILELIST)
1098        {
1099                delrc(getrcconfigint("rcup", NULL), screen, node);
1100                delrc(getrcconfigint("rcdown", NULL), screen, node);
1101                delrc(getrcconfigint("rcright", NULL), screen, node);
1102                delrc(getrcconfigint("rcleft", NULL), screen, node);
1103                delrc(getrcconfigint("rcok", NULL), screen, node);
1104                delrc(getrcconfigint("rcchup", NULL), screen, node);
1105                delrc(getrcconfigint("rcchdown", NULL), screen, node);
1106                delrc(getrcconfigint("rchelp", NULL), screen, node);
1107        }
1108        else if(node->type & PROGRESSBAR)
1109        {
1110                delrc(getrcconfigint("rcleft", NULL), screen, node);
1111                delrc(getrcconfigint("rcright", NULL), screen, node);
1112                delrc(getrcconfigint("rchelp", NULL), screen, node);
1113        }
1114
1115        debug(1000, "out");
1116        return 0;
1117}
1118
1119#endif
Note: See TracBrowser for help on using the repository browser.