void Test_MaskBlt_1bpp() { HDC hdcDst, hdcSrc; struct { BITMAPINFOHEADER bmiHeader; ULONG aulColors[2]; } bmiData = {{sizeof(BITMAPINFOHEADER), 8, 1, 1, 1, BI_RGB, 0, 10, 10, 2,0}, {0, 0xFFFFFF}}; PBITMAPINFO pbmi = (PBITMAPINFO)&bmiData; HBITMAP hbmDst, hbmSrc, hbmMsk; PUCHAR pjBitsDst, pjBitsSrc, pjBitsMsk; BOOL ret; /* Create a dest dc and bitmap */ hdcDst = CreateCompatibleDC(NULL); hbmDst = CreateDIBSection(hdcDst, pbmi, DIB_RGB_COLORS, (PVOID*)&pjBitsDst, NULL, 0); SelectObject(hdcDst, hbmDst); /* Create a source dc and bitmap */ hdcSrc = CreateCompatibleDC(NULL); hbmSrc = CreateDIBSection(hdcSrc, pbmi, DIB_RGB_COLORS, (PVOID*)&pjBitsSrc, NULL, 0); SelectObject(hdcSrc, hbmSrc); /* Create a 1 bpp mask bitmap */ hbmMsk = CreateDIBSection(hdcDst, pbmi, DIB_RGB_COLORS, (PVOID*)&pjBitsMsk, NULL, 0); /* Do the masking (SRCCOPY / NOOP) */ pjBitsDst[0] = 0xAA; pjBitsSrc[0] = 0xCC; pjBitsMsk[0] = 0xF0; ret = MaskBlt(hdcDst, 0, 0, 8, 1, hdcSrc, 0, 0, hbmMsk, 0, 0, MAKEROP4(SRCCOPY, 0xAA0000)); ok(ret == 1, "MaskBlt failed (%d)\n", ret); ok (pjBitsDst[0] == 0xCA, "pjBitsDst[0] == 0x%x\n", pjBitsDst[0]); pjBitsDst[0] = 0x00; pjBitsSrc[0] = 0xFF; pjBitsMsk[0] = 0xF0; ret = MaskBlt(hdcDst, 0, 0, 8, 1, hdcSrc, 0, 0, hbmMsk, 0, 0, MAKEROP4(SRCCOPY, 0xAA0000)); ok(ret == 1, "MaskBlt failed (%d)\n", ret); ok (pjBitsDst[0] == 0xF0, "pjBitsDst[0] == 0x%x\n", pjBitsDst[0]); /* Do the masking (NOTSRCERASE / SRCINVERT) */ pjBitsDst[0] = 0xF0; pjBitsSrc[0] = 0xCC; pjBitsMsk[0] = 0xAA; ret = MaskBlt(hdcDst, 0, 0, 8, 1, hdcSrc, 0, 0, hbmMsk, 0, 0, MAKEROP4(NOTSRCERASE, SRCINVERT)); // 22 ok(ret == 1, "MaskBlt failed (%d)\n", ret); ok (pjBitsDst[0] == 0x16, "pjBitsDst[0] == 0x%x\n", pjBitsDst[0]); /* Do the masking (MERGEPAINT / DSxn) */ pjBitsDst[0] = 0xF0; pjBitsSrc[0] = 0xCC; pjBitsMsk[0] = 0xAA; ret = MaskBlt(hdcDst, 0, 0, 8, 1, hdcSrc, 0, 0, hbmMsk, 0, 0, MAKEROP4(MERGEPAINT, 0x990000)); ok(ret == 1, "MaskBlt failed (%d)\n", ret); ok (pjBitsDst[0] == 0xE3, "pjBitsDst[0] == 0x%x\n", pjBitsDst[0]); }
void Test_MaskBlt_Brush() { HDC hdcDst, hdcSrc; struct { BITMAPINFOHEADER bmiHeader; ULONG aulColors[2]; } bmiData = {{sizeof(BITMAPINFOHEADER), 16, 16, 1, 1, BI_RGB, 0, 10, 10, 2,0}, {0, 0xFFFFFF}}; PBITMAPINFO pbmi = (PBITMAPINFO)&bmiData; HBITMAP hbmDst, hbmSrc, hbmMsk; PULONG pulBitsDst, pulBitsSrc, pulBitsMsk; BOOL ret; HBRUSH hbr; /* Create a dest dc and bitmap */ hdcDst = CreateCompatibleDC(NULL); hbmDst = CreateDIBSection(hdcDst, pbmi, DIB_RGB_COLORS, (PVOID*)&pulBitsDst, NULL, 0); SelectObject(hdcDst, hbmDst); /* Create a source dc and bitmap */ hdcSrc = CreateCompatibleDC(NULL); hbmSrc = CreateDIBSection(hdcSrc, pbmi, DIB_RGB_COLORS, (PVOID*)&pulBitsSrc, NULL, 0); SelectObject(hdcSrc, hbmSrc); hbr = CreateHatchBrush(HS_CROSS, 0); ok(hbr != 0, "failed to create brush\n"); ok(SelectObject(hdcDst, hbr) != 0, "failed to select brush\n"); /* Do the masking (SRCCOPY / NOOP) */ pulBitsDst[0] = 0x00000000; pulBitsSrc[0] = 0xFFFFFFFF; ret = MaskBlt(hdcDst, 0, 0, 8, 1, hdcSrc, 0, 0, NULL, 0, 0, MAKEROP4(SRCCOPY, 0xAA0000)); ok(ret == 1, "MaskBlt failed (%d)\n", ret); ok(pulBitsDst[0] == 0, "pulBitsDst[0] == 0x%lx\n", pulBitsDst[0]); /* Create a 1 bpp pattern brush */ pbmi->bmiHeader.biWidth = 8; hbmMsk = CreateDIBSection(hdcDst, pbmi, DIB_RGB_COLORS, (PVOID*)&pulBitsMsk, NULL, 0); ok(hbmMsk != 0, "CreateDIBSection failed\n"); hbr = CreatePatternBrush(hbmMsk); ok(hbr != 0, "CreatePatternBrush failed\n"); ok(SelectObject(hdcDst, hbr) != 0, "failed to select brush\n"); /* Do the masking (SRCCOPY / NOOP) */ pulBitsDst[0] = 0x00000000; pulBitsSrc[0] = 0xFFFFFFFF; pulBitsMsk[0] = 0xCCAAFF00; ret = MaskBlt(hdcDst, 0, 0, 16, 1, hdcSrc, 0, 0, NULL, 0, 0, MAKEROP4(SRCCOPY, 0xAA0000)); ok(ret == 1, "MaskBlt failed (%d)\n", ret); ok(pulBitsDst[0] == 0, "pulBitsDst[0] == 0x%lx\n", pulBitsDst[0]); }
void iupwinDrawBitmap(HDC hDC, HBITMAP hBitmap, HBITMAP hMask, int x, int y, int width, int height, int bpp) { HDC hMemDC = CreateCompatibleDC(hDC); HBITMAP oldBitmap = (HBITMAP)SelectObject(hMemDC, hBitmap); if (bpp == 32 && winAlphaBlend) { BLENDFUNCTION blendfunc; blendfunc.BlendOp = AC_SRC_OVER; blendfunc.BlendFlags = 0; blendfunc.SourceConstantAlpha = 0xFF; blendfunc.AlphaFormat = AC_SRC_ALPHA; winAlphaBlend(hDC, x, y, width, height, hMemDC, 0, 0, width, height, blendfunc); } else if (bpp == 8 && hMask) MaskBlt(hDC, x, y, width, height, hMemDC, 0, 0, hMask, 0, 0, MAKEROP4(SRCCOPY, 0xAA0000)); else BitBlt(hDC, x, y, width, height, hMemDC, 0, 0, SRCCOPY); SelectObject(hMemDC, oldBitmap); DeleteDC(hMemDC); }
KHMEXP void KHMAPI khui_ilist_draw(khui_ilist * il, int idx, HDC dc, int x, int y, int opt) { HDC dci; HBITMAP hb_oldi; if(idx < 0) return; dci = CreateCompatibleDC(dc); hb_oldi = SelectObject(dci, il->img); /*BitBlt(dc, x, y, il->cx, il->cy, dci, idx*il->cx, 0, SRCCOPY); */ MaskBlt(dc, x, y, il->cx, il->cy, dci, idx * il->cx, 0, il->mask, idx * il->cx, 0, MAKEROP4(SRCPAINT, SRCCOPY)); /* MaskBlt(dc, x, y, il->cx, il->cy, dci, idx * il->cx, 0, il->mask, idx * il->cx, 0, MAKEROP4(SRCINVERT, SRCCOPY)); */ SelectObject(dci, hb_oldi); DeleteDC(dci); }
//Performs the cloning void CloneTool::clone(DibSection * ds, SHIFT shift) { HDC dib_cdc=ds->GetCompDC(); //PLSPEC: NT only MaskBlt(dib_cdc,maskOffset.x,maskOffset.y,usedSize.cx,usedSize.cy, dib_cdc,maskOffset.x+shift.x,maskOffset.y+shift.y, mask->GetDSHandle(),0,0, MAKEROP4(ROP3_NOP,SRCCOPY)); }
void CGradientEditor::CStepHandle::OnDraw(HDC hDC, const LPRECT clientRect) { int xSrc = dragging ? WIDTH : 0; UpdateBounds(); MaskBlt(hDC, bounds.left, bounds.top, WIDTH, HEIGHT, parent->shBitmapDC, xSrc, 0, parent->shBmpMask, xSrc, 0, MAKEROP4(SRCCOPY, 0xAA0029)); SetBrushOrgEx(hDC, -20, 0, NULL); SelectObject(hDC, GetStockObject(DC_BRUSH)); SetDCBrushColor(hDC, gradient->GetStepColor(stepID)); WorkingMaskBlt(hDC, bounds.left, bounds.top, WIDTH, HEIGHT, hDC, xSrc, 0, parent->shBmpColorMask, xSrc, 0, MAKEROP4(PATCOPY, 0xAA0029)); }
void Test_MaskBlt_16bpp() { HDC hdcDst, hdcSrc; BITMAPINFO bmi1 = {{sizeof(BITMAPINFOHEADER), 8, 1, 1, 1, BI_RGB, 0, 10, 10, 0,0}}; BITMAPINFO bmi32 = {{sizeof(BITMAPINFOHEADER), 8, 1, 1, 16, BI_RGB, 0, 10, 10, 0,0}}; HBITMAP hbmDst, hbmSrc, hbmMsk; PUCHAR pjBitsMsk; PUSHORT pusBitsDst, pusBitsSrc; BOOL ret; /* Create a dest dc and bitmap */ hdcDst = CreateCompatibleDC(NULL); hbmDst = CreateDIBSection(hdcDst, &bmi32, DIB_RGB_COLORS, (PVOID*)&pusBitsDst, NULL, 0); SelectObject(hdcDst, hbmDst); /* Create a source dc and bitmap */ hdcSrc = CreateCompatibleDC(NULL); hbmSrc = CreateDIBSection(hdcSrc, &bmi32, DIB_RGB_COLORS, (PVOID*)&pusBitsSrc, NULL, 0); SelectObject(hdcSrc, hbmSrc); ok(hdcSrc && hbmSrc, "\n"); /* Create a 1 bpp mask bitmap */ hbmMsk = CreateDIBSection(hdcDst, &bmi1, DIB_RGB_COLORS, (PVOID*)&pjBitsMsk, NULL, 0); ok(hbmMsk != 0, "CreateDIBSection failed\n"); /* Do the masking */ pusBitsDst[0] = 0x1234; pusBitsDst[1] = 0x5678; pusBitsSrc[0] = 0x4321; pusBitsSrc[1] = 0x8765; pjBitsMsk[0] = 0x80; ret = MaskBlt(hdcDst, 0, 0, 8, 1, hdcSrc, 0, 0, hbmMsk, 0, 0, MAKEROP4(SRCCOPY, 0xAA0000)); ok(ret == 1, "MaskBlt failed (%d)\n", ret); ok (pusBitsDst[0] == 0x4321, "pusBitsDst[0] == 0x%x\n", pusBitsDst[0]); ok (pusBitsDst[1] == 0x5678, "pusBitsDst[0] == 0x%x\n", pusBitsDst[1]); pusBitsDst[0] = 0x1234; pusBitsDst[1] = 0x5678; ret = MaskBlt(hdcDst, 0, 0, 8, 1, hdcSrc, 0, 0, hbmMsk, 0, 0, MAKEROP4(SRCPAINT, MERGEPAINT)); ok(ret == 1, "MaskBlt failed (%d)\n", ret); ok (pusBitsDst[0] == 0x5335, "pusBitsDst[0] == 0x%x\n", pusBitsDst[0]); ok (pusBitsDst[1] == 0x7efa, "pusBitsDst[0] == 0x%x\n", pusBitsDst[1]); }
void CGDALContainer::DrawImage(HDC hDC, double dWorldOriginX, double dWorldOriginY, uint index) { if (hDC == NULL) return; int length = geoTiffs.size(); HDC hDCMem = CreateCompatibleDC(hDC); HBITMAP hMemBitmap; HBITMAP hbMask; HGDIOBJ oldObject = NULL; // have we got a device context? if (hDCMem) { // are we in range? if (index >= 0 && index < geoTiffs.size()) { // draw only if layer is uptodate if (geoTiffs[index]->isUptodate) { int currentBufferSize = geoTiffs[index]->getBufferSize(); // create new DIBSection for drawing the layer in hMemBitmap = ::CreateDIBSection(hDCMem, geoTiffs[index]->getBitmapInfo(), DIB_RGB_COLORS, (void **)&buffer, NULL, 0); if (hMemBitmap) { // copy the layer data into the DIBSection // memcpy_s(void *dest, size_t numberOfElements, const void *src, size_t count); memcpy_s(this->buffer, currentBufferSize, geoTiffs[index]->getBytes(), currentBufferSize); // select the DIBSection into temp dc oldObject = SelectObject(hDCMem, hMemBitmap); // get the mask of the layer geoTiffs[index]->getMask(hbMask); // blt the drawn layer through the mask onto our real device context MaskBlt(hDC, geoTiffs[index]->getRelativeX(), geoTiffs[index]->getRelativeY(), width, height, hDCMem, 0, 0, hbMask, 0, 0, MAKEROP4(geoTiffs[index]->getRasterOperation(), 0x00AA0029)); // 0x00AA0029 == Destination // Select old object back into dc (one can not delete an object if it is in the dc) SelectObject(hDCMem, oldObject); // delete the now unselected object DeleteObject(hMemBitmap); } } } DeleteDC(hDCMem); } }
BOOL wbDrawBitmap(HANDLE handle, HBITMAP hbmBits, int xPos, int yPos, int nWidth, int nHeight, int xOffset, int yOffset, COLORREF clTransp) { BOOL bRet; HDC hdcMem; HBITMAP hbmMask = NULL; if(!hbmBits) return FALSE; if(!DrawStart(handle)) return FALSE; if(nWidth < 1 && nHeight < 1) { DWORD dwDim; dwDim = wbGetImageDimensions(hbmBits); nWidth = LOWORD(dwDim); nHeight = HIWORD(dwDim); } if(clTransp != CLR_INVALID) hbmMask = wbCreateMask(hbmBits, clTransp); hdcMem = CreateCompatibleDC(hdcMain); SelectObject(hdcMem, hbmBits); if(clTransp != CLR_INVALID) { bRet = MaskBlt(hdcMain, xPos, yPos, nWidth, nHeight, hdcMem, xOffset, yOffset, hbmMask, xOffset, yOffset, MAKEROP4(SRCPAINT, SRCCOPY)); } else { bRet = BitBlt(hdcMain, xPos, yPos, nWidth, nHeight, hdcMem, xOffset, yOffset, SRCCOPY); } DeleteDC(hdcMem); if((clTransp != CLR_INVALID) && hbmMask) DeleteObject(hbmMask); if(!DrawEnd(handle)) return FALSE; return bRet; }
void InitAPIFlags (void) // InitAPIFlags // // Initialize API flags { // Check to see if we're running on Windows NT OSVERSIONINFO osvi; osvi.dwOSVersionInfoSize = sizeof(osvi); if (GetVersionEx(&osvi)) if (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT) g_dwAPIFlags |= API_FLAG_WINNT; // DWM runs on Vista and above if (osvi.dwMajorVersion >= 6) g_dwAPIFlags |= API_FLAG_DWM; // Check to see if MaskBlt is available HDC hSourceDC, hDestDC; HBITMAP hDestBmp, hSourceBmp, hMaskBmp; hSourceDC = CreateCompatibleDC(NULL); hDestDC = CreateCompatibleDC(NULL); hDestBmp = CreateCompatibleBitmap(hSourceDC, 10, 10); hSourceBmp = CreateCompatibleBitmap(hSourceDC, 10, 10); hMaskBmp = CreateCompatibleBitmap(hSourceDC, 10, 10); SelectObject(hSourceDC, hSourceBmp); SelectObject(hDestDC, hDestBmp); if (MaskBlt(hDestDC, 0, 0, 10, 10, hSourceDC, 0, 0, hMaskBmp, 0, 0, 0xCCAA0000L)) g_dwAPIFlags |= API_FLAG_MASKBLT; DeleteDC(hSourceDC); DeleteDC(hDestDC); DeleteObject(hDestBmp); DeleteObject(hSourceBmp); DeleteObject(hMaskBmp); }
void num_out(HDC dc, int x, int y, HBITMAP mask, int value, char *descr) { char temp[32]; int count, i, n; HDC hdccomp; hdccomp = CreateCompatibleDC(dc); SelectObject(hdccomp, mask); itoa(value, temp, 10); count = (int)strlen(temp); for(i = 0; i < count; ++i) { n = temp[i] - '0'; MaskBlt( dc, x, y+2, MASK_W, MASK_H, hdccomp, 0, 0, mask, n * MASK_W, 0, MAKEROP4(PATCOPY, 0x00AA0029)); x += MASK_W; } TextOut(dc, x + 5, y, descr, (int)strlen(descr)); DeleteDC(hdccomp); }
JNIEXPORT void JNICALL Java_org_apache_harmony_awt_gl_windows_GDIBlitter_xorImage (JNIEnv *env, jobject obj, jint srcX, jint srcY, jlong srcSurfStruct, jobject srcData, jint dstX, jint dstY, jlong dstSurfStruct, jint width, jint height, jint xorcolor, jdoubleArray matrix, jintArray clip, jint numVertex, jboolean invalidated, jintArray dirtyRegions, jint regCount){ SURFACE_STRUCTURE *srcSurf = (SURFACE_STRUCTURE *)srcSurfStruct; SURFACE_STRUCTURE *dstSurf = (SURFACE_STRUCTURE *)dstSurfStruct; srcSurf->invalidated = invalidated != 0; int *regions; if(dirtyRegions == 0){ regCount = 4; regions = (int *)malloc(4 * sizeof(int)); regions[0] = 0; regions[1] = 0; regions[2] = srcSurf->width - 1; regions[3] = srcSurf->height - 1; } else { regions = (int *)malloc(regCount * sizeof(int)); env->GetIntArrayRegion(dirtyRegions, 1, regCount, regions); } if(!initBitmap(srcSurf, env, srcData, false, regions, regCount)) return; BYTE r = (BYTE)((xorcolor >> 16) & 0xff); BYTE g = (BYTE)((xorcolor >> 8) & 0xff); BYTE b = (BYTE)(xorcolor & 0xff); HBRUSH brush = CreateSolidBrush(RGB(r, g, b)); XFORM currentTransform, transform; if(matrix != NULL){ jdouble * mtrx = (jdouble *)env->GetPrimitiveArrayCritical(matrix, 0); jdouble * old_mtrx = mtrx; transform.eM11 = (FLOAT)(*mtrx++); transform.eM12 = (FLOAT)(*mtrx++); transform.eM21 = (FLOAT)(*mtrx++); transform.eM22 = (FLOAT)(*mtrx++); transform.eDx = (FLOAT)(*mtrx++); transform.eDy = (FLOAT)(*mtrx); env->ReleasePrimitiveArrayCritical(matrix, old_mtrx, 0); SetGraphicsMode(dstSurf->gi->hdc, GM_ADVANCED); GetWorldTransform(dstSurf->gi->hdc, ¤tTransform); SetWorldTransform(dstSurf->gi->hdc, &transform); } HRGN oldClip = setGdiClip(env, dstSurf->gi->hdc, clip, numVertex); HGDIOBJ oldBrush = SelectObject(dstSurf->gi->hdc, brush); if(srcSurf->has_alpha){ int scanline_word = srcSurf->width / 16; if(srcSurf->width % 16 != 0) scanline_word++; BYTE *pm = (BYTE *)calloc(scanline_word * srcSurf->height * 2, 1); int byteIdx = 0; unsigned int *p = (unsigned int *)srcSurf->bmpData; for(int y = 0; y < srcSurf->height; y++){ for(int x = 0, shift = 7; x < srcSurf->width; x++, shift--, p++){ if(shift < 0 ){ shift = 7; byteIdx++; } unsigned int pixel = (*p >> 24) & 0xff; if(pixel > 127) pm[byteIdx] |= 1 << shift; } if(byteIdx % 2 != 0) byteIdx++; else byteIdx += 2; } HBITMAP mask = CreateBitmap(srcSurf->width, srcSurf->height, 1, 1, pm); free(pm); MaskBlt(dstSurf->gi->hdc, dstX, dstY, width, height, srcSurf->srcDC, srcX, srcY, mask, srcX, srcY, MAKEROP4(0x960169, 0xAA0029)); DeleteObject(mask); }else{
LRESULT dlgWndBadPIN::ProcecEvent ( UINT uMsg, // Message For This Window WPARAM wParam, // Additional Message Information LPARAM lParam ) // Additional Message Information { PAINTSTRUCT ps; RECT rect; switch( uMsg ) { case WM_COMMAND: { switch( LOWORD(wParam) ) { case IDB_OK: dlgResult = eIDMW::DLG_OK; close(); return TRUE; case IDB_CANCEL: dlgResult = eIDMW::DLG_CANCEL; close(); return TRUE; case IDB_RETRY: dlgResult = eIDMW::DLG_RETRY; close(); return TRUE; default: return DefWindowProc( m_hWnd, uMsg, wParam, lParam ); } } case WM_SIZE: { MWLOG(LEV_DEBUG, MOD_DLG, L" --> dlgWndBadPIN::ProcecEvent WM_SIZE (wParam=%X, lParam=%X)",wParam,lParam); if( IsIconic( m_hWnd ) ) return 0; break; } case WM_PAINT: { m_hDC = BeginPaint( m_hWnd, &ps ); HDC hdcMem; hdcMem = CreateCompatibleDC( m_hDC ); SelectObject( hdcMem , ImagePIN ); MaskBlt( m_hDC, 4, 4, IMG_SIZE, IMG_SIZE, hdcMem, 0, 0, ImagePIN_Mask, 0, 0, MAKEROP4( SRCCOPY, 0x00AA0029 ) ); DeleteDC(hdcMem); GetClientRect( m_hWnd, &rect ); rect.left += 136; rect.top += 32; rect.right -= 8; rect.bottom = 136 - 8; SetBkColor( m_hDC, GetSysColor( COLOR_3DFACE ) ); SelectObject( m_hDC, TextFont ); DrawText( m_hDC, szHeader, -1, &rect, DT_WORDBREAK ); EndPaint( m_hWnd, &ps ); SetForegroundWindow( m_hWnd ); return 0; } case WM_NCACTIVATE: { MWLOG(LEV_DEBUG, MOD_DLG, L" --> dlgWndBadPIN::ProcecEvent WM_NCACTIVATE (wParam=%X, lParam=%X)",wParam,lParam); if( !IsIconic( m_hWnd ) && m_ModalHold && Active_hWnd == m_hWnd ) { ShowWindow( m_hWnd, SW_SHOW ); SetFocus( m_hWnd ); return 0; } break; } case WM_KILLFOCUS: { MWLOG(LEV_DEBUG, MOD_DLG, L" --> dlgWndBadPIN::ProcecEvent WM_KILLFOCUS (wParam=%X, lParam=%X)",wParam,lParam); if( !IsIconic( m_hWnd ) && m_ModalHold && Active_hWnd == m_hWnd ) { if( GetParent((HWND)wParam ) != m_hWnd ) { SetFocus( m_hWnd ); return 0; } } break; } case WM_CREATE: { MWLOG(LEV_DEBUG, MOD_DLG, L" --> dlgWndBadPIN::ProcecEvent WM_CREATE (wParam=%X, lParam=%X)",wParam,lParam); HMENU hSysMenu; hSysMenu = GetSystemMenu( m_hWnd, FALSE ); EnableMenuItem( hSysMenu, 2, MF_BYPOSITION | MF_GRAYED ); return 1; } case WM_CLOSE: { MWLOG(LEV_DEBUG, MOD_DLG, L" --> dlgWndBadPIN::ProcecEvent WM_CLOSE (wParam=%X, lParam=%X)",wParam,lParam); if( IsIconic( m_hWnd ) ) return DefWindowProc( m_hWnd, uMsg, wParam, lParam ); ShowWindow( m_hWnd, SW_MINIMIZE ); return 0; } case WM_DESTROY: { MWLOG(LEV_DEBUG, MOD_DLG, L" --> dlgWndBadPIN::ProcecEvent WM_DESTROY (wParam=%X, lParam=%X)",wParam,lParam); break; } default: { return DefWindowProc( m_hWnd, uMsg, wParam, lParam ); } } return DefWindowProc( m_hWnd, uMsg, wParam, lParam ); }
void OnPaint(HWND hWnd, HDC hdc, PAINTSTRUCT *ps) { #ifdef USE_WATERMARK TODAYDRAWWATERMARKINFO dwi; #endif HDC drawdc, tempdc; HBITMAP hDrawBitMap; HBITMAP hRetDrawBmp; // HBITMAP hRetBmp; RECT rect; RECT selrect; // BITMAP bmp; int x, y; int i; HBRUSH hBrush; GetClientRect(hWnd, (LPRECT)&rect); drawdc = CreateCompatibleDC(hdc); tempdc = CreateCompatibleDC(hdc); hDrawBitMap = CreateCompatibleBitmap(hdc, rect.right, rect.bottom); hRetDrawBmp = SelectObject(drawdc, hDrawBitMap); #ifdef USE_WATERMARK dwi.hdc = drawdc; GetClientRect(hWnd, &dwi.rc); dwi.hwnd = hWnd; SendMessage(GetParent(hWnd), TODAYM_DRAWWATERMARK, 0, (LPARAM)&dwi); #else FillRect(drawdc, &rect, (HBRUSH)GetStockObject(WHITE_BRUSH)); #endif x = WinLeftMargin; y = WinTopMargin; for(i = 0; i < FileListCnt; i++) { if(SelItem == i) { SetRect(&selrect, x, y, x + IconSizeX + (HMargin * 2), y + IconSizeY + (VMargin * 2)); hBrush = CreateSolidBrush(GetSysColor(COLOR_HIGHLIGHT)); FillRect(drawdc, &selrect, hBrush); DeleteObject(hBrush); } SelectObject(tempdc, FileList[i].bitmap); #ifdef USE_MASKS MaskBlt(drawdc, x+HMargin, y+VMargin, IconSizeX, IconSizeY, tempdc, 0, 0, FileList[i].mask, 0, 0, MAKEROP4(0x00AA0029,SRCCOPY)); #else TransparentBlt(drawdc, x+HMargin, y+VMargin, IconSizeX, IconSizeY, tempdc, 0, 0, IconSizeX, IconSizeY, RGB(0, 0, 255)); #endif x+= IconSizeX+HMargin*2; } BitBlt(hdc, ps->rcPaint.left, ps->rcPaint.top, ps->rcPaint.right, ps->rcPaint.bottom, drawdc, ps->rcPaint.left, ps->rcPaint.top, SRCCOPY); SelectObject(drawdc, hRetDrawBmp); DeleteObject(hDrawBitMap); DeleteDC(drawdc); DeleteDC(tempdc); }
void endPaintingL(HDC hdc, LONG x, LONG y, COLORREF fg, COLORREF bg) { switch (activeTool) { case TOOL_FREESEL: { POINT *ptStackCopy; int i; rectSel_src[0] = rectSel_src[1] = 0x7fffffff; rectSel_src[2] = rectSel_src[3] = 0; for (i = 0; i <= ptSP; i++) { if (ptStack[i].x < rectSel_src[0]) rectSel_src[0] = ptStack[i].x; if (ptStack[i].y < rectSel_src[1]) rectSel_src[1] = ptStack[i].y; if (ptStack[i].x > rectSel_src[2]) rectSel_src[2] = ptStack[i].x; if (ptStack[i].y > rectSel_src[3]) rectSel_src[3] = ptStack[i].y; } rectSel_src[2] += 1 - rectSel_src[0]; rectSel_src[3] += 1 - rectSel_src[1]; rectSel_dest[0] = rectSel_src[0]; rectSel_dest[1] = rectSel_src[1]; rectSel_dest[2] = rectSel_src[2]; rectSel_dest[3] = rectSel_src[3]; if (ptSP != 0) { DeleteObject(hSelMask); hSelMask = CreateBitmap(rectSel_src[2], rectSel_src[3], 1, 1, NULL); DeleteObject(SelectObject(hSelDC, hSelMask)); ptStackCopy = HeapAlloc(GetProcessHeap(), HEAP_GENERATE_EXCEPTIONS, sizeof(POINT) * (ptSP + 1)); for (i = 0; i <= ptSP; i++) { ptStackCopy[i].x = ptStack[i].x - rectSel_src[0]; ptStackCopy[i].y = ptStack[i].y - rectSel_src[1]; } Poly(hSelDC, ptStackCopy, ptSP + 1, 0x00ffffff, 0x00ffffff, 1, 2, TRUE); HeapFree(GetProcessHeap(), 0, ptStackCopy); SelectObject(hSelDC, hSelBm = CreateDIBWithProperties(rectSel_src[2], rectSel_src[3])); resetToU1(); MaskBlt(hSelDC, 0, 0, rectSel_src[2], rectSel_src[3], hDrawingDC, rectSel_src[0], rectSel_src[1], hSelMask, 0, 0, MAKEROP4(SRCCOPY, WHITENESS)); Poly(hdc, ptStack, ptSP + 1, bg, bg, 1, 2, TRUE); newReversible(); MaskBlt(hDrawingDC, rectSel_src[0], rectSel_src[1], rectSel_src[2], rectSel_src[3], hSelDC, 0, 0, hSelMask, 0, 0, MAKEROP4(SRCCOPY, SRCAND)); placeSelWin(); ShowWindow(hSelection, SW_SHOW); /* force refresh of selection contents */ SendMessage(hSelection, WM_LBUTTONDOWN, 0, 0); SendMessage(hSelection, WM_MOUSEMOVE, 0, 0); SendMessage(hSelection, WM_LBUTTONUP, 0, 0); } HeapFree(GetProcessHeap(), 0, ptStack); ptStack = NULL; break; } case TOOL_RECTSEL: resetToU1(); if ((rectSel_src[2] != 0) && (rectSel_src[3] != 0)) { DeleteObject(hSelMask); hSelMask = CreateBitmap(rectSel_src[2], rectSel_src[3], 1, 1, NULL); DeleteObject(SelectObject(hSelDC, hSelMask)); Rect(hSelDC, 0, 0, rectSel_src[2], rectSel_src[3], 0x00ffffff, 0x00ffffff, 1, 2); SelectObject(hSelDC, hSelBm = CreateDIBWithProperties(rectSel_src[2], rectSel_src[3])); resetToU1(); BitBlt(hSelDC, 0, 0, rectSel_src[2], rectSel_src[3], hDrawingDC, rectSel_src[0], rectSel_src[1], SRCCOPY); Rect(hdc, rectSel_src[0], rectSel_src[1], rectSel_src[0] + rectSel_src[2], rectSel_src[1] + rectSel_src[3], bgColor, bgColor, 0, TRUE); newReversible(); BitBlt(hDrawingDC, rectSel_src[0], rectSel_src[1], rectSel_src[2], rectSel_src[3], hSelDC, 0, 0, SRCCOPY); placeSelWin(); ShowWindow(hSelection, SW_SHOW); /* force refresh of selection contents */ SendMessage(hSelection, WM_LBUTTONDOWN, 0, 0); SendMessage(hSelection, WM_MOUSEMOVE, 0, 0); SendMessage(hSelection, WM_LBUTTONUP, 0, 0); } break; case TOOL_RUBBER: Erase(hdc, last.x, last.y, x, y, bg, rubberRadius); break; case TOOL_PEN: Line(hdc, last.x, last.y, x, y, fg, 1); SetPixel(hdc, x, y, fg); break; case TOOL_LINE: resetToU1(); if (GetAsyncKeyState(VK_SHIFT) < 0) roundTo8Directions(start.x, start.y, &x, &y); Line(hdc, start.x, start.y, x, y, fg, lineWidth); break; case TOOL_BEZIER: pointSP++; if (pointSP == 4) pointSP = 0; break; case TOOL_RECT: resetToU1(); if (GetAsyncKeyState(VK_SHIFT) < 0) regularize(start.x, start.y, &x, &y); Rect(hdc, start.x, start.y, x, y, fg, bg, lineWidth, shapeStyle); break; case TOOL_SHAPE: resetToU1(); pointStack[pointSP].x = x; pointStack[pointSP].y = y; if ((pointSP > 0) && (GetAsyncKeyState(VK_SHIFT) < 0)) roundTo8Directions(pointStack[pointSP - 1].x, pointStack[pointSP - 1].y, &pointStack[pointSP].x, &pointStack[pointSP].y); pointSP++; if (pointSP >= 2) { if ((pointStack[0].x - x) * (pointStack[0].x - x) + (pointStack[0].y - y) * (pointStack[0].y - y) <= lineWidth * lineWidth + 1) { Poly(hdc, pointStack, pointSP, fg, bg, lineWidth, shapeStyle, TRUE); pointSP = 0; } else { Poly(hdc, pointStack, pointSP, fg, bg, lineWidth, shapeStyle, FALSE); } } if (pointSP == 255) pointSP--; break; case TOOL_ELLIPSE: resetToU1(); if (GetAsyncKeyState(VK_SHIFT) < 0) regularize(start.x, start.y, &x, &y); Ellp(hdc, start.x, start.y, x, y, fg, bg, lineWidth, shapeStyle); break; case TOOL_RRECT: resetToU1(); if (GetAsyncKeyState(VK_SHIFT) < 0) regularize(start.x, start.y, &x, &y); RRect(hdc, start.x, start.y, x, y, fg, bg, lineWidth, shapeStyle); break; } }
LRESULT CALLBACK SelectionWinProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { switch (message) { case WM_PAINT: { if (!moving) { HDC hDC = GetDC(hwnd); DefWindowProc(hwnd, message, wParam, lParam); SelectionFrame(hDC, 1, 1, rectSel_dest[2] * zoom / 1000 + 5, rectSel_dest[3] * zoom / 1000 + 5); ReleaseDC(hwnd, hDC); } break; } case WM_LBUTTONDOWN: xPos = LOWORD(lParam); yPos = HIWORD(lParam); SetCapture(hwnd); if (action != 0) SetCursor(LoadCursor(NULL, cursors[action])); moving = TRUE; break; case WM_MOUSEMOVE: if (moving) { TCHAR sizeStr[100]; int xDelta; int yDelta; resetToU1(); xFrac += (short)LOWORD(lParam) - xPos; yFrac += (short)HIWORD(lParam) - yPos; if (zoom < 1000) { xDelta = xFrac * 1000 / zoom; xFrac = 0; yDelta = yFrac * 1000 / zoom; yFrac = 0; } else { xDelta = xFrac * 1000 / zoom; xFrac -= (xFrac * 1000 / zoom) * zoom / 1000; yDelta = yFrac * 1000 / zoom; yFrac -= (yFrac * 1000 / zoom) * zoom / 1000; } switch (action) { case 0: rectSel_dest[0] += xDelta; rectSel_dest[1] += yDelta; break; case 1: rectSel_dest[0] += xDelta; rectSel_dest[1] += yDelta; rectSel_dest[2] -= xDelta; rectSel_dest[3] -= yDelta; break; case 2: rectSel_dest[1] += yDelta; rectSel_dest[3] -= yDelta; break; case 3: rectSel_dest[2] += xDelta; rectSel_dest[1] += yDelta; break; case 4: rectSel_dest[0] += xDelta; rectSel_dest[2] -= xDelta; break; case 5: rectSel_dest[2] += xDelta; break; case 6: rectSel_dest[0] += xDelta; rectSel_dest[2] -= xDelta; rectSel_dest[3] += yDelta; break; case 7: rectSel_dest[3] += yDelta; break; case 8: rectSel_dest[2] += xDelta; rectSel_dest[3] += yDelta; break; } _stprintf(sizeStr, _T("%d x %d"), rectSel_dest[2], rectSel_dest[3]); SendMessage(hStatusBar, SB_SETTEXT, 2, (LPARAM) sizeStr); if (action != 0) StretchBlt(hDrawingDC, rectSel_dest[0], rectSel_dest[1], rectSel_dest[2], rectSel_dest[3], hSelDC, 0, 0, GetDIBWidth(hSelBm), GetDIBHeight(hSelBm), SRCCOPY); else if (transpBg == 0) MaskBlt(hDrawingDC, rectSel_dest[0], rectSel_dest[1], rectSel_dest[2], rectSel_dest[3], hSelDC, 0, 0, hSelMask, 0, 0, MAKEROP4(SRCCOPY, SRCAND)); else { HBITMAP tempMask; HBRUSH oldBrush; HDC tempDC; tempMask = CreateBitmap(rectSel_dest[2], rectSel_dest[3], 1, 1, NULL); oldBrush = SelectObject(hSelDC, CreateSolidBrush(bgColor)); tempDC = CreateCompatibleDC(hSelDC); SelectObject(tempDC, tempMask); MaskBlt(tempDC, 0, 0, rectSel_dest[2], rectSel_dest[3], hSelDC, 0, 0, hSelMask, 0, 0, MAKEROP4(NOTSRCCOPY, BLACKNESS)); DeleteDC(tempDC); DeleteObject(SelectObject(hSelDC, oldBrush)); MaskBlt(hDrawingDC, rectSel_dest[0], rectSel_dest[1], rectSel_dest[2], rectSel_dest[3], hSelDC, 0, 0, tempMask, 0, 0, MAKEROP4(SRCCOPY, SRCAND)); DeleteObject(tempMask); } SendMessage(hImageArea, WM_PAINT, 0, 0); xPos = LOWORD(lParam); yPos = HIWORD(lParam); //SendMessage(hwnd, WM_PAINT, 0, 0); } else { int w = rectSel_dest[2] * zoom / 1000 + 6; int h = rectSel_dest[3] * zoom / 1000 + 6; xPos = LOWORD(lParam); yPos = HIWORD(lParam); SendMessage(hStatusBar, SB_SETTEXT, 2, (LPARAM) NULL); action = identifyCorner(xPos, yPos, w, h); if (action != 0) SetCursor(LoadCursor(NULL, cursors[action])); } break; case WM_LBUTTONUP: if (moving) { moving = FALSE; ReleaseCapture(); if (action != 0) { HDC hTempDC; HBITMAP hTempBm; hTempDC = CreateCompatibleDC(hSelDC); hTempBm = CreateDIBWithProperties(rectSel_dest[2], rectSel_dest[3]); SelectObject(hTempDC, hTempBm); SelectObject(hSelDC, hSelBm); StretchBlt(hTempDC, 0, 0, rectSel_dest[2], rectSel_dest[3], hSelDC, 0, 0, GetDIBWidth(hSelBm), GetDIBHeight(hSelBm), SRCCOPY); DeleteObject(hSelBm); hSelBm = hTempBm; hTempBm = CreateBitmap(rectSel_dest[2], rectSel_dest[3], 1, 1, NULL); SelectObject(hTempDC, hTempBm); SelectObject(hSelDC, hSelMask); StretchBlt(hTempDC, 0, 0, rectSel_dest[2], rectSel_dest[3], hSelDC, 0, 0, GetDIBWidth(hSelMask), GetDIBHeight(hSelMask), SRCCOPY); DeleteObject(hSelMask); hSelMask = hTempBm; SelectObject(hSelDC, hSelBm); DeleteDC(hTempDC); } placeSelWin(); ShowWindow(hSelection, SW_HIDE); ShowWindow(hSelection, SW_SHOW); } break; default: return DefWindowProc(hwnd, message, wParam, lParam); } return 0; }
BOOL SecMgrDisplayXGraphic( IN HWND hwnd, IN INT ControlId, IN BOOL Stronger ) { HWND ControlHandle; LONG ControlStyle; // // Make sure the control into which we are about to set this graphic // is a bitmap. // SecMgrpSetControlToBitmap( hwnd, ControlId ); // // Now put the bitmap in the control // //efine EXPERIMENT #ifndef EXPERIMENT if (Stronger) { SendDlgItemMessage( hwnd, ControlId, STM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM)SecMgrpUpArrowBitMap ); } else { SendDlgItemMessage( hwnd, ControlId, STM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM)SecMgrpXBitMap ); } #else { BOOL Result; HWND ControlHandle; HDC ControlDC, CompatibleDC; BITMAP BitmapInfo; RECT ControlRect; // // ControlHandle = GetDlgItem( hwnd, ControlId); DbgPrint(" ControlHandle = %d (0x%lx)\n", ControlHandle, ControlHandle ); ControlDC = GetDC( ControlHandle ); DbgPrint(" ControlDC = %d (0x%lx)\n", ControlDC, ControlDC ); CompatibleDC = CreateCompatibleDC( ControlDC ); DbgPrint(" CompatibleDC = %d (0x%lx)\n", CompatibleDC, CompatibleDC ); if (CompatibleDC != NULL) { if (GetWindowRect( ControlHandle, &ControlRect )) { DbgPrint(" WindowRec (Left,top) (%d,%d)\n", ControlRect.left, ControlRect.top ); SelectObject( CompatibleDC, SecMgrpXBitMap ); GetObject (SecMgrpXBitMap, sizeof(BITMAP), &BitmapInfo); Result = MaskBlt (ControlDC, ControlRect.left, ControlRect.top, BitmapInfo.bmWidth, BitmapInfo.bmHeight, CompatibleDC, 0, 0, SecMgrpXBitMapMask, 0,0, MAKEROP4(SRCCOPY,SRCAND)); #if DBG if (Result) { DbgPrint(" MaskBlt worked\n"); } else { DbgPrint(" MaskBlt ** FAILED ** GetLastError() = %d (0x%lx)\n", GetLastError(), GetLastError()); } #endif //DBG } DeleteDC (CompatibleDC); } } #endif // EXPERIMENT return(TRUE); }
/********************************************************************* * PlgBlt [GDI32.@] * */ BOOL WINAPI PlgBlt( HDC hdcDest, const POINT *lpPoint, HDC hdcSrc, INT nXSrc, INT nYSrc, INT nWidth, INT nHeight, HBITMAP hbmMask, INT xMask, INT yMask) { int oldgMode; /* parallelogram coords */ POINT plg[3]; /* rect coords */ POINT rect[3]; XFORM xf; XFORM SrcXf; XFORM oldDestXf; double det; /* save actual mode, set GM_ADVANCED */ oldgMode = SetGraphicsMode(hdcDest,GM_ADVANCED); if (oldgMode == 0) return FALSE; memcpy(plg,lpPoint,sizeof(POINT)*3); rect[0].x = nXSrc; rect[0].y = nYSrc; rect[1].x = nXSrc + nWidth; rect[1].y = nYSrc; rect[2].x = nXSrc; rect[2].y = nYSrc + nHeight; /* calc XFORM matrix to transform hdcDest -> hdcSrc (parallelogram to rectangle) */ /* determinant */ det = rect[1].x*(rect[2].y - rect[0].y) - rect[2].x*(rect[1].y - rect[0].y) - rect[0].x*(rect[2].y - rect[1].y); if (fabs(det) < 1e-5) { SetGraphicsMode(hdcDest,oldgMode); return FALSE; } TRACE("hdcSrc=%p %d,%d,%dx%d -> hdcDest=%p %d,%d,%d,%d,%d,%d\n", hdcSrc, nXSrc, nYSrc, nWidth, nHeight, hdcDest, plg[0].x, plg[0].y, plg[1].x, plg[1].y, plg[2].x, plg[2].y); /* X components */ xf.eM11 = (plg[1].x*(rect[2].y - rect[0].y) - plg[2].x*(rect[1].y - rect[0].y) - plg[0].x*(rect[2].y - rect[1].y)) / det; xf.eM21 = (rect[1].x*(plg[2].x - plg[0].x) - rect[2].x*(plg[1].x - plg[0].x) - rect[0].x*(plg[2].x - plg[1].x)) / det; xf.eDx = (rect[0].x*(rect[1].y*plg[2].x - rect[2].y*plg[1].x) - rect[1].x*(rect[0].y*plg[2].x - rect[2].y*plg[0].x) + rect[2].x*(rect[0].y*plg[1].x - rect[1].y*plg[0].x) ) / det; /* Y components */ xf.eM12 = (plg[1].y*(rect[2].y - rect[0].y) - plg[2].y*(rect[1].y - rect[0].y) - plg[0].y*(rect[2].y - rect[1].y)) / det; xf.eM22 = (rect[1].x*(plg[2].y - plg[0].y) - rect[2].x*(plg[1].y - plg[0].y) - rect[0].x*(plg[2].y - plg[1].y)) / det; xf.eDy = (rect[0].x*(rect[1].y*plg[2].y - rect[2].y*plg[1].y) - rect[1].x*(rect[0].y*plg[2].y - rect[2].y*plg[0].y) + rect[2].x*(rect[0].y*plg[1].y - rect[1].y*plg[0].y) ) / det; GetWorldTransform(hdcSrc,&SrcXf); CombineTransform(&xf,&xf,&SrcXf); /* save actual dest transform */ GetWorldTransform(hdcDest,&oldDestXf); SetWorldTransform(hdcDest,&xf); /* now destination and source DCs use same coords */ MaskBlt(hdcDest,nXSrc,nYSrc,nWidth,nHeight, hdcSrc, nXSrc,nYSrc, hbmMask,xMask,yMask, SRCCOPY); /* restore dest DC */ SetWorldTransform(hdcDest,&oldDestXf); SetGraphicsMode(hdcDest,oldgMode); return TRUE; }
// Draw the src rect of the specified image into the dest rect of the hdc void CImgBitsDIB::StretchBlt(HDC hdc, RECT* prcDst, RECT* prcSrc, DWORD dwRop, DWORD dwFlags) { HDC hdcDib = NULL; HBITMAP hbmSav = NULL; int xDst = prcDst->left; int yDst = prcDst->top; int xDstWid = prcDst->right - xDst; int yDstHei = prcDst->bottom - yDst; int xSrc = prcSrc->left; int ySrc = prcSrc->top; int xSrcWid = prcSrc->right - xSrc; int ySrcHei = prcSrc->bottom - ySrc; int yUseHei = _yHeight; // Cases in which there is nothing to draw if((!_pvImgBits && !_pvMaskBits && !_fSolid) || _yHeightValid==0) { return; } if(xDstWid<=0 || xSrcWid<=0 || _xWidth<=0 || yDstHei<=0 || ySrcHei<=0 || _yHeight<=0) { return; } if(dwRop!=SRCCOPY && (_pvMaskBits || _iTrans>=0)) { return; } // Step 1: Limit the source and dest rectangles to the visible area only. if(_yHeightValid>0 && _yHeightValid<_yHeight) { yUseHei = _yHeightValid; } if(xSrc < 0) { xDst += MulDivQuick(-xSrc, xDstWid, xSrcWid); xDstWid = prcDst->right - xDst; xSrcWid += xSrc; xSrc = 0; if(xDstWid<=0 || xSrcWid<=0) { return; } } if(ySrc < 0) { yDst += MulDivQuick(-ySrc, yDstHei, ySrcHei); yDstHei = prcDst->bottom - yDst; ySrcHei += ySrc; ySrc = 0; if(yDstHei<=0 || ySrcHei<=0) { return; } } if(xSrc+xSrcWid > _xWidth) { xDstWid = MulDivQuick(xDstWid, _xWidth-xSrc, xSrcWid); xSrcWid = _xWidth - xSrc; if(xDstWid<=0 || xSrcWid<=0) { return; } } if(ySrc+ySrcHei > yUseHei) { yDstHei = MulDivQuick(yDstHei, yUseHei-ySrc, ySrcHei); ySrcHei = yUseHei - ySrc; if(yDstHei<=0 || ySrcHei<=0) { return; } } // For the mirrored case, we need flip then offset. if(_fNeedMirroring) { // We need to handle clipping correctly and give a right-to-left tiling effect. // Let's take the "opposite" slice of the source. // The maximum will be the whole image. xSrc = - xSrc +_xWidth - xSrcWid; xDst += xDstWid - 1; xDstWid = - xDstWid; } // Optimization: if solid, just patblt the color if(_fSolid) { // Turn on the palette relative bit for palettized devices in order to ensure that dithering // doesn't happen here. The main reason is that is looks ugly, but more importantly we aren't // prepared to seam multiple copies of the image so that the dithering looks smooth. PatBltBrush(hdc, xDst, yDst, xDstWid, yDstHei, PATCOPY, _crSolid|g_crPaletteRelative); return; } SetStretchBltMode(hdc, COLORONCOLOR); // Step 2: For tranparent images, use mask to whiten drawing area if(_pvMaskBits || _iTrans>=0) { if(dwFlags & DRAWIMAGE_NOTRANS) { goto NoTransparency; } if(GetDeviceCaps(hdc, TECHNOLOGY) == DT_RASPRINTER) { // No transparency for printers that we know lie about their support for transparency. int iEscapeFunction = POSTSCRIPT_PASSTHROUGH; THREADSTATE* pts = GetThreadState(); if(Escape(hdc, QUERYESCSUPPORT, sizeof(int), (LPCSTR)&iEscapeFunction, NULL)) { // Skip transparency unless we are a mask-only image if(_pvImgBits || !_pvMaskBits) { goto NoTransparency; } } } if(_pvMaskBits) { // 1-bit mask case if(_hbmMask) { // We have an HBITMAP, not just bits Assert(!hdcDib && !hbmSav); hdcDib = GetMemoryDC(); if(!hdcDib) { goto Cleanup; } // Special case: use MaskBlt for the whole thing on NT if(xSrcWid==xDstWid && ySrcHei==yDstHei && _hbmImg) { hbmSav = (HBITMAP)SelectObject(hdcDib, _hbmImg); MaskBlt(hdc, xDst, yDst, xDstWid, yDstHei, hdcDib, xSrc, ySrc, _hbmMask, xSrc, ySrc, 0xAACC0020); goto Cleanup; } hbmSav = (HBITMAP)SelectObject(hdcDib, _hbmMask); if(!_pvImgBits) { // a mask-only one-bit image: just draw the "1" bits as black ::StretchBlt(hdc, xDst, yDst, xDstWid, yDstHei, hdcDib, xSrc, ySrc, xSrcWid, ySrcHei, MERGEPAINT); } else { // transparent mask: draw the "1" bits as white ::StretchBlt(hdc, xDst, yDst, xDstWid, yDstHei, hdcDib, xSrc, ySrc, xSrcWid, ySrcHei, SRCPAINT); } } else { // We have just bits, not an HBITMAP struct { BITMAPINFOHEADER bmih; union { RGBQUAD rgb[2]; WORD windex[2]; }; } bmiMask; // construct mask header memset(&bmiMask, 0, sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*2); bmiMask.bmih.biSize = sizeof(BITMAPINFOHEADER); bmiMask.bmih.biWidth = _xWidth; bmiMask.bmih.biHeight = _yHeight; bmiMask.bmih.biPlanes = 1; bmiMask.bmih.biBitCount = 1; if(!_pvImgBits) { // a mask-only one-bit image: just draw the "1" bits as black bmiMask.rgb[0] = g_rgbWhite; StretchDIBits(hdc, xDst, yDst, xDstWid, yDstHei, xSrc, _yHeight-ySrc-ySrcHei, xSrcWid, ySrcHei, _pvMaskBits, (BITMAPINFO*)&bmiMask, DIB_RGB_COLORS, SRCAND); } else if(_iBitCount<=8 && _fPalColors && !(dwFlags&DRAWIMAGE_NHPALETTE)) { // this setup only occurs on an 8-bit palettized display; we can use DIB_PAL_COLORS bmiMask.windex[1] = 255; StretchDIBits(hdc, xDst, yDst, xDstWid, yDstHei, xSrc, _yHeight-ySrc-ySrcHei, xSrcWid, ySrcHei, _pvMaskBits, (BITMAPINFO*)&bmiMask, DIB_PAL_COLORS, SRCPAINT); } else { bmiMask.rgb[1] = g_rgbWhite; StretchDIBits(hdc, xDst, yDst, xDstWid, yDstHei, xSrc, _yHeight-ySrc-ySrcHei, xSrcWid, ySrcHei, _pvMaskBits, (BITMAPINFO *)&bmiMask, DIB_RGB_COLORS, SRCPAINT); } } } else { // 1- 4- or 8-bit mask case (with _iTrans) long cTable = 1 << _iBitCount; Assert(_iTrans >= 0); Assert(_iTrans < cTable); Assert(_iBitCount <= 8); if(_hbmImg) { // We have an HBITMAP, not just bits RGBQUAD argbOld[256]; RGBQUAD argbNew[256]; memset(argbNew, 0, sizeof(RGBQUAD)*cTable); argbNew[_iTrans] = g_rgbWhite; Assert(!hdcDib && !hbmSav); hdcDib = GetMemoryDC(); if(!hdcDib) { goto Cleanup; } hbmSav = (HBITMAP)SelectObject(hdcDib, _hbmImg); // HBM case: we need to change the color table, which can only be done one-at-a time g_csImgTransBlt.Enter(); Verify(GetDIBColorTable(hdcDib, 0, cTable, argbOld) > 0); Verify(SetDIBColorTable(hdcDib, 0, cTable, argbNew) == (unsigned)cTable); ::StretchBlt(hdc, xDst, yDst, xDstWid, yDstHei, hdcDib, xSrc, ySrc, xSrcWid, ySrcHei, MERGEPAINT); Verify(SetDIBColorTable(hdcDib, 0, cTable, argbOld) == (unsigned)cTable); g_csImgTransBlt.Leave(); } else { // We have just bits, not an HBITMAP struct { BITMAPINFOHEADER bmih; RGBQUAD rgb[256]; } bmiMask; // construct mask header memset(&bmiMask, 0, sizeof(BITMAPINFOHEADER)+(sizeof(RGBQUAD)*cTable)); bmiMask.bmih.biSize = sizeof(BITMAPINFOHEADER); bmiMask.bmih.biWidth = _xWidth; bmiMask.bmih.biHeight = _yHeight; bmiMask.bmih.biPlanes = 1; bmiMask.bmih.biBitCount = _iBitCount; bmiMask.rgb[_iTrans] = g_rgbWhite; StretchDIBits(hdc, xDst, yDst, xDstWid, yDstHei, xSrc, _yHeight-ySrc-ySrcHei, xSrcWid, ySrcHei, _pvImgBits, (BITMAPINFO*)&bmiMask, DIB_RGB_COLORS, MERGEPAINT); } } // prepare for transparent blt: area to be painted is now whitened, so AND-blt on top of it dwRop = SRCAND; } NoTransparency: // Step 3: Draw the image bits if(_pvImgBits) { if(dwFlags & DRAWIMAGE_MASKONLY) { goto Cleanup; } if(_hbmImg) { // The normal case (not to a Win95 printer): call StretchBlt if(!hdcDib) { hdcDib = GetMemoryDC(); if(!hdcDib) { goto Cleanup; } } HBITMAP hbmOld; hbmOld = (HBITMAP)SelectObject(hdcDib, _hbmImg); if(!hbmSav) { hbmSav = hbmOld; } ::StretchBlt(hdc, xDst, yDst, xDstWid, yDstHei, hdcDib, xSrc, ySrc, xSrcWid, ySrcHei, dwRop); } else { // We have just bits, not an HBITMAP if(!_pbmih) { // No color table header: cobble up a standard header [perhaps these should just be globally cached?] struct { BITMAPINFOHEADER bmih; union { WORD windex[256]; RGBQUAD rgb[256]; DWORD bfmask[3]; }; } bmi; DWORD dwDibMode = DIB_RGB_COLORS; // construct mask header memset(&bmi, 0, sizeof(BITMAPINFOHEADER)+(_iBitCount>8?sizeof(DWORD)*3:sizeof(WORD)*(_iBitCount<<1))); bmi.bmih.biSize = sizeof(BITMAPINFOHEADER); bmi.bmih.biWidth = _xWidth; bmi.bmih.biHeight = _yHeight; bmi.bmih.biPlanes = 1; bmi.bmih.biBitCount = _iBitCount + (_iBitCount==15); if(_iBitCount == 4) { // Thanks to Steve Palmer: fix VGA color rendering bmi.bmih.biClrUsed = 16; bmi.bmih.biClrImportant = 16; CopyColorsFromPaletteEntries(bmi.rgb, g_peVga, 16); } else if(_iBitCount <= 8) { if(dwFlags & DRAWIMAGE_NHPALETTE) { // If being drawn on an <= 8-bit surface from a filter, we can make no assumptions about // the selected palette, so use RGB_COLORS LONG c; c = (1 << (_iBitCount-1)); memcpy(bmi.rgb, g_rgbHalftone, c*sizeof(RGBQUAD)); memcpy(bmi.rgb+c, g_rgbHalftone+256-c, c*sizeof(RGBQUAD)); } else { // internal draw, no color table with _iBitCount <= 8 means that the palette selected into hdc // is our standard 8-bit halftone palette and we can use DIB_PAL_COLORS LONG c; LONG d; WORD* pwi; dwDibMode = DIB_PAL_COLORS; for(c=(1<<(_iBitCount-1)),pwi=bmi.windex+c; c; *(--pwi)=(--c)); for(c=(1<<(_iBitCount-1)),pwi=bmi.windex+c*2,d=256; c; --c,*(--pwi)=(--d)); } } else if(_iBitCount == 16) { // sixteen-bit case: fill in the bitfields mask for 565 bmi.bmih.biCompression = BI_BITFIELDS; bmi.bfmask[0] = MASK565_0; bmi.bfmask[1] = MASK565_1; bmi.bfmask[2] = MASK565_2; } StretchDIBits(hdc, xDst, yDst, xDstWid, yDstHei, xSrc, _yHeight-ySrc-ySrcHei, xSrcWid, ySrcHei, _pvImgBits, (BITMAPINFO*)&bmi, dwDibMode, dwRop); } else { StretchDIBits(hdc, xDst, yDst, xDstWid, yDstHei, xSrc, _yHeight-ySrc-ySrcHei, xSrcWid, ySrcHei, _pvImgBits, (BITMAPINFO*)_pbmih, DIB_RGB_COLORS, dwRop); } } } Cleanup: if(hbmSav) { SelectObject(hdcDib, hbmSav); } if(hdcDib) { ReleaseMemoryDC(hdcDib); } }
// TODO code: optimise airspace drawing (same as DrawAirSpace()) // draw airspace using alpha blending //static void MapWindow::DrawTptAirSpace(HDC hdc, const RECT rc) { // since standard GDI functions (brushes, pens...) ignore alpha octet in ARGB // color value and don't set it in the resulting bitmap, we cannot use // perpixel alpha blending, instead we use global opacity for alpha blend // (same opacity for all pixels); for fully "transparent" areas (without // airspace) we must copy destination bitmap into source bitmap first so that // alpha blending of such areas results in the same pixels as origin pixels // in destination CAirspaceList::const_iterator it; CAirspaceList::const_reverse_iterator itr; const CAirspaceList& airspaces_to_draw = CAirspaceManager::Instance().GetNearAirspacesRef(); int airspace_type; bool found = false; bool borders_only = (GetAirSpaceFillType() == asp_fill_ablend_borders); bool outlined_only=(GetAirSpaceFillType()==asp_fill_border_only); static bool asp_selected_flash = false; asp_selected_flash = !asp_selected_flash; int nDC1 = SaveDC(mhdcbuffer); int nDC2 = SaveDC(hDCMask); int nDC3 = SaveDC(hDCTemp); // Draw airspace area if (1) { CCriticalSection::CGuard guard(CAirspaceManager::Instance().MutexRef()); if (borders_only) { // Draw in reverse order! // The idea behind this, is lower top level airspaces are smaller. (statistically) // They have to be draw later, because inside border area have to be in correct color, // not the color of the bigger airspace above this small one. for (itr=airspaces_to_draw.rbegin(); itr != airspaces_to_draw.rend(); ++itr) { if ((*itr)->DrawStyle() == adsFilled) { airspace_type = (*itr)->Type(); if (!found) { found = true; ClearTptAirSpace(hdc, rc); } // set filling brush SelectObject(mhdcbuffer, GetAirSpaceSldBrushByClass(airspace_type)); (*itr)->Draw(mhdcbuffer, rc, true); (*itr)->Draw(hDCMask, rc, false); } }//for } else { // Draw in direct order! for (it=airspaces_to_draw.begin(); it != airspaces_to_draw.end(); ++it) { if ((*it)->DrawStyle() == adsFilled) { airspace_type = (*it)->Type(); if (!found) { found = true; ClearTptAirSpace(hdc, rc); } // set filling brush SelectObject(hDCTemp, GetAirSpaceSldBrushByClass(airspace_type)); (*it)->Draw(hDCTemp, rc, true); } }//for }//else borders_only }//mutex release // alpha blending if (found) { if (borders_only) { MaskBlt(hDCTemp, rc.left,rc.top, rc.right-rc.left,rc.bottom-rc.top, mhdcbuffer,rc.left,rc.top, hMaskBitMap,rc.left,rc.top, MAKEROP4(SRCAND, 0x00AA0029)); } DoAlphaBlend(hdc, rc, hDCTemp, rc, (255 * GetAirSpaceOpacity()) / 100); } // draw it again, just the outlines // we will be drawing directly into given hdc, so store original PEN object HPEN hOrigPen = (HPEN) SelectObject(hdc, GetStockObject(WHITE_PEN)); if (1) { CCriticalSection::CGuard guard(CAirspaceManager::Instance().MutexRef()); for (it=airspaces_to_draw.begin(); it != airspaces_to_draw.end(); ++it) { if ((*it)->DrawStyle()) { airspace_type = (*it)->Type(); if ( (((*it)->DrawStyle()==adsFilled)&&!outlined_only&&!borders_only) ^ (asp_selected_flash && (*it)->Selected()) ) { SelectObject(hdc, GetStockObject(BLACK_PEN)); } else { SelectObject(hdc, hAirspacePens[airspace_type]); } (*it)->Draw(hdc, rc, false); } }//for } // restore original PEN SelectObject(hdc, hOrigPen); RestoreDC(mhdcbuffer, nDC1); RestoreDC(hDCMask, nDC2); RestoreDC(hDCTemp, nDC3); } // DrawTptAirSpace()
LRESULT dlgWndAskPIN::ProcecEvent ( UINT uMsg, // Message For This Window WPARAM wParam, // Additional Message Information LPARAM lParam ) // Additional Message Information { PAINTSTRUCT ps; RECT rect; switch( uMsg ) { case WM_COMMAND: { switch( LOWORD(wParam) ) { case IDC_EDIT: { if( EN_CHANGE == HIWORD(wParam) ) { long len = (long)SendMessage( GetDlgItem( m_hWnd, IDC_EDIT ), WM_GETTEXTLENGTH, 0, 0 ); EnableWindow( GetDlgItem( m_hWnd, IDOK ), ( (unsigned int)len >= m_ulPinMinLen ) ); } return TRUE; } case IDB_OK: GetPinResult(); dlgResult = eIDMW::DLG_OK; close(); return TRUE; case IDB_CANCEL: dlgResult = eIDMW::DLG_CANCEL; close(); return TRUE; default: unsigned short tmp = LOWORD(wParam); if( tmp >= IDB_KeypadStart && tmp < IDB_KeypadEnd ) // Keypad Buttons { wchar_t nameBuf[128]; SendMessage( GetDlgItem( m_hWnd, IDC_EDIT ), WM_GETTEXT, (WPARAM)(sizeof(nameBuf)), (LPARAM)nameBuf ); size_t iPos = wcslen( nameBuf ); if( iPos >= m_ulPinMaxLen ) return TRUE; if( tmp == IDB_KeypadEnd - 1 ) // Keypad Button 0 { nameBuf[ iPos++ ] = L'0'; } else // Keypad Button 1 to 9 { nameBuf[ iPos++ ] = 49 + tmp - IDB_KeypadStart; } nameBuf[ iPos++ ] = NULL; SendMessage( GetDlgItem( m_hWnd, IDC_EDIT ), WM_SETTEXT, 0, (LPARAM)nameBuf ); return TRUE; } if( tmp == IDB_KeypadEnd ) // Keypad Button CE { SendMessage( GetDlgItem( m_hWnd, IDC_EDIT ), WM_SETTEXT, 0, (LPARAM)"" ); //clear } return DefWindowProc( m_hWnd, uMsg, wParam, lParam ); } } case WM_DRAWITEM: { LPDRAWITEMSTRUCT lpDrawItem = (LPDRAWITEMSTRUCT)lParam; if( lpDrawItem->CtlType & ODT_BUTTON ) { //MWLOG(LEV_DEBUG, MOD_DLG, L" dlgWndAskPIN : Virtual pinpad - WM_DRAWITEM lParam=%x, wParam=%ld",lParam,wParam); //MWLOG(LEV_DEBUG, MOD_DLG, L" dlgWndAskPIN : Virtual pinpad - Entering WM_DRAWITEM lpDrawItem->hDC=%ld",lpDrawItem->hDC); FillRect( lpDrawItem->hDC, &lpDrawItem->rcItem, CreateSolidBrush( GetSysColor( COLOR_3DFACE ) ) ); //MWLOG(LEV_DEBUG, MOD_DLG, L" dlgWndAskPIN : Virtual pinpad - WM_DRAWITEM top=%ld, bottom=%ld, left=%ld, right=%ld", //lpDrawItem->rcItem.top,lpDrawItem->rcItem.bottom,lpDrawItem->rcItem.left,lpDrawItem->rcItem.right); HDC hdcMem = CreateCompatibleDC( lpDrawItem->hDC ); SelectObject( hdcMem , ImageKP_BTN[11] ); MaskBlt( lpDrawItem->hDC, (lpDrawItem->rcItem.right - KP_BTN_SIZE) / 2, (lpDrawItem->rcItem.bottom - KP_BTN_SIZE) / 2, KP_BTN_SIZE, KP_BTN_SIZE, hdcMem, 0, 0, ImageKP_BTN_Mask, 0, 0, MAKEROP4( SRCCOPY, 0x00AA0029 ) ); unsigned int iNum = 0; if( lpDrawItem->CtlID == IDB_KeypadEnd ) { iNum = 10; } else if( lpDrawItem->CtlID >= IDB_KeypadStart && lpDrawItem->CtlID < IDB_KeypadEnd -2 ) { iNum = lpDrawItem->CtlID - IDB_KeypadStart +1; } //MWLOG(LEV_DEBUG, MOD_DLG, L" dlgWndAskPIN : Virtual pinpad - WM_DRAWITEM iNum=%ld",iNum); SelectObject( hdcMem , ImageKP_BTN[iNum] ); BitBlt( lpDrawItem->hDC, (lpDrawItem->rcItem.right - KP_LBL_SIZE) / 2, (lpDrawItem->rcItem.bottom - KP_LBL_SIZE) / 2, KP_LBL_SIZE, KP_LBL_SIZE, hdcMem, 0, 0, SRCCOPY ); DeleteDC(hdcMem); if( lpDrawItem->itemState & ODS_SELECTED ) DrawEdge( lpDrawItem->hDC, &lpDrawItem->rcItem, EDGE_RAISED, BF_RECT ); if( lpDrawItem->itemState & ODS_HOTLIGHT ) DrawEdge( lpDrawItem->hDC, &lpDrawItem->rcItem, EDGE_SUNKEN, BF_RECT ); if( lpDrawItem->itemState & ODS_FOCUS ) { GetClientRect( lpDrawItem->hwndItem, &rect ); rect.left += 2; rect.right -= 2; rect.top += 2; rect.bottom -= 2; DrawFocusRect( lpDrawItem->hDC, &rect ); } //MWLOG(LEV_DEBUG, MOD_DLG, L" dlgWndAskPIN : Virtual pinpad - Leaving WM_DRAWITEM lpDrawItem->hDC=%ld",lpDrawItem->hDC); return TRUE; } break; } case WM_SIZE: { MWLOG(LEV_DEBUG, MOD_DLG, L" --> dlgWndAskPIN::ProcecEvent WM_SIZE (wParam=%X, lParam=%X)",wParam,lParam); if( IsIconic( m_hWnd ) ) return 0; break; } case WM_PAINT: { //MWLOG(LEV_DEBUG, MOD_DLG, L" dlgWndAskPIN : WM_PAINT"); m_hDC = BeginPaint( m_hWnd, &ps ); HDC hdcMem; hdcMem = CreateCompatibleDC( m_hDC ); HGDIOBJ oldObj = SelectObject( hdcMem , ImagePIN ); GetClientRect( m_hWnd, &rect ); MaskBlt( m_hDC, 4, m_KeypadHeight + 8, IMG_SIZE, IMG_SIZE, hdcMem, 0, 0, ImagePIN_Mask, 0, 0, MAKEROP4( SRCCOPY, 0x00AA0029 ) ); SelectObject( hdcMem, oldObj ); DeleteDC(hdcMem); if( m_UseKeypad ) { GetClientRect( m_hWnd, &rect ); rect.left += 8; rect.right -= 8; rect.top += 8; rect.bottom = m_KeypadHeight; DrawEdge( m_hDC, &rect, EDGE_RAISED, BF_RECT ); } GetClientRect( m_hWnd, &rect ); rect.left += IMG_SIZE + 16; rect.top = m_KeypadHeight + 8; rect.right -= 8; rect.bottom = rect.bottom - 40; SetBkColor( m_hDC, GetSysColor( COLOR_3DFACE ) ); SelectObject( m_hDC, TextFont ); DrawText( m_hDC, szHeader, -1, &rect, DT_WORDBREAK ); EndPaint( m_hWnd, &ps ); SetForegroundWindow( m_hWnd ); return 0; } case WM_ACTIVATE: { MWLOG(LEV_DEBUG, MOD_DLG, L" --> dlgWndAskPIN::ProcecEvent WM_ACTIVATE (wParam=%X, lParam=%X)",wParam,lParam); break; } case WM_NCACTIVATE: { MWLOG(LEV_DEBUG, MOD_DLG, L" --> dlgWndAskPIN::ProcecEvent WM_NCACTIVATE (wParam=%X, lParam=%X)",wParam,lParam); //if( !IsIconic( m_hWnd ) && m_ModalHold && Active_hWnd == m_hWnd ) //{ // ShowWindow( m_hWnd, SW_SHOW ); // SetFocus( m_hWnd ); // return 0; //} if(!wParam) { SetFocus( m_hWnd ); return 0; } break; } case WM_SETFOCUS: { MWLOG(LEV_DEBUG, MOD_DLG, L" --> dlgWndAskPIN::ProcecEvent WM_SETFOCUS (wParam=%X, lParam=%X)",wParam,lParam); break; } case WM_KILLFOCUS: { MWLOG(LEV_DEBUG, MOD_DLG, L" --> dlgWndAskPIN::ProcecEvent WM_KILLFOCUS (wParam=%X, lParam=%X)",wParam,lParam); //if( !IsIconic( m_hWnd ) && m_ModalHold && Active_hWnd == m_hWnd ) //{ // if( GetParent((HWND)wParam ) != m_hWnd ) // { // SetFocus( m_hWnd ); // return 0; // } //} break; } case WM_CREATE: { MWLOG(LEV_DEBUG, MOD_DLG, L" --> dlgWndAskPIN::ProcecEvent WM_CREATE (wParam=%X, lParam=%X)",wParam,lParam); HMENU hSysMenu; hSysMenu = GetSystemMenu( m_hWnd, FALSE ); EnableMenuItem( hSysMenu, 3, MF_BYPOSITION | MF_GRAYED ); SendMessage( m_hWnd, DM_SETDEFID, (WPARAM) IDC_EDIT, (LPARAM) 0); return DefWindowProc( (HWND)((CREATESTRUCT *)lParam)->lpCreateParams, uMsg, wParam, lParam ); } case WM_CLOSE: { MWLOG(LEV_DEBUG, MOD_DLG, L" --> dlgWndAskPIN::ProcecEvent WM_CLOSE (wParam=%X, lParam=%X)",wParam,lParam); if( IsIconic( m_hWnd ) ) return DefWindowProc( m_hWnd, uMsg, wParam, lParam ); ShowWindow( m_hWnd, SW_MINIMIZE ); return 0; } case WM_DESTROY: { MWLOG(LEV_DEBUG, MOD_DLG, L" --> dlgWndAskPIN::ProcecEvent WM_DESTROY (wParam=%X, lParam=%X)",wParam,lParam); break; } default: { return DefWindowProc( m_hWnd, uMsg, wParam, lParam ); } } return DefWindowProc( m_hWnd, uMsg, wParam, lParam ); }
/***************************************************************************** * SIC_OverlayShortcutImage [internal] * * NOTES * Creates a new icon as a copy of the passed-in icon, overlayed with a * shortcut image. * FIXME: This should go to the ImageList implementation! */ static HICON SIC_OverlayShortcutImage(HICON SourceIcon, BOOL large) { ICONINFO ShortcutIconInfo, TargetIconInfo; HICON ShortcutIcon = NULL, TargetIcon; BITMAP TargetBitmapInfo, ShortcutBitmapInfo; HDC ShortcutDC = NULL, TargetDC = NULL; HBITMAP OldShortcutBitmap = NULL, OldTargetBitmap = NULL; static int s_imgListIdx = -1; ZeroMemory(&ShortcutIconInfo, sizeof(ShortcutIconInfo)); ZeroMemory(&TargetIconInfo, sizeof(TargetIconInfo)); /* Get information about the source icon and shortcut overlay. * We will write over the source bitmaps to get the final ones */ if (! GetIconInfo(SourceIcon, &TargetIconInfo)) return NULL; /* Is it possible with the ImageList implementation? */ if(!TargetIconInfo.hbmColor) { /* Maybe we'll support this at some point */ FIXME("1bpp icon wants its overlay!\n"); goto fail; } if(!GetObjectW(TargetIconInfo.hbmColor, sizeof(BITMAP), &TargetBitmapInfo)) { goto fail; } /* search for the shortcut icon only once */ if (s_imgListIdx == -1) s_imgListIdx = SIC_LoadOverlayIcon(- IDI_SHELL_SHORTCUT); /* FIXME should use icon index 29 instead of the resource id, but not all icons are present yet so we can't use icon indices */ if (s_imgListIdx != -1) { if (large) ShortcutIcon = ImageList_GetIcon(ShellBigIconList, s_imgListIdx, ILD_TRANSPARENT); else ShortcutIcon = ImageList_GetIcon(ShellSmallIconList, s_imgListIdx, ILD_TRANSPARENT); } else ShortcutIcon = NULL; if (!ShortcutIcon || !GetIconInfo(ShortcutIcon, &ShortcutIconInfo)) { goto fail; } /* Is it possible with the ImageLists ? */ if(!ShortcutIconInfo.hbmColor) { /* Maybe we'll support this at some point */ FIXME("Should draw 1bpp overlay!\n"); goto fail; } if(!GetObjectW(ShortcutIconInfo.hbmColor, sizeof(BITMAP), &ShortcutBitmapInfo)) { goto fail; } /* Setup the masks */ ShortcutDC = CreateCompatibleDC(NULL); if (NULL == ShortcutDC) goto fail; OldShortcutBitmap = (HBITMAP)SelectObject(ShortcutDC, ShortcutIconInfo.hbmMask); if (NULL == OldShortcutBitmap) goto fail; TargetDC = CreateCompatibleDC(NULL); if (NULL == TargetDC) goto fail; OldTargetBitmap = (HBITMAP)SelectObject(TargetDC, TargetIconInfo.hbmMask); if (NULL == OldTargetBitmap) goto fail; /* Create the complete mask by ANDing the source and shortcut masks. * NOTE: in an ImageList, all icons have the same dimensions */ if (!BitBlt(TargetDC, 0, 0, ShortcutBitmapInfo.bmWidth, ShortcutBitmapInfo.bmHeight, ShortcutDC, 0, 0, SRCAND)) { goto fail; } /* * We must remove or add the alpha component to the shortcut overlay: * If we don't, SRCCOPY will copy it to our resulting icon, resulting in a * partially transparent icons where it shouldn't be, and to an invisible icon * if the underlying icon don't have any alpha channel information. (16bpp only icon for instance). * But if the underlying icon has alpha channel information, then we must mark the overlay information * as opaque. * NOTE: This code sucks(tm) and should belong to the ImageList implementation. * NOTE2: there are better ways to do this. */ if(ShortcutBitmapInfo.bmBitsPixel == 32) { BOOL add_alpha; BYTE buffer[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD)]; BITMAPINFO* lpbmi = (BITMAPINFO*)buffer; PVOID bits; PULONG pixel; INT i, j; /* Find if the source bitmap has an alpha channel */ if(TargetBitmapInfo.bmBitsPixel != 32) add_alpha = FALSE; else { ZeroMemory(buffer, sizeof(buffer)); lpbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); lpbmi->bmiHeader.biWidth = TargetBitmapInfo.bmWidth; lpbmi->bmiHeader.biHeight = TargetBitmapInfo.bmHeight; lpbmi->bmiHeader.biPlanes = 1; lpbmi->bmiHeader.biBitCount = 32; bits = HeapAlloc(GetProcessHeap(), 0, TargetBitmapInfo.bmHeight * TargetBitmapInfo.bmWidthBytes); if(!bits) goto fail; if(!GetDIBits(TargetDC, TargetIconInfo.hbmColor, 0, TargetBitmapInfo.bmHeight, bits, lpbmi, DIB_RGB_COLORS)) { ERR("GetBIBits failed!\n"); HeapFree(GetProcessHeap(), 0, bits); goto fail; } i = j = 0; pixel = (PULONG)bits; for(i=0; i<TargetBitmapInfo.bmHeight; i++) { for(j=0; j<TargetBitmapInfo.bmWidth; j++) { add_alpha = (*pixel++ & 0xFF000000) != 0; if(add_alpha) break; } if(add_alpha) break; } HeapFree(GetProcessHeap(), 0, bits); } /* Allocate the bits */ bits = HeapAlloc(GetProcessHeap(), 0, ShortcutBitmapInfo.bmHeight*ShortcutBitmapInfo.bmWidthBytes); if(!bits) goto fail; ZeroMemory(buffer, sizeof(buffer)); lpbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); lpbmi->bmiHeader.biWidth = ShortcutBitmapInfo.bmWidth; lpbmi->bmiHeader.biHeight = ShortcutBitmapInfo.bmHeight; lpbmi->bmiHeader.biPlanes = 1; lpbmi->bmiHeader.biBitCount = 32; if(!GetDIBits(TargetDC, ShortcutIconInfo.hbmColor, 0, ShortcutBitmapInfo.bmHeight, bits, lpbmi, DIB_RGB_COLORS)) { ERR("GetBIBits failed!\n"); HeapFree(GetProcessHeap(), 0, bits); goto fail; } pixel = (PULONG)bits; /* Remove alpha channel component or make it totally opaque */ for(i=0; i<ShortcutBitmapInfo.bmHeight; i++) { for(j=0; j<ShortcutBitmapInfo.bmWidth; j++) { if(add_alpha) *pixel++ |= 0xFF000000; else *pixel++ &= 0x00FFFFFF; } } /* GetDIBits return BI_BITFIELDS with masks set to 0, and SetDIBits fails when masks are 0. The irony... */ lpbmi->bmiHeader.biCompression = BI_RGB; /* Set the bits again */ if(!SetDIBits(TargetDC, ShortcutIconInfo.hbmColor, 0, ShortcutBitmapInfo.bmHeight, bits, lpbmi, DIB_RGB_COLORS)) { ERR("SetBIBits failed!, %lu\n", GetLastError()); HeapFree(GetProcessHeap(), 0, bits); goto fail; } HeapFree(GetProcessHeap(), 0, bits); } /* Now do the copy. We overwrite the original icon data */ if (NULL == SelectObject(ShortcutDC, ShortcutIconInfo.hbmColor) || NULL == SelectObject(TargetDC, TargetIconInfo.hbmColor)) goto fail; if (!MaskBlt(TargetDC, 0, 0, ShortcutBitmapInfo.bmWidth, ShortcutBitmapInfo.bmHeight, ShortcutDC, 0, 0, ShortcutIconInfo.hbmMask, 0, 0, MAKEROP4(0xAA0000, SRCCOPY))) { goto fail; } /* Clean up, we're not goto'ing to 'fail' after this so we can be lazy and not set handles to NULL */ SelectObject(TargetDC, OldTargetBitmap); DeleteDC(TargetDC); SelectObject(ShortcutDC, OldShortcutBitmap); DeleteDC(ShortcutDC); /* Create the icon using the bitmaps prepared earlier */ TargetIcon = CreateIconIndirect(&TargetIconInfo); /* CreateIconIndirect copies the bitmaps, so we can release our bitmaps now */ DeleteObject(TargetIconInfo.hbmColor); DeleteObject(TargetIconInfo.hbmMask); /* Delete what GetIconInfo gave us */ DeleteObject(ShortcutIconInfo.hbmColor); DeleteObject(ShortcutIconInfo.hbmMask); DestroyIcon(ShortcutIcon); return TargetIcon; fail: /* Clean up scratch resources we created */ if (NULL != OldTargetBitmap) SelectObject(TargetDC, OldTargetBitmap); if (NULL != TargetDC) DeleteDC(TargetDC); if (NULL != OldShortcutBitmap) SelectObject(ShortcutDC, OldShortcutBitmap); if (NULL != ShortcutDC) DeleteDC(ShortcutDC); if (NULL != TargetIconInfo.hbmColor) DeleteObject(TargetIconInfo.hbmColor); if (NULL != TargetIconInfo.hbmMask) DeleteObject(TargetIconInfo.hbmMask); if (NULL != ShortcutIconInfo.hbmColor) DeleteObject(ShortcutIconInfo.hbmColor); if (NULL != ShortcutIconInfo.hbmMask) DeleteObject(ShortcutIconInfo.hbmMask); if (NULL != ShortcutIcon) DestroyIcon(ShortcutIcon); return NULL; }
LRESULT dlgWndPinpadInfo::ProcecEvent( UINT uMsg, // Message For This Window WPARAM wParam, // Additional Message Information LPARAM lParam ) // Additional Message Information { PAINTSTRUCT ps; RECT rect; switch( uMsg ) { case WM_PAINT: { m_hDC = BeginPaint( m_hWnd, &ps ); HDC hdcMem; hdcMem = CreateCompatibleDC( m_hDC ); HGDIOBJ oldObj = SelectObject( hdcMem , ImagePIN ); GetClientRect( m_hWnd, &rect ); //Size of the background Image MaskBlt( m_hDC, 4, 8, 410, 261, hdcMem, 0, 0, ImagePIN_Mask, 0, 0, MAKEROP4( SRCCOPY, 0x00AA0029 ) ); SelectObject( hdcMem, oldObj ); DeleteDC(hdcMem); GetClientRect( m_hWnd, &rect ); rect.left += IMG_SIZE + 100; rect.top = 32; rect.right -= 8; rect.bottom = 136 - 8; SetBkColor( m_hDC, GetSysColor( COLOR_3DFACE ) ); SelectObject( m_hDC, TextFont ); DrawText( m_hDC, m_szHeader, -1, &rect, DT_WORDBREAK ); //Change top header dimensions GetClientRect( m_hWnd, &rect ); rect.left += IMG_SIZE + 100; rect.top = 60; rect.right -= 20; rect.bottom = rect.bottom - 60; SetBkColor( m_hDC, GetSysColor( COLOR_3DFACE ) ); SelectObject( m_hDC, TextFont ); DrawText( m_hDC, m_szMessage, -1, &rect, DT_WORDBREAK ); EndPaint( m_hWnd, &ps ); SetForegroundWindow( m_hWnd ); return 0; /* m_hDC = BeginPaint( m_hWnd, &ps ); HDC hdcMem; GetClientRect( m_hWnd, &rect ); rect.bottom = rect.top + IMG_SIZE + 8;//rect.bottom / 2; FillRect( m_hDC, &rect, CreateSolidBrush( RGB(255, 255, 255) ) ); hdcMem = CreateCompatibleDC( m_hDC ); SelectObject( hdcMem , ImagePIN ); BitBlt( m_hDC, 4, 4, IMG_SIZE, IMG_SIZE, hdcMem, 0, 0, SRCCOPY ); DeleteDC(hdcMem); rect.left += 136; rect.top += 32; rect.right -= 8; rect.bottom = 136 - 8; //SetBkColor( m_hDC, GetSysColor( COLOR_3DFACE ) ); DrawText( m_hDC, m_szHeader, -1, &rect, DT_WORDBREAK ); GetClientRect( m_hWnd, &rect ); rect.top=rect.top + IMG_SIZE + 8; rect.top = rect.top + 8; rect.bottom = rect.bottom - 8; rect.left = rect.left + 8; rect.right = rect.right - 8; FillRect( m_hDC, &rect, CreateSolidBrush( RGB(255, 255, 255) ) ); rect.top = rect.top + 8; rect.bottom = rect.bottom - 8; rect.left = rect.left + 8; rect.right = rect.right - 8; DrawText( m_hDC, m_szMessage, -1, &rect, DT_WORDBREAK ); EndPaint( m_hWnd, &ps ); SetForegroundWindow( m_hWnd ); return 0; */ } case WM_CREATE: { MWLOG(LEV_DEBUG, MOD_DLG, L" --> dlgWndPinpadInfo::ProcecEvent WM_CLOSE (wParam=%X, lParam=%X)",wParam,lParam); HMENU hSysMenu; hSysMenu = GetSystemMenu( m_hWnd, FALSE); EnableMenuItem( hSysMenu, 2, MF_BYPOSITION | MF_GRAYED ); return 1; } case WM_CLOSE: { MWLOG(LEV_DEBUG, MOD_DLG, L" --> dlgWndPinpadInfo::ProcecEvent WM_CLOSE (wParam=%X, lParam=%X)",wParam,lParam); if( m_ulHandle ) { unsigned long tmp = m_ulHandle; m_ulHandle = 0; DlgClosePinpadInfo( tmp ); } return 0; } case WM_DESTROY: { MWLOG(LEV_DEBUG, MOD_DLG, L" --> dlgWndModal::ProcecEvent WM_DESTROY (wParam=%X, lParam=%X)",wParam,lParam); break; } default: { return DefWindowProc( m_hWnd, uMsg, wParam, lParam ); } } return DefWindowProc( m_hWnd, uMsg, wParam, lParam ); }
void Test_MaskBlt_1bpp() { HDC hdcDst, hdcSrc; struct { BITMAPINFOHEADER bmiHeader; ULONG aulColors[2]; } bmiData = {{sizeof(BITMAPINFOHEADER), 8, 1, 1, 1, BI_RGB, 0, 10, 10, 2,0}, {0, 0xFFFFFF}}; PBITMAPINFO pbmi = (PBITMAPINFO)&bmiData; HBITMAP hbmDst, hbmSrc, hbmMsk; PUCHAR pjBitsDst, pjBitsSrc, pjBitsMsk; BOOL ret; /* Create a dest dc and bitmap */ hdcDst = CreateCompatibleDC(NULL); hbmDst = CreateDIBSection(hdcDst, pbmi, DIB_RGB_COLORS, (PVOID*)&pjBitsDst, NULL, 0); SelectObject(hdcDst, hbmDst); /* Create a source dc and bitmap */ hdcSrc = CreateCompatibleDC(NULL); hbmSrc = CreateDIBSection(hdcSrc, pbmi, DIB_RGB_COLORS, (PVOID*)&pjBitsSrc, NULL, 0); SelectObject(hdcSrc, hbmSrc); /* Create a 1 bpp mask bitmap */ hbmMsk = CreateDIBSection(hdcDst, pbmi, DIB_RGB_COLORS, (PVOID*)&pjBitsMsk, NULL, 0); /* Do the masking (SRCCOPY / NOOP) */ pjBitsDst[0] = 0xAA; pjBitsSrc[0] = 0xCC; pjBitsMsk[0] = 0xF0; ret = MaskBlt(hdcDst, 0, 0, 8, 1, hdcSrc, 0, 0, hbmMsk, 0, 0, MAKEROP4(SRCCOPY, 0xAA0000)); ok(ret == 1, "MaskBlt failed (%d)\n", ret); ok(pjBitsDst[0] == 0xCA, "pjBitsDst[0] == 0x%x\n", pjBitsDst[0]); pjBitsDst[0] = 0x00; pjBitsSrc[0] = 0xFF; pjBitsMsk[0] = 0xF0; ret = MaskBlt(hdcDst, 0, 0, 8, 1, hdcSrc, 0, 0, hbmMsk, 0, 0, MAKEROP4(SRCCOPY, 0xAA0000)); ok(ret == 1, "MaskBlt failed (%d)\n", ret); ok(pjBitsDst[0] == 0xF0, "pjBitsDst[0] == 0x%x\n", pjBitsDst[0]); /* Do the masking (NOTSRCERASE / SRCINVERT) */ pjBitsDst[0] = 0xF0; // 11110000 pjBitsSrc[0] = 0xCC; // 11001100 pjBitsMsk[0] = 0xAA; // 10101010 ret = MaskBlt(hdcDst, 0, 0, 8, 1, hdcSrc, 0, 0, hbmMsk, 0, 0, MAKEROP4(NOTSRCERASE, SRCINVERT)); // 22 ok(ret == 1, "MaskBlt failed (%d)\n", ret); ok(pjBitsDst[0] == 0x16, "pjBitsDst[0] == 0x%x\n", pjBitsDst[0]); /* Do the masking (MERGEPAINT / DSxn) */ pjBitsDst[0] = 0xF0; pjBitsSrc[0] = 0xCC; pjBitsMsk[0] = 0xAA; ret = MaskBlt(hdcDst, 0, 0, 8, 1, hdcSrc, 0, 0, hbmMsk, 0, 0, MAKEROP4(MERGEPAINT, 0x990000)); ok(ret == 1, "MaskBlt failed (%d)\n", ret); ok(pjBitsDst[0] == 0xE3, "pjBitsDst[0] == 0x%x\n", pjBitsDst[0]); /* Try a ROP that needs a mask with a NULL mask bitmap handle */ ret = MaskBlt(hdcDst, 0, 0, 8, 1, hdcSrc, 0, 0, NULL, 0, 0, MAKEROP4(SRCCOPY, 0xAA0000)); ok(ret == 1, "MaskBlt failed (%d)\n", ret); ok(pjBitsDst[0] == 0xCC, "pjBitsDst[0] == 0x%x\n", pjBitsDst[0]); /* Try a ROP that needs a mask with an invalid mask bitmap handle */ ret = MaskBlt(hdcDst, 0, 0, 8, 1, hdcSrc, 0, 0, (HBITMAP)0x123456, 0, 0, MAKEROP4(SRCCOPY, 0xAA0000)); ok(ret == 0, "MaskBlt should fail, but succeeded (%d)\n", ret); /* Try a ROP that needs a mask with an invalid mask bitmap */ ok(ghbmp24 != NULL, "ghbmp24 is NULL!\n"); ret = MaskBlt(hdcDst, 0, 0, 8, 1, hdcSrc, 0, 0, ghbmp24, 0, 0, MAKEROP4(SRCCOPY, 0xAA0000)); ok(ret == 0, "MaskBlt should fail, but succeeded (%d)\n", ret); /* Try a ROP that needs no mask with an invalid mask bitmap */ ret = MaskBlt(hdcDst, 0, 0, 8, 1, hdcSrc, 0, 0, (HBITMAP)0x123456, 0, 0, MAKEROP4(SRCCOPY, SRCCOPY)); ok(ret == 1, "MaskBlt failed (%d)\n", ret); /* Try (PATCOPY / NOOP) with a NULL source mask and bitmap */ ret = MaskBlt(hdcDst, 0, 0, 8, 1, NULL, 0, 0, NULL, 0, 0, MAKEROP4(PATCOPY, 0xAA0000)); ok(ret == 0, "MaskBlt should fail, but succeeded (%d)\n", ret); /* Try with a mask that is smaller than the rect */ DeleteObject(hbmMsk); pbmi->bmiHeader.biWidth = 4; hbmMsk = CreateDIBSection(hdcDst, pbmi, DIB_RGB_COLORS, (PVOID*)&pjBitsMsk, NULL, 0); /* Do the masking (SRCCOPY / NOOP) */ pjBitsDst[0] = 0xAA; // 10101010 pjBitsSrc[0] = 0xCC; // 11001100 pjBitsMsk[0] = 0x33; // 00110011 ret = MaskBlt(hdcDst, 0, 0, 5, 1, hdcSrc, 0, 0, hbmMsk, 0, 0, MAKEROP4(SRCCOPY, 0xAA0000)); ok(ret == 0, "MaskBlt should fail, but succeeded (%d)\n", ret); ret = MaskBlt(hdcDst, 0, 0, 4, 1, hdcSrc, 0, 0, hbmMsk, 1, 0, MAKEROP4(SRCCOPY, 0xAA0000)); ok(ret == 0, "MaskBlt should fail, but succeeded (%d)\n", ret); ret = MaskBlt(hdcDst, 0, 0, 4, 1, hdcSrc, 0, 0, hbmMsk, 0, 1, MAKEROP4(SRCCOPY, 0xAA0000)); ok(ret == 0, "MaskBlt should fail, but succeeded (%d)\n", ret); ret = MaskBlt(hdcDst, 0, 0, 4, 1, hdcSrc, 0, 0, hbmMsk, 0, 0, MAKEROP4(SRCCOPY, 0xAA0000)); ok(ret == 1, "MaskBlt failed (%d)\n", ret); ok(pjBitsDst[0] == 0x8A, "pjBitsDst[0] == 0x%x\n", pjBitsDst[0]); }