#include "precomp.h" // // OD.CPP // Order Decoding // // Copyright(c) Microsoft 1997- // #define MLZ_FILE_ZONE ZONE_ORDER // // OD_ViewStarting() // // Sets up the odLast... vars // BOOL ASShare::OD_ViewStarting(ASPerson * pasPerson) { BOOL rc = FALSE; TSHR_COLOR colorWhite = {0xFF,0xFF,0xFF}; BYTE brushExtra[7] = {0,0,0,0,0,0,0}; DebugEntry(ASShare::OD_ViewStarting); ValidateView(pasPerson); // // Invalidate OD results // pasPerson->m_pView->m_odInvalRgnTotal = CreateRectRgn(0, 0, 0, 0); if (pasPerson->m_pView->m_odInvalRgnTotal == NULL) { ERROR_OUT(("OD_PartyStartingHosting: Couldn't create total invalid OD region")); DC_QUIT; } pasPerson->m_pView->m_odInvalRgnOrder = CreateRectRgn(0, 0, 0, 0); if (pasPerson->m_pView->m_odInvalRgnOrder == NULL) { ERROR_OUT(("OD_PartyStartingHosting: Couldn't create order invalid OD region")); DC_QUIT; } // // Back color. // pasPerson->m_pView->m_odLastBkColor = 0; ODUseBkColor(pasPerson, TRUE, colorWhite); // // Text color. // pasPerson->m_pView->m_odLastTextColor = 0; ODUseTextColor(pasPerson, TRUE, colorWhite); // // Background mode. // pasPerson->m_pView->m_odLastBkMode = TRANSPARENT; ODUseBkMode(pasPerson, OPAQUE); // // ROP2. // pasPerson->m_pView->m_odLastROP2 = R2_BLACK; ODUseROP2(pasPerson, R2_COPYPEN); // // Fill Mode. It's zero, we don't need to do anything since 0 isn't // a valid mode, so we'll change it the first order we get that uses // one. // ASSERT(pasPerson->m_pView->m_odLastFillMode == 0); // // Arc Direction. It's zero, we don't need to do anything since 0 // isn't a valid dir, so we'll change it the first order we get that // uses one. // ASSERT(pasPerson->m_pView->m_odLastArcDirection == 0); // // Pen. // pasPerson->m_pView->m_odLastPenStyle = PS_DASH; pasPerson->m_pView->m_odLastPenWidth = 2; pasPerson->m_pView->m_odLastPenColor = 0; ODUsePen(pasPerson, TRUE, PS_SOLID, 1, colorWhite); // // Brush. // pasPerson->m_pView->m_odLastBrushOrgX = 1; pasPerson->m_pView->m_odLastBrushOrgY = 1; pasPerson->m_pView->m_odLastBrushBkColor = 0; pasPerson->m_pView->m_odLastBrushTextColor = 0; pasPerson->m_pView->m_odLastLogBrushStyle = BS_NULL; pasPerson->m_pView->m_odLastLogBrushHatch = HS_VERTICAL; pasPerson->m_pView->m_odLastLogBrushColor.red = 0; pasPerson->m_pView->m_odLastLogBrushColor.green = 0; pasPerson->m_pView->m_odLastLogBrushColor.blue = 0; ODUseBrush(pasPerson, TRUE, 0, 0, BS_SOLID, HS_HORIZONTAL, colorWhite, brushExtra); // // Char extra. // pasPerson->m_pView->m_odLastCharExtra = 1; ODUseTextCharacterExtra(pasPerson, 0); // // Text justification. // pasPerson->m_pView->m_odLastJustExtra = 1; pasPerson->m_pView->m_odLastJustCount = 1; ODUseTextJustification(pasPerson, 0, 0); // odLastBaselineOffset. This is zero, which is the default in the DC // right now so need to change anything. // // Font. // // We don't call ODUseFont because we know that the following values // are invalid. The first valid font to arrive will be selected. // ASSERT(pasPerson->m_pView->m_odLastFontID == NULL); pasPerson->m_pView->m_odLastFontCodePage = 0; pasPerson->m_pView->m_odLastFontWidth = 0; pasPerson->m_pView->m_odLastFontHeight = 0; pasPerson->m_pView->m_odLastFontWeight = 0; pasPerson->m_pView->m_odLastFontFlags = 0; pasPerson->m_pView->m_odLastFontFaceLen = 0; ZeroMemory(pasPerson->m_pView->m_odLastFaceName, sizeof(pasPerson->m_pView->m_odLastFaceName)); // // These next 4 variables which describe the current clip rectangle are // only valid if fRectReset is FALSE. If fRectReset is true then no // clipping is in force. // pasPerson->m_pView->m_odRectReset = TRUE; pasPerson->m_pView->m_odLastLeft = 0x12345678; pasPerson->m_pView->m_odLastTop = 0x12345678; pasPerson->m_pView->m_odLastRight = 0x12345678; pasPerson->m_pView->m_odLastBottom = 0x12345678; // odLastVGAColor? // odLastVGAResult? rc = TRUE; DC_EXIT_POINT: DebugExitBOOL(ASShare::OD_ViewStarting, rc); return(rc); } // // OD_ViewEnded() // Cleans up any created objects // void ASShare::OD_ViewEnded(ASPerson * pasPerson) { DebugEntry(ASShare::OD_ViewEnded); ValidateView(pasPerson); // // We may create and select in a font and a pen for our drawing decode. // Select them out and delete them. Since we can't delete stock objects, // if we didn't actually create one, there's no harm in it. // if (pasPerson->m_pView->m_usrDC != NULL) { DeleteBrush(SelectBrush(pasPerson->m_pView->m_usrDC, (HBRUSH)GetStockObject(BLACK_BRUSH))); DeletePen(SelectPen(pasPerson->m_pView->m_usrDC, (HPEN)GetStockObject(BLACK_PEN))); } // // Destroy the brush patern // if (pasPerson->m_pView->m_odLastBrushPattern != NULL) { DeleteBitmap(pasPerson->m_pView->m_odLastBrushPattern); pasPerson->m_pView->m_odLastBrushPattern = NULL; } // // Destroy the font -- but in this case we don't know that our font is // actually the one in the DC. od2 also selects in fonts. // if (pasPerson->m_pView->m_odLastFontID != NULL) { // Make sure this isn't selected in to usrDC SelectFont(pasPerson->m_pView->m_usrDC, (HFONT)GetStockObject(SYSTEM_FONT)); DeleteFont(pasPerson->m_pView->m_odLastFontID); pasPerson->m_pView->m_odLastFontID = NULL; } if (pasPerson->m_pView->m_odInvalRgnTotal != NULL) { DeleteRgn(pasPerson->m_pView->m_odInvalRgnTotal); pasPerson->m_pView->m_odInvalRgnTotal = NULL; } if (pasPerson->m_pView->m_odInvalRgnOrder != NULL) { DeleteRgn(pasPerson->m_pView->m_odInvalRgnOrder); pasPerson->m_pView->m_odInvalRgnOrder = NULL; } DebugExitVOID(ASShare::OD_ViewEnded); } // // OD_ReceivedPacket() // // Handles incoming orders packet from a host. Replays the drawing orders // into the screen bitmap for the host, then repaints the view with the // results. // void ASShare::OD_ReceivedPacket ( ASPerson * pasPerson, PS20DATAPACKET pPacket ) { PORDPACKET pOrders; HPALETTE hOldPalette; HPALETTE hOldSavePalette; UINT cOrders; UINT cUpdates; UINT i; LPCOM_ORDER_UA pOrder; UINT decodedLength; LPBYTE pEncodedOrder; TSHR_INT32 xOrigin; TSHR_INT32 yOrigin; BOOL fPalRGB; DebugEntry(ASShare::OD_ReceivedPacket); ValidateView(pasPerson); pOrders = (PORDPACKET)pPacket; // // The color type is RGB if we or they are < 256 colors // Else it's PALETTE if they are old, or new and not sending 24bpp // fPalRGB = TRUE; if ((g_usrScreenBPP < 8) || (pasPerson->cpcCaps.screen.capsBPP < 8)) { TRACE_OUT(("OD_ReceivedPacket: no PALRGB")); fPalRGB = FALSE; } else { // At 24bpp, no palette matching for RGB values unless we're <= 8 if ((g_usrScreenBPP > 8) && (pOrders->sendBPP > 8)) { TRACE_OUT(("OD_ReceivedPacket: no PALRGB")); fPalRGB = FALSE; } } if (g_usrPalettized) { // // Select and realize the current remote palette into the device // context. // hOldPalette = SelectPalette(pasPerson->m_pView->m_usrDC, pasPerson->pmPalette, FALSE); RealizePalette(pasPerson->m_pView->m_usrDC); // // We must select the same palette into the Save Bitmap DC so that // no color conversion occurs during save and restore operations. // if (pasPerson->m_pView->m_ssiDC != NULL) { hOldSavePalette = SelectPalette(pasPerson->m_pView->m_ssiDC, pasPerson->pmPalette, FALSE); RealizePalette(pasPerson->m_pView->m_ssiDC); } } // // Extract the number of orders supplied. // cOrders = pOrders->cOrders; if (m_oefOE2EncodingOn) { pEncodedOrder = (LPBYTE)(&pOrders->data); pOrder = NULL; } else { pOrder = (LPCOM_ORDER_UA)(&pOrders->data); pEncodedOrder = NULL; } // // Get the desktop origin for this person. // TRACE_OUT(( "Begin replaying %u orders ((", cOrders)); // // This should be empty, we should have reset it when we invalidated // the view of the host the last time we got a packet. // #ifdef _DEBUG { RECT rcBounds; ASSERT(pasPerson->m_pView->m_odInvalTotal == 0); GetRgnBox(pasPerson->m_pView->m_odInvalRgnTotal, &rcBounds); ASSERT(IsRectEmpty(&rcBounds)); } #endif // _DEBUG // // Repeat for each of the received orders. // for (i = 0; i < cOrders; i++) { if (m_oefOE2EncodingOn) { // // Decode the first order. The pOrder returned by // OD2_DecodeOrder should have all fields in local byte order // pOrder = OD2_DecodeOrder( (PDCEO2ORDER)pEncodedOrder, &decodedLength, pasPerson ); if (pOrder == NULL) { ERROR_OUT(( "Failed to decode order from pasPerson %u", pasPerson)); DC_QUIT; } } else { // // Convert any font ids to be local ids. // // // BOGUS LAURABU // pOrder is unaligned, FH_Convert... takes an aligned order // FH_ConvertAnyFontIDToLocal((LPCOM_ORDER)pOrder, pasPerson); decodedLength = pOrder->OrderHeader.cbOrderDataLength + sizeof(COM_ORDER_HEADER); } // // If the order is a Private Order then it is dealt with by // the Bitmap Cache Controller. // if (EXTRACT_TSHR_UINT16_UA(&(pOrder->OrderHeader.fOrderFlags)) & OF_PRIVATE) { RBC_ProcessCacheOrder(pasPerson, pOrder); } else if ( EXTRACT_TSHR_UINT16_UA( &(((LPPATBLT_ORDER)pOrder->abOrderData)->type)) == LOWORD(ORD_DESKSCROLL)) { ERROR_OUT(("Received DESKSCROLL order, obsolete, from 3.0 node [%d]", pasPerson->mcsID)); } else { // // Replay the received order. This will also add the // bounds to the invalidate region. // // OD_ReplayOrder(pasPerson, (LPCOM_ORDER)pOrder, fPalRGB); } if (m_oefOE2EncodingOn) { pEncodedOrder += decodedLength; } else { pOrder = (LPCOM_ORDER_UA)((LPBYTE)pOrder + decodedLength); } } TRACE_OUT(( "End replaying orders ))")); // // Pass the Update Region to the Shadow Window Presenter. // OD_UpdateView(pasPerson); DC_EXIT_POINT: if (g_usrPalettized) { // // Reinstate the old palette(s). // SelectPalette(pasPerson->m_pView->m_usrDC, hOldPalette, FALSE); if (pasPerson->m_pView->m_ssiDC != NULL) { SelectPalette(pasPerson->m_pView->m_ssiDC, hOldSavePalette, FALSE); } } DebugExitVOID(ASShare::OD_ReceivedPacket); } // // OD_UpdateView() // // This is called after we've processed an order packet and replayed the // drawing into our bitmap for the host. // // Replaying the drawing keeps a running tally of the area changed. This // function invalidates the changed area in the view of the host, so it // will repaint and show the updates. // void ASShare::OD_UpdateView(ASPerson * pasHost) { RECT rcBounds; DebugEntry(ASShare::OD_UpdateView); ValidateView(pasHost); // // Do nothing if there are no updates. // if (pasHost->m_pView->m_odInvalTotal == 0) { // Nothing got played back, nothing to repaint } else if (pasHost->m_pView->m_odInvalTotal <= MAX_UPDATE_REGION_ORDERS) { VIEW_InvalidateRgn(pasHost, pasHost->m_pView->m_odInvalRgnTotal); } else { // // Rather than invalidating a very complex region, which will // chew up a lot of memory, just invalidate the bounding box. // GetRgnBox(pasHost->m_pView->m_odInvalRgnTotal, &rcBounds); TRACE_OUT(("OD_UpdateView: Update region too complex; use bounds {%04d, %04d, %04d, %04d}", rcBounds.left, rcBounds.top, rcBounds.right, rcBounds.bottom)); // // BOGUS LAURABU! // This code used to add one to the right & bottom, which was // bogus EXCLUSIVE coordinate confusion. I fixed this--the bound // box is the right area. // SetRectRgn(pasHost->m_pView->m_odInvalRgnTotal, rcBounds.left, rcBounds.top, rcBounds.right, rcBounds.bottom); VIEW_InvalidateRgn(pasHost, pasHost->m_pView->m_odInvalRgnTotal); } // Now reset the update region to empty SetRectRgn(pasHost->m_pView->m_odInvalRgnTotal, 0, 0, 0, 0); pasHost->m_pView->m_odInvalTotal = 0; DebugExitVOID(ASShare::OD_UpdateView); } // // OD_ReplayOrder() // // Replays one drawing operation, the next one, in the packet of orders // we received from a host. // void ASShare::OD_ReplayOrder ( ASPerson * pasPerson, LPCOM_ORDER pOrder, BOOL fPalRGB ) { LPPATBLT_ORDER pDrawing; LPSTR faceName; UINT faceNameLength; UINT trueFontWidth; UINT maxFontHeight; TSHR_UINT16 nFontFlags; TSHR_UINT16 nCodePage; UINT i; RECT rcDst; DebugEntry(ASShare::OD_ReplayOrder); ValidateView(pasPerson); pDrawing = (LPPATBLT_ORDER)pOrder->abOrderData; // // These are VD coords. // WHEN 2.X INTEROP IS GONE, GET RID OF m_pView->m_dsScreenOrigin // RECT_FROM_TSHR_RECT16(&rcDst, pOrder->OrderHeader.rcsDst); // // The host bitmap is in screen, not VD, coords // if (pOrder->OrderHeader.fOrderFlags & OF_NOTCLIPPED) { // // The rectangle associated with this order is the bounding // rectangle of the order and does not clip it. We optimise this // case by passing in a large rectangle that will not result in // clipping to ODUseRectRegion. ODUseRectRegion will spot if this // is the same as the last clip region we set and take a fast exit // path. This improves performance substantially. // ODUseRectRegion(pasPerson, 0, 0, 10000, 10000); } else { ODUseRectRegion(pasPerson, rcDst.left, rcDst.top, rcDst.right, rcDst.bottom); } switch (pDrawing->type) { case ORD_DSTBLT_TYPE: ODReplayDSTBLT(pasPerson, (LPDSTBLT_ORDER)pDrawing, fPalRGB); break; case ORD_PATBLT_TYPE: ODReplayPATBLT(pasPerson, (LPPATBLT_ORDER)pDrawing, fPalRGB); break; case ORD_SCRBLT_TYPE: ODReplaySCRBLT(pasPerson, (LPSCRBLT_ORDER)pDrawing, fPalRGB); break; case ORD_MEMBLT_TYPE: case ORD_MEMBLT_R2_TYPE: ODReplayMEMBLT(pasPerson, (LPMEMBLT_ORDER)pDrawing, fPalRGB); break; case ORD_MEM3BLT_TYPE: case ORD_MEM3BLT_R2_TYPE: ODReplayMEM3BLT(pasPerson, (LPMEM3BLT_ORDER)pDrawing, fPalRGB); break; case ORD_RECTANGLE_TYPE: ODReplayRECTANGLE(pasPerson, (LPRECTANGLE_ORDER)pDrawing, fPalRGB); break; case ORD_POLYGON_TYPE: ODReplayPOLYGON(pasPerson, (LPPOLYGON_ORDER)pDrawing, fPalRGB); break; case ORD_PIE_TYPE: ODReplayPIE(pasPerson, (LPPIE_ORDER)pDrawing, fPalRGB); break; case ORD_ELLIPSE_TYPE: ODReplayELLIPSE(pasPerson, (LPELLIPSE_ORDER)pDrawing, fPalRGB); break; case ORD_ARC_TYPE: ODReplayARC(pasPerson, (LPARC_ORDER)pDrawing, fPalRGB); break; case ORD_CHORD_TYPE: ODReplayCHORD(pasPerson, (LPCHORD_ORDER)pDrawing, fPalRGB); break; case ORD_POLYBEZIER_TYPE: ODReplayPOLYBEZIER(pasPerson, (LPPOLYBEZIER_ORDER)pDrawing, fPalRGB); break; case ORD_ROUNDRECT_TYPE: ODReplayROUNDRECT(pasPerson, (LPROUNDRECT_ORDER)pDrawing, fPalRGB); break; case ORD_LINETO_TYPE: ODReplayLINETO(pasPerson, (LPLINETO_ORDER)pDrawing, fPalRGB); break; case ORD_EXTTEXTOUT_TYPE: ODReplayEXTTEXTOUT(pasPerson, (LPEXTTEXTOUT_ORDER)pDrawing, fPalRGB); break; case ORD_TEXTOUT_TYPE: ODReplayTEXTOUT(pasPerson, (LPTEXTOUT_ORDER)pDrawing, fPalRGB); break; case ORD_OPAQUERECT_TYPE: ODReplayOPAQUERECT(pasPerson, (LPOPAQUERECT_ORDER)pDrawing, fPalRGB); break; case ORD_SAVEBITMAP_TYPE: SSI_SaveBitmap(pasPerson, (LPSAVEBITMAP_ORDER)pDrawing); break; default: ERROR_OUT(( "ORDER: Unrecognised order %d from [%d]", (int)pDrawing->type, pasPerson->mcsID)); break; } // // rcDst is INCLUSIVE coords still // if ((rcDst.left <= rcDst.right) && (rcDst.top <= rcDst.bottom)) { SetRectRgn(pasPerson->m_pView->m_odInvalRgnOrder, rcDst.left, rcDst.top, rcDst.right+1, rcDst.bottom+1); // // Combine the rectangle region with the update region. // if (UnionRgn(pasPerson->m_pView->m_odInvalRgnTotal, pasPerson->m_pView->m_odInvalRgnTotal, pasPerson->m_pView->m_odInvalRgnOrder) <= ERROR) { RECT rcCur; // // Union failed; so simplyify the current region // WARNING_OUT(("OD_ReplayOrder: UnionRgn failed")); // // BOGUS LAURABU! // This code used to add one to the right & bottom, which is // bogus exclusive coord confusion. The bound box is the right // area. // GetRgnBox(pasPerson->m_pView->m_odInvalRgnTotal, &rcCur); SetRectRgn(pasPerson->m_pView->m_odInvalRgnTotal, rcCur.left, rcCur.top, rcCur.right, rcCur.bottom); // // Reset odInvalTotal count -- this is really a # of bounds rects // count, and now we have just one. // pasPerson->m_pView->m_odInvalTotal = 1; if (UnionRgn(pasPerson->m_pView->m_odInvalRgnTotal, pasPerson->m_pView->m_odInvalRgnTotal, pasPerson->m_pView->m_odInvalRgnOrder) <= ERROR) { ERROR_OUT(("OD_ReplayOrder: UnionRgn failed after simplification")); } } pasPerson->m_pView->m_odInvalTotal++; } DebugExitVOID(ASShare::OD_ReplayOrder); } // // ODReplayDSTBLT() // Replays a DSTBLT order // void ASShare::ODReplayDSTBLT ( ASPerson * pasPerson, LPDSTBLT_ORDER pDstBlt, BOOL fPalRGB ) { DebugEntry(ASShare::ODReplayDSTBLT); TRACE_OUT(("ORDER: DstBlt X %hd Y %hd w %hd h %hd rop %08lX", pDstBlt->nLeftRect, pDstBlt->nTopRect, pDstBlt->nWidth, pDstBlt->nHeight, (UINT)ODConvertToWindowsROP(pDstBlt->bRop))); // // Apply DS origin offset ourselves (do not use transform) // PatBlt(pasPerson->m_pView->m_usrDC, pDstBlt->nLeftRect - pasPerson->m_pView->m_dsScreenOrigin.x, pDstBlt->nTopRect - pasPerson->m_pView->m_dsScreenOrigin.y, pDstBlt->nWidth, pDstBlt->nHeight, ODConvertToWindowsROP(pDstBlt->bRop)); DebugExitVOID(ASShare::ODReplayDSTBLT); } // // ASShare::ODReplayPATBLT() // Replays a PATBLT order // void ASShare::ODReplayPATBLT ( ASPerson * pasPerson, LPPATBLT_ORDER pPatblt, BOOL fPalRGB ) { TSHR_COLOR BackColor; TSHR_COLOR ForeColor; DebugEntry(ASShare::ODReplayPATBLT); TRACE_OUT(("ORDER: PatBlt BC %08lX FC %08lX Brush %02X %02X X %d Y %d w %d h %d rop %08lX", pPatblt->BackColor, pPatblt->ForeColor, pPatblt->BrushStyle, pPatblt->BrushHatch, pPatblt->nLeftRect, pPatblt->nTopRect, pPatblt->nWidth, pPatblt->nHeight, ODConvertToWindowsROP(pPatblt->bRop) )); ODAdjustColor(pasPerson, &(pPatblt->BackColor), &BackColor, OD_BACK_COLOR); ODAdjustColor(pasPerson, &(pPatblt->ForeColor), &ForeColor, OD_FORE_COLOR); ODUseBkColor(pasPerson, fPalRGB, BackColor); ODUseTextColor(pasPerson, fPalRGB, ForeColor); ODUseBrush(pasPerson, fPalRGB, pPatblt->BrushOrgX, pPatblt->BrushOrgY, pPatblt->BrushStyle, pPatblt->BrushHatch, ForeColor, pPatblt->BrushExtra); // // Apply DS origin offset ourselves (do not use transform) // PatBlt(pasPerson->m_pView->m_usrDC, pPatblt->nLeftRect - pasPerson->m_pView->m_dsScreenOrigin.x, pPatblt->nTopRect - pasPerson->m_pView->m_dsScreenOrigin.y, pPatblt->nWidth, pPatblt->nHeight, ODConvertToWindowsROP(pPatblt->bRop)); DebugExitVOID(ASShare::ODReplayPATBLT); } // // ASShare::ODReplaySCRBLT() // Replays SCRBLT order // void ASShare::ODReplaySCRBLT ( ASPerson * pasPerson, LPSCRBLT_ORDER pScrBlt, BOOL fPalRGB ) { DebugEntry(ASShare::ODReplaySCRBLT); TRACE_OUT(("ORDER: ScrBlt dx %d dy %d w %d h %d sx %d sy %d rop %08lX", pScrBlt->nLeftRect, pScrBlt->nTopRect, pScrBlt->nWidth, pScrBlt->nHeight, pScrBlt->nXSrc, pScrBlt->nYSrc, ODConvertToWindowsROP(pScrBlt->bRop))); // // Apply DS origin offset ourselves (do not use transform) // BitBlt(pasPerson->m_pView->m_usrDC, pScrBlt->nLeftRect - pasPerson->m_pView->m_dsScreenOrigin.x, pScrBlt->nTopRect - pasPerson->m_pView->m_dsScreenOrigin.y, pScrBlt->nWidth, pScrBlt->nHeight, pasPerson->m_pView->m_usrDC, pScrBlt->nXSrc - pasPerson->m_pView->m_dsScreenOrigin.x, pScrBlt->nYSrc - pasPerson->m_pView->m_dsScreenOrigin.y, ODConvertToWindowsROP(pScrBlt->bRop)); DebugExitVOID(ASShare::ODReplaySCRBLT); } // // ASShare::ODReplayMEMBLT() // Replays MEMBLT and MEMBLT_R2 orders // void ASShare::ODReplayMEMBLT ( ASPerson * pasPerson, LPMEMBLT_ORDER pMemBlt, BOOL fPalRGB ) { HPALETTE hpalOld; HPALETTE hpalOld2; TSHR_UINT16 cacheIndex; UINT nXSrc; HBITMAP cacheBitmap; HBITMAP hOldBitmap; COLORREF clrBk; COLORREF clrText; DebugEntry(ASShare::ODReplayMEMBLT); ValidateView(pasPerson); TRACE_OUT(("MEMBLT nXSrc %d",pMemBlt->nXSrc)); hpalOld = SelectPalette(pasPerson->m_pView->m_usrWorkDC, pasPerson->pmPalette, FALSE); RealizePalette(pasPerson->m_pView->m_usrWorkDC); hpalOld2 = SelectPalette( pasPerson->m_pView->m_usrDC, pasPerson->pmPalette, FALSE ); RealizePalette(pasPerson->m_pView->m_usrDC); // // Now get the source bitmap. The cache is defined by // hBitmap. For R1 protocols the cache index is indicated // by the source offset on the order. For R2 it is // indicated by a separate field in the order. // The color table index is in the high order of hBitmap // cacheIndex = ((LPMEMBLT_R2_ORDER)pMemBlt)->cacheIndex; nXSrc = pMemBlt->nXSrc; TRACE_OUT(( "MEMBLT color %d cache %d:%d", MEMBLT_COLORINDEX(pMemBlt), MEMBLT_CACHETABLE(pMemBlt), cacheIndex)); cacheBitmap = RBC_MapCacheIDToBitmapHandle(pasPerson, MEMBLT_CACHETABLE(pMemBlt), cacheIndex, MEMBLT_COLORINDEX(pMemBlt)); hOldBitmap = SelectBitmap(pasPerson->m_pView->m_usrWorkDC, cacheBitmap); TRACE_OUT(("ORDER: MemBlt dx %d dy %d w %d h %d sx %d sy %d rop %08lX", pMemBlt->nLeftRect, pMemBlt->nTopRect, pMemBlt->nWidth, pMemBlt->nHeight, nXSrc, pMemBlt->nYSrc, ODConvertToWindowsROP(pMemBlt->bRop))); // // ALWAYS set back/fore color to white/black in case of rops like // SRCAND or SRCINVERT which will use their values. // clrBk = SetBkColor(pasPerson->m_pView->m_usrDC, RGB(255, 255, 255)); clrText = SetTextColor(pasPerson->m_pView->m_usrDC, RGB(0, 0, 0)); // // Apply DS origin offset ourselves (do not use transform) // BitBlt(pasPerson->m_pView->m_usrDC, pMemBlt->nLeftRect- pasPerson->m_pView->m_dsScreenOrigin.x, pMemBlt->nTopRect - pasPerson->m_pView->m_dsScreenOrigin.y, pMemBlt->nWidth, pMemBlt->nHeight, pasPerson->m_pView->m_usrWorkDC, nXSrc, pMemBlt->nYSrc, ODConvertToWindowsROP(pMemBlt->bRop)); // // If the relevant property is set hatch the area in blue. // if (m_usrHatchBitmaps) { SDP_DrawHatchedRect(pasPerson->m_pView->m_usrDC, pMemBlt->nLeftRect - pasPerson->m_pView->m_dsScreenOrigin.x, pMemBlt->nTopRect - pasPerson->m_pView->m_dsScreenOrigin.y, pMemBlt->nWidth, pMemBlt->nHeight, USR_HATCH_COLOR_BLUE); } // // Restore back, text colors // SetTextColor(pasPerson->m_pView->m_usrDC, clrText); SetBkColor(pasPerson->m_pView->m_usrDC, clrBk); // // Deselect the bitmap from the DC. // SelectBitmap(pasPerson->m_pView->m_usrWorkDC, hOldBitmap); SelectPalette(pasPerson->m_pView->m_usrWorkDC, hpalOld, FALSE); SelectPalette(pasPerson->m_pView->m_usrDC, hpalOld2, FALSE); DebugExitVOID(ASShare::ODReplayMEMBLT); } // // ASShare::ODReplayMEM3BLT() // Replays MEM3BLT and MEM3BLT_R2 orders // void ASShare::ODReplayMEM3BLT ( ASPerson * pasPerson, LPMEM3BLT_ORDER pMem3Blt, BOOL fPalRGB ) { HPALETTE hpalOld; HPALETTE hpalOld2; TSHR_UINT16 cacheIndex; int nXSrc; HBITMAP cacheBitmap; HBITMAP hOldBitmap; TSHR_COLOR BackColor; TSHR_COLOR ForeColor; DebugEntry(ASShare::ODReplayMEM3BLT); ValidateView(pasPerson); TRACE_OUT(("MEM3BLT nXSrc %d",pMem3Blt->nXSrc)); TRACE_OUT(("ORDER: Mem3Blt brush %04lX %04lX dx %d dy %d "\ "w %d h %d sx %d sy %d rop %08lX", pMem3Blt->BrushStyle, pMem3Blt->BrushHatch, pMem3Blt->nLeftRect, pMem3Blt->nTopRect, pMem3Blt->nWidth, pMem3Blt->nHeight, pMem3Blt->nXSrc, pMem3Blt->nYSrc, (UINT)ODConvertToWindowsROP(pMem3Blt->bRop))); hpalOld = SelectPalette(pasPerson->m_pView->m_usrWorkDC, pasPerson->pmPalette, FALSE); RealizePalette(pasPerson->m_pView->m_usrWorkDC); hpalOld2 = SelectPalette( pasPerson->m_pView->m_usrDC, pasPerson->pmPalette, FALSE); RealizePalette(pasPerson->m_pView->m_usrDC); // // Now get the source bitmap. The cache is defined by // hBitmap. For R1 protocols the cache index is indicated // by the source offset on the order. For R2 it is // indicated by a separate field in the order. // The color table index is in the high order of hBitmap // cacheIndex = ((LPMEM3BLT_R2_ORDER)pMem3Blt)->cacheIndex; nXSrc = pMem3Blt->nXSrc; TRACE_OUT(("MEM3BLT color %d cache %d:%d", MEMBLT_COLORINDEX(pMem3Blt), MEMBLT_CACHETABLE(pMem3Blt), cacheIndex)); cacheBitmap = RBC_MapCacheIDToBitmapHandle(pasPerson, MEMBLT_CACHETABLE(pMem3Blt), cacheIndex, MEMBLT_COLORINDEX(pMem3Blt)); hOldBitmap = SelectBitmap(pasPerson->m_pView->m_usrWorkDC, cacheBitmap); ODAdjustColor(pasPerson, &(pMem3Blt->BackColor), &BackColor, OD_BACK_COLOR); ODAdjustColor(pasPerson, &(pMem3Blt->ForeColor), &ForeColor, OD_FORE_COLOR); ODUseBkColor(pasPerson, fPalRGB, BackColor); ODUseTextColor(pasPerson, fPalRGB, ForeColor); ODUseBrush(pasPerson, fPalRGB, pMem3Blt->BrushOrgX, pMem3Blt->BrushOrgY, pMem3Blt->BrushStyle, pMem3Blt->BrushHatch, ForeColor, pMem3Blt->BrushExtra); // // Apply DS origin offset ourselves (do not use transform) // BitBlt(pasPerson->m_pView->m_usrDC, pMem3Blt->nLeftRect - pasPerson->m_pView->m_dsScreenOrigin.x, pMem3Blt->nTopRect - pasPerson->m_pView->m_dsScreenOrigin.y, pMem3Blt->nWidth, pMem3Blt->nHeight, pasPerson->m_pView->m_usrWorkDC, nXSrc, pMem3Blt->nYSrc, ODConvertToWindowsROP(pMem3Blt->bRop)); // // If the relevant property is set hatch the area in blue. // if (m_usrHatchBitmaps) { SDP_DrawHatchedRect(pasPerson->m_pView->m_usrDC, pMem3Blt->nLeftRect - pasPerson->m_pView->m_dsScreenOrigin.x, pMem3Blt->nTopRect - pasPerson->m_pView->m_dsScreenOrigin.y, pMem3Blt->nWidth, pMem3Blt->nHeight, USR_HATCH_COLOR_BLUE); } // // Deselect the bitmap from the DC. // SelectBitmap(pasPerson->m_pView->m_usrWorkDC, hOldBitmap); SelectPalette(pasPerson->m_pView->m_usrWorkDC, hpalOld, FALSE); SelectPalette(pasPerson->m_pView->m_usrDC, hpalOld2, FALSE); DebugExitVOID(ASShare::ODReplayMEM3BLT); } // // ASShare::ODReplayRECTANGLE() // Replays RECTANGLE order // void ASShare::ODReplayRECTANGLE ( ASPerson * pasPerson, LPRECTANGLE_ORDER pRectangle, BOOL fPalRGB ) { TSHR_COLOR BackColor; TSHR_COLOR ForeColor; TSHR_COLOR PenColor; DebugEntry(ASShare::ODReplayRECTANGLE); TRACE_OUT(("ORDER: Rectangle BC %08lX FC %08lX BM %04hX brush %02hX " \ "%02hX rop2 %04hX pen %04hX %04hX %08lX rect %d %d %d %d", pRectangle->BackColor, pRectangle->ForeColor, (TSHR_UINT16)pRectangle->BackMode, (TSHR_UINT16)pRectangle->BrushStyle, (TSHR_UINT16)pRectangle->BrushHatch, (TSHR_UINT16)pRectangle->ROP2, (TSHR_UINT16)pRectangle->PenStyle, (TSHR_UINT16)pRectangle->PenWidth, pRectangle->PenColor, (int)pRectangle->nLeftRect, (int)pRectangle->nTopRect, (int)pRectangle->nRightRect + 1, (int)pRectangle->nBottomRect + 1)); ODAdjustColor(pasPerson, &(pRectangle->BackColor), &BackColor, OD_BACK_COLOR); ODAdjustColor(pasPerson, &(pRectangle->ForeColor), &ForeColor, OD_FORE_COLOR); ODAdjustColor(pasPerson, &(pRectangle->PenColor), &PenColor, OD_PEN_COLOR); ODUseBkColor(pasPerson, fPalRGB, BackColor); ODUseTextColor(pasPerson, fPalRGB, ForeColor); ODUseBkMode(pasPerson, pRectangle->BackMode); ODUseBrush(pasPerson, fPalRGB, pRectangle->BrushOrgX, pRectangle->BrushOrgY, pRectangle->BrushStyle, pRectangle->BrushHatch, ForeColor, pRectangle->BrushExtra); ODUseROP2(pasPerson, pRectangle->ROP2); ODUsePen(pasPerson, fPalRGB, pRectangle->PenStyle, pRectangle->PenWidth, PenColor); // // The rectangle in the order is inclusive but Windows works // with exclusive rectangles. // // Apply DS origin offset ourselves (do not use transform) // Rectangle(pasPerson->m_pView->m_usrDC, pRectangle->nLeftRect - pasPerson->m_pView->m_dsScreenOrigin.x, pRectangle->nTopRect - pasPerson->m_pView->m_dsScreenOrigin.y, pRectangle->nRightRect - pasPerson->m_pView->m_dsScreenOrigin.x + 1, pRectangle->nBottomRect- pasPerson->m_pView->m_dsScreenOrigin.y + 1); DebugExitVOID(ASShare::ODReplayRECTANGLE); } // // ASShare::ODReplayPOLYGON() // Replays POLYGON order // void ASShare::ODReplayPOLYGON ( ASPerson * pasPerson, LPPOLYGON_ORDER pPolygon, BOOL fPalRGB ) { POINT aP[ORD_MAX_POLYGON_POINTS]; UINT i; UINT cPoints; TSHR_COLOR BackColor; TSHR_COLOR ForeColor; TSHR_COLOR PenColor; DebugEntry(ASShare::ODReplayPOLYGON); cPoints = pPolygon->variablePoints.len / sizeof(pPolygon->variablePoints.aPoints[0]); TRACE_OUT(("ORDER: Polygon BC %08lX FC %08lX BM %04hX brush %02hX %02hX " "%02hX %02hX rop2 %04hX pen %04hX %04hX %08lX points %d", pPolygon->BackColor, pPolygon->ForeColor, (TSHR_UINT16)pPolygon->BackMode, (TSHR_UINT16)pPolygon->BrushStyle, (TSHR_UINT16)pPolygon->BrushHatch, (TSHR_UINT16)pPolygon->ROP2, (TSHR_UINT16)pPolygon->PenStyle, (TSHR_UINT16)pPolygon->PenWidth, pPolygon->PenColor, cPoints)); // // Apply DS origin offset ourselves (do not use transform) // while copying to native size point array. // for (i = 0; i < cPoints; i++) { TRACE_OUT(( "aPoints[%u]: %d,%d", i, (int)(pPolygon->variablePoints.aPoints[i].x), (int)(pPolygon->variablePoints.aPoints[i].y))); aP[i].x = pPolygon->variablePoints.aPoints[i].x - pasPerson->m_pView->m_dsScreenOrigin.x; aP[i].y = pPolygon->variablePoints.aPoints[i].y - pasPerson->m_pView->m_dsScreenOrigin.y; } ODAdjustColor(pasPerson, &(pPolygon->BackColor), &BackColor, OD_BACK_COLOR); ODAdjustColor(pasPerson, &(pPolygon->ForeColor), &ForeColor, OD_FORE_COLOR); ODAdjustColor(pasPerson, &(pPolygon->PenColor), &PenColor, OD_PEN_COLOR); ODUseBkColor(pasPerson, fPalRGB, BackColor); ODUseTextColor(pasPerson, fPalRGB, ForeColor); ODUseBkMode(pasPerson, pPolygon->BackMode); ODUseBrush(pasPerson, fPalRGB, pPolygon->BrushOrgX, pPolygon->BrushOrgY, pPolygon->BrushStyle, pPolygon->BrushHatch, ForeColor, pPolygon->BrushExtra); ODUseROP2(pasPerson, pPolygon->ROP2); ODUsePen(pasPerson, fPalRGB, pPolygon->PenStyle, pPolygon->PenWidth, PenColor); ODUseFillMode(pasPerson, pPolygon->FillMode); Polygon(pasPerson->m_pView->m_usrDC, aP, cPoints); DebugExitVOID(ASShare::ODReplayPOLYGON); } // // ASShare::ODReplayPIE() // Replays PIE order // void ASShare::ODReplayPIE ( ASPerson * pasPerson, LPPIE_ORDER pPie, BOOL fPalRGB ) { TSHR_COLOR BackColor; TSHR_COLOR ForeColor; TSHR_COLOR PenColor; DebugEntry(ASShare::ODReplayPIE); TRACE_OUT(("ORDER: Pie BC %08lX FC %08lX BM %04hX brush %02hX " " %02hX rop2 %04hX pen %04hX %04hX %08lX rect %d %d %d %d", pPie->BackColor, pPie->ForeColor, (TSHR_UINT16)pPie->BackMode, (TSHR_UINT16)pPie->BrushStyle, (TSHR_UINT16)pPie->BrushHatch, (TSHR_UINT16)pPie->ROP2, (TSHR_UINT16)pPie->PenStyle, (TSHR_UINT16)pPie->PenWidth, pPie->PenColor, (int)pPie->nLeftRect, (int)pPie->nTopRect, (int)pPie->nRightRect + 1, (int)pPie->nBottomRect + 1)); ODAdjustColor(pasPerson, &(pPie->BackColor), &BackColor, OD_BACK_COLOR); ODAdjustColor(pasPerson, &(pPie->ForeColor), &ForeColor, OD_FORE_COLOR); ODAdjustColor(pasPerson, &(pPie->PenColor), &PenColor, OD_PEN_COLOR); ODUseBkColor(pasPerson, fPalRGB, BackColor); ODUseTextColor(pasPerson, fPalRGB, ForeColor); ODUseBkMode(pasPerson, pPie->BackMode); ODUseBrush(pasPerson, fPalRGB, pPie->BrushOrgX, pPie->BrushOrgY, pPie->BrushStyle, pPie->BrushHatch, ForeColor, pPie->BrushExtra); ODUseROP2(pasPerson, pPie->ROP2); ODUsePen(pasPerson, fPalRGB, pPie->PenStyle, pPie->PenWidth, PenColor); ODUseArcDirection(pasPerson, (int)pPie->ArcDirection); Pie(pasPerson->m_pView->m_usrDC, pPie->nLeftRect - pasPerson->m_pView->m_dsScreenOrigin.x, pPie->nTopRect - pasPerson->m_pView->m_dsScreenOrigin.y, pPie->nRightRect - pasPerson->m_pView->m_dsScreenOrigin.x + 1, pPie->nBottomRect - pasPerson->m_pView->m_dsScreenOrigin.y + 1, pPie->nXStart - pasPerson->m_pView->m_dsScreenOrigin.x, pPie->nYStart - pasPerson->m_pView->m_dsScreenOrigin.y, pPie->nXEnd - pasPerson->m_pView->m_dsScreenOrigin.x, pPie->nYEnd - pasPerson->m_pView->m_dsScreenOrigin.y); DebugExitVOID(ASShare::ODReplayPIE); } // // ASShare::ODReplayELLIPSE() // Replays ELLIPSE order // void ASShare::ODReplayELLIPSE ( ASPerson * pasPerson, LPELLIPSE_ORDER pEllipse, BOOL fPalRGB ) { TSHR_COLOR BackColor; TSHR_COLOR ForeColor; TSHR_COLOR PenColor; DebugEntry(ASShare::ODReplayELLIPSE); TRACE_OUT(("ORDER: Ellipse BC %08lX FC %08lX BM %04hX brush %02hX %02hX " "rop2 %04hX pen %04hX %04hX %08lX rect %d %d %d %d", pEllipse->BackColor, pEllipse->ForeColor, (TSHR_UINT16)pEllipse->BackMode, (TSHR_UINT16)pEllipse->BrushStyle, (TSHR_UINT16)pEllipse->BrushHatch, (TSHR_UINT16)pEllipse->ROP2, (TSHR_UINT16)pEllipse->PenStyle, (TSHR_UINT16)pEllipse->PenWidth, pEllipse->PenColor, (int)pEllipse->nLeftRect, (int)pEllipse->nTopRect, (int)pEllipse->nRightRect + 1, (int)pEllipse->nBottomRect + 1)); ODAdjustColor(pasPerson, &(pEllipse->BackColor), &BackColor, OD_BACK_COLOR); ODAdjustColor(pasPerson, &(pEllipse->ForeColor), &ForeColor, OD_FORE_COLOR); ODAdjustColor(pasPerson, &(pEllipse->PenColor), &PenColor, OD_PEN_COLOR); ODUseBkColor(pasPerson, fPalRGB, BackColor); ODUseTextColor(pasPerson, fPalRGB, ForeColor); ODUseBkMode(pasPerson, pEllipse->BackMode); ODUseBrush(pasPerson, fPalRGB, pEllipse->BrushOrgX, pEllipse->BrushOrgY, pEllipse->BrushStyle, pEllipse->BrushHatch, ForeColor, pEllipse->BrushExtra); ODUseROP2(pasPerson, pEllipse->ROP2); ODUsePen(pasPerson, fPalRGB, pEllipse->PenStyle, pEllipse->PenWidth, PenColor); Ellipse(pasPerson->m_pView->m_usrDC, pEllipse->nLeftRect - pasPerson->m_pView->m_dsScreenOrigin.x, pEllipse->nTopRect - pasPerson->m_pView->m_dsScreenOrigin.y, pEllipse->nRightRect - pasPerson->m_pView->m_dsScreenOrigin.x + 1, pEllipse->nBottomRect - pasPerson->m_pView->m_dsScreenOrigin.y + 1); DebugExitVOID(ASShare::ODReplayELLIPSE); } // // ASShare::ODReplayARC() // Replays ARC order // void ASShare::ODReplayARC ( ASPerson * pasPerson, LPARC_ORDER pArc, BOOL fPalRGB ) { TSHR_COLOR BackColor; TSHR_COLOR PenColor; DebugEntry(ASShare::ODReplayARC); TRACE_OUT(("ORDER: Arc BC %08lX BM %04hX rop2 %04hX pen %04hX " "%04hX %08lX rect %d %d %d %d", pArc->BackColor, (TSHR_UINT16)pArc->BackMode, (TSHR_UINT16)pArc->ROP2, (TSHR_UINT16)pArc->PenStyle, (TSHR_UINT16)pArc->PenWidth, pArc->PenColor, (int)pArc->nLeftRect, (int)pArc->nTopRect, (int)pArc->nRightRect + 1, (int)pArc->nBottomRect + 1)); ODAdjustColor(pasPerson, &(pArc->BackColor), &BackColor, OD_BACK_COLOR); ODAdjustColor(pasPerson, &(pArc->PenColor), &PenColor, OD_PEN_COLOR); ODUseBkColor(pasPerson, fPalRGB, BackColor); ODUseBkMode(pasPerson, pArc->BackMode); ODUseROP2(pasPerson, pArc->ROP2); ODUsePen(pasPerson, fPalRGB, pArc->PenStyle, pArc->PenWidth, PenColor); ODUseArcDirection(pasPerson, pArc->ArcDirection); Arc(pasPerson->m_pView->m_usrDC, pArc->nLeftRect - pasPerson->m_pView->m_dsScreenOrigin.x, pArc->nTopRect - pasPerson->m_pView->m_dsScreenOrigin.y, pArc->nRightRect - pasPerson->m_pView->m_dsScreenOrigin.x + 1, pArc->nBottomRect - pasPerson->m_pView->m_dsScreenOrigin.y + 1, pArc->nXStart - pasPerson->m_pView->m_dsScreenOrigin.x, pArc->nYStart - pasPerson->m_pView->m_dsScreenOrigin.y, pArc->nXEnd - pasPerson->m_pView->m_dsScreenOrigin.x, pArc->nYEnd - pasPerson->m_pView->m_dsScreenOrigin.y); DebugExitVOID(ASShare::ODReplayARC); } // // ASShare::ODReplayCHORD() // Replays CHORD order // void ASShare::ODReplayCHORD ( ASPerson * pasPerson, LPCHORD_ORDER pChord, BOOL fPalRGB ) { TSHR_COLOR BackColor; TSHR_COLOR ForeColor; TSHR_COLOR PenColor; DebugEntry(ASShare::ODReplayCHORD); TRACE_OUT(("ORDER: Chord BC %08lX FC %08lX BM %04hX brush " "%02hX %02hX rop2 %04hX pen %04hX %04hX %08lX rect " "%d %d %d %d", pChord->BackColor, pChord->ForeColor, (TSHR_UINT16)pChord->BackMode, (TSHR_UINT16)pChord->BrushStyle, (TSHR_UINT16)pChord->BrushHatch, (TSHR_UINT16)pChord->ROP2, (TSHR_UINT16)pChord->PenStyle, (TSHR_UINT16)pChord->PenWidth, pChord->PenColor, (int)pChord->nLeftRect, (int)pChord->nTopRect, (int)pChord->nRightRect + 1, (int)pChord->nBottomRect + 1)); ODAdjustColor(pasPerson, &(pChord->BackColor), &BackColor, OD_BACK_COLOR); ODAdjustColor(pasPerson, &(pChord->ForeColor), &ForeColor, OD_FORE_COLOR); ODAdjustColor(pasPerson, &(pChord->PenColor), &PenColor, OD_PEN_COLOR); ODUseBkColor(pasPerson, fPalRGB, BackColor); ODUseTextColor(pasPerson, fPalRGB, ForeColor); ODUseBkMode(pasPerson, pChord->BackMode); ODUseBrush(pasPerson, fPalRGB, pChord->BrushOrgX, pChord->BrushOrgY, pChord->BrushStyle, pChord->BrushHatch, ForeColor, pChord->BrushExtra); ODUseROP2(pasPerson, pChord->ROP2); ODUsePen(pasPerson, fPalRGB, pChord->PenStyle, pChord->PenWidth, PenColor); ODUseArcDirection(pasPerson, pChord->ArcDirection); Chord(pasPerson->m_pView->m_usrDC, pChord->nLeftRect - pasPerson->m_pView->m_dsScreenOrigin.x, pChord->nTopRect - pasPerson->m_pView->m_dsScreenOrigin.y, pChord->nRightRect - pasPerson->m_pView->m_dsScreenOrigin.x + 1, pChord->nBottomRect - pasPerson->m_pView->m_dsScreenOrigin.y + 1, pChord->nXStart - pasPerson->m_pView->m_dsScreenOrigin.x, pChord->nYStart - pasPerson->m_pView->m_dsScreenOrigin.y, pChord->nXEnd - pasPerson->m_pView->m_dsScreenOrigin.x, pChord->nYEnd - pasPerson->m_pView->m_dsScreenOrigin.y); DebugExitVOID(ASShare::ODReplayCHORD); } // // ASShare::ODReplayPOLYBEZIER() // Replays POLYBEZIER order // void ASShare::ODReplayPOLYBEZIER ( ASPerson * pasPerson, LPPOLYBEZIER_ORDER pPolyBezier, BOOL fPalRGB ) { POINT aP[ORD_MAX_POLYBEZIER_POINTS]; UINT i; UINT cPoints; TSHR_COLOR BackColor; TSHR_COLOR ForeColor; TSHR_COLOR PenColor; DebugEntry(ASShare::ODReplayPOLYBEZIER); cPoints = pPolyBezier->variablePoints.len / sizeof(pPolyBezier->variablePoints.aPoints[0]); TRACE_OUT(("ORDER: PolyBezier BC %08lX FC %08lX BM %04hX rop2 " "%04hX pen %04hX %04hX %08lX points %d", pPolyBezier->BackColor, pPolyBezier->ForeColor, (TSHR_UINT16)pPolyBezier->BackMode, (TSHR_UINT16)pPolyBezier->ROP2, (TSHR_UINT16)pPolyBezier->PenStyle, (TSHR_UINT16)pPolyBezier->PenWidth, pPolyBezier->PenColor, (int)cPoints)); // // Apply DS origin offset ourselves (do not use transform) // while copying to native size point array. // for (i = 0; i < cPoints; i++) { TRACE_OUT(("aPoints[%u]: %d,%d",(UINT)i, (int)(pPolyBezier->variablePoints.aPoints[i].x), (int)(pPolyBezier->variablePoints.aPoints[i].y))); aP[i].x = pPolyBezier->variablePoints.aPoints[i].x - pasPerson->m_pView->m_dsScreenOrigin.x; aP[i].y = pPolyBezier->variablePoints.aPoints[i].y - pasPerson->m_pView->m_dsScreenOrigin.y; } ODAdjustColor(pasPerson, &(pPolyBezier->BackColor), &BackColor, OD_BACK_COLOR); ODAdjustColor(pasPerson, &(pPolyBezier->ForeColor), &ForeColor, OD_FORE_COLOR); ODAdjustColor(pasPerson, &(pPolyBezier->PenColor), &PenColor, OD_PEN_COLOR); ODUseBkColor(pasPerson, fPalRGB, BackColor); ODUseTextColor(pasPerson, fPalRGB, ForeColor); ODUseBkMode(pasPerson, pPolyBezier->BackMode); ODUseROP2(pasPerson, pPolyBezier->ROP2); ODUsePen(pasPerson, fPalRGB, pPolyBezier->PenStyle, pPolyBezier->PenWidth, PenColor); PolyBezier(pasPerson->m_pView->m_usrDC, aP, cPoints); DebugExitVOID(ASShare::ODReplayPOLYBEZIER); } // // ASShare::ODReplayROUNDRECT() // void ASShare::ODReplayROUNDRECT ( ASPerson * pasPerson, LPROUNDRECT_ORDER pRoundRect, BOOL fPalRGB ) { TSHR_COLOR BackColor; TSHR_COLOR ForeColor; TSHR_COLOR PenColor; DebugEntry(ASShare::ODReplayROUNDRECT); TRACE_OUT(("ORDER: RoundRect BC %08lX FC %08lX BM %04hX " \ "brush %02hX %02hX rop2 %04hX pen %04hX %04hX " \ "%08lX rect %d %d %d %d ellipse %d %d", pRoundRect->BackColor, pRoundRect->ForeColor, (TSHR_UINT16)pRoundRect->BackMode, (TSHR_UINT16)pRoundRect->BrushStyle, (TSHR_UINT16)pRoundRect->BrushHatch, (TSHR_UINT16)pRoundRect->ROP2, (TSHR_UINT16)pRoundRect->PenStyle, (TSHR_UINT16)pRoundRect->PenWidth, pRoundRect->PenColor, (int)pRoundRect->nLeftRect, (int)pRoundRect->nTopRect, (int)pRoundRect->nRightRect, (int)pRoundRect->nBottomRect, (int)pRoundRect->nEllipseWidth, (int)pRoundRect->nEllipseHeight)); ODAdjustColor(pasPerson, &(pRoundRect->BackColor), &BackColor, OD_BACK_COLOR); ODAdjustColor(pasPerson, &(pRoundRect->ForeColor), &ForeColor, OD_FORE_COLOR); ODAdjustColor(pasPerson, &(pRoundRect->PenColor), &PenColor, OD_PEN_COLOR); ODUseBkColor(pasPerson, fPalRGB, BackColor); ODUseTextColor(pasPerson, fPalRGB, ForeColor); ODUseBkMode(pasPerson, pRoundRect->BackMode); ODUseBrush(pasPerson, fPalRGB, pRoundRect->BrushOrgX, pRoundRect->BrushOrgY, pRoundRect->BrushStyle, pRoundRect->BrushHatch, ForeColor, pRoundRect->BrushExtra); ODUseROP2(pasPerson, pRoundRect->ROP2); ODUsePen(pasPerson, fPalRGB, pRoundRect->PenStyle, pRoundRect->PenWidth, PenColor); // // Apply DS origin offset ourselves (do not use transform). // RoundRect(pasPerson->m_pView->m_usrDC, pRoundRect->nLeftRect - pasPerson->m_pView->m_dsScreenOrigin.x, pRoundRect->nTopRect - pasPerson->m_pView->m_dsScreenOrigin.y, pRoundRect->nRightRect - pasPerson->m_pView->m_dsScreenOrigin.x + 1, pRoundRect->nBottomRect- pasPerson->m_pView->m_dsScreenOrigin.y + 1, pRoundRect->nEllipseWidth, pRoundRect->nEllipseHeight); DebugExitVOID(ASShare::ODReplayROUNDRECT); } // // ASShare::ODReplayLINETO() // Replays LINETO order // void ASShare::ODReplayLINETO ( ASPerson * pasPerson, LPLINETO_ORDER pLineTo, BOOL fPalRGB ) { TSHR_COLOR BackColor; TSHR_COLOR PenColor; DebugEntry(ASShare::ODReplayLINETO); TRACE_OUT(("ORDER: LineTo BC %08lX BM %04X rop2 %04X pen " \ "%04X %04X %08lX x1 %d y1 %d x2 %d y2 %d", pLineTo->BackColor, pLineTo->BackMode, pLineTo->ROP2, pLineTo->PenStyle, pLineTo->PenWidth, pLineTo->PenColor, pLineTo->nXStart, pLineTo->nYStart, pLineTo->nXEnd, pLineTo->nYEnd)); ODAdjustColor(pasPerson, &(pLineTo->BackColor), &BackColor, OD_BACK_COLOR); ODAdjustColor(pasPerson, &(pLineTo->PenColor), &PenColor, OD_PEN_COLOR); ODUseBkColor(pasPerson, fPalRGB, BackColor); ODUseBkMode(pasPerson, pLineTo->BackMode); ODUseROP2(pasPerson, pLineTo->ROP2); ODUsePen(pasPerson, fPalRGB, pLineTo->PenStyle, pLineTo->PenWidth, PenColor); // // Apply DS origin offset ourselves (do not use transform) // MoveToEx(pasPerson->m_pView->m_usrDC, pLineTo->nXStart - pasPerson->m_pView->m_dsScreenOrigin.x, pLineTo->nYStart - pasPerson->m_pView->m_dsScreenOrigin.y, NULL); LineTo(pasPerson->m_pView->m_usrDC, pLineTo->nXEnd - pasPerson->m_pView->m_dsScreenOrigin.x, pLineTo->nYEnd - pasPerson->m_pView->m_dsScreenOrigin.y); DebugExitVOID(ASShare::ODReplayLINETO); } // // ASShare::ODReplayEXTTEXTOUT() // Replays EXTTEXTOUT order // void ASShare::ODReplayEXTTEXTOUT ( ASPerson * pasPerson, LPEXTTEXTOUT_ORDER pExtTextOut, BOOL fPalRGB ) { LPINT lpDx; RECT rect; DebugEntry(ASShare::ODReplayEXTTEXTOUT); ValidateView(pasPerson); // // Convert from TSHR_RECT32 to RECT we can manipulate // And convert to screen coords // rect.left = pExtTextOut->rectangle.left; rect.top = pExtTextOut->rectangle.top; rect.right = pExtTextOut->rectangle.right; rect.bottom = pExtTextOut->rectangle.bottom; OffsetRect(&rect, -pasPerson->m_pView->m_dsScreenOrigin.x, -pasPerson->m_pView->m_dsScreenOrigin.y); // // Get pointers to the optional/variable parameters. // if (pExtTextOut->fuOptions & ETO_WINDOWS) { // // Make the rectangle exclusive for Windows to use. // rect.right++; rect.bottom++; } if (pExtTextOut->fuOptions & ETO_LPDX) { // // if OE2 encoding is in use, the 'variable' string is // in fact fixed at its maximum possible value, hence // deltaX is always in the same place. // if (m_oefOE2EncodingOn) { lpDx = (LPINT)(pExtTextOut->variableDeltaX.deltaX); } else { // // If OE2 encoding is not in use, the variable string is // truly variable, hence the position of deltaX depends // on the length of the string. // lpDx = (LPINT)( ((LPBYTE)pExtTextOut) + FIELD_OFFSET(EXTTEXTOUT_ORDER, variableString.string) + pExtTextOut->variableString.len + sizeof(pExtTextOut->variableDeltaX.len) ); } // // Note that deltaLen contains the number of bytes used // for the deltas, NOT the number of deltas. // // // THERE IS A BUG IN THE ORDER ENCODING - THE DELTA // LENGTH FIELD IS NOT ALWAYS SET UP CORRECTLY. USE // THE STRING LENGTH INSTEAD. // } else { lpDx = NULL; } TRACE_OUT(( "ORDER: ExtTextOut %u %s", pExtTextOut->variableString.len, pExtTextOut->variableString.string)); // // Call our internal routine to draw the text // ODDrawTextOrder(pasPerson, TRUE, // ExtTextOut fPalRGB, &pExtTextOut->common, pExtTextOut->variableString.string, pExtTextOut->variableString.len, &rect, pExtTextOut->fuOptions, lpDx); DebugExitVOID(ASShare::ODReplayEXTTEXTOUT); } // // ASShare::ODReplayTEXTOUT() // Replays TEXTOUT order // void ASShare::ODReplayTEXTOUT ( ASPerson * pasPerson, LPTEXTOUT_ORDER pTextOut, BOOL fPalRGB ) { DebugEntry(ASShare::ODReplayTEXTOUT); TRACE_OUT(("ORDER: TextOut len %hu '%s' flags %04hx bc %08lX " \ "fc %08lX bm %04hx", (TSHR_UINT16)(pTextOut->variableString.len), pTextOut->variableString.string, pTextOut->common.FontFlags, pTextOut->common.BackColor, pTextOut->common.ForeColor, pTextOut->common.BackMode)); // // Call our internal routine to draw the text // ODDrawTextOrder(pasPerson, FALSE, // Not ExtTextOut fPalRGB, &pTextOut->common, pTextOut->variableString.string, pTextOut->variableString.len, NULL, // ExtTextOut specific 0, // ExtTextOut specific NULL); // ExtTextOut specific DebugExitVOID(ASShare::ODReplayTEXTOUT); } // // ASShare::ODReplayOPAQUERECT() // Replays OPAQUERECT order // void ASShare::ODReplayOPAQUERECT ( ASPerson * pasPerson, LPOPAQUERECT_ORDER pOpaqueRect, BOOL fPalRGB ) { RECT rect; TSHR_COLOR ForeColor; DebugEntry(ASShare::ODReplayOPAQUERECT); TRACE_OUT(( "ORDER: OpaqueRect BC %08lX x %d y %d w %x h %d", pOpaqueRect->Color, (int)pOpaqueRect->nLeftRect, (int)pOpaqueRect->nTopRect, (int)pOpaqueRect->nWidth, (int)pOpaqueRect->nHeight)); ODAdjustColor(pasPerson, &(pOpaqueRect->Color), &ForeColor, OD_FORE_COLOR); ODUseBkColor(pasPerson, fPalRGB, ForeColor); // // Apply DS origin offset ourselves (do not use transform) // rect.left = pOpaqueRect->nLeftRect- pasPerson->m_pView->m_dsScreenOrigin.x; rect.top = pOpaqueRect->nTopRect - pasPerson->m_pView->m_dsScreenOrigin.y; rect.right = rect.left + pOpaqueRect->nWidth; rect.bottom = rect.top + pOpaqueRect->nHeight; ExtTextOut(pasPerson->m_pView->m_usrDC, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL); DebugExitVOID(ASShare::ODReplayOPAQUERECT); } // // OD_ResetRectRegion() // void ASShare::OD_ResetRectRegion(ASPerson * pasPerson) { DebugEntry(ASShare::OD_ResetRectRegion); ValidateView(pasPerson); if (!pasPerson->m_pView->m_odRectReset) { SelectClipRgn(pasPerson->m_pView->m_usrDC, NULL); // // Indicate that the region is currently reset. // pasPerson->m_pView->m_odRectReset = TRUE; } DebugExitVOID(ASShare::OD_ResetRectRegion); } // // ODUseFont() // void ASShare::ODUseFont ( ASPerson * pasPerson, LPSTR pName, UINT facelength, UINT CodePage, UINT MaxHeight, UINT Height, UINT Width, UINT Weight, UINT flags ) { BOOL rc = TRUE; TEXTMETRIC* pfm = NULL; UINT textAlign; DebugEntry(ASShare::ODUseFont); ValidateView(pasPerson); // // If the baseline alignment flag has been set or cleared, change the // alignment in our surface (do this now before we reset the // odLastFontFlags variable). // if ((flags & NF_BASELINE) != (pasPerson->m_pView->m_odLastFontFlags & NF_BASELINE)) { textAlign = GetTextAlign(pasPerson->m_pView->m_usrDC); if ((flags & NF_BASELINE) != 0) { // // We are setting the baseline alignment flag. We have to // clear the top alignment flag and set the baseline flag (they // are mutually exclusive). // textAlign &= ~TA_TOP; textAlign |= TA_BASELINE; } else { // // We are clearing the baseline alignment flag. We have to set // the top alignment flag and clear the baseline flag (they are // mutually exclusive). // textAlign |= TA_TOP; textAlign &= ~TA_BASELINE; } SetTextAlign(pasPerson->m_pView->m_usrDC, textAlign); } // // The font face string is NOT null terminated in the order data so we // must use strncmp. // if ((pasPerson->m_pView->m_odLastFontFaceLen != facelength ) || (memcmp((LPSTR)pasPerson->m_pView->m_odLastFaceName,pName,facelength) != 0 ) || (pasPerson->m_pView->m_odLastFontCodePage != CodePage ) || (pasPerson->m_pView->m_odLastFontHeight != Height ) || (pasPerson->m_pView->m_odLastFontWidth != Width ) || (pasPerson->m_pView->m_odLastFontWeight != Weight ) || (pasPerson->m_pView->m_odLastFontFlags != flags )) { TRACE_OUT(( "Change font from %s (CodePage %d height %d width %d " \ "weight %d flags %04X) to %s (CodePage %d height %d " \ "width %d weight %u flags %04X)", pasPerson->m_pView->m_odLastFaceName, pasPerson->m_pView->m_odLastFontCodePage, pasPerson->m_pView->m_odLastFontHeight, pasPerson->m_pView->m_odLastFontWidth, pasPerson->m_pView->m_odLastFontWeight, pasPerson->m_pView->m_odLastFontFlags, pName, CodePage, Height, Width, Weight, flags)); memcpy(pasPerson->m_pView->m_odLastFaceName, pName, facelength); pasPerson->m_pView->m_odLastFontFaceLen = facelength; pasPerson->m_pView->m_odLastFaceName[facelength] = '\0'; pasPerson->m_pView->m_odLastFontCodePage = CodePage; pasPerson->m_pView->m_odLastFontHeight = Height; pasPerson->m_pView->m_odLastFontWidth = Width; pasPerson->m_pView->m_odLastFontWeight = Weight; pasPerson->m_pView->m_odLastFontFlags = flags; rc = USR_UseFont(pasPerson->m_pView->m_usrDC, &pasPerson->m_pView->m_odLastFontID, pfm, (LPSTR)pasPerson->m_pView->m_odLastFaceName, CodePage, MaxHeight, Height, Width, Weight, flags); } else { // // The font hasn't changed. But we must still select it in since // both OD2 and OD code select in fonts. // ASSERT(pasPerson->m_pView->m_odLastFontID != NULL); SelectFont(pasPerson->m_pView->m_usrDC, pasPerson->m_pView->m_odLastFontID); } DebugExitVOID(ASShare::ODUseFont); } // // FUNCTION: ASShare::ODUseRectRegion // // DESCRIPTION: // // Set the clipping rectangle in the ScreenBitmap to the given rectangle. // The values passed are inclusive. // // PARAMETERS: // void ASShare::ODUseRectRegion ( ASPerson * pasPerson, int left, int top, int right, int bottom ) { POINT aPoints[2]; HRGN hrgnRect; DebugEntry(ASShare::ODUseRectRegion); ValidateView(pasPerson); // Adjust for 2.x desktop scrolling left -= pasPerson->m_pView->m_dsScreenOrigin.x; top -= pasPerson->m_pView->m_dsScreenOrigin.y; right -= pasPerson->m_pView->m_dsScreenOrigin.x; bottom -= pasPerson->m_pView->m_dsScreenOrigin.y; if ((pasPerson->m_pView->m_odRectReset) || (left != pasPerson->m_pView->m_odLastLeft) || (top != pasPerson->m_pView->m_odLastTop) || (right != pasPerson->m_pView->m_odLastRight) || (bottom != pasPerson->m_pView->m_odLastBottom)) { // // The region clip rectangle has changed, so we change the region // in the screen bitmap DC. // aPoints[0].x = left; aPoints[0].y = top; aPoints[1].x = right; aPoints[1].y = bottom; // // Windows requires that the coordinates are in DEVICE values for // its SelectClipRgn call. // LPtoDP(pasPerson->m_pView->m_usrDC, aPoints, 2); if ((left > right) || (top > bottom)) { // // We get this for SaveScreenBitmap orders. SFR5292 // TRACE_OUT(( "Null bounds of region rect")); hrgnRect = CreateRectRgn(0, 0, 0, 0); } else { // We must add one to right & bottom since coords were inclusive hrgnRect = CreateRectRgn( aPoints[0].x, aPoints[0].y, aPoints[1].x+1, aPoints[1].y+1); } SelectClipRgn(pasPerson->m_pView->m_usrDC, hrgnRect); pasPerson->m_pView->m_odLastLeft = left; pasPerson->m_pView->m_odLastTop = top; pasPerson->m_pView->m_odLastRight = right; pasPerson->m_pView->m_odLastBottom = bottom; pasPerson->m_pView->m_odRectReset = FALSE; if (hrgnRect != NULL) { DeleteRgn(hrgnRect); } } DebugExitVOID(ASShare::ODUseRectRegion); } // // ODUseBrush creates the correct brush to use. NB. We rely on // UseTextColor and UseBKColor being called before this routine to set up // pasPerson->m_pView->m_odLastTextColor and pasPerson->m_pView->m_odLastBkColor correctly. // void ASShare::ODUseBrush ( ASPerson * pasPerson, BOOL fPalRGB, int x, int y, UINT Style, UINT Hatch, TSHR_COLOR Color, BYTE Extra[7] ) { HBRUSH hBrushNew = NULL; DebugEntry(ASShare::ODUseBrush); // Reset the origin if ((x != pasPerson->m_pView->m_odLastBrushOrgX) || (y != pasPerson->m_pView->m_odLastBrushOrgY)) { SetBrushOrgEx(pasPerson->m_pView->m_usrDC, x, y, NULL); // Update saved brush org pasPerson->m_pView->m_odLastBrushOrgX = x; pasPerson->m_pView->m_odLastBrushOrgY = y; } if ((Style != pasPerson->m_pView->m_odLastLogBrushStyle) || (Hatch != pasPerson->m_pView->m_odLastLogBrushHatch) || (memcmp(&Color, &pasPerson->m_pView->m_odLastLogBrushColor, sizeof(Color))) || (memcmp(Extra,pasPerson->m_pView->m_odLastLogBrushExtra,sizeof(pasPerson->m_pView->m_odLastLogBrushExtra))) || ((pasPerson->m_pView->m_odLastLogBrushStyle == BS_PATTERN) && ((pasPerson->m_pView->m_odLastTextColor != pasPerson->m_pView->m_odLastBrushTextColor) || (pasPerson->m_pView->m_odLastBkColor != pasPerson->m_pView->m_odLastBrushBkColor)))) { pasPerson->m_pView->m_odLastLogBrushStyle = Style; pasPerson->m_pView->m_odLastLogBrushHatch = Hatch; pasPerson->m_pView->m_odLastLogBrushColor = Color; memcpy(pasPerson->m_pView->m_odLastLogBrushExtra, Extra, sizeof(pasPerson->m_pView->m_odLastLogBrushExtra)); if (pasPerson->m_pView->m_odLastLogBrushStyle == BS_PATTERN) { // // A pattern from a bitmap is required. // if (pasPerson->m_pView->m_odLastBrushPattern == NULL) { TRACE_OUT(( "Creating bitmap to use for brush setup")); pasPerson->m_pView->m_odLastBrushPattern = CreateBitmap(8,8,1,1,NULL); } if (pasPerson->m_pView->m_odLastBrushPattern != NULL) { char lpBits[16]; // // Place the bitmap bits into an array of bytes in the // correct form for SetBitmapBits which uses 16 bits per // scanline. // lpBits[14] = (char)Hatch; lpBits[12] = Extra[0]; lpBits[10] = Extra[1]; lpBits[8] = Extra[2]; lpBits[6] = Extra[3]; lpBits[4] = Extra[4]; lpBits[2] = Extra[5]; lpBits[0] = Extra[6]; SetBitmapBits(pasPerson->m_pView->m_odLastBrushPattern,8*2,lpBits); hBrushNew = CreatePatternBrush(pasPerson->m_pView->m_odLastBrushPattern); if (hBrushNew == NULL) { ERROR_OUT(( "Failed to create pattern brush")); } else { pasPerson->m_pView->m_odLastBrushTextColor = pasPerson->m_pView->m_odLastTextColor; pasPerson->m_pView->m_odLastBrushBkColor = pasPerson->m_pView->m_odLastBkColor; } } } else { LOGBRUSH logBrush; logBrush.lbStyle = pasPerson->m_pView->m_odLastLogBrushStyle; logBrush.lbHatch = pasPerson->m_pView->m_odLastLogBrushHatch; logBrush.lbColor = ODCustomRGB(pasPerson->m_pView->m_odLastLogBrushColor.red, pasPerson->m_pView->m_odLastLogBrushColor.green, pasPerson->m_pView->m_odLastLogBrushColor.blue, fPalRGB); hBrushNew = CreateBrushIndirect(&logBrush); } if (hBrushNew == NULL) { ERROR_OUT(( "Failed to create brush")); } else { TRACE_OUT(( "Selecting new brush 0x%08x", hBrushNew)); DeleteBrush(SelectBrush(pasPerson->m_pView->m_usrDC, hBrushNew)); } } DebugExitVOID(ASShare::ODUseBrush); } // // ODDrawTextOrder() // Common text order playback code for EXTTEXTOUT and TEXTOUT // void ASShare::ODDrawTextOrder ( ASPerson * pasPerson, BOOL isExtTextOut, BOOL fPalRGB, LPCOMMON_TEXTORDER pCommon, LPSTR pText, UINT textLength, LPRECT pExtRect, UINT extOptions, LPINT pExtDx ) { LPSTR faceName; UINT faceNameLength; UINT maxFontHeight; TSHR_UINT16 nFontFlags; TSHR_UINT16 nCodePage; TSHR_COLOR BackColor; TSHR_COLOR ForeColor; DebugEntry(ASShare::ODDrawTextOrder); ODAdjustColor(pasPerson, &(pCommon->BackColor), &BackColor, OD_BACK_COLOR); ODAdjustColor(pasPerson, &(pCommon->ForeColor), &ForeColor, OD_FORE_COLOR); ODUseTextBkColor(pasPerson, fPalRGB, BackColor); ODUseTextColor(pasPerson, fPalRGB, ForeColor); ODUseBkMode(pasPerson, pCommon->BackMode); ODUseTextCharacterExtra(pasPerson, pCommon->CharExtra); ODUseTextJustification(pasPerson, pCommon->BreakExtra, pCommon->BreakCount); faceName = FH_GetFaceNameFromLocalHandle(pCommon->FontIndex, &faceNameLength); maxFontHeight = FH_GetMaxHeightFromLocalHandle(pCommon->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 = (TSHR_UINT16)FH_GetFontFlagsFromLocalHandle(pCommon->FontIndex); // // Get the local CodePage for the font. // nCodePage = (TSHR_UINT16)FH_GetCodePageFromLocalHandle(pCommon->FontIndex); ODUseFont(pasPerson, faceName, faceNameLength, nCodePage, maxFontHeight, pCommon->FontHeight, pCommon->FontWidth, pCommon->FontWeight, pCommon->FontFlags | (nFontFlags & NF_LOCAL)); // // Make the call. // if (isExtTextOut) { // // Apply DS origin offset ourselves (do not use transform) // ExtTextOut(pasPerson->m_pView->m_usrDC, pCommon->nXStart - pasPerson->m_pView->m_dsScreenOrigin.x, pCommon->nYStart - pasPerson->m_pView->m_dsScreenOrigin.y, extOptions & ETO_WINDOWS, pExtRect, pText, textLength, pExtDx); } else { // // Apply DS origin offset ourselves (do not use transform) // TextOut(pasPerson->m_pView->m_usrDC, pCommon->nXStart - pasPerson->m_pView->m_dsScreenOrigin.x, pCommon->nYStart - pasPerson->m_pView->m_dsScreenOrigin.y, pText, textLength); } DebugExitVOID(ASShare::ODDrawTextOrder); } // // ODAdjustColor() // // Used for playback on 4bpp devices. We convert colors that are 'close' // to VGA to their VGA equivalents. // // This function tries to find a close match in the VGA color set for a // given input color. Close is defined as follows: each color element // (red, green, blue) must be within 7 of the corresponding element in a // VGA color, without wrapping. For example // // - 0xc7b8c6 is 'close' to 0xc0c0c0 // // - 0xf8f8f8 is 'close' to 0xffffff // // - 0xff0102 is not 'close' to 0x000000, but is 'close' to 0xff0000 // // Closeness is determined as follows: // // - for each entry in the table s_odVGAColors // - ADD the addMask to the color // - AND the result with the andMask // - if the result equals the testMask, this VGA color is close match // // Think about it. It works. // // void ASShare::ODAdjustColor ( ASPerson * pasPerson, const TSHR_COLOR * pColorIn, LPTSHR_COLOR pColorOut, int type ) { int i; COLORREF color; COLORREF work; DebugEntry(ASShare::ODAdjustColor); *pColorOut = *pColorIn; if (g_usrScreenBPP > 4) { // Nothing to convert; bail out DC_QUIT; } // // Convert the color to a single integer // color = (pColorOut->red << 16) + (pColorOut->green << 8) + pColorOut->blue; // // See if this is the same as the last call of this type // if (color == pasPerson->m_pView->m_odLastVGAColor[type]) { *pColorOut = pasPerson->m_pView->m_odLastVGAResult[type]; TRACE_OUT(("Same as last %s color", (type == OD_BACK_COLOR ? "background" : type == OD_FORE_COLOR ? "foreground" : "pen"))); DC_QUIT; } // // Scan the table for a close match. // for (i = 0; i < 16; i++) { // // Check for a close match. Don't bother to look for an exact // match, as that is caught by this code. The trade off is between // - an additional test and jump in non-exact cases // - an 'add' and an 'and' in the exact case. // work = color; work += s_odVGAColors[i].addMask; work &= s_odVGAColors[i].andMask; if (work == s_odVGAColors[i].testMask) { TRACE_OUT(( "%#6.6lx is close match for %#6.6lx (%s)", s_odVGAColors[i].color, color, type == OD_BACK_COLOR ? "background" : type == OD_FORE_COLOR ? "foreground" : "pen")); *pColorOut = s_odVGAColors[i].result; break; } } if (i == 16) { TRACE_OUT(( "No close VGA match found for %#6.6lx (%s)", color, type == OD_BACK_COLOR ? "background" : type == OD_FORE_COLOR ? "foreground" : "pen")); } // // Save the result for next time. // pasPerson->m_pView->m_odLastVGAColor[type] = color; pasPerson->m_pView->m_odLastVGAResult[type] = *pColorOut; DC_EXIT_POINT: DebugExitVOID(ASShare::ODAdjustColor); } // // LITTLE ASShare::ODUse() functions // // // ASShare::ODUseTextBkColor() // void ASShare::ODUseTextBkColor ( ASPerson * pasPerson, BOOL fPalRGB, TSHR_COLOR color ) { COLORREF rgb; ValidateView(pasPerson); rgb = ODCustomRGB(color.red, color.green, color.blue, fPalRGB); SetBkColor(pasPerson->m_pView->m_usrDC, rgb); // Update BK COLOR cache pasPerson->m_pView->m_odLastBkColor = rgb; } // // ASShare::ODUseBkColor() // void ASShare::ODUseBkColor ( ASPerson * pasPerson, BOOL fPalRGB, TSHR_COLOR color ) { COLORREF rgb; ValidateView(pasPerson); rgb = ODCustomRGB(color.red, color.green, color.blue, fPalRGB); if (rgb != pasPerson->m_pView->m_odLastBkColor) { SetBkColor(pasPerson->m_pView->m_usrDC, rgb); // Update BK COLOR cache pasPerson->m_pView->m_odLastBkColor = rgb; } } // // ASShare::ODUseTextColor() // void ASShare::ODUseTextColor ( ASPerson * pasPerson, BOOL fPalRGB, TSHR_COLOR color ) { COLORREF rgb; ValidateView(pasPerson); rgb = ODCustomRGB(color.red, color.green, color.blue, fPalRGB); if (rgb != pasPerson->m_pView->m_odLastTextColor) { SetTextColor(pasPerson->m_pView->m_usrDC, rgb); // Update TEXT COLOR cache pasPerson->m_pView->m_odLastTextColor = rgb; } } // // ASShare::ODUseBkMode() // void ASShare::ODUseBkMode(ASPerson * pasPerson, int mode) { if (mode != pasPerson->m_pView->m_odLastBkMode) { SetBkMode(pasPerson->m_pView->m_usrDC, mode); // Update BK MODE cache pasPerson->m_pView->m_odLastBkMode = mode; } } // // ASShare::ODUsePen() // void ASShare::ODUsePen ( ASPerson * pasPerson, BOOL fPalRGB, UINT style, UINT width, TSHR_COLOR color ) { HPEN hPenNew; COLORREF rgb; ValidateView(pasPerson); rgb = ODCustomRGB(color.red, color.green, color.blue, fPalRGB); if ((style != pasPerson->m_pView->m_odLastPenStyle) || (rgb != pasPerson->m_pView->m_odLastPenColor) || (width != pasPerson->m_pView->m_odLastPenWidth)) { hPenNew = CreatePen(style, width, rgb); DeletePen(SelectPen(pasPerson->m_pView->m_usrDC, hPenNew)); // Update PEN cache pasPerson->m_pView->m_odLastPenStyle = style; pasPerson->m_pView->m_odLastPenColor = rgb; pasPerson->m_pView->m_odLastPenWidth = width; } } // // ASShare::ODUseROP2() // void ASShare::ODUseROP2(ASPerson * pasPerson, int rop2) { if (rop2 != pasPerson->m_pView->m_odLastROP2) { SetROP2(pasPerson->m_pView->m_usrDC, rop2); // Update ROP2 cache pasPerson->m_pView->m_odLastROP2 = rop2; } } // // ASShare::ODUseTextCharacterExtra() // void ASShare::ODUseTextCharacterExtra(ASPerson * pasPerson, int extra) { if (extra != pasPerson->m_pView->m_odLastCharExtra) { SetTextCharacterExtra(pasPerson->m_pView->m_usrDC, extra); // Update TEXT EXTRA cache pasPerson->m_pView->m_odLastCharExtra = extra; } } // // ASShare::ODUseTextJustification() // void ASShare::ODUseTextJustification(ASPerson * pasPerson, int extra, int count) { if ((extra != pasPerson->m_pView->m_odLastJustExtra) || (count != pasPerson->m_pView->m_odLastJustCount)) { SetTextJustification(pasPerson->m_pView->m_usrDC, extra, count); // Update TEXT JUST cache pasPerson->m_pView->m_odLastJustExtra = extra; pasPerson->m_pView->m_odLastJustCount = count; } } // // ASShare::ODUseFillMode() // void ASShare::ODUseFillMode(ASPerson * pasPerson, UINT mode) { if (mode != pasPerson->m_pView->m_odLastFillMode) { SetPolyFillMode(pasPerson->m_pView->m_usrDC, (mode == ORD_FILLMODE_WINDING) ? WINDING : ALTERNATE); // Update FILL MODE cache pasPerson->m_pView->m_odLastFillMode = mode; } } // // ASShare::ODUseArcDirection() // void ASShare::ODUseArcDirection(ASPerson * pasPerson, UINT dir) { if (dir != pasPerson->m_pView->m_odLastArcDirection) { SetArcDirection(pasPerson->m_pView->m_usrDC, (dir == ORD_ARC_CLOCKWISE) ? AD_CLOCKWISE : AD_COUNTERCLOCKWISE); // Update ARC DIR cache pasPerson->m_pView->m_odLastArcDirection = dir; } }