src/terminal/draw.c

   1 /* Public terminal drawing API. Frontend for the screen image in memory. */
   2 /* $Id: draw.c,v 1.109 2005/06/15 18:45:00 jonas Exp $ */
   3
   4 #ifdef HAVE_CONFIG_H
   5 #include "config.h"
   6 #endif
   7
   8 #include "elinks.h"
   9
  10 #include "config/options.h"
  11 #include "terminal/color.h"
  12 #include "terminal/draw.h"
  13 #include "terminal/screen.h"
  14 #include "terminal/terminal.h"
  15 #include "util/color.h"
  16 #include "util/box.h"
  17
  18 /* Makes sure that @x and @y are within the dimensions of the terminal. */
  19 #define check_range(term, x, y) \
  20         do { \
  21                 int_bounds(&(x), 0, (term)->width - 1); \
  22                 int_bounds(&(y), 0, (term)->height - 1); \
  23         } while (0)
  24
  25 #if defined(CONFIG_88_COLORS) || defined(CONFIG_256_COLORS)
  26 #define clear_screen_char_color(schar) do { memset((schar)->color, 0, 2); } while (0)
  27 #else
  28 #define clear_screen_char_color(schar) do { (schar)->color[0] = 0; } while (0)
  29 #endif
  30
  31
  32
  33 inline struct screen_char *
  34 get_char(struct terminal *term, int x, int y)
  35 {
  36         assert(term && term->screen && term->screen->image);
  37         if_assert_failed return NULL;
  38         check_range(term, x, y);
  39
  40         return &term->screen->image[x + term->width * y];
  41 }
  42
  43 void
  44 draw_border_cross(struct terminal *term, int x, int y,
  45                   enum border_cross_direction dir, struct color_pair *color)
  46 {
  47         static unsigned char border_trans[2][4] = {
  48                 /* Used for BORDER_X_{RIGHT,LEFT}: */
  49                 { BORDER_SVLINE, BORDER_SRTEE, BORDER_SLTEE },
  50                 /* Used for BORDER_X_{DOWN,UP}: */
  51                 { BORDER_SHLINE, BORDER_SDTEE, BORDER_SUTEE },
  52         };
  53         struct screen_char *screen_char = get_char(term, x, y);
  54         unsigned int d;
  55
  56         if (!screen_char) return;
  57         if (!(screen_char->attr & SCREEN_ATTR_FRAME)) return;
  58
  59         /* First check if there is already a horizontal/vertical line, so that
  60          * we will have to replace with a T char. Example: if there is a '|'
  61          * and the direction is right, replace with a '|-' T char.
  62          *
  63          * If this is not the case check if there is a T char and we are adding
  64          * the direction so that we end up with a cross. Example : if there is
  65          * a '|-' and the direction is left, replace with a '+' (cross) char. */
  66         d = dir>>1;
  67         if (screen_char->data == border_trans[d][0]) {
  68                 screen_char->data = border_trans[d][1 + (dir & 1)];
  69
  70         } else if (screen_char->data == border_trans[d][2 - (dir & 1)]) {
  71                 screen_char->data = BORDER_SCROSS;
  72         }
  73
  74         set_term_color(screen_char, color, 0,
  75                        get_opt_int_tree(term->spec, "colors"));
  76 }
  77
  78 void
  79 draw_border_char(struct terminal *term, int x, int y,
  80                  enum border_char border, struct color_pair *color)
  81 {
  82         struct screen_char *screen_char = get_char(term, x, y);
  83
  84         if (!screen_char) return;
  85
  86         screen_char->data = (unsigned char) border;
  87         screen_char->attr = SCREEN_ATTR_FRAME;
  88         set_term_color(screen_char, color, 0,
  89                        get_opt_int_tree(term->spec, "colors"));
  90         set_screen_dirty(term->screen, y, y);
  91 }
  92
  93 void
  94 draw_char_color(struct terminal *term, int x, int y, struct color_pair *color)
  95 {
  96         struct screen_char *screen_char = get_char(term, x, y);
  97
  98         if (!screen_char) return;
  99
 100         set_term_color(screen_char, color, 0,
 101                        get_opt_int_tree(term->spec, "colors"));
 102         set_screen_dirty(term->screen, y, y);
 103 }
 104
 105 void
 106 draw_char_data(struct terminal *term, int x, int y, unsigned char data)
 107 {
 108         struct screen_char *screen_char = get_char(term, x, y);
 109
 110         if (!screen_char) return;
 111
 112         screen_char->data = data;
 113         set_screen_dirty(term->screen, y, y);
 114 }
 115
 116 /* Updates a line in the terms screen. */
 117 /* When doing frame drawing @x can be different than 0. */
 118 void
 119 draw_line(struct terminal *term, int x, int y, int l, struct screen_char *line)
 120 {
 121         struct screen_char *screen_char = get_char(term, x, y);
 122         int size;
 123
 124         assert(line);
 125         if_assert_failed return;
 126         if (!screen_char) return;
 127
 128         size = int_min(l, term->width - x);
 129         if (size == 0) return;
 130
 131         copy_screen_chars(screen_char, line, size);
 132         set_screen_dirty(term->screen, y, y);
 133 }
 134
 135 void
 136 draw_border(struct terminal *term, struct box *box,
 137             struct color_pair *color, int width)
 138 {
 139         static enum border_char p1[] = {
 140                 BORDER_SULCORNER,
 141                 BORDER_SURCORNER,
 142                 BORDER_SDLCORNER,
 143                 BORDER_SDRCORNER,
 144                 BORDER_SVLINE,
 145                 BORDER_SHLINE,
 146         };
 147         static enum border_char p2[] = {
 148                 BORDER_DULCORNER,
 149                 BORDER_DURCORNER,
 150                 BORDER_DDLCORNER,
 151                 BORDER_DDRCORNER,
 152                 BORDER_DVLINE,
 153                 BORDER_DHLINE,
 154         };
 155         enum border_char *p = (width > 1) ? p2 : p1;
 156         struct box borderbox;
 157
 158         set_box(&borderbox, box->x - 1, box->y - 1,
 159                 box->width + 2, box->height + 2);
 160
 161         if (borderbox.width > 2) {
 162                 struct box bbox;
 163
 164                 /* Horizontal top border */
 165                 set_box(&bbox, box->x, borderbox.y, box->width, 1);
 166                 draw_box(term, &bbox, p[5], SCREEN_ATTR_FRAME, color);
 167
 168                 /* Horizontal bottom border */
 169                 bbox.y += borderbox.height - 1;
 170                 draw_box(term, &bbox, p[5], SCREEN_ATTR_FRAME, color);
 171         }
 172
 173         if (borderbox.height > 2) {
 174                 struct box bbox;
 175
 176                 /* Vertical left border */
 177                 set_box(&bbox, borderbox.x, box->y, 1, box->height);
 178                 draw_box(term, &bbox, p[4], SCREEN_ATTR_FRAME, color);
 179
 180                 /* Vertical right border */
 181                 bbox.x += borderbox.width - 1;
 182                 draw_box(term, &bbox, p[4], SCREEN_ATTR_FRAME, color);
 183         }
 184
 185         if (borderbox.width > 1 && borderbox.height > 1) {
 186                 int right = borderbox.x + borderbox.width - 1;
 187                 int bottom = borderbox.y + borderbox.height - 1;
 188
 189                 /* Upper left corner */
 190                 draw_border_char(term, borderbox.x, borderbox.y, p[0], color);
 191                 /* Upper right corner */
 192                 draw_border_char(term, right, borderbox.y, p[1], color);
 193                 /* Lower left corner */
 194                 draw_border_char(term, borderbox.x, bottom, p[2], color);
 195                 /* Lower right corner */
 196                 draw_border_char(term, right, bottom, p[3], color);
 197         }
 198
 199         set_screen_dirty(term->screen, borderbox.y, borderbox.y + borderbox.height);
 200 }
 201
 202 void
 203 draw_char(struct terminal *term, int x, int y,
 204           unsigned char data, enum screen_char_attr attr,
 205           struct color_pair *color)
 206 {
 207         struct screen_char *screen_char = get_char(term, x, y);
 208
 209         if (!screen_char) return;
 210
 211         screen_char->data = data;
 212         screen_char->attr = attr;
 213         set_term_color(screen_char, color, 0,
 214                        get_opt_int_tree(term->spec, "colors"));
 215
 216         set_screen_dirty(term->screen, y, y);
 217 }
 218
 219 void
 220 draw_box(struct terminal *term, struct box *box,
 221          unsigned char data, enum screen_char_attr attr,
 222          struct color_pair *color)
 223 {
 224         struct screen_char *line, *pos, *end;
 225         int width, height;
 226
 227         line = get_char(term, box->x, box->y);
 228         if (!line) return;
 229
 230         height = int_min(box->height, term->height - box->y);
 231         width = int_min(box->width, term->width - box->x);
 232
 233         if (height <= 0 || width <= 0) return;
 234
 235         /* Compose off the ending screen position in the areas first line. */
 236         end = &line[width - 1];
 237         end->attr = attr;
 238         end->data = data;
 239         if (color) {
 240                 set_term_color(end, color, 0,
 241                                get_opt_int_tree(term->spec, "colors"));
 242         } else {
 243                 clear_screen_char_color(end);
 244         }
 245
 246         /* Draw the first area line. */
 247         for (pos = line; pos < end; pos++) {
 248                 copy_screen_chars(pos, end, 1);
 249         }
 250
 251         /* Now make @end point to the last line */
 252         /* For the rest of the area use the first area line. */
 253         pos = line;
 254         while (--height) {
 255                 pos += term->width;
 256                 copy_screen_chars(pos, line, width);
 257         }
 258
 259         set_screen_dirty(term->screen, box->y, box->y + box->height);
 260 }
 261
 262 void
 263 draw_shadow(struct terminal *term, struct box *box,
 264             struct color_pair *color, int width, int height)
 265 {
 266         struct box dbox;
 267
 268         /* (horizontal) */
 269         set_box(&dbox, box->x + width, box->y + box->height,
 270                 box->width - width, height);
 271
 272         draw_box(term, &dbox, ' ', 0, color);
 273
 274         /* (vertical) */
 275         set_box(&dbox, box->x + box->width, box->y + height,
 276                 width, box->height);
 277
 278         draw_box(term, &dbox, ' ', 0, color);
 279 }
 280
 281 void
 282 draw_text(struct terminal *term, int x, int y,
 283           unsigned char *text, int length,
 284           enum screen_char_attr attr, struct color_pair *color)
 285 {
 286         int end_pos;
 287         struct screen_char *pos, *end;
 288
 289         assert(text && length >= 0);
 290         if_assert_failed return;
 291
 292         if (length <= 0) return;
 293         pos = get_char(term, x, y);
 294         if (!pos) return;
 295
 296         end_pos = int_min(length, term->width - x) - 1;
 297
 298 #ifdef CONFIG_DEBUG
 299         /* Detect attempt to set @end to a point outside @text,
 300          * it may occur in case of bad calculations. --Zas */
 301         if (end_pos < 0) {
 302                 INTERNAL("end_pos < 0 !!");
 303                 end_pos = 0;
 304         } else {
 305                 int textlen = strlen(text);
 306
 307                 if (end_pos >= textlen) {
 308                         INTERNAL("end_pos (%d) >= text length (%d) !!", end_pos, textlen);
 309                         end_pos = textlen - 1;
 310                 }
 311         }
 312 #endif
 313
 314         end = &pos[int_max(0, end_pos)];
 315
 316         if (color) {
 317                 /* Use the last char as template. */
 318                 end->attr = attr;
 319                 set_term_color(end, color, 0,
 320                                get_opt_int_tree(term->spec, "colors"));
 321
 322                 for (; pos < end && *text; text++, pos++) {
 323                         end->data = *text;
 324                         copy_screen_chars(pos, end, 1);
 325                 }
 326
 327                 end->data = *text;
 328
 329         } else {
 330                 for (; pos <= end && *text; text++, pos++) {
 331                         pos->data = *text;
 332                 }
 333         }
 334
 335         set_screen_dirty(term->screen, y, y);
 336 }
 337
 338 void
 339 set_cursor(struct terminal *term, int x, int y, int blockable)
 340 {
 341         assert(term && term->screen);
 342         if_assert_failed return;
 343
 344         if (blockable && get_opt_bool_tree(term->spec, "block_cursor")) {
 345                 x = term->width - 1;
 346                 y = term->height - 1;
 347         }
 348
 349         if (term->screen->cx != x || term->screen->cy != y) {
 350                 check_range(term, x, y);
 351
 352                 set_screen_dirty(term->screen, int_min(term->screen->cy, y),
 353                                                int_max(term->screen->cy, y));
 354                 term->screen->cx = x;
 355                 term->screen->cy = y;
 356         }
 357 }
 358
 359 void
 360 clear_terminal(struct terminal *term)
 361 {
 362         struct box box;
 363
 364         set_box(&box, 0, 0, term->width, term->height);
 365         draw_box(term, &box, ' ', 0, NULL);
 366         set_cursor(term, 0, 0, 1);
 367 }