internal void ParseItems(IXApplication app, IAttributeSet atts, IMetadata[] metadata,
out bool isStatic, out ItemsControlItem[] staticItems, out IMetadata itemsSourceMetadata)
{
if (atts.ContextType.IsEnum)
{
var items = EnumExtension.GetEnumFields(atts.ContextType);
staticItems = items.Select(i => new ItemsControlItem()
{
DisplayName = i.Value,
Value = i.Key
}).ToArray();
isStatic = true;
itemsSourceMetadata = null;
}
else
{
var customItemsAtt = atts.Get <ItemsSourceControlAttribute>();
if (customItemsAtt.StaticItems?.Any() == true)
{
staticItems = customItemsAtt
.StaticItems.Select(i => new ItemsControlItem(i)).ToArray();
isStatic = true;
itemsSourceMetadata = null;
}
else if (customItemsAtt.CustomItemsProvider != null)
{
itemsSourceMetadata = null;
if (customItemsAtt.Dependencies?.Any() != true)
{
var provider = customItemsAtt.CustomItemsProvider;
staticItems = provider.ProvideItems(app, new IControl[0]).Select(i => new ItemsControlItem(i)).ToArray();
isStatic = true;
}
else
{
isStatic = false;
staticItems = null;
}
}
else if (customItemsAtt.ItemsSource != null)
{
isStatic = false;
staticItems = null;
itemsSourceMetadata = metadata?.FirstOrDefault(m => object.Equals(m.Tag, customItemsAtt.ItemsSource));
if (itemsSourceMetadata == null)
{
throw new NullReferenceException($"Failed to find the items source metadata property: {customItemsAtt.ItemsSource}");
}
}
else
{
throw new NotSupportedException("Items source is not specified");
}
}
}
private static void TraverseSelectedFaces(IXApplication app)
{
foreach (var face in app.Documents.Active.Selections.OfType <IXFace>())
{
Console.WriteLine(face.Area);
}
}
public CommandsManager(IXExtension addIn, IXApplication app,
IMacroRunner macroRunner,
IMessageService msg, ISettingsProvider settsProvider,
IToolbarConfigurationProvider toolbarConfProvider,
IXLogger logger)
{
m_AddIn = addIn;
m_App = app;
m_MacroRunner = macroRunner;
m_Msg = msg;
m_SettsProvider = settsProvider;
m_ToolbarConfProvider = toolbarConfProvider;
m_Logger = logger;
m_CachedToggleStates = new Dictionary <CommandMacroInfo, bool>();
m_StateResolvers = new ConcurrentDictionary <CommandMacroInfo, IToggleButtonStateResolver>();
try
{
ToolbarInfo = LoadUserToolbar();
}
catch (Exception ex)
{
m_Msg.ShowError(ex, "Failed to load toolbar specification");
}
}
private static void SketchSegmentColors(IXApplication app)
{
var seg = app.Documents.Active.Selections.First() as IXSketchSegment;
var color = seg.Color;
seg.Color = System.Drawing.Color.Purple;
}
private static void CreateDrawingView(IXApplication app)
{
var partDoc = app.Documents.Active as IXDocument3D;
var view = partDoc.ModelViews[StandardViewType_e.Right];
var drw = app.Documents.NewDrawing();
var drwView = drw.Sheets.Active.DrawingViews.CreateModelViewBased(view);
}
public void UpdateState(IXApplication app, IControl source, IControl[] dependencies)
{
var itemsCtrl = (IItemsControl)source;
itemsCtrl.Items = m_ItemsProvider.ProvideItems(app, dependencies)
?.Select(i => new ItemsControlItem(i)).ToArray();
}
internal ControlUpdateStateData(IXApplication app, IBinding src, IBinding[] deps, IDependencyHandler handler)
{
m_App = app;
m_Source = src;
m_Dependencies = deps;
m_Handler = handler;
}
internal MetadataUpdateStateData(IXApplication app, IControl ctrl, IMetadata[] deps, IMetadataDependencyHandler handler)
{
m_App = app;
m_Ctrl = ctrl;
m_Dependencies = deps;
m_Handler = handler;
}
public void Init(IXApplication app, IRawDependencyGroup depGroup)
{
m_App = app;
m_ControlDependencies = new Dictionary <IBinding, List <ControlUpdateStateData> >();
m_MetadataDependencies = new Dictionary <IMetadata, List <MetadataUpdateStateData> >();
foreach (var data in depGroup.DependenciesTags)
{
var srcBnd = data.Key;
var dependOnTags = data.Value.Item1;
var handler = data.Value.Item2;
var dependOnBindings = new IBinding[dependOnTags.Length];
for (int i = 0; i < dependOnTags.Length; i++)
{
var dependOnTag = dependOnTags[i];
IBinding dependOnBinding;
if (!depGroup.TaggedBindings.TryGetValue(dependOnTag, out dependOnBinding))
{
throw new Exception("Dependent on binding is not found for tag");
}
dependOnBindings[i] = dependOnBinding;
}
foreach (var dependOnBinding in dependOnBindings)
{
List <ControlUpdateStateData> updates;
if (!m_ControlDependencies.TryGetValue(dependOnBinding, out updates))
{
dependOnBinding.ModelUpdated += OnModelUpdated;
updates = new List <ControlUpdateStateData>();
m_ControlDependencies.Add(dependOnBinding, updates);
}
updates.Add(new ControlUpdateStateData(m_App, srcBnd, dependOnBindings, handler));
}
}
foreach (var data in depGroup.MetadataDependencies)
{
var state = new MetadataUpdateStateData(m_App, data.Key, data.Value.Item1, data.Value.Item2);
foreach (var md in data.Value.Item1)
{
if (!m_MetadataDependencies.TryGetValue(md, out List <MetadataUpdateStateData> states))
{
md.Changed += OnMetadataChanged;
states = new List <MetadataUpdateStateData>();
m_MetadataDependencies.Add(md, states);
}
states.Add(state);
}
}
}
public DocumentsHandler(IXApplication app, IXLogger logger)
{
m_App = app;
m_Logger = logger;
m_Handlers = new List <Type>();
m_DocsMap = new Dictionary <IXDocument, List <IDocumentHandler> >();
}
public BaseCustomFeatureEditor(IXApplication app,
Type featDefType,
CustomFeatureParametersParser paramsParser,
IServiceProvider svcProvider, CreateDynamicControlsDelegate createDynCtrlHandler)
: this(app, featDefType, paramsParser, svcProvider)
{
InitPage(createDynCtrlHandler);
}
public void Load(IXApplication app, IEnumerable <IBinding> bindings,
IRawDependencyGroup dependencies, IMetadata[] metadata)
{
Bindings = bindings;
Dependency = new DependencyManager();
Metadata = metadata;
Dependency.Init(app, dependencies);
}
public void Init(IXApplication app, IXDocument model)
{
m_App = app;
m_Model = model;
m_App.Documents.DocumentActivated += OnDocumentActivated;
m_Model.StorageReadAvailable += OnStorageReadAvailable;
m_Model.StorageWriteAvailable += OnStorageWriteAvailable;
}
public void UpdateState(IXApplication app, IControl source, IControl[] dependencies)
{
var isChecked = dependencies.First()?.GetValue();
if (isChecked is bool)
{
source.Enabled = !(bool)isChecked;
}
}
public override IEnumerable <FolderItem> ProvideItems(IXApplication app, IControl[] dependencies)
{
var weldmentProfilesLoc = (app as ISwApplication).Sw.GetUserPreferenceStringValue(
(int)swUserPreferenceStringValue_e.swFileLocationsWeldmentProfiles)
.Split(new string[] { System.Environment.NewLine }, System.StringSplitOptions.RemoveEmptyEntries).First();
return(System.IO.Directory.GetDirectories(weldmentProfilesLoc)
.Select(d => new FolderItem(d)));
}
public void UpdateState(IXApplication app, IControl source, IControl[] dependencies)
{
var scope = dependencies.First()?.GetValue();
if (scope is InputScope_e)
{
source.Visible = (InputScope_e)scope != InputScope_e.Selection;
}
}
public MacroRunner(IXApplication app, IMacroExecutor runner, IMessageService msgSvc, IXLogger logger,
IToolbarModuleProxy toolbarModuleProxy, IFilePathResolver filePathResolver)
{
m_App = app;
m_Runner = runner;
m_ToolbarModuleProxy = toolbarModuleProxy;
m_MsgSvc = msgSvc;
m_Logger = logger;
m_FilePathResolver = filePathResolver;
}
internal AssemblyBatchRunJobExecutor(IXApplication app, IMacroRunnerExService macroRunnerSvc,
IXDocument[] documents, IEnumerable <MacroData> macros, bool activateDocs)
{
m_App = app;
m_MacroRunner = macroRunnerSvc;
m_Docs = documents;
m_Macros = macros;
m_ActivateDocs = activateDocs;
}
private void TryAddProcessToJob(IXApplication app)
{
try
{
m_JobMgr.AddProcess(app.Process);
}
catch (Exception ex)
{
m_Logger.Log(ex);
}
}
public void RunMacro(IXApplication app, string macroPath, MacroEntryPoint entryPoint,
MacroRunOptions_e opts, string args, IXDocument doc)
{
try
{
if (entryPoint == null)
{
var macro = app.OpenMacro(macroPath);
entryPoint = macro.EntryPoints.First();
}
if (!string.IsNullOrEmpty(args) || doc != null)
{
if (m_Runner != null)
{
var param = new MacroParameter();
if (doc != null)
{
param.Set("Model", GetDocumentDispatch(doc));
}
if (!string.IsNullOrEmpty(args))
{
param.Set("Args", ParseCommandLine(args));
}
var res = m_Runner.Run(GetAppDispatch(app),
macroPath, entryPoint.ModuleName,
entryPoint.ProcedureName, (int)opts, param, true);
if (!res.Result)
{
throw new MacroRunnerResultError(res.Message);
}
}
else
{
throw new UserException("Macro runner is not installed. Cannot run the macro with arguments");
}
}
else
{
var macro = app.OpenMacro(macroPath);
macro.Run(entryPoint, opts);
}
}
catch (MacroUserInterruptException) //do not consider this as an error
{
}
catch (MacroRunnerResultError resEx)
{
throw new MacroRunFailedException(macroPath, -1, resEx.Message);
}
}
public void UpdateState(IXApplication app, IControl source, IControl[] dependencies)
{
var itemsCtrl = (IItemsControl)source;
itemsCtrl.Items = m_ItemsProvider.ProvideItems(app, dependencies)
?.Select(i => new ItemsControlItem()
{
DisplayName = i.ToString(),
Value = i
}).ToArray();
}
public void Init(IXApplication app, IXDocument model)
{
m_HasChanges = false;
if (model is IXDrawing)
{
m_Drawing = (IXDrawing)model;
m_Drawing.StreamWriteAvailable += OnStreamWriteAvailable;
m_QrCodesLazy = new Lazy <ObservableCollection <QrCodeInfo> >(ReadQrCodeData);
}
}
public EscapeBatchExecutorCancelHandler(IBatchRunJobExecutor exec, IXApplication app, Dispatcher dispatcher)
{
m_Exec = exec;
m_App = app;
m_Dispatcher = dispatcher;
m_IsCancellingInProgress = false;
m_Hook = new KeyboardHook(m_App.Process);
m_Hook.KeyDown += OnKeyDown;
}
public IEnumerable <object> ProvideItems(IXApplication app, IControl[] dependencies)
{
var depVal = dependencies.First()?.GetValue()?.ToString();
return(new string[]
{
depVal + "_A",
depVal + "_B",
depVal + "_C"
});
}
public void Init(IXApplication app, IXDocument model)
{
m_App = app;
m_Model = model;
m_Model.StreamReadAvailable += LoadFromStream;
m_Model.StreamWriteAvailable += SaveToStream;
m_Model.StorageReadAvailable += LoadFromStorage;
m_Model.StorageWriteAvailable += SaveToStorage;
//m_App.ShowMessageBox($"Opened {model.Title}");
}
protected BaseCustomFeatureEditor(IXApplication app,
Type featDefType,
CustomFeatureParametersParser paramsParser,
IServiceProvider svcProvider)
{
m_App = app;
m_SvcProvider = svcProvider;
m_Logger = svcProvider.GetService <IXLogger>();
m_DefType = featDefType;
m_BodiesComparer = new XObjectEqualityComparer <IXBody>();
m_ParamsParser = paramsParser;
}
private static void Progress(IXApplication app)
{
using (var prg = app.CreateProgress())
{
for (int i = 0; i < 100; i++)
{
prg.Report((double)i / 100);
prg.SetStatus(i.ToString());
System.Threading.Thread.Sleep(100);
}
}
}
public PageBuilderBase(IXApplication app, IDataModelBinder dataBinder,
IPageConstructor <TPage> pageConstr,
params IPageElementConstructor <TGroup, TPage>[]
ctrlsContstrs)
{
m_App = app;
m_DataBinder = dataBinder;
m_PageConstructor = pageConstr;
m_ControlConstructors = new ConstructorsContainer <TPage, TGroup>(ctrlsContstrs);
}
public void Init(IXApplication app, IXDocument model)
{
m_Model = model;
m_DescPrp = m_Model.Properties["Description"];
m_D1Dim = m_Model.Dimensions["D1@Sketch1"];
m_Model.Closing += OnModelClosing;
m_Model.Selections.NewSelection += OnNewSelection;
m_DescPrp.ValueChanged += OnPropertyValueChanged;
m_D1Dim.ValueChanged += OnDimensionValueChanged;
}
private void OnProcessInput(IXApplication app, ICadApplicationInstanceProvider instProvider, List <IXDocument> input)
{
if (m_EnableOrdering)
{
var vm = new InputsSorterVM(instProvider.Descriptor);
var cts = new CancellationTokenSource();
var cancellationToken = cts.Token;
var src = input.ToArray();
input.Clear();
m_Host.WpfApplication.Dispatcher.Invoke(() =>
{
var wnd = new InputsSorterWindow();
wnd.Owner = m_Host.WpfApplication.MainWindow;
wnd.DataContext = vm;
wnd.Loaded += async(s, e) =>
{
try
{
var itemsList = await Task.Run(
() => m_Sorter.Sort(src,
p => vm.Progress = p,
cancellationToken));
vm.LoadItems(itemsList);
}
catch (OperationCanceledException)
{
}
};
var res = wnd.ShowDialog();
if (res == true)
{
foreach (ItemVM item in vm.InputView)
{
input.Add(item.Document);
}
}
else
{
cts.Cancel();
throw new OperationCanceledException();
}
});
}
}
