fb_start.c

早期freebsd实现

	while (dy > 0) {
		if (first) {	/* for the first time */
			ylen = prect.extent.y - offy;
			ylen = min(ylen, dy);
			trect.extent.y = ylen;
			trect.origin.y = prect.origin.y + offy;
			first = 0;
		} else {
			ylen = min(prect.extent.y, dy);
			trect.extent.y = ylen;
			trect.origin.y = prect.origin.y;
		}

		dp.x = rect.origin.x;
		dx = rect.extent.x;
		xlen = prect.extent.x - offx;
		trect.origin.x = prect.origin.x + offx;

		if (dx < xlen) {
			trect.extent.x = dx;
			(*blt)(fb, &cmd->ptnBitmap, &trect, &cmd->destBitmap, &dp, (lRectangle *)0);
		} else {
			trect.extent.x = xlen;
			(*blt)(fb, &cmd->ptnBitmap, &trect, &cmd->destBitmap, &dp, (lRectangle *)0);
			dp.x += xlen;
			dx -= xlen;
			trect.origin.x = prect.origin.x;
			while (dx > 0) {
				xlen = min(dx, prect.extent.x);
				trect.extent.x = xlen;
				(*blt)(fb, &cmd->ptnBitmap, &trect, &cmd->destBitmap, &dp, (lRectangle *)0);
				dp.x += xlen;
				dx -= xlen;
			}
		}

		dp.y += ylen;
		dy -= ylen;
	}

	cursorOn(fb);
}

bitblt3cmd(fb, cmd)
	struct fbdev fb;
	lBitblt3 *cmd;
{
	return (FB_ROK);
}

draw_rectangle(fb, dp)
	struct fbdev *fb;
	lPrimRect *dp;
{
	lRectangle trect, rect, prect;
	lPoint p;
	register int dx;
	int dy;
	register int offx, offy;
	register int xlen, ylen;
	int first;
	register int (*blt)();
	int t;

	rect = dp->rect;
	prect = dp->ptnRect;

	if (prect.extent.x <= 0 || prect.extent.y <= 0)
		return;

	if (dp->ptnBM.type == BM_FB &&
		!cliprect(&dp->ptnBM.rect, &fb->FrameRect, (lRectangle*)0))
		return;

	/* clip pattern rectangle */
	if (!cliprect(&prect, &dp->ptnBM.rect, (lRectangle *)0))
		return;

	if (!getclip(fb, &dp->drawBM, &dp->clip)) return;

	if (!cliprect(&rect, &dp->clip, (lRectangle *)0))
		return;

	if (setrop(fb, dp->func, dp->planemask, dp->fore_color, dp->aux_color,
			dp->transp, &dp->ptnBM, &dp->drawBM) < 0)
		return (FB_RERROR);

	blt = sel_ropfunc(dp->ptnBM.type, dp->drawBM.type);

	offx = MOD(rect.origin.x - dp->refPoint.x, prect.extent.x, t);
	offy = MOD(rect.origin.y - dp->refPoint.y, prect.extent.y, t);

	p = rect.origin;

	trect.origin.x = prect.origin.x + offx;
	trect.origin.y = prect.origin.y + offy;

	dy = rect.extent.y;

	cursorCheck(fb, dp->ptnBM.type, &prect, dp->drawBM.type, &rect);

	first = 1;
	while (dy > 0) {
		if (first) {	/* for the first time */
			ylen = prect.extent.y - offy;
			ylen = min(ylen, dy);
			trect.extent.y = ylen;
			trect.origin.y = prect.origin.y + offy;
			first = 0;
		} else {
			ylen = min(prect.extent.y, dy);
			trect.extent.y = ylen;
			trect.origin.y = prect.origin.y;
		}

		p.x = rect.origin.x;
		dx = rect.extent.x;
		xlen = prect.extent.x - offx;
		trect.origin.x = prect.origin.x + offx;

		if (dx < xlen) {
			trect.extent.x = dx;
			(*blt)(fb, &dp->ptnBM, &trect, &dp->drawBM, &p, (lRectangle *)0);
		} else {
			trect.extent.x = xlen;
			(*blt)(fb, &dp->ptnBM, &trect, &dp->drawBM, &p, (lRectangle *)0);
			p.x += xlen;
			dx -= xlen;
			trect.origin.x = prect.origin.x;
			while (dx > 0) {
				xlen = min(dx, prect.extent.x);
				trect.extent.x = xlen;
				(*blt)(fb, &dp->ptnBM, &trect, &dp->drawBM, &p, (lRectangle *)0);
				p.x += xlen;
				dx -= xlen;
			}
		}

		p.y += ylen;
		dy -= ylen;
	}

	cursorOn(fb);
}

draw_polymarker(fb, dp)
	struct fbdev *fb;
	register lPrimMarker *dp;
{
	register lPoint *ps;
	register int np;
	lRectangle cr;
	register int (*blt)();
#ifdef CPU_SINGLE
	struct fb_map *map;
	unsigned int p;
#endif

	cr = dp->clip;

	if ((dp->drawBM.type == BM_FB) &&
			!getclip(fb, &dp->drawBM, &cr))
		return (FB_ROK);

	if (dp->ptnBM.type == BM_FB &&
		!cliprect(&dp->ptnBM.rect, &fb->FrameRect, (lRectangle*)0))
		return (FB_ROK);

	if (setrop(fb, dp->func, dp->planemask, dp->fore_color, dp->aux_color,
			dp->transp, &dp->ptnBM, &dp->drawBM) < 0)
		return (FB_RERROR);

	blt = sel_ropfunc(dp->ptnBM.type, dp->drawBM.type);

	cursorCheck(fb, dp->ptnBM.type, &(dp->ptnRect), dp->drawBM.type, &cr);

#ifdef CPU_SINGLE
	map = (struct fb_map *)(dp->plist);
	p = map->fm_offset;
	ps = (lPoint *)TypeAt(map, p);
#else
	ps = dp->plist;
#endif
	np = dp->np;
	while (--np >= 0) {
		(*blt)(fb, &dp->ptnBM, &dp->ptnRect, &dp->drawBM, ps++, &cr);
		PRE_EMPT;
	}

	cursorOn(fb);

	return (FB_ROK);
}

static int patternx;
static int patterny;
static int patternwidth;
static lBitmap *pbm;		/* pattern bitmap */
static lBitmap *drawbm;		/* drawing bitmap */
static int (*blt)();

static
fill_line(fb, len, dp, offx, offy)
register struct fbdev *fb;
register int len;
register lPoint *dp;
int offx, offy;
{
	register int plen;
	static lRectangle srec = { 0, 0, 0, 1 };

	srec.origin.x = patternx + offx;
	srec.origin.y = patterny + offy;

	if ((plen = patternwidth - offx) > len) {
		srec.extent.x = len;
		(*blt)(fb, pbm, &srec, drawbm, dp, (lRectangle *)0);
		return;
	}

	srec.extent.x = plen;
	(*blt)(fb, pbm, &srec, drawbm, dp, (lRectangle *)0);
	dp->x += plen;
	len -= plen;
	srec.origin.x = patternx;
	plen = patternwidth;

	while (len > 0) {
		srec.extent.x = min(plen, len);
		(*blt)(fb, pbm, &srec, drawbm, dp, (lRectangle *)0);
		dp->x += plen;
		len -= plen;
	}
}

fill_scan(fb, fdata)
	register struct fbdev *fb;
	register lPrimFill *fdata;
{
	register lScanl	*ls;
	int nscan;
	lRectangle clip;
	lRectangle prect;
	register int minx, maxx, miny, maxy;
#ifdef CPU_SINGLE
	struct fb_map *map;
#endif
	register void (*rop_clear)();
	int (*sel_ropfunc())();

	if ((nscan = fdata->nscan) <= 0)
		return (FB_RERROR);
	
	/* clip pattern rectangle */
	prect = fdata->ptnRect;
	if (!getclip(fb, &fdata->ptnBM, &prect))
		return (0);

	if (prect.extent.x <= 0 || prect.extent.y <= 0)
		return (FB_RERROR);

	/* clip clip rectangle */
	clip = fdata->clip;
	if (!getclip(fb, &fdata->drawBM, &clip))
		return (0);

	if (setrop(fb, fdata->func, fdata->planemask,
	    fdata->fore_color, fdata->aux_color, fdata->transp,
	    &fdata->ptnBM, &fdata->drawBM) < 0)
		return (FB_RERROR);

#ifdef CPU_SINGLE
	map = (struct fb_map *)(fdata->scan);
	ls = (lScanl *)TypeAt(map, map->fm_offset);
#else
	ls = fdata->scan;
#endif

	minx = clip.origin.x;
	maxx = minx + clip.extent.x - 1;
	miny = clip.origin.y;
	maxy = miny + clip.extent.y - 1;

	cursorCheck(fb, fdata->ptnBM.type, &prect, fdata->drawBM.type, &clip);

	blt = sel_ropfunc(fdata->ptnBM.type, fdata->drawBM.type);
	if (blt == bitblt_1tofb || blt == bitblt_0tofb) {
		lRectangle dr;

		if (fb->fbbm_op->fb_rop_fillscan != (void (*)())nofunc) {
			fbbm_rop_fillscan(fb, ls, nscan, &clip,
			    blt == bitblt_1tofb);
			goto out;
		}
		dr.extent.y = 1;
		fbbm_rop_cinit(fb, fb->Pmask, blt == bitblt_1tofb);
		rop_clear = fb->fbbm_op->fb_rop_clear;
		while (--nscan >= 0) {
			if ((dr.origin.y = ls->y) >= miny &&
			    dr.origin.y <= maxy) {
				dr.origin.x = max(ls->x0, minx);
				if ((dr.extent.x =
				    min(ls->x1, maxx) - dr.origin.x + 1) > 0)
					(*rop_clear)(fb, &dr);
			}
			ls++;
		}
	} else {
		int len;
		int refx, refy;
		lPoint dp;
		int sizex, sizey;
		int t;

		sizex = prect.extent.x;
		sizey = prect.extent.y;
		refx = fdata->refPoint.x;
		refy = fdata->refPoint.y;

		patternx = prect.origin.x;
		patterny = prect.origin.y;
		patternwidth = sizex;

		pbm = &fdata->ptnBM;
		drawbm = &fdata->drawBM;

		while (--nscan >= 0) {
			if ((dp.y = ls->y) >= miny && dp.y <= maxy) {
				dp.x = max(ls->x0, minx);
				if ((len = min(ls->x1, maxx) - dp.x + 1) > 0)
					fill_line(fb, len, &dp,
					    MOD((dp.x - refx), sizex, t),
					    MOD((dp.y - refy), sizey, t));
			}
			ls++;
		}
	}
out:
	cursorOn(fb);
	return (FB_ROK);
}

put_string(fb, sdata)
	struct fbdev *fb;
	lPrimText *sdata;
{
	register int x, y;
	register int ex_factor = sdata->ex_factor;
	register unsigned c;
	register unsigned char *str;
	int len = sdata->len;
	int flen;
	int i, j, k, l;
	unsigned fchar = sdata->first_chr;
	unsigned lchar = sdata->last_chr;
	lRectangle cr, save;
	register int (*bltfunc)();
	register char *f_addr;		/* font address */
	register char **fnt_addr;
	static struct fb_map rommap;
#ifdef CPU_SINGLE
	struct fb_map *map;
	unsigned int p;
#endif

	lBitmap *fontBM;
	lRectangle srec;
	lPoint dp;

	extern int tmode;	/* in ../bm/vt100if.c */

	x = sdata->p.x << 16;
	y = sdata->p.y << 16;

	srec.extent.x = sdata->width;
	srec.extent.y = sdata->height;

	switch (sdata->type) {

	case ASCII:
		fontBM = &sdata->fontBM;

		break;

	case ROM_ASCII:
	case ROM_CONS:
		if (sdata->width >= 12 && sdata->height >= 24) {
			if (fb->Krom_BM1.type == (char)0xff) {
				fontBM = &fb->Krom_BM0;
				srec.extent.x = fb->Krom_font_extent0.x>>1;
				srec.extent.y = fb->Krom_font_extent0.y;
				fnt_addr = ext_fnt_addr;
			} else {
				fontBM = &fb->Krom_BM1;
				srec.extent.x = fb->Krom_font_extent1.x>>1;
				srec.extent.y = fb->Krom_font_extent1.y;
				fnt_addr = ext_fnt24_addr;
			}
		} else {
			if (fb->Krom_BM0.type == (char)0xff) {
				fontBM = &fb->Krom_BM1;
				srec.extent.x = fb->Krom_font_extent1.x>>1;
				srec.extent.y = fb->Krom_font_extent1.y;
				fnt_addr = ext_fnt24_addr;
			} else {
				fontBM = &fb->Krom_BM0;
				srec.extent.x = fb->Krom_font_extent0.x>>1;
				srec.extent.y = fb->Krom_font_extent0.y;
				fnt_addr = ext_fnt_addr;
			}
		}

		if (srec.extent.x > sdata->width)
			srec.extent.x = sdata->width;
		if (srec.extent.y > sdata->height)
			srec.extent.y = sdata->height;
		flen = (fontBM->width<<1) * fontBM->rect.extent.y;
		fontBM->base = (Word *)&rommap;
		break;

	case ROM_KANJI:
		if (sdata->width >= 24 && sdata->height >= 24) {
			if (fb->Krom_BM1.type == (char)0xff) {
				fontBM = &fb->Krom_BM0;
				srec.extent = fb->Krom_font_extent0;
				fnt_addr = ext_fnt_addr;
			} else {
				fontBM = &fb->Krom_BM1;
				srec.extent = fb->Krom_font_extent1;
				fnt_addr = ext_fnt24_addr;
			}
		} else {
			if (fb->Krom_BM0.type == (char)0xff) {
				fontBM = &fb->Krom_BM1;
				srec.extent = fb->Krom_font_extent1;
				fnt_addr = ext_fnt24_addr;
			} else {
				fontBM = &fb->Krom_BM0;
				srec.extent = fb->Krom_font_extent0;
				fnt_addr = ext_fnt_addr;
			}
		}

		if (srec.extent.x > sdata->width)
			srec.extent.x = sdata->width;
		if (srec.extent.y > sdata->height)
			srec.extent.y = sdata->height;
		save.extent.x = srec.extent.x;
		flen = (fontBM->width<<1) * fontBM->rect.extent.y;
		fontBM->base = (Word *)&rommap;
		break;

	default:
		return (FB_RERROR);
	}

	/* get clipping rectangle */
	cr = sdata->clip;

	if (!getclip(fb, &sdata->drawBM, &cr))
		return (FB_ROK);

	/* set rop code */
	if (setrop(fb, sdata->func, sdata->planemask,
			sdata->fore_color, sdata->aux_color,
			sdata->transp, fontBM, &sdata->drawBM) < 0)
		return (FB_RERROR);

	/* select rop function */
	bltfunc = sel_ropfunc(fontBM->type, sdata->drawBM.type);

#ifdef CPU_SINGLE
	map = (struct fb_map *)(sdata->str);
	p = map->fm_offset;
	str = (unsigned char *)TypeAt(map, p);
#else
	str = sdata->str;
#endif

	cursorCheck(fb, fontBM->type, &fontBM->rect, sdata->drawBM.type, &cr);

	switch (sdata->type) {

	case ASCII:
		if (sdata->column == 0)
			return (FB_RERROR);
		while (len-- > 0) {
			c = *str++;

			if (c < fchar || c > lchar)
				continue;

			c -= fchar;
			srec.origin.x = sdata->fp.x
				+ sdata->width * (c % sdata->column);
			srec.origin.y = sdata->fp.y
				+ sdata->height * (c / sdata->column);
			dp.x = x >> 16;
			dp.y = y >> 16;

			if (ex_factor == 1) {
				(*bltfunc)(fb, fontBM, &srec, &sdata->drawBM,
					&dp, &cr);
			} else {
				srec.extent.x = 1;

				for (i = 0; i < sdata->width; i++) {
					for (j = 0; j < ex_factor; j++) {
						(*bltfunc)(fb, fontBM, &srec,
							&sdata->drawBM,
							&dp, &cr);
						dp.x++;
						PRE_EMPT;
					}
					srec.origin.x++;
				}
			}
			x += sdata->dx;
			y += sdata->dy;
		}
		break;

	case ROM_ASCII:
	case ROM_CONS:
#ifdef IPC_MRX
		if (fb->type == FB_NWB251)
			fb->cache_off = 1;
#endif
		while (len-- > 0) {
			c = *str++;
			dp.x = x >> 16;
			dp.y = y >> 16;
			k = 0;
			srec.origin.x = srec.origin.y = 0;

			f_addr = 0;

			if ((c >= 0x20) && (c <= 0x7e)) {
				/*
				 * ASCII char
				 */
				f_addr = fnt_addr[c];
				goto disp;
			}

			if (sdata->type == ROM_ASCII) {
				if ((c >= 0xa1) && (c <= 0xdf)) {
					/*
					 * KANA char
					 */
					f_addr = fnt_addr[c + 64];
					goto disp;
				}
			}

			if (sdata->type == ROM_CONS) {
#ifdef KM_ASCII
				if (tmode == KM_ASCII) {
#endif
					if ((c >= 0xa0) && (c <= 0xff)) {
						/*
						 * ISO char
						 */
						f_addr = fnt_addr[c - 32];
						goto disp;
					}
#ifdef KM_ASCII
				} else {
					if ((c >= 0xa1) && (c <= 0xdf)) {
						/*
						 * KANA char
						 */
						f_addr = fnt_addr[c + 64];
						goto disp;
					}
				}
#endif
			}

disp:

			if (f_addr) {
				/*
				 * not ROM font
				 *	(font is in kernel data area)
				 */
				bltfunc = sel_ropfunc(BM_MEM,
						sdata->drawBM.type);
				rommap.fm_vaddr = f_addr;
				rommap.fm_offset = 0;
#ifdef IPC_MRX
				iopmemfbmap(f_addr, flen, &rommap);
#endif
				k = 1;
				l = fontBM->width;
				fontBM->width = 1;
				save = fontBM->rect;
				fontBM->rect.origin = srec.origin;
				fontBM->rect.extent.x = 12;
			} else if (fontBM->type == BM_MEM) {
				/*
				 * KANJI ROM except pop[cm]fb
				 */
				f_addr = fbbm_Krom_addr(fb, c, &srec);
				rommap.fm_vaddr = f_addr;
				rommap.fm_offset = 0;
#ifdef IPC_MRX
				iopmemfbmap(f_addr, flen, &rommap);
#endif
			} else {
				/*
				 * XXX
				 * fontBM->type == BM_FB -> fbbm_pop[cm]
				 *
				 * see fbpop[cm]_setup() routine
				 * in fbbm_pop[cm].c
				 */
				bltfunc = sel_ropfunc(fontBM->type,
							sdata->drawBM.type);

				bzero((caddr_t)fontBM->base,
						sizeof (struct fb_map));
				fbbm_Krom_addr(fb, c, &srec);
				fontBM->rect.origin = srec.origin;
			}

			if (ex_factor == 1) {
				(*bltfunc)(fb, fontBM, &srec, &sdata->drawBM,
					&dp, &cr);
			} else {
				srec.extent.x = 1;

				for (i = 0; i < sdata->width; i++) {

					for (j = 0; j < ex_factor; j++) {
						(*bltfunc)(fb, fontBM, &srec,
							&sdata->drawBM,
							&dp, &cr);
						dp.x++;
					}
					srec.origin.x++;
				}
			}
			PRE_EMPT;
			if (k != 0) {
				fontBM->rect = save;
				fontBM->width = l;
			}
			x += sdata->dx;