HENHMETAFILE CacheIconToEmf(HICON hIcon)
{
HENHMETAFILE result = 0;
EnterCriticalSection(&csEmfCache);
for (EMFCACHE *p = emfCache; p; p = p->next)
if (p->hIcon == hIcon)
{
if (p->prev)
{
p->prev->next = p->next;
if (p->next) p->next->prev = p->prev;
p->prev = 0;
emfCache->prev = p;
p->next = emfCache;
emfCache = p;
result = CopyEnhMetaFile(emfCache->hEmf, 0);
break;
}
}
// cache new item
if (!result)
{
EMFCACHE *newItem = new EMFCACHE;
newItem->prev = 0;
newItem->next = emfCache;
if (emfCache) emfCache->prev = newItem;
emfCache = newItem;
emfCacheSize++;
HDC emfdc = CreateEnhMetaFile(NULL, NULL, NULL, _T("icon"));
DrawIconEx(emfdc, 0, 0, (HICON)hIcon, 16, 16, 0, NULL, DI_NORMAL);
emfCache->hIcon = hIcon;
emfCache->hEmf = CloseEnhMetaFile(emfdc);
result = CopyEnhMetaFile(emfCache->hEmf, 0);
}
// tail cutoff
if (emfCacheSize > 20)
{
int n = 0;
EMFCACHE *p;
for (p = emfCache; p; p = p->next)
if (++n > 20)
break;
while (p->next)
{
EMFCACHE *tmp = p->next;
p->next = p->next->next;
delete tmp;
}
if (p->next) p->next->prev = p;
emfCacheSize = 20;
}
LeaveCriticalSection(&csEmfCache);
return result;
}
void WinMetaFile::WriteClipboard() const {
if(hemf && ::OpenClipboard(NULL)) {
::EmptyClipboard();
::SetClipboardData(CF_ENHMETAFILE, CopyEnhMetaFile(hemf, NULL));
::CloseClipboard();
}
}
void Picture_writeToWindowsMetafile (Picture me, MelderFile file) {
try {
HENHMETAFILE metafile = copyToMetafile (me);
MelderFile_delete (file); // overwrite any existing file with the same name
DeleteEnhMetaFile (CopyEnhMetaFile (metafile, Melder_peek32toW (file -> path)));
DeleteEnhMetaFile (metafile);
} catch (MelderError) {
Melder_throw (U"Picture not written to Windows metafile ", file);
}
}
static Any
get_clipboard_data(DisplayObj d, Name type)
{ HGLOBAL mem;
HENHMETAFILE hmf;
Any rval = FAIL;
OpenClipboard(CLIPBOARDWIN);
if ( type != NAME_winMetafile && (mem = GetClipboardData(CF_UNICODETEXT)) )
{ wchar_t *data = GlobalLock(mem);
wchar_t *copy, *q;
q = copy = pceMalloc((wcslen(data)+1)*sizeof(wchar_t));
for(; *data; data++)
{ if ( *data == '\r' && data[1] == '\n' )
{ data++;
*q++ = '\n';
} else
*q++ = *data;
}
*q = EOS;
rval = WCToString(copy, q-copy);
pceFree(copy);
GlobalUnlock(mem);
} else if ( type != NAME_winMetafile && (mem = GetClipboardData(CF_TEXT)) )
{ char far *data = GlobalLock(mem);
char *copy, *q;
q = copy = pceMalloc(strlen(data));
for(; *data; data++)
{ if ( *data == '\r' && data[1] == '\n' )
{ data++;
*q++ = '\n';
} else
*q++ = *data;
}
*q = EOS;
rval = CtoString(copy);
pceFree(copy);
GlobalUnlock(mem);
} else if ( type != NAME_text && (hmf = GetClipboardData(CF_ENHMETAFILE)) )
{ HENHMETAFILE copy = CopyEnhMetaFile(hmf, NULL);
if ( !copy )
{ errorPce(d, NAME_winMetafile, CtoName("CopyEnhMetaFile"), APIError());
fail;
}
rval = CtoWinMetafile(copy);
DeleteEnhMetaFile(hmf);
}
CloseClipboard();
return rval;
}
BOOL CFemmplotDoc::OnSaveDocument(LPCTSTR lpszPathName)
{
// TODO: Add your specialized code here and/or call the base class
BOOL flag=TRUE;
HENHMETAFILE hMetaCopy=CopyEnhMetaFile(hMetaPlot,lpszPathName);
if (hMetaCopy==NULL){
MsgBox("Problem writing file to disk");
flag=FALSE;
}
DeleteEnhMetaFile(hMetaCopy);
return flag; // CDocument::OnSaveDocument(lpszPathName);
}
int CMetafileDisplay::CreateFromClipboard( void)
{
if (enhMF != NULL)
{
DeleteEnhMetaFile(enhMF);
enhMF = NULL;
}
OpenClipboard();
HENHMETAFILE enhMFNew = (HENHMETAFILE) GetClipboardData(CF_ENHMETAFILE);
CloseClipboard();
if (enhMFNew != NULL)
enhMF = CopyEnhMetaFile(enhMFNew, NULL);
return enhMF == NULL ? -1 : 0;
}
void CDrawMetaFile::setMetaFile( HENHMETAFILE data )
{
HENHMETAFILE copy = CopyEnhMetaFile( data, NULL );
ENHMETAHEADER hdr;
GetEnhMetaFileHeader( data, sizeof(hdr), &hdr );
double width = fabs(static_cast<double>(hdr.rclFrame.left - hdr.rclFrame.right) ) ;
double height = fabs(static_cast<double>(hdr.rclFrame.bottom - hdr.rclFrame.top) ) ;
m_point_b.x = fabs(static_cast<double>(m_point_b.y - m_point_a.y)) * height / width;
m_metafile = m_pDesign->GetOptions()->AddMetaFile( new CImageMetafile( copy ) );
}
std::unique_ptr<Clipboard> Clipboard::Capture() {
auto clipboard = std::make_unique<Clipboard>(GetClipboardOwner());
if (clipboard == nullptr)
return nullptr;
UINT format_id = 0;
for (auto i = 0, l = CountClipboardFormats(); i < l; ++i) {
format_id = EnumClipboardFormats(format_id);
if (format_id == 0) // error
break;
auto handle = GetClipboardData(format_id);
if (handle == NULL) // error
continue;
std::unique_ptr<Format> format;
if (format_id == CF_BITMAP) {
// ignore
} else if (format_id == CF_ENHMETAFILE) {
auto meta_file =
CopyEnhMetaFile(reinterpret_cast<HENHMETAFILE>(handle), nullptr);
if (meta_file == NULL) // error
continue;
format = std::make_unique<MetaFileFormat>(meta_file);
} else {
auto size = GlobalSize(handle);
auto memory = GlobalLock(handle);
if (memory == nullptr) // error
continue;
format = std::make_unique<Format>(format_id, size);
memcpy(format->Get(), memory, size);
GlobalUnlock(handle);
}
if (format != nullptr)
clipboard->Add(std::move(format));
}
if (clipboard->IsEmpty())
return nullptr;
return clipboard;
}
HENHMETAFILE PasteFromClipboard(HWND hWnd)
{
HENHMETAFILE hEmf = NULL;
if ( OpenClipboard(hWnd) )
{
hEmf = (HENHMETAFILE) GetClipboardData(CF_ENHMETAFILE);
if ( hEmf )
hEmf = CopyEnhMetaFile(hEmf, NULL);
CloseClipboard();
}
return hEmf;
}
int emf_to_clipboard (char *emfname)
{
HWND mainw;
HENHMETAFILE hemf, hemfclip;
HANDLE htest;
mainw = GDK_WINDOW_HWND(mdata->main->window);
if (mainw == NULL) {
errbox("Got NULL HWND");
return 1;
}
if (!OpenClipboard(mainw)) {
errbox(_("Cannot open the clipboard"));
return 1;
}
EmptyClipboard();
hemf = GetEnhMetaFile(emfname);
if (hemf == NULL) {
errbox("Couldn't get handle to graphic metafile");
return 1;
}
hemfclip = CopyEnhMetaFile(hemf, NULL);
if (hemfclip == NULL) {
errbox("Couldn't copy graphic metafile");
return 1;
}
htest = SetClipboardData(CF_ENHMETAFILE, hemfclip);
if (htest == NULL) {
errbox("Failed to put data on clipboard");
return 1;
}
CloseClipboard();
DeleteEnhMetaFile(hemf);
return 0;
}
//*********************************
// OnButtonRun
//*********************************
void CDialogWmf::OnButtonRun()
{
BeginWaitCursor();
UpdateData(TRUE);
// Get DC
CDC *pDC = m_pDoc->GetView()->GetDC();
ASSERT(pDC);
// Get view rect
CRect rect;
m_pDoc->GetView()->GetClientRect(&rect);
rect.InflateRect(5,5);
// Create metafile device context
HDC hMetaDC = CreateEnhMetaFile(pDC->m_hDC,"metafile.emf",NULL,NULL);
if(!hMetaDC)
{
AfxMessageBox("Unable to create MetaFile");
ReleaseDC(pDC);
return;
}
// Get DC from handle
CDC *pMetaDC = CDC::FromHandle(hMetaDC);
ASSERT(pMetaDC);
pMetaDC->SetMapMode(MM_TEXT);
// Position / translation / scale
glPushMatrix();
CMeshView *pView = (CMeshView *)m_pDoc->GetView();
glTranslated(pView->m_xTranslation,pView->m_yTranslation,pView->m_zTranslation);
glRotatef(pView->m_xRotation, 1.0, 0.0, 0.0);
glRotatef(pView->m_yRotation, 0.0, 1.0, 0.0);
glRotatef(pView->m_zRotation, 0.0, 0.0, 1.0);
glScalef(pView->m_xScaling,pView->m_yScaling,pView->m_zScaling);
// Get OpenGL parameters
GLdouble modelMatrix[16];
GLdouble projMatrix[16];
GLint viewport[4];
glGetDoublev(GL_MODELVIEW_MATRIX,modelMatrix);
glGetDoublev(GL_PROJECTION_MATRIX,projMatrix);
glGetIntegerv(GL_VIEWPORT,viewport);
// Start rendering via std GDI 2D drawing functions
CSceneGraph3d *pScene = &m_pDoc->m_SceneGraph;
for(int i=0;i<pScene->NbObject();i++)
{
CObject3d *pObject = pScene->GetAt(i);
if(pObject->GetType() == TYPE_MESH3D) // meshes only
// The line mode (no sort)
if(m_Mode == MODE_LINE)
((CMesh3d *)pObject)->glDrawProjectLine(pMetaDC,
modelMatrix,
projMatrix,
viewport,
m_ColorLine,
m_Ratio,
rect.Height());
else
// The face mode (faces are z-sorted
// according to their barycenter)
((CMesh3d *)pObject)->glDrawProjectFace(pMetaDC,
modelMatrix,
projMatrix,
viewport,
m_ColorLine,
m_ColorFace,
m_Ratio,
rect.Height(),
m_RatioNbFaces);
}
glPopMatrix();
// Close metafile
HENHMETAFILE hMetaFile = CloseEnhMetaFile(hMetaDC);
// Fill the clipboard (direct sent to wmf2eps or
// any windows app such as Powerpoint)
OpenClipboard();
EmptyClipboard();
SetClipboardData(CF_ENHMETAFILE,CopyEnhMetaFile(hMetaFile,NULL));
CloseClipboard();
// Cleanup
DeleteEnhMetaFile(hMetaFile);
ReleaseDC(pDC);
EndWaitCursor();
}
void ClipboardData::ToClipboard()
{
// do we have a name to restore??
UINT format = uFormat;
if ( dataName != NULL)
{
UINT u = RegisterClipboardFormat( dataName);
if (u > 0)
{
// the format has changed it seems.
format = u;
}
}
switch (format)
{
case CF_HDROP:
{
ClipboardDropData* cdd = static_cast<ClipboardDropData*>(data);
// get the size of the clipboard.
size_t size = cdd->GetDropfilesSize();
if (size > 0)
{
// make some room for this DROPFILES item.
HGLOBAL hGlobal = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE | GMEM_DDESHARE, size);
// lock it so we can now use it.
DROPFILES *df = (DROPFILES*)GlobalLock(hGlobal);
// populate the data if we can.
if (cdd->PopulateDropFiles(df, size))
{
// release the lock
GlobalUnlock(hGlobal);
// set the data in the clipboard.
SetClipboardData(CF_HDROP, hGlobal);
}
else
{
// release the lock
GlobalUnlock(hGlobal);
// free the memory
GlobalFree(hGlobal);
}
}
}
break;
case CF_ENHMETAFILE:
SetClipboardData(CF_ENHMETAFILE, CopyEnhMetaFile((HENHMETAFILE)data, NULL));
break;
case CF_BITMAP:
SetClipboardData(CF_BITMAP, CopyBitmap( (HBITMAP)data ));
break;
default:
if (dataSize > 0)
{
// get some data
HGLOBAL hGlobal = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE | GMEM_DDESHARE, dataSize);
void* pMem = GlobalLock(hGlobal);
memcpy(pMem, data, dataSize);
GlobalUnlock(hGlobal);
// we can no save the data.
SetClipboardData(format, hGlobal);
}
else
{
// there is no data to set...
SetClipboardData(format, 0);
}
break;
}
}
/*
* clipboard_data_to_file - データをファイルに保存
*/
BOOL clipboard_data_to_file(DATA_INFO *di, const TCHAR *file_name, const int filter_index, TCHAR *err_str)
{
HMETAFILE hMeta;
HENHMETAFILE enh_meta;
BYTE *tmp;
DWORD size;
if (di->data == NULL) {
if (file_write_buf(file_name, NULL, 0, err_str) == FALSE) {
return FALSE;
}
return TRUE;
}
switch (di->format) {
case CF_OWNERDISPLAY:
return FALSE;
case CF_DSPMETAFILEPICT:
case CF_METAFILEPICT:
// メタファイル
if ((tmp = GlobalLock(di->data)) == NULL) {
message_get_error(GetLastError(), err_str);
return FALSE;
}
if ((hMeta = CopyMetaFile(((METAFILEPICT *)tmp)->hMF, file_name)) == NULL) {
message_get_error(GetLastError(), err_str);
GlobalUnlock(di->data);
return FALSE;
}
DeleteMetaFile(hMeta);
GlobalUnlock(di->data);
break;
case CF_DSPENHMETAFILE:
case CF_ENHMETAFILE:
// 拡張メタファイル
if ((enh_meta = CopyEnhMetaFile(di->data, file_name)) == NULL) {
message_get_error(GetLastError(), err_str);
return FALSE;
}
DeleteEnhMetaFile(enh_meta);
break;
default:
// その他
// データをバイト列に変換
if ((tmp = clipboard_data_to_bytes(di, &size)) == NULL) {
message_get_error(GetLastError(), err_str);
return FALSE;
}
// ファイルに書き込む
if (file_write_buf(file_name, tmp, di->size, err_str) == FALSE) {
mem_free(&tmp);
return FALSE;
}
mem_free(&tmp);
break;
}
return TRUE;
}
/*
* clipboard_copy_data - クリップボードデータのコピーを作成
*/
HANDLE clipboard_copy_data(const UINT format, const HANDLE data, DWORD *ret_size)
{
HANDLE ret = NULL;
BYTE *from_mem, *to_mem;
LOGPALETTE *lpal;
WORD pcnt;
if (data == NULL) {
return NULL;
}
switch (format) {
case CF_PALETTE:
// パレット
pcnt = 0;
if (GetObject(data, sizeof(WORD), &pcnt) == 0) {
return NULL;
}
if ((lpal = mem_calloc(sizeof(LOGPALETTE) + (sizeof(PALETTEENTRY) * pcnt))) == NULL) {
return NULL;
}
lpal->palVersion = 0x300;
lpal->palNumEntries = pcnt;
if (GetPaletteEntries(data, 0, pcnt, lpal->palPalEntry) == 0) {
mem_free(&lpal);
return NULL;
}
ret = CreatePalette(lpal);
*ret_size = sizeof(LOGPALETTE) + (sizeof(PALETTEENTRY) * pcnt);
mem_free(&lpal);
break;
case CF_DSPBITMAP:
case CF_BITMAP:
// ビットマップ
if ((to_mem = bitmap_to_dib(data, ret_size)) == NULL) {
return NULL;
}
ret = dib_to_bitmap(to_mem);
mem_free(&to_mem);
break;
case CF_OWNERDISPLAY:
*ret_size = 0;
break;
case CF_DSPMETAFILEPICT:
case CF_METAFILEPICT:
// コピー元ロック
if ((from_mem = GlobalLock(data)) == NULL) {
return NULL;
}
// メタファイル
if ((ret = GlobalAlloc(GHND, sizeof(METAFILEPICT))) == NULL) {
GlobalUnlock(data);
return NULL;
}
// コピー先ロック
if ((to_mem = GlobalLock(ret)) == NULL) {
GlobalFree(ret);
GlobalUnlock(data);
return NULL;
}
CopyMemory(to_mem, from_mem, sizeof(METAFILEPICT));
if ((((METAFILEPICT *)to_mem)->hMF = CopyMetaFile(((METAFILEPICT *)from_mem)->hMF, NULL)) != NULL) {
*ret_size = sizeof(METAFILEPICT) + GetMetaFileBitsEx(((METAFILEPICT *)to_mem)->hMF, 0, NULL);
}
// ロック解除
GlobalUnlock(ret);
GlobalUnlock(data);
break;
case CF_DSPENHMETAFILE:
case CF_ENHMETAFILE:
// 拡張メタファイル
if ((ret = CopyEnhMetaFile(data, NULL)) != NULL) {
*ret_size = GetEnhMetaFileBits(ret, 0, NULL);
}
break;
default:
// その他
// メモリチェック
if (IsBadReadPtr(data, 1) == TRUE) {
return NULL;
}
// サイズ取得
if ((*ret_size = GlobalSize(data)) == 0) {
return NULL;
}
// コピー元ロック
if ((from_mem = GlobalLock(data)) == NULL) {
return NULL;
}
// コピー先確保
if ((ret = GlobalAlloc(GHND, *ret_size)) == NULL) {
GlobalUnlock(data);
return NULL;
}
// コピー先ロック
if ((to_mem = GlobalLock(ret)) == NULL) {
GlobalFree(ret);
GlobalUnlock(data);
return NULL;
}
// コピー
CopyMemory(to_mem, from_mem, *ret_size);
// ロック解除
GlobalUnlock(ret);
GlobalUnlock(data);
break;
}
return ret;
}
