HBITMAP create_hbitmap_from_gdiplus_bitmap(Gdiplus::Bitmap * bitmap_ptr)
{
BITMAP bm;
Gdiplus::Rect rect;
Gdiplus::BitmapData bmpdata;
HBITMAP hBitmap;
rect.X = rect.Y = 0;
rect.Width = bitmap_ptr->GetWidth();
rect.Height = bitmap_ptr->GetHeight();
if (bitmap_ptr->LockBits(&rect, Gdiplus::ImageLockModeRead, PixelFormat32bppPARGB, &bmpdata) != Gdiplus::Ok)
{
// Error
return NULL;
}
bm.bmType = 0;
bm.bmWidth = bmpdata.Width;
bm.bmHeight = bmpdata.Height;
bm.bmWidthBytes = bmpdata.Stride;
bm.bmPlanes = 1;
bm.bmBitsPixel = 32;
bm.bmBits = bmpdata.Scan0;
hBitmap = CreateBitmapIndirect(&bm);
bitmap_ptr->UnlockBits(&bmpdata);
return hBitmap;
}
void CAtmoGradients::SetActiveZone(int zone)
{
if(!m_ZoneRadios || (zone<0)) return;
CAtmoZoneDefinition *azone = m_pConfig->getZoneDefinition( zone );
if(!azone) return;
m_active_zone = zone;
int *destWeight = new int[CAP_WIDTH * CAP_HEIGHT];
azone->UpdateWeighting(destWeight, m_pConfig->getLiveView_WidescreenMode(), m_edge_weight);
BITMAP bmp;
int byte = (CAP_WIDTH * 4);
if(byte & 1)
byte++;
unsigned char *pixel_buffer = new unsigned char[byte * CAP_HEIGHT];
unsigned char *tmp = pixel_buffer;
for(int y = 0; y < CAP_HEIGHT; y++)
{
tmp = pixel_buffer + y * byte;
for(int x = 0; x < CAP_WIDTH; x++)
{
*tmp = 0; tmp++; // R
*tmp = (unsigned char)destWeight[y * CAP_WIDTH + x]; tmp++; // G
*tmp = 0; tmp++; // B
*tmp = 0; tmp++; // A
}
}
bmp.bmType = 0;
bmp.bmBitsPixel = 32;
bmp.bmHeight = CAP_HEIGHT;
bmp.bmWidth = CAP_WIDTH;
bmp.bmWidthBytes = byte;
bmp.bmPlanes = 1;
bmp.bmBits = pixel_buffer;
if(m_current_gradient)
{
DeleteObject( m_current_gradient );
m_current_gradient = 0;
}
m_current_gradient = CreateBitmapIndirect(&bmp);
DWORD error = GetLastError();
delete []destWeight;
delete []pixel_buffer;
}
HBITMAP StretchBitmap (HBITMAP hBitmap1)
{
BITMAP bm1, bm2 ;
HBITMAP hBitmap2 ;
HDC hdc, hdcMem1, hdcMem2 ;
int cxChar, cyChar ;
// Get the width and height of a system font character
cxChar = LOWORD (GetDialogBaseUnits ()) ;
cyChar = HIWORD (GetDialogBaseUnits ()) ;
// Create 2 memory DCs compatible with the display
hdc = CreateIC (TEXT ("DISPLAY"), NULL, NULL, NULL) ;
hdcMem1 = CreateCompatibleDC (hdc) ;
hdcMem2 = CreateCompatibleDC (hdc) ;
DeleteDC (hdc) ;
// Get the dimensions of the bitmap to be stretched
GetObject (hBitmap1, sizeof (BITMAP), (PTSTR) &bm1) ;
// Scale these dimensions based on the system font size
bm2 = bm1 ;
bm2.bmWidth = (cxChar * bm2.bmWidth) / 4 ;
bm2.bmHeight = (cyChar * bm2.bmHeight) / 8 ;
bm2.bmWidthBytes = ((bm2.bmWidth + 15) / 16) * 2 ;
// Create a new bitmap of larger size
hBitmap2 = CreateBitmapIndirect (&bm2) ;
// Select the bitmaps in the memory DCs and do a StretchBlt
SelectObject (hdcMem1, hBitmap1) ;
SelectObject (hdcMem2, hBitmap2) ;
StretchBlt (hdcMem2, 0, 0, bm2.bmWidth, bm2.bmHeight,
hdcMem1, 0, 0, bm1.bmWidth, bm1.bmHeight, SRCCOPY) ;
// Clean up
DeleteDC (hdcMem1) ;
DeleteDC (hdcMem2) ;
DeleteObject (hBitmap1) ;
return hBitmap2 ;
}
/******************************************************************************
* CreateBitmap [GDI32.@]
*
* Creates a bitmap with the specified info.
*
* PARAMS
* width [I] bitmap width
* height [I] bitmap height
* planes [I] Number of color planes
* bpp [I] Number of bits to identify a color
* bits [I] Pointer to array containing color data
*
* RETURNS
* Success: Handle to bitmap
* Failure: 0
*/
HBITMAP WINAPI CreateBitmap( INT width, INT height, UINT planes,
UINT bpp, LPCVOID bits )
{
BITMAP bm;
bm.bmType = 0;
bm.bmWidth = width;
bm.bmHeight = height;
bm.bmWidthBytes = get_bitmap_stride( width, bpp );
bm.bmPlanes = planes;
bm.bmBitsPixel = bpp;
bm.bmBits = (LPVOID)bits;
return CreateBitmapIndirect( &bm );
}
LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static BITMAP bitmap = { 0, 8, 8, 2, 1, 1 } ;
static BYTE bits [8][2] = { 0xFF, 0, 0x0C, 0, 0x0C, 0, 0x0C, 0,
0xFF, 0, 0xC0, 0, 0xC0, 0, 0xC0, 0 } ;
static HBITMAP hBitmap ;
static int cxClient, cyClient, cxSource, cySource ;
HDC hdc, hdcMem ;
int x, y ;
PAINTSTRUCT ps ;
switch (message)
{
case WM_CREATE:
bitmap.bmBits = bits ;
hBitmap = CreateBitmapIndirect (&bitmap) ;
cxSource = bitmap.bmWidth ;
cySource = bitmap.bmHeight ;
return 0 ;
case WM_SIZE:
cxClient = LOWORD (lParam) ;
cyClient = HIWORD (lParam) ;
return 0 ;
case WM_PAINT:
hdc = BeginPaint (hwnd, &ps) ;
hdcMem = CreateCompatibleDC (hdc) ;
SelectObject (hdcMem, hBitmap) ;
for (y = 0 ; y < cyClient ; y += cySource)
for (x = 0 ; x < cxClient ; x += cxSource)
{
BitBlt (hdc, x, y, cxSource, cySource, hdcMem, 0, 0, SRCCOPY) ;
}
DeleteDC (hdcMem) ;
EndPaint (hwnd, &ps) ;
return 0 ;
case WM_DESTROY:
DeleteObject (hBitmap) ;
PostQuitMessage (0) ;
return 0 ;
}
return DefWindowProc (hwnd, message, wParam, lParam) ;
}
// helper function - creates a bitmap of the specified width and height
HBITMAP CreateScreenCompatibleBitmap( INT32 width, INT32 height)
{
HDC hProbeDC = ::CreateCompatibleDC(NULL); // device context used to probe the current screen mode
ERROR3IF(hProbeDC == NULL, "Couldn't create probe DC");
const BITMAP bitmapData =
{
0,
width,
height,
width * GetDeviceCaps(hProbeDC, BITSPIXEL) * GetDeviceCaps(hProbeDC, PLANES) / 8 ,
GetDeviceCaps(hProbeDC, PLANES),
GetDeviceCaps(hProbeDC, BITSPIXEL),
0L
};
DeleteDC(hProbeDC);
return CreateBitmapIndirect(&bitmapData);
}
/**********************************************************************
* BITMAP_CopyBitmap
*
*/
HBITMAP BITMAP_CopyBitmap(HBITMAP hbitmap)
{
HBITMAP res = 0;
BITMAP bm;
if (!GetObjectW( hbitmap, sizeof(bm), &bm )) return 0;
res = CreateBitmapIndirect(&bm);
if(res) {
char *buf = HeapAlloc( GetProcessHeap(), 0, bm.bmWidthBytes *
bm.bmHeight );
GetBitmapBits (hbitmap, bm.bmWidthBytes * bm.bmHeight, buf);
SetBitmapBits (res, bm.bmWidthBytes * bm.bmHeight, buf);
HeapFree( GetProcessHeap(), 0, buf );
}
return res;
}
HBITMAP IconToAndBitmap( HDC hdc, an_icon *icon )
{
BITMAP bitmap;
HBITMAP bitmap_handle;
BITMAPINFOHEADER *h;
hdc = hdc;
h = &icon->bm->bmiHeader;
bitmap.bmType = 0;
bitmap.bmWidth = h->biWidth;
bitmap.bmHeight = h->biWidth;
bitmap.bmWidthBytes = ( bitmap.bmWidth + 7 ) / 8;
bitmap.bmPlanes = 1;
bitmap.bmBitsPixel = 1;
bitmap.bmBits = icon->and_mask;
bitmap_handle = CreateBitmapIndirect( &bitmap );
return( bitmap_handle );
} /* IconToAndBitmap */
/*
* __CreateBitmapIndirect - cover for CreateBitmapIndirect
*/
HBITMAP FAR PASCAL __CreateBitmapIndirect( LPBITMAP bm )
{
HBITMAP rc;
DWORD alias,size;
LPSTR old;
size = (DWORD) bm->bmHeight * (DWORD) bm->bmWidthBytes;
size *= (DWORD) bm->bmPlanes;
DPMIGetHugeAlias( (DWORD) bm->bmBits, &alias, size );
old = bm->bmBits;
bm->bmBits = (LPSTR) alias;
rc = CreateBitmapIndirect( bm );
DPMIFreeHugeAlias( alias, size );
bm->bmBits = old;
return( rc );
} /* __CreateBitmapIndirect */
/**********************************************************************
* BITMAP_CopyBitmap
*
*/
HBITMAP BITMAP_CopyBitmap(HBITMAP hbitmap)
{
HBITMAP res;
DIBSECTION dib;
DWORD size;
if (!(size = GetObjectW( hbitmap, sizeof(dib), &dib ))) return 0;
if (size == sizeof(DIBSECTION))
{
void *bits;
BITMAPINFO *bi;
HDC dc = CreateCompatibleDC( NULL );
if (!dc) return 0;
if (!(bi = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET( BITMAPINFO, bmiColors[256] ))))
{
DeleteDC( dc );
return 0;
}
bi->bmiHeader = dib.dsBmih;
/* Get the color table or the color masks */
GetDIBits( dc, hbitmap, 0, 0, NULL, bi, DIB_RGB_COLORS );
res = CreateDIBSection( dc, bi, DIB_RGB_COLORS, &bits, NULL, 0 );
if (res) SetDIBits( dc, res, 0, dib.dsBm.bmHeight, dib.dsBm.bmBits, bi, DIB_RGB_COLORS );
HeapFree( GetProcessHeap(), 0, bi );
DeleteDC( dc );
return res;
}
res = CreateBitmapIndirect( &dib.dsBm );
if(res) {
char *buf = HeapAlloc( GetProcessHeap(), 0, dib.dsBm.bmWidthBytes * dib.dsBm.bmHeight );
GetBitmapBits (hbitmap, dib.dsBm.bmWidthBytes * dib.dsBm.bmHeight, buf);
SetBitmapBits (res, dib.dsBm.bmWidthBytes * dib.dsBm.bmHeight, buf);
HeapFree( GetProcessHeap(), 0, buf );
}
return res;
}
static BOOL ClipboardReadBitmap(HANDLE hFile, DWORD dwOffset, DWORD dwLength)
{
HGLOBAL hData;
HBITMAP hBitmap;
LPBITMAP lpBitmap;
hData = ClipboardReadMemoryBlock(hFile, dwOffset, dwLength);
if (!hData)
{
return FALSE;
}
lpBitmap = GlobalLock(hData);
if (!lpBitmap)
{
GlobalFree(hData);
return FALSE;
}
lpBitmap->bmBits = lpBitmap + sizeof(BITMAP) + 1;
hBitmap = CreateBitmapIndirect(lpBitmap);
GlobalUnlock(hData);
GlobalFree(hData);
if (!hBitmap)
{
SetLastError(ERROR_OUTOFMEMORY);
return FALSE;
}
if (!SetClipboardData(CF_BITMAP, hBitmap))
{
DeleteObject(hBitmap);
return FALSE;
}
return TRUE;
}
HBITMAP CopyBitmap(HBITMAP hBitmapSrc)
{
BITMAP bitmap;
HBITMAP hBitmapDst;
HDC hdcSrc, hdcDst;
GetObject(hBitmapSrc, sizeof (BITMAP), &bitmap);
hBitmapDst = CreateBitmapIndirect(&bitmap);
hdcSrc = CreateCompatibleDC(NULL);
hdcDst = CreateCompatibleDC(NULL);
SelectObject(hdcSrc, hBitmapSrc);
SelectObject(hdcDst, hBitmapDst);
BitBlt(hdcDst, 0, 0, bitmap.bmWidth, bitmap.bmHeight,
hdcSrc, 0, 0, SRCCOPY);
DeleteDC(hdcSrc);
DeleteDC(hdcDst);
return hBitmapDst;
}
// -----------------------------------------------------------------------
// Stencil the "set" bits of the bitmap onto the canvas in the given color
// at the given origin. The origin is in terms of the point system with
// the origin in the lower left, which must be converted to the device
// coordinate system which has an origin in the upper left. Further, the
// blt coordinates must be adjusted this way as well.
//
// If the transformation matrix is identity, the bitmap is simply blt'd
// using the raster operation discussed in the Petzold V3.0 book on page
// 624 which transfers only the black bits. It corresponds to the operation
// ((Destination ^ Pattern) & Source) ^ Pattern. If the transformer is not
// identity, then the Windows function StretchBlt is used to scale the
// bitmap. The default mode of STRETCH_ANDSCANS is appropriate since it
// favors the black bits.
//
// Currently, a rotated bitmap is NOT supported!
// -----------------------------------------------------------------------
void MWcanvas16::stencil(
const Bitmap* mask, // bitmap to render
const Color* c, // color to use
Coord x, // x-coordinate
Coord y) // y-coordinate
{
BitmapRep& br = * mask->rep();
HBITMAP hbm = CreateBitmapIndirect((BITMAP*) &(br.bm_));
HDC mem_hdc = CreateCompatibleDC(drawable_);
SelectObject(mem_hdc, hbm);
//
// convert the coordinates to TWIPS for the page space to device space
// mapping.
//
int x0 = COORD2TWIPS( x + mask->left_bearing() );
int y0 = COORD2TWIPS( y - mask->descent() );
int width = COORD2TWIPS( mask->width() );
int height = COORD2TWIPS( mask->height() );
// ---- set the color to use ----
flush();
color(c);
// For some reason, text color must be black when stenciling or the
// colors of the stencil are affected.
SetTextColor(drawable_, RGB(0, 0, 0));
// ---- blt... the destination will be transformed ----
MWassert( StretchBlt(drawable_, x0, y0 + height, width, - height,
mem_hdc, 0, 0, br.bm_.bmWidth, br.bm_.bmHeight, 0xB8074AL) );
// ---- cleanup ----
DeleteDC(mem_hdc);
DeleteObject(hbm);
}
void *wxGetClipboardData(wxDataFormat dataFormat, long *len)
{
void *retval = NULL;
switch ( dataFormat )
{
#ifndef __WXWINCE__
case wxDF_BITMAP:
{
BITMAP bm;
HBITMAP hBitmap = (HBITMAP) GetClipboardData(CF_BITMAP);
if (!hBitmap)
break;
HDC hdcMem = CreateCompatibleDC((HDC) NULL);
HDC hdcSrc = CreateCompatibleDC((HDC) NULL);
HBITMAP old = (HBITMAP) ::SelectObject(hdcSrc, hBitmap);
GetObject(hBitmap, sizeof(BITMAP), (LPSTR)&bm);
HBITMAP hNewBitmap = CreateBitmapIndirect(&bm);
if (!hNewBitmap)
{
SelectObject(hdcSrc, old);
DeleteDC(hdcMem);
DeleteDC(hdcSrc);
break;
}
HBITMAP old1 = (HBITMAP) SelectObject(hdcMem, hNewBitmap);
BitBlt(hdcMem, 0, 0, bm.bmWidth, bm.bmHeight,
hdcSrc, 0, 0, SRCCOPY);
// Select new bitmap out of memory DC
SelectObject(hdcMem, old1);
// Clean up
SelectObject(hdcSrc, old);
DeleteDC(hdcSrc);
DeleteDC(hdcMem);
// Create and return a new wxBitmap
wxBitmap *wxBM = new wxBitmap;
wxBM->SetHBITMAP((WXHBITMAP) hNewBitmap);
wxBM->SetWidth(bm.bmWidth);
wxBM->SetHeight(bm.bmHeight);
wxBM->SetDepth(bm.bmPlanes);
retval = wxBM;
break;
}
#endif
case wxDF_METAFILE:
case CF_SYLK:
case CF_DIF:
case CF_TIFF:
case CF_PALETTE:
case wxDF_DIB:
wxLogError(_("Unsupported clipboard format."));
return NULL;
case wxDF_OEMTEXT:
dataFormat = wxDF_TEXT;
// fall through
case wxDF_TEXT:
{
HANDLE hGlobalMemory = ::GetClipboardData(dataFormat);
if (!hGlobalMemory)
break;
DWORD hsize = ::GlobalSize(hGlobalMemory);
if (len)
*len = hsize;
char *s = new char[hsize];
if (!s)
break;
LPSTR lpGlobalMemory = (LPSTR) GlobalLock(hGlobalMemory);
memcpy(s, lpGlobalMemory, hsize);
GlobalUnlock(hGlobalMemory);
retval = s;
break;
}
default:
{
HANDLE hGlobalMemory = ::GetClipboardData(dataFormat);
if ( !hGlobalMemory )
break;
DWORD size = ::GlobalSize(hGlobalMemory);
if ( len )
*len = size;
void *buf = malloc(size);
if ( !buf )
break;
LPSTR lpGlobalMemory = (LPSTR) GlobalLock(hGlobalMemory);
memcpy(buf, lpGlobalMemory, size);
GlobalUnlock(hGlobalMemory);
retval = buf;
break;
}
}
if ( !retval )
{
wxLogSysError(_("Failed to retrieve data from the clipboard."));
}
return retval;
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% C r o p I m a g e T o H B i t m a p %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% CropImageToHBITMAP() extracts a specified region of the image and returns
% it as a Windows HBITMAP. While the same functionality can be accomplished by
% invoking CropImage() followed by ImageToHBITMAP(), this method is more
% efficient since it copies pixels directly to the HBITMAP.
%
% The format of the CropImageToHBITMAP method is:
%
% HBITMAP CropImageToHBITMAP(Image* image,const RectangleInfo *geometry,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o geometry: Define the region of the image to crop with members
% x, y, width, and height.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport void *CropImageToHBITMAP(Image *image,
const RectangleInfo *geometry,ExceptionInfo *exception)
{
#define CropImageTag "Crop/Image"
BITMAP
bitmap;
HBITMAP
bitmapH;
HANDLE
bitmap_bitsH;
MagickBooleanType
proceed;
RectangleInfo
page;
register const PixelPacket
*p;
register RGBQUAD
*q;
RGBQUAD
*bitmap_bits;
ssize_t
y;
/*
Check crop geometry.
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(geometry != (const RectangleInfo *) NULL);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
if (((geometry->x+(ssize_t) geometry->width) < 0) ||
((geometry->y+(ssize_t) geometry->height) < 0) ||
(geometry->x >= (ssize_t) image->columns) ||
(geometry->y >= (ssize_t) image->rows))
ThrowImageException(OptionError,"GeometryDoesNotContainImage");
page=(*geometry);
if ((page.x+(ssize_t) page.width) > (ssize_t) image->columns)
page.width=image->columns-page.x;
if ((page.y+(ssize_t) page.height) > (ssize_t) image->rows)
page.height=image->rows-page.y;
if (page.x < 0)
{
page.width+=page.x;
page.x=0;
}
if (page.y < 0)
{
page.height+=page.y;
page.y=0;
}
if ((page.width == 0) || (page.height == 0))
ThrowImageException(OptionError,"GeometryDimensionsAreZero");
/*
Initialize crop image attributes.
*/
bitmap.bmType = 0;
bitmap.bmWidth = (LONG) page.width;
bitmap.bmHeight = (LONG) page.height;
bitmap.bmWidthBytes = bitmap.bmWidth * 4;
bitmap.bmPlanes = 1;
bitmap.bmBitsPixel = 32;
bitmap.bmBits = NULL;
bitmap_bitsH=(HANDLE) GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE,page.width*
page.height*bitmap.bmBitsPixel);
if (bitmap_bitsH == NULL)
return(NULL);
bitmap_bits=(RGBQUAD *) GlobalLock((HGLOBAL) bitmap_bitsH);
if ( bitmap.bmBits == NULL )
bitmap.bmBits = bitmap_bits;
if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
SetImageColorspace(image,sRGBColorspace);
/*
Extract crop image.
*/
q=bitmap_bits;
for (y=0; y < (ssize_t) page.height; y++)
{
register ssize_t
x;
p=GetVirtualPixels(image,page.x,page.y+y,page.width,1,exception);
if (p == (const PixelPacket *) NULL)
break;
/* Transfer pixels, scaling to Quantum */
for( x=(ssize_t) page.width ; x> 0 ; x-- )
{
q->rgbRed = ScaleQuantumToChar(GetPixelRed(p));
q->rgbGreen = ScaleQuantumToChar(GetPixelGreen(p));
q->rgbBlue = ScaleQuantumToChar(GetPixelBlue(p));
q->rgbReserved = 0;
p++;
q++;
}
proceed=SetImageProgress(image,CropImageTag,y,page.height);
if (proceed == MagickFalse)
break;
}
if (y < (ssize_t) page.height)
{
GlobalUnlock((HGLOBAL) bitmap_bitsH);
GlobalFree((HGLOBAL) bitmap_bitsH);
return((void *) NULL);
}
bitmap.bmBits=bitmap_bits;
bitmapH=CreateBitmapIndirect(&bitmap);
GlobalUnlock((HGLOBAL) bitmap_bitsH);
GlobalFree((HGLOBAL) bitmap_bitsH);
return((void *) bitmapH);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% I m a g e T o H B i t m a p %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ImageToHBITMAP() creates a Windows HBITMAP from an image.
%
% The format of the ImageToHBITMAP method is:
%
% HBITMAP ImageToHBITMAP(Image *image,Exceptioninfo *exception)
%
% A description of each parameter follows:
%
% o image: the image to convert.
%
*/
MagickExport void *ImageToHBITMAP(Image *image,ExceptionInfo *exception)
{
BITMAP
bitmap;
HANDLE
bitmap_bitsH;
HBITMAP
bitmapH;
register ssize_t
x;
register const PixelPacket
*p;
register RGBQUAD
*q;
RGBQUAD
*bitmap_bits;
size_t
length;
ssize_t
y;
(void) ResetMagickMemory(&bitmap,0,sizeof(bitmap));
bitmap.bmType=0;
bitmap.bmWidth=(LONG) image->columns;
bitmap.bmHeight=(LONG) image->rows;
bitmap.bmWidthBytes=4*bitmap.bmWidth;
bitmap.bmPlanes=1;
bitmap.bmBitsPixel=32;
bitmap.bmBits=NULL;
length=bitmap.bmWidthBytes*bitmap.bmHeight;
bitmap_bitsH=(HANDLE) GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE,length);
if (bitmap_bitsH == NULL)
{
char
*message;
message=GetExceptionMessage(errno);
(void) ThrowMagickException(exception,GetMagickModule(),
ResourceLimitError,"MemoryAllocationFailed","`%s'",message);
message=DestroyString(message);
return(NULL);
}
bitmap_bits=(RGBQUAD *) GlobalLock((HGLOBAL) bitmap_bitsH);
q=bitmap_bits;
if (bitmap.bmBits == NULL)
bitmap.bmBits=bitmap_bits;
(void) SetImageColorspace(image,sRGBColorspace);
for (y=0; y < (ssize_t) image->rows; y++)
{
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const PixelPacket *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
q->rgbRed=ScaleQuantumToChar(GetPixelRed(p));
q->rgbGreen=ScaleQuantumToChar(GetPixelGreen(p));
q->rgbBlue=ScaleQuantumToChar(GetPixelBlue(p));
q->rgbReserved=0;
p++;
q++;
}
}
bitmap.bmBits=bitmap_bits;
bitmapH=CreateBitmapIndirect(&bitmap);
if (bitmapH == NULL)
{
char
*message;
message=GetExceptionMessage(errno);
(void) ThrowMagickException(exception,GetMagickModule(),
ResourceLimitError,"MemoryAllocationFailed","`%s'",message);
message=DestroyString(message);
}
GlobalUnlock((HGLOBAL) bitmap_bitsH);
GlobalFree((HGLOBAL) bitmap_bitsH);
return((void *) bitmapH);
}
long UPSF::BITMAP_To_UBit(
HGLOBAL& hUniv,
long& univSize,
BITMAP bitmap,
HBITMAP hBmp)
{
WORD nColorBits = bitmap.bmBitsPixel*bitmap.bmPlanes;
if(nColorBits!=1 && nColorBits!=4 && nColorBits!=8 && nColorBits!=24)
return AUPSF_CANTCONVERT;
long ColorTableSize;
if(nColorBits==24)
{
// 24-bit color -- no color table
ColorTableSize = 0;
}
else
ColorTableSize = pow2(nColorBits);
univSize = sizeof(BITMAPINFOHEADER) + ColorTableSize*sizeof(RGBQUAD);
if(!(hUniv = GlobalReAlloc(hUniv, univSize, MEMFLAGS)))
return AUPSF_MEMORYERROR;
BITMAPINFOHEADER* bmpIH = (BITMAPINFOHEADER*)GlobalLock(hUniv);
if(!bmpIH)
return AUPSF_MEMORYERROR;
bmpIH->biWidth = bitmap.bmWidth;
bmpIH->biHeight = bitmap.bmHeight;
bmpIH->biPlanes = 1;
bmpIH->biSize = sizeof(BITMAPINFOHEADER);
bmpIH->biBitCount = nColorBits;
bmpIH->biCompression = BI_RGB;
bmpIH->biXPelsPerMeter = 0;
bmpIH->biYPelsPerMeter = 0;
bmpIH->biSizeImage = 0;
bmpIH->biClrUsed = 0;
bmpIH->biClrImportant = 0;
// get some handles for bitmap conversion
HDC hDC = CreateDC("DISPLAY", NULL, NULL, NULL);
HBITMAP hBitmap;
if(!hBmp)
hBitmap = CreateBitmapIndirect(&bitmap);
else
hBitmap = hBmp;
// fill in the BITMAPINFO structure -- fills in the color table
GetDIBits(hDC, hBitmap, 0, bitmap.bmHeight, NULL, (LPBITMAPINFO)bmpIH, DIB_RGB_COLORS);
// check to see if the video driver messed up!
if(bmpIH->biSizeImage==0)
bmpIH->biSizeImage = (((DWORD)bitmap.bmWidth * nColorBits + 31)/8) * bitmap.bmHeight;
long BitmapSize = bmpIH->biSizeImage;
GlobalUnlock(hUniv);
// resize the universal memory without losing information
univSize += BitmapSize;
if(!(hUniv = GlobalReAlloc(hUniv, univSize, MEMFLAGS)))
return AUPSF_MEMORYERROR;
bmpIH = (BITMAPINFOHEADER*)GlobalLock(hUniv);
if(!bmpIH)
return AUPSF_MEMORYERROR;
void* bits = (void*)((BYTE*)bmpIH + (size_t)(ColorTableSize*sizeof(RGBQUAD) + sizeof(BITMAPINFOHEADER)));
// fill in the bitmap data -- copies the bits automatically
GetDIBits(hDC, hBitmap, 0, bitmap.bmHeight, (char*)bits, (LPBITMAPINFO)bmpIH, DIB_RGB_COLORS);
// free the resources
if(!hBmp)
DeleteObject(hBitmap);
DeleteDC(hDC);
GlobalUnlock(hUniv);
return AUPSF_NOERROR;
}
/*****************************************************************
* CreateCaret (USER32.@)
*/
BOOL WINAPI CreateCaret( HWND hwnd, HBITMAP bitmap, INT width, INT height )
{
BOOL ret;
RECT r;
int old_state = 0;
int hidden = 0;
HBITMAP hBmp = 0;
HWND prev = 0;
TRACE("hwnd=%p\n", hwnd);
if (!hwnd) return FALSE;
if (bitmap && (bitmap != (HBITMAP)1))
{
BITMAP bmp;
if (!GetObjectA( bitmap, sizeof(bmp), &bmp )) return FALSE;
width = bmp.bmWidth;
height = bmp.bmHeight;
bmp.bmBits = NULL;
hBmp = CreateBitmapIndirect(&bmp);
if (hBmp)
{
/* copy the bitmap */
LPBYTE buf = HeapAlloc(GetProcessHeap(), 0, bmp.bmWidthBytes * bmp.bmHeight);
GetBitmapBits(bitmap, bmp.bmWidthBytes * bmp.bmHeight, buf);
SetBitmapBits(hBmp, bmp.bmWidthBytes * bmp.bmHeight, buf);
HeapFree(GetProcessHeap(), 0, buf);
}
}
else
{
HDC hdc;
if (!width) width = GetSystemMetrics(SM_CXBORDER);
if (!height) height = GetSystemMetrics(SM_CYBORDER);
/* create the uniform bitmap on the fly */
hdc = GetDC(hwnd);
if (hdc)
{
HDC hMemDC = CreateCompatibleDC(hdc);
if (hMemDC)
{
if ((hBmp = CreateCompatibleBitmap(hMemDC, width, height )))
{
HBITMAP hPrevBmp = SelectObject(hMemDC, hBmp);
SetRect( &r, 0, 0, width, height );
FillRect(hMemDC, &r, ULongToHandle((bitmap ? COLOR_GRAYTEXT : COLOR_WINDOW) + 1));
SelectObject(hMemDC, hPrevBmp);
}
DeleteDC(hMemDC);
}
ReleaseDC(hwnd, hdc);
}
}
if (!hBmp) return FALSE;
SERVER_START_REQ( set_caret_window )
{
req->handle = wine_server_user_handle( hwnd );
req->width = width;
req->height = height;
if ((ret = !wine_server_call_err( req )))
{
prev = wine_server_ptr_handle( reply->previous );
r.left = reply->old_rect.left;
r.top = reply->old_rect.top;
r.right = reply->old_rect.right;
r.bottom = reply->old_rect.bottom;
old_state = reply->old_state;
hidden = reply->old_hide;
}
}
SERVER_END_REQ;
if (!ret) return FALSE;
if (prev && !hidden) /* hide the previous one */
{
/* FIXME: won't work if prev belongs to a different process */
KillSystemTimer( prev, TIMERID );
if (old_state) CARET_DisplayCaret( prev, &r );
}
if (Caret.hBmp) DeleteObject( Caret.hBmp );
Caret.hBmp = hBmp;
Caret.timeout = GetProfileIntA( "windows", "CursorBlinkRate", 500 );
return TRUE;
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
PAINTSTRUCT ps;
HDC hdc;
switch (message)
{
case WM_CREATE:
{
if (!hmWnd)
hmWnd = hWnd;
hdc = GetDC(hWnd);
CBIT = GetDeviceCaps(hdc, BITSPIXEL);
CBYTE = CBIT/8;
ReleaseDC(hWnd, hdc);
buffer = malloc(width*height*CBYTE);
bmp.bmType = 0;
bmp.bmWidth = width;
bmp.bmHeight = height;
bmp.bmWidthBytes = width*CBYTE;
bmp.bmPlanes = 1;
bmp.bmBitsPixel = CBIT;
bmp.bmBits = buffer;
if (CBYTE == 4)
fmt = COLOR_FORMAT_BGRA;
else if (CBYTE == 3)
fmt = COLOR_FORMAT_BGR;
else if (CBYTE == 2)
fmt = COLOR_FORMAT_RGB565;
ps_initialize();
canvas = ps_canvas_create_with_data(buffer, fmt, width, height, width*CBYTE);
context = ps_context_create(canvas, 0);
on_init(context, width, height);
}
break;
case WM_PAINT:
{
HDC mdc;
HGDIOBJ h;
hdc = BeginPaint(hWnd, &ps);
on_draw(context);
mdc = CreateCompatibleDC(hdc);
hbmp = CreateBitmapIndirect(&bmp);
h = SelectObject(mdc, hbmp);
BitBlt(hdc, 0, 0, width, height, mdc, 0, 0, SRCCOPY);
SelectObject(mdc, h);
DeleteObject(hbmp);
DeleteDC(mdc);
EndPaint(hWnd, &ps);
}
break;
case WM_TIMER:
on_timer();
break;
case WM_SIZE:
{
ps_canvas* old_canvas = 0;
width = LOWORD(lParam);
height = HIWORD(lParam);
free(buffer);
if (width < 1)
width = 1;
if (height < 1)
height = 1;
buffer = malloc(width*height*CBYTE);
bmp.bmType = 0;
bmp.bmWidth = width;
bmp.bmHeight = height;
bmp.bmWidthBytes = width*CBYTE;
bmp.bmPlanes = 1;
bmp.bmBitsPixel = CBIT;
bmp.bmBits = buffer;
canvas = ps_canvas_create_with_data(buffer, fmt, width, height, width*CBYTE);
old_canvas = ps_context_set_canvas(context, canvas);
ps_canvas_unref(old_canvas);
on_size(width, height);
}
break;
case WM_ERASEBKGND:
break;
case WM_LBUTTONDOWN:
on_mouse_event(LEFT_BUTTON_DOWN, wParam, LOWORD(lParam), HIWORD(lParam));
break;
case WM_MOUSEMOVE:
on_mouse_event(MOUSE_MOVE, wParam, LOWORD(lParam), HIWORD(lParam));
break;
case WM_KEYDOWN:
on_key_event(KEY_EVENT_DOWN, wParam);
break;
case WM_KEYUP:
on_key_event(KEY_EVENT_UP, wParam);
break;
case WM_DESTROY:
{
on_term(context);
ps_context_unref(context);
ps_canvas_unref(canvas);
ps_shutdown();
free(buffer);
PostQuitMessage(0);
}
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% C r o p I m a g e T o H B i t m a p %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% CropImageToHBITMAP() extracts a specified region of the image and returns
% it as a Windows HBITMAP. While the same functionality can be accomplished by
% invoking CropImage() followed by ImageToHBITMAP(), this method is more
% efficient since it copies pixels directly to the HBITMAP.
%
% The format of the CropImageToHBITMAP method is:
%
% HBITMAP CropImageToHBITMAP(Image* image,const RectangleInfo *geometry,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: The image.
%
% o geometry: Define the region of the image to crop with members
% x, y, width, and height.
%
% o exception: Return any errors or warnings in this structure.
%
*/
MagickExport void *CropImageToHBITMAP(Image *image,
const RectangleInfo *geometry,ExceptionInfo *exception)
{
#define CropImageTag "Crop/Image"
long
y;
MagickBooleanType
status;
RectangleInfo
page;
register const PixelPacket
*p;
BITMAP
bitmap;
HBITMAP
bitmapH;
HANDLE
bitmap_bitsH;
register RGBQUAD
*q;
RGBQUAD
*bitmap_bits;
/*
Check crop geometry.
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(geometry != (const RectangleInfo *) NULL);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
if (((geometry->x+(long) geometry->width) < 0) ||
((geometry->y+(long) geometry->height) < 0) ||
(geometry->x >= (long) image->columns) ||
(geometry->y >= (long) image->rows))
ThrowImageException(OptionError,"GeometryDoesNotContainImage");
page=(*geometry);
if ((page.x+(long) page.width) > (long) image->columns)
page.width=image->columns-page.x;
if ((page.y+(long) page.height) > (long) image->rows)
page.height=image->rows-page.y;
if (page.x < 0)
{
page.width+=page.x;
page.x=0;
}
if (page.y < 0)
{
page.height+=page.y;
page.y=0;
}
if ((page.width == 0) || (page.height == 0))
ThrowImageException(OptionError,"GeometryDimensionsAreZero");
/*
Initialize crop image attributes.
*/
bitmap.bmType = 0;
bitmap.bmWidth = page.width;
bitmap.bmHeight = page.height;
bitmap.bmWidthBytes = bitmap.bmWidth * 4;
bitmap.bmPlanes = 1;
bitmap.bmBitsPixel = 32;
bitmap.bmBits = NULL;
bitmap_bitsH = (HANDLE) GlobalAlloc (GMEM_MOVEABLE | GMEM_DDESHARE,
page.width*page.height*bitmap.bmBitsPixel);
if (bitmap_bitsH == NULL)
return(NULL);
bitmap_bits=(RGBQUAD *) GlobalLock((HGLOBAL) bitmap_bitsH);
if ( bitmap.bmBits == NULL )
bitmap.bmBits = bitmap_bits;
if (image->colorspace != RGBColorspace)
SetImageColorspace(image,RGBColorspace);
/*
Extract crop image.
*/
q=bitmap_bits;
for (y=0; y < (long) page.height; y++)
{
p=AcquireImagePixels(image,page.x,page.y+y,page.width,1,exception);
if (p == (const PixelPacket *) NULL)
break;
#if MAGICKCORE_QUANTUM_DEPTH == 8
/* Form of PixelPacket is identical to RGBQUAD when MAGICKCORE_QUANTUM_DEPTH==8 */
CopyMagickMemory((void*)q,(const void*)p,page.width*sizeof(PixelPacket));
q += page.width;
#else /* 16 or 32 bit Quantum */
{
long
x;
/* Transfer pixels, scaling to Quantum */
for( x=page.width ; x> 0 ; x-- )
{
q->rgbRed = ScaleQuantumToChar(p->red);
q->rgbGreen = ScaleQuantumToChar(p->green);
q->rgbBlue = ScaleQuantumToChar(p->blue);
q->rgbReserved = 0;
++q;
++p;
}
}
#endif
if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&
(QuantumTick(y,page.height) != MagickFalse))
{
status=image->progress_monitor(CropImageTag,y,page.height,
image->client_data);
if (status == MagickFalse)
break;
}
}
if (y < (long) page.height)
{
GlobalUnlock((HGLOBAL) bitmap_bitsH);
GlobalFree((HGLOBAL) bitmap_bitsH);
return((void *) NULL);
}
bitmap.bmBits = bitmap_bits;
bitmapH = CreateBitmapIndirect( &bitmap );
GlobalUnlock((HGLOBAL) bitmap_bitsH);
return((void *) bitmapH);
}
/******************************************************************************
* OleDuplicateData [OLE32.@]
*
* Duplicates clipboard data.
*
* PARAMS
* hSrc [I] Handle of the source clipboard data.
* cfFormat [I] The clipboard format of hSrc.
* uiFlags [I] Flags to pass to GlobalAlloc.
*
* RETURNS
* Success: handle to the duplicated data.
* Failure: NULL.
*/
HANDLE WINAPI OleDuplicateData(HANDLE hSrc, CLIPFORMAT cfFormat,
UINT uiFlags)
{
HANDLE hDst = NULL;
TRACE("(%p,%x,%x)\n", hSrc, cfFormat, uiFlags);
if (!uiFlags) uiFlags = GMEM_MOVEABLE;
switch (cfFormat)
{
case CF_ENHMETAFILE:
hDst = CopyEnhMetaFileW(hSrc, NULL);
break;
case CF_METAFILEPICT:
hDst = CopyMetaFileW(hSrc, NULL);
break;
case CF_PALETTE:
{
LOGPALETTE * logpalette;
UINT nEntries = GetPaletteEntries(hSrc, 0, 0, NULL);
if (!nEntries) return NULL;
logpalette = HeapAlloc(GetProcessHeap(), 0,
FIELD_OFFSET(LOGPALETTE, palPalEntry[nEntries]));
if (!logpalette) return NULL;
if (!GetPaletteEntries(hSrc, 0, nEntries, logpalette->palPalEntry))
{
HeapFree(GetProcessHeap(), 0, logpalette);
return NULL;
}
logpalette->palVersion = 0x300;
logpalette->palNumEntries = (WORD)nEntries;
hDst = CreatePalette(logpalette);
HeapFree(GetProcessHeap(), 0, logpalette);
break;
}
case CF_BITMAP:
{
LONG size;
BITMAP bm;
if (!GetObjectW(hSrc, sizeof(bm), &bm))
return NULL;
size = GetBitmapBits(hSrc, 0, NULL);
if (!size) return NULL;
bm.bmBits = HeapAlloc(GetProcessHeap(), 0, size);
if (!bm.bmBits) return NULL;
if (GetBitmapBits(hSrc, size, bm.bmBits))
hDst = CreateBitmapIndirect(&bm);
HeapFree(GetProcessHeap(), 0, bm.bmBits);
break;
}
default:
{
SIZE_T size = GlobalSize(hSrc);
LPVOID pvSrc = NULL;
LPVOID pvDst = NULL;
/* allocate space for object */
if (!size) return NULL;
hDst = GlobalAlloc(uiFlags, size);
if (!hDst) return NULL;
/* lock pointers */
pvSrc = GlobalLock(hSrc);
if (!pvSrc)
{
GlobalFree(hDst);
return NULL;
}
pvDst = GlobalLock(hDst);
if (!pvDst)
{
GlobalUnlock(hSrc);
GlobalFree(hDst);
return NULL;
}
/* copy data */
memcpy(pvDst, pvSrc, size);
/* cleanup */
GlobalUnlock(hDst);
GlobalUnlock(hSrc);
}
}
TRACE("returning %p\n", hDst);
return hDst;
}