Kean专题(12)—Plotting

雪山飞狐_lzh

http://through-the-interface.typepad.com/through_the_interface/plotting/
一、使用Design Review 2008的批打印插件
May 10, 2007
Automating batch printing of DWF files using Design Review 2008
We sometimes receive questions on how best to automate the printing of DWF files. Autodesk Design Review 2008 now has a new Batch Print Plug-in enabling just this.
Once you've installed the plug-in, you'll be able to use the Batch Print Wizard in Design Review (on the file menu, once a DWF has been loaded). This Wizard allows you to configure a batch job for Design Review to process and save it to a BPJ (Batch Print Job) file. This BPJ (which is basically a very simple XML file) can then be used to drive the batch print process automatically.
The next logical step is clearly to create the BPJ programmatically, which can be done using a number of XML libraries (MS XML etc.) or simply by writing out a text file using your favourite string output routines.
So let's look at creating the BPJ file "manually" using the Batch Print Wizard.
Here's the second screen you'll see, once you've skipped the welcome:

When you've selected the files you wish to print and added them to the right-hand side using the ">" button, you can move on to the next page:

This is where you modify the print setup for each of your DWFs, by clicking on the item and hitting "rint Setup", or just double-clicking the item.

And then you're ready to save the BPJ file (or just "rint" directly).
I saved mine as "c:\My Documents\MyFiles.bpj", and here are its contents, with additional whitespace added for readability:

1. <configuration_file>
2.   <DWF_File
3.     FileName="C:\My Documents\\First.dwf"
4.     PageSize="11.0 x 8.5 in"
5.     NoOfSections="2"
6.     Print_to_scale="100"
7.     User_defined_Zoom_Factor="100"
8.     Print_Style="0"
9.     Print_What="0"
10.     Fit_To_Paper="1"
11.     Paper_Size="9"
12.     Paper_Size_Width="2100"
13.     Paper_Size_Height="2970"
14.     Orientation="2"
15.     Number_of_copies="1"
16.     PrinterName="\\beihpa001\BEIPRN003"
17.     Page_Range="1"
18.     Print_Range_Str=""
19.     Reverse_Order="0"
20.     Collate="0"
21.     printColor="0"
22.     printAlignment="4"
23.     Use_DWF_Paper_Size="0"
24.     PaperName="A4"
25.     useHPIP="0"
26.     HPIPMediaID="-1"
27.     HPIPExcludeEModel="1"
28.     HPIPPaperName=""/>
29.   <DWF_File
30.     FileName="C:\My Documents\\Second.dwf"
31.     PageSize="11.0 x 8.5 in"
32.     NoOfSections="2"
33.     Print_to_scale="100"
34.     User_defined_Zoom_Factor="100"
35.     Print_Style="0"
36.     Print_What="0"
37.     Fit_To_Paper="1"
38.     Paper_Size="9"
39.     Paper_Size_Width="2100"
40.     Paper_Size_Height="2970"
41.     Orientation="2"
42.     Number_of_copies="1"
43.     PrinterName="\\beihpa001\BEIPRN003"
44.     Page_Range="1"
45.     Print_Range_Str=""
46.     Reverse_Order="0"
47.     Collate="0"
48.     printColor="0"
49.     printAlignment="4"
50.     Use_DWF_Paper_Size="0"
51.     PaperName="A4"
52.     useHPIP="0"
53.     HPIPMediaID="-1"
54.     HPIPExcludeEModel="1"
55.     HPIPPaperName=""/>
56. </configuration_file>

复制代码

This is clearly straightforward to create programmatically from your application. The next question is how best to automate the print process, now we have our BPJ.
The simplest way is to call the Design Review executable with the BPJ file as a command-line argument:

The executable returns straight away, and you'll see a log file created in the same location as the BPJ (in my case "c:\My Documents\MyFiles.log"), detailing the results of the print job:

1. Batch Printing initiated with Configuration file: "\My Documents\MyFiles.bpj". Start Time: Thu May 10 17:16:35 2007
3.   Opening DWF file : "C:\My Documents\\First.dwf". Start Time: Thu May 10 17:16:35 2007
5.   DWF file: "C:\My Documents\\First.dwf" Opened successfully. End Time: Thu May 10 17:16:37 2007
7.     Status:DWF Open Successful
9.   Started Printing DWF File: "C:\My Documents\\First.dwf". Start Time: Thu May 10 17:16:39 2007
11.       Printing To    : \\beihpa001\BEIPRN003
12.       HPIP set to    : False
13.       Paper Size    : 2100 X 2970
14.       Print Range    : Current Page
15.       No Of Copies  : 1
16.       Scale          : 100 %, Tile Pages (Not Applicable For 3D Sections)
17.       Print Alignment: LowerLeft (Not Applicable For 3D Sections)
18.       Orientation    : Landscape
19.       Print Color    : Color
21.       Started Printing Section Number : 0. Start Time: Thu May 10 17:16:39 2007
23.       Finished Printing Section Number: 0. End Time  : Thu May 10 17:16:42 2007
25.       Started Printing Section Number : 1. Start Time: Thu May 10 17:16:43 2007
27.       Finished Printing Section Number: 1. End Time  : Thu May 10 17:16:43 2007
29.   Finished Printing DWF file: "C:\My Documents\\First.dwf" . End Time: Thu May 10 17:16:43 2007
31.   Opening DWF file : "C:\My Documents\\Second.dwf". Start Time: Thu May 10 17:16:43 2007
33.   DWF file: "C:\My Documents\\Second.dwf" Opened successfully. End Time: Thu May 10 17:16:45 2007
35.     Status:DWF Open Successful
37.   Started Printing DWF File: "C:\My Documents\\Second.dwf". Start Time: Thu May 10 17:16:46 2007
39.       Printing To    : \\beihpa001\BEIPRN003
40.       HPIP set to    : False
41.       Paper Size    : 2100 X 2970
42.       Print Range    : Current Page
43.       No Of Copies  : 1
44.       Scale          : 100 %, Tile Pages (Not Applicable For 3D Sections)
45.       Print Alignment: LowerLeft (Not Applicable For 3D Sections)
46.       Orientation    : Landscape
47.       Print Color    : Color
49.       Started Printing Section Number : 0. Start Time: Thu May 10 17:16:46 2007
51.       Finished Printing Section Number: 0. End Time  : Thu May 10 17:16:49 2007
53.       Started Printing Section Number : 1. Start Time: Thu May 10 17:16:49 2007
55.       Finished Printing Section Number: 1. End Time  : Thu May 10 17:16:50 2007
57.   Finished Printing DWF file: "C:\My Documents\\Second.dwf" . End Time: Thu May 10 17:16:50 2007
59. Batch Printing Finished with Configuration file: "\My Documents\MyFiles.bpj". End Time: Thu May 10 17:16:50 2007
61. Total Time Taken to complete Batch Print Process: 0 hr: 0 Min: 15 Sec.

复制代码

This log file can be parsed programmatically if it's important for your application to know whether any pages had difficulty printing.

羊羊羊

图纸尺寸列表中 显示的是英文 MM，而不是中文 毫米，，而CAD自带德打印模块显示的 图纸尺寸 是 中文 毫米，编程 怎么实现

羊羊羊

打印预览有没有调过了的？为啥一直卡在预览界面？

羊羊羊

打印预览有没有调过了的？为啥一直卡在预览界面？

雪山飞狐_lzh

二、使用NetApi实现简单的打印任务
September 25, 2007
Driving a basic AutoCAD plot using .NET
I just missed my connecting flight in Chicago, so have 3 hours to pass until the next, and decided to post some code I finally got around to writing on the plane from Zurich.
I've had a few requests for code showing how to plot using the .NET API in AutoCAD. There's an existing ObjectARX (C++) sample on the SDK, under samples/editor/AsdkPlotAPI, but there isn't a publicly posted .NET version right now.
Here's the C# code I put together. Please bear in mind that it was written during less than ideal coding conditions, and I haven't spent a substantial amount of time going through it... it seems to work fine for me, but do post a comment if you have trouble with it.

2. using Autodesk.AutoCAD.Runtime;
3. using Autodesk.AutoCAD.ApplicationServices;
4. using Autodesk.AutoCAD.DatabaseServices;
5. using Autodesk.AutoCAD.EditorInput;
6. using Autodesk.AutoCAD.Geometry;
7. using Autodesk.AutoCAD.PlottingServices;
8. namespace PlottingApplication
9. {
10.   public class PlottingCommands
11.   {
12.     [CommandMethod("simplot")]
13.     static public void SimplePlot()
14.     {
15.       Document doc =
16.         Application.DocumentManager.MdiActiveDocument;
17.       Editor ed = doc.Editor;
18.       Database db = doc.Database;
19.       Transaction tr =
20.         db.TransactionManager.StartTransaction();
21.       using (tr)
22.       {
23.         // We'll be plotting the current layout
24.         BlockTableRecord btr =
25.           (BlockTableRecord)tr.GetObject(
26.             db.CurrentSpaceId,
27.             OpenMode.ForRead
28.           );
29.         Layout lo =
30.           (Layout)tr.GetObject(
31.             btr.LayoutId,
32.             OpenMode.ForRead
33.           );
34.         // We need a PlotInfo object
35.         // linked to the layout
36.         PlotInfo pi = new PlotInfo();
37.         pi.Layout = btr.LayoutId;
38.         // We need a PlotSettings object
39.         // based on the layout settings
40.         // which we then customize
41.         PlotSettings ps =
42.           new PlotSettings(lo.ModelType);
43.         ps.CopyFrom(lo);
44.         // The PlotSettingsValidator helps
45.         // create a valid PlotSettings object
46.         PlotSettingsValidator psv =
47.           PlotSettingsValidator.Current;
48.         // We'll plot the extents, centered and
49.         // scaled to fit
50.         psv.SetPlotType(
51.           ps,
52.           Autodesk.AutoCAD.DatabaseServices.PlotType.Extents
53.         );
54.         psv.SetUseStandardScale(ps, true);
55.         psv.SetStdScaleType(ps, StdScaleType.ScaleToFit);
56.         psv.SetPlotCentered(ps, true);
57.         // We'll use the standard DWF PC3, as
58.         // for today we're just plotting to file
59.         psv.SetPlotConfigurationName(
60.           ps,
61.           "DWF6 ePlot.pc3",
62.           "ANSI_A_(8.50_x_11.00_Inches)"
63.         );
64.         // We need to link the PlotInfo to the
65.         // PlotSettings and then validate it
66.         pi.OverrideSettings = ps;
67.         PlotInfoValidator piv =
68.           new PlotInfoValidator();
69.         piv.MediaMatchingPolicy =
70.           MatchingPolicy.MatchEnabled;
71.         piv.Validate(pi);
72.         // A PlotEngine does the actual plotting
73.         // (can also create one for Preview)
74.         if (PlotFactory.ProcessPlotState ==
75.             ProcessPlotState.NotPlotting)
76.         {
77.           PlotEngine pe =
78.             PlotFactory.CreatePublishEngine();
79.           using (pe)
80.           {
81.             // Create a Progress Dialog to provide info
82.             // and allow thej user to cancel
83.             PlotProgressDialog ppd =
84.               new PlotProgressDialog(false, 1, true);
85.             using (ppd)
86.             {
87.               ppd.set_PlotMsgString(
88.                 PlotMessageIndex.DialogTitle,
89.                 "Custom Plot Progress"
90.               );
91.               ppd.set_PlotMsgString(
92.                 PlotMessageIndex.CancelJobButtonMessage,
93.                 "Cancel Job"
94.               );
95.               ppd.set_PlotMsgString(
96.                 PlotMessageIndex.CancelSheetButtonMessage,
97.                 "Cancel Sheet"
98.               );
99.               ppd.set_PlotMsgString(
100.                 PlotMessageIndex.SheetSetProgressCaption,
101.                 "Sheet Set Progress"
102.               );
103.               ppd.set_PlotMsgString(
104.                 PlotMessageIndex.SheetProgressCaption,
105.                 "Sheet Progress"
106.               );
107.               ppd.LowerPlotProgressRange = 0;
108.               ppd.UpperPlotProgressRange = 100;
109.               ppd.PlotProgressPos = 0;
110.               // Let's start the plot, at last
111.               ppd.OnBeginPlot();
112.               ppd.IsVisible = true;
113.               pe.BeginPlot(ppd, null);
114.               // We'll be plotting a single document
115.               pe.BeginDocument(
116.                 pi,
117.                 doc.Name,
118.                 null,
119.                 1,
120.                 true, // Let's plot to file
121.                 "c:\\test-output"
122.               );
123.               // Which contains a single sheet
124.               ppd.OnBeginSheet();
125.               ppd.LowerSheetProgressRange = 0;
126.               ppd.UpperSheetProgressRange = 100;
127.               ppd.SheetProgressPos = 0;
128.               PlotPageInfo ppi = new PlotPageInfo();
129.               pe.BeginPage(
130.                 ppi,
131.                 pi,
132.                 true,
133.                 null
134.               );
135.               pe.BeginGenerateGraphics(null);
136.               pe.EndGenerateGraphics(null);
137.               // Finish the sheet
138.               pe.EndPage(null);
139.               ppd.SheetProgressPos = 100;
140.               ppd.OnEndSheet();
141.               // Finish the document
142.               pe.EndDocument(null);
143.               // And finish the plot
144.               ppd.PlotProgressPos = 100;
145.               ppd.OnEndPlot();
146.               pe.EndPlot(null);
147.             }
148.           }
149.         }
150.         else
151.         {
152.           ed.WriteMessage(
153.             "\nAnother plot is in progress."
154.           );
155.         }
156.       }
157.     }
158.   }
159. }

using Autodesk.AutoCAD.Runtime; using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.Geometry; using Autodesk.AutoCAD.PlottingServices; namespace PlottingApplication {   public class PlottingCommands   {     [CommandMethod("simplot")]     static public void SimplePlot()     {       Document doc =         Application.DocumentManager.MdiActiveDocument;       Editor ed = doc.Editor;       Database db = doc.Database;       Transaction tr =         db.TransactionManager.StartTransaction();       using (tr)       {         // We'll be plotting the current layout         BlockTableRecord btr =           (BlockTableRecord)tr.GetObject(             db.CurrentSpaceId,             OpenMode.ForRead           );         Layout lo =           (Layout)tr.GetObject(             btr.LayoutId,             OpenMode.ForRead           );         // We need a PlotInfo object         // linked to the layout         PlotInfo pi = new PlotInfo();         pi.Layout = btr.LayoutId;         // We need a PlotSettings object         // based on the layout settings         // which we then customize         PlotSettings ps =           new PlotSettings(lo.ModelType);         ps.CopyFrom(lo);         // The PlotSettingsValidator helps         // create a valid PlotSettings object         PlotSettingsValidator psv =           PlotSettingsValidator.Current;         // We'll plot the extents, centered and         // scaled to fit         psv.SetPlotType(           ps,           Autodesk.AutoCAD.DatabaseServices.PlotType.Extents         );         psv.SetUseStandardScale(ps, true);         psv.SetStdScaleType(ps, StdScaleType.ScaleToFit);         psv.SetPlotCentered(ps, true);         // We'll use the standard DWF PC3, as         // for today we're just plotting to file         psv.SetPlotConfigurationName(           ps,           "DWF6 ePlot.pc3",           "ANSI_A_(8.50_x_11.00_Inches)"         );         // We need to link the PlotInfo to the         // PlotSettings and then validate it         pi.OverrideSettings = ps;         PlotInfoValidator piv =           new PlotInfoValidator();         piv.MediaMatchingPolicy =           MatchingPolicy.MatchEnabled;         piv.Validate(pi);         // A PlotEngine does the actual plotting         // (can also create one for Preview)         if (PlotFactory.ProcessPlotState ==             ProcessPlotState.NotPlotting)         {           PlotEngine pe =             PlotFactory.CreatePublishEngine();           using (pe)           {             // Create a Progress Dialog to provide info             // and allow thej user to cancel             PlotProgressDialog ppd =               new PlotProgressDialog(false, 1, true);             using (ppd)             {               ppd.set_PlotMsgString(                 PlotMessageIndex.DialogTitle,                 "Custom Plot Progress"               );               ppd.set_PlotMsgString(                 PlotMessageIndex.CancelJobButtonMessage,                 "Cancel Job"               );               ppd.set_PlotMsgString(                 PlotMessageIndex.CancelSheetButtonMessage,                 "Cancel Sheet"               );               ppd.set_PlotMsgString(                 PlotMessageIndex.SheetSetProgressCaption,                 "Sheet Set Progress"               );               ppd.set_PlotMsgString(                 PlotMessageIndex.SheetProgressCaption,                 "Sheet Progress"               );               ppd.LowerPlotProgressRange = 0;               ppd.UpperPlotProgressRange = 100;               ppd.PlotProgressPos = 0;               // Let's start the plot, at last               ppd.OnBeginPlot();               ppd.IsVisible = true;               pe.BeginPlot(ppd, null);               // We'll be plotting a single document               pe.BeginDocument(                 pi,                 doc.Name,                 null,                 1,                 true, // Let's plot to file                 "c:\\test-output"               );               // Which contains a single sheet               ppd.OnBeginSheet();               ppd.LowerSheetProgressRange = 0;               ppd.UpperSheetProgressRange = 100;               ppd.SheetProgressPos = 0;               PlotPageInfo ppi = new PlotPageInfo();               pe.BeginPage(                 ppi,                 pi,                 true,                 null               );               pe.BeginGenerateGraphics(null);               pe.EndGenerateGraphics(null);               // Finish the sheet               pe.EndPage(null);               ppd.SheetProgressPos = 100;               ppd.OnEndSheet();               // Finish the document               pe.EndDocument(null);               // And finish the plot               ppd.PlotProgressPos = 100;               ppd.OnEndPlot();               pe.EndPlot(null);             }           }         }         else         {           ed.WriteMessage(             "\nAnother plot is in progress."           );         }       }     }   } }

A few comments on the code: I chose to plot to a file using the standard DWF plot driver/PC3 file, mainly as it avoids having to second-guess what printers/plotters everyone uses. :-) The SDK sample populates comboboxes in a dialog to allow selection of the device and the media size, but I've just gone with a choice that should work on all systems.
Here's what you should see when you launch the SIMPLOT command:

The output file should be created in "c:\test-output.dwf".
I added a simple check to fail gracefully when another plot is in progress... as this code will drive either a foreground or a background plot (depending on the value of the BACKGROUNDPLOT system variable), there's clear scope for failure if the code doesn't check via PlotFactory.ProcessPlotState (or handle the exception if another plot is already happening when you call PlotFactory.CreatePublishEngine()).
Now that I'm online I've found there's quite a similar code sample to the ADN site (also converted from the original SDK sample, I suspect):

雪山飞狐_lzh

三、使用NetApi实现多表打印任务
September 29, 2007
Driving a multi-sheet AutoCAD plot using .NET
Somewhat symmetrically I’m posting this from Chicago airport, once again, but thankfully I’m now on my way home. It was a busy week of meetings, but I did get the chance to put together some code that extended the last post into the realm of multi-sheet plot jobs.
The following code took some work, but I finally managed to iron out the obvious wrinkles and put together an approach to plot multiple sheets into a single document. The standard DWF6 driver doesn’t appear to support multiple sheet jobs (directly, at least), so I chose to use the DWFx driver that I probably downloaded and installed from here.
I haven’t “diffed” and colour-coded the changed lines with the previous post, as there ended up being quite a lot of swapping around etc., but you should be able to perform that comparison yourself, if you so wish.
Here’s the C# code:

2. using Autodesk.AutoCAD.Runtime;
3. using Autodesk.AutoCAD.ApplicationServices;
4. using Autodesk.AutoCAD.DatabaseServices;
5. using Autodesk.AutoCAD.EditorInput;
6. using Autodesk.AutoCAD.Geometry;
7. using Autodesk.AutoCAD.PlottingServices;
8. namespace PlottingApplication
9. {
10.   public class PlottingCommands
11.   {
12.     [CommandMethod("mplot")]
13.     static public void MultiSheetPlot()
14.     {
15.       Document doc =
16.         Application.DocumentManager.MdiActiveDocument;
17.       Editor ed = doc.Editor;
18.       Database db = doc.Database;
19.       Transaction tr =
20.         db.TransactionManager.StartTransaction();
21.       using (tr)
22.       {
23.         BlockTable bt =
24.           (BlockTable)tr.GetObject(
25.             db.BlockTableId,
26.             OpenMode.ForRead
27.           );
28.         PlotInfo pi = new PlotInfo();
29.         PlotInfoValidator piv =
30.           new PlotInfoValidator();
31.         piv.MediaMatchingPolicy =
32.           MatchingPolicy.MatchEnabled;
33.         // A PlotEngine does the actual plotting
34.         // (can also create one for Preview)
35.         if (PlotFactory.ProcessPlotState ==
36.             ProcessPlotState.NotPlotting)
37.         {
38.           PlotEngine pe =
39.             PlotFactory.CreatePublishEngine();
40.           using (pe)
41.           {
42.             // Create a Progress Dialog to provide info
43.             // and allow thej user to cancel
44.             PlotProgressDialog ppd =
45.               new PlotProgressDialog(false, 1, true);
46.             using (ppd)
47.             {
48.               ObjectIdCollection layoutsToPlot =
49.                 new ObjectIdCollection();
50.               foreach (ObjectId btrId in bt)
51.               {
52.                 BlockTableRecord btr =
53.                   (BlockTableRecord)tr.GetObject(
54.                     btrId,
55.                     OpenMode.ForRead
56.                   );
57.                 if (btr.IsLayout &&
58.                     btr.Name.ToUpper() !=
59.                       BlockTableRecord.ModelSpace.ToUpper())
60.                 {
61.                   layoutsToPlot.Add(btrId);
62.                 }
63.               }
64.               int numSheet = 1;
65.               foreach (ObjectId btrId in layoutsToPlot)
66.               {
67.                 BlockTableRecord btr =
68.                   (BlockTableRecord)tr.GetObject(
69.                     btrId,
70.                     OpenMode.ForRead
71.                   );
72.                 Layout lo =
73.                   (Layout)tr.GetObject(
74.                     btr.LayoutId,
75.                     OpenMode.ForRead
76.                   );
77.                 // We need a PlotSettings object
78.                 // based on the layout settings
79.                 // which we then customize
80.                 PlotSettings ps =
81.                   new PlotSettings(lo.ModelType);
82.                 ps.CopyFrom(lo);
83.                 // The PlotSettingsValidator helps
84.                 // create a valid PlotSettings object
85.                 PlotSettingsValidator psv =
86.                   PlotSettingsValidator.Current;
87.                 // We'll plot the extents, centered and
88.                 // scaled to fit
89.                 psv.SetPlotType(
90.                   ps,
91.                 Autodesk.AutoCAD.DatabaseServices.PlotType.Extents
92.                 );
93.                 psv.SetUseStandardScale(ps, true);
94.                 psv.SetStdScaleType(ps, StdScaleType.ScaleToFit);
95.                 psv.SetPlotCentered(ps, true);
96.                 // We'll use the standard DWFx PC3, as
97.                 // this supports multiple sheets
98.                 psv.SetPlotConfigurationName(
99.                   ps,
100.                   "DWFx ePlot (XPS Compatible).pc3",
101.                   "ANSI_A_(8.50_x_11.00_Inches)"
102.                 );
103.                 // We need a PlotInfo object
104.                 // linked to the layout
105.                 pi.Layout = btr.LayoutId;
106.                 // Make the layout we're plotting current
107.                 LayoutManager.Current.CurrentLayout =
108.                   lo.LayoutName;
109.                 // We need to link the PlotInfo to the
110.                 // PlotSettings and then validate it
111.                 pi.OverrideSettings = ps;
112.                 piv.Validate(pi);
113.                 if (numSheet == 1)
114.                 {
115.                   ppd.set_PlotMsgString(
116.                     PlotMessageIndex.DialogTitle,
117.                     "Custom Plot Progress"
118.                   );
119.                   ppd.set_PlotMsgString(
120.                     PlotMessageIndex.CancelJobButtonMessage,
121.                     "Cancel Job"
122.                   );
123.                   ppd.set_PlotMsgString(
124.                     PlotMessageIndex.CancelSheetButtonMessage,
125.                     "Cancel Sheet"
126.                   );
127.                   ppd.set_PlotMsgString(
128.                     PlotMessageIndex.SheetSetProgressCaption,
129.                     "Sheet Set Progress"
130.                   );
131.                   ppd.set_PlotMsgString(
132.                     PlotMessageIndex.SheetProgressCaption,
133.                     "Sheet Progress"
134.                   );
135.                   ppd.LowerPlotProgressRange = 0;
136.                   ppd.UpperPlotProgressRange = 100;
137.                   ppd.PlotProgressPos = 0;
138.                   // Let's start the plot, at last
139.                   ppd.OnBeginPlot();
140.                   ppd.IsVisible = true;
141.                   pe.BeginPlot(ppd, null);
142.                   // We'll be plotting a single document
143.                   pe.BeginDocument(
144.                     pi,
145.                     doc.Name,
146.                     null,
147.                     1,
148.                     true, // Let's plot to file
149.                     "c:\\test-multi-sheet"
150.                   );
151.                 }
152.                 // Which may contain multiple sheets
153.                 ppd.StatusMsgString =
154.                   "Plotting " +
155.                   doc.Name.Substring(
156.                     doc.Name.LastIndexOf("\") + 1
157.                   ) +
158.                   " - sheet " + numSheet.ToString() +
159.                   " of " + layoutsToPlot.Count.ToString();
160.                 ppd.OnBeginSheet();
161.                 ppd.LowerSheetProgressRange = 0;
162.                 ppd.UpperSheetProgressRange = 100;
163.                 ppd.SheetProgressPos = 0;
164.                 PlotPageInfo ppi = new PlotPageInfo();
165.                 pe.BeginPage(
166.                   ppi,
167.                   pi,
168.                   (numSheet == layoutsToPlot.Count),
169.                   null
170.                 );
171.                 pe.BeginGenerateGraphics(null);
172.                 ppd.SheetProgressPos = 50;
173.                 pe.EndGenerateGraphics(null);
174.                 // Finish the sheet
175.                 pe.EndPage(null);
176.                 ppd.SheetProgressPos = 100;
177.                 ppd.OnEndSheet();
178.                 numSheet++;
179.               }
180.               // Finish the document
181.               pe.EndDocument(null);
182.               // And finish the plot
183.               ppd.PlotProgressPos = 100;
184.               ppd.OnEndPlot();
185.               pe.EndPlot(null);
186.             }
187.           }
188.         }
189.         else
190.         {
191.           ed.WriteMessage(
192.             "\nAnother plot is in progress."
193.           );
194.         }
195.       }
196.     }
197.   }
198. }

using Autodesk.AutoCAD.Runtime; using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.Geometry; using Autodesk.AutoCAD.PlottingServices; namespace PlottingApplication {   public class PlottingCommands   {     [CommandMethod("mplot")]     static public void MultiSheetPlot()     {       Document doc =         Application.DocumentManager.MdiActiveDocument;       Editor ed = doc.Editor;       Database db = doc.Database;       Transaction tr =         db.TransactionManager.StartTransaction();       using (tr)       {         BlockTable bt =           (BlockTable)tr.GetObject(             db.BlockTableId,             OpenMode.ForRead           );         PlotInfo pi = new PlotInfo();         PlotInfoValidator piv =           new PlotInfoValidator();         piv.MediaMatchingPolicy =           MatchingPolicy.MatchEnabled;         // A PlotEngine does the actual plotting         // (can also create one for Preview)         if (PlotFactory.ProcessPlotState ==             ProcessPlotState.NotPlotting)         {           PlotEngine pe =             PlotFactory.CreatePublishEngine();           using (pe)           {             // Create a Progress Dialog to provide info             // and allow thej user to cancel             PlotProgressDialog ppd =               new PlotProgressDialog(false, 1, true);             using (ppd)             {               ObjectIdCollection layoutsToPlot =                 new ObjectIdCollection();               foreach (ObjectId btrId in bt)               {                 BlockTableRecord btr =                   (BlockTableRecord)tr.GetObject(                     btrId,                     OpenMode.ForRead                   );                 if (btr.IsLayout &&                     btr.Name.ToUpper() !=                       BlockTableRecord.ModelSpace.ToUpper())                 {                   layoutsToPlot.Add(btrId);                 }               }               int numSheet = 1;               foreach (ObjectId btrId in layoutsToPlot)               {                 BlockTableRecord btr =                   (BlockTableRecord)tr.GetObject(                     btrId,                     OpenMode.ForRead                   );                 Layout lo =                   (Layout)tr.GetObject(                     btr.LayoutId,                     OpenMode.ForRead                   );                 // We need a PlotSettings object                 // based on the layout settings                 // which we then customize                 PlotSettings ps =                   new PlotSettings(lo.ModelType);                 ps.CopyFrom(lo);                 // The PlotSettingsValidator helps                 // create a valid PlotSettings object                 PlotSettingsValidator psv =                   PlotSettingsValidator.Current;                 // We'll plot the extents, centered and                 // scaled to fit                 psv.SetPlotType(                   ps,                 Autodesk.AutoCAD.DatabaseServices.PlotType.Extents                 );                 psv.SetUseStandardScale(ps, true);                 psv.SetStdScaleType(ps, StdScaleType.ScaleToFit);                 psv.SetPlotCentered(ps, true);                 // We'll use the standard DWFx PC3, as                 // this supports multiple sheets                 psv.SetPlotConfigurationName(                   ps,                   "DWFx ePlot (XPS Compatible).pc3",                   "ANSI_A_(8.50_x_11.00_Inches)"                 );                 // We need a PlotInfo object                 // linked to the layout                 pi.Layout = btr.LayoutId;                 // Make the layout we're plotting current                 LayoutManager.Current.CurrentLayout =                   lo.LayoutName;                 // We need to link the PlotInfo to the                 // PlotSettings and then validate it                 pi.OverrideSettings = ps;                 piv.Validate(pi);                 if (numSheet == 1)                 {                   ppd.set_PlotMsgString(                     PlotMessageIndex.DialogTitle,                     "Custom Plot Progress"                   );                   ppd.set_PlotMsgString(                     PlotMessageIndex.CancelJobButtonMessage,                     "Cancel Job"                   );                   ppd.set_PlotMsgString(                     PlotMessageIndex.CancelSheetButtonMessage,                     "Cancel Sheet"                   );                   ppd.set_PlotMsgString(                     PlotMessageIndex.SheetSetProgressCaption,                     "Sheet Set Progress"                   );                   ppd.set_PlotMsgString(                     PlotMessageIndex.SheetProgressCaption,                     "Sheet Progress"                   );                   ppd.LowerPlotProgressRange = 0;                   ppd.UpperPlotProgressRange = 100;                   ppd.PlotProgressPos = 0;                   // Let's start the plot, at last                   ppd.OnBeginPlot();                   ppd.IsVisible = true;                   pe.BeginPlot(ppd, null);                   // We'll be plotting a single document                   pe.BeginDocument(                     pi,                     doc.Name,                     null,                     1,                     true, // Let's plot to file                     "c:\\test-multi-sheet"                   );                 }                 // Which may contain multiple sheets                 ppd.StatusMsgString =                   "Plotting " +                   doc.Name.Substring(                     doc.Name.LastIndexOf("\") + 1                   ) +                   " - sheet " + numSheet.ToString() +                   " of " + layoutsToPlot.Count.ToString();                 ppd.OnBeginSheet();                 ppd.LowerSheetProgressRange = 0;                 ppd.UpperSheetProgressRange = 100;                 ppd.SheetProgressPos = 0;                 PlotPageInfo ppi = new PlotPageInfo();                 pe.BeginPage(                   ppi,                   pi,                   (numSheet == layoutsToPlot.Count),                   null                 );                 pe.BeginGenerateGraphics(null);                 ppd.SheetProgressPos = 50;                 pe.EndGenerateGraphics(null);                 // Finish the sheet                 pe.EndPage(null);                 ppd.SheetProgressPos = 100;                 ppd.OnEndSheet();                 numSheet++;               }               // Finish the document               pe.EndDocument(null);               // And finish the plot               ppd.PlotProgressPos = 100;               ppd.OnEndPlot();               pe.EndPlot(null);             }           }         }         else         {           ed.WriteMessage(             "\nAnother plot is in progress."           );         }       }     }   } }

The output of the MPLOT command will be created in “c:\test-multi-sheet.dwfx”, which can then be viewed using Autodesk Design Review 2008 or the XPS viewer that ships with Windows Vista or from here for Windows XP.
Update
I spent some more time looking at this code and noticed a minor issue... We need to tell the plot dialog that we're working with multiple sheets in its constructor. So we first need to count the sheets and then create the dialog. Here's the modified section of code:

2.           PlotEngine pe =
3.             PlotFactory.CreatePublishEngine();
4.           using (pe)
5.           {
6.             // Collect all the paperspace layouts
7.             // for plotting
8.             ObjectIdCollection layoutsToPlot =
9.               new ObjectIdCollection();
10.             foreach (ObjectId btrId in bt)
11.             {
12.               BlockTableRecord btr =
13.                 (BlockTableRecord)tr.GetObject(
14.                   btrId,
15.                   OpenMode.ForRead
16.                 );
17.               if (btr.IsLayout &&
18.                   btr.Name.ToUpper() !=
19.                     BlockTableRecord.ModelSpace.ToUpper())
20.               {
21.                 layoutsToPlot.Add(btrId);
22.               }
23.             }
24.             // Create a Progress Dialog to provide info
25.             // and allow thej user to cancel
26.             PlotProgressDialog ppd =
27.               new PlotProgressDialog(
28.                 false,
29.                 layoutsToPlot.Count,
30.                 true
31.               );
32.             using (ppd)
33.             {

          PlotEngine pe =             PlotFactory.CreatePublishEngine();           using (pe)           {             // Collect all the paperspace layouts             // for plotting             ObjectIdCollection layoutsToPlot =               new ObjectIdCollection();             foreach (ObjectId btrId in bt)             {               BlockTableRecord btr =                 (BlockTableRecord)tr.GetObject(                   btrId,                   OpenMode.ForRead                 );               if (btr.IsLayout &&                   btr.Name.ToUpper() !=                     BlockTableRecord.ModelSpace.ToUpper())               {                 layoutsToPlot.Add(btrId);               }             }             // Create a Progress Dialog to provide info             // and allow thej user to cancel             PlotProgressDialog ppd =               new PlotProgressDialog(                 false,                 layoutsToPlot.Count,                 true               );             using (ppd)             {

This now leads to the plot progress dialog showing multiple progress bars:

雪山飞狐_lzh

四、单表打印预览
October 01, 2007
Previewing and plotting a single sheet in AutoCAD using .NET
This week's posts take the code I threw together last week for single-sheet and multi-sheet plotting, and introduces the concept of "plot preview".
I'm learning as I go for much of this, so there are structural (although usually not functional) changes being made to the code as it develops. In this instance, for example, I've factored off common functionality needed by both previewing and plotting into a single helper function. This will no doubt evolve further (and change in structure) when I come to apply the principle to multi-sheet plotting later in the week.
Here's the C# code:

2. using Autodesk.AutoCAD.Runtime;
3. using Autodesk.AutoCAD.ApplicationServices;
4. using Autodesk.AutoCAD.DatabaseServices;
5. using Autodesk.AutoCAD.EditorInput;
6. using Autodesk.AutoCAD.PlottingServices;
7. namespace PlottingApplication
8. {
9.   public class PreviewCommands
10.   {
11.     [CommandMethod("simprev")]
12.     static public void SimplePreview()
13.     {
14.       Document doc =
15.         Application.DocumentManager.MdiActiveDocument;
16.       Editor ed = doc.Editor;
17.       Database db = doc.Database;
18.       // PlotEngines do the previewing and plotting
19.       if (PlotFactory.ProcessPlotState ==
20.           ProcessPlotState.NotPlotting)
21.       {
22.         // First we preview...
23.         PreviewEndPlotStatus stat;
24.         PlotEngine pre =
25.           PlotFactory.CreatePreviewEngine(
26.             (int)PreviewEngineFlags.Plot
27.           );
28.         using (pre)
29.         {
30.           stat =
31.             PlotOrPreview(
32.               pre,
33.               true,
34.               db.CurrentSpaceId,
35.               ""
36.             );
37.         }
38.         if (stat == PreviewEndPlotStatus.Plot)
39.         {
40.           // And if the user asks, we plot...
41.           PlotEngine ple =
42.             PlotFactory.CreatePublishEngine();
43.           stat =
44.             PlotOrPreview(
45.               ple,
46.               false,
47.               db.CurrentSpaceId,
48.               "c:\\previewed-plot"
49.             );
50.         }
51.       }
52.       else
53.       {
54.         ed.WriteMessage(
55.           "\nAnother plot is in progress."
56.         );
57.       }
58.     }
59.     static PreviewEndPlotStatus PlotOrPreview(
60.       PlotEngine pe,
61.       bool isPreview,
62.       ObjectId spaceId,
63.       string filename)
64.     {
65.       Document doc =
66.         Application.DocumentManager.MdiActiveDocument;
67.       Editor ed = doc.Editor;
68.       Database db = doc.Database;
69.       PreviewEndPlotStatus ret =
70.         PreviewEndPlotStatus.Cancel;
71.       Transaction tr =
72.         db.TransactionManager.StartTransaction();
73.       using (tr)
74.       {
75.         // We'll be plotting the current layout
76.         BlockTableRecord btr =
77.           (BlockTableRecord)tr.GetObject(
78.             spaceId,
79.             OpenMode.ForRead
80.           );
81.         Layout lo =
82.           (Layout)tr.GetObject(
83.             btr.LayoutId,
84.             OpenMode.ForRead
85.           );
86.         // We need a PlotInfo object
87.         // linked to the layout
88.         PlotInfo pi = new PlotInfo();
89.         pi.Layout = btr.LayoutId;
90.         // We need a PlotSettings object
91.         // based on the layout settings
92.         // which we then customize
93.         PlotSettings ps =
94.           new PlotSettings(lo.ModelType);
95.         ps.CopyFrom(lo);
96.         // The PlotSettingsValidator helps
97.         // create a valid PlotSettings object
98.         PlotSettingsValidator psv =
99.           PlotSettingsValidator.Current;
100.         // We'll plot the extents, centered and
101.         // scaled to fit
102.         psv.SetPlotType(
103.           ps,
104.           Autodesk.AutoCAD.DatabaseServices.PlotType.Extents
105.         );
106.         psv.SetUseStandardScale(ps, true);
107.         psv.SetStdScaleType(ps, StdScaleType.ScaleToFit);
108.         psv.SetPlotCentered(ps, true);
109.         // We'll use the standard DWF PC3, as
110.         // for today we're just plotting to file
111.         psv.SetPlotConfigurationName(
112.           ps,
113.           "DWF6 ePlot.pc3",
114.           "ANSI_A_(8.50_x_11.00_Inches)"
115.         );
116.         // We need to link the PlotInfo to the
117.         // PlotSettings and then validate it
118.         pi.OverrideSettings = ps;
119.         PlotInfoValidator piv =
120.           new PlotInfoValidator();
121.         piv.MediaMatchingPolicy =
122.           MatchingPolicy.MatchEnabled;
123.         piv.Validate(pi);
124.         // Create a Progress Dialog to provide info
125.         // and allow thej user to cancel
126.         PlotProgressDialog ppd =
127.           new PlotProgressDialog(isPreview, 1, true);
128.         using (ppd)
129.         {
130.           ppd.set_PlotMsgString(
131.             PlotMessageIndex.DialogTitle,
132.             "Custom Preview Progress"
133.           );
134.           ppd.set_PlotMsgString(
135.             PlotMessageIndex.SheetName,
136.             doc.Name.Substring(
137.               doc.Name.LastIndexOf("\") + 1
138.             )
139.           );
140.           ppd.set_PlotMsgString(
141.             PlotMessageIndex.CancelJobButtonMessage,
142.             "Cancel Job"
143.           );
144.           ppd.set_PlotMsgString(
145.             PlotMessageIndex.CancelSheetButtonMessage,
146.             "Cancel Sheet"
147.           );
148.           ppd.set_PlotMsgString(
149.             PlotMessageIndex.SheetSetProgressCaption,
150.             "Sheet Set Progress"
151.           );
152.           ppd.set_PlotMsgString(
153.             PlotMessageIndex.SheetProgressCaption,
154.             "Sheet Progress"
155.           );
156.           ppd.LowerPlotProgressRange = 0;
157.           ppd.UpperPlotProgressRange = 100;
158.           ppd.PlotProgressPos = 0;
159.           // Let's start the plot/preview, at last
160.           ppd.OnBeginPlot();
161.           ppd.IsVisible = true;
162.           pe.BeginPlot(ppd, null);
163.           // We'll be plotting/previewing
164.           // a single document
165.           pe.BeginDocument(
166.             pi,
167.             doc.Name,
168.             null,
169.             1,
170.             !isPreview,
171.             filename
172.           );
173.           // Which contains a single sheet
174.           ppd.OnBeginSheet();
175.           ppd.LowerSheetProgressRange = 0;
176.           ppd.UpperSheetProgressRange = 100;
177.           ppd.SheetProgressPos = 0;
178.           PlotPageInfo ppi = new PlotPageInfo();
179.           pe.BeginPage(
180.             ppi,
181.             pi,
182.             true,
183.             null
184.           );
185.           pe.BeginGenerateGraphics(null);
186.           ppd.SheetProgressPos = 50;
187.           pe.EndGenerateGraphics(null);
188.           // Finish the sheet
189.           PreviewEndPlotInfo pepi =
190.             new PreviewEndPlotInfo();
191.           pe.EndPage(pepi);
192.           ret = pepi.Status;
193.           ppd.SheetProgressPos = 100;
194.           ppd.OnEndSheet();
195.           // Finish the document
196.           pe.EndDocument(null);
197.           // And finish the plot
198.           ppd.PlotProgressPos = 100;
199.           ppd.OnEndPlot();
200.           pe.EndPlot(null);
201.         }
202.         // Committing is cheaper than aborting
203.         tr.Commit();
204.       }
205.       return ret;
206.     }
207.   }
208. }

using Autodesk.AutoCAD.Runtime; using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.PlottingServices; namespace PlottingApplication {   public class PreviewCommands   {     [CommandMethod("simprev")]     static public void SimplePreview()     {       Document doc =         Application.DocumentManager.MdiActiveDocument;       Editor ed = doc.Editor;       Database db = doc.Database;       // PlotEngines do the previewing and plotting       if (PlotFactory.ProcessPlotState ==           ProcessPlotState.NotPlotting)       {         // First we preview...         PreviewEndPlotStatus stat;         PlotEngine pre =           PlotFactory.CreatePreviewEngine(             (int)PreviewEngineFlags.Plot           );         using (pre)         {           stat =             PlotOrPreview(               pre,               true,               db.CurrentSpaceId,               ""             );         }         if (stat == PreviewEndPlotStatus.Plot)         {           // And if the user asks, we plot...           PlotEngine ple =             PlotFactory.CreatePublishEngine();           stat =             PlotOrPreview(               ple,               false,               db.CurrentSpaceId,               "c:\\previewed-plot"             );         }       }       else       {         ed.WriteMessage(           "\nAnother plot is in progress."         );       }     }     static PreviewEndPlotStatus PlotOrPreview(       PlotEngine pe,       bool isPreview,       ObjectId spaceId,       string filename)     {       Document doc =         Application.DocumentManager.MdiActiveDocument;       Editor ed = doc.Editor;       Database db = doc.Database;       PreviewEndPlotStatus ret =         PreviewEndPlotStatus.Cancel;       Transaction tr =         db.TransactionManager.StartTransaction();       using (tr)       {         // We'll be plotting the current layout         BlockTableRecord btr =           (BlockTableRecord)tr.GetObject(             spaceId,             OpenMode.ForRead           );         Layout lo =           (Layout)tr.GetObject(             btr.LayoutId,             OpenMode.ForRead           );         // We need a PlotInfo object         // linked to the layout         PlotInfo pi = new PlotInfo();         pi.Layout = btr.LayoutId;         // We need a PlotSettings object         // based on the layout settings         // which we then customize         PlotSettings ps =           new PlotSettings(lo.ModelType);         ps.CopyFrom(lo);         // The PlotSettingsValidator helps         // create a valid PlotSettings object         PlotSettingsValidator psv =           PlotSettingsValidator.Current;         // We'll plot the extents, centered and         // scaled to fit         psv.SetPlotType(           ps,           Autodesk.AutoCAD.DatabaseServices.PlotType.Extents         );         psv.SetUseStandardScale(ps, true);         psv.SetStdScaleType(ps, StdScaleType.ScaleToFit);         psv.SetPlotCentered(ps, true);         // We'll use the standard DWF PC3, as         // for today we're just plotting to file         psv.SetPlotConfigurationName(           ps,           "DWF6 ePlot.pc3",           "ANSI_A_(8.50_x_11.00_Inches)"         );         // We need to link the PlotInfo to the         // PlotSettings and then validate it         pi.OverrideSettings = ps;         PlotInfoValidator piv =           new PlotInfoValidator();         piv.MediaMatchingPolicy =           MatchingPolicy.MatchEnabled;         piv.Validate(pi);         // Create a Progress Dialog to provide info         // and allow thej user to cancel         PlotProgressDialog ppd =           new PlotProgressDialog(isPreview, 1, true);         using (ppd)         {           ppd.set_PlotMsgString(             PlotMessageIndex.DialogTitle,             "Custom Preview Progress"           );           ppd.set_PlotMsgString(             PlotMessageIndex.SheetName,             doc.Name.Substring(               doc.Name.LastIndexOf("\") + 1             )           );           ppd.set_PlotMsgString(             PlotMessageIndex.CancelJobButtonMessage,             "Cancel Job"           );           ppd.set_PlotMsgString(             PlotMessageIndex.CancelSheetButtonMessage,             "Cancel Sheet"           );           ppd.set_PlotMsgString(             PlotMessageIndex.SheetSetProgressCaption,             "Sheet Set Progress"           );           ppd.set_PlotMsgString(             PlotMessageIndex.SheetProgressCaption,             "Sheet Progress"           );           ppd.LowerPlotProgressRange = 0;           ppd.UpperPlotProgressRange = 100;           ppd.PlotProgressPos = 0;           // Let's start the plot/preview, at last           ppd.OnBeginPlot();           ppd.IsVisible = true;           pe.BeginPlot(ppd, null);           // We'll be plotting/previewing           // a single document           pe.BeginDocument(             pi,             doc.Name,             null,             1,             !isPreview,             filename           );           // Which contains a single sheet           ppd.OnBeginSheet();           ppd.LowerSheetProgressRange = 0;           ppd.UpperSheetProgressRange = 100;           ppd.SheetProgressPos = 0;           PlotPageInfo ppi = new PlotPageInfo();           pe.BeginPage(             ppi,             pi,             true,             null           );           pe.BeginGenerateGraphics(null);           ppd.SheetProgressPos = 50;           pe.EndGenerateGraphics(null);           // Finish the sheet           PreviewEndPlotInfo pepi =             new PreviewEndPlotInfo();           pe.EndPage(pepi);           ret = pepi.Status;           ppd.SheetProgressPos = 100;           ppd.OnEndSheet();           // Finish the document           pe.EndDocument(null);           // And finish the plot           ppd.PlotProgressPos = 100;           ppd.OnEndPlot();           pe.EndPlot(null);         }         // Committing is cheaper than aborting         tr.Commit();       }       return ret;     }   } }

When you execute the SIMPREV command, you receive enter a "preview" mode, from where you can either cancel or plot. The trick was really in determining the button selected by the user, which we do by passing an appropriate object (of class PreviewEndPlotInfo) into the EndPage() function, to collect information on what the users selects. The next post will take this further, allowing the user to cycle through multiple sheets using "next" and "previous" buttons.

雪山飞狐_lzh

五、多表打印预览
October 04, 2007
Previewing and plotting multiple sheets in AutoCAD using .NET
This was a fun one to work on. The code in this post combines and extends upon techniques shown in two earlier posts: one showing how to plot multiple sheets and the other showing how to preview a single-sheet plot.
One of the key differences when plotting or previewing is that while plotting can directly support multiple sheets (assuming the device does so), previewing does not. The good news is that AutoCAD provides you the user interface elements to allow cycling through plots: the user is provided with "Next" and "revious" buttons - it's then up to you to implement the appropriate logic to preview different sheets when the buttons are used.
I chose to use the same helper function for both preview and plot, even though they are a little different in nature. The reason is obvious (to me, at least) - it reduces the amount of code to debug and maintain - but it might, for some, make the code a little less easy to read. Ultimately the trick I used was to reduce the set of sheets being handled at the beginning of the function to a single sheet in the case of a preview, which allowed me to combine both approaches in a single function.
Here's the C# code:

2. using Autodesk.AutoCAD.Runtime;
3. using Autodesk.AutoCAD.ApplicationServices;
4. using Autodesk.AutoCAD.DatabaseServices;
5. using Autodesk.AutoCAD.EditorInput;
6. using Autodesk.AutoCAD.PlottingServices;
7. using System.Collections.Generic;
8. namespace PlottingApplication
9. {
10.   public class PreviewCommands
11.   {
12.     [CommandMethod("mprev")]
13.     static public void MultiSheetPreview()
14.     {
15.       Document doc =
16.         Application.DocumentManager.MdiActiveDocument;
17.       Editor ed = doc.Editor;
18.       Database db = doc.Database;
19.       ObjectIdCollection layoutsToPlot =
20.         new ObjectIdCollection();
21.       Transaction tr =
22.         db.TransactionManager.StartTransaction();
23.       using (tr)
24.       {
25.         // First we need to collect the layouts to
26.         // plot/preview in tab order
27.         SortedDictionary<int, ObjectId> layoutDict =
28.           new SortedDictionary<int, ObjectId>();
29.         BlockTable bt =
30.           (BlockTable)tr.GetObject(
31.             db.BlockTableId,
32.             OpenMode.ForRead
33.           );
34.         foreach (ObjectId btrId in bt)
35.         {
36.           BlockTableRecord btr =
37.             (BlockTableRecord)tr.GetObject(
38.               btrId,
39.               OpenMode.ForRead
40.             );
41.           if (btr.IsLayout &&
42.               btr.Name.ToUpper() !=
43.                 BlockTableRecord.ModelSpace.ToUpper())
44.           {
45.             // The dictionary we're using will
46.             // sort on the tab order of the layout
47.             Layout lo =
48.               (Layout)tr.GetObject(
49.                 btr.LayoutId,
50.                 OpenMode.ForRead
51.               );
52.             layoutDict.Add(lo.TabOrder,btrId);
53.           }
54.         }
55.         // Let's now get the layout IDs and add them to a
56.         // standard ObjectIdCollection
57.         SortedDictionary<int,ObjectId>.ValueCollection vc =
58.           layoutDict.Values;
59.         foreach (ObjectId id in vc)
60.         {
61.           layoutsToPlot.Add(id);
62.         }
63.         // Committing is cheaper than aborting
64.         tr.Commit();
65.       }
66.       // PlotEngines do the previewing and plotting
67.       if (PlotFactory.ProcessPlotState ==
68.           ProcessPlotState.NotPlotting)
69.       {
70.         int layoutNum = 0;
71.         bool isFinished = false;
72.         bool isReadyForPlot = false;
73.         while (!isFinished)
74.         {
75.           // Create the preview engine with the appropriate
76.           // buttons enabled - this depends on which
77.           // layout in the list is being previewed
78.           PreviewEngineFlags flags =
79.             PreviewEngineFlags.Plot;
80.           if (layoutNum > 0)
81.             flags |= PreviewEngineFlags.PreviousSheet;
82.           if (layoutNum < layoutsToPlot.Count - 1)
83.             flags |= PreviewEngineFlags.NextSheet;
84.           PlotEngine pre =
85.             PlotFactory.CreatePreviewEngine((int)flags);
86.           using (pre)
87.           {
88.             PreviewEndPlotStatus stat =
89.               MultiplePlotOrPreview(
90.                 pre,
91.                 true,
92.                 layoutsToPlot,
93.                 layoutNum,
94.                 ""
95.               );
96.             // We're not checking the list bounds for
97.             // next/previous as the buttons are only shown
98.             // when they can be used
99.             if (stat == PreviewEndPlotStatus.Next)
100.             {
101.               layoutNum++;
102.             }
103.             else if (stat == PreviewEndPlotStatus.Previous)
104.             {
105.               layoutNum--;
106.             }
107.             else if (stat == PreviewEndPlotStatus.Normal ||
108.                     stat == PreviewEndPlotStatus.Cancel)
109.             {
110.               isFinished = true;
111.             }
112.             else if (stat == PreviewEndPlotStatus.Plot)
113.             {
114.               isFinished = true;
115.               isReadyForPlot = true;
116.             }
117.           }
118.         }
119.         // If the plot button was used to exit the preview...
120.         if (isReadyForPlot)
121.         {
122.           PlotEngine ple =
123.             PlotFactory.CreatePublishEngine();
124.           using (ple)
125.           {
126.             PreviewEndPlotStatus stat =
127.               MultiplePlotOrPreview(
128.                 ple,
129.                 false,
130.                 layoutsToPlot,
131.                 -1,
132.                 "c:\\multisheet-previewed-plot"
133.               );
134.           }
135.         }
136.       }
137.       else
138.       {
139.         ed.WriteMessage(
140.           "\nAnother plot is in progress."
141.         );
142.       }
143.     }
144.     static PreviewEndPlotStatus MultiplePlotOrPreview(
145.       PlotEngine pe,
146.       bool isPreview,
147.       ObjectIdCollection layoutSet,
148.       int layoutNumIfPreview,
149.       string filename
150.     )
151.     {
152.       Document doc =
153.         Application.DocumentManager.MdiActiveDocument;
154.       Editor ed = doc.Editor;
155.       Database db = doc.Database;
156.       PreviewEndPlotStatus ret =
157.         PreviewEndPlotStatus.Cancel;
158.       ObjectIdCollection layoutsToPlot;
159.       if (isPreview && layoutNumIfPreview >= 0)
160.       {
161.         // Preview is really pre-sheet, so we reduce the
162.         // sheet collection to contain the one we want
163.         layoutsToPlot = new ObjectIdCollection();
164.         layoutsToPlot.Add(
165.           layoutSet[layoutNumIfPreview]
166.         );
167.       }
168.       else
169.       {
170.         // If we're plotting we need all the sheets,
171.         // so copy the ObjectIds across
172.         ObjectId[] ids = new ObjectId[layoutSet.Count];
173.         layoutSet.CopyTo(ids,0);
174.         layoutsToPlot = new ObjectIdCollection(ids);
175.       }
176.       Transaction tr =
177.         db.TransactionManager.StartTransaction();
178.       using (tr)
179.       {
180.         // Create a Progress Dialog to provide info
181.         // and allow thej user to cancel
182.         PlotProgressDialog ppd =
183.           new PlotProgressDialog(
184.             isPreview,
185.             layoutsToPlot.Count,
186.             true
187.           );
188.         using (ppd)
189.         {
190.           int numSheet = 1;
191.           foreach (ObjectId btrId in layoutsToPlot)
192.           {
193.             BlockTableRecord btr =
194.               (BlockTableRecord)tr.GetObject(
195.                 btrId,
196.                 OpenMode.ForRead
197.               );
198.             Layout lo =
199.               (Layout)tr.GetObject(
200.                 btr.LayoutId,
201.                 OpenMode.ForRead
202.               );
203.             // We need a PlotSettings object
204.             // based on the layout settings
205.             // which we then customize
206.             PlotSettings ps =
207.               new PlotSettings(lo.ModelType);
208.             ps.CopyFrom(lo);
209.             // The PlotSettingsValidator helps
210.             // create a valid PlotSettings object
211.             PlotSettingsValidator psv =
212.               PlotSettingsValidator.Current;
213.             // We'll plot the extents, centered and
214.             // scaled to fit
215.             psv.SetPlotType(
216.               ps,
217.               Autodesk.AutoCAD.DatabaseServices.PlotType.Extents
218.             );
219.             psv.SetUseStandardScale(ps, true);
220.             psv.SetStdScaleType(ps, StdScaleType.ScaleToFit);
221.             psv.SetPlotCentered(ps, true);
222.             // We'll use the standard DWFx PC3, as
223.             // this supports multiple sheets
224.             psv.SetPlotConfigurationName(
225.               ps,
226.               "DWFx ePlot (XPS Compatible).pc3",
227.               "ANSI_A_(8.50_x_11.00_Inches)"
228.             );
229.             // We need a PlotInfo object
230.             // linked to the layout
231.             PlotInfo pi = new PlotInfo();
232.             pi.Layout = btr.LayoutId;
233.             // Make the layout we're plotting current
234.             LayoutManager.Current.CurrentLayout =
235.               lo.LayoutName;
236.             // We need to link the PlotInfo to the
237.             // PlotSettings and then validate it
238.             pi.OverrideSettings = ps;
239.             PlotInfoValidator piv =
240.               new PlotInfoValidator();
241.             piv.MediaMatchingPolicy =
242.               MatchingPolicy.MatchEnabled;
243.             piv.Validate(pi);
244.             // We set the sheet name per sheet
245.             ppd.set_PlotMsgString(
246.               PlotMessageIndex.SheetName,
247.               doc.Name.Substring(
248.                 doc.Name.LastIndexOf("\") + 1
249.               ) +
250.               " - " +
251.               lo.LayoutName
252.             );
253.             if (numSheet == 1)
254.             {
255.               // All other messages get set once
256.               ppd.set_PlotMsgString(
257.                 PlotMessageIndex.DialogTitle,
258.                 "Custom Preview Progress"
259.               );
260.               ppd.set_PlotMsgString(
261.                 PlotMessageIndex.CancelJobButtonMessage,
262.                 "Cancel Job"
263.               );
264.               ppd.set_PlotMsgString(
265.                 PlotMessageIndex.CancelSheetButtonMessage,
266.                 "Cancel Sheet"
267.               );
268.               ppd.set_PlotMsgString(
269.                 PlotMessageIndex.SheetSetProgressCaption,
270.                 "Sheet Set Progress"
271.               );
272.               ppd.set_PlotMsgString(
273.                 PlotMessageIndex.SheetProgressCaption,
274.                 "Sheet Progress"
275.               );
276.               ppd.LowerPlotProgressRange = 0;
277.               ppd.UpperPlotProgressRange = 100;
278.               ppd.PlotProgressPos = 0;
279.               // Let's start the plot/preview, at last
280.               ppd.OnBeginPlot();
281.               ppd.IsVisible = true;
282.               pe.BeginPlot(ppd, null);
283.               // We'll be plotting a single document
284.               pe.BeginDocument(
285.                 pi,
286.                 doc.Name,
287.                 null,
288.                 1,
289.                 !isPreview,
290.                 filename
291.               );
292.             }
293.             // Which may contains multiple sheets
294.             ppd.LowerSheetProgressRange = 0;
295.             ppd.UpperSheetProgressRange = 100;
296.             ppd.SheetProgressPos = 0;
297.             PlotPageInfo ppi = new PlotPageInfo();
298.             pe.BeginPage(
299.               ppi,
300.               pi,
301.               (numSheet == layoutsToPlot.Count),
302.               null
303.             );
304.             ppd.OnBeginSheet();
305.             pe.BeginGenerateGraphics(null);
306.             ppd.SheetProgressPos = 50;
307.             pe.EndGenerateGraphics(null);
308.             // Finish the sheet
309.             PreviewEndPlotInfo pepi =
310.               new PreviewEndPlotInfo();
311.             pe.EndPage(pepi);
312.             ret = pepi.Status;
313.             ppd.SheetProgressPos = 100;
314.             ppd.OnEndSheet();
315.             numSheet++;
316.             // Update the overall progress
317.             ppd.PlotProgressPos +=
318.               (100 / layoutsToPlot.Count);
319.           }
320.           // Finish the document
321.           pe.EndDocument(null);
322.           // And finish the plot
323.           ppd.PlotProgressPos = 100;
324.           ppd.OnEndPlot();
325.           pe.EndPlot(null);
326.         }
327.       }
328.       return ret;
329.     }
330.   }
331. }

using Autodesk.AutoCAD.Runtime; using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.PlottingServices; using System.Collections.Generic; namespace PlottingApplication {   public class PreviewCommands   {     [CommandMethod("mprev")]     static public void MultiSheetPreview()     {       Document doc =         Application.DocumentManager.MdiActiveDocument;       Editor ed = doc.Editor;       Database db = doc.Database;       ObjectIdCollection layoutsToPlot =         new ObjectIdCollection();       Transaction tr =         db.TransactionManager.StartTransaction();       using (tr)       {         // First we need to collect the layouts to         // plot/preview in tab order         SortedDictionary<int, ObjectId> layoutDict =           new SortedDictionary<int, ObjectId>();         BlockTable bt =           (BlockTable)tr.GetObject(             db.BlockTableId,             OpenMode.ForRead           );         foreach (ObjectId btrId in bt)         {           BlockTableRecord btr =             (BlockTableRecord)tr.GetObject(               btrId,               OpenMode.ForRead             );           if (btr.IsLayout &&               btr.Name.ToUpper() !=                 BlockTableRecord.ModelSpace.ToUpper())           {             // The dictionary we're using will             // sort on the tab order of the layout             Layout lo =               (Layout)tr.GetObject(                 btr.LayoutId,                 OpenMode.ForRead               );             layoutDict.Add(lo.TabOrder,btrId);           }         }         // Let's now get the layout IDs and add them to a         // standard ObjectIdCollection         SortedDictionary<int,ObjectId>.ValueCollection vc =           layoutDict.Values;         foreach (ObjectId id in vc)         {           layoutsToPlot.Add(id);         }         // Committing is cheaper than aborting         tr.Commit();       }       // PlotEngines do the previewing and plotting       if (PlotFactory.ProcessPlotState ==           ProcessPlotState.NotPlotting)       {         int layoutNum = 0;         bool isFinished = false;         bool isReadyForPlot = false;         while (!isFinished)         {           // Create the preview engine with the appropriate           // buttons enabled - this depends on which           // layout in the list is being previewed           PreviewEngineFlags flags =             PreviewEngineFlags.Plot;           if (layoutNum > 0)             flags |= PreviewEngineFlags.PreviousSheet;           if (layoutNum < layoutsToPlot.Count - 1)             flags |= PreviewEngineFlags.NextSheet;           PlotEngine pre =             PlotFactory.CreatePreviewEngine((int)flags);           using (pre)           {             PreviewEndPlotStatus stat =               MultiplePlotOrPreview(                 pre,                 true,                 layoutsToPlot,                 layoutNum,                 ""               );             // We're not checking the list bounds for             // next/previous as the buttons are only shown             // when they can be used             if (stat == PreviewEndPlotStatus.Next)             {               layoutNum++;             }             else if (stat == PreviewEndPlotStatus.Previous)             {               layoutNum--;             }             else if (stat == PreviewEndPlotStatus.Normal ||                     stat == PreviewEndPlotStatus.Cancel)             {               isFinished = true;             }             else if (stat == PreviewEndPlotStatus.Plot)             {               isFinished = true;               isReadyForPlot = true;             }           }         }         // If the plot button was used to exit the preview...         if (isReadyForPlot)         {           PlotEngine ple =             PlotFactory.CreatePublishEngine();           using (ple)           {             PreviewEndPlotStatus stat =               MultiplePlotOrPreview(                 ple,                 false,                 layoutsToPlot,                 -1,                 "c:\\multisheet-previewed-plot"               );           }         }       }       else       {         ed.WriteMessage(           "\nAnother plot is in progress."         );       }     }     static PreviewEndPlotStatus MultiplePlotOrPreview(       PlotEngine pe,       bool isPreview,       ObjectIdCollection layoutSet,       int layoutNumIfPreview,       string filename     )     {       Document doc =         Application.DocumentManager.MdiActiveDocument;       Editor ed = doc.Editor;       Database db = doc.Database;       PreviewEndPlotStatus ret =         PreviewEndPlotStatus.Cancel;       ObjectIdCollection layoutsToPlot;       if (isPreview && layoutNumIfPreview >= 0)       {         // Preview is really pre-sheet, so we reduce the         // sheet collection to contain the one we want         layoutsToPlot = new ObjectIdCollection();         layoutsToPlot.Add(           layoutSet[layoutNumIfPreview]         );       }       else       {         // If we're plotting we need all the sheets,         // so copy the ObjectIds across         ObjectId[] ids = new ObjectId[layoutSet.Count];         layoutSet.CopyTo(ids,0);         layoutsToPlot = new ObjectIdCollection(ids);       }       Transaction tr =         db.TransactionManager.StartTransaction();       using (tr)       {         // Create a Progress Dialog to provide info         // and allow thej user to cancel         PlotProgressDialog ppd =           new PlotProgressDialog(             isPreview,             layoutsToPlot.Count,             true           );         using (ppd)         {           int numSheet = 1;           foreach (ObjectId btrId in layoutsToPlot)           {             BlockTableRecord btr =               (BlockTableRecord)tr.GetObject(                 btrId,                 OpenMode.ForRead               );             Layout lo =               (Layout)tr.GetObject(                 btr.LayoutId,                 OpenMode.ForRead               );             // We need a PlotSettings object             // based on the layout settings             // which we then customize             PlotSettings ps =               new PlotSettings(lo.ModelType);             ps.CopyFrom(lo);             // The PlotSettingsValidator helps             // create a valid PlotSettings object             PlotSettingsValidator psv =               PlotSettingsValidator.Current;             // We'll plot the extents, centered and             // scaled to fit             psv.SetPlotType(               ps,               Autodesk.AutoCAD.DatabaseServices.PlotType.Extents             );             psv.SetUseStandardScale(ps, true);             psv.SetStdScaleType(ps, StdScaleType.ScaleToFit);             psv.SetPlotCentered(ps, true);             // We'll use the standard DWFx PC3, as             // this supports multiple sheets             psv.SetPlotConfigurationName(               ps,               "DWFx ePlot (XPS Compatible).pc3",               "ANSI_A_(8.50_x_11.00_Inches)"             );             // We need a PlotInfo object             // linked to the layout             PlotInfo pi = new PlotInfo();             pi.Layout = btr.LayoutId;             // Make the layout we're plotting current             LayoutManager.Current.CurrentLayout =               lo.LayoutName;             // We need to link the PlotInfo to the             // PlotSettings and then validate it             pi.OverrideSettings = ps;             PlotInfoValidator piv =               new PlotInfoValidator();             piv.MediaMatchingPolicy =               MatchingPolicy.MatchEnabled;             piv.Validate(pi);             // We set the sheet name per sheet             ppd.set_PlotMsgString(               PlotMessageIndex.SheetName,               doc.Name.Substring(                 doc.Name.LastIndexOf("\") + 1               ) +               " - " +               lo.LayoutName             );             if (numSheet == 1)             {               // All other messages get set once               ppd.set_PlotMsgString(                 PlotMessageIndex.DialogTitle,                 "Custom Preview Progress"               );               ppd.set_PlotMsgString(                 PlotMessageIndex.CancelJobButtonMessage,                 "Cancel Job"               );               ppd.set_PlotMsgString(                 PlotMessageIndex.CancelSheetButtonMessage,                 "Cancel Sheet"               );               ppd.set_PlotMsgString(                 PlotMessageIndex.SheetSetProgressCaption,                 "Sheet Set Progress"               );               ppd.set_PlotMsgString(                 PlotMessageIndex.SheetProgressCaption,                 "Sheet Progress"               );               ppd.LowerPlotProgressRange = 0;               ppd.UpperPlotProgressRange = 100;               ppd.PlotProgressPos = 0;               // Let's start the plot/preview, at last               ppd.OnBeginPlot();               ppd.IsVisible = true;               pe.BeginPlot(ppd, null);               // We'll be plotting a single document               pe.BeginDocument(                 pi,                 doc.Name,                 null,                 1,                 !isPreview,                 filename               );             }             // Which may contains multiple sheets             ppd.LowerSheetProgressRange = 0;             ppd.UpperSheetProgressRange = 100;             ppd.SheetProgressPos = 0;             PlotPageInfo ppi = new PlotPageInfo();             pe.BeginPage(               ppi,               pi,               (numSheet == layoutsToPlot.Count),               null             );             ppd.OnBeginSheet();             pe.BeginGenerateGraphics(null);             ppd.SheetProgressPos = 50;             pe.EndGenerateGraphics(null);             // Finish the sheet             PreviewEndPlotInfo pepi =               new PreviewEndPlotInfo();             pe.EndPage(pepi);             ret = pepi.Status;             ppd.SheetProgressPos = 100;             ppd.OnEndSheet();             numSheet++;             // Update the overall progress             ppd.PlotProgressPos +=               (100 / layoutsToPlot.Count);           }           // Finish the document           pe.EndDocument(null);           // And finish the plot           ppd.PlotProgressPos = 100;           ppd.OnEndPlot();           pe.EndPlot(null);         }       }       return ret;     }   } }

Here's what you see when you run the MPREV command:

Once you select the plot button, the plot gets driven as before:

雪山飞狐_lzh

六、选择打印设备和打印介质
October 09, 2007
Allowing selection of an AutoCAD plot device and media name using .NET
A comment came in on this previous post regarding how best to know whether a media name is valid during your plot configuration.
There are a few approaches, other than the one I chose of hardcoding the device and media names. The first is to implement a user interface of some kind which allows the user to select the device and media names. Another approach for setting the media name is to use PlotSettingsValidator.SetClosestMediaName() to choose the media name that most closely matches the paper size you desire.
Today I'll focus on the first option, although I'm only going to implement a basic, command-line user interface. It should be straightforward to extend this to implement a WinForm with comboboxes for the device and media names.
I implemented a simple function called ChooseDeviceAndMedia() which queries the current device list, allows selection from it, and then gets the media name list and allows selection from that. I chose not to worry about displaying locale-specific names, for now - I'll leave that for a future post (let me know if you're interested :-).
Here's the function integrated into the C# code from this previous post, which defines a command called MPLOT:

2. using Autodesk.AutoCAD.Runtime;
3. using Autodesk.AutoCAD.ApplicationServices;
4. using Autodesk.AutoCAD.DatabaseServices;
5. using Autodesk.AutoCAD.EditorInput;
6. using Autodesk.AutoCAD.Geometry;
7. using Autodesk.AutoCAD.PlottingServices;
8. using System.Collections.Specialized;
9. namespace PlottingApplication
10. {
11.   public class PlottingCommands
12.   {
13.     static public string[] ChooseDeviceAndMedia()
14.     {
15.       Document doc =
16.         Application.DocumentManager.MdiActiveDocument;
17.       Editor ed = doc.Editor;
18.       // Assign default return values
19.       string devname = "", medname = "";
20.       PlotSettingsValidator psv =
21.         PlotSettingsValidator.Current;
22.       // Let's first select the device
23.       StringCollection devlist =
24.         psv.GetPlotDeviceList();
25.       for (int i = 0; i < devlist.Count; i++)
26.       {
27.         ed.WriteMessage(
28.           "\n{0} {1}",
29.           i + 1,
30.           devlist[i]
31.         );
32.       }
33.       PromptIntegerOptions opts =
34.         new PromptIntegerOptions(
35.           "\nEnter number of device to select: "
36.         );
37.       opts.LowerLimit = 1;
38.       opts.UpperLimit = devlist.Count;
39.       PromptIntegerResult pir =
40.         ed.GetInteger(opts);
41.       if (pir.Status == PromptStatus.OK)
42.       {
43.         devname = devlist[pir.Value - 1];
44.         ed.WriteMessage(
45.           "\nSelected: {0}\n",
46.           devname
47.         );
48.         // Now let's select the media
49.         PlotSettings ps = new PlotSettings(true);
50.         using (ps)
51.         {
52.           // We should refresh the lists,
53.           // in case setting the device impacts
54.           // the available media
55.           psv.SetPlotConfigurationName(
56.             ps,
57.             devname,
58.             null
59.           );
60.           psv.RefreshLists(ps);
61.           StringCollection medlist =
62.             psv.GetCanonicalMediaNameList(ps);
63.           for (int i = 0; i < medlist.Count; i++)
64.           {
65.             ed.WriteMessage(
66.               "\n{0} {1}",
67.               i + 1,
68.               medlist[i]
69.             );
70.           }
71.           opts.Message =
72.             "\nEnter number of media to select: ";
73.           opts.LowerLimit = 1;
74.           opts.UpperLimit = medlist.Count;
75.           pir = ed.GetInteger(opts);
76.           if (pir.Status == PromptStatus.OK)
77.           {
78.             medname = medlist[pir.Value - 1];
79.             ed.WriteMessage(
80.               "\nSelected: {0}\n",
81.               medname
82.             );
83.           }
84.         }
85.       }
86.       return new string[2] { devname, medname };
87.     }
88.     [CommandMethod("mplot")]
89.     static public void MultiSheetPlot()
90.     {
91.       Document doc =
92.         Application.DocumentManager.MdiActiveDocument;
93.       Editor ed = doc.Editor;
94.       Database db = doc.Database;
95.       Transaction tr =
96.         db.TransactionManager.StartTransaction();
97.       using (tr)
98.       {
99.         BlockTable bt =
100.           (BlockTable)tr.GetObject(
101.             db.BlockTableId,
102.             OpenMode.ForRead
103.           );
104.         PlotInfo pi = new PlotInfo();
105.         PlotInfoValidator piv =
106.           new PlotInfoValidator();
107.         piv.MediaMatchingPolicy =
108.           MatchingPolicy.MatchEnabled;
109.         // A PlotEngine does the actual plotting
110.         // (can also create one for Preview)
111.         if (PlotFactory.ProcessPlotState ==
112.             ProcessPlotState.NotPlotting)
113.         {
114.           string[] devmed = ChooseDeviceAndMedia();
115.           // Only proceed if we have values for both
116.           if (devmed[0] != "" && devmed[1] != "")
117.           {
118.             string devname = devmed[0];
119.             string medname = devmed[1];
120.             PlotEngine pe =
121.               PlotFactory.CreatePublishEngine();
122.             using (pe)
123.             {
124.               // Collect all the paperspace layouts
125.               // for plotting
126.               ObjectIdCollection layoutsToPlot =
127.                 new ObjectIdCollection();
128.               foreach (ObjectId btrId in bt)
129.               {
130.                 BlockTableRecord btr =
131.                   (BlockTableRecord)tr.GetObject(
132.                     btrId,
133.                     OpenMode.ForRead
134.                   );
135.                 if (btr.IsLayout &&
136.                     btr.Name.ToUpper() !=
137.                       BlockTableRecord.ModelSpace.ToUpper())
138.                 {
139.                   layoutsToPlot.Add(btrId);
140.                 }
141.               }
142.               // Create a Progress Dialog to provide info
143.               // and allow thej user to cancel
144.               PlotProgressDialog ppd =
145.                 new PlotProgressDialog(
146.                   false,
147.                   layoutsToPlot.Count,
148.                   true
149.                 );
150.               using (ppd)
151.               {
152.                 int numSheet = 1;
153.                 foreach (ObjectId btrId in layoutsToPlot)
154.                 {
155.                   BlockTableRecord btr =
156.                     (BlockTableRecord)tr.GetObject(
157.                       btrId,
158.                       OpenMode.ForRead
159.                     );
160.                   Layout lo =
161.                     (Layout)tr.GetObject(
162.                       btr.LayoutId,
163.                       OpenMode.ForRead
164.                     );
165.                   // We need a PlotSettings object
166.                   // based on the layout settings
167.                   // which we then customize
168.                   PlotSettings ps =
169.                     new PlotSettings(lo.ModelType);
170.                   ps.CopyFrom(lo);
171.                   // The PlotSettingsValidator helps
172.                   // create a valid PlotSettings object
173.                   PlotSettingsValidator psv =
174.                     PlotSettingsValidator.Current;
175.                   // We'll plot the extents, centered and
176.                   // scaled to fit
177.                   psv.SetPlotType(
178.                     ps,
179.                   Autodesk.AutoCAD.DatabaseServices.PlotType.Extents
180.                   );
181.                   psv.SetUseStandardScale(ps, true);
182.                   psv.SetStdScaleType(ps, StdScaleType.ScaleToFit);
183.                   psv.SetPlotCentered(ps, true);
184.                   // We'll use the standard DWFx PC3, as
185.                   // this supports multiple sheets
186.                   psv.SetPlotConfigurationName(
187.                     ps,
188.                     devname,
189.                     medname
190.                   );
191.                   // We need a PlotInfo object
192.                   // linked to the layout
193.                   pi.Layout = btr.LayoutId;
194.                   // Make the layout we're plotting current
195.                   LayoutManager.Current.CurrentLayout =
196.                     lo.LayoutName;
197.                   // We need to link the PlotInfo to the
198.                   // PlotSettings and then validate it
199.                   pi.OverrideSettings = ps;
200.                   piv.Validate(pi);
201.                   if (numSheet == 1)
202.                   {
203.                     ppd.set_PlotMsgString(
204.                       PlotMessageIndex.DialogTitle,
205.                       "Custom Plot Progress"
206.                     );
207.                     ppd.set_PlotMsgString(
208.                       PlotMessageIndex.CancelJobButtonMessage,
209.                       "Cancel Job"
210.                     );
211.                     ppd.set_PlotMsgString(
212.                       PlotMessageIndex.CancelSheetButtonMessage,
213.                       "Cancel Sheet"
214.                     );
215.                     ppd.set_PlotMsgString(
216.                       PlotMessageIndex.SheetSetProgressCaption,
217.                       "Sheet Set Progress"
218.                     );
219.                     ppd.set_PlotMsgString(
220.                       PlotMessageIndex.SheetProgressCaption,
221.                       "Sheet Progress"
222.                     );
223.                     ppd.LowerPlotProgressRange = 0;
224.                     ppd.UpperPlotProgressRange = 100;
225.                     ppd.PlotProgressPos = 0;
226.                     // Let's start the plot, at last
227.                     ppd.OnBeginPlot();
228.                     ppd.IsVisible = true;
229.                     pe.BeginPlot(ppd, null);
230.                     // We'll be plotting a single document
231.                     pe.BeginDocument(
232.                       pi,
233.                       doc.Name,
234.                       null,
235.                       1,
236.                       true, // Let's plot to file
237.                       "c:\\test-multi-sheet"
238.                     );
239.                   }
240.                   // Which may contains multiple sheets
241.                   ppd.set_PlotMsgString(
242.                     PlotMessageIndex.SheetName,
243.                     doc.Name.Substring(
244.                       doc.Name.LastIndexOf("\") + 1
245.                     ) +
246.                     " - sheet " + numSheet.ToString() +
247.                     " of " + layoutsToPlot.Count.ToString()
248.                   );
249.                   ppd.OnBeginSheet();
250.                   ppd.LowerSheetProgressRange = 0;
251.                   ppd.UpperSheetProgressRange = 100;
252.                   ppd.SheetProgressPos = 0;
253.                   PlotPageInfo ppi = new PlotPageInfo();
254.                   pe.BeginPage(
255.                     ppi,
256.                     pi,
257.                     (numSheet == layoutsToPlot.Count),
258.                     null
259.                   );
260.                   pe.BeginGenerateGraphics(null);
261.                   ppd.SheetProgressPos = 50;
262.                   pe.EndGenerateGraphics(null);
263.                   // Finish the sheet
264.                   pe.EndPage(null);
265.                   ppd.SheetProgressPos = 100;
266.                   ppd.OnEndSheet();
267.                   numSheet++;
268.                   ppd.PlotProgressPos +=
269.                     (100 / layoutsToPlot.Count);
270.                 }
271.                 // Finish the document
272.                 pe.EndDocument(null);
273.                 // And finish the plot
274.                 ppd.PlotProgressPos = 100;
275.                 ppd.OnEndPlot();
276.                 pe.EndPlot(null);
277.               }
278.             }
279.           }
280.         }
281.         else
282.         {
283.           ed.WriteMessage(
284.             "\nAnother plot is in progress."
285.           );
286.         }
287.       }
288.     }
289.   }
290. }

using Autodesk.AutoCAD.Runtime; using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.Geometry; using Autodesk.AutoCAD.PlottingServices; using System.Collections.Specialized; namespace PlottingApplication {   public class PlottingCommands   {     static public string[] ChooseDeviceAndMedia()     {       Document doc =         Application.DocumentManager.MdiActiveDocument;       Editor ed = doc.Editor;       // Assign default return values       string devname = "", medname = "";       PlotSettingsValidator psv =         PlotSettingsValidator.Current;       // Let's first select the device       StringCollection devlist =         psv.GetPlotDeviceList();       for (int i = 0; i < devlist.Count; i++)       {         ed.WriteMessage(           "\n{0} {1}",           i + 1,           devlist[i]         );       }       PromptIntegerOptions opts =         new PromptIntegerOptions(           "\nEnter number of device to select: "         );       opts.LowerLimit = 1;       opts.UpperLimit = devlist.Count;       PromptIntegerResult pir =         ed.GetInteger(opts);       if (pir.Status == PromptStatus.OK)       {         devname = devlist[pir.Value - 1];         ed.WriteMessage(           "\nSelected: {0}\n",           devname         );         // Now let's select the media         PlotSettings ps = new PlotSettings(true);         using (ps)         {           // We should refresh the lists,           // in case setting the device impacts           // the available media           psv.SetPlotConfigurationName(             ps,             devname,             null           );           psv.RefreshLists(ps);           StringCollection medlist =             psv.GetCanonicalMediaNameList(ps);           for (int i = 0; i < medlist.Count; i++)           {             ed.WriteMessage(               "\n{0} {1}",               i + 1,               medlist[i]             );           }           opts.Message =             "\nEnter number of media to select: ";           opts.LowerLimit = 1;           opts.UpperLimit = medlist.Count;           pir = ed.GetInteger(opts);           if (pir.Status == PromptStatus.OK)           {             medname = medlist[pir.Value - 1];             ed.WriteMessage(               "\nSelected: {0}\n",               medname             );           }         }       }       return new string[2] { devname, medname };     }     [CommandMethod("mplot")]     static public void MultiSheetPlot()     {       Document doc =         Application.DocumentManager.MdiActiveDocument;       Editor ed = doc.Editor;       Database db = doc.Database;       Transaction tr =         db.TransactionManager.StartTransaction();       using (tr)       {         BlockTable bt =           (BlockTable)tr.GetObject(             db.BlockTableId,             OpenMode.ForRead           );         PlotInfo pi = new PlotInfo();         PlotInfoValidator piv =           new PlotInfoValidator();         piv.MediaMatchingPolicy =           MatchingPolicy.MatchEnabled;         // A PlotEngine does the actual plotting         // (can also create one for Preview)         if (PlotFactory.ProcessPlotState ==             ProcessPlotState.NotPlotting)         {           string[] devmed = ChooseDeviceAndMedia();           // Only proceed if we have values for both           if (devmed[0] != "" && devmed[1] != "")           {             string devname = devmed[0];             string medname = devmed[1];             PlotEngine pe =               PlotFactory.CreatePublishEngine();             using (pe)             {               // Collect all the paperspace layouts               // for plotting               ObjectIdCollection layoutsToPlot =                 new ObjectIdCollection();               foreach (ObjectId btrId in bt)               {                 BlockTableRecord btr =                   (BlockTableRecord)tr.GetObject(                     btrId,                     OpenMode.ForRead                   );                 if (btr.IsLayout &&                     btr.Name.ToUpper() !=                       BlockTableRecord.ModelSpace.ToUpper())                 {                   layoutsToPlot.Add(btrId);                 }               }               // Create a Progress Dialog to provide info               // and allow thej user to cancel               PlotProgressDialog ppd =                 new PlotProgressDialog(                   false,                   layoutsToPlot.Count,                   true                 );               using (ppd)               {                 int numSheet = 1;                 foreach (ObjectId btrId in layoutsToPlot)                 {                   BlockTableRecord btr =                     (BlockTableRecord)tr.GetObject(                       btrId,                       OpenMode.ForRead                     );                   Layout lo =                     (Layout)tr.GetObject(                       btr.LayoutId,                       OpenMode.ForRead                     );                   // We need a PlotSettings object                   // based on the layout settings                   // which we then customize                   PlotSettings ps =                     new PlotSettings(lo.ModelType);                   ps.CopyFrom(lo);                   // The PlotSettingsValidator helps                   // create a valid PlotSettings object                   PlotSettingsValidator psv =                     PlotSettingsValidator.Current;                   // We'll plot the extents, centered and                   // scaled to fit                   psv.SetPlotType(                     ps,                   Autodesk.AutoCAD.DatabaseServices.PlotType.Extents                   );                   psv.SetUseStandardScale(ps, true);                   psv.SetStdScaleType(ps, StdScaleType.ScaleToFit);                   psv.SetPlotCentered(ps, true);                   // We'll use the standard DWFx PC3, as                   // this supports multiple sheets                   psv.SetPlotConfigurationName(                     ps,                     devname,                     medname                   );                   // We need a PlotInfo object                   // linked to the layout                   pi.Layout = btr.LayoutId;                   // Make the layout we're plotting current                   LayoutManager.Current.CurrentLayout =                     lo.LayoutName;                   // We need to link the PlotInfo to the                   // PlotSettings and then validate it                   pi.OverrideSettings = ps;                   piv.Validate(pi);                   if (numSheet == 1)                   {                     ppd.set_PlotMsgString(                       PlotMessageIndex.DialogTitle,                       "Custom Plot Progress"                     );                     ppd.set_PlotMsgString(                       PlotMessageIndex.CancelJobButtonMessage,                       "Cancel Job"                     );                     ppd.set_PlotMsgString(                       PlotMessageIndex.CancelSheetButtonMessage,                       "Cancel Sheet"                     );                     ppd.set_PlotMsgString(                       PlotMessageIndex.SheetSetProgressCaption,                       "Sheet Set Progress"                     );                     ppd.set_PlotMsgString(                       PlotMessageIndex.SheetProgressCaption,                       "Sheet Progress"                     );                     ppd.LowerPlotProgressRange = 0;                     ppd.UpperPlotProgressRange = 100;                     ppd.PlotProgressPos = 0;                     // Let's start the plot, at last                     ppd.OnBeginPlot();                     ppd.IsVisible = true;                     pe.BeginPlot(ppd, null);                     // We'll be plotting a single document                     pe.BeginDocument(                       pi,                       doc.Name,                       null,                       1,                       true, // Let's plot to file                       "c:\\test-multi-sheet"                     );                   }                   // Which may contains multiple sheets                   ppd.set_PlotMsgString(                     PlotMessageIndex.SheetName,                     doc.Name.Substring(                       doc.Name.LastIndexOf("\") + 1                     ) +                     " - sheet " + numSheet.ToString() +                     " of " + layoutsToPlot.Count.ToString()                   );                   ppd.OnBeginSheet();                   ppd.LowerSheetProgressRange = 0;                   ppd.UpperSheetProgressRange = 100;                   ppd.SheetProgressPos = 0;                   PlotPageInfo ppi = new PlotPageInfo();                   pe.BeginPage(                     ppi,                     pi,                     (numSheet == layoutsToPlot.Count),                     null                   );                   pe.BeginGenerateGraphics(null);                   ppd.SheetProgressPos = 50;                   pe.EndGenerateGraphics(null);                   // Finish the sheet                   pe.EndPage(null);                   ppd.SheetProgressPos = 100;                   ppd.OnEndSheet();                   numSheet++;                   ppd.PlotProgressPos +=                     (100 / layoutsToPlot.Count);                 }                 // Finish the document                 pe.EndDocument(null);                 // And finish the plot                 ppd.PlotProgressPos = 100;                 ppd.OnEndPlot();                 pe.EndPlot(null);               }             }           }         }         else         {           ed.WriteMessage(             "\nAnother plot is in progress."           );         }       }     }   } }

Here's what I see at the command-line when I run the MPLOT command on my system (items 7-18 below are network printers in various Autodesk offices):

1. Command: MPLOT
2. 1 None
3. 2 SnagIt 8
4. 3 PDF-XChange 3.0
5. 4 Microsoft XPS Document Writer
6. 5 Microsoft Office Live Meeting Document Writer
7. 6 Adobe PDF
8. 7 \\adscctps1\cctprn000
9. 8 \\adsneups2\neuprn304
10. 9 \\adsneups2\neuprn306
11. 10 \\adsneups2\neuprn307
12. 11 \\adsneups2\neuprn317
13. 12 \\banhpa001\banprn001
14. 13 \\beihpa001\BEIPRN002
15. 14 \\beihpa001\BEIPRN003
16. 15 \\farhpa001\FARPRN101
17. 16 \\pra-pc61237\Xerox WorkCentre Pro 35 PCL6
18. 17 \\tokhpa001\tokprn401
19. 18 \\tokhpa001\tokprn402
20. 19 Default Windows System Printer.pc3
21. 20 DWF6 ePlot.pc3
22. 21 DWFx ePlot (XPS Compatible).pc3
23. 22 DWG To PDF.pc3
24. 23 PublishToWeb JPG.pc3
25. 24 PublishToWeb PNG.pc3
26. Enter number of device to select: 22
27. Selected: DWG To PDF.pc3
28. 1 ISO_expand_A0_(841.00_x_1189.00_MM)
29. 2 ISO_A0_(841.00_x_1189.00_MM)
30. 3 ISO_expand_A1_(841.00_x_594.00_MM)
31. 4 ISO_expand_A1_(594.00_x_841.00_MM)
32. 5 ISO_A1_(841.00_x_594.00_MM)
33. 6 ISO_A1_(594.00_x_841.00_MM)
34. 7 ISO_expand_A2_(594.00_x_420.00_MM)
35. 8 ISO_expand_A2_(420.00_x_594.00_MM)
36. 9 ISO_A2_(594.00_x_420.00_MM)
37. 10 ISO_A2_(420.00_x_594.00_MM)
38. 11 ISO_expand_A3_(420.00_x_297.00_MM)
39. 12 ISO_expand_A3_(297.00_x_420.00_MM)
40. 13 ISO_A3_(420.00_x_297.00_MM)
41. 14 ISO_A3_(297.00_x_420.00_MM)
42. 15 ISO_expand_A4_(297.00_x_210.00_MM)
43. 16 ISO_expand_A4_(210.00_x_297.00_MM)
44. 17 ISO_A4_(297.00_x_210.00_MM)
45. 18 ISO_A4_(210.00_x_297.00_MM)
46. 19 ARCH_expand_E1_(30.00_x_42.00_Inches)
47. 20 ARCH_E1_(30.00_x_42.00_Inches)
48. 21 ARCH_expand_E_(36.00_x_48.00_Inches)
49. 22 ARCH_E_(36.00_x_48.00_Inches)
50. 23 ARCH_expand_D_(36.00_x_24.00_Inches)
51. 24 ARCH_expand_D_(24.00_x_36.00_Inches)
52. 25 ARCH_D_(36.00_x_24.00_Inches)
53. 26 ARCH_D_(24.00_x_36.00_Inches)
54. 27 ARCH_expand_C_(24.00_x_18.00_Inches)
55. 28 ARCH_expand_C_(18.00_x_24.00_Inches)
56. 29 ARCH_C_(24.00_x_18.00_Inches)
57. 30 ARCH_C_(18.00_x_24.00_Inches)
58. 31 ANSI_expand_E_(34.00_x_44.00_Inches)
59. 32 ANSI_E_(34.00_x_44.00_Inches)
60. 33 ANSI_expand_D_(34.00_x_22.00_Inches)
61. 34 ANSI_expand_D_(22.00_x_34.00_Inches)
62. 35 ANSI_D_(34.00_x_22.00_Inches)
63. 36 ANSI_D_(22.00_x_34.00_Inches)
64. 37 ANSI_expand_C_(22.00_x_17.00_Inches)
65. 38 ANSI_expand_C_(17.00_x_22.00_Inches)
66. 39 ANSI_C_(22.00_x_17.00_Inches)
67. 40 ANSI_C_(17.00_x_22.00_Inches)
68. 41 ANSI_expand_B_(17.00_x_11.00_Inches)
69. 42 ANSI_expand_B_(11.00_x_17.00_Inches)
70. 43 ANSI_B_(17.00_x_11.00_Inches)
71. 44 ANSI_B_(11.00_x_17.00_Inches)
72. 45 ANSI_expand_A_(11.00_x_8.50_Inches)
73. 46 ANSI_expand_A_(8.50_x_11.00_Inches)
74. 47 ANSI_A_(11.00_x_8.50_Inches)
75. 48 ANSI_A_(8.50_x_11.00_Inches)
76. Enter number of media to select: 35
77. Selected: ANSI_D_(34.00_x_22.00_Inches)
78. Effective plotting area:  15.29 wide by 20.60 high
79. Effective plotting area:  13.29 wide by 17.31 high
80. Plotting viewport 2.
81. Plotting viewport 1.
82. Regenerating layout.
83. Regenerating model.
84. Effective plotting area:  15.69 wide by 20.60 high
85. Effective plotting area:  15.69 wide by 20.59 high
86. Plotting viewport 2.
87. Plotting viewport 1.
88. Regenerating layout.
89. Regenerating model.
90. Effective plotting area:  15.69 wide by 20.60 high
91. Effective plotting area:  15.69 wide by 20.59 high
92. Plotting viewport 2.
93. Plotting viewport 1.
94. Regenerating layout.
95. Regenerating model.
96. Effective plotting area:  15.69 wide by 20.60 high
97. Effective plotting area:  14.07 wide by 18.34 high
98. Plotting viewport 2.
99. Plotting viewport 1.
100. Regenerating layout.
101. Regenerating model.

复制代码

雪山飞狐_lzh

七、窗选打印
October 11, 2007
Plotting a window from AutoCAD using .NET
This post extends this previous post that dealt with driving a single-sheet AutoCAD plot by adding some code to handle selection and transformation of a window to plot.
First order of business was to allow the user to select the window to plot. For this I used the classic combination of Editor.GetPoint() for the first corner) and Editor.GetCorner() for the second. All well and good, but the points returned by these functions are in UCS (User Coordinate System) coordinates. Which meant that as it stood, the code would work just fine if (and only if) the view we were using to select the window was parallell with the World Coordinate System (and no additional UCS was in place). In order to deal with the very common scenario of either a UCS being used or the current modelspace view being orbited (etc.), we need to transform the current UCS coordinates into DCS, the Display Coordinate System.
Thankfully that's pretty easy: no need for matrices or anything, we simply use another old friend, acedTrans() (the ObjectARX equivalent of the (trans) function, for you LISPers out there). There isn't a direct equivalent for this function in the managed API (that I'm aware of), so we have to use P/Invoke to call the ObjectARX function. The technique is shown in this DevNote, for those of you that have access to the ADN website:
How to call acedTrans from .NET application?
Otherwise the changes to the original code are very minor: we need to set the extents of the window to plot and then set the plot type to "window", apparently in that order. AutoCAD complained when I initially made the calls in the opposite sequence.
Here's the C# code:

2. using Autodesk.AutoCAD.Runtime;
3. using Autodesk.AutoCAD.ApplicationServices;
4. using Autodesk.AutoCAD.DatabaseServices;
5. using Autodesk.AutoCAD.EditorInput;
6. using Autodesk.AutoCAD.PlottingServices;
7. using Autodesk.AutoCAD.Geometry;
8. using System.Runtime.InteropServices;
9. using System;
10. namespace PlottingApplication
11. {
12.   public class SimplePlottingCommands
13.   {
14.     [DllImport("acad.exe",
15.               CallingConvention = CallingConvention.Cdecl,
16.               EntryPoint="acedTrans")
17.     ]
18.     static extern int acedTrans(
19.       double[] point,
20.       IntPtr fromRb,
21.       IntPtr toRb,
22.       int disp,
23.       double[] result
24.     );
25.     [CommandMethod("winplot")]
26.     static public void WindowPlot()
27.     {
28.       Document doc =
29.         Application.DocumentManager.MdiActiveDocument;
30.       Editor ed = doc.Editor;
31.       Database db = doc.Database;
32.       PromptPointOptions ppo =
33.         new PromptPointOptions(
34.           "\nSelect first corner of plot area: "
35.         );
36.       ppo.AllowNone = false;
37.       PromptPointResult ppr =
38.         ed.GetPoint(ppo);
39.       if (ppr.Status != PromptStatus.OK)
40.         return;
41.       Point3d first = ppr.Value;
42.       PromptCornerOptions pco =
43.         new PromptCornerOptions(
44.           "\nSelect second corner of plot area: ",
45.           first
46.         );
47.       ppr = ed.GetCorner(pco);
48.       if (ppr.Status != PromptStatus.OK)
49.         return;
50.       Point3d second = ppr.Value;
51.       // Transform from UCS to DCS
52.       ResultBuffer rbFrom =
53.         new ResultBuffer(new TypedValue(5003, 1)),
54.                   rbTo =
55.         new ResultBuffer(new TypedValue(5003, 2));
56.       double[] firres = new double[] { 0, 0, 0 };
57.       double[] secres = new double[] { 0, 0, 0 };
58.       // Transform the first point...
59.       acedTrans(
60.         first.ToArray(),
61.         rbFrom.UnmanagedObject,
62.         rbTo.UnmanagedObject,
63.         0,
64.         firres
65.       );
66.       // ... and the second
67.       acedTrans(
68.         second.ToArray(),
69.         rbFrom.UnmanagedObject,
70.         rbTo.UnmanagedObject,
71.         0,
72.         secres
73.       );
74.       // We can safely drop the Z-coord at this stage
75.       Extents2d window =
76.         new Extents2d(
77.           firres[0],
78.           firres[1],
79.           secres[0],
80.           secres[1]
81.         );
82.       Transaction tr =
83.         db.TransactionManager.StartTransaction();
84.       using (tr)
85.       {
86.         // We'll be plotting the current layout
87.         BlockTableRecord btr =
88.           (BlockTableRecord)tr.GetObject(
89.             db.CurrentSpaceId,
90.             OpenMode.ForRead
91.           );
92.         Layout lo =
93.           (Layout)tr.GetObject(
94.             btr.LayoutId,
95.             OpenMode.ForRead
96.           );
97.         // We need a PlotInfo object
98.         // linked to the layout
99.         PlotInfo pi = new PlotInfo();
100.         pi.Layout = btr.LayoutId;
101.         // We need a PlotSettings object
102.         // based on the layout settings
103.         // which we then customize
104.         PlotSettings ps =
105.           new PlotSettings(lo.ModelType);
106.         ps.CopyFrom(lo);
107.         // The PlotSettingsValidator helps
108.         // create a valid PlotSettings object
109.         PlotSettingsValidator psv =
110.           PlotSettingsValidator.Current;
111.         // We'll plot the extents, centered and
112.         // scaled to fit
113.         psv.SetPlotWindowArea(ps, window);
114.         psv.SetPlotType(
115.           ps,
116.         Autodesk.AutoCAD.DatabaseServices.PlotType.Window
117.         );
118.         psv.SetUseStandardScale(ps, true);
119.         psv.SetStdScaleType(ps, StdScaleType.ScaleToFit);
120.         psv.SetPlotCentered(ps, true);
121.         // We'll use the standard DWF PC3, as
122.         // for today we're just plotting to file
123.         psv.SetPlotConfigurationName(
124.           ps,
125.           "DWF6 ePlot.pc3",
126.           "ANSI_A_(8.50_x_11.00_Inches)"
127.         );
128.         // We need to link the PlotInfo to the
129.         // PlotSettings and then validate it
130.         pi.OverrideSettings = ps;
131.         PlotInfoValidator piv =
132.           new PlotInfoValidator();
133.         piv.MediaMatchingPolicy =
134.           MatchingPolicy.MatchEnabled;
135.         piv.Validate(pi);
136.         // A PlotEngine does the actual plotting
137.         // (can also create one for Preview)
138.         if (PlotFactory.ProcessPlotState ==
139.             ProcessPlotState.NotPlotting)
140.         {
141.           PlotEngine pe =
142.             PlotFactory.CreatePublishEngine();
143.           using (pe)
144.           {
145.             // Create a Progress Dialog to provide info
146.             // and allow thej user to cancel
147.             PlotProgressDialog ppd =
148.               new PlotProgressDialog(false, 1, true);
149.             using (ppd)
150.             {
151.               ppd.set_PlotMsgString(
152.                 PlotMessageIndex.DialogTitle,
153.                 "Custom Plot Progress"
154.               );
155.               ppd.set_PlotMsgString(
156.                 PlotMessageIndex.CancelJobButtonMessage,
157.                 "Cancel Job"
158.               );
159.               ppd.set_PlotMsgString(
160.                 PlotMessageIndex.CancelSheetButtonMessage,
161.                 "Cancel Sheet"
162.               );
163.               ppd.set_PlotMsgString(
164.                 PlotMessageIndex.SheetSetProgressCaption,
165.                 "Sheet Set Progress"
166.               );
167.               ppd.set_PlotMsgString(
168.                 PlotMessageIndex.SheetProgressCaption,
169.                 "Sheet Progress"
170.               );
171.               ppd.LowerPlotProgressRange = 0;
172.               ppd.UpperPlotProgressRange = 100;
173.               ppd.PlotProgressPos = 0;
174.               // Let's start the plot, at last
175.               ppd.OnBeginPlot();
176.               ppd.IsVisible = true;
177.               pe.BeginPlot(ppd, null);
178.               // We'll be plotting a single document
179.               pe.BeginDocument(
180.                 pi,
181.                 doc.Name,
182.                 null,
183.                 1,
184.                 true, // Let's plot to file
185.                 "c:\\test-output"
186.               );
187.               // Which contains a single sheet
188.               ppd.OnBeginSheet();
189.               ppd.LowerSheetProgressRange = 0;
190.               ppd.UpperSheetProgressRange = 100;
191.               ppd.SheetProgressPos = 0;
192.               PlotPageInfo ppi = new PlotPageInfo();
193.               pe.BeginPage(
194.                 ppi,
195.                 pi,
196.                 true,
197.                 null
198.               );
199.               pe.BeginGenerateGraphics(null);
200.               pe.EndGenerateGraphics(null);
201.               // Finish the sheet
202.               pe.EndPage(null);
203.               ppd.SheetProgressPos = 100;
204.               ppd.OnEndSheet();
205.               // Finish the document
206.               pe.EndDocument(null);
207.               // And finish the plot
208.               ppd.PlotProgressPos = 100;
209.               ppd.OnEndPlot();
210.               pe.EndPlot(null);
211.             }
212.           }
213.         }
214.         else
215.         {
216.           ed.WriteMessage(
217.             "\nAnother plot is in progress."
218.           );
219.         }
220.       }
221.     }
222.   }
223. }

using Autodesk.AutoCAD.Runtime; using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.PlottingServices; using Autodesk.AutoCAD.Geometry; using System.Runtime.InteropServices; using System; namespace PlottingApplication {   public class SimplePlottingCommands   {     [DllImport("acad.exe",               CallingConvention = CallingConvention.Cdecl,               EntryPoint="acedTrans")     ]     static extern int acedTrans(       double[] point,       IntPtr fromRb,       IntPtr toRb,       int disp,       double[] result     );     [CommandMethod("winplot")]     static public void WindowPlot()     {       Document doc =         Application.DocumentManager.MdiActiveDocument;       Editor ed = doc.Editor;       Database db = doc.Database;       PromptPointOptions ppo =         new PromptPointOptions(           "\nSelect first corner of plot area: "         );       ppo.AllowNone = false;       PromptPointResult ppr =         ed.GetPoint(ppo);       if (ppr.Status != PromptStatus.OK)         return;       Point3d first = ppr.Value;       PromptCornerOptions pco =         new PromptCornerOptions(           "\nSelect second corner of plot area: ",           first         );       ppr = ed.GetCorner(pco);       if (ppr.Status != PromptStatus.OK)         return;       Point3d second = ppr.Value;       // Transform from UCS to DCS       ResultBuffer rbFrom =         new ResultBuffer(new TypedValue(5003, 1)),                   rbTo =         new ResultBuffer(new TypedValue(5003, 2));       double[] firres = new double[] { 0, 0, 0 };       double[] secres = new double[] { 0, 0, 0 };       // Transform the first point...       acedTrans(         first.ToArray(),         rbFrom.UnmanagedObject,         rbTo.UnmanagedObject,         0,         firres       );       // ... and the second       acedTrans(         second.ToArray(),         rbFrom.UnmanagedObject,         rbTo.UnmanagedObject,         0,         secres       );       // We can safely drop the Z-coord at this stage       Extents2d window =         new Extents2d(           firres[0],           firres[1],           secres[0],           secres[1]         );       Transaction tr =         db.TransactionManager.StartTransaction();       using (tr)       {         // We'll be plotting the current layout         BlockTableRecord btr =           (BlockTableRecord)tr.GetObject(             db.CurrentSpaceId,             OpenMode.ForRead           );         Layout lo =           (Layout)tr.GetObject(             btr.LayoutId,             OpenMode.ForRead           );         // We need a PlotInfo object         // linked to the layout         PlotInfo pi = new PlotInfo();         pi.Layout = btr.LayoutId;         // We need a PlotSettings object         // based on the layout settings         // which we then customize         PlotSettings ps =           new PlotSettings(lo.ModelType);         ps.CopyFrom(lo);         // The PlotSettingsValidator helps         // create a valid PlotSettings object         PlotSettingsValidator psv =           PlotSettingsValidator.Current;         // We'll plot the extents, centered and         // scaled to fit         psv.SetPlotWindowArea(ps, window);         psv.SetPlotType(           ps,         Autodesk.AutoCAD.DatabaseServices.PlotType.Window         );         psv.SetUseStandardScale(ps, true);         psv.SetStdScaleType(ps, StdScaleType.ScaleToFit);         psv.SetPlotCentered(ps, true);         // We'll use the standard DWF PC3, as         // for today we're just plotting to file         psv.SetPlotConfigurationName(           ps,           "DWF6 ePlot.pc3",           "ANSI_A_(8.50_x_11.00_Inches)"         );         // We need to link the PlotInfo to the         // PlotSettings and then validate it         pi.OverrideSettings = ps;         PlotInfoValidator piv =           new PlotInfoValidator();         piv.MediaMatchingPolicy =           MatchingPolicy.MatchEnabled;         piv.Validate(pi);         // A PlotEngine does the actual plotting         // (can also create one for Preview)         if (PlotFactory.ProcessPlotState ==             ProcessPlotState.NotPlotting)         {           PlotEngine pe =             PlotFactory.CreatePublishEngine();           using (pe)           {             // Create a Progress Dialog to provide info             // and allow thej user to cancel             PlotProgressDialog ppd =               new PlotProgressDialog(false, 1, true);             using (ppd)             {               ppd.set_PlotMsgString(                 PlotMessageIndex.DialogTitle,                 "Custom Plot Progress"               );               ppd.set_PlotMsgString(                 PlotMessageIndex.CancelJobButtonMessage,                 "Cancel Job"               );               ppd.set_PlotMsgString(                 PlotMessageIndex.CancelSheetButtonMessage,                 "Cancel Sheet"               );               ppd.set_PlotMsgString(                 PlotMessageIndex.SheetSetProgressCaption,                 "Sheet Set Progress"               );               ppd.set_PlotMsgString(                 PlotMessageIndex.SheetProgressCaption,                 "Sheet Progress"               );               ppd.LowerPlotProgressRange = 0;               ppd.UpperPlotProgressRange = 100;               ppd.PlotProgressPos = 0;               // Let's start the plot, at last               ppd.OnBeginPlot();               ppd.IsVisible = true;               pe.BeginPlot(ppd, null);               // We'll be plotting a single document               pe.BeginDocument(                 pi,                 doc.Name,                 null,                 1,                 true, // Let's plot to file                 "c:\\test-output"               );               // Which contains a single sheet               ppd.OnBeginSheet();               ppd.LowerSheetProgressRange = 0;               ppd.UpperSheetProgressRange = 100;               ppd.SheetProgressPos = 0;               PlotPageInfo ppi = new PlotPageInfo();               pe.BeginPage(                 ppi,                 pi,                 true,                 null               );               pe.BeginGenerateGraphics(null);               pe.EndGenerateGraphics(null);               // Finish the sheet               pe.EndPage(null);               ppd.SheetProgressPos = 100;               ppd.OnEndSheet();               // Finish the document               pe.EndDocument(null);               // And finish the plot               ppd.PlotProgressPos = 100;               ppd.OnEndPlot();               pe.EndPlot(null);             }           }         }         else         {           ed.WriteMessage(             "\nAnother plot is in progress."           );         }       }     }   } }

trample

有翻译过来的么，看着眼晕

menethil

有自定义图幅的方法吗？

azbd

打印预览有没有调过了的？为啥一直卡在预览界面？