andreacavalli
/
xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Death to afb. 

Planar framebuffer people, please talk to wfb for all your 1988 hardware
needs.
This commit is contained in:
Adam Jackson 2008-05-21 17:03:25 -04:00
parent c76fddeea2
commit 20ea99c655
37 changed files with 2 additions and 11867 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile.am
View File

@ -9,10 +9,6 @@ if XTRAP
XTRAP_DIR=XTrap
endif
if AFB
AFB_DIR=afb
endif
if MFB
MFB_DIR=mfb
endif

51
afb/Makefile.am
View File

@ -1,51 +0,0 @@
noinst_LTLIBRARIES = libafb.la
AM_CFLAGS = $(DIX_CFLAGS)
libafb_gen_sources = afbbltC.c afbbltX.c afbbltCI.c afbbltO.c afbbltG.c afbtileC.c afbtileG.c afbseg.c
DISTCLEANFILES = $(libafb_gen_sources)
libafb_la_SOURCES = afbgc.c afbwindow.c afbfont.c afbfillrct.c afbpixmap.c \
afbimage.c afbline.c afbbres.c afbhrzvert.c afbbresd.c afbpushpxl.c afbply1rct.c \
afbzerarc.c afbfillarc.c afbfillsp.c afbsetsp.c afbscrinit.c afbplygblt.c \
afbclip.c afbgetsp.c afbpolypnt.c afbbitblt.c afbcmap.c afbimggblt.c afbpntarea.c \
afbmisc.c afbtegblt.c $(libafb_gen_sources)
INCLUDES = -I$(top_srcdir)/mfb -I$(top_srcdir)/hw/xfree86/os-support
EXTRA_DIST = afbline.c afbblt.c afbtile.c README Xdaniver.doc
afbseg.c:
echo "#define POLYSEGMENT" > $@
echo "#include \"$(srcdir)/afbline.c\"" >> $@
afbbltC.c:
echo "#define MROP Mcopy" > $@
echo "#include \"$(srcdir)/afbblt.c\"" >> $@
afbbltX.c:
echo "#define MROP Mxor" > $@
echo "#include \"$(srcdir)/afbblt.c\"" >> $@
afbbltCI.c:
echo "#define MROP McopyInverted" > $@
echo "#include \"$(srcdir)/afbblt.c\"" >> $@
afbbltO.c:
echo "#define MROP Mor" > $@
echo "#include \"$(srcdir)/afbblt.c\"" >> $@
afbbltG.c:
echo "#define MROP 0" > $@
echo "#include \"$(srcdir)/afbblt.c\"" >> $@
afbtileC.c:
echo "#define MROP Mcopy" > $@
echo "#include \"$(srcdir)/afbtile.c\"" >> $@
afbtileG.c:
echo "#define MROP 0" > $@
echo "#include \"$(srcdir)/afbtile.c\"" >> $@
sdk_HEADERS = afb.h

10
afb/README
View File

@ -1,10 +0,0 @@
All stuff in this directory is based on Xdaniver (read Xdaniver.doc).
Actually this is the same code as in the ilbm directory, except that here the
conversion from normal bitplanes to interleaved bitplanes didn't happen.
--
Geert Uytterhoeven Geert.Uytterhoeven@cs.kuleuven.ac.be
Wavelets, Linux/m68k on Amiga http://www.cs.kuleuven.ac.be/~geert/
Department of Computer Science -- Katholieke Universiteit Leuven -- Belgium

218
afb/Xdaniver.doc
View File

@ -1,218 +0,0 @@
What is it?
-----------
Xdaniver is a fast, colour X11R6 server for the Amiga's custom chip set
under NetBSD 1.0 and NetBSD-current, supporting all the Amiga's display
depths from 1 to 4 (upto 16 colours) on ECS machines and 1 to 8 (upto 256
colours) on AGA machines (though, not all resolutions are available, see
General Information below).
Xdaniver is designed to be a drop-in replacement for the Xmono server provided
with the X11R6 binary distribution supplied by Bernd Ernesti available from
ftp.uni-regensburg.de or one of its mirrors.
Unlike previous colour X servers for the Amiga that emulate a chunky pixel
screen in fast RAM, use the standard frame buffer drivers provided with the
X11R6 source code to draw and then use a chunky to planar conversion routine
to write the results to the screen (all very slow), Xdaniver uses a heavily
modified mono frame buffer driver to draw directly using the Amiga's planar
format. The net result is much faster drawing and support for all the Amiga's
custom display depths but, as usual, the fewer planes used, the faster the
drawing operations of the X server. Even so, on my A1200 with a 33Mhz 68030,
I'm getting reasonable performance when using 8 bit planes in Dbl NTSC mode.
Installation
------------
You will need to have first obtained and installed the X11R6 binary
distribution available from ftp.uni-regensburg.de in
/pub/NetBSD-Amiga/contrib/X11 or one of its mirrors. Xdaniver has been
compiled to expect font and configuration files sitting under
/usr/local/X11R6, if your setup is different you will need to provide a
symbolic link from /usr/local/X11R6 to where your tree resides or supply
several command line flags to the server.
To get Xdaniver running as the default X server, copy the uncompressed binary
into /usr/local/X11R6/bin, remove the current X file from that directory
(which is a symbolic link to Xmono) and replace it with a link to Xdaniver:
gzip -d < X11R6.Xdaniver.1.01.tar.gz | tar xvf -
mv Xdaniver /usr/local/X11R6/bin
cd /usr/local/X11R6/bin
rm X
ln -s Xdaniver X
Note that on some setups, the devices /dev/kbd, /dev/mouse and /dev/view??
have been created to be accessable only by superuser; Xdaniver needs to open
these devices. To workaround this problem, log on as superuser and then
either make Xdaniver setuid root:
chown root Xdaniver
chmod 4755 Xdaniver
or give everyone access the devices:
chmod 666 /dev/kbd /dev/mouse /dev/view??
the latter option is a possible cause of a security hole if your machine is
ever used multi-user.
General Information
-------------------
The default resolution of the server is 700x430 and the default depth 4. AGA
users might what to increase the display depth by editing the startx script
and providing a -depth <depth> argument to Xdaniver on the xinit line of the
script. As always, the lower the depth, the faster the drawing and window
manipulation of the server.
The resolution can be altered similarly by suppling -width <width> and
-height <height> arguments to the server.
The NetBSD kernel selects actual screen modes by picking a mode who's
natural, non-overscanned size best-fits the requested resolution.
Unfortunately, for AGA users, the 1.0 kernel only has support for the
Dbl-NTSC AGA display mode and only this mode has support for depths greater
than 4. The NetBSD-current (work-in-progress) kernel also has support for
Dbl-PAL but still no support for the Super72 or other super-hires modes
(perhaps some kind, kernel-hacker could add support for them ?).
If you have a 2 button mouse (like me) you might want to try and use the 3
button mouse emulation. On other systems, it is usual for the left and right
buttons to be provided and emulate the middle button by pressing both
buttons together, however, the middle button is tends to be used more than
the right button so I have provided two options:
-emulateright (or -3), the two physical mouse buttons act as left and middle
and pressing them both together emulates the right button.
-emulatemiddle (or -2), the two physical mouse buttons act as left and right
and pressing them both together emulated the middle button.
When using screen depths of less than 6 (4 is the maximum for ECS machines)
the lack of possible colours on screen at once causes problems for many X
applications. Specifying -cc 2 as a command line argument to Xdaniver
causes the server to switch the default visual type from PsuedoColor to
StaticColor; to put it simply, the server prefills the colormap with a
selection of 16 colours (depth 4) and when an application asks for a
particular colour, its gets allocated one that is closest to one from the
selection of 16. This removes the 'WARNING: Cannot allocate colormap entry
for "XXX"' errors but at the expense of applications not being able to get
the precise colour they wanted. Also, some badly written X applications fail
altogether when presented with a StaticColor visual.
Bugs/Limitations
----------------
The limited choice of display resolutions for AGA/ECS machines is a real
pain - requires a kernel change to fix. Worse still, the kernel specifies
the maximum overscan resolution on the Dbl-NTSC to be 724x482 but selecting
anything more than 702x430 on my machine causes the screen either sheer
diagonally (as if the bytes per row calculation in Xdaniver or the kernel is
wrong) or completely loose sync (suggesting a custom chip register sync
calculation bug). As other, non-aga modes aren't affected when selection
overscan both problems seem to point to a kernel driver bug. Also, depths
greater than 4 for AGA users are only supported by the kernel in the Dbl-NTSC
mode (and Dbl-PAL with the current-NetBSD kernel).
I know of one bug so-far (there will be more), The PutImage request of an XY
format image expects the bitplane order to be the reverse of that specified
in the X protocol but since virtually all applications use the Z (chunky)
format, you are unlikely to come across this problem.
The PutImage request of Z format images is a little slow - when I have time
I'll try and add one of the fast assembly chunky-to-planar routines developed
for doom style games/demos. Unfortunately, the current crop all require a
picture size that is a multiple of 32 pixels and so cannot be used out-of-the-
box.
Some extra performance could easily be squeezed out of the terminal font
drawing code (used by xterm) - when I have time I'll add the code.
The Amiga's blitter and sprites are totally unused and will remain so
until/if someone else adds support to the kernel. The blitter would help
speed up screen scrolling and window manipulation and sprite support could
be used for the X pointer shape (if small enough) which would speed up all
drawing operations (no need to remove the software based pointer shape
first, draw, then replace the pointer shape).
I removed the X image extension (XIE) from the X server as it increased the
size of the binary by some 400k. I haven't come across any applications that
need it yet (I haven't been looking!) so if you need the extension for some
reason send me e-mail and I'll build a server with the extension included.
The 3 button mouse emulation is very simple - to emulate the 3rd button you
have to press both button precisely at the same moment - I've got quite good
at it now. When I have some spare time I'll add a timer so you will have a
few milli-seconds between one button being pressed and the next and it still
being registered as the emulated button.
AGA users don't forget to provide the -A flag to loadbsd to enable the one
AGA mode in the 1.0 kernel but only if you have a VGA, multisync or dual-scan
monitor, of course !
Xdaniver has been tested on:
A1200, 33Mhz 68030, 8Mb RAM and NetBSD 1.0 by myself.
A4000/40, 12Mb RAM and NetBSD 1.0 by Andreas Holzhammer.
A3000, 12Mb RAM and NetBSD 1.0 by Charlie Root, Stuart Park and others.
A3000, 25Mhz 68040, 18Mb RAM and NetBSD-current by Michael K. Sanders.
A2000, 8Mb RAM and NetBSD (version unknown) by Hubert Feyrer.
Release and Bug Fix History
---------------------------
1.0 - First release
1.01 Bugs fixed:
- Narrow (<32 pixels) Z format GetImage requests corrupted the stack
and could cause the server to core dump. (Xpaint caused this problem)
- Drawing dots (PolyPoint request) into a clipped window caused a
c pointer to go out of range, causing a core dump (xv showed this
problem).
New features:
- Simple 3 button mouse emulation using a 2 button mouse; specify
-emulate_middle (or -2) or -emulate_right (or -3) on the server's
command line and press both mouse buttons together emulate the 'missing'
button.
- Basic beep sound support added by sending bell characters to the
console.
- Source code released.
Disclaimer and Copyright Notices
--------------------------------
Multi-depth planar frame buffer code:
Copyright (c) 1995 by Daniver Limited.
Large portions:
Copyright (c) 1994 by Eduardo Horvath.
Copyright (c) 1987-1995 by the Regents of the University of California.
Copyright (c) 1987 by Sun Microsystems, Inc. Mountain View, CA.
Copyright (c) 1987-1995 by X Consortium.
Copyright (c) 1987, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
Copyright (c) 1989 Network Computing Devices, Inc., Mountain View, California.
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted, provided
that the above copyright notice appear in all copies. The Daniver Limited,
the above companies and individuals makes no representations about the
suitability of this software for any purpose. It is provided "as is" without
express or implied warranty.
Credits
-------
Thanks to Bernd Ernesti for making the operating system server source code
available for others to use and Eduardo Horvath and Andy Heffernan, who (I
think) did the original Xmono server port.
Also, many thanks to the first brave users who tested Xdaniver for me on other
Amiga setups and found a few bugs in the process.
Gary Henderson.
Daytime: garyh@wet.sbi.com
Home: gary@daniver.demon.co.uk

972
afb/afb.h
View File

@ -1,972 +0,0 @@
/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
/***********************************************************
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
/* Monochrome Frame Buffer definitions
written by drewry, september 1986
*/
#include "pixmap.h"
#include "region.h"
#include "gc.h"
#include "colormap.h"
#include "regionstr.h"
#include "privates.h"
#include "mibstore.h"
#include "mfb.h"
extern int afbInverseAlu[];
/* warning: PixelType definition duplicated in maskbits.h */
#ifndef PixelType
#define PixelType CARD32
#endif /* PixelType */
#define AFB_MAX_DEPTH 8
/* afbbitblt.c */
extern void afbDoBitblt(
DrawablePtr /*pSrc*/,
DrawablePtr /*pDst*/,
int /*alu*/,
RegionPtr /*prgnDst*/,
DDXPointPtr /*pptSrc*/,
unsigned long /*planemask*/
);
extern RegionPtr afbCopyArea(
DrawablePtr /*pSrcDrawable*/,
DrawablePtr /*pDstDrawable*/,
GCPtr/*pGC*/,
int /*srcx*/,
int /*srcy*/,
int /*width*/,
int /*height*/,
int /*dstx*/,
int /*dsty*/
);
/* afbbltC.c */
extern void afbDoBitbltCopy(
DrawablePtr /*pSrc*/,
DrawablePtr /*pDst*/,
int /*alu*/,
RegionPtr /*prgnDst*/,
DDXPointPtr /*pptSrc*/,
unsigned long /*planemask*/
);
/* afbbltCI.c */
extern void afbDoBitbltCopyInverted(
DrawablePtr /*pSrc*/,
DrawablePtr /*pDst*/,
int /*alu*/,
RegionPtr /*prgnDst*/,
DDXPointPtr /*pptSrc*/,
unsigned long /*planemask*/
);
/* afbbltG.c */
extern void afbDoBitbltGeneral(
DrawablePtr /*pSrc*/,
DrawablePtr /*pDst*/,
int /*alu*/,
RegionPtr /*prgnDst*/,
DDXPointPtr /*pptSrc*/,
unsigned long /*planemask*/
);
/* afbbltO.c */
extern void afbDoBitbltOr(
DrawablePtr /*pSrc*/,
DrawablePtr /*pDst*/,
int /*alu*/,
RegionPtr /*prgnDst*/,
DDXPointPtr /*pptSrc*/,
unsigned long /*planemask*/
);
/* afbbltX.c */
extern void afbDoBitbltXor(
DrawablePtr /*pSrc*/,
DrawablePtr /*pDst*/,
int /*alu*/,
RegionPtr /*prgnDst*/,
DDXPointPtr /*pptSrc*/,
unsigned long /*planemask*/
);
/* afbbres.c */
extern void afbBresS(
PixelType * /*addrl*/,
int /*nlwidth*/,
int /*sizeDst*/,
int /*depthDst*/,
int /*signdx*/,
int /*signdy*/,
int /*axis*/,
int /*x1*/,
int /*y1*/,
int /*e*/,
int /*e1*/,
int /*e2*/,
int /*len*/,
unsigned char * /*rrops*/
);
/* afbbresd.c */
extern void afbBresD(
int * /*pdashIndex*/,
unsigned char * /*pDash*/,
int /*numInDashList*/,
int * /*pdashOffset*/,
int /*isDoubleDash*/,
PixelType * /*addrl*/,
int /*nlwidth*/,
int /*sizeDst*/,
int /*depthDst*/,
int /*signdx*/,
int /*signdy*/,
int /*axis*/,
int /*x1*/,
int /*y1*/,
int /*e*/,
int /*e1*/,
int /*e2*/,
int /*len*/,
unsigned char * /*rrops*/,
unsigned char * /*bgrrops*/
);
/* afbclip.c */
extern RegionPtr afbPixmapToRegion(
PixmapPtr /*pPix*/
);
/* afbcmap.c */
extern int afbListInstalledColormaps(
ScreenPtr /*pScreen*/,
Colormap * /*pmaps*/
);
extern void afbInstallColormap(
ColormapPtr /*pmap*/
);
extern void afbUninstallColormap(
ColormapPtr /*pmap*/
);
extern void afbResolveColor(
unsigned short * /*pred*/,
unsigned short * /*pgreen*/,
unsigned short * /*pblue*/,
VisualPtr /*pVisual*/
);
extern Bool afbInitializeColormap(
ColormapPtr /*pmap*/
);
extern Bool afbInitVisuals(
VisualPtr * /*visualp*/,
DepthPtr * /*depthp*/,
int * /*nvisualp*/,
int * /*ndepthp*/,
int * /*rootDepthp*/,
VisualID * /*defaultVisp*/,
unsigned long /*sizes*/,
int /*bitsPerRGB*/
);
/* afbfillarc.c */
extern void afbPolyFillArcSolid(
DrawablePtr /*pDraw*/,
GCPtr /*pGC*/,
int /*narcs*/,
xArc * /*parcs*/
);
/* afbfillrct.c */
extern void afbPolyFillRect(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*nrectFill*/,
xRectangle * /*prectInit*/
);
/* afbply1rct.c */
extern void afbFillPolygonSolid(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*mode*/,
int /*shape*/,
int /*count*/,
DDXPointPtr /*ptsIn*/
);
/* afbfillsp.c */
extern void afbSolidFS(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*nInit*/,
DDXPointPtr /*pptInit*/,
int * /*pwidthInit*/,
int /*fSorted*/
);
extern void afbStippleFS(
DrawablePtr /*pDrawable*/,
GCPtr/*pGC*/,
int /*nInit*/,
DDXPointPtr /*pptInit*/,
int * /*pwidthInit*/,
int /*fSorted*/
);
extern void afbTileFS(
DrawablePtr /*pDrawable*/,
GCPtr/*pGC*/,
int /*nInit*/,
DDXPointPtr /*pptInit*/,
int * /*pwidthInit*/,
int /*fSorted*/
);
extern void afbUnnaturalTileFS(
DrawablePtr /*pDrawable*/,
GCPtr/*pGC*/,
int /*nInit*/,
DDXPointPtr /*pptInit*/,
int * /*pwidthInit*/,
int /*fSorted*/
);
extern void afbUnnaturalStippleFS(
DrawablePtr /*pDrawable*/,
GCPtr/*pGC*/,
int /*nInit*/,
DDXPointPtr /*pptInit*/,
int * /*pwidthInit*/,
int /*fSorted*/
);
extern void afbOpaqueStippleFS(
DrawablePtr /*pDrawable*/,
GCPtr/*pGC*/,
int /*nInit*/,
DDXPointPtr /*pptInit*/,
int * /*pwidthInit*/,
int /*fSorted*/
);
extern void afbUnnaturalOpaqueStippleFS(
DrawablePtr /*pDrawable*/,
GCPtr/*pGC*/,
int /*nInit*/,
DDXPointPtr /*pptInit*/,
int * /*pwidthInit*/,
int /*fSorted*/
);
/* afbfont.c */
extern Bool afbRealizeFont(
ScreenPtr /*pscr*/,
FontPtr /*pFont*/
);
extern Bool afbUnrealizeFont(
ScreenPtr /*pscr*/,
FontPtr /*pFont*/
);
/* afbgc.c */
extern Bool afbCreateGC(
GCPtr /*pGC*/
);
extern void afbReduceRop(
int /*alu*/,
Pixel /*src*/,
unsigned long /*planemask*/,
int /*depth*/,
unsigned char * /*rrops*/
);
/* afbgetsp.c */
extern void afbGetSpans(
DrawablePtr /*pDrawable*/,
int /*wMax*/,
DDXPointPtr /*ppt*/,
int * /*pwidth*/,
int /*nspans*/,
char * /*pdstStart*/
);
/* afbhrzvert.c */
extern void afbHorzS(
PixelType * /*addrl*/,
int /*nlwidth*/,
int /*sizeDst*/,
int /*depthDst*/,
int /*x1*/,
int /*y1*/,
int /*len*/,
unsigned char * /*rrops*/
);
extern void afbVertS(
PixelType * /*addrl*/,
int /*nlwidth*/,
int /*sizeDst*/,
int /*depthDst*/,
int /*x1*/,
int /*y1*/,
int /*len*/,
unsigned char * /*rrops*/
);
/* afbigbblak.c */
extern void afbImageGlyphBlt (
DrawablePtr /*pDrawable*/,
GCPtr/*pGC*/,
int /*x*/,
int /*y*/,
unsigned int /*nglyph*/,
CharInfoPtr * /*ppci*/,
pointer /*pglyphBase*/
);
/* afbigbwht.c */
/* afbimage.c */
extern void afbPutImage(
DrawablePtr /*dst*/,
GCPtr /*pGC*/,
int /*depth*/,
int /*x*/,
int /*y*/,
int /*w*/,
int /*h*/,
int /*leftPad*/,
int /*format*/,
char * /*pImage*/
);
extern void afbGetImage(
DrawablePtr /*pDrawable*/,
int /*sx*/,
int /*sy*/,
int /*w*/,
int /*h*/,
unsigned int /*format*/,
unsigned long /*planeMask*/,
char * /*pdstLine*/
);
/* afbline.c */
extern void afbLineSS(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*mode*/,
int /*npt*/,
DDXPointPtr /*pptInit*/
);
extern void afbLineSD(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*mode*/,
int /*npt*/,
DDXPointPtr /*pptInit*/
);
/* afbmisc.c */
extern void afbQueryBestSize(
int /*class*/,
unsigned short * /*pwidth*/,
unsigned short * /*pheight*/,
ScreenPtr /*pScreen*/
);
/* afbpntarea.c */
extern void afbSolidFillArea(
DrawablePtr /*pDraw*/,
int /*nbox*/,
BoxPtr /*pbox*/,
unsigned char * /*rrops*/
);
extern void afbStippleAreaPPW(
DrawablePtr /*pDraw*/,
int /*nbox*/,
BoxPtr /*pbox*/,
PixmapPtr /*pstipple*/,
unsigned char * /*rrops*/
);
extern void afbStippleArea(
DrawablePtr /*pDraw*/,
int /*nbox*/,
BoxPtr /*pbox*/,
PixmapPtr /*pstipple*/,
int /*xOff*/,
int /*yOff*/,
unsigned char * /*rrops*/
);
/* afbplygblt.c */
extern void afbPolyGlyphBlt(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*x*/,
int /*y*/,
unsigned int /*nglyph*/,
CharInfoPtr * /*ppci*/,
pointer /*pglyphBase*/
);
/* afbpixmap.c */
extern PixmapPtr afbCreatePixmap(
ScreenPtr /*pScreen*/,
int /*width*/,
int /*height*/,
int /*depth*/,
unsigned /*usage_hint*/
);
extern Bool afbDestroyPixmap(
PixmapPtr /*pPixmap*/
);
extern void afbXRotatePixmap(
PixmapPtr /*pPix*/,
int /*rw*/
);
extern void afbYRotatePixmap(
PixmapPtr /*pPix*/,
int /*rh*/
);
extern void afbCopyRotatePixmap(
PixmapPtr /*psrcPix*/,
PixmapPtr * /*ppdstPix*/,
int /*xrot*/,
int /*yrot*/
);
/* afbpolypnt.c */
extern void afbPolyPoint(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*mode*/,
int /*npt*/,
xPoint * /*pptInit*/
);
/* afbpushpxl.c */
extern void afbPushPixels(
GCPtr /*pGC*/,
PixmapPtr /*pBitMap*/,
DrawablePtr /*pDrawable*/,
int /*dx*/,
int /*dy*/,
int /*xOrg*/,
int /*yOrg*/
);
/* afbscrinit.c */
extern Bool afbScreenInit(
ScreenPtr /*pScreen*/,
pointer /*pbits*/,
int /*xsize*/,
int /*ysize*/,
int /*dpix*/,
int /*dpiy*/,
int /*width*/
);
/* afbseg.c */
extern void afbSegmentSS(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*nseg*/,
xSegment * /*pSeg*/
);
extern void afbSegmentSD(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*nseg*/,
xSegment * /*pSeg*/
);
/* afbsetsp.c */
extern void afbSetSpans(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
char * /*psrc*/,
DDXPointPtr /*ppt*/,
int * /*pwidth*/,
int /*nspans*/,
int /*fSorted*/
);
/* afbtegblt.c */
extern void afbTEGlyphBlt(
DrawablePtr /*pDrawable*/,
GCPtr/*pGC*/,
int /*x*/,
int /*y*/,
unsigned int /*nglyph*/,
CharInfoPtr * /*ppci*/,
pointer /*pglyphBase*/
);
/* afbtileC.c */
extern void afbTileAreaPPWCopy(
DrawablePtr /*pDraw*/,
int /*nbox*/,
BoxPtr /*pbox*/,
int /*alu*/,
PixmapPtr /*ptile*/,
unsigned long /*planemask*/
);
/* afbtileG.c */
extern void afbTileAreaPPWGeneral(
DrawablePtr /*pDraw*/,
int /*nbox*/,
BoxPtr /*pbox*/,
int /*alu*/,
PixmapPtr /*ptile*/,
unsigned long /*planemask*/
);
extern void afbTileAreaCopy(
DrawablePtr /*pDraw*/,
int /*nbox*/,
BoxPtr /*pbox*/,
int /*alu*/,
PixmapPtr /*ptile*/,
int /*xOff*/,
int /*yOff*/,
unsigned long /*planemask*/
);
/* afbtileG.c */
extern void afbTileAreaGeneral(
DrawablePtr /*pDraw*/,
int /*nbox*/,
BoxPtr /*pbox*/,
int /*alu*/,
PixmapPtr /*ptile*/,
int /*xOff*/,
int /*yOff*/,
unsigned long /*planemask*/
);
extern void afbOpaqueStippleAreaPPWCopy(
DrawablePtr /*pDraw*/,
int /*nbox*/,
BoxPtr /*pbox*/,
int /*alu*/,
PixmapPtr /*ptile*/,
unsigned char */*rropsOS*/,
unsigned long /*planemask*/
);
/* afbtileG.c */
extern void afbOpaqueStippleAreaPPWGeneral(
DrawablePtr /*pDraw*/,
int /*nbox*/,
BoxPtr /*pbox*/,
int /*alu*/,
PixmapPtr /*ptile*/,
unsigned char */*rropsOS*/,
unsigned long /*planemask*/
);
extern void afbOpaqueStippleAreaCopy(
DrawablePtr /*pDraw*/,
int /*nbox*/,
BoxPtr /*pbox*/,
int /*alu*/,
PixmapPtr /*ptile*/,
int /*xOff*/,
int /*yOff*/,
unsigned char */*rropsOS*/,
unsigned long /*planemask*/
);
/* afbtileG.c */
extern void afbOpaqueStippleAreaGeneral(
DrawablePtr /*pDraw*/,
int /*nbox*/,
BoxPtr /*pbox*/,
int /*alu*/,
PixmapPtr /*ptile*/,
int /*xOff*/,
int /*yOff*/,
unsigned char */*rropsOS*/,
unsigned long /*planemask*/
);
/* afbwindow.c */
extern Bool afbCreateWindow(
WindowPtr /*pWin*/
);
extern Bool afbDestroyWindow(
WindowPtr /*pWin*/
);
extern Bool afbMapWindow(
WindowPtr /*pWindow*/
);
extern Bool afbPositionWindow(
WindowPtr /*pWin*/,
int /*x*/,
int /*y*/
);
extern Bool afbUnmapWindow(
WindowPtr /*pWindow*/
);
extern void afbCopyWindow(
WindowPtr /*pWin*/,
DDXPointRec /*ptOldOrg*/,
RegionPtr /*prgnSrc*/
);
extern Bool afbChangeWindowAttributes(
WindowPtr /*pWin*/,
unsigned long /*mask*/
);
/* afbzerarc.c */
extern void afbZeroPolyArcSS(
DrawablePtr /*pDraw*/,
GCPtr /*pGC*/,
int /*narcs*/,
xArc * /*parcs*/
);
/*
private field of pixmap
pixmap.devPrivate = (PixelType *)pointer_to_bits
pixmap.devKind = width_of_pixmap_in_bytes
private field of screen
a pixmap, for which we allocate storage. devPrivate is a pointer to
the bits in the hardware framebuffer. note that devKind can be poked to
make the code work for framebuffers that are wider than their
displayable screen (e.g. the early vsII, which displayed 960 pixels
across, but was 1024 in the hardware.)
private field of GC
*/
typedef struct {
unsigned char rrops[AFB_MAX_DEPTH]; /* reduction of rasterop to 1 of 3 */
unsigned char rropOS[AFB_MAX_DEPTH]; /* rop for opaque stipple */
} afbPrivGC;
typedef afbPrivGC *afbPrivGCPtr;
extern DevPrivateKey afbScreenPrivateKey;
extern DevPrivateKey afbGCPrivateKey;
extern DevPrivateKey afbWindowPrivateKey;
#ifdef PIXMAP_PER_WINDOW
extern DevPrivateKey frameWindowPrivateKey;
#endif
#define afbGetGCPrivate(pGC) \
((afbPrivGC *)dixLookupPrivate(&(pGC)->devPrivates, afbGCPrivateKey))
/* Common macros for extracting drawing information */
#define afbGetTypedWidth(pDrawable,wtype)( \
(((pDrawable)->type == DRAWABLE_WINDOW) ? \
(int)(((PixmapPtr)dixLookupPrivate(&(pDrawable)->pScreen->devPrivates, afbScreenPrivateKey)->devKind) : \
(int)(((PixmapPtr)pDrawable)->devKind)) / sizeof (wtype))
#define afbGetByteWidth(pDrawable) afbGetTypedWidth(pDrawable, unsigned char)
#define afbGetPixelWidth(pDrawable) afbGetTypedWidth(pDrawable, PixelType)
#define afbGetTypedWidthAndPointer(pDrawable, width, pointer, wtype, ptype) {\
PixmapPtr _pPix; \
if ((pDrawable)->type == DRAWABLE_WINDOW) \
_pPix = (PixmapPtr)dixLookupPrivate(&(pDrawable)->pScreen->devPrivates, afbScreenPrivateKey); \
else \
_pPix = (PixmapPtr)(pDrawable); \
(pointer) = (ptype *) _pPix->devPrivate.ptr; \
(width) = ((int) _pPix->devKind) / sizeof (wtype); \
}
#define afbGetPixelWidthSizeDepthAndPointer(pDrawable, width, size, dep, pointer) {\
PixmapPtr _pPix; \
if ((pDrawable)->type == DRAWABLE_WINDOW) \
_pPix = (PixmapPtr)dixLookupPrivate(&(pDrawable)->pScreen->devPrivates, afbScreenPrivateKey); \
else \
_pPix = (PixmapPtr)(pDrawable); \
(pointer) = (PixelType *)_pPix->devPrivate.ptr; \
(width) = ((int)_pPix->devKind) / sizeof (PixelType); \
(size) = (width) * _pPix->drawable.height; \
(dep) = _pPix->drawable.depth; (void)(dep); \
}
#define afbGetByteWidthAndPointer(pDrawable, width, pointer) \
afbGetTypedWidthAndPointer(pDrawable, width, pointer, unsigned char, unsigned char)
#define afbGetPixelWidthAndPointer(pDrawable, width, pointer) \
afbGetTypedWidthAndPointer(pDrawable, width, pointer, PixelType, PixelType)
#define afbGetWindowTypedWidthAndPointer(pWin, width, pointer, wtype, ptype) {\
PixmapPtr _pPix = (PixmapPtr)dixLookupPrivate(&(pWin)->drawable.pScreen->devPrivates, afbScreenPrivateKey); \
(pointer) = (ptype *) _pPix->devPrivate.ptr; \
(width) = ((int) _pPix->devKind) / sizeof (wtype); \
}
#define afbGetWindowPixelWidthAndPointer(pWin, width, pointer) \
afbGetWindowTypedWidthAndPointer(pWin, width, pointer, PixelType, PixelType)
#define afbGetWindowByteWidthAndPointer(pWin, width, pointer) \
afbGetWindowTypedWidthAndPointer(pWin, width, pointer, char, char)
/* afb uses the following macros to calculate addresses in drawables.
* To support banked framebuffers, the macros come in four flavors.
* All four collapse into the same definition on unbanked devices.
*
* afbScanlineFoo - calculate address and do bank switching
* afbScanlineFooNoBankSwitch - calculate address, don't bank switch
* afbScanlineFooSrc - calculate address, switch source bank
* afbScanlineFooDst - calculate address, switch destination bank
*/
/* The NoBankSwitch versions are the same for banked and unbanked cases */
#define afbScanlineIncNoBankSwitch(_ptr, _off) _ptr += (_off)
#define afbScanlineOffsetNoBankSwitch(_ptr, _off) ((_ptr) + (_off))
#define afbScanlineDeltaNoBankSwitch(_ptr, _y, _w) \
afbScanlineOffsetNoBankSwitch(_ptr, (_y) * (_w))
#define afbScanlineNoBankSwitch(_ptr, _x, _y, _w) \
afbScanlineOffsetNoBankSwitch(_ptr, (_y) * (_w) + ((_x) >> MFB_PWSH))
#ifdef MFB_LINE_BANK
#include "afblinebank.h" /* get macro definitions from this file */
#else /* !MFB_LINE_BANK - unbanked case */
#define afbScanlineInc(_ptr, _off) afbScanlineIncNoBankSwitch(_ptr, _off)
#define afbScanlineIncSrc(_ptr, _off) afbScanlineInc(_ptr, _off)
#define afbScanlineIncDst(_ptr, _off) afbScanlineInc(_ptr, _off)
#define afbScanlineOffset(_ptr, _off) afbScanlineOffsetNoBankSwitch(_ptr, _off)
#define afbScanlineOffsetSrc(_ptr, _off) afbScanlineOffset(_ptr, _off)
#define afbScanlineOffsetDst(_ptr, _off) afbScanlineOffset(_ptr, _off)
#define afbScanlineSrc(_ptr, _x, _y, _w) afbScanline(_ptr, _x, _y, _w)
#define afbScanlineDst(_ptr, _x, _y, _w) afbScanline(_ptr, _x, _y, _w)
#define afbScanlineDeltaSrc(_ptr, _y, _w) afbScanlineDelta(_ptr, _y, _w)
#define afbScanlineDeltaDst(_ptr, _y, _w) afbScanlineDelta(_ptr, _y, _w)
#endif /* MFB_LINE_BANK */
#define afbScanlineDelta(_ptr, _y, _w) \
afbScanlineOffset(_ptr, (_y) * (_w))
#define afbScanline(_ptr, _x, _y, _w) \
afbScanlineOffset(_ptr, (_y) * (_w) + ((_x) >> MFB_PWSH))
/* precomputed information about each glyph for GlyphBlt code.
this saves recalculating the per glyph information for each box.
*/
typedef struct _afbpos{
int xpos; /* xposition of glyph's origin */
int xchar; /* x position mod 32 */
int leftEdge;
int rightEdge;
int topEdge;
int bottomEdge;
PixelType *pdstBase; /* longword with character origin */
int widthGlyph; /* width in bytes of this glyph */
} afbTEXTPOS;
/* reduced raster ops for afb */
#define RROP_BLACK GXclear
#define RROP_WHITE GXset
#define RROP_NOP GXnoop
#define RROP_INVERT GXinvert
#define RROP_COPY GXcopy
/* macros for afbbitblt.c, afbfillsp.c
these let the code do one switch on the rop per call, rather
than a switch on the rop per item (span or rectangle.)
*/
#define fnCLEAR(src, dst) (0)
#define fnAND(src, dst) (src & dst)
#define fnANDREVERSE(src, dst) (src & ~dst)
#define fnCOPY(src, dst) (src)
#define fnANDINVERTED(src, dst) (~src & dst)
#define fnNOOP(src, dst) (dst)
#define fnXOR(src, dst) (src ^ dst)
#define fnOR(src, dst) (src | dst)
#define fnNOR(src, dst) (~(src | dst))
#define fnEQUIV(src, dst) (~src ^ dst)
#define fnINVERT(src, dst) (~dst)
#define fnORREVERSE(src, dst) (src | ~dst)
#define fnCOPYINVERTED(src, dst) (~src)
#define fnORINVERTED(src, dst) (~src | dst)
#define fnNAND(src, dst) (~(src & dst))
#undef fnSET
#define fnSET(src, dst) (~0)
/* Using a "switch" statement is much faster in most cases
* since the compiler can do a look-up table or multi-way branch
* instruction, depending on the architecture. The result on
* A Sun 3/50 is at least 2.5 times faster, assuming a uniform
* distribution of RasterOp operation types.
*
* However, doing some profiling on a running system reveals
* GXcopy is the operation over 99.5% of the time and
* GXxor is the next most frequent (about .4%), so we make special
* checks for those first.
*
* Note that this requires a change to the "calling sequence"
* since we can't engineer a "switch" statement to have an lvalue.
*/
#undef DoRop
#define DoRop(result, alu, src, dst) \
{ \
if (alu == GXcopy) \
result = fnCOPY (src, dst); \
else if (alu == GXxor) \
result = fnXOR (src, dst); \
else \
switch (alu) { \
case GXclear: \
result = fnCLEAR (src, dst); \
break; \
case GXand: \
result = fnAND (src, dst); \
break; \
case GXandReverse: \
result = fnANDREVERSE (src, dst); \
break; \
case GXandInverted: \
result = fnANDINVERTED (src, dst); \
break; \
default: \
case GXnoop: \
result = fnNOOP (src, dst); \
break; \
case GXor: \
result = fnOR (src, dst); \
break; \
case GXnor: \
result = fnNOR (src, dst); \
break; \
case GXequiv: \
result = fnEQUIV (src, dst); \
break; \
case GXinvert: \
result = fnINVERT (src, dst); \
break; \
case GXorReverse: \
result = fnORREVERSE (src, dst); \
break; \
case GXcopyInverted: \
result = fnCOPYINVERTED (src, dst); \
break; \
case GXorInverted: \
result = fnORINVERTED (src, dst); \
break; \
case GXnand: \
result = fnNAND (src, dst); \
break; \
case GXset: \
result = fnSET (src, dst); \
break; \
} \
}
/* C expression fragments for various operations. These get passed in
* as -D's on the compile command line. See afb/Imakefile. This
* fixes XBUG 6319.
*
* This seems like a good place to point out that afb's use of the
* words black and white is an unfortunate misnomer. In afb code, black
* means zero, and white means one.
*/
#define MFB_OPEQ_WHITE |=
#define MFB_OPEQ_BLACK &=~
#define MFB_OPEQ_INVERT ^=
#define MFB_EQWHOLEWORD_WHITE =~0
#define MFB_EQWHOLEWORD_BLACK =0
#define MFB_EQWHOLEWORD_INVERT ^=~0
#define MFB_OP_WHITE /* nothing */
#define MFB_OP_BLACK ~

343
afb/afbbitblt.c
View File

@ -1,343 +0,0 @@
/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
/***********************************************************
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <stdlib.h>
#include <X11/X.h>
#include <X11/Xprotostr.h>
#include "regionstr.h"
#include "gcstruct.h"
#include "windowstr.h"
#include "pixmapstr.h"
#include "scrnintstr.h"
#include "mi.h"
#include "afb.h"
#include "maskbits.h"
/* CopyArea and CopyPlane for a monchrome frame buffer
clip the source rectangle to the source's available bits. (this
avoids copying unnecessary pieces that will just get exposed anyway.)
this becomes the new shape of the destination.
clip the destination region to the composite clip in the
GC. this requires translating the destination region to (dstx, dsty).
build a list of source points, one for each rectangle in the
destination. this is a simple translation.
go do the multiple rectangle copies
do graphics exposures
*/
/** Optimized for drawing pixmaps into windows, especially when drawing into
** unobscured windows. Calls to the general-purpose region code were
** replaced with rectangle-to-rectangle clipping comparisions. This is
** possible, since the pixmap is a single rectangle. In an unobscured
** window, the destination clip is also a single rectangle, and region
** code can be avoided entirely. This is a big savings, since the region
** code uses XAlloc() and makes many function calls.
**
** In addition, if source is a pixmap, there is no need to call the
** expensive miHandleExposures() routine. Instead, we simply return NULL.
**
** Previously, drawing a pixmap into an unobscured window executed at least
** 8 XAlloc()'s, 30 function calls, and hundreds of lines of code.
**
** Now, the same operation requires no XAlloc()'s, no region function calls,
** and much less overhead. Nice for drawing lots of small pixmaps.
*/
void
afbDoBitblt(DrawablePtr pSrc, DrawablePtr pDst, int alu, RegionPtr prgnDst, DDXPointPtr pptSrc, long unsigned int planemask)
{
switch (alu) {
case GXcopy:
afbDoBitbltCopy(pSrc, pDst, alu, prgnDst, pptSrc, planemask);
break;
case GXxor:
afbDoBitbltXor(pSrc, pDst, alu, prgnDst, pptSrc, planemask);
break;
case GXcopyInverted:
afbDoBitbltCopyInverted(pSrc, pDst, alu, prgnDst, pptSrc, planemask);
break;
case GXor:
afbDoBitbltOr(pSrc, pDst, alu, prgnDst, pptSrc, planemask);
break;
default:
afbDoBitbltGeneral(pSrc, pDst, alu, prgnDst, pptSrc, planemask);
break;
}
}
typedef void (*afb_blit_func)
(DrawablePtr, DrawablePtr, int, RegionPtr, DDXPointPtr, unsigned long);
static RegionPtr
afbBitBlt(register DrawablePtr pSrcDrawable, register DrawablePtr pDstDrawable, register GC *pGC, int srcx, int srcy, int width, int height, int dstx, int dsty, afb_blit_func doBitBlt, long unsigned int planemask)
{
RegionPtr prgnSrcClip = NULL; /* may be a new region, or just a copy */
Bool freeSrcClip = FALSE;
RegionPtr prgnExposed;
RegionRec rgnDst;
DDXPointPtr pptSrc;
register DDXPointPtr ppt;
register BoxPtr pbox;
int i;
register int dx;
register int dy;
xRectangle origSource;
DDXPointRec origDest;
int numRects;
BoxRec fastBox;
int fastClip = 0; /* for fast clipping with pixmap source */
int fastExpose = 0; /* for fast exposures with pixmap source */
origSource.x = srcx;
origSource.y = srcy;
origSource.width = width;
origSource.height = height;
origDest.x = dstx;
origDest.y = dsty;
if ((pSrcDrawable != pDstDrawable) && pSrcDrawable->pScreen->SourceValidate)
(*pSrcDrawable->pScreen->SourceValidate)(pSrcDrawable, srcx, srcy, width,
height);
srcx += pSrcDrawable->x;
srcy += pSrcDrawable->y;
/* clip the source */
if (pSrcDrawable->type == DRAWABLE_PIXMAP)
if ((pSrcDrawable == pDstDrawable) && (pGC->clientClipType == CT_NONE))
prgnSrcClip = pGC->pCompositeClip;
else
fastClip = 1;
else if (pGC->subWindowMode == IncludeInferiors)
if (!((WindowPtr)pSrcDrawable)->parent)
/*
* special case bitblt from root window in
* IncludeInferiors mode; just like from a pixmap
*/
fastClip = 1;
else if ((pSrcDrawable == pDstDrawable) && (pGC->clientClipType == CT_NONE))
prgnSrcClip = pGC->pCompositeClip;
else {
prgnSrcClip = NotClippedByChildren((WindowPtr)pSrcDrawable);
freeSrcClip = TRUE;
}
else
prgnSrcClip = &((WindowPtr)pSrcDrawable)->clipList;
fastBox.x1 = srcx;
fastBox.y1 = srcy;
fastBox.x2 = srcx + width;
fastBox.y2 = srcy + height;
/* Don't create a source region if we are doing a fast clip */
if (fastClip) {
fastExpose = 1;
/*
* clip the source; if regions extend beyond the source size,
* make sure exposure events get sent
*/
if (fastBox.x1 < pSrcDrawable->x) {
fastBox.x1 = pSrcDrawable->x;
fastExpose = 0;
}
if (fastBox.y1 < pSrcDrawable->y) {
fastBox.y1 = pSrcDrawable->y;
fastExpose = 0;
}
if (fastBox.x2 > pSrcDrawable->x + (int)pSrcDrawable->width) {
fastBox.x2 = pSrcDrawable->x + (int)pSrcDrawable->width;
fastExpose = 0;
}
if (fastBox.y2 > pSrcDrawable->y + (int)pSrcDrawable->height) {
fastBox.y2 = pSrcDrawable->y + (int)pSrcDrawable->height;
fastExpose = 0;
}
} else {
REGION_INIT(pGC->pScreen, &rgnDst, &fastBox, 1);
REGION_INTERSECT(pGC->pScreen, &rgnDst, &rgnDst, prgnSrcClip);
}
dstx += pDstDrawable->x;
dsty += pDstDrawable->y;
if (pDstDrawable->type == DRAWABLE_WINDOW)
if (!((WindowPtr)pDstDrawable)->realized) {
if (!fastClip)
REGION_UNINIT(pGC->pScreen, &rgnDst);
if (freeSrcClip)
REGION_DESTROY(pGC->pScreen, prgnSrcClip);
return NULL;
}
dx = srcx - dstx;
dy = srcy - dsty;
/* Translate and clip the dst to the destination composite clip */
if (fastClip) {
RegionPtr cclip;
/* Translate the region directly */
fastBox.x1 -= dx;
fastBox.x2 -= dx;
fastBox.y1 -= dy;
fastBox.y2 -= dy;
/* If the destination composite clip is one rectangle we can
do the clip directly. Otherwise we have to create a full
blown region and call intersect */
cclip = pGC->pCompositeClip;
if (REGION_NUM_RECTS(cclip) == 1) {
BoxPtr pBox = REGION_RECTS(cclip);
if (fastBox.x1 < pBox->x1)
fastBox.x1 = pBox->x1;
if (fastBox.x2 > pBox->x2)
fastBox.x2 = pBox->x2;
if (fastBox.y1 < pBox->y1)
fastBox.y1 = pBox->y1;
if (fastBox.y2 > pBox->y2)
fastBox.y2 = pBox->y2;
/* Check to see if the region is empty */
if (fastBox.x1 >= fastBox.x2 || fastBox.y1 >= fastBox.y2) {
REGION_NULL(pGC->pScreen, &rgnDst);
} else {
REGION_INIT(pGC->pScreen, &rgnDst, &fastBox, 1);
}
} else {
/* We must turn off fastClip now, since we must create
a full blown region. It is intersected with the
composite clip below. */
fastClip = 0;
REGION_INIT(pGC->pScreen, &rgnDst, &fastBox,1);
}
} else
REGION_TRANSLATE(pGC->pScreen, &rgnDst, -dx, -dy);
if (!fastClip) {
REGION_INTERSECT(pGC->pScreen, &rgnDst, &rgnDst,
pGC->pCompositeClip);
}
/* Do bit blitting */
numRects = REGION_NUM_RECTS(&rgnDst);
if (numRects && width && height) {
if(!(pptSrc = (DDXPointPtr)xalloc(numRects *
sizeof(DDXPointRec)))) {
REGION_UNINIT(pGC->pScreen, &rgnDst);
if (freeSrcClip)
REGION_DESTROY(pGC->pScreen, prgnSrcClip);
return NULL;
}
pbox = REGION_RECTS(&rgnDst);
ppt = pptSrc;
for (i = numRects; --i >= 0; pbox++, ppt++) {
ppt->x = pbox->x1 + dx;
ppt->y = pbox->y1 + dy;
}
(*doBitBlt)(pSrcDrawable, pDstDrawable, pGC->alu, &rgnDst, pptSrc,
planemask);
xfree(pptSrc);
}
prgnExposed = NULL;
if (pGC->fExpose) {
/* Pixmap sources generate a NoExposed (we return NULL to do this) */
if (!fastExpose)
prgnExposed = miHandleExposures(pSrcDrawable, pDstDrawable, pGC,
origSource.x, origSource.y,
(int)origSource.width,
(int)origSource.height, origDest.x,
origDest.y, (unsigned long)0);
}
REGION_UNINIT(pGC->pScreen, &rgnDst);
if (freeSrcClip)
REGION_DESTROY(pGC->pScreen, prgnSrcClip);
return prgnExposed;
}
RegionPtr
afbCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GC *pGC, int srcx, int srcy, int width, int height, int dstx, int dsty)
{
afb_blit_func doBitBlt;
switch (pGC->alu) {
case GXcopy:
doBitBlt = afbDoBitbltCopy;
break;
case GXxor:
doBitBlt = afbDoBitbltXor;
break;
case GXcopyInverted:
doBitBlt = afbDoBitbltCopyInverted;
break;
case GXor:
doBitBlt = afbDoBitbltOr;
break;
default:
doBitBlt = afbDoBitbltGeneral;
break;
}
return(afbBitBlt(pSrcDrawable, pDstDrawable, pGC, srcx, srcy,
width, height, dstx, dsty, doBitBlt, pGC->planemask));
}

563
afb/afbblt.c
View File

@ -1,563 +0,0 @@
/*
* afb copy area
*/
/*
Copyright (c) 1989 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Author: Keith Packard
*/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <stdlib.h>
#include <X11/X.h>
#include <X11/Xmd.h>
#include <X11/Xproto.h>
#include "afb.h"
#include "gcstruct.h"
#include "windowstr.h"
#include "scrnintstr.h"
#include "pixmapstr.h"
#include "regionstr.h"
#include "maskbits.h"
#include "fastblt.h"
#include "mergerop.h"
void
MROP_NAME(afbDoBitblt)(pSrc, pDst, alu, prgnDst, pptSrc, planemask)
DrawablePtr pSrc, pDst;
int alu;
RegionPtr prgnDst;
DDXPointPtr pptSrc;
unsigned long planemask;
{
PixelType *psrcBase, *pdstBase; /* start of src and dst bitmaps */
int widthSrc, widthDst; /* add to get to same position in next line */
int sizeSrc, sizeDst;
BoxPtr pbox;
int nbox;
BoxPtr pboxTmp, pboxNext, pboxBase, pboxNew1, pboxNew2;
/* temporaries for shuffling rectangles */
DDXPointPtr pptTmp, pptNew1, pptNew2;
/* shuffling boxes entails shuffling the
source points too */
int w, h;
int xdir; /* 1 = left right, -1 = right left/ */
int ydir; /* 1 = top down, -1 = bottom up */
PixelType *psrcLine, *pdstLine;
/* pointers to line with current src and dst */
register PixelType *psrc; /* pointer to current src longword */
register PixelType *pdst; /* pointer to current dst longword */
MROP_DECLARE_REG()
/* following used for looping through a line */
PixelType startmask, endmask; /* masks for writing ends of dst */
int nlMiddle; /* whole longwords in dst */
int xoffSrc, xoffDst;
register int leftShift, rightShift;
register PixelType bits;
register PixelType bits1;
register int nl; /* temp copy of nlMiddle */
int careful;
int depthSrc;
int depthDst;
MROP_INITIALIZE(alu,0);
afbGetPixelWidthSizeDepthAndPointer(pSrc, widthSrc, sizeSrc, depthSrc,
psrcBase);
afbGetPixelWidthSizeDepthAndPointer(pDst, widthDst, sizeDst, depthDst,
pdstBase);
/* Special case where depth of dest pixmap is 1 but source pixmap isn't
* Used for GetImage to copy a plane from a source pixmap to a particular
* dest pixmap plane.
* Note: planemask should have only one bit set or several planes from
* the source will be copied to the same dest plane.
*/
if (depthDst == 1 && depthDst != depthSrc)
sizeDst = 0;
/* XXX we have to err on the side of safety when both are windows,
* because we don't know if IncludeInferiors is being used.
*/
careful = ((pSrc == pDst) ||
((pSrc->type == DRAWABLE_WINDOW) &&
(pDst->type == DRAWABLE_WINDOW)));
pbox = REGION_RECTS(prgnDst);
nbox = REGION_NUM_RECTS(prgnDst);
pboxNew1 = NULL;
pptNew1 = NULL;
pboxNew2 = NULL;
pptNew2 = NULL;
if (careful && (pptSrc->y < pbox->y1)) {
/* walk source botttom to top */
ydir = -1;
widthSrc = -widthSrc;
widthDst = -widthDst;
if (nbox > 1) {
/* keep ordering in each band, reverse order of bands */
pboxNew1 = (BoxPtr)xalloc(sizeof(BoxRec)*nbox);
if(!pboxNew1)
return;
pptNew1 = (DDXPointPtr)xalloc(sizeof(DDXPointRec)*nbox);
if(!pptNew1) {
xfree(pboxNew1);
return;
}
pboxBase = pboxNext = pbox+nbox-1;
while (pboxBase >= pbox) {
while ((pboxNext >= pbox) &&
(pboxBase->y1 == pboxNext->y1))
pboxNext--;
pboxTmp = pboxNext+1;
pptTmp = pptSrc + (pboxTmp - pbox);
while (pboxTmp <= pboxBase) {
*pboxNew1++ = *pboxTmp++;
*pptNew1++ = *pptTmp++;
}
pboxBase = pboxNext;
}
pboxNew1 -= nbox;
pbox = pboxNew1;
pptNew1 -= nbox;
pptSrc = pptNew1;
}
} else {
/* walk source top to bottom */
ydir = 1;
}
if (careful && (pptSrc->x < pbox->x1)) {
/* walk source right to left */
xdir = -1;
if (nbox > 1) {
/* reverse order of rects in each band */
pboxNew2 = (BoxPtr)xalloc(sizeof(BoxRec) * nbox);
pptNew2 = (DDXPointPtr)xalloc(sizeof(DDXPointRec) * nbox);
if(!pboxNew2 || !pptNew2) {
if (pptNew2)
xfree(pptNew2);
if (pboxNew2)
xfree(pboxNew2);
if (pboxNew1) {
xfree(pptNew1);
xfree(pboxNew1);
}
return;
}
pboxBase = pboxNext = pbox;
while (pboxBase < pbox+nbox) {
while ((pboxNext < pbox+nbox) && (pboxNext->y1 == pboxBase->y1))
pboxNext++;
pboxTmp = pboxNext;
pptTmp = pptSrc + (pboxTmp - pbox);
while (pboxTmp != pboxBase) {
*pboxNew2++ = *--pboxTmp;
*pptNew2++ = *--pptTmp;
}
pboxBase = pboxNext;
}
pboxNew2 -= nbox;
pbox = pboxNew2;
pptNew2 -= nbox;
pptSrc = pptNew2;
}
} else {
/* walk source left to right */
xdir = 1;
}
while(nbox--) {
int d;
for (d = 0; d < depthSrc; d++) {
PixelType *psrcB;
PixelType *pdstB;
if (!(planemask & (1 << d)))
continue;
psrcB = psrcBase + sizeSrc * d; /* @@@ NEXT PLANE @@@ */
pdstB = pdstBase + sizeDst * d; /* @@@ NEXT PLANE @@@ */
w = pbox->x2 - pbox->x1;
h = pbox->y2 - pbox->y1;
if (ydir == -1) { /* start at last scanline of rectangle */
psrcLine = afbScanlineDeltaSrc(psrcB, -(pptSrc->y+h-1), widthSrc);
pdstLine = afbScanlineDeltaDst(pdstB, -(pbox->y2-1), widthDst);
} else { /* start at first scanline */
psrcLine = afbScanlineDeltaSrc(psrcB, pptSrc->y, widthSrc);
pdstLine = afbScanlineDeltaDst(pdstB, pbox->y1, widthDst);
}
if ((pbox->x1 & PIM) + w <= PPW) {
maskpartialbits (pbox->x1, w, startmask);
endmask = 0;
nlMiddle = 0;
} else {
maskbits(pbox->x1, w, startmask, endmask, nlMiddle);
}
if (xdir == 1) {
xoffSrc = pptSrc->x & PIM;
xoffDst = pbox->x1 & PIM;
pdstLine += (pbox->x1 >> PWSH);
psrcLine += (pptSrc->x >> PWSH);
#ifdef DO_UNALIGNED_BITBLT
nl = xoffSrc - xoffDst;
psrcLine = (PixelType *)(((unsigned char *) psrcLine) + nl);
#else
if (xoffSrc == xoffDst)
#endif
{
while (h--) {
psrc = psrcLine;
pdst = pdstLine;
if (startmask) {
*pdst = MROP_MASK(*psrc, *pdst, startmask);
psrc++;
pdst++;
}
nl = nlMiddle;
#ifdef LARGE_INSTRUCTION_CACHE
#ifdef FAST_CONSTANT_OFFSET_MODE
psrc += nl & (UNROLL-1);
pdst += nl & (UNROLL-1);
#define BodyOdd(n) pdst[-n] = MROP_SOLID (psrc[-n], pdst[-n]);
#define BodyEven(n) pdst[-n] = MROP_SOLID (psrc[-n], pdst[-n]);
#define LoopReset \
pdst += UNROLL; \
psrc += UNROLL;
#else
#define BodyOdd(n) *pdst = MROP_SOLID (*psrc, *pdst); pdst++; psrc++;
#define BodyEven(n) BodyOdd(n)
#define LoopReset ;
#endif
PackedLoop
#undef BodyOdd
#undef BodyEven
#undef LoopReset
#else
#ifdef NOTDEF
/* you'd think this would be faster --
* a single instruction instead of 6
* but measurements show it to be ~15% slower
*/
while ((nl -= 6) >= 0) {
asm ("moveml %1+,#0x0c0f;moveml#0x0c0f,%0"
: "=m" (*(char *)pdst)
: "m" (*(char *)psrc)
: "d0", "d1", "d2", "d3",
"a2", "a3");
pdst += 6;
}
nl += 6;
while (nl--)
*pdst++ = *psrc++;
#endif
DuffL(nl, label1,
*pdst = MROP_SOLID (*psrc, *pdst);
pdst++; psrc++;)
#endif
if (endmask)
*pdst = MROP_MASK(*psrc, *pdst, endmask);
afbScanlineIncDst(pdstLine, widthDst);
afbScanlineIncSrc(psrcLine, widthSrc);
}
}
#ifndef DO_UNALIGNED_BITBLT
else {
if (xoffSrc > xoffDst) {
leftShift = (xoffSrc - xoffDst);
rightShift = PPW - leftShift;
} else {
rightShift = (xoffDst - xoffSrc);
leftShift = PPW - rightShift;
}
while (h--) {
psrc = psrcLine;
pdst = pdstLine;
bits = 0;
if (xoffSrc > xoffDst)
bits = *psrc++;
if (startmask) {
bits1 = BitLeft(bits,leftShift);
bits = *psrc++;
bits1 |= BitRight(bits,rightShift);
*pdst = MROP_MASK(bits1, *pdst, startmask);
pdst++;
}
nl = nlMiddle;
#ifdef LARGE_INSTRUCTION_CACHE
bits1 = bits;
#ifdef FAST_CONSTANT_OFFSET_MODE
psrc += nl & (UNROLL-1);
pdst += nl & (UNROLL-1);
#define BodyOdd(n) \
bits = psrc[-n]; \
pdst[-n] = MROP_SOLID(BitLeft(bits1, leftShift) | BitRight(bits, rightShift), pdst[-n]);
#define BodyEven(n) \
bits1 = psrc[-n]; \
pdst[-n] = MROP_SOLID(BitLeft(bits, leftShift) | BitRight(bits1, rightShift), pdst[-n]);
#define LoopReset \
pdst += UNROLL; \
psrc += UNROLL;
#else
#define BodyOdd(n) \
bits = *psrc++; \
*pdst = MROP_SOLID(BitLeft(bits1, leftShift) | BitRight(bits, rightShift), *pdst); \
pdst++;
#define BodyEven(n) \
bits1 = *psrc++; \
*pdst = MROP_SOLID(BitLeft(bits, leftShift) | BitRight(bits1, rightShift), *pdst); \
pdst++;
#define LoopReset ;
#endif /* !FAST_CONSTANT_OFFSET_MODE */
PackedLoop
#undef BodyOdd
#undef BodyEven
#undef LoopReset
#else
DuffL(nl,label2,
bits1 = BitLeft(bits, leftShift);
bits = *psrc++;
*pdst = MROP_SOLID (bits1 | BitRight(bits, rightShift), *pdst);
pdst++;
)
#endif
if (endmask) {
bits1 = BitLeft(bits, leftShift);
if (BitLeft(endmask, rightShift)) {
bits = *psrc;
bits1 |= BitRight(bits, rightShift);
}
*pdst = MROP_MASK (bits1, *pdst, endmask);
}
afbScanlineIncDst(pdstLine, widthDst);
afbScanlineIncSrc(psrcLine, widthSrc);
}
}
#endif /* DO_UNALIGNED_BITBLT */
} else { /* xdir == -1 */
xoffSrc = (pptSrc->x + w - 1) & PIM;
xoffDst = (pbox->x2 - 1) & PIM;
pdstLine += ((pbox->x2-1) >> PWSH) + 1;
psrcLine += ((pptSrc->x+w - 1) >> PWSH) + 1;
#ifdef DO_UNALIGNED_BITBLT
nl = xoffSrc - xoffDst;
psrcLine = (PixelType *)
(((unsigned char *) psrcLine) + nl);
#else
if (xoffSrc == xoffDst)
#endif
{
while (h--) {
psrc = psrcLine;
pdst = pdstLine;
if (endmask) {
pdst--;
psrc--;
*pdst = MROP_MASK (*psrc, *pdst, endmask);
}
nl = nlMiddle;
#ifdef LARGE_INSTRUCTION_CACHE
#ifdef FAST_CONSTANT_OFFSET_MODE
psrc -= nl & (UNROLL - 1);
pdst -= nl & (UNROLL - 1);
#define BodyOdd(n) pdst[n-1] = MROP_SOLID (psrc[n-1], pdst[n-1]);
#define BodyEven(n) BodyOdd(n)
#define LoopReset \
pdst -= UNROLL;\
psrc -= UNROLL;
#else
#define BodyOdd(n) --pdst; --psrc; *pdst = MROP_SOLID(*psrc, *pdst);
#define BodyEven(n) BodyOdd(n)
#define LoopReset ;
#endif
PackedLoop
#undef BodyOdd
#undef BodyEven
#undef LoopReset
#else
DuffL(nl,label3,
--pdst; --psrc; *pdst = MROP_SOLID (*psrc, *pdst);)
#endif
if (startmask) {
--pdst;
--psrc;
*pdst = MROP_MASK(*psrc, *pdst, startmask);
}
afbScanlineIncDst(pdstLine, widthDst);
afbScanlineIncSrc(psrcLine, widthSrc);
}
}
#ifndef DO_UNALIGNED_BITBLT
else {
if (xoffDst > xoffSrc) {
rightShift = (xoffDst - xoffSrc);
leftShift = PPW - rightShift;
} else {
leftShift = (xoffSrc - xoffDst);
rightShift = PPW - leftShift;
}
while (h--) {
psrc = psrcLine;
pdst = pdstLine;
bits = 0;
if (xoffDst > xoffSrc)
bits = *--psrc;
if (endmask) {
bits1 = BitRight(bits, rightShift);
bits = *--psrc;
bits1 |= BitLeft(bits, leftShift);
pdst--;
*pdst = MROP_MASK(bits1, *pdst, endmask);
}
nl = nlMiddle;
#ifdef LARGE_INSTRUCTION_CACHE
bits1 = bits;
#ifdef FAST_CONSTANT_OFFSET_MODE
psrc -= nl & (UNROLL - 1);
pdst -= nl & (UNROLL - 1);
#define BodyOdd(n) \
bits = psrc[n-1]; \
pdst[n-1] = MROP_SOLID(BitRight(bits1, rightShift) | BitLeft(bits, leftShift),pdst[n-1]);
#define BodyEven(n) \
bits1 = psrc[n-1]; \
pdst[n-1] = MROP_SOLID(BitRight(bits, rightShift) | BitLeft(bits1, leftShift),pdst[n-1]);
#define LoopReset \
pdst -= UNROLL; \
psrc -= UNROLL;
#else
#define BodyOdd(n) \
bits = *--psrc; --pdst; \
*pdst = MROP_SOLID(BitRight(bits1, rightShift) | BitLeft(bits, leftShift),*pdst);
#define BodyEven(n) \
bits1 = *--psrc; --pdst; \
*pdst = MROP_SOLID(BitRight(bits, rightShift) | BitLeft(bits1, leftShift),*pdst);
#define LoopReset ;
#endif
PackedLoop
#undef BodyOdd
#undef BodyEven
#undef LoopReset
#else
DuffL(nl, label4,
bits1 = BitRight(bits, rightShift);
bits = *--psrc;
--pdst;
*pdst = MROP_SOLID(bits1 | BitLeft(bits, leftShift),*pdst);
)
#endif
if (startmask) {
bits1 = BitRight(bits, rightShift);
if (BitRight (startmask, leftShift)) {
bits = *--psrc;
bits1 |= BitLeft(bits, leftShift);
}
--pdst;
*pdst = MROP_MASK(bits1, *pdst, startmask);
}
afbScanlineIncDst(pdstLine, widthDst);
afbScanlineIncSrc(psrcLine, widthSrc);
}
}
#endif
}
}
pbox++;
pptSrc++;
}
if (pboxNew2) {
xfree(pptNew2);
xfree(pboxNew2);
}
if (pboxNew1) {
xfree(pptNew1);
xfree(pboxNew1);
}
}

323
afb/afbbres.c
View File

@ -1,323 +0,0 @@
/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
/***********************************************************
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <X11/X.h>
#include "misc.h"
#include "afb.h"
#include "maskbits.h"
#include "miline.h"
/* Solid bresenham line */
/* NOTES
e2 is used less often than e1, so it's not in a register
*/
void
afbBresS(addrlbase, nlwidth, sizeDst, depthDst, signdx, signdy, axis, x1, y1,
e, e1, e2, len, rrops)
PixelType *addrlbase; /* pointer to base of bitmap */
int nlwidth; /* width in longwords of bitmap */
int sizeDst;
int depthDst;
int signdx, signdy; /* signs of directions */
int axis; /* major axis (Y_AXIS or X_AXIS) */
int x1, y1; /* initial point */
register int e; /* error accumulator */
register int e1; /* bresenham increments */
int e2;
int len; /* length of line */
unsigned char *rrops;
{
register int yinc; /* increment to next scanline, in bytes */
register PixelType *addrl; /* bitmask long pointer */
register PixelType bit; /* current bit being set/cleared/etc. */
PixelType leftbit = mfbGetmask(0); /* leftmost bit to process in new word */
PixelType rightbit = mfbGetmask(PPW-1); /* rightmost bit to process in new word */
register int e3 = e2-e1;
PixelType tmp;
int saveE;
int saveLen;
int d;
/* point to longword containing first point */
yinc = signdy * nlwidth;
e = e-e1; /* to make looping easier */
if (!len)
return;
saveLen = len;
saveE = e;
for (d = 0; d < depthDst; d++) {
addrl = afbScanline(addrlbase, x1, y1, nlwidth);
addrlbase += sizeDst; /* @@@ NEXT PLANE @@@ */
len = saveLen;
e = saveE;
bit = mfbGetmask(x1 & PIM);
switch (rrops[d]) {
case RROP_BLACK:
if (axis == X_AXIS) {
if (signdx > 0) {
tmp = *addrl;
for (;;) {
tmp &= ~bit;
if (!--len)
break;
bit = SCRRIGHT(bit,1);
e += e1;
if (e >= 0) {
*addrl = tmp;
afbScanlineInc(addrl, yinc);
e += e3;
if (!bit) {
bit = leftbit;
addrl ++;
}
tmp = *addrl;
} else if (!bit) {
*addrl = tmp;
bit = leftbit;
addrl ++;
tmp = *addrl;
}
}
*addrl = tmp;
} else {
tmp = *addrl;
for (;;) {
tmp &= ~bit;
if (!--len)
break;
e += e1;
bit = SCRLEFT(bit,1);
if (e >= 0) {
*addrl = tmp;
afbScanlineInc(addrl, yinc);
e += e3;
if (!bit) {
bit = rightbit;
addrl --;
}
tmp = *addrl;
} else if (!bit) {
*addrl = tmp;
bit = rightbit;
addrl --;
tmp = *addrl;
}
}
*addrl = tmp;
}
} /* if X_AXIS */ else {
if (signdx > 0) {
while(len--) {
*addrl &= ~bit;
e += e1;
if (e >= 0) {
bit = SCRRIGHT(bit,1);
if (!bit) { bit = leftbit;addrl ++; }
e += e3;
}
afbScanlineInc(addrl, yinc);
}
} else {
while(len--) {
*addrl &= ~bit;
e += e1;
if (e >= 0) {
bit = SCRLEFT(bit,1);
if (!bit) { bit = rightbit;addrl --; }
e += e3;
}
afbScanlineInc(addrl, yinc);
}
}
} /* else Y_AXIS */
break;
case RROP_WHITE:
if (axis == X_AXIS) {
if (signdx > 0) {
tmp = *addrl;
for (;;) {
tmp |= bit;
if (!--len)
break;
e += e1;
bit = SCRRIGHT(bit,1);
if (e >= 0) {
*addrl = tmp;
afbScanlineInc(addrl, yinc);
e += e3;
if (!bit) {
bit = leftbit;
addrl ++;
}
tmp = *addrl;
} else if (!bit) {
*addrl = tmp;
bit = leftbit;
addrl ++;
tmp = *addrl;
}
}
*addrl = tmp;
} else {
tmp = *addrl;
for (;;) {
tmp |= bit;
if (!--len)
break;
e += e1;
bit = SCRLEFT(bit,1);
if (e >= 0) {
*addrl = tmp;
afbScanlineInc(addrl, yinc);
e += e3;
if (!bit) {
bit = rightbit;
addrl --;
}
tmp = *addrl;
} else if (!bit) {
*addrl = tmp;
bit = rightbit;
addrl --;
tmp = *addrl;
}
}
*addrl = tmp;
}
} /* if X_AXIS */ else {
if (signdx > 0) {
while(len--) {
*addrl |= bit;
e += e1;
if (e >= 0) {
bit = SCRRIGHT(bit,1);
if (!bit) { bit = leftbit;addrl ++; }
e += e3;
}
afbScanlineInc(addrl, yinc);
}
} else {
while(len--) {
*addrl |= bit;
e += e1;
if (e >= 0) {
bit = SCRLEFT(bit,1);
if (!bit) { bit = rightbit;addrl --; }
e += e3;
}
afbScanlineInc(addrl, yinc);
}
}
} /* else Y_AXIS */
break;
case RROP_INVERT:
if (axis == X_AXIS) {
if (signdx > 0) {
while(len--) {
*addrl ^= bit;
e += e1;
if (e >= 0) {
afbScanlineInc(addrl, yinc);
e += e3;
}
bit = SCRRIGHT(bit,1);
if (!bit) { bit = leftbit;addrl ++; }
}
} else {
while(len--) {
*addrl ^= bit;
e += e1;
if (e >= 0) {
afbScanlineInc(addrl, yinc);
e += e3;
}
bit = SCRLEFT(bit,1);
if (!bit) { bit = rightbit;addrl --; }
}
}
} /* if X_AXIS */ else {
if (signdx > 0) {
while(len--) {
*addrl ^= bit;
e += e1;
if (e >= 0) {
bit = SCRRIGHT(bit,1);
if (!bit) { bit = leftbit;addrl ++; }
e += e3;
}
afbScanlineInc(addrl, yinc);
}
} else {
while(len--) {
*addrl ^= bit;
e += e1;
if (e >= 0) {
bit = SCRLEFT(bit,1);
if (!bit) { bit = rightbit; addrl --; }
e += e3;
}
afbScanlineInc(addrl, yinc);
}
}
} /* else Y_AXIS */
} /* switch */
} /* for (d = ... ) */
}

214
afb/afbbresd.c
View File

@ -1,214 +0,0 @@
/***********************************************************
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <X11/X.h>
#include "misc.h"
#include "afb.h"
#include "maskbits.h"
#include "miline.h"
/* Dashed bresenham line */
#define StepDash\
if (!--dashRemaining) { \
if (++ dashIndex == numInDashList) \
dashIndex = 0; \
dashRemaining = pDash[dashIndex]; \
rop = fgrop; \
if (dashIndex & 1) \
rop = bgrop; \
}
void
afbBresD(pdashIndex, pDash, numInDashList, pdashOffset, isDoubleDash,
addrlbase, nlwidth, sizeDst, depthDst,
signdx, signdy, axis, x1, y1, e, e1, e2, len, rrops, bgrrops)
int *pdashIndex; /* current dash */
unsigned char *pDash; /* dash list */
int numInDashList; /* total length of dash list */
int *pdashOffset; /* offset into current dash */
int isDoubleDash;
PixelType *addrlbase; /* pointer to base of bitmap */
int nlwidth; /* width in longwords of bitmap */
int sizeDst;
int depthDst;
int signdx, signdy; /* signs of directions */
int axis; /* major axis (Y_AXIS or X_AXIS) */
int x1, y1; /* initial point */
register int e; /* error accumulator */
register int e1; /* bresenham increments */
int e2;
int len; /* length of line */
unsigned char *rrops;
unsigned char *bgrrops;
{
register int yinc; /* increment to next scanline, in bytes */
register PixelType *addrl;
register int e3 = e2-e1;
register unsigned long bit;
PixelType leftbit = mfbGetmask(0); /* leftmost bit to process in new word */
PixelType rightbit = mfbGetmask(PPW-1); /* rightmost bit to process in new word */
int dashIndex;
int dashOffset;
int dashRemaining;
int rop;
int fgrop;
int bgrop;
int saveE;
int saveLen;
int d;
dashOffset = *pdashOffset;
dashIndex = *pdashIndex;
dashRemaining = pDash[dashIndex] - dashOffset;
/* point to longword containing first point */
yinc = signdy * nlwidth;
e = e-e1; /* to make looping easier */
saveE = e;
saveLen = len;
for (d = 0; d < depthDst; d++) {
addrl = afbScanline(addrlbase, x1, y1, nlwidth);
addrlbase += sizeDst; /* @@@ NEXT PLANE @@@ */
fgrop = rrops[d];
bgrop = bgrrops[d];
e = saveE;
len = saveLen;
bit = mfbGetmask(x1 & PIM);
rop = fgrop;
if (!isDoubleDash)
bgrop = -1;
if (dashIndex & 1)
rop = bgrop;
if (axis == X_AXIS) {
if (signdx > 0) {
while(len--) {
if (rop == RROP_BLACK)
*addrl &= ~bit;
else if (rop == RROP_WHITE)
*addrl |= bit;
else if (rop == RROP_INVERT)
*addrl ^= bit;
e += e1;
if (e >= 0) {
afbScanlineInc(addrl, yinc);
e += e3;
}
bit = SCRRIGHT(bit,1);
if (!bit) { bit = leftbit;addrl ++; }
StepDash
}
} else {
while(len--) {
if (rop == RROP_BLACK)
*addrl &= ~bit;
else if (rop == RROP_WHITE)
*addrl |= bit;
else if (rop == RROP_INVERT)
*addrl ^= bit;
e += e1;
if (e >= 0) {
afbScanlineInc(addrl, yinc);
e += e3;
}
bit = SCRLEFT(bit,1);
if (!bit) { bit = rightbit;addrl --; }
StepDash
}
}
} /* if X_AXIS */ else {
if (signdx > 0) {
while(len--) {
if (rop == RROP_BLACK)
*addrl &= ~bit;
else if (rop == RROP_WHITE)
*addrl |= bit;
else if (rop == RROP_INVERT)
*addrl ^= bit;
e += e1;
if (e >= 0) {
bit = SCRRIGHT(bit,1);
if (!bit) { bit = leftbit;addrl ++; }
e += e3;
}
afbScanlineInc(addrl, yinc);
StepDash
}
} else {
while(len--) {
if (rop == RROP_BLACK)
*addrl &= ~bit;
else if (rop == RROP_WHITE)
*addrl |= bit;
else if (rop == RROP_INVERT)
*addrl ^= bit;
e += e1;
if (e >= 0) {
bit = SCRLEFT(bit,1);
if (!bit) { bit = rightbit;addrl --; }
e += e3;
}
afbScanlineInc(addrl, yinc);
StepDash
}
}
} /* else Y_AXIS */
} /* for (d = ...) */
*pdashIndex = dashIndex;
*pdashOffset = pDash[dashIndex] - dashRemaining;
}

248
afb/afbclip.c
View File

@ -1,248 +0,0 @@
/***********************************************************
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <stdlib.h>
#include <X11/X.h>
#include "regionstr.h"
#include "pixmapstr.h"
#include "scrnintstr.h"
#include "gc.h"
#include "maskbits.h"
#include "mi.h"
#include "afb.h"
#define ADDRECT(reg,r,fr,rx1,ry1,rx2,ry2) \
if (((rx1) < (rx2)) && ((ry1) < (ry2)) && \
(!((reg)->data->numRects && \
((r-1)->y1 == (ry1)) && \
((r-1)->y2 == (ry2)) && \
((r-1)->x1 <= (rx1)) && \
((r-1)->x2 >= (rx2))))) \
{ \
if ((reg)->data->numRects == (reg)->data->size) \
{ \
miRectAlloc(reg, 1); \
fr = REGION_BOXPTR(reg); \
r = fr + (reg)->data->numRects; \
} \
r->x1 = (rx1); \
r->y1 = (ry1); \
r->x2 = (rx2); \
r->y2 = (ry2); \
(reg)->data->numRects++; \
if(r->x1 < (reg)->extents.x1) \
(reg)->extents.x1 = r->x1; \
if(r->x2 > (reg)->extents.x2) \
(reg)->extents.x2 = r->x2; \
r++; \
}
/* Convert bitmap clip mask into clipping region.
* First, goes through each line and makes boxes by noting the transitions
* from 0 to 1 and 1 to 0.
* Then it coalesces the current line with the previous if they have boxes
* at the same X coordinates.
*/
RegionPtr
afbPixmapToRegion(pPix)
PixmapPtr pPix;
{
register RegionPtr pReg;
register PixelType *pw, w;
register int ib;
int width, h, base, rx1 = 0, crects;
PixelType *pwLineEnd;
int irectPrevStart, irectLineStart;
register BoxPtr prectO, prectN;
BoxPtr FirstRect, rects, prectLineStart;
Bool fInBox, fSame;
register PixelType mask0 = mfbGetmask(0);
PixelType *pwLine;
int nWidth;
pReg = REGION_CREATE(pPix->drawable.pScreen, NULL, 1);
if(!pReg)
return NullRegion;
FirstRect = REGION_BOXPTR(pReg);
rects = FirstRect;
pwLine = (PixelType *) pPix->devPrivate.ptr;
nWidth = pPix->devKind / PGSZB;
width = pPix->drawable.width;
pReg->extents.x1 = width - 1;
pReg->extents.x2 = 0;
irectPrevStart = -1;
for(h = 0; h < pPix->drawable.height; h++) {
pw = pwLine;
pwLine += nWidth;
irectLineStart = rects - FirstRect;
/* If the Screen left most bit of the word is set, we're starting in
* a box */
if(*pw & mask0) {
fInBox = TRUE;
rx1 = 0;
}
else
fInBox = FALSE;
/* Process all words which are fully in the pixmap */
pwLineEnd = pw + (width >> PWSH);
for (base = 0; pw < pwLineEnd; base += PPW) {
w = *pw++;
if (fInBox) {
if (!~w)
continue;
} else {
if (!w)
continue;
}
for(ib = 0; ib < PPW; ib++) {
/* If the Screen left most bit of the word is set, we're
* starting a box */
if(w & mask0) {
if(!fInBox) {
rx1 = base + ib;
/* start new box */
fInBox = TRUE;
}
} else {
if(fInBox) {
/* end box */
ADDRECT(pReg, rects, FirstRect,
rx1, h, base + ib, h + 1);
fInBox = FALSE;
}
}
/* Shift the word VISUALLY left one. */
w = SCRLEFT(w, 1);
}
}
if(width & PIM) {
/* Process final partial word on line */
w = *pw++;
for(ib = 0; ib < (width & PIM); ib++) {
/* If the Screen left most bit of the word is set, we're
* starting a box */
if(w & mask0) {
if(!fInBox) {
rx1 = base + ib;
/* start new box */
fInBox = TRUE;
}
} else {
if(fInBox) {
/* end box */
ADDRECT(pReg, rects, FirstRect,
rx1, h, base + ib, h + 1);
fInBox = FALSE;
}
}
/* Shift the word VISUALLY left one. */
w = SCRLEFT(w, 1);
}
}
/* If scanline ended with last bit set, end the box */
if(fInBox) {
ADDRECT(pReg, rects, FirstRect,
rx1, h, base + (width & PIM), h + 1);
}
/* if all rectangles on this line have the same x-coords as
* those on the previous line, then add 1 to all the previous y2s and
* throw away all the rectangles from this line
*/
fSame = FALSE;
if(irectPrevStart != -1) {
crects = irectLineStart - irectPrevStart;
if(crects == ((rects - FirstRect) - irectLineStart)) {
prectO = FirstRect + irectPrevStart;
prectN = prectLineStart = FirstRect + irectLineStart;
fSame = TRUE;
while(prectO < prectLineStart) {
if((prectO->x1 != prectN->x1) || (prectO->x2 != prectN->x2)) {
fSame = FALSE;
break;
}
prectO++;
prectN++;
}
if (fSame) {
prectO = FirstRect + irectPrevStart;
while(prectO < prectLineStart) {
prectO->y2 += 1;
prectO++;
}
rects -= crects;
pReg->data->numRects -= crects;
}
}
}
if(!fSame)
irectPrevStart = irectLineStart;
}
if (!pReg->data->numRects)
pReg->extents.x1 = pReg->extents.x2 = 0;
else
{
pReg->extents.y1 = REGION_BOXPTR(pReg)->y1;
pReg->extents.y2 = REGION_END(pReg)->y2;
if (pReg->data->numRects == 1) {
xfree(pReg->data);
pReg->data = (RegDataPtr)NULL;
}
}
#ifdef DEBUG
if (!miValidRegion(pReg))
FatalError("Assertion failed file %s, line %d: expr\n", __FILE__, __LINE__);
#endif
return(pReg);
}

84
afb/afbcmap.c
View File

@ -1,84 +0,0 @@
/************************************************************
Copyright 1987 by Sun Microsystems, Inc. Mountain View, CA.
All Rights Reserved
Permission to use, copy, modify, and distribute this
software and its documentation for any purpose and without
fee is hereby granted, provided that the above copyright no-
tice appear in all copies and that both that copyright no-
tice and this permission notice appear in supporting docu-
mentation, and that the names of Sun or X Consortium
not be used in advertising or publicity pertaining to
distribution of the software without specific prior
written permission. Sun and X Consortium make no
representations about the suitability of this software for
any purpose. It is provided "as is" without any express or
implied warranty.
SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT-
NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE LI-
ABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
THE USE OR PERFORMANCE OF THIS SOFTWARE.
********************************************************/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <X11/X.h>
#include <X11/Xproto.h>
#include "scrnintstr.h"
#include "colormapst.h"
#include "resource.h"
#include "micmap.h"
#include "afb.h"
int
afbListInstalledColormaps(ScreenPtr pScreen, Colormap *pmaps)
{
return miListInstalledColormaps(pScreen, pmaps);
}
void
afbInstallColormap(ColormapPtr pmap)
{
miInstallColormap(pmap);
}
void
afbUninstallColormap(ColormapPtr pmap)
{
miUninstallColormap(pmap);
}
void
afbResolveColor(short unsigned int *pred, short unsigned int *pgreen, short unsigned int *pblue, register VisualPtr pVisual)
{
miResolveColor(pred, pgreen, pblue, pVisual);
}
Bool
afbInitializeColormap(register ColormapPtr pmap)
{
return miInitializeColormap(pmap);
}
/*
* Given a list of formats for a screen, create a list
* of visuals and depths for the screen which correspond to
* the set which can be used with this version of afb.
*/
Bool
afbInitVisuals(VisualPtr *visualp, DepthPtr *depthp, int *nvisualp, int *ndepthp, int *rootDepthp, VisualID *defaultVisp, long unsigned int sizes, int bitsPerRGB)
{
return miInitVisuals(visualp, depthp, nvisualp, ndepthp, rootDepthp,
defaultVisp, sizes, bitsPerRGB, -1);
}

347
afb/afbfillarc.c
View File

@ -1,347 +0,0 @@
/************************************************************
Copyright (c) 1989 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
********************************************************/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <X11/X.h>
#include <X11/Xprotostr.h>
#include "regionstr.h"
#include "gcstruct.h"
#include "pixmapstr.h"
#include "scrnintstr.h"
#include "afb.h"
#include "maskbits.h"
#include "mifillarc.h"
#include "mi.h"
static void
afbFillEllipseSolid(DrawablePtr pDraw, xArc *arc, register unsigned char *rrops)
{
int x, y, e;
int yk, xk, ym, xm, dx, dy, xorg, yorg;
register int slw;
miFillArcRec info;
PixelType *addrlt, *addrlb;
register PixelType *pdst;
PixelType *addrl;
register int n;
register int d;
int nlwidth;
register int xpos;
PixelType startmask, endmask;
int nlmiddle;
int depthDst;
int sizeDst;
afbGetPixelWidthSizeDepthAndPointer(pDraw, nlwidth, sizeDst, depthDst,
addrlt);
miFillArcSetup(arc, &info);
MIFILLARCSETUP();
xorg += pDraw->x;
yorg += pDraw->y;
addrlb = addrlt;
addrlt += nlwidth * (yorg - y);
addrlb += nlwidth * (yorg + y + dy);
while (y) {
addrlt += nlwidth;
addrlb -= nlwidth;
MIFILLARCSTEP(slw);
if (!slw)
continue;
xpos = xorg - x;
pdst = addrl = afbScanlineOffset(addrlt, (xpos >> PWSH));
if (((xpos & PIM) + slw) < PPW) {
maskpartialbits(xpos, slw, startmask);
for (d = 0; d < depthDst; d++, pdst += sizeDst) { /* @@@ NEXT PLANE @@@ */
switch (rrops[d]) {
case RROP_BLACK:
*pdst &= ~startmask;
break;
case RROP_WHITE:
*pdst |= startmask;
break;
case RROP_INVERT:
*pdst ^= startmask;
break;
case RROP_NOP:
break;
}
}
if (miFillArcLower(slw)) {
pdst = afbScanlineOffset(addrlb, (xpos >> PWSH));
for (d = 0; d < depthDst; d++, pdst += sizeDst) { /* @@@ NEXT PLANE @@@ */
switch (rrops[d]) {
case RROP_BLACK:
*pdst &= ~startmask;
break;
case RROP_WHITE:
*pdst |= startmask;
break;
case RROP_INVERT:
*pdst ^= startmask;
break;
case RROP_NOP:
break;
}
}
}
continue;
}
maskbits(xpos, slw, startmask, endmask, nlmiddle);
for (d = 0; d < depthDst; d++, addrl += sizeDst) { /* @@@ NEXT PLANE @@@ */
n = nlmiddle;
pdst = addrl;
switch (rrops[d]) {
case RROP_BLACK:
if (startmask)
*pdst++ &= ~startmask;
while (n--)
*pdst++ = 0;
if (endmask)
*pdst &= ~endmask;
break;
case RROP_WHITE:
if (startmask)
*pdst++ |= startmask;
while (n--)
*pdst++ = ~0;
if (endmask)
*pdst |= endmask;
break;
case RROP_INVERT:
if (startmask)
*pdst++ ^= startmask;
while (n--)
*pdst++ ^= ~0;
if (endmask)
*pdst ^= endmask;
break;
case RROP_NOP:
break;
}
}
if (!miFillArcLower(slw))
continue;
addrl = afbScanlineOffset(addrlb, (xpos >> PWSH));
for (d = 0; d < depthDst; d++, addrl += sizeDst) { /* @@@ NEXT PLANE @@@ */
n = nlmiddle;
pdst = addrl;
switch (rrops[d]) {
case RROP_BLACK:
if (startmask)
*pdst++ &= ~startmask;
while (n--)
*pdst++ = 0;
if (endmask)
*pdst &= ~endmask;
break;
case RROP_WHITE:
if (startmask)
*pdst++ |= startmask;
while (n--)
*pdst++ = ~0;
if (endmask)
*pdst |= endmask;
break;
case RROP_INVERT:
if (startmask)
*pdst++ ^= startmask;
while (n--)
*pdst++ ^= ~0;
if (endmask)
*pdst ^= endmask;
break;
case RROP_NOP:
break;
}
}
}
}
#define FILLSPAN(xl,xr,addr) \
if (xr >= xl) { \
width = xr - xl + 1; \
addrl = afbScanlineOffset(addr, (xl >> PWSH)); \
if (((xl & PIM) + width) < PPW) { \
maskpartialbits(xl, width, startmask); \
for (pdst = addrl, d = 0; d < depthDst; d++, pdst += sizeDst) { /* @@@ NEXT PLANE @@@ */ \
switch (rrops[d]) { \
case RROP_BLACK: \
*pdst &= ~startmask; \
break; \
case RROP_WHITE: \
*pdst |= startmask; \
break; \
case RROP_INVERT: \
*pdst ^= startmask; \
break; \
case RROP_NOP: \
break; \
} \
} \
} else { \
maskbits(xl, width, startmask, endmask, nlmiddle); \
for (d = 0; d < depthDst; d++, addrl += sizeDst) { /* @@@ NEXT PLANE @@@ */ \
n = nlmiddle; \
pdst = addrl; \
switch (rrops[d]) { \
case RROP_BLACK: \
if (startmask) \
*pdst++ &= ~startmask; \
while (n--) \
*pdst++ = 0; \
if (endmask) \
*pdst &= ~endmask; \
break; \
case RROP_WHITE: \
if (startmask) \
*pdst++ |= startmask; \
while (n--) \
*pdst++ = ~0; \
if (endmask) \
*pdst |= endmask; \
break; \
case RROP_INVERT: \
if (startmask) \
*pdst++ ^= startmask; \
while (n--) \
*pdst++ ^= ~0; \
if (endmask) \
*pdst ^= endmask; \
break; \
case RROP_NOP: \
break; \
} \
} \
} \
}
#define FILLSLICESPANS(flip,addr) \
if (!flip) { \
FILLSPAN(xl, xr, addr); \
} else { \
xc = xorg - x; \
FILLSPAN(xc, xr, addr); \
xc += slw - 1; \
FILLSPAN(xl, xc, addr); \
}
static void
afbFillArcSliceSolidCopy(DrawablePtr pDraw, GCPtr pGC, xArc *arc, register unsigned char *rrops)
{
PixelType *addrl;
register PixelType *pdst;
register int n;
register int d;
int yk, xk, ym, xm, dx, dy, xorg, yorg, slw;
register int x, y, e;
miFillArcRec info;
miArcSliceRec slice;
int xl, xr, xc;
PixelType *addrlt, *addrlb;
int nlwidth;
int width;
PixelType startmask, endmask;
int nlmiddle;
int sizeDst;
int depthDst;
afbGetPixelWidthSizeDepthAndPointer(pDraw, nlwidth, sizeDst, depthDst,
addrlt);
miFillArcSetup(arc, &info);
miFillArcSliceSetup(arc, &slice, pGC);
MIFILLARCSETUP();
xorg += pDraw->x;
yorg += pDraw->y;
addrlb = addrlt;
addrlt = afbScanlineDeltaNoBankSwitch(addrlt, yorg - y, nlwidth);
addrlb = afbScanlineDeltaNoBankSwitch(addrlb, yorg + y + dy, nlwidth);
slice.edge1.x += pDraw->x;
slice.edge2.x += pDraw->x;
while (y > 0) {
afbScanlineIncNoBankSwitch(addrlt, nlwidth);
afbScanlineIncNoBankSwitch(addrlb, -nlwidth);
MIFILLARCSTEP(slw);
MIARCSLICESTEP(slice.edge1);
MIARCSLICESTEP(slice.edge2);
if (miFillSliceUpper(slice)) {
MIARCSLICEUPPER(xl, xr, slice, slw);
FILLSLICESPANS(slice.flip_top, addrlt);
}
if (miFillSliceLower(slice)) {
MIARCSLICELOWER(xl, xr, slice, slw);
FILLSLICESPANS(slice.flip_bot, addrlb);
}
}
}
void
afbPolyFillArcSolid(register DrawablePtr pDraw, GCPtr pGC, int narcs, xArc *parcs)
{
afbPrivGC *priv;
register xArc *arc;
register int i;
BoxRec box;
RegionPtr cclip;
unsigned char *rrops;
priv = (afbPrivGC *)dixLookupPrivate(&pGC->devPrivates,
afbGCPrivateKey);
rrops = priv->rrops;
cclip = pGC->pCompositeClip;
for (arc = parcs, i = narcs; --i >= 0; arc++) {
if (miFillArcEmpty(arc))
continue;
if (miCanFillArc(arc)) {
box.x1 = arc->x + pDraw->x;
box.y1 = arc->y + pDraw->y;
box.x2 = box.x1 + (int)arc->width + 1;
box.y2 = box.y1 + (int)arc->height + 1;
if (RECT_IN_REGION(pDraw->pScreen, cclip, &box) == rgnIN) {
if ((arc->angle2 >= FULLCIRCLE) ||
(arc->angle2 <= -FULLCIRCLE))
afbFillEllipseSolid(pDraw, arc, rrops);
else
afbFillArcSliceSolidCopy(pDraw, pGC, arc, rrops);
continue;
}
}
miPolyFillArc(pDraw, pGC, 1, arc);
}
}

292
afb/afbfillrct.c
View File

@ -1,292 +0,0 @@
/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
/***********************************************************
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <X11/X.h>
#include <X11/Xprotostr.h>
#include "pixmapstr.h"
#include "gcstruct.h"
#include "windowstr.h"
#include "regionstr.h"
#include "scrnintstr.h"
#include "afb.h"
#include "maskbits.h"
#define MODEQ(a, b) ((a) %= (b))
/*
filled rectangles.
translate the rectangles, clip them, and call the
helper function in the GC.
*/
#define NUM_STACK_RECTS 1024
void
afbPolyFillRect(DrawablePtr pDrawable, GCPtr pGC, int nrectFill, xRectangle *prectInit)
/* number of rectangles to fill */
/* Pointer to first rectangle to fill */
{
xRectangle *prect;
RegionPtr prgnClip;
register BoxPtr pbox;
register BoxPtr pboxClipped;
BoxPtr pboxClippedBase;
BoxPtr pextent;
BoxRec stackRects[NUM_STACK_RECTS];
int numRects;
int n;
int xorg, yorg;
afbPrivGC *priv;
unsigned char *rrops;
unsigned char *rropsOS;
priv = (afbPrivGC *)dixLookupPrivate(&pGC->devPrivates,
afbGCPrivateKey);
prgnClip = pGC->pCompositeClip;
rrops = priv->rrops;
rropsOS = priv->rropOS;
prect = prectInit;
xorg = pDrawable->x;
yorg = pDrawable->y;
if (xorg || yorg) {
prect = prectInit;
n = nrectFill;
Duff(n, prect->x += xorg; prect->y += yorg; prect++);
}
prect = prectInit;
numRects = REGION_NUM_RECTS(prgnClip) * nrectFill;
if (numRects > NUM_STACK_RECTS) {
pboxClippedBase = (BoxPtr)xalloc(numRects * sizeof(BoxRec));
if (!pboxClippedBase)
return;
}
else
pboxClippedBase = stackRects;
pboxClipped = pboxClippedBase;
if (REGION_NUM_RECTS(prgnClip) == 1) {
int x1, y1, x2, y2, bx2, by2;
pextent = REGION_RECTS(prgnClip);
x1 = pextent->x1;
y1 = pextent->y1;
x2 = pextent->x2;
y2 = pextent->y2;
while (nrectFill--) {
if ((pboxClipped->x1 = prect->x) < x1)
pboxClipped->x1 = x1;
if ((pboxClipped->y1 = prect->y) < y1)
pboxClipped->y1 = y1;
bx2 = (int) prect->x + (int) prect->width;
if (bx2 > x2)
bx2 = x2;
pboxClipped->x2 = bx2;
by2 = (int) prect->y + (int) prect->height;
if (by2 > y2)
by2 = y2;
pboxClipped->y2 = by2;
prect++;
if ((pboxClipped->x1 < pboxClipped->x2) &&
(pboxClipped->y1 < pboxClipped->y2)) {
pboxClipped++;
}
}
} else {
int x1, y1, x2, y2, bx2, by2;
pextent = REGION_EXTENTS(pGC->pScreen, prgnClip);
x1 = pextent->x1;
y1 = pextent->y1;
x2 = pextent->x2;
y2 = pextent->y2;
while (nrectFill--) {
BoxRec box;
if ((box.x1 = prect->x) < x1)
box.x1 = x1;
if ((box.y1 = prect->y) < y1)
box.y1 = y1;
bx2 = (int) prect->x + (int) prect->width;
if (bx2 > x2)
bx2 = x2;
box.x2 = bx2;
by2 = (int) prect->y + (int) prect->height;
if (by2 > y2)
by2 = y2;
box.y2 = by2;
prect++;
if ((box.x1 >= box.x2) || (box.y1 >= box.y2))
continue;
n = REGION_NUM_RECTS (prgnClip);
pbox = REGION_RECTS(prgnClip);
/* clip the rectangle to each box in the clip region
this is logically equivalent to calling Intersect()
*/
while(n--) {
pboxClipped->x1 = max(box.x1, pbox->x1);
pboxClipped->y1 = max(box.y1, pbox->y1);
pboxClipped->x2 = min(box.x2, pbox->x2);
pboxClipped->y2 = min(box.y2, pbox->y2);
pbox++;
/* see if clipping left anything */
if(pboxClipped->x1 < pboxClipped->x2 &&
pboxClipped->y1 < pboxClipped->y2) {
pboxClipped++;
}
}
}
}
if (pboxClipped != pboxClippedBase) {
switch (pGC->fillStyle) {
case FillSolid:
afbSolidFillArea(pDrawable, pboxClipped-pboxClippedBase,
pboxClippedBase, rrops);
break;
case FillTiled:
switch (pGC->alu) {
case GXcopy:
if (pGC->pRotatedPixmap)
afbTileAreaPPWCopy(pDrawable, pboxClipped-pboxClippedBase,
pboxClippedBase, GXcopy,
pGC->pRotatedPixmap, pGC->planemask);
else
afbTileAreaCopy (pDrawable, pboxClipped-pboxClippedBase,
pboxClippedBase, GXcopy,
pGC->tile.pixmap,
pGC->patOrg.x, pGC->patOrg.y,
pGC->planemask);
break;
default:
if (pGC->pRotatedPixmap)
afbTileAreaPPWGeneral(pDrawable, pboxClipped-pboxClippedBase,
pboxClippedBase, pGC->alu,
pGC->pRotatedPixmap,
pGC->planemask);
else
afbTileAreaGeneral(pDrawable, pboxClipped-pboxClippedBase,
pboxClippedBase, pGC->alu,
pGC->tile.pixmap,
pGC->patOrg.x, pGC->patOrg.y,
pGC->planemask);
break;
} /* switch (alu) */
break;
case FillStippled:
if (pGC->pRotatedPixmap)
afbStippleAreaPPW(pDrawable, pboxClipped-pboxClippedBase,
pboxClippedBase, pGC->pRotatedPixmap, rrops);
else
afbStippleArea(pDrawable, pboxClipped-pboxClippedBase,
pboxClippedBase, pGC->stipple,
pGC->patOrg.x, pGC->patOrg.y, rrops);
break;
case FillOpaqueStippled:
switch (pGC->alu) {
case GXcopy:
if (pGC->pRotatedPixmap)
afbOpaqueStippleAreaPPWCopy(pDrawable, pboxClipped-pboxClippedBase,
pboxClippedBase, GXcopy,
pGC->pRotatedPixmap,
rropsOS, pGC->planemask);
else
afbOpaqueStippleAreaCopy(pDrawable, pboxClipped-pboxClippedBase,
pboxClippedBase, GXcopy,
pGC->stipple,
pGC->patOrg.x, pGC->patOrg.y, rropsOS,
pGC->planemask);
break;
default:
if (pGC->pRotatedPixmap)
afbOpaqueStippleAreaPPWGeneral(pDrawable, pboxClipped-pboxClippedBase,
pboxClippedBase, pGC->alu,
pGC->pRotatedPixmap,
rropsOS,
pGC->planemask);
else
afbOpaqueStippleAreaGeneral(pDrawable, pboxClipped-pboxClippedBase,
pboxClippedBase, pGC->alu,
pGC->stipple,
pGC->patOrg.x, pGC->patOrg.y,
rropsOS,
pGC->planemask);
break;
} /* switch (alu) */
break;
}
}
if (pboxClippedBase != stackRects)
xfree(pboxClippedBase);
}

1130
afb/afbfillsp.c
View File

File diff suppressed because it is too large Load Diff

77
afb/afbfont.c
View File

@ -1,77 +0,0 @@
/*
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
*/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <X11/X.h>
#include <X11/Xmd.h>
#include <X11/Xproto.h>
#include "afb.h"
#include <X11/fonts/fontstruct.h>
#include "dixfontstr.h"
#include "scrnintstr.h"
/*ARGSUSED*/
Bool
afbRealizeFont( pscr, pFont)
ScreenPtr pscr;
FontPtr pFont;
{
return (TRUE);
}
/*ARGSUSED*/
Bool
afbUnrealizeFont( pscr, pFont)
ScreenPtr pscr;
FontPtr pFont;
{
return (TRUE);
}

685
afb/afbgc.c
View File

@ -1,685 +0,0 @@
/***********************************************************
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <string.h>
#include <X11/X.h>
#include <X11/Xmd.h>
#include <X11/Xproto.h>
#include "afb.h"
#include "dixfontstr.h"
#include <X11/fonts/fontstruct.h>
#include "gcstruct.h"
#include "windowstr.h"
#include "pixmapstr.h"
#include "scrnintstr.h"
#include "region.h"
#include "mistruct.h"
#include "migc.h"
#include "maskbits.h"
static void afbDestroyGC(GCPtr);
static void afbValidateGC(GCPtr, unsigned long, DrawablePtr);
static GCFuncs afbFuncs = {
afbValidateGC,
miChangeGC,
miCopyGC,
afbDestroyGC,
miChangeClip,
miDestroyClip,
miCopyClip
};
static GCOps afbGCOps = {
afbSolidFS,
afbSetSpans,
afbPutImage,
afbCopyArea,
miCopyPlane,
afbPolyPoint,
afbLineSS,
afbSegmentSS,
miPolyRectangle,
afbZeroPolyArcSS,
afbFillPolygonSolid,
afbPolyFillRect,
afbPolyFillArcSolid,
miPolyText8,
miPolyText16,
miImageText8,
miImageText16,
afbTEGlyphBlt,
afbPolyGlyphBlt,
afbPushPixels
};
static void
afbReduceOpaqueStipple(PixelType fg, PixelType bg, unsigned long planemask,
int depth, unsigned char *rop)
{
register int d;
register Pixel mask = 1;
bg ^= fg;
for (d = 0; d < depth; d++, mask <<= 1) {
if (!(planemask & mask))
rop[d] = RROP_NOP;
else if (!(bg & mask)) {
/* Both fg and bg have a 0 or 1 in this plane */
if (fg & mask)
rop[d] = RROP_WHITE;
else
rop[d] = RROP_BLACK;
} else {
/* Both fg and bg have different bits on this plane */
if (fg & mask)
rop[d] = RROP_COPY;
else
rop[d] = RROP_INVERT;
}
}
}
Bool
afbCreateGC(pGC)
register GCPtr pGC;
{
afbPrivGC *pPriv;
pGC->clientClip = NULL;
pGC->clientClipType = CT_NONE;
/* some of the output primitives aren't really necessary, since
they will be filled in ValidateGC because of dix/CreateGC()
setting all the change bits. Others are necessary because although
they depend on being a monochrome frame buffer, they don't change
*/
pGC->ops = &afbGCOps;
pGC->funcs = &afbFuncs;
/* afb wants to translate before scan convesion */
pGC->miTranslate = 1;
pPriv = (afbPrivGC *)dixLookupPrivate(&pGC->devPrivates,
afbGCPrivateKey);
afbReduceRop(pGC->alu, pGC->fgPixel, pGC->planemask, pGC->depth,
pPriv->rrops);
afbReduceOpaqueStipple(pGC->fgPixel, pGC->bgPixel, pGC->planemask,
pGC->depth, pPriv->rropOS);
pGC->fExpose = TRUE;
pGC->pRotatedPixmap = NullPixmap;
pGC->freeCompClip = FALSE;
return TRUE;
}
static void
afbComputeCompositeClip(GCPtr pGC, DrawablePtr pDrawable)
{
if (pDrawable->type == DRAWABLE_WINDOW) {
WindowPtr pWin = (WindowPtr) pDrawable;
RegionPtr pregWin;
Bool freeTmpClip, freeCompClip;
if (pGC->subWindowMode == IncludeInferiors) {
pregWin = NotClippedByChildren(pWin);
freeTmpClip = TRUE;
} else {
pregWin = &pWin->clipList;
freeTmpClip = FALSE;
}
freeCompClip = pGC->freeCompClip;
/*
* if there is no client clip, we can get by with just keeping the
* pointer we got, and remembering whether or not should destroy (or
* maybe re-use) it later. this way, we avoid unnecessary copying of
* regions. (this wins especially if many clients clip by children
* and have no client clip.)
*/
if (pGC->clientClipType == CT_NONE) {
if (freeCompClip)
REGION_DESTROY(pGC->pScreen, pGC->pCompositeClip);
pGC->pCompositeClip = pregWin;
pGC->freeCompClip = freeTmpClip;
} else {
/*
* we need one 'real' region to put into the composite clip. if
* pregWin the current composite clip are real, we can get rid of
* one. if pregWin is real and the current composite clip isn't,
* use pregWin for the composite clip. if the current composite
* clip is real and pregWin isn't, use the current composite
* clip. if neither is real, create a new region.
*/
REGION_TRANSLATE(pGC->pScreen, pGC->clientClip,
pDrawable->x + pGC->clipOrg.x,
pDrawable->y + pGC->clipOrg.y);
if (freeCompClip) {
REGION_INTERSECT(pGC->pScreen, pGC->pCompositeClip, pregWin,
pGC->clientClip);
if (freeTmpClip)
REGION_DESTROY(pGC->pScreen, pregWin);
} else if (freeTmpClip) {
REGION_INTERSECT(pGC->pScreen, pregWin, pregWin, pGC->clientClip);
pGC->pCompositeClip = pregWin;
} else {
pGC->pCompositeClip = REGION_CREATE(pGC->pScreen, NullBox, 0);
REGION_INTERSECT(pGC->pScreen, pGC->pCompositeClip,
pregWin, pGC->clientClip);
}
pGC->freeCompClip = TRUE;
REGION_TRANSLATE(pGC->pScreen, pGC->clientClip,
-(pDrawable->x + pGC->clipOrg.x),
-(pDrawable->y + pGC->clipOrg.y));
}
} /* end of composite clip for a window */
else {
BoxRec pixbounds;
/* XXX should we translate by drawable.x/y here ? */
pixbounds.x1 = 0;
pixbounds.y1 = 0;
pixbounds.x2 = pDrawable->width;
pixbounds.y2 = pDrawable->height;
if (pGC->freeCompClip) {
REGION_RESET(pGC->pScreen, pGC->pCompositeClip, &pixbounds);
} else {
pGC->freeCompClip = TRUE;
pGC->pCompositeClip = REGION_CREATE(pGC->pScreen, &pixbounds, 1);
}
if (pGC->clientClipType == CT_REGION) {
REGION_TRANSLATE(pGC->pScreen, pGC->pCompositeClip, -pGC->clipOrg.x,
-pGC->clipOrg.y);
REGION_INTERSECT(pGC->pScreen, pGC->pCompositeClip,
pGC->pCompositeClip, pGC->clientClip);
REGION_TRANSLATE(pGC->pScreen, pGC->pCompositeClip, pGC->clipOrg.x,
pGC->clipOrg.y);
}
} /* end of composite clip for pixmap */
} /* end afbComputeCompositeClip */
/* Clipping conventions
if the drawable is a window
CT_REGION ==> pCompositeClip really is the composite
CT_other ==> pCompositeClip is the window clip region
if the drawable is a pixmap
CT_REGION ==> pCompositeClip is the translated client region
clipped to the pixmap boundary
CT_other ==> pCompositeClip is the pixmap bounding box
*/
/*ARGSUSED*/
static void
afbValidateGC(pGC, changes, pDrawable)
register GCPtr pGC;
unsigned long changes;
DrawablePtr pDrawable;
{
register afbPrivGCPtr devPriv;
int mask; /* stateChanges */
int index; /* used for stepping through bitfields */
int xrot, yrot; /* rotations for tile and stipple pattern */
/* flags for changing the proc vector
and updating things in devPriv
*/
int new_rotate, new_rrop, new_line, new_text, new_fill;
DDXPointRec oldOrg; /* origin of thing GC was last used with */
oldOrg = pGC->lastWinOrg;
pGC->lastWinOrg.x = pDrawable->x;
pGC->lastWinOrg.y = pDrawable->y;
/* we need to re-rotate the tile if the previous window/pixmap
origin (oldOrg) differs from the new window/pixmap origin
(pGC->lastWinOrg)
*/
new_rotate = (oldOrg.x != pGC->lastWinOrg.x) ||
(oldOrg.y != pGC->lastWinOrg.y);
devPriv = (afbPrivGCPtr)dixLookupPrivate(&pGC->devPrivates,
afbGCPrivateKey);
/*
if the client clip is different or moved OR
the subwindowMode has changed OR
the window's clip has changed since the last validation
we need to recompute the composite clip
*/
if ((changes & (GCClipXOrigin|GCClipYOrigin|GCClipMask|GCSubwindowMode)) ||
(pDrawable->serialNumber != (pGC->serialNumber & DRAWABLE_SERIAL_BITS)))
afbComputeCompositeClip(pGC, pDrawable);
new_rrop = FALSE;
new_line = FALSE;
new_text = FALSE;
new_fill = FALSE;
mask = changes;
while (mask) {
index = lowbit(mask);
mask &= ~index;
/* this switch acculmulates a list of which procedures
might have to change due to changes in the GC. in
some cases (e.g. changing one 16 bit tile for another)
we might not really need a change, but the code is
being paranoid.
this sort of batching wins if, for example, the alu
and the font have been changed, or any other pair
of items that both change the same thing.
*/
switch (index) {
case GCPlaneMask:
case GCFunction:
case GCForeground:
new_rrop = TRUE;
break;
case GCBackground:
new_rrop = TRUE; /* for opaque stipples */
break;
case GCLineStyle:
case GCLineWidth:
case GCJoinStyle:
new_line = TRUE;
break;
case GCCapStyle:
break;
case GCFillStyle:
new_fill = TRUE;
break;
case GCFillRule:
break;
case GCTile:
if(pGC->tileIsPixel)
break;
new_rotate = TRUE;
new_fill = TRUE;
break;
case GCStipple:
if(pGC->stipple == (PixmapPtr)NULL)
break;
new_rotate = TRUE;
new_fill = TRUE;
break;
case GCTileStipXOrigin:
new_rotate = TRUE;
break;
case GCTileStipYOrigin:
new_rotate = TRUE;
break;
case GCFont:
new_text = TRUE;
break;
case GCSubwindowMode:
break;
case GCGraphicsExposures:
break;
case GCClipXOrigin:
break;
case GCClipYOrigin:
break;
case GCClipMask:
break;
case GCDashOffset:
break;
case GCDashList:
break;
case GCArcMode:
break;
default:
break;
}
}
/* deal with the changes we've collected .
new_rrop must be done first because subsequent things
depend on it.
*/
if(new_rotate || new_fill) {
Bool new_pix = FALSE;
/* figure out how much to rotate */
xrot = pGC->patOrg.x;
yrot = pGC->patOrg.y;
xrot += pDrawable->x;
yrot += pDrawable->y;
switch (pGC->fillStyle) {
case FillTiled:
/* copy current tile and stipple */
if (!pGC->tileIsPixel &&
(pGC->tile.pixmap->drawable.width <= PPW) &&
!(pGC->tile.pixmap->drawable.width &
(pGC->tile.pixmap->drawable.width - 1))) {
afbCopyRotatePixmap(pGC->tile.pixmap, &pGC->pRotatedPixmap,
xrot, yrot);
new_pix = TRUE;
}
break;
case FillStippled:
case FillOpaqueStippled:
if (pGC->stipple && (pGC->stipple->drawable.width <= PPW) &&
!(pGC->stipple->drawable.width &
(pGC->stipple->drawable.width - 1))) {
afbCopyRotatePixmap(pGC->stipple, &pGC->pRotatedPixmap,
xrot, yrot);
new_pix = TRUE;
}
}
/* destroy any previously rotated tile or stipple */
if (!new_pix && pGC->pRotatedPixmap) {
(*pDrawable->pScreen->DestroyPixmap)(pGC->pRotatedPixmap);
pGC->pRotatedPixmap = (PixmapPtr)NULL;
}
}
/*
* duck out here when the GC is unchanged
*/
if (!changes)
return;
if (new_rrop || new_fill) {
afbReduceRop(pGC->alu, pGC->fgPixel, pGC->planemask, pDrawable->depth,
devPriv->rrops);
afbReduceOpaqueStipple(pGC->fgPixel, pGC->bgPixel, pGC->planemask,
pGC->depth, devPriv->rropOS);
new_fill = TRUE;
}
if (new_line || new_fill || new_text) {
if (!pGC->ops->devPrivate.val) {
pGC->ops = miCreateGCOps(pGC->ops);
pGC->ops->devPrivate.val = 1;
}
}
if (new_line || new_fill) {
if (pGC->lineWidth == 0) {
if (pGC->lineStyle == LineSolid && pGC->fillStyle == FillSolid)
pGC->ops->PolyArc = afbZeroPolyArcSS;
else
pGC->ops->PolyArc = miZeroPolyArc;
} else
pGC->ops->PolyArc = miPolyArc;
if (pGC->lineStyle == LineSolid) {
if(pGC->lineWidth == 0) {
if (pGC->fillStyle == FillSolid) {
pGC->ops->PolySegment = afbSegmentSS;
pGC->ops->Polylines = afbLineSS;
}
else
{
pGC->ops->PolySegment = miPolySegment;
pGC->ops->Polylines = miZeroLine;
}
} else {
pGC->ops->PolySegment = miPolySegment;
pGC->ops->Polylines = miWideLine;
}
} else {
if(pGC->lineWidth == 0 && pGC->fillStyle == FillSolid) {
pGC->ops->PolySegment = afbSegmentSD;
pGC->ops->Polylines = afbLineSD;
} else {
pGC->ops->PolySegment = miPolySegment;
pGC->ops->Polylines = miWideDash;
}
}
}
if (new_text || new_fill) {
if ((pGC->font) &&
(FONTMAXBOUNDS(pGC->font,rightSideBearing) -
FONTMINBOUNDS(pGC->font,leftSideBearing) > 32 ||
FONTMINBOUNDS(pGC->font,characterWidth) < 0)) {
pGC->ops->PolyGlyphBlt = miPolyGlyphBlt;
pGC->ops->ImageGlyphBlt = miImageGlyphBlt;
} else {
/* special case ImageGlyphBlt for terminal emulator fonts */
if ((pGC->font) &&
TERMINALFONT(pGC->font)) {
pGC->ops->ImageGlyphBlt = afbTEGlyphBlt;
} else {
pGC->ops->ImageGlyphBlt = afbImageGlyphBlt;
}
/* now do PolyGlyphBlt */
if (pGC->fillStyle == FillSolid) {
pGC->ops->PolyGlyphBlt = afbPolyGlyphBlt;
} else {
pGC->ops->PolyGlyphBlt = miPolyGlyphBlt;
}
}
}
if (new_fill) {
/* install a suitable fillspans and pushpixels */
pGC->ops->PushPixels = afbPushPixels;
pGC->ops->FillPolygon = miFillPolygon;
pGC->ops->PolyFillArc = miPolyFillArc;
switch (pGC->fillStyle) {
case FillSolid:
pGC->ops->FillSpans = afbSolidFS;
pGC->ops->FillPolygon = afbFillPolygonSolid;
pGC->ops->PolyFillArc = afbPolyFillArcSolid;
break;
case FillTiled:
if (pGC->pRotatedPixmap)
pGC->ops->FillSpans = afbTileFS;
else
pGC->ops->FillSpans = afbUnnaturalTileFS;
break;
case FillOpaqueStippled:
if (pGC->pRotatedPixmap)
pGC->ops->FillSpans = afbOpaqueStippleFS;
else
pGC->ops->FillSpans = afbUnnaturalOpaqueStippleFS;
break;
case FillStippled:
if (pGC->pRotatedPixmap)
pGC->ops->FillSpans = afbStippleFS;
else
pGC->ops->FillSpans = afbUnnaturalStippleFS;
break;
}
} /* end of new_fill */
}
static void
afbDestroyGC(pGC)
GCPtr pGC;
{
if (pGC->pRotatedPixmap)
(*pGC->pScreen->DestroyPixmap)(pGC->pRotatedPixmap);
if (pGC->freeCompClip)
REGION_DESTROY(pGC->pScreen, pGC->pCompositeClip);
miDestroyGCOps(pGC->ops);
}
void
afbReduceRop(alu, src, planemask, depth, rop)
register int alu;
register Pixel src;
register unsigned long planemask;
int depth;
register unsigned char *rop;
{
register int d;
register Pixel mask = 1;
for (d = 0; d < depth; d++, mask <<= 1) {
if (!(planemask & mask))
rop[d] = RROP_NOP;
else if ((src & mask) == 0) /* src is black */
switch (alu) {
case GXclear:
rop[d] = RROP_BLACK;
break;
case GXand:
rop[d] = RROP_BLACK;
break;
case GXandReverse:
rop[d] = RROP_BLACK;
break;
case GXcopy:
rop[d] = RROP_BLACK;
break;
case GXandInverted:
rop[d] = RROP_NOP;
break;
case GXnoop:
rop[d] = RROP_NOP;
break;
case GXxor:
rop[d] = RROP_NOP;
break;
case GXor:
rop[d] = RROP_NOP;
break;
case GXnor:
rop[d] = RROP_INVERT;
break;
case GXequiv:
rop[d] = RROP_INVERT;
break;
case GXinvert:
rop[d] = RROP_INVERT;
break;
case GXorReverse:
rop[d] = RROP_INVERT;
break;
case GXcopyInverted:
rop[d] = RROP_WHITE;
break;
case GXorInverted:
rop[d] = RROP_WHITE;
break;
case GXnand:
rop[d] = RROP_WHITE;
break;
case GXset:
rop[d] = RROP_WHITE;
break;
}
else /* src is white */
switch (alu) {
case GXclear:
rop[d] = RROP_BLACK;
break;
case GXand:
rop[d] = RROP_NOP;
break;
case GXandReverse:
rop[d] = RROP_INVERT;
break;
case GXcopy:
rop[d] = RROP_WHITE;
break;
case GXandInverted:
rop[d] = RROP_BLACK;
break;
case GXnoop:
rop[d] = RROP_NOP;
break;
case GXxor:
rop[d] = RROP_INVERT;
break;
case GXor:
rop[d] = RROP_WHITE;
break;
case GXnor:
rop[d] = RROP_BLACK;
break;
case GXequiv:
rop[d] = RROP_NOP;
break;
case GXinvert:
rop[d] = RROP_INVERT;
break;
case GXorReverse:
rop[d] = RROP_WHITE;
break;
case GXcopyInverted:
rop[d] = RROP_BLACK;
break;
case GXorInverted:
rop[d] = RROP_NOP;
break;
case GXnand:
rop[d] = RROP_INVERT;
break;
case GXset:
rop[d] = RROP_WHITE;
break;
}
}
}

165
afb/afbgetsp.c
View File

@ -1,165 +0,0 @@
/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
/***********************************************************
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <X11/X.h>
#include <X11/Xmd.h>
#include "misc.h"
#include "region.h"
#include "gc.h"
#include "windowstr.h"
#include "pixmapstr.h"
#include "scrnintstr.h"
#include "afb.h"
#include "maskbits.h"
#include "servermd.h"
/* GetSpans -- for each span, gets bits from drawable starting at ppt[i]
* and continuing for pwidth[i] bits
* Each scanline returned will be server scanline padded, i.e., it will come
* out to an integral number of words.
*/
/*ARGSUSED*/
void
afbGetSpans(pDrawable, wMax, ppt, pwidth, nspans, pchardstStart)
DrawablePtr pDrawable; /* drawable from which to get bits */
int wMax; /* largest value of all *pwidths */
register DDXPointPtr ppt; /* points to start copying from */
int *pwidth; /* list of number of bits to copy */
int nspans; /* number of scanlines to copy */
char *pchardstStart; /* where to put the bits */
{
PixelType *pdstStart = (PixelType *)pchardstStart;
register PixelType *pdst; /* where to put the bits */
register PixelType *psrc; /* where to get the bits */
register PixelType tmpSrc; /* scratch buffer for bits */
PixelType *psrcBase; /* start of src bitmap */
int widthSrc; /* width of pixmap in bytes */
int sizeSrc;
int depthSrc;
register DDXPointPtr pptLast; /* one past last point to get */
int xEnd; /* last pixel to copy from */
register int nstart;
register int d;
int nend = 0;
int srcStartOver;
PixelType startmask, endmask;
unsigned int srcBit;
int nlMiddle, nl;
int w;
pptLast = ppt + nspans;
afbGetPixelWidthSizeDepthAndPointer(pDrawable, widthSrc, sizeSrc, depthSrc,
psrcBase);
pdst = pdstStart;
while(ppt < pptLast) {
/* XXX should this really be << PWSH, or * 8, or * PGSZB? */
xEnd = min(ppt->x + *pwidth, widthSrc << PWSH);
pwidth++;
for (d = 0; d < depthSrc; d++) {
psrc = afbScanline(psrcBase, ppt->x, ppt->y, widthSrc);
psrcBase += sizeSrc; /* @@@ NEXT PLANE @@@ */
w = xEnd - ppt->x;
srcBit = ppt->x & PIM;
if (srcBit + w <= PPW)
{
getandputbits0(psrc, srcBit, w, pdst);
pdst++;
}
else
{
maskbits(ppt->x, w, startmask, endmask, nlMiddle);
if (startmask)
nstart = PPW - srcBit;
else
nstart = 0;
if (endmask)
nend = xEnd & PIM;
srcStartOver = srcBit + nstart > PLST;
if (startmask)
{
getandputbits0(psrc, srcBit, nstart, pdst);
if(srcStartOver)
psrc++;
}
nl = nlMiddle;
#ifdef FASTPUTBITS
Duff(nl, putbits(*psrc, nstart, PPW, pdst); psrc++; pdst++;);
#else
while (nl--)
{
tmpSrc = *psrc;
putbits(tmpSrc, nstart, PPW, pdst);
psrc++;
pdst++;
}
#endif
if (endmask)
{
putbits(*psrc, nstart, nend, pdst);
if(nstart + nend > PPW)
pdst++;
}
if (startmask || endmask)
pdst++;
}
}
ppt++;
}
}

209
afb/afbhrzvert.c
View File

@ -1,209 +0,0 @@
/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
/***********************************************************
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <X11/X.h>
#include "gc.h"
#include "window.h"
#include "pixmap.h"
#include "region.h"
#include "afb.h"
#include "maskbits.h"
/* horizontal solid line
abs(len) > 1
*/
void
afbHorzS(pbase, nlwidth, sizeDst, depthDst, x1, y1, len, rrops)
PixelType *pbase; /* pointer to base of bitmap */
register int nlwidth; /* width in longwords of bitmap */
int sizeDst;
int depthDst;
int x1; /* initial point */
int y1;
int len; /* length of line */
register unsigned char *rrops;
{
register PixelType *addrl;
register PixelType startmask;
register PixelType endmask;
register int nlmiddle;
register int d;
int saveNLmiddle;
/* force the line to go left to right
but don't draw the last point
*/
if (len < 0) {
x1 += len;
x1 += 1;
len = -len;
}
/* all bits inside same longword */
if ( ((x1 & PIM) + len) < PPW) {
maskpartialbits(x1, len, startmask);
for (d = 0; d < depthDst; d++) {
addrl = afbScanline(pbase, x1, y1, nlwidth);
pbase += sizeDst; /* @@@ NEXT PLANE @@@ */
switch (rrops[d]) {
case RROP_BLACK:
*addrl &= ~startmask;
break;
case RROP_WHITE:
*addrl |= startmask;
break;
case RROP_INVERT:
*addrl ^= startmask;
break;
case RROP_NOP:
break;
} /* switch */
} /* for (d = ...) */
} else {
maskbits(x1, len, startmask, endmask, nlmiddle);
saveNLmiddle = nlmiddle;
for (d = 0; d < depthDst; d++) {
addrl = afbScanline(pbase, x1, y1, nlwidth);
pbase += sizeDst; /* @@@ NEXT PLANE @@@ */
nlmiddle = saveNLmiddle;
switch (rrops[d]) {
case RROP_BLACK:
if (startmask)
*addrl++ &= ~startmask;
Duff (nlmiddle, *addrl++ = 0x0);
if (endmask)
*addrl &= ~endmask;
break;
case RROP_WHITE:
if (startmask)
*addrl++ |= startmask;
Duff (nlmiddle, *addrl++ = ~0);
if (endmask)
*addrl |= endmask;
break;
case RROP_INVERT:
if (startmask)
*addrl++ ^= startmask;
Duff (nlmiddle, *addrl++ ^= ~0);
if (endmask)
*addrl ^= endmask;
break;
case RROP_NOP:
break;
} /* switch */
} /* for (d = ... ) */
}
}
/* vertical solid line
this uses do loops because pcc (Ultrix 1.2, bsd 4.2) generates
better code. sigh. we know that len will never be 0 or 1, so
it's OK to use it.
*/
void
afbVertS(pbase, nlwidth, sizeDst, depthDst, x1, y1, len, rrops)
PixelType *pbase; /* pointer to base of bitmap */
register int nlwidth; /* width in longwords of bitmap */
int sizeDst;
int depthDst;
int x1, y1; /* initial point */
register int len; /* length of line */
unsigned char *rrops;
{
register PixelType *addrl;
register PixelType bitmask;
int saveLen;
int d;
if (len < 0) {
nlwidth = -nlwidth;
len = -len;
}
saveLen = len;
for (d = 0; d < depthDst; d++) {
addrl = afbScanline(pbase, x1, y1, nlwidth);
pbase += sizeDst; /* @@@ NEXT PLANE @@@ */
len = saveLen;
switch (rrops[d]) {
case RROP_BLACK:
bitmask = mfbGetrmask(x1 & PIM);
Duff(len, *addrl &= bitmask; afbScanlineInc(addrl, nlwidth) );
break;
case RROP_WHITE:
bitmask = mfbGetmask(x1 & PIM);
Duff(len, *addrl |= bitmask; afbScanlineInc(addrl, nlwidth) );
break;
case RROP_INVERT:
bitmask = mfbGetmask(x1 & PIM);
Duff(len, *addrl ^= bitmask; afbScanlineInc(addrl, nlwidth) );
break;
case RROP_NOP:
break;
} /* switch */
} /* for (d = ...) */
}

272
afb/afbimage.c
View File

@ -1,272 +0,0 @@
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <string.h>
#include <X11/X.h>
#include "windowstr.h"
#include "pixmapstr.h"
#include "scrnintstr.h"
#include "gcstruct.h"
#include "afb.h"
#include "maskbits.h"
#include "servermd.h"
#include "mfb.h"
void
afbPutImage(pDraw, pGC, depth, x, y, width, height, leftPad, format, pImage)
DrawablePtr pDraw;
GCPtr pGC;
int depth, x, y, width, height;
int leftPad;
int format;
char *pImage;
{
PixmapPtr pPixmap;
if ((width == 0) || (height == 0))
return;
if (format != ZPixmap || depth == 1 || pDraw->depth == 1) {
pPixmap = GetScratchPixmapHeader(pDraw->pScreen, width+leftPad, height,
depth, depth,
BitmapBytePad(width+leftPad),
(pointer)pImage);
if (!pPixmap)
return;
pGC->fExpose = FALSE;
if (format == XYBitmap)
(void)(*pGC->ops->CopyPlane)((DrawablePtr)pPixmap, pDraw, pGC, leftPad,
0, width, height, x, y, 1);
else {
(void)(*pGC->ops->CopyArea)((DrawablePtr)pPixmap, pDraw, pGC, leftPad,
0, width, height, x, y);
}
pGC->fExpose = TRUE;
FreeScratchPixmapHeader(pPixmap);
} else {
/* Chunky to planar conversion required */
PixmapPtr pPixmap;
ScreenPtr pScreen = pDraw->pScreen;
int widthSrc;
int start_srcshift;
register int b;
register int dstshift;
register int shift_step;
register PixelType dst;
register PixelType srcbits;
register PixelType *pdst;
register PixelType *psrc;
int start_bit;
register int nl;
register int h;
register int d;
int sizeDst;
PixelType *pdstBase;
int widthDst;
int depthDst;
/* Create a tmp pixmap */
pPixmap = (pScreen->CreatePixmap)(pScreen, width, height, depth,
CREATE_PIXMAP_USAGE_SCRATCH);
if (!pPixmap)
return;
afbGetPixelWidthSizeDepthAndPointer((DrawablePtr)pPixmap, widthDst,
sizeDst, depthDst, pdstBase);
widthSrc = PixmapWidthInPadUnits(width, depth);
/* XXX: if depth == 8, use fast chunky to planar assembly function.*/
if (depth > 4) {
start_srcshift = 24;
shift_step = 8;
} else {
start_srcshift = 28;
shift_step = 4;
}
for (d = 0; d < depth; d++, pdstBase += sizeDst) { /* @@@ NEXT PLANE @@@ */
start_bit = start_srcshift + d;
psrc = (PixelType *)pImage;
pdst = pdstBase;
h = height;
while (h--) {
dstshift = PPW - 1;
dst = 0;
nl = widthSrc;
while (nl--) {
srcbits = *psrc++;
for (b = start_bit; b >= 0; b -= shift_step) {
dst |= ((srcbits >> b) & 1) << dstshift;
if (--dstshift < 0) {
dstshift = PPW - 1;
*pdst++ = dst;
dst = 0;
}
}
}
if (dstshift != PPW - 1)
*pdst++ = dst;
}
} /* for (d = ...) */
pGC->fExpose = FALSE;
(void)(*pGC->ops->CopyArea)((DrawablePtr)pPixmap, pDraw, pGC, leftPad, 0,
width, height, x, y);
pGC->fExpose = TRUE;
(*pScreen->DestroyPixmap)(pPixmap);
}
}
void
afbGetImage(pDrawable, sx, sy, width, height, format, planemask, pdstLine)
DrawablePtr pDrawable;
int sx, sy, width, height;
unsigned int format;
unsigned long planemask;
char *pdstLine;
{
BoxRec box;
DDXPointRec ptSrc;
RegionRec rgnDst;
ScreenPtr pScreen;
PixmapPtr pPixmap;
if ((width == 0) || (height == 0))
return;
pScreen = pDrawable->pScreen;
sx += pDrawable->x;
sy += pDrawable->y;
if (format == XYPixmap || pDrawable->depth == 1) {
pPixmap = GetScratchPixmapHeader(pScreen, width, height, 1, 1,
BitmapBytePad(width), (pointer)pdstLine);
if (!pPixmap)
return;
ptSrc.x = sx;
ptSrc.y = sy;
box.x1 = 0;
box.y1 = 0;
box.x2 = width;
box.y2 = height;
REGION_INIT(pScreen, &rgnDst, &box, 1);
pPixmap->drawable.depth = 1;
pPixmap->drawable.bitsPerPixel = 1;
/* dix layer only ever calls GetImage with 1 bit set in planemask
* when format is XYPixmap.
*/
afbDoBitblt(pDrawable, (DrawablePtr)pPixmap, GXcopy, &rgnDst, &ptSrc,
planemask);
FreeScratchPixmapHeader(pPixmap);
REGION_UNINIT(pScreen, &rgnDst);
} else {
/* Planar to chunky conversion required */
PixelType *psrcBits;
PixelType *psrcLine;
PixelType startmask, endmask;
int depthSrc;
int widthSrc;
int sizeSrc;
int sizeDst;
int widthDst;
register PixelType *psrc;
register PixelType *pdst;
register PixelType dst;
register PixelType srcbits;
register int d;
register int b;
register int dstshift;
register int shift_step;
register int start_endbit;
int start_startbit;
register int end_endbit = 0;
register int start_dstshift;
register int nl;
register int h;
int nlmiddle;
widthDst = PixmapWidthInPadUnits(width, pDrawable->depth);
sizeDst = widthDst * height;
/* Clear the dest image */
bzero(pdstLine, sizeDst << 2);
afbGetPixelWidthSizeDepthAndPointer(pDrawable, widthSrc, sizeSrc,
depthSrc, psrcBits);
psrcBits = afbScanline(psrcBits, sx, sy, widthSrc);
start_startbit = PPW - 1 - (sx & PIM);
if ((sx & PIM) + width < PPW) {
maskpartialbits(sx, width, startmask);
nlmiddle = 0;
endmask = 0;
start_endbit = PPW - ((sx + width) & PIM);
} else {
maskbits(sx, width, startmask, endmask, nlmiddle);
start_endbit = 0;
end_endbit = PPW - ((sx + width) & PIM);
}
/* ZPixmap images have either 4 or 8 bits per pixel dependent on
* depth.
*/
if (depthSrc > 4) {
start_dstshift = 24;
shift_step = 8;
} else {
start_dstshift = 28;
shift_step = 4;
}
#define SHIFT_BITS(start_bit,end_bit) \
for (b = (start_bit); b >= (end_bit); b--) { \
dst |= ((srcbits >> b) & 1) << dstshift; \
if ((dstshift -= shift_step) < 0) { \
dstshift = start_dstshift + d; \
*pdst++ = dst; \
dst = *pdst; \
} \
} \
for (d = 0; d < depthSrc; d++, psrcBits += sizeSrc) { /* @@@ NEXT PLANE @@@ */
psrcLine = psrcBits;
pdst = (PixelType *)pdstLine;
h = height;
while (h--) {
psrc = psrcLine;
psrcLine += widthSrc;
dst = *pdst;
dstshift = start_dstshift + d;
if (startmask) {
srcbits = *psrc++ & startmask;
SHIFT_BITS(start_startbit, start_endbit);
}
nl = nlmiddle;
while (nl--) {
srcbits = *psrc++;
SHIFT_BITS(PPW - 1, 0);
}
if (endmask) {
srcbits = *psrc & endmask;
SHIFT_BITS(PPW - 1, end_endbit);
}
if (dstshift != start_dstshift + d)
*pdst++ = dst;
} /* while (h--) */
} /* for (d = ...) */
}
}

472
afb/afbimggblt.c
View File

@ -1,472 +0,0 @@
/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
/***********************************************************
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <X11/X.h>
#include <X11/Xmd.h>
#include <X11/Xproto.h>
#include "afb.h"
#include <X11/fonts/fontstruct.h>
#include "dixfontstr.h"
#include "gcstruct.h"
#include "windowstr.h"
#include "scrnintstr.h"
#include "pixmapstr.h"
#include "regionstr.h"
#include "maskbits.h"
/*
we should eventually special-case fixed-width fonts for ImageText.
this works for fonts with glyphs <= 32 bits wide.
the clipping calculations are done for worst-case fonts.
we make no assumptions about the heights, widths, or bearings
of the glyphs. if we knew that the glyphs are all the same height,
we could clip the tops and bottoms per clipping box, rather
than per character per clipping box. if we knew that the glyphs'
left and right bearings were wlle-behaved, we could clip a single
character at the start, output until the last unclipped
character, and then clip the last one. this is all straightforward
to determine based on max-bounds and min-bounds from the font.
there is some inefficiency introduced in the per-character
clipping to make what's going on clearer.
(it is possible, for example, for a font to be defined in which the
next-to-last character in a font would be clipped out, but the last
one wouldn't. the code below deals with this.)
Image text looks at the bits in the glyph and the fg and bg in the
GC. it paints a rectangle, as defined in the protocol dcoument,
and the paints the characters.
the register allocations for startmask and endmask may not
be the right thing. are there two other deserving candidates?
xoff, pdst, pglyph, and tmpSrc seem like the right things, though.
*/
void
afbImageGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
DrawablePtr pDrawable;
GC *pGC;
int x, y;
unsigned int nglyph;
CharInfoPtr *ppci; /* array of character info */
pointer pglyphBase; /* start of array of glyphs */
{
ExtentInfoRec info; /* used by QueryGlyphExtents() */
BoxRec bbox; /* string's bounding box */
xRectangle backrect;/* backing rectangle to paint.
in the general case, NOT necessarily
the same as the string's bounding box
*/
CharInfoPtr pci;
int xorg, yorg; /* origin of drawable in bitmap */
int widthDst; /* width of dst in longwords */
/* these keep track of the character origin */
PixelType *pdstBase;
/* points to longword with character origin */
int xchar; /* xorigin of char (mod 32) */
/* these are used for placing the glyph */
register int xoff; /* x offset of left edge of glyph (mod 32) */
register PixelType *pdst;
/* pointer to current longword in dst */
register int d;
int depthDst;
int sizeDst;
int hSave;
int w; /* width of glyph in bits */
int h; /* height of glyph */
int widthGlyph; /* width of glyph, in bytes */
unsigned char rrops[AFB_MAX_DEPTH];
register unsigned char *pglyph;
/* pointer to current row of glyph */
unsigned char *pglyphSave;
/* used for putting down glyph */
register PixelType tmpSrc;
/* for getting bits from glyph */
register PixelType startmask;
register PixelType endmask;
register int nFirst;/* bits of glyph in current longword */
PixelType *pdstSave;
int oldFill;
afbPrivGC *pPriv = (afbPrivGC *)dixLookupPrivate(&pGC->devPrivates,
afbGCPrivateKey);
xorg = pDrawable->x;
yorg = pDrawable->y;
afbGetPixelWidthSizeDepthAndPointer(pDrawable, widthDst, sizeDst, depthDst,
pdstBase);
QueryGlyphExtents(pGC->font, ppci, (unsigned long)nglyph, &info);
backrect.x = x;
backrect.y = y - FONTASCENT(pGC->font);
backrect.width = info.overallWidth;
backrect.height = FONTASCENT(pGC->font) + FONTDESCENT(pGC->font);
x += xorg;
y += yorg;
bbox.x1 = x + info.overallLeft;
bbox.x2 = x + info.overallRight;
bbox.y1 = y - info.overallAscent;
bbox.y2 = y + info.overallDescent;
oldFill = pGC->fillStyle;
pGC->fillStyle = FillSolid;
afbReduceRop (pGC->alu, pGC->bgPixel, pGC->planemask, pGC->depth,
pPriv->rrops);
afbPolyFillRect(pDrawable, pGC, 1, &backrect);
pGC->fillStyle = oldFill;
afbReduceRop (pGC->alu, pGC->fgPixel, pGC->planemask, pGC->depth,
pPriv->rrops);
afbReduceRop (GXcopy, pGC->fgPixel, pGC->planemask, pGC->depth, rrops);
/* the faint-hearted can open their eyes now */
switch (RECT_IN_REGION(pGC->pScreen, pGC->pCompositeClip, &bbox)) {
case rgnOUT:
break;
case rgnIN:
pdstBase = afbScanlineNoBankSwitch(pdstBase, x, y, widthDst);
xchar = x & PIM;
while(nglyph--) {
pci = *ppci;
pglyphSave = FONTGLYPHBITS(pglyphBase, pci);
w = pci->metrics.rightSideBearing - pci->metrics.leftSideBearing;
hSave = pci->metrics.ascent + pci->metrics.descent;
widthGlyph = GLYPHWIDTHBYTESPADDED(pci);
/* start at top scanline of glyph */
pdstSave = afbScanlineDelta(pdstBase, -pci->metrics.ascent,
widthDst);
/* find correct word in scanline and x offset within it
for left edge of glyph
*/
xoff = xchar + pci->metrics.leftSideBearing;
if (xoff > PLST) {
pdstSave++;
xoff &= PIM;
} else if (xoff < 0) {
xoff += PPW;
pdstSave--;
}
for (d = 0; d < depthDst; d++) {
h = hSave;
pdst = pdstSave;
pdstSave += sizeDst; /* @@@ NEXT PLANE @@@ */
pglyph = pglyphSave;
if ((xoff + w) <= PPW) {
/* glyph all in one longword */
maskpartialbits(xoff, w, startmask);
switch (rrops[d]) {
case RROP_BLACK:
while (h--) {
getleftbits(pglyph, w, tmpSrc);
*pdst &= ~(SCRRIGHT(tmpSrc, xoff) & startmask);
pglyph += widthGlyph;
afbScanlineInc(pdst, widthDst);
}
break;
case RROP_WHITE:
while (h--) {
getleftbits(pglyph, w, tmpSrc);
*pdst |= SCRRIGHT(tmpSrc, xoff) & startmask;
pglyph += widthGlyph;
afbScanlineInc(pdst, widthDst);
}
break;
case RROP_NOP:
break;
}
} else {
/* glyph crosses longword boundary */
maskPPWbits(xoff, w, startmask, endmask);
nFirst = PPW - xoff;
switch (rrops[d]) {
case RROP_BLACK:
while (h--) {
getleftbits(pglyph, w, tmpSrc);
*pdst &= ~(SCRRIGHT(tmpSrc, xoff) & startmask);
*(pdst+1) &= ~(SCRLEFT(tmpSrc, nFirst) & endmask);
pglyph += widthGlyph;
afbScanlineInc(pdst, widthDst);
}
break;
case RROP_WHITE:
while (h--) {
getleftbits(pglyph, w, tmpSrc);
*pdst |= SCRRIGHT(tmpSrc, xoff) & startmask;
*(pdst+1) |= SCRLEFT(tmpSrc, nFirst) & endmask;
pglyph += widthGlyph;
afbScanlineInc(pdst, widthDst);
}
break;
case RROP_NOP:
break;
}
} /* glyph crosses longwords boundary */
} /* depth loop */
/* update character origin */
x += pci->metrics.characterWidth;
xchar += pci->metrics.characterWidth;
if (xchar > PLST) {
xchar -= PPW;
pdstBase++;
} else if (xchar < 0) {
xchar += PPW;
pdstBase--;
}
ppci++;
} /* while nglyph-- */
break;
case rgnPART:
{
afbTEXTPOS *ppos;
int nbox;
BoxPtr pbox;
RegionPtr cclip;
int xpos; /* x position of char origin */
int i;
BoxRec clip;
int leftEdge, rightEdge;
int topEdge, bottomEdge;
int glyphRow; /* first row of glyph not wholly
clipped out */
int glyphCol; /* leftmost visible column of glyph */
#if GETLEFTBITS_ALIGNMENT > 1
int getWidth; /* bits to get from glyph */
#endif
if(!(ppos = (afbTEXTPOS *)xalloc(nglyph * sizeof(afbTEXTPOS))))
return;
pdstBase = afbScanlineNoBankSwitch(pdstBase, x, y, widthDst);
xpos = x;
xchar = xpos & PIM;
for (i = 0; i < nglyph; i++) {
pci = ppci[i];
ppos[i].xpos = xpos;
ppos[i].xchar = xchar;
ppos[i].leftEdge = xpos + pci->metrics.leftSideBearing;
ppos[i].rightEdge = xpos + pci->metrics.rightSideBearing;
ppos[i].topEdge = y - pci->metrics.ascent;
ppos[i].bottomEdge = y + pci->metrics.descent;
ppos[i].pdstBase = pdstBase;
ppos[i].widthGlyph = GLYPHWIDTHBYTESPADDED(pci);
xpos += pci->metrics.characterWidth;
xchar += pci->metrics.characterWidth;
if (xchar > PLST) {
xchar &= PIM;
pdstBase++;
} else if (xchar < 0) {
xchar += PPW;
pdstBase--;
}
}
cclip = pGC->pCompositeClip;
pbox = REGION_RECTS(cclip);
nbox = REGION_NUM_RECTS(cclip);
/* HACK ALERT
since we continue out of the loop below so often, it
is easier to increment pbox at the top than at the end.
don't try this at home.
*/
pbox--;
while(nbox--) {
pbox++;
clip.x1 = max(bbox.x1, pbox->x1);
clip.y1 = max(bbox.y1, pbox->y1);
clip.x2 = min(bbox.x2, pbox->x2);
clip.y2 = min(bbox.y2, pbox->y2);
if ((clip.x2<=clip.x1) || (clip.y2<=clip.y1))
continue;
for(i=0; i<nglyph; i++) {
pci = ppci[i];
xchar = ppos[i].xchar;
/* clip the left and right edges */
if (ppos[i].leftEdge < clip.x1)
leftEdge = clip.x1;
else
leftEdge = ppos[i].leftEdge;
if (ppos[i].rightEdge > clip.x2)
rightEdge = clip.x2;
else
rightEdge = ppos[i].rightEdge;
w = rightEdge - leftEdge;
if (w <= 0)
continue;
/* clip the top and bottom edges */
if (ppos[i].topEdge < clip.y1)
topEdge = clip.y1;
else
topEdge = ppos[i].topEdge;
if (ppos[i].bottomEdge > clip.y2)
bottomEdge = clip.y2;
else
bottomEdge = ppos[i].bottomEdge;
hSave = bottomEdge - topEdge;
if (hSave <= 0)
continue;
glyphRow = (topEdge - y) + pci->metrics.ascent;
widthGlyph = ppos[i].widthGlyph;
pglyphSave = FONTGLYPHBITS(pglyphBase, pci);
pglyphSave += (glyphRow * widthGlyph);
glyphCol = (leftEdge - ppos[i].xpos) -
(pci->metrics.leftSideBearing);
#if GETLEFTBITS_ALIGNMENT > 1
getWidth = w + glyphCol;
#endif
pdstSave = afbScanlineDelta(ppos[i].pdstBase, -(y-topEdge),
widthDst);
xoff = xchar + (leftEdge - ppos[i].xpos);
if (xoff > PLST) {
xoff &= PIM;
pdstSave++;
} else if (xoff < 0) {
xoff += PPW;
pdstSave--;
}
for (d = 0; d < depthDst; d++) {
h = hSave;
pdst = pdstSave;
pdstSave += sizeDst; /* @@@ NEXT PLANE @@@ */
pglyph = pglyphSave;
if ((xoff + w) <= PPW) {
maskpartialbits(xoff, w, startmask);
switch (rrops[d]) {
case RROP_BLACK:
while (h--) {
getshiftedleftbits(pglyph, glyphCol, getWidth, tmpSrc);
*pdst &= ~(SCRRIGHT(tmpSrc, xoff) & startmask);
pglyph += widthGlyph;
afbScanlineInc(pdst, widthDst);
}
break;
case RROP_WHITE:
while (h--) {
getshiftedleftbits(pglyph, glyphCol, getWidth, tmpSrc);
*pdst |= SCRRIGHT(tmpSrc, xoff) & startmask;
pglyph += widthGlyph;
afbScanlineInc(pdst, widthDst);
}
break;
case RROP_NOP:
break;
}
} else {
maskPPWbits(xoff, w, startmask, endmask);
nFirst = PPW - xoff;
switch (rrops[d]) {
case RROP_BLACK:
while (h--) {
getshiftedleftbits(pglyph, glyphCol, getWidth, tmpSrc);
*pdst &= ~(SCRRIGHT(tmpSrc, xoff) & startmask);
*(pdst+1) &= ~(SCRLEFT(tmpSrc, nFirst) & endmask);
pglyph += widthGlyph;
afbScanlineInc(pdst, widthDst);
}
break;
case RROP_WHITE:
while (h--) {
getshiftedleftbits(pglyph, glyphCol, getWidth, tmpSrc);
*pdst |= SCRRIGHT(tmpSrc, xoff) & startmask;
*(pdst+1) |= SCRLEFT(tmpSrc, nFirst) & endmask;
pglyph += widthGlyph;
afbScanlineInc(pdst, widthDst);
}
break;
case RROP_NOP:
break;
}
}
} /* depth */
} /* for each glyph */
} /* while nbox-- */
xfree(ppos);
break;
}
default:
break;
}
}

707
afb/afbline.c
View File

@ -1,707 +0,0 @@
/***********************************************************
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <X11/X.h>
#include <stdlib.h>
#include "gcstruct.h"
#include "windowstr.h"
#include "pixmapstr.h"
#include "regionstr.h"
#include "scrnintstr.h"
#include "mistruct.h"
#include "afb.h"
#include "maskbits.h"
#include "miline.h"
/* single-pixel lines on a color frame buffer
NON-SLOPED LINES
horizontal lines are always drawn left to right; we have to
move the endpoints right by one after they're swapped.
horizontal lines will be confined to a single band of a
region. the code finds that band (giving up if the lower
bound of the band is above the line we're drawing); then it
finds the first box in that band that contains part of the
line. we clip the line to subsequent boxes in that band.
vertical lines are always drawn top to bottom (y-increasing.)
this requires adding one to the y-coordinate of each endpoint
after swapping.
SLOPED LINES
when clipping a sloped line, we bring the second point inside
the clipping box, rather than one beyond it, and then add 1 to
the length of the line before drawing it. this lets us use
the same box for finding the outcodes for both endpoints. since
the equation for clipping the second endpoint to an edge gives us
1 beyond the edge, we then have to move the point towards the
first point by one step on the major axis.
eventually, there will be a diagram here to explain what's going
on. the method uses Cohen-Sutherland outcodes to determine
outsideness, and a method similar to Pike's layers for doing the
actual clipping.
*/
void
#ifdef POLYSEGMENT
afbSegmentSS(pDrawable, pGC, nseg, pSeg)
DrawablePtr pDrawable;
GCPtr pGC;
int nseg;
register xSegment *pSeg;
#else
afbLineSS(pDrawable, pGC, mode, npt, pptInit)
DrawablePtr pDrawable;
GCPtr pGC;
int mode; /* Origin or Previous */
int npt; /* number of points */
DDXPointPtr pptInit;
#endif
{
int nboxInit;
register int nbox;
BoxPtr pboxInit;
register BoxPtr pbox;
#ifndef POLYSEGMENT
register DDXPointPtr ppt; /* pointer to list of translated points */
#endif
unsigned int oc1; /* outcode of point 1 */
unsigned int oc2; /* outcode of point 2 */
PixelType *addrlBase; /* pointer to start of drawable */
int nlwidth; /* width in longwords of destination pixmap */
int xorg, yorg; /* origin of window */
int adx; /* abs values of dx and dy */
int ady;
int signdx; /* sign of dx and dy */
int signdy;
int e, e1, e2; /* bresenham error and increments */
int len; /* length of segment */
int axis; /* major axis */
int octant;
unsigned int bias = miGetZeroLineBias(pDrawable->pScreen);
int depthDst;
#ifndef POLYSEGMENT
PixelType *addrl; /* address of destination pixmap */
int d;
#endif
int sizeDst;
unsigned char *rrops;
/* a bunch of temporaries */
register int y1, y2;
register int x1, x2;
RegionPtr cclip;
cclip = pGC->pCompositeClip;
rrops = ((afbPrivGC *)dixLookupPrivate(&pGC->devPrivates,
afbGCPrivateKey))->rrops;
pboxInit = REGION_RECTS(cclip);
nboxInit = REGION_NUM_RECTS(cclip);
afbGetPixelWidthSizeDepthAndPointer(pDrawable, nlwidth, sizeDst, depthDst,
addrlBase);
xorg = pDrawable->x;
yorg = pDrawable->y;
#ifdef POLYSEGMENT
while (nseg--)
#else
ppt = pptInit;
x2 = ppt->x + xorg;
y2 = ppt->y + yorg;
while(--npt)
#endif
{
nbox = nboxInit;
pbox = pboxInit;
#ifdef POLYSEGMENT
x1 = pSeg->x1 + xorg;
y1 = pSeg->y1 + yorg;
x2 = pSeg->x2 + xorg;
y2 = pSeg->y2 + yorg;
pSeg++;
#else
x1 = x2;
y1 = y2;
++ppt;
if (mode == CoordModePrevious) {
xorg = x1;
yorg = y1;
}
x2 = ppt->x + xorg;
y2 = ppt->y + yorg;
#endif
if (x1 == x2) /* vertical line */
{
/* make the line go top to bottom of screen, keeping
endpoint semantics
*/
if (y1 > y2) {
register int tmp;
tmp = y2;
y2 = y1 + 1;
y1 = tmp + 1;
#ifdef POLYSEGMENT
if (pGC->capStyle != CapNotLast)
y1--;
#endif
}
#ifdef POLYSEGMENT
else if (pGC->capStyle != CapNotLast)
y2++;
#endif
/* get to first band that might contain part of line */
while ((nbox) && (pbox->y2 <= y1)) {
pbox++;
nbox--;
}
if (nbox) {
/* stop when lower edge of box is beyond end of line */
while((nbox) && (y2 >= pbox->y1)) {
if ((x1 >= pbox->x1) && (x1 < pbox->x2)) {
int y1t, y2t;
/* this box has part of the line in it */
y1t = max(y1, pbox->y1);
y2t = min(y2, pbox->y2);
if (y1t != y2t)
afbVertS(addrlBase, nlwidth, sizeDst, depthDst, x1, y1t,
y2t-y1t, rrops); /* @@@ NEXT PLANE PASSED @@@ */
}
nbox--;
pbox++;
}
}
#ifndef POLYSEGMENT
y2 = ppt->y + yorg;
#endif
} else if (y1 == y2) /* horizontal line */ {
/* force line from left to right, keeping
endpoint semantics
*/
if (x1 > x2) {
register int tmp;
tmp = x2;
x2 = x1 + 1;
x1 = tmp + 1;
#ifdef POLYSEGMENT
if (pGC->capStyle != CapNotLast)
x1--;
#endif
}
#ifdef POLYSEGMENT
else if (pGC->capStyle != CapNotLast)
x2++;
#endif
/* find the correct band */
while( (nbox) && (pbox->y2 <= y1)) {
pbox++;
nbox--;
}
/* try to draw the line, if we haven't gone beyond it */
if ((nbox) && (pbox->y1 <= y1)) {
int tmp;
/* when we leave this band, we're done */
tmp = pbox->y1;
while((nbox) && (pbox->y1 == tmp)) {
int x1t, x2t;
if (pbox->x2 <= x1) {
/* skip boxes until one might contain start point */
nbox--;
pbox++;
continue;
}
/* stop if left of box is beyond right of line */
if (pbox->x1 >= x2) {
nbox = 0;
break;
}
x1t = max(x1, pbox->x1);
x2t = min(x2, pbox->x2);
if (x1t != x2t)
afbHorzS(addrlBase, nlwidth, sizeDst, depthDst, x1t, y1,
x2t-x1t, rrops); /* @@@ NEXT PLANE PASSED @@@ */
nbox--;
pbox++;
}
}
#ifndef POLYSEGMENT
x2 = ppt->x + xorg;
#endif
}
else /* sloped line */
{
CalcLineDeltas(x1, y1, x2, y2, adx, ady,
signdx, signdy, 1, 1, octant);
if (adx > ady) {
axis = X_AXIS;
e1 = ady << 1;
e2 = e1 - (adx << 1);
e = e1 - adx;
} else {
axis = Y_AXIS;
e1 = adx << 1;
e2 = e1 - (ady << 1);
e = e1 - ady;
SetYMajorOctant(octant);
}
FIXUP_ERROR(e, octant, bias);
/* we have bresenham parameters and two points.
all we have to do now is clip and draw.
*/
while(nbox--) {
oc1 = 0;
oc2 = 0;
OUTCODES(oc1, x1, y1, pbox);
OUTCODES(oc2, x2, y2, pbox);
if ((oc1 | oc2) == 0) {
if (axis == X_AXIS)
len = adx;
else
len = ady;
#ifdef POLYSEGMENT
if (pGC->capStyle != CapNotLast)
len++;
#endif
afbBresS(addrlBase, nlwidth, sizeDst, depthDst, signdx, signdy,
axis, x1, y1, e, e1, e2, len, rrops); /* @@@ NEXT PLANE PASSED @@@ */
break;
} else if (oc1 & oc2) {
pbox++;
} else {
int new_x1 = x1, new_y1 = y1, new_x2 = x2, new_y2 = y2;
int clip1 = 0, clip2 = 0;
int clipdx, clipdy;
int err;
if (miZeroClipLine(pbox->x1, pbox->y1, pbox->x2-1,
pbox->y2-1,
&new_x1, &new_y1, &new_x2, &new_y2,
adx, ady, &clip1, &clip2,
octant, bias, oc1, oc2) == -1) {
pbox++;
continue;
}
if (axis == X_AXIS)
len = abs(new_x2 - new_x1);
else
len = abs(new_y2 - new_y1);
#ifdef POLYSEGMENT
if (clip2 != 0 || pGC->capStyle != CapNotLast)
len++;
#else
len += (clip2 != 0);
#endif
if (len) {
/* unwind bresenham error term to first point */
if (clip1) {
clipdx = abs(new_x1 - x1);
clipdy = abs(new_y1 - y1);
if (axis == X_AXIS)
err = e+((clipdy*e2) + ((clipdx-clipdy)*e1));
else
err = e+((clipdx*e2) + ((clipdy-clipdx)*e1));
}
else
err = e;
afbBresS(addrlBase, nlwidth, sizeDst, depthDst, signdx,
signdy, axis, new_x1, new_y1, err, e1, e2, len,
rrops); /* @@@ NEXT PLANE PASSED @@@ */
}
pbox++;
}
} /* while (nbox--) */
} /* sloped line */
} /* while (nline--) */
#ifndef POLYSEGMENT
/* paint the last point if the end style isn't CapNotLast.
(Assume that a projecting, butt, or round cap that is one
pixel wide is the same as the single pixel of the endpoint.)
*/
if ((pGC->capStyle != CapNotLast) &&
((ppt->x + xorg != pptInit->x + pDrawable->x) ||
(ppt->y + yorg != pptInit->y + pDrawable->y) ||
(ppt == pptInit + 1))) {
nbox = nboxInit;
pbox = pboxInit;
while (nbox--) {
if ((x2 >= pbox->x1) && (y2 >= pbox->y1) && (x2 < pbox->x2) &&
(y2 < pbox->y2)) {
for (d = 0; d < depthDst; d++) {
addrl = afbScanline(addrlBase, x2, y2, nlwidth);
addrlBase += sizeDst; /* @@@ NEXT PLANE @@@ */
switch(rrops[d]) {
case RROP_BLACK:
*addrl &= mfbGetrmask(x2 & PIM);
break;
case RROP_WHITE:
*addrl |= mfbGetmask(x2 & PIM);
break;
case RROP_INVERT:
*addrl ^= mfbGetmask(x2 & PIM);
break;
case RROP_NOP:
break;
} /* switch */
} /* for (d = ...) */
break;
} else
pbox++;
}
}
#endif
}
/*
* Draw dashed 1-pixel lines.
*/
void
#ifdef POLYSEGMENT
afbSegmentSD(pDrawable, pGC, nseg, pSeg)
DrawablePtr pDrawable;
register GCPtr pGC;
int nseg;
register xSegment *pSeg;
#else
afbLineSD(pDrawable, pGC, mode, npt, pptInit)
DrawablePtr pDrawable;
register GCPtr pGC;
int mode; /* Origin or Previous */
int npt; /* number of points */
DDXPointPtr pptInit;
#endif
{
int nboxInit;
register int nbox;
BoxPtr pboxInit;
register BoxPtr pbox;
#ifndef POLYSEGMENT
register DDXPointPtr ppt; /* pointer to list of translated points */
#endif
register unsigned int oc1; /* outcode of point 1 */
register unsigned int oc2; /* outcode of point 2 */
PixelType *addrlBase; /* address of destination pixmap */
int nlwidth; /* width in longwords of destination pixmap */
int sizeDst;
int depthDst;
int xorg, yorg; /* origin of window */
int adx; /* abs values of dx and dy */
int ady;
int signdx; /* sign of dx and dy */
int signdy;
int e, e1, e2; /* bresenham error and increments */
int len; /* length of segment */
int axis; /* major axis */
int octant;
unsigned int bias = miGetZeroLineBias(pDrawable->pScreen);
int x1, x2, y1, y2;
RegionPtr cclip;
unsigned char *rrops;
unsigned char bgrrops[AFB_MAX_DEPTH];
unsigned char *pDash;
int dashOffset;
int numInDashList;
int dashIndex;
int isDoubleDash;
int dashIndexTmp, dashOffsetTmp;
int unclippedlen;
#ifndef POLYSEGMENT
PixelType *addrl;
int d;
#endif
cclip = pGC->pCompositeClip;
rrops = ((afbPrivGC *)dixLookupPrivate(&pGC->devPrivates,
afbGCPrivateKey))->rrops;
pboxInit = REGION_RECTS(cclip);
nboxInit = REGION_NUM_RECTS(cclip);
afbGetPixelWidthSizeDepthAndPointer(pDrawable, nlwidth, sizeDst, depthDst,
addrlBase);
/* compute initial dash values */
pDash = (unsigned char *) pGC->dash;
numInDashList = pGC->numInDashList;
isDoubleDash = (pGC->lineStyle == LineDoubleDash);
dashIndex = 0;
dashOffset = 0;
miStepDash ((int)pGC->dashOffset, &dashIndex, pDash,
numInDashList, &dashOffset);
if (isDoubleDash)
afbReduceRop (pGC->alu, pGC->bgPixel, pGC->planemask, pGC->depth,
bgrrops);
xorg = pDrawable->x;
yorg = pDrawable->y;
#ifdef POLYSEGMENT
while (nseg--)
#else
ppt = pptInit;
x2 = ppt->x + xorg;
y2 = ppt->y + yorg;
while(--npt)
#endif
{
nbox = nboxInit;
pbox = pboxInit;
#ifdef POLYSEGMENT
x1 = pSeg->x1 + xorg;
y1 = pSeg->y1 + yorg;
x2 = pSeg->x2 + xorg;
y2 = pSeg->y2 + yorg;
pSeg++;
#else
x1 = x2;
y1 = y2;
++ppt;
if (mode == CoordModePrevious) {
xorg = x1;
yorg = y1;
}
x2 = ppt->x + xorg;
y2 = ppt->y + yorg;
#endif
CalcLineDeltas(x1, y1, x2, y2, adx, ady, signdx, signdy,
1, 1, octant);
if (adx > ady) {
axis = X_AXIS;
e1 = ady << 1;
e2 = e1 - (adx << 1);
e = e1 - adx;
unclippedlen = adx;
} else {
axis = Y_AXIS;
e1 = adx << 1;
e2 = e1 - (ady << 1);
e = e1 - ady;
unclippedlen = ady;
SetYMajorOctant(octant);
}
FIXUP_ERROR(e, octant, bias);
/* we have bresenham parameters and two points.
all we have to do now is clip and draw.
*/
while(nbox--) {
oc1 = 0;
oc2 = 0;
OUTCODES(oc1, x1, y1, pbox);
OUTCODES(oc2, x2, y2, pbox);
if ((oc1 | oc2) == 0) {
#ifdef POLYSEGMENT
if (pGC->capStyle != CapNotLast)
unclippedlen++;
dashIndexTmp = dashIndex;
dashOffsetTmp = dashOffset;
afbBresD(&dashIndexTmp, pDash, numInDashList, &dashOffsetTmp,
isDoubleDash, addrlBase, nlwidth, sizeDst, depthDst,
signdx, signdy, axis, x1, y1, e, e1, e2, unclippedlen,
rrops, bgrrops); /* @@@ NEXT PLANE PASSED @@@ */
break;
#else
afbBresD(&dashIndex, pDash, numInDashList, &dashOffset,
isDoubleDash, addrlBase, nlwidth, sizeDst, depthDst,
signdx, signdy, axis, x1, y1, e, e1, e2, unclippedlen,
rrops, bgrrops); /* @@@ NEXT PLANE PASSED @@@ */
goto dontStep;
#endif
} else if (oc1 & oc2) {
pbox++;
} else /* have to clip */ {
int new_x1 = x1, new_y1 = y1, new_x2 = x2, new_y2 = y2;
int clip1 = 0, clip2 = 0;
int clipdx, clipdy;
int err;
if (miZeroClipLine(pbox->x1, pbox->y1, pbox->x2-1, pbox->y2-1,
&new_x1, &new_y1, &new_x2, &new_y2,
adx, ady, &clip1, &clip2,
octant, bias, oc1, oc2) == -1) {
pbox++;
continue;
}
dashIndexTmp = dashIndex;
dashOffsetTmp = dashOffset;
if (clip1) {
int dlen;
if (axis == X_AXIS)
dlen = abs(new_x1 - x1);
else
dlen = abs(new_y1 - y1);
miStepDash (dlen, &dashIndexTmp, pDash,
numInDashList, &dashOffsetTmp);
}
if (axis == X_AXIS)
len = abs(new_x2 - new_x1);
else
len = abs(new_y2 - new_y1);
#ifdef POLYSEGMENT
if (clip2 != 0 || pGC->capStyle != CapNotLast)
len++;
#else
len += (clip2 != 0);
#endif
if (len) {
/* unwind bresenham error term to first point */
if (clip1) {
clipdx = abs(new_x1 - x1);
clipdy = abs(new_y1 - y1);
if (axis == X_AXIS)
err = e+((clipdy*e2) + ((clipdx-clipdy)*e1));
else
err = e+((clipdx*e2) + ((clipdy-clipdx)*e1));
}
else
err = e;
afbBresD(&dashIndexTmp, pDash, numInDashList, &dashOffsetTmp,
isDoubleDash, addrlBase, nlwidth, sizeDst, depthDst,
signdx, signdy, axis, new_x1, new_y1, err, e1, e2,
len, rrops, bgrrops); /* @@@ NEXT PLANE PASSED @@@ */
}
pbox++;
}
} /* while (nbox--) */
#ifndef POLYSEGMENT
/*
* walk the dash list around to the next line
*/
miStepDash (unclippedlen, &dashIndex, pDash,
numInDashList, &dashOffset);
dontStep: ;
#endif
} /* while (nline--) */
#ifndef POLYSEGMENT
/* paint the last point if the end style isn't CapNotLast.
(Assume that a projecting, butt, or round cap that is one
pixel wide is the same as the single pixel of the endpoint.)
*/
if ((pGC->capStyle != CapNotLast) &&
((dashIndex & 1) == 0 || isDoubleDash) &&
((ppt->x + xorg != pptInit->x + pDrawable->x) ||
(ppt->y + yorg != pptInit->y + pDrawable->y) ||
(ppt == pptInit + 1))) {
nbox = nboxInit;
pbox = pboxInit;
while (nbox--) {
if ((x2 >= pbox->x1) && (y2 >= pbox->y1) && (x2 < pbox->x2) &&
(y2 < pbox->y2)) {
int rop;
for (d = 0; d < depthDst; d++) {
addrl = afbScanline(addrlBase, x2, y2, nlwidth);
addrlBase += sizeDst; /* @@@ NEXT PLANE @@@ */
rop = rrops[d];
if (dashIndex & 1)
rop = bgrrops[d];
switch (rop) {
case RROP_BLACK:
*addrl &= mfbGetrmask(x2 & PIM);
break;
case RROP_WHITE:
*addrl |= mfbGetmask(x2 & PIM);
break;
case RROP_INVERT:
*addrl ^= mfbGetmask(x2 & PIM);
break;
case RROP_NOP:
break;
}
} /* for (d = ...) */
break;
} else
pbox++;
}
}
#endif
}

94
afb/afbmisc.c
View File

@ -1,94 +0,0 @@
/***********************************************************
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <X11/X.h>
#include "misc.h"
#include "cursor.h"
#include "scrnintstr.h"
#include "afb.h"
/*ARGSUSED*/
void
afbQueryBestSize(class, pwidth, pheight, pScreen)
int class;
unsigned short *pwidth;
unsigned short *pheight;
ScreenPtr pScreen;
{
unsigned width, test;
switch(class) {
case CursorShape:
if (*pwidth > pScreen->width)
*pwidth = pScreen->width;
if (*pheight > pScreen->height)
*pheight = pScreen->height;
break;
case TileShape:
case StippleShape:
width = *pwidth;
if (!width) break;
/* Return the closes power of two not less than what they gave me */
test = 0x80000000;
/* Find the highest 1 bit in the width given */
while(!(test & width))
test >>= 1;
/* If their number is greater than that, bump up to the next
* power of two */
if((test - 1) & width)
test <<= 1;
*pwidth = test;
/* We don't care what height they use */
break;
}
}

299
afb/afbpixmap.c
View File

@ -1,299 +0,0 @@
/***********************************************************
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
/* pixmap management
written by drewry, september 1986
on a monchrome device, a pixmap is a bitmap.
*/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <string.h>
#include <X11/Xmd.h>
#include "scrnintstr.h"
#include "pixmapstr.h"
#include "maskbits.h"
#include "afb.h"
#include "mi.h"
#include "servermd.h"
#include "mfb.h"
PixmapPtr
afbCreatePixmap(pScreen, width, height, depth, usage_hint)
ScreenPtr pScreen;
int width;
int height;
int depth;
unsigned usage_hint;
{
PixmapPtr pPixmap;
size_t datasize;
size_t paddedWidth;
paddedWidth = BitmapBytePad(width);
if (paddedWidth > 32767 || height > 32767 || depth > 4)
return NullPixmap;
datasize = height * paddedWidth * depth;
pPixmap = AllocatePixmap(pScreen, datasize);
if (!pPixmap)
return(NullPixmap);
pPixmap->drawable.type = DRAWABLE_PIXMAP;
pPixmap->drawable.class = 0;
pPixmap->drawable.pScreen = pScreen;
pPixmap->drawable.depth = depth;
pPixmap->drawable.bitsPerPixel = depth;
pPixmap->drawable.id = 0;
pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
pPixmap->drawable.x = 0;
pPixmap->drawable.y = 0;
pPixmap->drawable.width = width;
pPixmap->drawable.height = height;
pPixmap->devKind = paddedWidth;
pPixmap->refcnt = 1;
pPixmap->devPrivate.ptr = datasize ?
(pointer)((char *)pPixmap + pScreen->totalPixmapSize) : NULL;
pPixmap->usage_hint = usage_hint;
return(pPixmap);
}
Bool
afbDestroyPixmap(pPixmap)
PixmapPtr pPixmap;
{
if(--pPixmap->refcnt)
return(TRUE);
dixFreePrivates(pPixmap->devPrivates);
xfree(pPixmap);
return(TRUE);
}
static PixmapPtr
afbCopyPixmap(PixmapPtr pSrc)
{
register PixmapPtr pDst;
int size;
ScreenPtr pScreen;
size = pSrc->drawable.height * pSrc->devKind * pSrc->drawable.depth;
pScreen = pSrc->drawable.pScreen;
pDst = (*pScreen->CreatePixmap)(pScreen,
pSrc->drawable.width,
pSrc->drawable.height,
pSrc->drawable.depth, 0);
if (!pDst)
return(NullPixmap);
memmove((char *)pDst->devPrivate.ptr, (char *)pSrc->devPrivate.ptr, size);
return(pDst);
}
/* replicates a pattern to be a full 32 bits wide.
relies on the fact that each scnaline is longword padded.
doesn't do anything if pixmap is not a factor of 32 wide.
changes width field of pixmap if successful, so that the fast
XRotatePixmap code gets used if we rotate the pixmap later.
calculate number of times to repeat
for each scanline of pattern
zero out area to be filled with replicate
left shift and or in original as many times as needed
*/
static void
afbPadPixmap(PixmapPtr pPixmap)
{
register int width = pPixmap->drawable.width;
register int h;
register PixelType mask;
register PixelType *p;
register PixelType bits; /* real pattern bits */
register int i;
int d;
int rep; /* repeat count for pattern */
if (width >= PPW)
return;
rep = PPW/width;
if (rep*width != PPW)
return;
mask = mfbGetendtab(width);
p = (PixelType *)(pPixmap->devPrivate.ptr);
for (d = 0; d < pPixmap->drawable.depth; d++) {
for (h = 0; h < pPixmap->drawable.height; h++) {
*p &= mask;
bits = *p;
for(i = 1; i < rep; i++) {
bits = SCRRIGHT(bits, width);
*p |= bits;
}
p++; /* @@@ NEXT PLANE @@@ */
}
}
pPixmap->drawable.width = PPW;
}
/* Rotates pixmap pPix by w pixels to the right on the screen. Assumes that
* words are PPW bits wide, and that the least significant bit appears on the
* left.
*/
void
afbXRotatePixmap(pPix, rw)
PixmapPtr pPix;
register int rw;
{
register PixelType *pw, *pwFinal;
register PixelType t;
if (pPix == NullPixmap)
return;
pw = (PixelType *)pPix->devPrivate.ptr;
rw %= (int)pPix->drawable.width;
if (rw < 0)
rw += (int)pPix->drawable.width;
if(pPix->drawable.width == PPW) {
pwFinal = pw + pPix->drawable.height * pPix->drawable.depth;
while(pw < pwFinal) {
t = *pw;
*pw++ = SCRRIGHT(t, rw) |
(SCRLEFT(t, (PPW-rw)) & mfbGetendtab(rw));
}
} else {
/* We no longer do this. Validate doesn't try to rotate odd-size
* tiles or stipples. afbUnnatural<tile/stipple>FS works directly off
* the unrotate tile/stipple in the GC
*/
ErrorF("X internal error: trying to rotate odd-sized pixmap.\n");
}
}
/* Rotates pixmap pPix by h lines. Assumes that h is always less than
pPix->height
works on any width.
*/
void
afbYRotatePixmap(pPix, rh)
register PixmapPtr pPix;
int rh;
{
int nbyDown; /* bytes to move down to row 0; also offset of
row rh */
int nbyUp; /* bytes to move up to line rh; also
offset of first line moved down to 0 */
char *pbase;
char *ptmp;
int height;
int d;
if (pPix == NullPixmap)
return;
height = (int) pPix->drawable.height;
rh %= height;
if (rh < 0)
rh += height;
nbyDown = rh * pPix->devKind;
nbyUp = (pPix->devKind * height) - nbyDown;
if(!(ptmp = (char *)xalloc(nbyUp)))
return;
for (d = 0; d < pPix->drawable.depth; d++) {
pbase = (char *)pPix->devPrivate.ptr + pPix->devKind * height * d; /* @@@ NEXT PLANE @@@ */
memmove(ptmp, pbase, nbyUp); /* save the low rows */
memmove(pbase, pbase+nbyUp, nbyDown); /* slide the top rows down */
memmove(pbase+nbyDown, ptmp, nbyUp); /* move lower rows up to row rh */
}
xfree(ptmp);
}
void
afbCopyRotatePixmap(psrcPix, ppdstPix, xrot, yrot)
register PixmapPtr psrcPix, *ppdstPix;
int xrot, yrot;
{
register PixmapPtr pdstPix;
if ((pdstPix = *ppdstPix) &&
(pdstPix->devKind == psrcPix->devKind) &&
(pdstPix->drawable.height == psrcPix->drawable.height) &&
(pdstPix->drawable.depth == psrcPix->drawable.depth)) {
memmove((char *)pdstPix->devPrivate.ptr,
(char *)psrcPix->devPrivate.ptr,
psrcPix->drawable.height * psrcPix->devKind *
psrcPix->drawable.depth);
pdstPix->drawable.width = psrcPix->drawable.width;
pdstPix->drawable.serialNumber = NEXT_SERIAL_NUMBER;
} else {
if (pdstPix)
/* FIX XBUG 6168 */
(*pdstPix->drawable.pScreen->DestroyPixmap)(pdstPix);
*ppdstPix = pdstPix = afbCopyPixmap(psrcPix);
if (!pdstPix)
return;
}
afbPadPixmap(pdstPix);
if (xrot)
afbXRotatePixmap(pdstPix, xrot);
if (yrot)
afbYRotatePixmap(pdstPix, yrot);
}

300
afb/afbply1rct.c
View File

@ -1,300 +0,0 @@
/*
*
Copyright (c) 1990 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
*
* Author: Keith Packard, MIT X Consortium
*/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <stdlib.h>
#include <X11/X.h>
#include "gcstruct.h"
#include "windowstr.h"
#include "pixmapstr.h"
#include "regionstr.h"
#include "scrnintstr.h"
#include "mistruct.h"
#include "afb.h"
#include "maskbits.h"
#if defined(mips) || defined(sparc)
#define GetHighWord(x) (((int)(x)) >> 16)
#else
#define GetHighWord(x) (((int)(x)) / 65536)
#endif
#if IMAGE_BYTE_ORDER == MSBFirst
#define intToCoord(i,x,y) (((x) = GetHighWord(i)), ((y) = (int)((short) (i))))
#define coordToInt(x,y) (((x) << 16) | (y))
#define intToX(i) (GetHighWord(i))
#define intToY(i) ((int)((short) i))
#else
#define intToCoord(i,x,y) (((x) = (int)((short) (i))), ((y) = GetHighWord(i)))
#define coordToInt(x,y) (((y) << 16) | (x))
#define intToX(i) ((int)((short) (i)))
#define intToY(i) (GetHighWord(i))
#endif
void
afbFillPolygonSolid (pDrawable, pGC, shape, mode, count, ptsIn)
DrawablePtr pDrawable;
GCPtr pGC;
int shape;
int mode;
int count;
DDXPointPtr ptsIn;
{
afbPrivGCPtr devPriv;
int nlwidth;
PixelType *addrl, *addr;
int maxy;
int origin;
register int vertex1, vertex2;
int c;
BoxPtr extents;
int clip;
int y;
int *vertex1p = NULL, *vertex2p;
int *endp;
int x1 = 0, x2 = 0;
int dx1 = 0, dx2 = 0;
int dy1 = 0, dy2 = 0;
int e1 = 0, e2 = 0;
int step1 = 0, step2 = 0;
int sign1 = 0, sign2 = 0;
int h;
int l, r;
PixelType mask, bits = ~((PixelType)0);
int nmiddle;
register unsigned char *rrops;
register int n;
register int d;
int sizeDst;
int depthDst;
register PixelType *pdst;
devPriv = (afbPrivGC *)dixLookupPrivate(&pGC->devPrivates,
afbGCPrivateKey);
if (mode == CoordModePrevious || shape != Convex ||
REGION_NUM_RECTS(pGC->pCompositeClip) != 1) {
miFillPolygon (pDrawable, pGC, shape, mode, count, ptsIn);
return;
}
origin = *((int *) &pDrawable->x);
origin -= (origin & 0x8000) << 1;
extents = &pGC->pCompositeClip->extents;
vertex1 = *((int *) &extents->x1) - origin;
vertex2 = *((int *) &extents->x2) - origin - 0x00010001;
clip = 0;
y = 32767;
maxy = 0;
vertex2p = (int *) ptsIn;
endp = vertex2p + count;
while (count--) {
c = *vertex2p;
clip |= (c - vertex1) | (vertex2 - c);
c = intToY(c);
if (c < y) {
y = c;
vertex1p = vertex2p;
}
vertex2p++;
if (c > maxy)
maxy = c;
}
if (y == maxy)
return;
if (clip & 0x80008000) {
miFillPolygon (pDrawable, pGC, shape, mode, vertex2p - (int *) ptsIn, ptsIn);
return;
}
afbGetPixelWidthSizeDepthAndPointer(pDrawable, nlwidth, sizeDst, depthDst,
addrl);
rrops = devPriv->rrops;
addrl = afbScanlineDelta(addrl, y + pDrawable->y, nlwidth);
origin = intToX(origin);
vertex2p = vertex1p;
vertex2 = vertex1 = *vertex2p++;
if (vertex2p == endp)
vertex2p = (int *) ptsIn;
#define Setup(c,x,vertex,dx,dy,e,sign,step) {\
x = intToX(vertex); \
if ((dy = intToY(c) - y)) { \
dx = intToX(c) - x; \
step = 0; \
if (dx >= 0) { \
e = 0; \
sign = 1; \
if (dx >= dy) {\
step = dx / dy; \
dx = dx % dy; \
} \
} else { \
e = 1 - dy; \
sign = -1; \
dx = -dx; \
if (dx >= dy) { \
step = - (dx / dy); \
dx = dx % dy; \
} \
} \
} \
x += origin; \
vertex = c; \
}
#define Step(x,dx,dy,e,sign,step) {\
x += step; \
if ((e += dx) > 0) { \
x += sign; \
e -= dy; \
} \
}
for (;;) {
if (y == intToY(vertex1)) {
do {
if (vertex1p == (int *) ptsIn)
vertex1p = endp;
c = *--vertex1p;
Setup (c,x1,vertex1,dx1,dy1,e1,sign1,step1)
} while (y >= intToY(vertex1));
h = dy1;
} else {
Step(x1,dx1,dy1,e1,sign1,step1)
h = intToY(vertex1) - y;
}
if (y == intToY(vertex2)) {
do {
c = *vertex2p++;
if (vertex2p == endp)
vertex2p = (int *) ptsIn;
Setup (c,x2,vertex2,dx2,dy2,e2,sign2,step2)
} while (y >= intToY(vertex2));
if (dy2 < h)
h = dy2;
} else {
Step(x2,dx2,dy2,e2,sign2,step2)
if ((c = (intToY(vertex2) - y)) < h)
h = c;
}
/* fill spans for this segment */
y += h;
for (;;) {
l = x1;
r = x2;
nmiddle = x2 - x1;
if (nmiddle < 0) {
nmiddle = -nmiddle;
l = x2;
r = x1;
}
c = l & PIM;
l -= c;
l = l >> PWSH;
addr = addrl + l;
if (c + nmiddle < PPW) {
mask = SCRRIGHT (bits,c) ^ SCRRIGHT (bits,c+nmiddle);
for (pdst = addr, d = 0; d < depthDst; d++, pdst += sizeDst) { /* @@@ NEXT PLANE @@@ */
switch (rrops[d]) {
case RROP_BLACK:
*pdst &= ~mask;
break;
case RROP_WHITE:
*pdst |= mask;
break;
case RROP_INVERT:
*pdst ^= mask;
break;
case RROP_NOP:
break;
}
}
} else {
if (c) {
mask = SCRRIGHT(bits, c);
for (pdst = addr, d = 0; d < depthDst; d++, pdst += sizeDst) { /* @@@ NEXT PLANE @@@ */
switch (rrops[d]) {
case RROP_BLACK:
*pdst &= ~mask;
break;
case RROP_WHITE:
*pdst |= mask;
break;
case RROP_INVERT:
*pdst ^= mask;
break;
case RROP_NOP:
break;
}
}
nmiddle += c - PPW;
addr++;
}
nmiddle >>= PWSH;
mask = ~SCRRIGHT(bits, r & PIM);
for (d = 0; d < depthDst; d++, addr += sizeDst) { /* @@@ NEXT PLANE @@@ */
n = nmiddle;
pdst = addr;
switch (rrops[d]) {
case RROP_BLACK:
Duff (n, *pdst++ = 0;)
if (mask)
*pdst &= ~mask;
break;
case RROP_WHITE:
Duff (n, *pdst++ = ~0;);
if (mask)
*pdst |= mask;
break;
case RROP_INVERT:
Duff (n, *pdst++ ^= ~0;);
if (mask)
*pdst ^= mask;
break;
case RROP_NOP:
break;
}
}
}
if (!--h)
break;
afbScanlineInc(addrl, nlwidth);
Step(x1,dx1,dy1,e1,sign1,step1)
Step(x2,dx2,dy2,e2,sign2,step2)
}
if (y == maxy)
break;
afbScanlineInc(addrl, nlwidth);
}
}

463
afb/afbplygblt.c
View File

@ -1,463 +0,0 @@
/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
/***********************************************************
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <X11/X.h>
#include <X11/Xmd.h>
#include <X11/Xproto.h>
#include "afb.h"
#include <X11/fonts/fontstruct.h>
#include "dixfontstr.h"
#include "gcstruct.h"
#include "windowstr.h"
#include "scrnintstr.h"
#include "pixmapstr.h"
#include "regionstr.h"
#include "maskbits.h"
/*
this works for fonts with glyphs <= 32 bits wide.
the clipping calculations are done for worst-case fonts.
we make no assumptions about the heights, widths, or bearings
of the glyphs. if we knew that the glyphs are all the same height,
we could clip the tops and bottoms per clipping box, rather
than per character per clipping box. if we knew that the glyphs'
left and right bearings were wlle-behaved, we could clip a single
character at the start, output until the last unclipped
character, and then clip the last one. this is all straightforward
to determine based on max-bounds and min-bounds from the font.
there is some inefficiency introduced in the per-character
clipping to make what's going on clearer.
(it is possible, for example, for a font to be defined in which the
next-to-last character in a font would be clipped out, but the last
one wouldn't. the code below deals with this.)
*/
void
afbPolyGlyphBlt (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
DrawablePtr pDrawable;
GC *pGC;
int x, y;
unsigned int nglyph;
CharInfoPtr *ppci; /* array of character info */
pointer pglyphBase; /* start of array of glyphs */
{
ExtentInfoRec info; /* used by QueryGlyphExtents() */
BoxRec bbox; /* string's bounding box */
CharInfoPtr pci;
int xorg, yorg; /* origin of drawable in bitmap */
int widthDst; /* width of dst in longwords */
/* these keep track of the character origin */
PixelType *pdstBase;
/* points to longword with character origin */
int xchar; /* xorigin of char (mod 32) */
/* these are used for placing the glyph */
register int xoff; /* x offset of left edge of glyph (mod 32) */
register PixelType *pdst; /* pointer to current longword in dst */
register int d;
int depthDst;
int sizeDst;
int hSave;
int w; /* width of glyph in bits */
int h; /* height of glyph */
int widthGlyph; /* width of glyph, in bytes */
unsigned char *rrops;
register unsigned char *pglyph;
/* pointer to current row of glyph */
unsigned char *pglyphSave;
/* used for putting down glyph */
register PixelType tmpSrc;
/* for getting bits from glyph */
register PixelType startmask;
register PixelType endmask;
register int nFirst; /* bits of glyph in current longword */
PixelType *pdstSave;
xorg = pDrawable->x;
yorg = pDrawable->y;
afbGetPixelWidthSizeDepthAndPointer(pDrawable, widthDst, sizeDst, depthDst,
pdstBase);
QueryGlyphExtents(pGC->font, ppci, (unsigned long)nglyph, &info);
x += xorg;
y += yorg;
bbox.x1 = x + info.overallLeft;
bbox.x2 = x + info.overallRight;
bbox.y1 = y - info.overallAscent;
bbox.y2 = y + info.overallDescent;
rrops = ((afbPrivGCPtr)dixLookupPrivate(&pGC->devPrivates,
afbGCPrivateKey))->rrops;
switch (RECT_IN_REGION(pGC->pScreen, pGC->pCompositeClip, &bbox)) {
case rgnOUT:
break;
case rgnIN:
pdstBase = afbScanlineNoBankSwitch(pdstBase, x, y, widthDst);
xchar = x & PIM;
while(nglyph--) {
pci = *ppci;
pglyphSave = FONTGLYPHBITS(pglyphBase, pci);
w = pci->metrics.rightSideBearing - pci->metrics.leftSideBearing;
hSave = pci->metrics.ascent + pci->metrics.descent;
widthGlyph = GLYPHWIDTHBYTESPADDED(pci);
/* start at top scanline of glyph */
pdstSave = afbScanlineDelta(pdstBase, -pci->metrics.ascent,
widthDst);
/* find correct word in scanline and x offset within it
for left edge of glyph
*/
xoff = xchar + pci->metrics.leftSideBearing;
if (xoff > PLST) {
pdstSave++;
xoff &= PIM;
} else if (xoff < 0) {
xoff += PPW;
pdstSave--;
}
for (d = 0; d < depthDst; d++) {
h = hSave;
pdst = pdstSave;
pdstSave += sizeDst; /* @@@ NEXT PLANE @@@ */
pglyph = pglyphSave;
if ((xoff + w) <= PPW) {
/* glyph all in one longword */
maskpartialbits(xoff, w, startmask);
switch (rrops[d]) {
case RROP_WHITE:
while (h--) {
getleftbits(pglyph, w, tmpSrc);
*pdst |= (SCRRIGHT(tmpSrc, xoff) & startmask);
pglyph += widthGlyph;
afbScanlineInc(pdst, widthDst);
}
break;
case RROP_BLACK:
while (h--) {
getleftbits(pglyph, w, tmpSrc);
*pdst &= ~(SCRRIGHT(tmpSrc, xoff) & startmask);
pglyph += widthGlyph;
afbScanlineInc(pdst, widthDst);
}
break;
case RROP_INVERT:
while (h--) {
getleftbits(pglyph, w, tmpSrc);
*pdst ^= (SCRRIGHT(tmpSrc, xoff) & startmask);
pglyph += widthGlyph;
afbScanlineInc(pdst, widthDst);
}
break;
}
} else {
/* glyph crosses longword boundary */
maskPPWbits(xoff, w, startmask, endmask);
nFirst = PPW - xoff;
switch (rrops[d]) {
case RROP_WHITE:
while (h--) {
getleftbits(pglyph, w, tmpSrc);
*pdst |= (SCRRIGHT(tmpSrc, xoff) & startmask);
*(pdst+1) |= (SCRLEFT(tmpSrc, nFirst) & endmask);
pglyph += widthGlyph;
afbScanlineInc(pdst, widthDst);
}
break;
case RROP_BLACK:
while (h--) {
getleftbits(pglyph, w, tmpSrc);
*pdst &= ~(SCRRIGHT(tmpSrc, xoff) & startmask);
*(pdst+1) &= ~(SCRLEFT(tmpSrc, nFirst) & endmask);
pglyph += widthGlyph;
afbScanlineInc(pdst, widthDst);
}
break;
case RROP_INVERT:
while (h--) {
getleftbits(pglyph, w, tmpSrc);
*pdst ^= (SCRRIGHT(tmpSrc, xoff) & startmask);
*(pdst+1) ^= (SCRLEFT(tmpSrc, nFirst) & endmask);
pglyph += widthGlyph;
afbScanlineInc(pdst, widthDst);
}
break;
}
} /* glyph crosses longwords boundary */
} /* depth loop */
/* update character origin */
x += pci->metrics.characterWidth;
xchar += pci->metrics.characterWidth;
if (xchar > PLST) {
xchar -= PPW;
pdstBase++;
} else if (xchar < 0) {
xchar += PPW;
pdstBase--;
}
ppci++;
} /* while nglyph-- */
break;
case rgnPART:
{
afbTEXTPOS *ppos;
int nbox;
BoxPtr pbox;
RegionPtr cclip;
int xpos; /* x position of char origin */
int i;
BoxRec clip;
int leftEdge, rightEdge;
int topEdge, bottomEdge;
int glyphRow; /* first row of glyph not wholly
clipped out */
int glyphCol; /* leftmost visible column of glyph */
#if GETLEFTBITS_ALIGNMENT > 1
int getWidth; /* bits to get from glyph */
#endif
if(!(ppos = (afbTEXTPOS *)xalloc(nglyph * sizeof(afbTEXTPOS))))
return;
pdstBase = afbScanlineNoBankSwitch(pdstBase, x, y, widthDst);
xpos = x;
xchar = xpos & PIM;
for (i = 0; i < nglyph; i++) {
pci = ppci[i];
ppos[i].xpos = xpos;
ppos[i].xchar = xchar;
ppos[i].leftEdge = xpos + pci->metrics.leftSideBearing;
ppos[i].rightEdge = xpos + pci->metrics.rightSideBearing;
ppos[i].topEdge = y - pci->metrics.ascent;
ppos[i].bottomEdge = y + pci->metrics.descent;
ppos[i].pdstBase = pdstBase;
ppos[i].widthGlyph = GLYPHWIDTHBYTESPADDED(pci);
xpos += pci->metrics.characterWidth;
xchar += pci->metrics.characterWidth;
if (xchar > PLST) {
xchar &= PIM;
pdstBase++;
} else if (xchar < 0) {
xchar += PPW;
pdstBase--;
}
}
cclip = pGC->pCompositeClip;
pbox = REGION_RECTS(cclip);
nbox = REGION_NUM_RECTS(cclip);
/* HACK ALERT
since we continue out of the loop below so often, it
is easier to increment pbox at the top than at the end.
don't try this at home.
*/
pbox--;
while(nbox--) {
pbox++;
clip.x1 = max(bbox.x1, pbox->x1);
clip.y1 = max(bbox.y1, pbox->y1);
clip.x2 = min(bbox.x2, pbox->x2);
clip.y2 = min(bbox.y2, pbox->y2);
if ((clip.x2<=clip.x1) || (clip.y2<=clip.y1))
continue;
for(i=0; i<nglyph; i++) {
pci = ppci[i];
xchar = ppos[i].xchar;
/* clip the left and right edges */
if (ppos[i].leftEdge < clip.x1)
leftEdge = clip.x1;
else
leftEdge = ppos[i].leftEdge;
if (ppos[i].rightEdge > clip.x2)
rightEdge = clip.x2;
else
rightEdge = ppos[i].rightEdge;
w = rightEdge - leftEdge;
if (w <= 0)
continue;
/* clip the top and bottom edges */
if (ppos[i].topEdge < clip.y1)
topEdge = clip.y1;
else
topEdge = ppos[i].topEdge;
if (ppos[i].bottomEdge > clip.y2)
bottomEdge = clip.y2;
else
bottomEdge = ppos[i].bottomEdge;
hSave = bottomEdge - topEdge;
if (hSave <= 0)
continue;
glyphRow = (topEdge - y) + pci->metrics.ascent;
widthGlyph = ppos[i].widthGlyph;
pglyphSave = FONTGLYPHBITS(pglyphBase, pci);
pglyphSave += (glyphRow * widthGlyph);
glyphCol = (leftEdge - ppos[i].xpos) -
(pci->metrics.leftSideBearing);
#if GETLEFTBITS_ALIGNMENT > 1
getWidth = w + glyphCol;
#endif
pdstSave = afbScanlineDelta(ppos[i].pdstBase, -(y-topEdge),
widthDst);
xoff = xchar + (leftEdge - ppos[i].xpos);
if (xoff > PLST) {
xoff &= PIM;
pdstSave++;
} else if (xoff < 0) {
xoff += PPW;
pdstSave--;
}
for (d = 0; d < depthDst; d++) {
h = hSave;
pdst = pdstSave;
pdstSave += sizeDst; /* @@@ NEXT PLANE @@@ */
pglyph = pglyphSave;
if ((xoff + w) <= PPW) {
maskpartialbits(xoff, w, startmask);
switch (rrops[d]) {
case RROP_WHITE:
while (h--) {
getshiftedleftbits(pglyph, glyphCol, getWidth, tmpSrc);
*pdst |= (SCRRIGHT(tmpSrc, xoff) & startmask);
pglyph += widthGlyph;
afbScanlineInc(pdst, widthDst);
}
break;
case RROP_BLACK:
while (h--) {
getshiftedleftbits(pglyph, glyphCol, getWidth, tmpSrc);
*pdst &= ~(SCRRIGHT(tmpSrc, xoff) & startmask);
pglyph += widthGlyph;
afbScanlineInc(pdst, widthDst);
}
break;
case RROP_INVERT:
while (h--) {
getshiftedleftbits(pglyph, glyphCol, getWidth, tmpSrc);
*pdst ^= (SCRRIGHT(tmpSrc, xoff) & startmask);
pglyph += widthGlyph;
afbScanlineInc(pdst, widthDst);
}
break;
}
} else {
maskPPWbits(xoff, w, startmask, endmask);
nFirst = PPW - xoff;
switch (rrops[d]) {
case RROP_WHITE:
while (h--) {
getshiftedleftbits(pglyph, glyphCol, getWidth, tmpSrc);
*pdst |= (SCRRIGHT(tmpSrc, xoff) & startmask);
*(pdst+1) |= (SCRLEFT(tmpSrc, nFirst) & endmask);
pglyph += widthGlyph;
afbScanlineInc(pdst, widthDst);
}
break;
case RROP_BLACK:
while (h--) {
getshiftedleftbits(pglyph, glyphCol, getWidth, tmpSrc);
*pdst &= ~(SCRRIGHT(tmpSrc, xoff) & startmask);
*(pdst+1) &= ~(SCRLEFT(tmpSrc, nFirst) & endmask);
pglyph += widthGlyph;
afbScanlineInc(pdst, widthDst);
}
break;
case RROP_INVERT:
while (h--) {
getshiftedleftbits(pglyph, glyphCol, getWidth, tmpSrc);
*pdst ^= (SCRRIGHT(tmpSrc, xoff) & startmask);
*(pdst+1) ^= (SCRLEFT(tmpSrc, nFirst) & endmask);
pglyph += widthGlyph;
afbScanlineInc(pdst, widthDst);
}
break;
}
}
} /* depth */
} /* for each glyph */
} /* while nbox-- */
xfree(ppos);
break;
}
default:
break;
}
}

655
afb/afbpntarea.c
View File

@ -1,655 +0,0 @@
/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
/***********************************************************
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <X11/X.h>
#include "windowstr.h"
#include "regionstr.h"
#include "pixmapstr.h"
#include "scrnintstr.h"
#include "afb.h"
#include "maskbits.h"
/*
the solid fillers are called for rectangles and window backgrounds.
the boxes are already translated.
maybe this should always take a pixmap instead of a drawable?
NOTE:
iy = ++iy < tileHeight ? iy : 0
is equivalent to iy%= tileheight, and saves a division.
*/
/*ARGSUSED*/
void
afbSolidFillArea (pDraw, nbox, pbox, rrops)
DrawablePtr pDraw;
int nbox;
BoxPtr pbox;
register unsigned char *rrops;
{
int nlwidth; /* width in longwords of the drawable */
int w; /* width of current box */
register int h; /* height of current box */
register PixelType *p; /* pointer to bits we're writing */
register int nlw; /* loop version of nlwMiddle */
register PixelType startmask;
register PixelType endmask;
/* masks for reggedy bits at either end of line */
register int nlwExtra;
/* to get from right of box to left of next span */
int nlwMiddle; /* number of longwords between sides of boxes */
PixelType *pbits; /* pointer to start of drawable */
PixelType *saveP;
int saveH;
int depthDst;
int sizeDst;
register int d;
afbGetPixelWidthSizeDepthAndPointer(pDraw, nlwidth, sizeDst, depthDst,
pbits);
while (nbox--) {
w = pbox->x2 - pbox->x1;
saveH = pbox->y2 - pbox->y1;
saveP = afbScanline(pbits, pbox->x1, pbox->y1, nlwidth);
if ( ((pbox->x1 & PIM) + w) < PPW) {
for (d = 0; d < depthDst; d++) {
h = saveH;
p = saveP;
saveP += sizeDst; /* @@@ NEXT PLANE @@@ */
maskpartialbits(pbox->x1, w, startmask);
nlwExtra = nlwidth;
switch (rrops[d]) {
case RROP_BLACK:
Duff(h, *p &= ~startmask; afbScanlineInc(p, nlwExtra));
break;
case RROP_WHITE:
Duff(h, *p |= startmask; afbScanlineInc(p, nlwExtra));
break;
case RROP_INVERT:
Duff(h, *p ^= startmask; afbScanlineInc(p, nlwExtra));
break;
case RROP_NOP:
break;
} /* switch */
} /* for (d = ..) */
} else {
maskbits(pbox->x1, w, startmask, endmask, nlwMiddle);
for (d = 0; d < depthDst; d++) {
h = saveH;
p = saveP;
saveP += sizeDst; /* @@@ NEXT PLANE @@@ */
nlwExtra = nlwidth - nlwMiddle;
if (startmask && endmask) {
nlwExtra -= 1;
switch (rrops[d]) {
case RROP_BLACK:
while (h--) {
nlw = nlwMiddle;
*p &= ~startmask;
p++;
Duff(nlw, *p++ = 0);
*p &= ~endmask;
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_WHITE:
while (h--) {
nlw = nlwMiddle;
*p |= startmask;
p++;
Duff(nlw, *p++ = ~0);
*p |= endmask;
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_INVERT:
while (h--) {
nlw = nlwMiddle;
*p ^= startmask;
p++;
Duff(nlw, *p++ ^= ~0);
*p ^= endmask;
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_NOP:
break;
}
} else if (startmask && !endmask) {
nlwExtra -= 1;
switch (rrops[d]) {
case RROP_BLACK:
while (h--) {
nlw = nlwMiddle;
*p &= ~startmask;
p++;
Duff(nlw, *p++ = 0);
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_WHITE:
while (h--) {
nlw = nlwMiddle;
*p |= startmask;
p++;
Duff(nlw, *p++ = ~0);
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_INVERT:
while (h--) {
nlw = nlwMiddle;
*p ^= startmask;
p++;
Duff(nlw, *p++ ^= ~0);
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_NOP:
break;
}
} else if (!startmask && endmask) {
switch (rrops[d]) {
case RROP_BLACK:
while (h--) {
nlw = nlwMiddle;
Duff(nlw, *p++ = 0);
*p &= ~endmask;
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_WHITE:
while (h--) {
nlw = nlwMiddle;
Duff(nlw, *p++ = ~0);
*p |= endmask;
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_INVERT:
while (h--) {
nlw = nlwMiddle;
Duff(nlw, *p++ ^= ~0);
*p ^= endmask;
afbScanlineInc(p, nlwExtra);
}
case RROP_NOP:
break;
}
} else { /* no ragged bits at either end */
switch (rrops[d]) {
case RROP_BLACK:
while (h--) {
nlw = nlwMiddle;
Duff(nlw, *p++ = 0);
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_WHITE:
while (h--) {
nlw = nlwMiddle;
Duff(nlw, *p++ = ~0);
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_INVERT:
while (h--) {
nlw = nlwMiddle;
Duff(nlw, *p++ ^= ~0);
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_NOP:
break;
} /* switch */
}
} /* for (d = 0 ... ) */
}
pbox++;
}
}
/* stipple a list of boxes -
you can use the reduced rasterop for stipples. if rrop is
black, AND the destination with (not stipple pattern). if rrop is
white OR the destination with the stipple pattern. if rrop is invert,
XOR the destination with the stipple pattern.
*/
/*ARGSUSED*/
void
afbStippleAreaPPW (pDraw, nbox, pbox, pstipple, rrops)
DrawablePtr pDraw;
int nbox;
BoxPtr pbox;
PixmapPtr pstipple;
unsigned char *rrops;
{
register PixelType *psrc;
/* pointer to bits in tile, if needed */
int tileHeight; /* height of the tile */
register PixelType srcpix;
int nlwidth; /* width in longwords of the drawable */
int w; /* width of current box */
register int nlw; /* loop version of nlwMiddle */
register PixelType *p; /* pointer to bits we're writing */
register int h; /* height of current box */
PixelType startmask;
PixelType endmask; /* masks for reggedy bits at either end of line */
int nlwMiddle; /* number of longwords between sides of boxes */
int nlwExtra; /* to get from right of box to left of next span */
int sizeDst;
int depthDst;
int d;
int saveIy;
register int iy; /* index of current scanline in tile */
PixelType *pbits; /* pointer to start of drawable */
PixelType *pBase;
afbGetPixelWidthSizeDepthAndPointer(pDraw, nlwidth, sizeDst, depthDst,
pBase);
tileHeight = pstipple->drawable.height;
psrc = (PixelType *)(pstipple->devPrivate.ptr);
while (nbox--) {
w = pbox->x2 - pbox->x1;
saveIy = pbox->y1 % tileHeight;
pbits = pBase;
if ( ((pbox->x1 & PIM) + w) < PPW) {
maskpartialbits(pbox->x1, w, startmask);
nlwExtra = nlwidth;
for (d = 0; d < depthDst; d++) {
p = afbScanline(pbits, pbox->x1, pbox->y1, nlwidth);
pbits += sizeDst; /* @@@ NEXT PLANE @@@ */
iy = saveIy;
h = pbox->y2 - pbox->y1;
switch (rrops[d]) {
case RROP_BLACK:
while (h--) {
srcpix = psrc[iy];
iy = ++iy < tileHeight ? iy : 0;
*p &= ~(srcpix & startmask);
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_WHITE:
while (h--) {
srcpix = psrc[iy];
iy = ++iy < tileHeight ? iy : 0;
*p |= (srcpix & startmask);
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_INVERT:
while (h--) {
srcpix = psrc[iy];
iy = ++iy < tileHeight ? iy : 0;
*p ^= (srcpix & startmask);
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_NOP:
break;
} /* switch */
} /* for (d = ...) */
} else {
maskbits(pbox->x1, w, startmask, endmask, nlwMiddle);
for (d = 0; d < depthDst; d++) {
nlwExtra = nlwidth - nlwMiddle;
p = afbScanline(pbits, pbox->x1, pbox->y1, nlwidth);
pbits += sizeDst; /* @@@ NEXT PLANE @@@ */
iy = saveIy;
h = pbox->y2 - pbox->y1;
if (startmask && endmask) {
nlwExtra -= 1;
switch (rrops[d]) {
case RROP_BLACK:
while (h--) {
srcpix = psrc[iy];
iy = ++iy < tileHeight ? iy : 0;
nlw = nlwMiddle;
*p &= ~(srcpix & startmask);
p++;
Duff (nlw, *p++ &= ~srcpix);
*p &= ~(srcpix & endmask);
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_WHITE:
while (h--) {
srcpix = psrc[iy];
iy = ++iy < tileHeight ? iy : 0;
nlw = nlwMiddle;
*p |= (srcpix & startmask);
p++;
Duff (nlw, *p++ |= srcpix);
*p |= (srcpix & endmask);
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_INVERT:
while (h--) {
srcpix = psrc[iy];
iy = ++iy < tileHeight ? iy : 0;
nlw = nlwMiddle;
*p ^= (srcpix & startmask);
p++;
Duff (nlw, *p++ ^= srcpix);
*p ^= (srcpix & endmask);
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_NOP:
break;
} /* switch */
} else if (startmask && !endmask) {
nlwExtra -= 1;
switch (rrops[d]) {
case RROP_BLACK:
while (h--) {
srcpix = psrc[iy];
iy = ++iy < tileHeight ? iy : 0;
nlw = nlwMiddle;
*p &= ~(srcpix & startmask);
p++;
Duff(nlw, *p++ &= ~srcpix);
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_WHITE:
while (h--) {
srcpix = psrc[iy];
iy = ++iy < tileHeight ? iy : 0;
nlw = nlwMiddle;
*p |= (srcpix & startmask);
p++;
Duff(nlw, *p++ |= srcpix);
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_INVERT:
while (h--) {
srcpix = psrc[iy];
iy = ++iy < tileHeight ? iy : 0;
nlw = nlwMiddle;
*p ^= (srcpix & startmask);
p++;
Duff(nlw, *p++ ^= srcpix);
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_NOP:
break;
} /* switch */
} else if (!startmask && endmask) {
switch (rrops[d]) {
case RROP_BLACK:
while (h--) {
srcpix = psrc[iy];
iy = ++iy < tileHeight ? iy : 0;
nlw = nlwMiddle;
Duff(nlw, *p++ &= ~srcpix);
*p &= ~(srcpix & endmask);
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_WHITE:
while (h--) {
srcpix = psrc[iy];
iy = ++iy < tileHeight ? iy : 0;
nlw = nlwMiddle;
Duff(nlw, *p++ |= srcpix);
*p |= (srcpix & endmask);
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_INVERT:
while (h--) {
srcpix = psrc[iy];
iy = ++iy < tileHeight ? iy : 0;
nlw = nlwMiddle;
Duff(nlw, *p++ ^= srcpix);
*p ^= (srcpix & endmask);
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_NOP:
break;
} /* switch */
} else { /* no ragged bits at either end */
switch (rrops[d]) {
case RROP_BLACK:
while (h--) {
srcpix = psrc[iy];
iy = ++iy < tileHeight ? iy : 0;
nlw = nlwMiddle;
Duff(nlw, *p++ &= ~srcpix);
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_WHITE:
while (h--) {
srcpix = psrc[iy];
iy = ++iy < tileHeight ? iy : 0;
nlw = nlwMiddle;
Duff(nlw, *p++ |= srcpix);
afbScanlineInc(p, nlwExtra);
}
break;
case RROP_INVERT:
while (h--) {
srcpix = psrc[iy];
iy = ++iy < tileHeight ? iy : 0;
nlw = nlwMiddle;
Duff(nlw, *p++ ^= srcpix);
afbScanlineInc(p, nlwExtra);
}
break;
} /* switch */
}
} /* for (d = ...) */
}
pbox++;
}
}
void
afbStippleArea (pDraw, nbox, pbox, pTile, xOff, yOff, rrops)
DrawablePtr pDraw;
int nbox;
BoxPtr pbox;
PixmapPtr pTile;
int xOff;
int yOff;
unsigned char *rrops;
{
register PixelType *psrc; /* pointer to bits in tile, if needed */
int nlwidth; /* width in longwords of the drawable */
register int h; /* height of current box */
register PixelType *pdst; /* pointer to bits we're writing */
int sizeDst;
int depthDst;
int tileLine;
int iline;
int w, width, x, xSrc, ySrc, srcStartOver, nend;
int tlwidth, rem, tileWidth, tileHeight, endinc;
int saveW;
register int rop;
PixelType *psrcT;
int d;
int nstart;
PixelType startmask;
PixelType endmask; /* masks for reggedy bits at either end of line */
int nlMiddle; /* number of longwords between sides of boxes */
int iy;
PixelType *pBase; /* pointer to start of drawable */
PixelType *saveP;
PixelType *pStartDst;
PixelType *pStartTile;
int saveH;
afbGetPixelWidthSizeDepthAndPointer(pDraw, nlwidth, sizeDst, depthDst,
pBase);
tileHeight = pTile->drawable.height;
tileWidth = pTile->drawable.width;
tlwidth = pTile->devKind / sizeof (PixelType);
xSrc = pDraw->x + ((xOff % tileWidth) - tileWidth);
ySrc = pDraw->y + ((yOff % tileHeight) - tileHeight);
while (nbox--) {
saveW = pbox->x2 - pbox->x1;
iline = (pbox->y1 - ySrc) % tileHeight;
psrcT = (PixelType *) pTile->devPrivate.ptr;
tileLine = iline * tlwidth;
saveH = pbox->y2 - pbox->y1;
saveP = afbScanline(pBase, pbox->x1, pbox->y1, nlwidth);
for (d = 0; d < depthDst; d++, saveP += sizeDst) { /* @@@ NEXT PLANE @@@ */
h = saveH;
pStartDst = saveP;
pStartTile = psrcT + tileLine;
iy = iline;
while (h--) {
x = pbox->x1;
width = saveW;
pdst = pStartDst;
rop = rrops[d];
while(width > 0) {
psrc = pStartTile;
w = min(tileWidth, width);
if((rem = (x - xSrc) % tileWidth) != 0) {
/* if we're in the middle of the tile, get
as many bits as will finish the span, or
as many as will get to the left edge of the tile,
or a longword worth, starting at the appropriate
offset in the tile.
*/
w = min(min(tileWidth - rem, width), BITMAP_SCANLINE_PAD);
endinc = rem / BITMAP_SCANLINE_PAD;
getandputrrop((psrc + endinc), (rem & PIM), (x & PIM),
w, pdst, rop)
if((x & PIM) + w >= PPW)
pdst++;
} else if(((x & PIM) + w) < PPW) {
/* doing < PPW bits is easy, and worth special-casing */
putbitsrrop(*psrc, x & PIM, w, pdst, rop);
} else {
/* start at the left edge of the tile,
and put down as much as we can
*/
maskbits(x, w, startmask, endmask, nlMiddle);
if (startmask)
nstart = PPW - (x & PIM);
else
nstart = 0;
if (endmask)
nend = (x + w) & PIM;
else
nend = 0;
srcStartOver = nstart > PLST;
if(startmask) {
putbitsrrop(*psrc, (x & PIM), nstart, pdst, rop);
pdst++;
if(srcStartOver)
psrc++;
}
while(nlMiddle--) {
getandputrrop0(psrc, nstart, PPW, pdst, rop);
pdst++;
psrc++;
}
if(endmask) {
getandputrrop0(psrc, nstart, nend, pdst, rop);
}
}
x += w;
width -= w;
} /* while (width > 0) */
pStartDst += nlwidth;
if (++iy >= tileHeight) {
iy = 0;
pStartTile = psrcT;
} else
pStartTile += tlwidth;
} /* while (h) */
} /* for (d = ... ) */
pbox++;
} /* for each box */
}

146
afb/afbpolypnt.c
View File

@ -1,146 +0,0 @@
/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
/***********************************************************
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <X11/X.h>
#include <X11/Xprotostr.h>
#include "pixmapstr.h"
#include "gcstruct.h"
#include "windowstr.h"
#include "regionstr.h"
#include "scrnintstr.h"
#include "afb.h"
#include "maskbits.h"
void
afbPolyPoint(pDrawable, pGC, mode, npt, pptInit)
register DrawablePtr pDrawable;
GCPtr pGC;
int mode; /* Origin or Previous */
int npt;
xPoint *pptInit;
{
register BoxPtr pbox;
register int nbox;
register int d;
register PixelType *addrl;
PixelType *pBase;
PixelType *pBaseSave;
int nlwidth;
int sizeDst;
int depthDst;
int nptTmp;
register xPoint *ppt;
register int x;
register int y;
register unsigned char *rrops;
afbPrivGC *pGCPriv;
pGCPriv = (afbPrivGC *)dixLookupPrivate(&pGC->devPrivates,
afbGCPrivateKey);
afbGetPixelWidthSizeDepthAndPointer(pDrawable, nlwidth, sizeDst, depthDst,
pBaseSave);
rrops = pGCPriv->rrops;
if ((mode == CoordModePrevious) && (npt > 1))
for (ppt = pptInit + 1, nptTmp = npt - 1; --nptTmp >= 0; ppt++) {
ppt->x += (ppt-1)->x;
ppt->y += (ppt-1)->y;
}
nbox = REGION_NUM_RECTS(pGC->pCompositeClip);
pbox = REGION_RECTS(pGC->pCompositeClip);
for (; --nbox >= 0; pbox++)
for (d = 0, pBase = pBaseSave; d < depthDst; d++, pBase += sizeDst) { /* @@@ NEXT PLANE @@@ */
addrl = pBase;
switch (rrops[d]) {
case RROP_BLACK:
for (ppt = pptInit, nptTmp = npt; --nptTmp >= 0; ppt++) {
x = ppt->x + pDrawable->x;
y = ppt->y + pDrawable->y;
if ((x >= pbox->x1) && (x < pbox->x2) &&
(y >= pbox->y1) && (y < pbox->y2))
*afbScanline(addrl, x, y, nlwidth) &= mfbGetrmask(x & PIM);
}
break;
case RROP_WHITE:
for (ppt = pptInit, nptTmp = npt; --nptTmp >= 0; ppt++) {
x = ppt->x + pDrawable->x;
y = ppt->y + pDrawable->y;
if ((x >= pbox->x1) && (x < pbox->x2) &&
(y >= pbox->y1) && (y < pbox->y2))
*afbScanline(addrl, x, y, nlwidth) |= mfbGetmask(x & PIM);
}
break;
case RROP_INVERT:
for (ppt = pptInit, nptTmp = npt; --nptTmp >= 0; ppt++) {
x = ppt->x + pDrawable->x;
y = ppt->y + pDrawable->y;
if ((x >= pbox->x1) && (x < pbox->x2) &&
(y >= pbox->y1) && (y < pbox->y2))
*afbScanline(addrl, x, y, nlwidth) ^= mfbGetmask(x & PIM);
}
break;
case RROP_NOP:
break;
} /* switch */
} /* for (d = ...) */
}

169
afb/afbpushpxl.c
View File

@ -1,169 +0,0 @@
/***********************************************************
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <string.h>
#include <X11/X.h>
#include "gcstruct.h"
#include "scrnintstr.h"
#include "pixmapstr.h"
#include "regionstr.h"
#include "maskbits.h"
#include "afb.h"
#define NPT 128
/* afbPushPixels -- squeegees the forground color of pGC through pBitMap
* into pDrawable. pBitMap is a stencil (dx by dy of it is used, it may
* be bigger) which is placed on the drawable at xOrg, yOrg. Where a 1 bit
* is set in the bitmap, the fill style is put onto the drawable using
* the GC's logical function. The drawable is not changed where the bitmap
* has a zero bit or outside the area covered by the stencil.
*/
void
afbPushPixels(GCPtr pGC, PixmapPtr pBitMap, DrawablePtr pDrawable, int dx, int dy, int xOrg, int yOrg)
{
int h, dxDivPPW, ibEnd;
PixelType *pwLineStart;
register PixelType *pw, *pwEnd;
register PixelType mask;
register int ib;
register PixelType w;
register int ipt; /* index into above arrays */
Bool fInBox;
DDXPointRec pt[NPT];
int width[NPT];
/* Now scan convert the pixmap and use the result to call fillspans in
* in the drawable with the original GC */
ipt = 0;
dxDivPPW = dx/PPW;
for (h = 0; h < dy; h++) {
pw = (PixelType *)
(((char *)(pBitMap->devPrivate.ptr))+(h * pBitMap->devKind));
pwLineStart = pw;
/* Process all words which are fully in the pixmap */
fInBox = FALSE;
pwEnd = pwLineStart + dxDivPPW;
while(pw < pwEnd) {
w = *pw;
mask = mfbGetendtab(1);
for(ib = 0; ib < PPW; ib++) {
if(w & mask) {
if(!fInBox) {
pt[ipt].x = ((pw - pwLineStart) << PWSH) + ib + xOrg;
pt[ipt].y = h + yOrg;
/* start new box */
fInBox = TRUE;
}
} else {
if(fInBox) {
width[ipt] = ((pw - pwLineStart) << PWSH) +
ib + xOrg - pt[ipt].x;
if (++ipt >= NPT) {
(*pGC->ops->FillSpans)(pDrawable, pGC, NPT, pt,
width, TRUE);
ipt = 0;
}
/* end box */
fInBox = FALSE;
}
}
mask = SCRRIGHT(mask, 1);
}
pw++;
}
ibEnd = dx & PIM;
if(ibEnd) {
/* Process final partial word on line */
w = *pw;
mask = mfbGetendtab(1);
for(ib = 0; ib < ibEnd; ib++) {
if(w & mask) {
if(!fInBox) {
/* start new box */
pt[ipt].x = ((pw - pwLineStart) << PWSH) + ib + xOrg;
pt[ipt].y = h + yOrg;
fInBox = TRUE;
}
} else {
if(fInBox) {
/* end box */
width[ipt] = ((pw - pwLineStart) << PWSH) +
ib + xOrg - pt[ipt].x;
if (++ipt >= NPT) {
(*pGC->ops->FillSpans)(pDrawable, pGC, NPT, pt,
width, TRUE);
ipt = 0;
}
fInBox = FALSE;
}
}
mask = SCRRIGHT(mask, 1);
}
}
/* If scanline ended with last bit set, end the box */
if(fInBox) {
width[ipt] = dx + xOrg - pt[ipt].x;
if (++ipt >= NPT) {
(*pGC->ops->FillSpans)(pDrawable, pGC, NPT, pt, width, TRUE);
ipt = 0;
}
}
}
/* Flush any remaining spans */
if (ipt) {
(*pGC->ops->FillSpans)(pDrawable, pGC, ipt, pt, width, TRUE);
}
}

218
afb/afbscrinit.c
View File

@ -1,218 +0,0 @@
/***********************************************************
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <stdlib.h>
#include <X11/X.h>
#include <X11/Xproto.h> /* for xColorItem */
#include <X11/Xmd.h>
#include "scrnintstr.h"
#include "pixmapstr.h"
#include "windowstr.h"
#include "resource.h"
#include "colormap.h"
#include "afb.h"
#include "mistruct.h"
#include "dix.h"
#include "mi.h"
#include "mibstore.h"
#include "migc.h"
#include "servermd.h"
#ifdef PIXMAP_PER_WINDOW
DevPrivateKey frameWindowPrivateKey = &frameWindowPrivateKey;
#endif
DevPrivateKey afbGCPrivateKey = &afbGCPrivateKey;
DevPrivateKey afbScreenPrivateKey = &afbScreenPrivateKey;
static Bool
afbCloseScreen(int index, ScreenPtr pScreen)
{
int d;
DepthPtr depths = pScreen->allowedDepths;
for (d = 0; d < pScreen->numDepths; d++)
xfree(depths[d].vids);
xfree(depths);
xfree(pScreen->visuals);
xfree(dixLookupPrivate(&pScreen->devPrivates, afbScreenPrivateKey));
return(TRUE);
}
static Bool
afbCreateScreenResources(ScreenPtr pScreen)
{
Bool retval;
pointer oldDevPrivate = pScreen->devPrivate;
pScreen->devPrivate = dixLookupPrivate(&pScreen->devPrivates,
afbScreenPrivateKey);
retval = miCreateScreenResources(pScreen);
/* Modify screen's pixmap devKind value stored off devPrivate to
* be the width of a single plane in longs rather than the width
* of a chunky screen in longs as incorrectly setup by the mi routine.
*/
((PixmapPtr)pScreen->devPrivate)->devKind = BitmapBytePad(pScreen->width);
dixSetPrivate(&pScreen->devPrivates, afbScreenPrivateKey,
pScreen->devPrivate);
pScreen->devPrivate = oldDevPrivate;
return(retval);
}
static PixmapPtr
afbGetWindowPixmap(WindowPtr pWin)
{
#ifdef PIXMAP_PER_WINDOW
return (PixmapPtr)dixLookupPrivate(&pWin->devPrivates,
frameWindowPrivateKey);
#else
ScreenPtr pScreen = pWin->drawable.pScreen;
return (* pScreen->GetScreenPixmap)(pScreen);
#endif
}
static void
afbSetWindowPixmap(WindowPtr pWin, PixmapPtr pPix)
{
#ifdef PIXMAP_PER_WINDOW
dixSetPrivate(&pWin->devPrivates, frameWindowPrivateKey, pPix);
#else
(* pWin->drawable.pScreen->SetScreenPixmap)(pPix);
#endif
}
static Bool
afbAllocatePrivates(ScreenPtr pScreen, DevPrivateKey *pGCKey)
{
if (pGCKey)
*pGCKey = afbGCPrivateKey;
pScreen->GetWindowPixmap = afbGetWindowPixmap;
pScreen->SetWindowPixmap = afbSetWindowPixmap;
return dixRequestPrivate(afbGCPrivateKey, sizeof(afbPrivGC));
}
/* dts * (inch/dot) * (25.4 mm / inch) = mm */
Bool
afbScreenInit(register ScreenPtr pScreen, pointer pbits, int xsize, int ysize, int dpix, int dpiy, int width)
/* pointer to screen bitmap */
/* in pixels */
/* dots per inch */
/* pixel width of frame buffer */
{
VisualPtr visuals;
DepthPtr depths;
int nvisuals;
int ndepths;
int rootdepth;
VisualID defaultVisual;
pointer oldDevPrivate;
rootdepth = 0;
if (!afbInitVisuals(&visuals, &depths, &nvisuals, &ndepths, &rootdepth,
&defaultVisual, 256, 8)) {
ErrorF("afbInitVisuals: FALSE\n");
return FALSE;
}
if (!afbAllocatePrivates(pScreen, NULL)) {
ErrorF("afbAllocatePrivates: FALSE\n");
return FALSE;
}
pScreen->defColormap = (Colormap)FakeClientID(0);
/* whitePixel, blackPixel */
pScreen->blackPixel = 0;
pScreen->whitePixel = 0;
pScreen->QueryBestSize = afbQueryBestSize;
/* SaveScreen */
pScreen->GetImage = afbGetImage;
pScreen->GetSpans = afbGetSpans;
pScreen->CreateWindow = afbCreateWindow;
pScreen->DestroyWindow = afbDestroyWindow;
pScreen->PositionWindow = afbPositionWindow;
pScreen->ChangeWindowAttributes = afbChangeWindowAttributes;
pScreen->RealizeWindow = afbMapWindow;
pScreen->UnrealizeWindow = afbUnmapWindow;
pScreen->CopyWindow = afbCopyWindow;
pScreen->CreatePixmap = afbCreatePixmap;
pScreen->DestroyPixmap = afbDestroyPixmap;
pScreen->RealizeFont = afbRealizeFont;
pScreen->UnrealizeFont = afbUnrealizeFont;
pScreen->CreateGC = afbCreateGC;
pScreen->CreateColormap = afbInitializeColormap;
pScreen->DestroyColormap = (DestroyColormapProcPtr)NoopDDA;
pScreen->InstallColormap = afbInstallColormap;
pScreen->UninstallColormap = afbUninstallColormap;
pScreen->ListInstalledColormaps = afbListInstalledColormaps;
pScreen->StoreColors = (StoreColorsProcPtr)NoopDDA;
pScreen->ResolveColor = afbResolveColor;
pScreen->BitmapToRegion = afbPixmapToRegion;
oldDevPrivate = pScreen->devPrivate;
if (!miScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width, rootdepth,
ndepths, depths, defaultVisual, nvisuals, visuals)) {
ErrorF("miScreenInit: FALSE\n");
return FALSE;
}
pScreen->CloseScreen = afbCloseScreen;
pScreen->CreateScreenResources = afbCreateScreenResources;
dixSetPrivate(&pScreen->devPrivates, afbScreenPrivateKey,
pScreen->devPrivate);
pScreen->devPrivate = oldDevPrivate;
return TRUE;
}

257
afb/afbsetsp.c
View File

@ -1,257 +0,0 @@
/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
/***********************************************************
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <X11/X.h>
#include <X11/Xmd.h>
#include "misc.h"
#include "regionstr.h"
#include "gcstruct.h"
#include "windowstr.h"
#include "pixmapstr.h"
#include "scrnintstr.h"
#include "afb.h"
#include "maskbits.h"
#include "servermd.h"
/* afbSetScanline -- copies the bits from psrc to the drawable starting at
* (xStart, y) and continuing to (xEnd, y). xOrigin tells us where psrc
* starts on the scanline. (I.e., if this scanline passes through multiple
* boxes, we may not want to start grabbing bits at psrc but at some offset
* further on.)
*/
static void
afbSetScanline(int y, int xOrigin, int xStart, int xEnd, PixelType *psrc,
int alu, PixelType *pdstBase, int widthDst, int sizeDst,
int depthDst, int sizeSrc)
{
int w; /* width of scanline in bits */
register PixelType *pdst; /* where to put the bits */
register PixelType tmpSrc; /* scratch buffer to collect bits in */
int dstBit; /* offset in bits from beginning of
* word */
register int nstart; /* number of bits from first partial */
register int nend; /* " " last partial word */
int offSrc;
PixelType startmask, endmask;
PixelType *savePsrc = psrc + ((xStart - xOrigin) >> PWSH);
int nlMiddle, nl;
int d;
for (d = 0; d < depthDst; d++) {
pdst = afbScanline(pdstBase, xStart, y, widthDst) + sizeDst * d; /* @@@ NEXT PLANE @@@ */
psrc = savePsrc + sizeSrc * d; /* @@@ NEXT PLANE @@@ */
offSrc = (xStart - xOrigin) & PIM;
w = xEnd - xStart;
dstBit = xStart & PIM;
if (dstBit + w <= PPW) {
getandputrop(psrc, offSrc, dstBit, w, pdst, alu)
} else {
maskbits(xStart, w, startmask, endmask, nlMiddle);
if (startmask)
nstart = PPW - dstBit;
else
nstart = 0;
if (endmask)
nend = xEnd & PIM;
else
nend = 0;
if (startmask) {
getandputrop(psrc, offSrc, dstBit, nstart, pdst, alu)
pdst++;
offSrc += nstart;
if (offSrc > PLST) {
psrc++;
offSrc -= PPW;
}
}
nl = nlMiddle;
while (nl--) {
getbits(psrc, offSrc, PPW, tmpSrc);
DoRop(*pdst, alu, tmpSrc, *pdst);
pdst++;
psrc++;
}
if (endmask) {
getandputrop0(psrc, offSrc, nend, pdst, alu);
}
}
}
}
/* SetSpans -- for each span copy pwidth[i] bits from psrc to pDrawable at
* ppt[i] using the raster op from the GC. If fSorted is TRUE, the scanlines
* are in increasing Y order.
* Source bit lines are server scanline padded so that they always begin
* on a word boundary.
*/
void
afbSetSpans(pDrawable, pGC, pcharsrc, ppt, pwidth, nspans, fSorted)
DrawablePtr pDrawable;
GCPtr pGC;
char *pcharsrc;
register DDXPointPtr ppt;
int *pwidth;
int nspans;
int fSorted;
{
PixelType *psrc = (PixelType *)pcharsrc;
PixelType *pdstBase; /* start of dst bitmap */
int widthDst; /* width of bitmap in words */
int sizeDst;
int depthDst;
int sizeSrc = 0;
register BoxPtr pbox, pboxLast, pboxTest;
register DDXPointPtr pptLast;
int alu;
RegionPtr prgnDst;
int xStart, xEnd;
int yMax;
alu = pGC->alu;
prgnDst = pGC->pCompositeClip;
pptLast = ppt + nspans;
yMax = pDrawable->y + (int) pDrawable->height;
afbGetPixelWidthSizeDepthAndPointer(pDrawable, widthDst, sizeDst, depthDst,
pdstBase);
pbox = REGION_RECTS(prgnDst);
pboxLast = pbox + REGION_NUM_RECTS(prgnDst);
if(fSorted) {
/* scan lines sorted in ascending order. Because they are sorted, we
* don't have to check each scanline against each clip box. We can be
* sure that this scanline only has to be clipped to boxes at or after the
* beginning of this y-band
*/
pboxTest = pbox;
while(ppt < pptLast) {
pbox = pboxTest;
if(ppt->y >= yMax)
break;
while(pbox < pboxLast) {
if(pbox->y1 > ppt->y) {
/* scanline is before clip box */
break;
} else if(pbox->y2 <= ppt->y) {
/* clip box is before scanline */
pboxTest = ++pbox;
continue;
} else if(pbox->x1 > ppt->x + *pwidth) {
/* clip box is to right of scanline */
break;
} else if(pbox->x2 <= ppt->x) {
/* scanline is to right of clip box */
pbox++;
continue;
}
/* at least some of the scanline is in the current clip box */
xStart = max(pbox->x1, ppt->x);
xEnd = min(ppt->x + *pwidth, pbox->x2);
sizeSrc = PixmapWidthInPadUnits(*pwidth, 1);
afbSetScanline(ppt->y, ppt->x, xStart, xEnd, psrc, alu, pdstBase,
widthDst, sizeDst, depthDst, sizeSrc);
if(ppt->x + *pwidth <= pbox->x2) {
/* End of the line, as it were */
break;
} else
pbox++;
}
/* We've tried this line against every box; it must be outside them
* all. move on to the next point */
ppt++;
psrc += sizeSrc * depthDst;
pwidth++;
}
} else {
/* scan lines not sorted. We must clip each line against all the boxes */
while(ppt < pptLast) {
if(ppt->y >= 0 && ppt->y < yMax) {
for(pbox = REGION_RECTS(prgnDst); pbox< pboxLast; pbox++) {
if(pbox->y1 > ppt->y) {
/* rest of clip region is above this scanline,
* skip it */
break;
}
if(pbox->y2 <= ppt->y) {
/* clip box is below scanline */
pbox++;
break;
}
if(pbox->x1 <= ppt->x + *pwidth &&
pbox->x2 > ppt->x) {
xStart = max(pbox->x1, ppt->x);
xEnd = min(pbox->x2, ppt->x + *pwidth);
sizeSrc = PixmapWidthInPadUnits(*pwidth, 1);
afbSetScanline(ppt->y, ppt->x, xStart, xEnd, psrc, alu,
pdstBase, widthDst, sizeDst, depthDst,
sizeSrc);
}
}
}
psrc += sizeSrc * depthDst;
ppt++;
pwidth++;
}
}
}

586
afb/afbtegblt.c
View File

@ -1,586 +0,0 @@
/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
/***********************************************************
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <X11/X.h>
#include <X11/Xmd.h>
#include <X11/Xproto.h>
#include "afb.h"
#include <X11/fonts/fontstruct.h>
#include "dixfontstr.h"
#include "gcstruct.h"
#include "windowstr.h"
#include "scrnintstr.h"
#include "pixmapstr.h"
#include "regionstr.h"
#include "maskbits.h"
/*
this works for fonts with glyphs <= PPW bits wide.
This should be called only with a terminal-emulator font;
this means that the FIXED_METRICS flag is set, and that
glyphbounds == charbounds.
in theory, this goes faster; even if it doesn't, it reduces the
flicker caused by writing a string over itself with image text (since
the background gets repainted per character instead of per string.)
this seems to be important for some converted X10 applications.
Image text looks at the bits in the glyph and the fg and bg in the
GC. it paints a rectangle, as defined in the protocol dcoument,
and the paints the characters.
*/
#if defined(NO_3_60_CG4) && defined(FASTPUTBITS) && defined(FASTGETBITS)
#define FASTCHARS
#endif
/*
* this macro "knows" that only characters <= 8 bits wide will
* fit this case (which is why it is independent of GLYPHPADBYTES)
*/
#if (BITMAP_BIT_ORDER == MSBFirst) && (GLYPHPADBYTES != 4)
#if GLYPHPADBYTES == 1
#define ShiftAmnt 24
#else
#define ShiftAmnt 16
#endif
/*
* Note: for BITMAP_BIT_ORDER != IMAGE_BYTE_ORDER, SCRRIGHT() evaluates its
* first argument more than once. Thus the imbedded char++ have to be moved.
* (DHD)
*/
#if BITMAP_BIT_ORDER == IMAGE_BYTE_ORDER
#if PPW == 32
#define GetBits4 c = (*char1++ << ShiftAmnt) | \
SCRRIGHT (*char2++ << ShiftAmnt, xoff2) | \
SCRRIGHT (*char3++ << ShiftAmnt, xoff3) | \
SCRRIGHT (*char4++ << ShiftAmnt, xoff4);
#else /* PPW */
#define GetBits4 c = ((unsigned long)(*char1++ << ShiftAmnt) << 32 ) | \
(SCRRIGHT (*char2++ << ShiftAmnt, xoff2) << 32 ) | \
(SCRRIGHT (*char3++ << ShiftAmnt, xoff3) << 32 ) | \
(SCRRIGHT (*char4++ << ShiftAmnt, xoff4) << 32 ) | \
(*char5++ << ShiftAmnt) | \
SCRRIGHT (*char6++ << ShiftAmnt, xoff6) | \
SCRRIGHT (*char7++ << ShiftAmnt, xoff7) | \
SCRRIGHT (*char8++ << ShiftAmnt, xoff8);
#endif /* PPW */
#else /* BITMAP_BIT_ORDER != IMAGE_BYTE_ORDER */
#if PPW == 32
#define GetBits4 c = (*char1++ << ShiftAmnt) | \
SCRRIGHT (*char2 << ShiftAmnt, xoff2) | \
SCRRIGHT (*char3 << ShiftAmnt, xoff3) | \
SCRRIGHT (*char4 << ShiftAmnt, xoff4); \
char2++; char3++; char4++;
#else /* PPW == 64 */
#define GetBits4 c = ((unsigned long)(*char1++ << ShiftAmnt) << 32 ) | \
(SCRRIGHT (*char2 << ShiftAmnt, xoff2) << 32 ) | \
(SCRRIGHT (*char3 << ShiftAmnt, xoff3) << 32 ) | \
(SCRRIGHT (*char4 << ShiftAmnt, xoff4) << 32 ) | \
(*char5++ << ShiftAmnt) | \
SCRRIGHT (*char6 << ShiftAmnt, xoff6) | \
SCRRIGHT (*char7 << ShiftAmnt, xoff7) | \
SCRRIGHT (*char8 << ShiftAmnt, xoff8); \
char2++; char3++; char4++; char6++; char7++; char8++;
#endif /* PPW */
#endif /* BITMAP_BIT_ORDER == IMAGE_BYTE_ORDER */
#else /* (BITMAP_BIT_ORDER != MSBFirst) || (GLYPHPADBYTES == 4) */
#if BITMAP_BIT_ORDER == IMAGE_BYTE_ORDER
#if PPW == 32
#define GetBits4 c = *char1++ | \
SCRRIGHT (*char2++, xoff2) | \
SCRRIGHT (*char3++, xoff3) | \
SCRRIGHT (*char4++, xoff4);
#else /* PPW == 64 */
#define GetBits4 c = (unsigned long)(((*char1++) << 64 ) | \
(SCRRIGHT (*char2++, xoff2) << 64 ) | \
(SCRRIGHT (*char3++, xoff3) << 64 ) | \
(SCRRIGHT (*char4++, xoff4) << 64 ) | \
SCRRIGHT (*char5++, xoff5) | \
SCRRIGHT (*char6++, xoff6) | \
SCRRIGHT (*char7++, xoff7) | \
SCRRIGHT (*char8++, xoff8));
#endif /* PPW */
#else /* BITMAP_BIT_ORDER != IMAGE_BYTE_ORDER */
#if PPW == 32
#define GetBits4 c = *char1++ | \
SCRRIGHT (*char2, xoff2) | \
SCRRIGHT (*char3, xoff3) | \
SCRRIGHT (*char4, xoff4); \
char2++; char3++; char4++;
#else /* PPW == 64 */
#define GetBits4 c = (unsigned long)(((*char1++) << 64 ) | \
(SCRRIGHT (*char2, xoff2) << 64 ) | \
(SCRRIGHT (*char3, xoff3) << 64 ) | \
(SCRRIGHT (*char4, xoff4) << 64 ) | \
SCRRIGHT (*char5, xoff5) | \
SCRRIGHT (*char6, xoff6) | \
SCRRIGHT (*char7, xoff7) | \
SCRRIGHT (*char8, xoff8)); \
char2++; char3++; char4++; \
char5++; char6++; char7++; char8++;
#endif /* PPW */
#endif /* BITMAP_BIT_ORDER == IMAGE_BYTE_ORDER */
#endif /* BITMAP_BIT_ORDER && GLYPHPADBYTES */
#if GLYPHPADBYTES == 1
typedef unsigned char *glyphPointer;
#define USE_LEFTBITS
#endif
#if GLYPHPADBYTES == 2
typedef unsigned short *glyphPointer;
#define USE_LEFTBITS
#endif
#if GLYPHPADBYTES == 4
typedef unsigned int *glyphPointer;
#endif
#ifdef USE_LEFTBITS
#define GetBits1 getleftbits (char1, widthGlyph, c); \
c &= glyphMask; \
char1 = (glyphPointer) (((char *) char1) + glyphBytes);
#else
#define GetBits1 c = *char1++;
#endif
void
afbTEGlyphBlt (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
DrawablePtr pDrawable;
GC *pGC;
int x, y;
unsigned int nglyph;
CharInfoPtr *ppci; /* array of character info */
pointer pglyphBase; /* start of array of glyphs */
{
FontPtr pfont = pGC->font;
int widthDst;
PixelType *pdstBase; /* pointer to longword with top row
of current glyph */
int h; /* height of glyph and char */
register int xpos; /* current x */
int ypos; /* current y */
int widthGlyph;
int hTmp; /* counter for height */
register PixelType startmask, endmask;
int nfirst; /* used if glyphs spans a longword boundary */
BoxRec bbox; /* for clipping */
int widthGlyphs;
int sizeDst;
int depthDst;
PixelType *saveDst;
register PixelType *dst;
register PixelType c;
register int d;
register int xoff1, xoff2, xoff3, xoff4;
register glyphPointer char1, char2, char3, char4;
glyphPointer schar1, schar2, schar3, schar4;
#if PPW == 64
register int xoff5, xoff6, xoff7, xoff8;
register glyphPointer char5, char6, char7, char8;
glyphPointer schar5, schar6, schar7, schar8;
#endif /* PPW */
unsigned char *rrops;
#ifdef USE_LEFTBITS
register PixelType glyphMask;
register PixelType tmpSrc;
register int glyphBytes;
#endif
afbGetPixelWidthSizeDepthAndPointer(pDrawable, widthDst, sizeDst, depthDst,
pdstBase);
xpos = x + pDrawable->x;
ypos = y + pDrawable->y;
widthGlyph = FONTMAXBOUNDS(pfont,characterWidth);
h = FONTASCENT(pfont) + FONTDESCENT(pfont);
xpos += FONTMAXBOUNDS(pfont,leftSideBearing);
ypos -= FONTASCENT(pfont);
rrops = ((afbPrivGCPtr)dixLookupPrivate(&pGC->devPrivates,
afbGCPrivateKey))->rropOS;
bbox.x1 = xpos;
bbox.x2 = xpos + (widthGlyph * nglyph);
bbox.y1 = ypos;
bbox.y2 = ypos + h;
switch (RECT_IN_REGION(pGC->pScreen, pGC->pCompositeClip, &bbox)) {
case rgnPART:
/* this is the WRONG thing to do, but it works.
calling the non-terminal text is easy, but slow, given
what we know about the font.
the right thing to do is something like:
for each clip rectangle
compute at which row the glyph starts to be in it,
and at which row the glyph ceases to be in it
compute which is the first glyph inside the left
edge, and the last one inside the right edge
draw a fractional first glyph, using only
the rows we know are in
draw all the whole glyphs, using the appropriate rows
draw any pieces of the last glyph, using the right rows
this way, the code would take advantage of knowing that
all glyphs are the same height and don't overlap.
one day...
*/
afbImageGlyphBlt (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase);
case rgnOUT:
return;
}
pdstBase = afbScanlineDeltaNoBankSwitch(pdstBase, ypos, widthDst);
widthGlyphs = widthGlyph * PGSZB;
#ifdef USE_LEFTBITS
glyphMask = mfbGetendtab(widthGlyph);
glyphBytes = GLYPHWIDTHBYTESPADDED(*ppci);
#endif
if (nglyph >= PGSZB && widthGlyphs <= PPW) {
while (nglyph >= PGSZB) {
nglyph -= PGSZB;
xoff1 = xpos & PIM;
xoff2 = widthGlyph;
xoff3 = xoff2 + widthGlyph;
xoff4 = xoff3 + widthGlyph;
#if PPW == 64
xoff5 = xoff4 + widthGlyph;
xoff6 = xoff5 + widthGlyph;
xoff7 = xoff6 + widthGlyph;
xoff8 = xoff7 + widthGlyph;
#endif /* PPW */
schar1 = (glyphPointer)FONTGLYPHBITS(pglyphBase,(*ppci++));
schar2 = (glyphPointer)FONTGLYPHBITS(pglyphBase,(*ppci++));
schar3 = (glyphPointer)FONTGLYPHBITS(pglyphBase,(*ppci++));
schar4 = (glyphPointer)FONTGLYPHBITS(pglyphBase,(*ppci++));
#if PPW == 64
schar5 = (glyphPointer)FONTGLYPHBITS(pglyphBase,(*ppci++));
schar6 = (glyphPointer)FONTGLYPHBITS(pglyphBase,(*ppci++));
schar7 = (glyphPointer)FONTGLYPHBITS(pglyphBase,(*ppci++));
schar8 = (glyphPointer)FONTGLYPHBITS(pglyphBase,(*ppci++));
#endif /* PPW */
hTmp = h;
saveDst = afbScanlineOffset(pdstBase, (xpos >> PWSH)); /* switch now */
#ifndef FASTCHARS
if (xoff1 + widthGlyphs <= PPW) {
maskpartialbits (xoff1, widthGlyphs, startmask);
#endif
for (d = 0; d < depthDst; d++) {
hTmp = h;
dst = saveDst;
saveDst += sizeDst; /* @@@ NEXT PLANE @@@ */
switch (rrops[d]) {
case RROP_BLACK:
while (hTmp--) {
#ifdef FASTCHARS
FASTPUTBITS(0, xoff1, widthGlyphs, dst);
#else
*(dst) &= ~startmask;
#endif
afbScanlineInc(dst, widthDst);
}
break;
case RROP_WHITE:
while (hTmp--) {
#ifdef FASTCHARS
FASTPUTBITS(~0, xoff1, widthGlyphs, dst);
#else
*(dst) |= startmask;
#endif
afbScanlineInc(dst, widthDst);
}
break;
case RROP_INVERT:
char1 = schar1;
char2 = schar2;
char3 = schar3;
char4 = schar4;
/* XXX */
while (hTmp--) {
GetBits4
#ifdef FASTCHARS
# if BITMAP_BIT_ORDER == MSBFirst
c >>= PPW - widthGlyphs;
# endif
FASTPUTBITS(~c, xoff1, widthGlyphs, dst);
#else
*(dst) = ((*dst) & ~startmask) | (~SCRRIGHT(c, xoff1) & startmask);
#endif
afbScanlineInc(dst, widthDst);
}
break;
case RROP_COPY:
char1 = schar1;
char2 = schar2;
char3 = schar3;
char4 = schar4;
while (hTmp--) {
GetBits4
#ifdef FASTCHARS
# if BITMAP_BIT_ORDER == MSBFirst
c >>= PPW - widthGlyphs;
#endif
FASTPUTBITS(c, xoff1, widthGlyphs, dst);
#else
*(dst) = ((*dst) & ~startmask) | (SCRRIGHT(c, xoff1) & startmask);
#endif
afbScanlineInc(dst, widthDst);
}
break;
case RROP_NOP:
break;
} /* switch (rrops[d]) */
} /* for (d = ... ) */
#ifndef FASTCHARS
} else {
maskPPWbits (xoff1, widthGlyphs, startmask, endmask);
nfirst = PPW - xoff1;
for (d = 0; d < depthDst; d++) {
hTmp = h;
dst = saveDst;
saveDst += sizeDst; /* @@@ NEXT PLANE @@@ */
switch (rrops[d]) {
case RROP_BLACK:
while (hTmp--) {
dst[0] &= ~startmask;
dst[1] &= ~endmask;
afbScanlineInc(dst, widthDst);
}
break;
case RROP_WHITE:
while (hTmp--) {
dst[0] |= startmask;
dst[1] |= endmask;
afbScanlineInc(dst, widthDst);
}
break;
case RROP_INVERT:
char1 = schar1;
char2 = schar2;
char3 = schar3;
char4 = schar4;
while (hTmp--) {
GetBits4
dst[0] = (dst[0] & ~startmask) | (~SCRRIGHT(c,xoff1) & startmask);
dst[1] = (dst[1] & ~endmask) | (~SCRLEFT(c,nfirst) & endmask);
afbScanlineInc(dst, widthDst);
}
break;
case RROP_COPY:
char1 = schar1;
char2 = schar2;
char3 = schar3;
char4 = schar4;
while (hTmp--) {
GetBits4
dst[0] = (dst[0] & ~startmask) | (SCRRIGHT(c,xoff1) & startmask);
dst[1] = (dst[1] & ~endmask) | (SCRLEFT(c,nfirst) & endmask);
afbScanlineInc(dst, widthDst);
}
break;
case RROP_NOP:
break;
} /* switch */
} /* for (d = ... ) */
}
#endif
xpos += widthGlyphs;
}
}
while(nglyph--) {
xoff1 = xpos & PIM;
schar1 = (glyphPointer) FONTGLYPHBITS(pglyphBase,(*ppci++));
hTmp = h;
saveDst = afbScanlineOffset(pdstBase, (xpos >> PWSH));
if (xoff1 + widthGlyph <= PPW) {
maskpartialbits (xoff1, widthGlyph, startmask);
for (d = 0; d < depthDst; d++) {
hTmp = h;
dst = saveDst;
saveDst += sizeDst; /* @@@ NEXT PLANE @@@ */
char1 = schar1;
switch (rrops[d]) {
case RROP_BLACK:
while (hTmp--) {
(*dst) &= ~startmask;
afbScanlineInc(dst, widthDst);
}
break;
case RROP_WHITE:
while (hTmp--) {
(*dst) |= startmask;
afbScanlineInc(dst, widthDst);
}
break;
case RROP_INVERT:
while (hTmp--) {
#ifdef FASTCHARS
#ifdef USE_LEFTBITS
FASTGETBITS (char1,0,widthGlyph,c);
char1 = (glyphPointer) (((char *) char1) + glyphBytes);
#else
c = *char1++;
#if BITMAP_BIT_ORDER == MSBFirst
c >>= PPW - widthGlyph;
#endif
#endif
FASTPUTBITS (~c,xoff1,widthGlyph,dst);
#else
GetBits1
(*dst) = ((*dst) & ~startmask) | (~SCRRIGHT(c, xoff1) & startmask);
#endif
afbScanlineInc(dst, widthDst);
}
break;
case RROP_COPY:
while (hTmp--) {
#ifdef FASTCHARS
#ifdef USE_LEFTBITS
FASTGETBITS (char1,0,widthGlyph,c);
char1 = (glyphPointer) (((char *) char1) + glyphBytes);
#else
c = *char1++;
#if BITMAP_BIT_ORDER == MSBFirst
c >>= PPW - widthGlyph;
#endif
#endif
FASTPUTBITS (c,xoff1,widthGlyph,dst);
#else
GetBits1
(*dst) = ((*dst) & ~startmask) | (SCRRIGHT(c, xoff1) & startmask);
#endif
afbScanlineInc(dst, widthDst);
}
break;
case RROP_NOP:
break;
} /* switch */
} /* for (d = ...) */
} else {
maskPPWbits (xoff1, widthGlyph, startmask, endmask);
nfirst = PPW - xoff1;
for (d = 0; d < depthDst; d++) {
hTmp = h;
dst = saveDst;
saveDst += sizeDst; /* @@@ NEXT PLANE @@@ */
char1 = schar1;
switch (rrops[d]) {
case RROP_BLACK:
while (hTmp--) {
dst[0] &= ~startmask;
dst[1] &= ~endmask;
afbScanlineInc(dst, widthDst);
}
break;
case RROP_WHITE:
while (hTmp--) {
dst[0] |= startmask;
dst[1] |= endmask;
afbScanlineInc(dst, widthDst);
}
break;
case RROP_INVERT:
while (hTmp--) {
GetBits1
dst[0] = (dst[0] & ~startmask) | (~SCRRIGHT(c,xoff1) & startmask);
dst[1] = (dst[1] & ~endmask) | (~SCRLEFT(c,nfirst) & endmask);
afbScanlineInc(dst, widthDst);
}
break;
case RROP_COPY:
while (hTmp--) {
GetBits1
dst[0] = (dst[0] & ~startmask) | (SCRRIGHT(c,xoff1) & startmask);
dst[1] = (dst[1] & ~endmask) | (SCRLEFT(c,nfirst) & endmask);
afbScanlineInc(dst, widthDst);
}
break;
case RROP_NOP:
break;
} /* switch */
} /* for (d = ...) */
}
xpos += widthGlyph;
}
}

857
afb/afbtile.c
View File

@ -1,857 +0,0 @@
/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
/***********************************************************
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <X11/X.h>
#include "windowstr.h"
#include "regionstr.h"
#include "pixmapstr.h"
#include "scrnintstr.h"
#include "afb.h"
#include "maskbits.h"
#include "mergerop.h"
/*
the boxes are already translated.
NOTE:
iy = ++iy < tileHeight ? iy : 0
is equivalent to iy%= tileheight, and saves a division.
*/
/*
tile area with a PPW bit wide pixmap
*/
void
MROP_NAME(afbTileAreaPPW)(pDraw, nbox, pbox, alu, ptile, planemask)
DrawablePtr pDraw;
int nbox;
BoxPtr pbox;
int alu;
PixmapPtr ptile;
unsigned long planemask;
{
register PixelType *psrc;
/* pointer to bits in tile, if needed */
int tileHeight; /* height of the tile */
register PixelType srcpix;
int nlwidth; /* width in longwords of the drawable */
int w; /* width of current box */
MROP_DECLARE_REG ()
register int h; /* height of current box */
register int nlw; /* loop version of nlwMiddle */
register PixelType *p; /* pointer to bits we're writing */
int sizeDst;
int depthDst;
register int d;
PixelType startmask;
PixelType endmask; /* masks for reggedy bits at either end of line */
int nlwMiddle; /* number of longwords between sides of boxes */
int nlwExtra; /* to get from right of box to left of next span */
register int iy; /* index of current scanline in tile */
PixelType *pbits; /* pointer to start of drawable */
PixelType *saveP;
PixelType *pSaveSrc;
int saveH;
int saveIY;
afbGetPixelWidthSizeDepthAndPointer(pDraw, nlwidth, sizeDst, depthDst,
pbits);
MROP_INITIALIZE(alu,~0)
tileHeight = ptile->drawable.height;
pSaveSrc = (PixelType *)(ptile->devPrivate.ptr);
while (nbox--) {
w = pbox->x2 - pbox->x1;
saveH = pbox->y2 - pbox->y1;
saveIY = pbox->y1 % tileHeight;
saveP = afbScanline(pbits, pbox->x1, pbox->y1, nlwidth);
psrc = pSaveSrc;
if (((pbox->x1 & PIM) + w) < PPW) {
maskpartialbits(pbox->x1, w, startmask);
nlwExtra = nlwidth;
for (d = 0; d < depthDst; d++, saveP += sizeDst, psrc += tileHeight) { /* @@@ NEXT PLANE @@@ */
if (!(planemask & (1 << d)))
continue;
p = saveP;
h = saveH;
iy = saveIY;
while (h--) {
srcpix = psrc[iy];
iy++;
if (iy == tileHeight)
iy = 0;
*p = MROP_MASK(srcpix,*p,startmask);
afbScanlineInc(p, nlwExtra);
}
}
} else {
maskbits(pbox->x1, w, startmask, endmask, nlwMiddle);
for (d = 0; d < depthDst; d++, saveP += sizeDst, psrc += tileHeight) { /* @@@ NEXT PLANE @@@ */
if (!(planemask & (1 << d)))
continue;
p = saveP;
h = saveH;
iy = saveIY;
nlwExtra = nlwidth - nlwMiddle;
if (startmask && endmask) {
nlwExtra -= 1;
while (h--) {
srcpix = psrc[iy];
iy++;
if (iy == tileHeight)
iy = 0;
nlw = nlwMiddle;
*p = MROP_MASK (srcpix,*p,startmask);
p++;
while (nlw--) {
*p = MROP_SOLID(srcpix,*p);
p++;
}
*p = MROP_MASK(srcpix,*p,endmask);
afbScanlineInc(p, nlwExtra);
}
} else if (startmask && !endmask) {
nlwExtra -= 1;
while (h--) {
srcpix = psrc[iy];
iy++;
if (iy == tileHeight)
iy = 0;
nlw = nlwMiddle;
*p = MROP_MASK(srcpix,*p,startmask);
p++;
while (nlw--) {
*p = MROP_SOLID(srcpix,*p);
p++;
}
afbScanlineInc(p, nlwExtra);
}
} else if (!startmask && endmask) {
while (h--) {
srcpix = psrc[iy];
iy++;
if (iy == tileHeight)
iy = 0;
nlw = nlwMiddle;
while (nlw--) {
*p = MROP_SOLID(srcpix,*p);
p++;
}
*p = MROP_MASK(srcpix,*p,endmask);
afbScanlineInc(p, nlwExtra);
}
} else { /* no ragged bits at either end */
while (h--) {
srcpix = psrc[iy];
iy++;
if (iy == tileHeight)
iy = 0;
nlw = nlwMiddle;
while (nlw--) {
*p = MROP_SOLID (srcpix,*p);
p++;
}
afbScanlineInc(p, nlwExtra);
}
}
} /* for (d = ...) */
}
pbox++;
}
}
void
MROP_NAME(afbTileArea)(pDraw, nbox, pbox, alu, pTile, xOff, yOff, planemask)
DrawablePtr pDraw;
int nbox;
BoxPtr pbox;
int alu;
PixmapPtr pTile;
int xOff;
int yOff;
unsigned long planemask;
{
register PixelType *psrc;
/* pointer to bits in tile, if needed */
int nlwidth; /* width in longwords of the drawable */
MROP_DECLARE_REG ()
register int h; /* height of current box */
register PixelType *pdst; /* pointer to bits we're writing */
register PixelType tmpsrc;
#if (MROP) != Mcopy
register PixelType tmpdst;
#endif
int sizeDst;
int depthDst;
int sizeTile;
int tileLine;
int iline;
int w, width, x, xSrc, ySrc, srcStartOver, nend;
int tlwidth, rem, tileWidth, tileHeight, endinc;
int saveW;
PixelType *psrcT;
int d;
int nstart;
PixelType startmask;
PixelType endmask; /* masks for reggedy bits at either end of line */
int nlMiddle; /* number of longwords between sides of boxes */
int iy;
PixelType *pBase; /* pointer to start of drawable */
PixelType *saveP;
PixelType *pStartDst;
PixelType *pStartTile;
int saveH;
afbGetPixelWidthSizeDepthAndPointer(pDraw, nlwidth, sizeDst, depthDst,
pBase);
MROP_INITIALIZE(alu,~0)
tileHeight = pTile->drawable.height;
tileWidth = pTile->drawable.width;
tlwidth = pTile->devKind / sizeof (PixelType);
sizeTile = tlwidth * tileHeight;
xSrc = pDraw->x + ((xOff % tileWidth) - tileWidth);
ySrc = pDraw->y + ((yOff % tileHeight) - tileHeight);
while (nbox--) {
saveW = pbox->x2 - pbox->x1;
iline = (pbox->y1 - ySrc) % tileHeight;
psrcT = (PixelType *) pTile->devPrivate.ptr;
tileLine = iline * tlwidth;
saveH = pbox->y2 - pbox->y1;
saveP = afbScanline(pBase, pbox->x1, pbox->y1, nlwidth);
for (d = 0; d < depthDst; d++, psrcT += sizeTile, saveP += sizeDst) { /* @@@ NEXT PLANE @@@ */
if (!(planemask & (1 << d)))
continue;
h = saveH;
pStartDst = saveP;
pStartTile = psrcT + tileLine;
iy = iline;
while (h--) {
x = pbox->x1;
width = saveW;
pdst = pStartDst;
while(width > 0) {
psrc = pStartTile;
w = min(tileWidth, width);
if((rem = (x - xSrc) % tileWidth) != 0) {
/* if we're in the middle of the tile, get
as many bits as will finish the span, or
as many as will get to the left edge of the tile,
or a longword worth, starting at the appropriate
offset in the tile.
*/
w = min(min(tileWidth - rem, width), BITMAP_SCANLINE_PAD);
endinc = rem / BITMAP_SCANLINE_PAD;
getbits ((psrc+endinc), (rem&PIM), w, tmpsrc);
#if (MROP) != Mcopy
getbits (pdst, (x & PIM), w, tmpdst);
tmpsrc = DoMergeRop (tmpsrc, tmpdst);
#endif
putbits (tmpsrc, (x & PIM), w, pdst);
if((x & PIM) + w >= PPW)
pdst++;
} else if(((x & PIM) + w) < PPW) {
/* doing < PPW bits is easy, and worth special-casing */
tmpsrc = *psrc;
#if (MROP) != Mcopy
getbits (pdst, (x & PIM), w, tmpdst);
tmpsrc = DoMergeRop (tmpsrc, tmpdst);
#endif
putbits (tmpsrc, (x & PIM), w, pdst);
} else {
/* start at the left edge of the tile,
and put down as much as we can
*/
maskbits(x, w, startmask, endmask, nlMiddle);
if (startmask)
nstart = PPW - (x & PIM);
else
nstart = 0;
if (endmask)
nend = (x + w) & PIM;
else
nend = 0;
srcStartOver = nstart > PLST;
if(startmask) {
tmpsrc = *psrc;
#if (MROP) != Mcopy
getbits (pdst, (x & PIM), nstart, tmpdst);
tmpsrc = DoMergeRop (tmpsrc, tmpdst);
#endif
putbits (tmpsrc, (x & PIM), nstart, pdst);
pdst++;
if(srcStartOver)
psrc++;
}
while(nlMiddle--) {
getbits (psrc, nstart, PPW, tmpsrc);
#if (MROP) != Mcopy
tmpdst = *pdst;
tmpsrc = DoMergeRop (tmpsrc, tmpdst);
#endif
*pdst++ = tmpsrc;
/*putbits (tmpsrc, 0, PPW, pdst);
pdst++;*/
psrc++;
}
if(endmask) {
getbits (psrc, nstart, nend, tmpsrc);
#if (MROP) != Mcopy
tmpdst = *pdst;
tmpsrc = DoMergeRop (tmpsrc, tmpdst);
#endif
putbits (tmpsrc, 0, nend, pdst);
}
}
x += w;
width -= w;
} /* while (width > 0) */
pStartDst += nlwidth;
if (++iy >= tileHeight) {
iy = 0;
pStartTile = psrcT;
} else
pStartTile += tlwidth;
} /* while (h) */
} /* for (d = ... ) */
pbox++;
} /* for each box */
}
void
MROP_NAME(afbOpaqueStippleAreaPPW)(pDraw, nbox, pbox, alu, ptile,
rropsOS, planemask)
DrawablePtr pDraw;
int nbox;
BoxPtr pbox;
int alu;
PixmapPtr ptile;
register unsigned char *rropsOS;
unsigned long planemask;
{
register PixelType *psrc;
/* pointer to bits in tile, if needed */
int tileHeight; /* height of the tile */
register PixelType srcpix = 0;
int nlwidth; /* width in longwords of the drawable */
int w; /* width of current box */
MROP_DECLARE_REG ()
register int h; /* height of current box */
register int nlw; /* loop version of nlwMiddle */
register PixelType *p; /* pointer to bits we're writing */
int sizeDst;
int depthDst;
register int d;
PixelType startmask;
PixelType endmask; /* masks for reggedy bits at either end of line */
int nlwMiddle; /* number of longwords between sides of boxes */
int nlwExtra; /* to get from right of box to left of next span */
register int iy; /* index of current scanline in tile */
PixelType *pbits; /* pointer to start of drawable */
PixelType *saveP;
int saveH;
int saveIY;
afbGetPixelWidthSizeDepthAndPointer(pDraw, nlwidth, sizeDst, depthDst,
pbits);
MROP_INITIALIZE(alu,~0)
tileHeight = ptile->drawable.height;
psrc = (PixelType *)(ptile->devPrivate.ptr);
while (nbox--) {
w = pbox->x2 - pbox->x1;
saveH = pbox->y2 - pbox->y1;
saveIY = pbox->y1 % tileHeight;
saveP = afbScanline(pbits, pbox->x1, pbox->y1, nlwidth);
if ( ((pbox->x1 & PIM) + w) < PPW) {
maskpartialbits(pbox->x1, w, startmask);
nlwExtra = nlwidth;
for (d = 0; d < depthDst; d++, saveP += sizeDst) { /* @@@ NEXT PLANE @@@ */
if (!(planemask & (1 << d)))
continue;
p = saveP;
h = saveH;
iy = saveIY;
while (h--) {
switch (rropsOS[d]) {
case RROP_BLACK:
srcpix = 0;
break;
case RROP_WHITE:
srcpix = ~0;
break;
case RROP_COPY:
srcpix = psrc[iy];
break;
case RROP_INVERT:
srcpix = ~psrc[iy];
break;
}
iy++;
if (iy == tileHeight)
iy = 0;
*p = MROP_MASK(srcpix,*p,startmask);
afbScanlineInc(p, nlwExtra);
}
}
} else {
maskbits(pbox->x1, w, startmask, endmask, nlwMiddle);
for (d = 0; d < depthDst; d++, saveP += sizeDst) { /* @@@ NEXT PLANE @@@ */
if (!(planemask & (1 << d)))
continue;
p = saveP;
h = saveH;
iy = saveIY;
nlwExtra = nlwidth - nlwMiddle;
if (startmask && endmask) {
nlwExtra -= 1;
while (h--) {
switch (rropsOS[d]) {
case RROP_BLACK:
srcpix = 0;
break;
case RROP_WHITE:
srcpix = ~0;
break;
case RROP_COPY:
srcpix = psrc[iy];
break;
case RROP_INVERT:
srcpix = ~psrc[iy];
break;
}
iy++;
if (iy == tileHeight)
iy = 0;
nlw = nlwMiddle;
*p = MROP_MASK (srcpix,*p,startmask);
p++;
while (nlw--) {
*p = MROP_SOLID(srcpix,*p);
p++;
}
*p = MROP_MASK(srcpix,*p,endmask);
afbScanlineInc(p, nlwExtra);
}
} else if (startmask && !endmask) {
nlwExtra -= 1;
while (h--) {
switch (rropsOS[d]) {
case RROP_BLACK:
srcpix = 0;
break;
case RROP_WHITE:
srcpix = ~0;
break;
case RROP_COPY:
srcpix = psrc[iy];
break;
case RROP_INVERT:
srcpix = ~psrc[iy];
break;
}
iy++;
if (iy == tileHeight)
iy = 0;
nlw = nlwMiddle;
*p = MROP_MASK(srcpix,*p,startmask);
p++;
while (nlw--) {
*p = MROP_SOLID(srcpix,*p);
p++;
}
afbScanlineInc(p, nlwExtra);
}
} else if (!startmask && endmask) {
while (h--) {
switch (rropsOS[d]) {
case RROP_BLACK:
srcpix = 0;
break;
case RROP_WHITE:
srcpix = ~0;
break;
case RROP_COPY:
srcpix = psrc[iy];
break;
case RROP_INVERT:
srcpix = ~psrc[iy];
break;
}
iy++;
if (iy == tileHeight)
iy = 0;
nlw = nlwMiddle;
while (nlw--) {
*p = MROP_SOLID(srcpix,*p);
p++;
}
*p = MROP_MASK(srcpix,*p,endmask);
afbScanlineInc(p, nlwExtra);
}
} else { /* no ragged bits at either end */
while (h--) {
switch (rropsOS[d]) {
case RROP_BLACK:
srcpix = 0;
break;
case RROP_WHITE:
srcpix = ~0;
break;
case RROP_COPY:
srcpix = psrc[iy];
break;
case RROP_INVERT:
srcpix = ~psrc[iy];
break;
}
iy++;
if (iy == tileHeight)
iy = 0;
nlw = nlwMiddle;
while (nlw--) {
*p = MROP_SOLID (srcpix,*p);
p++;
}
afbScanlineInc(p, nlwExtra);
}
}
} /* for (d = ...) */
}
pbox++;
}
}
void
MROP_NAME(afbOpaqueStippleArea)(pDraw, nbox, pbox, alu, pTile, xOff, yOff,
rropsOS, planemask)
DrawablePtr pDraw;
int nbox;
BoxPtr pbox;
int alu;
PixmapPtr pTile;
int xOff;
int yOff;
register unsigned char *rropsOS;
unsigned long planemask;
{
register PixelType *psrc;
/* pointer to bits in tile, if needed */
int nlwidth; /* width in longwords of the drawable */
MROP_DECLARE_REG ()
register int h; /* height of current box */
register PixelType *pdst; /* pointer to bits we're writing */
register PixelType tmpsrc = 0;
#if (MROP) != Mcopy
register PixelType tmpdst;
#endif
int sizeDst;
int depthDst;
int tileLine;
int iline;
int w, width, x, xSrc, ySrc, srcStartOver, nend;
int tlwidth, rem, tileWidth, tileHeight, endinc;
int saveW;
PixelType *psrcT;
int d;
int nstart;
PixelType startmask;
PixelType endmask; /* masks for reggedy bits at either end of line */
int nlMiddle; /* number of longwords between sides of boxes */
int iy;
PixelType *pBase; /* pointer to start of drawable */
PixelType *saveP;
PixelType *pStartDst;
PixelType *pStartTile;
int saveH;
afbGetPixelWidthSizeDepthAndPointer(pDraw, nlwidth, sizeDst, depthDst,
pBase);
MROP_INITIALIZE(alu,~0)
tileHeight = pTile->drawable.height;
tileWidth = pTile->drawable.width;
tlwidth = pTile->devKind / sizeof (PixelType);
xSrc = pDraw->x + ((xOff % tileWidth) - tileWidth);
ySrc = pDraw->y + ((yOff % tileHeight) - tileHeight);
while (nbox--) {
saveW = pbox->x2 - pbox->x1;
iline = (pbox->y1 - ySrc) % tileHeight;
psrcT = (PixelType *) pTile->devPrivate.ptr;
tileLine = iline * tlwidth;
saveH = pbox->y2 - pbox->y1;
saveP = afbScanline(pBase, pbox->x1, pbox->y1, nlwidth);
for (d = 0; d < depthDst; d++, saveP += sizeDst) { /* @@@ NEXT PLANE @@@ */
if (!(planemask & (1 << d)))
continue;
h = saveH;
pStartDst = saveP;
pStartTile = psrcT + tileLine;
iy = iline;
while (h--) {
x = pbox->x1;
width = saveW;
pdst = pStartDst;
while(width > 0) {
psrc = pStartTile;
w = min(tileWidth, width);
if((rem = (x - xSrc) % tileWidth) != 0) {
/* if we're in the middle of the tile, get
as many bits as will finish the span, or
as many as will get to the left edge of the tile,
or a longword worth, starting at the appropriate
offset in the tile.
*/
w = min(min(tileWidth - rem, width), BITMAP_SCANLINE_PAD);
endinc = rem / BITMAP_SCANLINE_PAD;
switch (rropsOS[d]) {
case RROP_BLACK:
tmpsrc = 0;
break;
case RROP_WHITE:
tmpsrc = ~0;
break;
case RROP_COPY:
getbits ((psrc+endinc), (rem&PIM), w, tmpsrc);
break;
case RROP_INVERT:
getbits ((psrc+endinc), (rem&PIM), w, tmpsrc);
tmpsrc = ~tmpsrc;
break;
}
#if (MROP) != Mcopy
getbits (pdst, (x & PIM), w, tmpdst);
tmpsrc = DoMergeRop (tmpsrc, tmpdst);
#endif
putbits (tmpsrc, (x & PIM), w, pdst);
if((x & PIM) + w >= PPW)
pdst++;
} else if(((x & PIM) + w) < PPW) {
/* doing < PPW bits is easy, and worth special-casing */
switch (rropsOS[d]) {
case RROP_BLACK:
tmpsrc = 0;
break;
case RROP_WHITE:
tmpsrc = ~0;
break;
case RROP_COPY:
tmpsrc = *psrc;
break;
case RROP_INVERT:
tmpsrc = ~*psrc;
break;
}
#if (MROP) != Mcopy
getbits (pdst, (x & PIM), w, tmpdst);
tmpsrc = DoMergeRop (tmpsrc, tmpdst);
#endif
putbits (tmpsrc, (x & PIM), w, pdst);
} else {
/* start at the left edge of the tile,
and put down as much as we can
*/
maskbits(x, w, startmask, endmask, nlMiddle);
if (startmask)
nstart = PPW - (x & PIM);
else
nstart = 0;
if (endmask)
nend = (x + w) & PIM;
else
nend = 0;
srcStartOver = nstart > PLST;
if(startmask) {
switch (rropsOS[d]) {
case RROP_BLACK:
tmpsrc = 0;
break;
case RROP_WHITE:
tmpsrc = ~0;
break;
case RROP_COPY:
tmpsrc = *psrc;
break;
case RROP_INVERT:
tmpsrc = ~*psrc;
break;
}
#if (MROP) != Mcopy
getbits (pdst, (x & PIM), nstart, tmpdst);
tmpsrc = DoMergeRop (tmpsrc, tmpdst);
#endif
putbits (tmpsrc, (x & PIM), nstart, pdst);
pdst++;
if(srcStartOver)
psrc++;
}
while(nlMiddle--) {
switch (rropsOS[d]) {
case RROP_BLACK:
tmpsrc = 0;
break;
case RROP_WHITE:
tmpsrc = ~0;
break;
case RROP_COPY:
getbits (psrc, nstart, PPW, tmpsrc);
break;
case RROP_INVERT:
getbits (psrc, nstart, PPW, tmpsrc);
tmpsrc = ~tmpsrc;
break;
}
#if (MROP) != Mcopy
tmpdst = *pdst;
tmpsrc = DoMergeRop (tmpsrc, tmpdst);
#endif
*pdst++ = tmpsrc;
/*putbits (tmpsrc, 0, PPW, pdst);
pdst++; */
psrc++;
}
if(endmask) {
switch (rropsOS[d]) {
case RROP_BLACK:
tmpsrc = 0;
break;
case RROP_WHITE:
tmpsrc = ~0;
break;
case RROP_COPY:
getbits (psrc, nstart, nend, tmpsrc);
break;
case RROP_INVERT:
getbits (psrc, nstart, nend, tmpsrc);
tmpsrc = ~tmpsrc;
break;
}
#if (MROP) != Mcopy
tmpdst = *pdst;
tmpsrc = DoMergeRop (tmpsrc, tmpdst);
#endif
putbits (tmpsrc, 0, nend, pdst);
}
}
x += w;
width -= w;
} /* while (width > 0) */
pStartDst += nlwidth;
if (++iy >= tileHeight) {
iy = 0;
pStartTile = psrcT;
} else
pStartTile += tlwidth;
} /* while (h) */
} /* for (d = ... ) */
pbox++;
} /* for each box */
}

164
afb/afbwindow.c
View File

@ -1,164 +0,0 @@
/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
/***********************************************************
Copyright (c) 1987 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <stdlib.h>
#include <X11/X.h>
#include "scrnintstr.h"
#include "windowstr.h"
#include "privates.h"
#include "afb.h"
#include "mistruct.h"
#include "regionstr.h"
#include "maskbits.h"
Bool
afbCreateWindow(WindowPtr pWin)
{
return (TRUE);
}
/* This always returns true, because Xfree can't fail. It might be possible
* on some devices for Destroy to fail */
Bool
afbDestroyWindow(WindowPtr pWin)
{
return (TRUE);
}
/*ARGSUSED*/
Bool
afbMapWindow(pWindow)
WindowPtr pWindow;
{
return (TRUE);
}
/*ARGSUSED*/
Bool
afbPositionWindow(WindowPtr pWin, int x, int y)
{
/* This is the "wrong" fix to the right problem, but it doesn't really
* cost very much. When the window is moved, we need to invalidate any
* RotatedPixmap that exists in any GC currently validated against this
* window.
*/
pWin->drawable.serialNumber = NEXT_SERIAL_NUMBER;
/* Again, we have no failure modes indicated by any of the routines
* we've called, so we have to assume it worked */
return (TRUE);
}
/*ARGSUSED*/
Bool
afbUnmapWindow(pWindow)
WindowPtr pWindow;
{
return (TRUE);
}
/* UNCLEAN!
this code calls the bitblt helper code directly.
afbCopyWindow copies only the parts of the destination that are
visible in the source.
*/
void
afbCopyWindow(pWin, ptOldOrg, prgnSrc)
WindowPtr pWin;
DDXPointRec ptOldOrg;
RegionPtr prgnSrc;
{
DDXPointPtr pptSrc;
register DDXPointPtr ppt;
RegionPtr prgnDst;
register BoxPtr pbox;
register int dx, dy;
register int i, nbox;
WindowPtr pwinRoot;
pwinRoot = WindowTable[pWin->drawable.pScreen->myNum];
prgnDst = REGION_CREATE(pWin->drawable.pScreen, NULL, 1);
dx = ptOldOrg.x - pWin->drawable.x;
dy = ptOldOrg.y - pWin->drawable.y;
REGION_TRANSLATE(pWin->drawable.pScreen, prgnSrc, -dx, -dy);
REGION_INTERSECT(pWin->drawable.pScreen, prgnDst, &pWin->borderClip,
prgnSrc);
pbox = REGION_RECTS(prgnDst);
nbox = REGION_NUM_RECTS(prgnDst);
if(!(pptSrc = (DDXPointPtr )xalloc(nbox * sizeof(DDXPointRec))))
return;
ppt = pptSrc;
for (i=nbox; --i >= 0; ppt++, pbox++) {
ppt->x = pbox->x1 + dx;
ppt->y = pbox->y1 + dy;
}
afbDoBitblt((DrawablePtr)pwinRoot, (DrawablePtr)pwinRoot, GXcopy, prgnDst,
pptSrc, ~0);
xfree(pptSrc);
REGION_DESTROY(pWin->drawable.pScreen, prgnDst);
}
Bool
afbChangeWindowAttributes(WindowPtr pWin, unsigned long mask)
{
return (TRUE);
}

201
afb/afbzerarc.c
View File

@ -1,201 +0,0 @@
/************************************************************
Copyright (c) 1989 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
********************************************************/
/* Derived from:
* "Algorithm for drawing ellipses or hyperbolae with a digital plotter"
* by M. L. V. Pitteway
* The Computer Journal, November 1967, Volume 10, Number 3, pp. 282-289
*/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <X11/X.h>
#include <X11/Xprotostr.h>
#include "regionstr.h"
#include "gcstruct.h"
#include "pixmapstr.h"
#include "scrnintstr.h"
#include "afb.h"
#include "maskbits.h"
#include "mizerarc.h"
#include "mi.h"
/*
* Note: LEFTMOST must be the bit leftmost in the actual screen
* representation. This depends also on the IMAGE_BYTE_ORDER.
* LONG2CHARS() takes care of the re-ordering as required. (DHD)
*/
#if (BITMAP_BIT_ORDER == MSBFirst)
#define LEFTMOST ((PixelType) LONG2CHARS((1 << PLST)))
#else
#define LEFTMOST ((PixelType) LONG2CHARS(1))
#endif
#define Pixelate(base,yoff,xoff) \
{ \
paddr = afbScanlineOffset(base, (yoff) + ((xoff)>>PWSH)); \
pmask = SCRRIGHT(LEFTMOST, (xoff) & PIM); \
for (de = 0; de < depthDst; de++, paddr += sizeDst) /* @@@ NEXT PLANE @@@ */ \
switch (rrops[de]) { \
case RROP_BLACK: \
*paddr &= ~pmask; \
break; \
case RROP_WHITE: \
*paddr |= pmask; \
break; \
case RROP_INVERT: \
*paddr ^= pmask; \
break; \
case RROP_NOP: \
break; \
} \
}
#define DoPix(bit,base,yoff,xoff) if (mask & bit) Pixelate(base,yoff,xoff);
static void
afbZeroArcSS(DrawablePtr pDraw, GCPtr pGC, xArc *arc)
{
miZeroArcRec info;
Bool do360;
register int de;
register int x, y, a, b, d, mask;
register int k1, k3, dx, dy;
PixelType *addrl;
PixelType *yorgl, *yorgol;
int nlwidth, yoffset, dyoffset;
int sizeDst, depthDst;
PixelType pmask;
register PixelType *paddr;
register unsigned char *rrops;
rrops = ((afbPrivGC *)dixLookupPrivate(&pGC->devPrivates,
afbGCPrivateKey))->rrops;
afbGetPixelWidthSizeDepthAndPointer(pDraw, nlwidth, sizeDst, depthDst,
addrl);
do360 = miZeroArcSetup(arc, &info, TRUE);
yorgl = addrl + ((info.yorg + pDraw->y) * nlwidth);
yorgol = addrl + ((info.yorgo + pDraw->y) * nlwidth);
info.xorg += pDraw->x;
info.xorgo += pDraw->x;
MIARCSETUP();
yoffset = y ? nlwidth : 0;
dyoffset = 0;
mask = info.initialMask;
if (!(arc->width & 1)) {
DoPix(2, yorgl, 0, info.xorgo);
DoPix(8, yorgol, 0, info.xorgo);
}
if (!info.end.x || !info.end.y) {
mask = info.end.mask;
info.end = info.altend;
}
if (do360 && (arc->width == arc->height) && !(arc->width & 1)) {
int xoffset = nlwidth;
PixelType *yorghl = afbScanlineDeltaNoBankSwitch(yorgl, info.h, nlwidth);
int xorghp = info.xorg + info.h;
int xorghn = info.xorg - info.h;
while (1) {
Pixelate(yorgl, yoffset, info.xorg + x);
Pixelate(yorgl, yoffset, info.xorg - x);
Pixelate(yorgol, -yoffset, info.xorg - x);
Pixelate(yorgol, -yoffset, info.xorg + x);
if (a < 0)
break;
Pixelate(yorghl, -xoffset, xorghp - y);
Pixelate(yorghl, -xoffset, xorghn + y);
Pixelate(yorghl, xoffset, xorghn + y);
Pixelate(yorghl, xoffset, xorghp - y);
xoffset += nlwidth;
MIARCCIRCLESTEP(yoffset += nlwidth;);
}
x = info.w;
yoffset = info.h * nlwidth;
} else if (do360) {
while (y < info.h || x < info.w) {
MIARCOCTANTSHIFT(dyoffset = nlwidth;);
Pixelate(yorgl, yoffset, info.xorg + x);
Pixelate(yorgl, yoffset, info.xorgo - x);
Pixelate(yorgol, -yoffset, info.xorgo - x);
Pixelate(yorgol, -yoffset, info.xorg + x);
MIARCSTEP(yoffset += dyoffset;, yoffset += nlwidth;);
}
} else {
while (y < info.h || x < info.w) {
MIARCOCTANTSHIFT(dyoffset = nlwidth;);
if ((x == info.start.x) || (y == info.start.y)) {
mask = info.start.mask;
info.start = info.altstart;
}
DoPix(1, yorgl, yoffset, info.xorg + x);
DoPix(2, yorgl, yoffset, info.xorgo - x);
DoPix(4, yorgol, -yoffset, info.xorgo - x);
DoPix(8, yorgol, -yoffset, info.xorg + x);
if ((x == info.end.x) || (y == info.end.y)) {
mask = info.end.mask;
info.end = info.altend;
}
MIARCSTEP(yoffset += dyoffset;, yoffset += nlwidth;);
}
}
if ((x == info.start.x) || (y == info.start.y))
mask = info.start.mask;
DoPix(1, yorgl, yoffset, info.xorg + x);
DoPix(4, yorgol, -yoffset, info.xorgo - x);
if (arc->height & 1) {
DoPix(2, yorgl, yoffset, info.xorgo - x);
DoPix(8, yorgol, -yoffset, info.xorg + x);
}
}
void
afbZeroPolyArcSS(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc *parcs)
{
register xArc *arc;
register int i;
BoxRec box;
RegionPtr cclip;
cclip = pGC->pCompositeClip;
for (arc = parcs, i = narcs; --i >= 0; arc++) {
if (miCanZeroArc(arc)) {
box.x1 = arc->x + pDraw->x;
box.y1 = arc->y + pDraw->y;
box.x2 = box.x1 + (int)arc->width + 1;
box.y2 = box.y1 + (int)arc->height + 1;
if (RECT_IN_REGION(pDraw->pScreen, cclip, &box) == rgnIN)
afbZeroArcSS(pDraw, pGC, arc);
else
miZeroPolyArc(pDraw, pGC, 1, arc);
} else
miPolyArc(pDraw, pGC, 1, arc);
}
}

6
configure.ac
View File

@ -573,7 +573,6 @@ AC_ARG_ENABLE(xglx, AS_HELP_STRING([--enable-xglx], [Build Xglx xgl mo
AC_ARG_ENABLE(xegl, AS_HELP_STRING([--enable-xegl], [Build Xegl xgl module (default: no)]), [XEGL=$enableval], [XEGL=no])
dnl legacy fb support
AC_ARG_ENABLE(mfb, AS_HELP_STRING([--enable-mfb], [Build legacy mono framebuffer support (default: disable)]), [MFB=$enableval], [MFB=no])
AC_ARG_ENABLE(afb, AS_HELP_STRING([--enable-afb], [Build legacy advanced framebuffer support (default: disable)]), [AFB=$enableval], [AFB=no])
dnl kdrive and its subsystems
AC_ARG_ENABLE(kdrive, AS_HELP_STRING([--enable-kdrive], [Build kdrive servers (default: no)]), [KDRIVE=$enableval], [KDRIVE=no])
AC_ARG_ENABLE(xephyr, AS_HELP_STRING([--enable-xephyr], [Build the kdrive Xephyr server (default: auto)]), [XEPHYR=$enableval], [XEPHYR=auto])
@ -1581,10 +1580,8 @@ AM_CONDITIONAL([XF86VIDMODE], [test "x$XF86VIDMODE" = xyes])
dnl legacy fb support
test "x$MFB" = xauto && MFB="$XORG"
test "x$AFB" = xauto && AFB="$XORG"
AM_CONDITIONAL(MFB, [test "x$MFB" = xyes])
AM_CONDITIONAL(AFB, [test "x$AFB" = xyes])
if test "x$MFB" = xyes -o "x$AFB" = xyes; then
if test "x$MFB" = xyes; then
if test "x$XORG" != xyes; then
AC_MSG_ERROR([legacy fb support requires the Xorg server])
fi
@ -1992,7 +1989,6 @@ AC_OUTPUT([
Makefile
glx/Makefile
include/Makefile
afb/Makefile
composite/Makefile
damageext/Makefile
dbe/Makefile

11
hw/xfree86/dixmods/Makefile.am
View File

@ -14,10 +14,6 @@ if DBE
DBEMOD = libdbe.la
endif
if AFB
AFBMOD = libafb.la
endif
if MFB
MFBMOD = libmfb.la
endif
@ -26,8 +22,7 @@ if RECORD
RECORDMOD = librecord.la
endif
module_LTLIBRARIES = $(AFBMOD) \
libfb.la \
module_LTLIBRARIES = libfb.la \
libwfb.la \
$(MFBMOD) \
libshadow.la
@ -48,10 +43,6 @@ INCLUDES = @XORG_INCS@ \
-I$(top_srcdir)/miext/shadow \
-I$(top_srcdir)/glx
libafb_la_LDFLAGS = -avoid-version
libafb_la_LIBADD = $(top_builddir)/afb/libafb.la
libafb_la_SOURCES = afbmodule.c
libdbe_la_LDFLAGS = -avoid-version
libdbe_la_LIBADD = $(top_builddir)/dbe/libdbe.la
libdbe_la_SOURCES = dbemodule.c

57
hw/xfree86/dixmods/afbmodule.c
View File

@ -1,57 +0,0 @@
/*
* Copyright (C) 1998 The XFree86 Project, Inc. All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* Except as contained in this notice, the name of the XFree86 Project shall
* not be used in advertising or otherwise to promote the sale, use or other
* dealings in this Software without prior written authorization from the
* XFree86 Project.
*/
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#include "xf86Module.h"
static MODULESETUPPROTO(afbSetup);
static XF86ModuleVersionInfo VersRec =
{
"afb",
MODULEVENDORSTRING,
MODINFOSTRING1,
MODINFOSTRING2,
XORG_VERSION_CURRENT,
1, 0, 0,
ABI_CLASS_ANSIC, /* Only need the ansic layer */
ABI_ANSIC_VERSION,
MOD_CLASS_NONE,
{0,0,0,0} /* signature, to be patched into the file by a tool */
};
_X_EXPORT XF86ModuleData afbModuleData = { &VersRec, afbSetup, NULL };
static pointer
afbSetup(pointer module, pointer opts, int *errmaj, int *errmin)
{
/* This modules requires mfb, so load it */
return LoadSubModule(module, "mfb", NULL, NULL, NULL, NULL,
errmaj, errmin);
}