curses 1.6.1 → 1.7.0

data/vendor/PDCursesMod/plan9/pdcutil.c

@@ -0,0 +1,370 @@
+#define _LOCK_EXTENSION
+#define _QLOCK_EXTENSION
+#define _PLAN9_SOURCE
+#define _RESEARCH_SOURCE
+#include <sys/types.h>
+#include <lock.h>
+#include <qlock.h>
+#include <lib9.h>
+#include <stdlib.h>
+#include <string.h>
+#include <bsd.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <assert.h>
+#include <utf.h>
+#include <fmt.h>
+#include <signal.h>
+#include <select.h>
+#include <sys/time.h>
+
+#define border curborder
+#include <curspriv.h>
+#undef border       /* conflicts with draw.h */
+#include <draw.h>
+#include <event.h>
+#include <keyboard.h>
+#include "pdcplan9.h"
+
+enum {
+	Ncolors = 18,
+	Eresized = 3,
+};
+
+uint rgbacolors[Ncolors] = {
+	0x000000FF,		/* black */
+	0x0000FFFF,		/* blue */
+	0x00AA00FF,		/* green */
+	0x00AAAAFF,		/* cyan */
+	0xAA0000FF,		/* red */
+	0xAA00AAFF,		/* purple */
+	0xFF5500FF,		/* brown */
+	0x7F7F7FFF,		/* white */
+	0x555555FF,		/* light black aka grey */
+	0x5555FFFF,		/* light blue */
+	0x55FF55FF,		/* light green */
+	0x55FFFFFF,		/* light cyan */
+	0xFF5555FF,		/* light red */
+	0xFF55FFFF,		/* light purple */
+	0xFFFF55FF,		/* light brown aka yellow */
+	0xFFFFFFFF,		/* light grey aka white */
+	0x9EEEEFF,
+	0x9EE9EFF,
+};
+
+static Image *colors[Ncolors];
+
+static void fatal(char *s)
+{
+	fprint(2, "curses: %s: %r\n", s);
+	abort();
+}
+
+
+void p9napms(int ms)
+{
+    _SLEEP(ms);
+}
+
+
+void p9setlabel(char *s)
+{
+	int fd;
+
+	fd = open("/dev/label", 1);
+	if (fd >= 0)
+	{
+		fprint(fd, "%s", s);
+		close(fd);
+	}
+}
+
+
+void p9resize(int nl, int nc)
+{
+	int fd;
+
+	fd = open("/dev/wctl", 1);
+	if (fd >= 0)
+	{
+		fprint(fd, "resize -dx %d -dy %d",
+		       nc * stringwidth(font, "0") + 8, nl * font->height + 8);
+		close(fd);
+	}
+}
+
+
+int p9getrows(void)
+{
+	return Dy(screen->r) / font->height;
+}
+
+
+int p9getcols(void)
+{
+	return Dx(screen->r) / stringwidth(font, "0");
+}
+
+
+#define ms SP->mouse_status
+static void setms(Mouse m)
+{
+	static uint clickmsec;
+	MOUSE_STATUS oldms;
+	int but, b, x, y;
+
+	oldms = ms;
+	memset(&ms, 0, sizeof(ms));
+	ms.x = (m.xy.x - screen->r.min.x) / stringwidth(font, "0");
+	ms.y = (m.xy.y - screen->r.min.y) / font->height;
+	if (ms.x != oldms.x || ms.y != oldms.y)
+		ms.changes |= PDC_MOUSE_MOVED;
+
+	/*scroll wheel */
+	if (m.buttons & (8 | 16))
+	{
+		if (m.buttons & 8)
+			ms.changes |= PDC_MOUSE_WHEEL_UP;
+		else
+			ms.changes |= PDC_MOUSE_WHEEL_DOWN;
+		return;
+	}
+	but = 0;
+	if (m.buttons & 1)
+		but = 1;
+	else if (m.buttons & 2)
+		but = 2;
+	else if (m.buttons & 4)
+		but = 3;
+
+	if (but == 0)
+		return;
+
+	b = m.buttons;
+	if (m.msec - clickmsec < 500)
+	{
+		ms.button[but - 1] = BUTTON_DOUBLE_CLICKED;
+		x = m.xy.x;
+		y = m.xy.y;
+		/* stay here until something interesting happens */
+		do
+			m = emouse();
+		while (m.buttons == b && abs(m.xy.x - x) < 3
+		       && abs(m.xy.y - y) < 3);
+	}
+	if (m.buttons == b)
+	{
+		uint msec = m.msec;
+		do
+			m = emouse();
+		while (m.buttons == b);
+		if (m.msec - msec < 250)
+			ms.button[but - 1] = BUTTON_CLICKED;
+		else
+			ms.button[but - 1] = BUTTON_PRESSED;
+	}
+	if (oldms.x == ms.x && oldms.y == ms.y)
+	{
+		if (m.msec - clickmsec < 500)
+			ms.button[but - 1] = BUTTON_DOUBLE_CLICKED;
+		else
+			clickmsec = m.msec;
+	}
+	/* choording should be here */
+	while (m.buttons == b)
+		m = emouse();
+
+	ms.changes |= 1 << (but - 1);
+}
+#undef ms
+
+
+static int transk(Rune k)
+{
+	switch (k)
+	{
+	case Khome:
+		return KEY_HOME;
+	case Kup:
+		return KEY_UP;
+	case Kpgup:
+		return KEY_PPAGE;
+	case Kprint:
+		return KEY_PRINT;
+	case Kleft:
+		return KEY_LEFT;
+	case Kright:
+		return KEY_RIGHT;
+	case Kdown:
+		return KEY_DOWN;
+	case Kpgdown:
+		return KEY_NPAGE;
+	case Kins:
+		return KEY_IC;
+	case Kend:
+		return KEY_END;
+	default:
+		return k;
+	}
+}
+
+static int resized;
+
+void eresized(int)
+{
+	if (getwindow(display, Refnone) < 0)
+		fatal("can't reattach to window");
+
+	draw(screen, screen->r, display->black, nil, ZP);
+	resized = TRUE;
+}
+
+
+int p9ecan(void)
+{
+	return ecanread(Ekeyboard | Emouse);
+}
+
+
+int p9eget(void)
+{
+	char c;
+	Event e;
+	int x = 0;
+
+	if (resized)
+	{
+		resized = FALSE;
+		SP->resized = TRUE;
+		x = KEY_RESIZE;
+	}
+	switch (event(&e))
+	{
+	case Emouse:
+		setms(e.mouse);
+		x = KEY_MOUSE;
+	case Ekeyboard:
+		if (e.kbdc == Kdel)
+			raise(SIGINT);
+		x = transk(e.kbdc);
+	};
+	return x;
+}
+
+void p9init(void)
+{
+	int i;
+
+	if (initdraw(0, "/lib/font/bit/fixed/unicode.9x15.font", "curses") < 0)
+		fatal("can't open display");
+
+	draw(screen, screen->r, display->black, nil, ZP);
+	einit(Ekeyboard | Emouse);
+	for (i = 0; i < Ncolors; i++)
+	{
+		colors[i] =
+		    allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1,
+			       rgbacolors[i]);
+		if (colors[i] == nil)
+			fatal("can't allocate image");
+	}
+}
+
+static Point getcur(int y, int x)
+{
+	Point p;
+
+	p.x = screen->r.min.x + stringwidth(font, "0") * x;
+	p.y = screen->r.min.y + font->height * y;
+
+	return p;
+}
+
+
+void p9putc(int y, int x, chtype ch)
+{
+	chtype attr;
+	int c, t;
+	short fg, bg;
+	Point p0, p1;
+	Rune buf[1];
+
+	attr = ch & A_ATTRIBUTES;
+	if (pair_content(PAIR_NUMBER(attr), &fg, &bg) == ERR)
+	{
+		fg = COLOR_WHITE;
+		bg = COLOR_BLACK;
+	}
+
+	fg |= attr & A_BOLD ? 8 : 0;
+	bg |= attr & A_BLINK ? 8 : 0;
+	if (attr & A_REVERSE)
+	{
+		t = fg;
+		fg = bg;
+		bg = t;
+	}
+	if( _is_altcharset( ch))
+		ch = acs_map[ch & 0x7f];
+
+	c = ch & A_CHARTEXT;
+
+	buf[0] = c;
+	p0 = getcur(y, x);
+	runestringnbg(screen, p0, colors[fg], ZP, font, buf, 1, colors[bg], ZP);
+	if (attr & A_UNDERLINE)
+	{
+		p1 = p0;
+		p1.x += runestringnwidth(font, buf, 1);
+		line(screen, p0, p1, Enddisc, Enddisc, 0, colors[fg], ZP);
+	}
+}
+
+
+void p9setcur(int oy, int ox, int y, int x, int vis)
+{
+	Image *c;
+	chtype *ch;
+	Point p;
+
+	ch = curscr->_y[oy] + ox;
+	p9putc(oy, ox, *ch);
+	if (vis == 0)
+		return;
+
+	if (vis == 1)
+		c = colors[Ncolors - 2];
+	else
+		c = colors[Ncolors - 1];
+
+	p = getcur(y, x);
+	draw(screen,
+	     Rect(p.x, p.y + font->height - 2, p.x + stringwidth(font, "0"),
+		  p.y + font->height), c, nil, ZP);
+
+	flushimage(display, 1);
+}
+
+void PDC_beep(void)
+{
+	PDC_LOG(("PDC_beep() - called\n"));
+}
+
+
+void PDC_napms(int ms)
+{
+	PDC_LOG(("PDC_napms() - called\n"));
+	p9napms(ms);
+}
+
+
+const char *PDC_sysname(void)
+{
+	PDC_LOG(("PDC_sysname() - called\n"));
+
+	return "PLAN9";
+}
+
+enum PDC_port PDC_port_val = PDC_PORT_PLAN9;
+
+

data/vendor/PDCursesMod/psffonts/README

@@ -0,0 +1,38 @@
+Fonts for PDCurses for SDL
+==========================
+
+Since PDCurses for SDL uses its own font format, you probably don't have 
+any ready to use. Here are a few to get you started. The ones in the 
+top-level directory are as follows:
+
+10x20.bmp	- From the 10x20 font that comes with Xorg
+6x12.bmp	- From Xorg
+9x18.bmp	- From Xorg
+default.bmp	- PDCurses' default font, from pc8x16s.bdf in the
+		  vgafonts.tar.gz package
+lc12x20.bmp	- Lucida Console at 12x20
+18x18.bmp	- From Xorg
+8x13.bmp	- From Xorg
+cour11x17.bmp	- From Xorg -- Courier
+dosemu.bmp	- DOSEmu's default font (8x16)
+medieval2.bmp	- I always liked the "medieval" font (see fntcol16); 
+		  this is an enlarged (16x28), smoothed version
+4x6.bmp		- From Xorg
+9x15.bmp	- From Xorg
+cour20x29.bmp	- From Xorg -- Courier
+vga11x19.bmp	- From vgafonts, which says it's Lucida Sans Typewriter
+
+In addition, the fntcol16 directory contains most of the fonts from the 
+fntcol16.zip package. These are all 8 pixels wide, with the height given 
+in the filename (e.g., modern-16.bmp).
+
+
+Distribution Status
+-------------------
+
+I'll let copyleft.txt in the fntcol16 directory explain the situation, 
+and just add that I don't claim any copyright on the compilation, 
+either.
+
+-- William McBrine
+   July 11, 2007

data/vendor/PDCursesMod/psffonts/README.md

@@ -0,0 +1,14 @@
+PSF2 fonts
+==========
+
+At present,  these fonts work only with the Linux framebuffer port.  It is likely that they'll eventually be used with SDLn and DOSVGA,  and possibly others,  thereby enabling a lot of redundant code to be consolidated.
+
+SDLn in non-wide mode uses its own font format,  in which the font is a monochrome Microsoft(R) Windows .bmp file,  with 32 characters across and eight down.  For example,  this is the default SDLn font :
+
+![image](https://www.projectpluto.com/temp/pdc_default_font.bmp)
+
+At one time,  a [wide selection of SDL fonts](https://sourceforge.net/projects/pdcurses/files/sdlfonts/1.0/sdlfonts.zip/download) was distributed with PDCurses.  The `bmp2psf2` program was written to convert SDL-formatted fonts into the [`psf2` format](https://www.win.tue.nl/~aeb/linux/kbd/font-formats-1.html).  `psf2` is more widely used and allows for more than 256 glyphs (in fact,  up to 2^32-1 glyphs,  with Unicode information.)
+
+This directory contains the SDL fonts after conversion to the `psf2` format.  See the [README file](README) for details on which fonts are which,  history,  and copyright/licence info.
+
+[Tools are available elsewhere for manipulating/converting `psf2` fonts.](https://www.seasip.info/Unix/PSF/)

data/vendor/PDCursesMod/psffonts/bmp2psf2.c

@@ -0,0 +1,130 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+
+/* Code to convert SDL fonts for PDCurses into the more generally
+useful PSF2 format.  The SDL fonts are Microsoft(R) .bmp files,
+with one bit per pixel.  If you load up the bitmap into a viewing
+program,  you'll see 256 glyphs arranged in 8 rows of 32 columns.
+Thus,  if the glyphs are xpix pixels wide and ypix high,  the .bmp
+will be 32*xpix wide and 8*ypix high.
+
+   This program will read in one or more .bmp files,  reverse the
+above math to determine glyph sizes from the .bmp size,  and write
+out a PSF2-formatted font file.  */
+
+#define PSF2_MAGIC0     0x72
+#define PSF2_MAGIC1     0xb5
+#define PSF2_MAGIC2     0x4a
+#define PSF2_MAGIC3     0x86
+
+/* bits used in flags */
+#define PSF2_HAS_UNICODE_TABLE 0x01
+
+/* max version recognized so far */
+#define PSF2_MAXVERSION 0
+
+/* UTF8 separators */
+#define PSF2_SEPARATOR  0xFF
+#define PSF2_STARTSEQ   0xFE
+
+struct psf2_header {
+        uint8_t magic[4];
+        uint32_t version;
+        uint32_t headersize;    /* offset of bitmaps in file */
+        uint32_t flags;
+        uint32_t length;        /* number of glyphs */
+        uint32_t charsize;      /* number of bytes for each character */
+        uint32_t height, width; /* max dimensions of glyphs */
+        /* charsize = height * ((width + 7) / 8) */
+};
+
+#define BIT_SET( buff, n) ((buff[(n) >> 3] << ((n) & 7)) & 0x80)
+
+static void set_up_psf2_header( struct psf2_header *hdr, const int height, const int width)
+{
+   hdr->magic[0] = PSF2_MAGIC0;
+   hdr->magic[1] = PSF2_MAGIC1;
+   hdr->magic[2] = PSF2_MAGIC2;
+   hdr->magic[3] = PSF2_MAGIC3;
+   hdr->version = 0;
+   hdr->headersize = sizeof( struct psf2_header);
+   hdr->flags = 0;
+   hdr->length = 256;
+   hdr->charsize = (uint32_t)( height * ((width + 7) / 8));
+   hdr->height = (uint32_t)height;
+   hdr->width = (uint32_t)width;
+}
+
+static int convert_bmp_font_to_psf2( const char *bmp_filename)
+{
+   FILE *ifile = fopen( bmp_filename, "rb"), *ofile;
+   int32_t header_size, width, height;
+   size_t glyph_size;
+   char buff[62];
+   uint8_t *glyphs;
+   int i, j;
+   struct psf2_header hdr;
+
+   assert( ifile);
+   if( fread( buff, sizeof( buff), 1, ifile) != 1)
+      assert( 0);
+   assert( buff[0] == 'B');
+   assert( buff[1] == 'M');
+   memcpy( &header_size, buff + 14, sizeof( int32_t));
+   memcpy( &width, buff + 18, sizeof( int32_t));
+   memcpy( &height, buff + 22, sizeof( int32_t));
+   printf( "Width %d  height %d  header len %d\n", (int)width, (int)height, (int)header_size);
+   glyph_size = (size_t)( width * height / 8);
+   printf( "Image size should be %d\n", 62 + (int)glyph_size);
+   glyphs = (uint8_t *)malloc( glyph_size);
+   if( fread( glyphs, glyph_size, 1, ifile) != 1)
+      assert( 0);
+   fclose( ifile);
+
+   strcpy( buff, bmp_filename);
+   strcpy( strstr( buff, ".bmp"), ".psf");
+   ofile = fopen( buff, "wb");
+   assert( ofile);
+   width /= 32;      /* cvt from BMP size to size,  in pixels,  of the */
+   height /= 8;      /* individual glyphs in the BMP */
+   set_up_psf2_header( &hdr, height, width);
+   if( fwrite( &hdr, sizeof( hdr), 1, ofile) != 1)
+      assert( 0);
+   for( i = 0; i < 256; i++)
+      for( j = 0; j < height; j++)
+         {
+         int x, x1 = (i % 32) * width, k;
+         int line_no = 8 * height - 1 - j - (i / 32) * height;
+         uint8_t *line_ptr = glyphs + line_no * width * 32 / 8;
+
+         assert( line_ptr < glyphs + glyph_size);
+         assert( line_ptr >= glyphs);
+         for( k = 0; k < (width + 7) / 8; k++)
+            {
+            uint8_t output_byte = 0;
+            int n_bits = width - k * 8;
+
+            if( n_bits > 8)
+               n_bits = 8;
+            for( x = 0; x < n_bits; x++, x1++)
+               if( BIT_SET( line_ptr, x1))
+                  output_byte ^= (uint8_t)(0x80 >> x);
+            if( fwrite( &output_byte, 1, 1, ofile) != 1)
+               assert( 0);
+            }
+         }
+   fclose( ofile);
+   return( 0);
+}
+
+int main( const int argc, const char **argv)
+{
+   int i;
+
+   for( i = 1; i < argc; i++)
+      convert_bmp_font_to_psf2( argv[i]);
+   return( 0);
+}