2002-01-28 12:56:43 +03:00
|
|
|
/* $NetBSD: ite_cc.c,v 1.31 2002/01/28 09:56:59 aymeric Exp $ */
|
1994-02-11 10:00:37 +03:00
|
|
|
|
1995-02-17 00:57:31 +03:00
|
|
|
/*
|
|
|
|
* Copyright (c) 1994 Christian E. Hopps
|
|
|
|
* 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. All advertising materials mentioning features or use of this software
|
|
|
|
* must display the following acknowledgement:
|
|
|
|
* This product includes software developed by Christian E. Hopps.
|
|
|
|
* 4. 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.
|
|
|
|
*/
|
1999-03-26 00:55:17 +03:00
|
|
|
|
|
|
|
#include "opt_amigaccgrf.h"
|
|
|
|
|
2002-01-28 12:56:43 +03:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__KERNEL_RCSID(0, "$NetBSD: ite_cc.c,v 1.31 2002/01/28 09:56:59 aymeric Exp $");
|
|
|
|
|
1994-06-15 23:05:55 +04:00
|
|
|
#include "grfcc.h"
|
|
|
|
#if NGRFCC > 0
|
|
|
|
|
1994-02-14 00:10:20 +03:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/conf.h>
|
|
|
|
#include <sys/proc.h>
|
1994-05-08 09:52:54 +04:00
|
|
|
#include <sys/device.h>
|
1994-02-14 00:10:20 +03:00
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <sys/tty.h>
|
|
|
|
#include <sys/systm.h>
|
1994-03-30 21:24:08 +04:00
|
|
|
#include <sys/queue.h>
|
1994-05-08 09:52:54 +04:00
|
|
|
#include <sys/termios.h>
|
1994-02-17 12:10:32 +03:00
|
|
|
#include <dev/cons.h>
|
1994-05-08 09:52:54 +04:00
|
|
|
#include <machine/cpu.h>
|
1994-02-14 00:10:20 +03:00
|
|
|
#include <amiga/dev/itevar.h>
|
|
|
|
#include <amiga/dev/iteioctl.h>
|
|
|
|
#include <amiga/amiga/cc.h>
|
1994-05-08 09:52:54 +04:00
|
|
|
#include <amiga/amiga/device.h>
|
1994-02-14 00:10:20 +03:00
|
|
|
#include <amiga/dev/grfabs_reg.h>
|
1994-05-08 09:52:54 +04:00
|
|
|
#include <amiga/dev/grfioctl.h>
|
|
|
|
#include <amiga/dev/grfvar.h>
|
|
|
|
#include <amiga/dev/grf_ccreg.h>
|
1994-02-14 00:10:20 +03:00
|
|
|
#include <amiga/dev/viewioctl.h>
|
|
|
|
#include <amiga/dev/viewvar.h>
|
|
|
|
|
1994-04-22 05:34:53 +04:00
|
|
|
#ifndef KFONT_CUSTOM
|
|
|
|
#ifdef KFONT_8X11
|
1994-05-08 09:52:54 +04:00
|
|
|
#define kernel_font_width kernel_font_width_8x11
|
|
|
|
#define kernel_font_height kernel_font_height_8x11
|
|
|
|
#define kernel_font_baseline kernel_font_baseline_8x11
|
|
|
|
#define kernel_font_boldsmear kernel_font_boldsmear_8x11
|
|
|
|
#define kernel_font_lo kernel_font_lo_8x11
|
|
|
|
#define kernel_font_hi kernel_font_hi_8x11
|
|
|
|
#define kernel_font kernel_font_8x11
|
|
|
|
#define kernel_cursor kernel_cursor_8x11
|
1994-04-22 05:34:53 +04:00
|
|
|
#else
|
1994-05-08 09:52:54 +04:00
|
|
|
#define kernel_font_width kernel_font_width_8x8
|
|
|
|
#define kernel_font_height kernel_font_height_8x8
|
|
|
|
#define kernel_font_baseline kernel_font_baseline_8x8
|
|
|
|
#define kernel_font_boldsmear kernel_font_boldsmear_8x8
|
|
|
|
#define kernel_font_lo kernel_font_lo_8x8
|
|
|
|
#define kernel_font_hi kernel_font_hi_8x8
|
|
|
|
#define kernel_font kernel_font_8x8
|
|
|
|
#define kernel_cursor kernel_cursor_8x8
|
1994-04-22 05:34:53 +04:00
|
|
|
#endif
|
|
|
|
#endif
|
1993-09-02 22:05:24 +04:00
|
|
|
|
2002-01-26 16:40:52 +03:00
|
|
|
extern u_char kernel_font_width, kernel_font_height, kernel_font_baseline;
|
1994-04-10 04:43:32 +04:00
|
|
|
extern short kernel_font_boldsmear;
|
|
|
|
extern u_char kernel_font_lo, kernel_font_hi;
|
|
|
|
extern u_char kernel_font[], kernel_cursor[];
|
1993-07-05 23:19:43 +04:00
|
|
|
|
1999-09-21 03:17:13 +04:00
|
|
|
|
2000-06-22 01:28:39 +04:00
|
|
|
#if !defined(USE_C_BFOPS) && !defined(__m68k__)
|
1999-09-21 03:17:13 +04:00
|
|
|
#define USE_C_BFOPS
|
2000-06-22 01:28:39 +04:00
|
|
|
#endif
|
|
|
|
|
1999-09-21 03:17:13 +04:00
|
|
|
#if !defined(USE_C_BFOPS)
|
|
|
|
#define BFEXT(v,p,o,w) asm("bfextu %1@{%2:%3},%0" : "=d" (v) : \
|
|
|
|
"a"(p), "d"(o), "d"(w))
|
|
|
|
#define BFINS(v,p,o,w) asm("bfins %0,%1@{%2:%3}" : /* no output */ : \
|
|
|
|
"d"(v), "a"(p), "d"(o), "d"(w))
|
|
|
|
#define BFCLR(p,o,w) asm("bfclr %0@{%1:%2}" : /* no output */ : \
|
|
|
|
"a"(p), "d"(o), "d"(w))
|
|
|
|
#define BFCHG(p,o,w) asm("bfchg %0@{%1:%2}" : /* no output */ : \
|
|
|
|
"a"(p), "d"(o), "d"(w))
|
|
|
|
#define BFSET(p,o,w) asm("bfset %0@{%1:%2}" : /* no output */ : \
|
|
|
|
"a"(p), "d"(o), "d"(w))
|
|
|
|
#else
|
|
|
|
#define BFEXT(v,p,o,w) do {v = ((u_int8_t *)(p))[(o)>>3];} while (0)
|
|
|
|
#define BFINS(v,p,o,w) do {((u_int8_t *)(p))[(o)>>3] = (v);} while (0)
|
|
|
|
#define BFCLR(p,o,w) BFINS(0x00,p,o,w)
|
|
|
|
#define BFSET(p,o,w) BFINS(0xff,p,o,w)
|
|
|
|
#define BFCHG(p,o,w) do {((u_int8_t *)(p))[(o)>>3] ^= 0xff;} while (0)
|
|
|
|
#endif
|
|
|
|
|
1993-09-02 22:05:24 +04:00
|
|
|
/*
|
|
|
|
* This is what ip->priv points to;
|
|
|
|
* it contains local variables for custom-chip ites.
|
|
|
|
*/
|
1994-04-10 04:43:32 +04:00
|
|
|
struct ite_priv {
|
|
|
|
view_t *view; /* the view for this ite. */
|
|
|
|
u_char **row_ptr; /* array of pointers into the bitmap */
|
|
|
|
u_long row_bytes;
|
|
|
|
u_long cursor_opt;
|
|
|
|
u_int *column_offset; /* array of offsets for columns */
|
|
|
|
u_int row_offset; /* the row offset */
|
|
|
|
u_short width; /* the bitmap width */
|
|
|
|
u_short underline; /* where the underline goes */
|
|
|
|
u_short ft_x; /* the font width */
|
|
|
|
u_short ft_y; /* the font height */
|
|
|
|
u_char *font_cell[256]; /* the font pointer */
|
|
|
|
};
|
|
|
|
typedef struct ite_priv ipriv_t;
|
1993-09-02 22:05:24 +04:00
|
|
|
|
2002-01-26 16:40:52 +03:00
|
|
|
void view_deinit(struct ite_softc *);
|
|
|
|
void view_init(struct ite_softc *);
|
1993-09-02 22:05:24 +04:00
|
|
|
|
2002-01-26 16:40:52 +03:00
|
|
|
static void putc8(struct ite_softc *, int, int, int, int);
|
|
|
|
static void clear8(struct ite_softc *, int, int, int, int);
|
|
|
|
static void scroll8(struct ite_softc *, int, int, int, int);
|
|
|
|
static void cursor32(struct ite_softc *, int);
|
|
|
|
static void scrollbmap(bmap_t *, u_short, u_short, u_short, u_short,
|
|
|
|
short, short, u_char);
|
1994-04-10 04:43:32 +04:00
|
|
|
|
|
|
|
/* patchable */
|
|
|
|
int ite_default_x = 0; /* def leftedge offset */
|
|
|
|
int ite_default_y = 0; /* def topedge offset */
|
|
|
|
int ite_default_width = 640; /* def width */
|
|
|
|
int ite_default_depth = 2; /* def depth */
|
1994-01-27 00:05:34 +03:00
|
|
|
#if defined (GRF_NTSC)
|
1994-04-10 04:43:32 +04:00
|
|
|
int ite_default_height = 400; /* def NTSC height */
|
1994-01-27 00:05:34 +03:00
|
|
|
#elif defined (GRF_PAL)
|
1994-04-10 04:43:32 +04:00
|
|
|
int ite_default_height = 512; /* def PAL height */
|
1994-01-27 00:05:34 +03:00
|
|
|
#else
|
1994-04-10 04:43:32 +04:00
|
|
|
int ite_default_height = 400; /* def NON-PAL/NTSC height (?) */
|
1993-09-02 22:05:24 +04:00
|
|
|
#endif
|
|
|
|
|
2002-01-26 16:40:52 +03:00
|
|
|
int ite_newsize(struct ite_softc *, struct itewinsize *);
|
|
|
|
static void putc_nm(ipriv_t *, u_char *, u_char *, u_int, u_int,
|
|
|
|
u_int, u_int);
|
|
|
|
static void putc_in(ipriv_t *, u_char *, u_char *, u_int, u_int,
|
|
|
|
u_int, u_int);
|
|
|
|
static void putc_ul(ipriv_t *, u_char *, u_char *, u_int, u_int,
|
|
|
|
u_int, u_int);
|
|
|
|
static void putc_ul_in(ipriv_t *, u_char *, u_char *, u_int, u_int,
|
|
|
|
u_int, u_int);
|
|
|
|
static void putc_bd(ipriv_t *, u_char *, u_char *, u_int, u_int,
|
|
|
|
u_int, u_int);
|
|
|
|
static void putc_bd_in(ipriv_t *, u_char *, u_char *, u_int, u_int,
|
|
|
|
u_int, u_int);
|
|
|
|
static void putc_bd_ul(ipriv_t *, u_char *, u_char *, u_int, u_int,
|
|
|
|
u_int, u_int);
|
|
|
|
static void putc_bd_ul_in(ipriv_t *, u_char *, u_char *, u_int, u_int,
|
|
|
|
u_int, u_int);
|
1996-04-22 01:10:48 +04:00
|
|
|
|
1994-05-08 09:52:54 +04:00
|
|
|
/*
|
|
|
|
* called from grf_cc to return console priority
|
|
|
|
*/
|
|
|
|
int
|
2002-01-26 16:40:52 +03:00
|
|
|
grfcc_cnprobe(void)
|
1994-05-08 09:52:54 +04:00
|
|
|
{
|
|
|
|
return(CN_INTERNAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2002-01-26 16:40:52 +03:00
|
|
|
* called from grf_cc to init ite portion of
|
1994-05-08 09:52:54 +04:00
|
|
|
* grf_softc struct
|
|
|
|
*/
|
|
|
|
void
|
2002-01-26 16:40:52 +03:00
|
|
|
grfcc_iteinit(struct grf_softc *gp)
|
1994-01-27 00:05:34 +03:00
|
|
|
{
|
1994-05-08 09:52:54 +04:00
|
|
|
gp->g_itecursor = cursor32;
|
|
|
|
gp->g_iteputc = putc8;
|
|
|
|
gp->g_iteclear = clear8;
|
|
|
|
gp->g_itescroll = scroll8;
|
|
|
|
gp->g_iteinit = view_init;
|
|
|
|
gp->g_itedeinit = view_deinit;
|
1993-07-05 23:19:43 +04:00
|
|
|
}
|
|
|
|
|
2002-01-26 16:40:52 +03:00
|
|
|
int
|
|
|
|
ite_newsize(struct ite_softc *ip, struct itewinsize *winsz)
|
1994-01-27 00:05:34 +03:00
|
|
|
{
|
1994-04-10 04:43:32 +04:00
|
|
|
extern struct view_softc views[];
|
|
|
|
struct view_size vs;
|
2002-01-26 16:40:52 +03:00
|
|
|
ipriv_t *cci = ip->priv;
|
1996-04-22 01:10:48 +04:00
|
|
|
u_long i;
|
1994-04-10 04:43:32 +04:00
|
|
|
int error;
|
|
|
|
|
|
|
|
vs.x = winsz->x;
|
|
|
|
vs.y = winsz->y;
|
|
|
|
vs.width = winsz->width;
|
|
|
|
vs.height = winsz->height;
|
|
|
|
vs.depth = winsz->depth;
|
1996-04-22 01:10:48 +04:00
|
|
|
error = viewioctl(0, VIOCSSIZE, (caddr_t)&vs, -1, NULL); /* XXX type of vs ? */
|
1994-04-10 04:43:32 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Reinitialize our structs
|
|
|
|
*/
|
2002-01-26 16:40:52 +03:00
|
|
|
cci->view = views[0].view;
|
1994-04-10 04:43:32 +04:00
|
|
|
|
2002-01-26 16:40:52 +03:00
|
|
|
ip->cols = cci->view->display.width / ip->ftwidth;
|
1994-04-10 04:43:32 +04:00
|
|
|
ip->rows = cci->view->display.height / ip->ftheight;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* save new values so that future opens use them
|
|
|
|
* this may not be correct when we implement Virtual Consoles
|
|
|
|
*/
|
|
|
|
ite_default_height = cci->view->display.height;
|
|
|
|
ite_default_width = cci->view->display.width;
|
|
|
|
ite_default_x = cci->view->display.x;
|
|
|
|
ite_default_y = cci->view->display.y;
|
|
|
|
ite_default_depth = cci->view->bitmap->depth;
|
|
|
|
|
2002-01-26 16:40:52 +03:00
|
|
|
if (cci->row_ptr)
|
1994-04-10 04:43:32 +04:00
|
|
|
free_chipmem(cci->row_ptr);
|
|
|
|
if (cci->column_offset)
|
|
|
|
free_chipmem(cci->column_offset);
|
|
|
|
|
|
|
|
cci->row_ptr = alloc_chipmem(sizeof(u_char *) * ip->rows);
|
|
|
|
cci->column_offset = alloc_chipmem(sizeof(u_int) * ip->cols);
|
2002-01-26 16:40:52 +03:00
|
|
|
|
1994-04-10 04:43:32 +04:00
|
|
|
if (cci->row_ptr == NULL || cci->column_offset == NULL)
|
|
|
|
panic("no chipmem for itecc data");
|
2002-01-26 16:40:52 +03:00
|
|
|
|
1994-01-27 00:05:34 +03:00
|
|
|
|
1994-04-10 04:43:32 +04:00
|
|
|
cci->width = cci->view->bitmap->bytes_per_row << 3;
|
|
|
|
cci->underline = ip->ftbaseline + 1;
|
2002-01-26 16:40:52 +03:00
|
|
|
cci->row_offset = cci->view->bitmap->bytes_per_row
|
1994-04-10 04:43:32 +04:00
|
|
|
+ cci->view->bitmap->row_mod;
|
|
|
|
cci->ft_x = ip->ftwidth;
|
|
|
|
cci->ft_y = ip->ftheight;
|
2002-01-26 16:40:52 +03:00
|
|
|
|
1994-04-10 04:43:32 +04:00
|
|
|
cci->row_bytes = cci->row_offset * ip->ftheight;
|
|
|
|
|
|
|
|
cci->row_ptr[0] = VDISPLAY_LINE (cci->view, 0, 0);
|
2002-01-26 16:40:52 +03:00
|
|
|
for (i = 1; i < ip->rows; i++)
|
1994-04-10 04:43:32 +04:00
|
|
|
cci->row_ptr[i] = cci->row_ptr[i-1] + cci->row_bytes;
|
|
|
|
|
|
|
|
/* initialize the column offsets */
|
|
|
|
cci->column_offset[0] = 0;
|
2002-01-26 16:40:52 +03:00
|
|
|
for (i = 1; i < ip->cols; i++)
|
1994-04-10 04:43:32 +04:00
|
|
|
cci->column_offset[i] = cci->column_offset[i - 1] + cci->ft_x;
|
|
|
|
|
|
|
|
/* initialize the font cell pointers */
|
|
|
|
cci->font_cell[ip->font_lo] = ip->font;
|
|
|
|
for (i=ip->font_lo+1; i<=ip->font_hi; i++)
|
|
|
|
cci->font_cell[i] = cci->font_cell[i-1] + ip->ftheight;
|
2002-01-26 16:40:52 +03:00
|
|
|
|
1994-04-10 04:43:32 +04:00
|
|
|
return (error);
|
1993-07-05 23:19:43 +04:00
|
|
|
}
|
|
|
|
|
1994-02-17 12:10:32 +03:00
|
|
|
void
|
2002-01-26 16:40:52 +03:00
|
|
|
view_init(register struct ite_softc *ip)
|
1993-07-05 23:19:43 +04:00
|
|
|
{
|
1994-04-10 04:43:32 +04:00
|
|
|
struct itewinsize wsz;
|
|
|
|
ipriv_t *cci;
|
|
|
|
|
|
|
|
cci = ip->priv;
|
1994-01-27 00:05:34 +03:00
|
|
|
|
1994-04-10 04:43:32 +04:00
|
|
|
if (cci)
|
|
|
|
return;
|
1994-01-27 00:05:34 +03:00
|
|
|
|
|
|
|
ip->font = kernel_font;
|
|
|
|
ip->font_lo = kernel_font_lo;
|
|
|
|
ip->font_hi = kernel_font_hi;
|
|
|
|
ip->ftwidth = kernel_font_width;
|
|
|
|
ip->ftheight = kernel_font_height;
|
|
|
|
ip->ftbaseline = kernel_font_baseline;
|
|
|
|
ip->ftboldsmear = kernel_font_boldsmear;
|
|
|
|
|
|
|
|
/* Find the correct set of rendering routines for this font. */
|
1994-04-10 04:43:32 +04:00
|
|
|
if (ip->ftwidth > 8)
|
1994-01-27 00:05:34 +03:00
|
|
|
panic("kernel font size not supported");
|
1994-04-10 04:43:32 +04:00
|
|
|
cci = alloc_chipmem(sizeof (*cci));
|
|
|
|
if (cci == NULL)
|
|
|
|
panic("no memory for console device.");
|
1993-07-05 23:19:43 +04:00
|
|
|
|
1994-01-27 00:05:34 +03:00
|
|
|
ip->priv = cci;
|
|
|
|
cci->cursor_opt = 0;
|
|
|
|
cci->view = NULL;
|
|
|
|
cci->row_ptr = NULL;
|
|
|
|
cci->column_offset = NULL;
|
|
|
|
|
1994-04-10 04:43:32 +04:00
|
|
|
wsz.x = ite_default_x;
|
|
|
|
wsz.y = ite_default_y;
|
|
|
|
wsz.width = ite_default_width;
|
|
|
|
wsz.height = ite_default_height;
|
|
|
|
wsz.depth = ite_default_depth;
|
|
|
|
|
|
|
|
ite_newsize (ip, &wsz);
|
1994-05-08 09:52:54 +04:00
|
|
|
cc_mode(ip->grf, GM_GRFON, NULL, 0, 0);
|
1994-01-27 00:05:34 +03:00
|
|
|
}
|
1993-07-05 23:19:43 +04:00
|
|
|
|
1994-01-27 00:05:34 +03:00
|
|
|
int
|
2002-01-26 16:40:52 +03:00
|
|
|
ite_grf_ioctl(struct ite_softc *ip, u_long cmd, caddr_t addr, int flag,
|
|
|
|
struct proc *p)
|
1994-01-27 00:05:34 +03:00
|
|
|
{
|
1994-04-10 04:43:32 +04:00
|
|
|
struct winsize ws;
|
|
|
|
struct itewinsize *is;
|
|
|
|
ipriv_t *cci;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
cci = ip->priv;
|
|
|
|
error = 0;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case ITEIOCGWINSZ:
|
|
|
|
is = (struct itewinsize *)addr;
|
|
|
|
is->x = cci->view->display.x;
|
|
|
|
is->y = cci->view->display.y;
|
|
|
|
is->width = cci->view->display.width;
|
|
|
|
is->height = cci->view->display.height;
|
|
|
|
is->depth = cci->view->bitmap->depth;
|
|
|
|
break;
|
|
|
|
case ITEIOCSWINSZ:
|
|
|
|
is = (struct itewinsize *)addr;
|
|
|
|
|
|
|
|
if (ite_newsize(ip, is))
|
|
|
|
error = ENOMEM;
|
|
|
|
else {
|
|
|
|
ws.ws_row = ip->rows;
|
|
|
|
ws.ws_col = ip->cols;
|
|
|
|
ws.ws_xpixel = cci->view->display.width;
|
|
|
|
ws.ws_ypixel = cci->view->display.height;
|
|
|
|
ite_reset (ip);
|
|
|
|
/*
|
2002-01-26 16:40:52 +03:00
|
|
|
* XXX tell tty about the change
|
|
|
|
* XXX this is messy, but works
|
1994-04-10 04:43:32 +04:00
|
|
|
*/
|
|
|
|
iteioctl(0, TIOCSWINSZ, (caddr_t)&ws, 0, p);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ITEIOCDSPWIN:
|
1994-05-08 09:52:54 +04:00
|
|
|
cc_mode(ip->grf, GM_GRFON, NULL, 0, 0);
|
1994-04-10 04:43:32 +04:00
|
|
|
break;
|
|
|
|
case ITEIOCREMWIN:
|
1994-05-08 09:52:54 +04:00
|
|
|
cc_mode(ip->grf, GM_GRFOFF, NULL, 0, 0);
|
1994-04-10 04:43:32 +04:00
|
|
|
break;
|
|
|
|
case VIOCSCMAP:
|
|
|
|
case VIOCGCMAP:
|
|
|
|
/*
|
|
|
|
* XXX needs to be fixed when multiple console implemented
|
|
|
|
* XXX watchout for that -1 its not really the kernel talking
|
|
|
|
* XXX these two commands don't use the proc pointer though
|
|
|
|
*/
|
1996-04-22 01:10:48 +04:00
|
|
|
error = viewioctl(0, cmd, addr, -1, p);
|
1994-04-10 04:43:32 +04:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
error = -1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return (error);
|
1994-01-27 00:05:34 +03:00
|
|
|
}
|
|
|
|
|
1994-02-17 12:10:32 +03:00
|
|
|
void
|
2002-01-26 16:40:52 +03:00
|
|
|
view_deinit(struct ite_softc *ip)
|
1994-01-27 00:05:34 +03:00
|
|
|
{
|
1994-04-10 04:43:32 +04:00
|
|
|
ip->flags &= ~ITE_INITED;
|
1993-07-05 23:19:43 +04:00
|
|
|
}
|
|
|
|
|
1994-01-27 00:05:34 +03:00
|
|
|
/*** (M<8)-by-N routines ***/
|
|
|
|
|
1993-09-02 22:05:24 +04:00
|
|
|
static void
|
1994-04-10 04:43:32 +04:00
|
|
|
cursor32(struct ite_softc *ip, int flag)
|
1993-07-05 23:19:43 +04:00
|
|
|
{
|
1994-04-10 04:43:32 +04:00
|
|
|
int cend, ofs, h, cstart, dr_plane;
|
1996-04-22 01:10:48 +04:00
|
|
|
u_char *pl;
|
1994-04-10 04:43:32 +04:00
|
|
|
ipriv_t *cci;
|
|
|
|
bmap_t *bm;
|
|
|
|
view_t *v;
|
|
|
|
|
|
|
|
cci = ip->priv;
|
|
|
|
v = cci->view;
|
|
|
|
bm = v->bitmap;
|
|
|
|
dr_plane = (bm->depth > 1 ? bm->depth-1 : 0);
|
|
|
|
|
|
|
|
if (flag == END_CURSOROPT)
|
|
|
|
cci->cursor_opt--;
|
|
|
|
else if (flag == START_CURSOROPT) {
|
|
|
|
if (!cci->cursor_opt)
|
|
|
|
cursor32 (ip, ERASE_CURSOR);
|
|
|
|
cci->cursor_opt++;
|
|
|
|
return; /* if we are already opted. */
|
1994-01-27 00:05:34 +03:00
|
|
|
}
|
2002-01-26 16:40:52 +03:00
|
|
|
|
|
|
|
if (cci->cursor_opt)
|
1994-04-10 04:43:32 +04:00
|
|
|
return; /* if we are still nested. */
|
|
|
|
/* else we draw the cursor. */
|
|
|
|
cstart = 0;
|
2002-01-26 16:40:52 +03:00
|
|
|
cend = ip->ftheight-1;
|
1994-04-10 04:43:32 +04:00
|
|
|
pl = VDISPLAY_LINE(v, dr_plane, (ip->cursory * ip->ftheight + cstart));
|
|
|
|
ofs = (ip->cursorx * ip->ftwidth);
|
2002-01-26 16:40:52 +03:00
|
|
|
|
1994-04-10 04:43:32 +04:00
|
|
|
if (flag != DRAW_CURSOR && flag != END_CURSOROPT) {
|
|
|
|
/*
|
|
|
|
* erase the cursor
|
|
|
|
*/
|
|
|
|
int h;
|
|
|
|
|
|
|
|
if (dr_plane) {
|
|
|
|
for (h = cend; h >= 0; h--) {
|
1999-09-21 03:17:13 +04:00
|
|
|
BFCLR(pl, ofs, ip->ftwidth);
|
1994-04-10 04:43:32 +04:00
|
|
|
pl += cci->row_offset;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for (h = cend; h >= 0; h--) {
|
1999-09-21 03:17:13 +04:00
|
|
|
BFCHG(pl, ofs, ip->ftwidth);
|
1994-04-10 04:43:32 +04:00
|
|
|
pl += cci->row_offset;
|
|
|
|
}
|
|
|
|
}
|
1994-01-27 00:05:34 +03:00
|
|
|
}
|
2002-01-26 16:40:52 +03:00
|
|
|
|
|
|
|
if (flag != DRAW_CURSOR && flag != MOVE_CURSOR &&
|
1994-04-10 04:43:32 +04:00
|
|
|
flag != END_CURSOROPT)
|
|
|
|
return;
|
2002-01-26 16:40:52 +03:00
|
|
|
|
|
|
|
/*
|
1994-04-10 04:43:32 +04:00
|
|
|
* draw the cursor
|
|
|
|
*/
|
|
|
|
|
1994-05-25 15:32:38 +04:00
|
|
|
ip->cursorx = min(ip->curx, ip->cols-1);
|
1994-01-27 00:05:34 +03:00
|
|
|
ip->cursory = ip->cury;
|
|
|
|
cstart = 0;
|
2002-01-26 16:40:52 +03:00
|
|
|
cend = ip->ftheight-1;
|
1994-04-10 04:43:32 +04:00
|
|
|
pl = VDISPLAY_LINE(v, dr_plane, ip->cursory * ip->ftheight + cstart);
|
|
|
|
ofs = ip->cursorx * ip->ftwidth;
|
|
|
|
|
1994-01-27 00:05:34 +03:00
|
|
|
if (dr_plane) {
|
1994-04-10 04:43:32 +04:00
|
|
|
for (h = cend; h >= 0; h--) {
|
1999-09-21 03:17:13 +04:00
|
|
|
BFSET(pl, ofs, ip->ftwidth);
|
1994-04-10 04:43:32 +04:00
|
|
|
pl += cci->row_offset;
|
|
|
|
}
|
1994-01-27 00:05:34 +03:00
|
|
|
} else {
|
1994-04-10 04:43:32 +04:00
|
|
|
for (h = cend; h >= 0; h--) {
|
1999-09-21 03:17:13 +04:00
|
|
|
BFCHG(pl, ofs, ip->ftwidth);
|
1994-04-10 04:43:32 +04:00
|
|
|
pl += cci->row_offset;
|
|
|
|
}
|
1994-01-27 00:05:34 +03:00
|
|
|
}
|
|
|
|
}
|
1993-09-02 22:05:24 +04:00
|
|
|
|
1993-07-05 23:19:43 +04:00
|
|
|
|
1994-01-27 00:05:34 +03:00
|
|
|
static inline
|
2002-01-26 16:40:52 +03:00
|
|
|
int expbits(int data)
|
1994-01-27 00:05:34 +03:00
|
|
|
{
|
1994-04-10 04:43:32 +04:00
|
|
|
int i, nd = 0;
|
|
|
|
|
|
|
|
if (data & 1)
|
|
|
|
nd |= 0x02;
|
|
|
|
for (i=1; i < 32; i++) {
|
|
|
|
if (data & (1 << i))
|
|
|
|
nd |= 0x5 << (i-1);
|
1994-01-27 00:05:34 +03:00
|
|
|
}
|
1994-04-10 04:43:32 +04:00
|
|
|
nd &= ~data;
|
|
|
|
return(~nd);
|
1993-07-05 23:19:43 +04:00
|
|
|
}
|
|
|
|
|
1994-01-27 00:05:34 +03:00
|
|
|
|
|
|
|
/* Notes: optimizations given the kernel_font_(width|height) #define'd.
|
|
|
|
* the dbra loops could be elminated and unrolled using height,
|
|
|
|
* the :width in the bfxxx instruction could be made immediate instead
|
|
|
|
* of a data register as it now is.
|
|
|
|
* the underline could be added when the loop is unrolled
|
|
|
|
*
|
|
|
|
* It would look like hell but be very fast.*/
|
2002-01-26 16:40:52 +03:00
|
|
|
|
|
|
|
static void
|
|
|
|
putc_nm(register ipriv_t *cci, register u_char *p, register u_char *f,
|
|
|
|
register u_int co, register u_int ro, register u_int fw,
|
|
|
|
register u_int fh)
|
1993-07-05 23:19:43 +04:00
|
|
|
{
|
1994-01-27 00:05:34 +03:00
|
|
|
while (fh--) {
|
1999-09-21 03:17:13 +04:00
|
|
|
BFINS(*f++, p, co, fw);
|
1994-01-27 00:05:34 +03:00
|
|
|
p += ro;
|
|
|
|
}
|
1993-07-05 23:19:43 +04:00
|
|
|
}
|
|
|
|
|
2002-01-26 16:40:52 +03:00
|
|
|
static void
|
|
|
|
putc_in(register ipriv_t *cci, register u_char *p, register u_char *f,
|
|
|
|
register u_int co, register u_int ro, register u_int fw,
|
|
|
|
register u_int fh)
|
1993-07-05 23:19:43 +04:00
|
|
|
{
|
1994-01-27 00:05:34 +03:00
|
|
|
while (fh--) {
|
2002-01-26 16:40:52 +03:00
|
|
|
BFINS(~(*f++), p, co, fw);
|
1994-01-27 00:05:34 +03:00
|
|
|
p += ro;
|
|
|
|
}
|
|
|
|
}
|
1993-07-05 23:19:43 +04:00
|
|
|
|
1993-09-02 22:05:24 +04:00
|
|
|
|
2002-01-26 16:40:52 +03:00
|
|
|
static void
|
|
|
|
putc_ul(register ipriv_t *cci, register u_char *p, register u_char *f,
|
|
|
|
register u_int co, register u_int ro, register u_int fw,
|
|
|
|
register u_int fh)
|
1994-01-27 00:05:34 +03:00
|
|
|
{
|
|
|
|
int underline = cci->underline;
|
|
|
|
while (underline--) {
|
1999-09-21 03:17:13 +04:00
|
|
|
BFINS(*f++,p,co,fw);
|
1994-01-27 00:05:34 +03:00
|
|
|
p += ro;
|
1993-07-05 23:19:43 +04:00
|
|
|
}
|
1993-09-02 22:05:24 +04:00
|
|
|
|
1999-09-21 03:17:13 +04:00
|
|
|
BFINS(expbits(*f++),p,co,fw);
|
1994-01-27 00:05:34 +03:00
|
|
|
p += ro;
|
|
|
|
|
|
|
|
underline = fh - cci->underline - 1;
|
|
|
|
while (underline--) {
|
1999-09-21 03:17:13 +04:00
|
|
|
BFINS(*f++,p,co,fw);
|
1994-01-27 00:05:34 +03:00
|
|
|
p += ro;
|
1993-07-05 23:19:43 +04:00
|
|
|
}
|
1993-09-02 22:05:24 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-01-26 16:40:52 +03:00
|
|
|
static void
|
|
|
|
putc_ul_in(register ipriv_t *cci, register u_char *p, register u_char *f,
|
|
|
|
register u_int co, register u_int ro, register u_int fw,
|
|
|
|
register u_int fh)
|
1994-01-27 00:05:34 +03:00
|
|
|
{
|
|
|
|
int underline = cci->underline;
|
|
|
|
while (underline--) {
|
1999-09-21 03:17:13 +04:00
|
|
|
BFINS(~(*f++),p,co,fw);
|
1994-01-27 00:05:34 +03:00
|
|
|
p += ro;
|
|
|
|
}
|
1993-09-02 22:05:24 +04:00
|
|
|
|
1999-09-21 03:17:13 +04:00
|
|
|
BFINS(~expbits(*f++),p,co,fw);
|
1994-01-27 00:05:34 +03:00
|
|
|
p += ro;
|
1993-09-02 22:05:24 +04:00
|
|
|
|
1994-01-27 00:05:34 +03:00
|
|
|
underline = fh - cci->underline - 1;
|
|
|
|
while (underline--) {
|
1999-09-21 03:17:13 +04:00
|
|
|
BFINS(~(*f++),p,co,fw);
|
1994-01-27 00:05:34 +03:00
|
|
|
p += ro;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* bold */
|
2002-01-26 16:40:52 +03:00
|
|
|
static void
|
|
|
|
putc_bd(register ipriv_t *cci, register u_char *p, register u_char *f,
|
|
|
|
register u_int co, register u_int ro, register u_int fw,
|
|
|
|
register u_int fh)
|
1993-09-02 22:05:24 +04:00
|
|
|
{
|
1994-02-14 00:10:20 +03:00
|
|
|
u_short ch;
|
2002-01-26 16:40:52 +03:00
|
|
|
|
1994-01-27 00:05:34 +03:00
|
|
|
while (fh--) {
|
|
|
|
ch = *f++;
|
2000-06-22 01:28:39 +04:00
|
|
|
ch |= ch >> 1;
|
|
|
|
BFINS(ch,p,co,fw);
|
1994-01-27 00:05:34 +03:00
|
|
|
p += ro;
|
|
|
|
}
|
|
|
|
}
|
1993-09-02 22:05:24 +04:00
|
|
|
|
2002-01-26 16:40:52 +03:00
|
|
|
static void
|
|
|
|
putc_bd_in(register ipriv_t *cci, register u_char *p, register u_char *f,
|
|
|
|
register u_int co, register u_int ro, register u_int fw,
|
|
|
|
register u_int fh)
|
1994-01-27 00:05:34 +03:00
|
|
|
{
|
1994-02-14 00:10:20 +03:00
|
|
|
u_short ch;
|
2002-01-26 16:40:52 +03:00
|
|
|
|
1994-01-27 00:05:34 +03:00
|
|
|
while (fh--) {
|
|
|
|
ch = *f++;
|
2000-06-22 01:28:39 +04:00
|
|
|
ch |= ch >> 1;
|
|
|
|
BFINS(~ch,p,co,fw);
|
1994-01-27 00:05:34 +03:00
|
|
|
p += ro;
|
|
|
|
}
|
|
|
|
}
|
1993-09-02 22:05:24 +04:00
|
|
|
|
|
|
|
|
2002-01-26 16:40:52 +03:00
|
|
|
static void
|
|
|
|
putc_bd_ul(register ipriv_t *cci, register u_char *p, register u_char *f,
|
|
|
|
register u_int co, register u_int ro, register u_int fw,
|
|
|
|
register u_int fh)
|
1994-01-27 00:05:34 +03:00
|
|
|
{
|
|
|
|
int underline = cci->underline;
|
1994-02-14 00:10:20 +03:00
|
|
|
u_short ch;
|
1994-01-27 00:05:34 +03:00
|
|
|
|
|
|
|
while (underline--) {
|
|
|
|
ch = *f++;
|
2000-06-22 01:28:39 +04:00
|
|
|
ch |= ch >> 1;
|
|
|
|
BFINS(ch,p,co,fw);
|
1994-01-27 00:05:34 +03:00
|
|
|
p += ro;
|
1993-09-02 22:05:24 +04:00
|
|
|
}
|
|
|
|
|
1994-01-27 00:05:34 +03:00
|
|
|
ch = *f++;
|
2000-06-22 01:28:39 +04:00
|
|
|
ch |= ch >> 1;
|
|
|
|
BFINS(expbits(ch),p,co,fw);
|
1994-01-27 00:05:34 +03:00
|
|
|
p += ro;
|
|
|
|
|
|
|
|
underline = fh - cci->underline - 1;
|
|
|
|
while (underline--) {
|
|
|
|
ch = *f++;
|
2000-06-22 01:28:39 +04:00
|
|
|
ch |= ch >> 1;
|
|
|
|
BFINS(ch,p,co,fw);
|
1994-01-27 00:05:34 +03:00
|
|
|
p += ro;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1993-09-02 22:05:24 +04:00
|
|
|
|
2002-01-26 16:40:52 +03:00
|
|
|
static void
|
|
|
|
putc_bd_ul_in(register ipriv_t *cci, register u_char *p, register u_char *f,
|
|
|
|
register u_int co, register u_int ro, register u_int fw,
|
|
|
|
register u_int fh)
|
1994-01-27 00:05:34 +03:00
|
|
|
{
|
|
|
|
int underline = cci->underline;
|
1994-02-14 00:10:20 +03:00
|
|
|
u_short ch;
|
2002-01-26 16:40:52 +03:00
|
|
|
|
1994-01-27 00:05:34 +03:00
|
|
|
while (underline--) {
|
|
|
|
ch = *f++;
|
2000-06-22 01:28:39 +04:00
|
|
|
ch |= ch >> 1;
|
|
|
|
BFINS(~ch,p,co,fw);
|
1994-01-27 00:05:34 +03:00
|
|
|
p += ro;
|
|
|
|
}
|
1993-09-02 22:05:24 +04:00
|
|
|
|
1994-01-27 00:05:34 +03:00
|
|
|
ch = *f++;
|
2000-06-22 01:28:39 +04:00
|
|
|
ch |= ch >> 1;
|
|
|
|
BFINS(~expbits(ch),p,co,fw);
|
1994-01-27 00:05:34 +03:00
|
|
|
p += ro;
|
|
|
|
|
|
|
|
underline = fh - cci->underline - 1;
|
|
|
|
while (underline--) {
|
|
|
|
ch = *f++;
|
2000-06-22 01:28:39 +04:00
|
|
|
ch |= ch >> 1;
|
|
|
|
BFINS(~ch,p,co,fw);
|
1994-01-27 00:05:34 +03:00
|
|
|
p += ro;
|
1993-09-02 22:05:24 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1994-01-27 00:05:34 +03:00
|
|
|
|
2002-01-26 16:40:52 +03:00
|
|
|
typedef void cc_putc_func(ipriv_t *, u_char *, u_char *, u_int, u_int,
|
|
|
|
u_int, u_int);
|
1994-01-27 00:05:34 +03:00
|
|
|
|
|
|
|
cc_putc_func *put_func[ATTR_ALL+1] = {
|
|
|
|
putc_nm,
|
|
|
|
putc_in,
|
|
|
|
putc_ul,
|
|
|
|
putc_ul_in,
|
|
|
|
putc_bd,
|
|
|
|
putc_bd_in,
|
|
|
|
putc_bd_ul,
|
|
|
|
putc_bd_ul_in,
|
|
|
|
/* no support for blink */
|
|
|
|
putc_nm,
|
|
|
|
putc_in,
|
|
|
|
putc_ul,
|
|
|
|
putc_ul_in,
|
|
|
|
putc_bd,
|
|
|
|
putc_bd_in,
|
|
|
|
putc_bd_ul,
|
|
|
|
putc_bd_ul_in
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/* FIX: shouldn't this advance the cursor even if the character to
|
|
|
|
be output is not available in the font? -ch */
|
|
|
|
|
1993-09-02 22:05:24 +04:00
|
|
|
static void
|
2002-01-26 16:40:52 +03:00
|
|
|
putc8(struct ite_softc *ip, int c, int dy, int dx, int mode)
|
1993-09-02 22:05:24 +04:00
|
|
|
{
|
1995-03-02 07:41:51 +03:00
|
|
|
ipriv_t *cci = (ipriv_t *) ip->priv;
|
|
|
|
/*
|
|
|
|
* if character is higher than font has glyphs, substitute
|
|
|
|
* highest glyph.
|
|
|
|
*/
|
|
|
|
c = (u_char)c;
|
|
|
|
if (c < ip->font_lo || c > ip->font_hi)
|
|
|
|
c = ip->font_hi;
|
|
|
|
put_func[mode](cci, cci->row_ptr[dy], cci->font_cell[c],
|
|
|
|
cci->column_offset[dx], cci->row_offset, cci->ft_x, cci->ft_y);
|
1993-09-02 22:05:24 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
1994-04-10 04:43:32 +04:00
|
|
|
clear8(struct ite_softc *ip, int sy, int sx, int h, int w)
|
1993-09-02 22:05:24 +04:00
|
|
|
{
|
1994-01-27 00:05:34 +03:00
|
|
|
ipriv_t *cci = (ipriv_t *) ip->priv;
|
|
|
|
bmap_t *bm = cci->view->bitmap;
|
1993-09-02 22:05:24 +04:00
|
|
|
|
|
|
|
if ((sx == 0) && (w == ip->cols))
|
|
|
|
{
|
|
|
|
/* common case: clearing whole lines */
|
|
|
|
while (h--)
|
|
|
|
{
|
1994-01-27 00:05:34 +03:00
|
|
|
int i;
|
2002-01-26 16:40:52 +03:00
|
|
|
u_char *ptr = cci->row_ptr[sy];
|
1994-01-27 00:05:34 +03:00
|
|
|
for (i=0; i < ip->ftheight; i++) {
|
|
|
|
bzero(ptr, bm->bytes_per_row);
|
|
|
|
ptr += bm->bytes_per_row + bm->row_mod; /* don't get any smart
|
|
|
|
ideas, becuase this is for
|
|
|
|
interleaved bitmaps */
|
|
|
|
}
|
1993-09-02 22:05:24 +04:00
|
|
|
sy++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* clearing only part of a line */
|
|
|
|
/* XXX could be optimized MUCH better, but is it worth the trouble? */
|
|
|
|
while (h--)
|
|
|
|
{
|
1994-01-27 00:05:34 +03:00
|
|
|
u_char *pl = cci->row_ptr[sy];
|
1993-09-02 22:05:24 +04:00
|
|
|
int ofs = sx * ip->ftwidth;
|
|
|
|
int i, j;
|
|
|
|
for (i = w-1; i >= 0; i--)
|
|
|
|
{
|
|
|
|
u_char *ppl = pl;
|
|
|
|
for (j = ip->ftheight-1; j >= 0; j--)
|
|
|
|
{
|
1999-09-21 03:17:13 +04:00
|
|
|
BFCLR(ppl, ofs, ip->ftwidth);
|
2002-01-26 16:40:52 +03:00
|
|
|
ppl += bm->row_mod + bm->bytes_per_row;
|
1993-09-02 22:05:24 +04:00
|
|
|
}
|
|
|
|
ofs += ip->ftwidth;
|
|
|
|
}
|
|
|
|
sy++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Note: sx is only relevant for SCROLL_LEFT or SCROLL_RIGHT. */
|
|
|
|
static void
|
2002-01-26 16:40:52 +03:00
|
|
|
scroll8(register struct ite_softc *ip, register int sy, int sx, int count,
|
|
|
|
int dir)
|
1993-09-02 22:05:24 +04:00
|
|
|
{
|
1994-01-27 00:05:34 +03:00
|
|
|
bmap_t *bm = ((ipriv_t *)ip->priv)->view->bitmap;
|
|
|
|
u_char *pl = ((ipriv_t *)ip->priv)->row_ptr[sy];
|
|
|
|
|
2002-01-26 16:40:52 +03:00
|
|
|
if (dir == SCROLL_UP)
|
1993-09-02 22:05:24 +04:00
|
|
|
{
|
|
|
|
int dy = sy - count;
|
|
|
|
|
1994-01-27 00:05:34 +03:00
|
|
|
/*FIX: add scroll bitmap call */
|
1994-04-10 04:43:32 +04:00
|
|
|
cursor32(ip, ERASE_CURSOR);
|
|
|
|
scrollbmap (bm, 0, dy*ip->ftheight,
|
1994-01-27 00:05:34 +03:00
|
|
|
bm->bytes_per_row >> 3, (ip->bottom_margin-dy+1)*ip->ftheight,
|
|
|
|
0, -(count*ip->ftheight), 0x1);
|
|
|
|
/* if (ip->cursory <= bot || ip->cursory >= dy) {
|
|
|
|
ip->cursory -= count;
|
|
|
|
} */
|
1993-09-02 22:05:24 +04:00
|
|
|
}
|
2002-01-26 16:40:52 +03:00
|
|
|
else if (dir == SCROLL_DOWN)
|
1993-09-02 22:05:24 +04:00
|
|
|
{
|
|
|
|
|
1994-01-27 00:05:34 +03:00
|
|
|
/* FIX: add scroll bitmap call */
|
1994-04-10 04:43:32 +04:00
|
|
|
cursor32(ip, ERASE_CURSOR);
|
|
|
|
scrollbmap (bm, 0, sy*ip->ftheight,
|
1994-01-27 00:05:34 +03:00
|
|
|
bm->bytes_per_row >> 3, (ip->bottom_margin-sy+1)*ip->ftheight,
|
|
|
|
0, count*ip->ftheight, 0x1);
|
|
|
|
/* if (ip->cursory <= bot || ip->cursory >= sy) {
|
|
|
|
ip->cursory += count;
|
|
|
|
} */
|
1993-09-02 22:05:24 +04:00
|
|
|
}
|
2002-01-26 16:40:52 +03:00
|
|
|
else if (dir == SCROLL_RIGHT)
|
1993-09-02 22:05:24 +04:00
|
|
|
{
|
|
|
|
int sofs = (ip->cols - count) * ip->ftwidth;
|
|
|
|
int dofs = (ip->cols) * ip->ftwidth;
|
|
|
|
int i, j;
|
|
|
|
|
1994-04-10 04:43:32 +04:00
|
|
|
cursor32(ip, ERASE_CURSOR);
|
1993-09-02 22:05:24 +04:00
|
|
|
for (j = ip->ftheight-1; j >= 0; j--)
|
|
|
|
{
|
|
|
|
int sofs2 = sofs, dofs2 = dofs;
|
|
|
|
for (i = (ip->cols - (sx + count))-1; i >= 0; i--)
|
|
|
|
{
|
|
|
|
int t;
|
|
|
|
sofs2 -= ip->ftwidth;
|
|
|
|
dofs2 -= ip->ftwidth;
|
1999-09-21 03:17:13 +04:00
|
|
|
BFEXT(t, pl, sofs2, ip->ftwidth);
|
|
|
|
BFINS(t, pl, dofs2, ip->ftwidth);
|
1993-09-02 22:05:24 +04:00
|
|
|
}
|
2002-01-26 16:40:52 +03:00
|
|
|
pl += bm->row_mod + bm->bytes_per_row;
|
1993-09-02 22:05:24 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else /* SCROLL_LEFT */
|
|
|
|
{
|
|
|
|
int sofs = (sx) * ip->ftwidth;
|
|
|
|
int dofs = (sx - count) * ip->ftwidth;
|
|
|
|
int i, j;
|
|
|
|
|
1994-04-10 04:43:32 +04:00
|
|
|
cursor32(ip, ERASE_CURSOR);
|
1993-09-02 22:05:24 +04:00
|
|
|
for (j = ip->ftheight-1; j >= 0; j--)
|
|
|
|
{
|
|
|
|
int sofs2 = sofs, dofs2 = dofs;
|
|
|
|
for (i = (ip->cols - sx)-1; i >= 0; i--)
|
|
|
|
{
|
|
|
|
int t;
|
1999-09-21 03:17:13 +04:00
|
|
|
BFEXT(t, pl, sofs2, ip->ftwidth);
|
|
|
|
BFINS(t, pl, dofs2, ip->ftwidth);
|
1993-09-02 22:05:24 +04:00
|
|
|
sofs2 += ip->ftwidth;
|
|
|
|
dofs2 += ip->ftwidth;
|
|
|
|
}
|
2002-01-26 16:40:52 +03:00
|
|
|
pl += bm->row_mod + bm->bytes_per_row;
|
1993-09-02 22:05:24 +04:00
|
|
|
}
|
2002-01-26 16:40:52 +03:00
|
|
|
}
|
1993-07-05 23:19:43 +04:00
|
|
|
}
|
|
|
|
|
2002-01-26 16:40:52 +03:00
|
|
|
void
|
|
|
|
scrollbmap(bmap_t *bm, u_short x, u_short y, u_short width, u_short height,
|
|
|
|
short dx, short dy, u_char mask)
|
1994-01-27 00:05:34 +03:00
|
|
|
{
|
2002-01-26 16:40:52 +03:00
|
|
|
u_short depth = bm->depth;
|
1994-02-14 00:10:20 +03:00
|
|
|
u_short lwpr = bm->bytes_per_row >> 2;
|
1994-01-27 00:05:34 +03:00
|
|
|
if (dx) {
|
|
|
|
/* FIX: */ panic ("delta x not supported in scroll bitmap yet.");
|
2002-01-26 16:40:52 +03:00
|
|
|
}
|
1994-01-27 00:05:34 +03:00
|
|
|
if (bm->flags & BMF_INTERLEAVED) {
|
|
|
|
height *= depth;
|
|
|
|
depth = 1;
|
|
|
|
}
|
|
|
|
if (dy == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (dy > 0) {
|
|
|
|
int i;
|
|
|
|
for (i=0; i < depth && mask; i++, mask >>= 1) {
|
|
|
|
if (0x1 & mask) {
|
|
|
|
u_long *pl = (u_long *)bm->plane[i];
|
|
|
|
u_long *src_y = pl + (lwpr*y);
|
|
|
|
u_long *dest_y = pl + (lwpr*(y+dy));
|
|
|
|
u_long count = lwpr*(height-dy);
|
|
|
|
u_long *clr_y = src_y;
|
|
|
|
u_long clr_count = dest_y - src_y;
|
|
|
|
u_long bc, cbc;
|
2002-01-26 16:40:52 +03:00
|
|
|
|
1994-01-27 00:05:34 +03:00
|
|
|
src_y += count - 1;
|
|
|
|
dest_y += count - 1;
|
|
|
|
|
|
|
|
bc = count >> 4;
|
|
|
|
count &= 0xf;
|
2002-01-26 16:40:52 +03:00
|
|
|
|
1994-01-27 00:05:34 +03:00
|
|
|
while (bc--) {
|
|
|
|
*dest_y-- = *src_y--; *dest_y-- = *src_y--;
|
|
|
|
*dest_y-- = *src_y--; *dest_y-- = *src_y--;
|
|
|
|
*dest_y-- = *src_y--; *dest_y-- = *src_y--;
|
|
|
|
*dest_y-- = *src_y--; *dest_y-- = *src_y--;
|
|
|
|
*dest_y-- = *src_y--; *dest_y-- = *src_y--;
|
|
|
|
*dest_y-- = *src_y--; *dest_y-- = *src_y--;
|
|
|
|
*dest_y-- = *src_y--; *dest_y-- = *src_y--;
|
|
|
|
*dest_y-- = *src_y--; *dest_y-- = *src_y--;
|
|
|
|
}
|
|
|
|
while (count--) {
|
|
|
|
*dest_y-- = *src_y--;
|
|
|
|
}
|
|
|
|
|
|
|
|
cbc = clr_count >> 4;
|
|
|
|
clr_count &= 0xf;
|
|
|
|
|
|
|
|
while (cbc--) {
|
|
|
|
*clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0;
|
|
|
|
*clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0;
|
|
|
|
*clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0;
|
|
|
|
*clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0;
|
|
|
|
}
|
|
|
|
while (clr_count--) {
|
|
|
|
*clr_y++ = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (dy < 0) {
|
|
|
|
int i;
|
|
|
|
for (i=0; i < depth && mask; i++, mask >>= 1) {
|
|
|
|
if (0x1 & mask) {
|
|
|
|
u_long *pl = (u_long *)bm->plane[i];
|
|
|
|
u_long *src_y = pl + (lwpr*(y-dy));
|
2002-01-26 16:40:52 +03:00
|
|
|
u_long *dest_y = pl + (lwpr*y);
|
1994-01-27 00:05:34 +03:00
|
|
|
long count = lwpr*(height + dy);
|
|
|
|
u_long *clr_y = dest_y + count;
|
|
|
|
u_long clr_count = src_y - dest_y;
|
|
|
|
u_long bc, cbc;
|
|
|
|
|
|
|
|
bc = count >> 4;
|
|
|
|
count &= 0xf;
|
2002-01-26 16:40:52 +03:00
|
|
|
|
1994-01-27 00:05:34 +03:00
|
|
|
while (bc--) {
|
|
|
|
*dest_y++ = *src_y++; *dest_y++ = *src_y++;
|
|
|
|
*dest_y++ = *src_y++; *dest_y++ = *src_y++;
|
|
|
|
*dest_y++ = *src_y++; *dest_y++ = *src_y++;
|
|
|
|
*dest_y++ = *src_y++; *dest_y++ = *src_y++;
|
|
|
|
*dest_y++ = *src_y++; *dest_y++ = *src_y++;
|
|
|
|
*dest_y++ = *src_y++; *dest_y++ = *src_y++;
|
|
|
|
*dest_y++ = *src_y++; *dest_y++ = *src_y++;
|
|
|
|
*dest_y++ = *src_y++; *dest_y++ = *src_y++;
|
|
|
|
}
|
|
|
|
while (count--) {
|
|
|
|
*dest_y++ = *src_y++;
|
|
|
|
}
|
|
|
|
|
|
|
|
cbc = clr_count >> 4;
|
|
|
|
clr_count &= 0xf;
|
|
|
|
|
|
|
|
while (cbc--) {
|
|
|
|
*clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0;
|
|
|
|
*clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0;
|
|
|
|
*clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0;
|
|
|
|
*clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0; *clr_y++ = 0;
|
|
|
|
}
|
|
|
|
while (clr_count--) {
|
|
|
|
*clr_y++ = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1994-06-15 23:05:55 +04:00
|
|
|
|
|
|
|
#endif /* NGRFCC */
|