/// <summary>
/// Runs an function and catches any exceptions thrown
/// wrapping and rethrowing them as a <see cref="SolidDnaException"/>
/// </summary>
/// <param name="func">The function to run</param>
/// <param name="errorTypeCode">The <see cref="SolidDnaErrorTypeCode"/> to wrap the exception in</param>
/// <param name="errorCode">The <see cref="SolidDnaErrorCode"/> to wrap the exception in</param>
/// <param name="errorDescription">The description of the error if thrown</param>
public static T Wrap <T>(Func <T> func, SolidDnaErrorTypeCode errorTypeCode, SolidDnaErrorCode errorCode, string errorDescription)
{
try
{
return(func());
}
catch (Exception ex)
{
// Create the SolidDNA exception
var error = new SolidDnaException(SolidDnaErrors.CreateError(
errorTypeCode,
errorCode,
errorDescription), ex);
// If it should just be logged and ignored, log it
if (SolidDnaEnvironment.LogAndIgnoreUncaughtExceptions)
{
// Log the error
Logger.Log($"SolidDNA Exception created. {error.SolidDnaError?.ToString()}");
if (error.InnerException != null)
{
Logger.Log($"Inner Exception: { error.InnerException.GetErrorMessage()}");
}
return(default(T));
}
// Otherwise, throw
else
{
throw error;
}
}
}
/// <summary>
/// Sets the material for the model
/// </summary>
/// <param name="material">The material</param>
/// <param name="configuration">The configuration to set the material on, null for the default</param>
///
public void SetMaterial(Material material, string configuration = null)
{
// Wrap any error
SolidDnaErrors.Wrap(() =>
{
// Make sure we are a part
if (!this.IsPart)
{
throw new InvalidOperationException(Localization.GetString("SolidWorksModelSetMaterialModelNotPartError"));
}
// If the material is null, remove the material
if (material == null || !material.DatabaseFileFound)
{
this.AsPart().SetMaterialPropertyName2(string.Empty, string.Empty, string.Empty);
}
// Otherwise set the material
else
{
this.AsPart().SetMaterialPropertyName2(configuration, material.Database, material.Name);
}
},
SolidDnaErrorTypeCode.SolidWorksModel,
SolidDnaErrorCode.SolidWorksModelSetMaterialError,
Localization.GetString("SolidWorksModelSetMaterialError"));
}
/// <summary>
/// Called after a file has finished opening
/// </summary>
/// <param name="filename">The filename to the file being opened</param>
/// <returns></returns>
private int FileOpenPostNotify(string filename)
{
// Wrap any error
SolidDnaErrors.Wrap(() =>
{
// If this is the file we were opening...
if (string.Equals(filename, mFileLoading, StringComparison.OrdinalIgnoreCase))
{
// File has been loaded
// So clear loading flag
mFileLoading = null;
// And update all properties and models
this.ReloadActiveModelInformation();
// Inform listeners
this.FileOpened(filename, mActiveModel);
}
},
SolidDnaErrorTypeCode.SolidWorksApplication,
SolidDnaErrorCode.SolidWorksApplicationFilePostOpenError,
Localization.GetString("SolidWorksApplicationFilePostOpenError"));
// NOTE: 0 is OK, anything else is an error
return(0);
}
/// <summary>
/// Called when the active model has changed
/// </summary>
/// <returns></returns>
private int ActiveModelChanged()
{
// Wrap any error
SolidDnaErrors.Wrap(() =>
{
// If we are currently loading a file...
if (mFileLoading != null)
{
// Chcek the active document
using (var activeDoc = new Model((ModelDoc2)mBaseObject.ActiveDoc))
{
// If this is the same file that is currently being loaded, ignore this event
if (activeDoc != null && string.Equals(mFileLoading, activeDoc.FilePath, StringComparison.OrdinalIgnoreCase))
{
return;
}
}
}
// If we got here, it isn't the current document so reload the data
this.ReloadActiveModelInformation();
},
SolidDnaErrorTypeCode.SolidWorksApplication,
SolidDnaErrorCode.SolidWorksApplicationActiveModelChangedError,
Localization.GetString("SolidWorksApplicationActiveModelChangedError"));
// NOTE: 0 is OK, anything else is an error
return(0);
}
/// <summary>
/// Create a command group from a list of <see cref="CommandManagerItem"/> items
/// </summary>
/// <param name="title">Name of the CommandGroup to create (see Remarks)</param>
/// <param name="items">The command items to add</param>
/// <param name="iconListsPath">The icon list absolute path based on a string format of the absolute path to the icon list images, replacing {0} with the size.
/// For example C:\Folder\myiconlist{0}.png</param>
/// <param name="tooltip">Tool tip for the CommandGroup</param>
/// <param name="hint">Text displayed in SOLIDWORKS status bar when a user's mouse pointer is over the CommandGroup</param>
/// <param name="position">Position of the CommandGroup in the CommandManager for all document templates.
/// NOTE: Specify 0 to add the CommandGroup to the beginning of the CommandManager, or specify -1 to add it to the end of the CommandManager.
/// NOTE: You can also use ICommandGroup::MenuPosition to control the position of the CommandGroup in specific document templates.</param>
/// <param name="ignorePreviousVersion">True to remove all previously saved customization and toolbar information before creating a new CommandGroup, false to not.
/// Call CommandManager.GetGroupDataFromRegistry before calling this method to determine how to set IgnorePreviousVersion. Set IgnorePreviousVersion to true to prevent SOLIDWORKS from saving the current toolbar setting to the registry, even if there is no previous version.</param>
/// <param name="hasMenu">Whether the CommandGroup should appear in the Tools dropdown menu.</param>
/// <param name="hasToolbar">Whether the CommandGroup should appear in the Command Manager and as a separate toolbar.</param>
/// <returns></returns>
public CommandManagerGroup CreateCommands(string title, List <CommandManagerItem> items, string iconListsPath = "", string tooltip = "", string hint = "", int position = -1, bool ignorePreviousVersion = true, bool hasMenu = true, bool hasToolbar = true)
{
// Wrap any error creating the taskpane in a SolidDna exception
return(SolidDnaErrors.Wrap(() =>
{
// Lock the list
lock (mCommandGroups)
{
// Create the command group
var group = CreateCommandGroup(title, items, tooltip, hint, position, ignorePreviousVersion, hasMenu, hasToolbar);
// Set icon list
group.SetIconLists(iconListsPath);
// Create the group
group.Create(this);
// Add this group to the list
mCommandGroups.Add(group);
// Return the group
return group;
}
},
SolidDnaErrorTypeCode.SolidWorksCommandManager,
SolidDnaErrorCode.SolidWorksCommandGroupCreateError,
Localization.GetString("ErrorSolidWorksCommandGroupAddError")));
}
/// <summary>
/// Gets the current SolidWorks version information
/// </summary>
/// <returns></returns>
protected SolidWorksVersion GetSolidWorksVersion()
{
// Wrap any error
return(SolidDnaErrors.Wrap(() =>
{
// Get version string (such as 23.2.0 for 2015 SP2.0)
var revisionNumber = mBaseObject.RevisionNumber();
// Get revision string (such as sw2015_SP20)
string revisionString;
// Get build number (such as d150130.002)
string buildNumber;
// Get the hotfix string
string hotfixString;
mBaseObject.GetBuildNumbers2(out revisionString, out buildNumber, out hotfixString);
return new SolidWorksVersion
{
RevisionNumber = revisionNumber,
Revision = revisionString,
BuildNumber = buildNumber,
Hotfix = hotfixString
};
},
SolidDnaErrorTypeCode.SolidWorksApplication,
SolidDnaErrorCode.SolidWorksApplicationVersionError,
Localization.GetString("SolidWorksApplicationVersionError")));
}
/// <summary>
/// Set's all icon lists based on a string format of the absolute path to the icon list images, replacing {0} with the size.
/// For example C:\Folder\myiconlist{0}.png would look for all sizes such as
/// C:\Folder\myiconlist20.png
/// C:\Folder\myiconlist32.png
/// C:\Folder\myiconlist40.png
/// ... and so on
/// </summary>
/// <param name="pathFormat">The absolute path, with {0} used to replace with the icon size</param>
public void SetIconLists(string pathFormat)
{
// Make sure we have something
if (string.IsNullOrWhiteSpace(pathFormat))
{
return;
}
// Make sure the path format contains "{0}"
if (!pathFormat.Contains("{0}"))
{
throw new SolidDnaException(SolidDnaErrors.CreateError(
SolidDnaErrorTypeCode.SolidWorksCommandManager,
SolidDnaErrorCode.SolidWorksCommandGroupIvalidPathFormatError,
Localization.GetString("ErrorSolidWorksCommandGroupIconListInvalidPathError")));
}
// Find 20 image
var result = string.Format(pathFormat, 20);
if (File.Exists(result))
{
IconList20Path = result;
}
// Find 32 image
result = string.Format(pathFormat, 32);
if (File.Exists(result))
{
IconList32Path = result;
}
// Find 40 image
result = string.Format(pathFormat, 40);
if (File.Exists(result))
{
IconList40Path = result;
}
// Find 64 image
result = string.Format(pathFormat, 64);
if (File.Exists(result))
{
IconList64Path = result;
}
// Find 96 image
result = string.Format(pathFormat, 96);
if (File.Exists(result))
{
IconList96Path = result;
}
// Find 128 image
result = string.Format(pathFormat, 128);
if (File.Exists(result))
{
IconList128Path = result;
}
}
/// <summary>
/// Create a command group flyout containing a list of <see cref="CommandManagerItem"/> items
/// </summary>
/// <param name="title">Name of the flyout to create</param>
/// <param name="items">The command items to add</param>
/// <param name="pathFormat">The icon list absolute path based on a string format of the absolute path to the icon list images, replacing {0} with the size.
/// For example C:\Folder\myiconlist{0}.png</param>
/// <param name="tooltip">Tool tip for the new flyout</param>
/// <param name="hint">Text displayed in SOLIDWORKS status bar when a user's mouse pointer is over the flyout</param>
/// <returns></returns>
public CommandManagerFlyout CreateFlyoutGroup(string title, List <CommandManagerItem> items, string pathFormat, string tooltip = "", string hint = "")
{
#region Icons
// Make sure the path format contains "{0}"
if (pathFormat == null || !pathFormat.Contains("{0}"))
{
throw new SolidDnaException(SolidDnaErrors.CreateError(
SolidDnaErrorTypeCode.SolidWorksCommandManager,
SolidDnaErrorCode.SolidWorksCommandGroupInvalidPathFormatError,
Localization.GetString("ErrorSolidWorksCommandGroupIconListInvalidPathError")));
}
var iconListPaths = new Dictionary <int, string>();
// Fill the dictionary with all paths that exist
foreach (var iconSize in mIconSizes)
{
var path = string.Format(pathFormat, iconSize);
if (File.Exists(path))
{
iconListPaths.Add(iconSize, path);
}
}
// Get icon paths
var icons = iconListPaths.Values.ToArray();
#endregion
// Create unique callback Id
var callbackId = Guid.NewGuid().ToString("N");
// Attempt to create the command flyout
var unsafeCommandFlyout = BaseObject.CreateFlyoutGroup2(
mFlyoutIdCount,
title,
tooltip,
hint,
icons,
icons,
$"Callback({callbackId})",
null);
// Create managed object
var flyout = new CommandManagerFlyout(
unsafeCommandFlyout,
mFlyoutIdCount++,
callbackId,
items,
title,
hint, tooltip);
// Return it
return(flyout);
}
/// <summary>
/// Read the material from the model
/// </summary>
/// <returns></returns>
public Material GetMaterial()
{
// Wrap any error
return(SolidDnaErrors.Wrap(() =>
{
// Get the Id's
var idString = mBaseObject.MaterialIdName;
// Make sure we have some data
if (idString == null || !idString.Contains("|"))
{
return null;
}
// The Id string is split by pipes |
var ids = idString.Split('|');
// We need at least the first and second
// (first is database file name, second is material name)
if (ids.Length < 2)
{
throw new ArgumentOutOfRangeException(Localization.GetString("SolidWorksModelGetMaterialIdMissingError"));
}
// Extract data
var databaseName = ids[0];
var materialName = ids[1];
// See if we have a database file with the same name
var fullPath = Dna.Application.GetMaterials()?.FirstOrDefault(f => string.Equals(databaseName, Path.GetFileNameWithoutExtension(f.Database), StringComparison.InvariantCultureIgnoreCase));
var found = fullPath != null;
// Now we have the file, try and find the material from it
if (found)
{
var foundMaterial = Dna.Application.FindMaterial(fullPath.Database, materialName);
if (foundMaterial != null)
{
return foundMaterial;
}
}
// If we got here, the material was not found
// So fill in as much information as we have
return new Material
{
Database = databaseName,
Name = materialName
};
},
SolidDnaErrorTypeCode.SolidWorksModel,
SolidDnaErrorCode.SolidWorksModelGetMaterialError,
Localization.GetString("SolidWorksModelGetMaterialError")));
}
/// <summary>
/// Adds a control (Windows <see cref="System.Windows.Forms.UserControl"/>) to the taskpane
/// that has been exposed to COM and has a given ProgId
/// </summary>
/// <typeparam name="T">The type of UserControl being created</typeparam>
/// <param name="progId">The [ProgId()] attribute value adorned on the UserControl class</param>
/// <param name="licenseKey">The license key (for specific SolidWorks add-in types)</param>
/// <returns></returns>
public async Task <T> AddControlAsync <T>(string progId, string licenseKey)
{
// Wrap any error creating the taskpane in a SolidDna exception
return(SolidDnaErrors.Wrap <T>(() =>
{
// Attempt to create the taskpane
return (T)BaseObject.AddControl(progId, licenseKey);
},
SolidDnaErrorTypeCode.SolidWorksTaskpane,
SolidDnaErrorCode.SolidWorksTaskpaneAddControlError,
await Localization.GetStringAsync("ErrorSolidWorksTaskpaneAddControlError")));
}
/// <summary>
/// Saves a file to the specified path, with the specified options
/// </summary>
/// <param name="savePath">The path of the file to save as</param>
/// <param name="version">The version</param>
/// <param name="options">Any save as options</param>
/// <param name="pdfExportData">The PDF Export data if the save as type is a PDF</param>
/// <returns></returns>
public ModelSaveResult SaveAs(string savePath, SaveAsVersion version = SaveAsVersion.CurrentVersion, SaveAsOptions options = SaveAsOptions.None, PdfExportData pdfExportData = null)
{
// Start with a successful result
var results = new ModelSaveResult();
// Set errors and warnings to none to start with
var errors = 0;
var warnings = 0;
// Wrap any error
return(SolidDnaErrors.Wrap(() =>
{
// Try and save the model using the SaveAs method
BaseObject.Extension.SaveAs(savePath, (int)version, (int)options, pdfExportData?.ExportData, ref errors, ref warnings);
// If this fails, try another way
if (errors != 0)
{
BaseObject.SaveAs4(savePath, (int)version, (int)options, ref errors, ref warnings);
}
// Add any warnings
results.Warnings = (SaveAsWarnings)warnings;
// Add any errors
results.Errors = (SaveAsErrors)errors;
// If successful, and this is not a new file
// (otherwise the RCW changes and SolidWorksApplication has to reload ActiveModel)...
if (results.Successful && HasBeenSaved)
{
// Reload model data
ReloadModelData();
}
// If we have not been saved, SolidWorks never fires any FileSave events at all
// so request a refresh of the ActiveModel. That is the best we can do
// as this RCW is now invalid. If this model is not active when saved then
// it will simply reload the active models information
if (!HasBeenSaved)
{
SolidWorksEnvironment.Application.RequestActiveModelChanged();
}
// Return result
return results;
},
SolidDnaErrorTypeCode.SolidWorksModel,
SolidDnaErrorCode.SolidWorksModelSaveAsError,
Localization.GetString("SolidWorksModelGetMaterialError")));
}
/// <summary>
/// Called when SolidWorks is idle
/// </summary>
/// <returns></returns>
private int OnIdleNotify()
{
// Wrap any error
SolidDnaErrors.Wrap(() =>
{
// Inform listeners
Idle();
},
SolidDnaErrorTypeCode.SolidWorksApplication,
SolidDnaErrorCode.SolidWorksApplicationError,
Localization.GetString("SolidWorksApplicationOnIdleNotificationError"));
// NOTE: 0 is OK, anything else is an error
return(0);
}
/// <summary>
/// Attempts to find the material from a SolidWorks material database file (sldmat)
/// If found, returns the full information about the material
/// </summary>
/// <param name="database">The full path to the database</param>
/// <param name="materialName">The material name to find</param>
/// <returns></returns>
public Material FindMaterial(string database, string materialName)
{
// Wrap any error
return(SolidDnaErrors.Wrap(() =>
{
// Get all materials from the database
var materials = GetMaterials(database);
// Return if found the material with the same name
return materials?.FirstOrDefault(f => string.Equals(f.Name, materialName, StringComparison.InvariantCultureIgnoreCase));
},
SolidDnaErrorTypeCode.SolidWorksApplication,
SolidDnaErrorCode.SolidWorksApplicationFindMaterialsError,
Localization.GetString("SolidWorksApplicationFindMaterialsError")));
}
/// <summary>
/// Casts the object to a <see cref="ModelDisplayDimension"/>
/// Check with <see cref="IsDimension"/> first to assure that it is this type
/// </summary>
/// <param name="action">The Dimension is passed into this action to be used within it</param>
public void AsDimension(Action <ModelDisplayDimension> action)
{
// Wrap any error
SolidDnaErrors.Wrap(() =>
{
// Create feature
using (var model = new ModelDisplayDimension((IDisplayDimension)mBaseObject))
{
// Run action
action(model);
}
},
SolidDnaErrorTypeCode.SolidWorksModel,
SolidDnaErrorCode.SolidWorksModelSelectedObjectCastError,
Localization.GetString("SolidWorksModelSelectedObjectCastError"));
}
/// <summary>
/// Gets the <see cref="ModelFeature"/> of the item in the feature tree based on its name
/// </summary>
/// <param name="featureName">Name of the feature</param>
/// <returns>The <see cref="ModelFeature"/> for the named feature</returns>
public void GetFeatureByName(string featureName, Action <ModelFeature> action)
{
// Wrap any error
SolidDnaErrors.Wrap(() =>
{
// Create feature
using (var model = new ModelFeature((Feature)mBaseObject.FeatureByName(featureName)))
{
// Run action
action(model);
}
},
SolidDnaErrorTypeCode.SolidWorksModel,
SolidDnaErrorCode.SolidWorksModelAssemblyGetFeatureByNameError,
Localization.GetString(nameof(SolidDnaErrorCode.SolidWorksModelAssemblyGetFeatureByNameError)));
}
/// <summary>
/// Get's the command tab for this
/// </summary>
/// <param name="type">The type of document to get the tab for. Use only Part, Assembly or Drawing one at a time, otherwise the first found tab gets returned</param>
/// <param name="title">The title of the command tab to get</param>
/// <param name="createIfNotExist">True to create the tab if it does not exist</param>
/// <param name="clearExistingItems">Removes any existing items on the tab if true</param>
/// <returns></returns>
public CommandManagerTab GetCommandTab(ModelType type, string title, bool createIfNotExist = true, bool clearExistingItems = true)
{
// Try and get the tab
var unsafeTab = mBaseObject.GetCommandTab((int)type, title);
// If we did not get it, just ignore
if (unsafeTab == null && !createIfNotExist)
{
return(null);
}
// If we want to remove any previous tabs...
while (clearExistingItems && unsafeTab != null)
{
// Remove it
mBaseObject.RemoveCommandTab(unsafeTab);
// Clean COM object
Marshal.ReleaseComObject(unsafeTab);
// Try and get another
unsafeTab = mBaseObject.GetCommandTab((int)type, title);
}
// Create it if it doesn't exist
if (unsafeTab == null)
{
unsafeTab = mBaseObject.AddCommandTab((int)type, title);
}
// If it's still null, we failed
if (unsafeTab == null)
{
// Throw error
throw new SolidDnaException(SolidDnaErrors.CreateError(
SolidDnaErrorTypeCode.SolidWorksCommandManager,
SolidDnaErrorCode.SolidWorksCommandGroupCreateTabError,
Localization.GetString("ErrorSolidWorksCommandCreateTabError")));
}
// Return tab
return(new CommandManagerTab(unsafeTab));
}
/// <summary>
/// Saves a file to the specified path, with the specified options
/// </summary>
/// <param name="savePath">The path of the file to save as</param>
/// <param name="version">The version</param>
/// <param name="options">Any save as options</param>
/// <param name="pdfExportData">The PDF Export data if the save as type is a PDF</param>
/// <returns></returns>
public ModelSaveResult SaveAs(string savePath, SaveAsVersion version = SaveAsVersion.CurrentVersion, SaveAsOptions options = SaveAsOptions.None, PdfExportData pdfExportData = null)
{
// Start with a successful result
var results = new ModelSaveResult();
// Set errors and warnings to none to start with
var errors = 0;
var warnings = 0;
// Wrap any error
return(SolidDnaErrors.Wrap(() =>
{
// Try and save the model using the SaveAs method
mBaseObject.Extension.SaveAs(savePath, (int)version, (int)options, pdfExportData?.ExportData, ref errors, ref warnings);
// If this fails, try another way
if (errors != 0)
{
mBaseObject.SaveAs4(savePath, (int)version, (int)options, ref errors, ref warnings);
}
// Add any warnings
results.Warnings = (SaveAsWarnings)warnings;
// Add any errors
results.Errors = (SaveAsErrors)errors;
// If successful...
if (results.Successful)
{
// Reload model data
ReloadModelData();
}
// Return result
return results;
},
SolidDnaErrorTypeCode.SolidWorksModel,
SolidDnaErrorCode.SolidWorksModelSaveAsError,
Localization.GetString("SolidWorksModelGetMaterialError")));
}
/// <summary>
/// Attempts to create
/// </summary>
/// <param name="iconPath">An absolute path to an icon to use for the taskpane (ideally 37x37px)</param>
/// <param name="toolTip">The title text to show at the top of the taskpane</param>
public async Task <Taskpane> CreateTaskpaneAsync(string iconPath, string toolTip)
{
// Wrap any error creating the taskpane in a SolidDna exception
return(SolidDnaErrors.Wrap <Taskpane>(() =>
{
// Attempt to create the taskpane
var comTaskpane = mBaseObject.CreateTaskpaneView2(iconPath, toolTip);
// If we fail, return null
if (comTaskpane == null)
{
return null;
}
// If we succeed, create SolidDna object
return new Taskpane(comTaskpane);
},
SolidDnaErrorTypeCode.SolidWorksTaskpane,
SolidDnaErrorCode.SolidWorksTaskpaneCreateError,
await Localization.GetStringAsync("ErrorSolidWorksTaskpaneCreateError")));
}
/// <summary>
/// Creates a command group
/// </summary>
/// <param name="title">The title</param>
/// <param name="items">The command items to add</param>
/// <param name="tooltip">The tool tip</param>
/// <param name="hint">The hint</param>
/// <param name="position">Position of the CommandGroup in the CommandManager for all document templates.
/// NOTE: Specify 0 to add the CommandGroup to the beginning of the CommandMananger, or specify -1 to add it to the end of the CommandManager.
/// NOTE: You can also use ICommandGroup::MenuPosition to control the position of the CommandGroup in specific document templates.</param>
/// <param name="ignorePreviousVersion">True to remove all previously saved customization and toolbar information before creating a new CommandGroup, false to not.
/// Call CommandManager.GetGroupDataFromRegistry before calling this method to determine how to set IgnorePreviousVersion.
/// Set IgnorePreviousVersion to true to prevent SOLIDWORKS from saving the current toolbar setting to the registry, even if there is no previous version.</param>
/// <param name="hasMenu">Whether the CommandGroup should appear in the Tools dropdown menu.</param>
/// <param name="hasToolbar">Whether the CommandGroup should appear in the Command Manager and as a separate toolbar.</param>
/// <returns></returns>
private CommandManagerGroup CreateCommandGroup(string title, List <CommandManagerItem> items, string tooltip = "", string hint = "", int position = -1, bool ignorePreviousVersion = true, bool hasMenu = true, bool hasToolbar = true)
{
// NOTE: We may need to look carefully at this Id if things get removed and re-added based on this SolidWorks note:
//
// If you change the definition of an existing CommandGroup (i.e., add or remove toolbar buttons), you must assign a
// new unique user-defined UserID to that CommandGroup. You must perform this action to avoid conflicts with any
// previously existing CommandGroups and to allow for backward and forward compatibility of the CommandGroups in your application.
//
// Get the next Id
var id = mCommandGroups.Count == 0 ? 1 : mCommandGroups.Max(f => f.UserId) + 1;
// Store error code
var errors = -1;
// Attempt to create the command group
var unsafeCommandGroup = mBaseObject.CreateCommandGroup2(id, title, tooltip, hint, position, ignorePreviousVersion, ref errors);
// Check for errors
if (errors != (int)swCreateCommandGroupErrors.swCreateCommandGroup_Success)
{
// Get enum name
var errorEnumString = ((swCreateCommandGroupErrors)errors).ToString();
// Throw error
throw new SolidDnaException(SolidDnaErrors.CreateError(
SolidDnaErrorTypeCode.SolidWorksCommandManager,
SolidDnaErrorCode.SolidWorksCommandGroupCreateError,
Localization.GetString("ErrorSolidWorksCommandGroupAddError") + $". {errorEnumString}"));
}
// Otherwise we got the command group
var group = new CommandManagerGroup(unsafeCommandGroup, items, id, title, tooltip, hint, hasMenu, hasToolbar);
// Return it
return(group);
}
/// <summary>
/// Called before a file has started opening
/// </summary>
/// <param name="filename">The filename to the file being opened</param>
/// <returns></returns>
private int FileOpenPreNotify(string filename)
{
// Don't handle the ActiveModelDocChangeNotify event for file open events
// - wait until the file is open instead
// NOTE: We need to check if the variable already has a value because in the case of a drawing
// we get multiple pre events - one for the drawing, and one for each model in it,
// we're only interested in the first
// Wrap any error
SolidDnaErrors.Wrap(() =>
{
if (mFileLoading == null)
{
mFileLoading = filename;
}
},
SolidDnaErrorTypeCode.SolidWorksApplication,
SolidDnaErrorCode.SolidWorksApplicationFilePreOpenError,
Localization.GetString("SolidWorksApplicationFilePreOpenError"));
// NOTE: 0 is OK, anything else is an error
return(0);
}
/// <summary>
/// Get's a list of all materials in SolidWorks
/// </summary>
/// <param name="database">If specified, limits the results to the specified database full path</param>
public List <Material> GetMaterials(string database = null)
{
// Wrap any error
return(SolidDnaErrors.Wrap(() =>
{
// Create an empty list
var list = new List <Material>();
// If we are using a specified database, use that
if (database != null)
{
ReadMaterials(database, ref list);
}
else
{
// Otherwise, get all known ones
// Get the list of material databases (full paths to sldmat files)
var databases = (string[])mBaseObject.GetMaterialDatabases();
// Get materials from each
if (databases != null)
{
foreach (var d in databases)
{
ReadMaterials(d, ref list);
}
}
}
// Order the list
return list.OrderBy(f => f.DisplayName).ToList();
},
SolidDnaErrorTypeCode.SolidWorksApplication,
SolidDnaErrorCode.SolidWorksApplicationGetMaterialsError,
Localization.GetString("SolidWorksApplicationGetMaterialsError")));
}
/// <summary>
/// Gets the mass properties of a part/assembly
/// </summary>
/// <param name="doNotThrowOnError">If true, don't throw on errors, just return empty mass</param>
/// <returns></returns>
public MassProperties GetMassProperties(bool doNotThrowOnError = true)
{
// Wrap any error
return(SolidDnaErrors.Wrap(() =>
{
// Make sure we are a part
if (!Parent.IsPart && !Parent.IsAssembly)
{
if (doNotThrowOnError)
{
return new MassProperties();
}
else
{
throw new InvalidOperationException(Localization.GetString("SolidWorksModelGetMassModelNotPartError"));
}
}
double[] massProps = null;
var status = -1;
//
// SolidWorks 2016 is the start of support for MassProperties2
//
// Tested on 2015 and crashes, so drop-back to lower version for support
//
if (SolidWorksEnvironment.Application.SolidWorksVersion.Version < 2016)
{
// NOTE: 2 is best accuracy
massProps = (double[])BaseObject.GetMassProperties(2, ref status);
}
else
{
// NOTE: 2 is best accuracy
massProps = (double[])BaseObject.GetMassProperties2(2, out status, false);
}
// Make sure it succeeded
if (status == (int)swMassPropertiesStatus_e.swMassPropertiesStatus_UnknownError)
{
if (doNotThrowOnError)
{
return new MassProperties();
}
else
{
throw new InvalidOperationException(Localization.GetString("SolidWorksModelGetMassModelStatusFailed"));
}
}
// If we have no mass, return empty
else if (status == (int)swMassPropertiesStatus_e.swMassPropertiesStatus_NoBody)
{
return new MassProperties();
}
// Otherwise we have the properties so return them
return new MassProperties(massProps);
},
SolidDnaErrorTypeCode.SolidWorksModel,
SolidDnaErrorCode.SolidWorksModelGetMassPropertiesError,
Localization.GetString("SolidWorksModelGetMassPropertiesError")));
}
/// <summary>
/// Creates the command group based on it's current children
/// NOTE: Once created, parent command manager must remove and re-create the group
/// This group cannot be re-used after creating, any edits will not take place
/// </summary>
/// <param name="manager">The command manager that is our owner</param>
public void Create(CommandManager manager)
{
if (mCreated)
{
throw new SolidDnaException(SolidDnaErrors.CreateError(
SolidDnaErrorTypeCode.SolidWorksCommandManager,
SolidDnaErrorCode.SolidWorksCommandGroupReActivateError,
Localization.GetString("ErrorSolidWorksCommandGroupReCreateError")));
}
#region Set Icons
//
// Set the icons
//
// NOTE: The order in which you specify the icons must be the same for this property and MainIconList.
//
// For example, if you specify an array of paths to
// 20 x 20 pixels, 32 x 32 pixels, and 40 x 40 pixels icons for this property
// then you must specify an array of paths to
// 20 x 20 pixels, 32 x 32 pixels, and 40 x 40 pixels icons for MainIconList.</remarks>
//
// Set all icon lists
var icons = GetIconListPaths();
// 2016+ support
mBaseObject.IconList = icons.ToArray();
// <2016 support
if (icons.Count > 0)
{
// Largest icon for this one
mBaseObject.LargeIconList = icons.Last();
// The list of icons
mBaseObject.MainIconList = icons.ToArray();
// Use the largest available image for small icons too
mBaseObject.SmallIconList = icons.Last();
}
#endregion
#region Add Items
// Add items
this.Items?.ForEach(item => AddCommandItem(item));
#endregion
// Activate the command group
mCreated = mBaseObject.Activate();
// Get command Ids
this.Items?.ForEach(item => item.CommandId = mBaseObject.CommandID[item.UniqueId]);
#region Command Tab
// Add to parts tab
var list = this.Items.Where(f => f.TabView != CommandManagerItemTabView.None && f.VisibleForParts).ToList();
if (list?.Count > 0)
{
AddItemsToTab(ModelType.Part, manager, list);
}
// Add to assembly tab
list = this.Items.Where(f => f.TabView != CommandManagerItemTabView.None && f.VisibleForAssemblies).ToList();
if (list?.Count > 0)
{
AddItemsToTab(ModelType.Assembly, manager, list);
}
// Add to drawing tab
list = this.Items.Where(f => f.TabView != CommandManagerItemTabView.None && f.VisibleForDrawings).ToList();
if (list?.Count > 0)
{
AddItemsToTab(ModelType.Drawing, manager, list);
}
#endregion
// If we failed to create, throw
if (!mCreated)
{
throw new SolidDnaException(SolidDnaErrors.CreateError(
SolidDnaErrorTypeCode.SolidWorksCommandManager,
SolidDnaErrorCode.SolidWorksCommandGroupActivateError,
Localization.GetString("ErrorSolidWorksCommandGroupActivateError")));
}
}
/// <summary>
/// Reads the material database and adds the materials to the given list
/// </summary>
/// <param name="database">The database to read</param>
/// <param name="list">The list to add materials to</param>
private void ReadMaterials(string database, ref List <Material> list)
{
// First make sure the file exists
if (!File.Exists(database))
{
throw new SolidDnaException(
SolidDnaErrors.CreateError(
SolidDnaErrorTypeCode.SolidWorksApplication,
SolidDnaErrorCode.SolidWorksApplicationGetMaterialsFileNotFoundError,
Localization.GetString("SolidWorksApplicationGetMaterialsFileNotFoundError")));
}
try
{
// File should be an XML document, so attempt to read that
using (var stream = File.Open(database, FileMode.Open, FileAccess.Read, FileShare.Read))
{
// Try and parse the Xml
var xmlDoc = XDocument.Load(stream);
// Make sure we got something
if (xmlDoc == null)
{
throw new ArgumentNullException(Localization.GetString("SolidWorksApplicationGetMaterialsXmlNotLoadedError"));
}
var materials = new List <Material>();
// Iterate all classification nodes and inside are the materials
xmlDoc.Root.Elements("classification")?.ToList()?.ForEach(f =>
{
// Get classification name
var classification = f.Attribute("name")?.Value;
// Iterate all materials
f.Elements("material").ToList().ForEach(material =>
{
// Add them to the list
materials.Add(new Material
{
Database = database,
DatabaseFileFound = true,
Classification = classification,
Name = material.Attribute("name")?.Value,
Description = material.Attribute("description")?.Value,
});
});
});
// If we found any materials, add them
if (materials.Count > 0)
{
list.AddRange(materials);
}
}
}
catch (Exception ex)
{
// If we crashed for any reason during parsing, wrap in SolidDna exception
if (!File.Exists(database))
{
throw new SolidDnaException(
SolidDnaErrors.CreateError(
SolidDnaErrorTypeCode.SolidWorksApplication,
SolidDnaErrorCode.SolidWorksApplicationGetMaterialsFileFormatError,
Localization.GetString("SolidWorksApplicationGetMaterialsFileFormatError"),
ex));
}
}
}
