Home | History | Annotate | Line # | Download | only in msgc
msg_sys.def revision 1.27 
      1 /*	$NetBSD: msg_sys.def,v 1.27 2004/06/05 19:05:36 dsl Exp $	*/
      2 
      3 /*
      4  * Copyright 1997 Piermont Information Systems Inc.
      5  * All rights reserved.
      6  *
      7  * Written by Philip A. Nelson for Piermont Information Systems Inc.
      8  *
      9  * Redistribution and use in source and binary forms, with or without
     10  * modification, are permitted provided that the following conditions
     11  * are met:
     12  * 1. Redistributions of source code must retain the above copyright
     13  *    notice, this list of conditions and the following disclaimer.
     14  * 2. Redistributions in binary form must reproduce the above copyright
     15  *    notice, this list of conditions and the following disclaimer in the
     16  *    documentation and/or other materials provided with the distribution.
     17  * 3. All advertising materials mentioning features or use of this software
     18  *    must display the following acknowledgement:
     19  *      This product includes software develooped for the NetBSD Project by
     20  *      Piermont Information Systems Inc.
     21  * 4. The name of Piermont Information Systems Inc. may not be used to endorse
     22  *    or promote products derived from this software without specific prior
     23  *    written permission.
     24  *
     25  * THIS SOFTWARE IS PROVIDED BY PIERMONT INFORMATION SYSTEMS INC. ``AS IS''
     26  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     28  * ARE DISCLAIMED. IN NO EVENT SHALL PIERMONT INFORMATION SYSTEMS INC. BE
     29  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     30  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     31  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     32  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     33  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     34  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     35  * THE POSSIBILITY OF SUCH DAMAGE.
     36  *
     37  */
     38 
     39 static WINDOW *msg_win = NULL;
     40 static char *cbuffer;
     41 static size_t cbuffersize;
     42 
     43 static int last_i_was_nl, last_i_was_space;
     44 static int last_o_was_punct, last_o_was_space;
     45 
     46 static void	_msg_beep(void);
     47 static int	_msg_vprintf(int, const char *, va_list);
     48 #define MSG_PROMPT_ECHO		1
     49 #define MSG_PROMPT_HIDE_DFLT	2
     50 static void	_msg_vprompt(const char *, int, const char *, char *,
     51 			size_t, va_list);
     52 
     53 static char *msgmap = MAP_FAILED;
     54 static size_t msgmapsz;
     55 static int msgmapcount;
     56 
     57 /* Routines */
     58 
     59 static void
     60 _msg_beep(void)
     61 {
     62 
     63 	fprintf(stderr, "\a");
     64 }
     65 
     66 WINDOW *
     67 msg_window(WINDOW *window)
     68 {
     69 	size_t ncbuffersize;
     70 	char *ncbuffer;
     71 	WINDOW *old;
     72 
     73 	old = msg_win;
     74 	if (!window)
     75 		return old;
     76 	msg_win = window;
     77 
     78 	ncbuffersize = getmaxx(window) * getmaxy(window) + 1;
     79 	while (ncbuffersize > cbuffersize) {
     80 		ncbuffer = malloc(ncbuffersize);
     81 		if (ncbuffer == NULL) {
     82 			/* we might get truncated messages... */
     83 			ncbuffersize <<= 1;
     84 			continue;
     85 		}
     86 		if (cbuffer != NULL)
     87 			free(cbuffer);
     88 		cbuffer = ncbuffer;
     89 		cbuffersize = ncbuffersize;
     90 		break;
     91 	}
     92 	last_o_was_punct = 0;
     93 	last_o_was_space = 1;
     94 	return old;
     95 }
     96 
     97 int
     98 msg_file(const char *file)
     99 {
    100 	int fd;
    101 
    102 	if (msgmap != MAP_FAILED)
    103 		munmap(msgmap, msgmapsz);
    104 	msgmap = MAP_FAILED;
    105 	if (!file)
    106 		return 0;
    107 	fd = open(file, O_RDONLY, 0);
    108 	if (fd == -1)
    109 		return -1;
    110 	msgmapsz = lseek(fd, 0, SEEK_END);
    111 	msgmap = mmap(0, msgmapsz, PROT_READ, MAP_SHARED, fd, 0);
    112 	close(fd);
    113 	if (msgmap == MAP_FAILED)
    114 		return -1;
    115 	/* check_magic */
    116 	if (strcmp(msgmap, "MSGTXTS") != 0) {
    117 		msg_file(NULL);
    118 		return -1;
    119 	}
    120 	msgmapcount = atoi(msgmap + 8);
    121 	return 0;
    122 }
    123 
    124 const char *
    125 msg_string(msg msg_no)
    126 {
    127 	int m = (intptr_t)msg_no;
    128 
    129 	if (m > sizeof msg_list / sizeof msg_list[0])
    130 		/* guess that we were passed a text string */
    131 		return msg_no;
    132 
    133 	if (msgmap != MAP_FAILED && m != 0 && m <= msgmapcount) {
    134 		unsigned int offset = atoi(msgmap + 8 + 8 * m);
    135 		if (offset != 0 && offset < msgmapsz)
    136 			return msgmap + offset;
    137 	}
    138 
    139 	return msg_list[m];
    140 }
    141 
    142 void
    143 msg_clear(void)
    144 {
    145 
    146 	wclear(msg_win);
    147 	last_o_was_punct = 0;
    148 	last_o_was_space = 1;
    149 }
    150 
    151 void
    152 msg_standout(void)
    153 {
    154 
    155 	wstandout(msg_win);
    156 }
    157 
    158 void
    159 msg_standend(void)
    160 {
    161 
    162 	wstandend(msg_win);
    163 }
    164 
    165 static int
    166 _msg_vprintf(int auto_fill, const char *fmt, va_list ap)
    167 {
    168 	const char *wstart, *afterw;
    169 	int wordlen, nspaces;
    170 	int ret;
    171 
    172 	ret = vsnprintf(cbuffer, cbuffersize, fmt, ap);
    173 
    174 	if (!auto_fill) {
    175 		waddstr(msg_win, cbuffer);
    176 
    177 		/*
    178 		 * nothing is perfect if they flow text after a table,
    179 		 * but this may be decent.
    180 		 */
    181 		last_i_was_nl = last_i_was_space = 1;
    182 		last_o_was_punct = 0;
    183 		last_o_was_space = 1;
    184 		goto out;
    185 	}
    186 
    187 	for (wstart = afterw = cbuffer; *wstart; wstart = afterw) {
    188 
    189 		/* eat one space, or a whole word of non-spaces */
    190 		if (isspace(*afterw))
    191 			afterw++;
    192 		else
    193 			while (*afterw && !isspace(*afterw))
    194 				afterw++;
    195 
    196 		/* this is an nl: special formatting necessary */
    197 		if (*wstart == '\n') {
    198 			if (last_i_was_nl || last_i_was_space) {
    199 
    200 				if (getcurx(msg_win) != 0)
    201 					waddch(msg_win, '\n');
    202 				if (last_i_was_nl) {
    203 					/* last was an nl: paragraph break */
    204 					waddch(msg_win, '\n');
    205 				} else {
    206 					/* last was space: line break */
    207 				}
    208 				last_o_was_punct = 0;
    209 				last_o_was_space = 1;
    210 			} else {
    211 				/* last_o_was_punct unchanged */
    212 				/* last_o_was_space unchanged */
    213 			}
    214 			last_i_was_space = 1;
    215 			last_i_was_nl = 1;
    216 			continue;
    217 		}
    218 
    219 		/* this is a tab: special formatting necessary. */
    220 		if (*wstart == '\t') {
    221 			if (last_i_was_nl) {
    222 				/* last was an nl: list indent */
    223 				if (getcurx(msg_win) != 0)
    224 					waddch(msg_win, '\n');
    225 			} else {
    226 				/* last was not an nl: columns */
    227 			}
    228 			waddch(msg_win, '\t');
    229 			last_i_was_nl = 0;
    230 			last_i_was_space = 1;
    231 			last_o_was_punct = 0;
    232 			last_o_was_space = 1;
    233 			continue;
    234 		}
    235 
    236 		/* this is a space: ignore it but set flags */
    237 		last_i_was_nl = 0;	/* all newlines handled above */
    238 		last_i_was_space = isspace(*wstart);
    239 		if (last_i_was_space)
    240 			continue;
    241 
    242 		/*
    243 		 * we have a real "word," i.e. a sequence of non-space
    244 		 * characters.  wstart is now the start of the word,
    245 		 * afterw is the next character after the end.
    246 		 */
    247 		wordlen = afterw - wstart;
    248 		nspaces = last_o_was_space ? 0 : (last_o_was_punct ? 2 : 1);
    249 		if ((getcurx(msg_win) + nspaces + wordlen) >=
    250 		      getmaxx(msg_win) &&
    251 		    wordlen < (getmaxx(msg_win) / 3)) {
    252 			/* wrap the line */
    253 			waddch(msg_win, '\n');
    254 			nspaces = 0;
    255 		}
    256 
    257 		/* output the word, preceded by spaces if necessary */
    258 		while (nspaces-- > 0)
    259 			waddch(msg_win, ' ');
    260 		waddbytes(msg_win, wstart, wordlen);
    261 
    262 		/* set up the 'last' state for the next time around */
    263 		switch (afterw[-1]) {
    264 		case '.':
    265 		case '?':
    266 		case '!':
    267 			last_o_was_punct = 1;
    268 			break;
    269 		default:
    270 			last_o_was_punct = 0;
    271 			break;
    272 		}
    273 		last_o_was_space = 0;
    274 
    275 		/* ... and do it all again! */
    276 	}
    277 
    278 	/* String ended with a newline.  They really want a line break. */
    279 	if (last_i_was_nl) {
    280 		if (getcurx(msg_win) != 0)
    281 			waddch(msg_win, '\n');
    282 		last_o_was_punct = 0;
    283 		last_o_was_space = 1;
    284 	}
    285 
    286 out:
    287 	wrefresh(msg_win);
    288 	return ret;
    289 }
    290 
    291 void
    292 msg_display(msg msg_no, ...)
    293 {
    294 	va_list ap;
    295 
    296 	msg_clear();
    297 
    298 	va_start(ap, msg_no);
    299 	(void)_msg_vprintf(1, msg_string(msg_no), ap);
    300 	va_end(ap);
    301 }
    302 
    303 void
    304 msg_display_add(msg msg_no, ...)
    305 {
    306 	va_list ap;
    307 
    308 	va_start(ap, msg_no);
    309 	(void)_msg_vprintf(1, msg_string(msg_no), ap);
    310 	va_end(ap);
    311 }
    312 
    313 static void
    314 _erase_ch(void)
    315 {
    316 	int y, x;
    317 
    318 	getyx(msg_win, y, x);
    319 	x--;
    320 	wmove(msg_win, y, x);
    321 	waddch(msg_win, ' ');
    322 	wmove(msg_win, y, x);
    323 }
    324 
    325 static void
    326 _msg_vprompt(const char *fmt, int flags, const char *def, char *val,
    327     size_t max_chars, va_list ap)
    328 {
    329 	int ch;
    330 	int len, pos, npos, off;
    331 	int first;
    332 	int txt_y, txt_x;
    333 	char *ibuf = alloca(max_chars);
    334 	int maxx;
    335 
    336 	keypad(msg_win, TRUE);
    337 	_msg_vprintf(0, fmt, ap);
    338 	ibuf[0] = 0;
    339 	if (def != NULL && *def) {
    340 		if (flags & MSG_PROMPT_HIDE_DFLT)
    341 			strlcpy(ibuf, def, max_chars);
    342 		else {
    343 			waddstr(msg_win, " [");
    344 			waddstr(msg_win, def);
    345 			waddstr(msg_win, "]");
    346 		}
    347 	}
    348 	waddstr(msg_win, ": ");
    349 	len = strlen(ibuf);
    350 	pos = len;
    351 	getyx(msg_win, txt_y, txt_x);
    352 	maxx = getmaxx(msg_win) - txt_x - 1;
    353 	off = 0;
    354 
    355 	for (first = 1; ; first = 0) {
    356 
    357 		if (flags & MSG_PROMPT_ECHO) {
    358 			/* shift text right as we near the buffer start */
    359 			if (pos - off < 4)
    360 				off = pos - 4;
    361 			/* keep offset to a minimum if we are at the end */
    362 			if (pos == len)
    363 				off = pos - maxx;
    364 			if (off < 0 || len <= maxx)
    365 				off = 0;
    366 			/* shift text left as we near the buffer end */
    367 			npos = pos + 4;
    368 			if (npos > len)
    369 				npos = len;
    370 			if (npos - off > maxx)
    371 				off = npos - maxx;
    372 			/* calc. length to display */
    373 			npos = len - off;
    374 			if (npos > maxx)
    375 				npos = maxx;
    376 			mvwaddnstr(msg_win, txt_y, txt_x, ibuf + off, npos);
    377 			wclrtoeol(msg_win);
    378 			if (off != 0)
    379 				mvwaddstr(msg_win, txt_y, txt_x, "+");
    380 			wmove(msg_win, txt_y, txt_x + pos - off);
    381 			wrefresh(msg_win);
    382 		}
    383 
    384 		ch = wgetch(msg_win);
    385 		if (ch == '\n')
    386 			break;
    387 
    388 		switch (ch) {
    389 		case KEY_BACKSPACE:
    390 		case 'h' & 0x1f: case 0x7f:  /* bs or del - delete left */
    391 			if (first) {
    392 				/* delete all of default string */
    393 				len = pos = 0;
    394 				break;
    395 			}
    396 			if (pos > 0) {
    397 				memmove(ibuf + pos - 1, ibuf + pos, len - pos);
    398 				len--;
    399 				pos--;
    400 			} else
    401 				_msg_beep();
    402 			break;
    403 		case 'u' & 0x1f:	/* ^U; line kill */
    404 			/* kill line */
    405 			len = pos = 0;
    406 			break;
    407 		case 'w' & 0x1f:        /* ^W; word kill */
    408 			/*
    409 			 * word kill kills the spaces and the 'word'
    410 			 * (non-spaces) last typed.  the spaces before
    411 			 * the 'word' aren't killed.
    412 			 */
    413 			npos = pos;
    414 			while (npos > 0 && isspace(ibuf[npos - 1]))
    415 				npos--;
    416 			while (npos > 0 && !isspace(ibuf[npos - 1]))
    417 				npos--;
    418 			memmove(ibuf + npos, ibuf + pos, len - pos);
    419 			len -= pos - npos;
    420 			pos = npos;
    421 			break;
    422 		case KEY_LEFT:
    423 			if (pos > 0)
    424 				pos--;
    425 			break;
    426 		case KEY_RIGHT:
    427 			if (len == 0 && pos == 0 && def != NULL) {
    428 				/* restore default! */
    429 				strlcpy(ibuf, def, max_chars);
    430 				len = pos = strlen(ibuf);
    431 				break;
    432 			}
    433 			if (pos < len)
    434 				pos++;
    435 			break;
    436 		default:
    437 			if (len < (max_chars - 1) && isprint(ch)) {
    438 				memmove(ibuf + pos + 1, ibuf + pos, len - pos);
    439 				ibuf[pos++] = ch;
    440 				len++;
    441 			} else
    442 				_msg_beep();
    443 			break;
    444 		}
    445 	}
    446 
    447 	if (flags & MSG_PROMPT_ECHO) {
    448 		mvwaddch(msg_win, txt_y, txt_x + len - off, '\n');
    449 		last_o_was_punct = 0;
    450 		last_o_was_space = 1;
    451 	}
    452 
    453 	/* copy the appropriate string to the output */
    454 	if (len != 0) {
    455 		ibuf[len] = '\0';
    456 		strlcpy(val, ibuf, max_chars);
    457 	} else if (def != NULL && val != def) {
    458 		strlcpy(val, def, max_chars);
    459 	}
    460 }
    461 
    462 void
    463 msg_prompt(msg msg_no, const char *def, char *val, size_t max_chars, ...)
    464 {
    465 	va_list ap;
    466 
    467 	msg_clear();
    468 
    469 	va_start(ap, max_chars);
    470 	_msg_vprompt(msg_string(msg_no), MSG_PROMPT_ECHO,
    471 		def, val, max_chars, ap);
    472 	va_end(ap);
    473 }
    474 
    475 void
    476 msg_prompt_win(msg msg_no, int x, int y, int w, int h,
    477 	const char *def, char *val, size_t max_chars, ...)
    478 {
    479 	va_list ap;
    480 	WINDOW *win, *svwin;
    481 	int maxx, maxy;
    482 	int msg_flags = MSG_PROMPT_ECHO | MSG_PROMPT_HIDE_DFLT;
    483 
    484 	maxx = getmaxx(msg_win);
    485 	maxy = getmaxy(msg_win);
    486 	if (w == 0) {
    487 		va_start(ap, max_chars);
    488 		w = vsnprintf(NULL, 0, msg_string(msg_no), ap);
    489 		va_end(ap);
    490 		if (def != NULL && *def != 0 && w + max_chars * 2 < maxx) {
    491 			w += 2 + strlen(def) + 1;
    492 			msg_flags &= ~MSG_PROMPT_HIDE_DFLT;
    493 		}
    494 		w += 1 + 2 + max_chars + 1;
    495 		if (w > maxx) {
    496 			if (!(msg_flags & MSG_PROMPT_HIDE_DFLT)) {
    497 				w -= 2 + strlen(def) + 1;
    498 				msg_flags |= MSG_PROMPT_HIDE_DFLT;
    499 			}
    500 			w = maxx;
    501 		}
    502 	}
    503 
    504 	if (x == -1)
    505 		x = (maxx - w) / 2 + 1;
    506 	if (h < 3)
    507 		h = 3;
    508 	if (y < 3)
    509 		y = (maxy - h) / 2;
    510 	if (y + h > maxy)
    511 		y = maxy - h;
    512 
    513 	win = subwin(msg_win, h, w, y, x);
    514 	if (win == NULL)
    515 		wprintw(msg_win, "msg_prompt_win: "
    516 			"newwin(%d, %d, %d, %d) failed\n",
    517 			h, w, y, x);
    518 	else {
    519 		wbkgd(win, getbkgd(msg_win));
    520 		wattrset(win, getattrs(msg_win));
    521 		box(win, 0, 0);
    522 		wrefresh(win);
    523 
    524 		/* Change message window to be our little box */
    525 		svwin = msg_window(subwin(msg_win, h - 2, w - 2, y + 1, x + 1));
    526 		wbkgd(msg_win, getbkgd(win));
    527 		wattrset(msg_win, getattrs(win));
    528 
    529 		msg_clear();
    530 	}
    531 
    532 	va_start(ap, max_chars);
    533 	_msg_vprompt(msg_string(msg_no), msg_flags, def, val, max_chars, ap);
    534 	va_end(ap);
    535 
    536 	if (win != NULL) {
    537 		wclear(win);
    538 		wrefresh(win);
    539 		/* Restore normal message window */
    540 		delwin(msg_window(svwin));
    541 		delwin(win);
    542 	}
    543 }
    544 
    545 void
    546 msg_prompt_add(msg msg_no, const char *def, char *val, size_t max_chars, ...)
    547 {
    548 	va_list ap;
    549 
    550 	va_start(ap, max_chars);
    551 	_msg_vprompt(msg_string(msg_no), MSG_PROMPT_ECHO, def, val, max_chars, ap);
    552 	va_end(ap);
    553 }
    554 
    555 void
    556 msg_prompt_noecho(msg msg_no, const char *def, char *val, size_t max_chars, ...)
    557 {
    558 	va_list ap;
    559 
    560 	msg_clear();
    561 
    562 	va_start(ap, max_chars);
    563 	_msg_vprompt(msg_string(msg_no), 0, def, val, max_chars, ap);
    564 	va_end(ap);
    565 }
    566 
    567 void
    568 msg_table_add(msg msg_no, ...)
    569 {
    570 	va_list ap;
    571 
    572 	va_start(ap, msg_no);
    573 	(void)_msg_vprintf(0, msg_string(msg_no), ap);
    574 	va_end(ap);
    575 }
    576 
    577 int
    578 msg_row(void)
    579 {
    580 
    581 	return getcury(msg_win) + getbegy(msg_win);
    582 }
    583