Exemple #1
0
void OpenEnhMetaFile(HWND hWnd)
{
	OPENFILENAME LFile;
	WCHAR FileName[MAX_PATH], FilePath[MAX_PATH];
	FileName[0] = '\0';
 	FilePath[0] = '\0';
	LFile.lStructSize = sizeof(OPENFILENAME);
	LFile.hwndOwner = hWnd;
	LFile.lpstrFilter =L"EMF (*.emf)\0";
	LFile.lpstrCustomFilter = 0;
	LFile.lpstrFile = FilePath;
	LFile.nMaxFile = MAX_PATH * sizeof(WCHAR);
	LFile.lpstrFileTitle = FileName;
	LFile.nMaxFileTitle = MAX_PATH * sizeof(WCHAR);
	LFile.lpstrInitialDir = 0;
	LFile.lpstrDefExt = L"emf\0";
	LFile.lpstrTitle = L"Open file from:";
	LFile.Flags = OFN_PATHMUSTEXIST;
	GetOpenFileName(&LFile);
	HENHMETAFILE enhFile = GetEnhMetaFile(LFile.lpstrFile);
	RECT client;
	GetClientRect(hWnd, &client);
	client.left += scrhor / 3;
	client.top += scrvert / 3;
	client.right += scrhor / 3;
	client.bottom += scrvert / 3;
	PlayEnhMetaFile(hdc1, enhFile, &client);
	PlayEnhMetaFile(hdc2, enhFile, &client);
	DeleteEnhMetaFile(enhFile);
	InvalidateRect(hWnd, NULL, false);
}
VOID SaveMetafile(HWND hWnd)
{ 
	HENHMETAFILE currentImage = RefreshMetafileDC(hWnd);
	
	TCHAR buffer[4 * MAX_LOADSTRING];
	OPENFILENAME openFileName = InitializeOpenFileNameStructure(hWnd, OFN_SHOWHELP | OFN_OVERWRITEPROMPT, buffer);

	TCHAR szDescription[MAX_LOADSTRING];
	LoadString(hInst, IDS_DESCRIPTIONSTRING, 
     (LPWSTR)szDescription, sizeof(szDescription)); 

	for (int i = 0; szDescription[i]!='\0'; i++) 
	{
		if (szDescription[i] == '%') 
				szDescription[i] = '\0'; 
	}
 
	GetSaveFileName(&openFileName); 
	GetClientRect(hWnd, &rect);
	HDC windowDC = GetDC(hWnd);
	RECT newRect = GetRect(windowDC);
	HDC newMetafileDC = CreateEnhMetaFile(windowDC, (LPTSTR) openFileName.lpstrFile, &newRect, (LPWSTR)szDescription);
	ReleaseDC(hWnd, windowDC);
	PlayEnhMetaFile(newMetafileDC, currentImage, &rect);
	currentImage = CloseEnhMetaFile(newMetafileDC);
	PlayEnhMetaFile(metafileDC, currentImage, &rect);
	ReleaseDC(hWnd, newMetafileDC);
	DeleteEnhMetaFile(currentImage);
}
VOID RefreshWindow(HWND hWnd)
{
	HDC windowDC = GetDC(hWnd);
	HENHMETAFILE currentImage = RefreshMetafileDC(hWnd);

	PlayEnhMetaFile(memoryDC, currentImage, &rect);
	PlayEnhMetaFile(metafileDC, currentImage, &rect);
	DeleteEnhMetaFile(currentImage);
	ReleaseDC(hWnd, windowDC);
}
VOID OpenImage(HWND hWnd, LPCWSTR fileName)
{
	HDC windowDC = GetDC(hWnd);
	HENHMETAFILE hemf = GetEnhMetaFile(fileName);  
	GetClientRect(hWnd, &rect); 
	ClearWindow(memoryDC);
	RefreshMetafileDC(hWnd);
	PlayEnhMetaFile(memoryDC, hemf, &rect);
	PlayEnhMetaFile(metafileDC, hemf, &rect);
	ReleaseDC(hWnd, windowDC); 
	DeleteEnhMetaFile(hemf);
}
Exemple #5
0
// displaying EMF at a given ratio
BOOL DisplayEMF(HDC hDC, HENHMETAFILE hEmf, int x, int y, int scalex, int scaley, KEnumEMF * enumerator, bool showxform)
{
	int width, height;
	GetEMFDimension(hDC, hEmf, width, height);

	RECT rect = { x, y, 
		x + (width  * scalex + 50)/100, 
		y + (height * scaley + 50)/100 };

	BOOL rslt;

	if ( enumerator )
		rslt = enumerator->EnumEMF(hDC, hEmf, & rect);
	else
		rslt = PlayEnhMetaFile(hDC, hEmf, & rect);

	if ( showxform )
	{
		XFORM xform;

		if ( GetPlayTransformation(hEmf, & rect, xform) )
		{
			TCHAR mess[128];

			_stprintf(mess, _T("x' = x * %8.5f + y * %8.5f + %8.5f"), xform.eM11, xform.eM21, xform.eDx);
			TextOut(hDC, x, rect.bottom + 10, mess, _tcslen(mess));

			_stprintf(mess, _T("y' = x * %8.5f + y * %8.5f + %8.5f"), xform.eM12, xform.eM22, xform.eDy);
			TextOut(hDC, x, rect.bottom + 40, mess, _tcslen(mess));
		}
	}

	return rslt;
}
Exemple #6
0
void PaintRoutine (HWND hwnd, HDC hdc, int cxArea, int cyArea)
{
     ENHMETAHEADER emh ;
     HENHMETAFILE  hemf ;
     int           cxMms, cyMms, cxPix, cyPix, cxImage, cyImage ;
     RECT          rect ;
     
     cxMms = GetDeviceCaps (hdc, HORZSIZE) ;
     cyMms = GetDeviceCaps (hdc, VERTSIZE) ;
     cxPix = GetDeviceCaps (hdc, HORZRES) ;
     cyPix = GetDeviceCaps (hdc, VERTRES) ;
     
     hemf = GetEnhMetaFile (TEXT ("emf11.emf")) ;
     
     GetEnhMetaFileHeader (hemf, sizeof (emh), &emh) ;
     
     cxImage = emh.rclFrame.right - emh.rclFrame.left ;
     cyImage = emh.rclFrame.bottom - emh.rclFrame.top ;
     
     cxImage = cxImage * cxPix / cxMms / 100 ;
     cyImage = cyImage * cyPix / cyMms / 100 ;
     
     rect.left   = (cxArea - cxImage) / 2 ;
     rect.top    = (cyArea - cyImage) / 2 ;
     rect.right  = (cxArea + cxImage) / 2 ;
     rect.bottom = (cyArea + cyImage) / 2 ;
     
     PlayEnhMetaFile (hdc, hemf, &rect) ;
   
     DeleteEnhMetaFile (hemf) ;
}
Exemple #7
0
BOOL RenderEMF(HENHMETAFILE hemf, int width, int height, const TCHAR * tgaFileName)
{
	KTarga24 targa;

	int w = (width+3)/4*4;
	
	if ( targa.Create(w, height, tgaFileName) )
	{
		targa.Prepare(w, height);

		// DIBSECTION dibsec;
		// GetObject(targa.GetBitmap(), sizeof(DIBSECTION), & dibsec);

		BitBlt(targa.m_hMemDC, 0, 0, width, height, NULL, 0, 0, WHITENESS); // clear
		
		RECT rect = { 0, 0, width, height };

		for (int h=0; h<=height; h+=128 )
		{
			HRGN hRgn = CreateRectRgn(0, h, width, h+128);

			SelectClipRgn(targa.m_hMemDC, hRgn);
			DeleteObject(hRgn);
			
			if ( ! PlayEnhMetaFile(targa.m_hMemDC, hemf, &rect) ) 
				return FALSE;
		}
 	}
	
	return FALSE;
}
Exemple #8
0
LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     ENHMETAHEADER emh ;
     HDC           hdc, hdcEMF ;
     HENHMETAFILE  hemfOld, hemf ;
     PAINTSTRUCT   ps ;
     RECT          rect ;
     
     switch (message)
     {
     case WM_CREATE:
          
               // Retrieve existing metafile and header
          
          hemfOld = GetEnhMetaFile (TEXT ("..\\emf3\\emf3.emf")) ;
          
          GetEnhMetaFileHeader (hemfOld, sizeof (ENHMETAHEADER), &emh) ;
          
               // Create a new metafile DC
          
          hdcEMF = CreateEnhMetaFile (NULL, TEXT ("emf7.emf"), NULL,
                                      TEXT ("EMF7\0EMF Demo #7\0")) ;
          
               // Enumerate the existing metafile
          
          EnumEnhMetaFile (hdcEMF, hemfOld, EnhMetaFileProc, NULL,
                           (RECT *) & emh.rclBounds) ;
          
               // Clean up
          
          hemf = CloseEnhMetaFile (hdcEMF) ;
          
          DeleteEnhMetaFile (hemfOld) ;
          DeleteEnhMetaFile (hemf) ;
          return 0 ;
          
     case WM_PAINT:
          hdc = BeginPaint (hwnd, &ps) ;
          
          GetClientRect (hwnd, &rect) ;
          
          rect.left   =     rect.right  / 4 ;
          rect.right  = 3 * rect.right  / 4 ;
          rect.top    =     rect.bottom / 4 ;
          rect.bottom = 3 * rect.bottom / 4 ;
          
          hemf = GetEnhMetaFile (TEXT ("emf7.emf")) ;
          
          PlayEnhMetaFile (hdc, hemf, &rect) ;
          DeleteEnhMetaFile (hemf) ;
          EndPaint (hwnd, &ps) ;
          return 0 ;
          
     case WM_DESTROY:
          PostQuitMessage (0) ;
          return 0 ;
     }
     return DefWindowProc (hwnd, message, wParam, lParam) ;
}
Exemple #9
0
void IW::CRender::Play(HENHMETAFILE hemf)
{
	IW::CDCRender dc(*this);
	bool bHasPal = dc.GetDeviceCaps(BITSPIXEL) <= 8;

	// Create a logical palette from the colors in the color table
	UINT nColors = GetEnhMetaFilePaletteEntries(hemf, 0, NULL);
	CPalette pal;

	if (bHasPal && nColors != GDI_ERROR && nColors != 0)
	{
		bHasPal = false;
		DWORD dwSize = sizeof (LOGPALETTE) + ((nColors - 1) * sizeof (PALETTEENTRY));

		LPLOGPALETTE logPalette = IW_ALLOCA(LPLOGPALETTE, dwSize);

		logPalette->palVersion = 0x300;
		logPalette->palNumEntries = nColors;

		if (nColors == GetEnhMetaFilePaletteEntries(hemf, nColors, logPalette->palPalEntry))
		{
			pal.CreatePalette(logPalette);
		}
	}

	HPALETTE hOldPal = NULL;

	if (bHasPal)
	{
		hOldPal = dc.SelectPalette(pal, TRUE);
		dc.RealizePalette();
	}

	CRect rcClip = _pSurface->GetClipRect();

	int nHeightRender = rcClip.bottom - rcClip.top;
	int nWidthRender = rcClip.right - rcClip.left;

	CBrush brush;
	CRect r(0, 0, nWidthRender, nHeightRender);

	if (brush.CreateSolidBrush(RGB(255,255,255)))
	{		
		dc.FillRect(&r, brush);
	}

	PlayEnhMetaFile(dc, hemf, &r);
	::GdiFlush();

	if (hOldPal)
		dc.SelectPalette(hOldPal, FALSE);
}
void EMFPreviewWindow::OnPaint( wxPaintEvent& event )
{
    wxPaintDC dc(this);

    dc.Clear();
    
    RECT rc;
    rc.top = 0;
    rc.left = 0;
    rc.bottom = GetClientSize().GetHeight();
    rc.right = GetClientSize().GetWidth();

    PlayEnhMetaFile((HDC)dc.GetHDC(), m_meta, &rc);
}
Exemple #11
0
LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     static HENHMETAFILE hemf ;
     HDC                 hdc, hdcEMF ;
     PAINTSTRUCT         ps ;
     RECT                rect ;
     
     switch (message)
     {
     case WM_CREATE:
          hdcEMF = CreateEnhMetaFile (NULL, NULL, NULL, NULL) ;

          Rectangle (hdcEMF, 100, 100, 200, 200) ;
          
          MoveToEx  (hdcEMF, 100, 100, NULL) ;
          LineTo    (hdcEMF, 200, 200) ;
          
          MoveToEx  (hdcEMF, 200, 100, NULL) ;
          LineTo    (hdcEMF, 100, 200) ;

          hemf = CloseEnhMetaFile (hdcEMF) ;
          return 0 ;
          
     case WM_PAINT:
          hdc = BeginPaint (hwnd, &ps) ;
          
          GetClientRect (hwnd, &rect) ;
          
          rect.left   =     rect.right  / 4 ;
          rect.right  = 3 * rect.right  / 4 ;
          rect.top    =     rect.bottom / 4 ;
          rect.bottom = 3 * rect.bottom / 4 ;
          
          PlayEnhMetaFile (hdc, hemf, &rect) ;
          
          EndPaint (hwnd, &ps) ;
          return 0 ;
          
     case WM_DESTROY:
          DeleteEnhMetaFile (hemf) ;
          
          PostQuitMessage (0) ;
          return 0 ;
     }
     return DefWindowProc (hwnd, message, wParam, lParam) ;
}
Exemple #12
0
//
//	function for drawing the custom-draw inserted buttons
//	Called from the WM_NOTIFY handler (HandleCustomDraw)
//
UINT CALLBACK CoolSB_DrawProc(HDC hdc, UINT uCmdId, UINT uButflags, RECT *rect)
{
	RECT rc;
	POINT pt;
	HPEN hpen, hold;

	HBITMAP hbm, oldbm;
	HDC hdcmem;

	if(hemf == 0)
		InitMetaFile();

	SetRect(&rc, 0, 0, 120, rect->bottom-rect->top);

	hdcmem = CreateCompatibleDC(hdc);
	hbm = CreateCompatibleBitmap(hdc, rc.right, rc.bottom);
	oldbm = SelectObject(hdcmem, hbm);

	SetWindowOrgEx(hdc, -rect->left, -rect->top, &pt);
	PlayEnhMetaFile(hdcmem, hemf, &rc);
	BitBlt(hdc, 0, 0, rc.right, rc.bottom, hdcmem, 0, 0, SRCCOPY);
	
	SetRect(&rc, 120, 0, rect->right-rect->left, rect->bottom-rect->top);
	FillRect(hdc, &rc, GetSysColorBrush(COLOR_3DFACE));
	
	hpen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_3DSHADOW));
	hold = SelectObject(hdc, hpen);
	MoveToEx(hdc, 120, 0, 0);
	LineTo(hdc, rect->right-rect->left, 0);
	
	SetWindowOrgEx(hdc, pt.x, pt.y, 0);		

	
	SelectObject(hdc, hold);
	SelectObject(hdcmem, oldbm);
	DeleteObject(hbm);
	DeleteDC(hdcmem);
	DeleteObject(hpen);
	
	UNREFERENCED_PARAMETER(uButflags);
	UNREFERENCED_PARAMETER(uCmdId);
	return 0;
}
Exemple #13
0
void PlayPlaceableMeta(HDC hdc,BYTE *pMeta,int len,RECT *rt)
{
    HENHMETAFILE hEnh;
    PAPMHEADER pHeader=(PAPMHEADER)pMeta;
    METAFILEPICT mp;

    if(pHeader->dwKey == 0x9ac6cdd7l) {
        mp.mm = MM_ANISOTROPIC;
        mp.xExt = pHeader->bbox.Right - pHeader->bbox.Left;
        mp.xExt = ( mp.xExt * 2540l ) / (DWORD)(pHeader->wInch);
        mp.yExt = pHeader->bbox.Bottom - pHeader->bbox.Top;
        mp.yExt = ( mp.yExt * 2540l ) / (DWORD)(pHeader->wInch);
        mp.hMF = NULL;

        hEnh = SetWinMetaFileBits(len, &(pMeta[sizeof(APMHEADER)]), hdc, &mp);
        PlayEnhMetaFile(hdc,hEnh,rt);
        DeleteEnhMetaFile(hEnh);
    }
}
void PLWEMFDecoder::GetImage (PLBmpBase & Bmp)
{
	HPALETTE hpal = NULL;
  LPLOGPALETTE plogpal (0);

  if (GetBitsPerPixel() == 8) {
		plogpal = (LPLOGPALETTE)new PLBYTE[sizeof(LOGPALETTE) + (sizeof(PALETTEENTRY) * 256)];
		memset(plogpal,0x0,sizeof(LOGPALETTE) + sizeof(PALETTEENTRY)*256);
		plogpal->palVersion = 0x300;
		plogpal->palNumEntries = 256;
		if (plogpal == NULL) {
			PLASSERT(false);
			raiseError (PL_ERRNO_MEMORY,"Cannot allocate palette.");
		}
    UINT pe = GetEnhMetaFilePaletteEntries(m_hemf, 0, NULL);
		GetEnhMetaFilePaletteEntries(m_hemf, pe, plogpal->palPalEntry);
	}

	// Setup a logical palette for our memory dc and also a
	// paintlib compatible palette for the paintlib bitmap
  PLPixel32 pPal[256];
	if (plogpal) {
		for (UINT i = 0; i < 256; i++) {
			pPal[i] = *(PLPixel32*)&plogpal->palPalEntry[i];
		}

		if ((hpal = CreatePalette((LPLOGPALETTE)plogpal))) {
			m_holdpal = SelectPalette(m_memdc, hpal, false);
			RealizePalette(m_memdc);
		}
		Bmp.SetPalette(pPal);
		delete [] plogpal;
	}

	// Play the metafile into the device context
	// First, setup a bounding rectangle and fill
	// the memory dc with white (some metafiles only
	// use a black pen to draw and have no actual fill
	// color set, This would cause a black on black
	// painting which is rather useless
	RECT rc;
	rc.left = rc.top = 0;
	rc.bottom = GetHeight();
	rc.right = GetWidth();

	FillRect(m_memdc,&rc,(HBRUSH)GetStockObject(WHITE_BRUSH));

	// Heeere we go....
	BOOL bres = PlayEnhMetaFile(m_memdc,m_hemf,&rc);

	// Finally, convert the Windows bitmap into a paintlib bitmap
	PLWinBmp& winbmp = dynamic_cast<PLWinBmp&>(Bmp);
	BITMAPINFO* pBMI = (BITMAPINFO*)winbmp.GetBMI();
	PLBYTE* pBits = (PLBYTE*)winbmp.GetBits();
	if (GetBitsPerPixel() == 8) {
		GetDIBits(m_dc, m_bm, 0, GetHeight(), winbmp.GetBits(), pBMI, DIB_RGB_COLORS);
	}
	else {
		GetDIBits(m_dc, m_bm, 0, GetHeight(), winbmp.GetBits(), pBMI, DIB_PAL_COLORS);
	}
}
Exemple #15
0
/*
** 24-bit only
*/
int win_emf_to_bmp(wmetafile *wmf,int dpi,WILLUSBITMAP *bmp,FILE *out)

    {
    HENHMETAFILE hemf;
    HWND    h;
    ENHMETAHEADER   header;
    double  width_in,height_in,dpi_adjust;
    int     width_pix,height_pix;
    int     width_bytes;
    HDC     hDC,hMemDC;
    RECT    lprect;
    BITMAPINFO         *bmi;
    static  HBITMAP hBitmap=NULL;
    int planes,bpp;
    static char *funcname="win_emf_to_bmp";

    hemf=(HENHMETAFILE)wmf;
    h=GetDesktopWindow();
    GetEnhMetaFileHeader(hemf,sizeof(ENHMETAHEADER),&header);

    /* Set up bitmap dimensions */
    width_in = (header.rclFrame.right-header.rclFrame.left)/2540.;
    height_in = (header.rclFrame.bottom-header.rclFrame.top)/2540.;
    dpi_adjust = header.rclFrame.left==0 ? 1.0 : (1.0/5.8);
/*
printf("h.rclframe.left=%g\n",header.rclFrame.left/2540.);
printf("width_in = %g\n",width_in);
printf("szlmm = %d\n",header.szlMillimeters);
printf("szlpix = %d\n",header.szlDevice);
printf("iType = %d\n",header.iType);
printf("dSig = %d\n",header.dSignature);
printf("nDesc = %d\n",header.nDescription);
printf("nVer = %d\n",header.nVersion);
printf("h.rclbounds.left=%d\n",header.rclBounds.left);
printf("h.rclbounds.width=%d\n",header.rclBounds.right-header.rclBounds.left);
*/
    width_pix = (int)(width_in*dpi*dpi_adjust);
    height_pix = (int)(height_in*dpi*dpi_adjust);
    width_bytes=width_pix;
    while (width_bytes&3)
        width_bytes++;
    lprect.left=0;
    lprect.right=width_pix-1;
    lprect.top=0;
    lprect.bottom=height_pix-1;

    /*
    ** Allocate bit map info structure (has to be allocated due to
    ** arbitrarily sized color palette ==> cannot be statically declared)
    */
    if (!willus_mem_alloc((double **)&bmi,sizeof(BITMAPINFOHEADER)+256*sizeof(RGBQUAD),funcname))
        return(2);
    bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);

    // Get device context
    hDC=GetDC(h);
    if (hDC==NULL)
        {
        willus_mem_free((double **)&bmi,funcname);
        nprintf(out,"win_emf_to_bmp:  Could not get DC.\n");
        return(4);
        }

    planes=GetDeviceCaps(hDC,PLANES);
    bpp=GetDeviceCaps(hDC,BITSPIXEL);
    // Create a windows bitmap to play the metafile into
    hBitmap=CreateBitmap(width_pix,height_pix,planes,bpp,NULL);
    if (hBitmap==NULL)
        {
        ReleaseDC(h,hDC);
        willus_mem_free((double **)&bmi,funcname);
        return(5);
        }

    // Create a device context for the windows bitmap
    hMemDC=CreateCompatibleDC(hDC);
    if (hMemDC==NULL)
        {
        nprintf(out,"win_emf_to_bmp:  Could not create hMemDC.\n");
        DeleteObject(hBitmap);
        ReleaseDC(h,hDC);
        willus_mem_free((double **)&bmi,funcname);
        return(6);
        }

    // Select the windows bitmap into the new device context
    SelectObject(hMemDC,hBitmap);

    // Clear the windows bitmap
    PatBlt(hMemDC,0,0,width_pix,height_pix,WHITENESS); // White background

    // Play the metafile into it
    PlayEnhMetaFile(hMemDC,hemf,&lprect);

    bmp->bpp=24;
    bmp->width=width_pix;
    bmp->height=height_pix;
    bmp->type=WILLUSBITMAP_TYPE_WIN32;
    bmp_alloc(bmp);

    // Set up the device independent bitmap
    bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmi->bmiHeader.biWidth = width_pix;
    bmi->bmiHeader.biHeight = height_pix;
    bmi->bmiHeader.biPlanes = 1;
    bmi->bmiHeader.biBitCount = 24;
    bmi->bmiHeader.biCompression = BI_RGB;
    bmi->bmiHeader.biSizeImage = 0;
    bmi->bmiHeader.biXPelsPerMeter = (int)(dpi*100./2.54);
    bmi->bmiHeader.biYPelsPerMeter = (int)(dpi*100./2.54);
    bmi->bmiHeader.biClrUsed = 0;
    bmi->bmiHeader.biClrImportant = 0;

    // Get the bits from the windows bitmap into the DI bitmap
    GetDIBits(hMemDC,hBitmap,0,height_pix,bmp->data,bmi,DIB_RGB_COLORS);
    DeleteDC(hMemDC);
    DeleteObject(hBitmap);
    ReleaseDC(h,hDC);
    willus_mem_free((double **)&bmi,funcname);
    return(0);
    }
/* ************************************
* MainWndProc
* 窗口消息处理函数
**************************************/
LRESULT CALLBACK MainWndProc(
							 HWND hwnd,
							 UINT uMsg,
							 WPARAM wParam,
							 LPARAM lParam)
{
	static HWND hwndNextViewer;

	HDC hdc;
	HDC hdcMem;
	PAINTSTRUCT ps;
	LPPAINTSTRUCT lpps;
	RECT rc;
	LPRECT lprc;
	HGLOBAL hglb;
	LPSTR lpstr;
	HBITMAP hbm;
	HENHMETAFILE hemf;
	HWND hwndOwner;

	switch (uMsg)
	{
	case WM_PAINT: // 收到WM_PAINT消息后显示粘贴板中的数据
		hdc = BeginPaint(hwnd, &ps);
		// uForamt全局变量,在WM_DRAWCLIPBOARD和WM_COMMAND
		// 消息处理中,使用SetAutoView设置
		// 根据粘贴板中数据的不同格式,使用不同的显示方式
		switch (uFormat)
		{
			// Owner-display 格式,粘贴板的所有者必须显示并刷新Viewer的窗口
		case CF_OWNERDISPLAY:
			// 获取粘贴板的所有者
			hwndOwner = GetClipboardOwner();
			// 获取粘贴板数据
			hglb = GlobalAlloc(GMEM_MOVEABLE, sizeof(PAINTSTRUCT));
			lpps = GlobalLock(hglb);
			memcpy(lpps, &ps, sizeof(PAINTSTRUCT));
			GlobalUnlock(hglb);
			// 向粘贴板所有都发送WM_PAINTCLIPBOARD消息
			SendMessage(hwndOwner, WM_PAINTCLIPBOARD,
				(WPARAM) hwnd, (LPARAM) hglb);
			GlobalFree(hglb);
			break;
			// 位图
		case CF_BITMAP:
			// 创建DC
			hdcMem = CreateCompatibleDC(hdc);
			if (hdcMem != NULL)
			{
				if (OpenClipboard(hwnd)) // 打开粘贴板
				{
					// 获取粘贴板数据
					hbm = (HBITMAP) GetClipboardData(uFormat);
					// 将位图选择入DC,显示在窗口客户区
					SelectObject(hdcMem, hbm);
					GetClientRect(hwnd, &rc);
					BitBlt(hdc, 0, 0, rc.right, rc.bottom,
						hdcMem, 0, 0, SRCCOPY);
					// 关闭粘贴板
					CloseClipboard();
				}
				// 释放DC
				DeleteDC(hdcMem);
			}
			break;
			// 文本
		case CF_TEXT:
			if (OpenClipboard(hwnd)) // 打开粘贴板
			{
				// 获得粘贴板数据
				hglb = GetClipboardData(uFormat);
				lpstr = GlobalLock(hglb);
				// 将文件绘制在窗口客户区
				GetClientRect(hwnd, &rc);
				DrawText(hdc, lpstr, -1, &rc, DT_LEFT);

				GlobalUnlock(hglb);
				// 关闭粘贴板
				CloseClipboard();
			}
			break;
			// enhanced-format metafile,加强格式图元文件
		case CF_ENHMETAFILE:
			// 打开粘贴板
			if (OpenClipboard(hwnd))
			{
				// 获取数据
				hemf = GetClipboardData(uFormat);
				// 调用PlayEnhMetaFile在窗口客户区上显示
				GetClientRect(hwnd, &rc);
				PlayEnhMetaFile(hdc, hemf, &rc);
				CloseClipboard();
			}
			break;

		case 0: // 粘贴板为空
			GetClientRect(hwnd, &rc);
			// 在窗户区中央显示
			DrawText(hdc, "The clipboard is empty.", -1,
				&rc, DT_CENTER | DT_SINGLELINE |
				DT_VCENTER);
			break;

		default: // 不支持其他格式
				//CF_DIB
				//CF_DIBV5
				//CF_DIF
				//CF_DSPBITMAP
				//CF_DSPENHMETAFILE
				//CF_DSPMETAFILEPICT
				//CF_DSPTEXT
				//CF_ENHMETAFILE
				//CF_HDROP
				//CF_LOCALE
				//CF_METAFILEPICT
				//CF_PALETTE
				//CF_PENDATA
				//CF_PRIVATEFIRST
				//CF_RIFF
				//CF_SYLK
				//CF_WAVE
				//CF_TIFF
				//CF_UNICODETEXT
				GetClientRect(hwnd, &rc);
			DrawText(hdc, "Unable to display format.", -1,
				&rc, DT_CENTER | DT_SINGLELINE |
				DT_VCENTER);
		}
		EndPaint(hwnd, &ps);
		break;

	case WM_SIZE: // 如果窗口大小改变,通知粘贴板所有者窗口
		if (uFormat == CF_OWNERDISPLAY)
		{
			hwndOwner = GetClipboardOwner();
			hglb = GlobalAlloc(GMEM_MOVEABLE, sizeof(RECT));
			lprc = GlobalLock(hglb);
			GetClientRect(hwnd, lprc);
			GlobalUnlock(hglb);

			SendMessage(hwndOwner, WM_SIZECLIPBOARD,
				(WPARAM) hwnd, (LPARAM) hglb);

			GlobalFree(hglb);
		}
		break;

	case WM_CREATE:

		// 在窗口创建时,在粘贴板Viewer链中增加一个Viewer
		hwndNextViewer = SetClipboardViewer(hwnd);
		break;

	case WM_CHANGECBCHAIN://Viewer链中的节点变化时会收到此消息

		// 在链中增加本Viewer后,位于链的第一个节点
		// 当链中有Viewer移除时,链中的第一个Viewer会收到此消息
		// 如果是本Viewer的下一个Viewer移除,那么更新
		if ((HWND) wParam == hwndNextViewer)
			hwndNextViewer = (HWND) lParam;
		// 否则将消息向下一个Viewer传递
		else if (hwndNextViewer != NULL)
			SendMessage(hwndNextViewer, uMsg, wParam, lParam);
		break;

	case WM_DESTROY:// 窗口关闭
		// 设置Viewer链,移除本Viewer。
		ChangeClipboardChain(hwnd, hwndNextViewer);
		// 退出
		PostQuitMessage(0);
		break;

	case WM_DRAWCLIPBOARD: // 粘贴板的内容改变时会收到此消息

		// 设置显示格式为Auto
		SetAutoView(hwnd);

		// 将消息发送给Viewer链中的下一个窗口
		SendMessage(hwndNextViewer, uMsg, wParam, lParam);
		break;

	case WM_INITMENUPOPUP:// 当POPUP菜单弹出时收到此消息
		// 根据粘贴板中内容的格式设置菜单
		if (!HIWORD(lParam))
			InitMenu(hwnd, (HMENU) wParam);
		break;

	case WM_COMMAND: // 处理用户菜单输入
		switch (LOWORD(wParam))
		{
		case ID_NULL:
			break;

		case ID_AUTO: // 点击auto菜单项
			SetAutoView(hwnd); // 设置显示格式为自动
			break;

		default:
			// 用户选择了特定的显示格式
			// 设置显示模式,uFormat全局变量
			// uFormat在WM_PAINT消息时引用
			fAuto = FALSE;
			uFormat = LOWORD(wParam);
			InvalidateRect(hwnd, NULL, TRUE);
		}
		break;

	default: // 其他消息
		return DefWindowProc(hwnd, uMsg, wParam, lParam);
	}
	return (LRESULT) NULL;
}
Exemple #17
0
void WinMetaFile::Paint(Draw& w, const Rect& r) const {
	ChkP();
	if(hemf)
		PlayEnhMetaFile(w, hemf, r);
}
Exemple #18
0
bool CxImageWMF::Decode(CxFile *hFile, long nForceWidth, long nForceHeight)
{
	if (hFile == NULL) return false;

	HENHMETAFILE	hMeta;
	HDC				hDC;
	int				cx,cy;

	//save the current position of the file
	long pos = hFile->Tell();

	// Read the Metafile and convert to an Enhanced Metafile
	METAFILEHEADER	mfh;
	hMeta = ConvertWmfFiletoEmf(hFile, &mfh);
	if (hMeta) {	// ok, it's a WMF

/////////////////////////////////////////////////////////////////////
//	We use the original WMF size information, because conversion to
//	EMF adjusts the Metafile to Full Screen or does not set rclBounds at all
//	ENHMETAHEADER	emh;
//	UINT			uRet;
//	uRet = GetEnhMetaFileHeader(hMeta,					// handle of enhanced metafile 
//								sizeof(ENHMETAHEADER),	// size of buffer, in bytes 
//								&emh); 					// address of buffer to receive data  
//	if (!uRet){
//		DeleteEnhMetaFile(hMeta);
//		return false;
//	}
//	// calculate size
//	cx = emh.rclBounds.right - emh.rclBounds.left;
//	cy = emh.rclBounds.bottom - emh.rclBounds.top;
/////////////////////////////////////////////////////////////////////

		// calculate size
		// scale the metafile (pixels/inch of metafile => pixels/inch of display)
		// mfh.inch already checked to be <> 0

		hDC = ::GetDC(0);
		int cx1 = ::GetDeviceCaps(hDC, LOGPIXELSX);
		int cy1 = ::GetDeviceCaps(hDC, LOGPIXELSY);
		::ReleaseDC(0, hDC);

		cx = (mfh.bbox.right - mfh.bbox.left) * cx1 / mfh.inch;
		cy = (mfh.bbox.bottom - mfh.bbox.top) * cy1 / mfh.inch;

	} else {		// maybe it's an EMF...

		hFile->Seek(pos,SEEK_SET);

		ENHMETAHEADER	emh;
		hMeta = ConvertEmfFiletoEmf(hFile, &emh);

		if (!hMeta){
			strcpy(info.szLastError,"corrupted WMF");
			return false; // definitively give up
		}
		// ok, it's an EMF
		// calculate size
		cx = emh.rclBounds.right - emh.rclBounds.left;
		cy = emh.rclBounds.bottom - emh.rclBounds.top;
	}

	if (info.nEscape) {	// Check if cancelled
		DeleteEnhMetaFile(hMeta);
		strcpy(info.szLastError,"Cancelled");
		return false;
	}

	if (!cx || !cy)	{
		DeleteEnhMetaFile(hMeta);
		strcpy(info.szLastError,"empty WMF");
		return false;
	}

	if (nForceWidth) cx=nForceWidth;
	if (nForceHeight) cy=nForceHeight;
	ShrinkMetafile(cx, cy);		// !! Otherwise Bitmap may have bombastic size

	HDC hDC0 = GetDC(0);	// DC of screen
	HBITMAP hBitmap = CreateCompatibleBitmap(hDC0, cx, cy);	// has # colors of display
	hDC = CreateCompatibleDC(hDC0);	// memory dc compatible with screen
	ReleaseDC(0, hDC0);	// don't need anymore. get rid of it.

	if (hDC){
		if (hBitmap){
			RECT rc = {0,0,cx,cy};
			int bpp = ::GetDeviceCaps(hDC, BITSPIXEL);

			HBITMAP hBitmapOld = (HBITMAP)SelectObject(hDC, hBitmap);

			// clear out the entire bitmap with windows background
			// because the MetaFile may not contain background information
			DWORD	dwBack = XMF_COLOR_BACK;
#if XMF_SUPPORT_TRANSPARENCY
			if (bpp == 24) dwBack = XMF_COLOR_TRANSPARENT;
#endif
		    DWORD OldColor = SetBkColor(hDC, dwBack);
		    ExtTextOut(hDC, 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL);
			SetBkColor(hDC, OldColor);

			//retrieves optional palette entries from the specified enhanced metafile
			PLOGPALETTE plogPal;
			PBYTE pjTmp; 
			HPALETTE hPal; 
			int iEntries = GetEnhMetaFilePaletteEntries(hMeta, 0, NULL);
			if (iEntries) { 
				if ((plogPal = (PLOGPALETTE)GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, 
					sizeof(DWORD) + sizeof(PALETTEENTRY)*iEntries )) == NULL) { 
					DeleteObject(hBitmap);
					DeleteDC(hDC);
					DeleteEnhMetaFile(hMeta);
					strcpy(info.szLastError,"Cancelled");
					return false;
				} 

				plogPal->palVersion = 0x300; 
				plogPal->palNumEntries = (WORD) iEntries; 
				pjTmp = (PBYTE) plogPal; 
				pjTmp += 4; 

				GetEnhMetaFilePaletteEntries(hMeta, iEntries, (PPALETTEENTRY)pjTmp); 
				hPal = CreatePalette(plogPal); 
				GlobalFree(plogPal); 

				SelectPalette(hDC, hPal, FALSE); 
				RealizePalette(hDC); 
			} 
			
			// Play the Metafile into Memory DC
			BOOL bRet = PlayEnhMetaFile(hDC,	// handle to a device context 
									hMeta,	// handle to an enhanced metafile  
									&rc); 	// pointer to bounding rectangle

			SelectObject(hDC, hBitmapOld);
			DeleteEnhMetaFile(hMeta);	// we are done with this one

			if (info.nEscape) {	// Check if cancelled
				DeleteObject(hBitmap);
				DeleteDC(hDC);
				strcpy(info.szLastError,"Cancelled");
				return false;
			}

			// the Bitmap now has the image.
			// Create our DIB and convert the DDB into DIB
			if (!Create(cx, cy, bpp, CXIMAGE_FORMAT_WMF)) {
				DeleteObject(hBitmap);
				DeleteDC(hDC);
				return false;
			}

#if XMF_SUPPORT_TRANSPARENCY
			if (bpp == 24) {
				RGBQUAD	rgbTrans = { XMF_RGBQUAD_TRANSPARENT };
				SetTransColor(rgbTrans);
			}
#endif
		    // We're finally ready to get the DIB. Call the driver and let
		    // it party on our bitmap. It will fill in the color table,
		    // and bitmap bits of our global memory block.
			bRet = GetDIBits(hDC, hBitmap, 0,
			        (UINT)cy, GetBits(), (LPBITMAPINFO)pDib, DIB_RGB_COLORS);

			DeleteObject(hBitmap);
			DeleteDC(hDC);

			return (bRet!=0);
		} else {
			DeleteDC(hDC);
		}
	} else {
		if (hBitmap) DeleteObject(hBitmap);
	}

	DeleteEnhMetaFile(hMeta);

	return false;
}
Exemple #19
0
// ================ PlayFile - PlayRecords =======================
//
BOOL COXMetaFile::PlayFile(CDC* pDC)
{	
	CRect cRect(0,0,m_rectBounds.right-m_rectBounds.left,
		m_rectBounds.bottom-m_rectBounds.top);
	return PlayEnhMetaFile(pDC->m_hDC,m_hEMF,&cRect); 
}
Exemple #20
0
static Image *ReadEMFImage(const ImageInfo *image_info,
  ExceptionInfo *exception)
{
  BITMAPINFO
    DIBinfo;

  HBITMAP
    hBitmap,
    hOldBitmap;

  HDC
    hDC;

  HENHMETAFILE
    hemf;

  Image
    *image;

  long
    height,
    width,
    y;

  RECT
    rect;

  register long
    x;

  register PixelPacket
    *q;

  RGBQUAD
    *pBits,
    *ppBits;

  image=AllocateImage(image_info);
  hemf=ReadEnhMetaFile(image_info->filename,&width,&height);
  if (!hemf)
    ThrowReaderException(CorruptImageError,ImproperImageHeader,image);
  if ((image->columns == 0) || (image->rows == 0))
    {
      double
        y_resolution = 72.0,
        x_resolution = 72.0;

      if (image->y_resolution > 0)
        {
          y_resolution=image->y_resolution;
          if (image->units == PixelsPerCentimeterResolution)
            y_resolution*=CENTIMETERS_INCH;
        }
      if (image->x_resolution > 0)
        {
          x_resolution=image->x_resolution;
          if (image->units == PixelsPerCentimeterResolution)
            x_resolution*=CENTIMETERS_INCH;
        }
      image->rows=ceil((height*CENTIMETERS_INCH)/1000*y_resolution);
      image->columns=ceil((width*CENTIMETERS_INCH)/1000*x_resolution);
    }
  if (image_info->size != (char *) NULL)
    {
      long
        x;

      image->columns=width;
      image->rows=height;
      x=0;
      y=0;
      (void) GetGeometry(image_info->size,&x,&y,&image->columns,&image->rows);
    }
  if (image_info->page != (char *) NULL)
    {
      char
        *geometry;

      long
        sans;

      register char
        *p;

/*       unsigned int */
/*         flags; */

      geometry=GetPageGeometry(image_info->page);
      p=strchr(geometry,'>');
      if (!p)
        {
          /*flags=*/ (void) GetMagickGeometry(geometry,&sans,&sans,&image->columns,
            &image->rows);
          if (image->x_resolution != 0.0)
            image->columns=(unsigned int)
              ((image->columns*image->x_resolution)+0.5);
          if (image->y_resolution != 0.0)
            image->rows=(unsigned int)
              ((image->rows*image->y_resolution)+0.5);
        }
      else
        {
          *p='\0';
          /*flags=*/ (void) GetMagickGeometry(geometry,&sans,&sans,&image->columns,
            &image->rows);
          if (image->x_resolution != 0.0)
            image->columns=(unsigned int)
              (((image->columns*image->x_resolution)/72.0)+0.5);
          if (image->y_resolution != 0.0)
            image->rows=(unsigned int)
              (((image->rows*image->y_resolution)/72.0)+0.5);
        }
      MagickFreeMemory(geometry);
    }
  hDC=GetDC(NULL);
  if (!hDC)
    ThrowReaderException(CoderError,UnableToCreateADC,image);
  /*
    Initialize the bitmap header info.
  */
  (void) memset(&DIBinfo,0,sizeof(BITMAPINFO));
  DIBinfo.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
  DIBinfo.bmiHeader.biWidth=image->columns;
  DIBinfo.bmiHeader.biHeight=(-1)*image->rows;
  DIBinfo.bmiHeader.biPlanes=1;
  DIBinfo.bmiHeader.biBitCount=32;
  DIBinfo.bmiHeader.biCompression=BI_RGB;
  hBitmap=
    CreateDIBSection(hDC,&DIBinfo,DIB_RGB_COLORS,(void **) &ppBits,NULL,0);
  ReleaseDC(NULL,hDC);
  if (!hBitmap)
    ThrowReaderException(CoderError,UnableToCreateBitmap,image);
  hDC=CreateCompatibleDC(NULL);
  if (!hDC)
    {
      DeleteObject(hBitmap);
      ThrowReaderException(CoderError,UnableToCreateADC,image);
    }
  hOldBitmap=(HBITMAP) SelectObject(hDC,hBitmap);
  if (!hOldBitmap)
    {
      DeleteDC(hDC);
      DeleteObject(hBitmap);
      ThrowReaderException(CoderError,UnableToCreateBitmap,image);
    }
  /*
    Initialize the bitmap to the image background color.
  */
  pBits=ppBits;
  for (y=0; y < (long) image->rows; y++)
  {
    for (x=0; x < (long) image->columns; x++)
    {
      pBits->rgbRed=ScaleQuantumToChar(image->background_color.red);
      pBits->rgbGreen=ScaleQuantumToChar(image->background_color.green);
      pBits->rgbBlue=ScaleQuantumToChar(image->background_color.blue);
      pBits++;
    }
  }
  rect.top=0;
  rect.left=0;
  rect.right=image->columns;
  rect.bottom=image->rows;
  /*
    Convert metafile pixels.
  */
  PlayEnhMetaFile(hDC,hemf,&rect);
  pBits=ppBits;
  for (y=0; y < (long) image->rows; y++)
  {
    q=SetImagePixels(image,0,y,image->columns,1);
    if (q == (PixelPacket *) NULL)
      break;
    for (x=0; x < (long) image->columns; x++)
    {
      q->red=ScaleCharToQuantum(pBits->rgbRed);
      q->green=ScaleCharToQuantum(pBits->rgbGreen);
      q->blue=ScaleCharToQuantum(pBits->rgbBlue);
      q->opacity=OpaqueOpacity;
      pBits++;
      q++;
    }
    if (!SyncImagePixels(image))
      break;
  }
  if (hemf)
    DeleteEnhMetaFile(hemf);
  SelectObject(hDC,hOldBitmap);
  DeleteDC(hDC);
  DeleteObject(hBitmap);
  return(image);
}
Exemple #21
0
PyObject *
PyImaging_DrawWmf(PyObject* self, PyObject* args)
{
    HBITMAP bitmap;
    HENHMETAFILE meta;
    BITMAPCOREHEADER core;
    HDC dc;
    RECT rect;
    PyObject* buffer = NULL;
    char* ptr;

    char* data;
    int datasize;
    int width, height;
    int x0, y0, x1, y1;
    if (!PyArg_ParseTuple(args, PY_ARG_BYTES_LENGTH"(ii)(iiii):_load", &data, &datasize,
                          &width, &height, &x0, &x1, &y0, &y1))
        return NULL;

    /* step 1: copy metafile contents into METAFILE object */

    if (datasize > 22 && GET32(data, 0) == 0x9ac6cdd7) {

        /* placeable windows metafile (22-byte aldus header) */
        meta = SetWinMetaFileBits(datasize-22, data+22, NULL, NULL);

    } else if (datasize > 80 && GET32(data, 0) == 1 &&
               GET32(data, 40) == 0x464d4520) {

        /* enhanced metafile */
        meta = SetEnhMetaFileBits(datasize, data);

    } else {

        /* unknown meta format */
        meta = NULL;

    }

    if (!meta) {
        PyErr_SetString(PyExc_IOError, "cannot load metafile");
        return NULL;
    }

    /* step 2: create bitmap */

    core.bcSize = sizeof(core);
    core.bcWidth = width;
    core.bcHeight = height;
    core.bcPlanes = 1;
    core.bcBitCount = 24;

    dc = CreateCompatibleDC(NULL);

    bitmap = CreateDIBSection(
        dc, (BITMAPINFO*) &core, DIB_RGB_COLORS, &ptr, NULL, 0
        );

    if (!bitmap) {
        PyErr_SetString(PyExc_IOError, "cannot create bitmap");
        goto error;
    }

    if (!SelectObject(dc, bitmap)) {
        PyErr_SetString(PyExc_IOError, "cannot select bitmap");
        goto error;
    }

    /* step 3: render metafile into bitmap */

    rect.left = rect.top = 0;
    rect.right = width;
    rect.bottom = height;

    /* FIXME: make background transparent? configurable? */
    FillRect(dc, &rect, GetStockObject(WHITE_BRUSH));

    if (!PlayEnhMetaFile(dc, meta, &rect)) {
        PyErr_SetString(PyExc_IOError, "cannot render metafile");
        goto error;
    }

    /* step 4: extract bits from bitmap */

    GdiFlush();

    buffer = PyBytes_FromStringAndSize(ptr, height * ((width*3 + 3) & -4));

error:
    DeleteEnhMetaFile(meta);

    if (bitmap)
        DeleteObject(bitmap);

    DeleteDC(dc);

    return buffer;
}
STDMETHODIMP DropTarget_Drop(DropTarget *dt,
			     IDataObject *ido,
			     DWORD keyState,
			     POINTL pt,
			     DWORD *effect) {
  STGMEDIUM medium;
  FORMATETC fmtetc;
  HRESULT hRes;

  freeDropFiles();

  DPRINTF(("DropTarget_Drop\n"));
  fmtetc.cfFormat = CF_HDROP;
  fmtetc.ptd = NULL;
  fmtetc.lindex = -1;
  fmtetc.dwAspect = DVASPECT_CONTENT;
  fmtetc.tymed = TYMED_HGLOBAL;
  DPRINTF(("Looking for file...\n"));

  hRes = ido->lpVtbl->GetData(ido, &fmtetc, &medium);
  if(hRes == S_OK) {
    HGLOBAL hDrop = medium.hGlobal;
    DWORD i;

    DPRINTF(("Success\n"));
    numDropFiles = DragQueryFile(hDrop, -1, NULL, 0);
    dropFiles = calloc(numDropFiles, sizeof(char*));
    for(i=0; i<numDropFiles; i++) {
      WCHAR *tmpPath;
      int len;
      len = DragQueryFileW(hDrop, i, NULL, 0);
      tmpPath = calloc(len+1, sizeof(WCHAR));
      DragQueryFileW(hDrop, i, tmpPath, len+1);
      len = WideCharToMultiByte(CP_UTF8, 0, tmpPath, -1, NULL, 0,NULL,NULL);
      dropFiles[i] = malloc(len);
      WideCharToMultiByte(CP_UTF8,0,tmpPath,-1,dropFiles[i],len,NULL,NULL);
      free(tmpPath);
      DPRINTF(("File: %s\n", dropFiles[i]));
    }
    DragFinish(hDrop);
    signalDrop(pt);
    if(medium.pUnkForRelease == NULL) {
      GlobalFree(hDrop);
    } else {
      medium.pUnkForRelease->lpVtbl->Release(medium.pUnkForRelease);
    }
    return S_OK;
  }

  if(FAILED(hRes)) {
    DPRINTF(("GetData failed (errCode = %x)\n", hRes));
  }

  fmtetc.cfFormat = CF_DIB;
  fmtetc.ptd = NULL;
  fmtetc.lindex = -1;
  fmtetc.dwAspect = DVASPECT_CONTENT;
  fmtetc.tymed = TYMED_HGLOBAL;
  DPRINTF(("Looking for HDIB...\n"));

  hRes = ido->lpVtbl->GetData(ido, &fmtetc, &medium);
  if(hRes == S_OK) {
    TCHAR tmpName[MAX_PATH+1];
    HANDLE hDib = medium.hGlobal;

    DPRINTF(("Success\n"));

    GetTempPath(MAX_PATH,tmpName);
    strcat(tmpName,"$$squeak$$.bmp");
    if(WriteDIB(tmpName, hDib)) {
      numDropFiles = 1;
      dropFiles = calloc(1, sizeof(void*));
      dropFiles[0] = _strdup(tmpName);
    }
    if(medium.pUnkForRelease == NULL) {
      GlobalFree(hDib);
    } else {
      medium.pUnkForRelease->lpVtbl->Release(medium.pUnkForRelease);
    }
    signalDrop(pt);
    return S_OK;
  }

  if(FAILED(hRes)) {
    DPRINTF(("GetData failed (errCode = %x)\n", hRes));
  }

  fmtetc.cfFormat = CF_BITMAP;
  fmtetc.ptd = NULL;
  fmtetc.lindex = -1;
  fmtetc.dwAspect = DVASPECT_CONTENT;
  fmtetc.tymed = TYMED_HGLOBAL;
  DPRINTF(("Looking for bitmap...\n"));

  hRes = ido->lpVtbl->GetData(ido, &fmtetc, &medium);
  if(hRes == S_OK) {
    TCHAR tmpName[MAX_PATH+1];
    HANDLE hDib;
    HBITMAP hBM = medium.hBitmap;

    DPRINTF(("Success\n"));

    GetTempPath(MAX_PATH,tmpName);
    strcat(tmpName,"$$squeak$$.bmp");
    hDib = DibFromBitmap(hBM, BI_RGB, 0, NULL);
    if(hDib) {
      if(WriteDIB(tmpName, hDib)) {
	numDropFiles = 1;
	dropFiles = calloc(1, sizeof(void*));
	dropFiles[0] = _strdup(tmpName);
      }
      DeleteObject(hDib);
    }
    if(medium.pUnkForRelease == NULL) {
      DeleteObject(hBM);
    } else {
      medium.pUnkForRelease->lpVtbl->Release(medium.pUnkForRelease);
    }
    signalDrop(pt);
    return S_OK;
  }
  if(FAILED(hRes)) {
    DPRINTF(("GetData failed (errCode = %x)\n", hRes));
  }

  fmtetc.cfFormat = CF_ENHMETAFILE;
  fmtetc.ptd = NULL;
  fmtetc.lindex = -1;
  fmtetc.dwAspect = DVASPECT_CONTENT;
  fmtetc.tymed = TYMED_ENHMF;
  DPRINTF(("Looking for ENHMF...\n"));

  hRes = ido->lpVtbl->GetData(ido, &fmtetc, &medium);
  if(hRes == S_OK) {
    TCHAR tmpName[MAX_PATH+1];
    HANDLE hMF = medium.hGlobal;
    HANDLE hDib;
    BITMAPINFO bmi;
    ENHMETAHEADER header;

    DPRINTF(("Success\n"));

    if(GetEnhMetaFileHeader(hMF, sizeof(header), &header) == 0) {
      DPRINTF(("GetEnhMetaFileHeader failed\n"));
    }
    bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmi.bmiHeader.biPlanes = 1;
    bmi.bmiHeader.biBitCount = 24;
    bmi.bmiHeader.biCompression = BI_RGB;
    bmi.bmiHeader.biWidth = header.rclBounds.right - header.rclBounds.left;
    bmi.bmiHeader.biHeight = header.rclBounds.bottom - header.rclBounds.top;
    DPRINTF(("w=%d\nh=%d\n", bmi.bmiHeader.biWidth, bmi.bmiHeader.biHeight));
    {
      HDC hDC, mDC;
      HANDLE old, hBM;
      RECT rect;

      hDC = GetDC(stWindow);
      if(!hDC) DPRINTF(("GetDC() failed\n"));
      //      hDib = CreateDIBitmap(hDC, &bmi, 0, NULL, &bmi, DIB_RGB_COLORS);
      hBM = CreateDIBSection(hDC, &bmi, DIB_RGB_COLORS, NULL, NULL, 0);
      if(!hBM) DPRINTF(("CreateDIBSection() failed\n"));
      mDC = CreateCompatibleDC(hDC);
      if(!mDC) DPRINTF(("CreateCompatibleDC() failed\n"));
      old = SelectObject(mDC, hBM);
      rect.left = rect.top = 0;
      rect.right = bmi.bmiHeader.biWidth;
      rect.bottom = bmi.bmiHeader.biHeight;
      if(!PlayEnhMetaFile(mDC, hMF, &rect))
	DPRINTF(("PlayEnhMetaFile() failed\n"));
      SelectObject(mDC, old);
      DeleteDC(mDC);
      ReleaseDC(stWindow, hDC);
      hDib = DibFromBitmap(hBM, BI_RGB, 0, NULL);
      DeleteObject(hBM);
    }

    GetTempPath(MAX_PATH,tmpName);
    strcat(tmpName,"$$squeak$$.bmp");
    if(WriteDIB(tmpName, hDib)) {
      numDropFiles = 1;
      dropFiles = calloc(1, sizeof(void*));
      dropFiles[0] = _strdup(tmpName);
    }
    GlobalFree(hDib);
    if(medium.pUnkForRelease == NULL) {
      DeleteObject(hMF);
    } else {
      medium.pUnkForRelease->lpVtbl->Release(medium.pUnkForRelease);
    }
    signalDrop(pt);
    return S_OK;
  }

  if(FAILED(hRes)) {
    DPRINTF(("GetData failed (errCode = %x)\n", hRes));
  }


  return S_OK;
}
Exemple #23
0
BOOL __stdcall pvdDisplayPaint2(void *pContext, void* pDisplayContext, pvdInfoDisplayPaint2* pDisplayPaint)
{
	_ASSERTE(pDisplayPaint->cbSize >= sizeof(pvdInfoDisplayPaint2));
	_ASSERTE(pDisplayContext);

	BOOL lbRc = FALSE;
	WmfContext* p = (WmfContext*)pDisplayContext;

	switch (pDisplayPaint->Operation)
	{
	case PVD_IDP_BEGIN:
		{
			//if (!BeginPaint(pDisplayPaint->hWnd, &p->ps)) {
			if (!(p->ps.hdc = GetDC(pDisplayPaint->hWnd))) {
				pDisplayPaint->nErrNumber = PWE_WIN32_ERROR;
				gnLastWin32Error = GetLastError();
			} else {
				lbRc = TRUE;
			}
		} break;
	case PVD_IDP_COMMIT:
		{
			//EndPaint(pDisplayPaint->hWnd, &p->ps);
			ReleaseDC(pDisplayPaint->hWnd, p->ps.hdc);
			lbRc = TRUE;
		} break;
	case PVD_IDP_COLORFILL:
		{
			ColorFill(p->ps.hdc, pDisplayPaint->DisplayRect, pDisplayPaint->nBackColor);
			lbRc = TRUE;
		} break;
	case PVD_IDP_PAINT:
		{
			
			if (pDisplayPaint->DisplayRect.right == pDisplayPaint->DisplayRect.left
				|| pDisplayPaint->DisplayRect.bottom == pDisplayPaint->DisplayRect.top
				|| pDisplayPaint->ImageRect.right == pDisplayPaint->ImageRect.left
				|| pDisplayPaint->ImageRect.bottom == pDisplayPaint->ImageRect.top
				)
			{
				ColorFill(p->ps.hdc, pDisplayPaint->DisplayRect, pDisplayPaint->nBackColor);
				lbRc = FALSE;
				pDisplayPaint->nErrNumber = PWE_INVALID_RECT;
			} else {

				SIZE FullSize = p->PreferredSize;
				POINT StartPoint = {0,0};

				if (pDisplayPaint->ImageRect.left || pDisplayPaint->ImageRect.top
					|| ((pDisplayPaint->DisplayRect.right - pDisplayPaint->DisplayRect.left) != FullSize.cx)
					|| ((pDisplayPaint->DisplayRect.bottom - pDisplayPaint->DisplayRect.top) != FullSize.cy))
				{
					FullSize.cx = (pDisplayPaint->DisplayRect.right - pDisplayPaint->DisplayRect.left)
						* p->PreferredSize.cx / (pDisplayPaint->ImageRect.right - pDisplayPaint->ImageRect.left);
					FullSize.cy = (pDisplayPaint->DisplayRect.bottom - pDisplayPaint->DisplayRect.top)
						* p->PreferredSize.cy / (pDisplayPaint->ImageRect.bottom - pDisplayPaint->ImageRect.top);
					_ASSERTE(FullSize.cx && FullSize.cy);
					StartPoint.x = pDisplayPaint->ImageRect.left * FullSize.cx / p->PreferredSize.cx;
					StartPoint.y = pDisplayPaint->ImageRect.top * FullSize.cy / p->PreferredSize.cy;
				}

				if (FullSize.cx != p->CurrentSize.cx || FullSize.cy != p->CurrentSize.cy) {
					if (!p->CreateComp(p->ps.hdc, FullSize.cx, FullSize.cy)) {
						pDisplayPaint->nErrNumber = PWE_WIN32_ERROR;
						gnLastWin32Error = GetLastError();
						lbRc = FALSE;
					} else {
						RECT rcFill = {0,0,FullSize.cx,FullSize.cy};

						ColorFill(p->hCompDC, rcFill, pDisplayPaint->nBackColor);

						// To stop this function, an application can call the CancelDC function from another thread to terminate the operation. In this case, the function returns FALSE.
						lbRc = PlayEnhMetaFile(p->hCompDC, p->h, &rcFill);
						if (!lbRc) {
							pDisplayPaint->nErrNumber = PWE_WIN32_ERROR;
							gnLastWin32Error = GetLastError();
						}
					}
				}

				if (p->hCompDC) {
					lbRc = BitBlt(p->ps.hdc, pDisplayPaint->DisplayRect.left, pDisplayPaint->DisplayRect.top,
						pDisplayPaint->DisplayRect.right - pDisplayPaint->DisplayRect.left,
						pDisplayPaint->DisplayRect.bottom - pDisplayPaint->DisplayRect.top,
						p->hCompDC, StartPoint.x, StartPoint.y, SRCCOPY);
					if (!lbRc) {
						pDisplayPaint->nErrNumber = PWE_WIN32_ERROR;
						gnLastWin32Error = GetLastError();
					}
				}
			}
		}
	}

	return lbRc;
}
Exemple #24
0
static Image *ReadEMFImage(const ImageInfo *image_info,
  ExceptionInfo *exception)
{
  BITMAPINFO
    DIBinfo;

  HBITMAP
    hBitmap,
    hOldBitmap;

  HDC
    hDC;

  HENHMETAFILE
    hemf;

  Image
    *image;

  long
    height,
    width,
    y;

  RECT
    rect;

  register long
    x;

  register PixelPacket
    *q;

  RGBQUAD
    *pBits,
    *ppBits;

  image=AcquireImage(image_info);
  hemf=ReadEnhMetaFile(image_info->filename,&width,&height);
  if (hemf == (HENHMETAFILE) NULL)
    ThrowReaderException(CorruptImageError,"ImproperImageHeader");
  if ((image->columns == 0) || (image->rows == 0))
    {
      double
        y_resolution,
        x_resolution;

      y_resolution=DefaultResolution;
      x_resolution=DefaultResolution;
      if (image->y_resolution > 0)
        {
          y_resolution=image->y_resolution;
          if (image->units == PixelsPerCentimeterResolution)
            y_resolution*=CENTIMETERS_INCH;
        }
      if (image->x_resolution > 0)
        {
          x_resolution=image->x_resolution;
          if (image->units == PixelsPerCentimeterResolution)
            x_resolution*=CENTIMETERS_INCH;
        }
      image->rows=(unsigned long) ((height/1000.0/CENTIMETERS_INCH)*
        y_resolution+0.5);
      image->columns=(unsigned long) ((width/1000.0/CENTIMETERS_INCH)*
        x_resolution+0.5);
    }
  if (image_info->size != (char *) NULL)
    {
      long
        x;

      image->columns=width;
      image->rows=height;
      x=0;
      y=0;
      (void) GetGeometry(image_info->size,&x,&y,&image->columns,&image->rows);
    }
  if (image_info->page != (char *) NULL)
    {
      char
        *geometry;

      long
        sans;

      register char
        *p;

      MagickStatusType
        flags;

      geometry=GetPageGeometry(image_info->page);
      p=strchr(geometry,'>');
      if (p == (char *) NULL)
        {
          flags=ParseMetaGeometry(geometry,&sans,&sans,&image->columns,
            &image->rows);
          if (image->x_resolution != 0.0)
            image->columns=(unsigned long) ((image->columns*
              image->x_resolution)+0.5);
          if (image->y_resolution != 0.0)
            image->rows=(unsigned long) ((image->rows*image->y_resolution)+0.5);
        }
      else
        {
          *p='\0';
          flags=ParseMetaGeometry(geometry,&sans,&sans,&image->columns,
            &image->rows);
          if (image->x_resolution != 0.0)
            image->columns=(unsigned long) (((image->columns*
              image->x_resolution)/DefaultResolution)+0.5);
          if (image->y_resolution != 0.0)
            image->rows=(unsigned long) (((image->rows*image->y_resolution)/
              DefaultResolution)+0.5);
        }
      geometry=DestroyString(geometry);
    }
  hDC=GetDC(NULL);
  if (hDC == (HDC) NULL)
    {
      DeleteEnhMetaFile(hemf);
      ThrowReaderException(ResourceLimitError,"UnableToCreateADC");
    }
  /*
    Initialize the bitmap header info.
  */
  (void) ResetMagickMemory(&DIBinfo,0,sizeof(BITMAPINFO));
  DIBinfo.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
  DIBinfo.bmiHeader.biWidth=image->columns;
  DIBinfo.bmiHeader.biHeight=(-1)*image->rows;
  DIBinfo.bmiHeader.biPlanes=1;
  DIBinfo.bmiHeader.biBitCount=32;
  DIBinfo.bmiHeader.biCompression=BI_RGB;
  hBitmap=CreateDIBSection(hDC,&DIBinfo,DIB_RGB_COLORS,(void **) &ppBits,
    NULL,0);
  ReleaseDC(NULL,hDC);
  if (hBitmap == (HBITMAP) NULL)
    {
      DeleteEnhMetaFile(hemf);
      ThrowReaderException(ResourceLimitError,"UnableToCreateBitmap");
    }
  hDC=CreateCompatibleDC(NULL);
  if (hDC == (HDC) NULL)
    {
      DeleteEnhMetaFile(hemf);
      DeleteObject(hBitmap);
      ThrowReaderException(ResourceLimitError,"UnableToCreateADC");
    }
  hOldBitmap=(HBITMAP) SelectObject(hDC,hBitmap);
  if (hOldBitmap == (HBITMAP) NULL)
    {
      DeleteEnhMetaFile(hemf);
      DeleteDC(hDC);
      DeleteObject(hBitmap);
      ThrowReaderException(ResourceLimitError,"UnableToCreateBitmap");
    }
  /*
    Initialize the bitmap to the image background color.
  */
  pBits=ppBits;
  for (y=0; y < (long) image->rows; y++)
  {
    for (x=0; x < (long) image->columns; x++)
    {
      pBits->rgbRed=ScaleQuantumToChar(image->background_color.red);
      pBits->rgbGreen=ScaleQuantumToChar(image->background_color.green);
      pBits->rgbBlue=ScaleQuantumToChar(image->background_color.blue);
      pBits++;
    }
  }
  rect.top=0;
  rect.left=0;
  rect.right=image->columns;
  rect.bottom=image->rows;
  /*
    Convert metafile pixels.
  */
  PlayEnhMetaFile(hDC,hemf,&rect);
  pBits=ppBits;
  for (y=0; y < (long) image->rows; y++)
  {
    q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
    if (q == (PixelPacket *) NULL)
      break;
    for (x=0; x < (long) image->columns; x++)
    {
      q->red=ScaleCharToQuantum(pBits->rgbRed);
      q->green=ScaleCharToQuantum(pBits->rgbGreen);
      q->blue=ScaleCharToQuantum(pBits->rgbBlue);
      q->opacity=OpaqueOpacity;
      pBits++;
      q++;
    }
    if (SyncAuthenticPixels(image,exception) == MagickFalse)
      break;
  }
  DeleteEnhMetaFile(hemf);
  SelectObject(hDC,hOldBitmap);
  DeleteDC(hDC);
  DeleteObject(hBitmap);
  return(GetFirstImageInList(image));
}
Exemple #25
0
//////////////////////////////////////////////////////////////////////////////
// CMainFrame message handlers
void CMainFrame::OnEditPaste() 
{
	CDemoDoc *NewDoc=(CDemoDoc*)((CDemoApp*)AfxGetApp())->demoTemplate->OpenDocumentFile(NULL); 

	if (NewDoc)
	{
		if (OpenClipboard())
		{
			HANDLE hData=NULL;
			
			if (hData = GetClipboardData(((CDemoApp*)AfxGetApp())->GetCF())){ //custom CxImage object
				CxImage *newima = new CxImage();
				DWORD dwSize = GlobalSize(hData);
				if (dwSize) {
					BYTE *lpVoid = (BYTE *)GlobalLock(hData);
					newima->UnDump(lpVoid);
					GlobalUnlock(lpVoid);
				}
				NewDoc->image = newima;
			} else if (hData = GetClipboardData(CF_DIB)){ // check if bitmap
				CxImage *newima = new CxImage();
				newima->CreateFromHANDLE(hData);
				NewDoc->image = newima;
			} else  {		
#if CXIMAGE_SUPPORT_WMF
				if (hData = GetClipboardData(CF_ENHMETAFILE)) //check if metafile
				{
					HENHMETAFILE hMeta = (HENHMETAFILE)hData;
					ENHMETAHEADER emh;
					GetEnhMetaFileHeader(hMeta, sizeof(emh), &emh); 

					int	cx,cy;
					cx = (int)((emh.rclBounds.right - emh.rclBounds.left)/2.54);
					cy = (int)((emh.rclBounds.bottom - emh.rclBounds.top)/2.54);

					HDC hDC0 = ::GetDC(0); // screen dc
					HBITMAP hBitmap = CreateCompatibleBitmap(hDC0, cx, cy);
					HDC	hDC = CreateCompatibleDC(hDC0);	// memory dc compatible with screen
					::ReleaseDC(0, hDC0);	// don't need anymore. get rid of it.

					if (hDC && hBitmap){

						RECT rc = {0,0,cx,cy};
						int bpp = ::GetDeviceCaps(hDC, BITSPIXEL);

						HBITMAP hBitmapOld = (HBITMAP)SelectObject(hDC, hBitmap);

						// paint the background
						DWORD	dwBack = RGB(255, 255, 255); //GetSysColor(COLOR_WINDOW);
						DWORD OldColor = SetBkColor(hDC, dwBack);
						ExtTextOut(hDC, 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL);
						SetBkColor(hDC, OldColor);

						// Play the Metafile into Memory DC
						BOOL bRet = PlayEnhMetaFile(hDC, hMeta,	&rc);

						SelectObject(hDC, hBitmapOld);

						CxImage *newima = new CxImage();
						if(bRet && newima->Create(cx, cy, bpp, CXIMAGE_FORMAT_WMF)){
							
							bRet = GetDIBits(hDC, hBitmap, 0,	(UINT)cy, newima->GetBits(),
								             (LPBITMAPINFO)newima->GetDIB(), DIB_RGB_COLORS);

							NewDoc->image = newima;
						}
						else
						{
							delete newima;
						}
					}
					if (hBitmap) DeleteObject(hBitmap);
					if (hDC) DeleteDC(hDC);
				}
#endif
			}
		}

		CloseClipboard();

		CString s;
		s.Format(_T("Clipboard Image %d"),((CDemoApp*)AfxGetApp())->m_nDocCount++);
		NewDoc->SetTitle(s);
		NewDoc->UpdateAllViews(0,WM_USER_NEWIMAGE);
		NewDoc->UpdateStatusBar();
	}
}
Exemple #26
0
// Создает (или возвращает уже созданный) HDC (CompatibleDC) для mp_BkImgData
bool CBackground::PutPluginBackgroundImage(/*CBackground* pBack,*/ LONG X, LONG Y, LONG Width, LONG Height)
{
	if (!this) return NULL;

	_ASSERTE(isMainThread());

	// Сразу
	mb_BkImgChanged = FALSE;

	/*if (mb_BkImgDelete && mp_BkImgData)
	{
		free(mp_BkImgData); mp_BkImgData = NULL;
		mb_BkImgExist = FALSE;
		return false;
	}*/
	if (!mb_BkImgExist)
		return false;

	MSectionLock SC;
	SC.Lock(mcs_BkImgData, FALSE);

	if (mb_BkEmfChanged)
	{
		// Сразу сброс
		mb_BkEmfChanged = FALSE;

		if (!mp_BkEmfData)
		{
			_ASSERTE(mp_BkEmfData!=NULL);
			return false;
		}

		// Нужно перекинуть EMF в mp_BkImgData
		BITMAPINFOHEADER bi = mp_BkEmfData->bi;
		size_t nBitSize = bi.biWidth*bi.biHeight*sizeof(COLORREF);
		size_t nWholeSize = sizeof(CESERVER_REQ_SETBACKGROUND)+nBitSize; //-V103 //-V119
		if (!mp_BkImgData || (mn_BkImgDataMax < nWholeSize))
		{
			if (mp_BkImgData)
				free(mp_BkImgData);
			mp_BkImgData = (CESERVER_REQ_SETBACKGROUND*)malloc(nWholeSize);
			if (!mp_BkImgData)
			{
				_ASSERTE(mp_BkImgData!=NULL);
				return false;
			}
		}

		*mp_BkImgData = *mp_BkEmfData;
		mp_BkImgData->bmp.bfType = 0x4D42/*BM*/;
		mp_BkImgData->bmp.bfSize = nBitSize+sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER); //-V119

		// Теперь нужно сформировать DIB и нарисовать в нем EMF
		HDC hScreen = GetDC(NULL);
		//RECT rcMeta = {0,0, mn_BkImgWidth, mn_BkImgHeight}; // (in pixels)
		//RECT rcMetaMM = {0,0, mn_BkImgWidth*10, mn_BkImgHeight*10}; // (in .01-millimeter units)
		//HDC hdcEmf = CreateEnhMetaFile(NULL, NULL, &rcMetaMM, L"ConEmu\0Far Background\0\0");
		//if (!hdcEmf)
		//{
		//	_ASSERTE(hdcEmf!=NULL);
		//	return;
		//}

		HDC hdcDib = CreateCompatibleDC(hScreen);
		if (!hdcDib)
		{
			_ASSERTE(hdcDib!=NULL);
			//DeleteEnhMetaFile(hdcEmf);
			return false;
		}
		COLORREF* pBits = NULL;
		HBITMAP hDib = CreateDIBSection(hScreen, (BITMAPINFO*)&bi, DIB_RGB_COLORS, (void**)&pBits, NULL, 0);
		ReleaseDC(NULL, hScreen); hScreen = NULL;
		if (!hDib || !pBits)
		{
			_ASSERTE(hDib && pBits);
			return false;
		}

		HBITMAP hOld = (HBITMAP)SelectObject(hdcDib, hDib);

		size_t nBitsSize = bi.biWidth*bi.biHeight*sizeof(COLORREF);
		// Залить черным - по умолчанию
		#ifdef _DEBUG
			memset(pBits, 128, nBitSize);
		#else
			memset(pBits, 0, nBitsSize);
		#endif

		DWORD nEmfBits = mp_BkEmfData->bmp.bfSize - sizeof(BITMAPFILEHEADER) - sizeof(BITMAPINFOHEADER);
		LPBYTE pEmfBits = (LPBYTE)(mp_BkEmfData+1);
		HENHMETAFILE hdcEmf = SetEnhMetaFileBits(nEmfBits, pEmfBits);
		RECT rcPlay = {0,0, bi.biWidth, bi.biHeight};
		DWORD nPlayErr = 0;
		if (hdcEmf)
		{
			#ifdef _DEBUG
			ENHMETAHEADER	emh = {0};
			DWORD			PixelsX, PixelsY, MMX, MMY, cx, cy;
			emh.nSize = sizeof(ENHMETAHEADER);
			if( GetEnhMetaFileHeader( hdcEmf, sizeof( ENHMETAHEADER ), &emh ) )
			{
				// Get the characteristics of the output device
				HDC hDC = GetDC(NULL);
				PixelsX = GetDeviceCaps( hDC, HORZRES );
				PixelsY = GetDeviceCaps( hDC, VERTRES );
				MMX = GetDeviceCaps( hDC, HORZSIZE ) * 100;
				MMY = GetDeviceCaps( hDC, VERTSIZE ) * 100;
				ReleaseDC(NULL, hDC);

				// Calculate the rect in which to draw the metafile based on the
				// intended size and the current output device resolution
				// Remember that the intended size is given in 0.01mm units, so
				// convert those to device units on the target device
				cx = (int)((float)(emh.rclFrame.right - emh.rclFrame.left) * PixelsX / (MMX));
				cy = (int)((float)(emh.rclFrame.bottom - emh.rclFrame.top) * PixelsY / (MMY));
				//pw->PreferredSize.cx = ip.MulDivI32((emh.rclFrame.right - emh.rclFrame.left), PixelsX, MMX);
				//pw->PreferredSize.cy = ip.MulDivI32((emh.rclFrame.bottom - emh.rclFrame.top), PixelsY, MMY);
				_ASSERTE(cx>0 && cy>0);
				//if (pw->PreferredSize.cx < 0) pw->PreferredSize.cx = -pw->PreferredSize.cx;
				//if (pw->PreferredSize.cy < 0) pw->PreferredSize.cy = -pw->PreferredSize.cy;
				//rcPlay = MakeRect(emh.rclBounds.left,emh.rclBounds.top,emh.rclBounds.right,emh.rclBounds.bottom);
			}
			#endif

			if (!PlayEnhMetaFile(hdcDib, hdcEmf, &rcPlay))
			{
				nPlayErr = GetLastError();
				_ASSERTE(FALSE && (nPlayErr == 0));
			}

			GdiFlush();
			memmove(mp_BkImgData+1, pBits, nBitSize);
		}
		UNREFERENCED_PARAMETER(nPlayErr);

		SelectObject(hdcDib, hOld);
		DeleteObject(hDib);
		DeleteDC(hdcDib);
		if (hdcEmf)
		{
			DeleteEnhMetaFile(hdcEmf);
		}
		else
		{
			return false;
		}
	}

	if (!mp_BkImgData)
	{
		// Нужен ли тут? Или допустимая ситуация?
		_ASSERTE(mp_BkImgData!=NULL);
		return false;
	}

	bool lbFade = false;

	if (gpSet->isFadeInactive && !gpConEmu->isMeForeground(false))
		lbFade = true;

	bool lbRc = FillBackground(&mp_BkImgData->bmp, X, Y, Width, Height, eUpLeft, lbFade);

	//mb_BkImgChanged = FALSE;
	return lbRc;
}
Exemple #27
0
void ME_DrawOLE(ME_Context *c, int x, int y, ME_Run *run,
                ME_Paragraph *para, BOOL selected)
{
  IDataObject*  ido;
  FORMATETC     fmt;
  STGMEDIUM     stgm;
  DIBSECTION    dibsect;
  ENHMETAHEADER emh;
  HDC           hMemDC;
  SIZE          sz;
  BOOL          has_size;

  assert(run->nFlags & MERF_GRAPHICS);
  assert(run->ole_obj);
  if (IOleObject_QueryInterface(run->ole_obj->poleobj, &IID_IDataObject, (void**)&ido) != S_OK)
  {
    FIXME("Couldn't get interface\n");
    return;
  }
  has_size = run->ole_obj->sizel.cx != 0 || run->ole_obj->sizel.cy != 0;
  fmt.cfFormat = CF_BITMAP;
  fmt.ptd = NULL;
  fmt.dwAspect = DVASPECT_CONTENT;
  fmt.lindex = -1;
  fmt.tymed = TYMED_GDI;
  if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
  {
    fmt.cfFormat = CF_ENHMETAFILE;
    fmt.tymed = TYMED_ENHMF;
    if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
    {
      FIXME("Couldn't get storage medium\n");
      IDataObject_Release(ido);
      return;
    }
  }
  switch (stgm.tymed)
  {
  case TYMED_GDI:
    GetObjectW(stgm.u.hBitmap, sizeof(dibsect), &dibsect);
    hMemDC = CreateCompatibleDC(c->hDC);
    SelectObject(hMemDC, stgm.u.hBitmap);
    if (has_size)
    {
      convert_sizel(c, &run->ole_obj->sizel, &sz);
    } else {
      sz.cx = MulDiv(dibsect.dsBm.bmWidth, c->dpi.cx, 96);
      sz.cy = MulDiv(dibsect.dsBm.bmHeight, c->dpi.cy, 96);
    }
    if (c->editor->nZoomNumerator != 0)
    {
      sz.cx = MulDiv(sz.cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
      sz.cy = MulDiv(sz.cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
    }
    if (sz.cx == dibsect.dsBm.bmWidth && sz.cy == dibsect.dsBm.bmHeight)
    {
      BitBlt(c->hDC, x, y - sz.cy,
             dibsect.dsBm.bmWidth, dibsect.dsBm.bmHeight,
             hMemDC, 0, 0, SRCCOPY);
    } else {
      StretchBlt(c->hDC, x, y - sz.cy, sz.cx, sz.cy,
                 hMemDC, 0, 0, dibsect.dsBm.bmWidth,
                 dibsect.dsBm.bmHeight, SRCCOPY);
    }
    DeleteDC(hMemDC);
    if (!stgm.pUnkForRelease) DeleteObject(stgm.u.hBitmap);
    break;
  case TYMED_ENHMF:
    GetEnhMetaFileHeader(stgm.u.hEnhMetaFile, sizeof(emh), &emh);
    if (has_size)
    {
      convert_sizel(c, &run->ole_obj->sizel, &sz);
    } else {
      sz.cy = MulDiv(emh.rclBounds.bottom - emh.rclBounds.top, c->dpi.cx, 96);
      sz.cx = MulDiv(emh.rclBounds.right - emh.rclBounds.left, c->dpi.cy, 96);
    }
    if (c->editor->nZoomNumerator != 0)
    {
      sz.cx = MulDiv(sz.cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
      sz.cy = MulDiv(sz.cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
    }

    {
      RECT    rc;

      rc.left = x;
      rc.top = y - sz.cy;
      rc.right = x + sz.cx;
      rc.bottom = y;
      PlayEnhMetaFile(c->hDC, stgm.u.hEnhMetaFile, &rc);
    }
    if (!stgm.pUnkForRelease) DeleteEnhMetaFile(stgm.u.hEnhMetaFile);
    break;
  default:
    FIXME("Unsupported tymed %d\n", stgm.tymed);
    selected = FALSE;
    break;
  }
  if (selected && !c->editor->bHideSelection)
    PatBlt(c->hDC, x, y - sz.cy, sz.cx, sz.cy, DSTINVERT);
  IDataObject_Release(ido);
}
Exemple #28
0
BOOL KCanvasWindow::Print(void)
{
	HDC             hDCPrinter;
    int             iEntries;
    
    if (hMetaFile == NULL) 
		return FALSE;

	// if (SpoolFile.PlaySpoolFile(CurEmfFileName, NULL, NULL, NULL))
	//	  return TRUE;

	{
		PRINTDLG        pd;
    
		memset(&pd, 0, sizeof(pd));
		pd.lStructSize = sizeof(PRINTDLG);
		pd.hwndOwner   = m_hWnd;
		pd.Flags       = PD_RETURNDC;
		pd.hInstance   = hInstance;

		if (!PrintDlg(&pd) || (pd.hDC==NULL)) 
			return FALSE;

		hDCPrinter = pd.hDC;
	}

	
	// EmfScope.UnlinkClientServer();

	
	{
		DOCINFO         DocInfo;
		char            title[128];

		// put a special tag before the title so spehon32 can ignore it
		strcpy(title, ItsMe);
		GetEnhMetaFileDescription(hMetaFile, sizeof(title)-strlen(title), title+strlen(title));

		memset(&DocInfo, 0, sizeof(DocInfo));
		DocInfo.cbSize      = sizeof(DOCINFO);
		DocInfo.lpszDocName = title;
		DocInfo.lpszOutput  = NULL;
		StartDoc(hDCPrinter, &DocInfo);
	}

    
	StartPage(hDCPrinter);

    
	iEntries = GetEnhMetaFilePaletteEntries(hMetaFile, 0, NULL);

    if (iEntries) 
	{
	    PLOGPALETTE     plogPal;
	    PBYTE           pjTmp;
		HPALETTE        hPal;

        if ((plogPal = (PLOGPALETTE)GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT,
                sizeof(DWORD) + sizeof(PALETTEENTRY)*iEntries )) == NULL) 
		{
            MessageBox(m_hWnd, "Failed in Creating Palette!", "Error", MB_OK);
        }

        plogPal->palVersion = 0x300;
        plogPal->palNumEntries = (WORD) iEntries;
        pjTmp = (PBYTE) plogPal;
        pjTmp += 8;

        GetEnhMetaFilePaletteEntries(hMetaFile, iEntries, (PPALETTEENTRY)pjTmp);
        hPal = CreatePalette(plogPal);
        GlobalFree(plogPal);

        SelectPalette(hDCPrinter, hPal, FALSE);
        RealizePalette(hDCPrinter);
    }


	{
        RECT rc;
		ENHMETAHEADER   EnhMetaHdr;
    
		GetEnhMetaFileHeader(hMetaFile, sizeof(ENHMETAHEADER), &EnhMetaHdr);

        rc.top    = 0;
		rc.left   = 0;
        rc.right  = EnhMetaHdr.szlDevice.cx;
        rc.bottom = EnhMetaHdr.szlDevice.cy;
        
		if (!PlayEnhMetaFile(hDCPrinter, hMetaFile, &rc)) 
		{
            char    text[128];

            wsprintf(text, "Fail in PlayEnhMetaFile! Error %ld\n", GetLastError());
            MessageBox(0, text, "Play", MB_OK);
		}
	}

    EndPage(hDCPrinter);
    EndDoc(hDCPrinter);

	// EmfScope.LinkClientServer();

	return TRUE;
}
Exemple #29
0
LRESULT KCanvasWindow::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch (uMsg)
	{
		case WM_CREATE:
			m_hWnd = hWnd;
			break;

		case WM_PAINT:
			if (hMetaFile || hNTMetaFile)
			{
				PAINTSTRUCT ps;
				RECT        rect;
				HBRUSH      bbrush;

				BeginPaint(hWnd, &ps);
				
				GetDisplayRect(&rect);
				
				bbrush = CreateSolidBrush(canvas_backcolor);
				FillRect(ps.hdc, &rect, bbrush);
				DeleteObject(bbrush);

				if (hMetaFile)
					if (canvas_delay==0)
						PlayEnhMetaFile(ps.hdc, hMetaFile, &rect);
					else
					{
						KProgress Progress;

						Progress.Create(EmfScope.hinst_EmfScope, EmfScope.m_hWnd, IDD_PROGRESS, IDC_PROGRESS, IDC_NUMBER, canvas_delay);	

						EnumEnhMetaFile(ps.hdc, hMetaFile, 
										(ENHMFENUMPROC) SlowPaintEMF,
										& Progress, 
										&rect);

						Progress.Destroy();
						SetFocus(EmfScope.m_hWnd);
					}
				else if (hNTMetaFile)
					PlayNTEnhMetaFile(ps.hdc, hNTMetaFile, &rect);

				EndPaint(hWnd, &ps);
			}
			else
				return DefWindowProc(hWnd, uMsg, wParam, lParam);
			break;

		
		case WM_DESTROY:
			if (hMetaFile)
			{
				DeleteEnhMetaFile(hMetaFile);
				hMetaFile = NULL;
			}

			if (hNTMetaFile)
			{
				delete hNTMetaFile;
				hNTMetaFile = NULL;
			}
			break;

		
		case WM_HSCROLL:
		case WM_VSCROLL:
			Scroll (uMsg, HIWORD (wParam), LOWORD(wParam));
			break;

		case WM_SIZE:
			SetScaleColor(0, 0);
			break;

		default:
			return DefWindowProc(hWnd, uMsg, wParam, lParam);
	}

	return 0;
}
LRESULT CMetafileDisplay::OnPaint(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
{
	CPaintDC dc(m_hWnd);

	if (enhMF != NULL)
	{
		RECT rc;
		GetClientRect(&rc);
		int cx = rc.right - rc.left;
		int cy = rc.bottom - rc.top;
		int tmp;

		SIZE szPic;
		ENHMETAHEADER hdr;
		::GetEnhMetaFileHeader(enhMF, sizeof(hdr), &hdr);
		szPic.cx = hdr.rclBounds.right - hdr.rclBounds.left;
		szPic.cy = hdr.rclBounds.bottom - hdr.rclBounds.top;

		if (szPic.cx == 0)
			szPic.cx = 1;
		if (szPic.cy == 0)
			szPic.cy = 1;
		if (szPic.cx == szPic.cy)
		{
			// make drawing rect square
			if (cx > cy)
			{
				rc.left = (cx - cy) / 2;
				rc.right = rc.left + cy;
			}
			else if (cy > cx)
			{
				rc.top = (cy - cx) / 2;
				rc.bottom = rc.top + cx;
			}
		}
		else
		{
			float r1 = (float) szPic.cx / (float) szPic.cy;
			float r2 = (float) cx / (float) cy;
			if (r1 < 1)
			{
				// h > w
				if (r2 < r1)
				{
					tmp = (int) (r1 * (float) cy);
					rc.left = (cx - tmp) / 2;
					rc.right = rc.left + tmp;
				}
			}
			else
			{
				// w > h
				if (r2 < r1)
				{
					tmp = (int) ((float) cx / r1);
					rc.top = (cy - tmp) / 2;
					rc.bottom = rc.top + tmp;
				}
			}
		}
		rc.top += 2;
		rc.left += 2;
		rc.right -= 2;
		rc.bottom -=2;
		PlayEnhMetaFile(dc, enhMF, &rc);
	}
	return 0;
}