Index: head/lib/libgssapi/gss_display_status.c =================================================================== --- head/lib/libgssapi/gss_display_status.c (revision 229783) +++ head/lib/libgssapi/gss_display_status.c (revision 229784) @@ -1,340 +1,340 @@ /*- * Copyright (c) 2005 Doug Rabson * 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. * 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. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. * * $FreeBSD$ */ /* - * Copyright (c) 1998 - 2005 Kungliga Tekniska Högskolan + * Copyright (c) 1998 - 2005 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * 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. * * 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. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``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 INSTITUTE OR CONTRIBUTORS 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. */ /* - * Copyright (c) 1998 - 2005 Kungliga Tekniska Högskolan + * Copyright (c) 1998 - 2005 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * 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. * * 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. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``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 INSTITUTE OR CONTRIBUTORS 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 #include #include #include #include #include "mech_switch.h" #include "utils.h" static const char * calling_error(OM_uint32 v) { static const char *msgs[] = { NULL, /* 0 */ "A required input parameter could not be read.", /* */ "A required output parameter could not be written.", /* */ "A parameter was malformed" }; v >>= GSS_C_CALLING_ERROR_OFFSET; if (v == 0) return ""; else if (v >= sizeof(msgs)/sizeof(*msgs)) return "unknown calling error"; else return msgs[v]; } static const char * routine_error(OM_uint32 v) { static const char *msgs[] = { "Function completed successfully", /* 0 */ "An unsupported mechanism was requested", "An invalid name was supplied", "A supplied name was of an unsupported type", "Incorrect channel bindings were supplied", "An invalid status code was supplied", "A token had an invalid MIC", "No credentials were supplied, " "or the credentials were unavailable or inaccessible.", "No context has been established", "A token was invalid", "A credential was invalid", "The referenced credentials have expired", "The context has expired", "Miscellaneous failure (see text)", "The quality-of-protection requested could not be provide", "The operation is forbidden by local security policy", "The operation or option is not available", "The requested credential element already exists", "The provided name was not a mechanism name.", }; v >>= GSS_C_ROUTINE_ERROR_OFFSET; if (v >= sizeof(msgs)/sizeof(*msgs)) return "unknown routine error"; else return msgs[v]; } static const char * supplementary_error(OM_uint32 v) { static const char *msgs[] = { "normal completion", "continuation call to routine required", "duplicate per-message token detected", "timed-out per-message token detected", "reordered (early) per-message token detected", "skipped predecessor token(s) detected" }; v >>= GSS_C_SUPPLEMENTARY_OFFSET; if (v >= sizeof(msgs)/sizeof(*msgs)) return "unknown routine error"; else return msgs[v]; } #if defined(__sparc64__) || defined(__arm__) || defined(__mips__) /* * These platforms don't support TLS on FreeBSD - threads will just * have to step on each other's error values for now. */ #define __thread #endif struct mg_thread_ctx { gss_OID mech; OM_uint32 maj_stat; OM_uint32 min_stat; gss_buffer_desc maj_error; gss_buffer_desc min_error; }; static __thread struct mg_thread_ctx last_error_context; static OM_uint32 _gss_mg_get_error(const gss_OID mech, OM_uint32 type, OM_uint32 value, gss_buffer_t string) { struct mg_thread_ctx *mg; mg = &last_error_context; if (mech != NULL && gss_oid_equal(mg->mech, mech) == 0) return (GSS_S_BAD_STATUS); switch (type) { case GSS_C_GSS_CODE: { if (value != mg->maj_stat || mg->maj_error.length == 0) break; string->value = malloc(mg->maj_error.length); string->length = mg->maj_error.length; memcpy(string->value, mg->maj_error.value, mg->maj_error.length); return (GSS_S_COMPLETE); } case GSS_C_MECH_CODE: { if (value != mg->min_stat || mg->min_error.length == 0) break; string->value = malloc(mg->min_error.length); string->length = mg->min_error.length; memcpy(string->value, mg->min_error.value, mg->min_error.length); return (GSS_S_COMPLETE); } } string->value = NULL; string->length = 0; return (GSS_S_BAD_STATUS); } void _gss_mg_error(struct _gss_mech_switch *m, OM_uint32 maj, OM_uint32 min) { OM_uint32 major_status, minor_status; OM_uint32 message_content; struct mg_thread_ctx *mg; mg = &last_error_context; gss_release_buffer(&minor_status, &mg->maj_error); gss_release_buffer(&minor_status, &mg->min_error); mg->mech = &m->gm_mech_oid; mg->maj_stat = maj; mg->min_stat = min; major_status = m->gm_display_status(&minor_status, maj, GSS_C_GSS_CODE, &m->gm_mech_oid, &message_content, &mg->maj_error); if (GSS_ERROR(major_status)) { mg->maj_error.value = NULL; mg->maj_error.length = 0; } major_status = m->gm_display_status(&minor_status, min, GSS_C_MECH_CODE, &m->gm_mech_oid, &message_content, &mg->min_error); if (GSS_ERROR(major_status)) { mg->min_error.value = NULL; mg->min_error.length = 0; } } OM_uint32 gss_display_status(OM_uint32 *minor_status, OM_uint32 status_value, int status_type, const gss_OID mech_type, OM_uint32 *message_content, gss_buffer_t status_string) { OM_uint32 major_status; _gss_buffer_zero(status_string); *message_content = 0; major_status = _gss_mg_get_error(mech_type, status_type, status_value, status_string); if (major_status == GSS_S_COMPLETE) { *message_content = 0; *minor_status = 0; return (GSS_S_COMPLETE); } *minor_status = 0; switch (status_type) { case GSS_C_GSS_CODE: { char *buf; if (GSS_SUPPLEMENTARY_INFO(status_value)) asprintf(&buf, "%s", supplementary_error( GSS_SUPPLEMENTARY_INFO(status_value))); else asprintf (&buf, "%s %s", calling_error(GSS_CALLING_ERROR(status_value)), routine_error(GSS_ROUTINE_ERROR(status_value))); if (buf == NULL) break; status_string->length = strlen(buf); status_string->value = buf; return (GSS_S_COMPLETE); } case GSS_C_MECH_CODE: { OM_uint32 maj_junk, min_junk; gss_buffer_desc oid; char *buf; maj_junk = gss_oid_to_str(&min_junk, mech_type, &oid); if (maj_junk != GSS_S_COMPLETE) { oid.value = strdup("unknown"); oid.length = 7; } asprintf (&buf, "unknown mech-code %lu for mech %.*s", (unsigned long)status_value, (int)oid.length, (char *)oid.value); if (maj_junk == GSS_S_COMPLETE) gss_release_buffer(&min_junk, &oid); if (buf == NULL) break; status_string->length = strlen(buf); status_string->value = buf; return (GSS_S_COMPLETE); } } _gss_buffer_zero(status_string); return (GSS_S_BAD_STATUS); } Index: head/lib/libgssapi/gss_pseudo_random.c =================================================================== --- head/lib/libgssapi/gss_pseudo_random.c (revision 229783) +++ head/lib/libgssapi/gss_pseudo_random.c (revision 229784) @@ -1,72 +1,72 @@ -/* - * Copyright (c) 2007 Kungliga Tekniska Högskolan +/*- + * Copyright (c) 2007 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * 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. * * 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. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``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 INSTITUTE OR CONTRIBUTORS 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. */ /* $FreeBSD$ */ /* $Id: gss_pseudo_random.c 20053 2007-01-24 01:31:35Z lha $ */ #include #include "mech_switch.h" #include "context.h" #include "utils.h" OM_uint32 gss_pseudo_random(OM_uint32 *minor_status, gss_ctx_id_t context, int prf_key, const gss_buffer_t prf_in, ssize_t desired_output_len, gss_buffer_t prf_out) { struct _gss_context *ctx = (struct _gss_context *) context; struct _gss_mech_switch *m = ctx->gc_mech; OM_uint32 major_status; _gss_buffer_zero(prf_out); *minor_status = 0; if (ctx == NULL) { *minor_status = 0; return GSS_S_NO_CONTEXT; } if (m->gm_pseudo_random == NULL) return GSS_S_UNAVAILABLE; major_status = (*m->gm_pseudo_random)(minor_status, ctx->gc_ctx, prf_key, prf_in, desired_output_len, prf_out); if (major_status != GSS_S_COMPLETE) _gss_mg_error(m, major_status, *minor_status); return major_status; } Index: head/lib/libgssapi/gss_release_oid.c =================================================================== --- head/lib/libgssapi/gss_release_oid.c (revision 229783) +++ head/lib/libgssapi/gss_release_oid.c (revision 229784) @@ -1,61 +1,61 @@ /*- - * Copyright (c) 2006 Kungliga Tekniska Högskolan + * Copyright (c) 2006 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * 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. * * 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. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``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 INSTITUTE OR CONTRIBUTORS 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. */ /* $FreeBSD$ */ #include #include /* RCSID("$Id: gss_release_oid.c 17747 2006-06-30 09:34:54Z lha $"); */ OM_uint32 gss_release_oid(OM_uint32 *minor_status, gss_OID *oid) { gss_OID o = *oid; *oid = GSS_C_NO_OID; if (minor_status != NULL) *minor_status = 0; if (o == GSS_C_NO_OID) return (GSS_S_COMPLETE); if (o->elements != NULL) { free(o->elements); o->elements = NULL; } o->length = 0; free(o); return (GSS_S_COMPLETE); } Index: head/lib/libutil/flopen.3 =================================================================== --- head/lib/libutil/flopen.3 (revision 229783) +++ head/lib/libutil/flopen.3 (revision 229784) @@ -1,101 +1,101 @@ .\"- -.\" Copyright (c) 2007 Dag-Erling Coïdan Smørgrav +.\" Copyright (c) 2007 Dag-Erling Coïdan Smørgrav .\" 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. .\" 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. .\" .\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. .\" .\" $FreeBSD$ .\" .Dd June 6, 2009 .Dt FLOPEN 3 .Os .Sh NAME .Nm flopen .Nd "Reliably open and lock a file" .Sh LIBRARY .Lb libutil .Sh SYNOPSIS .In sys/fcntl.h .In libutil.h .Ft int .Fn flopen "const char *path" "int flags" .Ft int .Fn flopen "const char *path" "int flags" "mode_t mode" .Sh DESCRIPTION The .Fn flopen function opens or creates a file and acquires an exclusive lock on it. It is essentially equivalent with calling .Fn open with the same parameters followed by .Fn flock with an .Va operation argument of .Dv LOCK_EX , except that .Fn flopen will attempt to detect and handle races that may occur between opening / creating the file and locking it. Thus, it is well suited for opening lock files, PID files, spool files, mailboxes and other kinds of files which are used for synchronization between processes. .Pp If .Va flags includes .Dv O_NONBLOCK and the file is already locked, .Fn flopen will fail and set .Va errno to .Dv EWOULDBLOCK . .Pp As with .Fn open , the additional .Va mode argument is required if .Va flags includes .Dv O_CREAT . .Sh RETURN VALUES If successful, .Fn flopen returns a valid file descriptor. Otherwise, it returns -1, and sets .Va errno as described in .Xr flock 2 and .Xr open 2 . .Sh SEE ALSO .Xr errno 2 , .Xr flock 2 , .Xr open 2 .Sh AUTHORS .An -nosplit The .Nm function and this manual page were written by .An Dag-Erling Sm\(/orgrav Aq des@FreeBSD.org . Index: head/lib/libutil/kld.3 =================================================================== --- head/lib/libutil/kld.3 (revision 229783) +++ head/lib/libutil/kld.3 (revision 229784) @@ -1,93 +1,93 @@ .\"- -.\" Copyright (c) 2006 Dag-Erling Coïdan Smørgrav +.\" Copyright (c) 2006 Dag-Erling Coïdan Smørgrav .\" 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. .\" 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. .\" .\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. .\" .\" $FreeBSD$ .\" .Dd February 18, 2006 .Dt KLD 3 .Os .Sh NAME .Nm kld_isloaded , .Nm kld_load .Nd kld utility functions .Sh LIBRARY .Lb libutil .Sh SYNOPSIS .In libutil.h .Ft int .Fn kld_isloaded "const char *name" .Ft int .Fn kld_load "const char *name" .Sh DESCRIPTION These functions facilitate loading kernel modules from userland applications. .Pp The .Fn kld_isloaded function takes a name and returns a non-zero value if a module of that name is currently loaded. The name can be either the name of a module file .Pq Pa cpufreq.ko , the same name without the .Pa .ko extension .Pq Pa cpufreq , or the name of a module contained within that file .Pq Pa cpu/ichss . Only the latter will return correct results if the module is compiled into the kernel. .Pp The .Fn kld_load function is a simple wrapper around the .Xr kldload 2 function. It returns zero if and only if the corresponding .Fn kldload call succeeded or returned .Er EEXIST (signifying that the requested module was already loaded). .Sh SEE ALSO .Xr kldfirstmod 2 , .Xr kldload 2 , .Xr kldnext 2 , .Xr kldstat 2 , .Xr modfnext 2 , .Xr modstat 2 , .Xr kld 4 .Sh HISTORY The .Fn kld_isloaded and .Fn kld_load functions first appeared in .Fx 6.3 . .Sh AUTHORS The .Fn kld_isloaded and .Fn kld_load functions and this manual page were written by .An Dag-Erling Sm\(/orgrav Aq des@FreeBSD.org . Index: head/lib/libvgl/bitmap.c =================================================================== --- head/lib/libvgl/bitmap.c (revision 229783) +++ head/lib/libvgl/bitmap.c (revision 229784) @@ -1,406 +1,406 @@ /*- - * Copyright (c) 1991-1997 Søren Schmidt + * 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 __FBSDID("$FreeBSD$"); #include #include #include #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 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; i = (width + start_offset) / 8; if (end_offset) i++; VGLPlane[0] = VGLBuf; VGLPlane[1] = VGLPlane[0] + i; VGLPlane[2] = VGLPlane[1] + i; VGLPlane[3] = VGLPlane[2] + i; 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; } if (start_offset || end_offset) width+=8; width /= 8; 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<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, width); } 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 = width; ; ) { len = min(VGLAdpInfo.va_window_size - offset, last); bcopy(&VGLPlane[i][width - 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; posVXsize * y + x; 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 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 VIDBUF8: case MEMBUF: address = dst->Bitmap + dst->VXsize * y + x; bcopy(line, address, width); break; case VIDBUF16: case VIDBUF24: case VIDBUF32: address = dst->Bitmap + (dst->VXsize * y + x) * dst->PixelBytes; bcopy(line, address, width * dst->PixelBytes); break; default: ; } } static void ReadVerticalLine(VGLBitmap *src, int x, int y, int width, byte *line) { int i, bit, pos, count, planepos, start_offset, end_offset, offset; int width2, len; byte *address; byte *VGLPlane[4]; switch (src->Type) { case VIDBUF4S: start_offset = (x & 0x07); end_offset = (x + width) & 0x07; count = (width + start_offset) / 8; if (end_offset) count++; VGLPlane[0] = VGLBuf; VGLPlane[1] = VGLPlane[0] + count; VGLPlane[2] = VGLPlane[1] + count; VGLPlane[3] = VGLPlane[2] + count; for (i=0; i<4; i++) { outb(0x3ce, 0x04); outb(0x3cf, i); pos = VGLAdpInfo.va_line_width*y + x/8; for (width2 = count; width2 > 0; ) { offset = VGLSetSegment(pos); len = min(VGLAdpInfo.va_window_size - offset, width2); bcopy(src->Bitmap + offset, &VGLPlane[i][count - width2], len); pos += len; width2 -= len; } } goto read_planar; case VIDBUF4: address = src->Bitmap + VGLAdpInfo.va_line_width * y + x/8; start_offset = (x & 0x07); end_offset = (x + width) & 0x07; count = (width + start_offset) / 8; if (end_offset) count++; VGLPlane[0] = VGLBuf; VGLPlane[1] = VGLPlane[0] + count; VGLPlane[2] = VGLPlane[1] + count; VGLPlane[3] = VGLPlane[2] + count; for (i=0; i<4; i++) { outb(0x3ce, 0x04); outb(0x3cf, i); bcopy(address, &VGLPlane[i][0], count); } read_planar: pos = 0; planepos = 0; bit = 7 - start_offset; while (pos < width) { for (; bit >= 0 && pos < width; bit--, pos++) { line[pos] = (VGLPlane[0][planepos] & (1<Bitmap + VGLAdpInfo.va_line_width * y + x/4; for (i=0; i<4; i++) { outb(0x3ce, 0x04); outb(0x3cf, (x + i)%4); for (planepos=0, pos=i; posVXsize * y + x; while (width > 0) { offset = VGLSetSegment(pos); i = min(VGLAdpInfo.va_window_size - offset, width); bcopy(src->Bitmap + offset, line, i); line += i; pos += i; width -= i; } break; case VIDBUF16S: case VIDBUF24S: case VIDBUF32S: width = width * src->PixelBytes; pos = (src->VXsize * y + x) * src->PixelBytes; while (width > 0) { offset = VGLSetSegment(pos); i = min(VGLAdpInfo.va_window_size - offset, width); bcopy(src->Bitmap + offset, line, i); line += i; pos += i; width -= i; } break; case VIDBUF8: case MEMBUF: address = src->Bitmap + src->VXsize * y + x; bcopy(address, line, width); break; case VIDBUF16: case VIDBUF24: case VIDBUF32: address = src->Bitmap + (src->VXsize * y + x) * src->PixelBytes; bcopy(address, line, width * src->PixelBytes); break; default: ; } } int __VGLBitmapCopy(VGLBitmap *src, int srcx, int srcy, VGLBitmap *dst, int dstx, int dsty, int width, int hight) { int srcline, dstline; 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; if (src->Type == MEMBUF) { for (srcline=srcy, dstline=dsty; srclineBitmap+(srcline*src->VXsize)+srcx)); } } else if (dst->Type == MEMBUF) { for (srcline=srcy, dstline=dsty; srclineBitmap+(dstline*dst->VXsize)+dstx)); } } else { byte buffer[2048]; /* XXX */ byte *p; if (width > sizeof(buffer)) { p = malloc(width); if (p == NULL) return 1; } else { p = buffer; } for (srcline=srcy, dstline=dsty; srcline sizeof(buffer)) free(p); } return 0; } int VGLBitmapCopy(VGLBitmap *src, int srcx, int srcy, VGLBitmap *dst, int dstx, int dsty, int width, int hight) { int error; VGLMouseFreeze(dstx, dsty, width, hight, 0); error = __VGLBitmapCopy(src, srcx, srcy, dst, dstx, dsty, width, hight); 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; return object; } void VGLBitmapDestroy(VGLBitmap *object) { if (object->Bitmap) free(object->Bitmap); free(object); } int VGLBitmapAllocateBits(VGLBitmap *object) { object->Bitmap = (byte *)malloc(object->VXsize*object->VYsize); if (object->Bitmap == NULL) return -1; return 0; } Index: head/lib/libvgl/keyboard.c =================================================================== --- head/lib/libvgl/keyboard.c (revision 229783) +++ head/lib/libvgl/keyboard.c (revision 229784) @@ -1,94 +1,94 @@ /*- - * Copyright (c) 1997 Søren Schmidt + * 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 __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #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; } Index: head/lib/libvgl/main.c =================================================================== --- head/lib/libvgl/main.c (revision 229783) +++ head/lib/libvgl/main.c (revision 229784) @@ -1,574 +1,574 @@ /*- - * Copyright (c) 1991-1997 Søren Schmidt + * 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 __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include "vgl.h" /* XXX Direct Color 24bits modes unsupported */ #define min(x, y) (((x) < (y)) ? (x) : (y)) #define max(x, y) (((x) > (y)) ? (x) : (y)) VGLBitmap *VGLDisplay; 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 vid_info_t VGLOldVInfo; void VGLEnd() { struct vt_mode smode; if (!VGLInitDone) return; VGLInitDone = 0; VGLSwitchPending = 0; VGLAbortPending = 0; signal(SIGUSR1, SIG_IGN); if (VGLMem != MAP_FAILED) { VGLClear(VGLDisplay, 0); munmap(VGLMem, VGLAdpInfo.va_window_size); } if (VGLOldMode >= M_VESA_BASE) { /* ugly, but necessary */ ioctl(0, _IO('V', VGLOldMode - M_VESA_BASE), 0); if (VGLOldMode == M_VESA_800x600) { int size[3]; size[0] = VGLOldVInfo.mv_csz; size[1] = VGLOldVInfo.mv_rsz; size[2] = 16; ioctl(0, KDRASTER, size); } } else { ioctl(0, _IO('S', VGLOldMode), 0); } 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 __unused) { VGLAbortPending = 1; signal(SIGINT, SIG_IGN); signal(SIGTERM, SIG_IGN); signal(SIGSEGV, SIG_IGN); signal(SIGBUS, SIG_IGN); signal(SIGUSR2, SIG_IGN); } 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; 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; /* If current mode is VESA_800x600 then save its geometry to restore later */ if ((VGLOldMode >= M_VESA_BASE) && (VGLOldMode == M_VESA_800x600)) { VGLOldVInfo.size = sizeof(VGLOldVInfo); if (ioctl(0, CONS_GETINFO, &VGLOldVInfo)) return -1; } VGLDisplay = (VGLBitmap *)malloc(sizeof(VGLBitmap)); if (VGLDisplay == NULL) return -2; if (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; 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; #if notyet case 3: VGLDisplay->Type = VIDBUF24; break; #endif 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; 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; VGLDisplay->VXsize = VGLAdpInfo.va_line_width *8/(VGLModeInfo.vi_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, 0, 0); if (VGLMem == MAP_FAILED) { VGLEnd(); return -7; } VGLDisplay->Bitmap = VGLMem; 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) { unsigned int offset; unsigned int len; int i; VGLSwitchPending = 0; if (VGLOnDisplay) { 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, 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); VGLPanScreen(VGLDisplay, VGLDisplay->Xorigin, VGLDisplay->Yorigin); switch (VGLDisplay->Type) { case VIDBUF4S: outb(0x3c6, 0xff); outb(0x3ce, 0x01); outb(0x3cf, 0x00); /* set/reset enable */ outb(0x3ce, 0x08); outb(0x3cf, 0xff); /* bit mask */ for (offset = 0; offset < VGLBufSize/VGLModeInfo.vi_planes; offset += len) { VGLSetSegment(offset); len = min(VGLBufSize/VGLModeInfo.vi_planes - offset, VGLAdpInfo.va_window_size); for (i = 0; i < VGLModeInfo.vi_planes; i++) { outb(0x3c4, 0x02); outb(0x3c5, 0x01<Type) { case VIDBUF4S: for (offset = 0; offset < VGLBufSize/VGLModeInfo.vi_planes; offset += len) { VGLSetSegment(offset); len = min(VGLBufSize/VGLModeInfo.vi_planes - offset, VGLAdpInfo.va_window_size); for (i = 0; i < VGLModeInfo.vi_planes; i++) { outb(0x3ce, 0x04); outb(0x3cf, i); bcopy(VGLMem, &VGLBuf[i*VGLBufSize/VGLModeInfo.vi_planes + offset], len); } } break; case VIDBUF4: case VIDBUF8X: /* * NOTE: the saved buffer is NOT in the MEMBUF format which * the ordinary memory bitmap object is stored in. XXX */ for (i = 0; i < VGLModeInfo.vi_planes; i++) { outb(0x3ce, 0x04); outb(0x3cf, i); bcopy(VGLMem, &VGLBuf[i*VGLAdpInfo.va_window_size], VGLAdpInfo.va_window_size); } break; case VIDBUF8: case VIDBUF8S: case VIDBUF16: case VIDBUF16S: case VIDBUF24: case VIDBUF24S: case VIDBUF32: case VIDBUF32S: for (offset = 0; offset < VGLBufSize; offset += len) { VGLSetSegment(offset); len = min(VGLBufSize - offset, VGLAdpInfo.va_window_size); bcopy(VGLMem, &VGLBuf[offset], len); } break; } VGLMem = MAP_FAILED; munmap(VGLDisplay->Bitmap, VGLAdpInfo.va_window_size); ioctl(0, VGLOldMode, 0); ioctl(0, KDSETMODE, KD_TEXT); 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) { 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 */ object->VXsize = VGLAdpInfo.va_line_width *8/(VGLModeInfo.vi_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; } Index: head/lib/libvgl/mouse.c =================================================================== --- head/lib/libvgl/mouse.c (revision 229783) +++ head/lib/libvgl/mouse.c (revision 229784) @@ -1,285 +1,285 @@ /*- - * Copyright (c) 1991-1997 Søren Schmidt + * 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 __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include "vgl.h" #define X 0xff static byte StdAndMask[MOUSE_IMG_SIZE*MOUSE_IMG_SIZE] = { X,X,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, X,X,X,X,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, X,X,X,X,X,X,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, 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,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,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,X,X,X,X,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,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, }; static byte StdOrMask[MOUSE_IMG_SIZE*MOUSE_IMG_SIZE] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,X,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,X,X,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,X,X,X,X,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,X,X,X,X,X,X,0,0,0,0,0,0,0,0,0, 0,X,X,0,X,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,X,X,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,X,X,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,X,X,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,X,X,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, }; #undef X static VGLBitmap VGLMouseStdAndMask = VGLBITMAP_INITIALIZER(MEMBUF, MOUSE_IMG_SIZE, MOUSE_IMG_SIZE, StdAndMask); static VGLBitmap VGLMouseStdOrMask = VGLBITMAP_INITIALIZER(MEMBUF, MOUSE_IMG_SIZE, MOUSE_IMG_SIZE, StdOrMask); static VGLBitmap *VGLMouseAndMask, *VGLMouseOrMask; static byte map[MOUSE_IMG_SIZE*MOUSE_IMG_SIZE]; static VGLBitmap VGLMouseSave = VGLBITMAP_INITIALIZER(MEMBUF, MOUSE_IMG_SIZE, MOUSE_IMG_SIZE, map); static int VGLMouseVisible = 0; static int VGLMouseFrozen = 0; static int VGLMouseShown = 0; static int VGLMouseXpos = 0; static int VGLMouseYpos = 0; static int VGLMouseButtons = 0; void VGLMousePointerShow() { byte buf[MOUSE_IMG_SIZE*MOUSE_IMG_SIZE]; VGLBitmap buffer = VGLBITMAP_INITIALIZER(MEMBUF, MOUSE_IMG_SIZE, MOUSE_IMG_SIZE, buf); byte crtcidx, crtcval, gdcidx, gdcval; int pos; if (!VGLMouseVisible) { VGLMouseVisible = 1; crtcidx = inb(0x3c4); crtcval = inb(0x3c5); gdcidx = inb(0x3ce); gdcval = inb(0x3cf); __VGLBitmapCopy(VGLDisplay, VGLMouseXpos, VGLMouseYpos, &VGLMouseSave, 0, 0, MOUSE_IMG_SIZE, MOUSE_IMG_SIZE); bcopy(VGLMouseSave.Bitmap, buffer.Bitmap, MOUSE_IMG_SIZE*MOUSE_IMG_SIZE); for (pos = 0; pos < MOUSE_IMG_SIZE*MOUSE_IMG_SIZE; pos++) buffer.Bitmap[pos]=(buffer.Bitmap[pos]&~(VGLMouseAndMask->Bitmap[pos])) | VGLMouseOrMask->Bitmap[pos]; __VGLBitmapCopy(&buffer, 0, 0, VGLDisplay, VGLMouseXpos, VGLMouseYpos, MOUSE_IMG_SIZE, MOUSE_IMG_SIZE); outb(0x3c4, crtcidx); outb(0x3c5, crtcval); outb(0x3ce, gdcidx); outb(0x3cf, gdcval); } } void VGLMousePointerHide() { byte crtcidx, crtcval, gdcidx, gdcval; if (VGLMouseVisible) { VGLMouseVisible = 0; crtcidx = inb(0x3c4); crtcval = inb(0x3c5); gdcidx = inb(0x3ce); gdcval = inb(0x3cf); __VGLBitmapCopy(&VGLMouseSave, 0, 0, VGLDisplay, VGLMouseXpos, VGLMouseYpos, MOUSE_IMG_SIZE, MOUSE_IMG_SIZE); outb(0x3c4, crtcidx); outb(0x3c5, crtcval); outb(0x3ce, gdcidx); outb(0x3cf, gdcval); } } void VGLMouseMode(int mode) { if (mode == VGL_MOUSESHOW) { if (VGLMouseShown == VGL_MOUSEHIDE) { VGLMousePointerShow(); VGLMouseShown = VGL_MOUSESHOW; } } else { if (VGLMouseShown == VGL_MOUSESHOW) { VGLMousePointerHide(); VGLMouseShown = VGL_MOUSEHIDE; } } } void VGLMouseAction(int dummy) { struct mouse_info mouseinfo; if (VGLMouseFrozen) { VGLMouseFrozen++; return; } mouseinfo.operation = MOUSE_GETINFO; ioctl(0, CONS_MOUSECTL, &mouseinfo); if (VGLMouseShown == VGL_MOUSESHOW) VGLMousePointerHide(); VGLMouseXpos = mouseinfo.u.data.x; VGLMouseYpos = mouseinfo.u.data.y; VGLMouseButtons = mouseinfo.u.data.buttons; if (VGLMouseShown == VGL_MOUSESHOW) VGLMousePointerShow(); } void VGLMouseSetImage(VGLBitmap *AndMask, VGLBitmap *OrMask) { if (VGLMouseShown == VGL_MOUSESHOW) VGLMousePointerHide(); VGLMouseAndMask = AndMask; VGLMouseOrMask = OrMask; if (VGLMouseShown == VGL_MOUSESHOW) VGLMousePointerShow(); } void VGLMouseSetStdImage() { if (VGLMouseShown == VGL_MOUSESHOW) VGLMousePointerHide(); VGLMouseAndMask = &VGLMouseStdAndMask; VGLMouseOrMask = &VGLMouseStdOrMask; if (VGLMouseShown == VGL_MOUSESHOW) VGLMousePointerShow(); } int VGLMouseInit(int mode) { struct mouse_info mouseinfo; int error; 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; } int VGLMouseStatus(int *x, int *y, char *buttons) { signal(SIGUSR2, SIG_IGN); *x = VGLMouseXpos; *y = VGLMouseYpos; *buttons = VGLMouseButtons; signal(SIGUSR2, VGLMouseAction); return VGLMouseShown; } int VGLMouseFreeze(int x, int y, int width, int hight, byte color) { if (!VGLMouseFrozen) { VGLMouseFrozen = 1; if (width > 1 || hight > 1) { /* bitmap */ if (VGLMouseShown == 1) { int overlap; if (x > VGLMouseXpos) overlap = (VGLMouseXpos + MOUSE_IMG_SIZE) - x; else overlap = (x + width) - VGLMouseXpos; if (overlap > 0) { if (y > VGLMouseYpos) overlap = (VGLMouseYpos + MOUSE_IMG_SIZE) - y; else overlap = (y + hight) - VGLMouseYpos; if (overlap > 0) VGLMousePointerHide(); } } } else { /* bit */ if (VGLMouseShown && x >= VGLMouseXpos && x < VGLMouseXpos + MOUSE_IMG_SIZE && y >= VGLMouseYpos && y < VGLMouseYpos + MOUSE_IMG_SIZE) { VGLMouseSave.Bitmap[(y-VGLMouseYpos)*MOUSE_IMG_SIZE+(x-VGLMouseXpos)] = (color); if (VGLMouseAndMask->Bitmap [(y-VGLMouseYpos)*MOUSE_IMG_SIZE+(x-VGLMouseXpos)]) { return 1; } } } } return 0; } void VGLMouseUnFreeze() { if (VGLMouseFrozen > 1) { VGLMouseFrozen = 0; VGLMouseAction(0); } else { VGLMouseFrozen = 0; if (VGLMouseShown == VGL_MOUSESHOW && !VGLMouseVisible) VGLMousePointerShow(); } } Index: head/lib/libvgl/simple.c =================================================================== --- head/lib/libvgl/simple.c (revision 229783) +++ head/lib/libvgl/simple.c (revision 229784) @@ -1,672 +1,672 @@ /*- - * Copyright (c) 1991-1997 Søren Schmidt + * 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 __FBSDID("$FreeBSD$"); #include #include #include "vgl.h" 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)) static void color2mem(u_long color, byte *b, int len) { switch (len) { case 4: b[3] = (color >> 24) & 0xff; /* fallthrough */ case 3: b[2] = (color >> 16) & 0xff; /* fallthrough */ case 2: b[1] = (color >> 8) & 0xff; /* fallthrough */ case 1: default: b[0] = color & 0xff; break; } return; } static u_long mem2color(byte *b, int len) { u_long color = 0; switch (len) { case 4: color |= (b[3] & 0xff) << 24; /* fallthrough */ case 3: color |= (b[2] & 0xff) << 16; /* fallthrough */ case 2: color |= (b[1] & 0xff) << 8; /* fallthrough */ case 1: default: color |= (b[0] & 0xff); break; } return color; } void VGLSetXY(VGLBitmap *object, int x, int y, u_long color) { int offset; byte b[4]; VGLCheckSwitch(); if (x>=0 && xVXsize && y>=0 && yVYsize) { if (!VGLMouseFreeze(x, y, 1, 1, color)) { switch (object->Type) { case MEMBUF: case VIDBUF8: object->Bitmap[y*object->VXsize+x]=((byte)color); break; case VIDBUF8S: object->Bitmap[VGLSetSegment(y*object->VXsize+x)]=((byte)color); break; case VIDBUF16: case VIDBUF24: case VIDBUF32: color2mem(color, b, object->PixelBytes); bcopy(b, &object->Bitmap[(y*object->VXsize+x) * object->PixelBytes], object->PixelBytes); break; case VIDBUF16S: case VIDBUF24S: case VIDBUF32S: color2mem(color, b, object->PixelBytes); offset = VGLSetSegment((y*object->VXsize+x) * object->PixelBytes); bcopy(b, &object->Bitmap[offset], object->PixelBytes); 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; } } VGLMouseUnFreeze(); } } u_long VGLGetXY(VGLBitmap *object, int x, int y) { int offset; byte b[4]; #if 0 int i; u_long color; byte mask; #endif VGLCheckSwitch(); if (x<0 || x>=object->VXsize || y<0 || y>=object->VYsize) return 0; switch (object->Type) { case MEMBUF: case VIDBUF8: return object->Bitmap[((y*object->VXsize)+x)]; case VIDBUF8S: return object->Bitmap[VGLSetSegment(y*object->VXsize+x)]; case VIDBUF16: case VIDBUF24: case VIDBUF32: bcopy(&object->Bitmap[(y*object->VXsize+x) * object->PixelBytes], b, object->PixelBytes); return (mem2color(b, object->PixelBytes)); case VIDBUF16S: case VIDBUF24S: case VIDBUF32S: offset = VGLSetSegment((y*object->VXsize+x) * object->PixelBytes); bcopy(&object->Bitmap[offset], b, object->PixelBytes); return (mem2color(b, object->PixelBytes)); case VIDBUF8X: outb(0x3ce, 0x04); outb(0x3cf, x & 0x3); return object->Bitmap[(unsigned)(VGLAdpInfo.va_line_width*y)+(x/4)]; case VIDBUF4S: offset = VGLSetSegment(y*VGLAdpInfo.va_line_width + x/8); goto get_planar; case VIDBUF4: offset = y*VGLAdpInfo.va_line_width + x/8; get_planar: #if 1 return (object->Bitmap[offset]&(0x80>>(x%8))) ? 1 : 0; /* XXX */ #else color = 0; mask = 0x80 >> (x%8); for (i = 0; i < VGLModeInfo.vi_planes; i++) { outb(0x3ce, 0x04); outb(0x3cf, i); color |= (object->Bitmap[offset] & mask) ? (1 << i) : 0; } return color; #endif } return 0; /* XXX black? */ } /* * 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, byte 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 (dx0) { 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 (dx0) { 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) { int offset; int len; int i, total = 0; byte b[4]; VGLCheckSwitch(); VGLMouseFreeze(0, 0, object->Xsize, object->Ysize, color); /* XXX */ switch (object->Type) { case MEMBUF: case VIDBUF8: memset(object->Bitmap, (byte)color, object->VXsize*object->VYsize); break; case VIDBUF8S: for (offset = 0; offset < object->VXsize*object->VYsize; ) { VGLSetSegment(offset); len = min(object->VXsize*object->VYsize - offset, VGLAdpInfo.va_window_size); memset(object->Bitmap, (byte)color, len); offset += len; } break; case VIDBUF16: case VIDBUF24: case VIDBUF32: color2mem(color, b, object->PixelBytes); total = object->VXsize*object->VYsize*object->PixelBytes; for (i = 0; i < total; i += object->PixelBytes) bcopy(b, object->Bitmap + i, object->PixelBytes); break; case VIDBUF16S: case VIDBUF24S: case VIDBUF32S: color2mem(color, b, object->PixelBytes); total = object->VXsize*object->VYsize*object->PixelBytes; for (offset = 0; offset < total; ) { VGLSetSegment(offset); len = min(total - offset, VGLAdpInfo.va_window_size); for (i = 0; i < len; i += object->PixelBytes) bcopy(b, object->Bitmap + offset + i, object->PixelBytes); offset += len; } break; case VIDBUF8X: /* 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); break; case VIDBUF4: case VIDBUF4S: /* 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); break; } VGLMouseUnFreeze(); } void VGLRestorePalette() { int i; 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; 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; 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) { 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 VGLSetBorder(byte color) { VGLCheckSwitch(); inb(0x3DA); outb(0x3C0,0x11); outb(0x3C0, color); inb(0x3DA); outb(0x3C0, 0x20); } void VGLBlankDisplay(int blank) { byte val; VGLCheckSwitch(); outb(0x3C4, 0x01); val = inb(0x3C5); outb(0x3C4, 0x01); outb(0x3C5, ((blank) ? (val |= 0x20) : (val &= 0xDF))); } Index: head/lib/libvgl/text.c =================================================================== --- head/lib/libvgl/text.c (revision 229783) +++ head/lib/libvgl/text.c (revision 229784) @@ -1,245 +1,245 @@ /*- - * Copyright (c) 1991-1997 Søren Schmidt + * 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 __FBSDID("$FreeBSD$"); #include #include #include "vgl.h" static VGLText *VGLTextFont = 0; 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* VGLTextFont->Height), fd); fclose(fd); } return 0; } void VGLBitmapPutChar(VGLBitmap *Object, int x, int y, byte ch, byte fgcol, byte bgcol, int fill, int dir) { int lin, bit; for(lin = 0; lin < VGLTextFont->Height; lin++) { for(bit = 0; bit < VGLTextFont->Width; bit++) { if (VGLTextFont->BitmapArray[((ch*VGLTextFont->Height)+lin)]&(1<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 }; Index: head/lib/libvgl/vgl.3 =================================================================== --- head/lib/libvgl/vgl.3 (revision 229783) +++ head/lib/libvgl/vgl.3 (revision 229784) @@ -1,470 +1,471 @@ -.\" Copyright (c) 1997 Søren Schmidt +.\"- +.\" 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. .\" .\" $FreeBSD$ .Dd November 7, 1999 .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" "byte fgcol" "byte bgcol" "int fill" "int dir" .Ft void .Fn VGLBitmapString "VGLBitmap *Object" "int x" "int y" "char *str" "byte fgcol" "byte 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 byte value. .Pp .Fn VGLSetXY sets the color of the pixel located at .Va x , y , coordinates of the .Va object argument to .Va color byte 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 underlaying 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 sos@FreeBSD.org Index: head/lib/libvgl/vgl.h =================================================================== --- head/lib/libvgl/vgl.h (revision 229783) +++ head/lib/libvgl/vgl.h (revision 229784) @@ -1,154 +1,154 @@ /*- - * Copyright (c) 1991-1997 Søren Schmidt + * 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. * * $FreeBSD$ */ #ifndef _VGL_H_ #define _VGL_H_ #include #include #include #include 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) } /* * 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 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); /* 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 */ void VGLMousePointerShow(void); void VGLMousePointerHide(void); void VGLMouseMode(int mode); void VGLMouseAction(int dummy); void VGLMouseSetImage(VGLBitmap *AndMask, VGLBitmap *OrMask); void VGLMouseSetStdImage(void); int VGLMouseInit(int mode); int VGLMouseStatus(int *x, int *y, char *buttons); int VGLMouseFreeze(int x, int y, int width, int hight, byte color); 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); 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, byte fgcol, byte bgcol, int fill, int dir); void VGLBitmapString(VGLBitmap *Object, int x, int y, char *str, byte fgcol, byte bgcol, int fill, int dir); #endif /* !_VGL_H_ */ Index: head/lib/msun/src/s_fabsl.c =================================================================== --- head/lib/msun/src/s_fabsl.c (revision 229783) +++ head/lib/msun/src/s_fabsl.c (revision 229784) @@ -1,43 +1,43 @@ /*- - * Copyright (c) 2003 Dag-Erling Coïdan Smørgrav + * Copyright (c) 2003 Dag-Erling Coïdan Smørgrav * 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. * * $FreeBSD$ */ #include #include "fpmath.h" long double fabsl(long double x) { union IEEEl2bits u; u.e = x; u.bits.sign = 0; return (u.e); }