public static void Check_MetafileHeader_WmfPlaceable(MetafileHeader header)
{
Assert.AreEqual(MetafileType.WmfPlaceable, header.Type, "Type");
Assert.AreEqual(0x300, header.Version, "Version");
// filesize - 22, which happens to be the size (22) of a PLACEABLEMETAHEADER struct
Assert.AreEqual(3474, header.MetafileSize, "MetafileSize");
Assert.AreEqual(-30, header.Bounds.X, "Bounds.X");
Assert.AreEqual(-40, header.Bounds.Y, "Bounds.Y");
Assert.AreEqual(3096, header.Bounds.Width, "Bounds.Width");
Assert.AreEqual(4127, header.Bounds.Height, "Bounds.Height");
Assert.AreEqual(606, header.DpiX, "DpiX");
Assert.AreEqual(606, header.DpiY, "DpiY");
Assert.AreEqual(0, header.EmfPlusHeaderSize, "EmfPlusHeaderSize");
Assert.AreEqual(0, header.LogicalDpiX, "LogicalDpiX");
Assert.AreEqual(0, header.LogicalDpiY, "LogicalDpiY");
Assert.IsNotNull(header.WmfHeader, "WmfHeader");
Check_MetaHeader_WmfPlaceable(header.WmfHeader);
Assert.IsFalse(header.IsDisplay(), "IsDisplay");
Assert.IsFalse(header.IsEmf(), "IsEmf");
Assert.IsFalse(header.IsEmfOrEmfPlus(), "IsEmfOrEmfPlus");
Assert.IsFalse(header.IsEmfPlus(), "IsEmfPlus");
Assert.IsFalse(header.IsEmfPlusDual(), "IsEmfPlusDual");
Assert.IsFalse(header.IsEmfPlusOnly(), "IsEmfPlusOnly");
Assert.IsTrue(header.IsWmf(), "IsWmf");
Assert.IsTrue(header.IsWmfPlaceable(), "IsWmfPlaceable");
}
public void GetMetafileHeader_FromFile_Emf()
{
using (Metafile mf = new Metafile(Emf)) {
MetafileHeader header1 = mf.GetMetafileHeader();
Check_MetafileHeader_Emf(header1);
}
}
public void SaveImg(DataRecord datarecord)
{
var pageContentRecord = datarecord as PageContentRecord;
var devmodeRecord = datarecord as EMRI_DEVMODERecord;
if (pageContentRecord != null)
{
this._PageCount++;
if ((this._PageCount == this._iViewPage) && (this._bPageLoaded) != true)
{
var memoryStream = new MemoryStream(pageContentRecord.EmfMetaFile);
_metaFile = new Metafile(memoryStream);
float fRatio = (float)_metaFile.Width / (float)_metaFile.Height;
this._ImgW = (int)(fRatio * this._ImgH);
this._scale = this._ImgW / (float)_metaFile.Width;
this._img = _metaFile.GetThumbnailImage(this._ImgW, this._ImgH, null, IntPtr.Zero);
MetafileHeader metaHead = _metaFile.GetMetafileHeader();
_nPageW = metaHead.Bounds.Width;
_nPageH = metaHead.Bounds.Height;
_DpiX = metaHead.DpiX;
_DpiY = metaHead.DpiY;
this._bPageLoaded = true;
}
}
if (devmodeRecord != null)
{
//this.deviceMode = devmodeRecord.Devmode;
}
}
public void Static_GetMetafileHeader_Stream_Null()
{
Assert.Throws <NullReferenceException>(() =>
{
MetafileHeader header = Metafile.GetMetafileHeader((Stream)null);
});
}
public void Static_GetMetafileHeader_Filename_Null()
{
Assert.Throws <ArgumentNullException>(() =>
{
MetafileHeader header = Metafile.GetMetafileHeader((string)null);
});
}
public void Static_GetMetafileHeader_Filename()
{
string filename = WmfPlaceable;
MetafileHeader header = Metafile.GetMetafileHeader(filename);
Check_MetafileHeader_WmfPlaceable(header);
}
private void CheckEmptyHeader(Metafile mf, EmfType type)
{
MetafileHeader mh = mf.GetMetafileHeader();
Assert.Equal(0, mh.Bounds.X);
Assert.Equal(0, mh.Bounds.Y);
Assert.Equal(0, mh.Bounds.Width);
Assert.Equal(0, mh.Bounds.Height);
Assert.Equal(0, mh.MetafileSize);
switch (type)
{
case EmfType.EmfOnly:
Assert.Equal(MetafileType.Emf, mh.Type);
break;
case EmfType.EmfPlusDual:
Assert.Equal(MetafileType.EmfPlusDual, mh.Type);
break;
case EmfType.EmfPlusOnly:
Assert.Equal(MetafileType.EmfPlusOnly, mh.Type);
break;
default:
Assert.True(false, string.Format("Unknown EmfType '{0}'", type));
break;
}
}
private static void Check_MetafileHeader_WmfPlaceable(MetafileHeader header)
{
Assert.Equal(MetafileType.WmfPlaceable, header.Type);
Assert.Equal(0x300, header.Version);
// filesize - 22, which happens to be the size (22) of a PLACEABLEMETAHEADER struct
Assert.Equal(3474, header.MetafileSize);
Assert.Equal(-30, header.Bounds.X);
Assert.Equal(-40, header.Bounds.Y);
Assert.Equal(3096, header.Bounds.Width);
Assert.Equal(4127, header.Bounds.Height);
Assert.Equal(606, header.DpiX);
Assert.Equal(606, header.DpiY);
Assert.Equal(0, header.EmfPlusHeaderSize);
Assert.Equal(0, header.LogicalDpiX);
Assert.Equal(0, header.LogicalDpiY);
Assert.NotNull(header.WmfHeader);
Check_MetaHeader_WmfPlaceable(header.WmfHeader);
Assert.False(header.IsDisplay());
Assert.False(header.IsEmf());
Assert.False(header.IsEmfOrEmfPlus());
Assert.False(header.IsEmfPlus());
Assert.False(header.IsEmfPlusDual());
Assert.False(header.IsEmfPlusOnly());
Assert.True(header.IsWmf());
Assert.True(header.IsWmfPlaceable());
}
private void CheckEmptyHeader(Metafile mf, EmfType type)
{
MetafileHeader mh = mf.GetMetafileHeader();
Assert.AreEqual(0, mh.Bounds.X, "Bounds.X");
Assert.AreEqual(0, mh.Bounds.Y, "Bounds.Y");
Assert.AreEqual(0, mh.Bounds.Width, "Bounds.Width");
Assert.AreEqual(0, mh.Bounds.Height, "Bounds.Height");
Assert.AreEqual(0, mh.MetafileSize, "MetafileSize");
switch (type)
{
case EmfType.EmfOnly:
Assert.AreEqual(MetafileType.Emf, mh.Type, "Type");
break;
case EmfType.EmfPlusDual:
Assert.AreEqual(MetafileType.EmfPlusDual, mh.Type, "Type");
break;
case EmfType.EmfPlusOnly:
Assert.AreEqual(MetafileType.EmfPlusOnly, mh.Type, "Type");
break;
default:
Assert.Fail("Unknown EmfType '{0}'", type);
break;
}
}
public void GetMetafileHeader_FromFile_Emf()
{
using (Metafile mf = new Metafile(Helpers.GetTestBitmapPath(Emf)))
{
MetafileHeader header1 = mf.GetMetafileHeader();
Check_MetafileHeader_Emf(header1);
}
}
public void Static_GetMetafileHeader_Stream()
{
string filename = WmfPlaceable;
using (FileStream fs = File.OpenRead(filename)) {
MetafileHeader header = Metafile.GetMetafileHeader(fs);
Check_MetafileHeader_WmfPlaceable(header);
}
}
public void GetMetafileHeader_FromFileStream_Emf()
{
using (FileStream fs = File.OpenRead(Helpers.GetTestBitmapPath(Emf)))
using (Metafile mf = new Metafile(fs))
{
MetafileHeader header1 = mf.GetMetafileHeader();
Check_MetafileHeader_Emf(header1);
}
}
public void GetMetafileHeader_FromFileStream_Emf()
{
using (FileStream fs = File.OpenRead(Emf)) {
using (Metafile mf = new Metafile(fs)) {
MetafileHeader header1 = mf.GetMetafileHeader();
Check_MetafileHeader_Emf(header1);
}
}
}
public void GetMetafileHeader_WmfPlaceable()
{
using (Metafile mf = new Metafile(WmfPlaceable)) {
MetafileHeader header1 = mf.GetMetafileHeader();
Check_MetafileHeader_WmfPlaceable(header1);
MetafileHeader header2 = mf.GetMetafileHeader();
Assert.IsFalse(Object.ReferenceEquals(header1, header2), "Same object");
}
}
public void GetMetafileHeader_FromMemoryStream_Emf()
{
string filename = Helpers.GetTestBitmapPath(Emf);
using (MemoryStream ms = new MemoryStream(File.ReadAllBytes(filename)))
using (Metafile mf = new Metafile(ms))
{
MetafileHeader header1 = mf.GetMetafileHeader();
Check_MetafileHeader_Emf(header1);
}
}
private void MetafileHeaderInfo_Click(object sender, System.EventArgs e)
{
Metafile curMetafile = new Metafile(@"f:\mtfile.wmf");
MetafileHeader header = curMetafile.GetMetafileHeader();
string mfAttributes = "";
mfAttributes += "Type :" + header.Type.ToString();
mfAttributes += ", Bounds:" + header.Bounds.ToString();
mfAttributes += ", Size:" + header.MetafileSize.ToString();
mfAttributes += ", Version:" + header.Version.ToString();
MessageBox.Show(mfAttributes);
curMetafile.Dispose();
}
public void GetMetafileHeader_FromFile_WmfPlaceable()
{
using (Metafile mf = new Metafile(WmfPlaceable)) {
MetafileHeader header1 = mf.GetMetafileHeader();
Check_MetafileHeader_WmfPlaceable(header1);
MetaHeader mh1 = header1.WmfHeader;
Check_MetaHeader_WmfPlaceable(mh1);
MetaHeader mh2 = mf.GetMetafileHeader().WmfHeader;
Assert.IsFalse(Object.ReferenceEquals(mh1, mh2), "Same object");
}
}
public void GetMetafileHeader_FromFile_WmfPlaceable()
{
using (Metafile mf = new Metafile(Helpers.GetTestBitmapPath(WmfPlaceable)))
{
MetafileHeader header1 = mf.GetMetafileHeader();
Check_MetafileHeader_WmfPlaceable(header1);
MetaHeader mh1 = header1.WmfHeader;
Check_MetaHeader_WmfPlaceable(mh1);
MetaHeader mh2 = mf.GetMetafileHeader().WmfHeader;
Assert.NotSame(mh1, mh2);
}
}
public void GetMetafileHeader_FromMemoryStream_Emf()
{
MemoryStream ms;
string filename = Emf;
using (FileStream fs = File.OpenRead(filename)) {
byte[] data = new byte[fs.Length];
fs.Read(data, 0, data.Length);
ms = new MemoryStream(data);
}
using (Metafile mf = new Metafile(ms)) {
MetafileHeader header1 = mf.GetMetafileHeader();
Check_MetafileHeader_Emf(header1);
}
ms.Close();
}
public void GetMetafileHeader_FromMemoryStream_WmfPlaceable()
{
string filename = Helpers.GetTestBitmapPath(WmfPlaceable);
using (MemoryStream ms = new MemoryStream(File.ReadAllBytes(filename)))
using (Metafile mf = new Metafile(ms))
{
MetafileHeader header1 = mf.GetMetafileHeader();
Check_MetafileHeader_WmfPlaceable(header1);
MetaHeader mh1 = header1.WmfHeader;
Check_MetaHeader_WmfPlaceable(mh1);
MetaHeader mh2 = mf.GetMetafileHeader().WmfHeader;
Assert.NotSame(mh1, mh2);
}
}
private void MetafileHeaderInfo_Click(object sender,
System.EventArgs e)
{
// Crete a Metafile Object
Metafile curMetafile = new Metafile("mtfile.wmf");
// Get MetafileHeader
MetafileHeader header = curMetafile.GetMetafileHeader();
// Read MetafileHeader attributes
string mfAttributes = "";
mfAttributes += "Type :" + header.Type.ToString();
mfAttributes += ", Bounds:" + header.Bounds.ToString();
mfAttributes += ", Size:" + header.MetafileSize.ToString();
mfAttributes += ", Version:" + header.Version.ToString();
// Display message box
MessageBox.Show(mfAttributes);
// Dispose
curMetafile.Dispose();
}
public static Bitmap fromEMF(string filepath)
{
using (Metafile source = new Metafile(filepath)){
MetafileHeader header = source.GetMetafileHeader();
//TODO get Scale from slider in Settings through the configuration class that Viruz refuses to make :YagooCry:
float scale = 4f;
int width = (int)Math.Round((scale * source.Width / header.DpiX * 100), 0, MidpointRounding.ToEven);
int height = (int)Math.Round((scale * source.Height / header.DpiY * 100), 0, MidpointRounding.ToEven);
//TODO set background color to white or transparent depending on the target format.
Bitmap target = new Bitmap(width, height);
using (var g = Graphics.FromImage(target))
{
g.DrawImage(source, 0, 0, width, height);
return(target);
}
}
}
private static void Check_MetafileHeader_Emf(MetafileHeader header)
{
Assert.Equal(MetafileType.Emf, header.Type);
Assert.Equal(65536, header.Version);
// extactly the filesize
Assert.Equal(20456, header.MetafileSize);
Assert.Equal(0, header.Bounds.X);
Assert.Equal(0, header.Bounds.Y);
Assert.Throws <ArgumentException>(() => header.WmfHeader);
Assert.False(header.IsDisplay());
Assert.True(header.IsEmf());
Assert.True(header.IsEmfOrEmfPlus());
Assert.False(header.IsEmfPlus());
Assert.False(header.IsEmfPlusDual());
Assert.False(header.IsEmfPlusOnly());
Assert.False(header.IsWmf());
Assert.False(header.IsWmfPlaceable());
}
public static void Check_MetafileHeader_Emf(MetafileHeader header)
{
Assert.AreEqual(MetafileType.Emf, header.Type, "Type");
Assert.AreEqual(65536, header.Version, "Version");
// extactly the filesize
Assert.AreEqual(20456, header.MetafileSize, "MetafileSize");
Assert.AreEqual(0, header.Bounds.X, "Bounds.X");
Assert.AreEqual(0, header.Bounds.Y, "Bounds.Y");
#if false
Assert.AreEqual(759, header.Bounds.Width, "Bounds.Width");
Assert.AreEqual(1073, header.Bounds.Height, "Bounds.Height");
Assert.AreEqual(96f, header.DpiX, 0.5f, "DpiX");
Assert.AreEqual(96f, header.DpiY, 0.5f, "DpiY");
Assert.AreEqual(6619188, header.EmfPlusHeaderSize, "EmfPlusHeaderSize");
Assert.AreEqual(3670064, header.LogicalDpiX, "LogicalDpiX");
Assert.AreEqual(3670064, header.LogicalDpiY, "LogicalDpiY");
#endif
try
{
Assert.IsNotNull(header.WmfHeader, "WmfHeader");
Assert.Fail("WmfHeader didn't throw an ArgumentException");
}
catch (ArgumentException)
{
}
catch (Exception e)
{
Assert.Fail("WmfHeader didn't throw an ArgumentException but: {0}.", e.ToString());
}
Assert.IsFalse(header.IsDisplay(), "IsDisplay");
Assert.IsTrue(header.IsEmf(), "IsEmf");
Assert.IsTrue(header.IsEmfOrEmfPlus(), "IsEmfOrEmfPlus");
Assert.IsFalse(header.IsEmfPlus(), "IsEmfPlus");
Assert.IsFalse(header.IsEmfPlusDual(), "IsEmfPlusDual");
Assert.IsFalse(header.IsEmfPlusOnly(), "IsEmfPlusOnly");
Assert.IsFalse(header.IsWmf(), "IsWmf");
Assert.IsFalse(header.IsWmfPlaceable(), "IsWmfPlaceable");
}
public void GetMetafileHeader_FromMemoryStream_WmfPlaceable()
{
MemoryStream ms;
string filename = WmfPlaceable;
using (FileStream fs = File.OpenRead(filename)) {
byte[] data = new byte[fs.Length];
fs.Read(data, 0, data.Length);
ms = new MemoryStream(data);
}
using (Metafile mf = new Metafile(ms)) {
MetafileHeader header1 = mf.GetMetafileHeader();
Check_MetafileHeader_WmfPlaceable(header1);
MetaHeader mh1 = header1.WmfHeader;
Check_MetaHeader_WmfPlaceable(mh1);
MetaHeader mh2 = mf.GetMetafileHeader().WmfHeader;
Assert.IsFalse(Object.ReferenceEquals(mh1, mh2), "Same object");
}
ms.Close();
}
void MenuFilePropsOnClick(object obj, EventArgs ea)
{
MetafileHeader mh = mf.GetMetafileHeader();
string str =
"Image Properties" +
"\n\tSize = " + mf.Size +
"\n\tHorizontal Resolution = " + mf.HorizontalResolution +
"\n\tVertical Resolution = " + mf.VerticalResolution +
"\n\tPhysical Dimension = " + mf.PhysicalDimension +
"\n\nMetafile Header Properties" +
"\n\tBounds = " + mh.Bounds +
"\n\tDpiX = " + mh.DpiX +
"\n\tDpiY = " + mh.DpiY +
"\n\tLogicalDpiX = " + mh.LogicalDpiX +
"\n\tLogicalDpiY = " + mh.LogicalDpiY +
"\n\tType = " + mh.Type +
"\n\tVersion = " + mh.Version +
"\n\tMetafileSize = " + mh.MetafileSize;
MessageBox.Show(str, Text);
}
private void button_SaveAs_Click(object sender, EventArgs e)
{
if (saveFileDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
//groupBox_Barcode.BackgroundImage.Save(saveFileDialog.FileName);
int width = 300;
int height = 100;
Graphics offScreenBufferGraphics;
Metafile m;
using (MemoryStream stream = new MemoryStream())
{
using (offScreenBufferGraphics = Graphics.FromHwndInternal(IntPtr.Zero))
{
IntPtr deviceContextHandle = offScreenBufferGraphics.GetHdc();
m = new Metafile(
stream,
deviceContextHandle,
new RectangleF(0, 0, width, height),
MetafileFrameUnit.Pixel,
EmfType.EmfPlusOnly);
offScreenBufferGraphics.ReleaseHdc();
}
}
int pos = 0;
string encodedValue =
"1001011011010101001101101011011001010101101001011010101001101101010100110110101010011011010110110010101011010011010101011001101010101100101011011010010101101011001101010100101101101";
int barWidth = width / encodedValue.Length;
int shiftAdjustment = (width % encodedValue.Length) / 2;
int barWidthModifier = 1;
using (Graphics g = Graphics.FromImage(m))
{
// Set everything to high quality
g.SmoothingMode = SmoothingMode.HighQuality;
g.InterpolationMode = InterpolationMode.HighQualityBicubic;
g.PixelOffsetMode = PixelOffsetMode.HighQuality;
g.CompositingQuality = CompositingQuality.HighQuality;
MetafileHeader metafileHeader = m.GetMetafileHeader();
g.ScaleTransform(
metafileHeader.DpiX / g.DpiX,
metafileHeader.DpiY / g.DpiY);
g.PageUnit = GraphicsUnit.Pixel;
g.SetClip(new RectangleF(0, 0, width, height));
// clears the image and colors the entire background
g.Clear(Color.White);
// lines are barWidth wide so draw the appropriate color line vertically
using (Pen pen = new Pen(Color.Black, (float)barWidth / barWidthModifier))
{
while (pos < encodedValue.Length)
{
if (encodedValue[pos] == '1')
{
g.DrawLine(
pen,
new Point(pos * barWidth + shiftAdjustment + 1, 0),
new Point(pos * barWidth + shiftAdjustment + 1, height));
}
pos++;
} // while
} // using
} // using
// Get a handle to the metafile
IntPtr iptrMetafileHandle = m.GetHenhmetafile();
// Export metafile to an image file
CopyEnhMetaFile(iptrMetafileHandle, saveFileDialog.FileName);
// Delete the metafile from memory
DeleteEnhMetaFile(iptrMetafileHandle);
}
}
public void Static_GetMetafileHeader_Stream_Null()
{
MetafileHeader header = Metafile.GetMetafileHeader((Stream)null);
}
public void Static_GetMetafileHeader_Filename_Null()
{
MetafileHeader header = Metafile.GetMetafileHeader((string)null);
}
