private bool UpdateDataEx(EcasAction a, bool bGuiToInternal, bool bDxTypeInfo)
		{
			m_bBlockTypeSelectionHandler = true;
			bool bResult = EcasUtil.UpdateDialog(EcasObjectType.Action, m_cmbActions,
				m_dgvParams, a, bGuiToInternal, bDxTypeInfo);
			m_bBlockTypeSelectionHandler = false;
			return bResult;
		}

        public void Execute(EcasAction a, EcasContext ctx)
        {
            if(a == null) throw new ArgumentNullException("a");

            foreach(EcasActionType t in m_actions)
            {
                if(t.Type.EqualsValue(a.Type))
                {
                    t.ExecuteMethod(a, ctx);
                    return;
                }
            }

            throw new NotSupportedException();
        }

 private static void ExecuteGlobalAutoType(EcasAction a, EcasContext ctx)
 {
     Program.MainForm.ExecuteGlobalAutoType();
 }

        private static void ExecuteSelectedAutoType(EcasAction a, EcasContext ctx)
        {
            try
            {
                // Do not Spr-compile the sequence here; it'll be compiled by
                // the auto-type engine (and this expects an auto-type sequence
                // as input, not a data string; compiling it here would e.g.
                // result in broken '%' characters in passwords)
                string strSeq = EcasUtil.GetParamString(a.Parameters, 0, false);
                if(string.IsNullOrEmpty(strSeq)) strSeq = null;

                PwEntry pe = Program.MainForm.GetSelectedEntry(true);
                if(pe == null) return;
                PwDatabase pd = Program.MainForm.DocumentManager.SafeFindContainerOf(pe);

                IntPtr hFg = NativeMethods.GetForegroundWindowHandle();
                if(AutoType.IsOwnWindow(hFg))
                    AutoType.PerformIntoPreviousWindow(Program.MainForm, pe,
                        pd, strSeq);
                else AutoType.PerformIntoCurrentWindow(pe, pd, strSeq);
            }
            catch(Exception) { Debug.Assert(false); }
        }

        private static void ExportDatabaseFile(EcasAction a, EcasContext ctx)
        {
            string strPath = EcasUtil.GetParamString(a.Parameters, 0, true);
            // if(string.IsNullOrEmpty(strPath)) return; // Allow no-file exports
            string strFormat = EcasUtil.GetParamString(a.Parameters, 1, true);
            if(string.IsNullOrEmpty(strFormat)) return;
            string strGroup = EcasUtil.GetParamString(a.Parameters, 2, true);
            string strTag = EcasUtil.GetParamString(a.Parameters, 3, true);

            PwDatabase pd = Program.MainForm.ActiveDatabase;
            if((pd == null) || !pd.IsOpen) return;

            PwGroup pg = pd.RootGroup;
            if(!string.IsNullOrEmpty(strGroup))
            {
                char chSep = strGroup[0];
                PwGroup pgSub = pg.FindCreateSubTree(strGroup.Substring(1),
                    new char[] { chSep }, false);
                pg = (pgSub ?? (new PwGroup(true, true, KPRes.Group, PwIcon.Folder)));
            }

            if(!string.IsNullOrEmpty(strTag))
            {
                // Do not use pg.Duplicate, because this method
                // creates new UUIDs
                pg = pg.CloneDeep();
                pg.TakeOwnership(true, true, true);

                GroupHandler gh = delegate(PwGroup pgSub)
                {
                    PwObjectList<PwEntry> l = pgSub.Entries;
                    long n = (long)l.UCount;
                    for(long i = n - 1; i >= 0; --i)
                    {
                        if(!l.GetAt((uint)i).HasTag(strTag))
                            l.RemoveAt((uint)i);
                    }

                    return true;
                };

                gh(pg);
                pg.TraverseTree(TraversalMethod.PreOrder, gh, null);
            }

            PwExportInfo pei = new PwExportInfo(pg, pd, true);
            IOConnectionInfo ioc = (!string.IsNullOrEmpty(strPath) ?
                IOConnectionInfo.FromPath(strPath) : null);
            ExportUtil.Export(pei, strFormat, ioc);
        }

 private static void CloseDatabaseFile(EcasAction a, EcasContext ctx)
 {
     Program.MainForm.CloseDocument(null, false, false, true);
 }

 private static void RemoveToolBarButton(EcasAction a, EcasContext ctx)
 {
     string strID = EcasUtil.GetParamString(a.Parameters, 0, true);
     Program.MainForm.RemoveCustomToolBarButton(strID);
 }

 private static void ShowEntriesByTag(EcasAction a, EcasContext ctx)
 {
     string strTag = EcasUtil.GetParamString(a.Parameters, 0, true);
     Program.MainForm.ShowEntriesByTag(strTag);
 }

        private static void ExportDatabaseFile(EcasAction a, EcasContext ctx)
        {
            string strPath = EcasUtil.GetParamString(a.Parameters, 0, true);
            // if(string.IsNullOrEmpty(strPath)) return; // Allow no-file exports
            string strFormat = EcasUtil.GetParamString(a.Parameters, 1, true);
            if(string.IsNullOrEmpty(strFormat)) return;

            PwDatabase pd = Program.MainForm.ActiveDatabase;
            if((pd == null) || !pd.IsOpen) return;

            PwExportInfo pei = new PwExportInfo(pd.RootGroup, pd, true);
            IOConnectionInfo ioc = (!string.IsNullOrEmpty(strPath) ?
                IOConnectionInfo.FromPath(strPath) : null);
            ExportUtil.Export(pei, strFormat, ioc);
        }

        private static CompositeKey KeyFromParams(EcasAction a, int iPassword,
            int iKeyFile, int iUserAccount)
        {
            string strPassword = EcasUtil.GetParamString(a.Parameters, iPassword, true);
            string strKeyFile = EcasUtil.GetParamString(a.Parameters, iKeyFile, true);
            bool bUserAccount = StrUtil.StringToBool(EcasUtil.GetParamString(
                a.Parameters, iUserAccount, true));

            CompositeKey cmpKey = null;
            if(!string.IsNullOrEmpty(strPassword) || !string.IsNullOrEmpty(strKeyFile) ||
                bUserAccount)
            {
                List<string> vArgs = new List<string>();
                if(!string.IsNullOrEmpty(strPassword))
                    vArgs.Add("-" + AppDefs.CommandLineOptions.Password + ":" + strPassword);
                if(!string.IsNullOrEmpty(strKeyFile))
                    vArgs.Add("-" + AppDefs.CommandLineOptions.KeyFile + ":" + strKeyFile);
                if(bUserAccount)
                    vArgs.Add("-" + AppDefs.CommandLineOptions.UserAccount);

                CommandLineArgs cmdArgs = new CommandLineArgs(vArgs.ToArray());
                cmpKey = KeyUtil.KeyFromCommandLine(cmdArgs);
            }

            return cmpKey;
        }

 private void OnActionAdd(object sender, EventArgs e)
 {
     EcasAction eNew = new EcasAction();
     EcasActionForm dlg = new EcasActionForm();
     dlg.InitEx(eNew);
     if(UIUtil.ShowDialogAndDestroy(dlg) == DialogResult.OK)
     {
         m_trigger.ActionCollection.Add(eNew);
         UpdateActionListEx(false);
     }
 }

        private static void ExecuteShellCmd(EcasAction a, EcasContext ctx)
        {
            string strCmd = EcasUtil.GetParamString(a.Parameters, 0, true, true);
            string strArgs = EcasUtil.GetParamString(a.Parameters, 1, true, true);
            bool bWait = StrUtil.StringToBool(EcasUtil.GetParamString(a.Parameters,
                2, string.Empty));

            if(string.IsNullOrEmpty(strCmd)) return;

            try
            {
                Process p;
                if(string.IsNullOrEmpty(strArgs)) p = Process.Start(strCmd);
                else p = Process.Start(strCmd, strArgs);

                if((p != null) && bWait)
                {
                    Program.MainForm.UIBlockInteraction(true);
                    MessageService.ExternalIncrementMessageCount();

                    try { p.WaitForExit(); }
                    catch(Exception) { Debug.Assert(false); }

                    MessageService.ExternalDecrementMessageCount();
                    Program.MainForm.UIBlockInteraction(false);
                }
            }
            catch(Exception e)
            {
                throw new Exception(strCmd + MessageService.NewParagraph + e.Message);
            }
        }

 public void InitEx(EcasAction e)
 {
     m_actionInOut = e;
     m_action = e.CloneDeep();
 }

		private static void OpenDatabaseFile(EcasAction a, EcasContext ctx)
		{
			string strPath = EcasUtil.GetParamString(a.Parameters, 0, true);
			if(string.IsNullOrEmpty(strPath)) return;

			string strIOUserName = EcasUtil.GetParamString(a.Parameters, 1, true);
			string strIOPassword = EcasUtil.GetParamString(a.Parameters, 2, true);

			IOConnectionInfo ioc = IOFromParameters(strPath, strIOUserName, strIOPassword);
			if(ioc == null) return;

			string strPassword = EcasUtil.GetParamString(a.Parameters, 3, true);
			string strKeyFile = EcasUtil.GetParamString(a.Parameters, 4, true);
			bool bUserAccount = StrUtil.StringToBool(EcasUtil.GetParamString(
				a.Parameters, 5, true));

			CompositeKey cmpKey = null;
			if(!string.IsNullOrEmpty(strPassword) || !string.IsNullOrEmpty(strKeyFile) ||
				bUserAccount)
			{
				List<string> vArgs = new List<string>();
				if(!string.IsNullOrEmpty(strPassword))
					vArgs.Add("-" + AppDefs.CommandLineOptions.Password + ":" + strPassword);
				if(!string.IsNullOrEmpty(strKeyFile))
					vArgs.Add("-" + AppDefs.CommandLineOptions.KeyFile + ":" + strKeyFile);
				if(bUserAccount)
					vArgs.Add("-" + AppDefs.CommandLineOptions.UserAccount);

				CommandLineArgs cmdArgs = new CommandLineArgs(vArgs.ToArray());
				cmpKey = KeyUtil.KeyFromCommandLine(cmdArgs);
			}

			Program.MainForm.OpenDatabase(ioc, cmpKey, ioc.IsLocalFile());
		}

		private static void ExecuteShellCmd(EcasAction a, EcasContext ctx)
		{
			string strCmd = EcasUtil.GetParamString(a.Parameters, 0, true);
			string strArgs = EcasUtil.GetParamString(a.Parameters, 1, true);

			if(string.IsNullOrEmpty(strCmd)) return;

			try
			{
				if(string.IsNullOrEmpty(strArgs)) Process.Start(strCmd);
				else Process.Start(strCmd, strArgs);
			}
			catch(Exception e)
			{
				throw new Exception(strCmd + MessageService.NewParagraph + e.Message);
			}
		}

 private static void EcasActionExecuteNull(EcasAction a, EcasContext ctx)
 {
 }

        public void ExecuteAction(EcasAction a, EcasContext ctx)
        {
            if(a == null) throw new ArgumentNullException("a");

            foreach(EcasActionProvider p in m_vActionProviders)
            {
                if(p.IsSupported(a.Type))
                {
                    p.Execute(a, ctx);
                    return;
                }
            }

            throw new Exception(KPRes.TriggerActionTypeUnknown + " " +
                KPRes.TypeUnknownHint + MessageService.NewParagraph + a.TypeString);
        }

        private static void ExecuteSleep(EcasAction a, EcasContext ctx)
        {
            uint uTimeSpan = EcasUtil.GetParamUInt(a.Parameters, 0);

            if((uTimeSpan != 0) && (uTimeSpan <= (uint)int.MaxValue))
                Thread.Sleep((int)uTimeSpan);
        }

		private static void ActivateDatabaseTab(EcasAction a, EcasContext ctx)
		{
			string strName = EcasUtil.GetParamString(a.Parameters, 0, true);
			bool bEmptyName = string.IsNullOrEmpty(strName);

			uint uSel = EcasUtil.GetParamUInt(a.Parameters, 1, 0);
			PwDatabase pdSel = ctx.Properties.Get<PwDatabase>(EcasProperty.Database);

			DocumentManagerEx dm = Program.MainForm.DocumentManager;
			foreach(PwDocument doc in dm.Documents)
			{
				if(doc.Database == null) { Debug.Assert(false); continue; }

				if(uSel == 0) // Select from all
				{
					if(bEmptyName) continue; // Name required in this case
				}
				else if(uSel == 1) // Triggering only
				{
					if(!object.ReferenceEquals(doc.Database, pdSel)) continue;
				}
				else { Debug.Assert(false); continue; }

				IOConnectionInfo ioc = null;
				if((doc.LockedIoc != null) && !string.IsNullOrEmpty(doc.LockedIoc.Path))
					ioc = doc.LockedIoc;
				else if((doc.Database.IOConnectionInfo != null) &&
					!string.IsNullOrEmpty(doc.Database.IOConnectionInfo.Path))
					ioc = doc.Database.IOConnectionInfo;

				if(bEmptyName || ((ioc != null) && (ioc.Path.IndexOf(strName,
					StrUtil.CaseIgnoreCmp) >= 0)))
				{
					Program.MainForm.MakeDocumentActive(doc);
					break;
				}
			}
		}

        private static void ImportIntoCurrentDatabase(EcasAction a, EcasContext ctx)
        {
            PwDatabase pd = Program.MainForm.ActiveDatabase;
            if((pd == null) || !pd.IsOpen) return;

            string strPath = EcasUtil.GetParamString(a.Parameters, 0, true);
            if(string.IsNullOrEmpty(strPath)) return;
            IOConnectionInfo ioc = IOConnectionInfo.FromPath(strPath);

            string strFormat = EcasUtil.GetParamString(a.Parameters, 1, true);
            if(string.IsNullOrEmpty(strFormat)) return;
            FileFormatProvider ff = Program.FileFormatPool.Find(strFormat);
            if(ff == null)
                throw new Exception(KPRes.Unknown + ": " + strFormat);

            uint uMethod = EcasUtil.GetParamUInt(a.Parameters, 2);
            Type tMM = Enum.GetUnderlyingType(typeof(PwMergeMethod));
            object oMethod = Convert.ChangeType(uMethod, tMM);
            PwMergeMethod mm = PwMergeMethod.None;
            if(Enum.IsDefined(typeof(PwMergeMethod), oMethod))
                mm = (PwMergeMethod)oMethod;
            else { Debug.Assert(false); }
            if(mm == PwMergeMethod.None) mm = PwMergeMethod.CreateNewUuids;

            CompositeKey cmpKey = KeyFromParams(a, 3, 4, 5);
            if((cmpKey == null) && ff.RequiresKey)
            {
                KeyPromptForm kpf = new KeyPromptForm();
                kpf.InitEx(ioc, false, true);

                if(UIUtil.ShowDialogNotValue(kpf, DialogResult.OK)) return;

                cmpKey = kpf.CompositeKey;
                UIUtil.DestroyForm(kpf);
            }

            bool? b = true;
            try { b = ImportUtil.Import(pd, ff, ioc, mm, cmpKey); }
            finally
            {
                if(b.GetValueOrDefault(false))
                    Program.MainForm.UpdateUI(false, null, true, null, true, null, true);
            }
        }