Example #1
0
        private bool GetCheckState(CommandMacroInfo macroInfo)
        {
            if (macroInfo.ToggleButtonStateCodeType == ToggleButtonStateCode_e.None)
            {
                return(false);
            }
            else
            {
                try
                {
                    IToggleButtonStateResolver stateResolver = null;

                    m_StateResolvers.TryGetValue(macroInfo, out stateResolver);

                    if (stateResolver != null)
                    {
                        return(stateResolver.Resolve());
                    }
                    else
                    {
                        return(false);
                    }
                }
                catch (Exception ex)
                {
                    m_Logger.Log(ex);
                    return(false);
                }
            }
        }
Example #2
0
        private bool TryResolveState(CommandMacroInfo macroInfo)
        {
            bool isChecked = false;

            try
            {
                if (macroInfo.ResolveButtonStateCodeOnce || macroInfo.ToggleButtonStateCodeType == ToggleButtonStateCode_e.None)
                {
                    if (!m_CachedToggleStates.TryGetValue(macroInfo, out isChecked))
                    {
                        GetCheckState(macroInfo);
                        m_CachedToggleStates.Add(macroInfo, isChecked);
                    }
                }
                else
                {
                    isChecked = GetCheckState(macroInfo);
                }
            }
            catch
            {
                isChecked = false;
            }

            return(isChecked);
        }
Example #3
0
 public void RunMacroCommand(CommandMacroInfo cmd)
 {
     try
     {
         m_MacroRunner.RunMacro(cmd.MacroPath, cmd.EntryPoint, cmd.UnloadAfterRun);
     }
     catch (Exception ex)
     {
         m_Logger.Log(ex);
         m_Msg.ShowError(ex, $"Failed to run macro: '{cmd.Title}'");
     }
 }
Example #4
0
 public void RunMacroCommand(CommandMacroInfo cmd)
 {
     try
     {
         m_MacroRunner.RunMacro(cmd.MacroPath, cmd.EntryPoint, false);
     }
     catch (Exception ex)
     {
         m_Logger.Log(ex);
         m_Msg.ShowError(ex, "Failed to run macro");
     }
 }
        internal CommandItemInfoSpec(CommandMacroInfo info, ISldWorks app)
        {
            m_Info = info;
            m_App  = app;

            UserId     = info.Id;
            Title      = info.Title;
            Tooltip    = info.Description;
            Icon       = info.GetCommandIcon();
            HasMenu    = true;
            HasToolbar = true;
        }
Example #6
0
        public bool TryRunMacroCommand(Triggers_e trigger, CommandMacroInfo macroInfo, IXDocument targetDoc, string workDir)
        {
            try
            {
                m_Logger.Log($"Invoking '{trigger}' trigger for '{macroInfo.Title}'", LoggerMessageSeverity_e.Debug);

                var eventType = GetEventType(trigger);

                var eventArgs = new MacroRunningArguments(macroInfo, targetDoc)
                {
                    Cancel = false
                };

                m_ToolbarModuleProxy.CallMacroRunning(eventType, eventArgs);

                if (!eventArgs.Cancel)
                {
                    var opts = eventArgs.MacroInfo.UnloadAfterRun ? MacroRunOptions_e.UnloadAfterRun : MacroRunOptions_e.Default;

                    var macroPath = m_FilePathResolver.Resolve(eventArgs.MacroInfo.MacroPath, workDir);

                    m_Logger.Log($"Running macro '{macroPath}' with arguments '{eventArgs.MacroInfo.Arguments}'", LoggerMessageSeverity_e.Debug);

                    var entryPoint = eventArgs.MacroInfo.EntryPoint;

                    if (entryPoint == null)
                    {
                        throw new UserException($"Entry point is not specified for macro '{macroInfo.Title}'");
                    }

                    m_Runner.RunMacro(m_App, macroPath,
                                      new MacroEntryPoint(entryPoint.ModuleName, entryPoint.SubName),
                                      opts, eventArgs.MacroInfo.Arguments, null);

                    return(true);
                }
                else
                {
                    m_Logger.Log($"Trigger '{trigger}' for '{macroInfo.Title}' invoking cancelled", LoggerMessageSeverity_e.Debug);
                    return(false);
                }
            }
            catch (Exception ex)
            {
                m_Logger.Log(ex);
                m_MsgSvc.ShowError(ex, $"Failed to run a macro '{macroInfo.Title}' on trigger '{trigger}'");
                return(false);
            }
        }
Example #7
0
 public bool RunMacroCommand(CommandMacroInfo cmd, out Exception err)
 {
     try
     {
         m_MacroRunner.RunMacro(cmd.MacroPath, cmd.EntryPoint, cmd.UnloadAfterRun);
         err = null;
         return(true);
     }
     catch (Exception ex)
     {
         m_Logger.Log(ex);
         err = ex;
         return(false);
     }
 }
Example #8
0
        internal CommandItemInfoSpec(CommandMacroInfo info) : base(info.Id)
        {
            Info = info;

            Title      = info.Title;
            Tooltip    = info.Description;
            Icon       = info.GetCommandIcon();
            HasToolbar = info.Location.HasFlag(Location_e.Toolbar);
            HasMenu    = info.Location.HasFlag(Location_e.Menu);
            //HasTabBox = info.Location.HasFlag(Location_e.TabBox);
            //if (HasTabBox)
            //{
            //    TabBoxStyle = XCad.UI.Commands.Enums.RibbonTabTextDisplay_e.TextBelow;
            //}
        }
Example #9
0
        internal CommandItemInfoSpec(CommandMacroInfo info, IIconsProvider[] iconsProviders, IFilePathResolver pathResolver, string workDir) : base(info.Id)
        {
            Info = info;

            Title              = info.Title;
            Tooltip            = info.Description;
            Icon               = info.GetCommandIcon(iconsProviders, pathResolver, workDir);
            HasToolbar         = info.Location.HasFlag(Location_e.Toolbar);
            HasMenu            = info.Location.HasFlag(Location_e.Menu);
            HasRibbon          = info.Location.HasFlag(Location_e.TabBox);
            SupportedWorkspace = GetWorkspace(info.Scope);

            if (HasRibbon)
            {
                RibbonTextStyle = RibbonTabTextDisplay_e.TextBelow;
            }
        }
Example #10
0
 private void OnMacroCommandClick(CommandMacroInfo cmd)
 {
     RunMacroCommand(cmd);
 }
 private void OnMacroCommandClick(CommandMacroInfo cmd)
 {
     MacroCommandClick?.Invoke(cmd);
 }