зеркало из https://github.com/mozilla/pjs.git
2263 строки
71 KiB
C++
2263 строки
71 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* The contents of this file are subject to the Netscape Public License
|
|
* Version 1.0 (the "NPL"); you may not use this file except in
|
|
* compliance with the NPL. You may obtain a copy of the NPL at
|
|
* http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the NPL is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
|
|
* for the specific language governing rights and limitations under the
|
|
* NPL.
|
|
*
|
|
* The Initial Developer of this code under the NPL is Netscape
|
|
* Communications Corporation. Portions created by Netscape are
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
|
|
* Reserved.
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
|
|
#include "cxdc.h"
|
|
#include "cntritem.h"
|
|
#include "intlwin.h"
|
|
#include "mainfrm.h"
|
|
#include "npapi.h"
|
|
#include "np.h"
|
|
#include "feembed.h"
|
|
#include "fmabstra.h"
|
|
#include "custom.h"
|
|
#include "prefapi.h"
|
|
#include "feimage.h"
|
|
#include "il_icons.h"
|
|
#include "prefinfo.h"
|
|
|
|
// Make an array of RGB colors that match the current palette.
|
|
// This array is used for contexts that don't employ DibPalColors.
|
|
// Returns TRUE on success, FALSE otherwise.
|
|
static const RGBQUAD rgbqWhite = {0xFF, 0xFF, 0xFF, 0};
|
|
static const RGBQUAD rgbqBlack = {0, 0, 0, 0};
|
|
|
|
//#define USE_IDENTITY_PALETTE
|
|
#ifdef XP_WIN32
|
|
//#define USE_DIB_SECTION
|
|
#endif
|
|
#ifdef USE_IDENTITY_PALETTE
|
|
# define PALETTEENTRY_FLAGS PC_NOCOLLAPSE
|
|
#else
|
|
# define PALETTEENTRY_FLAGS 0
|
|
#endif
|
|
extern "C"{
|
|
extern int gifAbort;
|
|
}
|
|
|
|
#define ROP_PSDPxax 0x00B8074AL
|
|
// Alters the transparent part of the source image (already selected into
|
|
// pSrcDC) with the specified brush
|
|
//
|
|
// Make sure that the WHOLE image is changed and not just the part that
|
|
// needs to be displayed; otherwise things will get out of sync
|
|
|
|
static BOOL
|
|
CopyPaletteToRGBArray(HPALETTE pPal, RGBQUAD *pRGBArray)
|
|
{
|
|
PALETTEENTRY *paletteEntries;
|
|
XP_ASSERT(pRGBArray);
|
|
|
|
paletteEntries = (PALETTEENTRY *)XP_ALLOC(sizeof(PALETTEENTRY) * 256);
|
|
|
|
if (!paletteEntries)
|
|
return FALSE;
|
|
|
|
// Copy existing palette
|
|
VERIFY(::GetPaletteEntries(pPal, 0, 256, paletteEntries) > 0);
|
|
|
|
for(int i = 0; i < 256; i++) {
|
|
pRGBArray[i].rgbRed = paletteEntries[i].peRed;
|
|
pRGBArray[i].rgbGreen = paletteEntries[i].peGreen;
|
|
pRGBArray[i].rgbBlue = paletteEntries[i].peBlue;
|
|
pRGBArray[i].rgbReserved = NULL;
|
|
}
|
|
|
|
XP_FREE(paletteEntries);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
void CDCCX::ImageComplete(NI_Pixmap* image)
|
|
{
|
|
FEBitmapInfo *imageInfo;
|
|
HDC hdc = GetContextDC();
|
|
if (!image || !hdc || IsPrintContext()) return;
|
|
|
|
imageInfo = (FEBitmapInfo*) image->client_data;
|
|
if(!imageInfo)
|
|
return;
|
|
|
|
#ifndef USE_DIB_SECTION
|
|
if(!imageInfo->hBitmap) {
|
|
// Attempt to create a bitmap
|
|
if (!imageInfo->IsMask ) {
|
|
imageInfo->hBitmap = ::CreateDIBitmap(hdc,
|
|
&(imageInfo->bmpInfo->bmiHeader),
|
|
CBM_INIT,
|
|
image->bits,
|
|
imageInfo->bmpInfo,
|
|
m_bUseDibPalColors ? DIB_PAL_COLORS : DIB_RGB_COLORS);
|
|
if (imageInfo->hBitmap) {
|
|
// Free the image bits since we no longer need them
|
|
CDCCX::HugeFree(image->bits);
|
|
image->bits = NULL;
|
|
}
|
|
}
|
|
else {
|
|
// If there is a mask then create another bitmap
|
|
// Build a BITMAPINFO struct for mask
|
|
char cMask[sizeof(BITMAPINFOHEADER) + (2 * sizeof(RGBQUAD))];
|
|
LPBITMAPINFO pBmInfoMask = (LPBITMAPINFO)cMask;
|
|
|
|
memcpy(pBmInfoMask, imageInfo->bmpInfo, sizeof(BITMAPINFOHEADER));
|
|
pBmInfoMask->bmiHeader.biBitCount = 1;
|
|
pBmInfoMask->bmiHeader.biCompression = BI_RGB; // must NOT be BI_BITFIELDS
|
|
|
|
// Build a color table for monochrome mask. Image lib sets the foreground
|
|
// pixels to 1 and the background pixels to 0. We want the monochrome
|
|
// mask to be the same way
|
|
pBmInfoMask->bmiColors[1] = rgbqBlack; // background pixels
|
|
pBmInfoMask->bmiColors[0] = rgbqWhite; // foreground pixels
|
|
// Create the mask. It's important that we use the memory DC, because we
|
|
// want a momochrome bitmap
|
|
imageInfo->hBitmap = ::CreateDIBitmap(m_pImageDC,
|
|
(LPBITMAPINFOHEADER)pBmInfoMask,
|
|
CBM_INIT,
|
|
image->bits,
|
|
pBmInfoMask,
|
|
DIB_RGB_COLORS);
|
|
|
|
if (imageInfo->hBitmap) {
|
|
// Free the mask bits since we no longer need them
|
|
CDCCX::HugeFree(image->bits);
|
|
image->bits = NULL;
|
|
}
|
|
}
|
|
}
|
|
#else
|
|
HBITMAP oldBmp;
|
|
oldBmp = imageInfo->hBitmap;
|
|
|
|
if (!imageInfo->IsMask ) {
|
|
imageInfo->hBitmap = ::CreateDIBitmap(hdc,
|
|
&(imageInfo->bmpInfo->bmiHeader),
|
|
CBM_INIT,
|
|
image->bits,
|
|
imageInfo->bmpInfo,
|
|
m_bUseDibPalColors ? DIB_PAL_COLORS : DIB_RGB_COLORS);
|
|
}
|
|
else {
|
|
// If there is a mask then create another bitmap
|
|
// Build a BITMAPINFO struct for mask
|
|
char cMask[sizeof(BITMAPINFOHEADER) + (2 * sizeof(RGBQUAD))];
|
|
LPBITMAPINFO pBmInfoMask = (LPBITMAPINFO)cMask;
|
|
|
|
memcpy(pBmInfoMask, imageInfo->bmpInfo, sizeof(BITMAPINFOHEADER));
|
|
pBmInfoMask->bmiHeader.biBitCount = 1;
|
|
pBmInfoMask->bmiHeader.biCompression = BI_RGB; // must NOT be BI_BITFIELDS
|
|
|
|
// Build a color table for monochrome mask. Image lib sets the foreground
|
|
// pixels to 1 and the background pixels to 0. We want the monochrome
|
|
// mask to be the same way
|
|
pBmInfoMask->bmiColors[1] = rgbqBlack; // background pixels
|
|
pBmInfoMask->bmiColors[0] = rgbqWhite; // foreground pixels
|
|
// Create the mask. It's important that we use the memory DC, because we
|
|
// want a momochrome bitmap
|
|
imageInfo->hBitmap = ::CreateDIBitmap(m_pImageDC,
|
|
(LPBITMAPINFOHEADER)pBmInfoMask,
|
|
CBM_INIT,
|
|
image->bits,
|
|
pBmInfoMask,
|
|
DIB_RGB_COLORS);
|
|
|
|
}
|
|
::DeleteObject(oldBmp);
|
|
image->bits = NULL;
|
|
#endif
|
|
ReleaseContextDC(hdc);
|
|
}
|
|
|
|
static WORD
|
|
GetBitCount(BITMAP &bmp)
|
|
{
|
|
WORD nBits = (WORD)(bmp.bmPlanes * bmp.bmBitsPixel);
|
|
|
|
#ifdef XP_WIN32
|
|
if (nBits == 1)
|
|
nBits = 1;
|
|
else if (nBits <= 4)
|
|
nBits = 4;
|
|
else if (nBits <= 8)
|
|
nBits = 8;
|
|
else if (nBits <= 16)
|
|
nBits = 16;
|
|
else if (nBits <= 24)
|
|
nBits = 24;
|
|
else
|
|
nBits = 32;
|
|
#else
|
|
if (nBits == 1)
|
|
nBits = 1;
|
|
else if (nBits <= 4)
|
|
nBits = 4;
|
|
else if (nBits <= 8)
|
|
nBits = 8;
|
|
else
|
|
nBits = 24;
|
|
#endif
|
|
|
|
return nBits;
|
|
}
|
|
|
|
#ifndef XP_WIN32
|
|
/* Quaternary raster codes */
|
|
#define MAKEROP4(fore,back) (DWORD)((((back) << 8) & 0xFF000000) | (fore))
|
|
#endif
|
|
|
|
BOOL CDCCX::CanWriteBitmapFile(LO_ImageStruct* pLOImage)
|
|
{
|
|
ASSERT(pLOImage);
|
|
if(!pLOImage) {
|
|
return(FALSE);
|
|
}
|
|
IL_Pixmap *pImage = IL_GetImagePixmap(pLOImage->image_req);
|
|
|
|
// Internal icons have no platform data.
|
|
FEBitmapInfo* imageinfo = (FEBitmapInfo*) pImage->client_data;
|
|
|
|
// We can't do anything if we don't have all the image bits
|
|
return imageinfo && imageinfo->hBitmap;
|
|
}
|
|
|
|
HANDLE CDCCX::WriteBitmapToMemory( IL_ImageReq *image_req, LO_Color* bg)
|
|
{
|
|
IL_Pixmap *pImage = IL_GetImagePixmap(image_req);
|
|
IL_Pixmap *pMask = IL_GetMaskPixmap(image_req);
|
|
|
|
// Windows bitmap file format looks like this:
|
|
//
|
|
// +------------------+
|
|
// | BITMAPFILEHEADER |
|
|
// |------------------|
|
|
// | BITMAPINFOHEADER |
|
|
// |------------------|
|
|
// | color table |
|
|
// |------------------|
|
|
// | image bits |
|
|
// +------------------+
|
|
FEBitmapInfo* imageinfo = (FEBitmapInfo*) pImage->client_data;
|
|
|
|
FEBitmapInfo* maskinfo = 0;
|
|
if (pMask)
|
|
maskinfo = (FEBitmapInfo*) pMask->client_data;
|
|
|
|
// We can't do anything if we don't have all the image bits
|
|
HGLOBAL hDib;
|
|
if (imageinfo && imageinfo->hBitmap) {
|
|
BITMAP bmp;
|
|
LPBITMAPINFOHEADER lpBmi;
|
|
WORD nBitCount;
|
|
LPBYTE lpBits;
|
|
int nColorTable;
|
|
|
|
// Determine the bits per pixel
|
|
if (!::GetObject(imageinfo->hBitmap, sizeof(bmp), &bmp))
|
|
return FALSE;
|
|
|
|
nBitCount = GetBitCount(bmp);
|
|
|
|
// We need to know how big the color table is. For 16-bit mode and 32-bit mode, we need to
|
|
// allocate room for 3 double-word color masks
|
|
if (nBitCount == 16 || nBitCount == 32)
|
|
nColorTable = 3;
|
|
else if (nBitCount < 16)
|
|
nColorTable = 1 << nBitCount;
|
|
else {
|
|
ASSERT(nBitCount == 24);
|
|
nColorTable = 0;
|
|
}
|
|
|
|
// Allocate space for a BITMAPINFO structure (BITMAPINFOHEADER structure
|
|
// plus space for the color table)
|
|
WORD dwSize = sizeof(BITMAPINFOHEADER) + nColorTable * sizeof(RGBQUAD);
|
|
hDib = GlobalAlloc(GMEM_SHARE, dwSize);
|
|
lpBmi = (LPBITMAPINFOHEADER)GlobalLock(hDib);
|
|
if (!lpBmi)
|
|
return FALSE;
|
|
|
|
// Initialize the BITMAPINFOHEADER structure
|
|
lpBmi->biSize = sizeof(BITMAPINFOHEADER);
|
|
lpBmi->biWidth = bmp.bmWidth;
|
|
lpBmi->biHeight = bmp.bmHeight;
|
|
lpBmi->biPlanes = 1;
|
|
lpBmi->biBitCount = nBitCount;
|
|
|
|
HDC hdc = GetContextDC();
|
|
|
|
// Note: NT 16-bit video mode won't work unless you use BI_BITFIELDS, and
|
|
// Win 95 probably won't work if you use BI_BITFIELDS. Win 3.x doesn't even
|
|
// support 16-bit DIBs, so it isn't an issue there
|
|
#ifdef XP_WIN32
|
|
if (sysInfo.m_bWinNT && (nBitCount == 16 || nBitCount == 32))
|
|
lpBmi->biCompression = BI_BITFIELDS;
|
|
else
|
|
lpBmi->biCompression = BI_RGB;
|
|
#else
|
|
lpBmi->biCompression = BI_RGB;
|
|
#endif
|
|
|
|
// Ask the driver to tell us the number of bits we need to allocate
|
|
::GetDIBits(hdc, imageinfo->hBitmap, 0, (int)lpBmi->biHeight, NULL, (LPBITMAPINFO)lpBmi, DIB_RGB_COLORS);
|
|
|
|
if (lpBmi->biSizeImage == 0) {
|
|
// The driver didn't tell us so we need to compute it ourselves
|
|
lpBmi->biSizeImage = ((((lpBmi->biWidth * nBitCount) + 31) & ~31) >> 3) * lpBmi->biHeight;
|
|
}
|
|
|
|
GlobalUnlock(hDib);
|
|
hDib = GlobalReAlloc(hDib, lpBmi->biSizeImage + dwSize,0);
|
|
// Allocate space for the bits
|
|
lpBits = (LPBYTE)GlobalLock(hDib);
|
|
if (!lpBits) {
|
|
free(lpBmi);
|
|
ReleaseContextDC(hdc);
|
|
return FALSE;
|
|
}
|
|
|
|
// Windows bitmap files don't allow for a mask. Therefore we have to set the transparent
|
|
// parts of the image to be the appropriate color. This ensures that the bitmap file matches
|
|
// what the user sees on the screen
|
|
//
|
|
// ZZZ: This code should be shared with the code in _StretchBlt()
|
|
COLORREF bgColor = bg ? RGB(bg->red, bg->green, bg->blue) : m_rgbBackgroundColor;
|
|
|
|
if (maskinfo && maskinfo->hBitmap) {
|
|
HBRUSH hBrush;
|
|
HDC tempDC = ::CreateCompatibleDC(hdc);
|
|
HBITMAP tempBmp = ::CreateCompatibleBitmap(hdc, lpBmi->biWidth, lpBmi->biHeight);
|
|
HBITMAP hOldBmp = (HBITMAP)::SelectObject(tempDC, tempBmp);
|
|
HBITMAP hOldBmp1 = (HBITMAP)::SelectObject(m_pImageDC, imageinfo->hBitmap);
|
|
|
|
if (m_iBitsPerPixel == 16)
|
|
// We don't want a dithered brush
|
|
hBrush = ::CreateSolidBrush(::GetNearestColor(hdc, bgColor));
|
|
else
|
|
hBrush = ::CreateSolidBrush(0x02000000L | bgColor);
|
|
|
|
::BitBlt(tempDC, 0, 0,lpBmi->biWidth, lpBmi->biHeight, m_pImageDC, 0, 0, SRCCOPY);
|
|
|
|
// Select the mask into the memory DC
|
|
::SelectObject(m_pImageDC, maskinfo->hBitmap);
|
|
|
|
// Change the transparent bits of the source bitmap to the desired background
|
|
// color by doing an AND raster op
|
|
//
|
|
// The mask is monochrome and will be converted to color to match the depth of
|
|
// the destination. The foreground pixels in the mask are set to 1, and the
|
|
// background pixels to 0. When converting to a color bitmap, white pixels (1)
|
|
// are set to the background color of the DC, and black pixels (0) are set to
|
|
// the text color of the DC
|
|
//
|
|
// Select the brush
|
|
HBRUSH hOldBrush = (HBRUSH)::SelectObject(tempDC, hBrush);
|
|
|
|
// Draw the brush where the mask is 0
|
|
::BitBlt(tempDC,
|
|
0,
|
|
0,
|
|
lpBmi->biWidth,
|
|
lpBmi->biHeight,
|
|
m_pImageDC,
|
|
0,
|
|
0,
|
|
MAKEROP4(SRCPAINT, R2_COPYPEN));
|
|
|
|
::SelectObject(tempDC, hOldBrush);
|
|
|
|
::DeleteObject(hBrush);
|
|
::GetDIBits(tempDC, tempBmp, 0, (int)lpBmi->biHeight, lpBits + dwSize, (LPBITMAPINFO)lpBmi, DIB_RGB_COLORS);
|
|
::SelectObject(m_pImageDC, hOldBmp1);
|
|
::SelectObject(tempDC, hOldBmp);
|
|
::DeleteObject(tempBmp);
|
|
::DeleteDC(tempDC);
|
|
}
|
|
else
|
|
// This time have the driver give us the color table and the bits
|
|
::GetDIBits(hdc, imageinfo->hBitmap, 0, (int)lpBmi->biHeight, lpBits + dwSize, (LPBITMAPINFO)lpBmi, DIB_RGB_COLORS);
|
|
ReleaseContextDC(hdc);
|
|
GlobalUnlock(hDib);
|
|
return (hDib);
|
|
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
|
|
BOOL CDCCX::WriteBitmapFile(LPCSTR lpszFileName, LO_ImageStruct* pLOImage)
|
|
{
|
|
ASSERT(pLOImage);
|
|
|
|
if(!pLOImage) {
|
|
return(FALSE);
|
|
}
|
|
IL_Pixmap *pImage = IL_GetImagePixmap(pLOImage->image_req);
|
|
IL_Pixmap *pMask = IL_GetMaskPixmap(pLOImage->image_req);
|
|
|
|
// Windows bitmap file format looks like this:
|
|
//
|
|
// +------------------+
|
|
// | BITMAPFILEHEADER |
|
|
// |------------------|
|
|
// | BITMAPINFOHEADER |
|
|
// |------------------|
|
|
// | color table |
|
|
// |------------------|
|
|
// | image bits |
|
|
// +------------------+
|
|
FEBitmapInfo* imageinfo = (FEBitmapInfo*) pImage->client_data;
|
|
|
|
FEBitmapInfo* maskinfo = 0;
|
|
if (pMask)
|
|
maskinfo = (FEBitmapInfo*) pMask->client_data;
|
|
|
|
// We can't do anything if we don't have all the image bits
|
|
if (imageinfo && imageinfo->hBitmap) {
|
|
BITMAP bmp;
|
|
LPBITMAPINFOHEADER lpBmi;
|
|
WORD nBitCount;
|
|
LPBYTE lpBits;
|
|
int nColorTable;
|
|
|
|
// Determine the bits per pixel
|
|
if (!::GetObject(imageinfo->hBitmap, sizeof(bmp), &bmp))
|
|
return FALSE;
|
|
|
|
nBitCount = GetBitCount(bmp);
|
|
|
|
// We need to know how big the color table is. For 16-bit mode and 32-bit mode, we need to
|
|
// allocate room for 3 double-word color masks
|
|
if (nBitCount == 16 || nBitCount == 32)
|
|
nColorTable = 3;
|
|
else if (nBitCount < 16)
|
|
nColorTable = 1 << nBitCount;
|
|
else {
|
|
ASSERT(nBitCount == 24);
|
|
nColorTable = 0;
|
|
}
|
|
|
|
// Allocate space for a BITMAPINFO structure (BITMAPINFOHEADER structure
|
|
// plus space for the color table)
|
|
lpBmi = (LPBITMAPINFOHEADER)calloc(sizeof(BITMAPINFOHEADER) + nColorTable * sizeof(RGBQUAD), 1);
|
|
|
|
if (!lpBmi)
|
|
return FALSE;
|
|
|
|
// Initialize the BITMAPINFOHEADER structure
|
|
lpBmi->biSize = sizeof(BITMAPINFOHEADER);
|
|
lpBmi->biWidth = bmp.bmWidth;
|
|
lpBmi->biHeight = bmp.bmHeight;
|
|
lpBmi->biPlanes = 1;
|
|
lpBmi->biBitCount = nBitCount;
|
|
|
|
HDC hdc = GetContextDC();
|
|
|
|
// Note: NT 16-bit video mode won't work unless you use BI_BITFIELDS, and
|
|
// Win 95 probably won't work if you use BI_BITFIELDS. Win 3.x doesn't even
|
|
// support 16-bit DIBs, so it isn't an issue there
|
|
#ifdef XP_WIN32
|
|
if (sysInfo.m_bWinNT && (nBitCount == 16 || nBitCount == 32))
|
|
lpBmi->biCompression = BI_BITFIELDS;
|
|
else
|
|
lpBmi->biCompression = BI_RGB;
|
|
#else
|
|
lpBmi->biCompression = BI_RGB;
|
|
#endif
|
|
|
|
// Ask the driver to tell us the number of bits we need to allocate
|
|
::GetDIBits(hdc, imageinfo->hBitmap, 0, (int)lpBmi->biHeight, NULL, (LPBITMAPINFO)lpBmi, DIB_RGB_COLORS);
|
|
|
|
if (lpBmi->biSizeImage == 0) {
|
|
// The driver didn't tell us so we need to compute it ourselves
|
|
lpBmi->biSizeImage = ((((lpBmi->biWidth * nBitCount) + 31) & ~31) >> 3) * lpBmi->biHeight;
|
|
}
|
|
|
|
// Allocate space for the bits
|
|
lpBits = (LPBYTE)HugeAlloc(lpBmi->biSizeImage, 1);
|
|
|
|
if (!lpBits) {
|
|
free(lpBmi);
|
|
ReleaseContextDC(hdc);
|
|
return FALSE;
|
|
}
|
|
|
|
// Windows bitmap files don't allow for a mask. Therefore we have to set the transparent
|
|
// parts of the image to be the appropriate color. This ensures that the bitmap file matches
|
|
// what the user sees on the screen
|
|
//
|
|
// ZZZ: This code should be shared with the code in _StretchBlt()
|
|
LO_Color* bg = (pLOImage->text_attr && !pLOImage->text_attr->no_background) ? &pLOImage->text_attr->bg : NULL;
|
|
COLORREF bgColor = bg ? RGB(bg->red, bg->green, bg->blue) : m_rgbBackgroundColor;
|
|
|
|
if (maskinfo && maskinfo->hBitmap) {
|
|
HBRUSH hBrush;
|
|
HDC tempDC = ::CreateCompatibleDC(hdc);
|
|
HBITMAP tempBmp = ::CreateCompatibleBitmap(hdc, lpBmi->biWidth, lpBmi->biHeight);
|
|
HBITMAP hOldBmp = (HBITMAP)::SelectObject(tempDC, tempBmp);
|
|
HBITMAP hOldBmp1 = (HBITMAP)::SelectObject(m_pImageDC, imageinfo->hBitmap);
|
|
|
|
if (m_iBitsPerPixel == 16)
|
|
// We don't want a dithered brush
|
|
hBrush = ::CreateSolidBrush(::GetNearestColor(hdc, bgColor));
|
|
else
|
|
hBrush = ::CreateSolidBrush(0x02000000L | bgColor);
|
|
::BitBlt(tempDC, 0, 0,lpBmi->biWidth, lpBmi->biHeight, m_pImageDC, 0, 0, SRCCOPY);
|
|
|
|
// Select the mask into the memory DC
|
|
::SelectObject(m_pImageDC, maskinfo->hBitmap);
|
|
|
|
// Change the transparent bits of the source bitmap to the desired background
|
|
// color by doing an AND raster op
|
|
//
|
|
// The mask is monochrome and will be converted to color to match the depth of
|
|
// the destination. The foreground pixels in the mask are set to 1, and the
|
|
// background pixels to 0. When converting to a color bitmap, white pixels (1)
|
|
// are set to the background color of the DC, and black pixels (0) are set to
|
|
// the text color of the DC
|
|
//
|
|
// Select the brush
|
|
HBRUSH hOldBrush = (HBRUSH)::SelectObject(tempDC, hBrush);
|
|
|
|
// Draw the brush where the mask is 0
|
|
::BitBlt(tempDC,
|
|
0,
|
|
0,
|
|
lpBmi->biWidth,
|
|
lpBmi->biHeight,
|
|
m_pImageDC,
|
|
0,
|
|
0,
|
|
MAKEROP4(SRCPAINT, R2_COPYPEN));
|
|
|
|
::SelectObject(tempDC, hOldBrush);
|
|
|
|
::DeleteObject(hBrush);
|
|
::GetDIBits(tempDC, tempBmp, 0, (int)lpBmi->biHeight, lpBits, (LPBITMAPINFO)lpBmi, DIB_RGB_COLORS);
|
|
::SelectObject(m_pImageDC, hOldBmp1);
|
|
::SelectObject(tempDC, hOldBmp);
|
|
::DeleteObject(tempBmp);
|
|
::DeleteDC(tempDC);
|
|
}
|
|
else
|
|
// This time have the driver give us the color table and the bits
|
|
::GetDIBits(hdc, imageinfo->hBitmap, 0, (int)lpBmi->biHeight, lpBits, (LPBITMAPINFO)lpBmi, DIB_RGB_COLORS);
|
|
ReleaseContextDC(hdc);
|
|
|
|
BITMAPFILEHEADER bf;
|
|
|
|
// Initialize the BITMAPFILEHEADER struct
|
|
bf.bfType = 0x4D42; // 'BM'
|
|
bf.bfReserved1 = 0;
|
|
bf.bfReserved2 = 0;
|
|
|
|
// Compute the offset to the bits. The bits are after the color table
|
|
bf.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + nColorTable * sizeof(RGBQUAD);
|
|
|
|
// Compute the size of the file
|
|
bf.bfSize = bf.bfOffBits + lpBmi->biSizeImage;
|
|
|
|
// Open the file and start writing
|
|
CStdioFile file;
|
|
|
|
TRY {
|
|
#ifndef XP_WIN32
|
|
file.Open(lpszFileName, CFile::modeWrite | CFile::modeCreate | CFile::typeBinary);
|
|
#else
|
|
file.Open(lpszFileName, CFile::modeWrite | CFile::modeCreate | CFile::typeBinary | CFile::shareExclusive);
|
|
#endif
|
|
// Write the BITMAPFILEHEADER structure
|
|
file.Write(&bf, sizeof(bf));
|
|
|
|
// Write the BITMAPINFOHEADER and color table
|
|
file.Write(lpBmi, sizeof(BITMAPINFOHEADER) + nColorTable * sizeof(RGBQUAD));
|
|
|
|
// Write the bits
|
|
#ifdef XP_WIN32
|
|
file.Write(lpBits, lpBmi->biSizeImage);
|
|
#else
|
|
file.WriteHuge(lpBits, lpBmi->biSizeImage);
|
|
#endif
|
|
file.Close();
|
|
}
|
|
CATCH(CFileException, e) {
|
|
CDCCX::HugeFree(lpBits);
|
|
free(lpBmi);
|
|
return FALSE;
|
|
}
|
|
END_CATCH
|
|
|
|
// Free up everything and return success
|
|
CDCCX::HugeFree(lpBits);
|
|
free(lpBmi);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
void CDCCX::LayoutNewDocument(MWContext *pContext, URL_Struct *pURL, int32 *pWidth, int32 *pHeight, int32 *pmWidth, int32 *pmHeight) {
|
|
// Set up the width, height, and margins as defualt values here.
|
|
// These should have been set up in the Initialize() member of a derived
|
|
// class.
|
|
if (pContext->grid_children) {
|
|
XP_ListDestroy (pContext->grid_children);
|
|
pContext->grid_children = 0;
|
|
}
|
|
*pWidth = m_lWidth;
|
|
*pHeight = m_lHeight;
|
|
|
|
// No known margins, up to dervied classes to correctly set.
|
|
// Don't set the margins if non-zero, Layout has it's own ideas about this.
|
|
|
|
// Set ourselves to be at the top of the document.
|
|
m_lOrgX = 0;
|
|
m_lOrgY = 0;
|
|
|
|
// Document has no substance.
|
|
m_lDocWidth = 0;
|
|
m_lDocHeight = 0;
|
|
|
|
|
|
// Flush the background color.
|
|
COLORREF rgbColor = prefInfo.m_rgbBackgroundColor;
|
|
FE_SetBackgroundColor(pContext, GetRValue(rgbColor), GetGValue(rgbColor), GetBValue(rgbColor));
|
|
|
|
// We're loading a new page, so flush the previous page's
|
|
// fonts so that we don't keep building a huge font cache.
|
|
ClearFontCache();
|
|
|
|
}
|
|
|
|
#define LIGHT_GRAY RGB(192, 192, 192)
|
|
#define DARK_GRAY RGB(128, 128, 128)
|
|
#define WHITE RGB(255, 255, 255)
|
|
#define BLACK RGB(0, 0, 0)
|
|
|
|
static void
|
|
GetSystem3DColors(COLORREF rgbBackground, COLORREF& rgbLightColor, COLORREF& rgbDarkColor)
|
|
{
|
|
#ifdef XP_WIN32
|
|
if (sysInfo.IsWin4_32()) {
|
|
// These are Windows 95 only
|
|
rgbLightColor = ::GetSysColor(COLOR_3DLIGHT);
|
|
rgbDarkColor = ::GetSysColor(COLOR_3DSHADOW);
|
|
} else {
|
|
rgbLightColor = LIGHT_GRAY;
|
|
rgbDarkColor = ::GetSysColor(COLOR_BTNSHADOW);
|
|
}
|
|
#else
|
|
rgbLightColor = LIGHT_GRAY;
|
|
rgbDarkColor = ::GetSysColor(COLOR_BTNSHADOW);
|
|
#endif
|
|
|
|
// We need to make sure that both colors are visible against
|
|
// the background
|
|
if (rgbLightColor == rgbBackground)
|
|
rgbLightColor = rgbBackground == LIGHT_GRAY ? WHITE : LIGHT_GRAY;
|
|
|
|
if (rgbDarkColor == rgbBackground)
|
|
rgbDarkColor = rgbBackground == DARK_GRAY ? BLACK : DARK_GRAY;
|
|
}
|
|
|
|
// Constants for calculating Highlight (TS = "TopShadow") and
|
|
// shadow (BS = "BottomShadow") values relative to background
|
|
// Taken from UNIX version -- Eric Bina's Visual.c
|
|
//
|
|
// Bias brightness calculation by standard color-sensitivity values
|
|
// (Percents -- UNIX used floats, but we don't need to)
|
|
//
|
|
#define RED_LUMINOSITY 30
|
|
#define GREEN_LUMINOSITY 59
|
|
#define BLUE_LUMINOSITY 11
|
|
|
|
// Percent effect of intensity, light, and luminosity & on brightness,
|
|
#define INTENSITY_FACTOR 25
|
|
#define LIGHT_FACTOR 0
|
|
#define LUMINOSITY_FACTOR 75
|
|
|
|
// LITE color model percent to interpolate RGB towards black for BS, TS
|
|
|
|
#define COLOR_LITE_BS_FACTOR 45
|
|
#define COLOR_LITE_TS_FACTOR 70
|
|
|
|
// DARK color model - percent to interpolate RGB towards white for BS, TS
|
|
|
|
#define COLOR_DARK_BS_FACTOR 30
|
|
#define COLOR_DARK_TS_FACTOR 50
|
|
#define MAX_COLOR 255
|
|
|
|
#define COLOR_DARK_THRESHOLD 51
|
|
#define COLOR_LIGHT_THRESHOLD 204
|
|
|
|
void CDCCX::Compute3DColors(COLORREF rgbColor, COLORREF &rgbLight, COLORREF &rgbDark)
|
|
{
|
|
unsigned uRed, uGreen, uBlue;
|
|
unsigned uRedBack = GetRValue(rgbColor);
|
|
unsigned uGreenBack = GetGValue(rgbColor);
|
|
unsigned uBlueBack = GetBValue(rgbColor);
|
|
unsigned intensity = (uRedBack + uGreenBack + uBlueBack) / 3;
|
|
unsigned luminosity = ((RED_LUMINOSITY * uRedBack)/ 100)
|
|
+ ((GREEN_LUMINOSITY * uGreenBack)/ 100)
|
|
+ ((BLUE_LUMINOSITY * uBlueBack)/ 100);
|
|
unsigned backgroundBrightness = ((intensity * INTENSITY_FACTOR) +
|
|
(luminosity * LUMINOSITY_FACTOR)) / 100;
|
|
unsigned f;
|
|
|
|
if (backgroundBrightness < COLOR_DARK_THRESHOLD) {
|
|
// Dark Background - interpolate 30% toward black
|
|
uRed = uRedBack - (COLOR_DARK_BS_FACTOR * uRedBack / 100);
|
|
uGreen = uGreenBack - (COLOR_DARK_BS_FACTOR * uGreenBack / 100);
|
|
uBlue = uBlueBack - (COLOR_DARK_BS_FACTOR * uBlueBack / 100);
|
|
|
|
rgbDark = RGB(uRed, uGreen, uBlue);
|
|
|
|
// This interpolotes to 50% toward white
|
|
uRed = uRedBack + (COLOR_DARK_TS_FACTOR *
|
|
(MAX_COLOR - uRedBack) / 100);
|
|
uGreen = uGreenBack + (COLOR_DARK_TS_FACTOR *
|
|
(MAX_COLOR - uGreenBack) / 100);
|
|
|
|
uBlue = uBlueBack + (COLOR_DARK_TS_FACTOR *
|
|
(MAX_COLOR - uBlueBack) / 100);
|
|
|
|
} else if (backgroundBrightness > COLOR_LIGHT_THRESHOLD) {
|
|
// Interpolate 45% toward black
|
|
uRed = uRedBack - (COLOR_LITE_BS_FACTOR * uRedBack / 100);
|
|
uGreen = uGreenBack - (COLOR_LITE_BS_FACTOR * uGreenBack / 100);
|
|
uBlue = uBlueBack - (COLOR_LITE_BS_FACTOR * uBlueBack / 100);
|
|
rgbDark = RGB(uRed, uGreen, uBlue);
|
|
|
|
// Original algorithm (from X source: visual.c) used:
|
|
// uRed = uRedBack - (COLOR_LITE_TS_FACTOR * uRedBack / 100),
|
|
// where FACTOR is 20%, but that makes no sense!
|
|
// I think the intention was large interpolation toward white,
|
|
// so use max of "medium" range (70%) for smooth continuity across threshhold
|
|
uRed = uRedBack + (COLOR_LITE_TS_FACTOR * (MAX_COLOR - uRedBack) / 100);
|
|
uGreen = uGreenBack + (COLOR_LITE_TS_FACTOR * (MAX_COLOR - uGreenBack) / 100);
|
|
uBlue = uBlueBack + (COLOR_LITE_TS_FACTOR * (MAX_COLOR - uBlueBack) / 100);
|
|
|
|
} else {
|
|
// Medium Background
|
|
f = COLOR_DARK_BS_FACTOR + (backgroundBrightness
|
|
* ( COLOR_LITE_BS_FACTOR - COLOR_DARK_BS_FACTOR )
|
|
/ MAX_COLOR);
|
|
|
|
uRed = uRedBack - (f * uRedBack / 100);
|
|
uGreen = uGreenBack - (f * uGreenBack / 100);
|
|
uBlue = uBlueBack - (f * uBlueBack / 100);
|
|
rgbDark = RGB(uRed, uGreen, uBlue);
|
|
|
|
f = COLOR_DARK_TS_FACTOR + (backgroundBrightness
|
|
* ( COLOR_LITE_TS_FACTOR - COLOR_DARK_TS_FACTOR )
|
|
/ MAX_COLOR);
|
|
|
|
uRed = uRedBack + (f * (MAX_COLOR - uRedBack) / 100);
|
|
uGreen = uGreenBack + (f * (MAX_COLOR - uGreenBack) / 100);
|
|
uBlue = uBlueBack + (f * (MAX_COLOR - uBlueBack) / 100);
|
|
}
|
|
|
|
// Safety check for upper limit
|
|
uRed = min(MAX_COLOR, uRed);
|
|
uGreen = min(MAX_COLOR, uGreen);
|
|
uBlue = min(MAX_COLOR, uBlue);
|
|
|
|
rgbLight = RGB(uRed, uGreen, uBlue);
|
|
|
|
// If either of these colors is the same as the background color
|
|
// then use the system 3D element colors instead
|
|
if (rgbLight == m_rgbBackgroundColor || rgbDark == m_rgbBackgroundColor) {
|
|
GetSystem3DColors(m_rgbBackgroundColor, rgbLight, rgbDark);
|
|
}
|
|
}
|
|
|
|
void CDCCX::Set3DColors(COLORREF crBackground)
|
|
{
|
|
Compute3DColors(crBackground, m_rgbLightColor, m_rgbDarkColor);
|
|
}
|
|
|
|
void CDCCX::SetBackgroundColor(MWContext *pContext, uint8 uRed, uint8 uGreen, uint8 uBlue)
|
|
{
|
|
// Generate the color reference
|
|
COLORREF crBackground = ResolveBGColor(uRed, uGreen, uBlue);
|
|
|
|
if( crBackground != m_rgbBackgroundColor ){
|
|
// Recalculate the color only if it has changed
|
|
m_rgbBackgroundColor = crBackground;
|
|
Set3DColors(m_rgbBackgroundColor);
|
|
}
|
|
|
|
// Determine transparency.
|
|
ResolveTransparentColor(uRed, uGreen, uBlue);
|
|
|
|
// Set the background color in the DC.
|
|
HDC hdc = GetContextDC();
|
|
if (hdc) {
|
|
::SetBkColor(hdc, m_rgbBackgroundColor);
|
|
}
|
|
#ifdef DDRAW
|
|
if (GetPrimarySurface()) {
|
|
hdc = GetDispDC(); // set the background color for offscreen surface.
|
|
if (hdc) {
|
|
::SetBkColor(hdc, m_rgbBackgroundColor);
|
|
}
|
|
}
|
|
#endif
|
|
ReleaseContextDC(hdc);
|
|
|
|
// Have any views (ledges) clear.
|
|
// Only do the FE_VIEW, since there aren't any other ledges right now.
|
|
FE_ClearView(pContext, FE_VIEW);
|
|
}
|
|
|
|
|
|
void CDCCX::SetTransparentColor(BYTE red, BYTE green, BYTE blue)
|
|
{
|
|
rgbTransparentColor.red = red;
|
|
rgbTransparentColor.green = green;
|
|
rgbTransparentColor.blue = blue;
|
|
}
|
|
|
|
// Create the initial identity palette that contains just the system colors
|
|
// and the colors.
|
|
HPALETTE
|
|
CDCCX::InitPalette(HDC hdc)
|
|
{
|
|
int i;
|
|
HPALETTE hPal;
|
|
// Create an identity palette
|
|
LPLOGPALETTE pLogPal = (LPLOGPALETTE)XP_ALLOC(sizeof(LOGPALETTE)
|
|
+ 256 * sizeof(PALETTEENTRY));
|
|
if(pLogPal != NULL) {
|
|
pLogPal->palVersion = 0x300;
|
|
pLogPal->palNumEntries = 256;
|
|
|
|
// Get entries 0-9 and 246-255, which are the standard system colors
|
|
GetSystemPaletteEntries(hdc, 0, pLogPal->palNumEntries,
|
|
pLogPal->palPalEntry);
|
|
|
|
// Initialize palette entry flags
|
|
for (i = 10; i < 246; i++) {
|
|
pLogPal->palPalEntry[i].peFlags = PALETTEENTRY_FLAGS;
|
|
#ifndef USE_IDENTITY_PALETTE
|
|
// Collapse all unspecified entries to black so that we are
|
|
// friendlier to other applications sharing the palette.
|
|
if(i >= (iLowerColors + MAX_IMAGE_PALETTE_ENTRIES)) {
|
|
pLogPal->palPalEntry[i].peRed = 0;
|
|
pLogPal->palPalEntry[i].peGreen = 0;
|
|
pLogPal->palPalEntry[i].peBlue = 0;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// Now add in the animation colors
|
|
for(int iLowCnt = iLowerSystemColors, j = 0; iLowCnt <
|
|
iLowerColors; iLowCnt++, j++) {
|
|
pLogPal->palPalEntry[iLowCnt].peRed = animationPalette[j].red;
|
|
pLogPal->palPalEntry[iLowCnt].peGreen = animationPalette[j].green;
|
|
pLogPal->palPalEntry[iLowCnt].peBlue = animationPalette[j].blue;
|
|
pLogPal->palPalEntry[iLowCnt].peFlags = PC_NOCOLLAPSE;
|
|
}
|
|
|
|
|
|
if(!(hPal = ::CreatePalette(pLogPal))) {
|
|
hPal = NULL;
|
|
}
|
|
|
|
|
|
// Done with this.
|
|
XP_FREE(pLogPal);
|
|
}
|
|
return hPal;
|
|
}
|
|
HPALETTE CDCCX::CreateColorPalette(HDC hdc, IL_IRGB& transparentColor, int bitsPerPixel)
|
|
{
|
|
HPALETTE hPal;
|
|
// Set up the per-context palette.
|
|
// This is per-window since not everything goes to the screen, and therefore
|
|
// won't always have the screen's attributes. (printing, metafiles DCs, etc).
|
|
IL_ColorMap * defaultColorMap = IL_NewCubeColorMap(NULL, 0,
|
|
MAX_IMAGE_PALETTE_ENTRIES+1);
|
|
hPal = CDCCX::InitPalette(hdc);
|
|
CDCCX::SetColormap(hdc, defaultColorMap, transparentColor, hPal);
|
|
IL_DestroyColorMap (defaultColorMap);
|
|
|
|
return hPal;
|
|
}
|
|
|
|
|
|
void CDCCX::SetColormap(HDC hdc, NI_ColorMap *pMap, IL_IRGB& transparentColor, HPALETTE hPal) {
|
|
|
|
PALETTEENTRY paletteEntries[256];
|
|
int iExactMatches = 0; // # of color requests we were able to match
|
|
int iFirstImageColor = iLowerColors;
|
|
int iLastImageColor = iLowerColors + MAX_IMAGE_PALETTE_ENTRIES - 1;
|
|
// Copy existing palette to get system colors and animation colors
|
|
GetPaletteEntries(hPal, 0, 256, paletteEntries);
|
|
if (!pMap->index) { // setup the index array.
|
|
pMap->index = (unsigned char*)XP_ALLOC(MAX_IMAGE_PALETTE_ENTRIES+1);
|
|
for (int i = 0; i < MAX_IMAGE_PALETTE_ENTRIES; i++) {
|
|
pMap->index[i] = iLowerColors + i;
|
|
paletteEntries[iLowerColors + i].peRed = pMap->map[i].red;
|
|
paletteEntries[iLowerColors + i].peGreen = pMap->map[i].green;
|
|
paletteEntries[iLowerColors + i].peBlue = pMap->map[i].blue;
|
|
paletteEntries[iLowerColors + i].peFlags = PALETTEENTRY_FLAGS;
|
|
}
|
|
}
|
|
paletteEntries[iLowerColors + MAX_IMAGE_PALETTE_ENTRIES].peRed = transparentColor.red;
|
|
paletteEntries[iLowerColors + MAX_IMAGE_PALETTE_ENTRIES].peGreen = transparentColor.green;
|
|
paletteEntries[iLowerColors + MAX_IMAGE_PALETTE_ENTRIES].peBlue = transparentColor.blue;
|
|
paletteEntries[iLowerColors + MAX_IMAGE_PALETTE_ENTRIES].peFlags = PC_NOCOLLAPSE;
|
|
|
|
paletteEntries[255].peRed = 0xFF;
|
|
paletteEntries[255].peGreen = 0xFF;
|
|
paletteEntries[255].peBlue = 0xFF;
|
|
paletteEntries[255].peFlags = PALETTEENTRY_FLAGS;
|
|
|
|
::SetPaletteEntries(hPal, iFirstImageColor, MAX_IMAGE_PALETTE_ENTRIES,
|
|
&paletteEntries[iFirstImageColor]);
|
|
}
|
|
|
|
void CDCCX::SetDocDimension(MWContext *pContext, int iLocation, int32 lWidth, int32 lLength) {
|
|
// Set the document height and width.
|
|
m_lDocWidth = lWidth;
|
|
m_lDocHeight = lLength;
|
|
}
|
|
|
|
void CDCCX::GetDocPosition(MWContext *pContext, int iLocation, int32 *lX_p, int32 *lY_p) {
|
|
*lX_p = m_lOrgX;
|
|
*lY_p = m_lOrgY;
|
|
}
|
|
|
|
BOOL CDCCX::OnOpenDocumentCX(const char *pPathName) {
|
|
// Should only happen with window contexts.
|
|
if(IsWindowContext() == FALSE) {
|
|
return(FALSE);
|
|
}
|
|
|
|
// Make sure there's something specified, otherwise just
|
|
// return sucess.
|
|
// Take passing in NULL as a request to initialize, which we do
|
|
// nothing with.
|
|
if(pPathName != NULL) {
|
|
// convert the path name to a URL.
|
|
CString csUrl;
|
|
WFE_ConvertFile2Url(csUrl, pPathName);
|
|
|
|
// Load it.
|
|
GetUrl(NET_CreateURLStruct(csUrl, NET_DONT_RELOAD), FO_CACHE_AND_PRESENT);
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
void CDCCX::ViewImages() {
|
|
#ifdef MOZ_NGLAYOUT
|
|
XP_ASSERT(0);
|
|
#else
|
|
if(IsDestroyed() == FALSE) {
|
|
// Tell layout that all images are to be force loaded.
|
|
LO_SetForceLoadImage(NULL, TRUE);
|
|
|
|
ExplicitlyLoadAllImages();
|
|
}
|
|
#endif /* MOZ_NGLAYOUT */
|
|
}
|
|
|
|
BOOL CDCCX::CanViewImages() {
|
|
BOOL bRetval;
|
|
if(prefInfo.m_bAutoLoadImages || IsDestroyed()) {
|
|
bRetval = FALSE;
|
|
}
|
|
else {
|
|
bRetval = TRUE;
|
|
}
|
|
|
|
return(bRetval);
|
|
}
|
|
|
|
// Set up the things that need to be in order to handle an OLE server
|
|
// metafile correctly.
|
|
void CDCCX::EnableOleServer()
|
|
{
|
|
TRACE("Enabling context as an OLE server\n");
|
|
|
|
// Mark a generic switch that can be checked elsewhere.
|
|
m_bOleServer = TRUE;
|
|
}
|
|
|
|
// Create a url struct from the history, with appropriate checking
|
|
// for NULL and such, so that we don't have this code scattered
|
|
// throughout the client.
|
|
// bClearStateData is a flag set to erase any data that can't be
|
|
// tossed around without upsetting the client (form data).
|
|
// It's off by default, so be careful out there.
|
|
URL_Struct *CDCCX::CreateUrlFromHist(BOOL bClearStateData, SHIST_SavedData *pSavedData, BOOL bWysiwyg)
|
|
{
|
|
// Make sure that we're not destroyed.
|
|
if(IsDestroyed()) {
|
|
return(NULL);
|
|
}
|
|
|
|
// Before we create the URL, we must save any state data of the current page
|
|
// that is needed to perform the next load (such as position)....
|
|
// Other's not dealing with history, save their data in the GetUrl call.
|
|
SHIST_SetPositionOfCurrentDoc(&(GetContext()->hist), 0);
|
|
#ifdef MOZ_NGLAYOUT
|
|
XP_ASSERT(0);
|
|
#else
|
|
if(GetOriginX() || GetOriginY()) {
|
|
#ifdef LAYERS
|
|
LO_Any *pAny = (LO_Any *)LO_XYToNearestElement(GetDocumentContext(), GetOriginX(), GetOriginY(), NULL);
|
|
#else
|
|
LO_Any *pAny = (LO_Any *)LO_XYToNearestElement(GetDocumentContext(), GetOriginX(), GetOriginY());
|
|
#endif /* LAYERS */
|
|
if(pAny != NULL) {
|
|
TRACE("Remembering document position at element id %ld\n", pAny->ele_id);
|
|
SHIST_SetPositionOfCurrentDoc(&(GetContext()->hist), pAny->ele_id);
|
|
}
|
|
}
|
|
#endif /* MOZ_NGLAYOUT */
|
|
|
|
// Call/return the base.
|
|
URL_Struct *pUrl = CStubsCX::CreateUrlFromHist(bClearStateData, pSavedData, bWysiwyg);
|
|
return(pUrl);
|
|
}
|
|
|
|
#ifndef MOZ_NGLAYOUT
|
|
//
|
|
// Make the given form element visible on the screen
|
|
//
|
|
void CDCCX::DisplayFormElement(MWContext *pContext, int iLocation, LO_FormElementStruct *pFormElement)
|
|
{
|
|
// Call the base.
|
|
CStubsCX::DisplayFormElement(pContext, iLocation, pFormElement);
|
|
|
|
// Figure the coordinates.
|
|
LTRB Rect;
|
|
|
|
// Note that we call this version of ResolveElement since we do
|
|
// something special for form elements. Note also that we don't
|
|
// check the return value since this function may be called before
|
|
// the form element is actually visible, but we have to correctly
|
|
// "display". In other words, this function is only called when the
|
|
// visibility or position of the form element changes and we need
|
|
// make the corresponding changes to the actual widget irrespective
|
|
// of whether it's visible or not.
|
|
ResolveElement(Rect, pFormElement);
|
|
|
|
SafeSixteen(Rect);
|
|
|
|
// Get our front end form element, and have it display itself at the given rectangle.
|
|
CFormElement *pFormClass = CFormElement::GetFormElement(ABSTRACTCX(GetContext()), pFormElement);
|
|
if(pFormClass != NULL) {
|
|
pFormClass->DisplayFormElement(Rect);
|
|
}
|
|
}
|
|
|
|
void CDCCX::FormTextIsSubmit(MWContext *pContext, LO_FormElementStruct *pFormElement)
|
|
{
|
|
// Call the base.
|
|
CStubsCX::FormTextIsSubmit(pContext, pFormElement);
|
|
|
|
// Get our front end form element, and have it do it's thang.
|
|
CFormElement *pFormClass = CFormElement::GetFormElement(ABSTRACTCX(GetContext()), pFormElement);
|
|
if(pFormClass != NULL) {
|
|
pFormClass->FormTextIsSubmit();
|
|
}
|
|
}
|
|
|
|
void CDCCX::GetFormElementInfo(MWContext *pContext, LO_FormElementStruct *pFormElement)
|
|
{
|
|
|
|
// Call the base.
|
|
CStubsCX::GetFormElementInfo(pContext, pFormElement);
|
|
|
|
// Get our front end form element, and have it do it's thang.
|
|
CFormElement *pFormClass = CFormElement::GetFormElement(ABSTRACTCX(GetContext()), pFormElement);
|
|
if(pFormClass != NULL) {
|
|
pFormClass->GetFormElementInfo();
|
|
}
|
|
}
|
|
|
|
|
|
void CDCCX::GetFormElementValue(MWContext *pContext, LO_FormElementStruct *pFormElement, XP_Bool bTurnOff)
|
|
{
|
|
|
|
// Call the base.
|
|
CStubsCX::GetFormElementValue(pContext, pFormElement, bTurnOff);
|
|
|
|
// Get our front end form element, and have it do it's thang.
|
|
CFormElement *pFormClass = CFormElement::GetFormElement(ABSTRACTCX(GetContext()), pFormElement);
|
|
if(pFormClass != NULL) {
|
|
pFormClass->GetFormElementValue(bTurnOff);
|
|
}
|
|
}
|
|
|
|
void CDCCX::ResetFormElement(MWContext *pContext, LO_FormElementStruct *pFormElement)
|
|
{
|
|
// Call the base.
|
|
CStubsCX::ResetFormElement(pContext, pFormElement);
|
|
|
|
// Get our front end form element, and have it do it's thang.
|
|
CFormElement *pFormClass = CFormElement::GetFormElement(ABSTRACTCX(GetContext()), pFormElement);
|
|
if(pFormClass != NULL) {
|
|
pFormClass->ResetFormElement();
|
|
}
|
|
}
|
|
|
|
void CDCCX::SetFormElementToggle(MWContext *pContext, LO_FormElementStruct *pFormElement, XP_Bool iState)
|
|
{
|
|
// Call the base.
|
|
CStubsCX::SetFormElementToggle(pContext, pFormElement, iState);
|
|
|
|
// Get our front end form element, and have it do it's thang.
|
|
CFormElement *pFormClass = CFormElement::GetFormElement(ABSTRACTCX(GetContext()), pFormElement);
|
|
if(pFormClass != NULL) {
|
|
pFormClass->SetFormElementToggle(iState);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Do a fill rect type operation.
|
|
void CDCCX::FloodRect(LTRB& Rect, HBRUSH hColor)
|
|
{
|
|
if(hColor) {
|
|
HDC hdc = GetContextDC();
|
|
if(hdc) {
|
|
RECT cr;
|
|
::SetRect(&cr, CASTINT(Rect.left), CASTINT(Rect.top), CASTINT(Rect.right), CASTINT(Rect.bottom));
|
|
::FillRect(hdc, &cr, hColor);
|
|
ReleaseContextDC(hdc);
|
|
}
|
|
}
|
|
}
|
|
BITMAPINFO* CDCCX::FillBitmapInfoHeader(NI_Pixmap* pImage)
|
|
{
|
|
BITMAPINFO *pBMInfo = NULL;
|
|
|
|
NI_PixmapHeader* imageHeader = &pImage->header;
|
|
int pixmap_depth = imageHeader->color_space->pixmap_depth;
|
|
|
|
|
|
if (pixmap_depth == 24 || pixmap_depth == 32)
|
|
pBMInfo = (BITMAPINFO *)XP_ALLOC(sizeof(BITMAPINFOHEADER)+ (1 * sizeof(RGBQUAD))); // space for header only
|
|
else if (pixmap_depth == 16)
|
|
pBMInfo = (BITMAPINFO *)XP_ALLOC(sizeof(BITMAPINFOHEADER)+ (3 * sizeof(RGBQUAD)) ); // space for header and color masks
|
|
else if (pixmap_depth == 8)
|
|
pBMInfo = (BITMAPINFO *)XP_ALLOC(sizeof(BITMAPINFOHEADER)+ (256 * sizeof(RGBQUAD)) ); // space for header and pallette
|
|
else if (pixmap_depth == 1)
|
|
pBMInfo = (BITMAPINFO *)XP_ALLOC(sizeof(BITMAPINFOHEADER)+ (2 * sizeof(RGBQUAD)) ); // space for header and pallette
|
|
ASSERT(pixmap_depth < 32);
|
|
if (!pBMInfo) return NULL; // error occor.
|
|
|
|
pBMInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
|
|
pBMInfo->bmiHeader.biWidth = pImage->header.width;
|
|
pBMInfo->bmiHeader.biHeight = pImage->header.height;
|
|
pBMInfo->bmiHeader.biPlanes = 1;
|
|
pBMInfo->bmiHeader.biBitCount = (short)pixmap_depth;
|
|
|
|
#ifdef XP_WIN32
|
|
// Don't allow this to happen on OLE servers, as the metafiles can't
|
|
// handle it.
|
|
if ((pixmap_depth > 1 ) && m_bRGB565) {
|
|
pBMInfo->bmiHeader.biCompression = BI_BITFIELDS;
|
|
|
|
// Define the color masks for a RGB565 DIB
|
|
LPDWORD lpMasks = (LPDWORD)pBMInfo->bmiColors;
|
|
lpMasks[0] = 0xF800; // red color mask
|
|
lpMasks[1] = 0x07E0; // green color mask
|
|
lpMasks[2] = 0x001F; // blue color mask
|
|
|
|
} else {
|
|
if (pixmap_depth == 24 || pixmap_depth == 32) {
|
|
LPDWORD lpMasks = (LPDWORD)pBMInfo->bmiColors;
|
|
*lpMasks = NULL;
|
|
}
|
|
|
|
pBMInfo->bmiHeader.biCompression = BI_RGB;
|
|
}
|
|
#else
|
|
pBMInfo->bmiHeader.biCompression = BI_RGB;
|
|
#endif
|
|
|
|
//pBMInfo->bmiHeader.biSizeImage = NULL;
|
|
pBMInfo->bmiHeader.biSizeImage = pImage->header.widthBytes * pImage->header.height;
|
|
pBMInfo->bmiHeader.biXPelsPerMeter = 0;
|
|
pBMInfo->bmiHeader.biYPelsPerMeter = 0;
|
|
|
|
pBMInfo->bmiHeader.biClrUsed = 0; // default value
|
|
pBMInfo->bmiHeader.biClrImportant = 0; // all important
|
|
|
|
if(m_bUseDibPalColors) {
|
|
if (pixmap_depth == 1) {
|
|
// Build an index table for monochrome images. Only XBMs are
|
|
// monochome
|
|
WORD* pPalIndex = (WORD*)(pBMInfo->bmiColors);
|
|
|
|
pPalIndex[0] = 255; // palette index for WHITE
|
|
pPalIndex[1] = 0; // palette index for BLACK
|
|
|
|
} else {
|
|
// pImage->depth != 1
|
|
unsigned short nClrUsed = (unsigned short)(1 << pBMInfo->bmiHeader.biBitCount);
|
|
|
|
// DIB_PAL_COLORS expects an array of 16-bit unsigned integers that specify
|
|
// an index into the currently realized logical palette
|
|
WORD* pPalIndx = (WORD*)(((unsigned char*)pBMInfo) + pBMInfo->bmiHeader.biSize);
|
|
for (unsigned short index = 0; index < nClrUsed; index++, pPalIndx++)
|
|
*pPalIndx = index;
|
|
}
|
|
|
|
} else {
|
|
// Not using DIB_PAL_COLORS
|
|
if (pixmap_depth == 8) {
|
|
RGBQUAD RGBArray[256];
|
|
CopyPaletteToRGBArray(GetPalette(), RGBArray);
|
|
memcpy(&(pBMInfo->bmiColors[0]), RGBArray, (256 * sizeof(RGBQUAD)));
|
|
|
|
|
|
|
|
} else if (pixmap_depth == 1) {
|
|
// Build the color table for monochrome images. Only XBMs are monochrome
|
|
pBMInfo->bmiColors[0].rgbRed = 255;
|
|
pBMInfo->bmiColors[0].rgbGreen = 255;
|
|
pBMInfo->bmiColors[0].rgbBlue = 255;
|
|
pBMInfo->bmiColors[0].rgbReserved = 0;
|
|
pBMInfo->bmiColors[1].rgbRed = 0;
|
|
pBMInfo->bmiColors[1].rgbGreen = 0;
|
|
pBMInfo->bmiColors[1].rgbBlue = 0;
|
|
pBMInfo->bmiColors[1].rgbReserved = 0;
|
|
}
|
|
}
|
|
return pBMInfo;
|
|
}
|
|
|
|
static void replaceColorSpace(NI_Pixmap* pImage, NI_ColorSpace* curColorSpace, int devicePixmap)
|
|
{
|
|
NI_PixmapHeader* imageHeader = &pImage->header;
|
|
NI_ColorSpace* color_space = imageHeader->color_space;
|
|
|
|
ASSERT(color_space->pixmap_depth < 32);
|
|
if (color_space->pixmap_depth == 1)
|
|
return;
|
|
if ((color_space->pixmap_depth <= 8) || (devicePixmap < color_space->pixmap_depth)) {
|
|
IL_ReleaseColorSpace(color_space);
|
|
IL_AddRefToColorSpace(curColorSpace);
|
|
imageHeader->color_space = curColorSpace;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
static BOOL
|
|
CanCreateBrush(HBITMAP hBitmap, int nBitsPerPixel)
|
|
{
|
|
BITMAP bitmap;
|
|
|
|
// Get the size of the bitmap
|
|
::GetObject(hBitmap, sizeof(bitmap), &bitmap);
|
|
|
|
// We can create a brush if the bitmap is exacly 8x8 or we're on NT
|
|
if (sysInfo.m_bWinNT) {
|
|
if (nBitsPerPixel == 24) {
|
|
// There's a reported problem with 24bpp mode on NT, but I haven't
|
|
// seen it on NT 4.0
|
|
// if (sysInfo.m_dwMajor < 4)
|
|
return FALSE;
|
|
}
|
|
|
|
// Large brushes on NT are a performance hog, so place an upper
|
|
// limit on the brush size.
|
|
return bitmap.bmWidth <= 64 && bitmap.bmHeight <= 64;
|
|
}
|
|
|
|
return bitmap.bmWidth == 8 && bitmap.bmHeight == 8;
|
|
}
|
|
|
|
HBITMAP CDCCX::CreateBitmap(HDC hTargetDC, NI_Pixmap *image)
|
|
{
|
|
ASSERT(hTargetDC);
|
|
FEBitmapInfo *imageInfo = (FEBitmapInfo*)image->client_data;
|
|
|
|
BITMAPINFO *pBmInfo = imageInfo->bmpInfo;
|
|
|
|
ASSERT(pBmInfo);
|
|
|
|
return ::CreateDIBitmap(hTargetDC, &pBmInfo->bmiHeader,
|
|
CBM_INIT, image->bits,
|
|
pBmInfo, m_bUseDibPalColors ? DIB_PAL_COLORS : DIB_RGB_COLORS);
|
|
|
|
}
|
|
|
|
|
|
int CDCCX::DisplayPixmap(NI_Pixmap* image, NI_Pixmap* mask, int32 x, int32 y, int32 x_offset, int32 y_offset, int32 width, int32 height, int32 lScaleWidth, int32 lScaleHeight, LTRB& Rect)
|
|
{
|
|
// If width and height are 0, then we assume the entire width and height.
|
|
// x and y are relative coords to the top left of the image.
|
|
HDC hdc;
|
|
#ifdef DDRAW
|
|
LPDIRECTDRAWSURFACE drawSurface = GetBackSurface();
|
|
#endif
|
|
hdc = GetDispDC();
|
|
|
|
FEBitmapInfo *imageInfo = (FEBitmapInfo*) image->client_data;
|
|
|
|
if (!imageInfo) return FALSE; // there is no image to display.
|
|
|
|
// set this flag, so the display boarder will not try to display the icon.
|
|
imageInfo->imageDisplayed = TRUE;
|
|
int xRepeat, yRepeat;
|
|
xRepeat = (CASTINT(width) + CASTINT(x_offset) + CASTINT(imageInfo->targetWidth) -1) / CASTINT(imageInfo->targetWidth);
|
|
yRepeat = (CASTINT(height) + CASTINT(y_offset) + CASTINT(imageInfo->targetHeight) -1) / CASTINT(imageInfo->targetHeight);
|
|
if (!ResolveElement(Rect, image, x_offset * m_lConvertX, y_offset *m_lConvertY,
|
|
x * m_lConvertX, y* m_lConvertY,
|
|
width* m_lConvertX, height* m_lConvertY,
|
|
lScaleWidth * m_lConvertX, lScaleHeight * m_lConvertY))
|
|
return FALSE;
|
|
SafeSixteen(Rect);
|
|
|
|
FEBitmapInfo *maskInfo = (FEBitmapInfo *)NULL;
|
|
|
|
if (mask) maskInfo = (FEBitmapInfo *)mask->client_data;
|
|
|
|
|
|
|
|
x_offset = (x_offset > 0) ? x_offset : 0;
|
|
y_offset = (y_offset > 0) ? y_offset : 0;
|
|
|
|
if ((xRepeat > 1) || (yRepeat > 1)) { // tiled
|
|
TileImage(hdc, Rect, image, mask, x * GetXConvertUnit(), y * GetYConvertUnit());
|
|
}
|
|
else {
|
|
if (maskInfo) {
|
|
if ((imageInfo->hBitmap) && (maskInfo->hBitmap)) {
|
|
#ifdef XP_WIN32
|
|
if (sysInfo.m_bWinNT && (GetContextType() != MetaFile) && !IsPrintContext()) {
|
|
HBITMAP hOldBitmap = (HBITMAP)::SelectObject(m_pImageDC, imageInfo->hBitmap);
|
|
// MaskBlt has two raster ops: one for the foreground pixels (value of 1)
|
|
// and one for the background pixels (value of 0). The raster op is
|
|
// specified using MAKEROP4(fore,back)
|
|
|
|
#ifdef USE_DIB_SECTION
|
|
if (image->bits)
|
|
::MaskBlt(hdc,
|
|
CASTINT(Rect.left),
|
|
CASTINT(Rect.top),
|
|
CASTINT(Rect.right - Rect.left),
|
|
CASTINT(Rect.bottom - Rect.top),
|
|
m_pImageDC, x_offset, y_offset,
|
|
maskInfo->hBitmap,
|
|
x_offset, y_offset,
|
|
MAKEROP4(SRCCOPY, 0x00AA0029)); // 0x00AA0029 is destination...
|
|
|
|
else
|
|
#endif
|
|
::MaskBlt(hdc,
|
|
CASTINT(Rect.left),
|
|
CASTINT(Rect.top),
|
|
CASTINT(Rect.right - Rect.left),
|
|
CASTINT(Rect.bottom - Rect.top),
|
|
m_pImageDC, x_offset, y_offset,
|
|
maskInfo->hBitmap,
|
|
x_offset, y_offset,
|
|
MAKEROP4(0x00AA0029, SRCCOPY)); // 0x00AA0029 is destination...
|
|
|
|
// Cleanup
|
|
::SelectObject(m_pImageDC, hOldBitmap);
|
|
}
|
|
else
|
|
#endif
|
|
StretchMaskBlt(hdc, imageInfo->hBitmap, maskInfo->hBitmap,
|
|
CASTINT(Rect.left),
|
|
CASTINT(Rect.top),
|
|
CASTINT(Rect.right - Rect.left),
|
|
CASTINT(Rect.bottom - Rect.top),
|
|
x_offset,
|
|
y_offset,
|
|
width,
|
|
height);
|
|
}
|
|
else {
|
|
_StretchDIBitsWithMask(hdc,
|
|
CASTINT(Rect.left),
|
|
CASTINT(Rect.top),
|
|
CASTINT(Rect.right - Rect.left),
|
|
CASTINT(Rect.bottom - Rect.top),
|
|
CASTINT(x_offset),
|
|
// the reason for this calculation is that Window's bitmap
|
|
// is reverse. The first scan line will be at the buttom of
|
|
// the bitmap buffer.
|
|
CASTINT(imageInfo->height - ((height ) + y_offset)),
|
|
CASTINT(width ),
|
|
CASTINT(height),
|
|
image,
|
|
mask);
|
|
}
|
|
}
|
|
else {
|
|
StretchPixmap(hdc, image,
|
|
CASTINT(Rect.left),
|
|
CASTINT(Rect.top),
|
|
CASTINT(Rect.right - Rect.left),
|
|
CASTINT(Rect.bottom - Rect.top),
|
|
x_offset,
|
|
y_offset,
|
|
width,
|
|
height);
|
|
|
|
}
|
|
}
|
|
ReleaseContextDC(hdc);
|
|
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
///////////////////
|
|
// Destination coordinates are in the logical units of pDC, and
|
|
// the source coordinates are in device units
|
|
void CDCCX::StretchPixmap(HDC hTargetDC, NI_Pixmap* pImage,
|
|
int32 dx, int32 dy, int32 dw, int32 dh,
|
|
int32 sx, int32 sy, int32 sw, int32 sh)
|
|
{
|
|
|
|
|
|
// Clamp the width and height if necessary
|
|
if (sx < 0 || sy < 0)
|
|
return;
|
|
FEBitmapInfo *imageInfo = (FEBitmapInfo*)pImage->client_data;
|
|
|
|
BITMAPINFO *pBmInfo = imageInfo->bmpInfo;
|
|
|
|
|
|
if (imageInfo->hBitmap) {
|
|
HBITMAP hOldBitmap;
|
|
|
|
// If we are using this image as a tile, the bitmap will already be selected
|
|
// into the memory DC for us.
|
|
if (!imageInfo->IsTile)
|
|
hOldBitmap = (HBITMAP)::SelectObject(m_pImageDC, imageInfo->hBitmap);
|
|
|
|
::StretchBlt(hTargetDC,
|
|
CASTINT(dx),
|
|
CASTINT(dy),
|
|
CASTINT(dw),
|
|
CASTINT(dh),
|
|
m_pImageDC,
|
|
CASTINT(sx),
|
|
CASTINT(sy),
|
|
CASTINT(sw),
|
|
CASTINT(sh),
|
|
pBmInfo->bmiHeader.biBitCount == 1 ? SRCAND : SRCCOPY);
|
|
|
|
// If we are using this image as a tile, the bitmap will be deselected for us.
|
|
if (!imageInfo->IsTile)
|
|
::SelectObject(m_pImageDC, hOldBitmap);
|
|
}
|
|
else {
|
|
|
|
// the reason for this calculation is because window's bmp is an
|
|
// upsidedown image. the bit in the pImage->bits does reflect
|
|
// this. So we need to sepcify the offset from the bottom up.
|
|
::StretchDIBits( hTargetDC,
|
|
CASTINT(dx),
|
|
CASTINT(dy),
|
|
CASTINT(dw),
|
|
CASTINT(dh),
|
|
CASTINT(sx),
|
|
CASTINT(imageInfo->height - (sh + sy)),
|
|
CASTINT(sw),
|
|
CASTINT(sh),
|
|
pImage->bits, // address of bitmap bits
|
|
imageInfo->bmpInfo, // address of bitmap data
|
|
CASTUINT(m_bUseDibPalColors ? DIB_PAL_COLORS : DIB_RGB_COLORS),
|
|
pBmInfo->bmiHeader.biBitCount == 1 ? SRCAND : SRCCOPY);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
HBITMAP CDCCX::CreateMask(HDC hTargetDC, NI_Pixmap* mask)
|
|
{
|
|
|
|
ASSERT(hTargetDC);
|
|
FEBitmapInfo *maskInfo = (FEBitmapInfo*)mask->client_data;
|
|
|
|
// Build a BITMAPINFO struct for mask
|
|
char cMask[sizeof(BITMAPINFOHEADER) + (2 * sizeof(RGBQUAD))];
|
|
LPBITMAPINFO pBmInfoMask = (LPBITMAPINFO)cMask;
|
|
|
|
memcpy(pBmInfoMask, maskInfo->bmpInfo, sizeof(BITMAPINFOHEADER));
|
|
pBmInfoMask->bmiHeader.biBitCount = 1;
|
|
pBmInfoMask->bmiHeader.biCompression = BI_RGB; // must NOT be BI_BITFIELDS
|
|
|
|
pBmInfoMask->bmiColors[1] = rgbqBlack; // background pixels
|
|
pBmInfoMask->bmiColors[0] = rgbqWhite; // foreground pixels
|
|
// Create the mask. It's important that we use the memory DC, because we
|
|
// want a momochrome bitmap
|
|
return ::CreateDIBitmap(hTargetDC,
|
|
(LPBITMAPINFOHEADER)pBmInfoMask,
|
|
CBM_INIT,
|
|
mask->bits,
|
|
pBmInfoMask,
|
|
// m_bUseDibPalColors ? DIB_PAL_COLORS : DIB_RGB_COLORS);
|
|
DIB_RGB_COLORS);
|
|
}
|
|
|
|
// StretchBlt a DIB with a mask
|
|
// Destination coordinates are in the logical units of pDC, and
|
|
// the source coordinates are in device units
|
|
void WFE_StretchDIBitsWithMask(HDC hTargetDC,
|
|
BOOL isDeviceDC,
|
|
HDC hOffscreenDC,
|
|
int dx,
|
|
int dy,
|
|
int dw,
|
|
int dh,
|
|
int sx,
|
|
int sy,
|
|
int sw,
|
|
int sh,
|
|
void XP_HUGE *imageBit,
|
|
BITMAPINFO* lpImageInfo,
|
|
void XP_HUGE *maskBit,
|
|
BOOL bUseDibPalColors,
|
|
COLORREF fillWithBackground
|
|
)
|
|
{
|
|
// Tile the shadow bitmap with the backdrop
|
|
HBITMAP pSaveBmp;
|
|
HBITMAP bmpShadow;
|
|
HDC hTempDC;
|
|
int32 targetX, targetY;
|
|
HDC memDC;
|
|
|
|
|
|
if (isDeviceDC) {
|
|
|
|
if (hOffscreenDC)
|
|
memDC = hOffscreenDC;
|
|
else {
|
|
memDC = ::CreateCompatibleDC(hTargetDC);
|
|
}
|
|
if (!(bmpShadow = (HBITMAP)CreateCompatibleBitmap(hTargetDC, dw, dh))) {
|
|
TRACE("_StretchBltWithMask() can't create bitmap!\n");
|
|
return;
|
|
}
|
|
pSaveBmp = (HBITMAP) ::SelectObject(memDC, bmpShadow);
|
|
if (!fillWithBackground) {
|
|
::StretchBlt(memDC, // get the screen bit.
|
|
CASTINT(0), CASTINT(0),
|
|
CASTINT(dw), CASTINT(dh),
|
|
hTargetDC,
|
|
CASTINT(dx), CASTINT(dy),
|
|
CASTINT(dw), CASTINT(dh),
|
|
SRCCOPY);
|
|
}
|
|
else { // the background is solid color.
|
|
HBRUSH hbr = ::CreateSolidBrush(fillWithBackground);
|
|
RECT tempRect;
|
|
tempRect.left = tempRect.top = 0;
|
|
tempRect.right = dw;
|
|
tempRect.bottom = dh;
|
|
::FillRect(memDC, &tempRect, hbr);
|
|
::DeleteObject(hbr);
|
|
}
|
|
hTempDC = memDC;
|
|
targetX = targetY = 0;
|
|
}
|
|
else {
|
|
hTempDC = hTargetDC;
|
|
targetX = dx;
|
|
targetY = dy;
|
|
}
|
|
|
|
char cMask[sizeof(BITMAPINFOHEADER) + (2 * sizeof(RGBQUAD))];
|
|
LPBITMAPINFO pBmInfoMask = (LPBITMAPINFO)cMask;
|
|
|
|
memcpy(pBmInfoMask, lpImageInfo, sizeof(BITMAPINFOHEADER));
|
|
pBmInfoMask->bmiHeader.biBitCount = 1;
|
|
pBmInfoMask->bmiHeader.biCompression = BI_RGB; // must NOT be BI_BITFIELDS
|
|
|
|
// Build a color table for monochrome mask. The image library sets foreground
|
|
// pixels to 1 and background pixels to 0. We want it the other way around
|
|
// when doing the AND operation
|
|
pBmInfoMask->bmiColors[0] = rgbqWhite; // background pixels
|
|
pBmInfoMask->bmiColors[1] = rgbqBlack; // foreground pixels
|
|
pBmInfoMask->bmiHeader.biSizeImage = 0;
|
|
int err = ::StretchDIBits(hTempDC,
|
|
CASTINT(targetX), CASTINT(targetY),
|
|
CASTINT(dw), CASTINT(dh),
|
|
CASTINT(sx), CASTINT(sy),
|
|
CASTINT(sw), CASTINT(sh),
|
|
maskBit,
|
|
pBmInfoMask,
|
|
DIB_RGB_COLORS,
|
|
SRCAND);
|
|
err = ::StretchDIBits(hTempDC,
|
|
CASTINT(targetX), CASTINT(targetY),
|
|
CASTINT(dw), CASTINT(dh),
|
|
CASTINT(sx), CASTINT(sy),
|
|
CASTINT(sw), CASTINT(sh),
|
|
imageBit,
|
|
lpImageInfo,
|
|
bUseDibPalColors ? DIB_PAL_COLORS : DIB_RGB_COLORS,
|
|
SRCPAINT);
|
|
if (isDeviceDC) {
|
|
|
|
::StretchBlt(hTargetDC,
|
|
CASTINT(dx), CASTINT(dy),
|
|
CASTINT(dw), CASTINT(dh),
|
|
memDC,
|
|
CASTINT(0), CASTINT(0),
|
|
CASTINT(dw),CASTINT(dh),
|
|
SRCCOPY);
|
|
|
|
::SelectObject(memDC, pSaveBmp);
|
|
VERIFY(::DeleteObject( bmpShadow));
|
|
if (!hOffscreenDC) { // Delete the temporary DC that we created.
|
|
::DeleteDC(memDC);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// StretchBlt a DIB with a mask
|
|
// Destination coordinates are in the logical units of pDC, and
|
|
// the source coordinates are in device units
|
|
void CDCCX::_StretchDIBitsWithMask(HDC hTargetDC,
|
|
int dx,
|
|
int dy,
|
|
int dw,
|
|
int dh,
|
|
int sx,
|
|
int sy,
|
|
int sw,
|
|
int sh,
|
|
NI_Pixmap *image,
|
|
NI_Pixmap *mask)
|
|
{
|
|
// Tile the shadow bitmap with the backdrop
|
|
FEBitmapInfo *imageInfo = (FEBitmapInfo*)image->client_data;
|
|
FEBitmapInfo *maskInfo = (FEBitmapInfo*)mask->client_data;
|
|
WFE_StretchDIBitsWithMask(hTargetDC, IsDeviceDC(), m_pImageDC,
|
|
dx, dy, dw, dh,
|
|
sx, sy, sw, sh,
|
|
image->bits,
|
|
imageInfo->bmpInfo,
|
|
mask->bits,
|
|
m_bUseDibPalColors);
|
|
}
|
|
|
|
|
|
void CDCCX::StretchMaskBlt(HDC hTargetDC, HBITMAP theBitmap, HBITMAP theMask,
|
|
int32 dx, int32 dy, int32 dw, int32 dh,
|
|
int32 sx, int32 sy, int32 sw, int32 sh)
|
|
{
|
|
// Tile the shadow bitmap with the backdrop
|
|
HDC memDC = NULL;
|
|
HBITMAP pSaveBmp;
|
|
HBITMAP bmpShadow;
|
|
HPALETTE hOldPal1 = NULL;
|
|
int32 targetX, targetY;
|
|
|
|
if (IsDeviceDC()) {
|
|
|
|
|
|
if (!(bmpShadow = (HBITMAP)CreateCompatibleBitmap(hTargetDC, CASTINT(dw), CASTINT(dh)))) {
|
|
TRACE("_StretchBltWithMask() can't create bitmap!\n");
|
|
return;
|
|
}
|
|
// Create memory DC
|
|
if (!(memDC=CreateCompatibleDC(hTargetDC))) {
|
|
TRACE("_StretchBltWithMask() can't create compatible memory DC!\n");
|
|
return;
|
|
}
|
|
if (m_bUseDibPalColors && m_pPal) {
|
|
hOldPal1 = (HPALETTE)::SelectPalette(memDC, m_pPal, FALSE);
|
|
}
|
|
|
|
pSaveBmp = (HBITMAP) ::SelectObject(memDC, bmpShadow);
|
|
::StretchBlt(memDC,
|
|
CASTINT(0), CASTINT(0),
|
|
CASTINT(dw), CASTINT(dh),
|
|
hTargetDC,
|
|
CASTINT(dx), CASTINT(dy),
|
|
CASTINT(dw), CASTINT(dh),
|
|
SRCCOPY);
|
|
targetX = targetY = 0;
|
|
}
|
|
else {
|
|
memDC = hTargetDC;
|
|
targetX = dx;
|
|
targetY = dy;
|
|
}
|
|
HBITMAP old = (HBITMAP)::SelectObject(m_pImageDC, theMask);
|
|
::StretchBlt(memDC,
|
|
CASTINT(targetX), CASTINT(targetY),
|
|
CASTINT(dw), CASTINT(dh),
|
|
m_pImageDC,
|
|
CASTINT(sx), CASTINT(sy),
|
|
CASTINT(sw), CASTINT(sh),
|
|
SRCAND);
|
|
|
|
// load the bitmap into the cached image CDC
|
|
::SelectObject(m_pImageDC, theBitmap);
|
|
|
|
::StretchBlt(memDC,
|
|
CASTINT(targetX), CASTINT(targetY),
|
|
CASTINT(dw), CASTINT(dh),
|
|
m_pImageDC,
|
|
CASTINT(sx), CASTINT(sy),
|
|
CASTINT(sw), CASTINT(sh),
|
|
SRCPAINT);
|
|
|
|
if (IsDeviceDC()) {
|
|
::StretchBlt(hTargetDC,
|
|
CASTINT(dx), CASTINT(dy),
|
|
CASTINT(dw), CASTINT(dh),
|
|
memDC,
|
|
CASTINT(0), CASTINT(0),
|
|
CASTINT(dw),CASTINT(dh),
|
|
SRCCOPY);
|
|
::SelectObject(memDC, pSaveBmp);
|
|
if (m_bUseDibPalColors && hOldPal1) {
|
|
::SelectPalette(memDC, hOldPal1, FALSE);
|
|
}
|
|
VERIFY(::DeleteDC(memDC));
|
|
VERIFY(::DeleteObject( bmpShadow));
|
|
}
|
|
::SelectObject(m_pImageDC, old);
|
|
|
|
}
|
|
|
|
// We need to allocate the space for the image decoding ourselves because it
|
|
// depends on what size machine we are on how we want to do it
|
|
BITMAPINFO *CDCCX::NewPixmap(NI_Pixmap *pImage, BOOL mask)
|
|
{
|
|
if(mask == FALSE) {
|
|
replaceColorSpace(
|
|
pImage,
|
|
/*this->*/curColorSpace,
|
|
/*this->*/m_iBitsPerPixel);
|
|
}
|
|
|
|
NI_PixmapHeader& header = pImage->header;
|
|
NI_ColorSpace *& color_space = header.color_space;
|
|
uint8& pixmap_depth = color_space->pixmap_depth;
|
|
|
|
if(pImage->bits == NULL) {
|
|
header.widthBytes = header.width;
|
|
header.widthBytes *= pixmap_depth;
|
|
if(pixmap_depth < 8) {
|
|
header.widthBytes += 7;
|
|
}
|
|
header.widthBytes /= 8;
|
|
|
|
// Make sure image width is 4byte aligned
|
|
int iAlign = CASTINT(header.widthBytes % 4);
|
|
if(iAlign) {
|
|
header.widthBytes += 4;
|
|
header.widthBytes -= iAlign;
|
|
}
|
|
//#ifndef XP_WIN32
|
|
#ifndef USE_DIB_SECTION
|
|
// The image buffer might need to be really big (i.e. over 32K)
|
|
// We need to use a huge memory allocation on the 16-bit version
|
|
pImage->bits = HugeAlloc(header.widthBytes * header.height, 1);
|
|
// Note: It's possible that the image is so huge that we can't allocate enough
|
|
// memory for it, especially under Win16 (e.g. 18 Mb images)
|
|
if(pImage->bits == NULL) {
|
|
return(NULL);
|
|
}
|
|
return(FillBitmapInfoHeader(pImage));
|
|
#else // for use with createDibSection.
|
|
BITMAPINFO* pbmInfo = FillBitmapInfoHeader(pImage);
|
|
FEBitmapInfo *imageInfo;
|
|
imageInfo = (FEBitmapInfo*) pImage->client_data;
|
|
HDC hdc = GetContextDC();
|
|
imageInfo->hBitmap = CreateDIBSection(hdc,
|
|
pbmInfo, // pointer to structure containing bitmap size, format, and color data
|
|
m_bUseDibPalColors ? DIB_PAL_COLORS : DIB_RGB_COLORS,
|
|
&pImage->bits, // pointer to variable to receive a pointer to the bitmap's bit values
|
|
NULL, // optional handle to a file mapping object
|
|
NULL // offset to the bitmap bit values within the file mapping object
|
|
);
|
|
ReleaseContextDC(hdc);
|
|
#ifdef DEBUG
|
|
// If this assert fires, please be sure to report the following
|
|
// information: pixmap_depth, header.widthBytes, header.height
|
|
// and the current display setting - kevina.
|
|
XP_ASSERT(pImage->bits);
|
|
|
|
if (pImage->bits) {
|
|
// Check whether the pointer is currently valid.
|
|
XP_ASSERT(!IsBadWritePtr((void *)pImage->bits,
|
|
(uint)(header.widthBytes*header.height)));
|
|
XP_ASSERT(!IsBadReadPtr((void *)pImage->bits,
|
|
(uint)(header.widthBytes*header.height)));
|
|
|
|
// For testing. Purify sometimes gets confused and complains that
|
|
// the shared memory pointer returned by CreateDIBSection is
|
|
// invalid, even though the previous assertions don't fire. If
|
|
// this happens, expect Purify to complain whenever the ImageLib
|
|
// accesses the bits pointer.
|
|
// memset(pImage->bits, ~0, (header.widthBytes * header.height));
|
|
memset(pImage->bits, ~0, 1);
|
|
}
|
|
#endif // DEBUG
|
|
|
|
if (!imageInfo->hBitmap) {
|
|
return FALSE;
|
|
}
|
|
else
|
|
return pbmInfo;
|
|
#endif
|
|
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
|
|
// Create a larger tile from a smaller one. The dimensions of the larger
|
|
// tile must be a multiple of the dimensions of the smaller tile.
|
|
static HBITMAP CreateLargerTile(HDC pDC, HDC pMemDCNew, HDC pMemDCOld,
|
|
NI_Pixmap *pImage, BOOL bUseDibPalColors,
|
|
int iOldWidth, int iOldHeight,
|
|
int iNewWidth, int iNewHeight)
|
|
{
|
|
int x, y;
|
|
HBITMAP pNewTile;
|
|
HGDIOBJ pSavedObj1, pSavedObj2;
|
|
FEBitmapInfo *imageInfo = (FEBitmapInfo *)pImage->client_data;
|
|
|
|
pNewTile = CreateCompatibleBitmap(pDC, iNewWidth, iNewHeight);
|
|
if (!pNewTile)
|
|
return NULL;
|
|
pSavedObj1 = (HGDIOBJ)::SelectObject(pMemDCNew, pNewTile);
|
|
if (imageInfo->hBitmap) {
|
|
pSavedObj2 = (HGDIOBJ)::SelectObject(pMemDCOld, imageInfo->hBitmap);
|
|
::BitBlt(pMemDCNew, 0, 0, iOldWidth, iOldHeight, pMemDCOld, 0, 0, SRCCOPY);
|
|
}
|
|
else {
|
|
uint iUsage = bUseDibPalColors ? DIB_PAL_COLORS : DIB_RGB_COLORS;
|
|
|
|
::StretchDIBits(pMemDCNew, 0, 0, iOldWidth, iOldHeight, 0, 0, iOldWidth, iOldHeight,
|
|
pImage->bits, imageInfo->bmpInfo, iUsage, SRCCOPY);
|
|
}
|
|
// Fill up the new tile exponentially for speed.
|
|
for (x = iOldWidth; x < iNewWidth; x *= 2) {
|
|
::BitBlt(pMemDCNew, x, 0, MIN(x,iNewWidth-x), iOldHeight, pMemDCNew, 0, 0, SRCCOPY);
|
|
}
|
|
for (y = iOldHeight; y < iNewHeight; y *= 2) {
|
|
::BitBlt(pMemDCNew, 0, y, iNewWidth, MIN(y,iNewHeight-y), pMemDCNew, 0, 0, SRCCOPY);
|
|
}
|
|
::SelectObject(pMemDCNew, pSavedObj1);
|
|
if (imageInfo->hBitmap)
|
|
::SelectObject(pMemDCOld, pSavedObj2);
|
|
|
|
return pNewTile;
|
|
}
|
|
#ifdef DDRAW
|
|
/*
|
|
* DDColorMatch
|
|
*
|
|
* convert a RGB color to a pysical color.
|
|
*
|
|
* we do this by leting GDI SetPixel() do the color matching
|
|
* then we lock the memory and see what it got mapped to.
|
|
*/
|
|
static DWORD DDColorMatch(IDirectDrawSurface *pdds, COLORREF rgb)
|
|
{
|
|
COLORREF rgbT;
|
|
HDC hdc;
|
|
DWORD dw = CLR_INVALID;
|
|
DDSURFACEDESC ddsd;
|
|
HRESULT hres;
|
|
|
|
//
|
|
// use GDI SetPixel to color match for us
|
|
//
|
|
if (rgb != CLR_INVALID && pdds->GetDC(&hdc) == DD_OK)
|
|
{
|
|
rgbT = GetPixel(hdc, 0, 0); // save current pixel value
|
|
SetPixel(hdc, 0, 0, rgb); // set our value
|
|
pdds->ReleaseDC(hdc);
|
|
}
|
|
|
|
//
|
|
// now lock the surface so we can read back the converted color
|
|
//
|
|
ddsd.dwSize = sizeof(ddsd);
|
|
while ((hres = pdds->Lock(NULL, &ddsd, 0, NULL)) == DDERR_WASSTILLDRAWING)
|
|
;
|
|
|
|
if (hres == DD_OK)
|
|
{
|
|
dw = *(DWORD *)ddsd.lpSurface; // get DWORD
|
|
dw &= (1 << ddsd.ddpfPixelFormat.dwRGBBitCount)-1; // mask it to bpp
|
|
pdds->Unlock(NULL);
|
|
}
|
|
|
|
//
|
|
// now put the color that was there back.
|
|
//
|
|
if (rgb != CLR_INVALID && pdds->GetDC(&hdc) == DD_OK)
|
|
{
|
|
SetPixel(hdc, 0, 0, rgbT);
|
|
pdds->ReleaseDC(hdc);
|
|
}
|
|
|
|
return dw;
|
|
}
|
|
// MWH this funtion only work when there is directDraw support. It use the transColor for
|
|
// transparent blt. if releaseTempSurf == FALSE. It is caller's responsibility to release
|
|
// the surf.
|
|
BOOL CDCCX::TransparentBlt(int dx,
|
|
int dy,
|
|
int dw,
|
|
int dh,
|
|
int sx,
|
|
int sy,
|
|
int sw,
|
|
int sh,
|
|
NI_Pixmap *image,
|
|
COLORREF transColor,
|
|
LPDIRECTDRAWSURFACE surf)
|
|
{
|
|
if (!GetPrimarySurface()) return FALSE;
|
|
LPDDSURFACEDESC ddesc = GetSurfDesc();
|
|
|
|
RECT rect;
|
|
HRESULT err = 1;
|
|
rect.left = rect.top = 0;
|
|
rect.bottom = dy + dh;
|
|
rect.right = dx + dw;
|
|
BOOL needRelease = TRUE;
|
|
LPDIRECTDRAWSURFACE tempsurf;
|
|
if (!surf) {
|
|
tempsurf = CreateOffscreenSurface(rect);
|
|
}
|
|
else {
|
|
tempsurf = surf;
|
|
needRelease = FALSE;
|
|
}
|
|
HDC tempDC;
|
|
FEBitmapInfo *imageInfo;
|
|
imageInfo = (FEBitmapInfo*) image->client_data;
|
|
if (tempsurf) {
|
|
tempsurf->GetDC(&tempDC);
|
|
::StretchDIBits(tempDC,
|
|
CASTINT(dx), CASTINT(dy),
|
|
CASTINT(dw), CASTINT(dh),
|
|
CASTINT(sx), CASTINT(sy),
|
|
CASTINT(sw), CASTINT(sh),
|
|
image->bits,
|
|
imageInfo->bmpInfo,
|
|
DIB_RGB_COLORS,
|
|
SRCCOPY);
|
|
ReleaseOffscreenSurfDC();
|
|
|
|
rect.left = dx;
|
|
rect.top = dy;
|
|
tempsurf->ReleaseDC(tempDC);
|
|
DDCOLORKEY colorKey;
|
|
if (ddesc->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) { //palette device
|
|
colorKey.dwColorSpaceLowValue = ::GetNearestPaletteIndex(GetPalette(), transColor);
|
|
colorKey.dwColorSpaceHighValue = ::GetNearestPaletteIndex(GetPalette(), transColor);
|
|
}
|
|
else {
|
|
colorKey.dwColorSpaceLowValue = DDColorMatch(tempsurf, transColor);
|
|
colorKey.dwColorSpaceHighValue = DDColorMatch(tempsurf, transColor);
|
|
}
|
|
tempsurf->SetColorKey(DDCKEY_SRCBLT, &colorKey);
|
|
err = GetBackSurface()->Blt(&rect, tempsurf, &rect, DDBLT_KEYSRC , NULL);
|
|
if (err == DDERR_SURFACELOST) {
|
|
RestoreAllDrawSurface();
|
|
err = GetBackSurface()->Blt(&rect, tempsurf, &rect, DDBLT_KEYSRC , NULL);
|
|
}
|
|
if (needRelease) {
|
|
tempsurf->Release();
|
|
}
|
|
LockOffscreenSurfDC();
|
|
}
|
|
if (err != 0) return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
#endif
|
|
|
|
#define ROUNDUP(_x,_toMultipleOf) (((_x)+(_toMultipleOf)-1)/(_toMultipleOf)*(_toMultipleOf))
|
|
|
|
void CDCCX::TileImage(HDC hdc, LTRB& Rect, NI_Pixmap* image, NI_Pixmap* mask, int32 x, int32 y)
|
|
{
|
|
int iMinTileWidth, iMinTileHeight, iTileWidth, iTileHeight;
|
|
int iRectWidth, iRectHeight, iOrigWidth, iOrigHeight;
|
|
HBITMAP pTmpImageBitmap = NULL, pTmpMaskBitmap = NULL, pSavedImageBitmap, pSavedMaskBitmap;
|
|
HGDIOBJ pOldObj;
|
|
FEBitmapInfo *imageInfo;
|
|
FEBitmapInfo *maskInfo;
|
|
imageInfo = (FEBitmapInfo*) image->client_data;
|
|
int32 lDrawingOrgX, lDrawingOrgY;
|
|
GetDrawingOrigin(&lDrawingOrgX, &lDrawingOrgY);
|
|
|
|
// If we a backdrop image has been explicitly specified and
|
|
// it is transparent, then don't use the NT brush feature,
|
|
// since it doesn't support masks.
|
|
if ((!mask) && (imageInfo->hBitmap) && (CanCreateBrush(imageInfo->hBitmap, m_iBitsPerPixel))) {
|
|
CPoint brushOrg(CASTINT(lDrawingOrgX - m_lOrgX), CASTINT(lDrawingOrgY - m_lOrgY));
|
|
HBRUSH hBrush = CreatePatternBrush(imageInfo->hBitmap);
|
|
ASSERT(hBrush);
|
|
|
|
// We need to align the brush properly. The values to SetBrushOrg() specifiy
|
|
// where the brush origin (i.e. the point (0, 0) of the brush) will be mapped.
|
|
// The coordinates must be in device units
|
|
::LPtoDP(hdc, &brushOrg, 1);
|
|
brushOrg.x %= (imageInfo->width * GetXConvertUnit());
|
|
brushOrg.y %= (imageInfo->height * GetYConvertUnit());
|
|
POINT tempPoint;
|
|
#ifdef _WIN32
|
|
::SetBrushOrgEx(hdc,brushOrg.x, brushOrg.y, &tempPoint);
|
|
#else
|
|
::SetBrushOrg( hdc, brushOrg.x, brushOrg.y );
|
|
#endif
|
|
// Erase the background
|
|
::FillRect(hdc, (RECT*)&Rect, hBrush);
|
|
VERIFY(::DeleteObject(hBrush));
|
|
|
|
#ifdef _WIN32
|
|
// Restore the brush origin
|
|
::SetBrushOrgEx(hdc, tempPoint.x, tempPoint.y, NULL);
|
|
#endif
|
|
ReleaseContextDC(hdc);
|
|
return;
|
|
}
|
|
|
|
if (mask) {
|
|
maskInfo = (FEBitmapInfo*) mask->client_data;
|
|
}
|
|
|
|
// If the width (or height) of the image is less than the smaller of
|
|
// 32 and half the width (or height) of the area to be tiled, then tile the
|
|
// image into a larger temporary bitmap and use the temporary bitmap
|
|
// as the tile. We also limit the actual area of the temporary tile to 4096.
|
|
iOrigWidth = imageInfo->width * GetXConvertUnit();
|
|
iOrigHeight = imageInfo->height *GetYConvertUnit();
|
|
iRectWidth = Rect.right - Rect.left;
|
|
iRectHeight = Rect.bottom - Rect.top;
|
|
iMinTileWidth = MIN(32,MAX(iRectWidth/2,1)); // Tile must be at least this wide.
|
|
iMinTileHeight = MIN(32,MAX(iRectHeight/2,1)); // Tile must be at least this high.
|
|
iTileWidth = ROUNDUP(iMinTileWidth, iOrigWidth); // Actual width of temporary tile.
|
|
iTileHeight = ROUNDUP(iMinTileHeight, iOrigHeight); // Actual height of temporary tile.
|
|
|
|
if ((iOrigWidth < iMinTileWidth || iOrigHeight < iMinTileHeight) &&
|
|
(iTileWidth * iTileHeight < 4096)) {
|
|
HDC pTmpDC = NULL;
|
|
|
|
// Create a temporary larger tile and use it instead of the original tile.
|
|
HDC hhDC = GetContextDC();
|
|
pTmpDC = CreateCompatibleDC(hhDC);
|
|
ReleaseContextDC(hhDC);
|
|
if (!pTmpDC)
|
|
return;
|
|
HPALETTE hOldPal;
|
|
if (m_bUseDibPalColors)
|
|
hOldPal = ::SelectPalette(pTmpDC, GetPalette(), FALSE);
|
|
pTmpImageBitmap = CreateLargerTile(hhDC, pTmpDC, m_pImageDC,
|
|
image, m_bUseDibPalColors,
|
|
iOrigWidth, iOrigHeight,
|
|
iTileWidth, iTileHeight);
|
|
if (!pTmpImageBitmap) { // OOM
|
|
if (m_bUseDibPalColors)
|
|
::SelectPalette(pTmpDC, hOldPal, FALSE);
|
|
VERIFY(::DeleteDC(pTmpDC));
|
|
return;
|
|
}
|
|
if (mask) {
|
|
pTmpMaskBitmap = CreateLargerTile(hhDC, pTmpDC, m_pImageDC,
|
|
mask, m_bUseDibPalColors,
|
|
iOrigWidth, iOrigHeight,
|
|
iTileWidth, iTileHeight);
|
|
if (!pTmpMaskBitmap) { // OOM
|
|
if (m_bUseDibPalColors)
|
|
::SelectPalette(pTmpDC, hOldPal, FALSE);
|
|
VERIFY(::DeleteDC(pTmpDC));
|
|
VERIFY(::DeleteObject(pTmpImageBitmap));
|
|
return;
|
|
}
|
|
}
|
|
pSavedImageBitmap = imageInfo->hBitmap;
|
|
imageInfo->hBitmap = pTmpImageBitmap;
|
|
imageInfo->width = iTileWidth;
|
|
imageInfo->height = iTileHeight;
|
|
if (mask) {
|
|
pSavedMaskBitmap = maskInfo->hBitmap;
|
|
maskInfo->hBitmap = pTmpMaskBitmap;
|
|
maskInfo->width = iTileWidth;
|
|
maskInfo->height = iTileHeight;
|
|
}
|
|
|
|
if (m_bUseDibPalColors)
|
|
::SelectPalette(pTmpDC, hOldPal, FALSE);
|
|
VERIFY(::DeleteDC(pTmpDC));
|
|
}
|
|
|
|
// Set a flag to indicate that we are in the tiling code.
|
|
imageInfo->IsTile = TRUE;
|
|
if (mask)
|
|
maskInfo->IsTile = TRUE;
|
|
|
|
// If we are going to call StretchPixmap, avoid selecting the image bitmap
|
|
// into the memory DC each time.
|
|
if (!mask && imageInfo->hBitmap)
|
|
pOldObj = ::SelectObject(m_pImageDC, imageInfo->hBitmap);
|
|
// We need to properly align the backdrop vertically (in logical units)
|
|
int srcY = CASTINT((((Rect.top - GetTopMargin())/ GetYConvertUnit()) - lDrawingOrgY + m_lOrgY ) % (imageInfo->height));
|
|
int dstHeight = CASTINT((imageInfo->height* GetYConvertUnit()) - (srcY * GetYConvertUnit()));
|
|
|
|
// MWH -- this loop needs a rewrite. I just do this for first pass on win16 compiler.
|
|
// Should not check for the which Blt we want to use inside the loop.
|
|
// Redraw the backdrop from left to right and top to bottom
|
|
for (int currentY = CASTINT(Rect.top); currentY < CASTINT(Rect.bottom);) {
|
|
// We need to properly align the backdrop horizontally (in logical units)
|
|
int srcX = CASTINT((((Rect.left - GetLeftMargin()) / GetXConvertUnit()) - lDrawingOrgX + m_lOrgX)% (imageInfo->width));
|
|
int dstWidth = CASTINT((imageInfo->width * GetXConvertUnit()) - srcX * GetXConvertUnit());
|
|
|
|
// Only draw as far down as we've been asked to draw
|
|
if (CASTINT(currentY + dstHeight) > CASTINT(Rect.bottom))
|
|
dstHeight = CASTINT(Rect.bottom - currentY);
|
|
|
|
|
|
// Loop across the row
|
|
for (int currentX = CASTINT(Rect.left); currentX < CASTINT(Rect.right);) {
|
|
// Only draw as far across as we've been asked to draw
|
|
if (currentX + dstWidth > Rect.right)
|
|
dstWidth = CASTINT(Rect.right - currentX);
|
|
|
|
// m_pImageDC is in device space, so we need to convert coordinates
|
|
RECT srcRect;
|
|
::SetRect(&srcRect, srcX, srcY, srcX + (dstWidth/ GetXConvertUnit()), srcY + (dstHeight/ GetYConvertUnit()));
|
|
if (mask) {
|
|
if (imageInfo->hBitmap && maskInfo->hBitmap) {
|
|
#ifdef _WIN32
|
|
if (sysInfo.m_bWinNT && (GetContextType() != MetaFile)) {
|
|
HBITMAP hOldBitmap = (HBITMAP)::SelectObject(m_pImageDC, imageInfo->hBitmap);
|
|
#ifdef USE_DIB_SECTION
|
|
if (image->bits)
|
|
MaskBlt(hdc,
|
|
currentX, currentY,
|
|
dstWidth,
|
|
dstHeight,
|
|
m_pImageDC, srcRect.left, srcRect.top,
|
|
maskInfo->hBitmap,
|
|
srcRect.left, srcRect.top,
|
|
MAKEROP4(SRCCOPY, 0x00AA0029)); // 0x00AA0029 is destination...
|
|
else
|
|
#endif
|
|
MaskBlt(hdc,
|
|
currentX, currentY,
|
|
dstWidth,
|
|
dstHeight,
|
|
m_pImageDC, srcRect.left, srcRect.top,
|
|
maskInfo->hBitmap,
|
|
srcRect.left, srcRect.top,
|
|
MAKEROP4(0x00AA0029, SRCCOPY)); // 0x00AA0029 is destination...
|
|
::SelectObject(m_pImageDC, hOldBitmap);
|
|
}
|
|
else
|
|
#endif
|
|
StretchMaskBlt(hdc,
|
|
imageInfo->hBitmap, maskInfo->hBitmap,
|
|
currentX, currentY,
|
|
dstWidth,
|
|
dstHeight,
|
|
srcRect.left, srcRect.top,
|
|
srcRect.right - srcRect.left,
|
|
srcRect.bottom - srcRect.top);
|
|
}
|
|
else { // blt bitmap with mask.
|
|
_StretchDIBitsWithMask(hdc,
|
|
currentX, currentY,
|
|
dstWidth,
|
|
dstHeight,
|
|
srcRect.left,
|
|
// the reason for this calculation is that Window's bitmap
|
|
// is reverse. The first scan line will be at the bottom of
|
|
// the bitmap buffer.
|
|
imageInfo->height - srcRect.bottom,
|
|
srcRect.right - srcRect.left,
|
|
srcRect.bottom - srcRect.top,
|
|
image,
|
|
mask);
|
|
}
|
|
|
|
}
|
|
else {
|
|
StretchPixmap(hdc, image,
|
|
currentX, currentY,
|
|
dstWidth,
|
|
dstHeight,
|
|
srcRect.left, srcRect.top,
|
|
srcRect.right - srcRect.left,
|
|
srcRect.bottom - srcRect.top);
|
|
|
|
}
|
|
|
|
currentX += dstWidth;
|
|
srcX = 0;
|
|
dstWidth = imageInfo->width * GetXConvertUnit();
|
|
}
|
|
|
|
currentY += dstHeight;
|
|
srcY = 0;
|
|
dstHeight = imageInfo->height * GetYConvertUnit();
|
|
}
|
|
// If we called StretchPixmap, restore the memory DC to its previous state.
|
|
if (!mask && imageInfo->hBitmap)
|
|
::SelectObject(m_pImageDC, pOldObj);
|
|
|
|
// If we created a temporary tile, then restore the original bitmaps.
|
|
if (pTmpImageBitmap) {
|
|
imageInfo->width = iOrigWidth;
|
|
imageInfo->height = iOrigHeight;
|
|
imageInfo->hBitmap = pSavedImageBitmap;
|
|
VERIFY(::DeleteObject(pTmpImageBitmap));
|
|
}
|
|
if (pTmpMaskBitmap) {
|
|
maskInfo->width = iOrigWidth;
|
|
maskInfo->height = iOrigHeight;
|
|
maskInfo->hBitmap = pSavedMaskBitmap;
|
|
VERIFY(::DeleteObject(pTmpMaskBitmap));
|
|
}
|
|
|
|
// Reset the flags to indicate that we are done tiling.
|
|
imageInfo->IsTile = FALSE;
|
|
if (mask)
|
|
maskInfo->IsTile = FALSE;
|
|
}
|
|
|
|
|