Kean专题(3)—Graphics_System

雪山飞狐_lzh

八、从主窗口和绘图窗口截图September 09, 2009
Taking screenshots of AutoCAD’s main and drawing windows using .NET
I received a comment on this previous post:
    Hi Kean, I tried to develop a routine based on this post but I found 2 things that I'd like to solve if possible. Your routine is just not usable for larger drawings (takes way to long). Also, your routine does not work properly in paper space. Please, don't get me wrong, I appreciate all the work you've put into this blog. I just desperately need to come up with a solution for snapshots that work on large drawings, that work in paper/model space and that use the current viewstyle settings (except the background color). Isn't there a way to somehow mimic the GetGsView function that is fast and works in paper space as well but has a downfall of creating a 3D view in the actual drawing whenever a 2D Wireframe visual style is set? Any help is really appreciated.
The previous post was really focused on using AutoCAD’s graphics system to generate a bitmap of the contained model. Something that may work better for certain specific scenarios is to capture graphics at the operating system level: essentially taking a screenshot (as opposed to what I previously called a snapshot – although frankly the difference is really which graphics system you ask to generate the graphics). The code I’ve adapted for use within AutoCAD is shown here.
Here’s the C# code:

2. using acApp = Autodesk.AutoCAD.ApplicationServices;
3. using Autodesk.AutoCAD.Runtime;
4. using System.Drawing.Imaging;
5. using System.Drawing;
7. namespace ScreenshotTest
8. {
9.   public class Commands
10.   {
11.     [CommandMethod("CSS")]
12.     static public void CaptureScreenShot()
13.     {
14.       ScreenShotToFile(
15.         acApp.Application.MainWindow,
16.         "c:\\main-window.png",
17.         0, 0, 0, 0
18.       );
19.       ScreenShotToFile(
20.         acApp.Application.DocumentManager.MdiActiveDocument.Window,
21.         "c:\\doc-window.png",
22.         30, 26, 10, 10
23.       );
24.     }
26.     private static void ScreenShotToFile(
27.       Autodesk.AutoCAD.Windows.Window wd,
28.       string filename,
29.       int top, int bottom, int left, int right
30.     )
31.     {
32.       Point pt = wd.Location;
33.       Size sz = wd.Size;
35.       pt.X += left;
36.       pt.Y += top;
37.       sz.Height -= top + bottom;
38.       sz.Width -= left + right;
40.       // Set the bitmap object to the size of the screen
42.       Bitmap bmp =
43.         new Bitmap(
44.           sz.Width,
45.           sz.Height,
46.           PixelFormat.Format32bppArgb
47.         );
48.       using (bmp)
49.       {
50.         // Create a graphics object from the bitmap
52.         using (Graphics gfx = Graphics.FromImage(bmp))
53.         {
54.           // Take a screenshot of our window
56.           gfx.CopyFromScreen(
57.             pt.X, pt.Y, 0,0, sz,
58.             CopyPixelOperation.SourceCopy
59.           );
61.           // Save the screenshot to the specified location
63.           bmp.Save(filename, ImageFormat.Png);
64.         }
65.       }
66.     }
67.   }
68. }

using acApp = Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.Runtime; using System.Drawing.Imaging; using System.Drawing; namespace ScreenshotTest {   public class Commands   {     [CommandMethod("CSS")]     static public void CaptureScreenShot()     {       ScreenShotToFile(         acApp.Application.MainWindow,         "c:\\main-window.png",         0, 0, 0, 0       );       ScreenShotToFile(         acApp.Application.DocumentManager.MdiActiveDocument.Window,         "c:\\doc-window.png",         30, 26, 10, 10       );     }     private static void ScreenShotToFile(       Autodesk.AutoCAD.Windows.Window wd,       string filename,       int top, int bottom, int left, int right     )     {       Point pt = wd.Location;       Size sz = wd.Size;       pt.X += left;       pt.Y += top;       sz.Height -= top + bottom;       sz.Width -= left + right;       // Set the bitmap object to the size of the screen       Bitmap bmp =         new Bitmap(           sz.Width,           sz.Height,           PixelFormat.Format32bppArgb         );       using (bmp)       {         // Create a graphics object from the bitmap         using (Graphics gfx = Graphics.FromImage(bmp))         {           // Take a screenshot of our window           gfx.CopyFromScreen(             pt.X, pt.Y, 0,0, sz,             CopyPixelOperation.SourceCopy           );           // Save the screenshot to the specified location           bmp.Save(filename, ImageFormat.Png);         }       }     }   } }

The code is pretty simple: it defines a command called CSS which creates two screenshots – one of the entire application window and one of the active document. The function that does the hard work – ScreenShotToFile() takes some arguments to allow cropping of the created image, as – for instance - the drawing window also contains some graphics that most people wouldn’t consider to be part of the drawing. If you want to see the reason for adding these four parameters, try passing zero to each of them in second call to the function (just as we do for the first), and look at the resulting image in c:\doc-window.png.
You’ll need to add references to a few additional .NET assemblies: System.Drawing and probably PresentationCore if you’re working with AutoCAD 2010.
Now let’s see what we get when we run our CSS command in an editing session. Two files get created – c:\main-window.png:

And c:\doc-window.png:

While this approach may not work for every situation, it’s another option to consider, depending on your requirements.

雪山飞狐_lzh

九、在文档中按选择区域截图
September 23, 2009
Taking a screenshot of a user-selected portion of a drawing using .NET
Following on from this recent post – and inspired by a question we received recently from a developer – I decided to extend the previous code to allow a user to select a portion of a drawing they would like to save to a file or place on the clipboard. This is actually a really useful tool for me when I’m writing this blog, so there was certainly a degree of self-interest involved. :-)
The technique shown in today’s post is actually pretty handy for other situations: it’s quite common to want to transform a point from drawing coordinates (which may well be in a specific User Coordinate System (UCS)) into screen coordinates, especially when wanting to display a window or a custom context menu at the cursor location.
To transform from UCS to screen coordinates we actually need three steps (and thanks to Adam Nagy, from DevTech EMEA, for creating code I borrowed from to get this working):
   1. Transform the selected point by the current UCS matrix to get WCS
          * This can be achieved using the .NET interface
   2. Transform the WCS point into Windows client coordinates
          * For this we need to P/Invoke the ObjectARX function acedCoordFromWorldToPixel()
   3. Transform the client coordinates into screen coordinates
          * For this we need to P/Invoke the Win32 API function ClientToScreen()
We need to do this for both corners of our user-selected window, of course. Once we have the corners in screen coordinates, the code from last time can be used: with a few modifications to support selection of top-right/bottom-left corners, rather than the assumed top-left/bottom-right, as well as adding support for placing the bitmap on the clipboard, rather than saving it to a file.
Here’s the updated C# code with our new WSS command:

2. using acApp = Autodesk.AutoCAD.ApplicationServices;
3. using Autodesk.AutoCAD.EditorInput;
4. using Autodesk.AutoCAD.Geometry;
5. using Autodesk.AutoCAD.Runtime;
7. using System.Drawing.Imaging;
8. using System.Drawing;
9. using System.Runtime.InteropServices;
10. using System.Windows.Interop;
11. using System;
13. namespace ScreenshotTest
14. {
15.   public class Commands
16.   {
17.     // For the coordinate tranformation we need...
19.     // An ObjectARX function:
21.     [DllImport(
22.       "acad.exe",
23.       EntryPoint="?acedCoordFromWorldToPixel@@YAHHQBNAAVCPoint@@@Z"
24.     )]
25.     static extern int acedCoordFromWorldToPixel(
26.       int windnum,
27.       double[] ptIn,
28.       out Point ptOut
29.     );
31.     // And a Win32 function:
33.     [DllImport("user32.dll")]
34.     static extern bool ClientToScreen(IntPtr hWnd, ref Point pt);
36.     // Command to capture the main and active drawing windows
38.     [CommandMethod("CSS")]
39.     static public void CaptureScreenShot()
40.     {
41.       ScreenShotToFile(
42.         acApp.Application.MainWindow,
43.         0, 0, 0, 0,
44.         "c:\\main-window.png",
45.         false
46.       );
47.       ScreenShotToFile(
48.         acApp.Application.DocumentManager.MdiActiveDocument.Window,
49.         30, 26, 10, 10,
50.         "c:\\doc-window.png",
51.         false
52.       );
53.     }
55.     // Command to capture a user-selected portion of a drawing
57.     [CommandMethod("WSS")]
58.     static public void WindowScreenShot()
59.     {
60.       acApp.Document doc =
61.         acApp.Application.DocumentManager.MdiActiveDocument;
62.       Editor ed = doc.Editor;
64.       // Ask the user for the screen window to capture
66.       PromptPointResult ppr =
67.         ed.GetPoint("\nSelect first point of capture window: ");
68.       if (ppr.Status != PromptStatus.OK)
69.         return;
70.       Point3d first = ppr.Value;
72.       ppr =
73.         ed.GetCorner(
74.           "\nSelect second point of capture window: ",
75.           first
76.         );
77.       if (ppr.Status != PromptStatus.OK)
78.         return;
79.       Point3d second = ppr.Value;
81.       // Generate screen coordinate points based on the
82.       // drawing points selected
84.       Point pt1, pt2;
86.       // First we get the viewport number
88.       short vp =
89.         (short)acApp.Application.GetSystemVariable("CVPORT");
91.       // Get the current UCS matrix (would be indentify if in WCS)
93.       Matrix3d ucsMat =
94.         ed.CurrentUserCoordinateSystem;
96.       // And then the handle to the current drawing window
98.       IntPtr hWnd = doc.Window.Handle;
100.       // Now calculate the selected corners in screen coordinates
102.       pt1 = ScreenFromDrawingPoint(ucsMat, hWnd, first, vp);
103.       pt2 = ScreenFromDrawingPoint(ucsMat, hWnd, second, vp);
105.       // Now save this portion of our screen as a raster image
107.       ScreenShotToFile(pt1, pt2, null, true);
108.     }
110.     // Perform our three tranformations to get from UCS (or WCS)
111.     // to screen coordinates
113.     private static Point ScreenFromDrawingPoint(
114.       Matrix3d ucsMat,
115.       IntPtr hWnd,
116.       Point3d ucsPt,
117.       short vpNum
118.     )
119.     {
120.       Point res;
121.       Point3d wcsPt = ucsPt.TransformBy(ucsMat);
122.       acedCoordFromWorldToPixel(vpNum, wcsPt.ToArray(), out res);
123.       ClientToScreen(hWnd, ref res);
124.       return res;
125.     }
127.     // Save the display of an AutoCAD window as a raster file
128.     // and/or an image on the clipboard
130.     private static void ScreenShotToFile(
131.       Autodesk.AutoCAD.Windows.Window wd,
132.       int top, int bottom, int left, int right,
133.       string filename,
134.       bool clipboard
135.     )
136.     {
137.       Point pt = wd.Location;
138.       Size sz = wd.Size;
140.       pt.X += left;
141.       pt.Y += top;
142.       sz.Height -= top + bottom;
143.       sz.Width -= left + right;
145.       SaveScreenPortion(pt, sz, filename, clipboard);
146.     }
148.     // Save a screen window between two corners as a raster file
149.     // and/or an image on the clipboard
151.     private static void ScreenShotToFile(
152.       Point pt1,
153.       Point pt2,
154.       string filename,
155.       bool clipboard
156.     )
157.     {
158.       // Create the top left corner from the two corners
159.       // provided (by taking the min of both X and Y values)
161.       Point pt =
162.         new Point(Math.Min(pt1.X, pt2.X), Math.Min(pt1.Y, pt2.Y));
164.       // Determine the size by subtracting X & Y values and
165.       // taking the absolute value of each
167.       Size sz =
168.         new Size(Math.Abs(pt1.X - pt2.X), Math.Abs(pt1.Y - pt2.Y));
170.       SaveScreenPortion(pt, sz, filename, clipboard);
171.     }
173.     // Save a portion of the screen display as a raster file
174.     // and/or an image on the clipboard
176.     private static void SaveScreenPortion(
177.       Point pt,
178.       Size sz,
179.       string filename,
180.       bool clipboard
181.     )
182.     {
183.       // Set the bitmap object to the size of the window
185.       Bitmap bmp =
186.         new Bitmap(
187.           sz.Width,
188.           sz.Height,
189.           PixelFormat.Format32bppArgb
190.         );
191.       using (bmp)
192.       {
193.         // Create a graphics object from the bitmap
195.         using (Graphics gfx = Graphics.FromImage(bmp))
196.         {
197.           // Take a screenshot of our window
199.           gfx.CopyFromScreen(
200.             pt.X, pt.Y, 0, 0, sz,
201.             CopyPixelOperation.SourceCopy
202.           );
204.           // Save the screenshot to the specified location
206.           if (filename != null && filename != "")
207.             bmp.Save(filename, ImageFormat.Png);
209.           // Copy it to the clipboard
211.           if (clipboard)
212.             System.Windows.Forms.Clipboard.SetImage(bmp);
213.         }
214.       }
215.     }
216.   }
217. }

using acApp = Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.Geometry; using Autodesk.AutoCAD.Runtime; using System.Drawing.Imaging; using System.Drawing; using System.Runtime.InteropServices; using System.Windows.Interop; using System; namespace ScreenshotTest {   public class Commands   {     // For the coordinate tranformation we need...     // An ObjectARX function:     [DllImport(       "acad.exe",       EntryPoint="?acedCoordFromWorldToPixel@@YAHHQBNAAVCPoint@@@Z"     )]     static extern int acedCoordFromWorldToPixel(       int windnum,       double[] ptIn,       out Point ptOut     );     // And a Win32 function:     [DllImport("user32.dll")]     static extern bool ClientToScreen(IntPtr hWnd, ref Point pt);     // Command to capture the main and active drawing windows     [CommandMethod("CSS")]     static public void CaptureScreenShot()     {       ScreenShotToFile(         acApp.Application.MainWindow,         0, 0, 0, 0,         "c:\\main-window.png",         false       );       ScreenShotToFile(         acApp.Application.DocumentManager.MdiActiveDocument.Window,         30, 26, 10, 10,         "c:\\doc-window.png",         false       );     }     // Command to capture a user-selected portion of a drawing     [CommandMethod("WSS")]     static public void WindowScreenShot()     {       acApp.Document doc =         acApp.Application.DocumentManager.MdiActiveDocument;       Editor ed = doc.Editor;       // Ask the user for the screen window to capture       PromptPointResult ppr =         ed.GetPoint("\nSelect first point of capture window: ");       if (ppr.Status != PromptStatus.OK)         return;       Point3d first = ppr.Value;       ppr =         ed.GetCorner(           "\nSelect second point of capture window: ",           first         );       if (ppr.Status != PromptStatus.OK)         return;       Point3d second = ppr.Value;       // Generate screen coordinate points based on the       // drawing points selected       Point pt1, pt2;       // First we get the viewport number       short vp =         (short)acApp.Application.GetSystemVariable("CVPORT");       // Get the current UCS matrix (would be indentify if in WCS)       Matrix3d ucsMat =         ed.CurrentUserCoordinateSystem;       // And then the handle to the current drawing window       IntPtr hWnd = doc.Window.Handle;       // Now calculate the selected corners in screen coordinates       pt1 = ScreenFromDrawingPoint(ucsMat, hWnd, first, vp);       pt2 = ScreenFromDrawingPoint(ucsMat, hWnd, second, vp);       // Now save this portion of our screen as a raster image       ScreenShotToFile(pt1, pt2, null, true);     }     // Perform our three tranformations to get from UCS (or WCS)     // to screen coordinates     private static Point ScreenFromDrawingPoint(       Matrix3d ucsMat,       IntPtr hWnd,       Point3d ucsPt,       short vpNum     )     {       Point res;       Point3d wcsPt = ucsPt.TransformBy(ucsMat);       acedCoordFromWorldToPixel(vpNum, wcsPt.ToArray(), out res);       ClientToScreen(hWnd, ref res);       return res;     }     // Save the display of an AutoCAD window as a raster file     // and/or an image on the clipboard     private static void ScreenShotToFile(       Autodesk.AutoCAD.Windows.Window wd,       int top, int bottom, int left, int right,       string filename,       bool clipboard     )     {       Point pt = wd.Location;       Size sz = wd.Size;       pt.X += left;       pt.Y += top;       sz.Height -= top + bottom;       sz.Width -= left + right;       SaveScreenPortion(pt, sz, filename, clipboard);     }     // Save a screen window between two corners as a raster file     // and/or an image on the clipboard     private static void ScreenShotToFile(       Point pt1,       Point pt2,       string filename,       bool clipboard     )     {       // Create the top left corner from the two corners       // provided (by taking the min of both X and Y values)       Point pt =         new Point(Math.Min(pt1.X, pt2.X), Math.Min(pt1.Y, pt2.Y));       // Determine the size by subtracting X & Y values and       // taking the absolute value of each       Size sz =         new Size(Math.Abs(pt1.X - pt2.X), Math.Abs(pt1.Y - pt2.Y));       SaveScreenPortion(pt, sz, filename, clipboard);     }     // Save a portion of the screen display as a raster file     // and/or an image on the clipboard     private static void SaveScreenPortion(       Point pt,       Size sz,       string filename,       bool clipboard     )     {       // Set the bitmap object to the size of the window       Bitmap bmp =         new Bitmap(           sz.Width,           sz.Height,           PixelFormat.Format32bppArgb         );       using (bmp)       {         // Create a graphics object from the bitmap         using (Graphics gfx = Graphics.FromImage(bmp))         {           // Take a screenshot of our window           gfx.CopyFromScreen(             pt.X, pt.Y, 0, 0, sz,             CopyPixelOperation.SourceCopy           );           // Save the screenshot to the specified location           if (filename != null && filename != "")             bmp.Save(filename, ImageFormat.Png);           // Copy it to the clipboard           if (clipboard)             System.Windows.Forms.Clipboard.SetImage(bmp);         }       }     }   } }

To get the code working, you may need to add an additional assembly reference to System.Windows.Forms.dll, which gives us access to the Clipboard. I should also mention that I’m running this code on AutoCAD 2010 on a 32-bit OS: if the DllImport statement to P/Invoke our ObjectARX function, you may need to find and declare the appropriate function signature.
To put our WSS command through its paces, let’s load a drawing and set a random UCS (I do this by changing the view using 3DORBIT and using the UCS command, setting it to the current View) and on top of that changing the view to be from a another random angle not aligned with this new UCS:

Now we NETLOAD our assembly and run the WSS command, selecting the two corners of our window:

And we can see that the resultant image is on the clipboard by pasting it somewhere (we could very easily adjust the code to save to a file, if we so chose) :

Update:
Paavo pointed out in a comment that I had missed a managed API method to replace the P/Invoke of acedCoordFromWorldToPixel(), which makes the code much cleaner and more portable across versions: Editor.PointToScreen(). We still have to P/Invoke ClientToScreen(), but at least that’s undecorated/unmangled.
Here’s the revised C# code, which I’ve included in its entirety because it has ended up meaning a change both to the ScreenFromDrawingPoint() function and the code that calls it: we need the editor to perform our transformation so we might as well use it within the function to retrieve the matrix representing the current UCS. Which simplifies things somewhat.

2. using acApp = Autodesk.AutoCAD.ApplicationServices;
3. using Autodesk.AutoCAD.EditorInput;
4. using Autodesk.AutoCAD.Geometry;
5. using Autodesk.AutoCAD.Runtime;
7. using System.Drawing.Imaging;
8. using System.Drawing;
9. using System.Runtime.InteropServices;
10. using System.Windows.Interop;
11. using System;
13. namespace ScreenshotTest
14. {
15.   public class Commands
16.   {
17.     // For the coordinate tranformation we need...
19.     // A Win32 function:
21.     [DllImport("user32.dll")]
22.     static extern bool ClientToScreen(IntPtr hWnd, ref Point pt);
24.     // Command to capture the main and active drawing windows
26.     [CommandMethod("CSS")]
27.     static public void CaptureScreenShot()
28.     {
29.       ScreenShotToFile(
30.         acApp.Application.MainWindow,
31.         0, 0, 0, 0,
32.         "c:\\main-window.png",
33.         false
34.       );
35.       ScreenShotToFile(
36.         acApp.Application.DocumentManager.MdiActiveDocument.Window,
37.         30, 26, 10, 10,
38.         "c:\\doc-window.png",
39.         false
40.       );
41.     }
43.     // Command to capture a user-selected portion of a drawing
45.     [CommandMethod("WSS")]
46.     static public void WindowScreenShot()
47.     {
48.       acApp.Document doc =
49.         acApp.Application.DocumentManager.MdiActiveDocument;
50.       Editor ed = doc.Editor;
52.       // Ask the user for the screen window to capture
54.       PromptPointResult ppr =
55.         ed.GetPoint("\nSelect first point of capture window: ");
56.       if (ppr.Status != PromptStatus.OK)
57.         return;
58.       Point3d first = ppr.Value;
60.       ppr =
61.         ed.GetCorner(
62.           "\nSelect second point of capture window: ",
63.           first
64.         );
65.       if (ppr.Status != PromptStatus.OK)
66.         return;
67.       Point3d second = ppr.Value;
69.       // Generate screen coordinate points based on the
70.       // drawing points selected
72.       Point pt1, pt2;
74.       // First we get the viewport number
76.       short vp =
77.         (short)acApp.Application.GetSystemVariable("CVPORT");
79.       // Then the handle to the current drawing window
81.       IntPtr hWnd = doc.Window.Handle;
83.       // Now calculate the selected corners in screen coordinates
85.       pt1 = ScreenFromDrawingPoint(ed, hWnd, first, vp);
86.       pt2 = ScreenFromDrawingPoint(ed, hWnd, second, vp);
88.       // Now save this portion of our screen as a raster image
90.       ScreenShotToFile(pt1, pt2, null, true);
91.     }
93.     // Perform our three tranformations to get from UCS (or WCS)
94.     // to screen coordinates
96.     private static Point ScreenFromDrawingPoint(
97.       Editor ed,
98.       IntPtr hWnd,
99.       Point3d ucsPt,
100.       short vpNum
101.     )
102.     {     
103.       Point3d wcsPt =
104.         ucsPt.TransformBy(
105.           ed.CurrentUserCoordinateSystem
106.         );
107.       Point res = ed.PointToScreen(wcsPt, vpNum);
108.       ClientToScreen(hWnd, ref res);
109.       return res;
110.     }
112.     // Save the display of an AutoCAD window as a raster file
113.     // and/or an image on the clipboard
115.     private static void ScreenShotToFile(
116.       Autodesk.AutoCAD.Windows.Window wd,
117.       int top, int bottom, int left, int right,
118.       string filename,
119.       bool clipboard
120.     )
121.     {
122.       Point pt = wd.Location;
123.       Size sz = wd.Size;
125.       pt.X += left;
126.       pt.Y += top;
127.       sz.Height -= top + bottom;
128.       sz.Width -= left + right;
130.       SaveScreenPortion(pt, sz, filename, clipboard);
131.     }
133.     // Save a screen window between two corners as a raster file
134.     // and/or an image on the clipboard
136.     private static void ScreenShotToFile(
137.       Point pt1,
138.       Point pt2,
139.       string filename,
140.       bool clipboard
141.     )
142.     {
143.       // Create the top left corner from the two corners
144.       // provided (by taking the min of both X and Y values)
146.       Point pt =
147.         new Point(Math.Min(pt1.X, pt2.X), Math.Min(pt1.Y, pt2.Y));
149.       // Determine the size by subtracting X & Y values and
150.       // taking the absolute value of each
152.       Size sz =
153.         new Size(Math.Abs(pt1.X - pt2.X), Math.Abs(pt1.Y - pt2.Y));
155.       SaveScreenPortion(pt, sz, filename, clipboard);
156.     }
158.     // Save a portion of the screen display as a raster file
159.     // and/or an image on the clipboard
161.     private static void SaveScreenPortion(
162.       Point pt,
163.       Size sz,
164.       string filename,
165.       bool clipboard
166.     )
167.     {
168.       // Set the bitmap object to the size of the window
170.       Bitmap bmp =
171.         new Bitmap(
172.           sz.Width,
173.           sz.Height,
174.           PixelFormat.Format32bppArgb
175.         );
176.       using (bmp)
177.       {
178.         // Create a graphics object from the bitmap
180.         using (Graphics gfx = Graphics.FromImage(bmp))
181.         {
182.           // Take a screenshot of our window
184.           gfx.CopyFromScreen(
185.             pt.X, pt.Y, 0, 0, sz,
186.             CopyPixelOperation.SourceCopy
187.           );
189.           // Save the screenshot to the specified location
191.           if (filename != null && filename != "")
192.             bmp.Save(filename, ImageFormat.Png);
194.           // Copy it to the clipboard
196.           if (clipboard)
197.             System.Windows.Forms.Clipboard.SetImage(bmp);
198.         }
199.       }
200.     }
201.   }
202. }

using acApp = Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.Geometry; using Autodesk.AutoCAD.Runtime; using System.Drawing.Imaging; using System.Drawing; using System.Runtime.InteropServices; using System.Windows.Interop; using System; namespace ScreenshotTest {   public class Commands   {     // For the coordinate tranformation we need...     // A Win32 function:     [DllImport("user32.dll")]     static extern bool ClientToScreen(IntPtr hWnd, ref Point pt);     // Command to capture the main and active drawing windows     [CommandMethod("CSS")]     static public void CaptureScreenShot()     {       ScreenShotToFile(         acApp.Application.MainWindow,         0, 0, 0, 0,         "c:\\main-window.png",         false       );       ScreenShotToFile(         acApp.Application.DocumentManager.MdiActiveDocument.Window,         30, 26, 10, 10,         "c:\\doc-window.png",         false       );     }     // Command to capture a user-selected portion of a drawing     [CommandMethod("WSS")]     static public void WindowScreenShot()     {       acApp.Document doc =         acApp.Application.DocumentManager.MdiActiveDocument;       Editor ed = doc.Editor;       // Ask the user for the screen window to capture       PromptPointResult ppr =         ed.GetPoint("\nSelect first point of capture window: ");       if (ppr.Status != PromptStatus.OK)         return;       Point3d first = ppr.Value;       ppr =         ed.GetCorner(           "\nSelect second point of capture window: ",           first         );       if (ppr.Status != PromptStatus.OK)         return;       Point3d second = ppr.Value;       // Generate screen coordinate points based on the       // drawing points selected       Point pt1, pt2;       // First we get the viewport number       short vp =         (short)acApp.Application.GetSystemVariable("CVPORT");       // Then the handle to the current drawing window       IntPtr hWnd = doc.Window.Handle;       // Now calculate the selected corners in screen coordinates       pt1 = ScreenFromDrawingPoint(ed, hWnd, first, vp);       pt2 = ScreenFromDrawingPoint(ed, hWnd, second, vp);       // Now save this portion of our screen as a raster image       ScreenShotToFile(pt1, pt2, null, true);     }     // Perform our three tranformations to get from UCS (or WCS)     // to screen coordinates     private static Point ScreenFromDrawingPoint(       Editor ed,       IntPtr hWnd,       Point3d ucsPt,       short vpNum     )     {            Point3d wcsPt =         ucsPt.TransformBy(           ed.CurrentUserCoordinateSystem         );       Point res = ed.PointToScreen(wcsPt, vpNum);       ClientToScreen(hWnd, ref res);       return res;     }     // Save the display of an AutoCAD window as a raster file     // and/or an image on the clipboard     private static void ScreenShotToFile(       Autodesk.AutoCAD.Windows.Window wd,       int top, int bottom, int left, int right,       string filename,       bool clipboard     )     {       Point pt = wd.Location;       Size sz = wd.Size;       pt.X += left;       pt.Y += top;       sz.Height -= top + bottom;       sz.Width -= left + right;       SaveScreenPortion(pt, sz, filename, clipboard);     }     // Save a screen window between two corners as a raster file     // and/or an image on the clipboard     private static void ScreenShotToFile(       Point pt1,       Point pt2,       string filename,       bool clipboard     )     {       // Create the top left corner from the two corners       // provided (by taking the min of both X and Y values)       Point pt =         new Point(Math.Min(pt1.X, pt2.X), Math.Min(pt1.Y, pt2.Y));       // Determine the size by subtracting X & Y values and       // taking the absolute value of each       Size sz =         new Size(Math.Abs(pt1.X - pt2.X), Math.Abs(pt1.Y - pt2.Y));       SaveScreenPortion(pt, sz, filename, clipboard);     }     // Save a portion of the screen display as a raster file     // and/or an image on the clipboard     private static void SaveScreenPortion(       Point pt,       Size sz,       string filename,       bool clipboard     )     {       // Set the bitmap object to the size of the window       Bitmap bmp =         new Bitmap(           sz.Width,           sz.Height,           PixelFormat.Format32bppArgb         );       using (bmp)       {         // Create a graphics object from the bitmap         using (Graphics gfx = Graphics.FromImage(bmp))         {           // Take a screenshot of our window           gfx.CopyFromScreen(             pt.X, pt.Y, 0, 0, sz,             CopyPixelOperation.SourceCopy           );           // Save the screenshot to the specified location           if (filename != null && filename != "")             bmp.Save(filename, ImageFormat.Png);           // Copy it to the clipboard           if (clipboard)             System.Windows.Forms.Clipboard.SetImage(bmp);         }       }     }   } }