Using Metafiles

On Tue, 12 Aug 2008 08:50:36 -0700, AliR (VC++ MVP) <Al**@online.no spam>
wrote:

Hi everyone,

I need to draw some rft to the screen. And I found some code out there
that
uses a Richedit control and sends it an EM_FORMATRANGE to do exactly
that.

Now I need to add scaling to this code. What I'm trying to do is to have
the richedit control draw to a metafile and then I can set the
ScaleTrasform
of the Graphics object and draw the metafile.

But everytime I call Metafile.GetHen hmetafile() it throws a "Parameter is
not valid" execption.

Why not use Graphics.FromIm age() to get a Graphics instance from the
Metafile, and then Graphics.GetHdc () to get the HDC to assign to
fmtRange.chrg.h dc?

By the way, the class "SafeNativeMeth ods" looks very much like code from
the .NET Framework itself. I don't know where you got that, but you may
want to be very careful to not be using code copied from .NET.
Microsoft's published the code, but I'm pretty sure the license is for
debugging purposes only, not for reuse within your own code.

Pete

"Peter Duniho" <Np*********@nn owslpianmk.comw rote in message
news:op******** *******@petes-computer.local. ..

Why not use Graphics.FromIm age() to get a Graphics instance from the
Metafile, and then Graphics.GetHdc () to get the HDC to assign to
fmtRange.chrg.h dc?

By the way, the class "SafeNativeMeth ods" looks very much like code from
the .NET Framework itself. I don't know where you got that, but you may
want to be very careful to not be using code copied from .NET.
Microsoft's published the code, but I'm pretty sure the license is for
debugging purposes only, not for reuse within your own code.

Pete

I got the code from here http://www.andrewvos.com/?p=392
which is pretty much the same code as
http://support.microsoft.com/kb/812425/en-us
Which .Net code are you refering to? Am I reinventing the wheele? Is there
built-in code that does this already?

I don't really see how GraphicFromImag e is going to help. Under native c++
code, I have to draw to a meta file and then I can use world transformations
to scale the text in a way that would not case detering and things like
that.

I tried your suggestion but it didn't draw anything.

public void Draw(Graphics graphics, RectangleF layoutArea, float
xFactor)
{
//Calculate the area to render.
SafeNativeMetho ds.RECT rectLayoutArea;
rectLayoutArea. Top = (int)(layoutAre a.Top * anInch);
rectLayoutArea. Bottom = (int)(layoutAre a.Bottom * anInch);
rectLayoutArea. Left = (int)(layoutAre a.Left * anInch);
rectLayoutArea. Right = (int)(layoutAre a.Right * anInch);

IntPtr hdc = graphics.GetHdc ();

Metafile metafile = new Metafile(hdc, layoutArea);

Graphics metagraphic = Graphics.FromIm age(metafile);
IntPtr hDCEMF = metagraphic.Get Hdc();

SafeNativeMetho ds.FORMATRANGE fmtRange;
fmtRange.chrg.c pMax = -1; //Indicate character from
to character to
fmtRange.chrg.c pMin = 0;
fmtRange.hdc = hDCEMF; //Use the same DC for
measuring and rendering
fmtRange.hdcTar get = hDCEMF; //Point at printer hDC
fmtRange.rc = rectLayoutArea; //Indicate the area on page
to print
fmtRange.rcPage = rectLayoutArea; //Indicate size of page

IntPtr wParam = IntPtr.Zero;
wParam = new IntPtr(1);

//Get the pointer to the FORMATRANGE structure in memory
IntPtr lParam = IntPtr.Zero;
lParam = Marshal.AllocCo TaskMem(Marshal .SizeOf(fmtRang e));
Marshal.Structu reToPtr(fmtRang e, lParam, false);

SafeNativeMetho ds.SendMessage( this.Handle,
SafeNativeMetho ds.EM_FORMATRAN GE, wParam, lParam);

//Free the block of memory allocated
Marshal.FreeCoT askMem(lParam);

metagraphic.Rel easeHdc(hDCEMF) ;
//Release the device context handle obtained by a previous call
graphics.Releas eHdc(hdc);

graphics.ScaleT ransform(xFacto r, xFactor);

graphics.DrawIm age(metafile, layoutArea.Loca tion);
}

"AliR (VC++ MVP)" <Al**@online.no spamwrote in message
news:iC******** **********@nlpi 067.nbdc.sbc.co m...

"Peter Duniho" <Np*********@nn owslpianmk.comw rote in message
news:op******** *******@petes-computer.local. ..

>Why not use Graphics.FromIm age() to get a Graphics instance from the
Metafile, and then Graphics.GetHdc () to get the HDC to assign to
fmtRange.chrg. hdc?

By the way, the class "SafeNativeMeth ods" looks very much like code from
the .NET Framework itself. I don't know where you got that, but you may
want to be very careful to not be using code copied from .NET.
Microsoft's published the code, but I'm pretty sure the license is for
debugging purposes only, not for reuse within your own code.

Pete

I got the code from here http://www.andrewvos.com/?p=392
which is pretty much the same code as
http://support.microsoft.com/kb/812425/en-us
Which .Net code are you refering to? Am I reinventing the wheele? Is
there built-in code that does this already?

I don't really see how GraphicFromImag e is going to help. Under native
c++ code, I have to draw to a meta file and then I can use world
transformations to scale the text in a way that would not case detering
and things like that.

I tried your suggestion but it didn't draw anything.

public void Draw(Graphics graphics, RectangleF layoutArea, float
xFactor)
{
//Calculate the area to render.
SafeNativeMetho ds.RECT rectLayoutArea;
rectLayoutArea. Top = (int)(layoutAre a.Top * anInch);
rectLayoutArea. Bottom = (int)(layoutAre a.Bottom * anInch);
rectLayoutArea. Left = (int)(layoutAre a.Left * anInch);
rectLayoutArea. Right = (int)(layoutAre a.Right * anInch);

IntPtr hdc = graphics.GetHdc ();

Metafile metafile = new Metafile(hdc, layoutArea);

Graphics metagraphic = Graphics.FromIm age(metafile);
IntPtr hDCEMF = metagraphic.Get Hdc();

SafeNativeMetho ds.FORMATRANGE fmtRange;
fmtRange.chrg.c pMax = -1; //Indicate character from
to character to
fmtRange.chrg.c pMin = 0;
fmtRange.hdc = hDCEMF; //Use the same DC for
measuring and rendering
fmtRange.hdcTar get = hDCEMF; //Point at printer hDC
fmtRange.rc = rectLayoutArea; //Indicate the area on
page to print
fmtRange.rcPage = rectLayoutArea; //Indicate size of page

IntPtr wParam = IntPtr.Zero;
wParam = new IntPtr(1);

//Get the pointer to the FORMATRANGE structure in memory
IntPtr lParam = IntPtr.Zero;
lParam = Marshal.AllocCo TaskMem(Marshal .SizeOf(fmtRang e));
Marshal.Structu reToPtr(fmtRang e, lParam, false);

SafeNativeMetho ds.SendMessage( this.Handle,
SafeNativeMetho ds.EM_FORMATRAN GE, wParam, lParam);

//Free the block of memory allocated
Marshal.FreeCoT askMem(lParam);

metagraphic.Rel easeHdc(hDCEMF) ;
//Release the device context handle obtained by a previous call
graphics.Releas eHdc(hdc);

graphics.ScaleT ransform(xFacto r, xFactor);

graphics.DrawIm age(metafile, layoutArea.Loca tion);
}

Here is the MFC version of this:
// setup rectangles for metafile fiddling
DC->DPtoHIMETRIC(& cTargetSize); // from MM_Text to MM_HIMETRIC
CRect cHiMetricRect(0 ,0,cTargetSize. cx,cTargetSize. cy);
CRect cTwipsRect(0,0, (TWIPS_INCH * cTargetSize.cx + HIMETRIC_INCH / 2) /
HIMETRIC_INCH,
(TWIPS_INCH * cTargetSize.cy + HIMETRIC_INCH / 2) / HIMETRIC_INCH);

// create the enhanced metafile
HDC hDCEMF = CreateEnhMetaFi le(DC->m_hDC,NULL,cHi MetricRect,NULL );

// setup the format struct and do the RTF range formatting call
FORMATRANGE stFR;
stFR.hdcTarget = stFR.hdc = hDCEMF; // render to the memory helper EMF
stFR.rcPage = stFR.rc = cTwipsRect; // using this rectangle (in twips)
stFR.chrg.cpMin = 0; // and render all of the text
stFR.chrg.cpMax = -1;
pCtrl->SendMessage(EM _FORMATRANGE,TR UE,(LPARAM) &stFR);
pCtrl->SendMessage(EM _FORMATRANGE,TR UE,NULL); // this call clears the cache

// drawing into the metafile is done, get ourselves an handle to it (used
for the replay)
HENHMETAFILE hEMF = CloseEnhMetaFil e(hDCEMF);

// calculate the automagic fudge factors by getting the device metrics
int nHorzSize = DC->GetDeviceCaps( HORZSIZE ); // width in millimeters
int nVertSize = DC->GetDeviceCaps( VERTSIZE ); // height in millimeters
int nHorzRes = DC->GetDeviceCaps( HORZRES ); // width in pixels
int nVertRes = DC->GetDeviceCaps( VERTRES ); // height in pixels
int nLogPixelsX = DC->GetDeviceCaps( LOGPIXELSX); // # of pixels per inch
horizontally
int nLogPixelsY = DC->GetDeviceCaps( LOGPIXELSY); // # of pixels per inch
vertically

float fHorzSizeInches = nHorzSize / 25.4f;
float fVertSizeInches = nVertSize / 25.4f;
float fHorzFudgeFacto r = (nHorzRes / fHorzSizeInches ) / nLogPixelsX; //
divide expected DPI with actual DPI
float fVertFudgeFacto r = (nVertRes / fVertSizeInches ) / nLogPixelsY; //

// do the world transforms, first apply the scale and fudge factors
XFORM stX;
ZeroMemory(&stX ,sizeof(stX));
stX.eM11 = fHorzFudgeFacto r * (m_XFactor);
stX.eM22 = fVertFudgeFacto r * (m_XFactor);
SetWorldTransfo rm(DC->m_hDC,&stX);

long Top = WinRect.top;
long Left = WinRect.left;
WinRect.OffsetR ect(-Left,-Top);
WinRect.OffsetR ect((int)(Left/fHorzFudgeFacto r),int(Top/fVertFudgeFacto r));

DC->PlayMetaFile(h EMF,&WinRect);

// that's it, kiss the metafile goodbye
DeleteEnhMetaFi le(hEMF);

On Tue, 12 Aug 2008 11:27:29 -0700, AliR (VC++ MVP) <Al**@online.no spam>
wrote:

I got the code from here http://www.andrewvos.com/?p=392
which is pretty much the same code as
http://support.microsoft.com/kb/812425/en-us
Which .Net code are you refering to? Am I reinventing the wheele? Is
there
built-in code that does this already?

That I know of, no. I was simply commenting on the class
"SafeNativeMeth ods", because that's the exact name used in the .NET
Framework's implementation. Could be that the original source lifted it
from the .NET source code, or just the name.

Personally, it doesn't concern me one way or the other. It's just that
someone using that code should be careful if they are at all concerned
about running afoul of Microsoft's legal department (which, while not as
rabid as those found in other corporations, do still need to justify their
existence).

I don't really see how GraphicFromImag e is going to help.

The Graphics instance you get from that wraps the Metafile itself, so any
DC you get from that Graphics instance is for the Metafile.

In other words, the HDC that you get from the Graphics instance returned
by that method returns exactly the thing you need to assign to the
FORMATRANGE.hdc field.

I don't know why the call to Metafile.GetHen hmetafile() doesn't work,
other than the fact that I personally have had trouble with the .NET
Metafile implementation in the past (in other words, things that you'd
think would work based on how the unmanaged version works, wind up not
working). But I do know that you can get an HDC that draws into the
Metafile by using Graphics.FromIm age() and the Graphics.GetHdc (). I'm
pretty sure I've done that before and had it work (for sure it works with
Bitmaps, and I'm pretty sure I've used it with Metafiles too).

Under native c++
code, I have to draw to a meta file and then I can use world
transformations
to scale the text in a way that would not case detering and things like
that.

I tried your suggestion but it didn't draw anything.

Well, it at least didn't cause an error, right?

I can't say exactly what's wrong with the code you're using. But I
suspect you're closer to a solution now than you were before. :)

You'll probably have to break the problem down into smaller parts and see
what's not working as expected. The code you're using is almost, but not
exactly, like the MSDN code, so one place to start would be to start with
_exactly_ the code in the MSDN sample and see if you can get that to work.

You should also check to see whether you're able to create a Metafile via
more conventional means that does what you want, to double-check that your
Metafile-specific code is valid.

And of course, I hope this is a silly question, but you are in fact
putting that code in a control that inherits RichTextBox, right?

Pete

I think I got it: (thank you Peter for your help)

public void Draw(Graphics graphics, RectangleF layoutArea, float
xFactor)
{
//Calculate the area to render.
SafeNativeMetho ds.RECT rectLayoutArea;
rectLayoutArea. Top = (int)(0 * anInch);
rectLayoutArea. Bottom = (int)(layoutAre a.Bottom * anInch);
rectLayoutArea. Left = (int)(0 * anInch);
rectLayoutArea. Right = (int)(layoutAre a.Right * anInch);
Bitmap Bmp = new Bitmap((int)lay outArea.Width,
(int)layoutArea .Height, PixelFormat.For mat32bppArgb);
Graphics g = Graphics.FromIm age(Bmp);
IntPtr hdc = g.GetHdc();

//create a metafile, convert the size to himetrics
Metafile metafile = new Metafile(hdc, new
RectangleF(0,0, layoutArea.Widt h*26,layoutArea .Height*26));

g.ReleaseHdc(hd c);
g.Dispose();

g = Graphics.FromIm age(metafile);
IntPtr hDCEMF = g.GetHdc();

SafeNativeMetho ds.FORMATRANGE fmtRange;
fmtRange.chrg.c pMax = -1; //Indicate character from
to character to
fmtRange.chrg.c pMin = 0;
fmtRange.hdc = hDCEMF; //Use the same DC for
measuring and rendering
fmtRange.hdcTar get = hDCEMF; //Point at printer hDC
fmtRange.rc = rectLayoutArea; //Indicate the area on page
to print
fmtRange.rcPage = rectLayoutArea; //Indicate size of page

IntPtr wParam = IntPtr.Zero;
wParam = new IntPtr(1);

//Get the pointer to the FORMATRANGE structure in memory
IntPtr lParam = IntPtr.Zero;
lParam = Marshal.AllocCo TaskMem(Marshal .SizeOf(fmtRang e));
Marshal.Structu reToPtr(fmtRang e, lParam, false);

SafeNativeMetho ds.SendMessage( this.Handle,
SafeNativeMetho ds.EM_FORMATRAN GE, wParam, lParam);

//Free the block of memory allocated
Marshal.FreeCoT askMem(lParam);

//Release the device context handle obtained by a previous call
g.ReleaseHdc(hD CEMF);
g.Dispose();

graphics.ScaleT ransform(xFacto r, xFactor);
graphics.DrawIm age(metafile, layoutArea.Loca tion);
}

AliR.