783 lines
17 KiB
C++
783 lines
17 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
|
|
//
|
|
//
|
|
BOOL WbMainWindow::CLP_Paste(void)
|
|
{
|
|
UINT length = 0;
|
|
HANDLE handle = NULL;
|
|
T126Obj* pGraphic = NULL;
|
|
BOOL bResult = FALSE;
|
|
|
|
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)
|
|
{
|
|
bResult= PasteDIB(lpbi);
|
|
|
|
// 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, FALSE);
|
|
|
|
if(lpbiNew != NULL)
|
|
{
|
|
bResult= PasteDIB(lpbiNew);
|
|
}
|
|
|
|
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.
|
|
DBG_SAVE_FILE_LINE
|
|
WbTextEditor* pPasteText = new WbTextEditor();
|
|
|
|
// 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);
|
|
|
|
RECT rcVis;
|
|
m_drawingArea.GetVisibleRect(&rcVis);
|
|
pPasteText->SetPenColor(RGB(0,0,0),TRUE);
|
|
pPasteText->SetAnchorPoint(0, 0);
|
|
pPasteText->MoveTo(rcVis.left, rcVis.top);
|
|
pPasteText->Draw();
|
|
pPasteText->m_pEditBox = NULL;
|
|
|
|
// Add the new grabbed bitmap
|
|
pPasteText->SetAllAttribs();
|
|
pPasteText->AddToWorkspace();
|
|
bResult = TRUE;
|
|
}
|
|
|
|
pGraphic = pPasteText;
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
default:
|
|
{
|
|
if (iFormat == g_ClipboardFormats[CLIPBOARD_PRIVATE])
|
|
{
|
|
|
|
WB_OBJ objectHeader;
|
|
ULONG length;
|
|
UINT type;
|
|
ULONG nItems = 0;
|
|
|
|
PBYTE pClipBoardBuffer;
|
|
if (pClipBoardBuffer = (PBYTE) ::GlobalLock(handle))
|
|
{
|
|
|
|
//
|
|
// Count objects before we paste.
|
|
//
|
|
PBYTE pClipBuff = pClipBoardBuffer;
|
|
length = ((PWB_OBJ)pClipBuff)->length;
|
|
pClipBuff += sizeof(objectHeader);
|
|
while(length)
|
|
{
|
|
nItems++;
|
|
pClipBuff += length;
|
|
length = ((PWB_OBJ)pClipBuff)->length;
|
|
pClipBuff += sizeof(objectHeader);
|
|
}
|
|
|
|
TimeToGetGCCHandles(nItems);
|
|
|
|
length = ((PWB_OBJ)pClipBoardBuffer)->length;
|
|
type = ((PWB_OBJ)pClipBoardBuffer)->type;
|
|
pClipBoardBuffer += sizeof(objectHeader);
|
|
|
|
while(length)
|
|
{
|
|
if(type == TYPE_T126_ASN_OBJECT)
|
|
{
|
|
bResult = T126_MCSSendDataIndication(length, pClipBoardBuffer, g_MyMemberID, TRUE);
|
|
}
|
|
else if(type == TYPE_T126_DIB_OBJECT)
|
|
{
|
|
bResult = PasteDIB((LPBITMAPINFOHEADER)pClipBoardBuffer);
|
|
}
|
|
|
|
pClipBoardBuffer += length;
|
|
length = ((PWB_OBJ)pClipBoardBuffer)->length;
|
|
type = ((PWB_OBJ)pClipBoardBuffer)->type;
|
|
pClipBoardBuffer += sizeof(objectHeader);
|
|
}
|
|
|
|
// Release the handle
|
|
::GlobalUnlock(handle);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
NoFormatData:
|
|
::CloseClipboard();
|
|
|
|
NoOpenClip:
|
|
return bResult;
|
|
}
|
|
|
|
|
|
//
|
|
//
|
|
// Function: Copy
|
|
//
|
|
// Purpose: Copy a graphic to the clipboard.
|
|
//
|
|
//
|
|
BOOL WbMainWindow::CLP_Copy()
|
|
{
|
|
BOOL bResult = FALSE;
|
|
|
|
MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::CLP_Copy");
|
|
|
|
//
|
|
// 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.
|
|
//
|
|
|
|
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();
|
|
}
|
|
|
|
|
|
return bResult;
|
|
}
|
|
|
|
|
|
//
|
|
//
|
|
// Function: RenderAllFormats
|
|
//
|
|
// Purpose: Render a graphic to the clipboard
|
|
//
|
|
//
|
|
BOOL WbMainWindow::CLP_RenderAllFormats()
|
|
{
|
|
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();
|
|
|
|
// Text graphic
|
|
bResult &= CLP_RenderAsText();
|
|
|
|
// DIBs
|
|
// bResult &= CLP_RenderAsImage();
|
|
|
|
// Bitmaps
|
|
bResult &= CLP_RenderAsBitmap();
|
|
|
|
// Close the clipboard
|
|
::CloseClipboard();
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
|
|
//
|
|
//
|
|
// Function: CLP_RenderPrivateFormat
|
|
//
|
|
// Purpose: Render the private format of a graphic to the clipboard.
|
|
// The clipboard should be open before this call is made.
|
|
//
|
|
//
|
|
BOOL WbMainWindow::CLP_RenderPrivateFormat()
|
|
{
|
|
MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::CLP_RenderPrivateFormat");
|
|
|
|
BOOL bResult = FALSE;
|
|
LPBYTE pDest = NULL;
|
|
HGLOBAL hMem = NULL;
|
|
HGLOBAL hRealloc = NULL;
|
|
WB_OBJ objectHeader;
|
|
ULONG length = sizeof(objectHeader);
|
|
BOOL bDoASN1CleanUp = FALSE;
|
|
|
|
|
|
ULONG previousLength = 0;
|
|
|
|
WBPOSITION pos;
|
|
T126Obj * pObj;
|
|
ASN1_BUF encodedPDU;
|
|
|
|
pos = g_pCurrentWorkspace->GetHeadPosition();
|
|
|
|
while(pos)
|
|
{
|
|
pObj = g_pCurrentWorkspace->GetNextObject(pos);
|
|
if(pObj && pObj->WasSelectedLocally())
|
|
{
|
|
|
|
//
|
|
// Get the encoded buffer
|
|
//
|
|
pObj->SetAllAttribs();
|
|
pObj->SetViewState(unselected_chosen);
|
|
pObj->GetEncodedCreatePDU(&encodedPDU);
|
|
objectHeader.length = encodedPDU.length;
|
|
|
|
|
|
if(pObj->GetType() == bitmapCreatePDU_chosen)
|
|
{
|
|
objectHeader.type = TYPE_T126_DIB_OBJECT;
|
|
}
|
|
else if(pObj->GetType() == drawingCreatePDU_chosen || pObj->GetType() == siNonStandardPDU_chosen)
|
|
{
|
|
objectHeader.type = TYPE_T126_ASN_OBJECT;
|
|
bDoASN1CleanUp = TRUE;
|
|
}
|
|
|
|
length += encodedPDU.length + sizeof(objectHeader);
|
|
|
|
if(pDest)
|
|
{
|
|
hRealloc = ::GlobalReAlloc(hMem, length, GMEM_MOVEABLE | GMEM_DDESHARE);
|
|
if(!hRealloc)
|
|
{
|
|
goto bail;
|
|
}
|
|
hMem = hRealloc;
|
|
|
|
}
|
|
else
|
|
{
|
|
// Allocate memory for the clipboard data
|
|
hMem = ::GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, length);
|
|
if(hMem == NULL)
|
|
{
|
|
goto bail;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Get a pointer to the destination
|
|
//
|
|
pDest = (LPBYTE)::GlobalLock(hMem);
|
|
|
|
//
|
|
// Write the header
|
|
//
|
|
memcpy(pDest + previousLength, &objectHeader, sizeof(objectHeader));
|
|
previousLength += sizeof(objectHeader);
|
|
|
|
//
|
|
// Copy the decoded data in the destination
|
|
//
|
|
memcpy(pDest + previousLength, encodedPDU.value, encodedPDU.length);
|
|
previousLength += encodedPDU.length;
|
|
|
|
//
|
|
// Terminate the block with a 0
|
|
//
|
|
objectHeader.length = 0;
|
|
memcpy(pDest + previousLength, &objectHeader, sizeof(objectHeader));
|
|
|
|
//
|
|
// Free the encoded data
|
|
//
|
|
if(bDoASN1CleanUp)
|
|
{
|
|
g_pCoder->Free(encodedPDU);
|
|
bDoASN1CleanUp = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Release the memory
|
|
::GlobalUnlock(hMem);
|
|
|
|
// Pass the data to the clipboard
|
|
if (::SetClipboardData(g_ClipboardFormats[CLIPBOARD_PRIVATE], hMem))
|
|
{
|
|
TRACE_DEBUG(("Rendered data in Whiteboard format"));
|
|
bResult = TRUE;
|
|
}
|
|
|
|
bail:
|
|
|
|
|
|
|
|
if(bDoASN1CleanUp)
|
|
{
|
|
g_pCoder->Free(encodedPDU);
|
|
}
|
|
|
|
// 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);
|
|
}
|
|
|
|
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()
|
|
{
|
|
MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::CLP_RenderAsText");
|
|
|
|
BOOL bResult = TRUE;
|
|
|
|
WBPOSITION pos;
|
|
|
|
T126Obj * pObj;
|
|
pos = g_pCurrentWorkspace->GetHeadPosition();
|
|
while(pos)
|
|
{
|
|
pObj = g_pCurrentWorkspace->GetNextObject(pos);
|
|
if(pObj && pObj->WasSelectedLocally() && pObj->GraphicTool() == TOOLTYPE_TEXT)
|
|
{
|
|
|
|
// Get the total length of the clipboard format of the text
|
|
StrArray& strText = ((TextObj*) pObj)->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"));
|
|
}
|
|
else
|
|
{
|
|
bResult = FALSE;
|
|
}
|
|
}
|
|
|
|
// If we failed to put the data into the clipboard, free the memory
|
|
if (bResult == FALSE)
|
|
{
|
|
::GlobalFree(hMem);
|
|
}
|
|
|
|
|
|
break; // JOSEF what about copying all the text objects in the clipboard
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
|
|
//
|
|
// CLP_RenderAsBitmap()
|
|
//
|
|
// This draws all other graphics into a bitmap and pastes the DIB contents
|
|
// onto the clipboard.
|
|
//
|
|
BOOL WbMainWindow::CLP_RenderAsBitmap()
|
|
{
|
|
BOOL bResult = FALSE;
|
|
HDC hdcDisplay = NULL;
|
|
HDC hdcMem = NULL;
|
|
HBITMAP hBitmap = NULL;
|
|
HBITMAP hOldBitmap = NULL;
|
|
HPALETTE hPalette;
|
|
RECT rcBounds = g_pDraw->m_selectorRect;
|
|
POINT pt;
|
|
LPBITMAPINFOHEADER lpbi;
|
|
T126Obj * pObj = NULL;
|
|
|
|
MLZ_EntryOut(ZONE_FUNCTION, "WbMainWindow::CLP_RenderAsBitmap");
|
|
|
|
//
|
|
// First, draw this 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;
|
|
}
|
|
|
|
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);
|
|
::SetWindowOrgEx(hdcMem, rcBounds.left,rcBounds.top, 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);
|
|
|
|
|
|
WBPOSITION pos;
|
|
|
|
pos = g_pCurrentWorkspace->GetHeadPosition();
|
|
|
|
while(pos)
|
|
{
|
|
pObj = g_pCurrentWorkspace->GetNextObject(pos);
|
|
|
|
if(pObj && pObj->WasSelectedLocally())
|
|
{
|
|
pObj->Draw(hdcMem);
|
|
}
|
|
}
|
|
|
|
SelectBitmap(hdcMem, hOldBitmap);
|
|
|
|
// Now get the dib bits...
|
|
hPalette = CreateSystemPalette();
|
|
lpbi = DIB_FromBitmap(hBitmap, hPalette, TRUE, FALSE);
|
|
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: 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;
|
|
}
|
|
|
|
return iFormat;
|
|
}
|
|
|
|
|
|
BOOL WbMainWindow::PasteDIB( LPBITMAPINFOHEADER lpbi)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
|
|
//
|
|
// Create a bitmap object
|
|
//
|
|
BitmapObj* pDIB = NULL;
|
|
DBG_SAVE_FILE_LINE
|
|
pDIB = new BitmapObj(TOOLTYPE_FILLEDBOX);
|
|
pDIB->SetBitmapSize(lpbi->biWidth,lpbi->biHeight);
|
|
|
|
RECT rect;
|
|
// Calculate the bounding rectangle from the size of the bitmap
|
|
rect.top = 0;
|
|
rect.left = 0;
|
|
rect.right = lpbi->biWidth;
|
|
rect.bottom = lpbi->biHeight;
|
|
pDIB->SetRect(&rect);
|
|
pDIB->SetAnchorPoint(rect.left, rect.top);
|
|
|
|
//
|
|
// Make a copy of the clipboard data
|
|
//
|
|
pDIB->m_lpbiImage = DIB_Copy(lpbi);
|
|
|
|
if(pDIB->m_lpbiImage!= NULL)
|
|
{
|
|
// Add the new bitmap
|
|
AddCapturedImage(pDIB);
|
|
bResult = TRUE;
|
|
}
|
|
else
|
|
{
|
|
delete pDIB;
|
|
}
|
|
|
|
return bResult;
|
|
}
|