frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

mi: ansify.

This commit is contained in:
Peter Hutterer 2008-05-28 12:27:07 +09:30
parent 64677f6a16
commit 9b544fa400
32 changed files with 345 additions and 628 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
mi/miarc.c
View File

@ -1042,11 +1042,7 @@ miFillWideEllipse(
*/
_X_EXPORT void
miPolyArc(pDraw, pGC, narcs, parcs)
DrawablePtr pDraw;
GCPtr pGC;
int narcs;
xArc *parcs;
miPolyArc(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc *parcs)
{
int i;
xArc *parc;

53
mi/mibitblt.c
View File

@ -74,14 +74,15 @@ extern int ffs(int);
* We let SetSpans worry about clipping to the destination.
*/
_X_EXPORT RegionPtr
miCopyArea(pSrcDrawable, pDstDrawable,
pGC, xIn, yIn, widthSrc, heightSrc, xOut, yOut)
DrawablePtr pSrcDrawable;
DrawablePtr pDstDrawable;
GCPtr pGC;
int xIn, yIn;
int widthSrc, heightSrc;
int xOut, yOut;
miCopyArea(DrawablePtr pSrcDrawable,
DrawablePtr pDstDrawable,
GCPtr pGC,
int xIn,
int yIn,
int widthSrc,
int heightSrc,
int xOut,
int yOut)
{
DDXPointPtr ppt, pptFirst;
unsigned int *pwidthFirst, *pwidth, *pbits;
@ -549,15 +550,16 @@ miOpqStipDrawable(DrawablePtr pDraw, GCPtr pGC, RegionPtr prgnSrc,
* Use the bitmap we've built up as a Stipple for the destination
*/
_X_EXPORT RegionPtr
miCopyPlane(pSrcDrawable, pDstDrawable,
pGC, srcx, srcy, width, height, dstx, dsty, bitPlane)
DrawablePtr pSrcDrawable;
DrawablePtr pDstDrawable;
GCPtr pGC;
int srcx, srcy;
int width, height;
int dstx, dsty;
unsigned long bitPlane;
miCopyPlane( DrawablePtr pSrcDrawable,
DrawablePtr pDstDrawable,
GCPtr pGC,
int srcx,
int srcy,
int width,
int height,
int dstx,
int dsty,
unsigned long bitPlane)
{
MiBits *ptile;
BoxRec box;
@ -643,12 +645,8 @@ miCopyPlane(pSrcDrawable, pDstDrawable,
* get the single plane specified in planemask
*/
_X_EXPORT void
miGetImage(pDraw, sx, sy, w, h, format, planeMask, pDst)
DrawablePtr pDraw;
int sx, sy, w, h;
unsigned int format;
unsigned long planeMask;
char * pDst;
miGetImage( DrawablePtr pDraw, int sx, int sy, int w, int h,
unsigned int format, unsigned long planeMask, char *pDst)
{
unsigned char depth;
int i, linelength, width, srcx, srcy;
@ -745,12 +743,9 @@ miGetImage(pDraw, sx, sy, w, h, format, planeMask, pDst)
* This part is simple, just call SetSpans
*/
_X_EXPORT void
miPutImage(pDraw, pGC, depth, x, y, w, h, leftPad, format, pImage)
DrawablePtr pDraw;
GCPtr pGC;
int depth, x, y, w, h, leftPad;
int format;
char *pImage;
miPutImage( DrawablePtr pDraw, GCPtr pGC, int depth,
int x, int y, int w, int h,
int leftPad, int format, char *pImage)
{
DDXPointPtr pptFirst, ppt;
int *pwidthFirst, *pwidth;

7
mi/micursor.c
View File

@ -57,11 +57,8 @@ SOFTWARE.
extern Bool Must_have_memory;
_X_EXPORT void
miRecolorCursor( pDev, pScr, pCurs, displayed)
DeviceIntPtr pDev;
ScreenPtr pScr;
CursorPtr pCurs;
Bool displayed;
miRecolorCursor(DeviceIntPtr pDev, ScreenPtr pScr,
CursorPtr pCurs, Bool displayed)
{
/*
* This is guaranteed to correct any color-dependent state which may have

13
mi/midash.c
View File

@ -53,12 +53,13 @@ SOFTWARE.
#include "mifpoly.h"
_X_EXPORT void
miStepDash (dist, pDashIndex, pDash, numInDashList, pDashOffset)
int dist; /* distance to step */
int *pDashIndex; /* current dash */
unsigned char *pDash; /* dash list */
int numInDashList; /* total length of dash list */
int *pDashOffset; /* offset into current dash */
miStepDash (
int dist, /* distance to step */
int *pDashIndex, /* current dash */
unsigned char *pDash, /* dash list */
int numInDashList, /* total length of dash list */
int *pDashOffset /* offset into current dash */
)
{
int dashIndex, dashOffset;
int totallen;

63
mi/midispcur.c
View File

@ -142,9 +142,7 @@ static miSpriteCursorFuncRec miDCFuncs = {
};
_X_EXPORT Bool
miDCInitialize (pScreen, screenFuncs)
ScreenPtr pScreen;
miPointerScreenFuncPtr screenFuncs;
miDCInitialize (ScreenPtr pScreen, miPointerScreenFuncPtr screenFuncs)
{
miDCScreenPtr pScreenPriv;
@ -171,9 +169,7 @@ miDCInitialize (pScreen, screenFuncs)
#define tossPict(pict) (pict ? FreePicture (pict, 0) : 0)
static Bool
miDCCloseScreen (index, pScreen)
int index;
ScreenPtr pScreen;
miDCCloseScreen (int index, ScreenPtr pScreen)
{
miDCScreenPtr pScreenPriv;
@ -185,9 +181,7 @@ miDCCloseScreen (index, pScreen)
}
static Bool
miDCRealizeCursor (pScreen, pCursor)
ScreenPtr pScreen;
CursorPtr pCursor;
miDCRealizeCursor (ScreenPtr pScreen, CursorPtr pCursor)
{
if (pCursor->bits->refcnt <= 1)
dixSetPrivate(&pCursor->bits->devPrivates, pScreen, NULL);
@ -235,9 +229,7 @@ miDCMakePicture (PicturePtr *ppPicture, DrawablePtr pDraw, WindowPtr pWin)
#endif
static miDCCursorPtr
miDCRealize (
ScreenPtr pScreen,
CursorPtr pCursor)
miDCRealize (ScreenPtr pScreen, CursorPtr pCursor)
{
miDCCursorPtr pPriv;
GCPtr pGC;
@ -349,9 +341,7 @@ miDCRealize (
}
static Bool
miDCUnrealizeCursor (pScreen, pCursor)
ScreenPtr pScreen;
CursorPtr pCursor;
miDCUnrealizeCursor (ScreenPtr pScreen, CursorPtr pCursor)
{
miDCCursorPtr pPriv;
@ -453,12 +443,8 @@ miDCMakeGC(
static Bool
miDCPutUpCursor (pDev, pScreen, pCursor, x, y, source, mask)
DeviceIntPtr pDev;
ScreenPtr pScreen;
CursorPtr pCursor;
int x, y;
unsigned long source, mask;
miDCPutUpCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor,
int x, int y, unsigned long source, unsigned long mask)
{
miDCScreenPtr pScreenPriv;
miDCCursorPtr pPriv;
@ -540,10 +526,8 @@ miDCPutUpCursor (pDev, pScreen, pCursor, x, y, source, mask)
}
static Bool
miDCSaveUnderCursor (pDev, pScreen, x, y, w, h)
DeviceIntPtr pDev;
ScreenPtr pScreen;
int x, y, w, h;
miDCSaveUnderCursor (DeviceIntPtr pDev, ScreenPtr pScreen,
int x, int y, int w, int h)
{
miDCScreenPtr pScreenPriv;
miDCBufferPtr pBuffer;
@ -583,10 +567,8 @@ miDCSaveUnderCursor (pDev, pScreen, x, y, w, h)
}
static Bool
miDCRestoreUnderCursor (pDev, pScreen, x, y, w, h)
DeviceIntPtr pDev;
ScreenPtr pScreen;
int x, y, w, h;
miDCRestoreUnderCursor (DeviceIntPtr pDev, ScreenPtr pScreen,
int x, int y, int w, int h)
{
miDCScreenPtr pScreenPriv;
miDCBufferPtr pBuffer;
@ -619,10 +601,8 @@ miDCRestoreUnderCursor (pDev, pScreen, x, y, w, h)
}
static Bool
miDCChangeSave (pDev, pScreen, x, y, w, h, dx, dy)
DeviceIntPtr pDev;
ScreenPtr pScreen;
int x, y, w, h, dx, dy;
miDCChangeSave (DeviceIntPtr pDev, ScreenPtr pScreen,
int x, int y, int w, int h, int dx, int dy)
{
miDCScreenPtr pScreenPriv;
miDCBufferPtr pBuffer;
@ -768,12 +748,9 @@ miDCChangeSave (pDev, pScreen, x, y, w, h, dx, dy)
}
static Bool
miDCMoveCursor (pDev, pScreen, pCursor, x, y, w, h, dx, dy, source, mask)
DeviceIntPtr pDev;
ScreenPtr pScreen;
CursorPtr pCursor;
int x, y, w, h, dx, dy;
unsigned long source, mask;
miDCMoveCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor,
int x, int y, int w, int h, int dx, int dy,
unsigned long source, unsigned long mask)
{
miDCCursorPtr pPriv;
miDCScreenPtr pScreenPriv;
@ -904,9 +881,7 @@ miDCMoveCursor (pDev, pScreen, pCursor, x, y, w, h, dx, dy, source, mask)
}
static Bool
miDCDeviceInitialize(pDev, pScreen)
DeviceIntPtr pDev;
ScreenPtr pScreen;
miDCDeviceInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
{
miDCBufferPtr pBuffer;
@ -930,9 +905,7 @@ miDCDeviceInitialize(pDev, pScreen)
}
static void
miDCDeviceCleanup(pDev, pScreen)
DeviceIntPtr pDev;
ScreenPtr pScreen;
miDCDeviceCleanup(DeviceIntPtr pDev, ScreenPtr pScreen)
{
miDCBufferPtr pBuffer;

33
mi/miexpose.c
View File

@ -128,15 +128,9 @@ exposing is done by the backing store's GraphicsExpose function, of course.
*/
_X_EXPORT RegionPtr
miHandleExposures(pSrcDrawable, pDstDrawable,
pGC, srcx, srcy, width, height, dstx, dsty, plane)
DrawablePtr pSrcDrawable;
DrawablePtr pDstDrawable;
GCPtr pGC;
int srcx, srcy;
int width, height;
int dstx, dsty;
unsigned long plane;
miHandleExposures(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
GCPtr pGC, int srcx, int srcy, int width, int height,
int dstx, int dsty, unsigned long plane)
{
ScreenPtr pscr;
RegionPtr prgnSrcClip; /* drawable-relative source clip */
@ -350,12 +344,8 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
/* send GraphicsExpose events, or a NoExpose event, based on the region */
_X_EXPORT void
miSendGraphicsExpose (client, pRgn, drawable, major, minor)
ClientPtr client;
RegionPtr pRgn;
XID drawable;
int major;
int minor;
miSendGraphicsExpose (ClientPtr client, RegionPtr pRgn, XID drawable,
int major, int minor)
{
if (pRgn && !REGION_NIL(pRgn))
{
@ -401,10 +391,7 @@ miSendGraphicsExpose (client, pRgn, drawable, major, minor)
void
miSendExposures(pWin, pRgn, dx, dy)
WindowPtr pWin;
RegionPtr pRgn;
int dx, dy;
miSendExposures( WindowPtr pWin, RegionPtr pRgn, int dx, int dy)
{
BoxPtr pBox;
int numRects;
@ -464,9 +451,7 @@ miSendExposures(pWin, pRgn, dx, dy)
}
_X_EXPORT void
miWindowExposures(pWin, prgn, other_exposed)
WindowPtr pWin;
RegionPtr prgn, other_exposed;
miWindowExposures( WindowPtr pWin, RegionPtr prgn, RegionPtr other_exposed)
{
RegionPtr exposures = prgn;
if ((prgn && !REGION_NIL(prgn)) ||
@ -654,9 +639,7 @@ miPaintWindow(WindowPtr pWin, RegionPtr prgn, int what)
* the GC. Useful when we have a scratch drawable and need to initialize
* it. */
_X_EXPORT void
miClearDrawable(pDraw, pGC)
DrawablePtr pDraw;
GCPtr pGC;
miClearDrawable(DrawablePtr pDraw, GCPtr pGC)
{
XID fg = pGC->fgPixel;
XID bg = pGC->bgPixel;

15
mi/mifillarc.c
View File

@ -53,9 +53,7 @@ Author: Bob Scheifler, MIT X Consortium
#define Dcos(d) cos((double)d*(M_PI/11520.0))
_X_EXPORT void
miFillArcSetup(arc, info)
xArc *arc;
miFillArcRec *info;
miFillArcSetup(xArc *arc, miFillArcRec *info)
{
info->y = arc->height >> 1;
info->dy = arc->height & 1;
@ -307,10 +305,7 @@ miGetPieEdge(
}
_X_EXPORT void
miFillArcSliceSetup(arc, slice, pGC)
xArc *arc;
miArcSliceRec *slice;
GCPtr pGC;
miFillArcSliceSetup(xArc *arc, miArcSliceRec *slice, GCPtr pGC)
{
int angle1, angle2;
@ -776,11 +771,7 @@ miFillArcSliceD(
* fill each arc as it comes.
*/
_X_EXPORT void
miPolyFillArc(pDraw, pGC, narcs, parcs)
DrawablePtr pDraw;
GCPtr pGC;
int narcs;
xArc *parcs;
miPolyFillArc(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc *parcs)
{
int i;
xArc *arc;

11
mi/mifillrct.c
View File

@ -67,11 +67,12 @@ SOFTWARE.
* clipping to the destination
*/
_X_EXPORT void
miPolyFillRect(pDrawable, pGC, nrectFill, prectInit)
DrawablePtr pDrawable;
GCPtr pGC;
int nrectFill; /* number of rectangles to fill */
xRectangle *prectInit; /* Pointer to first rectangle to fill */
miPolyFillRect(
DrawablePtr pDrawable,
GCPtr pGC,
int nrectFill, /* number of rectangles to fill */
xRectangle *prectInit /* Pointer to first rectangle to fill */
)
{
int i;
int height;

18
mi/mifpolycon.c
View File

@ -71,18 +71,20 @@ static int GetFPolyYBounds(SppPointPtr pts, int n, double yFtrans,
* interpolation involved because of the subpixel postioning.
*/
void
miFillSppPoly(dst, pgc, count, ptsIn, xTrans, yTrans, xFtrans, yFtrans)
DrawablePtr dst;
GCPtr pgc;
int count; /* number of points */
SppPointPtr ptsIn; /* the points */
int xTrans, yTrans; /* Translate each point by this */
double xFtrans, yFtrans; /* translate before conversion
by this amount. This provides
miFillSppPoly(
DrawablePtr dst,
GCPtr pgc,
int count, /* number of points */
SppPointPtr ptsIn, /* the points */
int xTrans, int yTrans, /* Translate each point by this */
double xFtrans,
double yFtrans /* translate before conversion
by this amount. This provides
a mechanism to match rounding
errors with any shape that must
meet the polygon exactly.
*/
)
{
double xl = 0.0, xr = 0.0, /* x vals of left and right edges */
ml = 0.0, /* left edge slope */

34
mi/migc.c
View File

@ -39,16 +39,13 @@ from The Open Group.
/* ARGSUSED */
_X_EXPORT void
miChangeGC(pGC, mask)
GCPtr pGC;
unsigned long mask;
miChangeGC(GCPtr pGC, unsigned long mask)
{
return;
}
_X_EXPORT void
miDestroyGC(pGC)
GCPtr pGC;
miDestroyGC(GCPtr pGC)
{
if (pGC->pRotatedPixmap)
(*pGC->pScreen->DestroyPixmap) (pGC->pRotatedPixmap);
@ -62,8 +59,7 @@ miDestroyGC(pGC)
*/
_X_EXPORT GCOpsPtr
miCreateGCOps(prototype)
GCOpsPtr prototype;
miCreateGCOps(GCOpsPtr prototype)
{
GCOpsPtr ret;
@ -78,8 +74,7 @@ miCreateGCOps(prototype)
}
_X_EXPORT void
miDestroyGCOps(ops)
GCOpsPtr ops;
miDestroyGCOps(GCOpsPtr ops)
{
if (ops->devPrivate.val)
xfree(ops);
@ -87,8 +82,7 @@ miDestroyGCOps(ops)
_X_EXPORT void
miDestroyClip(pGC)
GCPtr pGC;
miDestroyClip(GCPtr pGC)
{
if (pGC->clientClipType == CT_NONE)
return;
@ -109,11 +103,7 @@ miDestroyClip(pGC)
}
_X_EXPORT void
miChangeClip(pGC, type, pvalue, nrects)
GCPtr pGC;
int type;
pointer pvalue;
int nrects;
miChangeClip( GCPtr pGC, int type, pointer pvalue, int nrects)
{
(*pGC->funcs->DestroyClip) (pGC);
if (type == CT_PIXMAP)
@ -140,8 +130,7 @@ miChangeClip(pGC, type, pvalue, nrects)
}
_X_EXPORT void
miCopyClip(pgcDst, pgcSrc)
GCPtr pgcDst, pgcSrc;
miCopyClip(GCPtr pgcDst, GCPtr pgcSrc)
{
RegionPtr prgnNew;
@ -165,18 +154,13 @@ miCopyClip(pgcDst, pgcSrc)
/* ARGSUSED */
_X_EXPORT void
miCopyGC(pGCSrc, changes, pGCDst)
GCPtr pGCSrc;
unsigned long changes;
GCPtr pGCDst;
miCopyGC(GCPtr pGCSrc, unsigned long changes, GCPtr pGCDst)
{
return;
}
_X_EXPORT void
miComputeCompositeClip(pGC, pDrawable)
GCPtr pGC;
DrawablePtr pDrawable;
miComputeCompositeClip( GCPtr pGC, DrawablePtr pDrawable)
{
ScreenPtr pScreen;

32
mi/miglblt.c
View File

@ -82,13 +82,15 @@ with the sample server.
*/
_X_EXPORT void
miPolyGlyphBlt(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 */
miPolyGlyphBlt(
DrawablePtr pDrawable,
GC *pGC,
int x,
int y,
unsigned int nglyph,
CharInfoPtr *ppci, /* array of character info */
pointer pglyphBase /* start of array of glyphs */
)
{
int width, height;
PixmapPtr pPixmap;
@ -196,13 +198,15 @@ miPolyGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
_X_EXPORT void
miImageGlyphBlt(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 */
miImageGlyphBlt(
DrawablePtr pDrawable,
GC *pGC,
int x,
int y,
unsigned int nglyph,
CharInfoPtr *ppci, /* array of character info */
pointer pglyphBase /* start of array of glyphs */
)
{
ExtentInfoRec info; /* used by QueryGlyphExtents() */
XID gcvals[3];

8
mi/miinitext.c
View File

@ -454,9 +454,7 @@ void EnableDisableExtensionError(char *name, Bool enable)
/*ARGSUSED*/
void
InitExtensions(argc, argv)
int argc;
char *argv[];
InitExtensions(int argc, char *argv[])
{
if (!noGEExtension) GEExtensionInit();
@ -633,9 +631,7 @@ static ExtensionModule staticExtensions[] = {
/*ARGSUSED*/
void
InitExtensions(argc, argv)
int argc;
char *argv[];
InitExtensions(int argc, char *argv[])
{
int i;
ExtensionModule *ext;

82
mi/mipointer.c
View File

@ -81,11 +81,10 @@ static void miPointerDeviceCleanup(DeviceIntPtr pDev,
static EventList* events; /* for WarpPointer MotionNotifies */
_X_EXPORT Bool
miPointerInitialize (pScreen, spriteFuncs, screenFuncs, waitForUpdate)
ScreenPtr pScreen;
miPointerSpriteFuncPtr spriteFuncs;
miPointerScreenFuncPtr screenFuncs;
Bool waitForUpdate;
miPointerInitialize (ScreenPtr pScreen,
miPointerSpriteFuncPtr spriteFuncs,
miPointerScreenFuncPtr screenFuncs,
Bool waitForUpdate)
{
miPointerScreenPtr pScreenPriv;
@ -125,9 +124,7 @@ miPointerInitialize (pScreen, spriteFuncs, screenFuncs, waitForUpdate)
}
static Bool
miPointerCloseScreen (index, pScreen)
int index;
ScreenPtr pScreen;
miPointerCloseScreen (int index, ScreenPtr pScreen)
{
miPointerPtr pPointer;
DeviceIntPtr pDev;
@ -166,33 +163,26 @@ miPointerCloseScreen (index, pScreen)
*/
static Bool
miPointerRealizeCursor (pDev, pScreen, pCursor)
DeviceIntPtr pDev;
ScreenPtr pScreen;
CursorPtr pCursor;
miPointerRealizeCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
{
SetupScreen(pScreen);
return (*pScreenPriv->spriteFuncs->RealizeCursor) (pDev, pScreen, pCursor);
}
static Bool
miPointerUnrealizeCursor (pDev, pScreen, pCursor)
DeviceIntPtr pDev;
ScreenPtr pScreen;
CursorPtr pCursor;
miPointerUnrealizeCursor (DeviceIntPtr pDev,
ScreenPtr pScreen,
CursorPtr pCursor)
{
SetupScreen(pScreen);
return (*pScreenPriv->spriteFuncs->UnrealizeCursor) (pDev, pScreen, pCursor);
}
static Bool
miPointerDisplayCursor (pDev, pScreen, pCursor)
DeviceIntPtr pDev;
ScreenPtr pScreen;
CursorPtr pCursor;
miPointerDisplayCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
{
miPointerPtr pPointer;
/* return for keyboards */
if ((pDev->isMaster && !DevHasCursor(pDev)) ||
(!pDev->isMaster && pDev->u.master && !DevHasCursor(pDev->u.master)))
@ -207,10 +197,7 @@ miPointerDisplayCursor (pDev, pScreen, pCursor)
}
static void
miPointerConstrainCursor (pDev, pScreen, pBox)
DeviceIntPtr pDev;
ScreenPtr pScreen;
BoxPtr pBox;
miPointerConstrainCursor (DeviceIntPtr pDev, ScreenPtr pScreen, BoxPtr pBox)
{
miPointerPtr pPointer;
@ -222,22 +209,17 @@ miPointerConstrainCursor (pDev, pScreen, pBox)
/*ARGSUSED*/
static void
miPointerPointerNonInterestBox (pDev, pScreen, pBox)
DeviceIntPtr pDev;
ScreenPtr pScreen;
BoxPtr pBox;
miPointerPointerNonInterestBox (DeviceIntPtr pDev,
ScreenPtr pScreen,
BoxPtr pBox)
{
/* until DIX uses this, this will remain a stub */
}
/*ARGSUSED*/
static void
miPointerCursorLimits(pDev, pScreen, pCursor, pHotBox, pTopLeftBox)
DeviceIntPtr pDev;
ScreenPtr pScreen;
CursorPtr pCursor;
BoxPtr pHotBox;
BoxPtr pTopLeftBox;
miPointerCursorLimits(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor,
BoxPtr pHotBox, BoxPtr pTopLeftBox)
{
*pTopLeftBox = *pHotBox;
}
@ -245,11 +227,8 @@ miPointerCursorLimits(pDev, pScreen, pCursor, pHotBox, pTopLeftBox)
static Bool GenerateEvent;
static Bool
miPointerSetCursorPosition(pDev, pScreen, x, y, generateEvent)
DeviceIntPtr pDev;
ScreenPtr pScreen;
int x, y;
Bool generateEvent;
miPointerSetCursorPosition(DeviceIntPtr pDev, ScreenPtr pScreen,
int x, int y, Bool generateEvent)
{
SetupScreen (pScreen);
@ -261,14 +240,12 @@ miPointerSetCursorPosition(pDev, pScreen, x, y, generateEvent)
return TRUE;
}
/* Set up sprite information for the device.
/* Set up sprite information for the device.
This function will be called once for each device after it is initialized
in the DIX.
*/
*/
static Bool
miPointerDeviceInitialize(pDev, pScreen)
DeviceIntPtr pDev;
ScreenPtr pScreen;
miPointerDeviceInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
{
miPointerPtr pPointer;
SetupScreen (pScreen);
@ -299,13 +276,11 @@ miPointerDeviceInitialize(pDev, pScreen)
return TRUE;
}
/* Clean up after device.
/* Clean up after device.
This function will be called once before the device is freed in the DIX
*/
static void
miPointerDeviceCleanup(pDev, pScreen)
DeviceIntPtr pDev;
ScreenPtr pScreen;
miPointerDeviceCleanup(DeviceIntPtr pDev, ScreenPtr pScreen)
{
if (!pDev->isMaster && pDev->u.master)
return;
@ -320,10 +295,7 @@ miPointerDeviceCleanup(pDev, pScreen)
/* Once signals are ignored, the WarpCursor function can call this */
_X_EXPORT void
miPointerWarpCursor (pDev, pScreen, x, y)
DeviceIntPtr pDev;
ScreenPtr pScreen;
int x, y;
miPointerWarpCursor (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
{
miPointerPtr pPointer;
BOOL changedScreen = FALSE;
@ -506,8 +478,8 @@ miPointerAbsoluteCursor (int x, int y, unsigned long time)
/* Move the pointer on the current screen, and update the sprite. */
static void
miPointerMoved (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y,
unsigned long time)
miPointerMoved (DeviceIntPtr pDev, ScreenPtr pScreen,
int x, int y, unsigned long time)
{
miPointerPtr pPointer;
SetupScreen(pScreen);

9
mi/mipoly.c
View File

@ -67,12 +67,9 @@ SOFTWARE.
_X_EXPORT void
miFillPolygon(dst, pgc, shape, mode, count, pPts)
DrawablePtr dst;
GCPtr pgc;
int shape, mode;
int count;
DDXPointPtr pPts;
miFillPolygon( DrawablePtr dst, GCPtr pgc,
int shape, int mode,
int count, DDXPointPtr pPts)
{
int i;
int xorg, yorg;

11
mi/mipolycon.c
View File

@ -72,11 +72,12 @@ static int getPolyYBounds(DDXPointPtr pts, int n, int *by, int *ty);
* this code.
*/
_X_EXPORT Bool
miFillConvexPoly(dst, pgc, count, ptsIn)
DrawablePtr dst;
GCPtr pgc;
int count; /* number of points */
DDXPointPtr ptsIn; /* the points */
miFillConvexPoly(
DrawablePtr dst,
GCPtr pgc,
int count, /* number of points */
DDXPointPtr ptsIn /* the points */
)
{
int xl = 0, xr = 0; /* x vals of left and right edges */
int dl = 0, dr = 0; /* decision variables */

11
mi/mipolygen.c
View File

@ -66,11 +66,12 @@ SOFTWARE.
*/
Bool
miFillGeneralPoly(dst, pgc, count, ptsIn)
DrawablePtr dst;
GCPtr pgc;
int count; /* number of points */
DDXPointPtr ptsIn; /* the points */
miFillGeneralPoly(
DrawablePtr dst,
GCPtr pgc,
int count, /* number of points */
DDXPointPtr ptsIn /* the points */
)
{
EdgeTableEntry *pAET; /* the Active Edge Table */
int y; /* the current scanline */

13
mi/mipolypnt.c
View File

@ -56,12 +56,13 @@ SOFTWARE.
#include "mi.h"
_X_EXPORT void
miPolyPoint(pDrawable, pGC, mode, npt, pptInit)
DrawablePtr pDrawable;
GCPtr pGC;
int mode; /* Origin or Previous */
int npt;
xPoint *pptInit;
miPolyPoint(
DrawablePtr pDrawable,
GCPtr pGC,
int mode, /* Origin or Previous */
int npt,
xPoint *pptInit
)
{
int xorg;

6
mi/mipolyrect.c
View File

@ -56,11 +56,7 @@ SOFTWARE.
#include "mi.h"
_X_EXPORT void
miPolyRectangle(pDraw, pGC, nrects, pRects)
DrawablePtr pDraw;
GCPtr pGC;
int nrects;
xRectangle *pRects;
miPolyRectangle(DrawablePtr pDraw, GCPtr pGC, int nrects, xRectangle *pRects)
{
int i;
xRectangle *pR = pRects;

6
mi/mipolyseg.c
View File

@ -67,11 +67,7 @@ SOFTWARE.
_X_EXPORT void
miPolySegment(pDraw, pGC, nseg, pSegs)
DrawablePtr pDraw;
GCPtr pGC;
int nseg;
xSegment *pSegs;
miPolySegment(DrawablePtr pDraw, GCPtr pGC, int nseg, xSegment *pSegs)
{
int i;

29
mi/mipolytext.c
View File

@ -67,12 +67,7 @@ SOFTWARE.
#include "mi.h"
_X_EXPORT int
miPolyText8(pDraw, pGC, x, y, count, chars)
DrawablePtr pDraw;
GCPtr pGC;
int x, y;
int count;
char *chars;
miPolyText8(DrawablePtr pDraw, GCPtr pGC, int x, int y, int count, char *chars)
{
unsigned long n, i;
int w;
@ -89,12 +84,7 @@ miPolyText8(pDraw, pGC, x, y, count, chars)
}
_X_EXPORT int
miPolyText16(pDraw, pGC, x, y, count, chars)
DrawablePtr pDraw;
GCPtr pGC;
int x, y;
int count;
unsigned short *chars;
miPolyText16(DrawablePtr pDraw, GCPtr pGC, int x, int y, int count, unsigned short *chars)
{
unsigned long n, i;
int w;
@ -112,12 +102,7 @@ miPolyText16(pDraw, pGC, x, y, count, chars)
}
_X_EXPORT void
miImageText8(pDraw, pGC, x, y, count, chars)
DrawablePtr pDraw;
GCPtr pGC;
int x, y;
int count;
char *chars;
miImageText8(DrawablePtr pDraw, GCPtr pGC, int x, int y, int count, char *chars)
{
unsigned long n;
FontPtr font = pGC->font;
@ -130,12 +115,8 @@ miImageText8(pDraw, pGC, x, y, count, chars)
}
_X_EXPORT void
miImageText16(pDraw, pGC, x, y, count, chars)
DrawablePtr pDraw;
GCPtr pGC;
int x, y;
int count;
unsigned short *chars;
miImageText16(DrawablePtr pDraw, GCPtr pGC, int x, int y,
int count, unsigned short *chars)
{
unsigned long n;
FontPtr font = pGC->font;

21
mi/mipolyutil.c
View File

@ -161,13 +161,8 @@ miInsertEdgeInET(EdgeTable *ET, EdgeTableEntry *ETE, int scanline,
*/
Bool
miCreateETandAET(count, pts, ET, AET, pETEs, pSLLBlock)
int count;
DDXPointPtr pts;
EdgeTable *ET;
EdgeTableEntry *AET;
EdgeTableEntry *pETEs;
ScanLineListBlock *pSLLBlock;
miCreateETandAET(int count, DDXPointPtr pts, EdgeTable *ET, EdgeTableEntry *AET,
EdgeTableEntry *pETEs, ScanLineListBlock *pSLLBlock)
{
DDXPointPtr top, bottom;
DDXPointPtr PrevPt, CurrPt;
@ -257,8 +252,7 @@ miCreateETandAET(count, pts, ET, AET, pETEs, pSLLBlock)
*/
void
miloadAET(AET, ETEs)
EdgeTableEntry *AET, *ETEs;
miloadAET(EdgeTableEntry *AET, EdgeTableEntry *ETEs)
{
EdgeTableEntry *pPrevAET;
EdgeTableEntry *tmp;
@ -305,8 +299,7 @@ miloadAET(AET, ETEs)
*
*/
void
micomputeWAET(AET)
EdgeTableEntry *AET;
micomputeWAET(EdgeTableEntry *AET)
{
EdgeTableEntry *pWETE;
int inside = 1;
@ -344,8 +337,7 @@ micomputeWAET(AET)
*/
int
miInsertionSort(AET)
EdgeTableEntry *AET;
miInsertionSort(EdgeTableEntry *AET)
{
EdgeTableEntry *pETEchase;
EdgeTableEntry *pETEinsert;
@ -381,8 +373,7 @@ miInsertionSort(AET)
* Clean up our act.
*/
void
miFreeStorage(pSLLBlock)
ScanLineListBlock *pSLLBlock;
miFreeStorage(ScanLineListBlock *pSLLBlock)
{
ScanLineListBlock *tmpSLLBlock;

7
mi/mipushpxl.c
View File

@ -93,11 +93,8 @@ bitsizeof(int) padding and sacnline unit == bitsizeof(int).)
* in the server, we need to rename one of them
*/
_X_EXPORT void
miPushPixels(pGC, pBitMap, pDrawable, dx, dy, xOrg, yOrg)
GCPtr pGC;
PixmapPtr pBitMap;
DrawablePtr pDrawable;
int dx, dy, xOrg, yOrg;
miPushPixels(GCPtr pGC, PixmapPtr pBitMap, DrawablePtr pDrawable,
int dx, int dy, int xOrg, int yOrg)
{
int h, dxDivPPW, ibEnd;
MiBits *pwLineStart;

118
mi/miregion.c
View File

@ -237,9 +237,7 @@ InitRegions (void)
*****************************************************************/
_X_EXPORT RegionPtr
miRegionCreate(rect, size)
BoxPtr rect;
int size;
miRegionCreate(BoxPtr rect, int size)
{
RegionPtr pReg;
@ -253,8 +251,7 @@ miRegionCreate(rect, size)
}
_X_EXPORT void
miRegionDestroy(pReg)
RegionPtr pReg;
miRegionDestroy(RegionPtr pReg)
{
pixman_region_fini (pReg);
if (pReg != &miBrokenRegion)
@ -262,8 +259,7 @@ miRegionDestroy(pReg)
}
_X_EXPORT void
miPrintRegion(rgn)
RegionPtr rgn;
miPrintRegion(RegionPtr rgn)
{
int num, size;
int i;
@ -282,17 +278,14 @@ miPrintRegion(rgn)
}
_X_EXPORT Bool
miRegionEqual(reg1, reg2)
RegionPtr reg1;
RegionPtr reg2;
miRegionEqual(RegionPtr reg1, RegionPtr reg2)
{
return pixman_region_equal (reg1, reg2);
}
#ifdef DEBUG
Bool
miValidRegion(reg)
RegionPtr reg;
miValidRegion(RegionPtr reg)
{
int i, numRects;
@ -343,10 +336,7 @@ miValidRegion(reg)
*****************************************************************/
_X_EXPORT void
miRegionInit(pReg, rect, size)
RegionPtr pReg;
BoxPtr rect;
int size;
miRegionInit(RegionPtr pReg, BoxPtr rect, int size)
{
if (rect)
pixman_region_init_with_extents (pReg, rect);
@ -355,15 +345,13 @@ miRegionInit(pReg, rect, size)
}
_X_EXPORT void
miRegionUninit(pReg)
RegionPtr pReg;
miRegionUninit(RegionPtr pReg)
{
pixman_region_fini (pReg);
}
Bool
miRegionBreak (pReg)
RegionPtr pReg;
miRegionBreak (RegionPtr pReg)
{
xfreeData (pReg);
pReg->extents = miEmptyBox;
@ -372,9 +360,7 @@ miRegionBreak (pReg)
}
_X_EXPORT Bool
miRectAlloc(
RegionPtr pRgn,
int n)
miRectAlloc(RegionPtr pRgn, int n)
{
RegDataPtr data;
@ -413,9 +399,7 @@ miRectAlloc(
}
_X_EXPORT Bool
miRegionCopy(dst, src)
RegionPtr dst;
RegionPtr src;
miRegionCopy(RegionPtr dst, RegionPtr src)
{
return pixman_region_copy (dst, src);
}
@ -908,10 +892,11 @@ miSetExtents (RegionPtr pReg)
*/
/*ARGSUSED*/
_X_EXPORT Bool
miIntersect(newReg, reg1, reg2)
RegionPtr newReg; /* destination Region */
RegionPtr reg1;
RegionPtr reg2; /* source regions */
miIntersect(
RegionPtr newReg, /* destination Region */
RegionPtr reg1,
RegionPtr reg2 /* source regions */
)
{
return pixman_region_intersect (newReg, reg1, reg2);
}
@ -1010,11 +995,12 @@ miUnionO (
return TRUE;
}
_X_EXPORT Bool
miUnion(newReg, reg1, reg2)
RegionPtr newReg; /* destination Region */
RegionPtr reg1;
RegionPtr reg2; /* source regions */
_X_EXPORT Bool
miUnion(
RegionPtr newReg, /* destination Region */
RegionPtr reg1,
RegionPtr reg2 /* source regions */
)
{
return pixman_region_union (newReg, reg1, reg2);
}
@ -1041,9 +1027,7 @@ miUnion(newReg, reg1, reg2)
*
*/
_X_EXPORT Bool
miRegionAppend(dstrgn, rgn)
RegionPtr dstrgn;
RegionPtr rgn;
miRegionAppend(RegionPtr dstrgn, RegionPtr rgn)
{
int numRects, dnumRects, size;
BoxPtr new, old;
@ -1227,9 +1211,7 @@ QuickSortRects(
*/
_X_EXPORT Bool
miRegionValidate(badreg, pOverlap)
RegionPtr badreg;
Bool *pOverlap;
miRegionValidate(RegionPtr badreg, Bool *pOverlap)
{
/* Descriptor for regions under construction in Step 2. */
typedef struct {
@ -1418,10 +1400,7 @@ bail:
}
_X_EXPORT RegionPtr
miRectsToRegion(nrects, prect, ctype)
int nrects;
xRectangle *prect;
int ctype;
miRectsToRegion(int nrects, xRectangle *prect, int ctype)
{
RegionPtr pRgn;
@ -1535,10 +1514,7 @@ miRectsToRegion(nrects, prect, ctype)
*-----------------------------------------------------------------------
*/
_X_EXPORT Bool
miSubtract(regD, regM, regS)
RegionPtr regD;
RegionPtr regM;
RegionPtr regS;
miSubtract(RegionPtr regD, RegionPtr regM, RegionPtr regS)
{
return pixman_region_subtract (regD, regM, regS);
}
@ -1563,17 +1539,16 @@ miSubtract(regD, regM, regS)
*-----------------------------------------------------------------------
*/
_X_EXPORT Bool
miInverse(newReg, reg1, invRect)
RegionPtr newReg; /* Destination region */
RegionPtr reg1; /* Region to invert */
BoxPtr invRect; /* Bounding box for inversion */
miInverse(
RegionPtr newReg, /* Destination region */
RegionPtr reg1, /* Region to invert */
BoxPtr invRect /* Bounding box for inversion */
)
{
return pixman_region_inverse (newReg, reg1, invRect);
}
_X_EXPORT int
miRectIn(region, prect)
RegionPtr region;
BoxPtr prect;
miRectIn(RegionPtr region, BoxPtr prect)
{
return pixman_region_contains_rectangle (region, prect);
}
@ -1583,34 +1558,30 @@ miRectIn(region, prect)
*/
_X_EXPORT void
miTranslateRegion(pReg, x, y)
RegionPtr pReg;
int x;
int y;
miTranslateRegion(RegionPtr pReg, int x, int y)
{
pixman_region_translate (pReg, x, y);
}
_X_EXPORT void
miRegionReset(pReg, pBox)
RegionPtr pReg;
BoxPtr pBox;
miRegionReset(RegionPtr pReg, BoxPtr pBox)
{
pixman_region_reset (pReg, pBox);
}
_X_EXPORT Bool
miPointInRegion(pReg, x, y, box)
RegionPtr pReg;
int x, y;
BoxPtr box; /* "return" value */
miPointInRegion(
RegionPtr pReg,
int x,
int y,
BoxPtr box /* "return" value */
)
{
return pixman_region_contains_point (pReg, x, y, box);
}
_X_EXPORT Bool
miRegionNotEmpty(pReg)
RegionPtr pReg;
miRegionNotEmpty(RegionPtr pReg)
{
return pixman_region_not_empty (pReg);
}
@ -1623,8 +1594,7 @@ miRegionBroken(RegionPtr pReg)
}
_X_EXPORT void
miRegionEmpty(pReg)
RegionPtr pReg;
miRegionEmpty(RegionPtr pReg)
{
good(pReg);
xfreeData(pReg);
@ -1634,8 +1604,7 @@ miRegionEmpty(pReg)
}
_X_EXPORT BoxPtr
miRegionExtents(pReg)
RegionPtr pReg;
miRegionExtents(RegionPtr pReg)
{
good(pReg);
return(&pReg->extents);
@ -1877,8 +1846,7 @@ miClipSpans(
/* find the band in a region with the most rectangles */
_X_EXPORT int
miFindMaxBand(prgn)
RegionPtr prgn;
miFindMaxBand(RegionPtr prgn)
{
int nbox;
BoxPtr pbox;

55
mi/miscrinit.c
View File

@ -61,15 +61,8 @@ typedef struct
/* this plugs into pScreen->ModifyPixmapHeader */
_X_EXPORT Bool
miModifyPixmapHeader(pPixmap, width, height, depth, bitsPerPixel, devKind,
pPixData)
PixmapPtr pPixmap;
int width;
int height;
int depth;
int bitsPerPixel;
int devKind;
pointer pPixData;
miModifyPixmapHeader(PixmapPtr pPixmap, int width, int height, int depth,
int bitsPerPixel, int devKind, pointer pPixData)
{
if (!pPixmap)
return FALSE;
@ -140,8 +133,7 @@ miCloseScreen (int iScreen, ScreenPtr pScreen)
* screen pixmap here.
*/
_X_EXPORT Bool
miCreateScreenResources(pScreen)
ScreenPtr pScreen;
miCreateScreenResources(ScreenPtr pScreen)
{
miScreenInitParmsPtr pScrInitParms;
pointer value;
@ -180,10 +172,7 @@ miCreateScreenResources(pScreen)
}
Bool
miScreenDevPrivateInit(pScreen, width, pbits)
ScreenPtr pScreen;
int width;
pointer pbits;
miScreenDevPrivateInit(ScreenPtr pScreen, int width, pointer pbits)
{
miScreenInitParmsPtr pScrInitParms;
@ -201,19 +190,19 @@ miScreenDevPrivateInit(pScreen, width, pbits)
}
_X_EXPORT Bool
miScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width,
rootDepth, numDepths, depths, rootVisual, numVisuals, visuals)
ScreenPtr pScreen;
pointer pbits; /* pointer to screen bits */
int xsize, ysize; /* in pixels */
int dpix, dpiy; /* dots per inch */
int width; /* pixel width of frame buffer */
int rootDepth; /* depth of root window */
int numDepths; /* number of depths supported */
DepthRec *depths; /* supported depths */
VisualID rootVisual; /* root visual */
int numVisuals; /* number of visuals supported */
VisualRec *visuals; /* supported visuals */
miScreenInit(
ScreenPtr pScreen,
pointer pbits, /* pointer to screen bits */
int xsize, int ysize, /* in pixels */
int dpix, int dpiy, /* dots per inch */
int width, /* pixel width of frame buffer */
int rootDepth, /* depth of root window */
int numDepths, /* number of depths supported */
DepthRec *depths, /* supported depths */
VisualID rootVisual, /* root visual */
int numVisuals, /* number of visuals supported */
VisualRec *visuals /* supported visuals */
)
{
pScreen->width = xsize;
pScreen->height = ysize;
@ -304,23 +293,19 @@ miAllocateGCPrivateIndex()
_X_EXPORT DevPrivateKey miZeroLineScreenKey = &miZeroLineScreenKey;
_X_EXPORT void
miSetZeroLineBias(pScreen, bias)
ScreenPtr pScreen;
unsigned int bias;
miSetZeroLineBias(ScreenPtr pScreen, unsigned int bias)
{
dixSetPrivate(&pScreen->devPrivates, miZeroLineScreenKey, (pointer)bias);
}
_X_EXPORT PixmapPtr
miGetScreenPixmap(pScreen)
ScreenPtr pScreen;
miGetScreenPixmap(ScreenPtr pScreen)
{
return (PixmapPtr)(pScreen->devPrivate);
}
_X_EXPORT void
miSetScreenPixmap(pPix)
PixmapPtr pPix;
miSetScreenPixmap(PixmapPtr pPix)
{
if (pPix)
pPix->drawable.pScreen->devPrivate = (pointer)pPix;

15
mi/mispans.c
View File

@ -180,11 +180,8 @@ static void miSubtractSpans (SpanGroup *spanGroup, Spans *sub)
}
}
}
void miAppendSpans(spanGroup, otherGroup, spans)
SpanGroup *spanGroup;
SpanGroup *otherGroup;
Spans *spans;
void miAppendSpans(SpanGroup *spanGroup, SpanGroup *otherGroup, Spans *spans)
{
int ymin, ymax;
int spansCount;
@ -217,8 +214,7 @@ void miAppendSpans(spanGroup, otherGroup, spans)
}
} /* AppendSpans */
void miFreeSpanGroup(spanGroup)
SpanGroup *spanGroup;
void miFreeSpanGroup(SpanGroup *spanGroup)
{
if (spanGroup->group != NULL) xfree(spanGroup->group);
}
@ -376,10 +372,7 @@ miDisposeSpanGroup (SpanGroup *spanGroup)
}
}
void miFillUniqueSpanGroup(pDraw, pGC, spanGroup)
DrawablePtr pDraw;
GCPtr pGC;
SpanGroup *spanGroup;
void miFillUniqueSpanGroup(DrawablePtr pDraw, GCPtr pGC, SpanGroup *spanGroup)
{
int i;
Spans *spans;

98
mi/misprite.c
View File

@ -182,10 +182,9 @@ miSpriteReportDamage (DamagePtr pDamage, RegionPtr pRegion, void *closure)
*/
Bool
miSpriteInitialize (pScreen, cursorFuncs, screenFuncs)
ScreenPtr pScreen;
miSpriteCursorFuncPtr cursorFuncs;
miPointerScreenFuncPtr screenFuncs;
miSpriteInitialize (ScreenPtr pScreen,
miSpriteCursorFuncPtr cursorFuncs,
miPointerScreenFuncPtr screenFuncs)
{
miSpriteScreenPtr pScreenPriv;
VisualPtr pVisual;
@ -266,9 +265,7 @@ miSpriteInitialize (pScreen, cursorFuncs, screenFuncs)
*/
static Bool
miSpriteCloseScreen (i, pScreen)
int i;
ScreenPtr pScreen;
miSpriteCloseScreen (int i, ScreenPtr pScreen)
{
miSpriteScreenPtr pScreenPriv;
DeviceIntPtr pDev;
@ -291,12 +288,9 @@ miSpriteCloseScreen (i, pScreen)
}
static void
miSpriteGetImage (pDrawable, sx, sy, w, h, format, planemask, pdstLine)
DrawablePtr pDrawable;
int sx, sy, w, h;
unsigned int format;
unsigned long planemask;
char *pdstLine;
miSpriteGetImage (DrawablePtr pDrawable, int sx, int sy, int w, int h,
unsigned int format, unsigned long planemask,
char *pdstLine)
{
ScreenPtr pScreen = pDrawable->pScreen;
miSpriteScreenPtr pScreenPriv;
@ -331,13 +325,8 @@ miSpriteGetImage (pDrawable, sx, sy, w, h, format, planemask, pdstLine)
}
static void
miSpriteGetSpans (pDrawable, wMax, ppt, pwidth, nspans, pdstStart)
DrawablePtr pDrawable;
int wMax;
DDXPointPtr ppt;
int *pwidth;
int nspans;
char *pdstStart;
miSpriteGetSpans (DrawablePtr pDrawable, int wMax, DDXPointPtr ppt,
int *pwidth, int nspans, char *pdstStart)
{
ScreenPtr pScreen = pDrawable->pScreen;
miSpriteScreenPtr pScreenPriv;
@ -390,9 +379,8 @@ miSpriteGetSpans (pDrawable, wMax, ppt, pwidth, nspans, pdstStart)
}
static void
miSpriteSourceValidate (pDrawable, x, y, width, height)
DrawablePtr pDrawable;
int x, y, width, height;
miSpriteSourceValidate (DrawablePtr pDrawable, int x, int y, int width,
int height)
{
ScreenPtr pScreen = pDrawable->pScreen;
miSpriteScreenPtr pScreenPriv;
@ -461,11 +449,8 @@ miSpriteCopyWindow (WindowPtr pWindow, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
}
static void
miSpriteBlockHandler (i, blockData, pTimeout, pReadmask)
int i;
pointer blockData;
pointer pTimeout;
pointer pReadmask;
miSpriteBlockHandler (int i, pointer blockData, pointer pTimeout,
pointer pReadmask)
{
ScreenPtr pScreen = screenInfo.screens[i];
miSpriteScreenPtr pPriv;
@ -511,8 +496,7 @@ miSpriteBlockHandler (i, blockData, pTimeout, pReadmask)
}
static void
miSpriteInstallColormap (pMap)
ColormapPtr pMap;
miSpriteInstallColormap (ColormapPtr pMap)
{
ScreenPtr pScreen = pMap->pScreen;
miSpriteScreenPtr pPriv;
@ -546,10 +530,7 @@ miSpriteInstallColormap (pMap)
}
static void
miSpriteStoreColors (pMap, ndef, pdef)
ColormapPtr pMap;
int ndef;
xColorItem *pdef;
miSpriteStoreColors (ColormapPtr pMap, int ndef, xColorItem *pdef)
{
ScreenPtr pScreen = pMap->pScreen;
miSpriteScreenPtr pPriv;
@ -676,10 +657,7 @@ miSpriteFindColors (miCursorInfoPtr pDevCursor, ScreenPtr pScreen)
#define SPRITE_PAD 8
static Bool
miSpriteRealizeCursor (pDev, pScreen, pCursor)
DeviceIntPtr pDev;
ScreenPtr pScreen;
CursorPtr pCursor;
miSpriteRealizeCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
{
miSpriteScreenPtr pScreenPriv;
miCursorInfoPtr pCursorInfo;
@ -700,10 +678,7 @@ miSpriteRealizeCursor (pDev, pScreen, pCursor)
}
static Bool
miSpriteUnrealizeCursor (pDev, pScreen, pCursor)
DeviceIntPtr pDev;
ScreenPtr pScreen;
CursorPtr pCursor;
miSpriteUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
{
miSpriteScreenPtr pScreenPriv;
@ -713,12 +688,8 @@ miSpriteUnrealizeCursor (pDev, pScreen, pCursor)
}
static void
miSpriteSetCursor (pDev, pScreen, pCursor, x, y)
DeviceIntPtr pDev;
ScreenPtr pScreen;
CursorPtr pCursor;
int x;
int y;
miSpriteSetCursor (DeviceIntPtr pDev, ScreenPtr pScreen,
CursorPtr pCursor, int x, int y)
{
miSpriteScreenPtr pScreenPriv;
@ -837,10 +808,7 @@ miSpriteSetCursor (pDev, pScreen, pCursor, x, y)
}
static void
miSpriteMoveCursor (pDev, pScreen, x, y)
DeviceIntPtr pDev;
ScreenPtr pScreen;
int x, y;
miSpriteMoveCursor (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
{
miSpriteScreenPtr pScreenPriv;
CursorPtr pCursor;
@ -859,9 +827,7 @@ miSpriteMoveCursor (pDev, pScreen, x, y)
static Bool
miSpriteDeviceCursorInitialize(pDev, pScreen)
DeviceIntPtr pDev;
ScreenPtr pScreen;
miSpriteDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
{
miSpriteScreenPtr pScreenPriv;
miCursorInfoPtr pCursorInfo;
@ -895,9 +861,7 @@ miSpriteDeviceCursorInitialize(pDev, pScreen)
}
static void
miSpriteDeviceCursorCleanup(pDev, pScreen)
DeviceIntPtr pDev;
ScreenPtr pScreen;
miSpriteDeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScreen)
{
if (DevHasCursor(pDev))
{
@ -914,9 +878,7 @@ miSpriteDeviceCursorCleanup(pDev, pScreen)
*/
static void
miSpriteRemoveCursor (pDev, pScreen)
DeviceIntPtr pDev;
ScreenPtr pScreen;
miSpriteRemoveCursor (DeviceIntPtr pDev, ScreenPtr pScreen)
{
miSpriteScreenPtr pScreenPriv;
miCursorInfoPtr pCursorInfo;
@ -955,10 +917,8 @@ miSpriteRemoveCursor (pDev, pScreen)
* before waiting for something to do.
*/
static void
miSpriteSaveUnderCursor(pDev, pScreen)
DeviceIntPtr pDev;
ScreenPtr pScreen;
static void
miSpriteSaveUnderCursor(DeviceIntPtr pDev, ScreenPtr pScreen)
{
miSpriteScreenPtr pScreenPriv;
int x, y;
@ -1002,9 +962,7 @@ miSpriteSaveUnderCursor(pDev, pScreen)
*/
static void
miSpriteRestoreCursor (pDev, pScreen)
DeviceIntPtr pDev;
ScreenPtr pScreen;
miSpriteRestoreCursor (DeviceIntPtr pDev, ScreenPtr pScreen)
{
miSpriteScreenPtr pScreenPriv;
int x, y;
@ -1048,9 +1006,7 @@ miSpriteRestoreCursor (pDev, pScreen)
*/
static void
miSpriteComputeSaved (pDev, pScreen)
DeviceIntPtr pDev;
ScreenPtr pScreen;
miSpriteComputeSaved (DeviceIntPtr pDev, ScreenPtr pScreen)
{
miSpriteScreenPtr pScreenPriv;
int x, y, w, h;

16
mi/mivaltree.c
View File

@ -108,11 +108,8 @@ Equipment Corporation.
* Compute the visibility of a shaped window
*/
_X_EXPORT int
miShapedWindowIn (pScreen, universe, bounding, rect, x, y)
ScreenPtr pScreen;
RegionPtr universe, bounding;
BoxPtr rect;
int x, y;
miShapedWindowIn (ScreenPtr pScreen, RegionPtr universe, RegionPtr bounding,
BoxPtr rect, int x, int y)
{
BoxRec box;
BoxPtr boundBox;
@ -597,11 +594,12 @@ miTreeObscured(
*/
/*ARGSUSED*/
int
miValidateTree (pParent, pChild, kind)
WindowPtr pParent; /* Parent to validate */
WindowPtr pChild; /* First child of pParent that was
miValidateTree (
WindowPtr pParent, /* Parent to validate */
WindowPtr pChild, /* First child of pParent that was
* affected */
VTKind kind; /* What kind of configuration caused call */
VTKind kind /* What kind of configuration caused call */
)
{
RegionRec totalClip; /* Total clipping region available to
* the marked children. pParent's clipList

68
mi/miwideline.c
View File

@ -252,13 +252,16 @@ miFillRectPolyHelper (
}
_X_EXPORT /* static */ int
miPolyBuildEdge (x0, y0, k, dx, dy, xi, yi, left, edge)
double x0, y0;
double k; /* x0 * dy - y0 * dx */
int dx, dy;
int xi, yi;
int left;
PolyEdgePtr edge;
miPolyBuildEdge (
double x0,
double y0,
double k, /* x0 * dy - y0 * dx */
int dx,
int dy,
int xi,
int yi,
int left,
PolyEdgePtr edge)
{
int x, y, e;
int xady;
@ -311,14 +314,17 @@ miPolyBuildEdge (x0, y0, k, dx, dy, xi, yi, left, edge)
#define StepAround(v, incr, max) (((v) + (incr) < 0) ? (max - 1) : ((v) + (incr) == max) ? 0 : ((v) + (incr)))
_X_EXPORT /* static */ int
miPolyBuildPoly (vertices, slopes, count, xi, yi, left, right, pnleft, pnright, h)
PolyVertexPtr vertices;
PolySlopePtr slopes;
int count;
int xi, yi;
PolyEdgePtr left, right;
int *pnleft, *pnright;
int *h;
miPolyBuildPoly (
PolyVertexPtr vertices,
PolySlopePtr slopes,
int count,
int xi,
int yi,
PolyEdgePtr left,
PolyEdgePtr right,
int *pnleft,
int *pnright,
int *h)
{
int top, bottom;
double miny, maxy;
@ -910,11 +916,9 @@ miRoundJoinFace (LineFacePtr face, PolyEdgePtr edge, Bool *leftEdge)
}
_X_EXPORT void
miRoundJoinClip (pLeft, pRight, edge1, edge2, y1, y2, left1, left2)
LineFacePtr pLeft, pRight;
PolyEdgePtr edge1, edge2;
int *y1, *y2;
Bool *left1, *left2;
miRoundJoinClip (LineFacePtr pLeft, LineFacePtr pRight,
PolyEdgePtr edge1, PolyEdgePtr edge2,
int *y1, int *y2, Bool *left1, Bool *left2)
{
double denom;
@ -935,11 +939,7 @@ miRoundJoinClip (pLeft, pRight, edge1, edge2, y1, y2, left1, left2)
}
_X_EXPORT int
miRoundCapClip (face, isInt, edge, leftEdge)
LineFacePtr face;
Bool isInt;
PolyEdgePtr edge;
Bool *leftEdge;
miRoundCapClip (LineFacePtr face, Bool isInt, PolyEdgePtr edge, Bool *leftEdge)
{
int y;
int dx, dy;
@ -1525,14 +1525,10 @@ miCleanupSpanData (DrawablePtr pDrawable, GCPtr pGC, SpanDataPtr spanData)
}
_X_EXPORT void
miWideLine (pDrawable, pGC, mode, npt, pPts)
DrawablePtr pDrawable;
GCPtr pGC;
int mode;
int npt;
DDXPointPtr pPts;
miWideLine (DrawablePtr pDrawable, GCPtr pGC,
int mode, int npt, DDXPointPtr pPts)
{
int x1, y1, x2, y2;
int x1, y1, x2, y2;
SpanDataRec spanDataRec;
SpanDataPtr spanData;
long pixel;
@ -2023,12 +2019,8 @@ miWideDashSegment (
}
_X_EXPORT void
miWideDash (pDrawable, pGC, mode, npt, pPts)
DrawablePtr pDrawable;
GCPtr pGC;
int mode;
int npt;
DDXPointPtr pPts;
miWideDash (DrawablePtr pDrawable, GCPtr pGC,
int mode, int npt, DDXPointPtr pPts)
{
int x1, y1, x2, y2;
unsigned long pixel;

62
mi/miwindow.c
View File

@ -57,12 +57,10 @@ SOFTWARE.
#include "pixmapstr.h"
#include "mivalidate.h"
_X_EXPORT void
miClearToBackground(pWin, x, y, w, h, generateExposures)
WindowPtr pWin;
int x,y;
int w,h;
Bool generateExposures;
_X_EXPORT void
miClearToBackground(WindowPtr pWin,
int x, int y, int w, int h,
Bool generateExposures)
{
BoxRec box;
RegionRec reg;
@ -255,10 +253,11 @@ miCheckSubSaveUnder(
*-----------------------------------------------------------------------
*/
Bool
miChangeSaveUnder(pWin, first)
WindowPtr pWin;
WindowPtr first; /* First window to check.
miChangeSaveUnder(
WindowPtr pWin,
WindowPtr first /* First window to check.
* Used when pWin was restacked */
)
{
RegionRec rgn; /* Area obscured by saveUnder windows */
ScreenPtr pScreen;
@ -293,9 +292,7 @@ miChangeSaveUnder(pWin, first)
*-----------------------------------------------------------------------
*/
void
miPostChangeSaveUnder(pWin, pFirst)
WindowPtr pWin;
WindowPtr pFirst;
miPostChangeSaveUnder(WindowPtr pWin, WindowPtr pFirst)
{
WindowPtr pParent, pChild;
ChangeWindowAttributesProcPtr ChangeWindowAttributes;
@ -329,8 +326,7 @@ miPostChangeSaveUnder(pWin, pFirst)
}
void
miMarkWindow(pWin)
WindowPtr pWin;
miMarkWindow(WindowPtr pWin)
{
ValidatePtr val;
@ -345,10 +341,7 @@ miMarkWindow(pWin)
}
Bool
miMarkOverlappedWindows(pWin, pFirst, ppLayerWin)
WindowPtr pWin;
WindowPtr pFirst;
WindowPtr *ppLayerWin;
miMarkOverlappedWindows(WindowPtr pWin, WindowPtr pFirst, WindowPtr *ppLayerWin)
{
BoxPtr box;
WindowPtr pChild, pLast;
@ -434,8 +427,7 @@ miMarkOverlappedWindows(pWin, pFirst, ppLayerWin)
* and then send any regions still exposed to the client
*****/
_X_EXPORT void
miHandleValidateExposures(pWin)
WindowPtr pWin;
miHandleValidateExposures(WindowPtr pWin)
{
WindowPtr pChild;
ValidatePtr val;
@ -472,11 +464,7 @@ miHandleValidateExposures(pWin)
}
void
miMoveWindow(pWin, x, y, pNextSib, kind)
WindowPtr pWin;
int x,y;
WindowPtr pNextSib;
VTKind kind;
miMoveWindow(WindowPtr pWin, int x, int y, WindowPtr pNextSib, VTKind kind)
{
WindowPtr pParent;
Bool WasViewable = (Bool)(pWin->viewable);
@ -589,11 +577,10 @@ miRecomputeExposures (
}
void
miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
WindowPtr pWin;
int x,y;
unsigned int w, h;
WindowPtr pSib;
miSlideAndSizeWindow(WindowPtr pWin,
int x, int y,
unsigned int w, unsigned int h,
WindowPtr pSib)
{
WindowPtr pParent;
Bool WasViewable = (Bool)(pWin->viewable);
@ -917,8 +904,7 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
}
WindowPtr
miGetLayerWindow(pWin)
WindowPtr pWin;
miGetLayerWindow(WindowPtr pWin)
{
return pWin->firstChild;
}
@ -932,8 +918,7 @@ miGetLayerWindow(pWin)
*/
_X_EXPORT void
miSetShape(pWin)
WindowPtr pWin;
miSetShape(WindowPtr pWin)
{
Bool WasViewable = (Bool)(pWin->viewable);
ScreenPtr pScreen = pWin->drawable.pScreen;
@ -1003,9 +988,7 @@ miSetShape(pWin)
/* Keeps the same inside(!) origin */
_X_EXPORT void
miChangeBorderWidth(pWin, width)
WindowPtr pWin;
unsigned int width;
miChangeBorderWidth(WindowPtr pWin, unsigned int width)
{
int oldwidth;
Bool anyMarked = FALSE;
@ -1072,10 +1055,7 @@ miChangeBorderWidth(pWin, width)
}
void
miMarkUnrealizedWindow(pChild, pWin, fromConfigure)
WindowPtr pChild;
WindowPtr pWin;
Bool fromConfigure;
miMarkUnrealizedWindow(WindowPtr pChild, WindowPtr pWin, Bool fromConfigure)
{
if ((pChild != pWin) || fromConfigure)
{

11
mi/mizerarc.c
View File

@ -96,10 +96,7 @@ static miZeroArcPtRec oob = {65536, 65536, 0};
*/
_X_EXPORT Bool
miZeroArcSetup(arc, info, ok360)
xArc *arc;
miZeroArcRec *info;
Bool ok360;
miZeroArcSetup(xArc *arc, miZeroArcRec *info, Bool ok360)
{
int l;
int angle1, angle2;
@ -706,11 +703,7 @@ miZeroArcDashPts(
}
_X_EXPORT void
miZeroPolyArc(pDraw, pGC, narcs, parcs)
DrawablePtr pDraw;
GCPtr pGC;
int narcs;
xArc *parcs;
miZeroPolyArc(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc *parcs)
{
int maxPts = 0;
int n, maxw = 0;

17
mi/mizerclip.c
View File

@ -405,17 +405,12 @@ the numerator is therefore (2^32 - 1), which does not overflow an unsigned
*
*/
_X_EXPORT int
miZeroClipLine(xmin, ymin, xmax, ymax,
new_x1, new_y1, new_x2, new_y2,
adx, ady,
pt1_clipped, pt2_clipped, octant, bias, oc1, oc2)
int xmin, ymin, xmax, ymax;
int *new_x1, *new_y1, *new_x2, *new_y2;
int *pt1_clipped, *pt2_clipped;
unsigned int adx, ady;
int octant;
unsigned int bias;
int oc1, oc2;
miZeroClipLine(int xmin, int ymin, int xmax, int ymax,
int *new_x1, int *new_y1, int *new_x2, int *new_y2,
unsigned int adx, unsigned int ady,
int *pt1_clipped, int *pt2_clipped,
int octant, unsigned int bias,
int oc1, int oc2)
{
int swapped = 0;
int clipDone = 0;

25
mi/mizerline.c
View File

@ -98,12 +98,12 @@ SOFTWARE.
}
_X_EXPORT void
miZeroLine(pDraw, pGC, mode, npt, pptInit)
DrawablePtr pDraw;
GCPtr pGC;
int mode; /* Origin or Previous */
int npt; /* number of points */
DDXPointPtr pptInit;
miZeroLine(
DrawablePtr pDraw,
GCPtr pGC,
int mode, /* Origin or Previous */
int npt, /* number of points */
DDXPointPtr pptInit)
{
int Nspans, current_y = 0;
DDXPointPtr ppt;
@ -364,12 +364,13 @@ miZeroLine(pDraw, pGC, mode, npt, pptInit)
}
_X_EXPORT void
miZeroDashLine(dst, pgc, mode, nptInit, pptInit)
DrawablePtr dst;
GCPtr pgc;
int mode;
int nptInit; /* number of points in polyline */
DDXPointRec *pptInit; /* points in the polyline */
miZeroDashLine(
DrawablePtr dst,
GCPtr pgc,
int mode,
int nptInit, /* number of points in polyline */
DDXPointRec *pptInit /* points in the polyline */
)
{
/* XXX kludge until real zero-width dash code is written */
pgc->lineWidth = 1;