able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/enduser/netmeeting/as/cpi32/od2.cpp

1776 lines
61 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include "precomp.h"
//
// OD2.CPP
// Order Decoding Second Level
//
// Copyright(c) Microsoft 1997-
//
#define MLZ_FILE_ZONE ZONE_ORDER
//
// OD2_ViewStarting()
//
// For 3.0 nodes, we create the decoding data each time they start hosting.
// For 2.x nodes, we create the decoding data once and use it until they
// leave the share.
//
BOOL ASShare::OD2_ViewStarting(ASPerson * pasPerson)
{
PPARTYORDERDATA pThisParty;
BOOL rc = FALSE;
DebugEntry(ASShare::OD2_ViewStarting);
ValidatePerson(pasPerson);
if (pasPerson->od2Party != NULL)
{
ASSERT(pasPerson->cpcCaps.general.version < CAPS_VERSION_30);
TRACE_OUT(("OD2_ViewStarting: Reusing od2 data for 2.x node [%d]",
pasPerson->mcsID));
rc = TRUE;
DC_QUIT;
}
//
// Allocate memory for the required structure.
//
pThisParty = new PARTYORDERDATA;
pasPerson->od2Party = pThisParty;
if (!pThisParty)
{
ERROR_OUT(( "Failed to get memory for od2Party entry"));
DC_QUIT;
}
//
// Ensure the pointers are correctly set up.
//
ZeroMemory(pThisParty, sizeof(*pThisParty));
SET_STAMP(pThisParty, PARTYORDERDATA);
pThisParty->LastOrder[OE2_DSTBLT_ORDER ] = &pThisParty->LastDstblt;
pThisParty->LastOrder[OE2_PATBLT_ORDER ] = &pThisParty->LastPatblt;
pThisParty->LastOrder[OE2_SCRBLT_ORDER ] = &pThisParty->LastScrblt;
pThisParty->LastOrder[OE2_MEMBLT_ORDER ] = &pThisParty->LastMemblt;
pThisParty->LastOrder[OE2_MEM3BLT_ORDER ] = &pThisParty->LastMem3blt;
pThisParty->LastOrder[OE2_TEXTOUT_ORDER ] = &pThisParty->LastTextOut;
pThisParty->LastOrder[OE2_EXTTEXTOUT_ORDER] = &pThisParty->LastExtTextOut;
pThisParty->LastOrder[OE2_RECTANGLE_ORDER ] = &pThisParty->LastRectangle;
pThisParty->LastOrder[OE2_LINETO_ORDER ] = &pThisParty->LastLineTo;
pThisParty->LastOrder[OE2_OPAQUERECT_ORDER] = &pThisParty->LastOpaqueRect;
pThisParty->LastOrder[OE2_SAVEBITMAP_ORDER] = &pThisParty->LastSaveBitmap;
pThisParty->LastOrder[OE2_DESKSCROLL_ORDER] = &pThisParty->LastDeskScroll;
pThisParty->LastOrder[OE2_MEMBLT_R2_ORDER ] = &pThisParty->LastMembltR2;
pThisParty->LastOrder[OE2_MEM3BLT_R2_ORDER] = &pThisParty->LastMem3bltR2;
pThisParty->LastOrder[OE2_POLYGON_ORDER ] = &pThisParty->LastPolygon;
pThisParty->LastOrder[OE2_PIE_ORDER ] = &pThisParty->LastPie;
pThisParty->LastOrder[OE2_ELLIPSE_ORDER ] = &pThisParty->LastEllipse;
pThisParty->LastOrder[OE2_ARC_ORDER ] = &pThisParty->LastArc;
pThisParty->LastOrder[OE2_CHORD_ORDER ] = &pThisParty->LastChord;
pThisParty->LastOrder[OE2_POLYBEZIER_ORDER] = &pThisParty->LastPolyBezier;
pThisParty->LastOrder[OE2_ROUNDRECT_ORDER] = &pThisParty->LastRoundRect;
OD2_SyncIncoming(pasPerson);
rc = TRUE;
DC_EXIT_POINT:
DebugExitBOOL(ASShare::OD2_ViewStarting, rc);
return(rc);
}
//
// OD2_SyncIncoming()
// Called when NEW dude starts to share, a share is created, or someone new
// joins the share.
//
void ASShare::OD2_SyncIncoming(ASPerson * pasPerson)
{
PPARTYORDERDATA pThisParty;
DebugEntry(ASShare::OD2_SyncIncoming);
ValidateView(pasPerson);
pThisParty = pasPerson->od2Party;
pThisParty->LastOrderType = OE2_PATBLT_ORDER;
pThisParty->pLastOrder =
(LPCOM_ORDER)(pThisParty->LastOrder[pThisParty->LastOrderType]);
//
// Set all buffers to NULL Fill in the datalength fields and the type
// field. Note that because the type field is always the first one in
// an order we can cast each pointer to a TEXTOUT order to get the
// correct position for this field
//
#define Reset(field, ord) \
{ \
ZeroMemory(&pThisParty->field, sizeof(pThisParty->field)); \
((LPCOM_ORDER_HEADER)pThisParty->field)->cbOrderDataLength = \
sizeof(pThisParty->field) - sizeof(COM_ORDER_HEADER); \
TEXTFIELD(((LPCOM_ORDER)pThisParty->field))->type = LOWORD(ord); \
}
//
// The compiler generates a warning for our use of LOWORD here on a
// constant. We disable the warning just for now.
//
Reset(LastDstblt, ORD_DSTBLT);
Reset(LastPatblt, ORD_PATBLT);
Reset(LastScrblt, ORD_SCRBLT);
Reset(LastMemblt, ORD_MEMBLT);
Reset(LastMem3blt, ORD_MEM3BLT);
Reset(LastTextOut, ORD_TEXTOUT);
Reset(LastExtTextOut, ORD_EXTTEXTOUT);
Reset(LastRectangle, ORD_RECTANGLE);
Reset(LastLineTo, ORD_LINETO);
Reset(LastOpaqueRect, ORD_OPAQUERECT);
Reset(LastSaveBitmap, ORD_SAVEBITMAP);
Reset(LastDeskScroll, ORD_DESKSCROLL);
Reset(LastMembltR2, ORD_MEMBLT_R2);
Reset(LastMem3bltR2, ORD_MEM3BLT_R2);
Reset(LastPolygon, ORD_POLYGON);
Reset(LastPie, ORD_PIE);
Reset(LastEllipse, ORD_ELLIPSE);
Reset(LastArc, ORD_ARC);
Reset(LastChord, ORD_CHORD);
Reset(LastPolyBezier, ORD_POLYBEZIER);
Reset(LastRoundRect, ORD_ROUNDRECT);
//
// Reset the bounds rectangle
//
ZeroMemory(&pThisParty->LastBounds, sizeof(pThisParty->LastBounds));
//
// The sender and the receiver both set their structures to the same
// NULL state and the sender only ever sends differences from the
// current state. However the fontID fields in the received orders
// refer to the sender, so we must actually set our fontID fields to
// the local equivalent of the NULL entries just set.
// We cannot do this until we have actually received the font details
// so set the field to a dummy value we can recognise later.
//
TEXTFIELD(((LPCOM_ORDER)pThisParty->LastTextOut))->common.FontIndex =
DUMMY_FONT_ID;
EXTTEXTFIELD(((LPCOM_ORDER)pThisParty->LastExtTextOut))->common.
FontIndex = DUMMY_FONT_ID;
DebugExitVOID(ASShare::OD2_SyncIncoming);
}
//
// OD2_ViewEnded()
//
void ASShare::OD2_ViewEnded(ASPerson * pasPerson)
{
DebugEntry(ASShare::OD2_ViewEnded);
ValidatePerson(pasPerson);
//
// For 3.0 nodes, we can free the decode data; 3.0 senders clear theirs
// every time they host.
// For 2.x nodes, we must keep it around while they are in the share.
//
if (pasPerson->cpcCaps.general.version >= CAPS_VERSION_30)
{
OD2FreeIncoming(pasPerson);
}
else
{
TRACE_OUT(("OD2_ViewEnded: Keeping od2 data for 2.x node [%d]",
pasPerson->mcsID));
}
DebugExitVOID(ASShare::OD2_ViewEnded);
}
//
// OD2_PartyLeftShare()
// For 2.x nodes, frees the incoming OD2 data
//
void ASShare::OD2_PartyLeftShare(ASPerson * pasPerson)
{
DebugEntry(ASShare::OD2_PartyLeftShare);
ValidatePerson(pasPerson);
if (pasPerson->cpcCaps.general.version >= CAPS_VERSION_30)
{
// This should be gone!
ASSERT(pasPerson->od2Party == NULL);
}
else
{
TRACE_OUT(("OD2_PartyLeftShare: Freeing od2 data for 2.x node [%d]",
pasPerson->mcsID));
OD2FreeIncoming(pasPerson);
}
DebugExitVOID(ASShare::OD2_PartyLeftShare);
}
//
// OD2FreeIncoming()
// Frees per-party incoming OD2 resources
//
void ASShare::OD2FreeIncoming(ASPerson * pasPerson)
{
DebugEntry(OD2FreeIncoming);
if (pasPerson->od2Party != NULL)
{
if (pasPerson->od2Party->LastHFONT != NULL)
{
if (pasPerson->m_pView)
{
// For 3.0 nodes, pView won't be NULL; for 2.x nodes it may.
//
// This font might be currently selected into the DC for
// this person's desktop. Select it out.
//
SelectFont(pasPerson->m_pView->m_usrDC, (HFONT)GetStockObject(SYSTEM_FONT));
}
DeleteFont(pasPerson->od2Party->LastHFONT);
pasPerson->od2Party->LastHFONT = NULL;
}
delete pasPerson->od2Party;
pasPerson->od2Party = NULL;
}
DebugExitVOID(ASShare::OD2FreeIncoming);
}
//
// OD2_DecodeOrder()
//
LPCOM_ORDER ASShare::OD2_DecodeOrder
(
void * pEOrder,
LPUINT pLengthDecoded,
ASPerson * pasPerson
)
{
POE2ETFIELD pTableEntry;
UINT FieldChangedBits;
UINT FieldsChanged;
LPBYTE pNextDataToCopy;
RECT Rect;
LPBYTE pControlFlags;
LPTSHR_UINT32_UA pEncodingFlags;
LPSTR pEncodedOrder;
UINT numEncodingFlagBytes;
UINT encodedFieldLength;
UINT unencodedFieldLength;
UINT numReps;
UINT i;
LPBYTE pDest;
DebugEntry(ASShare::OD2_DecodeOrder);
ValidatePerson(pasPerson);
//
// Set up some local variables to access the encoding buffer in various
// ways.
//
pControlFlags = &((PDCEO2ORDER)pEOrder)->ControlFlags;
pEncodedOrder = (LPSTR)&((PDCEO2ORDER)pEOrder)->EncodedOrder[0];
pEncodingFlags = (LPTSHR_UINT32_UA)pEncodedOrder;
if ( (*pControlFlags & OE2_CF_STANDARD_ENC) == 0)
{
ERROR_OUT(("Specially encoded order received from %d", pasPerson));
return(NULL);
}
//
// If the unencoded flag is set, the order has not been encoded, so
// just return a pointer to the start of the data.
//
if ( (*pControlFlags & OE2_CF_UNENCODED) != 0)
{
//
// Convert the fields of the order header from wire format. Note
// that unencoded orders are also PRIVATE, and hence do not
// actually have the rcsDst field.
//
*pLengthDecoded = sizeof(COM_ORDER_HEADER)
+ EXTRACT_TSHR_UINT16_UA(
&(((LPCOM_ORDER_UA)pEncodedOrder)->OrderHeader.cbOrderDataLength))
+ FIELD_OFFSET(DCEO2ORDER, EncodedOrder);
TRACE_OUT(("Person [%d] Returning unencoded buffer length %u",
pasPerson->mcsID, *pLengthDecoded));
return((LPCOM_ORDER)pEncodedOrder);
}
//
// If type has changed, new type will be first byte in encoded order.
// Get pointer to last order of this type. The encoding flags follow
// this byte (if it is present).
//
if ( (*pControlFlags & OE2_CF_TYPE_CHANGE) != 0)
{
TRACE_OUT(("Person [%d] change type from %d to %d", pasPerson->mcsID,
(UINT)pasPerson->od2Party->LastOrderType,
(UINT)*(LPBYTE)pEncodedOrder));
pasPerson->od2Party->LastOrderType = *(LPTSHR_UINT8)pEncodedOrder;
pasPerson->od2Party->pLastOrder =
(LPCOM_ORDER)(pasPerson->od2Party->LastOrder[pasPerson->od2Party->LastOrderType]);
pEncodingFlags = (LPTSHR_UINT32_UA)&pEncodedOrder[1];
}
else
{
pEncodingFlags = (LPTSHR_UINT32_UA)&pEncodedOrder[0];
}
TRACE_OUT(("Person [%d] type %x", pasPerson->mcsID, pasPerson->od2Party->LastOrderType));
//
// Work out how many bytes we will need to store the encoding flags in.
// (We have a flag for each field in the order structure). This code
// we have written will cope with up to a DWORD of encoding flags.
//
numEncodingFlagBytes = (s_etable.NumFields[pasPerson->od2Party->LastOrderType]+7)/8;
if (numEncodingFlagBytes > 4)
{
ERROR_OUT(( "[%#lx] Too many flag bytes (%d) for this code",
pasPerson, numEncodingFlagBytes));
}
//
// Now we know how many bytes make up the flags we can get a pointer
// to the position at which to start encoding the orders fields into.
//
pNextDataToCopy = (LPBYTE)pEncodingFlags + numEncodingFlagBytes;
//
// Reset the flags field to zero
//
pasPerson->od2Party->pLastOrder->OrderHeader.fOrderFlags = 0;
//
// Rebuild the Order Common Header in the same order as it was
// encoded:
//
//
// If a bounding rectangle is included, copy it into the order header
//
if ( *pControlFlags & OE2_CF_BOUNDS )
{
OD2DecodeBounds((LPTSHR_UINT8*)&pNextDataToCopy,
&pasPerson->od2Party->pLastOrder->OrderHeader.rcsDst,
pasPerson);
}
//
// locate entry in encoding table for this ORDER type and extract the
// encoded order flags from the Encoded order
//
pTableEntry = s_etable.pFields[pasPerson->od2Party->LastOrderType];
FieldChangedBits = 0;
for (i=numEncodingFlagBytes; i>0; i--)
{
FieldChangedBits = FieldChangedBits << 8;
FieldChangedBits |= (UINT)((LPBYTE)pEncodingFlags)[i-1];
}
//
// We need to keep a record of which fields we change.
//
FieldsChanged = FieldChangedBits;
//
// Now decode the order: While field changed bits are non-zero
// If rightmost bit is non-zero
// copy data from the buffer to the copy of this order type
// skip to next entry in Encoding table
// shift field changed bits right one bit
//
while (FieldChangedBits != 0)
{
//
// If this field was encoded (ie changed since the last order)...
//
if ((FieldChangedBits & 1) != 0)
{
//
// Set up a pointer to the destination (unencoded) field.
//
pDest = ((LPBYTE)pasPerson->od2Party->pLastOrder)
+ pTableEntry->FieldPos
+ sizeof(COM_ORDER_HEADER);
//
// If the field type is OE2_ETF_DATA, we just copy the number
// of bytes given by the encoded length in the table.
//
if ((pTableEntry->FieldType & OE2_ETF_DATA) != 0)
{
encodedFieldLength = 1;
unencodedFieldLength = 1;
numReps = pTableEntry->FieldEncodedLen;
TRACE_OUT(("Byte data field, len %d", numReps));
}
else
{
//
// This is not a straightforward data copy. The length of
// the source and destination data is given in the table in
// the FieldEncodedLen and FieldUnencodedLen elements
// respectively.
//
encodedFieldLength = pTableEntry->FieldEncodedLen;
unencodedFieldLength = pTableEntry->FieldUnencodedLen;
if ((pTableEntry->FieldType & OE2_ETF_FIXED) != 0)
{
//
// If the field type is fixed (OE2_ETF_FIXED is set),
// we just have to decode one element of the given
// size.
//
numReps = 1;
TRACE_OUT(("Fixed fld: encoded size %d, unencoded size %d",
encodedFieldLength,
unencodedFieldLength));
}
else
{
//
// This is a variable field. The next byte to be
// decoded contains the number of BYTES of encoded data
// (not elements), so divide by the encoded field size
// to get numReps.
//
numReps = *pNextDataToCopy / encodedFieldLength;
TRACE_OUT(("Var field: encoded size %d, unencoded size " \
"%d, reps %d",
encodedFieldLength,
unencodedFieldLength,
numReps));
//
// Step past the length field in the encoded order
//
pNextDataToCopy++;
//
// For a variable length field, the unencoded version
// contains a UINT for the length (in bytes) of the
// following variable data, followed by the actual
// data. Fill in the length field in the unencoded
// order.
//
*(LPTSHR_UINT32)pDest = numReps * unencodedFieldLength;
pDest += sizeof(TSHR_UINT32);
}
}
//
// If the order was encoded using delta coordinate mode and
// this field is a coordinate then convert the coordinate from
// the single byte sized delta to a value of the size given by
// unencodedFieldLen...
//
// Note that we've already handled the leading length field of
// variable length fields above, so we don't have to worry
// about FIXED / VARIABLE issues here.
//
if ( (*pControlFlags & OE2_CF_DELTACOORDS) &&
(pTableEntry->FieldType & OE2_ETF_COORDINATES) )
{
//
// NOTE:
// numReps can be zero in the case of an EXTTEXTOUT
// order that needs the opaque rect but has no absolute
// char positioning
//
OD2CopyFromDeltaCoords((LPTSHR_INT8*)&pNextDataToCopy,
pDest,
unencodedFieldLength,
pTableEntry->FieldSigned,
numReps);
}
else
{
if ((pasPerson->od2Party->LastOrderType == OE2_POLYGON_ORDER) ||
(pasPerson->od2Party->LastOrderType == OE2_POLYBEZIER_ORDER))
{
//
// numReps can never be zero in this case
//
ASSERT(numReps);
}
OD2DecodeField(&pNextDataToCopy,
pDest,
encodedFieldLength,
unencodedFieldLength,
pTableEntry->FieldSigned,
numReps);
}
}
//
// Move on to the next field in the order structure...
//
FieldChangedBits = FieldChangedBits >> 1;
pTableEntry++;
}
//
// Check to see if we just got a font handle.
// Because of the rather nasty test against an unnamed bit in the
// FieldsChanged bits, we have a compile time check against the number
// of fields in the TEXT orders structures.
// The requirement for this code not to break is that the font handle
// field must stay as the 13th field (hence 1 << 12).
//
#if (OE2_NUM_TEXTOUT_FIELDS != 15) || (OE2_NUM_EXTTEXTOUT_FIELDS != 22)
#error code breaks if font handle not 13th field
#endif // OE2_NUM_TEXTOUT_FIELDS is 15 or 22
if (((pasPerson->od2Party->LastOrderType == OE2_EXTTEXTOUT_ORDER) &&
((FieldsChanged & (1 << 12)) ||
(EXTTEXTFIELD(((LPCOM_ORDER)pasPerson->od2Party->LastExtTextOut))->common.
FontIndex == DUMMY_FONT_ID))) ||
((pasPerson->od2Party->LastOrderType == OE2_TEXTOUT_ORDER) &&
((FieldsChanged & (1 << 12)) ||
(TEXTFIELD(((LPCOM_ORDER)pasPerson->od2Party->LastTextOut))->common.
FontIndex == DUMMY_FONT_ID))))
{
//
// This was a text order, and the font changed for it.
//
FH_ConvertAnyFontIDToLocal(pasPerson->od2Party->pLastOrder, pasPerson);
}
//
// if the OE2_CF_BOUNDS flag is not set, we have not yet constructed
// the bounding rectangle, so call OD2ReconstructBounds to do so
//
if ( (*pControlFlags & OE2_CF_BOUNDS) == 0)
{
OD2_CalculateBounds(pasPerson->od2Party->pLastOrder,
&Rect,
TRUE,
pasPerson);
pasPerson->od2Party->pLastOrder->OrderHeader.rcsDst.left
= (TSHR_INT16)Rect.left;
pasPerson->od2Party->pLastOrder->OrderHeader.rcsDst.right
= (TSHR_INT16)Rect.right;
pasPerson->od2Party->pLastOrder->OrderHeader.rcsDst.top
= (TSHR_INT16)Rect.top;
pasPerson->od2Party->pLastOrder->OrderHeader.rcsDst.bottom
= (TSHR_INT16)Rect.bottom;
pasPerson->od2Party->pLastOrder->OrderHeader.fOrderFlags |= OF_NOTCLIPPED;
}
//
// Return the decoded order length and a pointer to the order.
//
*pLengthDecoded = (UINT)(pNextDataToCopy - (LPBYTE)pEOrder);
TRACE_OUT(("Person [%d] Return decoded order length %u",
pasPerson->mcsID, *pLengthDecoded));
DebugExitPVOID(ASShare::OD2_DecodeOrder, pasPerson->od2Party->pLastOrder);
return(pasPerson->od2Party->pLastOrder);
}
//
// FUNCTION: OD2UseFont
//
// DESCRIPTION:
//
// Selects the font described by the parameters into the person's DC.
// so that we can then query the text extent etc.
// The queried metrics are available from pasPerson->od2Party->LastFontMetrics.
//
// PARAMETERS:
//
// RETURNS: TRUE if successful, FALSE otherwise.
//
//
BOOL ASShare::OD2UseFont
(
ASPerson * pasPerson,
LPSTR pName,
UINT facelength,
UINT codePage,
UINT MaxHeight,
UINT Height,
UINT Width,
UINT Weight,
UINT flags
)
{
BOOL rc = TRUE;
DebugEntry(ASShare::OD2UseFont);
ValidatePerson(pasPerson);
if ((pasPerson->od2Party->LastFontFaceLen != facelength ) ||
(memcmp((LPSTR)(pasPerson->od2Party->LastFaceName),pName,
facelength) != 0 ) ||
(pasPerson->od2Party->LastCodePage != codePage) ||
(pasPerson->od2Party->LastFontHeight != Height ) ||
(pasPerson->od2Party->LastFontWidth != Width ) ||
(pasPerson->od2Party->LastFontWeight != Weight ) ||
(pasPerson->od2Party->LastFontFlags != flags ))
{
TRACE_OUT(("Person [%d] Font %s (CP%d,w%d,h%d,f%04X,wgt%d) to %s (CP%d,w%d,h%d,f%04X,wgt%d)",
pasPerson->mcsID, pasPerson->od2Party->LastFaceName,
pasPerson->od2Party->LastCodePage, pasPerson->od2Party->LastFontWidth,
pasPerson->od2Party->LastFontHeight,
pasPerson->od2Party->LastFontFlags,
pasPerson->od2Party->LastFontWeight,
pName,
codePage,
Width,
Height,
flags,
Weight ));
memcpy(pasPerson->od2Party->LastFaceName,pName,facelength);
pasPerson->od2Party->LastFontFaceLen = facelength;
pasPerson->od2Party->LastFaceName[facelength] = '\0';
pasPerson->od2Party->LastFontHeight = Height;
pasPerson->od2Party->LastCodePage = codePage;
pasPerson->od2Party->LastFontWidth = Width;
pasPerson->od2Party->LastFontWeight = Weight;
pasPerson->od2Party->LastFontFlags = flags;
rc = USR_UseFont(pasPerson->m_pView->m_usrDC,
&pasPerson->od2Party->LastHFONT,
&pasPerson->od2Party->LastFontMetrics,
(LPSTR)pasPerson->od2Party->LastFaceName,
codePage,
MaxHeight,
Height,
Width,
Weight,
flags);
}
else
{
//
// The font hasn't changed, so LastHFONT should be the one we
// want. We must still select it in however, since several fonts
// get selected into usrDC.
//
ASSERT(pasPerson->od2Party->LastHFONT != NULL);
SelectFont(pasPerson->m_pView->m_usrDC, pasPerson->od2Party->LastHFONT);
}
DebugExitBOOL(ASShare::OD2UseFont, rc);
return(rc);
}
//
// OD2_CalculateTextOutBounds()
//
void ASShare::OD2_CalculateTextOutBounds
(
LPTEXTOUT_ORDER pTextOut,
LPRECT pRect,
BOOL fDecoding,
ASPerson * pasPerson
)
{
LPSTR pString;
int cbString;
BOOL fExtTextOut;
LPEXTTEXTOUT_ORDER pExtTextOut = NULL;
LPCOMMON_TEXTORDER pCommon;
LPSTR faceName;
UINT faceNameLength;
BOOL fFontSelected;
UINT FontIndex;
UINT width;
UINT maxFontHeight;
UINT nFontFlags;
UINT nCodePage;
DebugEntry(ASShare::OD2_CalculateTextOutBounds);
ValidatePerson(pasPerson);
//
// Workout if this is a TextOut or ExtTextOut order.
//
if (pTextOut->type == ORD_EXTTEXTOUT_TYPE)
{
fExtTextOut = TRUE;
pExtTextOut = (LPEXTTEXTOUT_ORDER)pTextOut;
pCommon = &(pExtTextOut->common);
//
// This code does not cope with calculating the bounds of an
// ExtTextOut order with a delta X array. We return a NULL
// rectangle in this case to force the OE2 code to transmit the
// bounds explicitly. However if we are decoding then we must
// calculate the rectangle (even though it may be wrong) to
// maintain backward compatability to previous versions of the
// product (R11) which did not return a NULL rect if delta-x was
// present.
//
if ( (pExtTextOut->fuOptions & ETO_LPDX)
&& (!fDecoding) )
{
TRACE_OUT(( "Delta X so return NULL rect"));
pRect->left = 0;
pRect->right = 0;
pRect->top = 0;
pRect->bottom = 0;
return;
}
}
else if (pTextOut->type == ORD_TEXTOUT_TYPE)
{
fExtTextOut = FALSE;
pCommon = &(pTextOut->common);
}
else
{
ERROR_OUT(( "{%p} Unexpected order type %x",
pasPerson, (int)pTextOut->type));
return;
}
//
// The order structures both have the variableString as their first
// variable field. If this were not the case then the code here would
// have to take into account that the encoding side packs variable
// sized fields while the decoding side does not pack them.
//
if (fExtTextOut)
{
cbString = pExtTextOut->variableString.len;
pString = (LPSTR)&pExtTextOut->variableString.string;
}
else
{
cbString = pTextOut->variableString.len;
pString = (LPSTR)&pTextOut->variableString.string;
}
FontIndex = pCommon->FontIndex;
width = pCommon->FontWidth;
//
// Get the facename from the handle, and get the various font width/
// height adjusted values.
//
faceName = FH_GetFaceNameFromLocalHandle(FontIndex,
&faceNameLength);
maxFontHeight = (UINT)FH_GetMaxHeightFromLocalHandle(FontIndex);
//
// Get the local font flags for the font, so that we can merge in any
// specific local flag information when setting up the font. The prime
// example of this is whether the local font we matched is TrueType or
// not, which information is not sent over the wire, but does need to
// be used when setting up the font - or else we may draw using a local
// fixed font of the same facename.
//
nFontFlags = FH_GetFontFlagsFromLocalHandle(FontIndex);
//
// Get the local codePage for the font.
//
nCodePage = FH_GetCodePageFromLocalHandle(FontIndex);
//
// Hosting only version does not ever decode orders.
//
//
// Select the font into the appropriate DC and query the text extent.
//
if (fDecoding)
{
fFontSelected = OD2UseFont(pasPerson,
faceName,
faceNameLength,
nCodePage,
maxFontHeight,
pCommon->FontHeight,
width,
pCommon->FontWeight,
pCommon->FontFlags
| (nFontFlags & NF_LOCAL));
if (!fFontSelected)
{
//
// We failed to select the correct font - so we cannot
// calculate the bounds correctly. However, the fact that we
// are in this routine means that on the host the text was
// unclipped. Therefore we just return a (fairly arbitrary)
// very big rect.
//
// This is far from a perfect answer (for example, it will
// force a big repaint), but allow us to keep running in a
// difficult situation (i.e. acute resource shortage).
//
pRect->left = 0;
pRect->right = 2000;
pRect->top = -2000;
pRect->bottom = 2000;
return;
}
OE_GetStringExtent(pasPerson->m_pView->m_usrDC,
&pasPerson->od2Party->LastFontMetrics,
pString, cbString, pRect );
}
else
{
ASSERT(m_pHost);
fFontSelected = m_pHost->OE2_UseFont(faceName,
(TSHR_UINT16)faceNameLength,
(TSHR_UINT16)nCodePage,
(TSHR_UINT16)maxFontHeight,
(TSHR_UINT16)pCommon->FontHeight,
(TSHR_UINT16)width,
(TSHR_UINT16)pCommon->FontWeight,
(TSHR_UINT16)(pCommon->FontFlags
| (nFontFlags & NF_LOCAL)));
if (!fFontSelected)
{
//
// We failed to select the correct font. We return a NULL
// rectangle in this case to force the OE2 code to transmit
// the bounds explicitly.
//
pRect->left = 0;
pRect->right = 0;
pRect->top = 0;
pRect->bottom = 0;
return;
}
OE_GetStringExtent(m_pHost->m_usrWorkDC, NULL, pString, cbString, pRect );
}
//
// We have a rectangle with the text extent in it relative to (0,0) so
// add in the text starting position to this to give us the bounding
// rectangle. At the same time we will convert the exclusive rect
// returned by OE_GetStringExtent to an inclusive rectangle as us
//
pRect->left += pCommon->nXStart;
pRect->right += pCommon->nXStart - 1;
pRect->top += pCommon->nYStart;
pRect->bottom += pCommon->nYStart - 1;
//
// If this is an ExtTextOut order then we must take into account the
// opaque/clipping rectangle if there is one.
//
if (fExtTextOut)
{
//
// If the rectangle is an opaque rectangle then expand the bounding
// rectangle to bound the opaque rectangle also.
//
if (pExtTextOut->fuOptions & ETO_OPAQUE)
{
pRect->left = min(pExtTextOut->rectangle.left, pRect->left);
pRect->right = max(pExtTextOut->rectangle.right,
pRect->right);
pRect->top = min(pExtTextOut->rectangle.top,
pRect->top);
pRect->bottom = max(pExtTextOut->rectangle.bottom,
pRect->bottom);
}
//
// If the rectangle is a clip rectangle then restrict the bounding
// rectangle to be within the clip rectangle.
//
if (pExtTextOut->fuOptions & ETO_CLIPPED)
{
pRect->left = max(pExtTextOut->rectangle.left,
pRect->left);
pRect->right = min(pExtTextOut->rectangle.right,
pRect->right);
pRect->top = max(pExtTextOut->rectangle.top,
pRect->top);
pRect->bottom = min(pExtTextOut->rectangle.bottom,
pRect->bottom);
}
}
DebugExitVOID(ASShare::OD2_CalculateTextOutBounds);
}
//
// OD2_CalculateBounds()
//
void ASShare::OD2_CalculateBounds
(
LPCOM_ORDER pOrder,
LPRECT pRect,
BOOL fDecoding,
ASPerson * pasPerson
)
{
UINT i;
UINT numPoints;
DebugEntry(ASShare::OD2_CalculateBounds);
ValidatePerson(pasPerson);
//
// Calculate the bounds according to the order type.
// All blts can be handled in the same way.
//
switch ( ((LPPATBLT_ORDER)pOrder->abOrderData)->type )
{
//
// Calculate bounds for the blts.
// This is the destination rectangle. Bounds are inclusive.
//
case ORD_DSTBLT_TYPE:
pRect->left =
((LPDSTBLT_ORDER)(pOrder->abOrderData))->nLeftRect;
pRect->top = ((LPDSTBLT_ORDER)(pOrder->abOrderData))->nTopRect;
pRect->right = pRect->left
+ ((LPDSTBLT_ORDER)(pOrder->abOrderData))->nWidth
- 1;
pRect->bottom = pRect->top
+ ((LPDSTBLT_ORDER)(pOrder->abOrderData))->nHeight
- 1;
break;
case ORD_PATBLT_TYPE:
pRect->left =
((LPPATBLT_ORDER)(pOrder->abOrderData))->nLeftRect;
pRect->top =
((LPPATBLT_ORDER)(pOrder->abOrderData))->nTopRect;
pRect->right =
pRect->left +
((LPPATBLT_ORDER)(pOrder->abOrderData))->nWidth - 1;
pRect->bottom =
pRect->top +
((LPPATBLT_ORDER)(pOrder->abOrderData))->nHeight - 1;
break;
case ORD_SCRBLT_TYPE:
pRect->left =
((LPSCRBLT_ORDER)(pOrder->abOrderData))->nLeftRect;
pRect->top =
((LPSCRBLT_ORDER)(pOrder->abOrderData))->nTopRect;
pRect->right =
pRect->left +
((LPSCRBLT_ORDER)(pOrder->abOrderData))->nWidth - 1;
pRect->bottom =
pRect->top +
((LPSCRBLT_ORDER)(pOrder->abOrderData))->nHeight - 1;
break;
case ORD_MEMBLT_TYPE:
pRect->left =
((LPMEMBLT_ORDER)(pOrder->abOrderData))->nLeftRect;
pRect->top =
((LPMEMBLT_ORDER)(pOrder->abOrderData))->nTopRect;
pRect->right =
pRect->left +
((LPMEMBLT_ORDER)(pOrder->abOrderData))->nWidth - 1;
pRect->bottom =
pRect->top +
((LPMEMBLT_ORDER)(pOrder->abOrderData))->nHeight - 1;
break;
case ORD_MEM3BLT_TYPE:
pRect->left =
((LPMEM3BLT_ORDER)(pOrder->abOrderData))->nLeftRect;
pRect->top =
((LPMEM3BLT_ORDER)(pOrder->abOrderData))->nTopRect;
pRect->right =
pRect->left +
((LPMEM3BLT_ORDER)(pOrder->abOrderData))->nWidth - 1;
pRect->bottom =
pRect->top +
((LPMEM3BLT_ORDER)(pOrder->abOrderData))->nHeight - 1;
break;
case ORD_MEMBLT_R2_TYPE:
pRect->left =
((LPMEMBLT_R2_ORDER)(pOrder->abOrderData))->nLeftRect;
pRect->top =
((LPMEMBLT_R2_ORDER)(pOrder->abOrderData))->nTopRect;
pRect->right =
pRect->left +
((LPMEMBLT_R2_ORDER)(pOrder->abOrderData))->nWidth - 1;
pRect->bottom =
pRect->top +
((LPMEMBLT_R2_ORDER)(pOrder->abOrderData))->nHeight - 1;
break;
case ORD_MEM3BLT_R2_TYPE:
pRect->left =
((LPMEM3BLT_R2_ORDER)(pOrder->abOrderData))->nLeftRect;
pRect->top =
((LPMEM3BLT_R2_ORDER)(pOrder->abOrderData))->nTopRect;
pRect->right =
pRect->left +
((LPMEM3BLT_R2_ORDER)(pOrder->abOrderData))->nWidth - 1;
pRect->bottom =
pRect->top +
((LPMEM3BLT_R2_ORDER)(pOrder->abOrderData))->nHeight - 1;
break;
//
// Calculate bounds for Rectangle.
// This is the rectangle itself. Bounds are inclusive.
//
case ORD_RECTANGLE_TYPE:
pRect->left =
((LPRECTANGLE_ORDER)(pOrder->abOrderData))->nLeftRect;
pRect->top =
((LPRECTANGLE_ORDER)(pOrder->abOrderData))->nTopRect;
pRect->right =
((LPRECTANGLE_ORDER)(pOrder->abOrderData))->nRightRect;
pRect->bottom =
((LPRECTANGLE_ORDER)(pOrder->abOrderData))->nBottomRect;
break;
case ORD_ROUNDRECT_TYPE:
pRect->left =
((LPROUNDRECT_ORDER)(pOrder->abOrderData))->nLeftRect;
pRect->top =
((LPROUNDRECT_ORDER)(pOrder->abOrderData))->nTopRect;
pRect->right =
((LPROUNDRECT_ORDER)(pOrder->abOrderData))->nRightRect;
pRect->bottom =
((LPROUNDRECT_ORDER)(pOrder->abOrderData))->nBottomRect;
break;
case ORD_POLYGON_TYPE:
//
// Calculate bounds for Polygon.
//
pRect->left = 0x7fff;
pRect->right = 0;
pRect->top = 0x7fff;
pRect->bottom = 0;
//
// BOGUS! LAURABU BUGBUG
//
// In NM 2.0, the wrong fields were being compared. x to top/
// bottom, and y to left/right.
//
// Effectively, this meant that we never matched the bounds
// in the rcsDst rect.
//
numPoints = ((LPPOLYGON_ORDER)(pOrder->abOrderData))->
variablePoints.len
/ sizeof(((LPPOLYGON_ORDER)(pOrder->abOrderData))->
variablePoints.aPoints[0]);
for (i = 0; i < numPoints; i++ )
{
if ( ((LPPOLYGON_ORDER)(pOrder->abOrderData))
->variablePoints.aPoints[i].y > pRect->bottom )
{
pRect->bottom = ((LPPOLYGON_ORDER)(pOrder->abOrderData))
->variablePoints.aPoints[i].y;
}
if ( ((LPPOLYGON_ORDER)(pOrder->abOrderData))
->variablePoints.aPoints[i].y < pRect->top )
{
pRect->top = ((LPPOLYGON_ORDER)(pOrder->abOrderData))
->variablePoints.aPoints[i].y;
}
if ( ((LPPOLYGON_ORDER)(pOrder->abOrderData))
->variablePoints.aPoints[i].x > pRect->right )
{
pRect->right = ((LPPOLYGON_ORDER)(pOrder->abOrderData))
->variablePoints.aPoints[i].x;
}
if ( ((LPPOLYGON_ORDER)(pOrder->abOrderData))
->variablePoints.aPoints[i].x < pRect->left )
{
pRect->left = ((LPPOLYGON_ORDER)(pOrder->abOrderData))
->variablePoints.aPoints[i].x;
}
}
TRACE_OUT(("Poly bounds: left:%d, right:%d, top:%d, bottom:%d",
pRect->left, pRect->right, pRect->top, pRect->bottom ));
break;
case ORD_PIE_TYPE:
//
// Pull out the bounding rectangle directly from the PIE order.
//
pRect->left = ((LPPIE_ORDER)(pOrder->abOrderData))->nLeftRect;
pRect->top = ((LPPIE_ORDER)(pOrder->abOrderData))->nTopRect;
pRect->right = ((LPPIE_ORDER)(pOrder->abOrderData))->nRightRect;
pRect->bottom = ((LPPIE_ORDER)(pOrder->abOrderData))->nBottomRect;
break;
case ORD_ELLIPSE_TYPE:
//
// Pull out the bounding rectangle directly from ELLIPSE order.
//
pRect->left = ((LPELLIPSE_ORDER)(pOrder->abOrderData))->nLeftRect;
pRect->top = ((LPELLIPSE_ORDER)(pOrder->abOrderData))->nTopRect;
pRect->right =
((LPELLIPSE_ORDER)(pOrder->abOrderData))->nRightRect;
pRect->bottom =
((LPELLIPSE_ORDER)(pOrder->abOrderData))->nBottomRect;
break;
case ORD_ARC_TYPE:
//
// Pull out the bounding rectangle directly from the ARC order.
//
pRect->left = ((LPARC_ORDER)(pOrder->abOrderData))->nLeftRect;
pRect->top = ((LPARC_ORDER)(pOrder->abOrderData))->nTopRect;
pRect->right = ((LPARC_ORDER)(pOrder->abOrderData))->nRightRect;
pRect->bottom = ((LPARC_ORDER)(pOrder->abOrderData))->nBottomRect;
break;
case ORD_CHORD_TYPE:
//
// Pull out the bounding rectangle directly from the CHORD
// order.
//
pRect->left = ((LPCHORD_ORDER)(pOrder->abOrderData))->nLeftRect;
pRect->top = ((LPCHORD_ORDER)(pOrder->abOrderData))->nTopRect;
pRect->right = ((LPCHORD_ORDER)(pOrder->abOrderData))->nRightRect;
pRect->bottom =
((LPCHORD_ORDER)(pOrder->abOrderData))->nBottomRect;
break;
case ORD_POLYBEZIER_TYPE:
//
// Calculate bounds for PolyBezier.
//
pRect->left = 0x7fff;
pRect->right = 0;
pRect->top = 0x7fff;
pRect->bottom = 0;
numPoints = ((LPPOLYBEZIER_ORDER)(pOrder->abOrderData))->
variablePoints.len
/ sizeof(((LPPOLYBEZIER_ORDER)(pOrder->abOrderData))->
variablePoints.aPoints[0]);
//
// BOGUS! LAURABU BUGBUG
//
// In NM 2.0, the wrong fields were being compared. x to top/
// bottom, and y to left/right.
//
// Effectively, this meant that we never matched the bounds
// in the rcsDst rect.
//
for (i = 0; i < numPoints; i++ )
{
if ( ((LPPOLYBEZIER_ORDER)(pOrder->abOrderData))
->variablePoints.aPoints[i].y > pRect->bottom )
{
pRect->bottom = ((LPPOLYBEZIER_ORDER)(pOrder->abOrderData))
->variablePoints.aPoints[i].y;
}
if ( ((LPPOLYBEZIER_ORDER)(pOrder->abOrderData))
->variablePoints.aPoints[i].y < pRect->top )
{
pRect->top = ((LPPOLYBEZIER_ORDER)(pOrder->abOrderData))
->variablePoints.aPoints[i].y;
}
if ( ((LPPOLYBEZIER_ORDER)(pOrder->abOrderData))
->variablePoints.aPoints[i].x > pRect->right )
{
pRect->right = ((LPPOLYBEZIER_ORDER)(pOrder->abOrderData))
->variablePoints.aPoints[i].x;
}
if ( ((LPPOLYBEZIER_ORDER)(pOrder->abOrderData))
->variablePoints.aPoints[i].x < pRect->left )
{
pRect->left = ((LPPOLYBEZIER_ORDER)(pOrder->abOrderData))
->variablePoints.aPoints[i].x;
}
}
TRACE_OUT((
"PolyBezier bounds: left:%d, right:%d, top:%d, bot:%d",
pRect->left, pRect->right, pRect->top, pRect->bottom));
break;
case ORD_LINETO_TYPE:
//
// Calculate bounds for LineTo. This is the rectangle with
// opposite vertices on the start and end points of the line.
// The gradient of the line determines whether the start or end
// point provides the top or bottom, left or right of the
// rectangle. Bounds are inclusive.
//
if ( ((LPLINETO_ORDER)(pOrder->abOrderData))->nXStart <
((LPLINETO_ORDER)(pOrder->abOrderData))->nXEnd )
{
pRect->left =
((LPLINETO_ORDER)(pOrder->abOrderData))->nXStart;
pRect->right =
((LPLINETO_ORDER)(pOrder->abOrderData))->nXEnd;
}
else
{
pRect->right =
((LPLINETO_ORDER)pOrder->abOrderData)->nXStart;
pRect->left =
((LPLINETO_ORDER)pOrder->abOrderData)->nXEnd;
}
if ( ((LPLINETO_ORDER)pOrder->abOrderData)->nYStart <
((LPLINETO_ORDER)pOrder->abOrderData)->nYEnd )
{
pRect->top =
((LPLINETO_ORDER)pOrder->abOrderData)->nYStart;
pRect->bottom =
((LPLINETO_ORDER)pOrder->abOrderData)->nYEnd;
}
else
{
pRect->bottom =
((LPLINETO_ORDER)pOrder->abOrderData)->nYStart;
pRect->top =
((LPLINETO_ORDER)pOrder->abOrderData)->nYEnd;
}
break;
case ORD_OPAQUERECT_TYPE:
//
// Calculate bounds for OpaqueRect. This is the rectangle
// itself. Bounds are inclusive.
//
pRect->left =
((LPOPAQUERECT_ORDER)(pOrder->abOrderData))->nLeftRect;
pRect->top =
((LPOPAQUERECT_ORDER)(pOrder->abOrderData))->nTopRect;
pRect->right =
pRect->left +
((LPOPAQUERECT_ORDER)(pOrder->abOrderData))->nWidth - 1;
pRect->bottom =
pRect->top +
((LPOPAQUERECT_ORDER)(pOrder->abOrderData))->nHeight - 1;
break;
case ORD_SAVEBITMAP_TYPE:
//
// Calculate bounds for SaveBitmap. This is the rectangle
// itself. Bounds are inclusive.
//
pRect->left =
((LPSAVEBITMAP_ORDER)(pOrder->abOrderData))->nLeftRect;
pRect->top =
((LPSAVEBITMAP_ORDER)(pOrder->abOrderData))->nTopRect;
pRect->bottom =
((LPSAVEBITMAP_ORDER)(pOrder->abOrderData))->nBottomRect;
pRect->right =
((LPSAVEBITMAP_ORDER)(pOrder->abOrderData))->nRightRect;
break;
case ORD_TEXTOUT_TYPE:
case ORD_EXTTEXTOUT_TYPE:
//
// TextOut and ExtTextOut bounds calculations are done by the
// OD2_CalculateTextOutBounds function.
//
OD2_CalculateTextOutBounds((LPTEXTOUT_ORDER)pOrder->abOrderData,
pRect,
fDecoding,
pasPerson);
break;
case ORD_DESKSCROLL_TYPE:
pRect->left = 0;
pRect->top = 0;
pRect->right = 0;
pRect->bottom = 0;
break;
default:
ERROR_OUT((
"{%p} unrecognized type passed to OD2ReconstructBounds: %d",
pasPerson,
(int)((LPPATBLT_ORDER)pOrder->abOrderData)->type));
break;
}
DebugExitVOID(ASShare::OD2_CalculateBounds);
}
//
// OD2DecodeBounds()
//
void ASShare::OD2DecodeBounds
(
LPBYTE* ppNextDataToCopy,
LPTSHR_RECT16 pRect,
ASPerson * pasPerson
)
{
LPBYTE pFlags;
DebugEntry(ASShare::OD2DecodeBounds);
ValidatePerson(pasPerson);
//
// The encoding used is a byte of flags followed by a variable number
// of 16bit coordinate values and 8bit delta coordinate values (which
// may be interleaved).
//
//
// The first byte of the encoding will contain the flags that represent
// how the coordinates of the rectangle were encoded.
//
pFlags = *ppNextDataToCopy;
(*ppNextDataToCopy)++;
//
// Initialise the rectangle with the last decoded coordinates.
//
*pRect = pasPerson->od2Party->LastBounds;
//
// If the flags indicate that none of the coordinates have changed then
// fast path and exit now.
//
if (*pFlags == 0)
{
return;
}
//
// For each of the four coordinate values in the rectangle: If the
// coordinate was encoded as an 8bit delta then add on the delta to the
// previous value. If the coordinate was encoded as a 16bit value
// then copy the value across. Otherwise the coordinate was the same
// as the previous one so leave it alone.
//
if (*pFlags & OE2_BCF_DELTA_LEFT)
{
OD2CopyFromDeltaCoords((LPTSHR_INT8*)ppNextDataToCopy,
&pRect->left,
sizeof(pRect->left),
TRUE, // The value is signed
1);
}
else if (*pFlags & OE2_BCF_LEFT)
{
pRect->left = EXTRACT_TSHR_INT16_UA(*ppNextDataToCopy);
(*ppNextDataToCopy) += sizeof(TSHR_INT16);
}
if (*pFlags & OE2_BCF_DELTA_TOP)
{
OD2CopyFromDeltaCoords((LPTSHR_INT8*)ppNextDataToCopy,
&pRect->top,
sizeof(pRect->top),
TRUE, // The value is signed
1);
}
else if (*pFlags & OE2_BCF_TOP)
{
pRect->top = EXTRACT_TSHR_INT16_UA(*ppNextDataToCopy);
(*ppNextDataToCopy) += sizeof(TSHR_INT16);
}
if (*pFlags & OE2_BCF_DELTA_RIGHT)
{
OD2CopyFromDeltaCoords((LPTSHR_INT8*)ppNextDataToCopy,
&pRect->right,
sizeof(pRect->right),
TRUE, // The value is signed
1);
}
else if (*pFlags & OE2_BCF_RIGHT)
{
pRect->right = EXTRACT_TSHR_INT16_UA(*ppNextDataToCopy);
(*ppNextDataToCopy) += sizeof(TSHR_INT16);
}
if (*pFlags & OE2_BCF_DELTA_BOTTOM)
{
OD2CopyFromDeltaCoords((LPTSHR_INT8*)ppNextDataToCopy,
&pRect->bottom,
sizeof(pRect->bottom),
TRUE, // The value is signed
1);
}
else if (*pFlags & OE2_BCF_BOTTOM)
{
pRect->bottom = EXTRACT_TSHR_INT16_UA(*ppNextDataToCopy);
(*ppNextDataToCopy) += sizeof(TSHR_INT16);
}
//
// Copy the rectangle for reference with the next encoding.
//
pasPerson->od2Party->LastBounds = *pRect;
DebugExitVOID(ASShare::OD2DecodeBounds);
}
//
// Copy an array of source elements to an array of destination elements,
// converting the types as the copy takes place.
//
// DESTARRAY - The destination array
// SRCARRAY - The source array
// DESTTYPE - The type of the elements in the destination array
// NUMELEMENTS - The number of elements in the array
//
//
#define CONVERT_ARRAY(DESTARRAY, SRCARRAY, DESTTYPE, NUMELEMENTS) \
{ \
UINT index; \
for (index=0 ; index<(NUMELEMENTS) ; index++) \
{ \
(DESTARRAY)[index] = (DESTTYPE)(SRCARRAY)[index]; \
} \
}
//
// Copy an array of source elements to an array of destination elements,
// converting the types as the copy takes place. This version allows for
// unaligned INT16 pointers
//
// DESTARRAY - The destination array
// SRCARRAY - The source array
// DESTTYPE - The type of the elements in the destination array
// NUMELEMENTS - The number of elements in the array
//
//
#define CONVERT_ARRAY_INT16_UA(DESTARRAY, SRCARRAY, DESTTYPE, NUMELEMENTS) \
{ \
UINT index; \
TSHR_INT16 value; \
for (index=0 ; index<(NUMELEMENTS) ; index++) \
{ \
value = EXTRACT_TSHR_INT16_UA((SRCARRAY)+index); \
(DESTARRAY)[index] = (DESTTYPE)value; \
} \
}
//
// Copy an array of source elements to an array of destination elements,
// converting the types as the copy takes place. This version allows for
// unaligned TSHR_UINT16 pointers
//
// DESTARRAY - The destination array
// SRCARRAY - The source array
// DESTTYPE - The type of the elements in the destination array
// NUMELEMENTS - The number of elements in the array
//
//
#define CONVERT_ARRAY_UINT16_UA(DESTARRAY, SRCARRAY, DESTTYPE, NUMELEMENTS) \
{ \
UINT index; \
TSHR_UINT16 value; \
for (index=0 ; index<(NUMELEMENTS) ; index++) \
{ \
value = EXTRACT_TSHR_UINT16_UA((SRCARRAY)+index); \
(DESTARRAY)[index] = (DESTTYPE)((TSHR_INT16)value); \
} \
}
//
// OD2DecodeField()
//
void ASShare::OD2DecodeField
(
LPBYTE* ppSrc,
LPVOID pDst,
UINT cbSrcField,
UINT cbDstField,
BOOL fSigned,
UINT numElements
)
{
LPTSHR_UINT8 pDst8 = (LPTSHR_UINT8)pDst;
LPTSHR_INT16 pDst16Signed = (LPTSHR_INT16)pDst;
LPTSHR_INT32 pDst32Signed = (LPTSHR_INT32)pDst;
LPTSHR_UINT16 pDst16Unsigned = (LPTSHR_UINT16)pDst;
LPTSHR_UINT32 pDst32Unsigned = (LPTSHR_UINT32)pDst;
LPTSHR_INT8 pSrc8Signed = (LPTSHR_INT8)*ppSrc;
LPTSHR_UINT8 pSrc8Unsigned = (LPTSHR_UINT8)*ppSrc;
LPTSHR_INT16_UA pSrc16Signed = (LPTSHR_INT16_UA)*ppSrc;
LPTSHR_UINT16_UA pSrc16Unsigned = (LPTSHR_UINT16_UA)*ppSrc;
//
// Note that the source fields may not be aligned correctly, so we use
// unaligned pointers. The destination is aligned correctly.
//
DebugEntry(ASShare::OD2DecodeField);
//
// Make sure that the destination field length is larger or equal to
// the source field length. If it isn't, something has gone wrong.
//
if (cbDstField < cbSrcField)
{
ERROR_OUT(( "Source field length %d is larger than destination %d",
cbSrcField,
cbDstField));
DC_QUIT;
}
//
// If the source and destination field lengths are the same, we can
// just do a copy (no type conversion required).
//
if (cbSrcField == cbDstField)
{
memcpy(pDst8, *ppSrc, cbDstField * numElements);
}
else
{
//
// We know that cbDstField must be greater than cbSrcField
// because of our checks above. So there are only three
// conversions to consider:
//
// 8 bit -> 16 bit
// 8 bit -> 32 bit
// 16 bit -> 32 bit
//
// We also have to get the signed / unsigned attributes correct. If
// we try to promote a signed value using unsigned pointers, we
// will get the wrong result.
//
// e.g. Consider converting the value -1 from a TSHR_INT16 to TSHR_INT32
// using unsigned pointers.
//
// -1 -> TSHR_UINT16 == 65535
// -> UINT == 65535
// -> TSHR_INT32 == 65535
//
//
if ((cbDstField == 4) && (cbSrcField == 1))
{
if (fSigned)
{
CONVERT_ARRAY(pDst32Signed,
pSrc8Signed,
TSHR_INT32,
numElements);
}
else
{
CONVERT_ARRAY(pDst32Unsigned,
pSrc8Unsigned,
TSHR_UINT32,
numElements);
}
}
else if ((cbDstField == 4) && (cbSrcField == 2))
{
if (fSigned)
{
CONVERT_ARRAY_INT16_UA(pDst32Signed,
pSrc16Signed,
TSHR_INT32,
numElements);
}
else
{
CONVERT_ARRAY_UINT16_UA(pDst32Unsigned,
pSrc16Unsigned,
TSHR_UINT32,
numElements);
}
}
else if ((cbDstField == 2) && (cbSrcField == 1))
{
if (fSigned)
{
CONVERT_ARRAY(pDst16Signed,
pSrc8Signed,
TSHR_INT16,
numElements);
}
else
{
CONVERT_ARRAY(pDst16Unsigned,
pSrc8Unsigned,
TSHR_UINT16,
numElements);
}
}
else
{
ERROR_OUT(( "Bad conversion, dest length = %d, src length = %d",
cbDstField,
cbSrcField));
}
}
DC_EXIT_POINT:
*ppSrc += cbSrcField * numElements;
DebugExitVOID(ASShare::OD2DecodeField);
}
//
// Given two arrays, a source array and an array of deltas, add each delta
// to the corresponding element in the source array, storing the results in
// the source array.
//
// srcArray - The array of source values
// srcArrayType - The type of the array of source values
// deltaArray - The array of deltas
// numElements - The number of elements in the arrays
//
//
#define COPY_DELTA_ARRAY(srcArray, srcArrayType, deltaArray, numElements) \
{ \
UINT index; \
for (index = 0; index < (numElements); index++) \
{ \
(srcArray)[index] = (srcArrayType) \
((srcArray)[index] + (deltaArray)[index]); \
} \
}
//
// OD2CopyFromDeltaCoords()
//
void ASShare::OD2CopyFromDeltaCoords
(
LPTSHR_INT8* ppSrc,
LPVOID pDst,
UINT cbDstField,
BOOL fSigned,
UINT numElements
)
{
LPTSHR_INT8 pDst8Signed = (LPTSHR_INT8)pDst;
LPTSHR_INT16 pDst16Signed = (LPTSHR_INT16)pDst;
LPTSHR_INT32 pDst32Signed = (LPTSHR_INT32)pDst;
LPTSHR_UINT8 pDst8Unsigned = (LPTSHR_UINT8)pDst;
LPTSHR_UINT16 pDst16Unsigned = (LPTSHR_UINT16)pDst;
LPTSHR_UINT32 pDst32Unsigned = (LPTSHR_UINT32)pDst;
DebugEntry(ASShare::OD2CopyFromDeltaCoords);
switch (cbDstField)
{
case 1:
if (fSigned)
{
COPY_DELTA_ARRAY(pDst8Signed, TSHR_INT8, *ppSrc, numElements);
}
else
{
COPY_DELTA_ARRAY(pDst8Unsigned, TSHR_UINT8, *ppSrc, numElements);
}
break;
case 2:
if (fSigned)
{
COPY_DELTA_ARRAY(pDst16Signed, TSHR_INT16, *ppSrc, numElements);
}
else
{
COPY_DELTA_ARRAY(pDst16Unsigned, TSHR_UINT16, *ppSrc, numElements);
}
break;
case 4:
if (fSigned)
{
COPY_DELTA_ARRAY(pDst32Signed, TSHR_INT32, *ppSrc, numElements);
}
else
{
COPY_DELTA_ARRAY(pDst32Unsigned, TSHR_UINT32, *ppSrc, numElements);
}
break;
default:
ERROR_OUT(( "Bad destination field length %d",
cbDstField));
DC_QUIT;
// break;
}
DC_EXIT_POINT:
*ppSrc += numElements;
DebugExitVOID(ASShare::OD2CopyFromDeltaCoords);
}

Reference in a new issue Copy permalink