1 /**************************************************************************** 2 * Copyright (c) 1998-2006,2007 Free Software Foundation, Inc. * 3 * * 4 * Permission is hereby granted, free of charge, to any person obtaining a * 5 * copy of this software and associated documentation files (the * 6 * "Software"), to deal in the Software without restriction, including * 7 * without limitation the rights to use, copy, modify, merge, publish, * 8 * distribute, distribute with modifications, sublicense, and/or sell * 9 * copies of the Software, and to permit persons to whom the Software is * 10 * furnished to do so, subject to the following conditions: * 11 * * 12 * The above copyright notice and this permission notice shall be included * 13 * in all copies or substantial portions of the Software. * 14 * * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * 16 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * 17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * 18 * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * 19 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * 20 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * 21 * THE USE OR OTHER DEALINGS IN THE SOFTWARE. * 22 * * 23 * Except as contained in this notice, the name(s) of the above copyright * 24 * holders shall not be used in advertising or otherwise to promote the * 25 * sale, use or other dealings in this Software without prior written * 26 * authorization. * 27 ****************************************************************************/ 28 29 /**************************************************************************** 30 * Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995 * 31 * and: Eric S. Raymond <esr@snark.thyrsus.com> * 32 * and: Thomas E. Dickey 1996-on * 33 ****************************************************************************/ 34 35 /* lib_color.c 36 * 37 * Handles color emulation of SYS V curses 38 */ 39 40 #include <curses.priv.h> 41 42 #include <term.h> 43 #include <tic.h> 44 45 MODULE_ID("$Id: lib_color.c,v 1.85 2007/04/07 17:07:28 tom Exp $") 46 47 /* 48 * These should be screen structure members. They need to be globals for 49 * historical reasons. So we assign them in start_color() and also in 50 * set_term()'s screen-switching logic. 51 */ 52 #if USE_REENTRANT 53 NCURSES_EXPORT(int) 54 NCURSES_PUBLIC_VAR(COLOR_PAIRS) (void) 55 { 56 return SP ? SP->_pair_count : -1; 57 } 58 NCURSES_EXPORT(int) 59 NCURSES_PUBLIC_VAR(COLORS) (void) 60 { 61 return SP ? SP->_color_count : -1; 62 } 63 #else 64 NCURSES_EXPORT_VAR(int) COLOR_PAIRS = 0; 65 NCURSES_EXPORT_VAR(int) COLORS = 0; 66 #endif 67 68 #define DATA(r,g,b) {r,g,b, 0,0,0, 0} 69 70 #define TYPE_CALLOC(type,elts) typeCalloc(type, (unsigned)(elts)) 71 72 #define MAX_PALETTE 8 73 74 #define OkColorHi(n) (((n) < COLORS) && ((n) < max_colors)) 75 #define InPalette(n) ((n) >= 0 && (n) < MAX_PALETTE) 76 77 /* 78 * Given a RGB range of 0..1000, we'll normally set the individual values 79 * to about 2/3 of the maximum, leaving full-range for bold/bright colors. 80 */ 81 #define RGB_ON 680 82 #define RGB_OFF 0 83 /* *INDENT-OFF* */ 84 static const color_t cga_palette[] = 85 { 86 /* R G B */ 87 DATA(RGB_OFF, RGB_OFF, RGB_OFF), /* COLOR_BLACK */ 88 DATA(RGB_ON, RGB_OFF, RGB_OFF), /* COLOR_RED */ 89 DATA(RGB_OFF, RGB_ON, RGB_OFF), /* COLOR_GREEN */ 90 DATA(RGB_ON, RGB_ON, RGB_OFF), /* COLOR_YELLOW */ 91 DATA(RGB_OFF, RGB_OFF, RGB_ON), /* COLOR_BLUE */ 92 DATA(RGB_ON, RGB_OFF, RGB_ON), /* COLOR_MAGENTA */ 93 DATA(RGB_OFF, RGB_ON, RGB_ON), /* COLOR_CYAN */ 94 DATA(RGB_ON, RGB_ON, RGB_ON), /* COLOR_WHITE */ 95 }; 96 97 static const color_t hls_palette[] = 98 { 99 /* H L S */ 100 DATA( 0, 0, 0), /* COLOR_BLACK */ 101 DATA( 120, 50, 100), /* COLOR_RED */ 102 DATA( 240, 50, 100), /* COLOR_GREEN */ 103 DATA( 180, 50, 100), /* COLOR_YELLOW */ 104 DATA( 330, 50, 100), /* COLOR_BLUE */ 105 DATA( 60, 50, 100), /* COLOR_MAGENTA */ 106 DATA( 300, 50, 100), /* COLOR_CYAN */ 107 DATA( 0, 50, 100), /* COLOR_WHITE */ 108 }; 109 /* *INDENT-ON* */ 110 111 #if NCURSES_EXT_FUNCS 112 /* 113 * These are called from _nc_do_color(), which in turn is called from 114 * vidattr - so we have to assume that SP may be null. 115 */ 116 static int 117 default_fg(void) 118 { 119 return (SP != 0) ? SP->_default_fg : COLOR_WHITE; 120 } 121 122 static int 123 default_bg(void) 124 { 125 return SP != 0 ? SP->_default_bg : COLOR_BLACK; 126 } 127 #else 128 #define default_fg() COLOR_WHITE 129 #define default_bg() COLOR_BLACK 130 #endif 131 132 /* 133 * SVr4 curses is known to interchange color codes (1,4) and (3,6), possibly 134 * to maintain compatibility with a pre-ANSI scheme. The same scheme is 135 * also used in the FreeBSD syscons. 136 */ 137 static int 138 toggled_colors(int c) 139 { 140 if (c < 16) { 141 static const int table[] = 142 {0, 4, 2, 6, 1, 5, 3, 7, 143 8, 12, 10, 14, 9, 13, 11, 15}; 144 c = table[c]; 145 } 146 return c; 147 } 148 149 static void 150 set_background_color(int bg, int (*outc) (int)) 151 { 152 if (set_a_background) { 153 TPUTS_TRACE("set_a_background"); 154 tputs(TPARM_1(set_a_background, bg), 1, outc); 155 } else { 156 TPUTS_TRACE("set_background"); 157 tputs(TPARM_1(set_background, toggled_colors(bg)), 1, outc); 158 } 159 } 160 161 static void 162 set_foreground_color(int fg, int (*outc) (int)) 163 { 164 if (set_a_foreground) { 165 TPUTS_TRACE("set_a_foreground"); 166 tputs(TPARM_1(set_a_foreground, fg), 1, outc); 167 } else { 168 TPUTS_TRACE("set_foreground"); 169 tputs(TPARM_1(set_foreground, toggled_colors(fg)), 1, outc); 170 } 171 } 172 173 static void 174 init_color_table(void) 175 { 176 const color_t *tp; 177 int n; 178 179 tp = (hue_lightness_saturation) ? hls_palette : cga_palette; 180 for (n = 0; n < COLORS; n++) { 181 if (InPalette(n)) { 182 SP->_color_table[n] = tp[n]; 183 } else { 184 SP->_color_table[n] = tp[n % MAX_PALETTE]; 185 if (hue_lightness_saturation) { 186 SP->_color_table[n].green = 100; 187 } else { 188 if (SP->_color_table[n].red) 189 SP->_color_table[n].red = 1000; 190 if (SP->_color_table[n].green) 191 SP->_color_table[n].green = 1000; 192 if (SP->_color_table[n].blue) 193 SP->_color_table[n].blue = 1000; 194 } 195 } 196 } 197 } 198 199 /* 200 * Reset the color pair, e.g., to whatever color pair 0 is. 201 */ 202 static bool 203 reset_color_pair(void) 204 { 205 bool result = FALSE; 206 207 if (orig_pair != 0) { 208 TPUTS_TRACE("orig_pair"); 209 putp(orig_pair); 210 result = TRUE; 211 } 212 return result; 213 } 214 215 /* 216 * Reset color pairs and definitions. Actually we do both more to accommodate 217 * badly-written terminal descriptions than for the relatively rare case where 218 * someone has changed the color definitions. 219 */ 220 bool 221 _nc_reset_colors(void) 222 { 223 int result = FALSE; 224 225 T((T_CALLED("_nc_reset_colors()"))); 226 if (SP->_color_defs > 0) 227 SP->_color_defs = -(SP->_color_defs); 228 229 if (reset_color_pair()) 230 result = TRUE; 231 if (orig_colors != 0) { 232 TPUTS_TRACE("orig_colors"); 233 putp(orig_colors); 234 result = TRUE; 235 } 236 returnBool(result); 237 } 238 239 NCURSES_EXPORT(int) 240 start_color(void) 241 { 242 int result = ERR; 243 244 T((T_CALLED("start_color()"))); 245 246 if (SP == 0) { 247 result = ERR; 248 } else if (SP->_coloron) { 249 result = OK; 250 } else { 251 252 if (reset_color_pair() != TRUE) { 253 set_foreground_color(default_fg(), _nc_outch); 254 set_background_color(default_bg(), _nc_outch); 255 } 256 257 if (max_pairs > 0 && max_colors > 0) { 258 SP->_pair_count = max_pairs; 259 SP->_color_count = max_colors; 260 #if !USE_REENTRANT 261 COLOR_PAIRS = max_pairs; 262 COLORS = max_colors; 263 #endif 264 265 if ((SP->_color_pairs = TYPE_CALLOC(colorpair_t, 266 max_pairs)) != 0) { 267 if ((SP->_color_table = TYPE_CALLOC(color_t, 268 max_colors)) != 0) { 269 SP->_color_pairs[0] = PAIR_OF(default_fg(), default_bg()); 270 init_color_table(); 271 272 T(("started color: COLORS = %d, COLOR_PAIRS = %d", 273 COLORS, COLOR_PAIRS)); 274 275 SP->_coloron = 1; 276 result = OK; 277 } else if (SP->_color_pairs != 0) { 278 FreeAndNull(SP->_color_pairs); 279 } 280 } 281 } else { 282 result = OK; 283 } 284 } 285 returnCode(result); 286 } 287 288 /* This function was originally written by Daniel Weaver <danw@znyx.com> */ 289 static void 290 rgb2hls(short r, short g, short b, short *h, short *l, short *s) 291 /* convert RGB to HLS system */ 292 { 293 short min, max, t; 294 295 if ((min = g < r ? g : r) > b) 296 min = b; 297 if ((max = g > r ? g : r) < b) 298 max = b; 299 300 /* calculate lightness */ 301 *l = (min + max) / 20; 302 303 if (min == max) { /* black, white and all shades of gray */ 304 *h = 0; 305 *s = 0; 306 return; 307 } 308 309 /* calculate saturation */ 310 if (*l < 50) 311 *s = ((max - min) * 100) / (max + min); 312 else 313 *s = ((max - min) * 100) / (2000 - max - min); 314 315 /* calculate hue */ 316 if (r == max) 317 t = 120 + ((g - b) * 60) / (max - min); 318 else if (g == max) 319 t = 240 + ((b - r) * 60) / (max - min); 320 else 321 t = 360 + ((r - g) * 60) / (max - min); 322 323 *h = t % 360; 324 } 325 326 /* 327 * Extension (1997/1/18) - Allow negative f/b values to set default color 328 * values. 329 */ 330 NCURSES_EXPORT(int) 331 init_pair(short pair, short f, short b) 332 { 333 colorpair_t result; 334 335 T((T_CALLED("init_pair(%d,%d,%d)"), pair, f, b)); 336 337 if ((pair < 0) || (pair >= COLOR_PAIRS) || SP == 0 || !SP->_coloron) 338 returnCode(ERR); 339 #if NCURSES_EXT_FUNCS 340 if (SP->_default_color) { 341 if (f < 0) 342 f = COLOR_DEFAULT; 343 if (b < 0) 344 b = COLOR_DEFAULT; 345 if (!OkColorHi(f) && !isDefaultColor(f)) 346 returnCode(ERR); 347 if (!OkColorHi(b) && !isDefaultColor(b)) 348 returnCode(ERR); 349 } else 350 #endif 351 { 352 if ((f < 0) || !OkColorHi(f) 353 || (b < 0) || !OkColorHi(b) 354 || (pair < 1)) 355 returnCode(ERR); 356 } 357 358 /* 359 * When a pair's content is changed, replace its colors (if pair was 360 * initialized before a screen update is performed replacing original 361 * pair colors with the new ones). 362 */ 363 result = PAIR_OF(f, b); 364 if (SP->_color_pairs[pair] != 0 365 && SP->_color_pairs[pair] != result) { 366 int y, x; 367 368 for (y = 0; y <= curscr->_maxy; y++) { 369 struct ldat *ptr = &(curscr->_line[y]); 370 bool changed = FALSE; 371 for (x = 0; x <= curscr->_maxx; x++) { 372 if (GetPair(ptr->text[x]) == pair) { 373 /* Set the old cell to zero to ensure it will be 374 updated on the next doupdate() */ 375 SetChar(ptr->text[x], 0, 0); 376 CHANGED_CELL(ptr, x); 377 changed = TRUE; 378 } 379 } 380 if (changed) 381 _nc_make_oldhash(y); 382 } 383 } 384 SP->_color_pairs[pair] = result; 385 if (GET_SCREEN_PAIR(SP) == pair) 386 SET_SCREEN_PAIR(SP, (chtype) (~0)); /* force attribute update */ 387 388 if (initialize_pair && InPalette(f) && InPalette(b)) { 389 const color_t *tp = hue_lightness_saturation ? hls_palette : cga_palette; 390 391 TR(TRACE_ATTRS, 392 ("initializing pair: pair = %d, fg=(%d,%d,%d), bg=(%d,%d,%d)", 393 pair, 394 tp[f].red, tp[f].green, tp[f].blue, 395 tp[b].red, tp[b].green, tp[b].blue)); 396 397 TPUTS_TRACE("initialize_pair"); 398 putp(TPARM_7(initialize_pair, 399 pair, 400 tp[f].red, tp[f].green, tp[f].blue, 401 tp[b].red, tp[b].green, tp[b].blue)); 402 } 403 404 returnCode(OK); 405 } 406 407 #define okRGB(n) ((n) >= 0 && (n) <= 1000) 408 409 NCURSES_EXPORT(int) 410 init_color(short color, short r, short g, short b) 411 { 412 int result = ERR; 413 414 T((T_CALLED("init_color(%d,%d,%d,%d)"), color, r, g, b)); 415 416 if (initialize_color != NULL 417 && SP != 0 418 && SP->_coloron 419 && (color >= 0 && OkColorHi(color)) 420 && (okRGB(r) && okRGB(g) && okRGB(b))) { 421 422 SP->_color_table[color].init = 1; 423 SP->_color_table[color].r = r; 424 SP->_color_table[color].g = g; 425 SP->_color_table[color].b = b; 426 427 if (hue_lightness_saturation) { 428 rgb2hls(r, g, b, 429 &SP->_color_table[color].red, 430 &SP->_color_table[color].green, 431 &SP->_color_table[color].blue); 432 } else { 433 SP->_color_table[color].red = r; 434 SP->_color_table[color].green = g; 435 SP->_color_table[color].blue = b; 436 } 437 438 TPUTS_TRACE("initialize_color"); 439 putp(TPARM_4(initialize_color, color, r, g, b)); 440 SP->_color_defs = max(color + 1, SP->_color_defs); 441 result = OK; 442 } 443 returnCode(result); 444 } 445 446 NCURSES_EXPORT(bool) 447 can_change_color(void) 448 { 449 T((T_CALLED("can_change_color()"))); 450 returnCode((can_change != 0) ? TRUE : FALSE); 451 } 452 453 NCURSES_EXPORT(bool) 454 has_colors(void) 455 { 456 T((T_CALLED("has_colors()"))); 457 returnCode((VALID_NUMERIC(max_colors) && VALID_NUMERIC(max_pairs) 458 && (((set_foreground != NULL) 459 && (set_background != NULL)) 460 || ((set_a_foreground != NULL) 461 && (set_a_background != NULL)) 462 || set_color_pair)) ? TRUE : FALSE); 463 } 464 465 NCURSES_EXPORT(int) 466 color_content(short color, short *r, short *g, short *b) 467 { 468 int result; 469 470 T((T_CALLED("color_content(%d,%p,%p,%p)"), color, r, g, b)); 471 if (color < 0 || !OkColorHi(color) || SP == 0 || !SP->_coloron) { 472 result = ERR; 473 } else { 474 NCURSES_COLOR_T c_r = SP->_color_table[color].red; 475 NCURSES_COLOR_T c_g = SP->_color_table[color].green; 476 NCURSES_COLOR_T c_b = SP->_color_table[color].blue; 477 478 if (r) 479 *r = c_r; 480 if (g) 481 *g = c_g; 482 if (b) 483 *b = c_b; 484 485 TR(TRACE_ATTRS, ("...color_content(%d,%d,%d,%d)", 486 color, c_r, c_g, c_b)); 487 result = OK; 488 } 489 returnCode(result); 490 } 491 492 NCURSES_EXPORT(int) 493 pair_content(short pair, short *f, short *b) 494 { 495 int result; 496 497 T((T_CALLED("pair_content(%d,%p,%p)"), pair, f, b)); 498 499 if ((pair < 0) || (pair >= COLOR_PAIRS) || SP == 0 || !SP->_coloron) { 500 result = ERR; 501 } else { 502 NCURSES_COLOR_T fg = ((SP->_color_pairs[pair] >> C_SHIFT) & C_MASK); 503 NCURSES_COLOR_T bg = (SP->_color_pairs[pair] & C_MASK); 504 505 #if NCURSES_EXT_FUNCS 506 if (fg == COLOR_DEFAULT) 507 fg = -1; 508 if (bg == COLOR_DEFAULT) 509 bg = -1; 510 #endif 511 512 if (f) 513 *f = fg; 514 if (b) 515 *b = bg; 516 517 TR(TRACE_ATTRS, ("...pair_content(%d,%d,%d)", pair, fg, bg)); 518 result = OK; 519 } 520 returnCode(result); 521 } 522 523 NCURSES_EXPORT(void) 524 _nc_do_color(short old_pair, short pair, bool reverse, int (*outc) (int)) 525 { 526 NCURSES_COLOR_T fg = COLOR_DEFAULT; 527 NCURSES_COLOR_T bg = COLOR_DEFAULT; 528 NCURSES_COLOR_T old_fg, old_bg; 529 530 if (pair < 0 || pair >= COLOR_PAIRS) { 531 return; 532 } else if (pair != 0) { 533 if (set_color_pair) { 534 TPUTS_TRACE("set_color_pair"); 535 tputs(TPARM_1(set_color_pair, pair), 1, outc); 536 return; 537 } else if (SP != 0) { 538 pair_content((short) pair, &fg, &bg); 539 } 540 } 541 542 if (old_pair >= 0 543 && SP != 0 544 && pair_content(old_pair, &old_fg, &old_bg) != ERR) { 545 if ((isDefaultColor(fg) && !isDefaultColor(old_fg)) 546 || (isDefaultColor(bg) && !isDefaultColor(old_bg))) { 547 #if NCURSES_EXT_FUNCS 548 /* 549 * A minor optimization - but extension. If "AX" is specified in 550 * the terminal description, treat it as screen's indicator of ECMA 551 * SGR 39 and SGR 49, and assume the two sequences are independent. 552 */ 553 if (SP->_has_sgr_39_49 554 && isDefaultColor(old_bg) 555 && !isDefaultColor(old_fg)) { 556 tputs("\033[39m", 1, outc); 557 } else if (SP->_has_sgr_39_49 558 && isDefaultColor(old_fg) 559 && !isDefaultColor(old_bg)) { 560 tputs("\033[49m", 1, outc); 561 } else 562 #endif 563 reset_color_pair(); 564 } 565 } else { 566 reset_color_pair(); 567 if (old_pair < 0) 568 return; 569 } 570 571 #if NCURSES_EXT_FUNCS 572 if (isDefaultColor(fg)) 573 fg = default_fg(); 574 if (isDefaultColor(bg)) 575 bg = default_bg(); 576 #endif 577 578 if (reverse) { 579 NCURSES_COLOR_T xx = fg; 580 fg = bg; 581 bg = xx; 582 } 583 584 TR(TRACE_ATTRS, ("setting colors: pair = %d, fg = %d, bg = %d", pair, 585 fg, bg)); 586 587 if (!isDefaultColor(fg)) { 588 set_foreground_color(fg, outc); 589 } 590 if (!isDefaultColor(bg)) { 591 set_background_color(bg, outc); 592 } 593 } 594