SolidWorks PDF Export Add-In Prototype

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237

using System;
using System.Runtime.InteropServices;
using SolidWorks.Interop.sldworks;
using SolidWorks.Interop.swconst;
using SolidWorks.Interop.swpublished;

namespace PdfExportAddin
{
    /// <summary>
    /// Minimal SOLIDWORKS add-in entry point.
    ///
    /// This class is COM-visible because SOLIDWORKS loads add-ins via COM.
    /// It implements ISwAddin, which is the standard add-in contract used by SOLIDWORKS.
    ///
    /// Responsibilities of this class:
    /// - Connect to and disconnect from SOLIDWORKS.
    /// - Register a simple command group/menu command.
    /// - Route the command to the PDF export service.
    /// - Keep the add-in bootstrap readable and low-risk.
    ///
    /// Design intent for future growth:
    /// - Keep add-in lifecycle code here.
    /// - Keep drawing export business logic in PdfExportService.
    /// - Add future commands/services as separate classes rather than bloating this file.
    /// </summary>
    [ComVisible(true)]
    [Guid(BuildInfo.AddinGuid)]
    [ProgId(BuildInfo.ProgId)]
    public sealed class SwPdfExportAddin : ISwAddin
    {
        private SldWorks _swApp;
        private int _addinCookie;
        private ICommandManager _commandManager;
        private PdfExportService _pdfExportService;

        /// <summary>
        /// SOLIDWORKS calls this when the add-in is loaded.
        ///
        /// This is the add-in's main initialization entry point.
        /// Required tasks performed here:
        /// - capture the SOLIDWORKS application pointer
        /// - store the add-in cookie
        /// - register callback info
        /// - create the PDF export service
        /// - register the menu command
        /// </summary>
        public bool ConnectToSW(object ThisSW, int Cookie)
        {
            _swApp = ThisSW as SldWorks;
            _addinCookie = Cookie;

            if (_swApp == null)
            {
                return false;
            }

            _swApp.SetAddinCallbackInfo2(0, this, _addinCookie);
            _pdfExportService = new PdfExportService(_swApp);
            _commandManager = _swApp.GetCommandManager(_addinCookie);

            AddCommandGroup();

            if (BuildInfo.ShowLoadMessage)
            {
                ShowInfo(
                    "PDF Export Test Add-in loaded.\n\n" +
                    "Use the command 'Save Active Drawing as PDF' from the add-in menu group.\n\n" +
                    "This starter add-in only enables the command when a drawing is active.");
            }

            return true;
        }

        /// <summary>
        /// SOLIDWORKS calls this when the add-in is being unloaded.
        ///
        /// Required cleanup:
        /// - remove command UI that we created
        /// - release references so SOLIDWORKS can unload cleanly
        /// </summary>
        public bool DisconnectFromSW()
        {
            try
            {
                RemoveCommandGroup();
            }
            catch
            {
                // Keep unload robust. During disconnect we do not want a UI cleanup issue
                // to prevent the add-in from unloading.
            }
            finally
            {
                _pdfExportService = null;
                _commandManager = null;
                _swApp = null;
            }

            return true;
        }

        /// <summary>
        /// Creates a minimal command group with a single menu command.
        ///
        /// Why menu only for the first trial?
        /// - Fewer moving parts than toolbar/icon setup.
        /// - Lower risk for the first add-in smoke test.
        /// - Easy to extend later into a CommandManager tab or toolbar.
        /// </summary>
        private void AddCommandGroup()
        {
            if (_commandManager == null)
            {
                return;
            }

            int errors = 0;
            bool ignorePreviousVersion = true;

            ICommandGroup group = _commandManager.CreateCommandGroup2(
                BuildInfo.CommandGroupId,
                BuildInfo.CommandGroupTitle,
                BuildInfo.CommandTooltip,
                BuildInfo.CommandTooltip,
                -1,
                ignorePreviousVersion,
                ref errors);

            if (group == null)
            {
                ShowError(string.Format("Failed to create command group. Error code={0}.", errors));
                return;
            }

            // Menu-only starter command. Once your pipeline is proven, this is the natural place
            // to add toolbar buttons, tabs, icons, multiple commands, and document-specific UI.
            group.AddCommandItem2(
                BuildInfo.CommandTitle,
                -1,
                BuildInfo.CommandTooltip,
                BuildInfo.CommandTooltip,
                -1,
                nameof(Command_SaveActiveDrawingAsPdf),
                nameof(Enable_SaveActiveDrawingAsPdf),
                0,
                (int)swCommandItemType_e.swMenuItem);

            group.HasMenu = true;
            group.HasToolbar = false;
            group.Activate();
        }

        /// <summary>
        /// Removes the command group created by this add-in.
        /// </summary>
        private void RemoveCommandGroup()
        {
            if (_commandManager == null)
            {
                return;
            }

            _commandManager.RemoveCommandGroup(BuildInfo.CommandGroupId);
        }

        /// <summary>
        /// SOLIDWORKS callback method for the command.
        ///
        /// IMPORTANT:
        /// The method name is passed to AddCommandItem2 as a string callback name,
        /// so renaming this method requires updating that string as well.
        /// </summary>
        public void Command_SaveActiveDrawingAsPdf()
        {
            if (_pdfExportService == null)
            {
                ShowError("PDF export service is not initialized.");
                return;
            }

            ExportResult result = _pdfExportService.ExportActiveDrawingToPdf();

            if (!result.IsSuccess)
            {
                ShowError(result.Message);
                return;
            }

            if (BuildInfo.ShowSuccessMessage)
            {
                ShowInfo(result.Message);
            }
        }

        /// <summary>
        /// SOLIDWORKS enable-method callback for the menu command.
        ///
        /// Return convention:
        /// - 1 = enabled
        /// - 0 = disabled
        ///
        /// This starter logic enables the command only when the active document is a drawing.
        /// </summary>
        public int Enable_SaveActiveDrawingAsPdf()
        {
            if (_swApp == null)
            {
                return 0;
            }

            ModelDoc2 model = _swApp.ActiveDoc as ModelDoc2;
            if (model == null)
            {
                return 0;
            }

            return model.GetType() == (int)swDocumentTypes_e.swDocDRAWING ? 1 : 0;
        }

        private void ShowInfo(string message)
        {
            _swApp?.SendMsgToUser2(
                message,
                (int)swMessageBoxIcon_e.swMbInformation,
                (int)swMessageBoxBtn_e.swMbOk);
        }

        private void ShowError(string message)
        {
            _swApp?.SendMsgToUser2(
                message,
                (int)swMessageBoxIcon_e.swMbStop,
                (int)swMessageBoxBtn_e.swMbOk);
        }
    }
}