Exemple #1
0
 private static void getEngines(List <Type> types)
 {
     foreach (Type t in types)
     {
         IMacroEngine typeInstance = null;
         try
         {
             if (t.IsVisible)
             {
                 typeInstance = Activator.CreateInstance(t) as IMacroEngine;
             }
         }
         catch { }
         if (typeInstance != null)
         {
             try
             {
                 m_engines.Add(typeInstance.Name, t);
             }
             catch (Exception ee)
             {
                 BusinessLogic.Log.Add(umbraco.BusinessLogic.LogTypes.Error, -1, "Can't import MacroEngine '" + t.FullName + "': " + ee);
             }
         }
     }
 }
Exemple #2
0
        /// <summary>
        /// Instiantiation of EventManager
        /// </summary>
        private MacroUI(IMacroEngine engine)
        {
            s_Instance = this;
            m_IsLoaded = false;

            MacroEngine = engine;
        }
Exemple #3
0
        /// <summary>
        /// Initializes the UI and Interop and binds events to the AddIn.
        /// </summary>
        /// <param name="application">Excel Application</param>
        /// <param name="dispatcher">Excel UI Dispatcher</param>
        /// <param name="RibbonMacros">A serialized list of ribbon accessible macros</param>
        public static MacroUI CreateApplicationInstance(IMacroEngine engine)
        {
            MacroUI ui = new MacroUI(engine);

            string[]  workspaces = new string[] { Path.GetFullPath(Files.AssemblyDirectory + "/Macros/") };
            HostState state      = new HostState(workspaces, Properties.Settings.Default.ActiveDocument, Properties.Settings.Default.IncludedLibraries);

            engine.Instantiate(state);
            ui.Instantiate(state);


            ui.MainWindow = new MainWindow()
            {
                DataContext = new MainWindowViewModel()
            };
            ((MainWindowViewModel)ui.MainWindow.DataContext).SetTheme(Macro_Editor.Properties.Settings.Default.Theme);

            if (ui.m_IsRibbonLoaded)
            {
                Events.InvokeEvent("LoadRibbonMacros");
            }

            ui.m_IsLoaded = true;

            return(ui);
        }
Exemple #4
0
 private async Task Work(IMacroEngine Macro, IPluginManager Plugins)
 {
     foreach (var c in Enumerable.Range(0, this.Loop))
     {
         await this.SendAndWait(Macro, this.Word, 50);
         Macro.Display(c.ToString());
     }
     Macro.Display("completed");
 }
Exemple #5
0
        public static IMacroEngine GetByExtension(string extension)
        {
            IMacroEngine engine =
                GetAll().Find(t => t.SupportedExtensions.Contains(extension));

            if (engine != null)
            {
                return(engine);
            }

            throw new MacroEngineException(string.Format("No MacroEngine found for extension '{0}'", extension));
        }
Exemple #6
0
 private async Task SendAndWait(IMacroEngine Macro, string text, int timems)
 {
     await Macro.SendLineAsync(text);
     await Macro.WaitAsync("\n>", ">> ?", "\n/>");
     await Macro.DelayAsync(timems);
 }
Exemple #7
0
        public async Task Sample(IMacroEngine Macro, IPluginManager Plugins)
        {

            Macro.Timeout = 0;

            await Macro.SendLineAsync("cs1");

            await Macro.WaitAsync("\n>");


            //var num = 2;
            await Macro.DelayAsync(1000);



            await Macro.SendLineAsync("cs2");

            await Macro.WaitLineAsync();


            await Macro.SendLineAsync("cs3");

            //Macro.Pause();
            //await Task.Delay(2000);
            //Macro.Resume();

            await Macro.WaitAsync("\n>");

            Macro.Display(Macro.History(0));
            Macro.Display(Macro.History(1));
            Macro.Display(Macro.History(2));
            Macro.Display(Macro.History(3));


            await Macro.SendLineAsync("abdefhjicbcddefghi");
            var i = await Macro.WaitAsync("abc", "defg", "hi");
            Macro.Display(i.ToString());

            //Macro.Cancel();

            var fileName = @"d.txt";

            var line = "";
            var list = new List<string>();

            using (var sr = new StreamReader(fileName, Encoding.UTF8))
            {
                while ((line = sr.ReadLine()) != null)
                {
                    list.Add(line);
                }
            }

            foreach (var str in list)
            {
                Macro.Display(str);
                //await Task.Delay(10);
            }
            //await Task.Delay(500);

            Macro.Timeout = 4000;

            await Macro.SendLineAsync("cs4");

            try
            {
                await Macro.WaitAsync("\ny>");
            }
            catch (TimeoutException)
            {
                Macro.Display("timeout");
                await Macro.SendLineAsync("retry");
            }


            await Macro.DelayAsync(3000);

            await Macro.SendLineAsync("cs5");

            await Macro.WaitAsync("\ny>");
            
        }
Exemple #8
0
 public async Task Execute(IMacroEngine Macro, IPluginManager Plugins)
 {
     await Macro.DelayAsync(10);
 }
Exemple #9
0
        /// <summary>
        /// マクロ実行
        /// </summary>
        /// <param name="Macro"></param>
        /// <param name="Plugins"></param>
        /// <returns></returns>
        public async Task RunAsync(IMacroEngine Macro, PluginManager Plugins)
        {
            //Macro.Start(this.Name);
            try
            {
                await this.AsyncFunc(Macro, Plugins);

                //送信バッファを空にする
                await Macro.SendLineAsync(null);
            }
            finally
            {
                //Macro.End(this.Name);
            }
        }
Exemple #10
0
 public MacroGlobal(IMacroEngine macro, IPluginManager plugins)
 {
     this.Macro = macro;
     this.Plugins = plugins;
 }