fixed header/bottom bar color for cygwin
[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) 2014 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 <locale.h> // setlocale
26 #include <string.h> // strchr
27 #include <unistd.h> // usleep
28
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) {
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
77     // header line 1 is displayed at the top
78     int bar_top = (deck->headers > 0) ? 1 : 0;
79     // header line 2 is displayed at the bottom
80     // anyway we display the slide number at the bottom
81     int bar_bottom = 1;
82
83     slide_t *slide = deck->slide;
84     line_t *line;
85
86     // set locale to display UTF-8 correctly in ncurses
87     setlocale(LC_CTYPE, "");
88
89     // init ncurses
90     initscr();
91
92     while(slide) {
93         lc = 0;
94         line = slide->line;
95
96         while(line) {
97             if(line->length > COLS) {
98                 i = line->length;
99                 offset = 0;
100                 while(i > COLS) {
101
102                     i = prev_blank(line->text, offset + COLS) - offset;
103
104                     // single word is > COLS
105                     if(!i) {
106                         // calculate min_width
107                         i = next_blank(line->text, offset + COLS) - offset;
108
109                         // disable ncurses
110                         endwin();
111
112                         // print error
113                         fprintf(stderr, "Error: Terminal width (%i columns) too small. Need at least %i columns.\n", COLS, i);
114                         fprintf(stderr, "You may need to shorten some lines by inserting line breaks.\n");
115
116                         return 1;
117                     }
118
119                     // set max_cols
120                     max_cols = MAX(i, max_cols);
121
122                     // iterate to next line
123                     offset = prev_blank(line->text, offset + COLS);
124                     i = line->length - offset;
125                     lc++;
126                 }
127                 // set max_cols one last time
128                 max_cols = MAX(i, max_cols);
129             } else {
130                 // set max_cols
131                 max_cols = MAX(line->length, max_cols);
132             }
133             lc++;
134             line = line->next;
135         }
136
137         max_lines = MAX(lc, max_lines);
138
139         slide = slide->next;
140     }
141
142     // not enough lines
143     if(max_lines + bar_top + bar_bottom > LINES) {
144
145         // disable ncurses
146         endwin();
147
148         // print error
149         fprintf(stderr, "Error: Terminal height (%i lines) too small. Need at least %i lines.\n", LINES, max_lines + bar_top + bar_bottom);
150         fprintf(stderr, "You may need to add additional horizontal rules ('***') to split your file in shorter slides.\n");
151
152         return 1;
153     }
154
155     // disable cursor
156     curs_set(0);
157
158     // disable output of keyboard typing
159     noecho();
160
161     // make getch() process one char at a time
162     cbreak();
163
164     // enable arrow keys
165     keypad(stdscr,TRUE);
166
167     // set colors
168     if(has_colors() == TRUE) {
169         start_color();
170         use_default_colors();
171
172         // 256 color mode
173         if(COLORS == 256) {
174
175             if(notrans) {
176                 if(invert) {
177                     trans = 15; // white in 256 color mode
178                 } else {
179                     trans = 16; // black in 256 color mode
180                 }
181             }
182
183             if(invert) {
184                 init_pair(CP_WHITE, 232, trans);
185                 init_pair(CP_BLUE, 21, trans);
186                 init_pair(CP_RED, 196, trans);
187                 init_pair(CP_BLACK, 15, 232);
188             } else {
189                 init_pair(CP_WHITE, 255, trans);
190                 init_pair(CP_BLUE, 123, trans);
191                 init_pair(CP_RED, 213, trans);
192                 init_pair(CP_BLACK, 16, 255);
193             }
194             init_pair(CP_YELLOW, 208, trans);
195
196             // enable color fading
197             if(!nofade)
198                 fade = true;
199
200         // 8 color mode
201         } else {
202
203             if(notrans) {
204                 if(invert) {
205                     trans = 7; // white in 8 color mode
206                 } else {
207                     trans = 0; // black in 8 color mode
208                 }
209             }
210
211             if(invert) {
212                 init_pair(CP_WHITE, 0, trans);
213                 init_pair(CP_BLACK, 7, 0);
214             } else {
215                 init_pair(CP_WHITE, 7, trans);
216                 init_pair(CP_BLACK, 0, 7);
217             }
218             init_pair(CP_BLUE, 4, trans);
219             init_pair(CP_RED, 1, trans);
220             init_pair(CP_YELLOW, 3, trans);
221         }
222
223         colors = 1;
224     }
225
226     // set background color of main window
227     if(colors)
228         wbkgd(stdscr, COLOR_PAIR(CP_YELLOW));
229
230     // setup main window
231     WINDOW *content = newwin(LINES - bar_top - bar_bottom, COLS, 0 + bar_top, 0);
232     if(colors)
233         wbkgd(content, COLOR_PAIR(CP_WHITE));
234
235     slide = deck->slide;
236     while(slide) {
237         // clear windows
238         werase(content);
239         werase(stdscr);
240
241         // always resize window in case terminal geometry has changed
242         wresize(content, LINES - bar_top - bar_bottom, COLS);
243
244         // setup header
245         if(bar_top) {
246             line = deck->header;
247             offset = next_blank(line->text, 0) + 1;
248             // add text to header
249             mvwprintw(stdscr,
250                       0, (COLS - line->length + offset) / 2,
251                       "%s", &line->text->text[offset]);
252         }
253
254         // setup footer
255         if(deck->headers > 1) {
256             line = deck->header->next;
257             offset = next_blank(line->text, 0) + 1;
258             // add text to left footer
259             mvwprintw(stdscr,
260                       LINES - 1, 3,
261                       "%s", &line->text->text[offset]);
262         }
263         // add slide number to right footer
264         mvwprintw(stdscr,
265                   LINES - 1, COLS - int_length(deck->slides) - int_length(sc) - 6,
266                   "%d / %d", sc, deck->slides);
267
268         // make header + fooder visible
269         wrefresh(content);
270         wrefresh(stdscr);
271
272         line = slide->line;
273         l = 0;
274
275         // print lines
276         while(line) {
277             add_line(content, l, (COLS - max_cols) / 2, line, max_cols, colors);
278             l += (line->length / COLS) + 1;
279             line = line->next;
280         }
281
282         // make content visible
283         wrefresh(content);
284
285         // fade in
286         if(fade)
287             fade_in(content, trans, colors, invert);
288
289         // re-enable fading after any undefined key press
290         if(COLORS == 256 && !nofade)
291             fade = true;
292
293         // wait for user input
294         c = getch();
295
296         // evaluate user input
297         i = 0;
298         switch(c) {
299
300             // show previous slide
301             case KEY_UP:
302             case KEY_LEFT:
303             case KEY_PPAGE:
304             case 8:   // BACKSPACE (ascii)
305             case 127: // BACKSPACE (xterm)
306             case 263: // BACKSPACE (getty)
307             case 'h':
308             case 'k':
309                 if(slide->prev) {
310                     slide = slide->prev;
311                     sc--;
312                 } else {
313                     fade = false;
314                 }
315                 break;
316
317             // show next slide
318             case KEY_DOWN:
319             case KEY_RIGHT:
320             case KEY_NPAGE:
321             case '\n': // ENTER
322             case ' ':  // SPACE
323             case 'j':
324             case 'l':
325                 if(slide->next) {
326                     slide = slide->next;
327                     sc++;
328                 } else {
329                     fade = false;
330                 }
331                 break;
332
333             // show slide n
334             case '9': i++;
335             case '8': i++;
336             case '7': i++;
337             case '6': i++;
338             case '5': i++;
339             case '4': i++;
340             case '3': i++;
341             case '2': i++;
342             case '1': i++;
343                 if(i <= deck->slides) {
344                     while(sc != i) {
345                         // search forward
346                         if(sc < i) {
347                             if(slide->next) {
348                                 slide = slide->next;
349                                 sc++;
350                             }
351                         // search backward
352                         } else {
353                             if(slide->prev) {
354                                 slide = slide->prev;
355                                 sc--;
356                             }
357                         }
358                     }
359                 } else {
360                     // disable fading if slide n doesn't exist
361                     fade = false;
362                 }
363                 break;
364
365             // show first slide
366             case KEY_HOME:
367                 slide = deck->slide;
368                 sc = 1;
369                 break;
370
371             // show last slide
372             case KEY_END:
373                 for(i = sc; i <= deck->slides; i++) {
374                     if(slide->next) {
375                             slide = slide->next;
376                             sc++;
377                     }
378                 }
379                 break;
380
381             // quit
382             case 'q':
383                 // do not fade out on exit
384                 fade = false;
385                 slide = NULL;
386                 break;
387
388             default:
389                 // disable fading on undefined key press
390                 fade = false;
391                 break;
392         }
393
394         // fade out
395         if(fade)
396             fade_out(content, trans, colors, invert);
397     }
398
399     endwin();
400
401     return 0;
402 }
403
404 void add_line(WINDOW *window, int y, int x, line_t *line, int max_cols, int colors) {
405
406     if(!line->text->text) {
407         return;
408     }
409
410     int i; // increment
411     int offset = 0; // text offset
412
413     // move the cursor in position
414     wmove(window, y, x);
415
416     // IS_UNORDERED_LIST_3
417     if(CHECK_BIT(line->bits, IS_UNORDERED_LIST_3)) {
418         offset = next_nonblank(line->text, 0);
419         char prompt[13];
420         strcpy(&prompt[0], CHECK_BIT(line->bits, IS_UNORDERED_LIST_1)? " |  " : "    ");
421         strcpy(&prompt[4], CHECK_BIT(line->bits, IS_UNORDERED_LIST_2)? " |  " : "    ");
422
423         if(CHECK_BIT(line->bits, IS_UNORDERED_LIST_EXT)) {
424             strcpy(&prompt[8], line->next && CHECK_BIT(line->next->bits, IS_UNORDERED_LIST_3)? " |  " : "    ");
425         } else {
426             strcpy(&prompt[8], " +- ");
427             offset += 2;
428         }
429
430         wprintw(window,
431                 "%s", prompt);
432
433         if(!CHECK_BIT(line->bits, IS_CODE))
434             inline_display(window, &line->text->text[offset], colors);
435
436     // IS_UNORDERED_LIST_2
437     } else if(CHECK_BIT(line->bits, IS_UNORDERED_LIST_2)) {
438         offset = next_nonblank(line->text, 0);
439         char prompt[9];
440         strcpy(&prompt[0], CHECK_BIT(line->bits, IS_UNORDERED_LIST_1)? " |  " : "    ");
441
442         if(CHECK_BIT(line->bits, IS_UNORDERED_LIST_EXT)) {
443             strcpy(&prompt[4], line->next && CHECK_BIT(line->next->bits, IS_UNORDERED_LIST_2)? " |  " : "    ");
444         } else {
445             strcpy(&prompt[4], " +- ");
446             offset += 2;
447         }
448
449         wprintw(window,
450                 "%s", prompt);
451
452         if(!CHECK_BIT(line->bits, IS_CODE))
453             inline_display(window, &line->text->text[offset], colors);
454
455     // IS_UNORDERED_LIST_1
456     } else if(CHECK_BIT(line->bits, IS_UNORDERED_LIST_1)) {
457         offset = next_nonblank(line->text, 0);
458         char prompt[5];
459
460         if(CHECK_BIT(line->bits, IS_UNORDERED_LIST_EXT)) {
461             strcpy(&prompt[0], line->next && CHECK_BIT(line->next->bits, IS_UNORDERED_LIST_1)? " |  " : "    ");
462         } else {
463             strcpy(&prompt[0], " +- ");
464             offset += 2;
465         }
466
467         wprintw(window,
468                 "%s", prompt);
469
470         if(!CHECK_BIT(line->bits, IS_CODE))
471             inline_display(window, &line->text->text[offset], colors);
472     }
473
474     // IS_CODE
475     if(CHECK_BIT(line->bits, IS_CODE)) {
476
477         // set static offset for code
478         offset = CODE_INDENT;
479
480         // reverse color for code blocks
481         if(colors)
482             wattron(window, COLOR_PAIR(CP_BLACK));
483
484         // print whole lines
485         wprintw(window,
486                 "%s", &line->text->text[offset]);
487     }
488
489     if(!CHECK_BIT(line->bits, IS_UNORDERED_LIST_1) &&
490        !CHECK_BIT(line->bits, IS_UNORDERED_LIST_2) &&
491        !CHECK_BIT(line->bits, IS_UNORDERED_LIST_3) &&
492        !CHECK_BIT(line->bits, IS_CODE)) {
493
494         // IS_QUOTE
495         if(CHECK_BIT(line->bits, IS_QUOTE)) {
496             while(line->text->text[offset] == '>') {
497                 // print a reverse color block
498                 if(colors) {
499                     wattron(window, COLOR_PAIR(CP_BLACK));
500                     wprintw(window, "%s", " ");
501                     wattron(window, COLOR_PAIR(CP_WHITE));
502                     wprintw(window, "%s", " ");
503                 } else {
504                     wprintw(window, "%s", ">");
505                 }
506
507                 // find next quote or break
508                 offset++;
509                 if(line->text->text[offset] == ' ')
510                     offset = next_word(line->text, offset);
511             }
512
513             inline_display(window, &line->text->text[offset], colors);
514         } else {
515
516             // IS_CENTER
517             if(CHECK_BIT(line->bits, IS_CENTER)) {
518                 if(line->length < max_cols) {
519                     wmove(window, y, x + ((max_cols - line->length) / 2));
520                 }
521             }
522
523             // IS_H1 || IS_H2
524             if(CHECK_BIT(line->bits, IS_H1) || CHECK_BIT(line->bits, IS_H2)) {
525
526                 // set headline color
527                 if(colors)
528                     wattron(window, COLOR_PAIR(CP_BLUE));
529
530                 // enable underline for H1
531                 if(CHECK_BIT(line->bits, IS_H1))
532                     wattron(window, A_UNDERLINE);
533
534                 // skip hashes
535                 while(line->text->text[offset] == '#')
536                     offset = next_word(line->text, offset);
537
538                 // print whole lines
539                 wprintw(window,
540                         "%s", &line->text->text[offset]);
541
542                 wattroff(window, A_UNDERLINE);
543
544             // no line-wide markdown
545             } else {
546
547                 inline_display(window, &line->text->text[offset], colors);
548             }
549         }
550     }
551
552     // fill rest off line with spaces
553     for(i = getcurx(window) - x; i < max_cols; i++)
554         wprintw(window, "%s", " ");
555
556     // reset to default color
557     if(colors)
558         wattron(window, COLOR_PAIR(CP_WHITE));
559     wattroff(window, A_UNDERLINE);
560 }
561
562 void inline_display(WINDOW *window, const char *c, const int colors) {
563     const static char *special = "\\*_`"; // list of interpreted chars
564     const char *i = c; // iterator
565     cstack_t *stack = cstack_init();
566
567
568     // for each char in line
569     for(; *i; i++) {
570
571         // if char is in special char list
572         if(strchr(special, *i)) {
573
574             // closing special char (or second backslash)
575             // only if not followed by :alnum:
576             if((stack->top)(stack, *i) &&
577                (!isalnum((int)i[1]) || *(i + 1) == '\0' || *i == '\\')) {
578
579                 switch(*i) {
580                     // print escaped backslash
581                     case '\\':
582                         wprintw(window, "%c", *i);
583                         break;
584                     // disable highlight
585                     case '*':
586                         if(colors)
587                             wattron(window, COLOR_PAIR(CP_WHITE));
588                         break;
589                     // disable underline
590                     case '_':
591                         wattroff(window, A_UNDERLINE);
592                         break;
593                     // disable inline code
594                     case '`':
595                         if(colors)
596                             wattron(window, COLOR_PAIR(CP_WHITE));
597                         break;
598                 }
599
600                 // remove top special char from stack
601                 (stack->pop)(stack);
602
603             // treat special as regular char
604             } else if((stack->top)(stack, '\\')) {
605                 wprintw(window, "%c", *i);
606
607                 // remove backslash from stack
608                 (stack->pop)(stack);
609
610             // opening special char
611             } else {
612
613                 // emphasis or code span can start after new-line or space only
614                 // and of cause after another emphasis markup
615                 if(*(i - 1) == ' ' ||
616                    ((*(i - 1) == '_' || *(i - 1) == '*') && (*(i - 2) == ' ' || (i - 1) == c)) ||
617                    *i == '\\' ||
618                    i == c) {
619
620                     switch(*i) {
621                         // enable highlight
622                         case '*':
623                             if(colors)
624                                 wattron(window, COLOR_PAIR(CP_RED));
625                             break;
626                         // enable underline
627                         case '_':
628                             wattron(window, A_UNDERLINE);
629                             break;
630                         // enable inline code
631                         case '`':
632                             if(colors)
633                                 wattron(window, COLOR_PAIR(CP_BLACK));
634                             break;
635                         // do nothing for backslashes
636                     }
637
638                     // push special char to stack
639                     (stack->push)(stack, *i);
640
641                 } else {
642                     wprintw(window, "%c", *i);
643                 }
644             }
645
646         } else {
647             // remove backslash from stack
648             if((stack->top)(stack, '\\'))
649                 (stack->pop)(stack);
650
651             // print regular char
652             wprintw(window, "%c", *i);
653         }
654     }
655
656     // pop stack until empty to prevent formated trailing spaces
657     while(!(stack->empty)(stack)) {
658         switch((stack->pop)(stack)) {
659             // disable highlight
660             case '*':
661                 if(colors)
662                     wattron(window, COLOR_PAIR(CP_WHITE));
663                 break;
664             // disable underline
665             case '_':
666                 wattroff(window, A_UNDERLINE);
667                 break;
668             // disable inline code
669             case '`':
670                 if(colors)
671                     wattron(window, COLOR_PAIR(CP_WHITE));
672                 break;
673             // do nothing for backslashes
674         }
675     }
676
677     (stack->delete)(stack);
678 }
679
680 void fade_out(WINDOW *window, int trans, int colors, int invert) {
681     int i; // increment
682     if(colors && COLORS == 256) {
683         for(i = 22; i >= 0; i--) {
684
685             // dim color pairs
686             if(invert) {
687                 init_pair(CP_WHITE, white_ramp_invert[i], trans);
688                 init_pair(CP_BLUE, blue_ramp_invert[i], trans);
689                 init_pair(CP_RED, red_ramp_invert[i], trans);
690                 init_pair(CP_BLACK, 15, white_ramp_invert[i]);
691             } else {
692                 init_pair(CP_WHITE, white_ramp[i], trans);
693                 init_pair(CP_BLUE, blue_ramp[i], trans);
694                 init_pair(CP_RED, red_ramp[i], trans);
695                 init_pair(CP_BLACK, 16, white_ramp[i]);
696             }
697
698             // refresh window with new color
699             wrefresh(window);
700
701             // delay for our eyes to recognize the change
702             usleep(FADE_DELAY);
703         }
704     }
705 }
706
707 void fade_in(WINDOW *window, int trans, int colors, int invert) {
708     int i; // increment
709     if(colors && COLORS == 256) {
710         for(i = 0; i <= 23; i++) {
711
712             // brighten color pairs
713             if(invert) {
714                 init_pair(CP_WHITE, white_ramp_invert[i], trans);
715                 init_pair(CP_BLUE, blue_ramp_invert[i], trans);
716                 init_pair(CP_RED, red_ramp_invert[i], trans);
717                 init_pair(CP_BLACK, 15, white_ramp_invert[i]);
718             } else {
719                 init_pair(CP_WHITE, white_ramp[i], trans);
720                 init_pair(CP_BLUE, blue_ramp[i], trans);
721                 init_pair(CP_RED, red_ramp[i], trans);
722                 init_pair(CP_BLACK, 16, white_ramp[i]);
723             }
724
725             // refresh window with new color
726             wrefresh(window);
727
728             // delay for our eyes to recognize the change
729             usleep(FADE_DELAY);
730         }
731     }
732 }
733
734 int int_length (int val) {
735     int l = 1;
736     while(val > 9) {
737         l++;
738         val /= 10;
739     }
740     return l;
741 }