public void BatchRunnerOptionsTest()
{
var opts = WithDocumentMock(
d =>
{
d.Input.Add("D:\\folder1");
d.Input.Add("D:\\folder2");
d.Filters.Clear();
d.Filters.Add(new FilterVM("*.sld*"));
d.Macros.Add(new MacroDataVM(new MacroData()
{
FilePath = "C:\\macro1.swp"
}));
d.Macros.Add(new MacroDataVM(new MacroData()
{
FilePath = "C:\\macro2.swp"
}));
d.Settings.IsTimeoutEnabled = true;
d.Settings.Timeout = 30;
d.Settings.OpenFileOptionSilent = true;
d.Settings.OpenFileOptionReadOnly = true;
d.Settings.StartupOptionBackground = true;
d.Settings.StartupOptionSilent = false;
d.Settings.StartupOptionSafe = false;
d.Settings.Version = SwApplicationFactory.CreateVersion(SwVersion_e.Sw2020);
});
Assert.IsTrue(new string[] { "*.sld*" }.SequenceEqual(opts.Filters));
Assert.IsTrue(new string[] { "C:\\macro1.swp", "C:\\macro2.swp" }.SequenceEqual(opts.Macros.Select(m => m.FilePath)));
Assert.IsTrue(new string[] { "D:\\folder1", "D:\\folder2" }.SequenceEqual(opts.Input));
Assert.AreEqual(30, opts.Timeout);
Assert.AreEqual(OpenFileOptions_e.Silent | OpenFileOptions_e.ReadOnly | OpenFileOptions_e.ForbidUpgrade, opts.OpenFileOptions);
Assert.AreEqual(StartupOptions_e.Background, opts.StartupOptions);
Assert.AreEqual("Sw2020", opts.VersionId);
}
public IXVersion ParseVersion(string version)
{
if (string.IsNullOrEmpty(version))
{
var installedVers = SwApplicationFactory.GetInstalledVersions();
if (installedVers.Any())
{
return(installedVers.OrderBy(v => (int)v.Major).First());
}
else
{
throw new Exception("Failed to find installed version of the host application");
}
}
else if (int.TryParse(version, out int rev))
{
var swVers = (SwVersion_e)Enum.Parse(typeof(SwVersion_e), $"Sw{rev}");
return(SwApplicationFactory.CreateVersion(swVers));
}
else if (version.StartsWith("solidworks", StringComparison.CurrentCultureIgnoreCase))
{
var swVers = (SwVersion_e)Enum.Parse(typeof(SwVersion_e), $"Sw{version.Substring("solidworks".Length).Trim()}");
return(SwApplicationFactory.CreateVersion(swVers));
}
else
{
var swVers = (SwVersion_e)Enum.Parse(typeof(SwVersion_e), version);
return(SwApplicationFactory.CreateVersion(swVers));
}
}
protected void UpdateSwReferences(string destPath, params string[] assmRelPaths)
{
Process prc;
using (var app = SwApplicationFactory.Create(SW_VERSION,
Xarial.XCad.Enums.ApplicationState_e.Background
| Xarial.XCad.Enums.ApplicationState_e.Silent
| Xarial.XCad.Enums.ApplicationState_e.Safe))
{
prc = app.Process;
foreach (var assmPath in assmRelPaths)
{
using (var doc = (ISwDocument)app.Documents.Open(Path.Combine(destPath, assmPath)))
{
doc.Model.ForceRebuild3(false);
doc.Save();
var deps = (doc.Model.Extension.GetDependencies(false, false, false, false, false) as string[]).Where((item, index) => index % 2 != 0).ToArray();
if (!deps.All(d => d.Contains("^") || d.StartsWith(destPath, StringComparison.CurrentCultureIgnoreCase)))
{
throw new Exception("Failed to setup source assemblies");
}
}
}
app.Close();
}
prc.Kill();
}
private string FindSwAppPath(SwVersion_e?vers)
{
RegistryKey swAppRegKey = null;
if (vers.HasValue)
{
var progId = string.Format(SwApplicationFactory.PROG_ID_TEMPLATE, (int)vers);
swAppRegKey = Registry.ClassesRoot.OpenSubKey(progId);
}
else
{
foreach (var versCand in Enum.GetValues(typeof(SwVersion_e)).Cast <int>().OrderByDescending(x => x))
{
var progId = string.Format(SwApplicationFactory.PROG_ID_TEMPLATE, versCand);
swAppRegKey = Registry.ClassesRoot.OpenSubKey(progId);
if (swAppRegKey != null)
{
break;
}
}
}
if (swAppRegKey != null)
{
return(SwApplicationFactory.FindSwPathFromRegKey(swAppRegKey));
}
else
{
throw new NullReferenceException("Failed to find the information about the installed SOLIDWORKS applications in the registry");
}
}
public void BatchRunnerOptionsTimeoutTest()
{
var mock = new Mock <IBatchRunnerModel>();
BatchJob opts = null;
mock.Setup(m => m.CreateExecutor(It.IsAny <BatchJob>())).Callback <BatchJob>(e => opts = e).Returns(new Mock <IBatchRunJobExecutor>().Object);
mock.Setup(m => m.InstalledVersions).Returns(new ISwVersion[] { SwApplicationFactory.CreateVersion(SwVersion_e.Sw2019), SwApplicationFactory.CreateVersion(SwVersion_e.Sw2020) });
mock.Setup(m => m.GetVersionId(It.IsAny <IXVersion>())).Returns("Sw2020");
mock.Setup(m => m.ParseVersion(It.IsAny <string>())).Returns(new Mock <IXVersion>().Object);
var modelMock = mock.Object;
var msgSvcMock = new Mock <IMessageService>().Object;
var vm = new BatchManagerVM(modelMock, msgSvcMock);
vm.Document = new BatchDocumentVM("", new BatchJob(), modelMock, msgSvcMock);
vm.Document.Input.Add("abc");
vm.Document.Macros.Add(new MacroData()
{
FilePath = "xyz"
});
vm.Document.Settings.Version = SwApplicationFactory.CreateVersion(SwVersion_e.Sw2019);
vm.Document.Settings.Timeout = 300;
vm.Document.Settings.IsTimeoutEnabled = false;
vm.Document.Settings.IsTimeoutEnabled = true;
vm.Document.RunJobCommand.Execute(null);
Assert.AreEqual(300, opts.Timeout);
}
public void Setup()
{
if (SW_PRC_ID < 0)
{
List <string> m_DisabledStartupAddIns;
SwApplicationFactory.DisableAllAddInsStartup(out m_DisabledStartupAddIns);
m_App = SwApplicationFactory.Create(null,
ApplicationState_e.Background
| ApplicationState_e.Safe
| ApplicationState_e.Silent);
if (m_DisabledStartupAddIns?.Any() == true)
{
SwApplicationFactory.EnableAddInsStartup(m_DisabledStartupAddIns);
}
m_CloseSw = true;
}
else if (SW_PRC_ID == 0)
{
var prc = Process.GetProcessesByName("SLDWORKS").First();
m_App = SwApplicationFactory.FromProcess(prc);
}
else
{
var prc = Process.GetProcessById(SW_PRC_ID);
m_App = SwApplicationFactory.FromProcess(prc);
}
m_SwApp = m_App.Sw;
m_Disposables = new List <IDisposable>();
}
public void ConfigureTest()
{
var app = SwApplicationFactory.FromProcess(Process.GetProcessesByName("SLDWORKS").First());
var svc = new CabinetConfiguratorService();
svc.Configure((IXAssembly)app.Documents.Active, 2.0, 1.0, 0.6, 4, 0.6, HandleType_e.C);
}
private static void CustomServices()
{
var app = SwApplicationFactory.PreCreate();
var svcColl = new ServiceCollection();
svcColl.AddOrReplace <IXLogger, MyLogger>();
app.CustomServices = svcColl;
app.Commit();
}
public void EqualityTest()
{
var v1 = SwApplicationFactory.CreateVersion(Xarial.XCad.SolidWorks.Enums.SwVersion_e.Sw2020);
var v2 = SwApplicationFactory.CreateVersion(Xarial.XCad.SolidWorks.Enums.SwVersion_e.Sw2020);
var v3 = SwApplicationFactory.CreateVersion(Xarial.XCad.SolidWorks.Enums.SwVersion_e.Sw2019);
Assert.That(v1.Equals(v2));
Assert.That(!v1.Equals(v3));
}
public IXApplication StartApplication(IXVersion vers, StartupOptions_e opts,
CancellationToken cancellationToken)
{
var app = SwApplicationFactory.PreCreate();
app.State = ApplicationState_e.Default;
app.Version = (ISwVersion)vers;
app.CustomServices = m_CustomServices;
List <string> forceDisabledAddIns = null;
if (opts.HasFlag(StartupOptions_e.Safe))
{
app.State |= ApplicationState_e.Safe;
TryDisableAddIns(out forceDisabledAddIns);
}
if (opts.HasFlag(StartupOptions_e.Background))
{
app.State |= ApplicationState_e.Background;
}
if (opts.HasFlag(StartupOptions_e.Silent))
{
app.State |= ApplicationState_e.Silent;
}
if (opts.HasFlag(StartupOptions_e.Hidden))
{
app.State |= ApplicationState_e.Hidden;
}
try
{
app.Commit(cancellationToken);
}
finally
{
if (forceDisabledAddIns != null)
{
TryEnableAddIns(forceDisabledAddIns);
}
}
app.Sw.UserControlBackground = true;
app.Sw.CommandInProgress = true;
//Note. By some reasons the process from IXApplication::Process does not fire exited event
var prc = Process.GetProcessById(app.Process.Id);
prc.EnableRaisingEvents = true;
prc.Exited += OnProcessExited;
m_ForceDisabledAddIns.Add(prc, forceDisabledAddIns);
return(app);
}
public void CompareExtensionTest()
{
var v1 = SwApplicationFactory.CreateVersion(Xarial.XCad.SolidWorks.Enums.SwVersion_e.Sw2020);
var v2 = SwApplicationFactory.CreateVersion(Xarial.XCad.SolidWorks.Enums.SwVersion_e.Sw2020);
var v3 = SwApplicationFactory.CreateVersion(Xarial.XCad.SolidWorks.Enums.SwVersion_e.Sw2019);
Assert.AreEqual(VersionEquality_e.Same, v1.Compare(v2));
Assert.AreEqual(VersionEquality_e.Newer, v1.Compare(v3));
Assert.AreEqual(VersionEquality_e.Older, v3.Compare(v2));
}
public void CompareTest()
{
var v1 = SwApplicationFactory.CreateVersion(Xarial.XCad.SolidWorks.Enums.SwVersion_e.Sw2020);
var v2 = SwApplicationFactory.CreateVersion(Xarial.XCad.SolidWorks.Enums.SwVersion_e.Sw2020);
var v3 = SwApplicationFactory.CreateVersion(Xarial.XCad.SolidWorks.Enums.SwVersion_e.Sw2019);
Assert.AreEqual(0, v1.CompareTo(v2));
Assert.AreEqual(1, v1.CompareTo(v3));
Assert.AreEqual(-1, v3.CompareTo(v2));
}
public MainWindow()
{
InitializeComponent();
var app = SwApplicationFactory.Create();
m_PrpsReader = new PropertiesReaderService(app);
var vm = new PropertiesTableVM(m_PrpsReader);
this.DataContext = vm;
}
protected override IXApplication CastApplication(object app)
{
if (app is ISldWorks)
{
return(SwApplicationFactory.FromPointer((ISldWorks)app));
}
else
{
throw new InvalidCastException("Pointer to dispatch is not ISldWorks");
}
}
private void TryDisableAddIns(out List <string> guids)
{
try
{
SwApplicationFactory.DisableAllAddInsStartup(out guids);
}
catch (Exception ex)
{
m_Logger.Log(ex);
guids = null;
}
}
private void TryEnableAddIns(List <string> guids)
{
try
{
if (guids?.Any() == true)
{
SwApplicationFactory.EnableAddInsStartup(guids);
}
}
catch (Exception ex)
{
m_Logger.Log(ex);
}
}
public void BatchRunnerOptionsTimeoutDisableTest()
{
var opts = WithDocumentMock(d =>
{
d.Input.Add("abc");
d.Macros.Add(new MacroDataVM(new MacroData()
{
FilePath = "xyz"
}));
d.Settings.Version = SwApplicationFactory.CreateVersion(SwVersion_e.Sw2019);
d.Settings.IsTimeoutEnabled = false;
});
Assert.AreEqual(-1, opts.Timeout);
}
static void Main(string[] args)
{
using (var app = SwApplicationFactory.Create(SwVersion_e.Sw2020, ApplicationState_e.Background))
{
var doc = (ISwDocument)app.Documents.Open(
Path.Combine(Path.GetDirectoryName(typeof(Program).Assembly.Location), @"template\model1.SLDPRT"),
readOnly: true);
Console.WriteLine("Enter width in meters");
var widthStr = Console.ReadLine();
if (!string.IsNullOrEmpty(widthStr))
{
doc.Dimensions["Width@Base"].SetValue(double.Parse(widthStr));
}
Console.WriteLine("Enter height in meters");
var heightStr = Console.ReadLine();
if (!string.IsNullOrEmpty(heightStr))
{
doc.Dimensions["Height@Boss"].SetValue(double.Parse(heightStr));
}
Console.WriteLine("Enter length in meters");
var lengthStr = Console.ReadLine();
if (!string.IsNullOrEmpty(lengthStr))
{
doc.Dimensions["Length@Base"].SetValue(double.Parse(lengthStr));
}
Console.WriteLine("Enter output file path");
var outFilePath = Console.ReadLine();
int errs = -1;
int warns = -1;
if (!doc.Model.Extension.SaveAs(outFilePath,
(int)SolidWorks.Interop.swconst.swSaveAsVersion_e.swSaveAsCurrentVersion,
(int)SolidWorks.Interop.swconst.swSaveAsOptions_e.swSaveAsOptions_Silent, null, ref errs, ref warns))
{
throw new Exception("Failed to save document");
}
app.Close();
}
}
static void Main(string[] args)
{
using (var app = SwApplicationFactory.Create(SwVersion_e.Sw2020, ApplicationState_e.Background))
{
ISldWorks swApp = app.Sw;
Console.WriteLine(swApp.RevisionNumber());
var doc = app.Documents.Open(@"D:\model1.SLDPRT", Documents.Enums.DocumentState_e.ReadOnly);
var swModel = (doc as ISwDocument).Model;
Console.WriteLine(swModel.GetTitle());
app.Close();
}
}
public void BatchRunnerOptionsTest()
{
var mock = new Mock <IBatchRunnerModel>();
BatchJob opts = null;
mock.Setup(m => m.CreateExecutor(It.IsAny <BatchJob>())).Callback <BatchJob>(e => opts = e).Returns(new Mock <IBatchRunJobExecutor>().Object);
mock.Setup(m => m.InstalledVersions).Returns(new ISwVersion[] { SwApplicationFactory.CreateVersion(SwVersion_e.Sw2019), SwApplicationFactory.CreateVersion(SwVersion_e.Sw2020) });
mock.Setup(m => m.GetVersionId(It.IsAny <IXVersion>())).Returns("Sw2020");
mock.Setup(m => m.ParseVersion(It.IsAny <string>())).Returns(new Mock <IXVersion>().Object);
var modelMock = mock.Object;
var msgSvcMock = new Mock <IMessageService>().Object;
var vm = new BatchManagerVM(modelMock, msgSvcMock);
vm.Document = new BatchDocumentVM("", new BatchJob(), modelMock, msgSvcMock);
vm.Document.Input.Add("D:\\folder1");
vm.Document.Input.Add("D:\\folder2");
vm.Document.Filters.Clear();
vm.Document.Filters.Add(new FilterVM("*.sld*"));
vm.Document.Macros.Add(new MacroData()
{
FilePath = "C:\\macro1.swp"
});
vm.Document.Macros.Add(new MacroData()
{
FilePath = "C:\\macro2.swp"
});
vm.Document.Settings.IsTimeoutEnabled = true;
vm.Document.Settings.Timeout = 30;
vm.Document.Settings.OpenFileOptionSilent = true;
vm.Document.Settings.OpenFileOptionReadOnly = true;
vm.Document.Settings.StartupOptionBackground = true;
vm.Document.Settings.StartupOptionSilent = false;
vm.Document.Settings.StartupOptionSafe = false;
vm.Document.Settings.Version = SwApplicationFactory.CreateVersion(SwVersion_e.Sw2020);
vm.Document.RunJobCommand.Execute(null);
Assert.IsTrue(new string[] { "*.sld*" }.SequenceEqual(opts.Filters));
Assert.IsTrue(new string[] { "C:\\macro1.swp", "C:\\macro2.swp" }.SequenceEqual(opts.Macros.Select(m => m.FilePath)));
Assert.IsTrue(new string[] { "D:\\folder1", "D:\\folder2" }.SequenceEqual(opts.Input));
Assert.AreEqual(30, opts.Timeout);
Assert.AreEqual(OpenFileOptions_e.Silent | OpenFileOptions_e.ReadOnly | OpenFileOptions_e.ForbidUpgrade, opts.OpenFileOptions);
Assert.AreEqual(StartupOptions_e.Background, opts.StartupOptions);
Assert.AreEqual("Sw2020", opts.VersionId);
}
static void Main(string[] args)
{
var sldProcess = Process.GetProcessesByName("SLDWORKS");
if (!sldProcess.Any())
{
Console.WriteLine("No SolidWorks opened");
}
else
{
var app = SwApplicationFactory.FromProcess(sldProcess.First());
ISldWorks sw = app.Sw;
}
Console.ReadLine();
}
static void Main(string[] args)
{
try
{
var app = SwApplicationFactory.Create(Xarial.XCad.SolidWorks.Enums.SwVersion_e.Sw2020,
ApplicationState_e.Default);
//var app = SwApplicationFactory.FromProcess(Process.GetProcessesByName("SLDWORKS").First());
//CustomServices();
//Progress(app);
//SketchSegmentColors(app);
//CreateDrawingView(app);
//var sw = Activator.CreateInstance(Type.GetTypeFromProgID("SldWorks.Application")) as ISldWorks;
//sw.Visible = true;
//var app = SwApplication.FromPointer(sw);
//CreateSketchEntities(app);
//TraverseSelectedFaces(app);
//CreateSweepFromSelection(app);
//CreateTempGeometry(app);
//CreateSweepFromSelection(app);
}
catch
{
}
Console.ReadLine();
}
public void IsVersionNewerOrEqualTest()
{
var sw2017sp23Mock = new Mock <SldWorks>();
sw2017sp23Mock.Setup(m => m.RevisionNumber()).Returns("25.2.3");
var app = SwApplicationFactory.FromPointer(sw2017sp23Mock.Object);
var r1 = app.IsVersionNewerOrEqual(SwVersion_e.Sw2017);
var r2 = app.IsVersionNewerOrEqual(SwVersion_e.Sw2017, 2);
var r3 = app.IsVersionNewerOrEqual(SwVersion_e.Sw2017, 2, 3);
var r4 = app.IsVersionNewerOrEqual(SwVersion_e.Sw2017, 3);
var r5 = app.IsVersionNewerOrEqual(SwVersion_e.Sw2017, 1);
var r6 = app.IsVersionNewerOrEqual(SwVersion_e.Sw2016, 4);
var r7 = app.IsVersionNewerOrEqual(SwVersion_e.Sw2018, 0);
Assert.IsTrue(r1);
Assert.IsTrue(r2);
Assert.IsTrue(r3);
Assert.IsFalse(r4);
Assert.IsTrue(r5);
Assert.IsTrue(r6);
Assert.IsFalse(r7);
Assert.Throws <ArgumentException>(() => app.IsVersionNewerOrEqual(SwVersion_e.Sw2017, null, 1));
}
static void Main(string[] args)
{
try
{
//var app1 = Activator.CreateInstance(Type.GetTypeFromProgID("SldWorks.Application"));
ISwApplication app = null;
DateTime start;
Process prc = null;
//var start = DateTime.Now;
//var app = SwApplicationFactory.Create(Xarial.XCad.SolidWorks.Enums.SwVersion_e.Sw2020);
//Console.WriteLine($"Default: {(DateTime.Now - start).TotalMilliseconds}");
//var prc = Process.GetProcessById(app.Sw.GetProcessID());
//prc.Kill();
//start = DateTime.Now;
//app = SwApplicationFactory.Create(Xarial.XCad.SolidWorks.Enums.SwVersion_e.Sw2020, ApplicationState_e.Silent);
//Console.WriteLine($"Silent: {(DateTime.Now - start).TotalMilliseconds}");
//prc = Process.GetProcessById(app.Sw.GetProcessID());
//prc.Kill();
//start = DateTime.Now;
//app = SwApplicationFactory.Create(Xarial.XCad.SolidWorks.Enums.SwVersion_e.Sw2020, ApplicationState_e.Safe);
//Console.WriteLine($"Safe: {(DateTime.Now - start).TotalMilliseconds}");
//prc = Process.GetProcessById(app.Sw.GetProcessID());
//prc.Kill();
//start = DateTime.Now;
//app = SwApplicationFactory.Create(Xarial.XCad.SolidWorks.Enums.SwVersion_e.Sw2020, ApplicationState_e.Hidden);
//Console.WriteLine($"Hidden: {(DateTime.Now - start).TotalMilliseconds}");
//prc = Process.GetProcessById(app.Sw.GetProcessID());
//prc.Kill();
start = DateTime.Now;
app = SwApplicationFactory.Create(Xarial.XCad.SolidWorks.Enums.SwVersion_e.Sw2020, ApplicationState_e.Background);
Console.WriteLine($"Background: {(DateTime.Now - start).TotalMilliseconds}");
//prc = Process.GetProcessById(app.Sw.GetProcessID());
//prc.Kill();
//var app = SwApplicationFactory.FromProcess(Process.GetProcessesByName("SLDWORKS").First());
Console.ReadLine();
return;
var o = app.Documents.Open(@"C:\Users\artem\OneDrive\xCAD\TestData\foreign.IGS");
var p = app.Documents.NewPart();
var d = app.Documents.NewDrawing();
var a = app.Documents.NewAssembly();
//SketchSegmentColors(app);
//CreateDrawingView(app);
//var sw = Activator.CreateInstance(Type.GetTypeFromProgID("SldWorks.Application")) as ISldWorks;
//sw.Visible = true;
//var app = SwApplication.FromPointer(sw);
//CreateSketchEntities(app);
//TraverseSelectedFaces(app);
//CreateSweepFromSelection(app);
//CreateTempGeometry(app);
//CreateSweepFromSelection(app);
}
catch
{
}
}
internal ISldWorks Start(Action <Process> startHandler, CancellationToken cancellationToken)
{
SwVersion_e?vers = null;
if (m_Version != null)
{
vers = m_Version.Major;
}
var args = new List <string>();
if (m_State.HasFlag(ApplicationState_e.Safe))
{
args.Add(SwApplicationFactory.CommandLineArguments.SafeMode);
}
if (m_State.HasFlag(ApplicationState_e.Silent))
{
args.Add(SwApplicationFactory.CommandLineArguments.SilentMode);
}
if (m_State.HasFlag(ApplicationState_e.Background))
{
args.Add(SwApplicationFactory.CommandLineArguments.BackgroundMode);
}
var swPath = FindSwAppPath(vers);
var prcInfo = new ProcessStartInfo(swPath, string.Join(" ", args));
if (m_State.HasFlag(ApplicationState_e.Hidden))
{
prcInfo.UseShellExecute = false;
prcInfo.CreateNoWindow = true;
prcInfo.WindowStyle = ProcessWindowStyle.Hidden;
}
var prc = Process.Start(prcInfo);
startHandler.Invoke(prc);
try
{
ISldWorks app;
do
{
if (cancellationToken.IsCancellationRequested)
{
throw new AppStartCancelledByUserException();
}
app = RotHelper.TryGetComObjectByMonikerName <ISldWorks>(SwApplicationFactory.GetMonikerName(prc));
Thread.Sleep(100);
}while (app == null);
if (m_State.HasFlag(ApplicationState_e.Hidden))
{
app.Visible = false;
}
return(app);
}
catch
{
if (prc != null)
{
try
{
prc.Kill();
}
catch
{
}
}
throw;
}
}
public IEnumerable <IXVersion> GetInstalledVersions() => SwApplicationFactory.GetInstalledVersions();
