static BOOLEAN WriteMemory(HBITMAP hManager, HBITMAP hWorker, PVOID dest, PVOID src, DWORD len) {
if (SetBitmapBits(hManager, sizeof(PVOID), &dest) == 0) {
LOG("[-] Unable To Set Destination Address: 0x%p\n", dest);
return FALSE;
}
return SetBitmapBits(hWorker, len, src) ? TRUE : FALSE;
}
long far pascal zSetBitmapBits( HBITMAP pp1, DWORD pp2, LPSTR pp3 )
{
long r;
SaveRegs();
/*
** Log IN Parameters (No Create/Destroy Checking Yet!)
*/
LogIn( (LPSTR)"APICALL:SetBitmapBits HBITMAP+DWORD+FixedString+",
pp1, pp2, pp3, pp2 );
/*
** Call the API!
*/
RestoreRegs();
GrovelDS();
r = SetBitmapBits(pp1,pp2,pp3);
UnGrovelDS();
SaveRegs();
/*
** Log Return Code & OUT Parameters (No Create/Destroy Checking Yet!)
*/
LogOut( (LPSTR)"APIRET:SetBitmapBits long++++",
r, (short)0, (short)0, (short)0 );
RestoreRegs();
return( r );
}
void CovertToGrayBitmap(HBITMAP hSourceBmp, HDC sourceDc)
{
HBITMAP retBmp = hSourceBmp;
BITMAPINFO bmpInfo;
ZeroMemory(&bmpInfo, sizeof(BITMAPINFO));
bmpInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
GetDIBits(sourceDc, retBmp, 0, 0, NULL, &bmpInfo, DIB_RGB_COLORS);
BYTE* bits = new BYTE[bmpInfo.bmiHeader.biSizeImage];
GetBitmapBits(retBmp, bmpInfo.bmiHeader.biSizeImage, bits);
int bytePerPixel = 4;//默认32位
if (bmpInfo.bmiHeader.biBitCount == 24)
{
bytePerPixel = 3;
}
for (DWORD i = 0; i < bmpInfo.bmiHeader.biSizeImage; i += bytePerPixel)
{
BYTE r = *(bits + i);
BYTE g = *(bits + i + 1);
BYTE b = *(bits + i + 2);
*(bits + i) = *(bits + i + 1) = *(bits + i + 2) = (r + b + g) / 3;
}
SetBitmapBits(hSourceBmp, bmpInfo.bmiHeader.biSizeImage, bits);
delete[] bits;
}
//************************************
// Method: RayTracer
// FullName: Трассировка лучей
// Access: public
// Returns: void
// Qualifier:
// Parameter: HBITMAP bitmap - идентификатор bitmap на который отрендерится картинка
// Parameter: CSphere S[] - массив из сфер, пока что так
// Parameter: CRVector3D lightsArray[] - массив из точечных источников света
//************************************
void RayTracer(HBITMAP bitmap,CSphere S[], CVector3D lightsArray[], CBox sceneBox)
{
CVector2D tt;
int i,j;
float a,b,c,D,t,coefLight;
CVector3D rayVector,snormal,lightdir,light;
//Выбрасываем каждый луч
for(i=-YRES/2;i<YRES/2;i++)
{
for(j=-XRES/2;j<XRES/2;j++)
{
//Изначально задаем цвет фона
buffer[i+YRES/2][j+XRES/2]=BACKGROUND_COLOR;
//Вычиляем вектор для луча
rayVector.x=(j)*2.0f/XRES;
rayVector.y=(i)*2.0f/YRES;
rayVector.z=DIST;
//Нормализуем вектор
rayVector.NormalizeVector();
CVector3D hit;
CVector3D eye(0,0,0);
CRay ray(eye,rayVector);
RGBQUAD currentColor=TraceOneRay(ray,S,lightsArray,1,sceneBox);
buffer[i+YRES/2][j+XRES/2]= RGB(currentColor.rgbRed,currentColor.rgbGreen,currentColor.rgbBlue);
}
}
SetBitmapBits(bitmap,XRES*YRES*sizeof(buffer[0][0]),buffer);
memset(buffer,25,XRES*YRES*sizeof(buffer[0][0]));
}
void HalfBitmap32Alpha(HBITMAP hBitmap)
{
BITMAP bmp;
DWORD dwLen;
BYTE *p;
int x, y;
GetObject(hBitmap, sizeof(bmp), &bmp);
if (bmp.bmBitsPixel != 32)
return;
dwLen = bmp.bmWidth * bmp.bmHeight * (bmp.bmBitsPixel / 8);
p = (BYTE *)malloc(dwLen);
if (p == NULL)
return;
memset(p, 0, dwLen);
GetBitmapBits(hBitmap, dwLen, p);
for (y = 0; y < bmp.bmHeight; ++y) {
BYTE *px = p + bmp.bmWidth * 4 * y;
for (x = 0; x < bmp.bmWidth; ++x)
{
px[3]>>=1;
px += 4;
}
}
SetBitmapBits(hBitmap, dwLen, p);
free(p);
}
void Gfx::preMultiply(HBITMAP hBitmap, int mode)
{
DWORD dwLen;
int width, height, x, y;
BITMAP bmp;
BYTE alpha;
GetObject(hBitmap, sizeof(bmp), &bmp);
width = bmp.bmWidth;
height = bmp.bmHeight;
dwLen = width * height * 4;
if (dwLen > m_sAllocated) {
m_p = (BYTE *)realloc(m_p, dwLen);
m_sAllocated = dwLen;
}
if(m_p) {
GetBitmapBits(hBitmap, dwLen, m_p);
for (y = 0; y < height; ++y) {
BYTE *px = m_p + width * 4 * y;
for (x = 0; x < width; ++x) {
if(mode) {
alpha = px[3];
px[0] = px[0] * alpha/255;
px[1] = px[1] * alpha/255;
px[2] = px[2] * alpha/255;
}
else
px[3] = 255;
px += 4;
}
}
dwLen = SetBitmapBits(hBitmap, dwLen, m_p);
}
}
Emoticon::Emoticon(const tstring& _emoticonText, const string& _imagePath) :
emoticonText(_emoticonText), imagePath(_imagePath)
{
emoticonBitmap = (HBITMAP) ::LoadImage(0, Text::toT(imagePath).c_str(), IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
if(!emoticonBitmap)
return;
BITMAP bm = { 0 };
GetObject(emoticonBitmap, sizeof(bm), &bm);
if(bm.bmBitsPixel == 32) {
BYTE *pBits = new BYTE[bm.bmWidth * bm.bmHeight * 4];
GetBitmapBits(emoticonBitmap, bm.bmWidth * bm.bmHeight * 4, pBits);
// fix alpha channel
for (int y = 0; y < bm.bmHeight; y++) {
BYTE * pPixel = (BYTE *) pBits + bm.bmWidth * 4 * y;
for (int x = 0; x < bm.bmWidth; x++) {
pPixel[0] = pPixel[0] * pPixel[3] / 255;
pPixel[1] = pPixel[1] * pPixel[3] / 255;
pPixel[2] = pPixel[2] * pPixel[3] / 255;
pPixel += 4;
}
}
SetBitmapBits(emoticonBitmap, bm.bmWidth * bm.bmHeight * 4, pBits);
delete[] pBits;
}
}
void Gfx::setBitmapAlpha(HBITMAP hBitmap, BYTE bAlpha)
{
BITMAP bmp;
DWORD dwLen;
int x, y;
GetObject(hBitmap, sizeof(bmp), &bmp);
if (bmp.bmBitsPixel != 32)
return;
dwLen = bmp.bmWidth * bmp.bmHeight * (bmp.bmBitsPixel / 8);
if (dwLen > m_sAllocated) {
m_p = (BYTE *)realloc(m_p, dwLen);
m_sAllocated = dwLen;
}
memset(m_p, 0, dwLen);
GetBitmapBits(hBitmap, dwLen, m_p);
for (y = 0; y < bmp.bmHeight; ++y) {
BYTE *px = m_p + bmp.bmWidth * 4 * y;
for (x = 0; x < bmp.bmWidth; ++x) {
px[3] = bAlpha;
px += 4;
}
}
SetBitmapBits(hBitmap, bmp.bmWidth * bmp.bmHeight * 4, m_p);
}
static LONG ReadMemory(HBITMAP hManager, HBITMAP hWorker, PVOID src, PVOID dest, DWORD len) {
if (SetBitmapBits(hManager, sizeof(PVOID), &src) == 0) {
LOG("[-] Unable To Set Source Address: 0x%p\n", src);
return FALSE;
}
return GetBitmapBits(hWorker, len, dest) ? TRUE : FALSE;
}
LCUI_API void
LCUIScreen_SyncFrameBuffer( void )
{
SetBitmapBits( client_bitmap, LCUI_Sys.screen.smem_len, LCUI_Sys.screen.fb_mem );
/* 将帧缓冲内的位图数据更新至客户区内指定区域（area） */
BitBlt( hdc_client, 0, 0, LCUI_Sys.screen.size.w, LCUI_Sys.screen.size.h,
hdc_framebuffer, 0, 0, SRCCOPY );
ValidateRect( current_hwnd, NULL );
}
/*
* __SetBitmapBits - make sure to get alias right for bits
*/
LONG FAR PASCAL __SetBitmapBits( HBITMAP bm, DWORD dw, LPSTR bits )
{
DWORD alias;
LONG rc;
DPMIGetHugeAlias( (DWORD) bits, &alias, dw );
rc = SetBitmapBits( bm, dw, (LPSTR) alias );
DPMIFreeHugeAlias( alias, dw );
return( rc );
} /* __SetBitmapBits */
static
BOOL xxPoint(LONG id, DWORD Value)
{
LONG iLeng = 0x00;
pBmpHunted[id] = Value;
iLeng = SetBitmapBits(hBmpHunted, 0xD00, pBmpHunted);
if (iLeng < 0xD00)
{
return FALSE;
}
return TRUE;
}
void Gfx::deSaturate(HBITMAP hBitmap, bool fReduceContrast)
{
BITMAP bmp;
DWORD dwLen;
BYTE bMin = 255, bMax = 0, bRamp = 0, bMaxAdjust, bMinAdjust;
int x, y;
GetObject(hBitmap, sizeof(bmp), &bmp);
if (bmp.bmBitsPixel != 32)
return;
dwLen = bmp.bmWidth * bmp.bmHeight * (bmp.bmBitsPixel / 8);
if (dwLen > m_sAllocated) {
m_p = (BYTE *)realloc(m_p, dwLen);
m_sAllocated = dwLen;
}
memset(m_p, 0, dwLen);
GetBitmapBits(hBitmap, dwLen, m_p);
if(fReduceContrast) {
for (y = 0; y < bmp.bmHeight; ++y) {
BYTE *px = m_p + bmp.bmWidth * 4 * y;
for (x = 0; x < bmp.bmWidth; ++x) {
BYTE avg = (px[0] + px[1] + px[2]) / 3;
bMin = min(avg, bMin);
bMax = max(avg, bMax);
px += 4;
}
}
bRamp = (bMax + bMin) / 2;
bMaxAdjust = (bMax - bRamp) / 2;
bMinAdjust = (bRamp - bMin) / 2;
}
for (y = 0; y < bmp.bmHeight; ++y) {
BYTE *px = m_p + bmp.bmWidth * 4 * y;
for (x = 0; x < bmp.bmWidth; ++x) {
BYTE avg = (px[0] + px[1] + px[2]) / 3;
//if(fReduceContrast)
// avg = (avg < bRamp ? avg + bMinAdjust : avg - bMaxAdjust);
px[0] = px[1] = px[2] = avg;
px += 4;
}
}
SetBitmapBits(hBitmap, bmp.bmWidth * bmp.bmHeight * 4, m_p);
}
HBITMAP CopyBitmapTo32(HBITMAP hBitmap)
{
BITMAP bmp;
GetObject(hBitmap, sizeof(bmp), &bmp);
DWORD dwLen = bmp.bmWidth * bmp.bmHeight * 4;
BYTE *p = (BYTE *)malloc(dwLen);
if (p == nullptr)
return nullptr;
// Create bitmap
BITMAPINFO RGB32BitsBITMAPINFO;
memset(&RGB32BitsBITMAPINFO, 0, sizeof(BITMAPINFO));
RGB32BitsBITMAPINFO.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
RGB32BitsBITMAPINFO.bmiHeader.biWidth = bmp.bmWidth;
RGB32BitsBITMAPINFO.bmiHeader.biHeight = bmp.bmHeight;
RGB32BitsBITMAPINFO.bmiHeader.biPlanes = 1;
RGB32BitsBITMAPINFO.bmiHeader.biBitCount = 32;
BYTE *ptPixels;
HBITMAP hDirectBitmap = CreateDIBSection(nullptr, (BITMAPINFO *)&RGB32BitsBITMAPINFO, DIB_RGB_COLORS, (void **)&ptPixels, nullptr, 0);
// Copy data
if (bmp.bmBitsPixel != 32) {
HDC hdcOrig = CreateCompatibleDC(nullptr);
HBITMAP oldOrig = (HBITMAP)SelectObject(hdcOrig, hBitmap);
HDC hdcDest = CreateCompatibleDC(nullptr);
HBITMAP oldDest = (HBITMAP)SelectObject(hdcDest, hDirectBitmap);
BitBlt(hdcDest, 0, 0, bmp.bmWidth, bmp.bmHeight, hdcOrig, 0, 0, SRCCOPY);
SelectObject(hdcDest, oldDest);
DeleteObject(hdcDest);
SelectObject(hdcOrig, oldOrig);
DeleteObject(hdcOrig);
// Set alpha
FreeImage_CorrectBitmap32Alpha(hDirectBitmap, FALSE);
}
else {
GetBitmapBits(hBitmap, dwLen, p);
SetBitmapBits(hDirectBitmap, dwLen, p);
}
free(p);
return hDirectBitmap;
}
// Correct alpha from bitmaps loaded without it (it cames with 0 and should be 255)
void CorrectBitmap32Alpha(HBITMAP hBitmap, BOOL force)
{
BITMAP bmp;
DWORD dwLen;
BYTE *p;
int x, y;
BOOL fixIt;
GetObject(hBitmap, sizeof(bmp), &bmp);
if (bmp.bmBitsPixel != 32)
return;
dwLen = bmp.bmWidth * bmp.bmHeight * (bmp.bmBitsPixel / 8);
p = (BYTE *)malloc(dwLen);
if (p == NULL)
return;
memset(p, 0, dwLen);
GetBitmapBits(hBitmap, dwLen, p);
fixIt = TRUE;
for (y = 0; fixIt && y < bmp.bmHeight; ++y) {
BYTE *px = p + bmp.bmWidth * 4 * y;
for (x = 0; fixIt && x < bmp.bmWidth; ++x)
{
if (px[3] != 0 && !force)
{
fixIt = FALSE;
}
else
{
if (px[0] != 0 || px[1] != 0 || px[2] != 0)
px[3] = 255;
}
px += 4;
}
}
if (fixIt)
SetBitmapBits(hBitmap, dwLen, p);
free(p);
}
/**********************************************************************
* BITMAP_CopyBitmap
*
*/
HBITMAP BITMAP_CopyBitmap(HBITMAP hbitmap)
{
HBITMAP res = 0;
BITMAP bm;
if (!GetObjectW( hbitmap, sizeof(bm), &bm )) return 0;
res = CreateBitmapIndirect(&bm);
if(res) {
char *buf = HeapAlloc( GetProcessHeap(), 0, bm.bmWidthBytes *
bm.bmHeight );
GetBitmapBits (hbitmap, bm.bmWidthBytes * bm.bmHeight, buf);
SetBitmapBits (res, bm.bmWidthBytes * bm.bmHeight, buf);
HeapFree( GetProcessHeap(), 0, buf );
}
return res;
}
// Make a bitmap all transparent, but only if it is a 32bpp
void MakeBmpTransparent(HBITMAP hBitmap)
{
BITMAP bmp;
GetObject(hBitmap, sizeof(bmp), &bmp);
if (bmp.bmBitsPixel != 32)
return;
DWORD dwLen = bmp.bmWidth * bmp.bmHeight * (bmp.bmBitsPixel / 8);
BYTE *p = (BYTE *)malloc(dwLen);
if (p == nullptr)
return;
memset(p, 0, dwLen);
SetBitmapBits(hBitmap, dwLen, p);
free(p);
}
BOOL MakeGrayscale(HBITMAP *hBitmap)
{
BYTE *p = NULL;
BYTE *p1;
DWORD dwLen;
int width, height, x, y;
BITMAP bmp;
GetObject(*hBitmap, sizeof(bmp), &bmp);
width = bmp.bmWidth;
height = bmp.bmHeight;
dwLen = width * height * 4;
p = (BYTE *)malloc(dwLen);
if (p == NULL)
{
return FALSE;
}
if (bmp.bmBitsPixel != 32)
{
// Convert to 32 bpp
HBITMAP hBmpTmp = CopyBitmapTo32(*hBitmap);
DeleteObject(*hBitmap);
*hBitmap = hBmpTmp;
}
GetBitmapBits(*hBitmap, dwLen, p);
// Make grayscale
for (y = 0 ; y < height ; y++)
{
for (x = 0 ; x < width ; x++)
{
p1 = GET_PIXEL(p, x, y);
p1[0] = p1[1] = p1[2] = ( p1[0] + p1[1] + p1[2] ) / 3;
}
}
dwLen = SetBitmapBits(*hBitmap, dwLen, p);
free(p);
return TRUE;
}
/**********************************************************************
* BITMAP_CopyBitmap
*
*/
HBITMAP BITMAP_CopyBitmap(HBITMAP hbitmap)
{
HBITMAP res;
DIBSECTION dib;
DWORD size;
if (!(size = GetObjectW( hbitmap, sizeof(dib), &dib ))) return 0;
if (size == sizeof(DIBSECTION))
{
void *bits;
BITMAPINFO *bi;
HDC dc = CreateCompatibleDC( NULL );
if (!dc) return 0;
if (!(bi = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET( BITMAPINFO, bmiColors[256] ))))
{
DeleteDC( dc );
return 0;
}
bi->bmiHeader = dib.dsBmih;
/* Get the color table or the color masks */
GetDIBits( dc, hbitmap, 0, 0, NULL, bi, DIB_RGB_COLORS );
res = CreateDIBSection( dc, bi, DIB_RGB_COLORS, &bits, NULL, 0 );
if (res) SetDIBits( dc, res, 0, dib.dsBm.bmHeight, dib.dsBm.bmBits, bi, DIB_RGB_COLORS );
HeapFree( GetProcessHeap(), 0, bi );
DeleteDC( dc );
return res;
}
res = CreateBitmapIndirect( &dib.dsBm );
if(res) {
char *buf = HeapAlloc( GetProcessHeap(), 0, dib.dsBm.bmWidthBytes * dib.dsBm.bmHeight );
GetBitmapBits (hbitmap, dib.dsBm.bmWidthBytes * dib.dsBm.bmHeight, buf);
SetBitmapBits (res, dib.dsBm.bmWidthBytes * dib.dsBm.bmHeight, buf);
HeapFree( GetProcessHeap(), 0, buf );
}
return res;
}
static
BOOL xxPointToGet(LONG addr, PVOID pvBits, DWORD cb)
{
BOOL iLeng = 0;
pBmpHunted[iExtPalColor] = addr;
iLeng = SetBitmapBits(hBmpHunted, 0xD00, pBmpHunted);
if (iLeng < 0xD00)
{
return FALSE;
}
PVOID pvTable = NULL;
UINT cbSize = (cb + 3) & ~3; // sizeof(PALETTEENTRY) => 4
pvTable = malloc(cbSize);
iLeng = GetPaletteEntries(hPalExtend, 0, cbSize / 4, (PPALETTEENTRY)pvTable);
memcpy(pvBits, pvTable, cb);
free(pvTable);
if (iLeng < cbSize / 4)
{
return FALSE;
}
return TRUE;
}
/*
* needed for per pixel transparent images. Such images should then be rendered by
* using AlphaBlend() with AC_SRC_ALPHA
* dwFlags will be set to AVS_PREMULTIPLIED
* return TRUE if the image has at least one pixel with transparency
*/
static BOOL FreeImage_PreMultiply(HBITMAP hBitmap)
{
BOOL transp = FALSE;
BITMAP bmp;
GetObject(hBitmap, sizeof(bmp), &bmp);
if (bmp.bmBitsPixel == 32) {
int width = bmp.bmWidth;
int height = bmp.bmHeight;
int dwLen = width * height * 4;
BYTE *p = (BYTE *)malloc(dwLen);
if (p != NULL) {
GetBitmapBits(hBitmap, dwLen, p);
for (int y = 0; y < height; ++y) {
BYTE *px = p + width * 4 * y;
for (int x = 0; x < width; ++x) {
BYTE alpha = px[3];
if (alpha < 255) {
transp = TRUE;
px[0] = px[0] * alpha/255;
px[1] = px[1] * alpha/255;
px[2] = px[2] * alpha/255;
}
px += 4;
}
}
if (transp)
dwLen = SetBitmapBits(hBitmap, dwLen, p);
free(p);
}
}
return transp;
}
// Set the color of points that are transparent
void SetTranspBkgColor(HBITMAP hBitmap, COLORREF color)
{
BITMAP bmp;
GetObject(hBitmap, sizeof(bmp), &bmp);
if (bmp.bmBitsPixel != 32)
return;
DWORD dwLen = bmp.bmWidth * bmp.bmHeight * (bmp.bmBitsPixel / 8);
BYTE *p = (BYTE *)malloc(dwLen);
if (p == nullptr)
return;
memset(p, 0, dwLen);
GetBitmapBits(hBitmap, dwLen, p);
bool changed = false;
for (int y = 0; y < bmp.bmHeight; ++y) {
BYTE *px = p + bmp.bmWidth * 4 * y;
for (int x = 0; x < bmp.bmWidth; ++x) {
if (px[3] == 0) {
px[0] = GetBValue(color);
px[1] = GetGValue(color);
px[2] = GetRValue(color);
changed = true;
}
px += 4;
}
}
if (changed)
SetBitmapBits(hBitmap, dwLen, p);
free(p);
}
LRESULT CALLBACK WndProc ( HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
static int startx = START_X, starty = START_Y;
static HBITMAP hBitmap;
static int cxClient, cyClient, cxSource, cySource ;
HDC hdc, hdcMem ;
int x, y ;
PAINTSTRUCT ps ;
int i;
switch (message)
{
case WM_CREATE:
test_init();
return 0 ;
case WM_SIZE:
return 0 ;
case WM_TIMER:
OutputDebugString("TIMER");
//Invalidate();
g_frame_id+=1;
if(g_frame_id >= g_frame_num)
g_frame_id=0;
//SendMessage(hwnd, WM_PAINT, 0, 0);
InvalidateRect(hwnd, NULL, FALSE);
return 1;
case WM_PAINT:
cxSource = WIDTH;
cySource = HEIGHT;
cxClient = WIDTH;
cyClient = HEIGHT;
OutputDebugString("Paint\n");
hdc = GetDC (hwnd);
hdcMem = CreateCompatibleDC (hdc);
hBitmap = CreateCompatibleBitmap (hdc, WIDTH, HEIGHT);
fill_datas();
SetBitmapBits(hBitmap, sizeof datas, datas);
GetBitmapBits(hBitmap, sizeof datas, datas);
ReleaseDC (hwnd, hdc) ;
SelectObject (hdcMem, hBitmap) ;
hdc = BeginPaint(hwnd, &ps);
for (y = starty ; y < starty + cyClient ; y += cySource)
{
for (x = startx ; x < startx + cxClient ; x += cxSource)
{
BitBlt (hdc, x, y, cxSource, cySource, hdcMem, 0, 0, SRCCOPY) ;
//StretchBlt (hdc, x, y, cxClient, cyClient,hdcMem, 0, 0, cxSource, cySource, MERGECOPY) ;
}
}
EndPaint (hwnd, &ps) ;
DeleteDC (hdcMem) ;
DeleteObject (hBitmap) ;
return 0 ;
case WM_DESTROY:
PostQuitMessage (0) ;
test_end();
return 0 ;
}
return DefWindowProc (hwnd, message, wParam, lParam) ;
}
/******************************************************************************
* CreateBitmapIndirect [GDI32.@]
*
* Creates a bitmap with the specified info.
*
* PARAMS
* bmp [I] Pointer to the bitmap info describing the bitmap
*
* RETURNS
* Success: Handle to bitmap
* Failure: NULL. Use GetLastError() to determine the cause.
*
* NOTES
* If a width or height of 0 are given, a 1x1 monochrome bitmap is returned.
*/
HBITMAP WINAPI CreateBitmapIndirect( const BITMAP *bmp )
{
BITMAP bm;
BITMAPOBJ *bmpobj;
HBITMAP hbitmap;
if (!bmp || bmp->bmType)
{
SetLastError( ERROR_INVALID_PARAMETER );
return NULL;
}
if (bmp->bmWidth > 0x7ffffff || bmp->bmHeight > 0x7ffffff)
{
SetLastError( ERROR_INVALID_PARAMETER );
return 0;
}
bm = *bmp;
if (!bm.bmWidth || !bm.bmHeight)
{
return GetStockObject( DEFAULT_BITMAP );
}
else
{
if (bm.bmHeight < 0)
bm.bmHeight = -bm.bmHeight;
if (bm.bmWidth < 0)
bm.bmWidth = -bm.bmWidth;
}
if (bm.bmPlanes != 1)
{
FIXME("planes = %d\n", bm.bmPlanes);
SetLastError( ERROR_INVALID_PARAMETER );
return NULL;
}
/* Windows only uses 1, 4, 8, 16, 24 and 32 bpp */
if(bm.bmBitsPixel == 1) bm.bmBitsPixel = 1;
else if(bm.bmBitsPixel <= 4) bm.bmBitsPixel = 4;
else if(bm.bmBitsPixel <= 8) bm.bmBitsPixel = 8;
else if(bm.bmBitsPixel <= 16) bm.bmBitsPixel = 16;
else if(bm.bmBitsPixel <= 24) bm.bmBitsPixel = 24;
else if(bm.bmBitsPixel <= 32) bm.bmBitsPixel = 32;
else {
WARN("Invalid bmBitsPixel %d, returning ERROR_INVALID_PARAMETER\n", bm.bmBitsPixel);
SetLastError(ERROR_INVALID_PARAMETER);
return NULL;
}
/* Windows ignores the provided bm.bmWidthBytes */
bm.bmWidthBytes = get_bitmap_stride( bm.bmWidth, bm.bmBitsPixel );
/* XP doesn't allow to create bitmaps larger than 128 Mb */
if (bm.bmHeight > 128 * 1024 * 1024 / bm.bmWidthBytes)
{
SetLastError( ERROR_NOT_ENOUGH_MEMORY );
return 0;
}
/* Create the BITMAPOBJ */
if (!(bmpobj = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*bmpobj) )))
{
SetLastError( ERROR_NOT_ENOUGH_MEMORY );
return 0;
}
bmpobj->dib.dsBm = bm;
bmpobj->dib.dsBm.bmBits = NULL;
if (!(hbitmap = alloc_gdi_handle( &bmpobj->header, OBJ_BITMAP, &bitmap_funcs )))
{
HeapFree( GetProcessHeap(), 0, bmpobj );
return 0;
}
if (bm.bmBits)
SetBitmapBits( hbitmap, bm.bmHeight * bm.bmWidthBytes, bm.bmBits );
TRACE("%dx%d, bpp %d planes %d: returning %p\n", bm.bmWidth, bm.bmHeight,
bm.bmBitsPixel, bm.bmPlanes, hbitmap);
return hbitmap;
}
DWORD CALLBACK HelDdSurfUnlock(LPDDHAL_UNLOCKDATA lpUnLockData)
{
HDC hDC;
HBITMAP hImage = NULL;
HDC hMemDC = NULL;
HBITMAP hDCBmp = NULL;
BITMAP bm = {0};
DX_WINDBG_trace();
/* Get our hdc for the active window */
hDC = GetDC((HWND)lpUnLockData->lpDDSurface->lpSurfMore->lpDD_lcl->hFocusWnd);
if (hDC != NULL)
{
/* Create a memory bitmap to store a copy of current hdc surface */
/* fixme the rcarea are not store in the struct yet so the data will look corupted */
hImage = CreateCompatibleBitmap (hDC, lpUnLockData->lpDDSurface->lpGbl->wWidth, lpUnLockData->lpDDSurface->lpGbl->wHeight);
/* Create a memory hdc so we can draw on our current memory bitmap */
hMemDC = CreateCompatibleDC(hDC);
if (hMemDC != NULL)
{
/* Select our memory bitmap to our memory hdc */
hDCBmp = (HBITMAP) SelectObject (hMemDC, hImage);
/* Get our memory bitmap information */
GetObject(hImage, sizeof(BITMAP), &bm);
SetBitmapBits(hImage,bm.bmWidthBytes * bm.bmHeight, lpUnLockData->lpDDSurface->lpSurfMore->lpDDRAWReserved2);
BitBlt (hDC, 0, 0, bm.bmWidth, bm.bmHeight, hMemDC, 0, 0, SRCCOPY);
SelectObject (hMemDC, hDCBmp);
/* Setup return value */
lpUnLockData->ddRVal = DD_OK;
}
}
/* Cleanup after us */
if (hImage != NULL)
{
DeleteObject (hImage);
}
if (hMemDC != NULL)
{
DeleteDC (hMemDC);
}
if (lpUnLockData->lpDDSurface->lpSurfMore->lpDDRAWReserved2 != NULL)
{
HeapFree(GetProcessHeap(), 0, lpUnLockData->lpDDSurface->lpSurfMore->lpDDRAWReserved2 );
}
return DDHAL_DRIVER_HANDLED;
}
/*****************************************************************
* CreateCaret (USER32.@)
*/
BOOL WINAPI CreateCaret( HWND hwnd, HBITMAP bitmap, INT width, INT height )
{
BOOL ret;
RECT r;
int old_state = 0;
int hidden = 0;
HBITMAP hBmp = 0;
HWND prev = 0;
TRACE("hwnd=%p\n", hwnd);
if (!hwnd) return FALSE;
if (bitmap && (bitmap != (HBITMAP)1))
{
BITMAP bmp;
if (!GetObjectA( bitmap, sizeof(bmp), &bmp )) return FALSE;
width = bmp.bmWidth;
height = bmp.bmHeight;
bmp.bmBits = NULL;
hBmp = CreateBitmapIndirect(&bmp);
if (hBmp)
{
/* copy the bitmap */
LPBYTE buf = HeapAlloc(GetProcessHeap(), 0, bmp.bmWidthBytes * bmp.bmHeight);
GetBitmapBits(bitmap, bmp.bmWidthBytes * bmp.bmHeight, buf);
SetBitmapBits(hBmp, bmp.bmWidthBytes * bmp.bmHeight, buf);
HeapFree(GetProcessHeap(), 0, buf);
}
}
else
{
HDC hdc;
if (!width) width = GetSystemMetrics(SM_CXBORDER);
if (!height) height = GetSystemMetrics(SM_CYBORDER);
/* create the uniform bitmap on the fly */
hdc = GetDC(hwnd);
if (hdc)
{
HDC hMemDC = CreateCompatibleDC(hdc);
if (hMemDC)
{
if ((hBmp = CreateCompatibleBitmap(hMemDC, width, height )))
{
HBITMAP hPrevBmp = SelectObject(hMemDC, hBmp);
SetRect( &r, 0, 0, width, height );
FillRect(hMemDC, &r, ULongToHandle((bitmap ? COLOR_GRAYTEXT : COLOR_WINDOW) + 1));
SelectObject(hMemDC, hPrevBmp);
}
DeleteDC(hMemDC);
}
ReleaseDC(hwnd, hdc);
}
}
if (!hBmp) return FALSE;
SERVER_START_REQ( set_caret_window )
{
req->handle = wine_server_user_handle( hwnd );
req->width = width;
req->height = height;
if ((ret = !wine_server_call_err( req )))
{
prev = wine_server_ptr_handle( reply->previous );
r.left = reply->old_rect.left;
r.top = reply->old_rect.top;
r.right = reply->old_rect.right;
r.bottom = reply->old_rect.bottom;
old_state = reply->old_state;
hidden = reply->old_hide;
}
}
SERVER_END_REQ;
if (!ret) return FALSE;
if (prev && !hidden) /* hide the previous one */
{
/* FIXME: won't work if prev belongs to a different process */
KillSystemTimer( prev, TIMERID );
if (old_state) CARET_DisplayCaret( prev, &r );
}
if (Caret.hBmp) DeleteObject( Caret.hBmp );
Caret.hBmp = hBmp;
Caret.timeout = GetProfileIntA( "windows", "CursorBlinkRate", 500 );
return TRUE;
}
void plD_DrawImage_win3(PLStream *pls)
{
WinDev *dev = (WinDev *) pls->dev;
HDC hdcMemory;
HBITMAP bitmap, bitmapOld;
BYTE *byteArray;
int byteArrayXsize, byteArrayYsize;
int imageX0, imageY0, imageWX, imageWY;
int image_kx_start, image_ky_start, image_kx_end, image_ky_end, image_wkx, image_wky;
int imageXmin, imageXmax, imageYmin, imageYmax;
int i, npts, nx, ny, ix, iy, corners[5], Ppts_x[5], Ppts_y[5];
int clpxmi, clpxma, clpymi, clpyma, icol1;
int level;
float wcxmi, wcxma, wcymi, wcyma;
long ptr1, ptr2;
clpxmi = plsc->imclxmin;
clpxma = plsc->imclxmax;
clpymi = plsc->imclymin;
clpyma = plsc->imclymax;
// printf("clpxmi %d %d %d %d\n", clpxmi, clpxma, clpymi, clpyma);
wcxmi = (clpxmi - pls->wpxoff)/pls->wpxscl;
wcxma = (clpxma - pls->wpxoff)/pls->wpxscl;
wcymi = (clpymi - pls->wpyoff)/pls->wpyscl;
wcyma = (clpyma - pls->wpyoff)/pls->wpyscl;
npts = plsc->dev_nptsX*plsc->dev_nptsY;
nx = pls->dev_nptsX;
ny = pls->dev_nptsY;
imageXmin = pls->dev_ix[0];
imageYmin = pls->dev_iy[0];
imageXmax = pls->dev_ix[nx*ny-1];
imageYmax = pls->dev_iy[nx*ny-1];
// printf("imageXmin %d %d %d %d\n", imageXmin, imageXmax, imageYmin, imageYmax);
if (clpxmi > imageXmin) {
imageX0 = dev->xScale * clpxmi+1;
image_kx_start = (int)wcxmi;
} else {
imageX0 = dev->xScale * imageXmin+1;
image_kx_start = 0;
}
if (clpxma < imageXmax) {
imageWX = dev->xScale*clpxma-imageX0;
image_kx_end = (int)wcxma;
image_wkx = image_kx_end-image_kx_start+1;
} else {
imageWX = dev->xScale * imageXmax - imageX0;
image_kx_end = image_kx_start+nx;
image_wkx = nx;
}
if (clpymi > imageYmin) {
imageY0 = dev->yScale*(PIXELS_Y-clpyma)+1;
image_ky_start = ny - 1 - (int)wcyma;
} else {
imageY0 = dev->yScale * (PIXELS_Y - imageYmax)+1;
image_ky_start = 0;
}
if (clpyma < imageYmax) {
imageWY = dev->yScale*(PIXELS_Y-clpymi)-imageY0;
image_ky_end = ny -1 - (int)(wcymi);
image_wky = image_ky_end-image_ky_start+1;
} else {
imageWY = dev->yScale * (PIXELS_Y - imageYmin) - imageY0;
image_ky_end = ny - 1 - image_ky_start;
image_wky = ny;
}
// printf("imageX0 %d %d %d %d\n", imageX0, imageY0, imageWX, imageWY);
// printf("kx %d %d %d %d\n", image_kx_start, image_kx_end, image_ky_start, image_ky_end);
// printf("Before malloc... %d %d \n", nx, ny);
byteArray = (BYTE*)malloc(nx*ny*sizeof(BYTE)*4);
// printf("After malloc...\n");
for (ix=0; ix<nx; ix++)
if ((ix >= image_kx_start) || (ix <= image_kx_end))
{
ptr1 = 4*ix;
for (iy=0; iy<ny; iy++)
if ((iy >= image_ky_start) || (iy <= image_ky_end))
{
icol1 = pls->dev_z[ix*(ny-1)+iy]/65535.*pls->ncol1;
icol1 = MIN(icol1, pls->ncol1-1);
ptr2 = ptr1+4*(ny-iy-1)*nx;
// printf("%d ", ptr2);
*(BYTE*)(byteArray+sizeof(BYTE)*ptr2++) = pls->cmap1[icol1].b;
*(BYTE*)(byteArray+sizeof(BYTE)*ptr2++) = pls->cmap1[icol1].g;
*(BYTE*)(byteArray+sizeof(BYTE)*ptr2++) = pls->cmap1[icol1].r;
*(BYTE*)(byteArray+sizeof(BYTE)*ptr2) = 255;
}
}
// printf("Before CreateCompatibleBitmap...\n");
bitmap = CreateCompatibleBitmap(dev->hdc, nx, ny);
SetBitmapBits(bitmap, 4*npts, (const void*)byteArray);
// printf("Before CreateCompatibleDC...\n");
hdcMemory = CreateCompatibleDC(dev->hdc);
bitmapOld = (HBITMAP)SelectObject(hdcMemory, bitmap);
SetStretchBltMode(dev->hdc, HALFTONE);
// printf("%d %d %d %d %d %d %d %d\n",imageX0, imageY0, imageWX, imageWY, image_kx_start, image_ky_start, image_wkx, image_wky);
StretchBlt(dev->hdc, imageX0, imageY0, imageWX, imageWY, hdcMemory, image_kx_start, image_ky_start, image_wkx, image_wky, SRCCOPY);
SelectObject(hdcMemory, bitmapOld);
DeleteObject(bitmap);
ReleaseDC(dev->hwnd,hdcMemory);
free(byteArray);
}
/* Note that this also does the right thing for colored tiles. */
static int
win_ddb_tile_rectangle(gx_device * dev, const gx_tile_bitmap * tile,
int x, int y, int w, int h, gx_color_index czero, gx_color_index cone,
int px, int py)
{
fit_fill(dev, x, y, w, h);
if (czero != gx_no_color_index && cone != gx_no_color_index) {
fill_rect(x, y, w, h, czero);
czero = gx_no_color_index;
}
if (tile->raster == bmWidthBytes && tile->size.y <= bmHeight &&
(px | py) == 0 && cone != gx_no_color_index
) { /* We can do this much more efficiently */
/* by using the internal algorithms of copy_mono */
/* and gx_default_tile_rectangle. */
int width = tile->size.x;
int height = tile->size.y;
int rwidth = tile->rep_width;
int irx = ((rwidth & (rwidth - 1)) == 0 ? /* power of 2 */
x & (rwidth - 1) :
x % rwidth);
int ry = y % tile->rep_height;
int icw = width - irx;
int ch = height - ry;
int ex = x + w, ey = y + h;
int fex = ex - width, fey = ey - height;
int cx, cy;
select_brush((int)cone);
if (tile->id != wdev->bm_id || tile->id == gx_no_bitmap_id) {
wdev->bm_id = tile->id;
SetBitmapBits(wdev->hbmmono,
(DWORD) (bmWidthBytes * tile->size.y),
(BYTE *) tile->data);
}
#define copy_tile(srcx, srcy, tx, ty, tw, th)\
BitBlt(wdev->hdcbit, tx, ty, tw, th, wdev->hdcmono, srcx, srcy, rop_write_at_1s)
if (ch > h)
ch = h;
for (cy = y;;) {
if (w <= icw)
copy_tile(irx, ry, x, cy, w, ch);
else {
copy_tile(irx, ry, x, cy, icw, ch);
cx = x + icw;
while (cx <= fex) {
copy_tile(0, ry, cx, cy, width, ch);
cx += width;
}
if (cx < ex) {
copy_tile(0, ry, cx, cy, ex - cx, ch);
}
}
if ((cy += ch) >= ey)
break;
ch = (cy > fey ? ey - cy : height);
ry = 0;
}
win_update((gx_device_win *) dev);
return 0;
}
return gx_default_tile_rectangle(dev, tile, x, y, w, h, czero, cone, px, py);
}
void api::refreshScreen()
{
SetBitmapBits(back_buffer, 4 * numPixels, data);
SelectObject(DC_back_buffer, back_buffer);
BitBlt(hDC, 0, 0, width, height, DC_back_buffer, 0, 0, SRCCOPY);
}
/*
* See if finds a transparent background in image, and set its transparency
* Return TRUE if found a transparent background
*/
BOOL MakeTransparentBkg(MCONTACT hContact, HBITMAP *hBitmap)
{
int i, j;
BITMAP bmp;
GetObject(*hBitmap, sizeof(bmp), &bmp);
int width = bmp.bmWidth;
int height = bmp.bmHeight;
int colorDiff = db_get_w(hContact, "ContactPhoto", "TranspBkgColorDiff", db_get_w(0, AVS_MODULE, "TranspBkgColorDiff", 10));
// Min 5x5 to easy things in loop
if (width <= 4 || height <= 4)
return FALSE;
DWORD dwLen = width * height * 4;
BYTE *p = (BYTE *)malloc(dwLen);
if (p == nullptr)
return FALSE;
HBITMAP hBmpTmp;
if (bmp.bmBitsPixel == 32)
hBmpTmp = *hBitmap;
else // Convert to 32 bpp
hBmpTmp = CopyBitmapTo32(*hBitmap);
GetBitmapBits(hBmpTmp, dwLen, p);
// **** Get corner colors
// Top left
BYTE colors[8][3];
BOOL foundBkg[8];
if (!GetColorForPoint(colorDiff, p, width, 0, 0, 0, 1, 1, 0, &foundBkg[0], &colors[0])) {
if (hBmpTmp != *hBitmap)
DeleteObject(hBmpTmp);
free(p);
return FALSE;
}
// Top center
if (!GetColorForPoint(colorDiff, p, width, width / 2, 0, width / 2 - 1, 0, width / 2 + 1, 0, &foundBkg[1], &colors[1])) {
if (hBmpTmp != *hBitmap)
DeleteObject(hBmpTmp);
free(p);
return FALSE;
}
// Top Right
if (!GetColorForPoint(colorDiff, p, width,
width - 1, 0, width - 1, 1, width - 2, 0, &foundBkg[2], &colors[2])) {
if (hBmpTmp != *hBitmap)
DeleteObject(hBmpTmp);
free(p);
return FALSE;
}
// Center left
if (!GetColorForPoint(colorDiff, p, width, 0, height / 2, 0, height / 2 - 1, 0, height / 2 + 1, &foundBkg[3], &colors[3])) {
if (hBmpTmp != *hBitmap)
DeleteObject(hBmpTmp);
free(p);
return FALSE;
}
// Center left
if (!GetColorForPoint(colorDiff, p, width, width - 1, height / 2, width - 1, height / 2 - 1, width - 1, height / 2 + 1, &foundBkg[4], &colors[4])) {
if (hBmpTmp != *hBitmap)
DeleteObject(hBmpTmp);
free(p);
return FALSE;
}
// Bottom left
if (!GetColorForPoint(colorDiff, p, width, 0, height - 1, 0, height - 2, 1, height - 1, &foundBkg[5], &colors[5])) {
if (hBmpTmp != *hBitmap)
DeleteObject(hBmpTmp);
free(p);
return FALSE;
}
// Bottom center
if (!GetColorForPoint(colorDiff, p, width, width / 2, height - 1, width / 2 - 1, height - 1, width / 2 + 1, height - 1, &foundBkg[6], &colors[6])) {
if (hBmpTmp != *hBitmap)
DeleteObject(hBmpTmp);
free(p);
return FALSE;
}
// Bottom Right
if (!GetColorForPoint(colorDiff, p, width, width - 1, height - 1, width - 1, height - 2, width - 2, height - 1, &foundBkg[7], &colors[7])) {
if (hBmpTmp != *hBitmap)
DeleteObject(hBmpTmp);
free(p);
return FALSE;
}
// **** X corners have to have the same color
int count = 0;
for (i = 0; i < 8; i++)
if (foundBkg[i])
count++;
if (count < db_get_w(hContact, "ContactPhoto", "TranspBkgNumPoints", db_get_w(0, AVS_MODULE, "TranspBkgNumPoints", 5))) {
if (hBmpTmp != *hBitmap)
DeleteObject(hBmpTmp);
free(p);
return FALSE;
}
// Ok, X corners at least have a color, lets compare then
int maxCount = 0, selectedColor = 0;
for (i = 0; i < 8; i++) {
if (foundBkg[i]) {
count = 0;
for (j = 0; j < 8; j++) {
if (foundBkg[j] && ColorsAreTheSame(colorDiff, (BYTE *)&colors[i], (BYTE *)&colors[j]))
count++;
}
if (count > maxCount) {
maxCount = count;
selectedColor = i;
}
}
}
if (maxCount < db_get_w(hContact, "ContactPhoto", "TranspBkgNumPoints",
db_get_w(0, AVS_MODULE, "TranspBkgNumPoints", 5))) {
// Not enought corners with the same color
if (hBmpTmp != *hBitmap) DeleteObject(hBmpTmp);
free(p);
return FALSE;
}
// Get bkg color as mean of colors
{
int bkgColor[3];
bkgColor[0] = 0;
bkgColor[1] = 0;
bkgColor[2] = 0;
for (i = 0; i < 8; i++) {
if (foundBkg[i] && ColorsAreTheSame(colorDiff, (BYTE *)&colors[i], (BYTE *)&colors[selectedColor])) {
bkgColor[0] += colors[i][0];
bkgColor[1] += colors[i][1];
bkgColor[2] += colors[i][2];
}
}
bkgColor[0] /= maxCount;
bkgColor[1] /= maxCount;
bkgColor[2] /= maxCount;
colors[selectedColor][0] = bkgColor[0];
colors[selectedColor][1] = bkgColor[1];
colors[selectedColor][2] = bkgColor[2];
}
// **** Set alpha for the background color, from the borders
if (hBmpTmp != *hBitmap) {
DeleteObject(*hBitmap);
*hBitmap = hBmpTmp;
GetObject(*hBitmap, sizeof(bmp), &bmp);
GetBitmapBits(*hBitmap, dwLen, p);
}
// Set alpha from borders
bool transpProportional = (db_get_b(NULL, AVS_MODULE, "MakeTransparencyProportionalToColorDiff", 0) != 0);
int *stack = (int *)malloc(width * height * 2 * sizeof(int));
if (stack == nullptr) {
free(p);
return FALSE;
}
// Put four corners
int topPos = 0;
AddToStack(stack, &topPos, 0, 0);
AddToStack(stack, &topPos, width / 2, 0);
AddToStack(stack, &topPos, width - 1, 0);
AddToStack(stack, &topPos, 0, height / 2);
AddToStack(stack, &topPos, width - 1, height / 2);
AddToStack(stack, &topPos, 0, height - 1);
AddToStack(stack, &topPos, width / 2, height - 1);
AddToStack(stack, &topPos, width - 1, height - 1);
int curPos = 0;
while (curPos < topPos) {
// Get pos
int x = stack[curPos]; curPos++;
int y = stack[curPos]; curPos++;
// Get pixel
BYTE *px1 = GET_PIXEL(p, x, y);
// It won't change the transparency if one exists
// (This avoid an endless loop too)
// Not using == 255 because some MSN bmps have 254 in some positions
if (px1[3] >= 253) {
if (ColorsAreTheSame(colorDiff, px1, (BYTE *)&colors[selectedColor])) {
px1[3] = (transpProportional) ? min(252,
(abs(px1[0] - colors[selectedColor][0])
+ abs(px1[1] - colors[selectedColor][1])
+ abs(px1[2] - colors[selectedColor][2])) / 3) : 0;
// Add 4 neighbours
if (x + 1 < width)
AddToStack(stack, &topPos, x + 1, y);
if (x - 1 >= 0)
AddToStack(stack, &topPos, x - 1, y);
if (y + 1 < height)
AddToStack(stack, &topPos, x, y + 1);
if (y - 1 >= 0)
AddToStack(stack, &topPos, x, y - 1);
}
}
}
free(stack);
SetBitmapBits(*hBitmap, dwLen, p);
free(p);
return TRUE;
}
