archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
4.9 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/windows/core/ntgdi/gre/xlateobj.hxx

1437 lines
48 KiB
Raw Permalink Blame History

/******************************Module*Header*******************************\
* Module Name: xlateobj.hxx
*
* This file contains the class prototypes for palettes and xlates
*
* Created: 08-Nov-1990 19:30:06
* Author: Patrick Haluptzok patrickh
*
* Copyright (c) 1990-1999 Microsoft Corporation
*
* TERMINOLOGY:
*
* Logical hpal: Something an application creates. These exist in the
* hdc.
*
* Physical hpal: An hpal that describes a surface. These are unique per
* hsurf. They can only be changed by GDI, not directly
* by an application.
*
* Every hdc has 3 fields for compatibiliy with Win3.0 Animate
* palette functionality.
*
* The first one is in the DCLEVEL:
*
* HPALETTE hpal; // Indicates the current hpal for the DC.
*
* These fields are not in the DCLEVEL:
*
* HDC hdcHpalPrev; // These two hdc fields enable tracking where
* HDC hdcHpalNext; // a hpal has been selected in.
*
* Every hpal has 2 fields for compatibility with Win3.0 Animate.
*
* HDC hdcHead; // The head of the list for the dc's that
* // this hpal is selected into
* ULONG cRef; // count of dc's and levels this baby is
* // selected into
*
* When a hpal is selected into a hdc, the hdc is added into a
* linked list of hdc associated with the hpal. The reference
* count for the hpal is incremented. The previous hpal has
* it's reference count decremented, and the hdc is taken out
* of it's linked list. This is so we can run down the list
* of DC the palette is selected into to do the AnimatePalette.
*
* The hpal is saved with SaveDC. SaveDC increments the reference count
* of the corresponding hpal and copies it to the new level.
*
* On RestoreDC decrement the old hpal's reference count. If the hpal's
* on the levels are different, the new hpal must be added back in the
* linked list, ***NOTE: it doesn't need to increment the reference count
* for the new level's hpal, the reference count already has
* this level added in it.
*
* A RealizePalette creates a xlateobj for mapping entries from the hdc's
* hpal to the hsurf's hpal if the surface is managed by the window manager.
* If the surface is not window managed the mapping is so trivial that a
* xlateobj is not created.
*
* GLOBAL Notions:
*
* STOCKOBJ_PAL
* PPALETTE ppalDefault;
* PPALETTE ppalDefaultSurface8bpp;
*
* STOCKOBJ_PAL is what every DC has when it is called by GetDC. It is
* the special case palette that is always locked, non-modifiable and
* contains the 20 default colors. The constructors and destructors and
* methods all should do the right thing for the default palette, i.e.
* never really lock it or modify it, but allow everyone to look at it
* and copy it.
*
* Tue 04-Dec-1990 -by- Patrick Haluptzok [patrickh]
* update
\**************************************************************************/
#ifndef _XLATEOBJ_
#define _XLATEOBJ_
#ifndef GDIFLAGS_ONLY // used for gdikdx
typedef struct _PIXEL32
{
BYTE b;
BYTE g;
BYTE r;
BYTE a;
}PIXEL32,*PPIXEL32;
typedef union _ALPHAPIX
{
PIXEL32 pix;
RGBQUAD rgb;
ULONG ul;
} ALPHAPIX,*PALPHAPIX;
typedef union _PAL_ULONG
{
PALETTEENTRY pal;
ULONG ul;
} PAL_ULONG;
typedef union _BGR_ULONG
{
RGBQUAD rgb;
ULONG ul;
} BGR_ULONG;
typedef union _HDEVPPAL
{
HDEV hdev;
PPALETTE ppal;
} HDEVPPAL;
typedef struct _PAL_LOGPALETTE
{
SHORT palVersion;
SHORT palNumEntries;
PALETTEENTRY palPalEntry[20];
} PAL_LOGPALETTE;
// The translate structure is used on palette managed devices to convert
// logical palette indices to physical palette indices.
typedef struct _TRANSLATE
{
ULONG iUniq; // Surface time this translate was made for. 0 if rerealize necesary.
BYTE ajVector[1]; // NOTE: THIS IS A VARIABLE-LENGTH FIELD AND MUST BE LAST
} TRANSLATE;
typedef TRANSLATE *PTRANSLATE;
typedef struct _TRANSLATE20
{
ULONG iUniq;
BYTE ajVector[20];
} TRANSLATE20;
extern TRANSLATE20 defaultTranslate;
extern PAL_LOGPALETTE logDefaultPal;
extern BYTE HalftoneColorCube[];
//
// forward reference
//
// NOTE: the cache size must be a power of 2, quicker modula calculation.
#define XLATE_CACHE_SIZE ((ULONG) 8)
#define XLATE_MODULA (XLATE_CACHE_SIZE - (ULONG) 1)
#endif // GDIFLAGS_ONLY used for gdikdx
#define DIB_PAL_NONE 3
// PALOBJ flags - Fist bunch are defined in winddi.h
//#define PAL_INDEXED 0x00000001
//#define PAL_BITFIELDS 0x00000002
//#define PAL_RGB 0x00000004
//#define PAL_BGR 0x00000008
//#define PAL_CMYK 0x00000010
#define PAL_DC 0x00000100 // See below for comments
#define PAL_FIXED 0x00000200
#define PAL_FREE 0x00000400
#define PAL_MANAGED 0x00000800
#define PAL_NOSTATIC 0x00001000
#define PAL_MONOCHROME 0x00002000
#define PAL_BRUSHHACK 0x00004000
#define PAL_DIBSECTION 0x00008000
#define PAL_NOSTATIC256 0x00010000
#define PAL_HT 0x00100000
#define PAL_RGB16_555 0x00200000
#define PAL_RGB16_565 0x00400000
#define PAL_GAMMACORRECT 0x00800000 // This bit is only for palette on surface
//
// PAL_DIBSECTION is set when the palette is created for a DIBSECTION being
// created with DIB_PAL_COLORS. When this happens we should attempt to map
// the colors directly as identity xlate if possible, rather than doing the
// first color match wins routine.
//
// PAL_DC specifies the palette was created by an application through
// CreatePalette. These palettes only live in DC's, never in
// surfaces. These may be selected into multiple DC's, with the
// restriction that only one of the DC's hsurf's hpal is of type
// PAL_MANAGED
// Physical palettes are unique to an hsurf. No two surfaces have
// the same palette, though their entries may be the same. (They can also
// share color tables if it's a palette for a DirectDRaw object.) There are
// 3 different PAL_SURF types.
// 1. PAL_FIXED is a fixed palette. If this flag is set then
// the palette for this surface cannot be changed.
// 2. PAL_FREE means the palette is completely free. If it's selected into
// a DC with an hpal, the DC's hpal will map right in 1-1. This is the
// type of palette a Bitmap would have.
// 3. PAL_MANAGED means this palette has some entries fixed and
// some are settable. The fixed entries must be the first 10 and
// last 10. This is what a palette managed device has.
// PAL_NOSTATIC is a flag that signifies that for this PAL_MANAGED surface
// only two colors black, white, (first and last) are reserved.
// PAL_MONOCHROME is the flag stuck on monochrome bitmaps that should
// have their 0-> mapped to the foreground color of the dest DC and
// the 1-> mapped to the background color. The flag is put on palettes
// of bitmaps created via the call CreateBitmap, CreateBitmapIndirect.
// CreateDIBitmap treats monochromes just like 4,8 etc. it looks at
// the associated color table with the bitmap and therefore doesn't
// mark the palette PAL_MONOCHROME. This flag is required for
// Win 3.0 compatibility.
// There are 2 classes of palettes:
//
// A. PAL_INDEXED - the palette is described by an array of RGB's.
// 1. PAL_MONOCHROME - is a subset of PAL_INDEXED
//
// B. Not PAL_INDEXED, cEntries == 0
// the palette has no table, it describes how to convert
// the bits directly into RGBs via masks.
// 1. PAL_RGB - Classical RGB.
// PAL_RGB specifies a palette as being true RGB. An application creates
// an RGB palette by calling CreatePalette with numentries equal to 0.
// The byte order from low to high is R, G, B, flag.
// PAL_BGR specifies RGB expect the ordering from low to high is
// B, G, R, flags
// If the palette has less than 20 colors simultaneously then it must be a
// fixed palette or a free palette, none of the entries may be settable
// and the driver may pass back any colors it wants for it's palette.
// Windows3.1 flags for palette matching
#define PC_USED 0x10
#define PC_FOREGROUND 0x20
#ifndef GDIFLAGS_ONLY // used for gdikdx
//
// in some cases build an xlate table from rgb333 to palette entries
//
typedef PBYTE PRGB555XLATE;
#endif // GDIFLAGS_ONLY used for gdikdx
// Specify on calls to search for nearest COLORREFs or PALENTRYs whether
// to do an exact match search before doing the nearest match, since an
// exact search is so much faster.
#define SE_DONT_SEARCH_EXACT_FIRST 0x00
#define SE_DO_SEARCH_EXACT_FIRST 0x01
//
// ulXlatePalUnique maintains "time" of the last change to a palette or xlateobj.
// This is needed to tell if a xlateobj or translate is valid.
//
#ifndef GDIFLAGS_ONLY // used for gdikdx
extern ULONG ulXlatePalUnique;
extern PAL_ULONG aPalHalftone[];
//
// Function prototype for palette-specific routines to convert a
// PALETTEENTRY to the destination device's color format.
//
class PALETTE;
typedef ULONG (FASTCALL *PFN_GetFromPalentry)(PALETTE*, ULONG);
//
// Function prototype for optimized routines to convert between two
// bitfields (or RGB or BGR) format colors.
//
typedef ULONG (FASTCALL *PFN_pfnXlate)(XLATEOBJ*, ULONG);
/******************************Public*Class*******************************\
* class PALETTE
*
* Palette class
*
* History:
* 07-Nov-1990 -by- Patrick Haluptzok patrickh
* Wrote it.
\**************************************************************************/
class PALETTE : public OBJECT
{
public:
FLONG flPal; // flags in palette
ULONG cEntries; // count of entries currently in palette
ULONG ulTime; // Time that specifies when the palette
// was last modified. Use this to determine
// if xlateobj are still valid.
HDC hdcHead; // Head of the linked list of DC's this hpalette
// is selected into so we traverse all the DC's
// an hpal is selected into to do AnimatePalette
// ect. correctly
HDEVPPAL hSelected; // For a PAL_DC this is the hdev of the pdev
// this
// palette is selected into. We track this
// because a palette can only be selected into
// the DC's of 1 device at a
// time. The DEVLOCK of the pdev serializes
// access to the pxlates in the palDC.
// For a PAL_MANAGED palette this is
// the hpal of its default palette.
ULONG cRefhpal; // For a PAL_DC this is the
// count of times this hpal is selected into a DC.
// For a PAL_xxx this is the
// index in the cache table of where the last
// hxlate used for this surf palette was stuffed.
ULONG cRefRegular; // For a PAL_MANAGED this is the number of reserved
// entries.
// For the special case where we have created a DIB
// via DIB_PAL_COLORS, we store the actual length of
// the DIB's color table here so we don't have to
// make as big an xlate
// For a DIBSECTION bitmap this is the count of
// entries that are used. This is for
// Get/SetDIBColorTable to remember the ClrUsed.
HDEV hdevOwner; // Pointer to PDEV who create this palette by EngCreatePalette()
// this entry is used only for the palette on the surface.
// [note] later to 'union' with someelse value which
// is only used for logical palette.
PTRANSLATE ptransFore; // Foreground mapping.
PTRANSLATE ptransCurrent; // Current mapping which may == ptransFore.
PTRANSLATE ptransOld; // The old translate for UpdateColors.
// This needs to be kept around to support
// UpdateColors.
PFN_GetFromPalentry pfnGetNearestFromPalentry;
PFN_GetFromPalentry pfnGetMatchFromPalentry;
// Indirect functions to convert a PALETTEENTRY
// to the destination device's color format
ULONG ulRGBTime;
PRGB555XLATE pRGBXlate; // prgbXlate is allocated for a palette when doing
// translations from 16,24,32 bit per pixel formats
// to the palette format. ulRGBTime is used to determine
// if the xlate is valid.
PAL_ULONG *apalColor; // Pointer to color table. Usually points to
// &apalColorTabe[0], except for a DirectDraw
// GetDC surface, for which it points directly to
// the screen surface's color table
PALETTE *ppalColor; // Palette that owns the color table
// NOTE: THIS IS A VARIABLE-LENGTH FIELD AND MUST BE LAST
PAL_ULONG apalColorTable[1]; // array of rgb values that each index corresponds
// plus array of intensities from least intense to most
// intense (plus index to corresponding rgb value)
};
typedef PALETTE *PPALETTE;
/******************************Public*Class********************************\
* XLATE
*
* This is the data structure for an xlate object. An xlate tranlates
* indices from being relative one palette to being relative to another.
*
* History:
* Mon 07-Mar-1994 -by- Patrick Haluptzok [patrickh]
* Derive off of XLATEOBJ.
*
* 18-Nov-1990 -by- Patrick Haluptzok patrickh
* Wrote it.
\**************************************************************************/
class XLATE : public _XLATEOBJ
{
public:
// ULONG iUniq; // Uniqueness
// FLONG flXlate; // Accelerator flags
// USHORT iSrcType; // Src palette type
// USHORT iDstType; // Dst palette type
// ULONG cEntries; // Count of entries in table
// ULONG *pulXlate; // Pointer to translation vector.
ULONG iBackSrc; // tracked for blting to monochrome
ULONG iForeDst; // tracked for blting from monochrome
ULONG iBackDst; // tracked for blting from monochrome
LONG lCacheIndex; // Is XLATE_CACHE_JOURNAL if for journal play back
// Is XLATE_CACHE_INVALID if it's not in cache
// Otherwise it's the cache index.
PPALETTE ppalSrc; // Points to Src palette.
PPALETTE ppalDst; // Points to Dst palette.
PPALETTE ppalDstDC; // Points to Dst DC palette.
HANDLE hcmXform; // ICM Color Transform for operation
LONG lIcmMode; // ICM mode for operation
FLONG flPrivate; // Private accelerator flags
// NOTE: THIS IS A VARIABLE-LENGTH FIELD AND MUST BE LAST
ULONG ai[1]; // The translation vector.
public:
BOOL bIsIdentity() { return(flXlate & XO_TRIVIAL); }
ULONG ulTranslate(ULONG cIndex) { return(XLATEOBJ_iXlate(this, cIndex)); }
VOID vSetIndex(ULONG ulIndex, ULONG ulValue)
{
ASSERTGDI(ulIndex < cEntries, "ERROR XLATE vSetIndex");
ai[ulIndex] = ulValue;
}
VOID FASTCALL vMapNewXlate(PTRANSLATE ptrans);
VOID vCheckForTrivial();
VOID vCheckForICM(HANDLE hcmXform,ULONG lIcmMode);
PFN_pfnXlate pfnXlateBetweenBitfields();
};
typedef XLATE *PXLATE;
//
// This class is for the global identity xlate we have sitting around.
//
class XLATE256 : public XLATE
{
public:
ULONG aiExtra[255]; // We have a 256 array of ident xlate.
};
class XLATE2 : public XLATE
{
public:
ULONG aiExtra[1]; // We have a 2 entry array.
};
extern XLATE256 xloIdent;
// The following constants are for reserved uniqueness values.
// 1 is reserved for the identity xlate.
// 2 is reserved for the palette time for a palette managed bitmap palette.
// If ever wrapping is an issue I would increment by 2, start at an even #
// and put the reserved times at odd offsets.
#define XLATE_IDENTITY_UNIQ 1
#define COMPAT_PAL_MAN_BM_UNIQ 2
#define XLATE_START_UNIQ 3
//
// The 2 common palettes used in Windows are:
// The palette for mononchrome bitmaps
// The default logical palette for DC's
//
extern PPALETTE ppalDefault;
extern PPALETTE gppalRGB;
extern PPALETTE ppalDefaultSurface8bpp;
extern PPALETTE ppalMono;
extern HPALETTE hpalMono;
/******************************Public*Structure****************************\
* P_BITFIELDS
*
* This supports the 16 and 32 bit-bitfield palette types. The bitfields
* for each color are assumed to be contiguous and don't overlap.
*
* Let a 16 or 32 bit index be represented by:
*
* { X | Y | Z } where X is the high ignored bits, Y is the color bits
* for a particular Color and Z is the ignored low bits.
*
* cColorRight = (Y > 8) ? (Z + Y - 8) : (Z);
*
* Let w=0 for red, w=8 for green, w=16 for blue
*
* cColorLeft = (Y > 8) ? (w) : (w + 8 - Y)
*
* We compute this for R,G,B and from these we can transform the colors
* from RGB to indexes and back again no matter how wide or what order
* the bitfields for each of the colors is.
*
* History:
* 08-Nov-1991 -by- Patrick Haluptzok patrickh
* Wrote it.
\**************************************************************************/
typedef struct _P_BITFIELDS
{
FLONG flRed; // Masks for the corresponding bits
FLONG flGre;
FLONG flBlu;
ULONG cRedLeft;
ULONG cGreLeft;
ULONG cBluLeft;
ULONG cRedRight;
ULONG cGreRight;
ULONG cBluRight;
ULONG cRedMiddle;
ULONG cGreMiddle;
ULONG cBluMiddle;
} P_BITFIELDS;
/******************************Public*Class*******************************\
* class XEPALOBJ
*
* Palette User Object
*
* History:
* Thu 29-Aug-1991 -by- Patrick Haluptzok [patrickh]
* changed it to be XEPALOBJ
*
* 07-Nov-1990 -by- Patrick Haluptzok patrickh
* Wrote it.
\**************************************************************************/
class XEPALOBJ /* xepal */
{
protected:
PPALETTE ppal;
public:
XEPALOBJ() { ppal = (PPALETTE) NULL; }
XEPALOBJ(PPALETTE ppalNew) { ppal = ppalNew; }
VOID vAltCheckLock(HPALETTE hpal)
{
ppal = (PPALETTE) HmgShareCheckLock((HOBJ)hpal, PAL_TYPE);
}
VOID vAltLock(HPALETTE hpal)
{
ppal = (PPALETTE) HmgShareLock((HOBJ)hpal, PAL_TYPE);
}
VOID vAltUnlock()
{
if (ppal != (PPALETTE) NULL)
{
DEC_SHARE_REF_CNT(ppal);
ppal = (PPALETTE) NULL;
}
}
// These are the common functions
HPALETTE hpal() { return((HPALETTE) ppal->hGet()); }
BOOL bValid() { return(ppal != (PPALETTE) NULL); }
BOOL bIsPalDefault() { return(ppal == ppalDefault); }
VOID vSetPID(W32PID pid) { HmgSetOwner((HOBJ)hpal(), pid, PAL_TYPE); }
VOID vRefPalette() { if (ppal != NULL) INC_SHARE_REF_CNT(ppal); }
VOID vUnrefPalette();
BOOL bDeletePalette(BOOL bCleanup = FALSE, CLEANUPTYPE cutype = CLEANUP_NONE); // release associated memory
// Bitfield functions
FLONG flRed() { return(((P_BITFIELDS *) ppal->apalColor)->flRed); }
VOID flRed(FLONG flNew) { ((P_BITFIELDS *) ppal->apalColor)->flRed = flNew; }
FLONG flGre() { return(((P_BITFIELDS *) ppal->apalColor)->flGre); }
VOID flGre(FLONG flNew) { ((P_BITFIELDS *) ppal->apalColor)->flGre = flNew; }
FLONG flBlu() { return(((P_BITFIELDS *) ppal->apalColor)->flBlu); }
VOID flBlu(FLONG flNew) { ((P_BITFIELDS *) ppal->apalColor)->flBlu = flNew; }
ULONG& cRedLeft() { return(((P_BITFIELDS *) ppal->apalColor)->cRedLeft); }
VOID cRedLeft(ULONG ul) { ((P_BITFIELDS *) ppal->apalColor)->cRedLeft = ul; }
ULONG& cGreLeft() { return(((P_BITFIELDS *) ppal->apalColor)->cGreLeft); }
VOID cGreLeft(ULONG ul) { ((P_BITFIELDS *) ppal->apalColor)->cGreLeft = ul; }
ULONG& cBluLeft() { return(((P_BITFIELDS *) ppal->apalColor)->cBluLeft); }
VOID cBluLeft(ULONG ul) { ((P_BITFIELDS *) ppal->apalColor)->cBluLeft = ul; }
ULONG& cRedRight() { return(((P_BITFIELDS *) ppal->apalColor)->cRedRight); }
VOID cRedRight(ULONG ul) { ((P_BITFIELDS *) ppal->apalColor)->cRedRight = ul; }
ULONG& cGreRight() { return(((P_BITFIELDS *) ppal->apalColor)->cGreRight); }
VOID cGreRight(ULONG ul) { ((P_BITFIELDS *) ppal->apalColor)->cGreRight = ul; }
ULONG& cBluRight() { return(((P_BITFIELDS *) ppal->apalColor)->cBluRight); }
VOID cBluRight(ULONG ul) { ((P_BITFIELDS *) ppal->apalColor)->cBluRight = ul; }
ULONG& cRedMiddle() { return(((P_BITFIELDS *) ppal->apalColor)->cRedMiddle); }
VOID cRedMiddle(ULONG ul) { ((P_BITFIELDS *) ppal->apalColor)->cRedMiddle = ul; }
ULONG& cGreMiddle() { return(((P_BITFIELDS *) ppal->apalColor)->cGreMiddle); }
VOID cGreMiddle(ULONG ul) { ((P_BITFIELDS *) ppal->apalColor)->cGreMiddle = ul; }
ULONG& cBluMiddle() { return(((P_BITFIELDS *) ppal->apalColor)->cBluMiddle); }
VOID cBluMiddle(ULONG ul) { ((P_BITFIELDS *) ppal->apalColor)->cBluMiddle = ul; }
ULONG ulBitfieldToRGB(ULONG ulIndex);
ULONG ulIndexToRGB(ULONG ulIndex);
// General functions
PPALETTE ppalGet() { return(ppal); }
PVOID pvPalette() { return((PVOID) ppal); }
VOID ppalSet(PPALETTE ppalNew) { ppal = ppalNew; }
FLONG flPal() { return(ppal->flPal); }
VOID flPalSet(FLONG flag) { ppal->flPal = flag; }
VOID flPal(FLONG flag) { ppal->flPal |= flag; }
ULONG iPalMode() { return(ppal->flPal & (PAL_RGB | PAL_BGR | PAL_CMYK | PAL_INDEXED | PAL_BITFIELDS)); }
BOOL bIsRGB() { return(ppal->flPal & PAL_RGB); }
BOOL bIsBGR() { return(ppal->flPal & PAL_BGR); }
BOOL bIs565() { return(ppal->flPal & PAL_RGB16_565); }
BOOL bIs555() { return(ppal->flPal & PAL_RGB16_555); }
BOOL bIsCMYK() { return(ppal->flPal & PAL_CMYK); }
BOOL bIsIndexed() { return(ppal->cEntries); }
BOOL bIsPalDC() { return(ppal->flPal & PAL_DC); }
BOOL bIsBitfields() { return(ppal->flPal & PAL_BITFIELDS); }
BOOL bIsPalDibsection() { return(ppal->flPal & PAL_DIBSECTION); }
BOOL bIsHalftone() { return(ppal->flPal & PAL_HT);}
ULONG cEntries() { return(ppal->cEntries); }
VOID cEntries(ULONG ulTemp) { ppal->cEntries = ulTemp; }
PPALETTE ppalColor() { return(ppal->ppalColor); }
PAL_ULONG *apalColorGet() { return(ppal->apalColor); }
VOID vComputeCallTables();
VOID apalColorSet(PPALETTE ppalGlobal)
{
if (ppal->ppalColor != ppal)
{
// Handle re-assignment case
DEC_SHARE_REF_CNT(ppal->ppalColor);
}
INC_SHARE_REF_CNT(ppalGlobal);
ppal->apalColor = ppalGlobal->apalColor;
ppal->ppalColor = ppalGlobal;
}
VOID apalResetColorTable()
{
if (ppal->ppalColor != ppal)
{
// Handle re-assignment case
DEC_SHARE_REF_CNT(ppal->ppalColor);
}
// Note that this does not transfer ownership of the color table
ppal->apalColor = &ppal->apalColorTable[0];
ppal->ppalColor = ppal;
}
ULONG ulTime()
{
if (ppal->ppalColor != ppal)
{
// Note if color table lives in different PALETTE, get time from there.
return(ppal->ppalColor->ulTime);
}
else
{
return(ppal->ulTime);
}
}
VOID ulTime(ULONG ulNewTime)
{
ppal->ulTime = ulNewTime;
if (ppal->ppalColor != ppal)
{
// Note if color table lives in different PALETTE, update that's ulTime, too.
ppal->ppalColor->ulTime = ulNewTime;
}
}
VOID vUpdateTime() { ulTime(ulGetNewUniqueness(ulXlatePalUnique)); }
VOID vSetHTPal() { ppal->flPal |= PAL_HT; }
VOID vClearHTPal() { ppal->flPal &= ~PAL_HT; }
BOOL bIsHTPal() { return(ppal->flPal & PAL_HT); }
PALETTEENTRY palentryGet(ULONG ulIndex)
{
ASSERTGDI(ulIndex < ppal->cEntries, "ERROR palentryGet: ulIndex > cEntries");
return(ppal->apalColor[ulIndex].pal);
}
ULONG ulEntryGet(ULONG ulIndex)
{
ASSERTGDI(ulIndex < ppal->cEntries, "ERROR ulentryGet: ulIndex > cEntries");
return(ppal->apalColor[ulIndex].ul);
}
VOID palentrySet(ULONG ulIndex, PALETTEENTRY palentry)
{
ASSERTGDI(ulIndex < ppal->cEntries, "ERROR palentrySet: ulIndex > cEntries");
ppal->apalColor[ulIndex].pal = palentry;
}
VOID ulEntrySet(ULONG ulIndex, ULONG ulRGB)
{
ASSERTGDI(ulIndex < ppal->cEntries, "ERROR palentrySet: ulIndex > cEntries");
ppal->apalColor[ulIndex].ul = ulRGB;
}
ULONG ulSetEntries(ULONG iStart, ULONG cEntry, CONST PALETTEENTRY *ppalentry);
ULONG ulAnimatePalette(ULONG iStart, ULONG cEntry, CONST PALETTEENTRY *ppalentry);
ULONG ulGetEntries(ULONG iStart, ULONG cEntry, PPALETTEENTRY ppalentry, BOOL bZeroFlags);
ULONG ulGetNearestFromPalentryNoExactMatchFirst(CONST PALETTEENTRY palentry);
ULONG ulGetMatchFromPalentry(CONST PALETTEENTRY palentry)
{
return(ppal->pfnGetMatchFromPalentry(ppal, *((ULONG*) &palentry)));
}
ULONG ulGetMatchFromPalentry(CONST ULONG palentry)
{
return(ppal->pfnGetMatchFromPalentry(ppal, palentry));
}
ULONG ulGetNearestFromPalentry(CONST PALETTEENTRY palentry)
{
return(ppal->pfnGetNearestFromPalentry(ppal, *((ULONG*) &palentry)));
}
ULONG ulGetNearestFromPalentry(CONST ULONG palentry)
{
return(ppal->pfnGetNearestFromPalentry(ppal, palentry));
}
ULONG ulGetNearestFromPalentry(
CONST PALETTEENTRY palentry,
ULONG seSearchExactFirst
)
{
ULONG ul;
if (seSearchExactFirst == SE_DONT_SEARCH_EXACT_FIRST)
{
ul = ulGetNearestFromPalentryNoExactMatchFirst(palentry);
}
else
{
ul = ulGetNearestFromPalentry(palentry);
}
return(ul);
}
VOID vInitMono();
VOID vInitVGA();
VOID vInit256Rainbow();
VOID vInit256Default();
// These are the DC palette functions - PALOBJDC
VOID hdcHead(HDC hdcHead)
{
ASSERTGDI(ppal->flPal & PAL_DC, "ERROR hdcHead() passed invalid palette type\n");
ppal->hdcHead = hdcHead;
}
HDC hdcHead()
{
ASSERTGDI(ppal->flPal & PAL_DC, "ERROR hdcHead() 1passed invalid palette type\n");
return(ppal->hdcHead);
}
VOID cRefhpal(ULONG ulTemp)
{
ASSERTGDI(ppal->flPal & PAL_DC, "ERROR cRefhpal not called on PAL_DC1\n");
ppal->cRefhpal = ulTemp;
}
ULONG cRefhpal()
{
ASSERTGDI(ppal->flPal & PAL_DC, "ERROR cRefhpal not called on PAL_DC\n");
return(ppal->cRefhpal);
}
VOID iXlateIndex(ULONG ulTemp)
{
ASSERTGDI(!(ppal->flPal & PAL_DC), "ERROR iXlateIndex called on PAL_DC1\n");
ASSERTGDI(ulTemp < XLATE_CACHE_SIZE, "ERROR saving too large cache index \n");
ppal->cRefhpal = ulTemp;
}
ULONG iXlateIndex()
{
ASSERTGDI(!(ppal->flPal & PAL_DC), "ERROR iXlateIndex called on PAL_DC\n");
ASSERTGDI(ppal->cRefhpal < XLATE_CACHE_SIZE, "ERROR retrieving out of bounds cache index \n");
return(ppal->cRefhpal);
}
VOID ptransFore(PTRANSLATE ptrans)
{
ASSERTGDI(ppal->flPal & PAL_DC, "ERROR pxlFore() passed invalid palette type\n");
ppal->ptransFore = ptrans;
}
PTRANSLATE ptransFore()
{
ASSERTGDI(ppal->flPal & PAL_DC, "ERROR pxlFore() 1passed invalid palette type\n");
return(ppal->ptransFore);
}
VOID ptransCurrent(PTRANSLATE ptrans)
{
ASSERTGDI(ppal->flPal & PAL_DC, "ERROR ptransCurrent() passed invalid palette type\n");
ppal->ptransCurrent = ptrans;
}
PTRANSLATE ptransCurrent()
{
ASSERTGDI(ppal->flPal & PAL_DC, "ERROR ptransCurrent() 1passed invalid palette type\n");
return(ppal->ptransCurrent);
}
VOID ptransOld(PTRANSLATE ptrans)
{
ASSERTGDI(ppal->flPal & PAL_DC, "ERROR ptransOld() passed invalid palette type\n");
ppal->ptransOld = ptrans;
}
PTRANSLATE ptransOld()
{
ASSERTGDI(ppal->flPal & PAL_DC, "ERROR ptransOld() 1passed invalid palette type\n");
return(ppal->ptransOld);
}
//
// For ResizePalette
//
BOOL bSwap(PPALETTE*,ULONG,ULONG);
//
// This returns the index in the surface palette an index in the dc
// palette maps to. It assumes you checked for a valid ptrans and a
// valid index range.
//
ULONG ulTranslateDCtoCurrent(ULONG ulIndex)
{
ASSERTGDI(ppal->flPal & PAL_DC, "ERROR GDI ulTranslateIndex");
ASSERTGDI(ulIndex < ppal->cEntries, "ERROR GDI ulTranslateIndex1");
ASSERTGDI(ppal->ptransCurrent != (PTRANSLATE) NULL, "ERROR GDI ulTranslateIndex2");
return((ULONG) ppal->ptransCurrent->ajVector[ulIndex]);
}
//
// This returns the index in the surface palette an index in the dc
// palette maps to. It assumes you checked for a valid ptrans and a
// valid index range.
//
ULONG ulTranslateDCtoFore(ULONG ulIndex)
{
ASSERTGDI(ppal->flPal & PAL_DC, "ERROR GDI ulTranslateIndex1");
ASSERTGDI(ulIndex < ppal->cEntries, "ERROR GDI ulTranslateIndex11");
ASSERTGDI(ppal->ptransFore != (PTRANSLATE) NULL, "ERROR GDI ulTranslateIndex21");
return((ULONG) ppal->ptransFore->ajVector[ulIndex]);
}
//
// For a palette managed DC this is the hdev the palette is selected into.
//
HDEV hdev()
{
ASSERTGDI(ppal->flPal & PAL_DC, "ERROR hdev() passed invalid palette type\n");
return(ppal->hSelected.hdev);
}
VOID hdev(HDEV hdev)
{
ASSERTGDI(ppal->flPal & PAL_DC, "ERROR hdev() 1passed invalid palette type\n");
ppal->hSelected.hdev = hdev;
}
BOOL bSet_hdev(HDEV hdev);
VOID vInc_cRef()
{
ASSERTGDI(ppal->flPal & PAL_DC, "vInc_cRef() passed invalid palette type\n");
InterlockedIncrement((PLONG) &(ppal->cRefhpal));
}
VOID vDec_cRef()
{
ASSERTGDI(ppal->flPal & PAL_DC, "vDec_cRef() passed invalid palette type\n");
ASSERTGDI(ppal->cRefhpal != 0, "cRefhpal == 0 in vDec Palette");
InterlockedDecrement((PLONG) &(ppal->cRefhpal));
}
// These are the surface palette functions - PALOBJS
BOOL bIsPalFixed() { return(ppal->flPal & PAL_FIXED); }
BOOL bIsPalManaged() { return(ppal->flPal & PAL_MANAGED); }
BOOL bIsPalFree() { return(ppal->flPal & PAL_FREE); }
BOOL bIsMonochrome() { return((ppal != NULL) && (ppal->flPal & PAL_MONOCHROME)); }
VOID vCopy_rgbquad(RGBQUAD *prgbquad, ULONG iStart, ULONG cEntries);
VOID vCopy_cmykquad(ULONG *pcmykquad, ULONG iStart, ULONG cEntries);
ULONG ulGetExactIndexFromPalentry(PAL_ULONG Color);
PTRANSLATE ptransMapIn(XEPALOBJ palDC, BOOL bForeground, ULONG *pulUsedChanged, ULONG *pulUnUsedChanged);
BOOL bJamItIn(XEPALOBJ palDC, BOOL bForeground, BOOL *pulUsedChanged, BOOL *pulUnUsedEntriesChanged);
ULONG ulRealizeOnFree(XEPALOBJ palDC);
VOID ulNumReserved(ULONG ulTemp)
{
ASSERTGDI(!(ppal->flPal & PAL_DC), "ERROR ulNumReserved called on PAL_DC1\n");
ASSERTGDI(ulTemp < ppal->cEntries, "ERROR saving too large free index \n");
ppal->cRefRegular = ulTemp;
}
ULONG cColorTableLength() {
ASSERTGDI(!(ppal->flPal & PAL_DC), "ERROR cColorTableLength called on PAL_DC1\n");
return ppal->cRefRegular;
}
VOID cColorTableLength(ULONG ulLength) {
ASSERTGDI(!(ppal->flPal & PAL_DC), "ERROR cColorTableLength called on PAL_DC1\n");
ppal->cRefRegular = ulLength;
}
ULONG ulNumReserved()
{
ASSERTGDI(!(ppal->flPal & PAL_DC), "ERROR ulNumReserved called on PAL_DC\n");
ASSERTGDI(ppal->cRefRegular <= (ppal->cEntries - 1), "ERROR retrieving out of bounds free index \n");
ASSERTGDI(ppal->cRefRegular >= 1, "ERROR ulNumReserved too small\n");
return(ppal->cRefRegular);
}
BOOL bIsNoStatic()
{
return(ppal->flPal & PAL_NOSTATIC);
}
BOOL bIsNoStatic256()
{
return(ppal->flPal & PAL_NOSTATIC256);
}
VOID vSetNoStatic()
{
ppal->flPal = (ppal->flPal | PAL_NOSTATIC) & ~PAL_NOSTATIC256;
}
VOID vSetNoStatic256()
{
ppal->flPal = (ppal->flPal | PAL_NOSTATIC256) & ~PAL_NOSTATIC;
}
VOID vMakeNoXlate();
PPALETTE ppalOriginal()
{
ASSERTGDI(ppal->flPal & PAL_MANAGED, "ERROR hpalOriginal() passed invalid palette type\n");
return(ppal->hSelected.ppal);
}
VOID ppalOriginal(PPALETTE ppalNew)
{
ASSERTGDI(ppal->flPal & PAL_MANAGED, "ERROR hpalOriginal() 1passed invalid palette type\n");
ppal->hSelected.ppal = ppalNew;
}
VOID vCopyEntriesFrom(XEPALOBJ palSrc)
{
RtlCopyMemory(apalColorGet(),
palSrc.apalColorGet(),
(UINT) (MIN(palSrc.cEntries(), cEntries())) * sizeof(PAL_ULONG));
}
VOID vFill_rgbquads(RGBQUAD *prgb, ULONG iStart, ULONG cEntries);
VOID vFill_triples(RGBTRIPLE *prgb, ULONG iStart, ULONG cEntries);
VOID vAddToList(XDCOBJ& dco);
VOID vRemoveFromList(XDCOBJ& dco);
VOID vGetEntriesFrom(XEPALOBJ palDC, XEPALOBJ palSurf, PUSHORT pusIndices, ULONG cEntry);
BOOL bEqualEntries(XEPALOBJ pal);
BOOL bGenColorXlate555();
PRGB555XLATE pGetRGBXlate();
BYTE Xlate555(BYTE r,BYTE g, BYTE b)
{
return(ppal->pRGBXlate[
((r & 0xf8) << 7) ||
((g & 0xf8) << 2) ||
((b & 0xf8) >> 3)]);
}
//
// ICM: GammaCorrection stuff for 8bpp surface
//
BOOL bNeedGammaCorrection() { return(ppal->flPal & PAL_GAMMACORRECT); }
BOOL bNeedGammaCorrection(BOOL b) { SETFLAG(b,ppal->flPal,PAL_GAMMACORRECT);return (b); }
VOID CorrectColors(PPALETTEENTRY ppalentry, ULONG cEntries);
HDEV hdevOwner() { return(ppal->hdevOwner); }
HDEV hdevOwner(HDEV hdev_) { ppal->hdevOwner = hdev_;return(hdev_); }
};
/*********************************Class************************************\
* class EPALOBJ : public XEPALOBJ
*
* Used for creating a user object from a pointer to the object.
*
* History:
* Wed 28-Aug-1991 -by- Patrick Haluptzok [patrickh]
* Wrote it.
\**************************************************************************/
class EPALOBJ : public XEPALOBJ /* palo */
{
public:
EPALOBJ() {ppal = (PPALETTE) NULL; }
EPALOBJ(HPALETTE hpal) {ppal = (PPALETTE) HmgShareCheckLock((HOBJ)hpal, PAL_TYPE);}
~EPALOBJ()
{
if (ppal != (PPALETTE) NULL)
{
DEC_SHARE_REF_CNT(ppal);
}
}
};
/******************************Public*Class********************************\
* class PALMEMOBJ
*
* Palette Memory Object
*
* History:
* 07-Nov-1990 -by- Patrick Haluptzok patrickh
* Wrote it.
\**************************************************************************/
class PALMEMOBJ : public XEPALOBJ /* epalmo */
{
private:
BOOL bKeep;
public:
PALMEMOBJ() {bKeep = FALSE; ppal = (PPALETTE) NULL;}
BOOL bCreatePalette(ULONG iMode, ULONG cColors, ULONG *pulColors,
FLONG flRed, FLONG flGreen, FLONG flBlue,
ULONG iType);
BOOL bCreateHTPalette(LONG iFormatHT, GDIINFO *pGdiInfo);
~PALMEMOBJ();
VOID vKeepIt() { bKeep = TRUE; }
};
// structure for entry in the xlate cache.
typedef struct _XLATETABLE
{
ULONG ulReference; // How many people are currently using it.
PXLATE pxlate;
ULONG ulPalSrc; // palette src time when xlate created
ULONG ulPalDst; // palette dst time when xlate created
ULONG ulPalSrcDC; // palette src DC time when xlate created
ULONG ulPalDstDC; // palette dst DC time when xlate created
} XLATETABLE;
extern XLATETABLE xlateTable[XLATE_CACHE_SIZE];
extern ULONG ulTableIndex;
#endif // GDIFLAGS_ONLY used for gdikdx
// This signifies the xlate wasn't put in the cache. The destructor
// checks for this and deletes it if it's not in the cache.
#define XLATE_CACHE_JOURNAL -2
#define XLATE_CACHE_INVALID -1
// This describes the overall logic of surface to surface xlates.
// There are basically n types of xlates to worry about:
//
// 1. XO_TRIVIAL - no translation occurs, identity.
//
// 2. XO_TABLE - look up in a table for the correct table translation.
//
// a. XO_TO_MONO - look in to table for the correct tranlation,
// but when getting it out of the cache make sure iBackSrc is the
// same. iBackSrc goes to 1, everything else to 0.
// b. XLATE_FROM_MONO - look into table for the correct translation
// but when getting it out of the cache make sure iBackDst and
// iForeDst are both still valid. 1 goes to iBackDst, 0 to iForeDst.
// c. just plain jane indexed to indexed or rgb translation.
//
// 3. XO_RGB_SRC - Have to call XLATEOBJ_iXlate to get it translated.
//
// a. XO_TO_MONO - we have saved the iBackColor in ai[0]
// b. just plain jane RGB to indexed. Grab the RGB, find the closest
// match in Dst palette. Lot's of work.
//
// 4. XO_RGB_BOTH - Bit mashing time. Call XLATEOBJ_iXlate
//
// The code is written to quickly recognize the XO_TRIVIAL case, efficiently
// compute and cache the translate table for the type XO_TABLE case, and
// do the correct, expensive work required for cases 3 and 4.
// #define XO_TRIVIAL 0x00000001
// #define XO_TABLE 0x00000002
// #define XO_TO_MONO 0x00000004
// #define XO_FROM_CMYK 0x00000008
// #define XO_DEVICE_ICM 0x00000010
// #define XO_HOST_ICM 0x00000020
#define XLATE_FROM_MONO 0x00000100
#define XLATE_RGB_SRC 0x00000200
#define XLATE_RGB_BOTH 0x00000400
#define XLATE_PAL_MANAGED 0x00000800
#define XLATE_USE_CURRENT 0x00001000
#define XLATE_USE_SURFACE_PAL 0x00002000 // Only used with MultiMonitor system
#define XLATE_USE_FOREGROUND 0x00004000 // Only used with MultiMonitor system
#ifndef GDIFLAGS_ONLY // used for gdikdx
extern "C" ULONG XLATEOBJ_iXlate(XLATEOBJ *pxo, ULONG cIndex);
PXLATE
CreateXlateObject(
HANDLE hcmXform,
LONG lIcmMode,
XEPALOBJ palSrc,
XEPALOBJ palDst,
XEPALOBJ palSrcDC,
XEPALOBJ palDstDC,
ULONG iForeDst,
ULONG iBackDst,
ULONG iBackSrc,
ULONG flCreate
);
PXLATE
pCreateXlate(
ULONG ulNumEntries
);
/*********************************Class************************************\
* EXLATEOBJ
*
* This is the user object for a palette translation table.
*
* History:
* Wed 09-Mar-1994 -by- Patrick Haluptzok [patrickh]
* Get rid of stack object, clean up.
*
* Sun 05-May-1991 -by- Patrick Haluptzok [patrickh]
* add new DDI changes to code, deja vu.
*
* Mon 04-Feb-1991 -by- Patrick Haluptzok [patrickh]
* add DDI changes to code.
*
* Mon 03-Dec-1990 -by- Patrick Haluptzok [patrickh]
* wrote the first pass for NT.
\**************************************************************************/
class EXLATEOBJ
{
protected:
XLATE *pxlate;
public:
EXLATEOBJ() { pxlate = (PXLATE) NULL; }
EXLATEOBJ(PXLATE pxlateNew) { pxlate = pxlateNew; }
~EXLATEOBJ() { vAltUnlock(); }
BOOL bValid() { return(pxlate != (PXLATE) NULL); }
XLATE *pxlo() { return(pxlate); }
VOID vMakeIdentity() { pxlate = &xloIdent; }
PXLATE pInitXlate(PXLATE pxlateN)
{
return(pxlate = pxlateN);
}
PXLATE pCreateXlateObject(ULONG ul)
{
return(pxlate = pCreateXlate(ul));
}
PXLATE pInitXlateNoCache(
HANDLE hcmXform,
LONG lIcmMode,
XEPALOBJ palSrc,
XEPALOBJ palDst,
XEPALOBJ palDstDC,
ULONG iForeDst, // For Mono->Color 0 goes to it
ULONG iBackDst, // For Mono->Color 1 goes to it
ULONG iBackSrc, // For Color->Mono index goes to 1
ULONG flCreate = 0) // Used for Multi-Monitor System
{
//
// Cache ignorant initializer for Xlates. Good for short lived palettes.
//
return(pxlate = CreateXlateObject(
hcmXform,
lIcmMode,
palSrc,
palDst,
palDstDC,
palDstDC,
iForeDst,
iBackDst,
iBackSrc,
flCreate
)
);
}
ULONG iBackSrc() { return(pxlate->iBackSrc); }
ULONG iForeDst() { return(pxlate->iForeDst); }
ULONG iBackDst() { return(pxlate->iBackDst); }
PPALETTE ppalSrc() { return(pxlate->ppalSrc); }
PPALETTE ppalDst() { return(pxlate->ppalDst); }
PPALETTE ppalDstDC() { return(pxlate->ppalDstDC);}
VOID vAltLock(PXLATE pxlateN) { pxlate = (PXLATE) pxlateN;}
VOID vAltUnlock()
{
if (pxlate != (PXLATE) NULL)
{
if (pxlate->lCacheIndex >= 0)
{
//
// It's in the cache
//
ASSERTGDI(pxlate->lCacheIndex < XLATE_CACHE_SIZE, "ERROR not a cache index");
ASSERTGDI(xlateTable[pxlate->lCacheIndex].ulReference != 0, "ERROR xlateindex too small");
InterlockedDecrement((LPLONG) &(xlateTable[pxlate->lCacheIndex].ulReference));
}
else if (pxlate->lCacheIndex == XLATE_CACHE_INVALID)
{
VFREEMEM(pxlate);
}
#if DBG
else
{
ASSERTGDI(pxlate->lCacheIndex == XLATE_CACHE_JOURNAL, "ERROR cacheIndex not valid");
}
#endif
}
}
BOOL bMakeXlate(PUSHORT,XEPALOBJ,SURFACE*,ULONG,ULONG);
BOOL bInitXlateObj(HANDLE hcmXform,
LONG lIcmMode,
XEPALOBJ palSrc,
XEPALOBJ palDst,
XEPALOBJ palSrcDC,
XEPALOBJ palDstDC,
ULONG iForeDst, // For Mono->Color 0 goes to it
ULONG iBackDst, // For Mono->Color 1 goes to it
ULONG iBackSrc, // For Color->Mono index goes to 1
ULONG flCreate = 0); // Used for Multi-Monitor System
VOID vAddToCache(XEPALOBJ palSrc,
XEPALOBJ palDest,
XEPALOBJ palSrcDC,
XEPALOBJ palDestDC);
BOOL bSearchCache(XEPALOBJ palSrc,
XEPALOBJ palDst,
XEPALOBJ palSrcDC,
XEPALOBJ palDstDC,
ULONG iForeDst,
ULONG iBackDst,
ULONG iBackSrc,
ULONG flCreate);
BOOL bCreateXlateFromTable(ULONG cEntries, PULONG pIndices, XEPALOBJ palDst);
VOID vDelete();
};
PBYTE
XLATEOBJ_pGetXlate555(
XLATEOBJ *pxlo
);
BYTE
XLATEOBJ_ulIndexToPalSurf(
XLATEOBJ *,
PBYTE,
ULONG
);
BYTE
XLATEOBJ_RGB32ToPalSurf(
XLATEOBJ *,
PBYTE,
ULONG
);
BYTE
XLATEOBJ_BGR32ToPalSurf(
XLATEOBJ *,
PBYTE,
ULONG
);
BYTE
XLATEOBJ_RGB16_565ToPalSurf(
XLATEOBJ *,
PBYTE,
ULONG
);
BYTE
XLATEOBJ_RGB16_555ToPalSurf(
XLATEOBJ *,
PBYTE,
ULONG
);
typedef BYTE (*PFN_XLATE_RGB_TO_PALETTE)(XLATEOBJ *,PBYTE,ULONG);
/******************************Public*Class********************************\
* class XLATEMEMOBJ
*
* Xlate Memory Object
*
* History:
* 07-Nov-1990 -by- Patrick Haluptzok patrickh
* Wrote it.
\**************************************************************************/
class XLATEMEMOBJ : public EXLATEOBJ /* xlmo */
{
public:
XLATEMEMOBJ(XEPALOBJ palSurf, XEPALOBJ palDC);
~XLATEMEMOBJ();
};
//
// Prototypes for internal functions used in palette management.
//
BOOL
bDeletePalette(
HPAL hpal,
BOOL bCleanup = FALSE,
CLEANUPTYPE cutype = CLEANUP_NONE
);
ULONG
rgbFromColorref(
XEPALOBJ palSurf,
XEPALOBJ palDC,
ULONG crColor
);
ULONG
ulGetNearestIndexFromColorref(
XEPALOBJ palSurf,
XEPALOBJ palDC,
ULONG crColor,
ULONG seSearchExactFirst = SE_DO_SEARCH_EXACT_FIRST
);
ULONG
ulGetMatchingIndexFromColorref(
XEPALOBJ palSurf,
XEPALOBJ palDC,
ULONG crColor
);
ULONG
ulIndexToRGB(
XEPALOBJ palSrc,
XEPALOBJ palDC,
ULONG iSolidColor
);
ULONG
ulColorRefToRGB(
XEPALOBJ palSrc,
XEPALOBJ palDC,
ULONG iSolidColor
);
BOOL
bIsCompatible(
PPALETTE *pppalReference,
PPALETTE ppalBM,
SURFACE *pSurfBM,
HDEV hdev
);
VOID
vDeleteXLATEOBJ(
PXLATE pxlate
);
BOOL
CreateSurfacePal(
XEPALOBJ palSrc,
FLONG iPalType,
ULONG ulNumReserved,
ULONG ulNumPalReg
);
VOID
ParseBits(
FLONG flag,
ULONG *pcRight,
ULONG *pcLeft,
ULONG *pcMiddle,
ULONG cForColor
);
VOID
vMatchAPal(
PDC pdc,
XEPALOBJ palSurf,
XEPALOBJ palDC,
ULONG *pulnPhysChanged,
ULONG *pulnTransChanged
);
PTRANSLATE
ptransMatchAPal(
PDC pdc,
XEPALOBJ palSurf,
XEPALOBJ palDC,
BOOL bForeground,
ULONG *pulnPhysChanged,
ULONG *pulnTransChanged
);
BOOL
bEqualRGB_In_Palette(
XEPALOBJ,
XEPALOBJ
);
PPALETTE
CreatePhysicalPalette(
HDC hdc,
HPALETTE hpal
);
PPALETTE
ppalGetPPal(
HDC hdc,
HPALETTE hpal
);
VOID
vResetSurfacePalette(
HDEV hdev
);
//
// asm accelerator for ulGetNearestPalentry
//
extern "C" {
PPALETTEENTRY
ppalSearchNearestEntry(
PPALETTEENTRY ppalTemp,
CONST PALETTEENTRY palentry,
ULONG cEntries,
PUINT pArrayOfSquares
);
}
PPALETTE
ppalGet_ip(
XEPALOBJ,
HANDLE,
PPDEV
);
#endif
#endif // GDIFLAGS_ONLY used for gdikdx