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);
}
/* must be balanced by a call to HEndSpoolGraf() */
void HSpoolGraf(char *fname)
{
int wmm,hmm; /* width and height in millimeters */
int wpx,hpx; /* width and height in pixels */
char *description = "Created by HGraf";
RECT r;
HDC dc = GetDC(theWindow);
int er;
wmm = GetDeviceCaps(dc, HORZSIZE);
hmm = GetDeviceCaps(dc, VERTSIZE);
wpx = GetDeviceCaps(dc, HORZRES);
hpx = GetDeviceCaps(dc, VERTRES);
r.left = (ClientRect.left * wmm * 100)/wpx;
r.top = (ClientRect.top * hmm * 100)/hpx;
r.right = (ClientRect.right * wmm * 100)/wpx;
r.bottom = (ClientRect.bottom * hmm * 100)/hpx;
DCSaved = memDC;
memDC = CreateEnhMetaFile(dc,fname,&r,description);
er = GetLastError();
ReleaseDC(theWindow,dc);
WritingToMeta = TRUE;
}
void rectdraw0(long *w, long *x, long *y, long lw)
{
char tmppath[MAX_PATH], fname[MAX_PATH];
struct plot_eng plotWin32;
HDC hEmf;
int bg_r,bg_g,bg_b;
GetTempPath(sizeof(tmppath), tmppath);
sprintf(fname, "%s\\gp-ploth-%lx.emf", tmppath, time(NULL)/(24*60*60)*1000+GetTickCount());
hEmf = CreateEnhMetaFile(GetDC(NULL), fname, NULL, NULL);
SetMapMode(hEmf, MM_TEXT);
SelectObject(hEmf, GetStockObject(DEFAULT_GUI_FONT));
color_to_rgb(gel(GP_DATA->colormap,1), &bg_r, &bg_g, &bg_b);
SetBkColor(hEmf, RGB(bg_r,bg_g,bg_b));
SetBkMode(hEmf, OPAQUE);
plotWin32.sc=&SetForeground;
plotWin32.pt=&DrawPoint;
plotWin32.ln=&DrawLine;
plotWin32.bx=&DrawRectangle;
plotWin32.mp=&DrawPoints;
plotWin32.ml=&DrawLines;
plotWin32.st=&DrawString;
plotWin32.pl=&pari_plot;
plotWin32.data=(void*)hEmf;
gen_rectdraw0(&plotWin32, w, x, y, lw, 1, 1);
DeleteEnhMetaFile(CloseEnhMetaFile(hEmf));
ShellExecute(NULL,NULL,fname,NULL,NULL,SW_SHOWDEFAULT);
}
// =============== CreateFile & CloseFile
// ----------------------------------------------
HDC COXMetaFile::CreateFile(CString strFileName, CString strDescript,
CString sDefExt/* = _T("emf")*/,
int nIDFilter/*"EMF Files(*.emf)|*.emf|All Files(*.*)|*.*|"*/)
{
m_hDCMeta = NULL;
CString sFilter;
VERIFY(sFilter.LoadString(nIDFilter));
// Dlg
if(! strFileName.GetLength())
{
CString sFileName=_T("*.");
sFileName+=sDefExt;
CFileDialog NewMetaFile(FALSE, sDefExt, sFileName,
OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, sFilter);
if(NewMetaFile.DoModal() != IDOK)
return NULL;
m_strFileName = NewMetaFile.GetPathName();
}
else
m_strFileName = strFileName;
m_hDCMeta = CreateEnhMetaFile(NULL, m_strFileName, NULL, strDescript) ;
#ifdef _DEBUG
if(!m_hDCMeta)
AfxMessageBox(_T("Error in CreateEnhMetaFile\n")+strDescript);
#endif
return m_hDCMeta;
}
static HENHMETAFILE create_emf(void)
{
const RECT rect = {0, 0, 100, 100};
HDC hdc = CreateEnhMetaFile(NULL, NULL, &rect, "HENHMETAFILE Marshaling Test\0Test\0\0");
ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rect, "Test String", strlen("Test String"), NULL);
return CloseEnhMetaFile(hdc);
}
/**
** Higher-level interface: Output Enhanced META File format (-m emf)
**/
int to_emf(const GEN_PAR * pg, const OUT_PAR * po)
{
HANDLE outDC;
int err = 0;
if (!pg->quiet)
Eprintf("\n\n- Writing emf code to \"%s\"\n",
*po->outfile == '-' ? "stdout" : po->outfile);
/* Init. */
if (*po->outfile != '-') {
if ((outDC =
CreateEnhMetaFile(NULL, po->outfile, NULL,
"hp2xx\0\0")) == 0) {
PError("hp2xx (emf)");
return ERROR;
}
} else {
PError("hp2xx (Cant send metafile to stdout emf)");
return ERROR;
}
SetMapMode(outDC, MM_ANISOTROPIC);
SetViewportExtEx(outDC, 10, -10, NULL); // size mult
err = plotit(outDC, pg, po);
CloseEnhMetaFile(outDC);
if (!pg->quiet) {
Eprintf("\nlines=%d moves=%d", lines, moves);
Eprintf("\n");
}
return err;
}
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) ;
}
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;
}
HDC InitialiseEnhMetafileDC(HWND hWnd)
{
HDC windowDC = GetDC(hWnd);
RECT newRect = GetRect(windowDC);
metafileDC = CreateEnhMetaFile(windowDC, NULL, &newRect, NULL);
ReleaseDC(hWnd, windowDC);
return metafileDC;
}
/* width and height are in mm */
metafile newmetafile(const char *name, double width, double height)
{
metafile obj;
HDC hDC;
RECT wr;
static double cppix=-1, ppix, cppiy, ppiy;
/*
* In theory, (cppix=ppix) and (cppiy=ppiy). However, we
* use the ratio to adjust the 'reference dimension'
* in case.... ("Importing graph in MsWord" thread)
*/
if (cppix < 0) {
cppix = 25.40 * devicewidth(NULL) / devicewidthmm(NULL);
ppix = 100 * devicepixelsx(NULL);
cppiy = 25.40 * deviceheight(NULL) / deviceheightmm(NULL);
ppiy = 100 * devicepixelsy(NULL);
}
/* This is all very peculiar. We would really like to create
a metafile measured in some sensible units, but it seems
we get it in units of 0.01mm *on the current screen* with
horizontal and vertical resolution set for that screen.
And of course Windows is famous for getting screen sizes wrong.
*/
wr.left = 0;
wr.top = 0 ;
wr.right = (ppix * width) / cppix ;
wr.bottom = (ppiy * height) / cppiy ;
/* Here the size is in 0.01mm units */
hDC = CreateEnhMetaFile(NULL, strlen(name) ? name : NULL, &wr,
"GraphApp\0\0");
if ( !hDC ) {
R_ShowMessage(_("Unable to create metafile"));
return NULL;
}
obj = new_object(MetafileObject, (HANDLE) hDC, get_metafile_base());
if ( !obj ) {
R_ShowMessage(_("Insufficient memory to create metafile"));
DeleteEnhMetaFile(CloseEnhMetaFile(hDC));
return NULL;
}
/* In looks like Windows rounds up the width and height, so we
do too. 1 out is common, but 2 out has been seen.
This is needed to get complete painting of the background.
*/
obj->rect = rect(0, 0, 2+(ppix * width)/2540, 2+(ppiy * height)/2540);
obj->depth = GetDeviceCaps(hDC, BITSPIXEL) * GetDeviceCaps(hDC, PLANES);
obj->die = private_delmetafile;
obj->drawstate = copydrawstate();
obj->drawstate->dest = obj;
settext(obj, name ? name : "");
return obj;
}
/*
%F cdCreateCanvas para EMF.
O DC é um EMF em memoria.
*/
static void cdcreatecanvas(cdCanvas* canvas, void* data)
{
cdCtxCanvas* ctxcanvas;
char* strdata = (char*)data;
int w = 0, h = 0;
double xres, yres;
FILE* file;
char filename[10240] = "";
HDC ScreenDC, hDC;
RECT rect;
/* Inicializa parametros */
if (strdata == NULL)
return;
strdata += cdGetFileName(strdata, filename);
if (filename[0] == 0)
return;
sscanf(strdata,"%dx%d", &w, &h);
if (w == 0 || h == 0)
return;
/* Verifica se o arquivo pode ser aberto para escrita */
file = fopen(filename, "wb");
if (file == NULL) return;
fclose(file);
ScreenDC = GetDC(NULL);
/* LOGPIXELS can not be used for EMF */
xres = (double)GetDeviceCaps(ScreenDC, HORZRES) / (double)GetDeviceCaps(ScreenDC, HORZSIZE);
yres = (double)GetDeviceCaps(ScreenDC, VERTRES) / (double)GetDeviceCaps(ScreenDC, VERTSIZE);
rect.left = 0;
rect.top = 0;
rect.right = (int)(100. * w / xres);
rect.bottom = (int)(100. * h / yres);
hDC = CreateEnhMetaFile(ScreenDC,filename,&rect,NULL);
ReleaseDC(NULL, ScreenDC);
if(!hDC)
return;
/* Inicializa driver WIN32 */
ctxcanvas = cdwCreateCanvas(canvas, NULL, hDC, CDW_EMF);
canvas->w = w;
canvas->h = h;
canvas->xres = xres;
canvas->yres = yres;
canvas->w_mm = ((double)w) / xres;
canvas->h_mm = ((double)h) / yres;
canvas->bpp = 24;
ctxcanvas->clip_pnt[2].x = ctxcanvas->clip_pnt[1].x = canvas->w - 1;
ctxcanvas->clip_pnt[3].y = ctxcanvas->clip_pnt[2].y = canvas->h - 1;
}
static HENHMETAFILE copyToMetafile (Picture me) {
RECT rect;
HDC dc;
PRINTDLG defaultPrinter;
int resolution;
memset (& defaultPrinter, 0, sizeof (PRINTDLG));
defaultPrinter. lStructSize = sizeof (PRINTDLG);
defaultPrinter. Flags = PD_RETURNDEFAULT | PD_RETURNDC;
PrintDlg (& defaultPrinter);
SetRect (& rect, my selx1 * 2540, (12 - my sely2) * 2540, my selx2 * 2540, (12 - my sely1) * 2540);
dc = CreateEnhMetaFile (defaultPrinter. hDC, nullptr, & rect, L"Praat\0");
if (! dc) Melder_throw (U"Cannot create Windows metafile.");
resolution = GetDeviceCaps (dc, LOGPIXELSX); // Virtual PC: 360; Parallels Desktop: 600
//Melder_fatal (U"resolution ", resolution);
if (Melder_debug == 6) {
DEVMODE *devMode = * (DEVMODE **) defaultPrinter. hDevMode;
MelderInfo_open ();
MelderInfo_writeLine (U"DEVICE CAPS:");
MelderInfo_writeLine (U"aspect x ", GetDeviceCaps (dc, ASPECTX),
U" y ", GetDeviceCaps (dc, ASPECTY));
MelderInfo_writeLine (U"res(pixels) hor ", GetDeviceCaps (dc, HORZRES),
U" vert ", GetDeviceCaps (dc, VERTRES));
MelderInfo_writeLine (U"size(mm) hor ", GetDeviceCaps (dc, HORZSIZE),
U" vert ", GetDeviceCaps (dc, VERTSIZE));
MelderInfo_writeLine (U"pixels/inch hor ", GetDeviceCaps (dc, LOGPIXELSX),
U" vert ", GetDeviceCaps (dc, LOGPIXELSY));
MelderInfo_writeLine (U"physicalOffset(pixels) hor ", GetDeviceCaps (dc, PHYSICALOFFSETX),
U" vert ", GetDeviceCaps (dc, PHYSICALOFFSETY));
MelderInfo_writeLine (U"PRINTER:");
MelderInfo_writeLine (U"dmFields ", devMode -> dmFields);
if (devMode -> dmFields & DM_YRESOLUTION)
MelderInfo_writeLine (U"y resolution ", devMode -> dmYResolution);
if (devMode -> dmFields & DM_PRINTQUALITY)
MelderInfo_writeLine (U"print quality ", devMode -> dmPrintQuality);
if (devMode -> dmFields & DM_PAPERWIDTH)
MelderInfo_writeLine (U"paper width ", devMode -> dmPaperWidth);
if (devMode -> dmFields & DM_PAPERLENGTH)
MelderInfo_writeLine (U"paper length ", devMode -> dmPaperLength);
if (devMode -> dmFields & DM_PAPERSIZE)
MelderInfo_writeLine (U"paper size ", devMode -> dmPaperSize);
if (devMode -> dmFields & DM_ORIENTATION)
MelderInfo_writeLine (U"orientation ", devMode -> dmOrientation);
MelderInfo_close ();
}
autoGraphics pictGraphics = Graphics_create_screen ((void *) dc, nullptr, resolution);
Graphics_setWsViewport (pictGraphics.peek(), 0, WIN_WIDTH * resolution, 0, WIN_HEIGHT * resolution);
Graphics_setWsWindow (pictGraphics.peek(), 0.0, WIN_WIDTH, 12.0 - WIN_HEIGHT, 12.0);
Graphics_play (my graphics.get(), pictGraphics.peek());
HENHMETAFILE metafile = CloseEnhMetaFile (dc);
return metafile;
}
HDC QuerySaveEMFFile(const TCHAR * description, const RECT * rcFrame, TCHAR szFileName[])
{
KFileDialog fd;
if ( fd.GetSaveFileName(NULL, _T("emf"), _T("Enhanced Metafiles")) )
{
if ( szFileName )
_tcscpy(szFileName, fd.m_TitleName);
return CreateEnhMetaFile(NULL, fd.m_TitleName, rcFrame, description);
}
else
return NULL;
}
void CreateRoutine (HWND hwnd)
{
HDC hdcEMF ;
HENHMETAFILE hemf ;
hdcEMF = CreateEnhMetaFile (NULL, TEXT ("emf11.emf"), NULL,
TEXT ("EMF11\0EMF Demo #11\0")) ;
SetMapMode (hdcEMF, MM_LOENGLISH) ;
DrawRuler (hdcEMF, 600, 100) ;
hemf = CloseEnhMetaFile (hdcEMF) ;
DeleteEnhMetaFile (hemf) ;
}
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) ;
}
static cairo_surface_t *
open_emf(int dpi, const char *fname)
{
HDC hdc;
cairo_surface_t *surface;
XFORM xform = {1, 0, 0, 1, 0, 0};
int disp_dpi;
hdc = CreateEnhMetaFile(NULL, fname, NULL, NULL);
if (hdc == NULL) {
return NULL;
}
SetGraphicsMode(hdc, GM_ADVANCED);
disp_dpi = GetDeviceCaps(hdc, LOGPIXELSX);
xform.eM11 = xform.eM22 = 1.0 * disp_dpi / dpi;
SetWorldTransform(hdc, &xform);
surface = cairo_win32_printing_surface_create(hdc);
StartPage(hdc);
return surface;
}
void SaveEnhMetaFile(HWND hWnd)
{
OPENFILENAME SFile;
WCHAR FileName[MAX_PATH], FilePath[MAX_PATH];
FileName[0] = '\0';
FilePath[0] = '\0';
SFile.lStructSize = sizeof(OPENFILENAME);
SFile.hwndOwner = hWnd;
SFile.lpstrFilter = L"EMF(*.emf)\0";
SFile.lpstrCustomFilter = 0;
SFile.lpstrFile = FilePath;
SFile.nMaxFile = MAX_PATH * sizeof(WCHAR);
SFile.lpstrFileTitle = FileName;
SFile.nMaxFileTitle = MAX_PATH * sizeof(WCHAR);
SFile.lpstrInitialDir = 0;
SFile.lpstrDefExt = L"emf";
SFile.lpstrTitle = L"Save file as:";
SFile.Flags = OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT;
GetSaveFileName(&SFile);
HDC hdcRef = GetDC(hWnd);
int iWidthMM, iHeightMM, iWidthPels, iHeightPels;
RECT EnhClient;
iWidthMM = GetDeviceCaps(hdcRef, HORZSIZE);
iHeightMM = GetDeviceCaps(hdcRef, VERTSIZE);
iWidthPels = GetDeviceCaps(hdcRef, HORZRES);
iHeightPels = GetDeviceCaps(hdcRef, VERTRES);
GetClientRect(hWnd, &EnhClient);
EnhClient.left = (EnhClient.left * iWidthMM * 100) / iWidthPels;
EnhClient.top = (EnhClient.top * iHeightMM * 100) / iHeightPels;
EnhClient.right = (EnhClient.right * iWidthMM * 100) / iWidthPels;
EnhClient.bottom = (EnhClient.bottom * iHeightMM * 100) / iHeightPels;
HDC hdcEmf = CreateEnhMetaFile(hdcRef, SFile.lpstrFile, &EnhClient, 0);
BitBlt(hdcEmf, 0, 0, scrhor/3, scrvert/3, hdc1, scrhor/3, scrvert/3, SRCCOPY);
CloseEnhMetaFile(hdcEmf);
ReleaseDC(hWnd, hdcRef);
}
HBITMAP CContextMenuHelper::InitializeOwnerDrawItem(HMENU hMenu, UINT index, SIZE *lpSize) {
m_iLeftOfText = 0;
m_pBuffer = NULL;
HBITMAP hBitmap = NULL;
HRESULT hr;
IContextMenu2* pcm2;
if (SUCCEEDED(hr = m_lpcm->QueryInterface(IID_IContextMenu2, (LPVOID*)&pcm2))) {
// get item data
MENUITEMINFO mii;
ZeroMemory(&mii, sizeof(MENUITEMINFO));
mii.cbSize = sizeof(MENUITEMINFO);
mii.fMask = MIIM_DATA | MIIM_ID;
if (::GetMenuItemInfo(hMenu, index, TRUE, &mii) && mii.dwItemData != NULL) {
// get item dimensions
MEASUREITEMSTRUCT mis;
ZeroMemory(&mis, sizeof(MEASUREITEMSTRUCT));
mis.CtlType = ODT_MENU;
mis.itemData = mii.dwItemData;
mis.itemID = mii.wID;
// fake ownerdraw msg
if (SUCCEEDED(hr = (pcm2->HandleMenuMsg(WM_MEASUREITEM, 0, (LPARAM)&mis)))) {
if (mis.itemWidth && mis.itemHeight > 0) {
HDC hDC = CreateEnhMetaFile(NULL, NULL, NULL, NULL);
RECT r = { 0, 0, mis.itemWidth, mis.itemHeight };
BOOL bStringFound = FALSE;
// fake ownerdraw msg
DRAWITEMSTRUCT dis;
ZeroMemory(&dis, sizeof(DRAWITEMSTRUCT));
dis.CtlType = ODT_MENU;
dis.itemID = mii.wID;
dis.itemData = mii.dwItemData;
dis.itemAction = ODA_DRAWENTIRE;
dis.hwndItem = (HWND)hMenu;
dis.hDC = hDC;
dis.rcItem = r;
if (SUCCEEDED(hr = pcm2->HandleMenuMsg(WM_DRAWITEM, 0, (LPARAM)&dis))) {
HENHMETAFILE hEMF = CloseEnhMetaFile(hDC);
// enum metafile records and search for strings
char buf[MAX_PATH] = { 0 };
m_pBuffer = buf;
m_iLeftOfText = 0;
::EnumEnhMetaFile(NULL, hEMF, EnhMetaFileProc, this, NULL);
::DeleteEnhMetaFile(hEMF);
m_pBuffer = NULL;
if (buf[0] != 0) {
bStringFound = ::ModifyMenu(hMenu, index, MF_BYPOSITION | MF_STRING, mii.wID, buf);
}
}
// Try to get bitmap
hDC = ::CreateCompatibleDC(m_hDC);
if (hDC != NULL) {
// obtain image rect
if (bStringFound) {
if (m_iLeftOfText > 0) {
r.left = (m_iLeftOfText - 16) / 2;
r.top = (mis.itemHeight - 16) / 2;
} else {
r.top = (mis.itemHeight - 16) / 2;
r.left = r.top;
}
r.right = r.left + 16;
r.bottom = r.top + 16;
}
if (lpSize != NULL) {
lpSize->cx = r.right - r.left;
lpSize->cy = r.bottom - r.top;
}
hBitmap = ::CreateCompatibleBitmap(m_hDC, r.right - r.left, r.bottom - r.top);
if (hBitmap != NULL) {
HBITMAP hPrevBitmap = (HBITMAP)::SelectObject(hDC, hBitmap);
// draw item on a bitmap
COLORREF crBack = ::GetSysColor(COLOR_MENU);
::SetWindowOrgEx(hDC, r.left, r.top, NULL);
::FillRect(hDC, &r, ::CreateSolidBrush(crBack));
dis.hDC = hDC;
pcm2->HandleMenuMsg(WM_DRAWITEM, 0, (LPARAM)&dis);
::SelectObject(hDC, hPrevBitmap);
}
::DeleteDC(hDC);
}
}
}
}
pcm2->Release();
}
return hBitmap;
}
static void cdcreatecanvas(cdCanvas* canvas, void *data)
{
char* strsize = (char*)data;
int w = 0, h = 0, wtype = CDW_EMF; /* default clipboard type */
double xres=0, yres=0;
HDC hDC;
BITMAPINFO bmi;
BYTE* bits;
HBITMAP hBitmapClip, hOldBitmapClip;
/* Inicializa parametros */
if (strsize == NULL)
return;
if (strstr(strsize, "-b") != NULL)
wtype = CDW_BMP;
else if (strstr(strsize, "-m") != NULL)
wtype = -1; /* CD METAFILE */
if (wtype != -1)
{
sscanf(strsize,"%dx%d",&w, &h);
if (w == 0 || h == 0)
return;
}
if (wtype == CDW_EMF)
{
HDC ScreenDC = GetDC(NULL);
RECT rect;
/* LOGPIXELS can not be used for EMF */
xres = (double)GetDeviceCaps(ScreenDC, HORZRES) / (double)GetDeviceCaps(ScreenDC, HORZSIZE);
yres = (double)GetDeviceCaps(ScreenDC, VERTRES) / (double)GetDeviceCaps(ScreenDC, VERTSIZE);
rect.left = 0;
rect.top = 0;
rect.right = (int)(100. * w / xres);
rect.bottom = (int)(100. * h / yres);
hDC = CreateEnhMetaFile(ScreenDC,NULL,&rect,NULL);
ReleaseDC(NULL, ScreenDC);
}
else if (wtype == CDW_BMP)
{
HDC ScreenDC = GetDC(NULL);
hDC = CreateCompatibleDC(ScreenDC);
xres = (double)GetDeviceCaps(ScreenDC, HORZRES) / (double)GetDeviceCaps(ScreenDC, HORZSIZE);
yres = (double)GetDeviceCaps(ScreenDC, VERTRES) / (double)GetDeviceCaps(ScreenDC, VERTSIZE);
bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmi.bmiHeader.biWidth = w;
bmi.bmiHeader.biHeight = h;
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = 24;
bmi.bmiHeader.biCompression = BI_RGB;
bmi.bmiHeader.biSizeImage = 0;
bmi.bmiHeader.biXPelsPerMeter = (long)(GetDeviceCaps(ScreenDC, LOGPIXELSX) / 0.0254);
bmi.bmiHeader.biYPelsPerMeter = (long)(GetDeviceCaps(ScreenDC, LOGPIXELSY) / 0.0254);
bmi.bmiHeader.biClrUsed = 0;
bmi.bmiHeader.biClrImportant = 0;
hBitmapClip = CreateDIBSection(hDC, &bmi, DIB_RGB_COLORS, &bits, NULL, 0);
ReleaseDC(NULL, ScreenDC);
if (!hBitmapClip)
return;
hOldBitmapClip = SelectObject(hDC, hBitmapClip);
}
if (wtype == -1)
{
char filename[10240];
char str[10240];
if (!cdStrTmpFileName(filename))
return;
sprintf(str, "%s %s", filename, strsize);
cdcreatecanvasMF(canvas, str);
}
else
{
cdCtxCanvas* ctxcanvas;
/* Inicializa driver WIN32 */
ctxcanvas = cdwCreateCanvas(canvas, NULL, hDC, wtype);
canvas->w = w;
canvas->h = h;
canvas->xres = xres;
canvas->yres = yres;
canvas->w_mm = ((double)w) / xres;
canvas->h_mm = ((double)h) / yres;
canvas->bpp = 24;
ctxcanvas->clip_pnt[2].x = ctxcanvas->clip_pnt[1].x = canvas->w - 1;
ctxcanvas->clip_pnt[3].y = ctxcanvas->clip_pnt[2].y = canvas->h - 1;
if (wtype == CDW_BMP)
{
ctxcanvas->hBitmapClip = hBitmapClip;
ctxcanvas->hOldBitmapClip = hOldBitmapClip;
ctxcanvas->bmiClip = bmi;
ctxcanvas->bitsClip = bits;
}
}
}
// Вызывается ТОЛЬКО в главной нити!
void CPluginBackground::UpdateBackground()
{
if (!mn_BgPluginsCount)
return;
if (!ghConEmuWndDC || !IsWindow(ghConEmuWndDC))
return;
if (mb_ThNeedLoad)
{
LoadThSet(TRUE/*Мы уже в главной нити*/);
}
//RECT rcClient; GetClientRect(ghConEmuWndDC, &rcClient);
struct PaintBackgroundArg Arg = m_Default;
Arg.cbSize = sizeof(struct PaintBackgroundArg);
//m_Default.dcSizeX = Arg.dcSizeX = rcClient.right+1;
//m_Default.dcSizeY = Arg.dcSizeY = rcClient.bottom+1;
m_Default.dcSizeX = Arg.dcSizeX = (m_Default.rcConWorkspace.right-m_Default.rcConWorkspace.left+1)*m_Default.MainFont.nFontCellWidth;
m_Default.dcSizeY = Arg.dcSizeY = (m_Default.rcConWorkspace.bottom-m_Default.rcConWorkspace.top+1)*m_Default.MainFont.nFontHeight;
// **********************************************************************************
// запомнить данные из m_Default в m_Last, но т.к. там есть указатели - move не катит
// **********************************************************************************
//memmove(&m_Last, &m_Default, sizeof(m_Last));
m_Last.MainFont = m_Default.MainFont;
memmove(m_Last.crPalette, m_Default.crPalette, sizeof(m_Last.crPalette));
m_Last.dcSizeX = m_Default.dcSizeX;
m_Last.dcSizeY = m_Default.dcSizeY;
m_Last.rcDcLeft = m_Default.rcDcLeft;
m_Last.rcDcRight = m_Default.rcDcRight;
m_Last.rcConWorkspace = m_Default.rcConWorkspace;
m_Last.conCursor = m_Default.conCursor;
m_Last.FarInterfaceSettings.Raw = m_Default.FarInterfaceSettings.Raw;
m_Last.FarPanelSettings.Raw = m_Default.FarPanelSettings.Raw;
memmove(m_Last.nFarColors, m_Default.nFarColors, sizeof(m_Last.nFarColors));
m_Last.bPanelsAllowed = m_Default.bPanelsAllowed;
// struct tag_BkPanelInfo
m_Last.LeftPanel.bVisible = m_Default.LeftPanel.bVisible;
m_Last.LeftPanel.bFocused = m_Default.LeftPanel.bFocused;
m_Last.LeftPanel.bPlugin = m_Default.LeftPanel.bPlugin;
m_Last.LeftPanel.rcPanelRect = m_Default.LeftPanel.rcPanelRect;
m_Last.RightPanel.bVisible = m_Default.RightPanel.bVisible;
m_Last.RightPanel.bFocused = m_Default.RightPanel.bFocused;
m_Last.RightPanel.bPlugin = m_Default.RightPanel.bPlugin;
m_Last.RightPanel.rcPanelRect = m_Default.RightPanel.rcPanelRect;
// строки
lstrcpyW(m_Last.LeftPanel.szCurDir, m_Default.LeftPanel.szCurDir);
lstrcpyW(m_Last.LeftPanel.szFormat, m_Default.LeftPanel.szFormat);
lstrcpyW(m_Last.LeftPanel.szHostFile, m_Default.LeftPanel.szHostFile);
lstrcpyW(m_Last.RightPanel.szCurDir, m_Default.RightPanel.szCurDir);
lstrcpyW(m_Last.RightPanel.szFormat, m_Default.RightPanel.szFormat);
lstrcpyW(m_Last.RightPanel.szHostFile, m_Default.RightPanel.szHostFile);
// **********************************************************************************
if (m_Default.dcSizeX < 1 || m_Default.dcSizeY < 1)
{
_ASSERTE(m_Default.dcSizeX >= 1 && m_Default.dcSizeY >= 1);
return;
}
SetDcPanelRect(&Arg.rcDcLeft, &Arg.LeftPanel, &Arg);
SetDcPanelRect(&Arg.rcDcRight, &Arg.RightPanel, &Arg);
// gpTabs отстает от реальности.
Arg.Place = m_Default.Place;
//if (!gpTabs)
// Arg.Place = pbp_Panels;
//else if (gnCurrentWindowType == WTYPE_EDITOR)
// Arg.Place = pbp_Editor;
//else if (gnCurrentWindowType == WTYPE_VIEWER)
// Arg.Place = pbp_Viewer;
//else if (Arg.LeftPanel.bVisible || Arg.RightPanel.bVisible)
//{
// _ASSERTE(gnCurrentWindowType == WTYPE_PANELS);
// Arg.Place = pbp_Panels;
//}
BITMAPINFOHEADER bi = {sizeof(BITMAPINFOHEADER)};
bi.biWidth = Arg.dcSizeX;
bi.biHeight = Arg.dcSizeY;
bi.biPlanes = 1;
bi.biBitCount = 32; //-V112
bi.biCompression = BI_RGB;
//_ASSERTE(Arg.LeftPanel.bVisible || Arg.RightPanel.bVisible);
HDC hScreen = GetDC(NULL);
RECT rcMeta = {0,0, Arg.dcSizeX, Arg.dcSizeY}; // (in pixels)
int iWidthMM = GetDeviceCaps(hScreen, HORZSIZE); if (iWidthMM <= 0) { _ASSERTE(iWidthMM>0); iWidthMM = 1024; }
int iHeightMM = GetDeviceCaps(hScreen, VERTSIZE); if (iHeightMM <= 0) { _ASSERTE(iHeightMM>0); iHeightMM = 768; }
int iWidthPels = GetDeviceCaps(hScreen, HORZRES); if (iWidthPels <= 0) { _ASSERTE(iWidthPels>0); iWidthPels = 0; }
int iHeightPels = GetDeviceCaps(hScreen, VERTRES); if (iHeightPels <= 0) { _ASSERTE(iHeightPels>0); iHeightPels = 0; }
RECT rcMetaMM = {0,0, (rcMeta.right * iWidthMM * 100)/iWidthPels, (rcMeta.bottom * iHeightMM * 100)/iHeightPels}; // (in .01-millimeter units)
HDC hdc = NULL;
HENHMETAFILE hEmf = NULL;
COLORREF* pBits = NULL;
HBITMAP hDib = NULL, hOld = NULL;
#ifdef CREATE_EMF_TEMP_FILES
wchar_t szEmfFile[MAX_PATH] = {};
#endif
wchar_t *pszEmfFile = NULL;
if (SETBACKGROUND_USE_EMF==1)
{
#ifdef CREATE_EMF_TEMP_FILES
GetTempPath(MAX_PATH-32, szEmfFile);
int nLen = lstrlen(szEmfFile);
if (*szEmfFile && szEmfFile[nLen-1] != L'\\')
{
szEmfFile[nLen++] = L'\\';
szEmfFile[nLen] = 0;
}
_wsprintf(szEmfFile+nLen, SKIPLEN(31) L"CeBack%u.emf", GetCurrentProcessId());
pszEmfFile = szEmfFile;
#endif
hdc = CreateEnhMetaFile(hScreen, pszEmfFile, &rcMetaMM, L"ConEmu\0Far Background\0\0");
if (!hdc)
{
_ASSERTE(hdc!=NULL);
return;
}
}
else
{
hdc = CreateCompatibleDC(hScreen);
if (!hdc)
{
_ASSERTE(hdc!=NULL);
return;
}
_ASSERTE(pBits = NULL);
hDib = CreateDIBSection(hScreen, (BITMAPINFO*)&bi, DIB_RGB_COLORS, (void**)&pBits, NULL, 0);
}
ReleaseDC(NULL, hScreen); hScreen = NULL;
Arg.hdc = hdc;
if (SETBACKGROUND_USE_EMF==1)
{
HBRUSH hFillBr = CreateSolidBrush (
#ifdef _DEBUG
RGB(128,128,0)
#else
RGB(0,0,0)
#endif
);
FillRect(hdc, &rcMeta, hFillBr);
DeleteObject(hFillBr);
}
else
{
if (!hDib || !pBits)
{
_ASSERTE(hDib && pBits);
if (hDib)
DeleteObject(hDib);
if (hdc)
DeleteDC(hdc);
return;
}
hOld = (HBITMAP)SelectObject(hdc, hDib);
// Залить черным - по умолчанию
#ifdef _DEBUG
memset(pBits, 128, bi.biWidth*bi.biHeight*4); //-V112
#else
memset(pBits, 0, bi.biWidth*bi.biHeight*4);
#endif
}
// Painting!
int nProcessed = 0;
MSectionLock SC; SC.Lock(csBgPlugins, TRUE);
DWORD nFromLevel = 0, nNextLevel, nSuggested;
DWORD dwDrawnPlaces = Arg.Place;
while(true)
{
nNextLevel = nFromLevel;
struct RegisterBackgroundArg *p = mp_BgPlugins;
for(int i = 0; i < mn_BgPluginsCount; i++, p++)
{
if (p->Cmd != rbc_Register ||
!(p->dwPlaces & Arg.Place) ||
!(p->PaintConEmuBackground))
continue; // пустая, неактивная в данном контексте, или некорректная ячейка
// Слои
nSuggested = p->dwSuggestedLevel;
if (nSuggested < nFromLevel)
{
continue; // Этот слой уже обработан
}
else if (nSuggested > nFromLevel)
{
// Этот слой нужно будет обработать в следующий раз
if ((nNextLevel == nFromLevel) || (nSuggested < nNextLevel))
nNextLevel = nSuggested;
continue;
}
// На уровне 0 (заливающий фон) должен быть только один плагин
Arg.dwLevel = (nProcessed == 0) ? 0 : (nFromLevel == 0 && nProcessed) ? 1 : nFromLevel;
Arg.lParam = mp_BgPlugins[i].lParam;
Arg.dwDrawnPlaces = 0;
//mp_BgPlugins[i].PaintConEmuBackground(&Arg);
UpdateBackground_Exec(mp_BgPlugins+i, &Arg);
// Что плагин покрасил (панели/редактор/вьювер считаются покрашенными по умолчанию)
dwDrawnPlaces |= Arg.dwDrawnPlaces;
//
nProcessed++;
}
if (nNextLevel == nFromLevel)
break; // больше слоев нет
nFromLevel = nNextLevel;
}
SC.Unlock();
// Sending background to GUI!
if (nProcessed < 1)
{
// Ситуация возникает при старте ConEmu, когда панелей "еще нет"
//_ASSERTE(nProcessed >= 1);
if (mb_BgWasSent)
{
mb_BgWasSent = FALSE;
CESERVER_REQ *pIn = ExecuteNewCmd(CECMD_SETBACKGROUND, sizeof(CESERVER_REQ_HDR)+sizeof(CESERVER_REQ_SETBACKGROUND));
if (pIn)
{
pIn->Background.nType = 1;
pIn->Background.bEnabled = FALSE;
pIn->Background.dwDrawnPlaces = 0;
CESERVER_REQ *pOut = ExecuteGuiCmd(FarHwnd, pIn, FarHwnd);
if (pOut)
{
ExecuteFreeResult(pOut);
}
ExecuteFreeResult(pIn);
}
}
}
else // есть "отработавшие" плагины, обновить Background!
{
GdiFlush();
DWORD nBitSize = 0, nBitsError = 0;
if (SETBACKGROUND_USE_EMF==1)
{
hEmf = CloseEnhMetaFile(hdc);
hdc = NULL;
nBitSize = GetEnhMetaFileBits(hEmf, 0, NULL);
if (nBitSize == 0)
{
dwDrawnPlaces = 0;
nBitsError = GetLastError();
_ASSERTE(nBitSize!=0);
if (hEmf)
{
// В случае ошибки - сразу удаляем
DeleteEnhMetaFile(hEmf);
hEmf = NULL;
}
}
}
else
{
nBitSize = bi.biWidth*bi.biHeight*sizeof(COLORREF);
}
DWORD nWholeSize = sizeof(CESERVER_REQ_HDR)+sizeof(CESERVER_REQ_SETBACKGROUND)+nBitSize; //-V103 //-V119
CESERVER_REQ *pIn = ExecuteNewCmd(CECMD_SETBACKGROUND, nWholeSize);
if (!pIn)
{
_ASSERTE(pIn);
}
else
{
pIn->Background.nType = 1;
pIn->Background.bEnabled = TRUE;
pIn->Background.dwDrawnPlaces = dwDrawnPlaces;
if (SETBACKGROUND_USE_EMF==1)
pIn->Background.bmp.bfType = 0x4645/*EF*/;
else
pIn->Background.bmp.bfType = 0x4D42/*BM*/;
pIn->Background.bmp.bfSize = nBitSize+sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER); //-V119
pIn->Background.bmp.bfOffBits = sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER); //-V119
pIn->Background.bi = bi;
if (SETBACKGROUND_USE_EMF==1)
{
LPBYTE pBits = ((LPBYTE)&pIn->Background)+sizeof(pIn->Background);
DWORD nBitsRc = (nBitSize && hEmf) ? GetEnhMetaFileBits(hEmf, nBitSize, pBits) : 0;
_ASSERTE(nBitsRc == nBitSize);
if (!nBitsRc)
{
_ASSERTE(nBitsRc!=NULL);
// Отключить нафиг
ExecutePrepareCmd(&pIn->hdr, CECMD_SETBACKGROUND, nWholeSize-nBitSize);
pIn->Background.nType = 1;
pIn->Background.bEnabled = FALSE;
pIn->Background.dwDrawnPlaces = 0;
}
}
else
{
memmove(((LPBYTE)&pIn->Background)+sizeof(pIn->Background), pBits, bi.biWidth*bi.biHeight*sizeof(COLORREF));
}
CESERVER_REQ *pOut = ExecuteGuiCmd(FarHwnd, pIn, FarHwnd);
// Вызывается ТОЛЬКО в главной нити
_ASSERTE(GetCurrentThreadId() == gnMainThreadId);
if (pOut)
{
mb_BgWasSent = TRUE;
// Сбросим флажок "Ошибка уже была показана"
if (pOut->BackgroundRet.nResult == esbr_OK)
{
mb_BgErrorShown = FALSE;
}
// Показать ошибку, если есть
else if ((pOut->BackgroundRet.nResult > esbr_OK) && (pOut->BackgroundRet.nResult <= esbr_LastErrorNo)
&& (pOut->BackgroundRet.nResult != esbr_ConEmuInShutdown)
&& !mb_BgErrorShown)
{
mb_BgErrorShown = TRUE;
Plugin()->ShowMessage(CEBkError_ExecFailed+pOut->BackgroundRet.nResult, 0);
}
ExecuteFreeResult(pOut);
}
else if (!mb_BgErrorShown)
{
mb_BgErrorShown = TRUE;
Plugin()->ShowMessage(CEBkError_ExecFailed, 0);
}
ExecuteFreeResult(pIn);
}
}
if (SETBACKGROUND_USE_EMF == 0)
{
if (hdc && hOld)
SelectObject(hdc, hOld);
if (hDib)
DeleteObject(hDib);
if (hdc)
DeleteDC(hdc);
}
else
{
if (hdc)
{
hEmf = CloseEnhMetaFile(hdc);
hdc = NULL;
}
if (hEmf)
{
DeleteEnhMetaFile(hEmf);
hEmf = NULL;
}
}
}
BOOL CDrawDoc::StoreForPrinting(CArchive& ar)
{
// setting up EMF DC, using default printer as reference
HDC hPrt = ((CDrawApp*)AfxGetApp()) -> GetDefaultPrinterIC() ;
if (!hPrt) return FALSE;
RECT rect={0, 0, GetDeviceCaps(hPrt,HORZSIZE)*100, GetDeviceCaps(hPrt,VERTSIZE)*100};
CDC dc;
if (! (dc.m_hDC = CreateEnhMetaFile(hPrt, NULL, &rect, NULL))) return FALSE;
dc.SetAttribDC(dc.m_hDC);
// recording meta file
POSITION pos = GetFirstViewPosition();
CDrawView* pView = (CDrawView*)GetNextView(pos);
if (pView == NULL) return FALSE;
CDrawView::m_IsRecording = TRUE;
pView -> OnPrepareDC(&dc, NULL);
Draw(&dc, pView);
CDrawView::m_IsRecording = FALSE;
HENHMETAFILE hEmf = CloseEnhMetaFile(dc.m_hDC);
// storing EMF into archive
DWORD size = GetEnhMetaFileBits(hEmf, NULL, NULL);
if (size == 0) return FALSE;
HGLOBAL hglobal = GlobalAlloc(GMEM_MOVEABLE, size);
if (hglobal == NULL) return FALSE;
LPBYTE buf = (LPBYTE)GlobalLock(hglobal);
if (buf == NULL) return FALSE;
if (GetEnhMetaFileBits(hEmf,size,buf) != size) return FALSE;
SEPFILEHEADER header;
// set EMF size (header)
header.dwEmfSize = size;
// get text objects count
pos = m_objects.GetHeadPosition();
DWORD count=0;
while (pos != NULL)
{
CDrawText* pObj = (CDrawText*)(m_objects.GetNext(pos));
if (pObj->GetLogFontCopy() != NULL)
count++;
}
// set text records (header)
header.dwTextRecords = count;
// set page size (in logical) (header)
header.sizePage = GetSize();
// write header
ar.Write(&header,sizeof(SEPFILEHEADER));
// write EMF into archive
ar.Write(buf, size);
GlobalUnlock(hglobal);
GlobalFree(hglobal);
DeleteEnhMetaFile(hEmf);
// Save text objects for job-info realization and printing
// write text records into archive
pos = m_objects.GetHeadPosition();
while (pos != NULL)
{
CDrawText* pObj = (CDrawText*)(m_objects.GetNext(pos));
LOGFONT *plf;
if ((plf=pObj->GetLogFontCopy()) != NULL) // is text object
{
TEXTBOX tbox;
tbox.position = pObj->m_position;
tbox.color = pObj->m_color;
tbox.align = pObj->m_align;
tbox.lf = pObj->m_lf;
strncpy(tbox.text,pObj->m_text,SEPMAXTEXT);
ar.Write(&tbox,sizeof(TEXTBOX));
}
}
return TRUE;
}
// Convert this document into a metafile for pasting into
// other applications
HENHMETAFILE CTinyCadDoc::CreateMetafile( CDC &ref_dc, const TCHAR *file_name, bool bw )
{
// Calculate the boundries
CDRect rect = CDRect(0,0,0,0);
if (IsSelected())
{
BOOL first = TRUE;
selectIterator it = GetSelectBegin();
while ( it != GetSelectEnd() )
{
CDrawingObject *pointer=*it;
if (first)
{
rect.top = pointer->m_point_a.y;
rect.bottom = pointer->m_point_a.y;
rect.left = pointer->m_point_a.x;
rect.right = pointer->m_point_a.x;
first = FALSE;
}
rect.top = min(rect.top,min(pointer->m_point_a.y,pointer->m_point_b.y));
rect.bottom = max(rect.bottom,max(pointer->m_point_a.y,pointer->m_point_b.y));
rect.left = min(rect.left,min(pointer->m_point_a.x,pointer->m_point_b.x));
rect.right = max(rect.right,max(pointer->m_point_a.x,pointer->m_point_b.x));
++ it;
}
}
else
{
rect = CDRect( 0,0, GetDetails().m_szPage.cx, GetDetails().m_szPage.cy );
}
rect.InflateRect( 0,0, 10,10 );
// Transform the origin so the design lies at 0,0
Transform newTransform;
int iWidthMM = ref_dc.GetDeviceCaps(HORZSIZE);
int iHeightMM = ref_dc.GetDeviceCaps(VERTSIZE);
int iWidthPels = ref_dc.GetDeviceCaps(HORZRES);
int iHeightPels = ref_dc.GetDeviceCaps(VERTRES);
// Convert client coordinates to .01-mm units.
// Use iWidthMM, iWidthPels, iHeightMM, and
// iHeightPels to determine the number of
// .01-millimeter units per pixel in the x-
// and y-directions.
rect.left = (rect.left * iWidthMM * 100)/iWidthPels;
rect.top = (rect.top * iHeightMM * 100)/iHeightPels;
rect.right = (rect.right * iWidthMM * 100)/iWidthPels;
rect.bottom = (rect.bottom * iHeightMM * 100)/iHeightPels;
// Create the metafile device context.
CRect ir( static_cast<int>(rect.left),static_cast<int>(rect.top),static_cast<int>(rect.right),static_cast<int>(rect.bottom) );
HDC hdcMeta = CreateEnhMetaFile(ref_dc.m_hDC,file_name, &ir, GetDetails().GetTitle() );
if (!hdcMeta)
{
AfxMessageBox(_T("Cannot create enhanced metafile for the copy"));
return NULL;
}
CDC theMetaDC;
theMetaDC.Attach( hdcMeta );
// Now render into this dc
newTransform.SetZoomFactor( 1.0 );
// Create the DC and render...
{
CContext dc(&theMetaDC,newTransform);
dc.SetBlack( bw );
if (IsSelected())
{
// Draw just the selected part
CJunctionUtils j(this);
selectIterator it = GetSelectBegin();
while ( it != GetSelectEnd() )
{
j.AddObjectToTodo( *it );
(*it)->Paint(dc,draw_normal);
++ it;
}
j.PaintJunctions( dc, draw_normal );
}
else
{
// Draw the whole design into the metafile
for( drawingIterator i = GetDrawingBegin(); i != GetDrawingEnd(); i++ )
{
(*i)->Paint(dc,draw_normal);
}
// Show the design details
Display( dc );
}
}
theMetaDC.Detach();
return CloseEnhMetaFile( hdcMeta );
}
//
// Draw a series of "tabs" into a meta-file,
// which we will use to custom-draw one of the inserted
// scrollbar buttons
//
void InitMetaFile(void)
{
HDC hdcEMF;
RECT rect;
int totalwidth = 120;
int width = 110, height = GetSystemMetrics(SM_CYHSCROLL);
LOGFONT lf;
POINT pts[4];
int tabwidth = 40, tabxslope = 5;
pts[0].x = 0;
pts[0].y = 0;
pts[1].x = tabxslope;
pts[1].y = height - 1;
pts[2].x = tabwidth - tabxslope;
pts[2].y = height - 1;
pts[3].x = tabwidth;
pts[3].y = 0;
hpen = CreatePen(PS_SOLID,0,GetSysColor(COLOR_3DSHADOW));
whitepen = CreatePen(PS_INSIDEFRAME,0,RGB(0xff,0xff,0xff));
SetRect(&rect, 0, 0, totalwidth, height+1);
hdcEMF = CreateEnhMetaFile(NULL, NULL, NULL, NULL);
ZeroMemory(&lf, sizeof(lf));
lf.lfHeight = -MulDiv(7, GetDeviceCaps(hdcEMF, LOGPIXELSY), 72);
lf.lfPitchAndFamily = DEFAULT_PITCH;
lf.lfCharSet = ANSI_CHARSET;
lstrcpy(lf.lfFaceName, "Arial");//Small fonts");
hfont = CreateFontIndirect(&lf);
pts[0].x = 0;
pts[0].y = 0;
pts[1].x = tabxslope;
pts[1].y = height - 1;
pts[2].x = tabwidth - tabxslope;
pts[2].y = height - 1;
pts[3].x = tabwidth;
pts[3].y = 0;
FillRect (hdcEMF, &rect, GetSysColorBrush(COLOR_3DFACE));//GetStockObject(WHITE_BRUSH);
//fit as many lines in as space permits
SelectObject(hdcEMF, GetSysColorBrush(COLOR_3DFACE));
DrawTab(hdcEMF, width-tabwidth, tabwidth, height - 1, tabxslope, FALSE);
DrawTab(hdcEMF, width-tabwidth-tabwidth+tabxslope, tabwidth, height - 1, tabxslope, FALSE);
DrawTab(hdcEMF, 0, tabwidth, height - 1, tabxslope, TRUE);
SelectObject(hdcEMF, hpen);
MoveToEx(hdcEMF, 110, 0, 0);
LineTo(hdcEMF, totalwidth, 0);
SelectObject(hdcEMF, hfont);
SetBkMode(hdcEMF, TRANSPARENT);
TextOut(hdcEMF, 10,1, "Build", 5);
TextOut(hdcEMF, 42,1, "Debug", 5);
TextOut(hdcEMF, 78,1, "Result", 6);
SelectObject(hdcEMF, oldpen);
DeleteObject(hpen);
DeleteObject(whitepen);
hemf = CloseEnhMetaFile(hdcEMF);
}
//*********************************
// 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();
}
static bool MCTextLayoutStyleItem(MCTextLayoutState& self, SCRIPT_ANALYSIS p_analysis, const unichar_t *p_chars, uint32_t p_char_count, MCTextLayoutFont *p_primary_font)
{
bool t_success;
t_success = true;
// Create a metafile dc into which we render the text
HDC t_metafile_dc;
t_metafile_dc = nil;
if (t_success)
{
t_metafile_dc = CreateEnhMetaFile(nil, nil, nil, nil);
if (t_metafile_dc == nil)
t_success = false;
}
// Choose the primary font
if (t_success)
SelectObject(t_metafile_dc, p_primary_font -> handle);
// Now use ScriptStringAnalyse to output the text into the metafile.
SCRIPT_STRING_ANALYSIS t_ssa;
t_ssa = nil;
if (t_success)
{
SCRIPT_STATE t_script_state;
SCRIPT_CONTROL t_script_control;
MCMemoryClear(&t_script_state, sizeof(SCRIPT_STATE));
MCMemoryClear(&t_script_control, sizeof(SCRIPT_CONTROL));
if (ScriptStringAnalyse(t_metafile_dc, p_chars, p_char_count, 0, -1, SSA_METAFILE | SSA_FALLBACK | SSA_GLYPHS | SSA_LINK, 0, &t_script_control, &t_script_state, nil, nil, nil, &t_ssa) != S_OK)
t_success = false;
}
// Render the analysed text into the metafile.
if (t_success)
if (ScriptStringOut(t_ssa, 0, 0, 0, nil, 0, 0, FALSE) != S_OK)
t_success = false;
// Fetch the metafile (we are done with the DC now)
HENHMETAFILE t_metafile;
t_metafile = nil;
if (t_metafile_dc != nil)
{
t_metafile = CloseEnhMetaFile(t_metafile_dc);
if (t_metafile == nil)
t_success = false;
}
// Now process the metafile to get the subranges of text styled to the
// appropriate fallback font.
if (t_success)
{
MCTextLayoutStyleItemContext t_context;
t_context . state = &self;
t_context . chars = p_chars;
t_context . char_count = p_char_count;
t_context . analysis = p_analysis;
t_context . primary_font = p_primary_font;
t_context . current_font = p_primary_font;
t_context . pending_x = 0;
t_context . pending_font = nil;
t_context . pending_chars = nil;
t_context . pending_char_count = 0;
if (!EnumEnhMetaFile(nil, t_metafile, MCTextLayoutStyleItemCallback, &t_context, nil))
t_success = false;
}
// Free the metafile
if (t_metafile != nil)
DeleteEnhMetaFile(t_metafile);
return t_success;
}
int GPcreatewidget (
Gwidget_t *parent, Gwidget_t *widget, int attrn, Gwattr_t *attrp
) {
PIXpoint_t po;
PIXsize_t ps;
PRINTDLG pd;
DOCINFO di;
DEVMODE *dmp;
/* the 2 here is to provide enough space for palPalEntry[0] and [1] */
LOGPALETTE pal[2];
HBRUSH brush;
HPEN pen;
HBITMAP bmap;
char *s, *s1;
int color, lflag, ai, dpix, dpiy, i;
s = Gpscanvasname;
lflag = FALSE;
po.x = po.y = 0;
ps.x = ps.y = MINPWSIZE;
for (ai = 0; ai < attrn; ai++) {
switch (attrp[ai].id) {
case G_ATTRORIGIN:
GETORIGIN (attrp[ai].u.p, po);
break;
case G_ATTRSIZE:
GETSIZE (attrp[ai].u.s, ps, MINPWSIZE);
break;
case G_ATTRNAME:
if (attrp[ai].u.t && attrp[ai].u.t[0])
s = attrp[ai].u.t;
break;
case G_ATTRMODE:
if (strcmp ("landscape", attrp[ai].u.t) == 0)
lflag = TRUE;
else if (strcmp ("portrait", attrp[ai].u.t) == 0)
lflag = FALSE;
else {
Gerr (POS, G_ERRBADATTRVALUE, attrp[ai].u.t);
return -1;
}
break;
case G_ATTRCOLOR:
/* will do it after the widget is created */
break;
case G_ATTRVIEWPORT:
/* will do it after the widget is created */
break;
case G_ATTRWINDOW:
/* will do it after the widget is created */
break;
case G_ATTRWINDOWID:
Gerr (POS, G_ERRCANNOTSETATTR1, "windowid");
return -1;
case G_ATTRUSERDATA:
widget->udata = attrp[ai].u.u;
break;
default:
Gerr (POS, G_ERRBADATTRID, attrp[ai].id);
return -1;
}
}
s1 = s + strlen (s) - 3;
if (s1 > s && strncmp (s1, "emf", 3) == 0) {
WPU->mode = 1;
ps.x *= 8.235, ps.y *= 8.235;
if (!(GC = CreateEnhMetaFile (NULL, s, NULL, "LEFTY\\0GRAPH\\0\\0"))) {
Gerr (POS, G_ERRCANNOTCREATEWIDGET);
return -1;
}
} else { /* open the printer device */
WPU->mode = 2;
di.cbSize = sizeof (DOCINFO);
di.lpszDocName = NULL;
di.lpszOutput = NULL;
di.lpszDatatype = "LEFTY";
di.fwType = 0;
pd.lStructSize = sizeof (pd);
pd.hwndOwner = NULL;
pd.hDevMode = NULL;
pd.hDevNames = NULL;
pd.hDC = NULL;
pd.Flags = PD_RETURNDC | PD_RETURNDEFAULT;
pd.nFromPage = 0;
pd.nToPage = 0;
pd.nMinPage = 0;
pd.nMaxPage = 0;
pd.nCopies = 1;
pd.hInstance = NULL;
pd.lCustData = NULL;
pd.lpfnPrintHook = NULL;
pd.lpfnSetupHook = NULL;
pd.lpPrintTemplateName = NULL;
pd.lpSetupTemplateName = NULL;
pd.hPrintTemplate = NULL;
pd.hSetupTemplate = NULL;
if (!PrintDlg (&pd)) {
Gerr (POS, G_ERRCANNOTCREATEWIDGET);
return -1;
}
if (lflag && pd.hDevMode) {
dmp = (DEVMODE *) GlobalLock (pd.hDevMode);
dmp->dmOrientation = DMORIENT_LANDSCAPE;
GlobalUnlock (pd.hDevMode);
pd.Flags = PD_RETURNDC;
if (!PrintDlg (&pd)) {
Gerr (POS, G_ERRCANNOTCREATEWIDGET);
return -1;
}
}
GC = pd.hDC;
dpix = GetDeviceCaps (GC, LOGPIXELSX);
if (dpix != 300)
ps.x = ps.x * (double) dpix / 300.0;
dpiy = GetDeviceCaps (GC, LOGPIXELSY);
if (dpiy != 300)
ps.y = ps.y * (double) dpiy / 300.0;
if (StartDoc (GC, &di) <= 0 || StartPage (GC) <= 0) {
Gerr (POS, G_ERRCANNOTCREATEWIDGET);
return -1;
}
}
WPU->wrect.o.x = 0.0, WPU->wrect.o.y = 0.0;
WPU->wrect.c.x = 1.0, WPU->wrect.c.y = 1.0;
WPU->vsize.x = ps.x, WPU->vsize.y = ps.y;
WPU->ncolor = 2;
pal[0].palVersion = 0x300; /* HA HA HA */
pal[0].palNumEntries = 2;
pal[0].palPalEntry[0].peRed = 255;
pal[0].palPalEntry[0].peGreen = 255;
pal[0].palPalEntry[0].peBlue = 255;
pal[0].palPalEntry[0].peFlags = 0;
pal[0].palPalEntry[1].peRed = 0;
pal[0].palPalEntry[1].peGreen = 0;
pal[0].palPalEntry[1].peBlue = 0;
pal[0].palPalEntry[1].peFlags = 0;
WPU->cmap = CreatePalette (&pal[0]);
WPU->colors[0].color = pal[0].palPalEntry[0];
for (i = 1; i < G_MAXCOLORS; i++)
WPU->colors[i].color = pal[0].palPalEntry[1];
SelectPalette (GC, WPU->cmap, FALSE);
RealizePalette (GC);
WPU->colors[0].inuse = TRUE;
WPU->colors[1].inuse = TRUE;
for (i = 2; i < G_MAXCOLORS; i++)
WPU->colors[i].inuse = FALSE;
WPU->gattr.color = 1;
brush = CreateSolidBrush (PALETTEINDEX (1));
SelectObject (GC, brush);
pen = CreatePen (PS_SOLID, 1, PALETTEINDEX (1));
SelectObject (GC, pen);
SetTextColor (GC, PALETTEINDEX (1));
SetBkMode (GC, TRANSPARENT);
WPU->gattr.width = 0;
WPU->gattr.mode = G_SRC;
WPU->gattr.fill = 0;
WPU->gattr.style = 0;
WPU->defgattr = WPU->gattr;
WPU->font = NULL;
if (Gdepth == 1) {
for (i = 0; i < 17; i++) {
if (!(bmap = CreateBitmap (4, 4, 1, 1, &grays[i][0])))
continue;
WPU->grays[i] = CreatePatternBrush (bmap);
}
}
for (ai = 0; ai < attrn; ai++) {
switch (attrp[ai].id) {
case G_ATTRCOLOR:
color = attrp[ai].u.c.index;
if (color < 0 || color > G_MAXCOLORS) {
Gerr (POS, G_ERRBADCOLORINDEX, color);
return -1;
}
WPU->colors[color].color.peRed = attrp[ai].u.c.r;
WPU->colors[color].color.peGreen = attrp[ai].u.c.g;
WPU->colors[color].color.peBlue = attrp[ai].u.c.b;
WPU->colors[color].color.peFlags = 0;
if (color >= WPU->ncolor)
ResizePalette (WPU->cmap, color + 1), WPU->ncolor = color + 1;
SetPaletteEntries (
WPU->cmap, (int) color, 1, &WPU->colors[color].color
);
RealizePalette (GC);
WPU->colors[color].inuse = TRUE;
if (color == WPU->gattr.color)
WPU->gattr.color = -1;
break;
case G_ATTRVIEWPORT:
if (attrp[ai].u.s.x == 0)
attrp[ai].u.s.x = 1;
if (attrp[ai].u.s.y == 0)
attrp[ai].u.s.y = 1;
WPU->vsize.x = attrp[ai].u.s.x + 0.5;
WPU->vsize.y = attrp[ai].u.s.y + 0.5;
SetWindowPos (
widget->w, (HWND) NULL, 0, 0, WPU->vsize.x,
WPU->vsize.y, SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE
);
break;
case G_ATTRWINDOW:
if (attrp[ai].u.r.o.x == attrp[ai].u.r.c.x)
attrp[ai].u.r.c.x = attrp[ai].u.r.o.x + 1;
if (attrp[ai].u.r.o.y == attrp[ai].u.r.c.y)
attrp[ai].u.r.c.y = attrp[ai].u.r.o.y + 1;
WPU->wrect = attrp[ai].u.r;
break;
}
}
return 0;
}
LRESULT C_BranchProperties::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
C_STLException::install();
try {
base::OnInitDialog(uMsg, wParam, lParam, bHandled);
#define LENGTH 48
for (int n = 0; n < 3; n++) {
C_NullDC nulldc;
if (NULL == s_hJoinSel[n]->GetHandle()) {
HENHMETAFILE meta = NULL;
HDC metadc = CreateEnhMetaFile(nulldc.GetHandle(), NULL, NULL, NULL);
if (metadc) {
C_DC dc(metadc);
DrawJoinStyle(dc, n, 12, 0x800080);
}
meta = CloseEnhMetaFile(metadc);
s_hJoinSel[n]->SetHandle(meta);
}
if (NULL == s_hJoinUnsel[n]->GetHandle()) {
HENHMETAFILE meta = NULL;
HDC metadc = CreateEnhMetaFile(nulldc.GetHandle(), NULL, NULL, NULL);
if (metadc) {
C_DC dc(metadc);
DrawJoinStyle(dc, n, 12, 0xFFFF);
}
meta = CloseEnhMetaFile(metadc);
s_hJoinUnsel[n]->SetHandle(meta);
}
if (NULL == s_hJoinGrey[n]->GetHandle()) {
HENHMETAFILE meta = NULL;
HDC metadc = CreateEnhMetaFile(nulldc.GetHandle(), NULL, NULL, NULL);
if (metadc) {
C_DC dc(metadc);
DrawJoinStyle(dc, n, 12, 0xF0F0F0);
}
meta = CloseEnhMetaFile(metadc);
s_hJoinGrey[n]->SetHandle(meta);
}
}
for (n = 0; n < 3; n++) {
C_NullDC nulldc;
if (NULL == s_hEndSel[n]->GetHandle()) {
HENHMETAFILE meta = NULL;
HDC metadc = CreateEnhMetaFile(nulldc.GetHandle(), NULL, NULL, NULL);
if (metadc) {
C_DC dc(metadc);
DrawEndStyle(dc, n, 8, 0x800080);
}
meta = CloseEnhMetaFile(metadc);
s_hEndSel[n]->SetHandle(meta);
}
if (NULL == s_hEndUnsel[n]->GetHandle()) {
HENHMETAFILE meta = NULL;
HDC metadc = CreateEnhMetaFile(nulldc.GetHandle(), NULL, NULL, NULL);
if (metadc) {
C_DC dc(metadc);
DrawEndStyle(dc, n, 8, 0xFFFF);
}
meta = CloseEnhMetaFile(metadc);
s_hEndUnsel[n]->SetHandle(meta);
}
if (NULL == s_hEndGrey[n]->GetHandle()) {
HENHMETAFILE meta = NULL;
HDC metadc = CreateEnhMetaFile(nulldc.GetHandle(), NULL, NULL, NULL);
if (metadc) {
C_DC dc(metadc);
DrawEndStyle(dc, n, 8, 0xF0F0F0);
}
meta = CloseEnhMetaFile(metadc);
s_hEndGrey[n]->SetHandle(meta);
}
}
RECT r = { 0, 0, 0, 0 };
m_spinWidth->Create(m_hWnd, r);
DWORD dwExStyle = 0;
#ifdef SMARTACE
m_spinRecurveHeight->Create(m_hWnd, r);
m_spinRecurveRate->Create(m_hWnd, r);
m_penEnd.Create(m_hWnd, r);
m_penEnd.ShowWindow(TRUE);
m_penEnd.SetDialog(this);
m_penJoin.Create(m_hWnd, r);
m_penJoin.ShowWindow(TRUE);
m_penJoin.SetDialog(this);
m_penRecurve.Create(m_hWnd, r);
dwExStyle = m_penRecurve.GetWindowLong(GWL_STYLE);
dwExStyle = m_spinRecurveRate->GetWindowLong(GWL_STYLE);
m_penRecurve.SetWindowLong(GWL_STYLE, dwExStyle);
dwExStyle = m_spinRecurveRate->GetWindowLong(GWL_EXSTYLE);
m_penRecurve.SetWindowLong(GWL_EXSTYLE, dwExStyle);
m_penRecurve.SetParent(m_hWnd);
m_penRecurve.ShowWindow(TRUE);
m_penRecurve.SetButton(this);
InitEnds();
InitJoin();
#endif
m_penRoute.Create(m_hWnd, r);
dwExStyle = m_penRoute.GetWindowLong(GWL_STYLE);
dwExStyle = m_spinWidth->GetWindowLong(GWL_STYLE);
m_penRoute.SetWindowLong(GWL_STYLE, dwExStyle);
dwExStyle = m_spinWidth->GetWindowLong(GWL_EXSTYLE);
m_penRoute.SetWindowLong(GWL_EXSTYLE, dwExStyle);
m_penRoute.SetParent(m_hWnd);
m_penRoute.ShowWindow(TRUE);
m_penRoute.SetButton(this);
HWND wnd = GetDlgItem(IDC_BTN_COLOR);
m_btnFill.SubclassWindow(wnd);
TCHAR w[256];
TCHAR l[256];
::_stprintf(w, _T("Branch"));
::_stprintf(l, _T("Fill"));
m_btnFill.SendMessage(TTM_TOOLTIP_LOADTEXT, reinterpret_cast<WPARAM>(w), reinterpret_cast<WPARAM>(l));
if (m_spinWidth.get()) {
::_stprintf(l, _T("Width"));
m_spinWidth->SendMessage(TTM_TOOLTIP_LOADTEXT, reinterpret_cast<WPARAM>(w), reinterpret_cast<WPARAM>(l));
}
m_penRoute.SetItemHeight(24);
#ifdef SMARTACE
InitRoute();
wnd = GetDlgItem(IDC_CHK_TAPER_RECURVE);
m_chkTaperRecurve.SubclassWindow(wnd);
if (m_spinRecurveHeight.get()) {
::_stprintf(l, _T("RecurveHeight"));
m_spinRecurveHeight->SendMessage(TTM_TOOLTIP_LOADTEXT, reinterpret_cast<WPARAM>(w), reinterpret_cast<WPARAM>(l));
m_spinRecurveHeight->SetMinValue(1);
m_spinRecurveHeight->SetMaxValue(256);
}
if (m_spinRecurveRate.get()) {
::_stprintf(l, _T("RecurveRate"));
m_spinRecurveRate->SendMessage(TTM_TOOLTIP_LOADTEXT, reinterpret_cast<WPARAM>(w), reinterpret_cast<WPARAM>(l));
m_spinRecurveRate->SetMinValue(1);
m_spinRecurveRate->SetMaxValue(512);
}
m_penRecurve.SetItemHeight(24);
InitRecurve();
#endif
}
catch (C_STLNonStackException const &exception) {
exception.Log(_T("Exception in C_BranchProperties::"));
}
return S_OK;
}
/*
* This is a hack used by Chrome and WebKit to expose the fallback font used
* by Uniscribe for some given text for use with custom shapers / font engines.
*/
static char *UniscribeFallback( const char *psz_family, uni_char_t codepoint )
{
HDC hdc = NULL;
HDC meta_file_dc = NULL;
HENHMETAFILE meta_file = NULL;
LPTSTR psz_fbuffer = NULL;
char *psz_result = NULL;
hdc = CreateCompatibleDC( NULL );
if( !hdc )
return NULL;
meta_file_dc = CreateEnhMetaFile( hdc, NULL, NULL, NULL );
if( !meta_file_dc )
goto error;
LOGFONT lf;
memset( &lf, 0, sizeof( lf ) );
psz_fbuffer = ToT( psz_family );
if( !psz_fbuffer )
goto error;
_tcsncpy( ( LPTSTR ) &lf.lfFaceName, psz_fbuffer, LF_FACESIZE );
free( psz_fbuffer );
lf.lfCharSet = DEFAULT_CHARSET;
HFONT hFont = CreateFontIndirect( &lf );
if( !hFont )
goto error;
HFONT hOriginalFont = SelectObject( meta_file_dc, hFont );
TCHAR text = codepoint;
SCRIPT_STRING_ANALYSIS script_analysis;
HRESULT hresult = ScriptStringAnalyse( meta_file_dc, &text, 1, 0, -1,
SSA_METAFILE | SSA_FALLBACK | SSA_GLYPHS | SSA_LINK,
0, NULL, NULL, NULL, NULL, NULL, &script_analysis );
if( SUCCEEDED( hresult ) )
{
hresult = ScriptStringOut( script_analysis, 0, 0, 0, NULL, 0, 0, FALSE );
ScriptStringFree( &script_analysis );
}
SelectObject( meta_file_dc, hOriginalFont );
DeleteObject( hFont );
meta_file = CloseEnhMetaFile( meta_file_dc );
if( SUCCEEDED( hresult ) )
{
LOGFONT log_font;
log_font.lfFaceName[ 0 ] = 0;
EnumEnhMetaFile( 0, meta_file, MetaFileEnumProc, &log_font, NULL );
if( log_font.lfFaceName[ 0 ] )
psz_result = FromT( log_font.lfFaceName );
}
DeleteEnhMetaFile(meta_file);
DeleteDC( hdc );
return psz_result;
error:
if( meta_file_dc ) DeleteEnhMetaFile( CloseEnhMetaFile( meta_file_dc ) );
if( hdc ) DeleteDC( hdc );
return NULL;
}
void C_BranchProperties::InitRoute()
{
static T_SafeArray<C_EnhMetafile> hRoute;
static stringarray captions;
static stringarray values;
#define ROUTES 9
if (0 == hRoute.GetLength()) {
hRoute.ReDim(ROUTES);
static String c[ROUTES] = {
_T("None"),
_T("Taper"),
_T("Solid Arrow"),
_T("Arrow"),
_T("Solid Arrow"),
_T("Arrow"),
_T("Solid Tapered Arrow"),
_T("Step Down"),
_T("Step Side")
};
hRoute.ReDim(ROUTES);
captions.ReDim(ROUTES);
values.ReDim(ROUTES);
C_BufferPtr buffer;
buffer.Create();
if (buffer) {
C_DrawTargetPtr target(buffer);
target->put_XOffset(0);
target->put_YOffset(0);
C_BranchPtr branch;
branch.Create();
C_PositionPtr position(branch);
C_ItemPtr item(branch);
if (position && item) {
I_CascadingStyle *_style = NULL;
item->get_StyleSheet(&_style);
C_StylePtr style(_style);
if (_style) {
_style->Release();
}
if (style) {
C_Branch *p = NULL;
item->get_Handle(reinterpret_cast<long*>(&p));
if (p) {
C_Area area(4);
area[0]->x = 0;
area[0]->y = 0;
area[1]->x = 75;
area[1]->y = 30;
area[2]->x = 75;
area[2]->y = 0;
area[3]->x = 150;
area[3]->y = 30;
position->put_Points(&area.GetData());
C_ArchivePtr arc;
arc.Create();
if (arc) {
for (int n = 0; n < ROUTES; n++) {
*captions[n] = c[n];
C_NullDC nulldc;
if (NULL == hRoute[n]->GetHandle()) {
HDC metadc = CreateEnhMetaFile(nulldc.GetHandle(), NULL, NULL, NULL);
if (metadc) {
buffer->put_DeviceContext(reinterpret_cast<long>(metadc));
TCHAR t[1024];
if (shapes[n].GetLength() > 0) {
::_stprintf(t, _T("route:%s;recurve:CustomBranches.clsTaper;rc-height:8;pen-style:0;width:1"), shapes[n].toLPCTSTR());
}
*values[n] = t;
BSTR definition = values[n]->toBSTR();
style->put_Definition(definition);
String::FreeBSTR(&definition);
item->putref_StyleSheet(style);
p->_Draw(target);
hRoute[n]->SetHandle(CloseEnhMetaFile(metadc));
}
}
}
}
}
}
}
}
}
m_penRoute.Init(captions, values, &hRoute);
}
LRESULT CMainDlg::OnSavePic(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
CSaveArgs dlg;
dlg.width = picWidth;
dlg.height = picHeight;
dlg.inchOrMM = picInchOrMM;
strcpy(dlg.fileName, picFileName);
if (dlg.DoModal(m_hWnd) == IDOK)
{
picWidth = dlg.width;
picHeight = dlg.height;
picInchOrMM = dlg.inchOrMM;
strcpy(picFileName, dlg.fileName);
int dx, dy;
int iWidthMM, iHeightMM;
int iWidthPels, iHeightPels;
HDC hdcRef = NULL;
int isIC = FALSE;
/*
* Not really necessary, but useful...
* This will calculate resolution for the default printer.
* That generates a larger image generally and maybe will
* look better when printed from a document file.
*/
PRINTDLG pd;
memset(&pd, 0, sizeof(pd));
pd.lStructSize = sizeof(PRINTDLG);
pd.Flags = PD_RETURNDEFAULT;
pd.hwndOwner = m_hWnd;
if (PrintDlg(&pd))
{
DEVNAMES *dn = (DEVNAMES*)GlobalLock(pd.hDevNames);
char *driver = ((char *)dn) + dn->wDriverOffset;
char *device = ((char *)dn) + dn->wDeviceOffset;
char *port = ((char *)dn) + dn->wOutputOffset;
hdcRef = CreateIC(driver, device, port, NULL);
if (hdcRef)
isIC = TRUE;
GlobalUnlock(pd.hDevNames);
GlobalFree(pd.hDevNames);
GlobalFree(pd.hDevMode);
}
if (!hdcRef)
hdcRef = GetDC();
iWidthMM = GetDeviceCaps(hdcRef, HORZSIZE);
iHeightMM = GetDeviceCaps(hdcRef, VERTSIZE);
iWidthPels = GetDeviceCaps(hdcRef, HORZRES);
iHeightPels = GetDeviceCaps(hdcRef, VERTRES);
dx = GetDeviceCaps(hdcRef, LOGPIXELSX);
dy = GetDeviceCaps(hdcRef, LOGPIXELSY);
// Calculate bounds at output resolution
RECT rcpix;
rcpix.left = 0;
rcpix.top = 0;
if (picInchOrMM)
{
rcpix.right = (int) ((double)dx * (picWidth / 25.4));
rcpix.bottom = (int) ((double) dy * (picHeight / 25.4));
}
else
{
rcpix.right = (int) ((double)dx * picWidth);
rcpix.bottom = (int) ((double) dy * picHeight);
}
// produce a bounding box in HIMETRIC for the metafile
RECT rc;
rc.left = (rcpix.left * iWidthMM * 100)/iWidthPels;
rc.top = (rcpix.top * iHeightMM * 100)/iHeightPels;
rc.right = (rcpix.right * iWidthMM * 100)/iWidthPels;
rc.bottom = (rcpix.bottom * iHeightMM * 100)/iHeightPels;
HDC drawdc = CreateEnhMetaFile(hdcRef, picFileName, &rc, "Waveform Explorer, (c) Daniel R. Mitchell\0Waveform Explorer\0");
//HFONT hf = CreateFont((8*dy)/72, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
// OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, PROOF_QUALITY, FF_DONTCARE|DEFAULT_PITCH, "Tahoma");
//SelectObject(drawdc, hf);
wndPlot.Plot(drawdc, rcpix);
HENHMETAFILE mf = CloseEnhMetaFile(drawdc);
DeleteEnhMetaFile(mf);
// DeleteObject(hf);
if (isIC)
DeleteDC(hdcRef);
else
ReleaseDC(hdcRef);
}
return 0;
}
