scriptup 0.0.0

data/sketchup-sdk-win/headers/SketchUpAPI/import_export/modelexporterplugin.h

@@ -0,0 +1,165 @@
+// Copyright 2012-2020 Trimble Inc. All Rights Reserved.
+
+/**
+ * @file
+ * @brief Interfaces for SketchUpModelExporterInterface.
+ */
+#ifndef MODELEXPORTERPLUGIN_H_
+#define MODELEXPORTERPLUGIN_H_
+
+#include <map>
+#include <string>
+
+#include <SketchUpAPI/import_export/pluginprogresscallback.h>
+
+/**
+@struct SketchUpModelExporterInterface
+@brief  A valid SketchUp "exporter" plugin must support the following interface.
+        See the SDK samples for an example.
+*/
+class SketchUpModelExporterInterface {
+ public:
+  /**
+  @brief  Returns a unique ASCII (non-localized) identifier for the exporter.
+          For example, all SketchUp supplied exporters use the following
+          convention for the id name: com.sketchup.exporters.extension. This id
+          is used to identify the current default exporter and saved between
+          invocations of SketchUp.
+  @return
+  - A unique string identifier for the plugin
+  */
+  virtual std::string GetIdentifier() const = 0;
+
+  /**
+  @brief The number of extensions supported by the exporter.  Must be > 0.
+  @return
+  - The number of file extensions supported by this plugin
+  */
+  virtual int GetFileExtensionCount() const = 0;
+
+  /**
+  @brief  Each extension, assumed to be ASCII and case independent with no
+          leading dot.
+  @param[in] index The index of the extension
+  @return
+  - The file extension retrieved
+  */
+  virtual std::string GetFileExtension(int index) const = 0;
+
+  /**
+  @brief Return a brief description of the exporter for the file drop down box
+         which may be extension specific. For example you may return "AutoCAD
+         DWG Files" corresponding to the dwg extension and "AutoCAD DXF Files"
+         corresponding to the dxf extension. Each extension and description pair
+         will be entered into the exporter drop down list as a separate entry.
+  @param[in] index The index of the extension
+  @return
+  - The description retrieved
+  */
+  virtual std::string GetDescription(int index) const = 0;
+
+
+  /**
+  @brief Indicates whether the exporter supports an options dialog.
+  @return
+  - true if the exporter supports an options dialog. If so, the "Options" button
+    will be enabled when your exporter is chosen, and selecting that button will
+    call the exporter's ShowOptionsDialog method.
+  */
+  virtual bool SupportsOptions() const {
+    return false;
+  }
+
+  /**
+  @brief  Displays a modal dialog which controls options supported by the
+          exporter. Implementing this is required if SupportOptions is true.
+          Options should be saved someplace which persists between this method
+          and ConvertFromSkp as well as between sessions.
+  @param[in] model_has_selection Indicates if the model has a current selection
+               set. May be used in concert with ExportSelectionSetOnly to allow
+               the exporter to export just the selected portion of the model.
+               For example, you may enable a check box which controls this and
+               return the state of that check box from ExportSelectionSetOnly.
+  */
+  virtual void ShowOptionsDialog(bool model_has_selection) {
+  }
+
+  /**
+  @brief  Indicates whether the plugin supports exporting just the selection.
+  @return
+  - true if the exporter supports an option to just export the selection AND the
+    user has set that to true. If true, SketchUp will save the selected portion
+    of the model and pass that into the ConvertFromSkp method.
+  */
+  virtual bool ExportSelectionSetOnly() {
+    return false;
+  }
+
+  /**
+  @brief Indicates whether the plugin supports the progress callback.
+  @return
+  - true if the exporter supports the progress callback.  If true, the plugin
+    should periodically update the status with messages and percent complete
+    as well as check if the user pressed the cancel button.  If false, SketchUp
+    will provide limited feedback on the progress of the export step.
+  */
+  virtual bool SupportsProgress() const {
+    return true;
+  }
+
+  /**
+  @brief  Performs the conversion from a temporary skp file to the target output
+          file using options set during the ShowOptionsDialog method.
+  @param[in] input_skp Either a saved version of the current model or the
+                       current selection (if ExportSelectionSetOnly returns
+                       true). The method should read this file and convert to
+                       the output file. The file name is specified in UTF-8 and
+                       may require conversion to a platform-dependent format
+                       (i.e. UTF-16) for proper support of international file
+                       names.
+  @param[in] output    The requested output file in UTF-8.
+  @param[in] progress  The exporter should support this progress interface. See
+                       that for details. The method should be tolerant to a NULL
+                       progress callback.
+  @param[in] reserved  Reserved for internal use.
+  @return
+  - true on success
+  - false on failure or cancellation
+  */
+  virtual bool ConvertFromSkp(
+      const std::string& input_skp, const std::string& output,
+      SketchUpPluginProgressCallback* progress, void* reserved) = 0;
+  /**
+  @brief Displays a modal dialog showing an optional summary of the export
+         process.  The default does nothing.  Note that Ruby scripting often
+         disables this dialog.
+  */
+  virtual void ShowSummaryDialog() {
+  }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __OBJC__
+  #import <Foundation/Foundation.h>
+/** Each Mac plugin should support this simple protocol.
+ */
+@protocol SketchUpModelExporterPlugin<NSObject>
+/**
+@brief Returns an auto-released instance of the exporter.
+*/
++ (id<SketchUpModelExporterPlugin>)exporter;
+
+/**
+@brief  This returns our c++ interface from the obj-c wrapper.
+*/
+- (SketchUpModelExporterInterface*)sketchUpModelExporterInterface;
+@end
+
+#else
+/**
+ * Each Windows DLL should export a function which returns the C++ interface.
+ */
+typedef SketchUpModelExporterInterface* (*GetSketchUpModelExporterInterfaceFunc)(void);
+#endif
+#endif  // MODELEXPORTERPLUGIN_H_

data/sketchup-sdk-win/headers/SketchUpAPI/import_export/modelimporterplugin.h

@@ -0,0 +1,183 @@
+// Copyright 2012-2020  Trimble, Inc. All Rights Reserved.
+
+/**
+ * @file
+ * @brief Interfaces for SketchUpModelImporterInterface.
+ */
+#ifndef MODELIMPORTERPLUGIN_H_
+#define MODELIMPORTERPLUGIN_H_
+
+#include <string>
+
+#include <SketchUpAPI/import_export/pluginprogresscallback.h>
+
+/** @brief Return type of SketchUpOptionsDialogResponse::ShowOptionsDialog(). */
+enum SketchUpOptionsDialogResponse {
+  IMPORTER_OPTIONS_UNAVAILABLE = 0,  ///< Importer options not available.
+  IMPORTER_OPTIONS_CANCELLED = 1,    ///< Importer options cancelled.
+  IMPORTER_OPTIONS_ACCEPTED = 2      ///< Importer options accepted.
+};
+
+/** Return type of GetImporterBehavior(). */
+enum SketchUpModelImporterBehavior {
+  IMPORT_MODEL_AT_ORIGIN = 0,     ///< Preserves coordinates of the imported
+                                  ///< geometry.
+  IMPORT_MODEL_AS_COMPONENT = 1,  ///< Model gets imported as a selected
+                                  ///< component with the move tool activated.
+  ///< New Sketchup 2017 import behaviors.
+  IMPORT_MODEL_PRESERVE_ORIGIN = IMPORT_MODEL_AT_ORIGIN,  ///< Same as
+                                                          ///< IMPORT_MODEL_AT_ORIGIN.
+  IMPORT_MODEL_RESET_ORIGIN_TO_BBOX_MIN = 2               ///< Translates the coordinates of
+                                                          ///< the imported geometry such
+                                                          ///< that the minimum point of the
+                                                          ///< bounding box is at the origin.
+};
+
+/**
+@struct SketchUpModelImporterInterface
+@brief  A valid SketchUp "importer" plugin must support the following interface.
+        See the SDK samples for an example.
+*/
+class SketchUpModelImporterInterface {
+ public:
+  /**
+  @brief Returns a unique ASCII (non-localized) identifier for the importer.
+         For example, all SketchUp supplied importers use the following
+         convention for the id name:  com.sketchup.importers.extension.
+         This id is used to identify the current default importer and
+         saved between invocations of SketchUp.
+  @return
+  - A unique string identifier for the plugin
+  */
+  virtual std::string GetIdentifier() const = 0;
+
+  /**
+  @brief The number of extensions supported by the importer.  Must be > 0.
+  @return
+  - The number of file extensions supported by this plugin
+  */
+  virtual int GetFileExtensionCount() const = 0;
+
+  /**
+  @brief Each extension, assumed to be ASCII and case independent with no
+         leading dot.
+  @param[in] index The index of the extension
+  @return
+  - The file extension retrieved
+   */
+  virtual std::string GetFileExtension(int index) const = 0;
+
+  /**
+  @brief Return a brief description of the importer for the file drop down
+         box. For example, "AutoCAD DWG Files". SketchUp uses this description
+         together with all the extensions to form a single entry in the import
+         dialog drop down list: e.g., "AutoCAD DWG Files (*.dwg,*.dxf)"
+  @return
+  - The description retrieved
+  */
+  virtual std::string GetDescription() const = 0;
+
+  /**
+  @brief Indicates whether the importer supports an options dialog.
+  @return
+  - true if the importer supports an options dialog. If so, the "Options" button
+    will be enabled when your importer is chosen, and selecting that button will
+    call the importer's ShowOptionsDialog method.
+  */
+  virtual bool SupportsOptions() const {
+    return false;
+  }
+
+  /**
+  @brief  Displays a modal dialog which controls options supported by the
+          importer. Implementing this is required if SupportOptions is true.
+          Options should be saved someplace which persists between this method
+          and ConvertToSkp as well as between sessions.
+  @warning *** Breaking Change: The behavior of this method was changed in
+          SketchUp 2019.2, API 7.1 on the Windows API and SketchUp 2020, API 8.0
+          on the MacOS API. In previous releases, the method returned void. Now
+          it will return \ref SketchUpOptionsDialogResponse.
+  @return SketchUpOptionsDialogResponse
+          IMPORTER_OPTIONS_UNAVAILABLE if unable to display options,
+          IMPORTER_OPTIONS_CANCELLED if options were cancelled,
+          IMPORTER_OPTIONS_ACCEPTED if options were accepted
+
+  */
+  virtual SketchUpOptionsDialogResponse ShowOptionsDialog() {
+    return IMPORTER_OPTIONS_UNAVAILABLE;
+  }
+
+  /**
+  @brief Indicates whether the plugin supports the progress callback.
+  @return
+  - true if the exporter supports the progress callback.  If true, the plugin
+    should periodically update the status with messages and percent complete
+    as well as check if the user pressed the cancel button.  If false, SketchUp
+    will provide limited feedback on the progress of the export step.
+  */
+  virtual bool SupportsProgress() const {
+    return true;
+  }
+
+  /**
+  @brief  This performs the conversion from the selected input file to the
+          given temporary output file using options set during the
+          ShowOptionsDialog method.  The output file is then inserted into
+          the current model using rules defined by the GetImporterBehavior
+          method.
+  @param[in] input                     The user selected input file. The file
+                                       name is specified in UTF-8 and may
+                                       require conversion to a platform
+                                       dependent format (i.e. UTF-16) for proper
+                                       support of international file names.
+  @param[in] output_skp                A temporary output file in UTF-8.
+  @param[in] progress                  The importer should support this progress
+                                       interface. See that for details. The
+                                       method should be tolerant to a NULL
+                                       progress callback.
+  @param reserved                      Reserved for internal use.
+  @return
+  - true on success
+  - false on failure or cancellation
+  */
+  virtual bool ConvertToSkp(
+      const std::string& input, const std::string& output_skp,
+      SketchUpPluginProgressCallback* progress, void* reserved) = 0;
+  /**
+  @brief Displays a modal dialog showing an optional summary of the import
+         process.  The default does nothing.  Note that Ruby scripting often
+         disables this dialog.
+  */
+  virtual void ShowSummaryDialog() {
+  }
+  /**
+  @brief  Defines the method SketchUp uses when placing the imported model.
+  */
+  virtual SketchUpModelImporterBehavior GetImporterBehavior() const {
+    return IMPORT_MODEL_PRESERVE_ORIGIN;
+  }
+
+};
+
+#ifdef __OBJC__
+/** Each Mac plugin should support this simple protocol.
+ */
+@protocol SketchUpModelImporterPlugin<NSObject>
+/**
+@brief Returns an auto-released instance of the importer.
+*/
++ (id<SketchUpModelImporterPlugin>)importer;
+
+/**
+@brief  This returns our c++ interface from the obj-c wrapper.
+*/
+// This grabs our c++ interface from the obj-c wrapper.
+- (SketchUpModelImporterInterface*)sketchUpModelImporterInterface;
+@end
+
+#else
+/** Each Windows DLL should export a function which returns the c++ interface.
+ */
+typedef SketchUpModelImporterInterface* (*GetSketchUpModelImporterInterfaceFunc)(void);
+#endif
+#endif  // MODELIMPORTERPLUGIN_H_

data/sketchup-sdk-win/headers/SketchUpAPI/import_export/pluginprogresscallback.h

@@ -0,0 +1,84 @@
+// Copyright 2013-2020 Trimble Inc. All Rights Reserved.
+
+/**
+ * @file
+ * @brief Interfaces for import/export progress feedback and cancellation.
+ */
+#ifndef SKETCHUPPLUGINPROGRESSCALLBACK_H_
+#define SKETCHUPPLUGINPROGRESSCALLBACK_H_
+
+#include <string>
+
+/**
+@struct SketchUpPluginProgressCallback
+@brief  Interface to provide import/export progress feedback and cancellation.
+
+All well behaved SketchUp importer/exporter plugins should support progress
+feedback and cancellation through this interface. SketchUp will pop up a
+progress/cancel dialog prior to calling the appropriate Convert method on the
+importer/exporter plugin and supply a concrete implementation of this interface.
+The plugin should supply feedback to the user by estimating how far along the
+conversion is (via SetPercentDone or SetStepSize and Step), provide some textual
+progress (via SetProgressMessage) and test for cancellation by calling
+HasBeenCancelled.
+
+For example, the main loop of an importer plugin may look like this:
+
+\code{.cpp}
+progress_callback->SetProgressMessage("Importing 50 things!");
+progress_callback->SetStepSize(1.0);
+for (int steps = 0; steps < 50; ++steps) {
+  progress_callback->Step();
+  // Do something which builds an skp model
+  if (progress_callback->HasBeenCancelled()) {
+    // Clean up and return
+    return false;
+  }
+}
+progress_callback->SetProgressMessage("We're half way there!");
+// Do some more larger steps
+progress_callback->SetPercentDone(75.0);
+progress_callback->SetProgressMessage("Finishing up!");
+// And some more
+progress_callback->SetPercentDone(100.0);
+// Success!
+return true;
+\endcode
+
+*/
+class SketchUpPluginProgressCallback {
+ public:
+  /**
+  @brief  Call this to test if the user has pressed the cancel button.  Your
+          code should clean up and return promptly after detecting this.
+  @return Returns true if the user has pressed cancel.
+  */
+  virtual bool HasBeenCancelled() = 0;
+
+  /**
+  @brief  Call this to set the percent complete on the dialog.
+  @param[in] percent The percent done from 0 to 100.
+   */
+  virtual void SetPercentDone(double percent) = 0;
+
+  /**
+  @brief  You may also set a step size and increment it using the Step method.
+  @param[in] percent The percent to increment with each call to Step.
+   */
+  virtual void SetStepSize(double percent) = 0;
+
+  /**
+  @brief  Increments the progress dialog by the step size set using
+          SetStepSize.
+  */
+  virtual void Step() = 0;
+
+  /**
+  @brief  Supplies a UTF-8 message which will be presented on the progress
+          dialog.
+  @param utf8_message The message.
+  */
+  virtual void SetProgressMessage(const std::string& utf8_message) = 0;
+};
+
+#endif  // SKETCHUPPLUGINPROGRESSCALLBACK_H_

data/sketchup-sdk-win/headers/SketchUpAPI/initialize.h

@@ -0,0 +1,43 @@
+// Copyright 2013-2020 Trimble Inc.  All Rights Reserved
+
+/**
+ * @file
+ * @brief Functionality for the API interface itself.
+ */
+#ifndef SKETCHUP_INITIALIZE_H_
+#define SKETCHUP_INITIALIZE_H_
+
+#include <SketchUpAPI/common.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+@brief Initializes the slapi interface. Must be called before calling any other
+       API function.
+@attention This function should not be used from the Live API.
+*/
+SU_EXPORT void SUInitialize();
+
+/**
+@brief Signals termination of use of the slapi interface. Must be called when
+       done using API functions.
+@attention This function should not be used from the Live API.
+*/
+SU_EXPORT void SUTerminate();
+
+/**
+@brief Returns the major and minor API version numbers.
+@param[out] major The major version number retrieved.
+@param[out] minor The minor version number retrieved.
+@note This function hasn't reliably reported the correct versions prior to
+      version 8.2 of the SDK.
+*/
+SU_EXPORT void SUGetAPIVersion(size_t* major, size_t* minor);
+
+#ifdef __cplusplus
+}  //  extern "C" {
+#endif
+
+#endif  // SKETCHUP_INITIALIZE_H_