diff options
Diffstat (limited to 'lib/libvgl')
| -rw-r--r-- | lib/libvgl/Makefile | 42 | ||||
| -rw-r--r-- | lib/libvgl/Makefile.depend | 15 | ||||
| -rw-r--r-- | lib/libvgl/bitmap.c | 314 | ||||
| -rw-r--r-- | lib/libvgl/keyboard.c | 94 | ||||
| -rw-r--r-- | lib/libvgl/main.c | 529 | ||||
| -rw-r--r-- | lib/libvgl/mouse.c | 421 | ||||
| -rw-r--r-- | lib/libvgl/simple.c | 686 | ||||
| -rw-r--r-- | lib/libvgl/text.c | 249 | ||||
| -rw-r--r-- | lib/libvgl/vgl.3 | 469 | ||||
| -rw-r--r-- | lib/libvgl/vgl.h | 161 |
10 files changed, 2980 insertions, 0 deletions
diff --git a/lib/libvgl/Makefile b/lib/libvgl/Makefile new file mode 100644 index 000000000000..e679b82db369 --- /dev/null +++ b/lib/libvgl/Makefile @@ -0,0 +1,42 @@ +PACKAGE=lib${LIB} +LIB= vgl +SHLIB_MAJOR= 6 +CFLAGS+=-Wall -I${.CURDIR} +SRCS= main.c simple.c bitmap.c text.c mouse.c keyboard.c +INCS= vgl.h +MAN= vgl.3 +WARNS?= 2 +MLINKS+= vgl.3 VGLBitmapAllocateBits.3 \ + vgl.3 VGLBitmapCopy.3 \ + vgl.3 VGLBitmapCreate.3 \ + vgl.3 VGLBitmapDestroy.3 \ + vgl.3 VGLBitmapPutChar.3 \ + vgl.3 VGLBitmapString.3 \ + vgl.3 VGLBlankDisplay.3 \ + vgl.3 VGLBox.3 \ + vgl.3 VGLCheckSwitch.3 \ + vgl.3 VGLClear.3 \ + vgl.3 VGLEllipse.3 \ + vgl.3 VGLEnd.3 \ + vgl.3 VGLFilledBox.3 \ + vgl.3 VGLFilledEllipse.3 \ + vgl.3 VGLGetXY.3 \ + vgl.3 VGLInit.3 \ + vgl.3 VGLLine.3 \ + vgl.3 VGLKeyboardInit.3 \ + vgl.3 VGLKeyboardEnd.3 \ + vgl.3 VGLKeyboardGetCh.3 \ + vgl.3 VGLMouseInit.3 \ + vgl.3 VGLMouseMode.3 \ + vgl.3 VGLMouseSetImage.3 \ + vgl.3 VGLMouseSetStdImage.3 \ + vgl.3 VGLMouseStatus.3 \ + vgl.3 VGLPanScreen.3 \ + vgl.3 VGLSetBorder.3 \ + vgl.3 VGLSetPalette.3 \ + vgl.3 VGLSetPaletteIndex.3 \ + vgl.3 VGLSetVScreenSize.3 \ + vgl.3 VGLSetXY.3 \ + vgl.3 VGLTextSetFontFile.3 + +.include <bsd.lib.mk> diff --git a/lib/libvgl/Makefile.depend b/lib/libvgl/Makefile.depend new file mode 100644 index 000000000000..6ef78fac5cbf --- /dev/null +++ b/lib/libvgl/Makefile.depend @@ -0,0 +1,15 @@ +# Autogenerated - do NOT edit! + +DIRDEPS = \ + include \ + include/xlocale \ + lib/${CSU_DIR} \ + lib/libc \ + lib/libcompiler_rt \ + + +.include <dirdeps.mk> + +.if ${DEP_RELDIR} == ${_DEP_RELDIR} +# local dependencies - needed for -jN in clean tree +.endif diff --git a/lib/libvgl/bitmap.c b/lib/libvgl/bitmap.c new file mode 100644 index 000000000000..2beeb8ee68c4 --- /dev/null +++ b/lib/libvgl/bitmap.c @@ -0,0 +1,314 @@ +/*- + * SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (c) 1991-1997 Søren Schmidt + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer, + * in this position and unchanged. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <sys/types.h> +#include <signal.h> +#include <sys/fbio.h> +#include "vgl.h" + +#define min(x, y) (((x) < (y)) ? (x) : (y)) + +static byte mask[8] = {0xff, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01}; +static int color2bit[16] = {0x00000000, 0x00000001, 0x00000100, 0x00000101, + 0x00010000, 0x00010001, 0x00010100, 0x00010101, + 0x01000000, 0x01000001, 0x01000100, 0x01000101, + 0x01010000, 0x01010001, 0x01010100, 0x01010101}; + +static void +WriteVerticalLine(VGLBitmap *dst, int x, int y, int width, byte *line) +{ + int bwidth, i, pos, last, planepos, start_offset, end_offset, offset; + int len; + unsigned int word = 0; + byte *address; + byte *VGLPlane[4]; + + switch (dst->Type) { + case VIDBUF4: + case VIDBUF4S: + start_offset = (x & 0x07); + end_offset = (x + width) & 0x07; + bwidth = (width + start_offset) / 8; + if (end_offset) + bwidth++; + VGLPlane[0] = VGLBuf; + VGLPlane[1] = VGLPlane[0] + bwidth; + VGLPlane[2] = VGLPlane[1] + bwidth; + VGLPlane[3] = VGLPlane[2] + bwidth; + pos = 0; + planepos = 0; + last = 8 - start_offset; + while (pos < width) { + word = 0; + while (pos < last && pos < width) + word = (word<<1) | color2bit[line[pos++]&0x0f]; + VGLPlane[0][planepos] = word; + VGLPlane[1][planepos] = word>>8; + VGLPlane[2][planepos] = word>>16; + VGLPlane[3][planepos] = word>>24; + planepos++; + last += 8; + } + planepos--; + if (end_offset) { + word <<= (8 - end_offset); + VGLPlane[0][planepos] = word; + VGLPlane[1][planepos] = word>>8; + VGLPlane[2][planepos] = word>>16; + VGLPlane[3][planepos] = word>>24; + } + outb(0x3ce, 0x01); outb(0x3cf, 0x00); /* set/reset enable */ + outb(0x3ce, 0x08); outb(0x3cf, 0xff); /* bit mask */ + for (i=0; i<4; i++) { + outb(0x3c4, 0x02); + outb(0x3c5, 0x01<<i); + outb(0x3ce, 0x04); + outb(0x3cf, i); + pos = VGLAdpInfo.va_line_width*y + x/8; + if (dst->Type == VIDBUF4) { + if (end_offset) + VGLPlane[i][planepos] |= dst->Bitmap[pos+planepos] & mask[end_offset]; + if (start_offset) + VGLPlane[i][0] |= dst->Bitmap[pos] & ~mask[start_offset]; + bcopy(&VGLPlane[i][0], dst->Bitmap + pos, bwidth); + } else { /* VIDBUF4S */ + if (end_offset) { + offset = VGLSetSegment(pos + planepos); + VGLPlane[i][planepos] |= dst->Bitmap[offset] & mask[end_offset]; + } + offset = VGLSetSegment(pos); + if (start_offset) + VGLPlane[i][0] |= dst->Bitmap[offset] & ~mask[start_offset]; + for (last = bwidth; ; ) { + len = min(VGLAdpInfo.va_window_size - offset, last); + bcopy(&VGLPlane[i][bwidth - last], dst->Bitmap + offset, len); + pos += len; + last -= len; + if (last <= 0) + break; + offset = VGLSetSegment(pos); + } + } + } + break; + case VIDBUF8X: + address = dst->Bitmap + VGLAdpInfo.va_line_width * y + x/4; + for (i=0; i<4; i++) { + outb(0x3c4, 0x02); + outb(0x3c5, 0x01 << ((x + i)%4)); + for (planepos=0, pos=i; pos<width; planepos++, pos+=4) + address[planepos] = line[pos]; + if ((x + i)%4 == 3) + ++address; + } + break; + case VIDBUF8S: + case VIDBUF16S: + case VIDBUF24S: + case VIDBUF32S: + width = width * dst->PixelBytes; + pos = (dst->VXsize * y + x) * dst->PixelBytes; + while (width > 0) { + offset = VGLSetSegment(pos); + i = min(VGLAdpInfo.va_window_size - offset, width); + bcopy(line, dst->Bitmap + offset, i); + line += i; + pos += i; + width -= i; + } + break; + case MEMBUF: + case VIDBUF8: + case VIDBUF16: + case VIDBUF24: + case VIDBUF32: + address = dst->Bitmap + (dst->VXsize * y + x) * dst->PixelBytes; + bcopy(line, address, width * dst->PixelBytes); + break; + default: + ; + } +} + +int +__VGLBitmapCopy(VGLBitmap *src, int srcx, int srcy, + VGLBitmap *dst, int dstx, int dsty, int width, int hight) +{ + byte *buffer, *p; + int mousemerge, srcline, dstline, yend, yextra, ystep; + + mousemerge = 0; + if (hight < 0) { + hight = -hight; + mousemerge = (dst == VGLDisplay && + VGLMouseOverlap(dstx, dsty, width, hight)); + if (mousemerge) + buffer = alloca(width*src->PixelBytes); + } + if (srcx>src->VXsize || srcy>src->VYsize + || dstx>dst->VXsize || dsty>dst->VYsize) + return -1; + if (srcx < 0) { + width=width+srcx; dstx-=srcx; srcx=0; + } + if (srcy < 0) { + hight=hight+srcy; dsty-=srcy; srcy=0; + } + if (dstx < 0) { + width=width+dstx; srcx-=dstx; dstx=0; + } + if (dsty < 0) { + hight=hight+dsty; srcy-=dsty; dsty=0; + } + if (srcx+width > src->VXsize) + width=src->VXsize-srcx; + if (srcy+hight > src->VYsize) + hight=src->VYsize-srcy; + if (dstx+width > dst->VXsize) + width=dst->VXsize-dstx; + if (dsty+hight > dst->VYsize) + hight=dst->VYsize-dsty; + if (width < 0 || hight < 0) + return -1; + yend = srcy + hight; + yextra = 0; + ystep = 1; + if (src->Bitmap == dst->Bitmap && srcy < dsty) { + yend = srcy - 1; + yextra = hight - 1; + ystep = -1; + } + for (srcline = srcy + yextra, dstline = dsty + yextra; srcline != yend; + srcline += ystep, dstline += ystep) { + p = src->Bitmap+(srcline*src->VXsize+srcx)*dst->PixelBytes; + if (mousemerge && VGLMouseOverlap(dstx, dstline, width, 1)) { + bcopy(p, buffer, width*src->PixelBytes); + p = buffer; + VGLMouseMerge(dstx, dstline, width, p); + } + WriteVerticalLine(dst, dstx, dstline, width, p); + } + return 0; +} + +int +VGLBitmapCopy(VGLBitmap *src, int srcx, int srcy, + VGLBitmap *dst, int dstx, int dsty, int width, int hight) +{ + int error; + + if (hight < 0) + return -1; + if (src == VGLDisplay) + src = &VGLVDisplay; + if (src->Type != MEMBUF) + return -1; /* invalid */ + if (dst == VGLDisplay) { + VGLMouseFreeze(); + __VGLBitmapCopy(src, srcx, srcy, &VGLVDisplay, dstx, dsty, width, hight); + error = __VGLBitmapCopy(src, srcx, srcy, &VGLVDisplay, dstx, dsty, + width, hight); + if (error != 0) + return error; + src = &VGLVDisplay; + srcx = dstx; + srcy = dsty; + } else if (dst->Type != MEMBUF) + return -1; /* invalid */ + error = __VGLBitmapCopy(src, srcx, srcy, dst, dstx, dsty, width, -hight); + if (dst == VGLDisplay) + VGLMouseUnFreeze(); + return error; +} + +VGLBitmap +*VGLBitmapCreate(int type, int xsize, int ysize, byte *bits) +{ + VGLBitmap *object; + + if (type != MEMBUF) + return NULL; + if (xsize < 0 || ysize < 0) + return NULL; + object = (VGLBitmap *)malloc(sizeof(*object)); + if (object == NULL) + return NULL; + object->Type = type; + object->Xsize = xsize; + object->Ysize = ysize; + object->VXsize = xsize; + object->VYsize = ysize; + object->Xorigin = 0; + object->Yorigin = 0; + object->Bitmap = bits; + object->PixelBytes = VGLDisplay->PixelBytes; + return object; +} + +void +VGLBitmapDestroy(VGLBitmap *object) +{ + if (object->Bitmap) + free(object->Bitmap); + free(object); +} + +int +VGLBitmapAllocateBits(VGLBitmap *object) +{ + object->Bitmap = malloc(object->VXsize*object->VYsize*object->PixelBytes); + if (object->Bitmap == NULL) + return -1; + return 0; +} + +void +VGLBitmapCvt(VGLBitmap *src, VGLBitmap *dst) +{ + u_long color; + int dstpos, i, pb, size, srcpb, srcpos; + + size = src->VXsize * src->VYsize; + srcpb = src->PixelBytes; + if (srcpb <= 0) + srcpb = 1; + pb = dst->PixelBytes; + if (pb == srcpb) { + bcopy(src->Bitmap, dst->Bitmap, size * pb); + return; + } + if (srcpb != 1) + return; /* not supported */ + for (srcpos = dstpos = 0; srcpos < size; srcpos++) { + color = VGLrgb332ToNative(src->Bitmap[srcpos]); + for (i = 0; i < pb; i++, color >>= 8) + dst->Bitmap[dstpos++] = color; + } +} diff --git a/lib/libvgl/keyboard.c b/lib/libvgl/keyboard.c new file mode 100644 index 000000000000..25399330dba5 --- /dev/null +++ b/lib/libvgl/keyboard.c @@ -0,0 +1,94 @@ +/*- + * SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (c) 1997 Søren Schmidt + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer + * in this position and unchanged. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <sys/cdefs.h> +#include <stdio.h> +#include <sys/types.h> +#include <sys/ioctl.h> +#include <termios.h> +#include <sys/time.h> +#include <sys/fbio.h> +#include <sys/kbio.h> +#include "vgl.h" + +static struct termios VGLKeyboardTty; +static int VGLKeyboardMode = -1; + +int +VGLKeyboardInit(int mode) +{ + static struct termios term; + + ioctl(0, KDGKBMODE, &VGLKeyboardMode); + tcgetattr(0, &VGLKeyboardTty); + + term = VGLKeyboardTty; + cfmakeraw(&term); + term.c_iflag = IGNPAR | IGNBRK; + term.c_oflag = OPOST | ONLCR; + term.c_cflag = CREAD | CS8; + term.c_lflag &= ~(ICANON | ECHO | ISIG); + term.c_cc[VTIME] = 0; + term.c_cc[VMIN] = 0; + cfsetispeed(&term, 9600); + cfsetospeed(&term, 9600); + tcsetattr(0, TCSANOW | TCSAFLUSH, &term); + + switch (mode) { + case VGL_RAWKEYS: + ioctl(0, KDSKBMODE, K_RAW); + break; + case VGL_CODEKEYS: + ioctl(0, KDSKBMODE, K_CODE); + break; + case VGL_XLATEKEYS: + ioctl(0, KDSKBMODE, K_XLATE); + break; + } + return 0; +} + +void +VGLKeyboardEnd() +{ + if (VGLKeyboardMode != -1) { + ioctl(0, KDSKBMODE, VGLKeyboardMode); + tcsetattr(0, TCSANOW | TCSAFLUSH, &VGLKeyboardTty); + } +} + +int +VGLKeyboardGetCh() +{ + unsigned char ch = 0; + + read (0, &ch, 1); + return (int)ch; +} diff --git a/lib/libvgl/main.c b/lib/libvgl/main.c new file mode 100644 index 000000000000..13e376c48417 --- /dev/null +++ b/lib/libvgl/main.c @@ -0,0 +1,529 @@ +/*- + * SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (c) 1991-1997 Søren Schmidt + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer + * in this position and unchanged. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <sys/cdefs.h> +#include <signal.h> +#include <stdio.h> +#include <sys/types.h> +#include <sys/file.h> +#include <sys/ioctl.h> +#include <sys/mman.h> +#include <sys/fbio.h> +#include <sys/kbio.h> +#include <sys/consio.h> +#include "vgl.h" + +#define min(x, y) (((x) < (y)) ? (x) : (y)) +#define max(x, y) (((x) > (y)) ? (x) : (y)) + +VGLBitmap *VGLDisplay; +VGLBitmap VGLVDisplay; +video_info_t VGLModeInfo; +video_adapter_info_t VGLAdpInfo; +byte *VGLBuf; + +static int VGLMode; +static int VGLOldMode; +static size_t VGLBufSize; +static byte *VGLMem = MAP_FAILED; +static int VGLSwitchPending; +static int VGLAbortPending; +static int VGLOnDisplay; +static unsigned int VGLCurWindow; +static int VGLInitDone = 0; +static video_info_t VGLOldModeInfo; +static vid_info_t VGLOldVInfo; +static int VGLOldVXsize; + +void +VGLEnd() +{ +struct vt_mode smode; + int size[3]; + + if (!VGLInitDone) + return; + VGLInitDone = 0; + signal(SIGUSR1, SIG_IGN); + signal(SIGUSR2, SIG_IGN); + VGLSwitchPending = 0; + VGLAbortPending = 0; + VGLMouseMode(VGL_MOUSEHIDE); + + if (VGLMem != MAP_FAILED) { + VGLClear(VGLDisplay, 0); + munmap(VGLMem, VGLAdpInfo.va_window_size); + } + + ioctl(0, FBIO_SETLINEWIDTH, &VGLOldVXsize); + + if (VGLOldMode >= M_VESA_BASE) + ioctl(0, _IO('V', VGLOldMode - M_VESA_BASE), 0); + else + ioctl(0, _IO('S', VGLOldMode), 0); + if (VGLOldModeInfo.vi_flags & V_INFO_GRAPHICS) { + size[0] = VGLOldVInfo.mv_csz; + size[1] = VGLOldVInfo.mv_rsz; + size[2] = VGLOldVInfo.font_size; + ioctl(0, KDRASTER, size); + } + if (VGLModeInfo.vi_mem_model != V_INFO_MM_DIRECT) + ioctl(0, KDDISABIO, 0); + ioctl(0, KDSETMODE, KD_TEXT); + smode.mode = VT_AUTO; + ioctl(0, VT_SETMODE, &smode); + if (VGLBuf) + free(VGLBuf); + VGLBuf = NULL; + free(VGLDisplay); + VGLDisplay = NULL; + VGLKeyboardEnd(); +} + +static void +VGLAbort(int arg) +{ + sigset_t mask; + + VGLAbortPending = 1; + signal(SIGINT, SIG_IGN); + signal(SIGTERM, SIG_IGN); + signal(SIGUSR2, SIG_IGN); + if (arg == SIGBUS || arg == SIGSEGV) { + signal(arg, SIG_DFL); + sigemptyset(&mask); + sigaddset(&mask, arg); + sigprocmask(SIG_UNBLOCK, &mask, NULL); + VGLEnd(); + kill(getpid(), arg); + } +} + +static void +VGLSwitch(int arg __unused) +{ + if (!VGLOnDisplay) + VGLOnDisplay = 1; + else + VGLOnDisplay = 0; + VGLSwitchPending = 1; + signal(SIGUSR1, VGLSwitch); +} + +int +VGLInit(int mode) +{ + struct vt_mode smode; + int adptype, depth; + + if (VGLInitDone) + return -1; + + signal(SIGUSR1, VGLSwitch); + signal(SIGINT, VGLAbort); + signal(SIGTERM, VGLAbort); + signal(SIGSEGV, VGLAbort); + signal(SIGBUS, VGLAbort); + signal(SIGUSR2, SIG_IGN); + + VGLOnDisplay = 1; + VGLSwitchPending = 0; + VGLAbortPending = 0; + + if (ioctl(0, CONS_GET, &VGLOldMode) || ioctl(0, CONS_CURRENT, &adptype)) + return -1; + if (IOCGROUP(mode) == 'V') /* XXX: this is ugly */ + VGLModeInfo.vi_mode = (mode & 0x0ff) + M_VESA_BASE; + else + VGLModeInfo.vi_mode = mode & 0x0ff; + if (ioctl(0, CONS_MODEINFO, &VGLModeInfo)) /* FBIO_MODEINFO */ + return -1; + + /* Save info for old mode to restore font size if old mode is graphics. */ + VGLOldModeInfo.vi_mode = VGLOldMode; + if (ioctl(0, CONS_MODEINFO, &VGLOldModeInfo)) + return -1; + VGLOldVInfo.size = sizeof(VGLOldVInfo); + if (ioctl(0, CONS_GETINFO, &VGLOldVInfo)) + return -1; + + VGLDisplay = (VGLBitmap *)malloc(sizeof(VGLBitmap)); + if (VGLDisplay == NULL) + return -2; + + if (VGLModeInfo.vi_mem_model != V_INFO_MM_DIRECT && ioctl(0, KDENABIO, 0)) { + free(VGLDisplay); + return -3; + } + + VGLInitDone = 1; + + /* + * vi_mem_model specifies the memory model of the current video mode + * in -CURRENT. + */ + switch (VGLModeInfo.vi_mem_model) { + case V_INFO_MM_PLANAR: + /* we can handle EGA/VGA planner modes only */ + if (VGLModeInfo.vi_depth != 4 || VGLModeInfo.vi_planes != 4 + || (adptype != KD_EGA && adptype != KD_VGA)) { + VGLEnd(); + return -4; + } + VGLDisplay->Type = VIDBUF4; + VGLDisplay->PixelBytes = 1; + break; + case V_INFO_MM_PACKED: + /* we can do only 256 color packed modes */ + if (VGLModeInfo.vi_depth != 8) { + VGLEnd(); + return -4; + } + VGLDisplay->Type = VIDBUF8; + VGLDisplay->PixelBytes = 1; + break; + case V_INFO_MM_VGAX: + VGLDisplay->Type = VIDBUF8X; + VGLDisplay->PixelBytes = 1; + break; + case V_INFO_MM_DIRECT: + VGLDisplay->PixelBytes = VGLModeInfo.vi_pixel_size; + switch (VGLDisplay->PixelBytes) { + case 2: + VGLDisplay->Type = VIDBUF16; + break; + case 3: + VGLDisplay->Type = VIDBUF24; + break; + case 4: + VGLDisplay->Type = VIDBUF32; + break; + default: + VGLEnd(); + return -4; + } + break; + default: + VGLEnd(); + return -4; + } + + ioctl(0, VT_WAITACTIVE, 0); + ioctl(0, KDSETMODE, KD_GRAPHICS); + if (ioctl(0, mode, 0)) { + VGLEnd(); + return -5; + } + if (ioctl(0, CONS_ADPINFO, &VGLAdpInfo)) { /* FBIO_ADPINFO */ + VGLEnd(); + return -6; + } + + /* + * Calculate the shadow screen buffer size. In -CURRENT, va_buffer_size + * always holds the entire frame buffer size, wheather it's in the linear + * mode or windowed mode. + * VGLBufSize = VGLAdpInfo.va_buffer_size; + * In -STABLE, va_buffer_size holds the frame buffer size, only if + * the linear frame buffer mode is supported. Otherwise the field is zero. + * We shall calculate the minimal size in this case: + * VGLAdpInfo.va_line_width*VGLModeInfo.vi_height*VGLModeInfo.vi_planes + * or + * VGLAdpInfo.va_window_size*VGLModeInfo.vi_planes; + * Use whichever is larger. + */ + if (VGLAdpInfo.va_buffer_size != 0) + VGLBufSize = VGLAdpInfo.va_buffer_size; + else + VGLBufSize = max(VGLAdpInfo.va_line_width*VGLModeInfo.vi_height, + VGLAdpInfo.va_window_size)*VGLModeInfo.vi_planes; + /* + * The above is for old -CURRENT. Current -CURRENT since r203535 and/or + * r248799 restricts va_buffer_size to the displayed size in VESA modes to + * avoid wasting kva for mapping unused parts of the frame buffer. But all + * parts were usable here. Applying the same restriction to user mappings + * makes our virtualization useless and breaks our panning, but large frame + * buffers are also difficult for us to manage (clearing and switching may + * be too slow, and malloc() may fail). Restrict ourselves similarly to + * get the same efficiency and bugs for all kernels. + */ + if (VGLModeInfo.vi_mode >= M_VESA_BASE) + VGLBufSize = VGLAdpInfo.va_line_width*VGLModeInfo.vi_height* + VGLModeInfo.vi_planes; + VGLBuf = malloc(VGLBufSize); + if (VGLBuf == NULL) { + VGLEnd(); + return -7; + } + +#ifdef LIBVGL_DEBUG + fprintf(stderr, "VGLBufSize:0x%x\n", VGLBufSize); +#endif + + /* see if we are in the windowed buffer mode or in the linear buffer mode */ + if (VGLBufSize/VGLModeInfo.vi_planes > VGLAdpInfo.va_window_size) { + switch (VGLDisplay->Type) { + case VIDBUF4: + VGLDisplay->Type = VIDBUF4S; + break; + case VIDBUF8: + VGLDisplay->Type = VIDBUF8S; + break; + case VIDBUF16: + VGLDisplay->Type = VIDBUF16S; + break; + case VIDBUF24: + VGLDisplay->Type = VIDBUF24S; + break; + case VIDBUF32: + VGLDisplay->Type = VIDBUF32S; + break; + default: + VGLEnd(); + return -8; + } + } + + VGLMode = mode; + VGLCurWindow = 0; + + VGLDisplay->Xsize = VGLModeInfo.vi_width; + VGLDisplay->Ysize = VGLModeInfo.vi_height; + depth = VGLModeInfo.vi_depth; + if (depth == 15) + depth = 16; + VGLOldVXsize = + VGLDisplay->VXsize = VGLAdpInfo.va_line_width + *8/(depth/VGLModeInfo.vi_planes); + VGLDisplay->VYsize = VGLBufSize/VGLModeInfo.vi_planes/VGLAdpInfo.va_line_width; + VGLDisplay->Xorigin = 0; + VGLDisplay->Yorigin = 0; + + VGLMem = (byte*)mmap(0, VGLAdpInfo.va_window_size, PROT_READ|PROT_WRITE, + MAP_FILE | MAP_SHARED, 0, 0); + if (VGLMem == MAP_FAILED) { + VGLEnd(); + return -7; + } + VGLDisplay->Bitmap = VGLMem; + + VGLVDisplay = *VGLDisplay; + VGLVDisplay.Type = MEMBUF; + if (VGLModeInfo.vi_depth < 8) + VGLVDisplay.Bitmap = malloc(2 * VGLBufSize); + else + VGLVDisplay.Bitmap = VGLBuf; + + VGLSavePalette(); + +#ifdef LIBVGL_DEBUG + fprintf(stderr, "va_line_width:%d\n", VGLAdpInfo.va_line_width); + fprintf(stderr, "VGLXsize:%d, Ysize:%d, VXsize:%d, VYsize:%d\n", + VGLDisplay->Xsize, VGLDisplay->Ysize, + VGLDisplay->VXsize, VGLDisplay->VYsize); +#endif + + smode.mode = VT_PROCESS; + smode.waitv = 0; + smode.relsig = SIGUSR1; + smode.acqsig = SIGUSR1; + smode.frsig = SIGINT; + if (ioctl(0, VT_SETMODE, &smode)) { + VGLEnd(); + return -9; + } + VGLTextSetFontFile((byte*)0); + VGLClear(VGLDisplay, 0); + return 0; +} + +void +VGLCheckSwitch() +{ + if (VGLAbortPending) { + VGLEnd(); + exit(0); + } + while (VGLSwitchPending) { + VGLSwitchPending = 0; + if (VGLOnDisplay) { + if (VGLModeInfo.vi_mem_model != V_INFO_MM_DIRECT) + ioctl(0, KDENABIO, 0); + ioctl(0, KDSETMODE, KD_GRAPHICS); + ioctl(0, VGLMode, 0); + VGLCurWindow = 0; + VGLMem = (byte*)mmap(0, VGLAdpInfo.va_window_size, PROT_READ|PROT_WRITE, + MAP_FILE | MAP_SHARED, 0, 0); + + /* XXX: what if mmap() has failed! */ + VGLDisplay->Type = VIDBUF8; /* XXX */ + switch (VGLModeInfo.vi_mem_model) { + case V_INFO_MM_PLANAR: + if (VGLModeInfo.vi_depth == 4 && VGLModeInfo.vi_planes == 4) { + if (VGLBufSize/VGLModeInfo.vi_planes > VGLAdpInfo.va_window_size) + VGLDisplay->Type = VIDBUF4S; + else + VGLDisplay->Type = VIDBUF4; + } else { + /* shouldn't be happening */ + } + break; + case V_INFO_MM_PACKED: + if (VGLModeInfo.vi_depth == 8) { + if (VGLBufSize/VGLModeInfo.vi_planes > VGLAdpInfo.va_window_size) + VGLDisplay->Type = VIDBUF8S; + else + VGLDisplay->Type = VIDBUF8; + } + break; + case V_INFO_MM_VGAX: + VGLDisplay->Type = VIDBUF8X; + break; + case V_INFO_MM_DIRECT: + switch (VGLModeInfo.vi_pixel_size) { + case 2: + if (VGLBufSize/VGLModeInfo.vi_planes > VGLAdpInfo.va_window_size) + VGLDisplay->Type = VIDBUF16S; + else + VGLDisplay->Type = VIDBUF16; + break; + case 3: + if (VGLBufSize/VGLModeInfo.vi_planes > VGLAdpInfo.va_window_size) + VGLDisplay->Type = VIDBUF24S; + else + VGLDisplay->Type = VIDBUF24; + break; + case 4: + if (VGLBufSize/VGLModeInfo.vi_planes > VGLAdpInfo.va_window_size) + VGLDisplay->Type = VIDBUF32S; + else + VGLDisplay->Type = VIDBUF32; + break; + default: + /* shouldn't be happening */ + break; + } + default: + /* shouldn't be happening */ + break; + } + + VGLDisplay->Bitmap = VGLMem; + VGLDisplay->Xsize = VGLModeInfo.vi_width; + VGLDisplay->Ysize = VGLModeInfo.vi_height; + VGLSetVScreenSize(VGLDisplay, VGLDisplay->VXsize, VGLDisplay->VYsize); + VGLRestoreBlank(); + VGLRestoreBorder(); + VGLMouseRestore(); + VGLPanScreen(VGLDisplay, VGLDisplay->Xorigin, VGLDisplay->Yorigin); + VGLBitmapCopy(&VGLVDisplay, 0, 0, VGLDisplay, 0, 0, + VGLDisplay->VXsize, VGLDisplay->VYsize); + VGLRestorePalette(); + ioctl(0, VT_RELDISP, VT_ACKACQ); + } + else { + VGLMem = MAP_FAILED; + munmap(VGLDisplay->Bitmap, VGLAdpInfo.va_window_size); + ioctl(0, VGLOldMode, 0); + ioctl(0, KDSETMODE, KD_TEXT); + if (VGLModeInfo.vi_mem_model != V_INFO_MM_DIRECT) + ioctl(0, KDDISABIO, 0); + ioctl(0, VT_RELDISP, VT_TRUE); + VGLDisplay->Bitmap = VGLBuf; + VGLDisplay->Type = MEMBUF; + VGLDisplay->Xsize = VGLDisplay->VXsize; + VGLDisplay->Ysize = VGLDisplay->VYsize; + while (!VGLOnDisplay) pause(); + } + } +} + +int +VGLSetSegment(unsigned int offset) +{ + if (offset/VGLAdpInfo.va_window_size != VGLCurWindow) { + ioctl(0, CONS_SETWINORG, offset); /* FBIO_SETWINORG */ + VGLCurWindow = offset/VGLAdpInfo.va_window_size; + } + return (offset%VGLAdpInfo.va_window_size); +} + +int +VGLSetVScreenSize(VGLBitmap *object, int VXsize, int VYsize) +{ + int depth; + + if (VXsize < object->Xsize || VYsize < object->Ysize) + return -1; + if (object->Type == MEMBUF) + return -1; + if (ioctl(0, FBIO_SETLINEWIDTH, &VXsize)) + return -1; + ioctl(0, CONS_ADPINFO, &VGLAdpInfo); /* FBIO_ADPINFO */ + depth = VGLModeInfo.vi_depth; + if (depth == 15) + depth = 16; + object->VXsize = VGLAdpInfo.va_line_width + *8/(depth/VGLModeInfo.vi_planes); + object->VYsize = VGLBufSize/VGLModeInfo.vi_planes/VGLAdpInfo.va_line_width; + if (VYsize < object->VYsize) + object->VYsize = VYsize; + +#ifdef LIBVGL_DEBUG + fprintf(stderr, "new size: VGLXsize:%d, Ysize:%d, VXsize:%d, VYsize:%d\n", + object->Xsize, object->Ysize, object->VXsize, object->VYsize); +#endif + + return 0; +} + +int +VGLPanScreen(VGLBitmap *object, int x, int y) +{ + video_display_start_t origin; + + if (x < 0 || x + object->Xsize > object->VXsize + || y < 0 || y + object->Ysize > object->VYsize) + return -1; + if (object->Type == MEMBUF) + return 0; + origin.x = x; + origin.y = y; + if (ioctl(0, FBIO_SETDISPSTART, &origin)) + return -1; + object->Xorigin = x; + object->Yorigin = y; + +#ifdef LIBVGL_DEBUG + fprintf(stderr, "new origin: (%d, %d)\n", x, y); +#endif + + return 0; +} diff --git a/lib/libvgl/mouse.c b/lib/libvgl/mouse.c new file mode 100644 index 000000000000..c4019fd7606f --- /dev/null +++ b/lib/libvgl/mouse.c @@ -0,0 +1,421 @@ +/*- + * SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (c) 1991-1997 Søren Schmidt + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer + * in this position and unchanged. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <sys/cdefs.h> +#include <stdio.h> +#include <sys/types.h> +#include <sys/ioctl.h> +#include <sys/signal.h> +#include <sys/consio.h> +#include <sys/fbio.h> +#include "vgl.h" + +static void VGLMouseAction(int dummy); + +#define BORDER 0xff /* default border -- light white in rgb 3:3:2 */ +#define INTERIOR 0xa0 /* default interior -- red in rgb 3:3:2 */ +#define LARGE_MOUSE_IMG_XSIZE 19 +#define LARGE_MOUSE_IMG_YSIZE 32 +#define SMALL_MOUSE_IMG_XSIZE 10 +#define SMALL_MOUSE_IMG_YSIZE 16 +#define X 0xff /* any nonzero in And mask means part of cursor */ +#define B BORDER +#define I INTERIOR +static byte LargeAndMask[] = { + X,X,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + X,X,X,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + X,X,X,X,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + X,X,X,X,X,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + X,X,X,X,X,X,0,0,0,0,0,0,0,0,0,0,0,0,0, + X,X,X,X,X,X,X,0,0,0,0,0,0,0,0,0,0,0,0, + X,X,X,X,X,X,X,X,0,0,0,0,0,0,0,0,0,0,0, + X,X,X,X,X,X,X,X,X,0,0,0,0,0,0,0,0,0,0, + X,X,X,X,X,X,X,X,X,X,0,0,0,0,0,0,0,0,0, + X,X,X,X,X,X,X,X,X,X,X,0,0,0,0,0,0,0,0, + X,X,X,X,X,X,X,X,X,X,X,X,0,0,0,0,0,0,0, + X,X,X,X,X,X,X,X,X,X,X,X,X,0,0,0,0,0,0, + X,X,X,X,X,X,X,X,X,X,X,X,X,X,0,0,0,0,0, + X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,0,0,0,0, + X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,0,0,0, + X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,0,0, + X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,0, + X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X, + X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X, + X,X,X,X,X,X,X,X,X,X,X,X,0,0,0,0,0,0,0, + X,X,X,X,X,X,X,X,X,X,X,X,0,0,0,0,0,0,0, + X,X,X,X,X,X,0,X,X,X,X,X,X,0,0,0,0,0,0, + X,X,X,X,X,0,0,X,X,X,X,X,X,0,0,0,0,0,0, + X,X,X,X,0,0,0,0,X,X,X,X,X,X,0,0,0,0,0, + X,X,X,0,0,0,0,0,X,X,X,X,X,X,0,0,0,0,0, + X,X,0,0,0,0,0,0,0,X,X,X,X,X,X,0,0,0,0, + 0,0,0,0,0,0,0,0,0,X,X,X,X,X,X,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,X,X,X,X,X,X,0,0,0, + 0,0,0,0,0,0,0,0,0,0,X,X,X,X,X,X,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,X,X,X,X,X,X,0,0, + 0,0,0,0,0,0,0,0,0,0,0,X,X,X,X,X,X,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,X,X,X,X,0,0,0, +}; +static byte LargeOrMask[] = { + B,B,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + B,I,B,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + B,I,I,B,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + B,I,I,I,B,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + B,I,I,I,I,B,0,0,0,0,0,0,0,0,0,0,0,0,0, + B,I,I,I,I,I,B,0,0,0,0,0,0,0,0,0,0,0,0, + B,I,I,I,I,I,I,B,0,0,0,0,0,0,0,0,0,0,0, + B,I,I,I,I,I,I,I,B,0,0,0,0,0,0,0,0,0,0, + B,I,I,I,I,I,I,I,I,B,0,0,0,0,0,0,0,0,0, + B,I,I,I,I,I,I,I,I,I,B,0,0,0,0,0,0,0,0, + B,I,I,I,I,I,I,I,I,I,I,B,0,0,0,0,0,0,0, + B,I,I,I,I,I,I,I,I,I,I,I,B,0,0,0,0,0,0, + B,I,I,I,I,I,I,I,I,I,I,I,I,B,0,0,0,0,0, + B,I,I,I,I,I,I,I,I,I,I,I,I,I,B,0,0,0,0, + B,I,I,I,I,I,I,I,I,I,I,I,I,I,I,B,0,0,0, + B,I,I,I,I,I,I,I,I,I,I,I,I,I,I,I,B,0,0, + B,I,I,I,I,I,I,I,I,I,I,I,I,I,I,I,I,B,0, + B,I,I,I,I,I,I,I,I,I,I,I,I,I,I,I,I,I,B, + B,I,I,I,I,I,I,I,I,I,I,B,B,B,B,B,B,B,B, + B,I,I,I,I,I,I,I,I,I,I,B,0,0,0,0,0,0,0, + B,I,I,I,I,I,B,I,I,I,I,B,0,0,0,0,0,0,0, + B,I,I,I,I,B,0,B,I,I,I,I,B,0,0,0,0,0,0, + B,I,I,I,B,0,0,B,I,I,I,I,B,0,0,0,0,0,0, + B,I,I,B,0,0,0,0,B,I,I,I,I,B,0,0,0,0,0, + B,I,B,0,0,0,0,0,B,I,I,I,I,B,0,0,0,0,0, + B,B,0,0,0,0,0,0,0,B,I,I,I,I,B,0,0,0,0, + 0,0,0,0,0,0,0,0,0,B,I,I,I,I,B,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,B,I,I,I,I,B,0,0,0, + 0,0,0,0,0,0,0,0,0,0,B,I,I,I,I,B,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,B,I,I,I,I,B,0,0, + 0,0,0,0,0,0,0,0,0,0,0,B,I,I,I,I,B,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,B,B,B,B,0,0,0, +}; +static byte SmallAndMask[] = { + X,X,0,0,0,0,0,0,0,0, + X,X,X,0,0,0,0,0,0,0, + X,X,X,X,0,0,0,0,0,0, + X,X,X,X,X,0,0,0,0,0, + X,X,X,X,X,X,0,0,0,0, + X,X,X,X,X,X,X,0,0,0, + X,X,X,X,X,X,X,X,0,0, + X,X,X,X,X,X,X,X,X,0, + X,X,X,X,X,X,X,X,X,X, + X,X,X,X,X,X,X,X,X,X, + X,X,X,X,X,X,X,0,0,0, + X,X,X,0,X,X,X,X,0,0, + X,X,0,0,X,X,X,X,0,0, + 0,0,0,0,0,X,X,X,X,0, + 0,0,0,0,0,X,X,X,X,0, + 0,0,0,0,0,0,X,X,0,0, +}; +static byte SmallOrMask[] = { + B,B,0,0,0,0,0,0,0,0, + B,I,B,0,0,0,0,0,0,0, + B,I,I,B,0,0,0,0,0,0, + B,I,I,I,B,0,0,0,0,0, + B,I,I,I,I,B,0,0,0,0, + B,I,I,I,I,I,B,0,0,0, + B,I,I,I,I,I,I,B,0,0, + B,I,I,I,I,I,I,I,B,0, + B,I,I,I,I,I,I,I,I,B, + B,I,I,I,I,I,B,B,B,B, + B,I,I,B,I,I,B,0,0,0, + B,I,B,0,B,I,I,B,0,0, + B,B,0,0,B,I,I,B,0,0, + 0,0,0,0,0,B,I,I,B,0, + 0,0,0,0,0,B,I,I,B,0, + 0,0,0,0,0,0,B,B,0,0, +}; +#undef X +#undef B +#undef I +static VGLBitmap VGLMouseLargeAndMask = + VGLBITMAP_INITIALIZER(MEMBUF, LARGE_MOUSE_IMG_XSIZE, LARGE_MOUSE_IMG_YSIZE, + LargeAndMask); +static VGLBitmap VGLMouseLargeOrMask = + VGLBITMAP_INITIALIZER(MEMBUF, LARGE_MOUSE_IMG_XSIZE, LARGE_MOUSE_IMG_YSIZE, + LargeOrMask); +static VGLBitmap VGLMouseSmallAndMask = + VGLBITMAP_INITIALIZER(MEMBUF, SMALL_MOUSE_IMG_XSIZE, SMALL_MOUSE_IMG_YSIZE, + SmallAndMask); +static VGLBitmap VGLMouseSmallOrMask = + VGLBITMAP_INITIALIZER(MEMBUF, SMALL_MOUSE_IMG_XSIZE, SMALL_MOUSE_IMG_YSIZE, + SmallOrMask); +static VGLBitmap *VGLMouseAndMask, *VGLMouseOrMask; +static int VGLMouseShown = VGL_MOUSEHIDE; +static int VGLMouseXpos = 0; +static int VGLMouseYpos = 0; +static int VGLMouseButtons = 0; +static volatile sig_atomic_t VGLMintpending; +static volatile sig_atomic_t VGLMsuppressint; + +#define INTOFF() (VGLMsuppressint++) +#define INTON() do { \ + if (--VGLMsuppressint == 0 && VGLMintpending) \ + VGLMouseAction(0); \ + } while (0) + +int +__VGLMouseMode(int mode) +{ + int oldmode; + + INTOFF(); + oldmode = VGLMouseShown; + if (mode == VGL_MOUSESHOW) { + if (VGLMouseShown == VGL_MOUSEHIDE) { + VGLMouseShown = VGL_MOUSESHOW; + __VGLBitmapCopy(&VGLVDisplay, VGLMouseXpos, VGLMouseYpos, + VGLDisplay, VGLMouseXpos, VGLMouseYpos, + VGLMouseAndMask->VXsize, -VGLMouseAndMask->VYsize); + } + } + else { + if (VGLMouseShown == VGL_MOUSESHOW) { + VGLMouseShown = VGL_MOUSEHIDE; + __VGLBitmapCopy(&VGLVDisplay, VGLMouseXpos, VGLMouseYpos, + VGLDisplay, VGLMouseXpos, VGLMouseYpos, + VGLMouseAndMask->VXsize, VGLMouseAndMask->VYsize); + } + } + INTON(); + return oldmode; +} + +void +VGLMouseMode(int mode) +{ + __VGLMouseMode(mode); +} + +static void +VGLMouseAction(int dummy) +{ + struct mouse_info mouseinfo; + int mousemode; + + if (VGLMsuppressint) { + VGLMintpending = 1; + return; + } +again: + INTOFF(); + VGLMintpending = 0; + mouseinfo.operation = MOUSE_GETINFO; + ioctl(0, CONS_MOUSECTL, &mouseinfo); + if (VGLMouseXpos != mouseinfo.u.data.x || + VGLMouseYpos != mouseinfo.u.data.y) { + mousemode = __VGLMouseMode(VGL_MOUSEHIDE); + VGLMouseXpos = mouseinfo.u.data.x; + VGLMouseYpos = mouseinfo.u.data.y; + __VGLMouseMode(mousemode); + } + VGLMouseButtons = mouseinfo.u.data.buttons; + + /* + * Loop to handle any new (suppressed) signals. This is INTON() without + * recursion. !SA_RESTART prevents recursion in signal handling. So the + * maximum recursion is 2 levels. + */ + VGLMsuppressint = 0; + if (VGLMintpending) + goto again; +} + +void +VGLMouseSetImage(VGLBitmap *AndMask, VGLBitmap *OrMask) +{ + int mousemode; + + mousemode = __VGLMouseMode(VGL_MOUSEHIDE); + + VGLMouseAndMask = AndMask; + + if (VGLMouseOrMask != NULL) { + free(VGLMouseOrMask->Bitmap); + free(VGLMouseOrMask); + } + VGLMouseOrMask = VGLBitmapCreate(MEMBUF, OrMask->VXsize, OrMask->VYsize, 0); + VGLBitmapAllocateBits(VGLMouseOrMask); + VGLBitmapCvt(OrMask, VGLMouseOrMask); + + __VGLMouseMode(mousemode); +} + +void +VGLMouseSetStdImage() +{ + if (VGLDisplay->VXsize > 800) + VGLMouseSetImage(&VGLMouseLargeAndMask, &VGLMouseLargeOrMask); + else + VGLMouseSetImage(&VGLMouseSmallAndMask, &VGLMouseSmallOrMask); +} + +int +VGLMouseInit(int mode) +{ + struct mouse_info mouseinfo; + VGLBitmap *ormask; + int border, error, i, interior; + + switch (VGLModeInfo.vi_mem_model) { + case V_INFO_MM_PACKED: + case V_INFO_MM_PLANAR: + border = 0x0f; + interior = 0x04; + break; + case V_INFO_MM_VGAX: + border = 0x3f; + interior = 0x24; + break; + default: + border = BORDER; + interior = INTERIOR; + break; + } + if (VGLModeInfo.vi_mode == M_BG640x480) + border = 0; /* XXX (palette makes 0x04 look like 0x0f) */ + if (getenv("VGLMOUSEBORDERCOLOR") != NULL) + border = strtoul(getenv("VGLMOUSEBORDERCOLOR"), NULL, 0); + if (getenv("VGLMOUSEINTERIORCOLOR") != NULL) + interior = strtoul(getenv("VGLMOUSEINTERIORCOLOR"), NULL, 0); + ormask = &VGLMouseLargeOrMask; + for (i = 0; i < ormask->VXsize * ormask->VYsize; i++) + ormask->Bitmap[i] = ormask->Bitmap[i] == BORDER ? border : + ormask->Bitmap[i] == INTERIOR ? interior : 0; + ormask = &VGLMouseSmallOrMask; + for (i = 0; i < ormask->VXsize * ormask->VYsize; i++) + ormask->Bitmap[i] = ormask->Bitmap[i] == BORDER ? border : + ormask->Bitmap[i] == INTERIOR ? interior : 0; + VGLMouseSetStdImage(); + mouseinfo.operation = MOUSE_MODE; + mouseinfo.u.mode.signal = SIGUSR2; + if ((error = ioctl(0, CONS_MOUSECTL, &mouseinfo))) + return error; + signal(SIGUSR2, VGLMouseAction); + mouseinfo.operation = MOUSE_GETINFO; + ioctl(0, CONS_MOUSECTL, &mouseinfo); + VGLMouseXpos = mouseinfo.u.data.x; + VGLMouseYpos = mouseinfo.u.data.y; + VGLMouseButtons = mouseinfo.u.data.buttons; + VGLMouseMode(mode); + return 0; +} + +void +VGLMouseRestore(void) +{ + struct mouse_info mouseinfo; + + INTOFF(); + mouseinfo.operation = MOUSE_GETINFO; + if (ioctl(0, CONS_MOUSECTL, &mouseinfo) == 0) { + mouseinfo.operation = MOUSE_MOVEABS; + mouseinfo.u.data.x = VGLMouseXpos; + mouseinfo.u.data.y = VGLMouseYpos; + ioctl(0, CONS_MOUSECTL, &mouseinfo); + } + INTON(); +} + +int +VGLMouseStatus(int *x, int *y, char *buttons) +{ + INTOFF(); + *x = VGLMouseXpos; + *y = VGLMouseYpos; + *buttons = VGLMouseButtons; + INTON(); + return VGLMouseShown; +} + +void +VGLMouseFreeze(void) +{ + INTOFF(); +} + +int +VGLMouseFreezeXY(int x, int y) +{ + INTOFF(); + if (VGLMouseShown != VGL_MOUSESHOW) + return 0; + if (x >= VGLMouseXpos && x < VGLMouseXpos + VGLMouseAndMask->VXsize && + y >= VGLMouseYpos && y < VGLMouseYpos + VGLMouseAndMask->VYsize && + VGLMouseAndMask->Bitmap[(y-VGLMouseYpos)*VGLMouseAndMask->VXsize+ + (x-VGLMouseXpos)]) + return 1; + return 0; +} + +int +VGLMouseOverlap(int x, int y, int width, int hight) +{ + int overlap; + + if (VGLMouseShown != VGL_MOUSESHOW) + return 0; + if (x > VGLMouseXpos) + overlap = (VGLMouseXpos + VGLMouseAndMask->VXsize) - x; + else + overlap = (x + width) - VGLMouseXpos; + if (overlap <= 0) + return 0; + if (y > VGLMouseYpos) + overlap = (VGLMouseYpos + VGLMouseAndMask->VYsize) - y; + else + overlap = (y + hight) - VGLMouseYpos; + return overlap > 0; +} + +void +VGLMouseMerge(int x, int y, int width, byte *line) +{ + int pos, x1, xend, xstart; + + xstart = x; + if (xstart < VGLMouseXpos) + xstart = VGLMouseXpos; + xend = x + width; + if (xend > VGLMouseXpos + VGLMouseAndMask->VXsize) + xend = VGLMouseXpos + VGLMouseAndMask->VXsize; + for (x1 = xstart; x1 < xend; x1++) { + pos = (y - VGLMouseYpos) * VGLMouseAndMask->VXsize + x1 - VGLMouseXpos; + if (VGLMouseAndMask->Bitmap[pos]) + bcopy(&VGLMouseOrMask->Bitmap[pos * VGLDisplay->PixelBytes], + &line[(x1 - x) * VGLDisplay->PixelBytes], VGLDisplay->PixelBytes); + } +} + +void +VGLMouseUnFreeze() +{ + INTON(); +} diff --git a/lib/libvgl/simple.c b/lib/libvgl/simple.c new file mode 100644 index 000000000000..3ae07db1993b --- /dev/null +++ b/lib/libvgl/simple.c @@ -0,0 +1,686 @@ +/*- + * SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (c) 1991-1997 Søren Schmidt + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer + * in this position and unchanged. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <sys/cdefs.h> +#include <signal.h> +#include <sys/fbio.h> +#include <sys/kbio.h> +#include <sys/endian.h> +#include "vgl.h" + +static int VGLBlank; +static byte VGLBorderColor; +static byte VGLSavePaletteRed[256]; +static byte VGLSavePaletteGreen[256]; +static byte VGLSavePaletteBlue[256]; + +#define ABS(a) (((a)<0) ? -(a) : (a)) +#define SGN(a) (((a)<0) ? -1 : 1) +#define min(x, y) (((x) < (y)) ? (x) : (y)) +#define max(x, y) (((x) > (y)) ? (x) : (y)) + +void +VGLSetXY(VGLBitmap *object, int x, int y, u_long color) +{ + int offset, soffset, undermouse; + + VGLCheckSwitch(); + if (x>=0 && x<object->VXsize && y>=0 && y<object->VYsize) { + if (object == VGLDisplay) { + undermouse = VGLMouseFreezeXY(x, y); + VGLSetXY(&VGLVDisplay, x, y, color); + } else if (object->Type != MEMBUF) + return; /* invalid */ + else + undermouse = 0; + if (!undermouse) { + offset = (y * object->VXsize + x) * object->PixelBytes; + switch (object->Type) { + case VIDBUF8S: + case VIDBUF16S: + case VIDBUF32S: + offset = VGLSetSegment(offset); + /* FALLTHROUGH */ + case MEMBUF: + case VIDBUF8: + case VIDBUF16: + case VIDBUF24: + case VIDBUF32: + color = htole32(color); + switch (object->PixelBytes) { + case 1: + memcpy(&object->Bitmap[offset], &color, 1); + break; + case 2: + memcpy(&object->Bitmap[offset], &color, 2); + break; + case 3: + memcpy(&object->Bitmap[offset], &color, 3); + break; + case 4: + memcpy(&object->Bitmap[offset], &color, 4); + break; + } + break; + case VIDBUF24S: + soffset = VGLSetSegment(offset); + color = htole32(color); + switch (VGLAdpInfo.va_window_size - soffset) { + case 1: + memcpy(&object->Bitmap[soffset], &color, 1); + soffset = VGLSetSegment(offset + 1); + memcpy(&object->Bitmap[soffset], (byte *)&color + 1, 2); + break; + case 2: + memcpy(&object->Bitmap[soffset], &color, 2); + soffset = VGLSetSegment(offset + 2); + memcpy(&object->Bitmap[soffset], (byte *)&color + 2, 1); + break; + default: + memcpy(&object->Bitmap[soffset], &color, 3); + break; + } + break; + case VIDBUF8X: + outb(0x3c4, 0x02); + outb(0x3c5, 0x01 << (x&0x3)); + object->Bitmap[(unsigned)(VGLAdpInfo.va_line_width*y)+(x/4)] = ((byte)color); + break; + case VIDBUF4S: + offset = VGLSetSegment(y*VGLAdpInfo.va_line_width + x/8); + goto set_planar; + case VIDBUF4: + offset = y*VGLAdpInfo.va_line_width + x/8; +set_planar: + outb(0x3c4, 0x02); outb(0x3c5, 0x0f); + outb(0x3ce, 0x00); outb(0x3cf, (byte)color & 0x0f); /* set/reset */ + outb(0x3ce, 0x01); outb(0x3cf, 0x0f); /* set/reset enable */ + outb(0x3ce, 0x08); outb(0x3cf, 0x80 >> (x%8)); /* bit mask */ + object->Bitmap[offset] |= (byte)color; + } + } + if (object == VGLDisplay) + VGLMouseUnFreeze(); + } +} + +u_long +VGLGetXY(VGLBitmap *object, int x, int y) +{ + u_long color; + int offset; + + VGLCheckSwitch(); + if (x<0 || x>=object->VXsize || y<0 || y>=object->VYsize) + return 0; + if (object == VGLDisplay) + object = &VGLVDisplay; + else if (object->Type != MEMBUF) + return 0; /* invalid */ + offset = (y * object->VXsize + x) * object->PixelBytes; + switch (object->PixelBytes) { + case 1: + memcpy(&color, &object->Bitmap[offset], 1); + return le32toh(color) & 0xff; + case 2: + memcpy(&color, &object->Bitmap[offset], 2); + return le32toh(color) & 0xffff; + case 3: + memcpy(&color, &object->Bitmap[offset], 3); + return le32toh(color) & 0xffffff; + case 4: + memcpy(&color, &object->Bitmap[offset], 4); + return le32toh(color); + } + return 0; /* invalid */ +} + + /* + * Symmetric Double Step Line Algorithm by Brian Wyvill from + * "Graphics Gems", Academic Press, 1990. + */ + +#define SL_SWAP(a,b) {a^=b; b^=a; a^=b;} +#define SL_ABSOLUTE(i,j,k) ( (i-j)*(k = ( (i-j)<0 ? -1 : 1))) + +void +plot(VGLBitmap * object, int x, int y, int flag, u_long color) +{ + /* non-zero flag indicates the pixels need swapping back. */ + if (flag) + VGLSetXY(object, y, x, color); + else + VGLSetXY(object, x, y, color); +} + + +void +VGLLine(VGLBitmap *object, int x1, int y1, int x2, int y2, u_long color) +{ + int dx, dy, incr1, incr2, D, x, y, xend, c, pixels_left; + int sign_x, sign_y, step, reverse, i; + + dx = SL_ABSOLUTE(x2, x1, sign_x); + dy = SL_ABSOLUTE(y2, y1, sign_y); + /* decide increment sign by the slope sign */ + if (sign_x == sign_y) + step = 1; + else + step = -1; + + if (dy > dx) { /* chooses axis of greatest movement (make dx) */ + SL_SWAP(x1, y1); + SL_SWAP(x2, y2); + SL_SWAP(dx, dy); + reverse = 1; + } else + reverse = 0; + /* note error check for dx==0 should be included here */ + if (x1 > x2) { /* start from the smaller coordinate */ + x = x2; + y = y2; +/* x1 = x1; + y1 = y1; */ + } else { + x = x1; + y = y1; + x1 = x2; + y1 = y2; + } + + + /* Note dx=n implies 0 - n or (dx+1) pixels to be set */ + /* Go round loop dx/4 times then plot last 0,1,2 or 3 pixels */ + /* In fact (dx-1)/4 as 2 pixels are already plotted */ + xend = (dx - 1) / 4; + pixels_left = (dx - 1) % 4; /* number of pixels left over at the + * end */ + plot(object, x, y, reverse, color); + if (pixels_left < 0) + return; /* plot only one pixel for zero length + * vectors */ + plot(object, x1, y1, reverse, color); /* plot first two points */ + incr2 = 4 * dy - 2 * dx; + if (incr2 < 0) { /* slope less than 1/2 */ + c = 2 * dy; + incr1 = 2 * c; + D = incr1 - dx; + + for (i = 0; i < xend; i++) { /* plotting loop */ + ++x; + --x1; + if (D < 0) { + /* pattern 1 forwards */ + plot(object, x, y, reverse, color); + plot(object, ++x, y, reverse, color); + /* pattern 1 backwards */ + plot(object, x1, y1, reverse, color); + plot(object, --x1, y1, reverse, color); + D += incr1; + } else { + if (D < c) { + /* pattern 2 forwards */ + plot(object, x, y, reverse, color); + plot(object, ++x, y += step, reverse, + color); + /* pattern 2 backwards */ + plot(object, x1, y1, reverse, color); + plot(object, --x1, y1 -= step, reverse, + color); + } else { + /* pattern 3 forwards */ + plot(object, x, y += step, reverse, color); + plot(object, ++x, y, reverse, color); + /* pattern 3 backwards */ + plot(object, x1, y1 -= step, reverse, + color); + plot(object, --x1, y1, reverse, color); + } + D += incr2; + } + } /* end for */ + + /* plot last pattern */ + if (pixels_left) { + if (D < 0) { + plot(object, ++x, y, reverse, color); /* pattern 1 */ + if (pixels_left > 1) + plot(object, ++x, y, reverse, color); + if (pixels_left > 2) + plot(object, --x1, y1, reverse, color); + } else { + if (D < c) { + plot(object, ++x, y, reverse, color); /* pattern 2 */ + if (pixels_left > 1) + plot(object, ++x, y += step, reverse, color); + if (pixels_left > 2) + plot(object, --x1, y1, reverse, color); + } else { + /* pattern 3 */ + plot(object, ++x, y += step, reverse, color); + if (pixels_left > 1) + plot(object, ++x, y, reverse, color); + if (pixels_left > 2) + plot(object, --x1, y1 -= step, reverse, color); + } + } + } /* end if pixels_left */ + } + /* end slope < 1/2 */ + else { /* slope greater than 1/2 */ + c = 2 * (dy - dx); + incr1 = 2 * c; + D = incr1 + dx; + for (i = 0; i < xend; i++) { + ++x; + --x1; + if (D > 0) { + /* pattern 4 forwards */ + plot(object, x, y += step, reverse, color); + plot(object, ++x, y += step, reverse, color); + /* pattern 4 backwards */ + plot(object, x1, y1 -= step, reverse, color); + plot(object, --x1, y1 -= step, reverse, color); + D += incr1; + } else { + if (D < c) { + /* pattern 2 forwards */ + plot(object, x, y, reverse, color); + plot(object, ++x, y += step, reverse, + color); + + /* pattern 2 backwards */ + plot(object, x1, y1, reverse, color); + plot(object, --x1, y1 -= step, reverse, + color); + } else { + /* pattern 3 forwards */ + plot(object, x, y += step, reverse, color); + plot(object, ++x, y, reverse, color); + /* pattern 3 backwards */ + plot(object, x1, y1 -= step, reverse, color); + plot(object, --x1, y1, reverse, color); + } + D += incr2; + } + } /* end for */ + /* plot last pattern */ + if (pixels_left) { + if (D > 0) { + plot(object, ++x, y += step, reverse, color); /* pattern 4 */ + if (pixels_left > 1) + plot(object, ++x, y += step, reverse, + color); + if (pixels_left > 2) + plot(object, --x1, y1 -= step, reverse, + color); + } else { + if (D < c) { + plot(object, ++x, y, reverse, color); /* pattern 2 */ + if (pixels_left > 1) + plot(object, ++x, y += step, reverse, color); + if (pixels_left > 2) + plot(object, --x1, y1, reverse, color); + } else { + /* pattern 3 */ + plot(object, ++x, y += step, reverse, color); + if (pixels_left > 1) + plot(object, ++x, y, reverse, color); + if (pixels_left > 2) { + if (D > c) /* step 3 */ + plot(object, --x1, y1 -= step, reverse, color); + else /* step 2 */ + plot(object, --x1, y1, reverse, color); + } + } + } + } + } +} + +void +VGLBox(VGLBitmap *object, int x1, int y1, int x2, int y2, u_long color) +{ + VGLLine(object, x1, y1, x2, y1, color); + VGLLine(object, x2, y1, x2, y2, color); + VGLLine(object, x2, y2, x1, y2, color); + VGLLine(object, x1, y2, x1, y1, color); +} + +void +VGLFilledBox(VGLBitmap *object, int x1, int y1, int x2, int y2, u_long color) +{ + int y; + + for (y=y1; y<=y2; y++) VGLLine(object, x1, y, x2, y, color); +} + +static inline void +set4pixels(VGLBitmap *object, int x, int y, int xc, int yc, u_long color) +{ + if (x!=0) { + VGLSetXY(object, xc+x, yc+y, color); + VGLSetXY(object, xc-x, yc+y, color); + if (y!=0) { + VGLSetXY(object, xc+x, yc-y, color); + VGLSetXY(object, xc-x, yc-y, color); + } + } + else { + VGLSetXY(object, xc, yc+y, color); + if (y!=0) + VGLSetXY(object, xc, yc-y, color); + } +} + +void +VGLEllipse(VGLBitmap *object, int xc, int yc, int a, int b, u_long color) +{ + int x = 0, y = b, asq = a*a, asq2 = a*a*2, bsq = b*b; + int bsq2 = b*b*2, d = bsq-asq*b+asq/4, dx = 0, dy = asq2*b; + + while (dx<dy) { + set4pixels(object, x, y, xc, yc, color); + if (d>0) { + y--; dy-=asq2; d-=dy; + } + x++; dx+=bsq2; d+=bsq+dx; + } + d+=(3*(asq-bsq)/2-(dx+dy))/2; + while (y>=0) { + set4pixels(object, x, y, xc, yc, color); + if (d<0) { + x++; dx+=bsq2; d+=dx; + } + y--; dy-=asq2; d+=asq-dy; + } +} + +static inline void +set2lines(VGLBitmap *object, int x, int y, int xc, int yc, u_long color) +{ + if (x!=0) { + VGLLine(object, xc+x, yc+y, xc-x, yc+y, color); + if (y!=0) + VGLLine(object, xc+x, yc-y, xc-x, yc-y, color); + } + else { + VGLLine(object, xc, yc+y, xc, yc-y, color); + } +} + +void +VGLFilledEllipse(VGLBitmap *object, int xc, int yc, int a, int b, u_long color) +{ + int x = 0, y = b, asq = a*a, asq2 = a*a*2, bsq = b*b; + int bsq2 = b*b*2, d = bsq-asq*b+asq/4, dx = 0, dy = asq2*b; + + while (dx<dy) { + set2lines(object, x, y, xc, yc, color); + if (d>0) { + y--; dy-=asq2; d-=dy; + } + x++; dx+=bsq2; d+=bsq+dx; + } + d+=(3*(asq-bsq)/2-(dx+dy))/2; + while (y>=0) { + set2lines(object, x, y, xc, yc, color); + if (d<0) { + x++; dx+=bsq2; d+=dx; + } + y--; dy-=asq2; d+=asq-dy; + } +} + +void +VGLClear(VGLBitmap *object, u_long color) +{ + VGLBitmap src; + int i, len, mousemode, offset; + + VGLCheckSwitch(); + if (object == VGLDisplay) { + VGLMouseFreeze(); + VGLClear(&VGLVDisplay, color); + } else if (object->Type != MEMBUF) + return; /* invalid */ + switch (object->Type) { + case MEMBUF: + case VIDBUF8: + case VIDBUF8S: + case VIDBUF16: + case VIDBUF16S: + case VIDBUF24: + case VIDBUF24S: + case VIDBUF32: + case VIDBUF32S: + src.Type = MEMBUF; + src.Xsize = object->Xsize; + src.VXsize = object->VXsize; + src.Ysize = 1; + src.VYsize = 1; + src.Xorigin = 0; + src.Yorigin = 0; + src.Bitmap = alloca(object->VXsize * object->PixelBytes); + src.PixelBytes = object->PixelBytes; + color = htole32(color); + for (i = 0; i < object->VXsize; i++) + bcopy(&color, src.Bitmap + i * object->PixelBytes, object->PixelBytes); + for (i = 0; i < object->VYsize; i++) + __VGLBitmapCopy(&src, 0, 0, object, 0, i, object->VXsize, -1); + break; + + case VIDBUF8X: + mousemode = __VGLMouseMode(VGL_MOUSEHIDE); + /* XXX works only for Xsize % 4 = 0 */ + outb(0x3c6, 0xff); + outb(0x3c4, 0x02); outb(0x3c5, 0x0f); + memset(object->Bitmap, (byte)color, VGLAdpInfo.va_line_width*object->VYsize); + __VGLMouseMode(mousemode); + break; + + case VIDBUF4: + case VIDBUF4S: + mousemode = __VGLMouseMode(VGL_MOUSEHIDE); + /* XXX works only for Xsize % 8 = 0 */ + outb(0x3c4, 0x02); outb(0x3c5, 0x0f); + outb(0x3ce, 0x05); outb(0x3cf, 0x02); /* mode 2 */ + outb(0x3ce, 0x01); outb(0x3cf, 0x00); /* set/reset enable */ + outb(0x3ce, 0x08); outb(0x3cf, 0xff); /* bit mask */ + for (offset = 0; offset < VGLAdpInfo.va_line_width*object->VYsize; ) { + VGLSetSegment(offset); + len = min(object->VXsize*object->VYsize - offset, + VGLAdpInfo.va_window_size); + memset(object->Bitmap, (byte)color, len); + offset += len; + } + outb(0x3ce, 0x05); outb(0x3cf, 0x00); + __VGLMouseMode(mousemode); + break; + } + if (object == VGLDisplay) + VGLMouseUnFreeze(); +} + +static inline u_long +VGLrgbToNative(uint16_t r, uint16_t g, uint16_t b) +{ + int nr, ng, nb; + + nr = VGLModeInfo.vi_pixel_fsizes[2]; + ng = VGLModeInfo.vi_pixel_fsizes[1]; + nb = VGLModeInfo.vi_pixel_fsizes[0]; + return (r >> (16 - nr) << (ng + nb)) | (g >> (16 - ng) << nb) | + (b >> (16 - nb) << 0); +} + +u_long +VGLrgb332ToNative(byte c) +{ + uint16_t r, g, b; + + /* 3:3:2 to 16:16:16 */ + r = ((c & 0xe0) >> 5) * 0xffff / 7; + g = ((c & 0x1c) >> 2) * 0xffff / 7; + b = ((c & 0x03) >> 0) * 0xffff / 3; + + return VGLrgbToNative(r, g, b); +} + +void +VGLRestorePalette() +{ + int i; + + if (VGLModeInfo.vi_mem_model == V_INFO_MM_DIRECT) + return; + outb(0x3C6, 0xFF); + inb(0x3DA); + outb(0x3C8, 0x00); + for (i=0; i<256; i++) { + outb(0x3C9, VGLSavePaletteRed[i]); + inb(0x84); + outb(0x3C9, VGLSavePaletteGreen[i]); + inb(0x84); + outb(0x3C9, VGLSavePaletteBlue[i]); + inb(0x84); + } + inb(0x3DA); + outb(0x3C0, 0x20); +} + +void +VGLSavePalette() +{ + int i; + + if (VGLModeInfo.vi_mem_model == V_INFO_MM_DIRECT) + return; + outb(0x3C6, 0xFF); + inb(0x3DA); + outb(0x3C7, 0x00); + for (i=0; i<256; i++) { + VGLSavePaletteRed[i] = inb(0x3C9); + inb(0x84); + VGLSavePaletteGreen[i] = inb(0x3C9); + inb(0x84); + VGLSavePaletteBlue[i] = inb(0x3C9); + inb(0x84); + } + inb(0x3DA); + outb(0x3C0, 0x20); +} + +void +VGLSetPalette(byte *red, byte *green, byte *blue) +{ + int i; + + if (VGLModeInfo.vi_mem_model == V_INFO_MM_DIRECT) + return; + for (i=0; i<256; i++) { + VGLSavePaletteRed[i] = red[i]; + VGLSavePaletteGreen[i] = green[i]; + VGLSavePaletteBlue[i] = blue[i]; + } + VGLCheckSwitch(); + outb(0x3C6, 0xFF); + inb(0x3DA); + outb(0x3C8, 0x00); + for (i=0; i<256; i++) { + outb(0x3C9, VGLSavePaletteRed[i]); + inb(0x84); + outb(0x3C9, VGLSavePaletteGreen[i]); + inb(0x84); + outb(0x3C9, VGLSavePaletteBlue[i]); + inb(0x84); + } + inb(0x3DA); + outb(0x3C0, 0x20); +} + +void +VGLSetPaletteIndex(byte color, byte red, byte green, byte blue) +{ + if (VGLModeInfo.vi_mem_model == V_INFO_MM_DIRECT) + return; + VGLSavePaletteRed[color] = red; + VGLSavePaletteGreen[color] = green; + VGLSavePaletteBlue[color] = blue; + VGLCheckSwitch(); + outb(0x3C6, 0xFF); + inb(0x3DA); + outb(0x3C8, color); + outb(0x3C9, red); outb(0x3C9, green); outb(0x3C9, blue); + inb(0x3DA); + outb(0x3C0, 0x20); +} + +void +VGLRestoreBorder(void) +{ + VGLSetBorder(VGLBorderColor); +} + +void +VGLSetBorder(byte color) +{ + if (VGLModeInfo.vi_mem_model == V_INFO_MM_DIRECT && ioctl(0, KDENABIO, 0)) + return; + VGLCheckSwitch(); + inb(0x3DA); + outb(0x3C0,0x11); outb(0x3C0, color); + inb(0x3DA); + outb(0x3C0, 0x20); + VGLBorderColor = color; + if (VGLModeInfo.vi_mem_model == V_INFO_MM_DIRECT) + ioctl(0, KDDISABIO, 0); +} + +void +VGLRestoreBlank(void) +{ + VGLBlankDisplay(VGLBlank); +} + +void +VGLBlankDisplay(int blank) +{ + byte val; + + if (VGLModeInfo.vi_mem_model == V_INFO_MM_DIRECT && ioctl(0, KDENABIO, 0)) + return; + VGLCheckSwitch(); + outb(0x3C4, 0x01); val = inb(0x3C5); outb(0x3C4, 0x01); + outb(0x3C5, ((blank) ? (val |= 0x20) : (val &= 0xDF))); + VGLBlank = blank; + if (VGLModeInfo.vi_mem_model == V_INFO_MM_DIRECT) + ioctl(0, KDDISABIO, 0); +} diff --git a/lib/libvgl/text.c b/lib/libvgl/text.c new file mode 100644 index 000000000000..2aaa197c1a64 --- /dev/null +++ b/lib/libvgl/text.c @@ -0,0 +1,249 @@ +/*- + * SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (c) 1991-1997 Søren Schmidt + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer + * in this position and unchanged. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <sys/cdefs.h> +#include <stdio.h> +#include <sys/fbio.h> +#include "vgl.h" + +static VGLText *VGLTextFont; + +extern byte VGLFont[]; + +int +VGLTextSetFontFile(char *filename) +{ +FILE *fd; + + if (VGLTextFont) { + if (VGLTextFont->BitmapArray != VGLFont) + free (VGLTextFont->BitmapArray); + free(VGLTextFont); + } + + if ((VGLTextFont=(VGLText*)malloc(sizeof(VGLText))) == (VGLText*)0) + return 1; + + if (filename==NULL) { + VGLTextFont->Width = 8; + VGLTextFont->Height = 8; + VGLTextFont->BitmapArray = VGLFont; + } + else { + if ((fd=fopen(filename, "r"))==(FILE*)0) + return 1; + fread(&VGLTextFont->Width, 1 , 1, fd); + fread(&VGLTextFont->Height, 1 , 1, fd); + VGLTextFont->BitmapArray = + (byte*)malloc(256*((VGLTextFont->Width + 7)/8)*VGLTextFont->Height); + fread(VGLTextFont->BitmapArray, 1, + (256*((VGLTextFont->Width + 7)/8)*VGLTextFont->Height), fd); + fclose(fd); + } + return 0; +} + +void +VGLBitmapPutChar(VGLBitmap *Object, int x, int y, byte ch, + u_long fgcol, u_long bgcol, int fill, int dir) +{ + int b, Bpc, Bpl, lin, bit, topbit; + + Bpl = (VGLTextFont->Width + 7) / 8; + Bpc = Bpl * VGLTextFont->Height; + topbit = VGLTextFont->Width - 1; + for(lin = 0; lin < VGLTextFont->Height; lin++) { + for(bit = 0; bit < VGLTextFont->Width; bit++) { + b = bit + (-VGLTextFont->Width & 7); + if (VGLTextFont->BitmapArray[(ch*Bpc)+(lin*Bpl)+(b/8)]&(1<<(b%8))) + switch (dir) { + case 0: + VGLSetXY(Object, (x+topbit-bit), (y+lin), fgcol); + break; + case 1: + VGLSetXY(Object, (x+lin), (y-topbit+bit), fgcol); + break; + case 2: + VGLSetXY(Object, (x-topbit+bit), (y-lin), fgcol); + break; + case 3: + VGLSetXY(Object, (x-lin), (y+topbit-bit), fgcol); + break; + case 4: + VGLSetXY(Object, (x+lin+topbit-bit), (y+lin+bit), fgcol); + break; + } + else if (fill) + switch (dir) { + case 0: + VGLSetXY(Object, (x+topbit-bit), (y+lin), bgcol); + break; + case 1: + VGLSetXY(Object, (x+lin), (y-topbit+bit), bgcol); + break; + case 2: + VGLSetXY(Object, (x-topbit+bit), (y-lin), bgcol); + break; + case 3: + VGLSetXY(Object, (x-lin), (y+topbit-bit), bgcol); + break; + case 4: + VGLSetXY(Object, (x+lin+topbit-bit), (y+lin+bit), bgcol); + break; + } + } + } +} + +void +VGLBitmapString(VGLBitmap *Object, int x, int y, char *str, + u_long fgcol, u_long bgcol, int fill, int dir) +{ + int pos; + + for (pos=0; pos<strlen(str); pos++) { + switch (dir) { + case 0: + VGLBitmapPutChar(Object, x+(pos*VGLTextFont->Width), y, + str[pos], fgcol, bgcol, fill, dir); + break; + case 1: + VGLBitmapPutChar(Object, x, y-(pos*VGLTextFont->Width), + str[pos], fgcol, bgcol, fill, dir); + break; + case 2: + VGLBitmapPutChar(Object, x-(pos*VGLTextFont->Width), y, + str[pos], fgcol, bgcol, fill, dir); + break; + case 3: + VGLBitmapPutChar(Object, x, y+(pos*VGLTextFont->Width), + str[pos], fgcol, bgcol, fill, dir); + break; + case 4: + VGLBitmapPutChar(Object, x+(pos*VGLTextFont->Width), + y-(pos*VGLTextFont->Width), + str[pos], fgcol, bgcol, fill, dir); + break; + } + } +} + +byte VGLFont[] = { +0,0,0,0,0,0,0,0,126,129,165,129,189,153,129,126,126,255,219,255,195,231, +255,126,108,254,254,254,124,56,16,0,16,56,124,254,124,56,16,0,56,124,56, +254,254,124,56,124,16,16,56,124,254,124,56,124,0,0,24,60,60,24,0,0,255, +255,231,195,195,231,255,255,0,60,102,66,66,102,60,0,255,195,153,189,189, +153,195,255,15,7,15,125,204,204,204,120,60,102,102,102,60,24,126,24,63, +51,63,48,48,112,240,224,127,99,127,99,99,103,230,192,153,90,60,231,231, +60,90,153,128,224,248,254,248,224,128,0,2,14,62,254,62,14,2,0,24,60,126, +24,24,126,60,24,102,102,102,102,102,0,102,0,127,219,219,123,27,27,27,0, +62,99,56,108,108,56,204,120,0,0,0,0,126,126,126,0,24,60,126,24,126,60,24, +255,24,60,126,24,24,24,24,0,24,24,24,24,126,60,24,0,0,24,12,254,12,24,0, +0,0,48,96,254,96,48,0,0,0,0,192,192,192,254,0,0,0,36,102,255,102,36,0,0, +0,24,60,126,255,255,0,0,0,255,255,126,60,24,0,0,0,0,0,0,0,0,0,0,48,120, +120,48,48,0,48,0,108,108,108,0,0,0,0,0,108,108,254,108,254,108,108,0,48, +124,192,120,12,248,48,0,0,198,204,24,48,102,198,0,56,108,56,118,220,204, +118,0,96,96,192,0,0,0,0,0,24,48,96,96,96,48,24,0,96,48,24,24,24,48,96,0, +0,102,60,255,60,102,0,0,0,48,48,252,48,48,0,0,0,0,0,0,0,48,48,96,0,0,0, +252,0,0,0,0,0,0,0,0,0,48,48,0,6,12,24,48,96,192,128,0,124,198,206,222,246, +230,124,0,48,112,48,48,48,48,252,0,120,204,12,56,96,204,252,0,120,204,12, +56,12,204,120,0,28,60,108,204,254,12,30,0,252,192,248,12,12,204,120,0,56, +96,192,248,204,204,120,0,252,204,12,24,48,48,48,0,120,204,204,120,204,204, +120,0,120,204,204,124,12,24,112,0,0,48,48,0,0,48,48,0,0,48,48,0,0,48,48, +96,24,48,96,192,96,48,24,0,0,0,252,0,0,252,0,0,96,48,24,12,24,48,96,0,120, +204,12,24,48,0,48,0,124,198,222,222,222,192,120,0,48,120,204,204,252,204, +204,0,252,102,102,124,102,102,252,0,60,102,192,192,192,102,60,0,248,108, +102,102,102,108,248,0,254,98,104,120,104,98,254,0,254,98,104,120,104,96, +240,0,60,102,192,192,206,102,62,0,204,204,204,252,204,204,204,0,120,48, +48,48,48,48,120,0,30,12,12,12,204,204,120,0,230,102,108,120,108,102,230, +0,240,96,96,96,98,102,254,0,198,238,254,254,214,198,198,0,198,230,246,222, +206,198,198,0,56,108,198,198,198,108,56,0,252,102,102,124,96,96,240,0,120, +204,204,204,220,120,28,0,252,102,102,124,108,102,230,0,120,204,224,112, +28,204,120,0,252,180,48,48,48,48,120,0,204,204,204,204,204,204,252,0,204, +204,204,204,204,120,48,0,198,198,198,214,254,238,198,0,198,198,108,56,56, +108,198,0,204,204,204,120,48,48,120,0,254,198,140,24,50,102,254,0,120,96, +96,96,96,96,120,0,192,96,48,24,12,6,2,0,120,24,24,24,24,24,120,0,16,56, +108,198,0,0,0,0,0,0,0,0,0,0,0,255,48,48,24,0,0,0,0,0,0,0,120,12,124,204, +118,0,224,96,96,124,102,102,220,0,0,0,120,204,192,204,120,0,28,12,12,124, +204,204,118,0,0,0,120,204,252,192,120,0,56,108,96,240,96,96,240,0,0,0,118, +204,204,124,12,248,224,96,108,118,102,102,230,0,48,0,112,48,48,48,120,0, +12,0,12,12,12,204,204,120,224,96,102,108,120,108,230,0,112,48,48,48,48, +48,120,0,0,0,204,254,254,214,198,0,0,0,248,204,204,204,204,0,0,0,120,204, +204,204,120,0,0,0,220,102,102,124,96,240,0,0,118,204,204,124,12,30,0,0, +220,118,102,96,240,0,0,0,124,192,120,12,248,0,16,48,124,48,48,52,24,0,0, +0,204,204,204,204,118,0,0,0,204,204,204,120,48,0,0,0,198,214,254,254,108, +0,0,0,198,108,56,108,198,0,0,0,204,204,204,124,12,248,0,0,252,152,48,100, +252,0,28,48,48,224,48,48,28,0,24,24,24,0,24,24,24,0,224,48,48,28,48,48, +224,0,118,220,0,0,0,0,0,0,0,16,56,108,198,198,254,0,0,0,0,0,0,0,0,0,0,0, +60,126,255,126,24,0,170,85,85,170,170,85,85,170,68,68,68,68,31,4,4,4,124, +64,64,64,31,16,16,16,56,68,68,56,30,17,20,19,64,64,64,124,31,16,16,16,56, +108,56,0,0,0,0,0,0,0,24,24,24,24,126,0,68,100,76,68,16,16,16,31,68,68,40, +16,31,4,4,4,24,24,24,24,248,0,0,0,0,0,0,0,248,24,24,24,0,0,0,0,31,24,24, +24,24,24,24,24,31,0,0,0,24,24,24,24,255,24,24,24,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,255,0,0,0,0,0,0,0,0,0,255,0,0,0,0,0,0,0,0,0,24,24,24, +24,31,24,24,24,24,24,24,24,248,24,24,24,24,24,24,24,255,0,0,0,0,0,0,0,255, +24,24,24,24,24,24,24,24,24,24,24,0,12,48,96,24,12,126,0,0,48,12,6,24,48, +126,0,0,0,3,62,54,54,108,0,0,0,4,126,16,126,64,0,0,28,48,48,48,48,126,0, +0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,48,0,48,48,120,120,48,0,0,0,16,124,192, +192,124,16,0,56,96,96,240,96,252,0,0,195,60,102,102,60,195,0,0,204,204, +120,48,252,48,0,24,24,24,0,24,24,24,0,126,192,124,198,124,6,252,0,198,0, +0,0,0,0,0,0,124,130,186,162,186,130,124,0,28,6,30,34,31,63,0,0,0,51,102, +204,102,51,0,0,0,254,6,0,0,0,0,0,0,0,0,0,0,0,0,0,124,130,186,178,170,130, +124,0,254,0,0,0,0,0,0,0,56,108,56,0,0,0,0,0,0,16,124,16,0,124,0,0,28,54, +6,24,62,0,0,0,30,2,14,2,30,0,0,0,24,48,0,0,0,0,0,0,0,0,204,204,204,204, +118,192,126,202,202,126,10,10,10,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,24,48,6, +14,6,6,6,0,0,0,14,17,17,17,14,31,0,0,0,204,102,51,102,204,0,0,96,224,102, +108,51,103,15,3,96,224,102,108,54,106,4,14,240,32,150,108,51,103,15,3,48, +0,48,96,192,204,120,0,24,12,48,120,204,252,204,0,96,192,48,120,204,252, +204,0,120,132,48,120,204,252,204,0,102,152,48,120,204,252,204,0,204,0,48, +120,204,252,204,0,48,72,48,120,204,252,204,0,62,120,152,156,248,152,158, +0,60,102,192,192,192,102,28,48,48,24,254,98,120,98,254,0,24,48,254,98,120, +98,254,0,56,68,254,98,120,98,254,0,102,0,254,98,120,98,254,0,96,48,120, +48,48,48,120,0,24,48,120,48,48,48,120,0,120,132,120,48,48,48,120,0,204, +0,120,48,48,48,120,0,120,108,102,246,102,108,120,0,102,152,230,246,222, +206,198,0,48,24,124,198,198,198,124,0,24,48,124,198,198,198,124,0,56,68, +124,198,198,198,124,0,102,152,124,198,198,198,124,0,198,0,124,198,198,198, +124,0,0,198,108,56,56,108,198,0,6,124,206,154,178,230,120,192,96,48,204, +204,204,204,252,0,24,48,204,204,204,204,252,0,120,132,204,204,204,204,252, +0,204,0,204,204,204,204,252,0,24,48,204,204,120,48,120,0,96,120,108,120, +96,96,96,0,120,204,196,220,198,198,220,192,48,24,120,12,124,204,118,0,24, +48,120,12,124,204,118,0,120,132,120,12,124,204,118,0,102,152,120,12,124, +204,118,0,204,0,120,12,124,204,118,0,48,72,56,12,124,204,118,0,0,0,236, +50,126,176,110,0,0,0,60,102,192,102,28,48,48,24,120,204,252,192,120,0,24, +48,120,204,252,192,120,0,120,132,120,204,252,192,120,0,204,0,120,204,252, +192,120,0,96,48,0,112,48,48,120,0,24,48,0,112,48,48,120,0,112,136,0,112, +48,48,120,0,204,0,0,112,48,48,120,0,108,56,108,12,108,204,120,0,102,152, +248,204,204,204,204,0,96,48,0,124,198,198,124,0,24,48,0,124,198,198,124, +0,56,68,0,124,198,198,124,0,102,152,0,124,198,198,124,0,198,0,0,124,198, +198,124,0,0,0,24,0,126,0,24,0,0,0,6,124,222,246,124,192,96,48,0,204,204, +204,118,0,24,48,0,204,204,204,118,0,48,72,0,204,204,204,118,0,204,0,0,204, +204,204,118,0,24,48,204,204,204,124,12,248,224,120,108,102,108,120,224, +0,204,0,204,204,204,124,12,248 +}; diff --git a/lib/libvgl/vgl.3 b/lib/libvgl/vgl.3 new file mode 100644 index 000000000000..b17ad315fc0c --- /dev/null +++ b/lib/libvgl/vgl.3 @@ -0,0 +1,469 @@ +.\"- +.\" Copyright (c) 1997 Søren Schmidt +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer, +.\" in this position and unchanged. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" 3. The name of the author may not be used to endorse or promote products +.\" derived from this software without specific prior written permission. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +.\" IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +.\" OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +.\" IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +.\" INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +.\" NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +.\" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +.\" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +.\" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +.\" THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +.Dd February 25, 2012 +.Dt VGL 3 +.Os +.Sh NAME +.Nm VGLBitmapAllocateBits , +.Nm VGLBitmapCopy , +.Nm VGLBitmapCreate , +.Nm VGLBitmapDestroy , +.Nm VGLBitmapPutChar , +.Nm VGLBitmapString , +.Nm VGLBlankDisplay , +.Nm VGLBox , +.Nm VGLCheckSwitch , +.Nm VGLClear , +.Nm VGLEllipse , +.Nm VGLEnd , +.Nm VGLFilledBox , +.Nm VGLFilledEllipse , +.Nm VGLGetXY , +.Nm VGLInit , +.Nm VGLLine , +.Nm VGLKeyboardInit , +.Nm VGLKeyboardEnd , +.Nm VGLKeyboardGetCh , +.Nm VGLMouseInit , +.Nm VGLMouseMode , +.Nm VGLMouseSetImage , +.Nm VGLMouseSetStdImage , +.Nm VGLMouseStatus , +.Nm VGLPanScreen , +.Nm VGLSetBorder , +.Nm VGLSetPalette , +.Nm VGLSetPaletteIndex , +.Nm VGLSetVScreenSize , +.Nm VGLSetXY , +.Nm VGLTextSetFontFile +.Nd Video Graphics Library functions +.Sh LIBRARY +.Lb libvgl +.Sh SYNOPSIS +.In sys/fbio.h +.In sys/consio.h +.In sys/kbio.h +.In vgl.h +.Ft int +.Fn VGLInit "int mode" +.Ft void +.Fn VGLEnd "void" +.Ft void +.Fn VGLCheckSwitch "void" +.Ft int +.Fn VGLTextSetFontFile "char *filename" +.Ft int +.Fn VGLKeyboardInit "int code" +.Ft void +.Fn VGLKeyboardEnd "void" +.Ft int +.Fn VGLKeyboardGetCh "void" +.Ft int +.Fn VGLMouseInit "int mode" +.Ft void +.Fn VGLMouseMode "int mode" +.Ft int +.Fn VGLMouseStatus "int *x" "int *y" "char *buttons" +.Ft void +.Fn VGLMouseSetImage "VGLBitmap *AndMask" "VGLBitmap *OrMask" +.Ft void +.Fn VGLMouseSetStdImage "void" +.Ft u_long +.Fn VGLGetXY "VGLBitmap *object" "int x" "int y" +.Ft void +.Fn VGLSetXY "VGLBitmap *object" "int x" "int y" "u_long color" +.Ft void +.Fn VGLLine "VGLBitmap *object" "int x1" "int y1" "int x2" "int y2" "u_long color" +.Ft void +.Fn VGLBox "VGLBitmap *object" "int x1" "int y1" "int x2" "int y2" "u_long color" +.Ft void +.Fn VGLFilledBox "VGLBitmap *object" "int x1" "int y1" "int x2" "int y2" "u_long color" +.Ft void +.Fn VGLEllipse "VGLBitmap *object" "int xc" "int yc" "int a" "int b" "u_long color" +.Ft void +.Fn VGLFilledEllipse "VGLBitmap *object" "int xc" "int yc" "int a" "int b" "u_long color" +.Ft VGLBitmap * +.Fn VGLBitmapCreate "int type" "int xsize" "int ysize" "byte *bits" +.Ft void +.Fn VGLBitmapDestroy "VGLBitmap *object" +.Ft int +.Fn VGLBitmapAllocateBits "VGLBitmap *object" +.Ft int +.Fn VGLBitmapCopy "VGLBitmap *src" "int srcx" "int srcy" "VGLBitmap *dst" "int dstx" "int dsty" "int width" "int hight" +.Ft void +.Fn VGLBitmapPutChar "VGLBitmap *Object" "int x" "int y" "byte ch" "u_long fgcol" "u_long bgcol" "int fill" "int dir" +.Ft void +.Fn VGLBitmapString "VGLBitmap *Object" "int x" "int y" "char *str" "u_long fgcol" "u_long bgcol" "int fill" "int dir" +.Ft void +.Fn VGLClear "VGLBitmap *object" "u_long color" +.Ft void +.Fn VGLSetPalette "byte *red" "byte *green" "byte *blue" +.Ft void +.Fn VGLSetPaletteIndex "byte color" "byte red" "byte green" "byte blue" +.Ft void +.Fn VGLSetBorder "byte color" +.Ft int +.Fn VGLSetVScreenSize "VGLBitmap *object" "int vxsize" "int vysize" +.Ft int +.Fn VGLPanScreen "VGLBitmap *object" "int x" "int y" +.Ft void +.Fn VGLBlankDisplay "int blank" +.Sh DESCRIPTION +.Nm Libvgl +is a library that enables the programmer access to the graphics +modes supported by the console driver (syscons). +The library takes care of +programming the actual video hardware, and provides a number of simple +functions to do various graphic operations. +There is also support for a +mouse via the standard mouse system in +.Fx , +see +.Xr mouse 4 , +including the ability to transparently have a mouse pointer superimposed on +the graphic image currently being worked on. +The library takes care of screen switching by storing the current image in +memory before switching to another virtual console, and restoring when the +user switches back. +This allows several graphic applications at once, but +on different virtual consoles. +.Pp +Below is a short description of the various functions: +.Pp +.Fn VGLInit +initialize the library and set up the graphic mode +.Va mode . +.Pp +.Fn VGLEnd +terminate graphic mode, and restore the screenmode that was active before +.Fn VGLInit +was called. +.Pp +.Fn VGLCheckSwitch +if the program goes into longer periods of processing without doing +any graphics output, calling this function occasionally will allow +the system to switch screens. +.Pp +.Fn VGLTextSetFontFile +instruct the char/string functions to use the font in file +.Pa filename +instead of the builtin font. +.Pp +.Fn VGLKeyboardInit +set up the keyboard in the +.Dq raw +I/O mode and +specify the key code to be used. +.Va code +must be +.Dv VGL_XLATEKEYS , +.Dv VGL_CODEKEYS , +or +.Dv VGL_RAWKEYS . +When +.Dv VGL_XLATEKEYS +is specified, the keyboard translates the raw keyboard scan code into +a character code. +If +.Dv VGL_RAWKEYS +is used, the raw keyboard scan code is read as is. +.Dv VGL_CODEKEYS +is the intermediate key code; each key is assigned a unique code whereas +more than one raw scan code may be generated when a key is pressed. +.Pp +.Fn VGLKeyboardEnd +when you have finished using the keyboard, call this function. +.Pp +.Fn VGLKeyboardGetCh +read one byte from the keyboard. +As the keyboard I/O is in the +.Dq raw +input mode, the function will not block even if there is no input data, +and returns 0. +.Pp +.Fn VGLMouseInit +initialize the mouse. +The optional on-screen mouse pointer is shown if the +argument is +.Dv VGL_MOUSESHOW . +.Pp +.Fn VGLMouseMode +either shows the mouse pointer if the argument is +.Dv VGL_MOUSESHOW , +or hides the mouse pointer if the argument is +.Dv VGL_MOUSEHIDE . +.Pp +.Fn VGLMouseStatus +returns the current mouse pointer coordinates and button state in +.Va x , y , +buttons. +The return value reflects if the mouse pointer +is currently shown on screen or not. +.Pp +.Fn VGLMouseSetImage +with this function it is possible to change the image of the mouse pointer +on screen. +.Pp +.Fn VGLMouseSetStdImage +this function restores the mouse pointer to the standard arrow. +.Pp +.Fn VGLGetXY +retrieves the color of the pixel located at +.Va x , y , +coordinates of the +.Va object +argument, and returns it as a u_long value. +.Pp +.Fn VGLSetXY +sets the color of the pixel located at +.Va x , y , +coordinates of the +.Va object +argument to +.Va color +u_long value. +.Pp +.Fn VGLLine +draw a line from +.Va x1 , y1 +to +.Va x2 , y2 +in color +.Va color . +.Pp +.Fn VGLBox +draw a box with upper left hand corner at +.Va x1 , y1 +and lower right hand corner at +.Va x2 , y2 +in color +.Va color . +.Pp +.Fn VGLFilledBox +draw a filled (solid) box with upper left hand corner at +.Va x1 , y1 +and lower right hand corner at +.Va x2 , y2 +in color +.Va color . +.Pp +.Fn VGLEllipse +draw an ellipse centered at +.Va xc , yc +make it +.Va a +pixels wide, and +.Va b +pixels high in color +.Va color . +.Pp +.Fn VGLFilledEllipse +draw a filled (solid) ellipse centered at +.Va xc , yc +make it +.Va a +pixels wide, and +.Va b +pixels high in color +.Va color . +.Pp +.Fn VGLBitmapCreate +create a bitmap object and initialize it with the specified +values and bit data. +.Va type +must be +.Dv MEMBUF +for the in-memory bitmap. +.Va bits +may be NULL so that bitmap data may be associated later. +.Pp +There also is a macro, +.Fn VGLBITMAP_INITIALIZER "type" "xsize" "ysize" "bits" +to initialize a statically declared bitmap object. +.Pp +.Fn VGLBitmapDestroy +free the bitmap data and the bitmap object. +.Pp +.Fn VGLBitmapAllocateBits +allocate a bit data buffer for the specified object. +.Pp +.Fn VGLBitmapCopy +copy a rectangle of pixels from bitmap +.Va src +upper left hand corner at +.Va srcx , srcy +to bitmap +.Va dst +at +.Va dstx , dsty +of the size +.Va width , height . +.Pp +.Fn VGLBitmapPutChar +write the character +.Va ch +at position +.Va x , y +in foreground color +.Va fgcol . +If +.Va fill +is != 0, use the color +.Va bgcol +as background otherwise the background is transparent. +The character is drawn in the direction specified by the argument +.Va dir . +.Pp +.Fn VGLBitmapString +write the string +.Va str +at position +.Va x , y +in foreground color +.Va fgcol . +If +.Va fill +is != 0, use the color +.Va bgcol +as background otherwise the background is transparent. +The string is drawn in the direction specified by the argument +.Va dir . +.Pp +.Fn VGLClear +clears the entire bitmap to color +.Va color . +.Pp +.Fn VGLSetPalette +this function sets the palette used, the arguments +.Va red , green , blue +should point to byte arrays of 256 positions each. +.Pp +.Fn VGLSetPaletteIndex +set the palette index +.Va color +to the specified RGB value. +.Pp +.Fn VGLSetBorder +set the border color to color +.Va color . +.Pp +.Fn VGLSetVScreenSize +change the virtual screen size of the display. +Note that this +function must be called when our vty is in the foreground. +And +.Va object +must be +.Va VGLDisplay . +Passing an in-memory bitmap to this function results in error. +.Pp +The desired virtual screen width may not be achievable because +of the video card hardware. +In such case the video driver (and +underlying video BIOS) may choose the next largest values. +Always examine +.Va object->VXsize +and +.Va VYsize +after calling this function, in order to see how the virtual screen +is actually set up. +.Pp +In order to set up the largest possible virtual screen, you may +call this function with arbitrary large values. +.Pp +.Dl VGLSetVScreenSize(10000, 10000); +.Pp +.Fn VGLPanScreen +change the origin of the displayed screen in the virtual screen. +Note that this function must be called when our vty is in the +foreground. +.Va object +must be +.Va VGLDisplay . +Passing an in-memory bitmap to this function results in error. +.Pp +.Fn VGLBlankDisplay +blank the display if the argument +.Va blank +\*(Ne 0. +This can be done to shut off the screen during display updates that +the user should first see when it is done. +.Ss Program termination and signal processing +It is important to call +.Fn VGLEnd +before terminating the program. +Care must be taken if you install signal handlers and try to call +.Fn VGLEnd +and +.Xr exit 3 +to end the program. +If a signal is caught while the program is inside +.Nm libvgl +functions, +.Fn VGLEnd +may not be able to properly restore the graphics hardware. +.Pp +The recommended way to handle signals and program termination is to +have a flag to indicate signal's delivery. +Your signal handlers set this flag but do not terminate +the program immediately. +The main part of the program checks the flag to see if it is +supposed to terminate, and calls +.Fn VGLEnd +and +.Xr exit 3 +if the flag is set. +.Pp +Note that +.Fn VGLInit +installs its internal signal handlers for +.Dv SIGINT , SIGTERM , SIGSEGV , +and +.Dv SIGBUS , +and terminates the program at appropriate time, +after one of these signals is caught. +If you want to have your own signal handlers for these signals, +install handlers +.Em after +.Fn VGLInit . +.Pp +.Dv SIGUSR1 +and +.Dv SIGUSR2 +are internally used by +.Nm libvgl +to control screen switching and the mouse pointer, +and are not available to +.Nm libvgl +client programs. +.Sh HISTORY +The +.Nm vgl +library appeared in +.Fx 3.0 . +.Sh AUTHORS +.An S\(/oren Schmidt Aq Mt sos@FreeBSD.org diff --git a/lib/libvgl/vgl.h b/lib/libvgl/vgl.h new file mode 100644 index 000000000000..fc4b96e68389 --- /dev/null +++ b/lib/libvgl/vgl.h @@ -0,0 +1,161 @@ +/*- + * SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (c) 1991-1997 Søren Schmidt + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer + * in this position and unchanged. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _VGL_H_ +#define _VGL_H_ + +#include <stdlib.h> +#include <unistd.h> +#include <string.h> +#include <machine/cpufunc.h> + +typedef unsigned char byte; +typedef struct { + byte Type; + int Xsize, Ysize; + int VXsize, VYsize; + int Xorigin, Yorigin; + byte *Bitmap; + int PixelBytes; +} VGLBitmap; + +#define VGLBITMAP_INITIALIZER(t, x, y, bits) \ + { (t), (x), (y), (x), (y), 0, 0, (bits), -1 } + +/* + * Defined Type's + */ +#define MEMBUF 0 +#define VIDBUF4 1 +#define VIDBUF8 2 +#define VIDBUF8X 3 +#define VIDBUF8S 4 +#define VIDBUF4S 5 +#define VIDBUF16 6 /* Direct Color linear buffer */ +#define VIDBUF24 7 /* Direct Color linear buffer */ +#define VIDBUF32 8 /* Direct Color linear buffer */ +#define VIDBUF16S 9 /* Direct Color segmented buffer */ +#define VIDBUF24S 10 /* Direct Color segmented buffer */ +#define VIDBUF32S 11 /* Direct Color segmented buffer */ +#define NOBUF 255 + +typedef struct VGLText { + byte Width, Height; + byte *BitmapArray; +} VGLText; + +typedef struct VGLObject { + int Id; + int Type; + int Status; + int Xpos, Ypos; + int Xhot, Yhot; + VGLBitmap *Image; + VGLBitmap *Mask; + int (*CallBackFunction)(); +} VGLObject; + +#define MOUSE_IMG_SIZE 16 +#define VGL_MOUSEHIDE 0 +#define VGL_MOUSESHOW 1 +#define VGL_MOUSEFREEZE 0 +#define VGL_MOUSEUNFREEZE 1 +#define VGL_DIR_RIGHT 0 +#define VGL_DIR_UP 1 +#define VGL_DIR_LEFT 2 +#define VGL_DIR_DOWN 3 +#define VGL_RAWKEYS 1 +#define VGL_CODEKEYS 2 +#define VGL_XLATEKEYS 3 + +extern video_adapter_info_t VGLAdpInfo; +extern video_info_t VGLModeInfo; +extern VGLBitmap *VGLDisplay; +extern VGLBitmap VGLVDisplay; +extern byte *VGLBuf; + +/* + * Prototypes + */ +/* bitmap.c */ +int __VGLBitmapCopy(VGLBitmap *src, int srcx, int srcy, VGLBitmap *dst, int dstx, int dsty, int width, int hight); +int VGLBitmapCopy(VGLBitmap *src, int srcx, int srcy, VGLBitmap *dst, int dstx, int dsty, int width, int hight); +VGLBitmap *VGLBitmapCreate(int type, int xsize, int ysize, byte *bits); +void VGLBitmapDestroy(VGLBitmap *object); +int VGLBitmapAllocateBits(VGLBitmap *object); +void VGLBitmapCvt(VGLBitmap *src, VGLBitmap *dst); +/* keyboard.c */ +int VGLKeyboardInit(int mode); +void VGLKeyboardEnd(void); +int VGLKeyboardGetCh(void); +/* main.c */ +void VGLEnd(void); +int VGLInit(int mode); +void VGLCheckSwitch(void); +int VGLSetVScreenSize(VGLBitmap *object, int VXsize, int VYsize); +int VGLPanScreen(VGLBitmap *object, int x, int y); +int VGLSetSegment(unsigned int offset); +/* mouse.c */ +int __VGLMouseMode(int mode); +void VGLMouseMode(int mode); +void VGLMouseSetImage(VGLBitmap *AndMask, VGLBitmap *OrMask); +void VGLMouseSetStdImage(void); +int VGLMouseInit(int mode); +void VGLMouseRestore(void); +int VGLMouseStatus(int *x, int *y, char *buttons); +void VGLMouseFreeze(void); +int VGLMouseFreezeXY(int x, int y); +void VGLMouseMerge(int x, int y, int width, byte *line); +int VGLMouseOverlap(int x, int y, int width, int hight); +void VGLMouseUnFreeze(void); +/* simple.c */ +void VGLSetXY(VGLBitmap *object, int x, int y, u_long color); +u_long VGLGetXY(VGLBitmap *object, int x, int y); +void VGLLine(VGLBitmap *object, int x1, int y1, int x2, int y2, u_long color); +void VGLBox(VGLBitmap *object, int x1, int y1, int x2, int y2, u_long color); +void VGLFilledBox(VGLBitmap *object, int x1, int y1, int x2, int y2, u_long color); +void VGLEllipse(VGLBitmap *object, int xc, int yc, int a, int b, u_long color); +void VGLFilledEllipse(VGLBitmap *object, int xc, int yc, int a, int b, u_long color); +void VGLClear(VGLBitmap *object, u_long color); +u_long VGLrgb332ToNative(byte c); +void VGLRestoreBlank(void); +void VGLRestoreBorder(void); +void VGLRestorePalette(void); +void VGLSavePalette(void); +void VGLSetPalette(byte *red, byte *green, byte *blue); +void VGLSetPaletteIndex(byte color, byte red, byte green, byte blue); +void VGLSetBorder(byte color); +void VGLBlankDisplay(int blank); +/* text.c */ +int VGLTextSetFontFile(char *filename); +void VGLBitmapPutChar(VGLBitmap *Object, int x, int y, byte ch, u_long fgcol, u_long bgcol, int fill, int dir); +void VGLBitmapString(VGLBitmap *Object, int x, int y, char *str, u_long fgcol, u_long bgcol, int fill, int dir); + +#endif /* !_VGL_H_ */ |