// draw a box directly to display memory int _near Drawbox_Cmd( LPTSTR pszCmdLine ) { register TCHAR *pszArg, *pszLine; int nTop, nLeft, nBottom, nRight, nStyle, nAttribute = -1, nFill = -1, n, nFlags = 0, nShade; if (( pszCmdLine == NULL ) || ( *pszCmdLine == _TEXT('\0') )) return ( Usage( DRAWBOX_USAGE )); // get the arguments & colors if ( sscanf( pszCmdLine, _TEXT("%d%d%d%d%d%n"), &nTop, &nLeft, &nBottom, &nRight, &nStyle, &n ) == 6 ) { pszLine = pszCmdLine + n; nAttribute = GetColors( pszLine, 0 ); // check for a FILL color if (( *pszLine ) && ( _strnicmp( first_arg( pszLine ), BOX_FILL, 3 ) == 0 ) && (( pszArg = first_arg( next_arg( pszLine, 1 ))) != NULL )) { if ( _strnicmp( pszArg, BRIGHT, 3 ) == 0 ) { // set intensity bit nFill = 0x80; if (( pszArg = first_arg( next_arg( pszLine, 1 ))) == NULL ) return ( Usage( DRAWBOX_USAGE )); } else nFill = 0; if (( nShade = color_shade( pszArg )) <= 15 ) { nFill |= ( nShade << 4 ); next_arg( pszLine, 1 ); } } // check for a SHADOW or ZOOM while ( *pszLine ) { if ( _strnicmp( pszLine, BOX_SHADOW, 3 ) == 0 ) nFlags |= BOX_SHADOWED; else if ( _strnicmp( pszLine, BOX_ZOOM, 3 ) == 0 ) nFlags |= BOX_ZOOMED; next_arg( pszLine, 1 ); } } if (( nAttribute == -1 ) || ( verify_row_col( nTop, nLeft )) || ( verify_row_col( nBottom, nRight ))) return ( Usage( DRAWBOX_USAGE )); if ( nLeft == 999 ) { if (( nLeft = (( GetScrCols() - nRight ) / 2 )) < 0 ) nLeft = 0; nRight += nLeft; } if ( nTop == 999 ) { if (( nTop = (( GetScrRows() - nBottom ) / 2 )) < 0 ) nTop = 0; nBottom += nTop; } _box( nTop, nLeft, nBottom, nRight, nStyle, nAttribute, nFill, nFlags, 1 ); return 0; }
// draw a horizontal or vertical line directly to the display static int _fastcall __drawline( LPTSTR pszCmdLine, int fVertical ) { register int nAttribute = -1; int nRow, nColumn, nLength, nStyle, n; // get the arguments & colors if (( pszCmdLine == NULL ) || ( *pszCmdLine == _TEXT('\0') )) return ( Usage( (( fVertical ) ? DRAWVLINE_USAGE : DRAWHLINE_USAGE ))); if ( sscanf( pszCmdLine, _TEXT("%d%d%d%d%n"), &nRow, &nColumn, &nLength, &nStyle, &n ) == 5 ) nAttribute = GetColors( pszCmdLine+n, 0 ); // if row or column == 999, center the line if ( nColumn == 999 ) { nColumn = ( GetScrCols() - (( fVertical ) ? 0 : nLength )) / 2; if ( nColumn < 0 ) nColumn = 0; } if ( nRow == 999 ) { nRow = ( GetScrRows() - (( fVertical ) ? nLength : 0 )) / 2; if ( nRow < 0 ) nRow = 0; } return ((( nAttribute == -1 ) || ( verify_row_col( nRow, nColumn )) || ( _line( nRow, nColumn, nLength, nStyle, fVertical, nAttribute, 1 ) != 0 )) ? Usage( (( fVertical ) ? DRAWVLINE_USAGE : DRAWHLINE_USAGE ) ) : 0 ); }
inline bool MtgCard::operator==(const MtgCard& rhs) { return GetLayout() == rhs.GetLayout() && GetManacost() == rhs.GetManacost() && GetCmc() == rhs.GetCmc() && CompareStringList(GetColors(), rhs.GetColors()) && type == rhs.type && CompareStringList(GetSupertypes(), rhs.GetSupertypes()) && CompareStringList(GetTypes(), rhs.GetTypes()) && CompareStringList(GetSubtypes(), rhs.GetSubtypes()) && GetRarity() == rhs.GetRarity() && text == rhs.GetText() && GetFlavor() == rhs.GetFlavor() && GetArtist() == rhs.GetArtist() && GetNumber() == rhs.GetNumber() && GetPower() == rhs.GetPower() && GetToughness() == rhs.GetToughness() && GetLoyalty() == rhs.GetLoyalty() && GetMultiverseid() == rhs.GetMultiverseid() && CompareIntList(GetVariations(), rhs.GetVariations()) && GetImageName() == rhs.GetImageName() && GetWatermark() == rhs.GetWatermark() && GetBorder() == rhs.GetBorder() && IsTimeshifted() == rhs.IsTimeshifted() && GetHand() == rhs.GetHand() && GetLife() == rhs.GetLife() && IsReserved() == rhs.IsReserved() && GetReleasedate() == rhs.GetReleasedate() && IsStarter() == rhs.IsStarter() && CompareStringPairList(GetRulings(), rhs.GetRulings()) && CompareStringPairList(GetForeignNames(), rhs.GetForeignNames()) && GetOriginalText() == rhs.GetOriginalText() && GetOriginalType() == rhs.GetOriginalType() && CompareStringPairList(GetLegalities(), rhs.GetLegalities()) && GetEdition() == rhs.GetEdition(); }
// Map the colors of the DIB (using GetNearestPaletteIndex) to a palette //************************************************************************ void CDib::MapToPalette( HPALETTE hpal ) //************************************************************************ { int n, nDibColors; LPBYTE lpBits; LPRGBQUAD lpRgb; BYTE xlat[256]; DWORD SizeImage; BOOL bChanged; if ( !hpal ) return; if ( m_bmiHeader.biBitCount != 8 ) return; if ( GetColorTableType() == DIB_PAL_COLORS ) return; // build a xlat table. from the current DIB colors to the given palette nDibColors = GetNumColors(); lpRgb = GetColors(); bChanged = NO; for ( n=0; n<nDibColors; n++ ) { xlat[n] = (BYTE)GetNearestPaletteIndex( hpal, RGB(lpRgb->rgbRed, lpRgb->rgbGreen, lpRgb->rgbBlue) ); if ( xlat[n] != n ) bChanged = YES; lpRgb++; } if ( !bChanged ) { // Now reset the DIB color table to match the palette SetColorTable( hpal, DIB_RGB_COLORS ); return; } // translate the DIB bits lpBits = (LPBYTE)GetPtr(); SizeImage = GetSizeImage(); switch (m_bmiHeader.biCompression) { case BI_RLE8: xlatRle8(lpBits, SizeImage, xlat); break; case BI_RGB: xlatClut8(lpBits, SizeImage, xlat); break; } // Now reset the DIB color table to match the palette SetColorTable( hpal, DIB_RGB_COLORS ); }
// Modifies the color table of the passed DIB for use with the wUsage // parameter specifed. // // if wUsage is DIB_PAL_COLORS the DIB color table is set to 0-256 // if wUsage is DIB_RGB_COLORS the DIB color table is set to the RGB values // in the passed palette //************************************************************************ BOOL CDib::SetColorTable( HPALETTE hpal, UINT wUsage ) //************************************************************************ { PALETTEENTRY ape[256]; LPRGBQUAD pRgb; LPWORD pw; WORD wColors; int n, nColors; switch (wUsage) { // Set the DIB color table to palette indexes case DIB_PAL_COLORS: pw = (LPWORD)GetColors(); for ( n=0; n<256; n++ ) *pw++ = n; break; // Set the DIB color table to RGBQUADS default: case DIB_RGB_COLORS: if (!hpal) hpal = (HPALETTE)GetStockObject(DEFAULT_PALETTE); GetObject( hpal, sizeof(WORD), (LPSTR)&wColors ); nColors = min(wColors,256); GetPaletteEntries( hpal, 0, nColors, ape ); pRgb = GetColors(); // m_bmiHeader.biClrUsed = nColors; for ( n=0; n<nColors; n++ ) { pRgb[n].rgbRed = ape[n].peRed; pRgb[n].rgbGreen = ape[n].peGreen; pRgb[n].rgbBlue = ape[n].peBlue; pRgb[n].rgbReserved = 0; } break; } return TRUE; }
//************************************************************************ UINT CDib::GetColorTableType() //************************************************************************ { LPDWORD lpDWORD; lpDWORD = (LPDWORD)GetColors(); if ( *lpDWORD == 0x00010000 ) // its looks like indices 0, 1, ... return( DIB_PAL_COLORS ); else return( DIB_RGB_COLORS ); }
// draw a horizontal or vertical line directly to the display int drawline_cmd( int argc, char **argv ) { int attribute = -1; int row, col, len, width; // get the arguments & colors if (( argc >= 6 ) && ( sscanf( argv[1], "%d%d%d%d", &row, &col, &len, &width ) == 4 )) attribute = GetColors( argv[5], 0 ); return ((( attribute == -1 ) || ( verify_row_col( row, col )) || ( _line( row, col, len, width,(_ctoupper( argv[0][4] ) == 'V' ), attribute, 1 ) != 0 )) ? usage( DRAWLINE_USAGE ) : 0 ); }
// draw a box directly to display memory int drawbox_cmd(int argc, char **argv) { char *arg, *pszLine; int top, left, bottom, right, style, attribute = -1, fill = -1; int box_flags = 0; // get the arguments & colors if ((argc >= 7) && (sscanf(argv[1],"%d%d%d%d%d",&top,&left,&bottom,&right,&style) == 5)) { pszLine = argv[6]; attribute = GetColors(pszLine,0); // check for a FILL color if ((*pszLine) && (_strnicmp(first_arg(pszLine),BOX_FILL,3) == 0) && ((arg = first_arg(next_arg(pszLine,1))) != NULL)) { if (_strnicmp(arg,BRIGHT,3) == 0) { // set intensity bit fill = 0x80; if ((arg = first_arg(next_arg(pszLine,1))) == NULL) return (usage(DRAWBOX_USAGE)); } else fill = 0; if ((argc = color_shade(arg)) <= 15) { fill |= (argc << 4); (void)next_arg(pszLine,1); } } // check for a SHADOW or ZOOM while (*pszLine) { if (_strnicmp(pszLine,BOX_SHADOW,3) == 0) box_flags |= BOX_SHADOWED; else if (_strnicmp(pszLine,BOX_ZOOM,3) == 0) box_flags |= BOX_ZOOMED; (void)next_arg(pszLine,1); } } if ((attribute == -1) || (verify_row_col(top,left)) || (verify_row_col(bottom,right))) return (usage(DRAWBOX_USAGE)); _box(top,left,bottom,right,style,attribute,fill,box_flags,1); return 0; }
//----------------------------------------------------------------------------- // Procedurally generates the camo texture... //----------------------------------------------------------------------------- void CCamoMaterialProxy::GenerateCamoTexture( ITexture* pTexture, IVTFTexture *pVTFTexture ) { if (!m_pEnt) return; #if 0 CamoInstanceData_t *pInstanceData; pInstanceData = ( CamoInstanceData_t * )FindInstanceData( pEnt ); if( !pInstanceData ) { pInstanceData = ( CamoInstanceData_t * )AllocateInstanceData( pEnt ); if( !pInstanceData ) { return; } // init the instance data } #endif Vector entityPosition; entityPosition = m_pEnt->GetAbsOrigin(); QAngle entityAngles; entityAngles = m_pEnt->GetAbsAngles(); // Get the bounding box for the entity Vector mins, maxs; mins = m_pEnt->WorldAlignMins(); maxs = m_pEnt->WorldAlignMaxs(); Vector traceDirection; Vector traceEnd; trace_t traceResult; Vector forward, right, up; AngleVectors( entityAngles, &forward, &right, &up ); Vector position, transformedPosition; Vector maxsMinusMins = maxs - mins; Vector diffuseColor[256]; Vector baseColor; unsigned char camoPalette[256][3]; // Calculate the camo palette //Msg( "start of loop\n" ); int i; for( i = 0; i < m_CamoPatternNumColors; i++ ) { GetColors( diffuseColor[i], baseColor, i, mins, maxsMinusMins, forward, right, up, entityPosition ); #if 1 camoPalette[i][0] = diffuseColor[i][0] * baseColor[0] * 255.0f; camoPalette[i][1] = diffuseColor[i][1] * baseColor[1] * 255.0f; camoPalette[i][2] = diffuseColor[i][2] * baseColor[2] * 255.0f; #endif #if 0 camoPalette[i][0] = baseColor[0] * 255.0f; camoPalette[i][1] = baseColor[1] * 255.0f; camoPalette[i][2] = baseColor[2] * 255.0f; #endif #if 0 camoPalette[i][0] = diffuseColor[i][0] * 255.0f; camoPalette[i][1] = diffuseColor[i][1] * 255.0f; camoPalette[i][2] = diffuseColor[i][2] * 255.0f; #endif } int width = pVTFTexture->Width(); int height = pVTFTexture->Height(); if( width != m_CamoPatternWidth || height != m_CamoPatternHeight ) { return; } unsigned char *imageData = pVTFTexture->ImageData( 0, 0, 0 ); enum ImageFormat imageFormat = pVTFTexture->Format(); if( imageFormat != IMAGE_FORMAT_RGB888 ) { return; } // optimize #if 1 int x, y; for( y = 0; y < height; y++ ) { for( x = 0; x < width; x++ ) { int offset = 3 * ( x + y * width ); assert( offset < width * height * 3 ); int paletteID = m_pCamoPatternImage[x + y * width]; assert( paletteID < 256 ); #if 1 imageData[offset + 0] = camoPalette[paletteID][0]; imageData[offset + 1] = camoPalette[paletteID][1]; imageData[offset + 2] = camoPalette[paletteID][2]; #else imageData[offset] = 255; imageData[offset + 1] = 0; imageData[offset + 2] = 0; #endif } } #endif }
// Note we only support 8bpp DIBs here, and.. // there is no regard for color table matching between the DIBs //************************************************************************ void CDib::DibBlt(PDIB pdibDst, int dstLeft, int dstTop, int dstWidth, int dstHeight, int srcLeft, int srcTop, int srcWidth, int srcHeight, BOOL bTransparent, LPRGBTRIPLE lpRGB, LPTR lpLut, HPALETTE hPal ) //************************************************************************ { HPTR pSrc, pDst; int iScanS, iScanD, iOverrun; if ( !pdibDst ) return; if ( GetBitCount() != 8 ) return; if ( pdibDst->GetBitCount() != 8 ) return; // Check the coordinate bounds, to avoid an out of range pointer if ( srcLeft < 0 ) { dstLeft -= srcLeft; srcWidth += srcLeft; dstWidth += srcLeft; srcLeft = 0; } if ( srcTop < 0 ) { dstTop -= srcTop; srcHeight += srcTop; dstHeight += srcTop; srcTop = 0; } if ( dstLeft < 0 ) { srcLeft -= dstLeft; srcWidth += dstLeft; dstWidth += dstLeft; dstLeft = 0; } if ( dstTop < 0 ) { srcTop -= dstTop; srcHeight += dstTop; dstHeight += dstTop; dstTop = 0; } if ( srcWidth <= 0 || srcHeight <= 0 || dstWidth <= 0 || dstHeight <= 0 ) return; if ( srcLeft - GetWidth() >= 0 ) return; if ( srcTop - abs(GetHeight()) >= 0 ) return; if ( dstLeft - pdibDst->GetWidth() >= 0 ) return; if ( dstTop - abs(pdibDst->GetHeight()) >= 0 ) return; if ( (iOverrun = srcLeft + srcWidth - GetWidth()) > 0 ) { srcWidth -= iOverrun; dstWidth -= iOverrun; } if ( (iOverrun = srcTop + srcHeight - abs(GetHeight())) > 0 ) { srcHeight -= iOverrun; dstHeight -= iOverrun; } if ( (iOverrun = dstLeft + dstWidth - pdibDst->GetWidth()) > 0 ) { dstWidth -= iOverrun; srcWidth -= iOverrun; } if ( (iOverrun = dstTop + dstHeight - abs(pdibDst->GetHeight())) > 0 ) { dstHeight -= iOverrun; srcHeight -= iOverrun; } if ( srcWidth <= 0 || srcHeight <= 0 || dstWidth <= 0 || dstHeight <= 0 ) return; // Get pointers to the start points in the source and destination if ( !(pSrc = GetXY( srcLeft, srcTop )) ) return; if ( !(pDst = pdibDst->GetXY( dstLeft, dstTop )) ) return; // Get the scan line widths of each DIB. iScanS = GetWidthBytes(); iScanD = pdibDst->GetWidthBytes(); // Upside down DIBs have to move backwards if ( GetHeight() > 0 ) iScanS = -iScanS; if ( pdibDst->GetHeight() > 0 ) iScanD = -iScanD; if ( !bTransparent ) { // Copy the lines. while ( --srcHeight >= 0 ) { hmemcpy( pDst, pSrc, srcWidth ); pSrc += iScanS; pDst += iScanD; } } else if (lpRGB) { // Copy lines with transparency mask WORD src, dst, wMini; BYTE dstPixel, srcColor, red, green, blue; int iSinc, iDinc, iCount; LPRGBQUAD pTable = GetColors(); if (lpLut) { wMini = RGB3toMiniRGB(lpRGB->rgbtRed, lpRGB->rgbtGreen, lpRGB->rgbtBlue); srcColor = lpLut[wMini]; } else if (hPal) { srcColor = (BYTE)GetNearestPaletteIndex( hPal, RGB(lpRGB->rgbtRed, lpRGB->rgbtGreen, lpRGB->rgbtBlue) ); } else srcColor = 0; iSinc = iScanS - srcWidth; // Source increment value iDinc = iScanD - srcWidth; // Destination increment value while ( --srcHeight >= 0 ) { iCount = srcWidth; // Number of pixels to scan. while ( --iCount >= 0 ) { src = (WORD)(*pSrc++); // Copy pixel only if it isn't transparent. if (src == 0) pDst++; else if (src == 255) *pDst++ = srcColor; else { if (src > 127) ++src; dst = 256-src; dstPixel = *pDst; red = (BYTE)((((WORD)lpRGB->rgbtRed * src) + ((WORD)pTable[dstPixel].rgbRed * dst)) >> 8); green = (BYTE)((((WORD)lpRGB->rgbtGreen * src) + ((WORD)pTable[dstPixel].rgbGreen * dst)) >> 8); blue = (BYTE)((((WORD)lpRGB->rgbtBlue * src) + ((WORD)pTable[dstPixel].rgbBlue * dst)) >> 8); if (lpLut) { wMini = RGB3toMiniRGB(red, green, blue); *pDst++ = lpLut[wMini]; } else if (hPal) { *pDst++ = (BYTE)GetNearestPaletteIndex( hPal, RGB(red, green, blue) ); } else { pDst++; } } } pSrc += iSinc; pDst += iDinc; } } else { // Copy lines with transparency.
// Create a GDI palette from a DIB color table //************************************************************************ HPALETTE CDib::CreatePalette() //************************************************************************ { // create an identity palette from the DIB's color table return ( CreateIdentityPalette( GetColors(), GetNumColors() ) ); }
// Will read a file in DIB format and return a global HANDLE to its // BITMAPINFO. This function will work with both "old" and "new" // bitmap formats, but will always return a "new" BITMAPINFO //************************************************************************ BOOL CDib::ReadBitmapInfo( HFILE fh ) //************************************************************************ { DWORD off, size; HANDLE hbi = NULL; int i, nNumColors; LPRGBQUAD pRgb; BITMAPINFOHEADER bi; BITMAPCOREHEADER bc; BITMAPFILEHEADER bf; if ( fh < 0 ) return FALSE; off = _llseek(fh,0L,SEEK_CUR); if (sizeof(bf) != _lread(fh,(LPSTR)&bf,sizeof(bf))) return FALSE; // do we have a RC HEADER? if (bf.bfType != BFT_BITMAP) { bf.bfOffBits = 0L; _llseek(fh,off,SEEK_SET); } if (sizeof(bi) != _lread(fh,(LPSTR)&bi,sizeof(bi))) return FALSE; // what type of bitmap info is this? if ( (size = bi.biSize) == sizeof(BITMAPCOREHEADER) ) { bc = *(LPBITMAPCOREHEADER)&bi; bi.biSize = sizeof(BITMAPINFOHEADER); bi.biWidth = (DWORD)bc.bcWidth; bi.biHeight = (DWORD)bc.bcHeight; bi.biPlanes = (UINT)bc.bcPlanes; bi.biBitCount = (UINT)bc.bcBitCount; bi.biCompression = BI_RGB; bi.biSizeImage = 0; bi.biXPelsPerMeter = 0; bi.biYPelsPerMeter = 0; bi.biClrUsed = 0; bi.biClrImportant = 0; _llseek(fh,(long)sizeof(BITMAPCOREHEADER)-sizeof(BITMAPINFOHEADER),SEEK_CUR); } //!!! hack for BI_BITFIELDS if ( bi.biCompression == BI_BITFIELDS && !bi.biClrUsed ) bi.biClrUsed = 3; // Copy in the bitmap info header m_bmiHeader = bi; FixHeader(); nNumColors = GetNumColors(); pRgb = GetColors(); if (nNumColors) { if (size == sizeof(BITMAPCOREHEADER)) { // convert old color table (3 byte entries) to new (4 byte entries) _lread(fh,(LPVOID)pRgb,nNumColors * sizeof(RGBTRIPLE)); for (i=nNumColors-1; i>=0; i--) { RGBQUAD rgb; rgb.rgbRed = ((LPRGBTRIPLE)pRgb)[i].rgbtRed; rgb.rgbBlue = ((LPRGBTRIPLE)pRgb)[i].rgbtBlue; rgb.rgbGreen = ((LPRGBTRIPLE)pRgb)[i].rgbtGreen; rgb.rgbReserved = (BYTE)0; pRgb[i] = rgb; } } else { _lread(fh,(LPVOID)pRgb,nNumColors * sizeof(RGBQUAD)); } } if (bf.bfOffBits) _llseek(fh,off + bf.bfOffBits,SEEK_SET); return TRUE; }
void Mesh::GetColors(int index, Vector *V) { GetColors(faces[index].points, V); }
void TextStyleListBox::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct) { //CRect members to store the position of the items CRect rItem; CDC* dc = CDC::FromHandle(lpDrawItemStruct->hDC); if ((int)lpDrawItemStruct->itemID < 0) { // If there are no elements in the CListBox // based on whether the list box has Focus or not // draw the Focus Rect or Erase it, if ((lpDrawItemStruct->itemAction & ODA_FOCUS) && (lpDrawItemStruct->itemState & ODS_FOCUS)) { dc->DrawFocusRect(&lpDrawItemStruct->rcItem); } else if ((lpDrawItemStruct->itemAction & ODA_FOCUS) && !(lpDrawItemStruct->itemState & ODS_FOCUS)) { dc->DrawFocusRect(&lpDrawItemStruct->rcItem); } return; } // String to store the text CString csStyle; // Get the item text. GetText(lpDrawItemStruct->itemID, csStyle); //Initialize the CListBox Item's row size rItem = lpDrawItemStruct->rcItem; UINT nFormat = DT_LEFT | DT_SINGLELINE | DT_VCENTER; if (GetStyle() & LBS_USETABSTOPS) nFormat |= DT_EXPANDTABS; COLORREF cText; COLORREF cBg; CFont font; font.CreatePointFont(100,"Times New Roman"); LgbColorsDef cColors; GetColors(csStyle, cColors); cText = RGB(cColors.m_iFgRed, cColors.m_iFgGreen, cColors.m_iFgBlue); cBg = RGB(cColors.m_iBgRed, cColors.m_iBgGreen, cColors.m_iBgBlue); // If CListBox item selected, draw the highlight rectangle. // Or if CListBox item deselected, draw the rectangle using the window color. if ((lpDrawItemStruct->itemState & ODS_SELECTED) && (lpDrawItemStruct->itemAction & (ODA_SELECT | ODA_DRAWENTIRE))) { CBrush br(::GetSysColor(COLOR_HIGHLIGHT)); dc->FillRect(&rItem, &br); } else if (!(lpDrawItemStruct->itemState & ODS_SELECTED) && (lpDrawItemStruct->itemAction & ODA_SELECT)) { dc->FillSolidRect(&rItem, cBg); //CBrush br(::GetSysColor(COLOR_WINDOW)); //dc->FillRect(&rItem, &br); } else if (!(lpDrawItemStruct->itemState & ODS_SELECTED)) { dc->FillSolidRect(&rItem, cBg); } // If the CListBox item has focus, draw the focus rect. // If the item does not have focus, erase the focus rect. if ((lpDrawItemStruct->itemAction & ODA_FOCUS) && (lpDrawItemStruct->itemState & ODS_FOCUS)) { dc->DrawFocusRect(&rItem); } else if ((lpDrawItemStruct->itemAction & ODA_FOCUS) && !(lpDrawItemStruct->itemState & ODS_FOCUS)) { dc->DrawFocusRect(&rItem); } // To draw the Text in the CListBox set the background mode to Transparent. int iBkMode = dc->SetBkMode(TRANSPARENT); dc->SetBkColor(cBg); dc->SetTextColor(cText); dc->SelectObject(&font); //Draw the Text dc->TextOut(rItem.left, rItem.top, csStyle); // create memory device context CDC* pSrcMemDC = new CDC; assert( NULL != pSrcMemDC ); pSrcMemDC->CreateCompatibleDC(dc); // RGB + Alpha int totalBytes = rItem.Width() * rItem.Height() * 4; // create bitmap CBitmap* pSrcBmp = new CBitmap; assert( NULL != pSrcBmp ); // initialize pSrcBmp->CreateCompatibleBitmap(dc, rItem.Width(), rItem.Height()); pSrcMemDC->SelectObject(pSrcBmp); void *byteArr = new BYTE [ totalBytes ]; assert( NULL != byteArr ); BYTE *tmp = (BYTE *) byteArr; // set the flagged array to the bitmap pSrcBmp->SetBitmapBits( totalBytes, byteArr ); // Write text using EHS font blitter LgbTextIcon dumTextIcon; CString csFont = GetFont(csStyle); EhsWidgetClass* pWidget; EhsTgtViewportSurfaceClass* pSurface = NULL; EhsGraphicsColourClass xFgColour, xBgColour; EhsGraphicsFontClass* pFont = dumTextIcon.GetFontPtr(csFont); if (0) { //if (pFont) { //xFgColour = EhsGraphicsColour_argb(cColors.m_iFgRed, cColors.m_iFgGreen, cColors.m_iFgBlue, cColors.m_iFgAlpha); xFgColour = EhsGraphicsColour_argb(150, 150, 150, 150); xBgColour = EhsGraphicsColour_argb(255, 255, 255, 0); EhsWidgetTable_init(&EhsWidgetTable); pWidget = EhsWidgetTextbox_init(rItem.left, rItem.top, 0, rItem.Width(), rItem.Height(), xFgColour, xBgColour, pFont); EhsWidget_create(pWidget); EhsGraphicsColourClass xPalette[2]; xPalette[0] = EHS_WIDGET_TEXTBOX(pWidget).xBgColour; xPalette[1] = EHS_WIDGET_TEXTBOX(pWidget).xFgColour; pSurface = EhsTgtViewportSurface_create(NULL,pWidget->xCurRect.nWidth,pWidget->xCurRect.nHeight,EHS_GRAPHICS_COLOUR_A1,xPalette,2); if (pSurface) { EhsWidgetTextbox_draw(pWidget, NULL, NULL, pSurface); // Copy the written data back from the bitmap pSrcBmp->GetBitmapBits( totalBytes, byteArr ); // Blit Text int x,y; for (y = 0; y < rItem.Height(); y++) { int nPixIdx = y * rItem.Width() * 4; int nBmpIdx = y * ((pSurface->nWid+7)/8); for (x = 0; x < rItem.Width(); x++) { int nBit = 1 << (7u - (x % 8u)); int nX = x*4; if ((nBit & EhsTgtViewportSurface_bitmap(pSurface)[nBmpIdx + x/8]) == nBit) { tmp[nPixIdx+nX] = (unsigned char) cColors.m_iFgBlue; tmp[nPixIdx+nX+1] = (unsigned char) cColors.m_iFgGreen; tmp[nPixIdx+nX+2] = (unsigned char) cColors.m_iFgRed; tmp[nPixIdx+nX+3] = (unsigned char) cColors.m_iFgAlpha; } else { tmp[nPixIdx+nX] = 255; tmp[nPixIdx+nX+1] = 255; tmp[nPixIdx+nX+2] = 255; tmp[nPixIdx+nX+3] = 0; } } } if (!pWidget->bOptimiseForSpeed) { EhsTgtViewportSurface_destroy(NULL, pSurface); } } } /* // Copy this data into bitmap pSrcBmp->SetBitmapBits( totalBytes, byteArr ); BLENDFUNCTION bf; bf.BlendOp = AC_SRC_OVER; bf.BlendFlags = 0; bf.SourceConstantAlpha = 255; bf.AlphaFormat = AC_SRC_ALPHA; AlphaBlend( dc->GetSafeHdc(), rItem.left, rItem.top, rItem.Width(), rItem.Height(), pSrcMemDC->GetSafeHdc(), 0, 0, rItem.Width(), rItem.Height(), bf ); int PicSizeX = 30; int PicSizeY = 16; pSrcMemDC->SelectObject(pSrcBmp); dc->BitBlt(rItem.left+5, rItem.top+1, PicSizeX, PicSizeY, pSrcMemDC, 0, 0, SRCCOPY); */ pSrcMemDC->DeleteDC(); delete pSrcMemDC; pSrcBmp->DeleteObject(); delete pSrcBmp; delete [] byteArr; }