zoukankan      html  css  js  c++  java
  • ZedGraph 柱状图、饼图、折线图演示源码

    1. //
    2. //This library is free software; you can redistribute it and/or
    3. //modify it under the terms of the GNU Lesser General Public
    4. //License as published by the Free Software Foundation; either
    5. //version 2.1 of the License, or (at your option) any later version.
    6. //
    7. //This library is distributed in the hope that it will be useful,
    8. //but WITHOUT ANY WARRANTY; without even the implied warranty of
    9. //MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    10. //Lesser General Public License for more details.
    11. //
    12. //You should have received a copy of the GNU Lesser General Public
    13. //License along with this library; if not, write to the Free Software
    14. //Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
    15. //=============================================================================
    16.  
    17. using System;
    18. using System.ComponentModel;
    19. using System.Drawing;
    20. using System.Drawing.Drawing2D;
    21. using System.Drawing.Text;
    22. using System.Windows.Forms;
    23. using System.Threading;
    24. using System.Drawing.Imaging;
    25. using System.IO;
    26. using System.Text;
    27.  
    28. using System.Runtime.InteropServices;
    29. //using System.Diagnostics;
    30.  
    31. namespace ZedGraph
    32. {
    33.     partial class ZedGraphControl
    34.     {
    35.  
    36.     #region ContextMenu
    37.  
    38.         // Revision: JCarpenter 10/06
    39.         /// <summary>
    40.         /// Public enumeration that specifies the type of
    41.         /// object present at the Context Menu's mouse location
    42.         /// </summary>
    43.         public enum ContextMenuObjectState
    44.         {
    45.             /// <summary>
    46.             /// The object is an Inactive Curve Item at the Context Menu's mouse position
    47.             /// </summary>
    48.             InactiveSelection,
    49.             /// <summary>
    50.             /// The object is an active Curve Item at the Context Menu's mouse position
    51.             /// </summary>
    52.             ActiveSelection,
    53.             /// <summary>
    54.             /// There is no selectable object present at the Context Menu's mouse position
    55.             /// </summary>
    56.             Background
    57.         }
    58.  
    59.         //Revision: JCarpenter 10/06
    60.         /// <summary>
    61.         /// Find the object currently under the mouse cursor, and return its state.
    62.         /// </summary>
    63.         private ContextMenuObjectState GetObjectState()
    64.         {
    65.             ContextMenuObjectState objState = ContextMenuObjectState.Background;
    66.  
    67.             // Determine object state
    68.             Point mousePt = this.PointToClient( Control.MousePosition );
    69.             int iPt;
    70.             GraphPane pane;
    71.             object nearestObj;
    72.  
    73.             using ( Graphics g = this.CreateGraphics() )
    74.             {
    75.                 if ( this.MasterPane.FindNearestPaneObject( mousePt, g, out pane,
    76.                         out nearestObj, out iPt ) )
    77.                 {
    78.                     CurveItem item = nearestObj as CurveItem;
    79.  
    80.                     if ( item != null && iPt >= 0 )
    81.                     {
    82.                         if ( item.IsSelected )
    83.                             objState = ContextMenuObjectState.ActiveSelection;
    84.                         else
    85.                             objState = ContextMenuObjectState.InactiveSelection;
    86.                     }
    87.                 }
    88.             }
    89.  
    90.             return objState;
    91.         }
    92.  
    93.         /// <summary>
    94.         /// protected method to handle the popup context menu in the <see cref="ZedGraphControl"/>.
    95.         /// </summary>
    96.         /// <param name="sender"></param>
    97.         /// <param name="e"></param>
    98.         private void contextMenuStrip1_Opening( object sender, CancelEventArgs e )
    99.         {
    100.             // disable context menu by default
    101.             e.Cancel = true;
    102.             ContextMenuStrip menuStrip = sender as ContextMenuStrip;
    103.  
    104.             //Revision: JCarpenter 10/06
    105.             ContextMenuObjectState objState = GetObjectState();
    106.  
    107.             if ( _masterPane != null && menuStrip != null )
    108.             {
    109.                 menuStrip.Items.Clear();
    110.  
    111.                 _isZooming = false;
    112.                 _isPanning = false;
    113.                 Cursor.Current = Cursors.Default;
    114.  
    115.                 _menuClickPt = this.PointToClient( Control.MousePosition );
    116.                 GraphPane pane = _masterPane.FindPane( _menuClickPt );
    117.  
    118.                 if ( _isShowContextMenu )
    119.                 {
    120.                     string menuStr = string.Empty;
    121.  
    122.                     ToolStripMenuItem item = new ToolStripMenuItem();
    123.                     item.Name = "copy";
    124.                     item.Tag = "copy";
    125.                     item.Text = _resourceManager.GetString( "copy" );
    126.                     item.Click += new System.EventHandler( this.MenuClick_Copy );
    127.                     menuStrip.Items.Add( item );
    128.  
    129.                     item = new ToolStripMenuItem();
    130.                     item.Name = "save_as";
    131.                     item.Tag = "save_as";
    132.                     item.Text = _resourceManager.GetString( "save_as" );
    133.                     item.Click += new System.EventHandler( this.MenuClick_SaveAs );
    134.                     menuStrip.Items.Add( item );
    135.  
    136.                     item = new ToolStripMenuItem();
    137.                     item.Name = "page_setup";
    138.                     item.Tag = "page_setup";
    139.                     item.Text = _resourceManager.GetString( "page_setup" );
    140.                     item.Click += new System.EventHandler( this.MenuClick_PageSetup );
    141.                     menuStrip.Items.Add( item );
    142.  
    143.                     item = new ToolStripMenuItem();
    144.                     item.Name = "print";
    145.                     item.Tag = "print";
    146.                     item.Text = _resourceManager.GetString( "print" );
    147.                     item.Click += new System.EventHandler( this.MenuClick_Print );
    148.                     menuStrip.Items.Add( item );
    149.  
    150.                     item = new ToolStripMenuItem();
    151.                     item.Name = "show_val";
    152.                     item.Tag = "show_val";
    153.                     item.Text = _resourceManager.GetString( "show_val" );
    154.                     item.Click += new System.EventHandler( this.MenuClick_ShowValues );
    155.                     item.Checked = this.IsShowPointValues;
    156.                     menuStrip.Items.Add( item );
    157.  
    158.                     item = new ToolStripMenuItem();
    159.                     item.Name = "unzoom";
    160.                     item.Tag = "unzoom";
    161.  
    162.                     if ( pane == null || pane.ZoomStack.IsEmpty )
    163.                         menuStr = _resourceManager.GetString( "unzoom" );
    164.                     else
    165.                     {
    166.                         switch ( pane.ZoomStack.Top.Type )
    167.                         {
    168.                             case ZoomState.StateType.Zoom:
    169.                             case ZoomState.StateType.WheelZoom:
    170.                                 menuStr = _resourceManager.GetString( "unzoom" );
    171.                                 break;
    172.                             case ZoomState.StateType.Pan:
    173.                                 menuStr = _resourceManager.GetString( "unpan" );
    174.                                 break;
    175.                             case ZoomState.StateType.Scroll:
    176.                                 menuStr = _resourceManager.GetString( "unscroll" );
    177.                                 break;
    178.                         }
    179.                     }
    180.  
    181.                     //menuItem.Text = "Un-" + ( ( pane == null || pane.zoomStack.IsEmpty ) ?
    182.                     //  "Zoom" : pane.zoomStack.Top.TypeString );
    183.                     item.Text = menuStr;
    184.                     item.Click += new EventHandler( this.MenuClick_ZoomOut );
    185.                     if ( pane == null || pane.ZoomStack.IsEmpty )
    186.                         item.Enabled = false;
    187.                     menuStrip.Items.Add( item );
    188.  
    189.                     item = new ToolStripMenuItem();
    190.                     item.Name = "undo_all";
    191.                     item.Tag = "undo_all";
    192.                     menuStr = _resourceManager.GetString( "undo_all" );
    193.                     item.Text = menuStr;
    194.                     item.Click += new EventHandler( this.MenuClick_ZoomOutAll );
    195.                     if ( pane == null || pane.ZoomStack.IsEmpty )
    196.                         item.Enabled = false;
    197.                     menuStrip.Items.Add( item );
    198.  
    199.                     item = new ToolStripMenuItem();
    200.                     item.Name = "set_default";
    201.                     item.Tag = "set_default";
    202.                     menuStr = _resourceManager.GetString( "set_default" );
    203.                     item.Text = menuStr;
    204.                     item.Click += new EventHandler( this.MenuClick_RestoreScale );
    205.                     if ( pane == null )
    206.                         item.Enabled = false;
    207.                     menuStrip.Items.Add( item );
    208.  
    209.                     // if e.Cancel is set to false, the context menu does not display
    210.                     // it is initially set to false because the context menu has no items
    211.                     e.Cancel = false;
    212.  
    213.                     // Provide Callback for User to edit the context menu
    214.                     //Revision: JCarpenter 10/06 - add ContextMenuObjectState objState
    215.                     if ( this.ContextMenuBuilder != null )
    216.                         this.ContextMenuBuilder( this, menuStrip, _menuClickPt, objState );
    217.                 }
    218.             }
    219.         }
    220.  
    221.         /// <summary>
    222.         /// Handler for the "Copy" context menu item.  Copies the current image to a bitmap on the
    223.         /// clipboard.
    224.         /// </summary>
    225.         /// <param name="sender"></param>
    226.         /// <param name="e"></param>
    227.         protected void MenuClick_Copy( System.Object sender, System.EventArgs e )
    228.         {
    229.             Copy( _isShowCopyMessage );
    230.         }
    231.  
    232.         /// <summary>
    233.         /// Handler for the "Copy" context menu item.  Copies the current image to a bitmap on the
    234.         /// clipboard.
    235.         /// </summary>
    236.         /// <param name="isShowMessage">boolean value that determines whether or not a prompt will be
    237.         /// displayed.  true to show a message of "Image Copied to ClipBoard".</param>
    238.         public void Copy( bool isShowMessage )
    239.         {
    240.             if ( _masterPane != null )
    241.             {
    242.                 //Clipboard.SetDataObject( _masterPane.GetImage(), true );
    243.  
    244.                 // Threaded copy mode to avoid crash with MTA
    245.                 // Contributed by Dave Moor
    246.                 Thread ct = new Thread( new ThreadStart( this.ClipboardCopyThread ) );
    247.                 //ct.ApartmentState = ApartmentState.STA;
    248.                 ct.SetApartmentState( ApartmentState.STA );
    249.                 ct.Start();
    250.                 ct.Join();
    251.  
    252.                 if ( isShowMessage )
    253.                 {
    254.                     string str = _resourceManager.GetString( "copied_to_clip" );
    255.                     //MessageBox.Show( "Image Copied to ClipBoard" );
    256.                     MessageBox.Show( str );
    257.                 }
    258.             }
    259.         }
    260.  
    261.         /// <summary>
    262.         /// A threaded version of the copy method to avoid crash with MTA
    263.         /// </summary>
    264.         private void ClipboardCopyThread()
    265.         {
    266.             Clipboard.SetDataObject( ImageRender(), true );
    267.         }
    268.  
    269.         //
    270.         /// <summary>
    271.         /// Setup for creation of a new image, applying appropriate anti-alias properties and
    272.         /// returning the resultant image file
    273.         /// </summary>
    274.         /// <returns></returns>
    275.         private Image ImageRender()
    276.         {
    277.             return _masterPane.GetImage( _masterPane.IsAntiAlias );
    278.         }
    279.  
    280.         /// <summary>
    281.         /// Special handler that copies the current image to an Emf file on the clipboard.
    282.         /// </summary>
    283.         /// <remarks>This version is similar to the regular <see cref="Copy" /> method, except that
    284.         /// it will place an Emf image (vector) on the ClipBoard instead of the regular bitmap.</remarks>
    285.         /// <param name="isShowMessage">boolean value that determines whether or not a prompt will be
    286.         /// displayed.  true to show a message of "Image Copied to ClipBoard".</param>
    287.         public void CopyEmf(bool isShowMessage)
    288.         {
    289.             if (_masterPane != null)
    290.             {
    291.                 // Threaded copy mode to avoid crash with MTA
    292.                 // Contributed by Dave Moor
    293.                 Thread ct = new Thread(new ThreadStart(this.ClipboardCopyThreadEmf));
    294.                 //ct.ApartmentState = ApartmentState.STA;
    295.                 ct.SetApartmentState(ApartmentState.STA);
    296.                 ct.Start();
    297.                 ct.Join();
    298.  
    299.                 if (isShowMessage)
    300.                 {
    301.                     string str = _resourceManager.GetString("copied_to_clip");
    302.                     MessageBox.Show(str);
    303.                 }
    304.             }
    305.         }
    306.  
    307.         /// <summary>
    308.         /// A threaded version of the copy method to avoid crash with MTA
    309.         /// </summary>
    310.         private void ClipboardCopyThreadEmf()
    311.         {
    312.             using (Graphics g = this.CreateGraphics())
    313.             {
    314.                 IntPtr hdc = g.GetHdc();
    315.                 Metafile metaFile = new Metafile(hdc, EmfType.EmfPlusOnly);
    316.                 g.ReleaseHdc(hdc);
    317.  
    318.                 using (Graphics gMeta = Graphics.FromImage(metaFile))
    319.                 {
    320.                     this._masterPane.Draw( gMeta );
    321.                 }
    322.  
    323.                 //IntPtr hMeta = metaFile.GetHenhmetafile();
    324.                 ClipboardMetafileHelper.PutEnhMetafileOnClipboard( this.Handle, metaFile );
    325.                 //System.Windows.Forms.Clipboard.SetDataObject(hMeta, true);
    326.  
    327.                 //g.Dispose();
    328.             }
    329.         }
    330.  
    331.         /// <summary>
    332.         /// Handler for the "Save Image As" context menu item.  Copies the current image to the selected
    333.         /// file.
    334.         /// </summary>
    335.         /// <param name="sender"></param>
    336.         /// <param name="e"></param>
    337.         protected void MenuClick_SaveAs( System.Object sender, System.EventArgs e )
    338.         {
    339.             SaveAs();
    340.         }
    341.  
    342.         /// <summary>
    343.         /// Handler for the "Save Image As" context menu item.  Copies the current image to the selected
    344.         /// file in either the Emf (vector), or a variety of Bitmap formats.
    345.         /// </summary>
    346.         /// <remarks>
    347.         /// Note that <see cref="SaveAsBitmap" /> and <see cref="SaveAsEmf" /> methods are provided
    348.         /// which allow for Bitmap-only or Emf-only handling of the "Save As" context menu item.
    349.         /// </remarks>
    350.         public void SaveAs()
    351.         {
    352.             SaveAs( null );
    353.         }
    354.  
    355.         /// <summary>
    356.         /// Copies the current image to the selected file in 
    357.         /// Emf (vector), or a variety of Bitmap formats.
    358.         /// </summary>
    359.         /// <param name="DefaultFileName">
    360.         /// Accepts a default file name for the file dialog (if "" or null, default is not used)
    361.         /// </param>
    362.         /// <returns>
    363.         /// The file name saved, or "" if cancelled.
    364.         /// </returns>
    365.         /// <remarks>
    366.         /// Note that <see cref="SaveAsBitmap" /> and <see cref="SaveAsEmf" /> methods are provided
    367.         /// which allow for Bitmap-only or Emf-only handling of the "Save As" context menu item.
    368.         /// </remarks>
    369.         public String SaveAs( String DefaultFileName )
    370.         {
    371.             if ( _masterPane != null )
    372.             {
    373.                 _saveFileDialog.Filter =
    374.                     "Emf Format (*.emf)|*.emf|" +
    375.                     "PNG Format (*.png)|*.png|" +
    376.                     "Gif Format (*.gif)|*.gif|" +
    377.                     "Jpeg Format (*.jpg)|*.jpg|" +
    378.                     "Tiff Format (*.tif)|*.tif|" +
    379.                     "Bmp Format (*.bmp)|*.bmp";
    380.  
    381.                 if ( DefaultFileName != null && DefaultFileName.Length > 0 )
    382.                 {
    383.                     String ext = System.IO.Path.GetExtension( DefaultFileName ).ToLower();
    384.                     switch (ext)
    385.                     {
    386.                         case ".emf": _saveFileDialog.FilterIndex = 1; break;
    387.                         case ".png": _saveFileDialog.FilterIndex = 2; break;
    388.                         case ".gif": _saveFileDialog.FilterIndex = 3; break;
    389.                         case ".jpeg":
    390.                         case ".jpg": _saveFileDialog.FilterIndex = 4; break;
    391.                         case ".tiff":
    392.                         case ".tif": _saveFileDialog.FilterIndex = 5; break;
    393.                         case ".bmp": _saveFileDialog.FilterIndex = 6; break;
    394.                     }
    395.                     //If we were passed a file name, not just an extension, use it
    396.                     if ( DefaultFileName.Length > ext.Length )
    397.                     {
    398.                         _saveFileDialog.FileName = DefaultFileName;
    399.                     }
    400.                 }
    401.  
    402.                 if ( _saveFileDialog.ShowDialog() == DialogResult.OK )
    403.                 {
    404.                     Stream myStream = _saveFileDialog.OpenFile();
    405.                     if ( myStream != null )
    406.                     {
    407.                         if ( _saveFileDialog.FilterIndex == 1 )
    408.                         {
    409.                             myStream.Close();
    410.                             SaveEmfFile( _saveFileDialog.FileName );
    411.                         }
    412.                         else
    413.                         {
    414.                             ImageFormat format = ImageFormat.Png;
    415.                             switch (_saveFileDialog.FilterIndex)
    416.                             {
    417.                                 case 2: format = ImageFormat.Png; break;
    418.                                 case 3: format = ImageFormat.Gif; break;
    419.                                 case 4: format = ImageFormat.Jpeg; break;
    420.                                 case 5: format = ImageFormat.Tiff; break;
    421.                                 case 6: format = ImageFormat.Bmp; break;
    422.                             }
    423.  
    424.                             ImageRender().Save( myStream, format );
    425.                             //_masterPane.GetImage().Save( myStream, format );
    426.                             myStream.Close();
    427.                         }
    428.                         return _saveFileDialog.FileName;
    429.                     }
    430.                 }
    431.             }
    432.             return "";
    433.         }
    434.  
    435.         /// <summary>
    436.         /// Handler for the "Save Image As" context menu item.  Copies the current image to the selected
    437.         /// Bitmap file.
    438.         /// </summary>
    439.         /// <remarks>
    440.         /// Note that this handler saves as a bitmap only.  The default handler is
    441.         /// <see cref="SaveAs()" />, which allows for Bitmap or EMF formats
    442.         /// </remarks>
    443.         public void SaveAsBitmap()
    444.         {
    445.             if ( _masterPane != null )
    446.             {
    447.                 _saveFileDialog.Filter =
    448.                     "PNG Format (*.png)|*.png|" +
    449.                     "Gif Format (*.gif)|*.gif|" +
    450.                     "Jpeg Format (*.jpg)|*.jpg|" +
    451.                     "Tiff Format (*.tif)|*.tif|" +
    452.                     "Bmp Format (*.bmp)|*.bmp";
    453.  
    454.                 if ( _saveFileDialog.ShowDialog() == DialogResult.OK )
    455.                 {
    456.                     ImageFormat format = ImageFormat.Png;
    457.                     if ( _saveFileDialog.FilterIndex == 2 )
    458.                         format = ImageFormat.Gif;
    459.                     else if ( _saveFileDialog.FilterIndex == 3 )
    460.                         format = ImageFormat.Jpeg;
    461.                     else if ( _saveFileDialog.FilterIndex == 4 )
    462.                         format = ImageFormat.Tiff;
    463.                     else if ( _saveFileDialog.FilterIndex == 5 )
    464.                         format = ImageFormat.Bmp;
    465.  
    466.                     Stream myStream = _saveFileDialog.OpenFile();
    467.                     if ( myStream != null )
    468.                     {
    469.                         //_masterPane.GetImage().Save( myStream, format );
    470.                         ImageRender().Save( myStream, format );
    471.                         myStream.Close();
    472.                     }
    473.                 }
    474.             }
    475.         }
    476.  
    477.         /// <summary>
    478.         /// Handler for the "Save Image As" context menu item.  Copies the current image to the selected
    479.         /// Emf format file.
    480.         /// </summary>
    481.         /// <remarks>
    482.         /// Note that this handler saves as an Emf format only.  The default handler is
    483.         /// <see cref="SaveAs()" />, which allows for Bitmap or EMF formats.
    484.         /// </remarks>
    485.         public void SaveAsEmf()
    486.         {
    487.             if ( _masterPane != null )
    488.             {
    489.                 _saveFileDialog.Filter = "Emf Format (*.emf)|*.emf";
    490.  
    491.                 if ( _saveFileDialog.ShowDialog() == DialogResult.OK )
    492.                 {
    493.                     Stream myStream = _saveFileDialog.OpenFile();
    494.                     if ( myStream != null )
    495.                     {
    496.                         myStream.Close();
    497.                         //_masterPane.GetMetafile().Save( _saveFileDialog.FileName );
    498.                         SaveEmfFile(_saveFileDialog.FileName);
    499.                     }
    500.                 }
    501.             }
    502.         }
    503.  
    504.         /// <summary>
    505.         /// Save the current Graph to the specified filename in EMF (vector) format.
    506.         /// See <see cref="SaveAsEmf()" /> for public access.
    507.         /// </summary>
    508.         /// <remarks>
    509.         /// Note that this handler saves as an Emf format only.  The default handler is
    510.         /// <see cref="SaveAs()" />, which allows for Bitmap or EMF formats.
    511.         /// </remarks>
    512.         internal void SaveEmfFile( string fileName )
    513.         {
    514.             using (Graphics g = this.CreateGraphics())
    515.             {
    516.                 IntPtr hdc = g.GetHdc();
    517.                 Metafile metaFile = new Metafile(hdc, EmfType.EmfPlusOnly);
    518.                 using (Graphics gMeta = Graphics.FromImage(metaFile))
    519.                 {
    520.                     //PaneBase.SetAntiAliasMode( gMeta, IsAntiAlias );
    521.                     //gMeta.CompositingMode = CompositingMode.SourceCopy;
    522.                     //gMeta.CompositingQuality = CompositingQuality.HighQuality;
    523.                     //gMeta.InterpolationMode = InterpolationMode.HighQualityBicubic;
    524.                     //gMeta.SmoothingMode = SmoothingMode.AntiAlias;
    525.                     //gMeta.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
    526.                     this._masterPane.Draw(gMeta);
    527.                     //gMeta.Dispose();
    528.                 }
    529.  
    530.                 ClipboardMetafileHelper.SaveEnhMetafileToFile(metaFile, fileName );
    531.  
    532.                 g.ReleaseHdc(hdc);
    533.                 //g.Dispose();
    534.             }
    535.  
    536.         }
    537.  
    538.         internal class ClipboardMetafileHelper
    539.         {
    540.             [DllImport("user32.dll")]
    541.             static extern bool OpenClipboard(IntPtr hWndNewOwner);
    542.             [DllImport("user32.dll")]
    543.             static extern bool EmptyClipboard();
    544.             [DllImport("user32.dll")]
    545.             static extern IntPtr SetClipboardData(uint uFormat, IntPtr hMem);
    546.             [DllImport("user32.dll")]
    547.             static extern bool CloseClipboard();
    548.             [DllImport("gdi32.dll")]
    549.             static extern IntPtr CopyEnhMetaFile(IntPtr hemfSrc, System.Text.StringBuilder hNULL);
    550.             [DllImport("gdi32.dll")]
    551.             static extern bool DeleteEnhMetaFile(IntPtr hemf);
    552.  
    553.             static internal bool SaveEnhMetafileToFile( Metafile mf, string fileName )
    554.             {
    555.                 bool bResult = false;
    556.                 IntPtr hEMF;
    557.                 hEMF = mf.GetHenhmetafile(); // invalidates mf
    558.                 if (!hEMF.Equals(new IntPtr(0)))
    559.                 {
    560.                     StringBuilder tempName = new StringBuilder(fileName);
    561.                     CopyEnhMetaFile(hEMF, tempName);
    562.                     DeleteEnhMetaFile(hEMF);
    563.                 }
    564.                 return bResult;
    565.             }
    566.  
    567.             static internal bool SaveEnhMetafileToFile(Metafile mf)
    568.             {
    569.                 bool bResult = false;
    570.                 IntPtr hEMF;
    571.                 hEMF = mf.GetHenhmetafile(); // invalidates mf
    572.                 if (!hEMF.Equals(new IntPtr(0)))
    573.                 {
    574.                     SaveFileDialog sfd = new SaveFileDialog();
    575.                     sfd.Filter = "Extended Metafile (*.emf)|*.emf";
    576.                     sfd.DefaultExt = ".emf";
    577.                     if (sfd.ShowDialog() == DialogResult.OK)
    578.                     {
    579.                         StringBuilder temp = new StringBuilder(sfd.FileName);
    580.                         CopyEnhMetaFile(hEMF, temp);
    581.                     }
    582.                     DeleteEnhMetaFile(hEMF);
    583.                 }
    584.                 return bResult;
    585.             }
    586.  
    587.             // Metafile mf is set to a state that is not valid inside this function.
    588.             static internal bool PutEnhMetafileOnClipboard(IntPtr hWnd, Metafile mf)
    589.             {
    590.                 bool bResult = false;
    591.                 IntPtr hEMF, hEMF2;
    592.                 hEMF = mf.GetHenhmetafile(); // invalidates mf
    593.                 if (!hEMF.Equals(new IntPtr(0)))
    594.                 {
    595.                     hEMF2 = CopyEnhMetaFile(hEMF, null);
    596.                     if (!hEMF2.Equals(new IntPtr(0)))
    597.                     {
    598.                         if (OpenClipboard(hWnd))
    599.                         {
    600.                             if (EmptyClipboard())
    601.                             {
    602.                                 IntPtr hRes = SetClipboardData(14 /*CF_ENHMETAFILE*/, hEMF2);
    603.                                 bResult = hRes.Equals(hEMF2);
    604.                                 CloseClipboard();
    605.                             }
    606.                         }
    607.                     }
    608.                     DeleteEnhMetaFile(hEMF);
    609.                 }
    610.                 return bResult;
    611.             }
    612.         }
    613.  
    614.         /// <summary>
    615.         /// Handler for the "Show Values" context menu item.  Toggles the <see cref="IsShowPointValues"/>
    616.         /// property, which activates the point value tooltips.
    617.         /// </summary>
    618.         /// <param name="sender"></param>
    619.         /// <param name="e"></param>
    620.         protected void MenuClick_ShowValues( object sender, System.EventArgs e )
    621.         {
    622.             ToolStripMenuItem item = sender as ToolStripMenuItem;
    623.             if ( item != null )
    624.                 this.IsShowPointValues = !item.Checked;
    625.         }
    626.  
    627.         /// <summary>
    628.         /// Handler for the "Set Scale to Default" context menu item.  Sets the scale ranging to
    629.         /// full auto mode for all axes.
    630.         /// </summary>
    631.         /// <remarks>
    632.         /// This method differs from the <see cref="ZoomOutAll" /> method in that it sets the scales
    633.         /// to full auto mode.  The <see cref="ZoomOutAll" /> method sets the scales to their initial
    634.         /// setting prior to any user actions (which may or may not be full auto mode).
    635.         /// </remarks>
    636.         /// <param name="sender"></param>
    637.         /// <param name="e"></param>
    638.         protected void MenuClick_RestoreScale( object sender, EventArgs e )
    639.         {
    640.             if ( _masterPane != null )
    641.             {
    642.                 GraphPane pane = _masterPane.FindPane( _menuClickPt );
    643.                 RestoreScale( pane );
    644.             }
    645.         }
    646.  
    647.         /// <summary>
    648.         /// Handler for the "Set Scale to Default" context menu item.  Sets the scale ranging to
    649.         /// full auto mode for all axes.
    650.         /// </summary>
    651.         /// <remarks>
    652.         /// This method differs from the <see cref="ZoomOutAll" /> method in that it sets the scales
    653.         /// to full auto mode.  The <see cref="ZoomOutAll" /> method sets the scales to their initial
    654.         /// setting prior to any user actions (which may or may not be full auto mode).
    655.         /// </remarks>
    656.         /// <param name="primaryPane">The <see cref="GraphPane" /> object which is to have the
    657.         /// scale restored</param>
    658.         public void RestoreScale( GraphPane primaryPane )
    659.         {
    660.             if ( primaryPane != null )
    661.             {
    662.                 //Go ahead and save the old zoomstates, which provides an "undo"-like capability
    663.                 //ZoomState oldState = primaryPane.ZoomStack.Push( primaryPane, ZoomState.StateType.Zoom );
    664.                 ZoomState oldState = new ZoomState( primaryPane, ZoomState.StateType.Zoom );
    665.  
    666.                 using ( Graphics g = this.CreateGraphics() )
    667.                 {
    668.                     if ( _isSynchronizeXAxes || _isSynchronizeYAxes )
    669.                     {
    670.                         foreach ( GraphPane pane in _masterPane._paneList )
    671.                         {
    672.                             pane.ZoomStack.Push( pane, ZoomState.StateType.Zoom );
    673.                             ResetAutoScale( pane, g );
    674.                         }
    675.                     }
    676.                     else
    677.                     {
    678.                         primaryPane.ZoomStack.Push( primaryPane, ZoomState.StateType.Zoom );
    679.                         ResetAutoScale( primaryPane, g );
    680.                     }
    681.  
    682.                     // Provide Callback to notify the user of zoom events
    683.                     if ( this.ZoomEvent != null )
    684.                         this.ZoomEvent( this, oldState, new ZoomState( primaryPane, ZoomState.StateType.Zoom ) );
    685.  
    686.                     //g.Dispose();
    687.                 }
    688.                 Refresh();
    689.             }
    690.         }
    691.  
    692.         private void ResetAutoScale( GraphPane pane, Graphics g )
    693.         {
    694.             pane.XAxis.ResetAutoScale( pane, g );
    695.             pane.X2Axis.ResetAutoScale( pane, g );
    696.             foreach ( YAxis axis in pane.YAxisList )
    697.                 axis.ResetAutoScale( pane, g );
    698.             foreach ( Y2Axis axis in pane.Y2AxisList )
    699.                 axis.ResetAutoScale( pane, g );
    700.         }
    701.  
    702.         /*
    703.                 public void RestoreScale( GraphPane primaryPane )
    704.                 {
    705.                     if ( primaryPane != null )
    706.                     {
    707.                         Graphics g = this.CreateGraphics();
    708.                         ZoomState oldState = new ZoomState( primaryPane, ZoomState.StateType.Zoom );
    709.                         //ZoomState newState = null;
    710.  
    711.                         if ( _isSynchronizeXAxes || _isSynchronizeYAxes )
    712.                         {
    713.                             foreach ( GraphPane pane in _masterPane._paneList )
    714.                             {
    715.                                 if ( pane == primaryPane )
    716.                                 {
    717.                                     pane.XAxis.ResetAutoScale( pane, g );
    718.                                     foreach ( YAxis axis in pane.YAxisList )
    719.                                         axis.ResetAutoScale( pane, g );
    720.                                     foreach ( Y2Axis axis in pane.Y2AxisList )
    721.                                         axis.ResetAutoScale( pane, g );
    722.                                 }
    723.                             }
    724.                         }
    725.                         else
    726.                         {
    727.                             primaryPane.XAxis.ResetAutoScale( primaryPane, g );
    728.                             foreach ( YAxis axis in primaryPane.YAxisList )
    729.                                 axis.ResetAutoScale( primaryPane, g );
    730.                             foreach ( Y2Axis axis in primaryPane.Y2AxisList )
    731.                                 axis.ResetAutoScale( primaryPane, g );
    732.                         }
    733.  
    734.                         // Provide Callback to notify the user of zoom events
    735.                         if ( this.ZoomEvent != null )
    736.                             this.ZoomEvent( this, oldState, new ZoomState( primaryPane, ZoomState.StateType.Zoom ) );
    737.  
    738.                         g.Dispose();
    739.                         Refresh();
    740.                     }
    741.                 }
    742.         */
    743.         /*
    744.                 public void ZoomOutAll( GraphPane primaryPane )
    745.                 {
    746.                     if ( primaryPane != null && !primaryPane.ZoomStack.IsEmpty )
    747.                     {
    748.                         ZoomState.StateType type = primaryPane.ZoomStack.Top.Type;
    749.  
    750.                         ZoomState oldState = new ZoomState( primaryPane, type );
    751.                         //ZoomState newState = pane.ZoomStack.PopAll( pane );
    752.                         ZoomState newState = null;
    753.                         if ( _isSynchronizeXAxes || _isSynchronizeYAxes )
    754.                         {
    755.                             foreach ( GraphPane pane in _masterPane._paneList )
    756.                             {
    757.                                 ZoomState state = pane.ZoomStack.PopAll( pane );
    758.                                 if ( pane == primaryPane )
    759.                                     newState = state;
    760.                             }
    761.                         }
    762.                         else
    763.                             newState = primaryPane.ZoomStack.PopAll( primaryPane );
    764.  
    765.                         // Provide Callback to notify the user of zoom events
    766.                         if ( this.ZoomEvent != null )
    767.                             this.ZoomEvent( this, oldState, newState );
    768.  
    769.                         Refresh();
    770.                     }
    771.                 }
    772.  
    773.         */
    774.  
    775.         /// <summary>
    776.         /// Handler for the "UnZoom/UnPan" context menu item.  Restores the scale ranges to the values
    777.         /// before the last zoom or pan operation.
    778.         /// </summary>
    779.         /// <param name="sender"></param>
    780.         /// <param name="e"></param>
    781.         protected void MenuClick_ZoomOut( System.Object sender, System.EventArgs e )
    782.         {
    783.             if ( _masterPane != null )
    784.             {
    785.                 GraphPane pane = _masterPane.FindPane( _menuClickPt );
    786.                 ZoomOut( pane );
    787.             }
    788.         }
    789.  
    790.         /// <summary>
    791.         /// Handler for the "UnZoom/UnPan" context menu item.  Restores the scale ranges to the values
    792.         /// before the last zoom, pan, or scroll operation.
    793.         /// </summary>
    794.         /// <remarks>
    795.         /// Triggers a <see cref="ZoomEvent" /> for any type of undo (including pan, scroll, zoom, and
    796.         /// wheelzoom).  This method will affect all the
    797.         /// <see cref="GraphPane" /> objects in the <see cref="MasterPane" /> if
    798.         /// <see cref="IsSynchronizeXAxes" /> or <see cref="IsSynchronizeYAxes" /> is true.
    799.         /// </remarks>
    800.         /// <param name="primaryPane">The primary <see cref="GraphPane" /> object which is to be
    801.         /// zoomed out</param>
    802.         public void ZoomOut( GraphPane primaryPane )
    803.         {
    804.             if ( primaryPane != null && !primaryPane.ZoomStack.IsEmpty )
    805.             {
    806.                 ZoomState.StateType type = primaryPane.ZoomStack.Top.Type;
    807.  
    808.                 ZoomState oldState = new ZoomState( primaryPane, type );
    809.                 ZoomState newState = null;
    810.                 if ( _isSynchronizeXAxes || _isSynchronizeYAxes )
    811.                 {
    812.                     foreach ( GraphPane pane in _masterPane._paneList )
    813.                     {
    814.                         ZoomState state = pane.ZoomStack.Pop( pane );
    815.                         if ( pane == primaryPane )
    816.                             newState = state;
    817.                     }
    818.                 }
    819.                 else
    820.                     newState = primaryPane.ZoomStack.Pop( primaryPane );
    821.  
    822.                 // Provide Callback to notify the user of zoom events
    823.                 if ( this.ZoomEvent != null )
    824.                     this.ZoomEvent( this, oldState, newState );
    825.  
    826.                 Refresh();
    827.             }
    828.         }
    829.  
    830.         /// <summary>
    831.         /// Handler for the "Undo All Zoom/Pan" context menu item.  Restores the scale ranges to the values
    832.         /// before all zoom and pan operations
    833.         /// </summary>
    834.         /// <remarks>
    835.         /// This method differs from the <see cref="RestoreScale" /> method in that it sets the scales
    836.         /// to their initial setting prior to any user actions.  The <see cref="RestoreScale" /> method
    837.         /// sets the scales to full auto mode (regardless of what the initial setting may have been).
    838.         /// </remarks>
    839.         /// <param name="sender"></param>
    840.         /// <param name="e"></param>
    841.         protected void MenuClick_ZoomOutAll( System.Object sender, System.EventArgs e )
    842.         {
    843.             if ( _masterPane != null )
    844.             {
    845.                 GraphPane pane = _masterPane.FindPane( _menuClickPt );
    846.                 ZoomOutAll( pane );
    847.             }
    848.         }
    849.  
    850.         /// <summary>
    851.         /// Handler for the "Undo All Zoom/Pan" context menu item.  Restores the scale ranges to the values
    852.         /// before all zoom and pan operations
    853.         /// </summary>
    854.         /// <remarks>
    855.         /// This method differs from the <see cref="RestoreScale" /> method in that it sets the scales
    856.         /// to their initial setting prior to any user actions.  The <see cref="RestoreScale" /> method
    857.         /// sets the scales to full auto mode (regardless of what the initial setting may have been).
    858.         /// </remarks>
    859.         /// <param name="primaryPane">The <see cref="GraphPane" /> object which is to be zoomed out</param>
    860.         public void ZoomOutAll( GraphPane primaryPane )
    861.         {
    862.             if ( primaryPane != null && !primaryPane.ZoomStack.IsEmpty )
    863.             {
    864.                 ZoomState.StateType type = primaryPane.ZoomStack.Top.Type;
    865.  
    866.                 ZoomState oldState = new ZoomState( primaryPane, type );
    867.                 //ZoomState newState = pane.ZoomStack.PopAll( pane );
    868.                 ZoomState newState = null;
    869.                 if ( _isSynchronizeXAxes || _isSynchronizeYAxes )
    870.                 {
    871.                     foreach ( GraphPane pane in _masterPane._paneList )
    872.                     {
    873.                         ZoomState state = pane.ZoomStack.PopAll( pane );
    874.                         if ( pane == primaryPane )
    875.                             newState = state;
    876.                     }
    877.                 }
    878.                 else
    879.                     newState = primaryPane.ZoomStack.PopAll( primaryPane );
    880.  
    881.                 // Provide Callback to notify the user of zoom events
    882.                 if ( this.ZoomEvent != null )
    883.                     this.ZoomEvent( this, oldState, newState );
    884.  
    885.                 Refresh();
    886.             }
    887.         }
    888.  
    889.     #endregion
    890.  
    891.     }
    892. }
  • 相关阅读:
    第十周课程总结
    第九周课程总结&实验报告(七)
    第八周课程总结&实验报告(六)
    第七周课程总结&实验报告(五)
    第六周&java实验报告四
    第五周课程总结&试验报告(三)
    课程总结
    第十四周课程总结
    第十三周学习总结
    第十二周编程总结
  • 原文地址:https://www.cnblogs.com/xihong2014/p/4200444.html
Copyright © 2011-2022 走看看