removed temp files
[smdp.git] / src / viewer.c
1 /*
2  * Functions necessary to display a deck of slides in different color modes
3  * using ncurses. Only white, red, and blue are supported, as they can be
4  * faded in 256 color mode.
5  * Copyright (C) 2015 Michael Goehler
6  *
7  * This file is part of mdp.
8  *
9  * This program is free software: you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation, either version 3 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program. If not, see <http://www.gnu.org/licenses/>.
21  *
22  */
23
24 #include <ctype.h>  // isalnum
25 #include <wchar.h>  // wcschr
26 #include <wctype.h> // iswalnum
27 #include <string.h> // strcpy
28 #include <unistd.h> // usleep
29 #include "viewer.h"
30
31 // color ramp for fading from black to color
32 static short white_ramp[24] = { 16, 232, 233, 234, 235, 236,
33                                237, 238, 239, 240, 241, 242,
34                                244, 245, 246, 247, 248, 249,
35                                250, 251, 252, 253, 254, 255 };
36
37 static short blue_ramp[24]  = { 16,  17,  17,  18,  18,  19,
38                                 19,  20,  20,  21,  27,  33,
39                                 32,  39,  38,  45,  44,  44,
40                                 81,  81,  51,  51, 123, 123 };
41
42 static short red_ramp[24]   = { 16,  52,  52,  53,  53,  89,
43                                 89,  90,  90, 126, 127, 127,
44                                163, 163, 164, 164, 200, 200,
45                                201, 201, 207, 207, 213, 213 };
46
47 // color ramp for fading from white to color
48 static short white_ramp_invert[24] = { 15, 255, 254, 254, 252, 251,
49                                       250, 249, 248, 247, 246, 245,
50                                       243, 242, 241, 240, 239, 238,
51                                       237, 236, 235, 234, 233, 232};
52
53 static short blue_ramp_invert[24]  = { 15, 231, 231, 195, 195, 159,
54                                       159, 123, 123,  87,  51,  44,
55                                        45,  38,  39,  32,  33,  33,
56                                        26,  26,  27,  27,  21,  21};
57
58 static short red_ramp_invert[24]   = { 15, 231, 231, 224, 224, 225,
59                                       225, 218, 218, 219, 212, 213,
60                                       206, 207, 201, 200, 199, 199,
61                                       198, 198, 197, 197, 196, 196};
62
63 int ncurses_display(deck_t *deck, int notrans, int nofade, int invert, int reload, int noreload, int slidenum) {
64
65     int c = 0;          // char
66     int i = 0;          // iterate
67     int l = 0;          // line number
68     int lc = 0;         // line count
69     int sc = 1;         // slide count
70     int colors = 0;     // amount of colors supported
71     int fade = 0;       // disable color fading by default
72     int trans = -1;     // enable transparency if term supports it
73     int max_lines = 0;  // max lines per slide
74     int max_cols = 0;   // max columns per line
75     int offset;         // text offset
76     int stop = 0;       // passed stop bits per slide
77
78     // header line 1 is displayed at the top
79     int bar_top = (deck->headers > 0) ? 1 : 0;
80     // header line 2 is displayed at the bottom
81     // anyway we display the slide number at the bottom
82     int bar_bottom = (slidenum || deck->headers > 1)? 1 : 0;
83
84     slide_t *slide = deck->slide;
85     line_t *line;
86
87     // init ncurses
88     initscr();
89
90     while(slide) {
91         lc = 0;
92         line = slide->line;
93
94         while(line && line->text) {
95
96             if (line->text->value)
97                 lc += url_count_inline(line->text->value);
98
99             if (line->text->value)
100                 line->length -= url_len_inline(line->text->value);
101
102             if(line->length > COLS) {
103                 i = line->length;
104                 offset = 0;
105                 while(i > COLS) {
106
107                     i = prev_blank(line->text, offset + COLS) - offset;
108
109                     // single word is > COLS
110                     if(!i) {
111                         // calculate min_width
112                         i = next_blank(line->text, offset + COLS) - offset;
113
114                         // disable ncurses
115                         endwin();
116
117                         // print error
118                         fwprintf(stderr, L"Error: Terminal width (%i columns) too small. Need at least %i columns.\n", COLS, i);
119                         fwprintf(stderr, L"You may need to shorten some lines by inserting line breaks.\n");
120
121                         // no reload
122                         return 0;
123                     }
124
125                     // set max_cols
126                     max_cols = MAX(i, max_cols);
127
128                     // iterate to next line
129                     offset = prev_blank(line->text, offset + COLS);
130                     i = line->length - offset;
131                     lc++;
132                 }
133                 // set max_cols one last time
134                 max_cols = MAX(i, max_cols);
135             } else {
136                 // set max_cols
137                 max_cols = MAX(line->length, max_cols);
138             }
139             lc++;
140             line = line->next;
141         }
142
143         max_lines = MAX(lc, max_lines);
144
145         slide = slide->next;
146     }
147
148     // not enough lines
149     if(max_lines + bar_top + bar_bottom > LINES) {
150
151         // disable ncurses
152         endwin();
153
154         // print error
155         fwprintf(stderr, L"Error: Terminal height (%i lines) too small. Need at least %i lines.\n", LINES, max_lines + bar_top + bar_bottom);
156         fwprintf(stderr, L"You may need to add additional horizontal rules (---) to split your file in shorter slides.\n");
157
158         // no reload
159         return 0;
160     }
161
162     // disable cursor
163     curs_set(0);
164
165     // disable output of keyboard typing
166     noecho();
167
168     // make getch() process one char at a time
169     cbreak();
170
171     // enable arrow keys
172     keypad(stdscr,TRUE);
173
174     // set colors
175     if(has_colors() == TRUE) {
176         start_color();
177         use_default_colors();
178
179         // 256 color mode
180         if(COLORS == 256) {
181
182             if(notrans) {
183                 if(invert) {
184                     trans = 15; // white in 256 color mode
185                 } else {
186                     trans = 16; // black in 256 color mode
187                 }
188             }
189
190             if(invert) {
191                 init_pair(CP_WHITE, 232, trans);
192                 init_pair(CP_BLUE, 21, trans);
193                 init_pair(CP_RED, 196, trans);
194                 init_pair(CP_BLACK, 15, 232);
195             } else {
196                 init_pair(CP_WHITE, 255, trans);
197                 init_pair(CP_BLUE, 123, trans);
198                 init_pair(CP_RED, 213, trans);
199                 init_pair(CP_BLACK, 16, 255);
200             }
201             init_pair(CP_YELLOW, 208, trans);
202
203             // enable color fading
204             if(!nofade)
205                 fade = true;
206
207         // 8 color mode
208         } else {
209
210             if(notrans) {
211                 if(invert) {
212                     trans = 7; // white in 8 color mode
213                 } else {
214                     trans = 0; // black in 8 color mode
215                 }
216             }
217
218             if(invert) {
219                 init_pair(CP_WHITE, 0, trans);
220                 init_pair(CP_BLACK, 7, 0);
221             } else {
222                 init_pair(CP_WHITE, 7, trans);
223                 init_pair(CP_BLACK, 0, 7);
224             }
225             init_pair(CP_BLUE, 4, trans);
226             init_pair(CP_RED, 1, trans);
227             init_pair(CP_YELLOW, 3, trans);
228         }
229
230         colors = 1;
231     }
232
233     // set background color of main window
234     if(colors)
235         wbkgd(stdscr, COLOR_PAIR(CP_YELLOW));
236
237     // setup main window
238     WINDOW *content = newwin(LINES - bar_top - bar_bottom, COLS, 0 + bar_top, 0);
239     if(colors)
240         wbkgd(content, COLOR_PAIR(CP_WHITE));
241
242     slide = deck->slide;
243
244     // find slide to reload
245     while(reload > 1 && reload <= deck->slides) {
246         slide = slide->next;
247         sc++;
248         reload--;
249     }
250
251     // reset reload indicator
252     reload = 0;
253
254     while(slide) {
255
256         url_init();
257
258         // clear windows
259         werase(content);
260         werase(stdscr);
261
262         // always resize window in case terminal geometry has changed
263         wresize(content, LINES - bar_top - bar_bottom, COLS);
264
265         // setup header
266         if(bar_top) {
267             line = deck->header;
268             offset = next_blank(line->text, 0) + 1;
269             // add text to header
270             mvwaddwstr(stdscr,
271                        0, (COLS - line->length + offset) / 2,
272                        &line->text->value[offset]);
273         }
274
275         // setup footer
276         if(deck->headers > 1) {
277             line = deck->header->next;
278             offset = next_blank(line->text, 0) + 1;
279             switch(slidenum) {
280                 case 0: // add text to center footer
281                     mvwaddwstr(stdscr,
282                                LINES - 1, (COLS - line->length + offset) / 2,
283                                &line->text->value[offset]);
284                     break;
285                 case 1:
286                 case 2: // add text to left footer
287                     mvwaddwstr(stdscr,
288                                LINES - 1, 3,
289                                &line->text->value[offset]);
290                     break;
291             }
292         }
293
294         // add slide number to right footer
295         switch(slidenum) {
296             case 1: // show slide number only
297                 mvwprintw(stdscr,
298                           LINES - 1, COLS - int_length(sc) - 3,
299                           "%d", sc);
300                 break;
301             case 2: // show current slide & number of slides
302                 mvwprintw(stdscr,
303                           LINES - 1, COLS - int_length(deck->slides) - int_length(sc) - 6,
304                           "%d / %d", sc, deck->slides);
305                 break;
306         }
307
308         // make header + fooder visible
309         wrefresh(content);
310         wrefresh(stdscr);
311
312         line = slide->line;
313         l = stop = 0;
314
315         // print lines
316         while(line) {
317             add_line(content, l, (COLS - max_cols) / 2, line, max_cols, colors);
318
319             // raise stop counter if we pass a line having a stop bit
320             if(CHECK_BIT(line->bits, IS_STOP))
321                 stop++;
322
323             l += (line->length / COLS) + 1;
324             line = line->next;
325
326             // only stop here if we didn't stop here recently
327             if(stop > slide->stop)
328                 break;
329         }
330
331         // print pandoc URL references
332         // only if we already printed all lines of the current slide
333         if(!line) {
334             int i, ymax;
335             getmaxyx( content, ymax, i );
336             for (i = 0; i < url_get_amount(); i++) {
337                 mvwprintw(content, ymax - url_get_amount() - 1 + i, 3,
338                           "[%d] ", i);
339                 waddwstr(content, url_get_target(i));
340             }
341         }
342
343         // make content visible
344         wrefresh(content);
345
346         // fade in
347         if(fade)
348             fade_in(content, trans, colors, invert);
349
350         // re-enable fading after any undefined key press
351         if(COLORS == 256 && !nofade)
352             fade = true;
353
354         // wait for user input
355         c = getch();
356
357         // evaluate user input
358         i = 0;
359         switch(c) {
360
361             // show previous slide or stop bit
362             case KEY_UP:
363             case KEY_LEFT:
364             case KEY_PPAGE:
365             case 8:   // BACKSPACE (ascii)
366             case 127: // BACKSPACE (xterm)
367             case 263: // BACKSPACE (getty)
368             case 'h':
369             case 'k':
370                 if(stop > 1 || (stop == 1 && !line)) {
371                     // show current slide again
372                     // but stop one stop bit earlier
373                     slide->stop--;
374                     fade = false;
375                 } else {
376                     if(slide->prev) {
377                         // show previous slide
378                         slide = slide->prev;
379                         sc--;
380                         //stop on first bullet point always
381                         if(slide->stop > 0)
382                             slide->stop = 0;
383                     } else {
384                         // do nothing
385                         fade = false;
386                     }
387                 }
388                 break;
389
390             // show next slide or stop bit
391             case KEY_DOWN:
392             case KEY_RIGHT:
393             case KEY_NPAGE:
394             case '\n': // ENTER
395             case ' ':  // SPACE
396             case 'j':
397             case 'l':
398                 if(stop && line) {
399                     // show current slide again
400                     // but stop one stop bit later (or at end of slide)
401                     slide->stop++;
402                     fade = false;
403                 } else {
404                     if(slide->next) {
405                         // show next slide
406                         slide = slide->next;
407                         sc++;
408                     } else {
409                         // do nothing
410                         fade = false;
411                     }
412                 }
413                 break;
414
415             // show slide n
416             case '9':
417             case '8':
418             case '7':
419             case '6':
420             case '5':
421             case '4':
422             case '3':
423             case '2':
424             case '1':
425                 i = get_slide_number(c);
426                 if(i > 0 && i <= deck->slides) {
427                     while(sc != i) {
428                         // search forward
429                         if(sc < i) {
430                             if(slide->next) {
431                                 slide = slide->next;
432                                 sc++;
433                             }
434                         // search backward
435                         } else {
436                             if(slide->prev) {
437                                 slide = slide->prev;
438                                 sc--;
439                             }
440                         }
441                     }
442                 } else {
443                     // disable fading if slide n doesn't exist
444                     fade = false;
445                 }
446                 break;
447
448             // show first slide
449             case 'g':
450             case KEY_HOME:
451                 slide = deck->slide;
452                 sc = 1;
453                 break;
454
455             // show last slide
456             case 'G':
457             case KEY_END:
458                 for(i = sc; i <= deck->slides; i++) {
459                     if(slide->next) {
460                             slide = slide->next;
461                             sc++;
462                     }
463                 }
464                 break;
465
466             // reload
467             case 'r':
468                 if(noreload == 0) {
469                     // reload slide N
470                     reload = sc;
471                     slide = NULL;
472                 } else {
473                     // disable fading if reload is not possible
474                     fade = false;
475                 }
476                 break;
477
478             // quit
479             case 'q':
480                 // do not fade out on exit
481                 fade = false;
482                 // do not reload
483                 reload = 0;
484                 slide = NULL;
485                 break;
486
487             default:
488                 // disable fading on undefined key press
489                 fade = false;
490                 break;
491         }
492
493         // fade out
494         if(fade)
495             fade_out(content, trans, colors, invert);
496
497         url_purge();
498     }
499
500     // disable ncurses
501     endwin();
502
503     // free ncurses memory
504     delwin(content);
505     if(reload == 0)
506         delwin(stdscr);
507
508     // return reload indicator (0 means no reload)
509     return reload;
510 }
511
512 void add_line(WINDOW *window, int y, int x, line_t *line, int max_cols, int colors) {
513
514     if(!line->text->value) {
515         return;
516     }
517
518     int i; // increment
519     int offset = 0; // text offset
520
521     // move the cursor in position
522     wmove(window, y, x);
523
524     // IS_UNORDERED_LIST_3
525     if(CHECK_BIT(line->bits, IS_UNORDERED_LIST_3)) {
526         offset = next_nonblank(line->text, 0);
527         char prompt[13];
528         strcpy(&prompt[0], CHECK_BIT(line->bits, IS_UNORDERED_LIST_1)? " |  " : "    ");
529         strcpy(&prompt[4], CHECK_BIT(line->bits, IS_UNORDERED_LIST_2)? " |  " : "    ");
530
531         if(CHECK_BIT(line->bits, IS_UNORDERED_LIST_EXT)) {
532             strcpy(&prompt[8], line->next && CHECK_BIT(line->next->bits, IS_UNORDERED_LIST_3)? " |  " : "    ");
533         } else {
534             strcpy(&prompt[8], " +- ");
535             offset += 2;
536         }
537
538         wprintw(window,
539                 "%s", prompt);
540
541         if(!CHECK_BIT(line->bits, IS_CODE))
542             inline_display(window, &line->text->value[offset], colors);
543
544     // IS_UNORDERED_LIST_2
545     } else if(CHECK_BIT(line->bits, IS_UNORDERED_LIST_2)) {
546         offset = next_nonblank(line->text, 0);
547         char prompt[9];
548         strcpy(&prompt[0], CHECK_BIT(line->bits, IS_UNORDERED_LIST_1)? " |  " : "    ");
549
550         if(CHECK_BIT(line->bits, IS_UNORDERED_LIST_EXT)) {
551             strcpy(&prompt[4], line->next && CHECK_BIT(line->next->bits, IS_UNORDERED_LIST_2)? " |  " : "    ");
552         } else {
553             strcpy(&prompt[4], " +- ");
554             offset += 2;
555         }
556
557         wprintw(window,
558                 "%s", prompt);
559
560         if(!CHECK_BIT(line->bits, IS_CODE))
561             inline_display(window, &line->text->value[offset], colors);
562
563     // IS_UNORDERED_LIST_1
564     } else if(CHECK_BIT(line->bits, IS_UNORDERED_LIST_1)) {
565         offset = next_nonblank(line->text, 0);
566         char prompt[5];
567
568         if(CHECK_BIT(line->bits, IS_UNORDERED_LIST_EXT)) {
569             strcpy(&prompt[0], line->next && CHECK_BIT(line->next->bits, IS_UNORDERED_LIST_1)? " |  " : "    ");
570         } else {
571             strcpy(&prompt[0], " +- ");
572             offset += 2;
573         }
574
575         wprintw(window,
576                 "%s", prompt);
577
578         if(!CHECK_BIT(line->bits, IS_CODE))
579             inline_display(window, &line->text->value[offset], colors);
580     }
581
582     // IS_CODE
583     if(CHECK_BIT(line->bits, IS_CODE)) {
584
585         if (!CHECK_BIT(line->bits, IS_TILDE_CODE)) {
586             // set static offset for code
587             offset = CODE_INDENT;
588         }
589
590         // reverse color for code blocks
591         if(colors)
592             wattron(window, COLOR_PAIR(CP_BLACK));
593
594         // print whole lines
595         waddwstr(window, &line->text->value[offset]);
596     }
597
598     if(!CHECK_BIT(line->bits, IS_UNORDERED_LIST_1) &&
599        !CHECK_BIT(line->bits, IS_UNORDERED_LIST_2) &&
600        !CHECK_BIT(line->bits, IS_UNORDERED_LIST_3) &&
601        !CHECK_BIT(line->bits, IS_CODE)) {
602
603         // IS_QUOTE
604         if(CHECK_BIT(line->bits, IS_QUOTE)) {
605             while(line->text->value[offset] == '>') {
606                 // print a reverse color block
607                 if(colors) {
608                     wattron(window, COLOR_PAIR(CP_BLACK));
609                     wprintw(window, "%s", " ");
610                     wattron(window, COLOR_PAIR(CP_WHITE));
611                     wprintw(window, "%s", " ");
612                 } else {
613                     wprintw(window, "%s", ">");
614                 }
615
616                 // find next quote or break
617                 offset++;
618                 if(line->text->value[offset] == ' ')
619                     offset = next_word(line->text, offset);
620             }
621
622             inline_display(window, &line->text->value[offset], colors);
623         } else {
624
625             // IS_CENTER
626             if(CHECK_BIT(line->bits, IS_CENTER)) {
627                 if(line->length < max_cols) {
628                     wmove(window, y, x + ((max_cols - line->length) / 2));
629                 }
630             }
631
632             // IS_H1 || IS_H2
633             if(CHECK_BIT(line->bits, IS_H1) || CHECK_BIT(line->bits, IS_H2)) {
634
635                 // set headline color
636                 if(colors)
637                     wattron(window, COLOR_PAIR(CP_BLUE));
638
639                 // enable underline for H1
640                 if(CHECK_BIT(line->bits, IS_H1))
641                     wattron(window, A_UNDERLINE);
642
643                 // skip hashes
644                 while(line->text->value[offset] == '#')
645                     offset = next_word(line->text, offset);
646
647                 // print whole lines
648                 waddwstr(window, &line->text->value[offset]);
649
650                 wattroff(window, A_UNDERLINE);
651
652             // no line-wide markdown
653             } else {
654
655                 inline_display(window, &line->text->value[offset], colors);
656             }
657         }
658     }
659
660     // fill rest off line with spaces
661     // we only need this if the color is inverted (e.g. code-blocks),
662     // to ensure the background fades too
663     if(CHECK_BIT(line->bits, IS_CODE))
664         for(i = getcurx(window) - x; i < max_cols; i++)
665             wprintw(window, "%s", " ");
666
667     // reset to default color
668     if(colors)
669         wattron(window, COLOR_PAIR(CP_WHITE));
670     wattroff(window, A_UNDERLINE);
671 }
672
673 void inline_display(WINDOW *window, const wchar_t *c, const int colors) {
674     const static wchar_t *special = L"\\*_`!["; // list of interpreted chars
675     const wchar_t *i = c; // iterator
676     const wchar_t *start_link_name, *start_url;
677     int length_link_name, url_num;
678     cstack_t *stack = cstack_init();
679
680
681     // for each char in line
682     for(; *i; i++) {
683
684         // if char is in special char list
685         if(wcschr(special, *i)) {
686
687             // closing special char (or second backslash)
688             // only if not followed by :alnum:
689             if((stack->top)(stack, *i) &&
690                (!iswalnum(i[1]) || *(i + 1) == L'\0' || *i == L'\\')) {
691
692                 switch(*i) {
693                     // print escaped backslash
694                     case L'\\':
695                         waddnwstr(window, i, 1);
696                         break;
697                     // disable highlight
698                     case L'*':
699                         if(colors)
700                             wattron(window, COLOR_PAIR(CP_WHITE));
701                         break;
702                     // disable underline
703                     case L'_':
704                         wattroff(window, A_UNDERLINE);
705                         break;
706                     // disable inline code
707                     case L'`':
708                         if(colors)
709                             wattron(window, COLOR_PAIR(CP_WHITE));
710                         break;
711                 }
712
713                 // remove top special char from stack
714                 (stack->pop)(stack);
715
716             // treat special as regular char
717             } else if((stack->top)(stack, L'\\')) {
718                 waddnwstr(window, i, 1);
719
720                 // remove backslash from stack
721                 (stack->pop)(stack);
722
723             // opening special char
724             } else {
725
726                 // emphasis or code span can start after new-line or space only
727                 // and of cause after another emphasis markup
728                 //TODO this condition looks ugly
729                 if(i == c ||
730                    iswspace(*(i - 1)) ||
731                    ((iswspace(*(i - 1)) || *(i - 1) == L'*' || *(i - 1) == L'_') &&
732                     ((i - 1) == c || iswspace(*(i - 2)))) ||
733                    *i == L'\\') {
734
735                     // url in pandoc style
736                     if ((*i == L'[' && wcschr(i, L']')) ||
737                         (*i == L'!' && *(i + 1) == L'[' && wcschr(i, L']'))) {
738
739                         if (*i == L'!') i++;
740
741                         if (wcschr(i, L']')[1] == L'(' && wcschr(i, L')')) {
742                             i++;
743
744                             // turn higlighting and underlining on
745                             if (colors)
746                                 wattron(window, COLOR_PAIR(CP_BLUE));
747                             wattron(window, A_UNDERLINE);
748
749                             start_link_name = i;
750
751                             // print the content of the label
752                             // the label is printed as is
753                             do {
754                                 waddnwstr(window, i, 1);
755                                 i++;
756                             } while (*i != L']');
757
758                             length_link_name = i - 1 - start_link_name;
759
760                             i++;
761                             i++;
762
763                             start_url = i;
764
765                             while (*i != L')') i++;
766
767                             url_num = url_add(start_link_name, length_link_name, start_url, i - start_url, 0, 0);
768
769                             wprintw(window, " [%d]", url_num);
770
771                             // turn highlighting and underlining off
772                             wattroff(window, A_UNDERLINE);
773                             wattron(window, COLOR_PAIR(CP_WHITE));
774
775                         } else {
776                             wprintw(window, "[");
777                         }
778
779                     } else switch(*i) {
780                         // enable highlight
781                         case L'*':
782                             if(colors)
783                                 wattron(window, COLOR_PAIR(CP_RED));
784                             break;
785                         // enable underline
786                         case L'_':
787                             wattron(window, A_UNDERLINE);
788                             break;
789                         // enable inline code
790                         case L'`':
791                             if(colors)
792                                 wattron(window, COLOR_PAIR(CP_BLACK));
793                             break;
794                         // do nothing for backslashes
795                     }
796
797                     // push special char to stack
798                     (stack->push)(stack, *i);
799
800                 } else {
801                     waddnwstr(window, i, 1);
802                 }
803             }
804
805         } else {
806             // remove backslash from stack
807             if((stack->top)(stack, L'\\'))
808                 (stack->pop)(stack);
809
810             // print regular char
811             waddnwstr(window, i, 1);
812         }
813     }
814
815     // pop stack until empty to prevent formated trailing spaces
816     while(!(stack->empty)(stack)) {
817         switch((stack->pop)(stack)) {
818             // disable highlight
819             case L'*':
820                 if(colors)
821                     wattron(window, COLOR_PAIR(CP_WHITE));
822                 break;
823             // disable underline
824             case L'_':
825                 wattroff(window, A_UNDERLINE);
826                 break;
827             // disable inline code
828             case L'`':
829                 if(colors)
830                     wattron(window, COLOR_PAIR(CP_WHITE));
831                 break;
832             // do nothing for backslashes
833         }
834     }
835
836     (stack->delete)(stack);
837 }
838
839 void fade_out(WINDOW *window, int trans, int colors, int invert) {
840     int i; // increment
841     if(colors && COLORS == 256) {
842         for(i = 22; i >= 0; i--) {
843
844             // dim color pairs
845             if(invert) {
846                 init_pair(CP_WHITE, white_ramp_invert[i], trans);
847                 init_pair(CP_BLUE, blue_ramp_invert[i], trans);
848                 init_pair(CP_RED, red_ramp_invert[i], trans);
849                 init_pair(CP_BLACK, 15, white_ramp_invert[i]);
850             } else {
851                 init_pair(CP_WHITE, white_ramp[i], trans);
852                 init_pair(CP_BLUE, blue_ramp[i], trans);
853                 init_pair(CP_RED, red_ramp[i], trans);
854                 init_pair(CP_BLACK, 16, white_ramp[i]);
855             }
856
857             // refresh window with new color
858             wrefresh(window);
859
860             // delay for our eyes to recognize the change
861             usleep(FADE_DELAY);
862         }
863     }
864 }
865
866 void fade_in(WINDOW *window, int trans, int colors, int invert) {
867     int i; // increment
868     if(colors && COLORS == 256) {
869         for(i = 0; i <= 23; i++) {
870
871             // brighten color pairs
872             if(invert) {
873                 init_pair(CP_WHITE, white_ramp_invert[i], trans);
874                 init_pair(CP_BLUE, blue_ramp_invert[i], trans);
875                 init_pair(CP_RED, red_ramp_invert[i], trans);
876                 init_pair(CP_BLACK, 15, white_ramp_invert[i]);
877             } else {
878                 init_pair(CP_WHITE, white_ramp[i], trans);
879                 init_pair(CP_BLUE, blue_ramp[i], trans);
880                 init_pair(CP_RED, red_ramp[i], trans);
881                 init_pair(CP_BLACK, 16, white_ramp[i]);
882             }
883
884             // refresh window with new color
885             wrefresh(window);
886
887             // delay for our eyes to recognize the change
888             usleep(FADE_DELAY);
889         }
890     }
891 }
892
893 int int_length (int val) {
894     int l = 1;
895     while(val > 9) {
896         l++;
897         val /= 10;
898     }
899     return l;
900 }
901
902 int get_slide_number(char init) {
903     int retval = init - '0';
904     char c;
905     // block for tenths of a second when using getch, ERR if no input
906     halfdelay(GOTO_SLIDE_DELAY);
907     while((c = getch()) != ERR) {
908         if (c < '0' || c > '9') {
909             retval = -1;
910             break;
911         }
912         retval = (retval * 10) + (c - '0');
913     }
914     nocbreak();     // cancel half delay mode
915     cbreak();       // go back to cbreak
916     return retval;
917 }