1072 lines
29 KiB
C++
1072 lines
29 KiB
C++
//
|
|
// CLPBD.CPP
|
|
// Clipboard Handling
|
|
//
|
|
// Copyright Microsoft 1998-
|
|
//
|
|
|
|
// PRECOMP
|
|
#include "precomp.h"
|
|
|
|
|
|
|
|
//
|
|
// NFC, SFR 5921. Maximum length of a string pasted from the clipboard.
|
|
// We impose this limit as our graphic object code cant
|
|
// handle more then this number of chars.
|
|
//
|
|
#define WB_MAX_TEXT_PASTE_LEN (INT_MAX-1)
|
|
|
|
//
|
|
//
|
|
// Function: Paste
|
|
//
|
|
// Purpose: Paste a format from the clipboard
|
|
//
|
|
//
|
|
DCWbGraphic* WbMainWindow::CLP_Paste(void)
|
|
{
|
|
UINT length = 0;
|
|
HANDLE handle = NULL;
|
|
DCWbGraphic* pGraphic = NULL;
|
|
|
|
MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::CLP_Paste");
|
|
|
|
// Get the highest priority acceptable format in the clipboard
|
|
int iFormat = CLP_AcceptableClipboardFormat();
|
|
if (!iFormat)
|
|
goto NoOpenClip;
|
|
|
|
TRACE_MSG(("Found acceptable format %d", iFormat));
|
|
|
|
// Open the clipboard
|
|
|
|
if (!::OpenClipboard(m_hwnd))
|
|
{
|
|
WARNING_OUT(("CLP_Paste: can't open clipboard"));
|
|
goto NoOpenClip;
|
|
}
|
|
|
|
handle = ::GetClipboardData(iFormat);
|
|
if (!handle)
|
|
{
|
|
WARNING_OUT(("CLP_Paste: can't get data for format %d", iFormat));
|
|
goto NoFormatData;
|
|
}
|
|
|
|
switch (iFormat)
|
|
{
|
|
//
|
|
// Check the standard formats
|
|
//
|
|
case CF_DIB:
|
|
{
|
|
TRACE_MSG(("Pasting CF_DIB"));
|
|
|
|
// Lock the handle to get a pointer to the DIB
|
|
LPBITMAPINFOHEADER lpbi;
|
|
lpbi = (LPBITMAPINFOHEADER) ::GlobalLock(handle);
|
|
if (lpbi != NULL)
|
|
{
|
|
LPBITMAPINFOHEADER lpbiNew;
|
|
|
|
// Make a copy of the clipboard data
|
|
lpbiNew = DIB_Copy(lpbi);
|
|
if (lpbiNew != NULL)
|
|
{
|
|
// Create a graphic object
|
|
DCWbGraphicDIB* pDIB = new DCWbGraphicDIB();
|
|
if (!pDIB)
|
|
{
|
|
ERROR_OUT(("CF_DIB clipboard handling; couldn't create new DCWbGraphicDIB object"));
|
|
}
|
|
else
|
|
{
|
|
pDIB->SetImage(lpbiNew);
|
|
}
|
|
|
|
TRACE_MSG(("Set DIB into graphic object %lx",pDIB));
|
|
pGraphic = pDIB;
|
|
}
|
|
|
|
// Release the memory
|
|
::GlobalUnlock(handle);
|
|
}
|
|
}
|
|
break;
|
|
|
|
//
|
|
// We have a metafile. Play it into a bitmap and then use the
|
|
// data.
|
|
//
|
|
case CF_ENHMETAFILE:
|
|
{
|
|
TRACE_MSG(("Pasting CF_ENHMETAFILE"));
|
|
|
|
HDC hDrawingDC;
|
|
ENHMETAHEADER meta_header;
|
|
HBITMAP hBitmap = NULL;
|
|
HDC meta_dc = NULL;
|
|
HBITMAP hSaveBitmap;
|
|
HPEN hSavePen;
|
|
HPALETTE hPalette;
|
|
RECT meta_rect;
|
|
LPBITMAPINFOHEADER lpbiNew;
|
|
int tmp;
|
|
|
|
// We just need a DC compatible with the drawing area wnd
|
|
hDrawingDC = m_drawingArea.GetCachedDC();
|
|
|
|
// make a dc
|
|
meta_dc = ::CreateCompatibleDC(hDrawingDC);
|
|
if (!meta_dc)
|
|
goto CleanupMetaFile;
|
|
|
|
// figure out image size.
|
|
::GetEnhMetaFileHeader( (HENHMETAFILE)handle,
|
|
sizeof( ENHMETAHEADER ),
|
|
&meta_header );
|
|
meta_rect.left = meta_rect.top = 0;
|
|
|
|
meta_rect.right = ((meta_header.rclFrame.right - meta_header.rclFrame.left)
|
|
* ::GetDeviceCaps(hDrawingDC, LOGPIXELSX ))/2540;
|
|
|
|
meta_rect.bottom = ((meta_header.rclFrame.bottom - meta_header.rclFrame.top)
|
|
* ::GetDeviceCaps(hDrawingDC, LOGPIXELSY ))/2540;
|
|
|
|
// Normalize coords
|
|
if (meta_rect.right < meta_rect.left)
|
|
{
|
|
tmp = meta_rect.left;
|
|
meta_rect.left = meta_rect.right;
|
|
meta_rect.right = tmp;
|
|
}
|
|
if (meta_rect.bottom < meta_rect.top)
|
|
{
|
|
tmp = meta_rect.top;
|
|
meta_rect.top = meta_rect.bottom;
|
|
meta_rect.bottom = tmp;
|
|
}
|
|
|
|
// make a place to play meta in
|
|
hBitmap = ::CreateCompatibleBitmap(hDrawingDC,
|
|
meta_rect.right - meta_rect.left,
|
|
meta_rect.bottom - meta_rect.top);
|
|
if (!hBitmap)
|
|
goto CleanupMetaFile;
|
|
|
|
hSaveBitmap = SelectBitmap(meta_dc, hBitmap);
|
|
|
|
// erase our paper
|
|
hSavePen = SelectPen(meta_dc, GetStockObject(NULL_PEN));
|
|
|
|
::Rectangle(meta_dc, meta_rect.left, meta_rect.top,
|
|
meta_rect.right + 1, meta_rect.bottom + 1);
|
|
|
|
SelectPen(meta_dc, hSavePen);
|
|
|
|
// play the tape
|
|
::PlayEnhMetaFile(meta_dc, (HENHMETAFILE)handle, &meta_rect);
|
|
|
|
// unplug our new bitmap
|
|
SelectBitmap(meta_dc, hSaveBitmap);
|
|
|
|
// Check for a palette object in the clipboard
|
|
hPalette = (HPALETTE)::GetClipboardData(CF_PALETTE);
|
|
|
|
// Create a new DIB from the bitmap
|
|
lpbiNew = DIB_FromBitmap(hBitmap, hPalette, FALSE);
|
|
if (lpbiNew != NULL)
|
|
{
|
|
// Create a DIB graphic from the DIB
|
|
DCWbGraphicDIB* pDIB = new DCWbGraphicDIB();
|
|
if (!pDIB)
|
|
{
|
|
ERROR_OUT(("CF_ENHMETAFILE handling; couldn't allocate DCWbGraphicDIB object"));
|
|
}
|
|
else
|
|
{
|
|
pDIB->SetImage(lpbiNew);
|
|
}
|
|
|
|
TRACE_MSG(("Set bitmap DIB into graphic object %lx",pDIB));
|
|
pGraphic = pDIB;
|
|
}
|
|
|
|
CleanupMetaFile:
|
|
// Free our temp intermediate bitmap
|
|
if (hBitmap != NULL)
|
|
{
|
|
DeleteBitmap(hBitmap);
|
|
}
|
|
|
|
if (meta_dc != NULL)
|
|
{
|
|
::DeleteDC(meta_dc);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case CF_TEXT:
|
|
{
|
|
LPSTR pData;
|
|
|
|
TRACE_DEBUG(("Pasting text"));
|
|
|
|
// Get a handle to the clipboard contents
|
|
pData = (LPSTR)::GlobalLock(handle);
|
|
|
|
if(pData)
|
|
{
|
|
// Create a text object to hold the data - get the font to
|
|
// use from the tool attributes group.
|
|
DCWbGraphicText* pPasteText = new DCWbGraphicText();
|
|
|
|
// Use the current font attributes
|
|
if (!pPasteText)
|
|
{
|
|
ERROR_OUT(("CF_TEXT handling; failed to allocate DCWbGraphicText object"));
|
|
}
|
|
else
|
|
{
|
|
pPasteText->SetFont(m_pCurrentTool->GetFont());
|
|
pPasteText->SetText(pData);
|
|
}
|
|
|
|
pGraphic = pPasteText;
|
|
}
|
|
|
|
// Release the handle
|
|
::GlobalUnlock(handle);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
{
|
|
if (iFormat == g_ClipboardFormats[CLIPBOARD_PRIVATE_SINGLE_OBJ])
|
|
{
|
|
// There is a Whiteboard private format object in the clipboard.
|
|
// The format of this object is exactly as stored in the page, we
|
|
// can therefore use it immediately.
|
|
TRACE_DEBUG(("Pasting a private Whiteboard object"));
|
|
|
|
// Get a handle to the clipboard contents
|
|
PWB_GRAPHIC pHeader;
|
|
if (pHeader = (PWB_GRAPHIC) ::GlobalLock(handle))
|
|
{
|
|
// Add the object to the page
|
|
pGraphic = DCWbGraphic::CopyGraphic(pHeader);
|
|
|
|
// Release the handle
|
|
::GlobalUnlock(handle);
|
|
}
|
|
}
|
|
else if (iFormat == g_ClipboardFormats[CLIPBOARD_PRIVATE_MULTI_OBJ])
|
|
{
|
|
DCWbGraphicMarker * pMarker = m_drawingArea.GetMarker();
|
|
if (!pMarker)
|
|
{
|
|
ERROR_OUT(("Couldn't get marker from drawing area"));
|
|
}
|
|
else
|
|
{
|
|
pMarker->Paste(handle);
|
|
}
|
|
|
|
pGraphic = pMarker;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
NoFormatData:
|
|
::CloseClipboard();
|
|
|
|
NoOpenClip:
|
|
return pGraphic;
|
|
}
|
|
|
|
|
|
//
|
|
//
|
|
// Function: Copy
|
|
//
|
|
// Purpose: Copy a graphic to the clipboard. The second parameter
|
|
// indicates whether immediate rendering is required.
|
|
//
|
|
//
|
|
BOOL WbMainWindow::CLP_Copy(DCWbGraphic* pGraphic, BOOL bRenderNow)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
|
|
MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::CLP_Copy");
|
|
ASSERT(pGraphic != NULL);
|
|
|
|
//
|
|
// We act according to the format of the selected graphic.
|
|
//
|
|
// For all formats we supply the Whiteboard private format (which is
|
|
// just a copy of the flat representation of the graphic).
|
|
//
|
|
// We supply standard formats as follows.
|
|
//
|
|
// For bitmaps and all others we supply CF_DIB.
|
|
//
|
|
// For text graphics we supply CF_TEXT.
|
|
//
|
|
|
|
// Free up the saved delayed rendering graphic since we are about to
|
|
// replace it in the clipboard
|
|
CLP_FreeDelayedGraphic();
|
|
|
|
// Save the page and handle of the new graphic, since they'll be used
|
|
// for/ rendering it, either now or later
|
|
m_hPageClip = pGraphic->Page();
|
|
m_hGraphicClip = pGraphic->Handle();
|
|
|
|
if (bRenderNow)
|
|
{
|
|
TRACE_MSG(("Rendering the graphic now"));
|
|
|
|
// Have to empty the clipboard before rendering the formats.
|
|
if (::OpenClipboard(m_hwnd))
|
|
{
|
|
// Get ownership of the clipboard
|
|
::EmptyClipboard();
|
|
::CloseClipboard();
|
|
|
|
// Render the graphic
|
|
bResult = CLP_RenderAllFormats(pGraphic);
|
|
}
|
|
|
|
// We can forget about this object now.
|
|
ASSERT(m_pDelayedGraphicClip == NULL);
|
|
|
|
m_hPageClip = WB_PAGE_HANDLE_NULL;
|
|
m_hGraphicClip = NULL;
|
|
}
|
|
else
|
|
{
|
|
TRACE_MSG(("Delaying rendering"));
|
|
|
|
// For delayed rendering we insist that the graphic has been saved
|
|
// to external storage. It must therefore have a valid page and graphic
|
|
// handle.
|
|
ASSERT(m_hPageClip != WB_PAGE_HANDLE_NULL);
|
|
ASSERT(m_hGraphicClip != NULL);
|
|
|
|
// Give formats (but no data) to the clipboard
|
|
bResult = CLP_DelayAllFormats(pGraphic);
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
//
|
|
//
|
|
// Function: DelayAllFormats
|
|
//
|
|
// Purpose: Copy a graphic to the clipboard with delayed rendering
|
|
//
|
|
//
|
|
BOOL WbMainWindow::CLP_DelayAllFormats(DCWbGraphic* pGraphic)
|
|
{
|
|
MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::CLP_DelayAllFormats");
|
|
BOOL bResult = FALSE;
|
|
|
|
if (::OpenClipboard(m_hwnd))
|
|
{
|
|
// Empty / get ownership of the clipboard
|
|
bResult = ::EmptyClipboard();
|
|
|
|
// Add the private format
|
|
HANDLE hResult;
|
|
hResult =
|
|
::SetClipboardData(g_ClipboardFormats[CLIPBOARD_PRIVATE_SINGLE_OBJ], NULL);
|
|
TRACE_DEBUG(("Adding Whiteboard object to clipboard"));
|
|
|
|
if (pGraphic->IsGraphicTool() == enumGraphicText)
|
|
{
|
|
// Text graphic
|
|
hResult = ::SetClipboardData(CF_TEXT, NULL);
|
|
TRACE_DEBUG(("Adding text to clipboard"));
|
|
}
|
|
else
|
|
{
|
|
// All other graphics
|
|
hResult = ::SetClipboardData(CF_DIB, NULL);
|
|
TRACE_DEBUG(("Adding DIB to clipboard"));
|
|
}
|
|
|
|
::CloseClipboard();
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
|
|
//
|
|
//
|
|
// Function: RenderAllFormats
|
|
//
|
|
// Purpose: Render a graphic to the clipboard
|
|
//
|
|
//
|
|
BOOL WbMainWindow::CLP_RenderAllFormats(DCWbGraphic* pGraphic)
|
|
{
|
|
MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::CLP_RenderAllFormats");
|
|
BOOL bResult = FALSE;
|
|
|
|
// Open the clipboard
|
|
if (bResult = ::OpenClipboard(m_hwnd))
|
|
{
|
|
TRACE_DEBUG(("Rendering all formats of graphic"));
|
|
|
|
// Render the private format
|
|
bResult &= CLP_RenderPrivateFormat(pGraphic);
|
|
|
|
if (pGraphic->IsGraphicTool() == enumGraphicText)
|
|
{
|
|
// Text graphic
|
|
bResult &= CLP_RenderAsText(pGraphic);
|
|
}
|
|
else if (pGraphic->IsGraphicTool() == enumGraphicDIB)
|
|
{
|
|
// DIBs
|
|
bResult &= CLP_RenderAsImage(pGraphic);
|
|
}
|
|
else
|
|
{
|
|
bResult &= CLP_RenderAsBitmap(pGraphic);
|
|
}
|
|
|
|
// Close the clipboard
|
|
::CloseClipboard();
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
|
|
|
|
BOOL WbMainWindow::CLP_RenderPrivateFormat(DCWbGraphic* pGraphic)
|
|
{
|
|
if (pGraphic->IsGraphicTool() == enumGraphicMarker)
|
|
return( ((DCWbGraphicMarker*)pGraphic)->RenderPrivateMarkerFormat() );
|
|
else
|
|
return(CLP_RenderPrivateSingleFormat(pGraphic));
|
|
}
|
|
|
|
|
|
//
|
|
//
|
|
// Function: RenderPrivateSingleFormat
|
|
//
|
|
// Purpose: Render the private format of a graphic to the clipboard.
|
|
// The clipboard should be open before this call is made.
|
|
//
|
|
//
|
|
BOOL WbMainWindow::CLP_RenderPrivateSingleFormat(DCWbGraphic* pGraphic)
|
|
{
|
|
MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::CLP_RenderPrivateFormat");
|
|
ASSERT(pGraphic != NULL);
|
|
|
|
BOOL bResult = FALSE;
|
|
|
|
// Get a pointer to the graphic data
|
|
PWB_GRAPHIC pHeader = CLP_GetGraphicData();
|
|
if (pHeader != NULL)
|
|
{
|
|
// Allocate memory for the clipboard data
|
|
HANDLE hMem = ::GlobalAlloc(GHND, pHeader->length);
|
|
if (hMem != NULL)
|
|
{
|
|
// Get a pointer to the memory
|
|
LPBYTE pDest = (LPBYTE)::GlobalLock(hMem);
|
|
if (pDest != NULL)
|
|
{
|
|
// Copy the graphic data to the allocated memory
|
|
memcpy(pDest, pHeader, pHeader->length);
|
|
TRACE_MSG(("Copied data %d bytes into %lx",pHeader->length,pDest));
|
|
|
|
// make sure copy isn't "locked" (bug 474)
|
|
((PWB_GRAPHIC)pDest)->locked = WB_GRAPHIC_LOCK_NONE;
|
|
|
|
// Release the memory
|
|
::GlobalUnlock(hMem);
|
|
|
|
// Pass the data to the clipboard
|
|
if (::SetClipboardData(g_ClipboardFormats[CLIPBOARD_PRIVATE_SINGLE_OBJ], hMem))
|
|
{
|
|
TRACE_DEBUG(("Rendered data in Whiteboard format"));
|
|
bResult = TRUE;
|
|
}
|
|
}
|
|
|
|
// If we failed to put the data into the clipboard, free the memory.
|
|
// (If we did put it into the clipboard we must not free it).
|
|
if (bResult == FALSE)
|
|
{
|
|
WARNING_OUT(("Render failed"));
|
|
::GlobalFree(hMem);
|
|
}
|
|
}
|
|
|
|
// Release the graphic data
|
|
CLP_ReleaseGraphicData(pHeader);
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
//
|
|
//
|
|
// Function: RenderAsText
|
|
//
|
|
// Purpose: Render the text format of a graphic to the clipboard.
|
|
// The clipboard should be open before this call is made.
|
|
// This member should only be called for text graphics.
|
|
//
|
|
//
|
|
BOOL WbMainWindow::CLP_RenderAsText
|
|
(
|
|
DCWbGraphic* pGraphic
|
|
)
|
|
{
|
|
MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::CLP_RenderAsText");
|
|
|
|
ASSERT(pGraphic != NULL);
|
|
ASSERT(pGraphic->IsGraphicTool() == enumGraphicText);
|
|
|
|
BOOL bResult = FALSE;
|
|
|
|
// Get the total length of the clipboard format of the text
|
|
StrArray& strText = ((DCWbGraphicText*) pGraphic)->strTextArray;
|
|
int iCount = strText.GetSize();
|
|
int iIndex;
|
|
DWORD dwLength = 0;
|
|
|
|
for (iIndex = 0; iIndex < iCount; iIndex++)
|
|
{
|
|
// Length of string plus 2 for carriage return and line feed
|
|
dwLength += lstrlen(strText[iIndex]) + 2;
|
|
}
|
|
|
|
// One more for the terminating NULL
|
|
dwLength += 1;
|
|
|
|
// Allocate memory for the clipboard data
|
|
HANDLE hMem = ::GlobalAlloc(GHND, dwLength);
|
|
if (hMem != NULL)
|
|
{
|
|
// Get a pointer to the memory
|
|
LPSTR pDest = (LPSTR) ::GlobalLock(hMem);
|
|
if (pDest != NULL)
|
|
{
|
|
// Write the graphic data to the allocated memory
|
|
for (iIndex = 0; iIndex < iCount; iIndex++)
|
|
{
|
|
_tcscpy(pDest, strText[iIndex]);
|
|
pDest += lstrlen(strText[iIndex]);
|
|
|
|
// Add the carriage return and line feed
|
|
*pDest++ = '\r';
|
|
*pDest++ = '\n';
|
|
}
|
|
|
|
// Add the final NULL
|
|
*pDest = '\0';
|
|
|
|
// Release the memory
|
|
::GlobalUnlock(hMem);
|
|
|
|
// Pass the data to the clipboard
|
|
if (::SetClipboardData(CF_TEXT, hMem))
|
|
{
|
|
TRACE_DEBUG(("Rendered data in text format"));
|
|
bResult = TRUE;
|
|
}
|
|
}
|
|
|
|
// If we failed to put the data into the clipboard, free the memory
|
|
if (bResult == FALSE)
|
|
{
|
|
::GlobalFree(hMem);
|
|
}
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
//
|
|
//
|
|
// Function: RenderAsImage
|
|
//
|
|
// Purpose: Render the bitmap format of a graphic to the clipboard.
|
|
// The clipboard should be open before this call is made.
|
|
// This member should only be called for DIB graphics.
|
|
//
|
|
//
|
|
BOOL WbMainWindow::CLP_RenderAsImage
|
|
(
|
|
DCWbGraphic* pGraphic
|
|
)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
HANDLE hMem = NULL;
|
|
BYTE* pDest = NULL;
|
|
|
|
MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::CLP_RenderAsImage");
|
|
|
|
ASSERT(pGraphic != NULL);
|
|
ASSERT(pGraphic->IsGraphicTool() == enumGraphicDIB);
|
|
|
|
// Get a pointer to the graphic data
|
|
PWB_GRAPHIC pHeader = CLP_GetGraphicData();
|
|
if (pHeader != NULL)
|
|
{
|
|
LPBITMAPINFOHEADER lpbi;
|
|
|
|
TRACE_MSG(("Getting a DIB image from %lx",pHeader));
|
|
lpbi = (LPBITMAPINFOHEADER) (((LPBYTE) pHeader) + pHeader->dataOffset);
|
|
DWORD dwLength = pHeader->length - pHeader->dataOffset;
|
|
|
|
// Allocate the memory
|
|
hMem = ::GlobalAlloc(GHND, dwLength);
|
|
if (hMem != NULL)
|
|
{
|
|
LPBYTE pDest = (LPBYTE)::GlobalLock(hMem);
|
|
if (pDest != NULL)
|
|
{
|
|
TRACE_MSG(("Building DIB at %lx length %ld",pDest, dwLength));
|
|
memcpy(pDest, lpbi, dwLength);
|
|
::GlobalUnlock(hMem);
|
|
|
|
if (::SetClipboardData(CF_DIB, hMem))
|
|
{
|
|
TRACE_DEBUG(("Rendered data in DIB format"));
|
|
bResult = TRUE;
|
|
}
|
|
|
|
// If we failed to put the data into the clipboard, free the memory
|
|
if (!bResult)
|
|
{
|
|
ERROR_OUT(("Error putting DIB into clipboard"));
|
|
::GlobalFree(hMem);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR_OUT(("Could not allocate memory for DIB"));
|
|
}
|
|
|
|
// Release the data
|
|
CLP_ReleaseGraphicData(pHeader);
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
|
|
//
|
|
// CLP_RenderAsBitmap()
|
|
//
|
|
// This draws all other graphics into a bitmap and pastes the DIB contents
|
|
// onto the clipboard.
|
|
//
|
|
BOOL WbMainWindow::CLP_RenderAsBitmap(DCWbGraphic* pGraphic)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
HDC hdcDisplay = NULL;
|
|
HDC hdcMem = NULL;
|
|
HBITMAP hBitmap = NULL;
|
|
HBITMAP hOldBitmap = NULL;
|
|
HPALETTE hPalette;
|
|
RECT rcBounds;
|
|
POINT pt;
|
|
LPBITMAPINFOHEADER lpbi;
|
|
|
|
MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::CLP_RenderAsBitmap");
|
|
|
|
ASSERT(pGraphic != NULL);
|
|
ASSERT(pGraphic->IsGraphicTool() != enumGraphicText);
|
|
ASSERT(pGraphic->IsGraphicTool() != enumGraphicDIB);
|
|
|
|
//
|
|
// First, draw it into a bitmap
|
|
// Second, get the DIB bits of the bitmap
|
|
//
|
|
|
|
hdcDisplay = ::CreateDC("DISPLAY", NULL, NULL, NULL);
|
|
if (!hdcDisplay)
|
|
{
|
|
ERROR_OUT(("Can't create DISPLAY dc"));
|
|
goto AsBitmapDone;
|
|
}
|
|
|
|
hdcMem = ::CreateCompatibleDC(hdcDisplay);
|
|
if (!hdcMem)
|
|
{
|
|
ERROR_OUT(("Can't create DISPLAY compatible dc"));
|
|
goto AsBitmapDone;
|
|
}
|
|
|
|
pGraphic->GetBoundsRect(&rcBounds);
|
|
|
|
hBitmap = ::CreateCompatibleBitmap(hdcDisplay,
|
|
(rcBounds.right - rcBounds.left), (rcBounds.bottom - rcBounds.top));
|
|
if (!hBitmap)
|
|
{
|
|
ERROR_OUT(("Can't create compatible bitmap"));
|
|
goto AsBitmapDone;
|
|
}
|
|
|
|
hOldBitmap = SelectBitmap(hdcMem, hBitmap);
|
|
if (!hOldBitmap)
|
|
{
|
|
ERROR_OUT(("Failed to select compatible bitmap"));
|
|
goto AsBitmapDone;
|
|
}
|
|
|
|
::SetMapMode(hdcMem, MM_ANISOTROPIC);
|
|
pGraphic->GetPosition(&pt);
|
|
::SetWindowOrgEx(hdcMem, pt.x, pt.y, NULL);
|
|
|
|
// Clear out bitmap with white background -- now that origin has been
|
|
// altered, we can use drawing area coors.
|
|
::PatBlt(hdcMem, rcBounds.left, rcBounds.top, rcBounds.right - rcBounds.left,
|
|
rcBounds.bottom - rcBounds.top, WHITENESS);
|
|
|
|
if (pGraphic->IsGraphicTool() == enumGraphicMarker)
|
|
{
|
|
((DCWbGraphicMarker *)pGraphic)->Draw(hdcMem, TRUE);
|
|
}
|
|
else
|
|
{
|
|
pGraphic->Draw(hdcMem);
|
|
}
|
|
|
|
SelectBitmap(hdcMem, hOldBitmap);
|
|
|
|
// Now get the dib bits...
|
|
hPalette = CreateSystemPalette();
|
|
lpbi = DIB_FromBitmap(hBitmap, hPalette, TRUE);
|
|
if (hPalette != NULL)
|
|
::DeletePalette(hPalette);
|
|
|
|
// And put the handle on the clipboard
|
|
if (lpbi != NULL)
|
|
{
|
|
if (::SetClipboardData(CF_DIB, (HGLOBAL)lpbi))
|
|
{
|
|
bResult = TRUE;
|
|
}
|
|
else
|
|
{
|
|
::GlobalFree((HGLOBAL)lpbi);
|
|
}
|
|
}
|
|
|
|
AsBitmapDone:
|
|
if (hBitmap != NULL)
|
|
::DeleteBitmap(hBitmap);
|
|
|
|
if (hdcMem != NULL)
|
|
::DeleteDC(hdcMem);
|
|
|
|
if (hdcDisplay != NULL)
|
|
::DeleteDC(hdcDisplay);
|
|
|
|
return(bResult);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Function: RenderFormat
|
|
//
|
|
// Purpose: Render the specified format of the graphic in the clipboard.
|
|
//
|
|
//
|
|
BOOL WbMainWindow::CLP_RenderFormat(int iFormat)
|
|
{
|
|
MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::CLP_RenderFormat");
|
|
|
|
BOOL bResult = FALSE;
|
|
|
|
// Get a graphic from the handle
|
|
DCWbGraphic* pGraphic = CLP_GetGraphic();
|
|
|
|
if (pGraphic != NULL)
|
|
{
|
|
// Check if it is the private format that is wanted
|
|
switch (iFormat)
|
|
{
|
|
default:
|
|
{
|
|
if (iFormat == g_ClipboardFormats[CLIPBOARD_PRIVATE_SINGLE_OBJ])
|
|
{
|
|
bResult = CLP_RenderPrivateFormat(pGraphic);
|
|
}
|
|
else
|
|
{
|
|
ERROR_OUT(("Unrecognized CLP format %d", iFormat));
|
|
}
|
|
}
|
|
break;
|
|
|
|
case CF_TEXT:
|
|
{
|
|
bResult = CLP_RenderAsText(pGraphic);
|
|
}
|
|
break;
|
|
|
|
case CF_DIB:
|
|
{
|
|
if (pGraphic->IsGraphicTool() == enumGraphicDIB)
|
|
bResult = CLP_RenderAsImage(pGraphic);
|
|
else
|
|
bResult = CLP_RenderAsBitmap(pGraphic);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
//
|
|
//
|
|
// Function: RenderAllFormats
|
|
//
|
|
// Purpose: Render all formats of the graphic in the clipboard.
|
|
//
|
|
//
|
|
BOOL WbMainWindow::CLP_RenderAllFormats(void)
|
|
{
|
|
MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::CLP_RenderAllFormats");
|
|
|
|
BOOL bResult = FALSE;
|
|
|
|
// Get a graphic from the handle
|
|
DCWbGraphic* pGraphic = CLP_GetGraphic();
|
|
|
|
if (pGraphic != NULL)
|
|
{
|
|
bResult = CLP_RenderAllFormats(pGraphic);
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
//
|
|
//
|
|
// Function: AcceptableClipboardFormat
|
|
//
|
|
// Purpose: Return highest priority clipboard format if an acceptable
|
|
// one is available, else return NULL.
|
|
//
|
|
//
|
|
int WbMainWindow::CLP_AcceptableClipboardFormat(void)
|
|
{
|
|
// Look for any of the supported formats being available
|
|
int iFormat = ::GetPriorityClipboardFormat((UINT *)g_ClipboardFormats, CLIPBOARD_ACCEPTABLE_FORMATS);
|
|
if (iFormat == -1)
|
|
{
|
|
iFormat = 0;
|
|
}
|
|
|
|
// the following is a performance enhancement: if we have found at some
|
|
// point that the object on the clipboard does not have whiteboard
|
|
// private format, then we can discard the delayed graphic because we
|
|
// know we'll never be asked to render it.
|
|
if (iFormat != g_ClipboardFormats[CLIPBOARD_PRIVATE_SINGLE_OBJ])
|
|
{
|
|
CLP_FreeDelayedGraphic();
|
|
}
|
|
|
|
return iFormat;
|
|
}
|
|
|
|
//
|
|
//
|
|
// Function: LastCopiedPage
|
|
//
|
|
// Purpose: Return the handle of the page on which the last graphic
|
|
// copied to the clipboard was located.
|
|
//
|
|
//
|
|
WB_PAGE_HANDLE WbMainWindow::CLP_LastCopiedPage(void) const
|
|
{
|
|
// If there's no graphic, there shouldn't be a page either
|
|
ASSERT((m_hGraphicClip != NULL) == (m_hPageClip != WB_PAGE_HANDLE_NULL));
|
|
return(m_hPageClip);
|
|
}
|
|
|
|
WB_GRAPHIC_HANDLE WbMainWindow::CLP_LastCopiedGraphic(void) const
|
|
{
|
|
return(m_hGraphicClip);
|
|
}
|
|
|
|
//
|
|
//
|
|
// Function: GetGraphic
|
|
//
|
|
// Purpose: Retrieve the graphic object for copying to the clipboard. If
|
|
// the object has been saved, then use the local copy,
|
|
// otherwise get the page to construct it now.
|
|
//
|
|
//
|
|
DCWbGraphic* WbMainWindow::CLP_GetGraphic(void)
|
|
{
|
|
DCWbGraphic* pGraphic;
|
|
|
|
MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::CLP_GetGraphic");
|
|
|
|
// if we have not saved the graphic's contents, then we must have a
|
|
// valid page and graphic handle, since we construct the graphic now
|
|
if (m_pDelayedGraphicClip == NULL)
|
|
{
|
|
ASSERT(m_hPageClip != WB_PAGE_HANDLE_NULL);
|
|
ASSERT(m_hGraphicClip != NULL);
|
|
|
|
pGraphic = DCWbGraphic::ConstructGraphic(m_hPageClip, m_hGraphicClip);
|
|
}
|
|
else
|
|
{
|
|
pGraphic = m_pDelayedGraphicClip;
|
|
TRACE_MSG(("returning delayed graphic %lx",pGraphic));
|
|
}
|
|
|
|
return(pGraphic);
|
|
}
|
|
|
|
//
|
|
//
|
|
// Function: GetGraphicData
|
|
//
|
|
// Purpose: Retrieve the graphic data for copying to the clipboard. If
|
|
// the data has been saved, then get a pointer to the copy (in
|
|
// global memory), otherwise get it from the page.
|
|
//
|
|
// The memory must be released with ReleaseGraphicData as soon
|
|
// as possible.
|
|
//
|
|
//
|
|
PWB_GRAPHIC WbMainWindow::CLP_GetGraphicData(void)
|
|
{
|
|
PWB_GRAPHIC pHeader;
|
|
|
|
MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::CLP_GetGraphicData");
|
|
|
|
// if we have not saved the graphic's contents, then we must have a
|
|
// valid page and graphic handle, since we get the graphic data now
|
|
pHeader = m_pDelayedDataClip;
|
|
if (pHeader == NULL)
|
|
{
|
|
ASSERT(m_hPageClip != WB_PAGE_HANDLE_NULL);
|
|
ASSERT(m_hGraphicClip != NULL);
|
|
|
|
pHeader = PG_GetData(m_hPageClip, m_hGraphicClip);
|
|
}
|
|
|
|
return(pHeader);
|
|
}
|
|
|
|
//
|
|
//
|
|
// Function: ReleaseGraphicData
|
|
//
|
|
// Purpose: Release the data which was accessed by an earlier call to
|
|
// GetGraphicData.
|
|
//
|
|
//
|
|
void WbMainWindow::CLP_ReleaseGraphicData(PWB_GRAPHIC pHeader)
|
|
{
|
|
MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::CLP_ReleaseGraphicData");
|
|
|
|
// release it in the right way, depending on whether we got the data
|
|
// from the page, or just got a pointer to existing global data in
|
|
// CLP_GetGraphicData
|
|
if (m_pDelayedDataClip == NULL)
|
|
{
|
|
g_pwbCore->WBP_GraphicRelease(m_hPageClip, m_hGraphicClip, pHeader);
|
|
}
|
|
}
|
|
|
|
//
|
|
//
|
|
// Function: SaveDelayedGraphic
|
|
//
|
|
// Purpose: Create a copy of the graphic which was copied to the
|
|
// clipboard with delayed rendering.
|
|
//
|
|
//
|
|
void WbMainWindow::CLP_SaveDelayedGraphic(void)
|
|
{
|
|
MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::CLP_SaveDelayedGraphic");
|
|
|
|
// Free any previously-held delayed graphic
|
|
CLP_FreeDelayedGraphic();
|
|
|
|
// Get the new delayed graphic object and a pointer to its data
|
|
DCWbGraphic* pGraphic = CLP_GetGraphic();
|
|
TRACE_MSG(("Got graphic at address %lx",pGraphic));
|
|
|
|
m_pDelayedGraphicClip = pGraphic->Copy();
|
|
TRACE_MSG(("Copied to %lx",m_pDelayedGraphicClip));
|
|
delete pGraphic;
|
|
|
|
PWB_GRAPHIC pHeader = PG_GetData(m_hPageClip, m_hGraphicClip);
|
|
TRACE_MSG(("Graphic header %lx",pHeader));
|
|
|
|
// Copy the graphic's data into global memory, and save the handle
|
|
m_pDelayedDataClip = (PWB_GRAPHIC)::GlobalAlloc(GPTR, pHeader->length);
|
|
if (m_pDelayedDataClip != NULL)
|
|
{
|
|
// Copy the graphic data to the allocated memory
|
|
memcpy(m_pDelayedDataClip, pHeader, pHeader->length);
|
|
}
|
|
|
|
// Release the graphic's data (now we have our own copy)
|
|
g_pwbCore->WBP_GraphicRelease(m_hPageClip, m_hGraphicClip, pHeader);
|
|
|
|
// set the graphic handle to NULL because we won't be using it
|
|
// any more
|
|
m_hPageClip = WB_PAGE_HANDLE_NULL;
|
|
m_hGraphicClip = NULL;
|
|
}
|
|
|
|
|
|
//
|
|
//
|
|
// Function: FreeDelayedGraphic
|
|
//
|
|
// Purpose: Free the copy of the delayed graphic (if any).
|
|
//
|
|
//
|
|
void WbMainWindow::CLP_FreeDelayedGraphic(void)
|
|
{
|
|
MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::CLP_FreeDelayedGraphic");
|
|
|
|
if (m_pDelayedGraphicClip != NULL)
|
|
{
|
|
// free the graphic object
|
|
TRACE_MSG(("Freeing delayed graphic"));
|
|
|
|
delete m_pDelayedGraphicClip;
|
|
m_pDelayedGraphicClip = NULL;
|
|
}
|
|
|
|
if (m_pDelayedDataClip != NULL)
|
|
{
|
|
// free the associated data
|
|
TRACE_MSG(("Freeing delayed memory %x", m_pDelayedDataClip));
|
|
|
|
::GlobalFree((HGLOBAL)m_pDelayedDataClip);
|
|
m_pDelayedDataClip = NULL;
|
|
}
|
|
}
|