HANDLE      hcmXform,
LONG        lIcmMode,
XEPALOBJ    palSrc,
XEPALOBJ    palDestSurf,
XEPALOBJ    palSrcDC,
XEPALOBJ    palDestDC,
ULONG       iForeDst,
ULONG       iBackDst,
ULONG       iBackSrc,
ULONG       flCreateFlag

/*

Allocates an xlate and sets it up.

Arguments:

palSrc        - src surface palette
palDestSurf   - dst surface palette
palSrcDC      - src DC palette
palDestDC     - dst DC palette
iForeDst      - For Mono->Color this is
                what a 0 goes to
iBackDst      - For Mono->Color this is
                what a 1 goes to
iBackSrc      - For Color->Mono this is
                the color that goes to 1,
                all other colors go to 0.

History:

02-May-1991 -by- ...

*/

ASSERTGDI(

palDestDC.bValid(),
"CreateXlateObject recieved bad ppalDstDC,
bug in GDI"

);

ASSERTGDI(

palSrc.bValid() || palDestSurf.bValid(),
"CreateXlaetObject recieved bad ppalSrc,
bug in GDI"

);

ASSERTGDI(

palSrc.ppalGet() != palDestSurf.ppalGet(),
"Didn't recognize ident quickly"

);

ULONG ulTemp;

- no c code -

// cEntry == 0 means the source palette is an
// RGB/Bitfields type.
// An invalid palette means it's a compatible
// bitmap on a palette managed device.
ULONG cEntry = (

palSrc.bValid() ? palSrc.cEntries() : 256

);
// bug: Some of the following code paths assume,
// that they can write up to 256 entries.
// If this is not the case, we have a buffer overrun.

// cEntry == 0 means the source palette is an
// RGB/Bitfields type.
// An invalid palette means it's a compatible
// bitmap on a palette managed device.
ULONG cEntry = 256;

// cEntry == 0 means the source palette is an
// RGB/Bitfields type.
// An invalid palette means it's a compatible
// bitmap on a palette managed device.
ULONG cEntry = (

palSrc.bValid() ? palSrc.cEntries() : 256

);

// cEntry == 0 means the source palette is an
// RGB/Bitfields type.
// An invalid palette means it's a compatible
// bitmap on a palette managed device.
ULONG cEntry = (

palSrc.bValid() ? palSrc.cEntries() : 256

);
// bug: Some of the following code paths assume,
// that they can write up to 256 entries.
// If this is not the case, we have a buffer overrun.

// Allocate room for the structure.
PXLATE pxlate = pCreateXlate(cEntry);

...

// Ok, lets build the translate vector.
if(

!palSrc.bValid() || (

palSrc.bIsPalManaged() && (

ptransFore == ptransCurrent ||
flCreateFlag & XLATE_USE_FOREGROUND

)

)

){

// bug related note: In this code branch palSrc
// might be valid and cEntry might be smaller
// than 256|d.

...

// The source is a compatible bitmap on a
// palette managed device or the screen
// with Dst DC palette having been realized
// in the foreground.
//
// We start out assuming an identity blt.
// This means, that the color translation
// is:
//    color on dest. surface = color of src. surf.

...

ASSERTGDI(

cEntry == 256,
"ERROR xlate too small"

);

// bug related note: This is a code snippet,
// where a buffer overrun might happen.
for(

ulTemp = 0;
ulTemp < 256;
ulTemp++

){

pxlate->ai[ulTemp] = ulTemp;

}

for(

ulTemp = 0;
ulTemp < cEntry;
ulTemp++

){

pxlate->ai[ulTemp] = ulTemp;

}

// bug related note: This is a code snippet,
// where a buffer overrun might happen.
for(

ulTemp = 0;
ulTemp < 256;
ulTemp++

){

pxlate->ai[ulTemp] = ulTemp;

}

if(!palDestSurf.bValid()){

// Compatible bitmap to compatible bitmap
// on palette managed device. Both are
// relevant to the foreground realize of
// the DestDC palette so the xlate is
// identity.
...

}else if(

palDestSurf.bIsPalDibsection() &&
bEqualRGB_In_Palette(

palDestSurf,
palDestDC

)

){

// If you blt from a compatible bitmap to a
// DIBSECTION it will be identity if the
// RGB's of both the DC palette and the
// DIBSECTION's palette are the same. We do
// this special check so that if they
// contain duplicates we still get an
// identity xlate.
...

}else if(

palDestSurf.bIsPalDibsection() &&
palSrc.bValid() &&
bEqualRGB_In_Palette(

palDestSurf,
palSrc

)

){

...

}else if(palDestSurf.bIsPalManaged()){

// Compatible bitmap to the screen on a
// palette managed device. The compatible
// bitmaps colors are defined as the
// foreground realization of the
// destination DC's palette.
//
// If the Dst DC's palette is realized in
// the foreground it's identity.
//
// Otherwise we translate from the current
// to the foreground indices.

if(ptransCurrent == ptransFore){

// It's in the foreground or not
// realized yet so it's identity.

// Not realized case also hits on
// default logical palette.
...

}else{

// It's foreground to current
// translation.

ASSERTGDI(

ptransFore != ptransCurrent,
"Should have been identity,
never get here"

);

ASSERTGDI(

ptransFore,
"ERROR this should not have
got here Fore"

);

ASSERTGDI(

ptransCurrent,
"ERROR this should not have
got here Current"

);

// bug related note: This is a code
// snippet, where a buffer overrun
// might happen.
for(

ulTemp = 0;
ulTemp < palDestDC.cEntries();
ulTemp++

){

pxlate->ai[

ptransFore->ajVector[

ulTemp

]

] = (ULONG)(

ptransCurrent->ajVector[

ulTemp

]

);

}

for(

ulTemp = 0;
ulTemp < min(

palDestDC.cEntries(),
cEntry

);
ulTemp++

){

pxlate->ai[

ptransFore->ajVector[

ulTemp

]

] = (ULONG)(

ptransCurrent->ajVector[

ulTemp

]

);

}

// eax = palDestDC.cEntries()
000E24FB|mov eax, dword ptr [edi+14]

// if: eax <= cEntry
// then: jump to: end of the min block
000E24FE|cmp eax, [ebp-4]
000E2501|jbe 000E2506

// eax = cEntry
000E2503|mov eax, [ebp-4]

// 000E2506|- end of the min block -

// bug related note: This is a code
// snippet, where a buffer overrun
// might happen.
for(

ulTemp = 0;
ulTemp < palDestDC.cEntries();
ulTemp++

){

pxlate->ai[

ptransFore->ajVector[

ulTemp

]

] = (ULONG)(

ptransCurrent->ajVector[

ulTemp

]

);

}

// Now map the default colors that
// are really there, independent of
// logical palette.
if(palDestSurf.bIsNoStatic()){

// bug related note: This is a
// code snippet, where a buffer
// overrun might happen.

// Only black and white are
// here.
pxlate->ai[0] = 0;
pxlate->ai[255] = 255;

// Only black and white are
// here.
pxlate->ai[0] = 0;
pxlate->ai[cEntry - 1] = 255;

// bug related note: This is a
// code snippet, where a buffer
// overrun might happen.

// Only black and white are
// here.
pxlate->ai[0] = 0;
pxlate->ai[255] = 255;

}else if(

!palDestSurf.bIsNoStatic256()

){

// All the 20 holy colors are here.
// Fix them up.
for(

ulTemp = 0;
ulTemp < 10;
ulTemp++

){

pxlate->ai[

ulTemp

] = ulTemp;

// bug related note: This
// is a code snippet,
// where a buffer overrun
// might happen.
pxlate->ai[

ulTemp + 246

] = ulTemp + 246;

}

// Some of the default/10 + 10 holy
// colors are here. Fix what exists.
for(

ulTemp = 0;
ulTemp < 256;
ulTemp++

){

if(ulTemp == 10){

// One small step for the CPU,
// but one giant leap for the
// loop.
ulTemp = 246;

}

if(ulTemp >= cEntry){

break;

}

pxlate->ai[

ulTemp

] = ulTemp;

}

// All the 20 holy colors are here.
// Fix them up.
for(

ulTemp = 0;
ulTemp < 10;
ulTemp++

){

pxlate->ai[

ulTemp

] = ulTemp;

// bug related note: This
// is a code snippet,
// where a buffer overrun
// might happen.
pxlate->ai[

ulTemp + 246

] = ulTemp + 246;

}

}

}

}else if(palDestSurf.bIsMonochrome()){

// bug related note: This is a code snippet,
// where a buffer overrun might happen.
RtlZeroMemory(

pxlate->ai,
256 * sizeof(ULONG)

);

RtlZeroMemory(

pxlate->ai,
cEntry * sizeof(ULONG)

);

// bug related note: This is a code snippet,
// where a buffer overrun might happen.
RtlZeroMemory(

pxlate->ai,
256 * sizeof(ULONG)

);

ulTemp = ulGetNearestIndexFromColorref(

palSrc,
palSrcDC,
iBackSrc,
1

);

// check if it's ">=",
// not ">" like the string says
ASSERTGDI(

ulTemp < 256,
"ERROR palSrc invalid -
ulGetNearest is > 256"

);

pxlate->vSetIndex(

ulTemp,
1

);

...

}else{

// Blting from palette-managed bitmap to
// non-palette managed surface.
//
// Do all the non-default colors that are
// realized.

// If the dest is 256 entries we will just
// leave the identity xlate as the initial
// state.
if(palDestSurf.cEntries() != 256){

// If the dest has the same number of
// entries like cEntry is set, then we
// will just leave the identity xlate as
// the initial state.
if(palDestSurf.cEntries() != cEntry){

// If the dest is 256 entries we will just
// leave the identity xlate as the initial
// state.
if(palDestSurf.cEntries() != 256){

// Otherwise we 0 it out so we don't
// have a translation index left
// that's potentially bigger than the
// destination palette.

// bug related note: This is a code
// snippet, where a buffer overrun
// might happen.
RtlZeroMemory(

pxlate->ai,
256 * sizeof(ULONG)

);

}

// Otherwise we 0 it out so we don't
// have a translation index left
// that's potentially bigger than the
// destination palette.
RtlZeroMemory(

pxlate->ai,
cEntry * sizeof(ULONG)

);

}

// Otherwise we 0 it out so we don't
// have a translation index left
// that's potentially bigger than the
// destination palette.

// bug related note: This is a code
// snippet, where a buffer overrun
// might happen.
RtlZeroMemory(

pxlate->ai,
256 * sizeof(ULONG)

);

}

// We need to fill in where the default
// colors map.
for(

ulTemp = 0;
ulTemp < 10;
ulTemp++

){

pxlate->ai[ulTemp] = (

palDestSurf.ulGet­Nearest­From­Palentry(

logDefaultPal.palPalEntry[

ulTemp

]

)

);

// bug related note: This is a code
// snippet, where a buffer overrun might
// happen.
pxlate->ai[ulTemp + 246] = (

palDestSurf.ulGet­Nearest­From­Palentry(

logDefaultPal.palPalEntry[

ulTemp+10

]

)

);

}

// We need to fill in where the
// default/10 + 10 holy colors map.
for(

ulTemp = 0;
ulTemp < 256|d;
ulTemp++

){

if(ulTemp == 10|d){

ulTemp = 246|d;

}

if(ulTemp >= cEntry){

break;

}

if(ulTemp < 10|d){

temp = logDefaultPal.palPalEntry[

ulTemp

];

}else{

temp = logDefaultPal.palPalEntry[

  ulTemp
- 246|d
+ 10|d

]

}

temp = (

palDestSurf.ulGet­Nearest­From­Palentry(

temp

)

);

pxlate->ai[ulTemp] = temp;

}

// We need to fill in where the default
// colors map.
for(

ulTemp = 0;
ulTemp < 10;
ulTemp++

){

pxlate->ai[ulTemp] = (

palDestSurf.ulGet­Nearest­From­Palentry(

logDefaultPal.palPalEntry[

ulTemp

]

)

);

// bug related note: This is a code
// snippet, where a buffer overrun might
// happen.
pxlate->ai[ulTemp + 246] = (

palDestSurf.ulGet­Nearest­From­Palentry(

logDefaultPal.palPalEntry[

ulTemp+10

]

)

);

}

if(flCreateFlag & XLATE_USE_SURFACE_PAL){

// Map directly to destination
// surface palette from source
// surface palette.
for(

ulTemp = 0;
ulTemp < palSrc.cEntries();
ulTemp++

){

pxlate->ai[

ulTemp

] = palDestSurf.ulGet­Nearest­From­Palentry(

palSrc.palentryGet(

ulTemp

)

);

}

...

}else{

// Go through DC palette and then map to
// destination surface palette.

if(ptransFore){

// bug related note: This is a code
// snippet, where a buffer overrun
// might happen.

for(

ulTemp = 0;
ulTemp < palDestDC.cEntries();
ulTemp++

){

pxlate->ai[

ptransFore->ajVector[ulTemp]

] = palDestSurf.ulGet­Nearest­From­Palentry(

palDestDC.palentryGet(ulTemp)

);

}

}

}

}

for(

ulTemp = 0;
ulTemp < min(

palDestDC.cEntries(),
cEntry

);
ulTemp++

){

pxlate->ai[

ptransFore->ajVector[ulTemp]

] = palDestSurf.ulGet­Nearest­From­Palentry(

palDestDC.palentryGet(ulTemp)

);

}

}

}

}

// edi = palDestDC.cEntries()
000E2648|mov edi, dword ptr [edi+14]

// if: palDestDC.cEntries() <= cEntry
// then: jump to: end of the min block
000E264B|cmp edi, [ebp-4]
000E264E|jbe 000E2653

// edi = cEntry
000E2650|mov edi, [ebp-4]

// 000E2653|- end of the min block -

// bug related note: This is a code
// snippet, where a buffer overrun
// might happen.

for(

ulTemp = 0;
ulTemp < palDestDC.cEntries();
ulTemp++

){

pxlate->ai[

ptransFore->ajVector[ulTemp]

] = palDestSurf.ulGet­Nearest­From­Palentry(

palDestDC.palentryGet(ulTemp)

);

}

}

}

}

}else if(

palSrc.bIsPalDibsection() && (

(

palDestSurf.bValid() &&
palDestSurf.bIsPalDibsection() &&
bEqualRGB_In_Palette(

palSrc,
palDestSurf

)

) || (

(

!palDestSurf.bValid() || (

palDestSurf.bIsPalManaged() &&
ptransFore == ptransCurrent

)

) && bEqualRGB_In_Palette(

palSrc,
palDestDC

)

)

)

){

// Blting from a Dibsection &&
// ((To another Dibsection with ident palette) ||
//  (((To a compatible palette managed bitmap) ||
//    (To a palette managed screen with the DstDc's
//     logical palette realized in the foreground)) &&
//   (the dst logical palette == Dibsection's palette)
// ))
//
// This is identity. We do this special check so even
// if there are duplicate colors in the palette we
// still get identity.

// bug related note: This is a code snippet, where a
// buffer overrun might happen.
for(

ulTemp = 0;
ulTemp < 256;
ulTemp++

){

pxlate->ai[ulTemp] = ulTemp;

}

...

// Blting from a Dibsection &&
// ((To another Dibsection with ident palette) ||
// (((To a compatible palette managed bitmap) ||
// (To a palette managed screen with the DstDc's
// logical palette realized in the foreground)) &&
// (the dst logical palette == Dibsection's palette)
// ))
//
// This is identity. We do this special check so even
// if there are duplicate colors in the palette we
// still get identity.
for(

ulTemp = 0;
ulTemp < cEntry;
ulTemp++

){

pxlate->ai[ulTemp] = ulTemp;

}

...

// Blting from a Dibsection &&
// ((To another Dibsection with ident palette) ||
// (((To a compatible palette managed bitmap) ||
// (To a palette managed screen with the DstDc's
// logical palette realized in the foreground)) &&
// (the dst logical palette == Dibsection's palette)
// ))
//
// This is identity. We do this special check so even
// if there are duplicate colors in the palette we
// still get identity.

// bug related note: This is a code snippet, where a
// buffer overrun might happen.
for(

ulTemp = 0;
ulTemp < 256;
ulTemp++

){

pxlate->ai[ulTemp] = ulTemp;

}

...

}else if(

palSrc.bIsPalManaged() &&
!palDestSurf.bValid()

){

// We are blting from the screen to a compatible
// bitmap on a palette managed device where the
// screen is realized in the background.

// Make it identity by default.

// bug related note: This is a code snippet,
// where a buffer overrun might happen.
for(

ulTemp = 0;
ulTemp < 256;
ulTemp++

){

pxlate->ai[ulTemp] = ulTemp;

}

// We are blting from the screen to a compatible
// bitmap on a palette managed device where the
// screen is realized in the background.

// Make it identity by default.
for(

ulTemp = 0;
ulTemp < cEntry;
ulTemp++

){

pxlate->ai[ulTemp] = ulTemp;

}

// We are blting from the screen to a compatible
// bitmap on a palette managed device where the
// screen is realized in the background.

// Make it identity by default.

// bug related note: This is a code snippet,
// where a buffer overrun might happen.
for(

ulTemp = 0;
ulTemp < 256;
ulTemp++

){

pxlate->ai[ulTemp] = ulTemp;

}

// We are blting background to foreground.
// i.e. we are blting current realize to
// foreground realize.

ASSERTGDI(

pxlate->cEntries == 256,
"ERROR xlate too small"

);

ASSERTGDI(

ptransFore != ptransCurrent,
"Should have been identity, never get here"

);

ASSERTGDI(

ptransFore != NULL,
"ERROR this should not have got here Fore"

);

ASSERTGDI(

ptransCurrent != NULL,
"ERROR this should not have got here Current"

);

// bug related note: This is a code
// snippet, where a buffer overrun
// might happen.
for(

ulTemp = 0;
ulTemp < palDestDC.cEntries();
ulTemp++

){

pxlate->ai[

ptransCurrent->ajVector[ulTemp]

] = ptransFore->ajVector[ulTemp];

}

// bug related note: This is a code
// snippet, where a buffer overrun
// might happen.
for(

ulTemp = 0;
ulTemp < min(

palDestDC.cEntries(),
cEntry

);
ulTemp++

){

pxlate->ai[

ptransCurrent->ajVector[ulTemp]

] = ptransFore->ajVector[ulTemp];

}

// eax = palDestDC.cEntries()
000E22C2|mov eax, dword ptr [edi+14]

// if: eax <= cEntry
// then: jump to: end of the min block
000E22C5|cmp eax, [ebp-4]
000E22C8|jbe 000E22CD

// eax = cEntry
000E22CA|mov eax, [ebp-4]

// 000E22CD|- end of the min block -

// bug related note: This is a code
// snippet, where a buffer overrun
// might happen.
for(

ulTemp = 0;
ulTemp < palDestDC.cEntries();
ulTemp++

){

pxlate->ai[

ptransCurrent->ajVector[ulTemp]

] = ptransFore->ajVector[ulTemp];

}

// Now map the default colors that
// are really there, independent of
// logical palette realization.
if(palSrc.bIsNoStatic()){

// bug related note: This is a
// code snippet, where a buffer
// overrun might happen.

// Only black and white are
// here.
pxlate->ai[0] = 0;
pxlate->ai[255] = 255;

// Only black and white are
// here.
pxlate->ai[0] = 0;
pxlate->ai[cEntry - 1] = 255;

// bug related note: This is a
// code snippet, where a buffer
// overrun might happen.

// Only black and white are
// here.
pxlate->ai[0] = 0;
pxlate->ai[255] = 255;

}else if(!palSrc.bIsNoStatic256()){

// All the 20 holy colors are here.
// Fix them up.
for(

ulTemp = 0;
ulTemp < 10;
ulTemp++

){

pxlate->ai[

ulTemp

] = ulTemp;

// bug related note: This
// is a code snippet,
// where a buffer overrun
// might happen.
pxlate->ai[

ulTemp + 246

] = ulTemp + 246;

}

go to: 000E255A

// All the 20 holy colors are here.
// Fix them up.
for(

ulTemp = 0;
ulTemp < 10;
ulTemp++

){

pxlate->ai[

ulTemp

] = ulTemp;

// bug related note: This
// is a code snippet,
// where a buffer overrun
// might happen.
pxlate->ai[

ulTemp + 246

] = ulTemp + 246;

}

}

}else if(palSrc.bIsMonochrome()){

if(

palDestSurf &&
palDestSurf.bIsMonochrome()

){

// It's identity blt.

// bug related note: This is a code snippet,
// where a buffer overrun might happen.
// However, it is unlikely.

pxlate->vSetIndex(

0,
0

);

pxlate->vSetIndex(

1,
1

);

// It's identity blt.

// The chance, that we will have a buffer
// overrun in this code path is low.
// However, we don't take chances in kernel
// mode.
//
// Also, we should set
// pxlate->flXlate->XO_TRIVIAL.
//
// To do this, we set the number of entries,
// which need to be defined, to
// min(cEntry, 2) and then we jump to the
// code, that does everything for us.

ulTemp = min(

cEntry,
2|d

);

go to: 000E228A

// eax = cEntry
000E2342|mov eax, [ebp-4]

// if: eax <= 2|d
// then: jump to: end of the min block
000E2345|cmp eax, 2|d
000E2348|jbe 000E234D

// eax = 2|d
000E234A|push 2|d
000E234C|pop eax

// 000E234D|- end of the min block -

// It's identity blt.

// bug related note: This is a code snippet,
// where a buffer overrun might happen.
// However, it is unlikely.

pxlate->vSetIndex(

0,
0

);

pxlate->vSetIndex(

1,
1

);

}else{

if(bCMYKColor){

}else{

pxlate->iForeDst = iForeDst;
pxlate->iBackDst = iBackDst;

if(bCMYKColor){

}else{

if(bCMYKColor){

// bug related note: This is a code
// snippet, where a buffer overrun might
// happen. However, it is unlikely.

pxlate->vSetIndex(

0,
iForeDst

);

pxlate->vSetIndex(

1,
iBackDst

);

// Store the values, which need to be
// stored at a temporary location for
// now. They will be stored in
// pxlate->ai later if there is
// enough space to do so.

temp_0 = iForeDst;
temp_1 = iBackDst;

// bug related note: This is a code
// snippet, where a buffer overrun might
// happen. However, it is unlikely.

pxlate->vSetIndex(

0,
iForeDst

);

pxlate->vSetIndex(

1,
iBackDst

);

}else{

// bug related note: This is a code
// snippet, where a buffer overrun might
// happen. However, it is unlikely.

pxlate->vSetIndex(

0,
ulGetNearestIndexFromColorref(

palDestSurf,
palDestDC,
iForeDst,
1

)

);

pxlate->vSetIndex(

1,
ulGetNearestIndexFromColorref(

palDestSurf,
palDestDC,
iBackDst,
1

)

);

}

}else{

// Store the values, which need to be
// stored at a temporary location for
// now. They will be stored in
// pxlate->ai later if there is
// enough space to do so.

temp_0 = ulGetNearestIndexFromColorref(

palDestSurf,
palDestDC,
iForeDst,
1

);

temp_1 = ulGetNearestIndexFromColorref(

palDestSurf,
palDestDC,
iBackDst,
1

);

}

}else{

// bug related note: This is a code
// snippet, where a buffer overrun might
// happen. However, it is unlikely.

pxlate->vSetIndex(

0,
ulGetNearestIndexFromColorref(

palDestSurf,
palDestDC,
iForeDst,
1

)

);

pxlate->vSetIndex(

1,
ulGetNearestIndexFromColorref(

palDestSurf,
palDestDC,
iBackDst,
1

)

);

}

// XLATE_FROM_MONO is set so we know to look at
// colors in cache code for getting a hit.

pxlate->flPrivate |= XLATE_FROM_MONO;
pxlate->iForeDst = iForeDst;
pxlate->iBackDst = iBackDst;

}

if(cEntry >= 1){

pxlate->ai[0] = temp_0;

}

if(cEntry > 1){

pxlate->ai[1] = temp_1;

}

// XLATE_FROM_MONO is set so we know to look at
// colors in cache code for getting a hit.

pxlate->flPrivate |= XLATE_FROM_MONO;

}

// XLATE_FROM_MONO is set so we know to look at
// colors in cache code for getting a hit.

pxlate->flPrivate |= XLATE_FROM_MONO;
pxlate->iForeDst = iForeDst;
pxlate->iBackDst = iBackDst;

}

}else if(!cEntry){

// Src is a RGB/Bitfields palette.

// bug related note: In this code branch
// no entries should be stored in
// pxlate->ai, because we announce 0|d
// entries. However, technically there
// is enough space to store 1|d entry,
// because the size of pxlate->ai is
// always at least 1|d.

ASSERTGDI(

!palSrc.cEntries(),
"ERROR how could this happen"

);

if(

palDestSurf &&
palDestSurf.bIsMonochrome()

){

// Put the color the Background of the source
// matches in pulXlate[0]
pxlate->ai[0] = ulGetNearestIndexFromColorref(

palSrc,
palSrcDC,
iBackSrc,
1

);

pxlate->flXlate |= XO_TO_MONO;
pxlate->iBackSrc = iBackSrc;

// The S3 and other snazzy drivers look at
// this and get the color out of slot 0 when
// XO_TO_MONO is set to get way better
// performance in WinBench.
pxlate->pulXlate = pxlate->ai;

}

}else{

// Src is a regular indexed palette, it wouldn't have
// duplicating entries in it so we don't need to check
// for the Dibsection case. This is like a palette for
// a 16 color VGA or a printer or a SetDIBitsToDevice.

if(

palDestSurf.bValid() &&
palDestSurf.bIsMonochrome()

){

RtlZeroMemory(

pxlate->ai,
cEntry * sizeof(ULONG)

);

temp = ulGetNearestIndexFromColorref(

palSrc,
palSrcDC,
iBackSrc,
1

);

ASSERTGDI(

cEntry < pxlate->cEntries,
"ERROR this is not in range"

);

pxlate->vSetIndex(

temp,
1

);

pxlate->flXlate |= XO_TO_MONO;
pxlate->iBackSrc = iBackSrc;

}else{

if(bCMYKColor){

// Copy source CMYK color table to index table.

ulTemp = cEntry

while(ulTemp--){

pxlate->ai[ulTemp] = (

palSrc.ulEntryGet(ulTemp)

);

}

}else{

// If the destination is palette managed,
// map to logical palette and then
// translate to physical indices
// accordingly. Otherwise map to the
// physical palette directly.

PPALETTE ppalTemp;

if(

bPalManaged &&
!(flCreateFlag & XLATE_USE_SURFACE_PAL)

){

ppalTemp = palDestDC.ppalGet();

}else{

ppalTemp = palDestSurf.ppalGet();

if(flCreateFlag & XLATE_USE_SURFACE_PAL){

pxlate->flPrivate |= (

XLATE_USE_SURFACE_PAL

);

}

}

XEPALOBJ palTemp(ppalTemp);

// ppalTemp = palDestDC
000E241C|mov dword ptr [ebp+1C], edi

000E241F|jmp short 000E2431

// ppalTemp = palDestSurf
000E2424|mov dword ptr [ebp+1C], ebx

000E2421|mov edx, dword ptr [ebp+2C]
000E2427|and edx, eax
000E2429|mov dword ptr [ebp+20], edx

// if: !(flCreateFlag & XLATE_USE_SURFACE_PAL)
// then: jump to: 000E2431
000E242C|je short 000E2431

// pxlate->flPrivate |= LATE_USE_SURFACE_PAL
000E242E|or dword ptr [esi+38], eax

// ppalTemp = palDestDC
000B0601|mov dword ptr [ebp+20], ebx

000B0604|jmp short 000B0616

// ppalTemp = palDestSurf
000B060B|mov dword ptr [ebp+20], edi

000B0606|mov edx, dword ptr [ebp+2C]
000B0609|and edx, eax
000B060E|mov dword ptr [ebp+24], edx

// if: !(flCreateFlag & XLATE_USE_SURFACE_PAL)
// then: jump to: 000B0616
000B0611|je short 000B0616

// pxlate->flPrivate |= LATE_USE_SURFACE_PAL
000B0613|or dword ptr [esi+38], eax

// eax = palDestDC
000B3CFD|mov eax, dword ptr [ebp+1C]

000B3D00|jmp short 000B3D0F

// eax = palDestSurf is already the case,
// because the value is already in eax

000B3D02|mov edx, dword ptr [ebp+2C]
000B3D05|and edx, ecx
000B3D07|mov dword ptr [ebp+28], edx

// if: !(flCreateFlag & XLATE_USE_SURFACE_PAL)
// then: jump to: 000B3D0F
000B3D0A|je short 000B3D0F

// pxlate->flPrivate |= LATE_USE_SURFACE_PAL
000B3D0C|or dword ptr [esi+38], ecx

// eax = palDestDC
000B3F4D|mov eax, dword ptr [ebp+1C]

000B3F50|jmp short 000B3F5F

// eax = palDestSurf is already the case,
// because the value is already in eax

000B3F52|mov edx, dword ptr [ebp+2C]
000B3F55|and edx, ecx
000B3F57|mov dword ptr [ebp+28], edx

// if: !(flCreateFlag & XLATE_USE_SURFACE_PAL)
// then: jump to: 000B3F5F
000B3F5A|je short 000B3F5F

// pxlate->flPrivate |= LATE_USE_SURFACE_PAL
000B3F5C|or dword ptr [esi+38], ecx

// By modifying cEntry this code is asking for
// trouble. Technically this code works because
// this function will not use cEntry anymore
// once this code is executed. However, any
// future modifications to this function will
// be harder if we always need to keep in mind,
// that the value in cEntry is lost.
while(cEntry--){

pxlate->ai[cEntry] = (

palTemp.ulGetNearestFromPalentry(

palSrc.palentryGet(cEntry)

)

);

}

for(

ulTemp = 0;
ulTemp < cEntry;
ulTemp++

){

pxlate->ai[ulTemp] = (

palTemp.ulGetNearestFromPalentry(

palSrc.palentryGet(ulTemp)

)

);

}

// By modifying cEntry this code is asking for
// trouble. Technically this code works because
// this function will not use cEntry anymore
// once this code is executed. However, any
// future modifications to this function will
// be harder if we always need to keep in mind,
// that the value in cEntry is lost.
while(cEntry--){

pxlate->ai[cEntry] = (

palTemp.ulGetNearestFromPalentry(

palSrc.palentryGet(cEntry)

)

);

}

for(

ulTemp = 0;
ulTemp < cEntry;
ulTemp++

){

pxlate->ai[ulTemp] = (

palTemp.ulGetNearestFromPalentry(

palSrc.palentryGet(ulTemp)

)

);

}

if(

bPalManaged &&
!(flCreateFlag & XLATE_USE_SURFACE_PAL)

){

// Map from DC palette to surface palette.

if(palDestSurf.bValid()){

temp = ptransCurrent;

}else{

temp = ptransFore;

}

pxlate->vMapNewXlate(

temp

);

// temp = address(ptransFore)
000E2473|mov edx, dword ptr [ebp+0C]

// temp = address(ptransFore)
000B0655|mov edx, dword ptr [ebp+1C]

// temp = address(ptransFore)
000B3D58|mov edx, dword ptr [ebp+0C]

// temp = address(ptransFore)
000B3FA8|mov edx, dword ptr [ebp+0C]

}

}

}

}

pxlate->vCheckForTrivial();

unknown_object->unknown_function();

return(pxlate);

ULONG ulNumEntries

/*

This allocates an xlate object with ulNumEntries.

Returns:

The pointer to the xlate object,
NULL for failure.

History:

17-May-1991 -by- ...

*/

temp = (

  sizeof(XLATE)
+ sizeof(ULONG) * ulNumEntries

)

pxlate = 0;

if(temp){

// Allocate room for the XLATE.
PXLATE pxlate = (PXLATE)PALLOCNOZ(

temp,
'tlxG'

);

)

...

return(pxlate);