void puttext(int left, int top, int right, int bottom, unsigned char *str)
{
int orig_y, orig_x;
attr_t attrs;
short pair;
getyx(stdscr, orig_y, orig_x);
attr_get(&attrs, &pair, NULL);
for (int y = top - 1; y <= bottom - 1; y++)
{
for (int x = left - 1; x <= right - 1; x++)
{
unsigned char chr = *str++;
unsigned char col = *str++;
wchar_t w = cp437[chr];
if (w == 0) w = (wchar_t)' ';
textcolor(col);
mvaddnwstr(y, x, &w, 1);
}
}
attr_set(attrs, pair, NULL);
move(orig_y, orig_x);
}
/* Among other things, 'newtest' demonstrates how to make a Win32a
PDCurses app that is a for-real, "pure Windows" version (instead of
a console application). Doing this is quite easy, and has certain
advantages. If the app is invoked from a command prompt, the only
difference you'll see is that the app runs separately (that is, you
can continue to use the command prompt, switching between it, your
PDCurses/Win32a app, and other processes). Which is the main reason
I did it; it meant that I could invoke a PDCurses-based text editor,
for example, and still have use of the command line.
(NOTE that, for reasons I don't actually understand, this happens
when the Visual C++ compiler is used. With MinGW or OpenWatcom, it's
still "really" a console app.)
To do it, we ensure that the usual main() function has an alternative
dummy_main() form, taking the same arguments as main(). We add a
WinMain() function, whose sole purpose is to reformulate lpszCmdLine
into argc/argv form, and pass it on to dummy_main(). And, of course,
we can switch back to a "normal" console app by removing the above
#define PURE_WINDOWS_VERSION line. */
#ifdef PURE_WINDOWS_VERSION
#undef MOUSE_MOVED
#include <windows.h>
int dummy_main( int argc, char **argv);
int APIENTRY WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpszCmdLine, int nCmdShow)
{
char *argv[30];
int i, argc = 1;
argv[0] = "newtest";
for( i = 0; lpszCmdLine[i]; i++)
if( lpszCmdLine[i] != ' ' && (!i || lpszCmdLine[i - 1] == ' '))
argv[argc++] = lpszCmdLine + i;
for( i = 0; lpszCmdLine[i]; i++)
if( lpszCmdLine[i] == ' ')
lpszCmdLine[i] = '\0';
return dummy_main( argc, (char **)argv);
}
int dummy_main( int argc, char **argv)
#else /* "usual", console-app version: */
int main( int argc, char **argv)
#endif
{
int quit = 0, i, use_slk = 1;
int fmt = 0xa;
bool blink_state = FALSE;
int cursor_state_1 = 2, cursor_state_2 = 3;
int show_slk_index_line = 0;
int redraw = 1;
unsigned extra_character_to_show = 0;
#ifdef PDC_WIDE
unsigned unicode_offset = 0x80;
#endif
/* setlocale(LC_ALL, ".utf8"); */
ttytype[0] = 25; ttytype[1] = 90; /* Allow 25 to 90 lines... */
ttytype[2] = 80; ttytype[3] = (char)200; /* ...and 80 to 200 columns */
/* (This program gets weird artifacts when smaller than 25x80.) */
for( i = 1; i < argc; i++)
if( argv[i][0] == '-')
switch( argv[i][1])
{
case 's':
use_slk = 0;
break;
case 'l':
setlocale( LC_ALL, argv[i] + 2);
break;
case 'e':
sscanf( argv[i] + 2, "%x", &extra_character_to_show);
break;
case 'f':
sscanf( argv[i] + 2, "%x", (unsigned *)&fmt);
break;
case 'i':
show_slk_index_line = 1;
break;
case 'r': /* allow user-resizable windows */
{
int min_lines, max_lines, min_cols, max_cols;
if( sscanf( argv[i] + 2, "%d,%d,%d,%d",
&min_lines, &max_lines,
&min_cols, &max_cols) == 4)
{
ttytype[0] = min_lines;
ttytype[1] = max_lines;
ttytype[2] = min_cols;
ttytype[3] = max_cols;
}
}
break;
case 'd': /* set window size before initscr */
{
int n_lines, n_cols;
if( sscanf( argv[i] + 2, "%d,%d", &n_lines,
&n_cols) == 2)
resize_term( n_lines, n_cols);
}
break;
#ifdef PDC_WIDE
case 'u':
sscanf( argv[i] + 2, "%x", &unicode_offset);
break;
#endif
default:
printf( "Option '%s' unrecognized\n", argv[i]);
break;
}
if( use_slk)
slk_init( show_slk_index_line ? 3 : 0);
Xinitscr(argc, argv);
if( use_slk)
slk_setup( show_slk_index_line ? -fmt : fmt);
start_color();
# if defined(NCURSES_VERSION) || (defined(PDC_BUILD) && PDC_BUILD > 3000)
use_default_colors();
# endif
cbreak();
noecho();
clear();
refresh();
#ifdef __PDCURSES__
PDC_set_title( "NewTest: tests various PDCurses features");
#endif
keypad( stdscr, TRUE);
init_pair( 1, 15, COLOR_BLACK);
init_pair( 2, COLOR_BLACK, COLOR_YELLOW);
mousemask( ALL_MOUSE_EVENTS, NULL);
attrset( COLOR_PAIR( 1));
while( !quit)
{
char buff[40];
const int xmax = getmaxx( stdscr);
const int ymax = getmaxy( stdscr);
int color_block_start = 54, c;
int color_block_cols = (xmax - color_block_start) / 2;
const int color_block_lines = 19;
const char *cursor_state_text[N_CURSORS] = {
"Invisible (click to change) ",
"Underscore (click to change)",
"Block (click to change) ",
"Outline (click to change) ",
"Caret (click to change) ",
"Half-block (click to change)",
"Central (click to change) ",
"Cross (click to change) ",
"Heavy box (click to change) " };
if( color_block_cols < 0)
color_block_cols = 0;
if( redraw)
{
mvaddstr( 1, COL1, "'Normal' white-on-black");
#if(CHTYPE_LONG >= 2) /* "non-standard" 64-bit chtypes */
attron( A_DIM);
mvaddstr( 2, COL1, "Dimmed text");
attroff( A_DIM);
#endif
#ifdef PDC_WIDE
mvaddwstr( 3, COL1, L"'Normal' text, but wide");
#endif
attron( A_BLINK);
mvaddstr( 6, 40, "Blinking");
attron( A_BOLD);
mvaddstr( 8, 40, "BlinkBold");
attron( A_ITALIC);
mvaddstr( 0, COL2, "BlinkBoldItalic");
attrset( COLOR_PAIR( 3));
attron( A_UNDERLINE);
#ifdef PDC_WIDE
mvaddstr( 1, COL2, "Underlined");
addwstr( L"WideUnder");
#endif
attrset( COLOR_PAIR( 1));
attron( A_UNDERLINE | A_ITALIC);
mvaddstr( 2, COL2, "UnderlinedItalic");
attrset( COLOR_PAIR( 2));
attron( A_BLINK);
mvaddstr( 4, COL1, "Black-on-yellow blinking");
attrset( COLOR_PAIR( 1));
move( 4, COL2);
text_in_a_box( "Text in a box");
#ifdef CHTYPE_LONG
attrset( COLOR_PAIR( 6));
attron( A_STRIKEOUT);
mvaddstr( 10, 40, "Strikeout");
attrset( COLOR_PAIR( 1));
#endif
#ifdef PDC_WIDE
move( 11, 40);
text_in_a_box( "Next Ucode pg");
if( unicode_offset)
{
move( 12, 40);
text_in_a_box( "Prev Ucode pg");
}
mvprintw( 13, 40, "U+%04x ", unicode_offset);
#endif
for( i = 0; i < 128; i++)
{ /* Show extended characters: */
#ifdef PDC_WIDE
wchar_t buff[20];
swprintf( buff, 20, L"%02x ",
(unsigned)( i + unicode_offset) & 0xff);
mvaddwstr( 5 + i % 16, (i / 16) * 5, buff);
if( i + unicode_offset > ' ')
addch( (chtype)( i + unicode_offset));
else
addch( ' ');
addch( ' ');
#else
char buff[6];
sprintf( buff, "%02x %c", i + 128, (char)(i + 128));
mvaddstr( 5 + i % 16, (i / 16) * 5, buff);
#endif
}
#if(CHTYPE_LONG >= 2) /* "non-standard" 64-bit chtypes */
for( i = 0; i < 3 && i + 21 < ymax; i++)
{ /* Demonstrate full RGB color control: */
int j;
const char *output_text[3] = {
"Red on green to white on black | (you can get full RGB colors when desired,",
"Blue on yellow to black on red | with palette coloring still being available)",
"White on red to green on blue, underlined and italic" };
const int len = (int)strlen( output_text[i]);
move( 21 + i, 1);
for( j = 0; j < len && j + 1 < xmax; j++)
{
attr_t output_color;
const int oval = j * 31 / len;
const int reverse = 31 - oval;
if( !i)
output_color = A_RGB( 31, oval, oval, 0, reverse, 0);
else if( i == 1)
output_color = A_RGB( 0, 0, reverse, 31, reverse, 0);
else
{
output_color = A_RGB( reverse, 31, reverse,
reverse, 0, oval);
output_color |= A_UNDERLINE | A_ITALIC;
}
attrset( output_color);
addch( output_text[i][j]);
}
}
#endif /* #if(CHTYPE_LONG >= 2) */
redraw = 0;
attrset( COLOR_PAIR( 1));
if( extra_character_to_show && ymax > 23)
mvaddch( 23, 63, (chtype)extra_character_to_show);
#ifdef PDC_WIDE
for( i = 0; i < 6; i++)
{
static const wchar_t spanish[] = L"Espa\xf1ol";
const int line = 24 + i / 3;
const int col = 5 + 25 * (i % 3);
static const wchar_t russian[] = {0x0420, 0x0443, 0x0441, 0x0441,
0x043a, 0x0438, 0x0439, L' ', 0x044f, 0x0437, 0x044b, 0x043a, 0};
static const wchar_t greek[] = {0x0395, 0x03bb, 0x03bb, 0x03b7,
0x03bd, 0x03b9, 0x03ba, 0x03ac, 0};
static const wchar_t georgian[] = {0x10e5, 0x10d0, 0x10e0, 0x10d7,
0x10e3, 0x10da, 0x10d8, L' ', 0x10d4, 0x10dc, 0x10d0, 0};
static const wchar_t fullwidth[] = { 0xff26, 0xff55, 0xff4c, 0xff4c,
0xff57, 0xff49, 0xff44, 0xff54, 0xff48, 0 }; /* "Fullwidth" */
static const wchar_t combining_marks[] = { L'C', L'o', 0x35c, L'm',
L'b', 0x30a, L'i', L'n', L'i', 0x304, L'n', 0x30b, 0x329,
L'g', 0x310,
L' ', L'C', 0x338, L'h', 0x306, L'a', 0x361, L'r', L's',
0x30e, 0x348, 0 };
static const wchar_t *texts[6] = { spanish, russian, greek,
georgian, fullwidth, combining_marks};
if( line < ymax && col < xmax)
mvaddnwstr( line, 5 + 25 * (i % 3), texts[i], xmax - col);
}
#endif
#ifdef MAYBE_TRY_THIS_SOMEWHERE_ELSE
mvaddstr( 1, COL3, "Click on cursor descriptions to");
mvaddstr( 2, COL3, "cycle through possible cursors");
mvaddstr( 3, COL3, "Click on colors at left to change");
mvaddstr( 4, COL3, "colors used for under/over/outlining");
mvaddstr( 5, COL3, "Click 'Blink' at bottom to toggle");
mvaddstr( 6, COL3, "'real' blinking vs. 'highlit' blink");
#endif
}
mvaddnstr( 19, color_block_start, cursor_state_text[cursor_state_1],
xmax - color_block_start);
mvaddnstr( 20, color_block_start, cursor_state_text[cursor_state_2],
xmax - color_block_start);
curs_set( (cursor_state_1 << 8) | cursor_state_2);
for( i = 0; i < color_block_cols * color_block_lines; i++)
{
const int n_color_blocks = 256;
attrset( COLOR_PAIR( i >= n_color_blocks ? 2 : i));
if( i > 2 && i < n_color_blocks)
init_pair((short)i, (short)i, COLOR_BLACK);
if( !(i % color_block_cols))
move( i / color_block_cols, color_block_start);
attron( A_REVERSE);
addstr( " ");
}
move( 19, color_block_start - 3);
refresh();
c = getch( );
attrset( COLOR_PAIR( 1));
if( c == KEY_RESIZE)
{
redraw = 1;
resize_term( 0, 0);
}
else if( c == KEY_F(1) || c == 27)
quit = 1;
else if( c == KEY_F(2))
{
blink_state ^= 1;
PDC_set_blink( blink_state);
}
else if( c == KEY_F(3)) /* toggle SLKs */
{
use_slk ^= 1;
if( use_slk)
slk_restore( );
else
slk_clear( );
}
else if( c >= KEY_F(4) && c < KEY_F(12))
{
sscanf( labels[c - KEY_F(1)], "%x", (unsigned *)&fmt);
if( use_slk)
slk_setup( show_slk_index_line ? -fmt : fmt);
}
// else if( c == 'w')
// PDC_write_screen_to_file( "scrdump.htm", curscr);
if( c != KEY_MOUSE)
{
sprintf( buff, "Key %s hit ", keyname( c));
mvaddstr( 0, COL1, buff);
}
else
{
MEVENT mouse_event;
#ifdef __PDCURSES__
nc_getmouse( &mouse_event);
#else
getmouse( &mouse_event);
#endif
sprintf( buff, "Mouse at %d x %d: %x ", mouse_event.x,
mouse_event.y, (unsigned)mouse_event.bstate);
mvaddstr( 0, COL1, buff);
if( mouse_event.x >= color_block_start
&& mouse_event.y < color_block_lines)
{
int new_color = (mouse_event.x - color_block_start) / 2
+ mouse_event.y * color_block_cols;
if( new_color >= 256)
new_color = -1;
PDC_set_line_color( (short)new_color);
}
else if( mouse_event.x >= color_block_start)
{
int shift = ((mouse_event.bstate & BUTTON_MODIFIER_SHIFT) ?
N_CURSORS - 1 : 1);
if( mouse_event.y == 19) /* blink/non-blink toggle */
cursor_state_1 = (cursor_state_1 + shift) % N_CURSORS;
else if( mouse_event.y == 20) /* cycle cursor state */
cursor_state_2 = (cursor_state_2 + shift) % N_CURSORS;
}
#ifdef PDC_WIDE
else if( mouse_event.x >= 40 && mouse_event.x < 40 + 10)
{
if( mouse_event.y == 11)
{
redraw = 1;
unicode_offset += 0x80;
}
else if( mouse_event.y == 12 && unicode_offset)
{
redraw = 1;
unicode_offset -= 0x80;
}
}
#endif
}
}
endwin();
return 0;
}
int
main(int argc, char *argv[])
{
int optc;
int option_differences = 0,
option_differences_cumulative = 0,
option_exec = 0,
option_beep = 0,
option_color = 0,
option_errexit = 0,
option_help = 0, option_version = 0;
double interval = 2;
char *command;
wchar_t *wcommand = NULL;
char **command_argv;
int command_length = 0; /* not including final \0 */
int wcommand_columns = 0; /* not including final \0 */
int wcommand_characters = 0; /* not including final \0 */
watch_usec_t next_loop; /* next loop time in us, used for precise time
keeping only */
int pipefd[2];
int status;
pid_t child;
setlocale(LC_ALL, "");
progname = argv[0];
while ((optc = getopt_long(argc, argv, "+bced::hn:pvtx", longopts, (int *) 0))
!= EOF) {
switch (optc) {
case 'b':
option_beep = 1;
break;
case 'c':
option_color = 1;
break;
case 'd':
option_differences = 1;
if (optarg)
option_differences_cumulative = 1;
break;
case 'e':
option_errexit = 1;
break;
case 'h':
option_help = 1;
break;
case 't':
show_title = 0;
break;
case 'x':
option_exec = 1;
break;
case 'n':
{
char *str;
interval = strtod(optarg, &str);
if (!*optarg || *str)
do_usage();
if(interval < 0.1)
interval = 0.1;
if(interval > ~0u/1000000)
interval = ~0u/1000000;
}
break;
case 'p':
precise_timekeeping = 1;
break;
case 'v':
option_version = 1;
break;
default:
do_usage();
break;
}
}
if (option_version) {
fprintf(stderr, "%s\n", VERSION);
if (!option_help)
exit(0);
}
if (option_help) {
fprintf(stderr, usage, progname);
fputs(" -b, --beep\t\t\t\tbeep if the command has a non-zero exit\n", stderr);
fputs(" -d, --differences[=cumulative]\thighlight changes between updates\n", stderr);
fputs("\t\t(cumulative means highlighting is cumulative)\n", stderr);
fputs(" -e, --errexit\t\t\t\texit watch if the command has a non-zero exit\n", stderr);
fputs(" -h, --help\t\t\t\tprint a summary of the options\n", stderr);
fputs(" -n, --interval=<seconds>\t\tseconds to wait between updates\n", stderr);
fputs(" -p, --precise\t\t\t\tprecise timing, ignore command run time\n", stderr);
fputs(" -v, --version\t\t\t\tprint the version number\n", stderr);
fputs(" -t, --no-title\t\t\tturns off showing the header\n", stderr);
fputs(" -x, --exec\t\t\t\tpass command to exec instead of sh\n", stderr);
exit(0);
}
if (optind >= argc)
do_usage();
command_argv=&(argv[optind]); /* save for later */
command = strdup(argv[optind++]);
command_length = strlen(command);
for (; optind < argc; optind++) {
char *endp;
int s = strlen(argv[optind]);
command = realloc(command, command_length + s + 2); /* space and \0 */
endp = command + command_length;
*endp = ' ';
memcpy(endp + 1, argv[optind], s);
command_length += 1 + s; /* space then string length */
command[command_length] = '\0';
}
// convert to wide for printing purposes
//mbstowcs(NULL, NULL, 0);
wcommand_characters = mbstowcs(NULL, command, 0);
if(wcommand_characters < 0) {
fprintf(stderr, "Unicode Handling Error\n");
exit(1);
}
wcommand = (wchar_t*)malloc((wcommand_characters+1) * sizeof(wcommand));
if(wcommand == NULL) {
fprintf(stderr, "Unicode Handling Error (malloc)\n");
exit(1);
}
mbstowcs(wcommand, command, wcommand_characters+1);
wcommand_columns = wcswidth(wcommand, -1);
get_terminal_size();
/* Catch keyboard interrupts so we can put tty back in a sane state. */
signal(SIGINT, die);
signal(SIGTERM, die);
signal(SIGHUP, die);
signal(SIGWINCH, winch_handler);
/* Set up tty for curses use. */
curses_started = 1;
initscr();
if (option_color) {
if (has_colors()) {
start_color();
use_default_colors();
init_ansi_colors();
} else
option_color = 0;
}
nonl();
noecho();
cbreak();
if (precise_timekeeping)
next_loop = get_time_usec();
for (;;) {
time_t t = time(NULL);
char *ts = ctime(&t);
int tsl = strlen(ts);
char *header;
FILE *p;
int x, y;
int oldeolseen = 1;
if (screen_size_changed) {
get_terminal_size();
resizeterm(height, width);
clear();
/* redrawwin(stdscr); */
screen_size_changed = 0;
first_screen = 1;
}
if (show_title) {
// left justify interval and command,
// right justify time, clipping all to fit window width
int hlen = asprintf(&header, "Every %.1fs: ", interval);
// the rules:
// width < tsl : print nothing
// width < tsl + hlen + 1: print ts
// width = tsl + hlen + 1: print header, ts
// width < tsl + hlen + 4: print header, ..., ts
// width < tsl + hlen + wcommand_columns: print header, truncated wcommand, ..., ts
// width > "": print header, wcomand, ts
// this is slightly different from how it used to be
if(width >= tsl) {
if(width >= tsl + hlen + 1) {
mvaddstr(0, 0, header);
if(width >= tsl + hlen + 2) {
if(width < tsl + hlen + 4) {
mvaddstr(0, width - tsl - 4, "... ");
}else{
if(width < tsl + hlen + wcommand_columns) {
// print truncated
int avail_columns = width - tsl - hlen;
int using_columns = wcommand_columns;
int using_characters = wcommand_characters;
while(using_columns > avail_columns - 4) {
using_characters--;
using_columns = wcswidth(wcommand, using_characters);
}
mvaddnwstr(0, hlen, wcommand, using_characters);
mvaddstr(0, width - tsl - 4, "... ");
}else{
mvaddwstr(0, hlen, wcommand);
}
}
}
}
mvaddstr(0, width - tsl + 1, ts);
}
free(header);
}
/* allocate pipes */
if (pipe(pipefd)<0) {
perror("pipe");
do_exit(7);
}
/* flush stdout and stderr, since we're about to do fd stuff */
fflush(stdout);
fflush(stderr);
/* fork to prepare to run command */
child=fork();
if (child<0) { /* fork error */
perror("fork");
do_exit(2);
} else if (child==0) { /* in child */
close (pipefd[0]); /* child doesn't need read side of pipe */
close (1); /* prepare to replace stdout with pipe */
if (dup2 (pipefd[1], 1)<0) { /* replace stdout with write side of pipe */
perror("dup2");
exit(3);
}
dup2(1, 2); /* stderr should default to stdout */
if (option_exec) { /* pass command to exec instead of system */
if (execvp(command_argv[0], command_argv)==-1) {
perror("exec");
exit(4);
}
} else {
status=system(command); /* watch manpage promises sh quoting */
/* propagate command exit status as child exit status */
if (!WIFEXITED(status)) { /* child exits nonzero if command does */
exit(1);
} else {
exit(WEXITSTATUS(status));
}
}
}
/* otherwise, we're in parent */
close(pipefd[1]); /* close write side of pipe */
if ((p=fdopen(pipefd[0], "r"))==NULL) {
perror("fdopen");
do_exit(5);
}
for (y = show_title; y < height; y++) {
int eolseen = 0, tabpending = 0;
wint_t carry = WEOF;
for (x = 0; x < width; x++) {
wint_t c = L' ';
int attr = 0;
if (!eolseen) {
/* if there is a tab pending, just spit spaces until the
next stop instead of reading characters */
if (!tabpending)
do {
if(carry == WEOF) {
c = my_getwc(p);
}else{
c = carry;
carry = WEOF;
}
}while (c != WEOF && !isprint(c) && c<128
&& wcwidth(c) == 0
&& c != L'\n'
&& c != L'\t'
&& (c != L'\033' || option_color != 1));
if (c == L'\033' && option_color == 1) {
x--;
process_ansi(p);
continue;
}
if (c == L'\n')
if (!oldeolseen && x == 0) {
x = -1;
continue;
} else
eolseen = 1;
else if (c == L'\t')
tabpending = 1;
if (x==width-1 && wcwidth(c)==2) {
y++;
x = -1; //process this double-width
carry = c; //character on the next line
continue; //because it won't fit here
}
if (c == WEOF || c == L'\n' || c == L'\t')
c = L' ';
if (tabpending && (((x + 1) % 8) == 0))
tabpending = 0;
}
move(y, x);
if (option_differences) {
cchar_t oldc;
in_wch(&oldc);
attr = !first_screen
&& ((wchar_t)c != oldc.chars[0]
||
(option_differences_cumulative
&& (oldc.attr & A_ATTRIBUTES)));
}
if (attr)
standout();
addnwstr((wchar_t*)&c,1);
if (attr)
standend();
if(wcwidth(c) == 0) { x--; }
if(wcwidth(c) == 2) { x++; }
}
oldeolseen = eolseen;
}
fclose(p);
/* harvest child process and get status, propagated from command */
if (waitpid(child, &status, 0)<0) {
perror("waitpid");
do_exit(8);
};
/* if child process exited in error, beep if option_beep is set */
if ((!WIFEXITED(status) || WEXITSTATUS(status))) {
if (option_beep) beep();
if (option_errexit) do_exit(8);
}
first_screen = 0;
refresh();
if (precise_timekeeping) {
watch_usec_t cur_time = get_time_usec();
next_loop += USECS_PER_SEC*interval;
if (cur_time < next_loop)
usleep(next_loop - cur_time);
} else
usleep(interval * 1000000);
}
endwin();
return 0;
}
