コード例 #1
0
        protected override void OnPrintPage(PrintPageEventArgs e)
        {
            base.OnPrintPage(e);

            Stream pageToPrint = m_pages[m_currentPage];
            pageToPrint.Position = 0;

            // Load each page into a Metafile to draw it.
            using (Metafile pageMetaFile = new Metafile(pageToPrint))
            {
                Rectangle adjustedRect = new Rectangle(
                        e.PageBounds.Left - (int)e.PageSettings.HardMarginX,
                        e.PageBounds.Top - (int)e.PageSettings.HardMarginY,
                        e.PageBounds.Width,
                        e.PageBounds.Height);

                // Draw a white background for the report
                e.Graphics.FillRectangle(Brushes.White, adjustedRect);

                // Draw the report content
                e.Graphics.DrawImage(pageMetaFile, adjustedRect);

                // Prepare for next page.  Make sure we haven't hit the end.
                m_currentPage++;
                e.HasMorePages = m_currentPage < m_pages.Count;
            }
        }
コード例 #2
0
    protected override void OnPrintPage(PrintPageEventArgs e)
    {
        if (this.PrinterSettings.PrintRange == System.Drawing.Printing.PrintRange.SomePages)
        {
            while (++_page < this.PrinterSettings.FromPage)
            {
                // Fake the pages that need to be skipped by printing them to a Metafile
                IntPtr hDev = e.Graphics.GetHdc();
                try
                {
                    using (var mf = new Metafile(hDev, e.PageBounds))
                    using (var gr = Graphics.FromImage(mf))
                    {
                        var ppe = new PrintPageEventArgs(gr, e.MarginBounds, e.PageBounds, e.PageSettings);
                        base.OnPrintPage(ppe);
                    }
                }
                finally
                {
                    e.Graphics.ReleaseHdc(hDev);
                }
            }

            // Print the real page
            base.OnPrintPage(e);

            // No need to continue past PageTo
            if (this.PrinterSettings.ToPage > 0 && _page >= this.PrinterSettings.ToPage) e.HasMorePages = false;
        }
        else
        {
            base.OnPrintPage(e);
        }
    }
コード例 #3
0
 public static Bitmap GetImage(IntPtr hwnd)
 {
     try
         {
             if (OpenClipboard(hwnd))
             {
                 IntPtr data = GetClipboardData(14); // CF_ENHMETAFILE      14
                 if (data != IntPtr.Zero)
                 {
                     using (Metafile mf = new Metafile(data, true))
                     {
                         Bitmap b = new Bitmap(mf);
                         return b;
                     }
                 }
             }
         }
         finally
         {
             CloseClipboard();
         }
         return null;
 }
コード例 #4
0
ファイル: MetafileHelper.cs プロジェクト: Wiladams/NewTOAPIA
	// Metafile mf is set to a state that is not valid inside this function.
	static public bool PutEnhMetafileOnClipboard( IntPtr hWnd, Metafile mf )
	{
		bool bResult = false;
		IntPtr hEMF, hEMF2;
		hEMF = mf.GetHenhmetafile(); // invalidates mf
		if( ! hEMF.Equals( new IntPtr(0) ) )
		{
			hEMF2 = CopyEnhMetaFile( hEMF, new IntPtr(0) );
			if( ! hEMF2.Equals( new IntPtr(0) ) )
			{
				if( OpenClipboard( hWnd ) )
				{
					if( EmptyClipboard() )
					{
						IntPtr hRes = SetClipboardData( 14 /*CF_ENHMETAFILE*/, hEMF2 );
						bResult = hRes.Equals( hEMF2 );
						CloseClipboard();
					}
				}
			}
			DeleteEnhMetaFile( hEMF );
		}
		return bResult;
	}
コード例 #5
0
 public void EnumerateMetafile(Metafile metafile, RectangleF destinationRectangle, RectangleF sourceRectangle, GraphicsUnit unit, System.Drawing.Graphics.EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttributes)
 {
     this.baseGraphics.EnumerateMetafile(metafile, destinationRectangle, sourceRectangle, unit, callback, callbackData, imageAttributes);
 }
コード例 #6
0
ファイル: DeckModel.cs プロジェクト: zhujingcheng/CP3
            /// <summary>
            /// Fills the given serialization context with this object
            /// </summary>
            /// <param name="info">The field information for the class</param>
            /// <param name="context">The stream containing the serialized object</param>
            public void GetObjectData(SerializationInfo info, StreamingContext context)
            {
                //Add key
                info.AddValue("key", this.key);
                //Add image in a special way
                byte[] bits = null;

                // The Image class is not capable of multithreaded access.
                // Simultaneous access will throw a
                //    "InvalidOperationException: The object is currently in use elsewhere."
                // So it needs to be locked, and also locked anywhere else the Image is accessed
                // (such as in ImageSheetRenderer.Paint).
                using (Synchronizer.Lock(this.m_image)) {
                    if (this.m_image.RawFormat.Guid == ImageFormat.Emf.Guid)
                    {
                        info.AddValue("type", "emf");
                        Metafile mf  = (Metafile)((Metafile)this.m_image).Clone();
                        IntPtr   ptr = mf.GetHenhmetafile();
                        Debug.Assert(ptr != IntPtr.Zero, "Failed to get pointer to image.");
                        uint size = GetEnhMetaFileBits(ptr, 0, null);
                        bits = new byte[size];
                        uint numBits = GetEnhMetaFileBits(ptr, size, bits);
                        mf.Dispose();
                        Debug.Assert(size == numBits, "Improper serialization of metafile!");
                    }
                    else if (this.m_image.RawFormat.Guid == ImageFormat.Wmf.Guid)
                    {
                        info.AddValue("type", "wmf");
                        Metafile mf  = (Metafile)((Metafile)this.m_image).Clone();
                        IntPtr   ptr = mf.GetHenhmetafile();
                        Debug.Assert(ptr != IntPtr.Zero, "Failed to get pointer to image.");
                        uint size = GetMetaFileBitsEx(ptr, 0, null);
                        bits = new byte[size];
                        uint numBits = GetMetaFileBitsEx(ptr, size, bits);
                        mf.Dispose();
                        Debug.Assert(size == numBits, "Improper serialization of metafile!");
                    }
                    else if (this.m_image.RawFormat.Guid == ImageFormat.Png.Guid)
                    {
                        info.AddValue("type", "png");
                        System.IO.MemoryStream ms = new System.IO.MemoryStream(100000);
                        this.m_image.Save(ms, ImageFormat.Png);
                        bits = ms.ToArray();
                    }
                    else if (this.m_image.RawFormat.Guid == ImageFormat.Jpeg.Guid)
                    {
                        info.AddValue("type", "Jpeg");
                        System.IO.MemoryStream ms = new System.IO.MemoryStream();
                        long[] quality            = new long[1];
                        quality[0] = 100;
                        System.Drawing.Imaging.EncoderParameters encoderParams = new System.Drawing.Imaging.EncoderParameters();
                        System.Drawing.Imaging.EncoderParameter  encoderParam  = new System.Drawing.Imaging.EncoderParameter(System.Drawing.Imaging.Encoder.Quality, quality);
                        encoderParams.Param[0] = encoderParam;
                        ImageCodecInfo[] arrayICI = ImageCodecInfo.GetImageEncoders();
                        ImageCodecInfo   jpegICI  = null;
                        for (int x = 0; x < arrayICI.Length; x++)
                        {
                            if (arrayICI[x].FormatDescription.Equals("JPEG"))
                            {
                                jpegICI = arrayICI[x];
                                break;
                            }
                        }
                        if (jpegICI != null)
                        {
                            this.m_image.Save(ms, jpegICI, encoderParams);
                        }

                        bits = ms.ToArray();
                    }
                    else
                    {
                        info.AddValue("type", "png");
                        System.IO.MemoryStream ms = new System.IO.MemoryStream(100000);
                        this.m_image.Save(ms, ImageFormat.Png);
                        bits = ms.ToArray();
                    }
                }
                info.AddValue("image", bits);
            }
コード例 #7
0
        /// <summary>
        ///加载路径下的一张图片,读取失败或格式不支持返回一张默认图片
        /// </summary>
        ///
        ///<note>
        ///外部使用完 Image 之后,必须明确调用 Image.Dipose() 立刻释放,因
        ///为 svg 文件会生成 emf 临时文件,需要释放资源才能删除
        ///</note>
        static public Image LoaderImage(string path)
        {
            Bitmap defaultBitmap = global::BesPrinter.Properties.Resources.unsupported_image;

            Image image = null;

            if (!File.Exists(path))
            {
                image = defaultBitmap;  //文件不存在,返回默认图片
            }
            else
            {
                FileInfo fileInfo = new FileInfo(path);
                if (fileInfo.Extension == ".bmp" ||
                    fileInfo.Extension == ".png" ||
                    fileInfo.Extension == ".jpg" ||
                    fileInfo.Extension == ".jpeg")
                {
                    FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read); //从文件流打开,不占用文件
                    image = Image.FromStream(fileStream);
                    fileStream.Close();
                    fileStream.Dispose();
                }
                else if (fileInfo.Extension == ".svg")
                {
                    //临时创建一个 svg 转换而来的 emf 文件
                    string emfTempPath = Path.GetTempFileName();
                    try
                    {
                        SvgDocument svg = SvgDocument.Open(path);
                        using (Graphics bufferGraphics = Graphics.FromHwndInternal(IntPtr.Zero))
                        {
                            using (var metafile = new Metafile(emfTempPath, bufferGraphics.GetHdc()))
                            {
                                using (Graphics graphics = Graphics.FromImage(metafile))
                                {
                                    svg.Draw(graphics);
                                }
                            }

                            image = new Metafile(emfTempPath); //读取 emf 文件
                        }
                    }
                    catch (Exception e)
                    {
                        MessageBox.Show(e.Message, Trans.tr("Tip"), MessageBoxButtons.OK, MessageBoxIcon.Information);
                    }
                    finally
                    {
                        //现在获得图片不能立刻删除文件,不然得到 image 也无法获得其中的数据
                        if (listTempEmfFiles == null)
                        {
                            listTempEmfFiles = new List <string>();
                        }
                        listTempEmfFiles.Add(emfTempPath);
                    }
                }
                else if (fileInfo.Extension == ".emf")
                {
                    FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read); //从文件流打开,不占用文件
                    image = new Metafile(fileStream);
                    fileStream.Close();
                    fileStream.Dispose();
                }
                else
                {
                    image = defaultBitmap; //格式不支持不存在,返回默认图片
                }
            }

            if (image == null)
            {
                image = defaultBitmap;  //如果存在读取失败的情况,使用默认图片返回
            }
            return(image);
        }
コード例 #8
0
ファイル: AutoPrintingDemo.cs プロジェクト: iMutex/EBusiness
    private void PrintPage(object sender, PrintPageEventArgs ev)
    {
        Metafile pageImage = new Metafile(m_streams[m_currentPageIndex]);
        ev.Graphics.DrawImage(pageImage, ev.PageBounds);

        m_currentPageIndex++;
        ev.HasMorePages = (m_currentPageIndex < m_streams.Count);
    }
コード例 #9
0
        public Metafile[] DrawPlot(Element_ND[] Elements, Node_ND[] Nodes, Vector[] GlobalUnknowns, out Vector MinV, out Vector MaxV)
        {
            int NP = GlobalUnknowns.Length;

            Metafile[] Plots = new Metafile[NP];
            Graphics[] gs    = new Graphics[NP];
            for (int i = 0; i < NP; i++)
            {
                Plots[i] = ImageMethods.MakeMetafile(PageWidth, PageHeight);
                gs[i]    = Graphics.FromImage(Plots[i]);
            }

            SetPlotTypeToDisplay();
            MinV = new Vector(NP);
            MaxV = new Vector(NP);
            Node_ND.Set_UnknownForNode(Nodes, GlobalUnknowns[0]);
            Surfaces[] TheSurfaces = Element_ND.Make_GraphicSurfaces(Elements, Plot_ObjectResolution);
            Surfaces.CalculateMinMax_Values(TheSurfaces, out MinV.Values[0], out MaxV.Values[0]);
            for (int i = 1; i < NP; i++)
            {
                Node_ND.Set_UnknownForNode(Nodes, GlobalUnknowns[i]);
                Element_ND.Change_GraphicSurfaces_Values(Elements, ref TheSurfaces, Plot_ObjectResolution);
                Surfaces.CalculateMinMax_Values(TheSurfaces, out MinV.Values[i], out MaxV.Values[i]);
            }
            double Min = MinV.Min();
            double Max = MaxV.Max();

            for (int i = 0; i < NP; i++)
            {
                Node_ND.Set_UnknownForNode(Nodes, GlobalUnknowns[i]);
                Element_ND.Change_GraphicSurfaces_Values(Elements, ref TheSurfaces, Plot_ObjectResolution);
                if (FixedScale)
                {
                    TheGraph.DrawGraph(gs[i], Xo, TheSurfaces, Min, Max);
                }
                else
                {
                    TheGraph.DrawGraph(gs[i], Xo, TheSurfaces, MinV.Values[i], MaxV.Values[i]);
                }
                if (ColorPlotOn)
                {
                    if (FixedScale)
                    {
                        Plot_ColorScale.Initialize_Calculate_WidthAndHeight(ref gs[i], Min, Max);
                    }
                    else
                    {
                        Plot_ColorScale.Initialize_Calculate_WidthAndHeight(ref gs[i], MinV.Values[i], MaxV.Values[i]);
                    }
                    Plot_ColorScale.x_c            = new Vector(X_TR);
                    Plot_ColorScale.x_c.Values[0] += ColorScalePad + Plot_ColorScale.Width / 2.0D;
                    Plot_ColorScale.AddColorScale(ref gs[i]);
                }
                Vector Title_c = new Vector(X_TC);
                Plot_Title.GetWidthAndHeight(gs[i]);
                Title_c.Values[1] += -TitlePad - Plot_Title.Height;
                Plot_Title.DrawTitle(gs[i], Title_c);

                Vector OPPS_Graphics_c = new Vector(2);
                OOPS_Graphics_Title.GetWidthAndHeight(gs[i]);
                OPPS_Graphics_c.Values[0] = PageWidth - ColorScalePad - OOPS_Graphics_Title.Width / 2.0D;
                OPPS_Graphics_c.Values[1] = PageHeight - ColorScalePad - OOPS_Graphics_Title.Height;
                OOPS_Graphics_Title.DrawTitle(gs[i], OPPS_Graphics_c);

                gs[i].Dispose();
            }
            return(Plots);
        }
コード例 #10
0
        public string GetSelectionImg(string paperName)
        {
            cutTimes      = 1;
            cutTimesCount = 0;

            const int MAX_height = 3000;
            //string timeResult = "";

            Range range  = Globals.ThisAddIn.Application.Selection.Range;
            Range range2 = Globals.ThisAddIn.Application.Selection.Range;

            //timeResult = timeResult + "Time1:" + DateTime.Now.ToString() + "\n";
            string imgName = Guid.NewGuid().ToString() + ".png";

            if (!Directory.Exists(Globals.ThisAddIn.exerciseJsonPath + paperName))
            {
                Directory.CreateDirectory(Globals.ThisAddIn.exerciseJsonPath + paperName);
            }


            double    zoom     = 0.33;
            const int imgWidth = 1188;


            Image imgTemp = Metafile.FromStream(new MemoryStream(range.EnhMetaFileBits));


            //imgTemp.Save(Globals.ThisAddIn.exerciseJsonPath + paperName + "\\" + imgName, System.Drawing.Imaging.ImageFormat.Png);


            if (MAX_height < imgTemp.Height)
            {
                Paragraphs paragraphs = range.Paragraphs;
                Tables     tables     = range.Tables;

                List <StartEnd> paragraphList = new List <StartEnd>();
                List <StartEnd> tableList     = new List <StartEnd>();

                for (int i = 0; i < paragraphs.Count; i++)
                {
                    Paragraph paragraph = paragraphs[i + 1];
                    StartEnd  startEnd  = new StartEnd();
                    startEnd.Start = paragraph.Range.Start;
                    startEnd.End   = paragraph.Range.End;

                    paragraphList.Add(startEnd);
                }
                for (int i = 0; i < tables.Count; i++)
                {
                    Table    table    = tables[i + 1];
                    StartEnd startEnd = new StartEnd();
                    startEnd.Start = table.Range.Start;
                    startEnd.End   = table.Range.End;

                    tableList.Add(startEnd);
                }

                List <StartEnd> resultList = CutRange(paragraphList, tableList);

                List <StartEnd> finalImgRangeList = new List <StartEnd>();
                for (int i = 0; i < resultList.Count; i++)
                {
                    StartEnd startendImg = new StartEnd();
                    startendImg.Start = resultList[i].Start;
                    startendImg.End   = resultList[i].End;
                    for (int j = i; j < resultList.Count; j++)
                    {
                        range2.SetRange((int)resultList[i].Start, (int)resultList[j].End);
                        Image img = Metafile.FromStream(new MemoryStream(range2.EnhMetaFileBits));
                        if (img.Height < MAX_height)
                        {
                            startendImg.End = resultList[j].End;
                            if (j == resultList.Count - 1)
                            {
                                i = j;
                            }
                        }
                        else
                        {
                            if (i == j)
                            {
                                MessageBox.Show("请确定没有超过一页的段落或表格");
                                Globals.ThisAddIn.Application.ActiveWindow.ScrollIntoView(range2);

                                return("");
                            }
                            i = j - 1;
                            break;
                        }
                    }
                    finalImgRangeList.Add(startendImg);
                }
                cutTimes = finalImgRangeList.Count;


                //timeResult = timeResult + "Time2:" + DateTime.Now.ToString() + "\n";


                int allImgHeight = 0;
                int allImgWidth  = 0;
                for (int i = 0; i < finalImgRangeList.Count; i++)
                {
                    range2.SetRange((int)finalImgRangeList[i].Start, (int)finalImgRangeList[i].End);
                    Image img = Metafile.FromStream(new MemoryStream(range2.EnhMetaFileBits));
                    if (img.Width > allImgWidth)
                    {
                        allImgWidth = img.Width;
                    }

                    allImgHeight += img.Height;
                }
                //for(int i=0;i<resultList.Count;i++)
                //{
                //    int start=(int)resultList[i].Start;
                //    int end=(int)resultList[i].End;
                //    range2.SetRange(start,end);
                //    if (i % 2 == 0)
                //        range2.HighlightColorIndex = WdColorIndex.wdRed;
                //    else
                //        range2.HighlightColorIndex = WdColorIndex.wdYellow;
                //}

                //zoom = (double)imgWidth / (double)allImgWidth;
                System.Drawing.Bitmap bmp = new Bitmap(imgWidth, (int)(allImgHeight * zoom));

                System.Drawing.Graphics gx = System.Drawing.Graphics.FromImage(bmp); // 创建Graphics对象
                gx.InterpolationMode = InterpolationMode.HighQualityBicubic;
                // 指定高质量、低速度呈现。
                gx.SmoothingMode      = SmoothingMode.HighQuality;
                gx.CompositingQuality = CompositingQuality.HighQuality;

                gx.CompositingMode   = CompositingMode.SourceOver;
                gx.TextRenderingHint = System.Drawing.Text.TextRenderingHint.ClearTypeGridFit;
                int    startPosition = 0;
                double oldZoom       = zoom;
                for (int i = 0; i < finalImgRangeList.Count; i++)
                {
                    range2.SetRange((int)finalImgRangeList[i].Start, (int)finalImgRangeList[i].End);
                    Image img = Metafile.FromStream(new MemoryStream(range2.EnhMetaFileBits));

                    if ((double)imgWidth / (double)img.Width < zoom)
                    {
                        zoom = (double)imgWidth / (double)img.Width;
                    }

                    gx.FillRectangle(new SolidBrush(System.Drawing.Color.Transparent), 0, startPosition, (int)(img.Width * zoom), (int)(img.Height * zoom));
                    gx.DrawImage(img, new System.Drawing.Rectangle(0, startPosition, (int)(img.Width * zoom), (int)(img.Height * zoom)));

                    startPosition += (int)(img.Height * zoom);
                    zoom           = oldZoom;

                    cutTimesCount = i + 1;
                }

                //bmp = KiSharpen(bmp,(float)0.3);
                bmp.Save(Globals.ThisAddIn.exerciseJsonPath + paperName + "\\" + imgName, System.Drawing.Imaging.ImageFormat.Png);
            }
            else
            {
                //zoom = (double)imgWidth / (double)imgTemp.Width;
                System.Drawing.Bitmap   bmp = new Bitmap(imgWidth, (int)(imgTemp.Height * zoom));
                System.Drawing.Graphics gx  = System.Drawing.Graphics.FromImage(bmp); // 创建Graphics对象
                gx.InterpolationMode = InterpolationMode.HighQualityBicubic;
                // 指定高质量、低速度呈现。
                gx.SmoothingMode      = SmoothingMode.HighQuality;
                gx.CompositingQuality = CompositingQuality.HighQuality;

                gx.CompositingMode   = CompositingMode.SourceOver;
                gx.TextRenderingHint = System.Drawing.Text.TextRenderingHint.ClearTypeGridFit;

                gx.FillRectangle(new SolidBrush(System.Drawing.Color.Transparent), 0, 0, (int)(imgTemp.Width * zoom), (int)(imgTemp.Height * zoom));
                gx.DrawImage(imgTemp, new System.Drawing.Rectangle(0, 0, (int)(imgTemp.Width * zoom), (int)(imgTemp.Height * zoom)));
                //imgTemp.Save(Globals.ThisAddIn.exerciseJsonPath + paperName + "\\" + imgName, System.Drawing.Imaging.ImageFormat.Png);
                bmp.Save(Globals.ThisAddIn.exerciseJsonPath + paperName + "\\" + imgName, System.Drawing.Imaging.ImageFormat.Png);
            }
            //timeResult = timeResult + "Time3:" + DateTime.Now.ToString() + "\n";

            cutTimes      = 1;
            cutTimesCount = 0;

            //MessageBox.Show(timeResult);
            return(imgName);
        }
コード例 #11
0
ファイル: SystemMonitor.cs プロジェクト: nogna/Upbot
        /// <summary>
        /// Sends different message/image depending on what state the system currently has.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="systemRunStateEventArgs"></param>
        private void WhenSystemDataAPIOnSystemState(object sender, SystemRunStateEventArgs systemRunStateEventArgs)
        {
            try
            {
                SystemRunState state = systemRunStateEventArgs.State; //Updating the current system state

                #region Some logic. Check if the system have started a run, if the state is the previous state etc.
                if (state == SystemRunState.Manual || state == SystemRunState.Running)
                {
                    mHasOneRun = true;
                    return;
                }

                if (!mHasOneRun)
                {
                    return;
                }
                if (mPreviousState == state)
                {
                    return;
                }
                #endregion

                #region Get the current relevant information from the current run
                currentSystemStatus = mSystemDataAPI.GetCurrentSystemStatus();
                systemName          = mSystemDataAPI.GetInstrumentInformation().SystemName;
                methodName          = mSystemDataAPI.GetCurrentSystemStatus().MethodName;
                methodInfo          = string.IsNullOrEmpty(methodName) ? "Manual run" : "Method " + methodName;
                #endregion

                mPreviousState = state; //Updating the previous system state

                #region logic for the different states
                switch (state)
                {
                    #region Pause states
                case SystemRunState.ManualUserPause:     //if a user manually pauses the proccess.
                    numberOfInterrupts++;
                    messageToTwitter = formTheStringToTwitter("is now paused by a user.");


                    SendTweet(messageToTwitter);

                    break;

                case SystemRunState.Pause:
                    numberOfInterrupts++;
                    messageToTwitter = formTheStringToTwitter("is now paused.");


                    SendTweet(messageToTwitter);

                    break;
                    #endregion

                    #region Error state

                case SystemRunState.AlarmError:     //if the proccess receives an error

                    if (!hasEnded)
                    {
                        numberOfInterrupts++;
                        messageToTwitter = formTheStringToTwitter("encountered an error!");
                        metafile         = mReportingAPI.GetMetafile();


                        SendTweet(messageToTwitter, metafile);
                    }

                    break;
                    #endregion

                    #region User Ended run state
                case SystemRunState.TransitToEnd:     //if a user manually ends the run

                    messageToTwitter = formTheStringToTwitter("has #ended.");
                    metafile         = mReportingAPI.GetMetafile();

                    SendTweet(messageToTwitter, metafile);


                    //reset and updates values
                    numberOfInterrupts = 0;
                    hasEnded           = true;

                    break;
                    #endregion

                    #region User resumed state
                case SystemRunState.TransitToManualRun:     //if a user continues the run after (if it was paused)

                    messageToTwitter = formTheStringToTwitter("is resumed.");
                    SendTweet(messageToTwitter);

                    break;
                    #endregion

                default:
                    break;
                }
                #endregion
            }

            catch (Exception e)
            {
                //Writing the error message to a logger
                mLogger.LogErrorToUNICORNLog(e.Message);
            }
        }
コード例 #12
0
        /// <summary>
        /// Renders a document as enhanced metafile. The metafile is rendered into a stream. You can create a metafile object afterwards from that stream.
        /// </summary>
        /// <param name="renderingProc">Procedure for rendering the document.
        /// The argument is a graphics context, which is set to GraphicsUnits equal to Points.
        /// The drawing must be inside of the boundaries of docSize.X and docSize.Y.
        /// </param>
        /// <param name="stream">Destination stream. The metafile is rendered into this stream. The stream has to be writeable and seekable. At return, the position of the stream is set to 0, thus the stream is ready to be used to create a metafile object from it.</param>
        /// <param name="docSize">Size of the document in points (1/72 inch)</param>
        /// <param name="sourceDpiResolution">The resolution in dpi of the source. This parameter is used only if creating the reference graphics context from the current printer fails. In this case, a context from a bitmap with the provided resolution is created.</param>
        /// <param name="outputScalingFactor">Output scaling factor. If less than 1, the image will appear smaller than originally, if greater than 1, the image will appear larger than originally.</param>
        /// <param name="pixelFormat">Optional: Only used if the graphics context can not be created from a printer document. Pixel format of the bitmap that is used in this case to construct the graphics context.</param>
        /// <returns>The rendered enhanced metafile (vector format).</returns>
        /// <remarks>
        /// <para>
        /// I found no other way to realize different dpi resolutions, independently of screen or printer device contexts, as to patch the resulting metafile stream with
        /// informations about an 'artifical' device, which has exactly the resolution that is neccessary. By careful choice of the size of this artifical device one can
        /// avoid rounding errors concerning resolution and size.
        /// It happens that some programs (for instance MS Word 2010 when saving as PDF document) mess up the size of the metafile graphics, if the graphics was created with a PageUnit
        /// (of the graphics context) other than PIXELS.
        /// Thus I now always use PIXEL as PageUnit and scale the graphics context accordingly.
        /// </para>
        /// <para>
        /// Another problem, which is actually without solution, is that e.g. MS Office will not show polylines with more than 8125 points. These polylines are included in the metafile,
        /// but MS Office seems to ignore them. On the other hand, CorelDraw X5 can show these polylines correctly.
        /// This problem might be related to the EmfPlus format, because MS Office will show these polylines if the EmfOnly format is used. But EmfOnly can not handle transparencies, thus
        /// it is not really a choice.
        /// </para>
        /// </remarks>
        public static (int pixelsX, int pixelsY) RenderAsEnhancedMetafileToStream(Action <Graphics> renderingProc, System.IO.Stream stream, PointD2D docSize, double sourceDpiResolution, double outputScalingFactor, PixelFormat pixelFormat = PixelFormat.Format32bppArgb)
        {
            if (stream == null)
            {
                throw new ArgumentNullException("stream");
            }
            if (!stream.CanWrite)
            {
                throw new ArgumentException("stream is not writeable");
            }
            if (!stream.CanSeek)
            {
                throw new ArgumentException("stream is not seekable");
            }
            stream.SetLength(0);

            var scaledDocSize = docSize * outputScalingFactor;

            // our artifical device has a square size, and the size is an integer multiple of 5 inch (5 inch because this is the smallest size which converts to an integer number of millimeters: 127 mm)
            int deviceSizeInch = (int)(5 * Math.Ceiling(Math.Max(scaledDocSize.X, scaledDocSize.Y) / (72 * 5)));

            // we have to design our artifical device so that it has a resolution of sourceDpiResolution/outputScalingFactor
            // this accounts for the fact, that if
            double deviceResolution = sourceDpiResolution / outputScalingFactor;

            // then the number of pixels of the device is simple the device size in inch times the device resolution
            int devicePixelsX = (int)Math.Round(deviceSizeInch * deviceResolution);
            int devicePixelsY = (int)Math.Round(deviceSizeInch * deviceResolution);

            // device size in millimeter. Because of the choice of the device size (see above) there should be no rounding errors here
            int deviceSizeXMillimeter = (deviceSizeInch * 254) / 10;
            int deviceSizeYMillimeter = (deviceSizeInch * 254) / 10;

            // device size in micrometer
            int deviceSizeXMicrometer = deviceSizeInch * 25400;
            int deviceSizeYMicrometer = deviceSizeInch * 25400;

            // bounds of the graphic in pixels. Because it is in pixels, it is calculated with the unscaled size of the document and the sourceDpiResolution
            int graphicBoundsLeft_Pixels   = 0;
            int graphicBoundsTop_Pixels    = 0;
            int graphicBoundsWidth_Pixels  = (int)Math.Ceiling(sourceDpiResolution * docSize.X / 72);
            int graphicBoundsHeight_Pixels = (int)Math.Ceiling(sourceDpiResolution * docSize.Y / 72);

            // position and size of the bounding box. Please not that the bounds are scaled with the outputScalingFactor
            int boundingBoxLeft_HIMETRIC   = 0;
            int boundingBoxTop_HIMETRIC    = 0;
            int boundingBoxWidth_HIMETRIC  = (int)Math.Ceiling(scaledDocSize.X * 2540.0 / 72);
            int boundingBoxHeight_HIMETRIC = (int)Math.Ceiling(scaledDocSize.Y * 2540.0 / 72);

            Metafile metafile;

            using (var helperbitmap = new System.Drawing.Bitmap(4, 4, PixelFormat.Format32bppArgb))
            {
                using (var grfxReference = Graphics.FromImage(helperbitmap))
                {
                    IntPtr deviceContextHandle = grfxReference.GetHdc();

                    metafile = new Metafile(
                        stream,
                        deviceContextHandle,
                        new RectangleF(boundingBoxLeft_HIMETRIC, boundingBoxTop_HIMETRIC, boundingBoxWidth_HIMETRIC, boundingBoxHeight_HIMETRIC),
                        MetafileFrameUnit.GdiCompatible,
                        EmfType.EmfPlusDual); // EmfOnly is working with PolyLines with more than 8125 Points, but can not handle transparencies  // EmfPlusDual and EmfPlusOnly: there is no display of polylines with more than 8125 points, although the polyline seems embedded in the EMF. // EmfPlusOnly can not be converted to WMF

                    grfxReference.ReleaseHdc();
                }
            }

            using (var grfxMetafile = Graphics.FromImage(metafile))
            {
                // Set everything to high quality
                grfxMetafile.SmoothingMode      = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
                grfxMetafile.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;

                // 2014-10-10 Setting InterpolationMode to HighQualityBicubic and PixelOffsetMode to HighQuality
                // causes problems when rendering small bitmaps (at a large magnification, for instance the density image legend):
                // the resulting image seems a litte soft, the colors somehow distorted, so I decided not to use them here any more

                //grfxMetafile.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
                //grfxMetafile.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighQuality;

                grfxMetafile.PageUnit  = GraphicsUnit.Pixel;                  // Attention: always use pixels here. Any other choice will cause problems in some programs (see remarks above).
                grfxMetafile.PageScale = (float)(sourceDpiResolution / 72.0); // because our choice of GraphicsUnit is pixels, at the resolution of 72 dpi one point is one pixel. At a higher resolution, one point is more than one pixel.

                grfxMetafile.SetClip(new RectangleF(0, 0, (float)docSize.X, (float)docSize.Y));
                renderingProc(grfxMetafile);
            }
            stream.Flush();

            // we have to patch the resulting metafile stream with the parameters of the graphics and the device

            stream.Position = 0x04;
            var buf4 = new byte[4];

            stream.Read(buf4, 0, 4);
            int headerSize = BitConverter.ToInt32(buf4, 0); // Read the header size to make sure that Metafile header extension 2 is present

            // At position 0x08 there are the bounds of the graphic (not the bounding box, but the box for all the graphical elements)
            stream.Position = 0x08;
            stream.Write(BitConverter.GetBytes(graphicBoundsLeft_Pixels), 0, 4);
            stream.Write(BitConverter.GetBytes(graphicBoundsTop_Pixels), 0, 4);
            stream.Write(BitConverter.GetBytes(graphicBoundsWidth_Pixels), 0, 4);
            stream.Write(BitConverter.GetBytes(graphicBoundsHeight_Pixels), 0, 4);

            // At position 0x48 the device parameters are located: here the number of pixels of the device
            stream.Position = 0x48;
            stream.Write(BitConverter.GetBytes(devicePixelsX), 0, 4);         //  the number of pixels of the device X
            stream.Write(BitConverter.GetBytes(devicePixelsY), 0, 4);         // the number of pixels of the device Y
            stream.Write(BitConverter.GetBytes(deviceSizeXMillimeter), 0, 4); // size X of the device in millimeter
            stream.Write(BitConverter.GetBytes(deviceSizeYMillimeter), 0, 4); // size Y of the device in millimeter

            if (headerSize >= (0x64 + 0x08))
            {
                stream.Position = 0x64;
                stream.Write(BitConverter.GetBytes(deviceSizeXMicrometer), 0, 4); // size X of the device in micrometer
                stream.Write(BitConverter.GetBytes(deviceSizeYMicrometer), 0, 4); // size Y of the device in micrometer
            }

            stream.Flush();

            stream.Position = 0;

            metafile.Dispose(); // we can safely dispose this metafile, because stream and metafile are independent of each other, and only the stream is patched

            return(devicePixelsX, devicePixelsY);
        }
コード例 #13
0
        public override Graphics OnStartPage(PrintDocument document, PrintPageEventArgs e)
        {
            Debug.Assert(dc != null && graphics == null, "PrintController methods called in the wrong order?");

            // For security purposes, don't assume our public methods methods are called in any particular order
            CheckSecurity();

            base.OnStartPage(document, e);


            try {
                IntSecurity.AllPrintingAndUnmanagedCode.Assert();
                if (e.CopySettingsToDevMode)
                {
                    e.PageSettings.CopyToHdevmode(modeHandle);
                }

                Size size = e.PageBounds.Size;

                // Metafile framing rectangles apparently use hundredths of mm as their unit of measurement,
                // instead of the GDI+ standard hundredth of an inch.
                Size metafileSize = PrinterUnitConvert.Convert(size, PrinterUnit.Display, PrinterUnit.HundredthsOfAMillimeter);

                // Create a Metafile which accepts only GDI+ commands since we are the ones creating
                // and using this ...
                // Framework creates a dual-mode EMF for each page in the preview.
                // When these images are displayed in preview,
                // they are added to the dual-mode EMF. However,
                // GDI+ breaks during this process if the image
                // is sufficiently large and has more than 254 colors.
                // This code path can easily be avoided by requesting
                // an EmfPlusOnly EMF..
                Metafile metafile = new Metafile(dc.Hdc, new Rectangle(0, 0, metafileSize.Width, metafileSize.Height), MetafileFrameUnit.GdiCompatible, EmfType.EmfPlusOnly);

                PreviewPageInfo info = new PreviewPageInfo(metafile, size);
                list.Add(info);
                PrintPreviewGraphics printGraphics = new PrintPreviewGraphics(document, e);
                graphics = Graphics.FromImage(metafile);

                if (graphics != null && document.OriginAtMargins)
                {
                    // Adjust the origin of the graphics object to be at the
                    // user-specified margin location
                    //
                    int   dpiX           = UnsafeNativeMethods.GetDeviceCaps(new HandleRef(dc, dc.Hdc), SafeNativeMethods.LOGPIXELSX);
                    int   dpiY           = UnsafeNativeMethods.GetDeviceCaps(new HandleRef(dc, dc.Hdc), SafeNativeMethods.LOGPIXELSY);
                    int   hardMarginX_DU = UnsafeNativeMethods.GetDeviceCaps(new HandleRef(dc, dc.Hdc), SafeNativeMethods.PHYSICALOFFSETX);
                    int   hardMarginY_DU = UnsafeNativeMethods.GetDeviceCaps(new HandleRef(dc, dc.Hdc), SafeNativeMethods.PHYSICALOFFSETY);
                    float hardMarginX    = hardMarginX_DU * 100 / dpiX;
                    float hardMarginY    = hardMarginY_DU * 100 / dpiY;

                    graphics.TranslateTransform(-hardMarginX, -hardMarginY);
                    graphics.TranslateTransform(document.DefaultPageSettings.Margins.Left, document.DefaultPageSettings.Margins.Top);
                }


                graphics.PrintingHelper = printGraphics;


                if (antiAlias)
                {
                    graphics.TextRenderingHint = TextRenderingHint.AntiAlias;
                    graphics.SmoothingMode     = SmoothingMode.AntiAlias;
                }
            }
            finally {
                CodeAccessPermission.RevertAssert();
            }
            return(graphics);
        }
コード例 #14
0
 public void EnumerateMetafile(Metafile metafile, RectangleF destinationRectangle, RectangleF sourceRectangle, GraphicsUnit sourceUnit, System.Drawing.Graphics.EnumerateMetafileProc callback, IntPtr callbackData)
 {
     this.baseGraphics.EnumerateMetafile(metafile, destinationRectangle, sourceRectangle, sourceUnit, callback, callbackData);
 }
コード例 #15
0
        // ** overrides
        /// <summary>
        /// Selects the text or image that will be rendered by the field.
        /// </summary>
        /// <param name="value">Field text.</param>
        /// <param name="img">Field image.</param>
        /// <param name="designTime">Whether we in design time or runtime.</param>
        override protected void GetRenderContent(ref string value, ref Image img, bool designTime)
        {
            // create image
            C1Report parentReport = ParentReport;

            using (Bitmap bmp = new Bitmap(1, 1))
                using (Graphics g = Graphics.FromImage(bmp))
                {
                    //
                    PointF dpi = new PointF(g.DpiX, g.DpiY);

                    // calculate field size in pixels
                    // (based on field size in twips and screen resolution)
                    Rectangle rc = new Rectangle(Point.Empty, GetFieldSizePixels(dpi));

                    // create metafile image (this is the return value)
                    IntPtr hdc = g.GetHdc();
                    // consider the real screen logical dpi (144 in the big fonts mode (150%), and 96 and 120 in 100% and 125% accordingly)
                    // the folowing coefficients will != 1 in the big fonts mode only
                    float kX = dpi.X / GraphicsUtils.RealScreenDpiX;
                    float kY = dpi.Y / GraphicsUtils.RealScreenDpiY;
                    // set clipping area with taking account of the coefficients
                    img = new Metafile(hdc, new RectangleF(0, 0, rc.Width * kX, rc.Height * kY), MetafileFrameUnit.Pixel, this.ParentReport.EmfType);
                    using (Graphics meta = Graphics.FromImage(img))
                    {
                        // some multiples of 90 degrees create spurious lines <<B168>>
                        meta.PageUnit = GraphicsUnit.Pixel;
                        int angle = _angle;
                        while (angle < 0)
                        {
                            angle += 360;
                        }
                        if (angle % 90 == 0)
                        {
                            angle++;
                        }

                        // draw background
                        using (LinearGradientBrush br = new LinearGradientBrush(rc, _clrFrom, _clrTo, angle))
                        {
                            // fill background as usual
                            if (BackColor != Utils.TransparentColor)
                            {
                                // update brush
                                if (_brBack == null || _brBack.Color != Utils.FromWpfColor(BackColor))
                                {
                                    _brBack = new SolidBrush(Utils.FromWpfColor(BackColor));
                                }
                                meta.FillRectangle(_brBack, rc);
                            }

                            // create pen if necessary
                            Pen pen = null;
                            if (BorderColor != Utils.TransparentColor && BorderStyle == BorderStyleEnum.Transparent && LineWidth > 0)
                            {
                                int lineWidth = Math.Max(1, (int)(LineWidth * dpi.X / 1440f));
                                rc.Inflate(-lineWidth / 2, -lineWidth / 2);
                                //rc.Inflate(-1, -1);
                                pen = new Pen(Utils.FromWpfColor(BorderColor), lineWidth);
                            }

                            // draw the background and border
                            rc.Width--;
                            rc.Height--;

                            // calculate corner radius in pixels
                            var cornerRadiusPixel = new CornerRadius(
                                (int)(_cornerRadius.TopLeftX * dpi.X / 1440f),
                                (int)(_cornerRadius.TopLeftY * dpi.Y / 1440f),
                                (int)(_cornerRadius.TopRightX * dpi.X / 1440f),
                                (int)(_cornerRadius.TopRightY * dpi.Y / 1440f),
                                (int)(_cornerRadius.BottomLeftX * dpi.X / 1440f),
                                (int)(_cornerRadius.BottomLeftY * dpi.Y / 1440f),
                                (int)(_cornerRadius.BottomRightX * dpi.X / 1440f),
                                (int)(_cornerRadius.BottomRightY * dpi.Y / 1440f));

                            RoundRect(meta, br, pen, rc, cornerRadiusPixel);

                            // dispose of pen
                            if (pen != null)
                            {
                                pen.Dispose();
                            }
                        }

                        // draw string content
                        if (value != null && value.Length > 0)
                        {
                            // update brush
                            if (_brFore == null || _brFore.Color != Utils.FromWpfColor(ForeColor))
                            {
                                _brFore = new SolidBrush(Utils.FromWpfColor(ForeColor));
                            }

                            // draw string
                            meta.DrawString(value, Font, _brFore, rc, GetStringFormat());
                        }
                    }

                    img = FixMetafile((Metafile)img, hdc, dpi);

                    // done with reference dc
                    g.ReleaseHdc(hdc);
                }
        }
コード例 #16
0
 public void EnumerateMetafile(Metafile metafile, PointF[] destinationPoints, RectangleF sourceRectangle, GraphicsUnit sourceUnit, System.Drawing.Graphics.EnumerateMetafileProc callback)
 {
     this.baseGraphics.EnumerateMetafile(metafile, destinationPoints, sourceRectangle, sourceUnit, callback);
 }
コード例 #17
0
 public void EnumerateMetafile(Metafile metafile, PointF[] destinationPoints, System.Drawing.Graphics.EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttributes)
 {
     this.baseGraphics.EnumerateMetafile(metafile, destinationPoints, callback, callbackData, imageAttributes);
 }
コード例 #18
0
ファイル: EbnfForm.cs プロジェクト: fperezpt/EBNFVisualizer
    private void saveEmf(String path)
    {
        FileStream fs = new FileStream(path,FileMode.Create );
        Graphics g = CreateGraphics();
        IntPtr hDC = g.GetHdc();
        Metafile m = new Metafile( fs, hDC );

        g.ReleaseHdc( hDC );
        g.Dispose();

        Graphics vg= Graphics.FromImage(m);
        Node.drawComponent(currentSymbol, vg);
        vg.Dispose();
        m.Dispose();
        fs.Close();
    }
コード例 #19
0
		protected virtual void ExportToMetafile(FileStream stream, string path)
		{
			Metafile metafile = new Metafile();
			metafile.AddDiagram(this);

			if (stream != null)
			{
				metafile.Save(stream);
			}
			else
			{
				metafile.Save(path);
			}
		}
コード例 #20
0
ファイル: ExRichTextBox.cs プロジェクト: hescano/IRClean
    /// <summary>
    /// Wraps the image in an Enhanced Metafile by drawing the image onto the
    /// graphics context, then converts the Enhanced Metafile to a Windows
    /// Metafile, and finally appends the bits of the Windows Metafile in HEX
    /// to a string and returns the string.
    /// </summary>
    /// <param name="_image"></param>
    /// <returns>
    /// A string containing the bits of a Windows Metafile in HEX
    /// </returns>
    private string GetRtfImage(Image _image)
    {
        StringBuilder _rtf = null;

        // Used to store the enhanced metafile
        MemoryStream _stream = null;

        // Used to create the metafile and draw the image
        Graphics _graphics = null;

        // The enhanced metafile
        Metafile _metaFile = null;

        // Handle to the device context used to create the metafile
        IntPtr _hdc = default(IntPtr);

        try
        {
            _rtf = new StringBuilder();
            _stream = new MemoryStream();

            // Get a graphics context from the RichTextBox
            using (var __graphics = this.CreateGraphics())
            {

                // Get the device context from the graphics context
                _hdc = __graphics.GetHdc();

                // Create a new Enhanced Metafile from the device context
                _metaFile = new Metafile(_stream, _hdc);

                // Release the device context
                __graphics.ReleaseHdc(_hdc);
            }

            // Get a graphics context from the Enhanced Metafile
            using (var __graphics = Graphics.FromImage(_metaFile))
            {

                // Draw the image on the Enhanced Metafile

                __graphics.DrawImage(_image, new Rectangle(0, 0, _image.Width, _image.Height));
            }

            // Get the handle of the Enhanced Metafile
            IntPtr _hEmf = _metaFile.GetHenhmetafile();

            // A call to EmfToWmfBits with a null buffer return the size of the
            // buffer need to store the WMF bits.  Use this to get the buffer
            // size.
            uint _bufferSize = GdipEmfToWmfBits(_hEmf, 0, null, MM_ANISOTROPIC, EmfToWmfBitsFlags.EmfToWmfBitsFlagsDefault);

            // Create an array to hold the bits
            byte[] _buffer = new byte[_bufferSize];

            // A call to EmfToWmfBits with a valid buffer copies the bits into the
            // buffer an returns the number of bits in the WMF.
            uint _convertedSize = GdipEmfToWmfBits(_hEmf, _bufferSize, _buffer, MM_ANISOTROPIC, EmfToWmfBitsFlags.EmfToWmfBitsFlagsDefault);

            // Append the bits to the RTF string
            for (int i = 0; i <= _buffer.Length - 1; i++)
            {
                _rtf.Append(String.Format("{0:X2}", _buffer[i]));
            }

            return _rtf.ToString();
        }
        finally
        {
            if (_graphics != null)
            {
                _graphics.Dispose();
            }
            if (_metaFile != null)
            {
                _metaFile.Dispose();
            }
            if (_stream != null)
            {
                _stream.Close();
            }
        }
    }
コード例 #21
0
 private void DoPrintPage(object sender, PrintPageEventArgs e)
 {
     using (Graphics g = e.Graphics)
     {
         if (mDoc.PageCount == 0)
         {
             return;
         }
         if (mDoc.Page == 0)
         {
             return;
         }
         XRect  cropBox    = mDoc.CropBox;
         double srcWidth   = (cropBox.Width / 72) * 100;
         double srcHeight  = (cropBox.Height / 72) * 100;
         double pageWidth  = e.PageBounds.Width;
         double pageHeight = e.PageBounds.Height;
         double marginX    = e.PageSettings.HardMarginX;
         double marginY    = e.PageSettings.HardMarginY;
         double dstWidth   = pageWidth - (marginX * 2);
         double dstHeight  = pageHeight - (marginY * 2);
         // if source bigger than destination then scale
         if ((srcWidth > dstWidth) || (srcHeight > dstHeight))
         {
             double sx = dstWidth / srcWidth;
             double sy = dstHeight / srcHeight;
             double s  = Math.Min(sx, sy);
             srcWidth  *= s;
             srcHeight *= s;
         }
         // now center
         double x = (pageWidth - srcWidth) / 2;
         double y = (pageHeight - srcHeight) / 2;
         // save state
         RectangleF theRect = new RectangleF((float)x, (float)y, (float)srcWidth, (float)srcHeight);
         int        theRez  = e.PageSettings.PrinterResolution.X;
         // draw content
         mDoc.Rect.SetRect(cropBox);
         mDoc.Rendering.DotsPerInch    = theRez;
         mDoc.Rendering.ColorSpace     = "RGB";
         mDoc.Rendering.BitsPerChannel = 8;
         if (mRenderTextAsPolygon)
         {
             //i.e. render text as polygon (non default)
             mDoc.SetInfo(0, "RenderTextAsText", "0");
         }
         byte[] theData = mDoc.Rendering.GetData(".emf");
         if (mTempFilePath != null)
         {
             File.WriteAllBytes(mTempFilePath + @"\" + mDoc.PageNumber + ".emf", theData);
         }
         using (MemoryStream theStream = new MemoryStream(theData))
         {
             using (Metafile theEMF = new Metafile(theStream))
             {
                 g.DrawImage(theEMF, theRect);
             }
         }
         e.HasMorePages = mDoc.PageNumber < mDoc.PageCount;
         if (!e.HasMorePages)
         {
             return;
         }
         //increment to next page, corrupted PDF's have occasionally failed to increment
         //which would otherwise put us in a spooling infinite loop, which is bad, so this check avoids it
         int oldPageNumber = mDoc.PageNumber;
         ++mDoc.PageNumber;
         int newPageNumber = mDoc.PageNumber;
         if ((oldPageNumber + 1) != newPageNumber)
         {
             throw new Exception("PDF cannot be printed as it is corrupt, pageNumbers will not increment properly.");
         }
     }
 }
コード例 #22
0
        // ** overrides
        /// <summary>
        /// Selects the text or image that will be rendered by the field.
        /// </summary>
        /// <param name="value">Field text.</param>
        /// <param name="img">Field image.</param>
        /// <param name="designTime">Whether we in design time or runtime.</param>
        override protected void GetRenderContent(ref string value, ref Image img, bool designTime)
        {
            // create image
            using (Graphics g = Graphics.FromHwnd(IntPtr.Zero))
            {
                // calculate field size in pixels
                // (based on field size in twips and screen resolution)
                Size      size = GetFieldSizePixels(g);
                Rectangle rc   = new Rectangle(Point.Empty, size);

                // create metafile image (this is the return value)
                IntPtr hdc = g.GetHdc();
                img = new Metafile(hdc, rc, MetafileFrameUnit.Pixel);
                using (Graphics meta = Graphics.FromImage(img))
                {
                    // some multiples of 90 degrees create spurious lines <<B168>>
                    int angle = _angle;
                    while (angle < 0)
                    {
                        angle += 360;
                    }
                    if (angle % 90 == 0)
                    {
                        angle++;
                    }

                    // calculate border radius in pixels
                    int radius = (int)(_radius * 96f / 1440f);

                    // draw background
                    using (LinearGradientBrush br = new LinearGradientBrush(rc, _clrFrom, _clrTo, angle))
                    {
                        // fill background as usual
                        if (BackColor != Utils.TransparentColor)
                        {
                            // update brush
                            if (_brBack == null || _brBack.Color != Utils.FromWpfColor(BackColor))
                            {
                                _brBack = new SolidBrush(Utils.FromWpfColor(BackColor));
                            }
                            meta.FillRectangle(_brBack, rc);
                        }

                        // create pen if necessary
                        Pen pen = null;
                        if (BorderColor != Utils.TransparentColor && BorderStyle == BorderStyleEnum.Transparent && LineWidth > 0)
                        {
                            int lineWidth = Math.Max(1, (int)(LineWidth * 96f / 1440f));
                            rc.Inflate(-lineWidth / 2, -lineWidth / 2);
                            pen = new Pen(Utils.FromWpfColor(BorderColor), lineWidth);
                        }

                        // draw the background and border
                        RoundRect(meta, br, pen, rc, radius, radius);

                        // dispose of pen
                        if (pen != null)
                        {
                            pen.Dispose();
                        }
                    }

                    // draw string content
                    if (value != null && value.Length > 0)
                    {
                        // update brush
                        if (_brFore == null || _brFore.Color != Utils.FromWpfColor(ForeColor))
                        {
                            _brFore = new SolidBrush(Utils.FromWpfColor(ForeColor));
                        }

                        // draw string
                        meta.DrawString(value, Font, _brFore, rc, GetStringFormat());
                    }
                }

                // adjust image size for actual screen resolution
                // (as opposed to 'logical dpi')
                img = AdjustImageSize(hdc, img);

                // done with reference dc
                g.ReleaseHdc(hdc);
            }
        }
コード例 #23
0
ファイル: RtfImage.cs プロジェクト: Akshat122/Texditor
        private static byte[] GetWmfBytes(Bitmap bitmap)
        {
            MemoryStream stream   = null;
            Graphics     graphics = null;
            Metafile     metaFile = null;
            IntPtr       hEmf     = IntPtr.Zero;

            byte[] data = null;

            try
            {
                using (stream = new MemoryStream())
                {
                    using (graphics = Graphics.FromImage(bitmap))
                    {
                        // Get the device context from the graphics context
                        IntPtr hdc = graphics.GetHdc();

                        // Create a new Enhanced Metafile from the device context
                        metaFile = new Metafile(stream, hdc);

                        // Release the device context
                        graphics.ReleaseHdc(hdc);
                    }

                    // Get a graphics context from the Enhanced Metafile
                    using (graphics = Graphics.FromImage(metaFile))
                    {
                        // Draw the image on the Enhanced Metafile
                        graphics.DrawImage(bitmap, new Rectangle(0, 0, bitmap.Width, bitmap.Height));
                    }

                    using (metaFile)
                    {
                        hEmf = metaFile.GetHenhmetafile();

                        uint bufferSize = GdipEmfToWmfBits(hEmf, 0, null, 8, EmfToWmfBitsFlags.Default);

                        data = new byte[bufferSize];

                        GdipEmfToWmfBits(hEmf, bufferSize, data, 8, EmfToWmfBitsFlags.Default);
                    }
                }
            }
            catch
            {
                data = null;
            }
            finally
            {
                if (hEmf != IntPtr.Zero)
                {
                    DeleteEnhMetaFile(hEmf);
                }

                if (stream != null)
                {
                    stream.Flush();
                    stream.Close();
                }

                if (metaFile != null)
                {
                    metaFile.Dispose();
                }

                if (graphics != null)
                {
                    graphics.Dispose();
                }
            }

            return(data);
        }
コード例 #24
0
ファイル: MainForm.cs プロジェクト: matthiaswatkins/trizbort
        private void saveImage(string fileName)
        {
            var format = ImageFormat.Png;
            var ext    = Path.GetExtension(fileName);

            if (StringComparer.InvariantCultureIgnoreCase.Compare(ext, ".jpg") == 0 ||
                StringComparer.InvariantCultureIgnoreCase.Compare(ext, ".jpeg") == 0)
            {
                format = ImageFormat.Jpeg;
            }
            else if (StringComparer.InvariantCultureIgnoreCase.Compare(ext, ".bmp") == 0)
            {
                format = ImageFormat.Bmp;
            }
            else if (StringComparer.InvariantCultureIgnoreCase.Compare(ext, ".emf") == 0)
            {
                format = ImageFormat.Emf;
            }

            var size = Canvas.ComputeCanvasBounds(true).Size *(Settings.SaveAt100 ? 1.0f : Canvas.ZoomFactor);

            size.X = Numeric.Clamp(size.X, 16, 8192);
            size.Y = Numeric.Clamp(size.Y, 16, 8192);

            try
            {
                if (format == ImageFormat.Emf)
                {
                    // export as a metafile
                    using (var nativeGraphics = Graphics.FromHwnd(Canvas.Handle))
                    {
                        using (var stream = new MemoryStream())
                        {
                            try
                            {
                                var dc = nativeGraphics.GetHdc();
                                using (var metafile = new Metafile(stream, dc))
                                {
                                    using (var imageGraphics = Graphics.FromImage(metafile))
                                    {
                                        using (var graphics = XGraphics.FromGraphics(imageGraphics, new XSize(size.X, size.Y)))
                                        {
                                            Canvas.Draw(graphics, true, size.X, size.Y);
                                        }
                                    }
                                    var handle = metafile.GetHenhmetafile();
                                    var copy   = CopyEnhMetaFile(handle, fileName);
                                    DeleteEnhMetaFile(copy);
                                }
                            }
                            finally
                            {
                                nativeGraphics.ReleaseHdc();
                            }
                        }
                    }
                }
                else
                {
                    // export as an image
                    using (var bitmap = new Bitmap((int)Math.Ceiling(size.X), (int)Math.Ceiling(size.Y)))
                    {
                        using (var imageGraphics = Graphics.FromImage(bitmap))
                        {
                            using (var graphics = XGraphics.FromGraphics(imageGraphics, new XSize(size.X, size.Y)))
                            {
                                Canvas.Draw(graphics, true, size.X, size.Y);
                            }
                        }
                        bitmap.Save(fileName, format);
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(Program.MainForm, string.Format("There was a problem exporting the map:\n\n{0}", ex.Message),
                                Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
コード例 #25
0
ファイル: rtf.cs プロジェクト: JohnHartley/argumentative
        /// <summary>
        /// Wraps the image in an Enhanced Metafile by drawing the image onto the
        /// graphics context, then converts the Enhanced Metafile to a Windows
        /// Metafile, and finally appends the bits of the Windows Metafile in HEX
        /// to a string and returns the string.
        /// </summary>
        /// <param name="_image"></param>
        /// <returns>
        /// A string containing the bits of a Windows Metafile in HEX
        /// </returns>
        private string GetRtfImage(Image _image)
        {
            StringBuilder _rtf = null;

            // Used to store the enhanced metafile
            MemoryStream _stream = null;

            // Used to create the metafile and draw the image
            Graphics _graphics = null;

            // The enhanced metafile
            Metafile _metaFile = null;

            // Handle to the device context used to create the metafile
            IntPtr _hdc;

            _graphics = Graphics.FromImage(_image);

            try {
                _rtf    = new StringBuilder();
                _stream = new MemoryStream();

                // Get a graphics context from the RichTextBox
                using (_graphics = Graphics.FromImage(_image)) {                // was created from the inherited richTextBox
                    // Get the device context from the graphics context
                    _hdc = _graphics.GetHdc();

                    // Create a new Enhanced Metafile from the device context
                    _metaFile = new Metafile(_stream, _hdc);

                    // Release the device context
                    _graphics.ReleaseHdc(_hdc);
                }

                // Get a graphics context from the Enhanced Metafile
                using (_graphics = Graphics.FromImage(_metaFile)) {
                    // Draw the image on the Enhanced Metafile
                    _graphics.DrawImage(_image, new Rectangle(0, 0, _image.Width, _image.Height));
                }

                // Get the handle of the Enhanced Metafile
                IntPtr _hEmf = _metaFile.GetHenhmetafile();

                // A call to EmfToWmfBits with a null buffer return the size of the
                // buffer need to store the WMF bits.  Use this to get the buffer
                // size.
                uint _bufferSize = GdipEmfToWmfBits(_hEmf, 0, null, MM_ANISOTROPIC,
                                                    EmfToWmfBitsFlags.EmfToWmfBitsFlagsDefault);

                // Create an array to hold the bits
                byte[] _buffer = new byte[_bufferSize];

                // A call to EmfToWmfBits with a valid buffer copies the bits into the
                // buffer an returns the number of bits in the WMF.
                uint _convertedSize = GdipEmfToWmfBits(_hEmf, _bufferSize, _buffer, MM_ANISOTROPIC,
                                                       EmfToWmfBitsFlags.EmfToWmfBitsFlagsDefault);

                // Append the bits to the RTF string
                for (int i = 0; i < _buffer.Length; ++i)
                {
                    _rtf.Append(String.Format("{0:X2}", _buffer[i]));
                }

                return(_rtf.ToString());
            }
            finally {
                if (_graphics != null)
                {
                    _graphics.Dispose();
                }
                if (_metaFile != null)
                {
                    _metaFile.Dispose();
                }
                if (_stream != null)
                {
                    _stream.Close();
                }
            }
        }
コード例 #26
0
        public bool PrintReport(string printerName, string reportPath, int id, int printID, short paperSize, short copiesCount)
        {
            System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.WaitCursor;
            this.RenderedReport = this.RenderReport(reportPath, id, paperSize);
            if (null == this.RenderedReport)
            {
                return(false);
            }
            try
            {
                // Wait for the report to completely render.
                if (m_numberOfPages < 1)
                {
                    return(false);
                }
                PrintDocument pd = new PrintDocument();
                rs.ItemNamespaceHeaderValue = new RS.ItemNamespaceHeader();
                rs.ItemNamespaceHeaderValue.ItemNamespace = RS.ItemNamespaceEnum.PathBased;
                RS.Property[] properties = rs.GetProperties(reportPath, null);
                pheight = pd.DefaultPageSettings.PaperSize.Height;
                pwidth  = pd.DefaultPageSettings.PaperSize.Width;
                double theight = 0;
                double twidth  = 0;
                ma = new Margins(0, 0, 0, 0);
                bool size = false;
                foreach (RS.Property property in properties)
                {
                    switch (property.Name.ToLower())
                    {
                    case "pageheight":
                        theight = (double.Parse(property.Value) / 0.254);
                        pheight = (int)System.Math.Round(theight);
                        size    = true;
                        break;

                    case "pagewidth":
                        twidth = double.Parse(property.Value) / 0.254;
                        pwidth = (int)System.Math.Round(twidth);
                        size   = true;
                        break;

                    case "topmargin":
                        ma.Top = (int)(double.Parse(property.Value) / 0.254);
                        break;

                    case "bottommargin":
                        ma.Bottom = (int)(double.Parse(property.Value) / 0.254);
                        break;

                    case "rightmargin":
                        ma.Right = (int)(double.Parse(property.Value) / 0.254);
                        break;

                    case "leftmargin":
                        ma.Left = (int)(double.Parse(property.Value) / 0.254);
                        break;
                    }
                    //Console.WriteLine(property.Name + ": " + property.Value);
                }
                Console.WriteLine("{0}: paper change", DateTime.Now.ToString("HH:mm:ss fff"));

                if (!size)
                {
                    if (this.m_currentPageStream != null)
                    {
                        this.m_currentPageStream.Close();
                        this.m_currentPageStream = null;
                    }
                    m_currentPageStream = new MemoryStream(this.m_renderedReport[0]);
                    // Set its postion to start.
                    m_currentPageStream.Position = 0;
                    // Initialize the metafile
                    if (null != m_metafile)
                    {
                        m_metafile.Dispose();
                        m_metafile = null;
                    }
                    // Load the metafile image for this page
                    m_metafile = new Metafile((Stream)m_currentPageStream);
                    pheight    = m_metafile.Height;
                    pwidth     = m_metafile.Width;
                }

                landscape = false;
                if (pwidth > pheight && !pd.DefaultPageSettings.Landscape)
                {
                    landscape = true;
                }

                PrinterSettings printerSettings = new PrinterSettings();
                printerSettings.MaximumPage = m_numberOfPages;
                printerSettings.MinimumPage = 1;
                printerSettings.PrintRange  = PrintRange.SomePages;
                printerSettings.FromPage    = 1;
                printerSettings.ToPage      = m_numberOfPages;
                printerSettings.Copies      = copiesCount;
                m_currentPrintingPage       = 1;
                m_lastPrintingPage          = m_numberOfPages;
                printerSettings.PrinterName = printerName;
                pd.PrinterSettings          = printerSettings;

                if (landscape)
                {
                    if (pd.DefaultPageSettings.PaperSize.Width != pheight || pd.DefaultPageSettings.PaperSize.Height != pwidth)
                    {
                        PaperSize papers = new PaperSize(reportPath, pheight, pwidth);
                        papers.PaperName = "ReportPrintingLandscape";
                        pd.DefaultPageSettings.PaperSize = papers;
                    }
                    pd.DefaultPageSettings.Landscape = true;
                }
                else
                {
                    if (pd.DefaultPageSettings.PaperSize.Width != pwidth || pd.DefaultPageSettings.PaperSize.Height != pheight)
                    {
                        PaperSize papers = new PaperSize(reportPath, pwidth, pheight);
                        papers.PaperName = "ReportPrinting";
                        pd.DefaultPageSettings.PaperSize = papers;
                    }
                    pd.DefaultPageSettings.Landscape = false;
                }

                pd.OriginAtMargins             = true;
                pd.DefaultPageSettings.Margins = ma;
                pd.PrintPage += pd_PrintPage;

                pd.DocumentName = "?docviewprint=" + id.ToString() + "&docviewtypeid=" + printID.ToString() + "&id=" + id.ToString();
                pd.EndPrint    += pd_EndPrint;

                // Print report
                Console.WriteLine("{0}: Printing report...", DateTime.Now.ToString("HH:mm:ss fff"));
                if (pd.PrinterSettings.IsValid)
                {
                    pd.Print();
                }
                else
                {
                    Console.WriteLine("{0}: Encorrect parameters", DateTime.Now.ToString("HH:mm:ss fff"));
                }
                pd.Dispose();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
                // Clean up goes here.
            }
            return(true);
        }
コード例 #27
0
ファイル: SystemMonitor.cs プロジェクト: nogna/Upbot
 /// <summary>
 /// gets the Twitter credentials from XML-file then uploads the message and the image to Twitter.
 /// </summary>
 /// <param name="message"></param>
 private void SendTweet(String message, Metafile image)
 {
     SocialMediaUploader.getTwitterCredentialsFromXML();
     SocialMediaUploader.sendTweet(message, image);
 }
コード例 #28
0
    public static void Print(this LocalReport report, PageSettings pageSettings)
    {
        string deviceInfo =
            $@"<DeviceInfo>
                    <OutputFormat>EMF</OutputFormat>
                    <PageWidth>{pageSettings.PaperSize.Width * 100}in</PageWidth>
                    <PageHeight>{pageSettings.PaperSize.Height * 100}in</PageHeight>
                    <MarginTop>{pageSettings.Margins.Top * 100}in</MarginTop>
                    <MarginLeft>{pageSettings.Margins.Left * 100}in</MarginLeft>
                    <MarginRight>{pageSettings.Margins.Right * 100}in</MarginRight>
                    <MarginBottom>{pageSettings.Margins.Bottom * 100}in</MarginBottom>
                </DeviceInfo>";

        Warning[] warnings;
        var       streams          = new List <Stream>();
        var       currentPageIndex = 0;

        report.Render("Image", deviceInfo,
                      (name, fileNameExtension, encoding, mimeType, willSeek) =>
        {
            var stream = new MemoryStream();
            streams.Add(stream);
            return(stream);
        }, out warnings);

        foreach (Stream stream in streams)
        {
            stream.Position = 0;
        }

        if (streams == null || streams.Count == 0)
        {
            throw new Exception("Error: no stream to print.");
        }

        var printDocument = new PrintDocument();

        printDocument.DefaultPageSettings = pageSettings;
        if (!printDocument.PrinterSettings.IsValid)
        {
            throw new Exception("Error: cannot find the default printer.");
        }
        else
        {
            printDocument.PrintPage += (sender, e) =>
            {
                Metafile  pageImage    = new Metafile(streams[currentPageIndex]);
                Rectangle adjustedRect = new Rectangle(
                    e.PageBounds.Left - (int)e.PageSettings.HardMarginX,
                    e.PageBounds.Top - (int)e.PageSettings.HardMarginY,
                    e.PageBounds.Width,
                    e.PageBounds.Height);
                e.Graphics.FillRectangle(Brushes.White, adjustedRect);
                e.Graphics.DrawImage(pageImage, adjustedRect);
                currentPageIndex++;
                e.HasMorePages = (currentPageIndex < streams.Count);
                e.Graphics.DrawRectangle(Pens.Red, adjustedRect);
            };
            printDocument.EndPrint += (Sender, e) =>
            {
                if (streams != null)
                {
                    foreach (Stream stream in streams)
                    {
                        stream.Close();
                    }
                    streams = null;
                }
            };
            printDocument.Print();
        }
    }
コード例 #29
0
        // Main
        static void Main(string[] args)
        {
            try
            {
                // enable HTML5 etc (assuming we're running IE9+)
                SetFeatureBrowserFeature("FEATURE_BROWSER_EMULATION", 9000);
                // force software rendering
                SetFeatureBrowserFeature("FEATURE_IVIEWOBJECTDRAW_DMLT9_WITH_GDI", 0);
                SetFeatureBrowserFeature("FEATURE_GPU_RENDERING", 0);

                using (var apartment = new MessageLoopApartment())
                {
                    // create WebBrowser on a seprate thread with its own message loop
                    var webBrowser = apartment.Invoke(() => new WebBrowser());

                    // navigate and wait for the result
                    apartment.Invoke(() =>
                    {
                        var pageLoadedTcs             = new TaskCompletionSource <bool>();
                        webBrowser.DocumentCompleted += (s, e) =>
                                                        pageLoadedTcs.TrySetResult(true);

                        webBrowser.DocumentText = HTML;
                        return(pageLoadedTcs.Task);
                    }).Wait();

                    // save the picture
                    apartment.Invoke(() =>
                    {
                        webBrowser.Size = IMAGE_SIZE;
                        var rectangle   = new Rectangle(0, 0, webBrowser.Width, webBrowser.Height);

                        // get reference DC
                        using (var screenGraphics = webBrowser.CreateGraphics())
                        {
                            var screenHdc = screenGraphics.GetHdc();
                            // create a metafile
                            using (var metafile = new Metafile(screenHdc, rectangle, MetafileFrameUnit.Pixel))
                            {
                                using (var graphics = Graphics.FromImage(metafile))
                                {
                                    var hdc  = graphics.GetHdc();
                                    var rect = new Rectangle(0, 0, 320, 50);
                                    OleDraw(webBrowser.ActiveXInstance, DVASPECT_CONTENT, hdc, ref rectangle);
                                    graphics.ReleaseHdc(hdc);
                                }
                                // save the metafile as bitmap
                                metafile.Save(FILE_NAME, ImageFormat.Png);
                            }
                            screenGraphics.ReleaseHdc(screenHdc);
                        }
                    });

                    // dispose of webBrowser
                    apartment.Invoke(() => webBrowser.Dispose());
                    webBrowser = null;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
        }
コード例 #30
0
ファイル: ImageHelper.cs プロジェクト: tomay3000/FastReport
 public static bool SaveAndConvert(Image image, Stream stream, ImageFormat format)
 {
     if (image == null)
     {
         return(false);
     }
     if (format == ImageFormat.Jpeg || format == ImageFormat.Gif ||
         format == ImageFormat.Tiff || format == ImageFormat.Bmp ||
         format == ImageFormat.Png ||
         format == ImageFormat.MemoryBmp)
     {
         if (image is Bitmap)
         {
             if (format == ImageFormat.MemoryBmp)
             {
                 throw new Exception(Res.Get("Export,Image,ImageParceFormatException"));
             }
             image.Save(stream, format);
             return(true);
         }
         //from mf to bitmap
         using (Metafile metafile = image as Metafile)
             using (Bitmap bitmap = new Bitmap(image.Width, image.Height))
             {
                 bitmap.SetResolution(96F, 96F);
                 using (Graphics g = Graphics.FromImage(bitmap))
                 {
                     g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
                     g.DrawImage(metafile, 0, 0, (float)image.Width, (float)image.Height);
                     g.Dispose();
                 }
                 bitmap.Save(stream, format);
             }
         return(true);
     }
     else if (format == ImageFormat.Icon)
     {
         return(SaveAsIcon(image, stream, true));
     }
     else if (format == ImageFormat.Wmf || format == ImageFormat.Emf)
     {
         if (image is Metafile)
         {
             Metafile emf = null;
             using (Bitmap bmp = new Bitmap(1, 1))
                 using (Graphics g = Graphics.FromImage(bmp))
                 {
                     IntPtr hdc = g.GetHdc();
                     emf = new Metafile(stream, hdc);
                     g.ReleaseHdc(hdc);
                 }
             using (Graphics g = Graphics.FromImage(emf))
             {
                 g.DrawImage(image, 0, 0);
             }
             return(true);
         }
     }
     //throw new Exception(Res.Get("Export,Image,ImageParceFormatException")); // we cant convert image to exif or from bitmap to mf
     return(false);
 }
コード例 #31
0
ファイル: CustomChart.cs プロジェクト: loxadim/GEDKeeper
        /* TODO(zsv): Need to find an appropriate icon in the general style
         * for the main toolbar - screenshot capture for windows with charts. */
        public void SaveSnapshot(string fileName)
        {
            string ext = FileHelper.GetFileExtension(fileName);

            ExtSize imageSize = GetImageSize();

            if (ext == ".svg")
            {
                var prevRenderer = fRenderer;
                SetRenderer(new SVGRenderer(fileName, imageSize.Width, imageSize.Height));
                fRenderer.BeginDrawing();
                try {
                    using (var gfx = CreateGraphics()) {
                        fRenderer.SetTarget(gfx);

                        RenderImage(RenderTarget.SVG);
                    }
                } finally {
                    fRenderer.EndDrawing();
                    SetRenderer(prevRenderer);
                }

                return;
            }

            if ((ext == ".bmp" || ext == ".jpg") && imageSize.Width >= 65535)
            {
                AppHost.StdDialogs.ShowError(LangMan.LS(LSID.LSID_TooMuchWidth));
            }
            else
            {
                ImageFormat imFmt = ImageFormat.Png;
                if (ext == ".bmp")
                {
                    imFmt = ImageFormat.Bmp;
                }
                else
                if (ext == ".emf")
                {
                    imFmt = ImageFormat.Emf;
                }
                else
                if (ext == ".png")
                {
                    imFmt = ImageFormat.Png;
                }
                else
                if (ext == ".gif")
                {
                    imFmt = ImageFormat.Gif;
                }
                else
                if (ext == ".jpg")
                {
                    imFmt = ImageFormat.Jpeg;
                }

                Image pic;
                if (Equals(imFmt, ImageFormat.Emf))
                {
                    using (var gfx = CreateGraphics()) {
                        pic = new Metafile(fileName, gfx.GetHdc());
                    }
                }
                else
                {
                    pic = new Bitmap(imageSize.Width, imageSize.Height, PixelFormat.Format24bppRgb);
                }

                try {
                    using (Graphics gfx = Graphics.FromImage(pic)) {
                        fRenderer.SetTarget(gfx);
                        RenderImage(RenderTarget.RasterFile);
                    }

                    pic.Save(fileName, imFmt);
                } finally {
                    pic.Dispose();
                }
            }
        }
コード例 #32
0
ファイル: MetafileTest.cs プロジェクト: zzwwqqq/mono
 public void Static_GetMetafileHeader_Stream_Null()
 {
     Assert.Throws <NullReferenceException> (() => Metafile.GetMetafileHeader((Stream)null));
 }
コード例 #33
0
ファイル: EmfHelper.cs プロジェクト: starry-au/vixen-modules
 /// <summary>
 /// Copies the given <see cref="T:System.Drawing.Imaging.MetaFile" /> to the clipboard.
 /// The given <see cref="T:System.Drawing.Imaging.MetaFile" /> is set to an invalid state inside this function.
 /// </summary>
 static public bool PutEnhMetafileOnClipboard(IntPtr hWnd, Metafile metafile)
 {
     return(PutEnhMetafileOnClipboard(hWnd, metafile, true));
 }
コード例 #34
0
ファイル: MetafileTest.cs プロジェクト: zzwwqqq/mono
 public void Static_GetMetafileHeader_Filename_Null()
 {
     Assert.Throws <ArgumentNullException> (() => Metafile.GetMetafileHeader((string)null));
 }
コード例 #35
0
        protected virtual void doc_PrintPage(object sender, PrintPageEventArgs e)
        {
            //如果允许分页,则打印每一页,否则则打印当前页
            if (_baseDoc.PagerSetting.AllowPage)
            {
                _baseDoc.PageIndexChanged(_baseDoc.PagerSetting.PagerDesc[_pageIndex].PageIndex,
                                          _baseDoc.PagerSetting.PagerDesc[_pageIndex].IsMain,
                                          _baseDoc.DataSource);
            }

            //创建 metafile
            _printMetafile = GetPageMetafile();
            //_printMetafile.Save(@"D:\printMetafile0.emf");
            //调整边距
            Rectangle rect = new Rectangle(0, 0, _printMetafile.Width, _printMetafile.Height);

            double widthZoom  = 1;
            double heightZoom = 1;

            double widthSize  = (e.MarginBounds.Width);
            double heightSize = (e.MarginBounds.Height);

            if (widthSize < rect.Width)
            {
                widthZoom = widthSize / rect.Width;
            }
            //纵轴缩小
            if (heightSize < rect.Height)
            {
                heightZoom = heightSize / rect.Height;
            }
            double    zoom     = (widthZoom < heightZoom) ? widthZoom : heightZoom;
            Rectangle zoomRect = new Rectangle(rect.X, rect.Y, (int)(rect.Width * zoom), (int)(rect.Height * zoom));

            MemoryStream mStream   = new MemoryStream();
            Graphics     ggggg     = _baseDoc.CreateGraphics();
            IntPtr       ipHdctemp = ggggg.GetHdc();
            Metafile     mf        = new Metafile(mStream, ipHdctemp);

            ggggg.ReleaseHdc(ipHdctemp);
            ggggg.Dispose();
            Graphics gMf = Graphics.FromImage(mf);

            gMf.DrawImage(_printMetafile, zoomRect);
            gMf.Save();
            gMf.Dispose();
            _printMetafile = mf;
            //_printMetafile.Save(@"D:\printMetafile1.emf");
            metafileDelegate = new Graphics.EnumerateMetafileProc(MetafileCallback);

            //开始正式打印
            PrintPage(_printMetafile, e, zoomRect.Width, zoomRect.Height);
            metafileDelegate = null;

            _pageIndex++;

            if (_pageFromHeight)
            {
                Rectangle r = GetPrintRect();
                if ((_pageIndex) * _pagePrintHeight < r.Height)
                {
                    e.HasMorePages = true;
                }
            }
            else
            {
                if (_baseDoc.PagerSetting.AllowPage && _pageIndex < _baseDoc.PagerSetting.TotalPageCount)
                {
                    e.HasMorePages = true;
                }
                else
                {
                    _pageIndex = 0;
                }
            }
        }
コード例 #36
0
ファイル: MetafileTest.cs プロジェクト: zzwwqqq/mono
 public void Static_GetMetafileHeader_IntPtr_Zero()
 {
     Assert.Throws <ArgumentException> (() => Metafile.GetMetafileHeader(IntPtr.Zero));
 }
コード例 #37
0
        /// <summary>转换源文件为目标文件</summary>
        public override bool Execute(string sourceFile, string destFile, Size size)
        {
            var meta = new Metafile(sourceFile);

            return(base.Execute(meta, sourceFile, destFile, size));
        }
コード例 #38
0
ファイル: MetafileTest.cs プロジェクト: zzwwqqq/mono
 public void Metafile_String()
 {
     string   filename = WmfPlaceable;
     Metafile mf       = new Metafile(filename);
     Metafile clone    = (Metafile)mf.Clone();
 }