Fix setting for multiple action keywords

1. completed rewrite the action keyword setting logic.
2. Fix setting for multiple action keywords in #352
3. Fix setting for Web Search plugin

Plugins/Wox.Plugin.WebSearch/Properties/Annotations.cs

@@ -0,0 +1,996 @@
+using System;
+
+#pragma warning disable 1591
+// ReSharper disable UnusedMember.Global
+// ReSharper disable MemberCanBePrivate.Global
+// ReSharper disable UnusedAutoPropertyAccessor.Global
+// ReSharper disable IntroduceOptionalParameters.Global
+// ReSharper disable MemberCanBeProtected.Global
+// ReSharper disable InconsistentNaming
+
+namespace Wox.Plugin.WebSearch.Annotations
+{
+  /// <summary>
+  /// Indicates that the value of the marked element could be <c>null</c> sometimes,
+  /// so the check for <c>null</c> is necessary before its usage.
+  /// </summary>
+  /// <example><code>
+  /// [CanBeNull] object Test() => null;
+  /// 
+  /// void UseTest() {
+  ///   var p = Test();
+  ///   var s = p.ToString(); // Warning: Possible 'System.NullReferenceException'
+  /// }
+  /// </code></example>
+  [AttributeUsage(
+    AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
+    AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event)]
+  public sealed class CanBeNullAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that the value of the marked element could never be <c>null</c>.
+  /// </summary>
+  /// <example><code>
+  /// [NotNull] object Foo() {
+  ///   return null; // Warning: Possible 'null' assignment
+  /// }
+  /// </code></example>
+  [AttributeUsage(
+    AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
+    AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event)]
+  public sealed class NotNullAttribute : Attribute { }
+
+  /// <summary>
+  /// Can be appplied to symbols of types derived from IEnumerable as well as to symbols of Task
+  /// and Lazy classes to indicate that the value of a collection item, of the Task.Result property
+  /// or of the Lazy.Value property can never be null.
+  /// </summary>
+  [AttributeUsage(
+    AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
+    AttributeTargets.Delegate | AttributeTargets.Field)]
+  public sealed class ItemNotNullAttribute : Attribute { }
+
+  /// <summary>
+  /// Can be appplied to symbols of types derived from IEnumerable as well as to symbols of Task
+  /// and Lazy classes to indicate that the value of a collection item, of the Task.Result property
+  /// or of the Lazy.Value property can be null.
+  /// </summary>
+  [AttributeUsage(
+    AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
+    AttributeTargets.Delegate | AttributeTargets.Field)]
+  public sealed class ItemCanBeNullAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that the marked method builds string by format pattern and (optional) arguments.
+  /// Parameter, which contains format string, should be given in constructor. The format string
+  /// should be in <see cref="string.Format(IFormatProvider,string,object[])"/>-like form.
+  /// </summary>
+  /// <example><code>
+  /// [StringFormatMethod("message")]
+  /// void ShowError(string message, params object[] args) { /* do something */ }
+  /// 
+  /// void Foo() {
+  ///   ShowError("Failed: {0}"); // Warning: Non-existing argument in format string
+  /// }
+  /// </code></example>
+  [AttributeUsage(
+    AttributeTargets.Constructor | AttributeTargets.Method |
+    AttributeTargets.Property | AttributeTargets.Delegate)]
+  public sealed class StringFormatMethodAttribute : Attribute
+  {
+    /// <param name="formatParameterName">
+    /// Specifies which parameter of an annotated method should be treated as format-string
+    /// </param>
+    public StringFormatMethodAttribute(string formatParameterName)
+    {
+      FormatParameterName = formatParameterName;
+    }
+
+    public string FormatParameterName { get; private set; }
+  }
+
+  /// <summary>
+  /// For a parameter that is expected to be one of the limited set of values.
+  /// Specify fields of which type should be used as values for this parameter.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field)]
+  public sealed class ValueProviderAttribute : Attribute
+  {
+    public ValueProviderAttribute(string name)
+    {
+      Name = name;
+    }
+
+    [NotNull] public string Name { get; private set; }
+  }
+
+  /// <summary>
+  /// Indicates that the function argument should be string literal and match one
+  /// of the parameters of the caller function. For example, ReSharper annotates
+  /// the parameter of <see cref="System.ArgumentNullException"/>.
+  /// </summary>
+  /// <example><code>
+  /// void Foo(string param) {
+  ///   if (param == null)
+  ///     throw new ArgumentNullException("par"); // Warning: Cannot resolve symbol
+  /// }
+  /// </code></example>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class InvokerParameterNameAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that the method is contained in a type that implements
+  /// <c>System.ComponentModel.INotifyPropertyChanged</c> interface and this method
+  /// is used to notify that some property value changed.
+  /// </summary>
+  /// <remarks>
+  /// The method should be non-static and conform to one of the supported signatures:
+  /// <list>
+  /// <item><c>NotifyChanged(string)</c></item>
+  /// <item><c>NotifyChanged(params string[])</c></item>
+  /// <item><c>NotifyChanged{T}(Expression{Func{T}})</c></item>
+  /// <item><c>NotifyChanged{T,U}(Expression{Func{T,U}})</c></item>
+  /// <item><c>SetProperty{T}(ref T, T, string)</c></item>
+  /// </list>
+  /// </remarks>
+  /// <example><code>
+  /// public class Foo : INotifyPropertyChanged {
+  ///   public event PropertyChangedEventHandler PropertyChanged;
+  /// 
+  ///   [NotifyPropertyChangedInvocator]
+  ///   protected virtual void NotifyChanged(string propertyName) { ... }
+  ///
+  ///   string _name;
+  /// 
+  ///   public string Name {
+  ///     get { return _name; }
+  ///     set { _name = value; NotifyChanged("LastName"); /* Warning */ }
+  ///   }
+  /// }
+  /// </code>
+  /// Examples of generated notifications:
+  /// <list>
+  /// <item><c>NotifyChanged("Property")</c></item>
+  /// <item><c>NotifyChanged(() =&gt; Property)</c></item>
+  /// <item><c>NotifyChanged((VM x) =&gt; x.Property)</c></item>
+  /// <item><c>SetProperty(ref myField, value, "Property")</c></item>
+  /// </list>
+  /// </example>
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class NotifyPropertyChangedInvocatorAttribute : Attribute
+  {
+    public NotifyPropertyChangedInvocatorAttribute() { }
+    public NotifyPropertyChangedInvocatorAttribute(string parameterName)
+    {
+      ParameterName = parameterName;
+    }
+
+    public string ParameterName { get; private set; }
+  }
+
+  /// <summary>
+  /// Describes dependency between method input and output.
+  /// </summary>
+  /// <syntax>
+  /// <p>Function Definition Table syntax:</p>
+  /// <list>
+  /// <item>FDT      ::= FDTRow [;FDTRow]*</item>
+  /// <item>FDTRow   ::= Input =&gt; Output | Output &lt;= Input</item>
+  /// <item>Input    ::= ParameterName: Value [, Input]*</item>
+  /// <item>Output   ::= [ParameterName: Value]* {halt|stop|void|nothing|Value}</item>
+  /// <item>Value    ::= true | false | null | notnull | canbenull</item>
+  /// </list>
+  /// If method has single input parameter, it's name could be omitted.<br/>
+  /// Using <c>halt</c> (or <c>void</c>/<c>nothing</c>, which is the same)
+  /// for method output means that the methos doesn't return normally.<br/>
+  /// <c>canbenull</c> annotation is only applicable for output parameters.<br/>
+  /// You can use multiple <c>[ContractAnnotation]</c> for each FDT row,
+  /// or use single attribute with rows separated by semicolon.<br/>
+  /// </syntax>
+  /// <examples><list>
+  /// <item><code>
+  /// [ContractAnnotation("=> halt")]
+  /// public void TerminationMethod()
+  /// </code></item>
+  /// <item><code>
+  /// [ContractAnnotation("halt &lt;= condition: false")]
+  /// public void Assert(bool condition, string text) // regular assertion method
+  /// </code></item>
+  /// <item><code>
+  /// [ContractAnnotation("s:null => true")]
+  /// public bool IsNullOrEmpty(string s) // string.IsNullOrEmpty()
+  /// </code></item>
+  /// <item><code>
+  /// // A method that returns null if the parameter is null,
+  /// // and not null if the parameter is not null
+  /// [ContractAnnotation("null => null; notnull => notnull")]
+  /// public object Transform(object data) 
+  /// </code></item>
+  /// <item><code>
+  /// [ContractAnnotation("s:null=>false; =>true,result:notnull; =>false, result:null")]
+  /// public bool TryParse(string s, out Person result)
+  /// </code></item>
+  /// </list></examples>
+  [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
+  public sealed class ContractAnnotationAttribute : Attribute
+  {
+    public ContractAnnotationAttribute([NotNull] string contract)
+      : this(contract, false) { }
+
+    public ContractAnnotationAttribute([NotNull] string contract, bool forceFullStates)
+    {
+      Contract = contract;
+      ForceFullStates = forceFullStates;
+    }
+
+    public string Contract { get; private set; }
+    public bool ForceFullStates { get; private set; }
+  }
+
+  /// <summary>
+  /// Indicates that marked element should be localized or not.
+  /// </summary>
+  /// <example><code>
+  /// [LocalizationRequiredAttribute(true)]
+  /// class Foo {
+  ///   string str = "my string"; // Warning: Localizable string
+  /// }
+  /// </code></example>
+  [AttributeUsage(AttributeTargets.All)]
+  public sealed class LocalizationRequiredAttribute : Attribute
+  {
+    public LocalizationRequiredAttribute() : this(true) { }
+    public LocalizationRequiredAttribute(bool required)
+    {
+      Required = required;
+    }
+
+    public bool Required { get; private set; }
+  }
+
+  /// <summary>
+  /// Indicates that the value of the marked type (or its derivatives)
+  /// cannot be compared using '==' or '!=' operators and <c>Equals()</c>
+  /// should be used instead. However, using '==' or '!=' for comparison
+  /// with <c>null</c> is always permitted.
+  /// </summary>
+  /// <example><code>
+  /// [CannotApplyEqualityOperator]
+  /// class NoEquality { }
+  /// 
+  /// class UsesNoEquality {
+  ///   void Test() {
+  ///     var ca1 = new NoEquality();
+  ///     var ca2 = new NoEquality();
+  ///     if (ca1 != null) { // OK
+  ///       bool condition = ca1 == ca2; // Warning
+  ///     }
+  ///   }
+  /// }
+  /// </code></example>
+  [AttributeUsage(AttributeTargets.Interface | AttributeTargets.Class | AttributeTargets.Struct)]
+  public sealed class CannotApplyEqualityOperatorAttribute : Attribute { }
+
+  /// <summary>
+  /// When applied to a target attribute, specifies a requirement for any type marked
+  /// with the target attribute to implement or inherit specific type or types.
+  /// </summary>
+  /// <example><code>
+  /// [BaseTypeRequired(typeof(IComponent)] // Specify requirement
+  /// class ComponentAttribute : Attribute { }
+  /// 
+  /// [Component] // ComponentAttribute requires implementing IComponent interface
+  /// class MyComponent : IComponent { }
+  /// </code></example>
+  [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+  [BaseTypeRequired(typeof(Attribute))]
+  public sealed class BaseTypeRequiredAttribute : Attribute
+  {
+    public BaseTypeRequiredAttribute([NotNull] Type baseType)
+    {
+      BaseType = baseType;
+    }
+
+    [NotNull] public Type BaseType { get; private set; }
+  }
+
+  /// <summary>
+  /// Indicates that the marked symbol is used implicitly (e.g. via reflection, in external library),
+  /// so this symbol will not be marked as unused (as well as by other usage inspections).
+  /// </summary>
+  [AttributeUsage(AttributeTargets.All)]
+  public sealed class UsedImplicitlyAttribute : Attribute
+  {
+    public UsedImplicitlyAttribute()
+      : this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default) { }
+
+    public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags)
+      : this(useKindFlags, ImplicitUseTargetFlags.Default) { }
+
+    public UsedImplicitlyAttribute(ImplicitUseTargetFlags targetFlags)
+      : this(ImplicitUseKindFlags.Default, targetFlags) { }
+
+    public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags)
+    {
+      UseKindFlags = useKindFlags;
+      TargetFlags = targetFlags;
+    }
+
+    public ImplicitUseKindFlags UseKindFlags { get; private set; }
+    public ImplicitUseTargetFlags TargetFlags { get; private set; }
+  }
+
+  /// <summary>
+  /// Should be used on attributes and causes ReSharper to not mark symbols marked with such attributes
+  /// as unused (as well as by other usage inspections)
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Class | AttributeTargets.GenericParameter)]
+  public sealed class MeansImplicitUseAttribute : Attribute
+  {
+    public MeansImplicitUseAttribute()
+      : this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default) { }
+
+    public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags)
+      : this(useKindFlags, ImplicitUseTargetFlags.Default) { }
+
+    public MeansImplicitUseAttribute(ImplicitUseTargetFlags targetFlags)
+      : this(ImplicitUseKindFlags.Default, targetFlags) { }
+
+    public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags)
+    {
+      UseKindFlags = useKindFlags;
+      TargetFlags = targetFlags;
+    }
+
+    [UsedImplicitly] public ImplicitUseKindFlags UseKindFlags { get; private set; }
+    [UsedImplicitly] public ImplicitUseTargetFlags TargetFlags { get; private set; }
+  }
+
+  [Flags]
+  public enum ImplicitUseKindFlags
+  {
+    Default = Access | Assign | InstantiatedWithFixedConstructorSignature,
+    /// <summary>Only entity marked with attribute considered used.</summary>
+    Access = 1,
+    /// <summary>Indicates implicit assignment to a member.</summary>
+    Assign = 2,
+    /// <summary>
+    /// Indicates implicit instantiation of a type with fixed constructor signature.
+    /// That means any unused constructor parameters won't be reported as such.
+    /// </summary>
+    InstantiatedWithFixedConstructorSignature = 4,
+    /// <summary>Indicates implicit instantiation of a type.</summary>
+    InstantiatedNoFixedConstructorSignature = 8,
+  }
+
+  /// <summary>
+  /// Specify what is considered used implicitly when marked
+  /// with <see cref="MeansImplicitUseAttribute"/> or <see cref="UsedImplicitlyAttribute"/>.
+  /// </summary>
+  [Flags]
+  public enum ImplicitUseTargetFlags
+  {
+    Default = Itself,
+    Itself = 1,
+    /// <summary>Members of entity marked with attribute are considered used.</summary>
+    Members = 2,
+    /// <summary>Entity marked with attribute and all its members considered used.</summary>
+    WithMembers = Itself | Members
+  }
+
+  /// <summary>
+  /// This attribute is intended to mark publicly available API
+  /// which should not be removed and so is treated as used.
+  /// </summary>
+  [MeansImplicitUse(ImplicitUseTargetFlags.WithMembers)]
+  public sealed class PublicAPIAttribute : Attribute
+  {
+    public PublicAPIAttribute() { }
+    public PublicAPIAttribute([NotNull] string comment)
+    {
+      Comment = comment;
+    }
+
+    public string Comment { get; private set; }
+  }
+
+  /// <summary>
+  /// Tells code analysis engine if the parameter is completely handled when the invoked method is on stack.
+  /// If the parameter is a delegate, indicates that delegate is executed while the method is executed.
+  /// If the parameter is an enumerable, indicates that it is enumerated while the method is executed.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class InstantHandleAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that a method does not make any observable state changes.
+  /// The same as <c>System.Diagnostics.Contracts.PureAttribute</c>.
+  /// </summary>
+  /// <example><code>
+  /// [Pure] int Multiply(int x, int y) => x * y;
+  /// 
+  /// void M() {
+  ///   Multiply(123, 42); // Waring: Return value of pure method is not used
+  /// }
+  /// </code></example>
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class PureAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that the return value of method invocation must be used.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class MustUseReturnValueAttribute : Attribute
+  {
+    public MustUseReturnValueAttribute() { }
+    public MustUseReturnValueAttribute([NotNull] string justification)
+    {
+      Justification = justification;
+    }
+
+    public string Justification { get; private set; }
+  }
+
+  /// <summary>
+  /// Indicates the type member or parameter of some type, that should be used instead of all other ways
+  /// to get the value that type. This annotation is useful when you have some "context" value evaluated
+  /// and stored somewhere, meaning that all other ways to get this value must be consolidated with existing one.
+  /// </summary>
+  /// <example><code>
+  /// class Foo {
+  ///   [ProvidesContext] IBarService _barService = ...;
+  /// 
+  ///   void ProcessNode(INode node) {
+  ///     DoSomething(node, node.GetGlobalServices().Bar);
+  ///     //              ^ Warning: use value of '_barService' field
+  ///   }
+  /// }
+  /// </code></example>
+  [AttributeUsage(
+    AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Parameter |
+    AttributeTargets.Method)]
+  public sealed class ProvidesContextAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that a parameter is a path to a file or a folder within a web project.
+  /// Path can be relative or absolute, starting from web root (~).
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class PathReferenceAttribute : Attribute
+  {
+    public PathReferenceAttribute() { }
+    public PathReferenceAttribute([PathReference] string basePath)
+    {
+      BasePath = basePath;
+    }
+
+    public string BasePath { get; private set; }
+  }
+
+  /// <summary>
+  /// An extension method marked with this attribute is processed by ReSharper code completion
+  /// as a 'Source Template'. When extension method is completed over some expression, it's source code
+  /// is automatically expanded like a template at call site.
+  /// </summary>
+  /// <remarks>
+  /// Template method body can contain valid source code and/or special comments starting with '$'.
+  /// Text inside these comments is added as source code when the template is applied. Template parameters
+  /// can be used either as additional method parameters or as identifiers wrapped in two '$' signs.
+  /// Use the <see cref="MacroAttribute"/> attribute to specify macros for parameters.
+  /// </remarks>
+  /// <example>
+  /// In this example, the 'forEach' method is a source template available over all values
+  /// of enumerable types, producing ordinary C# 'foreach' statement and placing caret inside block:
+  /// <code>
+  /// [SourceTemplate]
+  /// public static void forEach&lt;T&gt;(this IEnumerable&lt;T&gt; xs) {
+  ///   foreach (var x in xs) {
+  ///      //$ $END$
+  ///   }
+  /// }
+  /// </code>
+  /// </example>
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class SourceTemplateAttribute : Attribute { }
+
+  /// <summary>
+  /// Allows specifying a macro for a parameter of a <see cref="SourceTemplateAttribute">source template</see>.
+  /// </summary>
+  /// <remarks>
+  /// You can apply the attribute on the whole method or on any of its additional parameters. The macro expression
+  /// is defined in the <see cref="MacroAttribute.Expression"/> property. When applied on a method, the target
+  /// template parameter is defined in the <see cref="MacroAttribute.Target"/> property. To apply the macro silently
+  /// for the parameter, set the <see cref="MacroAttribute.Editable"/> property value = -1.
+  /// </remarks>
+  /// <example>
+  /// Applying the attribute on a source template method:
+  /// <code>
+  /// [SourceTemplate, Macro(Target = "item", Expression = "suggestVariableName()")]
+  /// public static void forEach&lt;T&gt;(this IEnumerable&lt;T&gt; collection) {
+  ///   foreach (var item in collection) {
+  ///     //$ $END$
+  ///   }
+  /// }
+  /// </code>
+  /// Applying the attribute on a template method parameter:
+  /// <code>
+  /// [SourceTemplate]
+  /// public static void something(this Entity x, [Macro(Expression = "guid()", Editable = -1)] string newguid) {
+  ///   /*$ var $x$Id = "$newguid$" + x.ToString();
+  ///   x.DoSomething($x$Id); */
+  /// }
+  /// </code>
+  /// </example>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method, AllowMultiple = true)]
+  public sealed class MacroAttribute : Attribute
+  {
+    /// <summary>
+    /// Allows specifying a macro that will be executed for a <see cref="SourceTemplateAttribute">source template</see>
+    /// parameter when the template is expanded.
+    /// </summary>
+    public string Expression { get; set; }
+
+    /// <summary>
+    /// Allows specifying which occurrence of the target parameter becomes editable when the template is deployed.
+    /// </summary>
+    /// <remarks>
+    /// If the target parameter is used several times in the template, only one occurrence becomes editable;
+    /// other occurrences are changed synchronously. To specify the zero-based index of the editable occurrence,
+    /// use values >= 0. To make the parameter non-editable when the template is expanded, use -1.
+    /// </remarks>>
+    public int Editable { get; set; }
+
+    /// <summary>
+    /// Identifies the target parameter of a <see cref="SourceTemplateAttribute">source template</see> if the
+    /// <see cref="MacroAttribute"/> is applied on a template method.
+    /// </summary>
+    public string Target { get; set; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+  public sealed class AspMvcAreaMasterLocationFormatAttribute : Attribute
+  {
+    public AspMvcAreaMasterLocationFormatAttribute(string format)
+    {
+      Format = format;
+    }
+
+    public string Format { get; private set; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+  public sealed class AspMvcAreaPartialViewLocationFormatAttribute : Attribute
+  {
+    public AspMvcAreaPartialViewLocationFormatAttribute(string format)
+    {
+      Format = format;
+    }
+
+    public string Format { get; private set; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+  public sealed class AspMvcAreaViewLocationFormatAttribute : Attribute
+  {
+    public AspMvcAreaViewLocationFormatAttribute(string format)
+    {
+      Format = format;
+    }
+
+    public string Format { get; private set; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+  public sealed class AspMvcMasterLocationFormatAttribute : Attribute
+  {
+    public AspMvcMasterLocationFormatAttribute(string format)
+    {
+      Format = format;
+    }
+
+    public string Format { get; private set; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+  public sealed class AspMvcPartialViewLocationFormatAttribute : Attribute
+  {
+    public AspMvcPartialViewLocationFormatAttribute(string format)
+    {
+      Format = format;
+    }
+
+    public string Format { get; private set; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+  public sealed class AspMvcViewLocationFormatAttribute : Attribute
+  {
+    public AspMvcViewLocationFormatAttribute(string format)
+    {
+      Format = format;
+    }
+
+    public string Format { get; private set; }
+  }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
+  /// is an MVC action. If applied to a method, the MVC action name is calculated
+  /// implicitly from the context. Use this attribute for custom wrappers similar to
+  /// <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String)</c>.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)]
+  public sealed class AspMvcActionAttribute : Attribute
+  {
+    public AspMvcActionAttribute() { }
+    public AspMvcActionAttribute(string anonymousProperty)
+    {
+      AnonymousProperty = anonymousProperty;
+    }
+
+    public string AnonymousProperty { get; private set; }
+  }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. Indicates that a parameter is an MVC area.
+  /// Use this attribute for custom wrappers similar to
+  /// <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String)</c>.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class AspMvcAreaAttribute : Attribute
+  {
+    public AspMvcAreaAttribute() { }
+    public AspMvcAreaAttribute(string anonymousProperty)
+    {
+      AnonymousProperty = anonymousProperty;
+    }
+
+    public string AnonymousProperty { get; private set; }
+  }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is
+  /// an MVC controller. If applied to a method, the MVC controller name is calculated
+  /// implicitly from the context. Use this attribute for custom wrappers similar to
+  /// <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String, String)</c>.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)]
+  public sealed class AspMvcControllerAttribute : Attribute
+  {
+    public AspMvcControllerAttribute() { }
+    public AspMvcControllerAttribute(string anonymousProperty)
+    {
+      AnonymousProperty = anonymousProperty;
+    }
+
+    public string AnonymousProperty { get; private set; }
+  }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. Indicates that a parameter is an MVC Master. Use this attribute
+  /// for custom wrappers similar to <c>System.Web.Mvc.Controller.View(String, String)</c>.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class AspMvcMasterAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. Indicates that a parameter is an MVC model type. Use this attribute
+  /// for custom wrappers similar to <c>System.Web.Mvc.Controller.View(String, Object)</c>.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class AspMvcModelTypeAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is an MVC
+  /// partial view. If applied to a method, the MVC partial view name is calculated implicitly
+  /// from the context. Use this attribute for custom wrappers similar to
+  /// <c>System.Web.Mvc.Html.RenderPartialExtensions.RenderPartial(HtmlHelper, String)</c>.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)]
+  public sealed class AspMvcPartialViewAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. Allows disabling inspections for MVC views within a class or a method.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
+  public sealed class AspMvcSuppressViewErrorAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. Indicates that a parameter is an MVC display template.
+  /// Use this attribute for custom wrappers similar to 
+  /// <c>System.Web.Mvc.Html.DisplayExtensions.DisplayForModel(HtmlHelper, String)</c>.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class AspMvcDisplayTemplateAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. Indicates that a parameter is an MVC editor template.
+  /// Use this attribute for custom wrappers similar to
+  /// <c>System.Web.Mvc.Html.EditorExtensions.EditorForModel(HtmlHelper, String)</c>.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class AspMvcEditorTemplateAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. Indicates that a parameter is an MVC template.
+  /// Use this attribute for custom wrappers similar to
+  /// <c>System.ComponentModel.DataAnnotations.UIHintAttribute(System.String)</c>.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class AspMvcTemplateAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
+  /// is an MVC view component. If applied to a method, the MVC view name is calculated implicitly
+  /// from the context. Use this attribute for custom wrappers similar to
+  /// <c>System.Web.Mvc.Controller.View(Object)</c>.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)]
+  public sealed class AspMvcViewAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
+  /// is an MVC view component name.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class AspMvcViewComponentAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
+  /// is an MVC view component view. If applied to a method, the MVC view component view name is default.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)]
+  public sealed class AspMvcViewComponentViewAttribute : Attribute { }
+
+  /// <summary>
+  /// ASP.NET MVC attribute. When applied to a parameter of an attribute,
+  /// indicates that this parameter is an MVC action name.
+  /// </summary>
+  /// <example><code>
+  /// [ActionName("Foo")]
+  /// public ActionResult Login(string returnUrl) {
+  ///   ViewBag.ReturnUrl = Url.Action("Foo"); // OK
+  ///   return RedirectToAction("Bar"); // Error: Cannot resolve action
+  /// }
+  /// </code></example>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property)]
+  public sealed class AspMvcActionSelectorAttribute : Attribute { }
+
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field)]
+  public sealed class HtmlElementAttributesAttribute : Attribute
+  {
+    public HtmlElementAttributesAttribute() { }
+    public HtmlElementAttributesAttribute(string name)
+    {
+      Name = name;
+    }
+
+    public string Name { get; private set; }
+  }
+
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
+  public sealed class HtmlAttributeValueAttribute : Attribute
+  {
+    public HtmlAttributeValueAttribute([NotNull] string name)
+    {
+      Name = name;
+    }
+
+    [NotNull] public string Name { get; private set; }
+  }
+
+  /// <summary>
+  /// Razor attribute. Indicates that a parameter or a method is a Razor section.
+  /// Use this attribute for custom wrappers similar to 
+  /// <c>System.Web.WebPages.WebPageBase.RenderSection(String)</c>.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)]
+  public sealed class RazorSectionAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates how method, constructor invocation or property access
+  /// over collection type affects content of the collection.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Property)]
+  public sealed class CollectionAccessAttribute : Attribute
+  {
+    public CollectionAccessAttribute(CollectionAccessType collectionAccessType)
+    {
+      CollectionAccessType = collectionAccessType;
+    }
+
+    public CollectionAccessType CollectionAccessType { get; private set; }
+  }
+
+  [Flags]
+  public enum CollectionAccessType
+  {
+    /// <summary>Method does not use or modify content of the collection.</summary>
+    None = 0,
+    /// <summary>Method only reads content of the collection but does not modify it.</summary>
+    Read = 1,
+    /// <summary>Method can change content of the collection but does not add new elements.</summary>
+    ModifyExistingContent = 2,
+    /// <summary>Method can add new elements to the collection.</summary>
+    UpdatedContent = ModifyExistingContent | 4
+  }
+
+  /// <summary>
+  /// Indicates that the marked method is assertion method, i.e. it halts control flow if
+  /// one of the conditions is satisfied. To set the condition, mark one of the parameters with 
+  /// <see cref="AssertionConditionAttribute"/> attribute.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class AssertionMethodAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates the condition parameter of the assertion method. The method itself should be
+  /// marked by <see cref="AssertionMethodAttribute"/> attribute. The mandatory argument of
+  /// the attribute is the assertion type.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class AssertionConditionAttribute : Attribute
+  {
+    public AssertionConditionAttribute(AssertionConditionType conditionType)
+    {
+      ConditionType = conditionType;
+    }
+
+    public AssertionConditionType ConditionType { get; private set; }
+  }
+
+  /// <summary>
+  /// Specifies assertion type. If the assertion method argument satisfies the condition,
+  /// then the execution continues. Otherwise, execution is assumed to be halted.
+  /// </summary>
+  public enum AssertionConditionType
+  {
+    /// <summary>Marked parameter should be evaluated to true.</summary>
+    IS_TRUE = 0,
+    /// <summary>Marked parameter should be evaluated to false.</summary>
+    IS_FALSE = 1,
+    /// <summary>Marked parameter should be evaluated to null value.</summary>
+    IS_NULL = 2,
+    /// <summary>Marked parameter should be evaluated to not null value.</summary>
+    IS_NOT_NULL = 3,
+  }
+
+  /// <summary>
+  /// Indicates that the marked method unconditionally terminates control flow execution.
+  /// For example, it could unconditionally throw exception.
+  /// </summary>
+  [Obsolete("Use [ContractAnnotation('=> halt')] instead")]
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class TerminatesProgramAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that method is pure LINQ method, with postponed enumeration (like Enumerable.Select,
+  /// .Where). This annotation allows inference of [InstantHandle] annotation for parameters
+  /// of delegate type by analyzing LINQ method chains.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class LinqTunnelAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that IEnumerable, passed as parameter, is not enumerated.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class NoEnumerationAttribute : Attribute { }
+
+  /// <summary>
+  /// Indicates that parameter is regular expression pattern.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class RegexPatternAttribute : Attribute { }
+
+  /// <summary>
+  /// XAML attribute. Indicates the type that has <c>ItemsSource</c> property and should be treated
+  /// as <c>ItemsControl</c>-derived type, to enable inner items <c>DataContext</c> type resolve.
+  /// </summary>
+  [AttributeUsage(AttributeTargets.Class)]
+  public sealed class XamlItemsControlAttribute : Attribute { }
+
+  /// <summary>
+  /// XAML attribute. Indicates the property of some <c>BindingBase</c>-derived type, that
+  /// is used to bind some item of <c>ItemsControl</c>-derived type. This annotation will
+  /// enable the <c>DataContext</c> type resolve for XAML bindings for such properties.
+  /// </summary>
+  /// <remarks>
+  /// Property should have the tree ancestor of the <c>ItemsControl</c> type or
+  /// marked with the <see cref="XamlItemsControlAttribute"/> attribute.
+  /// </remarks>
+  [AttributeUsage(AttributeTargets.Property)]
+  public sealed class XamlItemBindingOfItemsControlAttribute : Attribute { }
+
+  [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+  public sealed class AspChildControlTypeAttribute : Attribute
+  {
+    public AspChildControlTypeAttribute(string tagName, Type controlType)
+    {
+      TagName = tagName;
+      ControlType = controlType;
+    }
+
+    public string TagName { get; private set; }
+    public Type ControlType { get; private set; }
+  }
+
+  [AttributeUsage(AttributeTargets.Property | AttributeTargets.Method)]
+  public sealed class AspDataFieldAttribute : Attribute { }
+
+  [AttributeUsage(AttributeTargets.Property | AttributeTargets.Method)]
+  public sealed class AspDataFieldsAttribute : Attribute { }
+
+  [AttributeUsage(AttributeTargets.Property)]
+  public sealed class AspMethodPropertyAttribute : Attribute { }
+
+  [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+  public sealed class AspRequiredAttributeAttribute : Attribute
+  {
+    public AspRequiredAttributeAttribute([NotNull] string attribute)
+    {
+      Attribute = attribute;
+    }
+
+    public string Attribute { get; private set; }
+  }
+
+  [AttributeUsage(AttributeTargets.Property)]
+  public sealed class AspTypePropertyAttribute : Attribute
+  {
+    public bool CreateConstructorReferences { get; private set; }
+
+    public AspTypePropertyAttribute(bool createConstructorReferences)
+    {
+      CreateConstructorReferences = createConstructorReferences;
+    }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+  public sealed class RazorImportNamespaceAttribute : Attribute
+  {
+    public RazorImportNamespaceAttribute(string name)
+    {
+      Name = name;
+    }
+
+    public string Name { get; private set; }
+  }
+
+  [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+  public sealed class RazorInjectionAttribute : Attribute
+  {
+    public RazorInjectionAttribute(string type, string fieldName)
+    {
+      Type = type;
+      FieldName = fieldName;
+    }
+
+    public string Type { get; private set; }
+    public string FieldName { get; private set; }
+  }
+
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class RazorHelperCommonAttribute : Attribute { }
+
+  [AttributeUsage(AttributeTargets.Property)]
+  public sealed class RazorLayoutAttribute : Attribute { }
+
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class RazorWriteLiteralMethodAttribute : Attribute { }
+
+  [AttributeUsage(AttributeTargets.Method)]
+  public sealed class RazorWriteMethodAttribute : Attribute { }
+
+  [AttributeUsage(AttributeTargets.Parameter)]
+  public sealed class RazorWriteMethodParameterAttribute : Attribute { }
+
+  /// <summary>
+  /// Prevents the Member Reordering feature from tossing members of the marked class.
+  /// </summary>
+  /// <remarks>
+  /// The attribute must be mentioned in your member reordering patterns
+  /// </remarks>
+  [AttributeUsage(AttributeTargets.All)]
+  public sealed class NoReorder : Attribute { }
+}

Plugins/Wox.Plugin.WebSearch/WebSearchPlugin.cs

@@ -1,17 +1,19 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Windows.Controls;
+using Wox.Plugin.WebSearch.Annotations;
 using Wox.Plugin.WebSearch.SuggestionSources;
 
 namespace Wox.Plugin.WebSearch
 {
-    public class WebSearchPlugin : IPlugin, ISettingProvider, IPluginI18n, IInstantQuery
+    public class WebSearchPlugin : IPlugin, ISettingProvider, IPluginI18n, IInstantQuery, IMultipleActionKeywords
     {
-        private PluginInitContext _context;
+        public PluginInitContext Context { get; private set; }
 
         public List<Result> Query(Query query)
         {
@@ -23,7 +25,7 @@ namespace Wox.Plugin.WebSearch
             {
                 string keyword = query.Search;
                 string title = keyword;
-                string subtitle = _context.API.GetTranslation("wox_plugin_websearch_search") + " " + webSearch.Title;
+                string subtitle = Context.API.GetTranslation("wox_plugin_websearch_search") + " " + webSearch.Title;
                 if (string.IsNullOrEmpty(keyword))
                 {
                     title = subtitle;
@@ -54,7 +56,7 @@ namespace Wox.Plugin.WebSearch
 
         private IEnumerable<Result> ResultsFromSuggestions(string keyword, string subtitle, WebSearch webSearch)
         {
-            ISuggestionSource sugg = SuggestionSourceFactory.GetSuggestionSource(WebSearchStorage.Instance.WebSearchSuggestionSource, _context);
+            ISuggestionSource sugg = SuggestionSourceFactory.GetSuggestionSource(WebSearchStorage.Instance.WebSearchSuggestionSource, Context);
             var suggestions = sugg?.GetSuggestions(keyword);
             if (suggestions != null)
             {
@@ -77,7 +79,7 @@ namespace Wox.Plugin.WebSearch
 
         public void Init(PluginInitContext context)
         {
-            _context = context;
+            this.Context = context;
 
             if (WebSearchStorage.Instance.WebSearches == null)
                 WebSearchStorage.Instance.WebSearches = WebSearchStorage.Instance.LoadDefaultWebSearches();
@@ -87,7 +89,7 @@ namespace Wox.Plugin.WebSearch
 
         public Control CreateSettingPanel()
         {
-            return new WebSearchesSetting(_context);
+            return new WebSearchesSetting(this);
         }
 
         #endregion
@@ -99,15 +101,35 @@ namespace Wox.Plugin.WebSearch
 
         public string GetTranslatedPluginTitle()
         {
-            return _context.API.GetTranslation("wox_plugin_websearch_plugin_name");
+            return Context.API.GetTranslation("wox_plugin_websearch_plugin_name");
         }
 
         public string GetTranslatedPluginDescription()
         {
-            return _context.API.GetTranslation("wox_plugin_websearch_plugin_description");
+            return Context.API.GetTranslation("wox_plugin_websearch_plugin_description");
         }
 
         public bool IsInstantQuery(string query) => false;
 
+        [NotifyPropertyChangedInvocator]
+        public void NotifyActionKeywordsUpdated(string oldActionKeywords, string newActionKeywords)
+        {
+            ActionKeywordsChanged?.Invoke(this, new ActionKeywordsChangedEventArgs
+            {
+                OldActionKeyword = oldActionKeywords,
+                NewActionKeyword = newActionKeywords
+            });
+        }
+
+        [NotifyPropertyChangedInvocator]
+        public void NotifyActionKeywordsAdded(string newActionKeywords)
+        {
+            ActionKeywordsChanged?.Invoke(this, new ActionKeywordsChangedEventArgs
+            {
+                NewActionKeyword = newActionKeywords
+            });
+        }
+
+        public event ActionKeywordsChangedEventHandler ActionKeywordsChanged;
     }
 }

Plugins/Wox.Plugin.WebSearch/WebSearchSetting.xaml

@@ -37,7 +37,7 @@
         </StackPanel>
         <StackPanel Orientation="Horizontal" HorizontalAlignment="Right" Grid.Row="5" Grid.Column="1">
             <Button x:Name="btnCancel" Click="BtnCancel_OnClick" Margin="10 0 10 0" Width="80" Height="25" Content="{DynamicResource wox_plugin_websearch_cancel}"></Button>
-            <Button x:Name="btnAdd" Margin="10 0 10 0"  Width="80" Height="25" Click="btnAdd_OnClick">
+            <Button x:Name="btnConfirm" Margin="10 0 10 0"  Width="80" Height="25" Click="btnConfirm_OnClick">
                 <TextBlock x:Name="lblAdd" Text="{DynamicResource wox_plugin_websearch_add}"></TextBlock></Button>
         </StackPanel>
     </Grid>

Plugins/Wox.Plugin.WebSearch/WebSearchSetting.xaml.cs

@@ -5,37 +5,40 @@ using System.Reflection;
 using System.Windows;
 using System.Windows.Media.Imaging;
 using Microsoft.Win32;
+using Wox.Infrastructure.Exception;
 
 namespace Wox.Plugin.WebSearch
 {
     public partial class WebSearchSetting : Window
     {
-        private string defaultWebSearchImageDirectory = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Images\\websearch");
+        private string _defaultWebSearchImageDirectory = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Images\\websearch");
-        private WebSearchesSetting settingWindow;
+        private readonly WebSearchesSetting _settingWindow;
-        private bool update;
+        private bool _isUpdate;
-        private WebSearch updateWebSearch;
+        private WebSearch _updateWebSearch;
-        private PluginInitContext context;
+        private readonly PluginInitContext _context;
+        private readonly WebSearchPlugin _plguin;
 
-        public WebSearchSetting(WebSearchesSetting settingWidow,PluginInitContext context)
+        public WebSearchSetting(WebSearchesSetting settingWidow)
         {
-            this.context = context;
+            _plguin = settingWidow.Plugin;
-            this.settingWindow = settingWidow;
+            _context = settingWidow.Context;
+            _settingWindow = settingWidow;
             InitializeComponent();
         }
 
         public void UpdateItem(WebSearch webSearch)
         {
-            updateWebSearch = WebSearchStorage.Instance.WebSearches.FirstOrDefault(o => o == webSearch);
+            _updateWebSearch = WebSearchStorage.Instance.WebSearches.FirstOrDefault(o => o == webSearch);
-            if (updateWebSearch == null || string.IsNullOrEmpty(updateWebSearch.Url))
+            if (_updateWebSearch == null || string.IsNullOrEmpty(_updateWebSearch.Url))
             {
 
-                string warning = context.API.GetTranslation("wox_plugin_websearch_invalid_web_search");
+                string warning = _context.API.GetTranslation("wox_plugin_websearch_invalid_web_search");
                 MessageBox.Show(warning);
                 Close();
                 return;
             }
 
-            update = true;
+            _isUpdate = true;
             lblAdd.Text = "Update";
             tbIconPath.Text = webSearch.IconPath;
             ShowIcon(webSearch.IconPath);
@@ -49,7 +52,7 @@ namespace Wox.Plugin.WebSearch
         {
             try
             {
-                imgIcon.Source = new BitmapImage(new Uri(path));
+                imgIcon.Source = new BitmapImage(new Uri(path, UriKind.Relative));
             }
             catch (Exception)
             {
@@ -61,12 +64,15 @@ namespace Wox.Plugin.WebSearch
             Close();
         }
 
-        private void btnAdd_OnClick(object sender, RoutedEventArgs e)
+        /// <summary>
+        /// Confirm button for both add and update
+        /// </summary>
+        private void btnConfirm_OnClick(object sender, RoutedEventArgs e)
         {
             string title = tbTitle.Text;
             if (string.IsNullOrEmpty(title))
             {
-                string warning = context.API.GetTranslation("wox_plugin_websearch_input_title");
+                string warning = _context.API.GetTranslation("wox_plugin_websearch_input_title");
                 MessageBox.Show(warning);
                 return;
             }
@@ -74,81 +80,75 @@ namespace Wox.Plugin.WebSearch
             string url = tbUrl.Text;
             if (string.IsNullOrEmpty(url))
             {
-                string warning = context.API.GetTranslation("wox_plugin_websearch_input_url");
+                string warning = _context.API.GetTranslation("wox_plugin_websearch_input_url");
                 MessageBox.Show(warning);
                 return;
             }
 
-            string action = tbActionword.Text;
+            string newActionKeyword = tbActionword.Text.Trim();
-            if (string.IsNullOrEmpty(action))
+            if (string.IsNullOrEmpty(newActionKeyword))
             {
-                string warning = context.API.GetTranslation("wox_plugin_websearch_input_action_keyword");
+                string warning = _context.API.GetTranslation("wox_plugin_websearch_input_action_keyword");
                 MessageBox.Show(warning);
                 return;
             }
 
-
+            if (_isUpdate)
-            if (!update)
             {
-                if (WebSearchStorage.Instance.WebSearches.Exists(o => o.ActionKeyword == action))
+                try
                 {
-                    string warning = context.API.GetTranslation("wox_plugin_websearch_action_keyword_exist");
+                    _plguin.NotifyActionKeywordsUpdated(_updateWebSearch.ActionKeyword, newActionKeyword);
-                    MessageBox.Show(warning);
+                }
+                catch (WoxPluginException exception)
+                {
+                    MessageBox.Show(exception.Message);
+                    return;
+                }
+
+                _updateWebSearch.ActionKeyword = newActionKeyword;
+                _updateWebSearch.IconPath = tbIconPath.Text;
+                _updateWebSearch.Enabled = cbEnable.IsChecked ?? false;
+                _updateWebSearch.Url = url;
+                _updateWebSearch.Title = title;
+            }
+            else
+            {
+                try
+                {
+                    _plguin.NotifyActionKeywordsAdded(newActionKeyword);
+                }
+                catch (WoxPluginException exception)
+                {
+                    MessageBox.Show(exception.Message);
                     return;
                 }
                 WebSearchStorage.Instance.WebSearches.Add(new WebSearch()
                 {
-                    ActionKeyword = action,
+                    ActionKeyword = newActionKeyword,
                     Enabled = cbEnable.IsChecked ?? false,
                     IconPath = tbIconPath.Text,
                     Url = url,
                     Title = title
                 });
-                
-                //save the action keywords, the order is not metters. Wox will read this metadata when save settings.
-                context.CurrentPluginMetadata.ActionKeywords.Add(action);
-
-                string msg = context.API.GetTranslation("wox_plugin_websearch_succeed");
-                MessageBox.Show(msg);
             }
-            else
-            {
-                if (WebSearchStorage.Instance.WebSearches.Exists(o => o.ActionKeyword == action && o != updateWebSearch))
-                {
-                    string warning = context.API.GetTranslation("wox_plugin_websearch_action_keyword_exist");
-                    MessageBox.Show(warning);
-                    return;
-                }
-                updateWebSearch.ActionKeyword = action;
-                updateWebSearch.IconPath = tbIconPath.Text;
-                updateWebSearch.Enabled = cbEnable.IsChecked ?? false;
-                updateWebSearch.Url = url;
-                updateWebSearch.Title= title;
-                
-                //save the action keywords, the order is not metters. Wox will read this metadata when save settings.
-                context.CurrentPluginMetadata.ActionKeywords.Add(action);
 
-                string msg = context.API.GetTranslation("wox_plugin_websearch_succeed");
-                MessageBox.Show(msg);
-            }
             WebSearchStorage.Instance.Save();
-
+            _settingWindow.ReloadWebSearchView();
-            settingWindow.ReloadWebSearchView();
             Close();
         }
 
         private void BtnSelectIcon_OnClick(object sender, RoutedEventArgs e)
         {
-            if(!Directory.Exists(defaultWebSearchImageDirectory))
+            if (!Directory.Exists(_defaultWebSearchImageDirectory))
             {
-                defaultWebSearchImageDirectory =
+                _defaultWebSearchImageDirectory =
                     Path.GetDirectoryName(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
             }
 
             var dlg = new OpenFileDialog
             {
-                InitialDirectory = defaultWebSearchImageDirectory,
+                InitialDirectory = _defaultWebSearchImageDirectory,
-                Filter ="Image files (*.jpg, *.jpeg, *.gif, *.png, *.bmp) |*.jpg; *.jpeg; *.gif; *.png; *.bmp"
+                Filter = "Image files (*.jpg, *.jpeg, *.gif, *.png, *.bmp) |*.jpg; *.jpeg; *.gif; *.png; *.bmp"
             };
 
             bool? result = dlg.ShowDialog();

Plugins/Wox.Plugin.WebSearch/WebSearchesSetting.xaml.cs

@@ -10,14 +10,14 @@ namespace Wox.Plugin.WebSearch
     /// </summary>
     public partial class WebSearchesSetting : UserControl
     {
-        PluginInitContext context;
+        public PluginInitContext Context { get; }
+        public WebSearchPlugin Plugin { get; }
 
-        public WebSearchesSetting(PluginInitContext context)
+        public WebSearchesSetting(WebSearchPlugin plugin)
         {
-            this.context = context;
+            Context = plugin.Context;
-
+            Plugin = plugin;
             InitializeComponent();
-
             Loaded += Setting_Loaded;
         }
 
@@ -28,7 +28,7 @@ namespace Wox.Plugin.WebSearch
             comboBoxSuggestionSource.Visibility = WebSearchStorage.Instance.EnableWebSearchSuggestion
                 ? Visibility.Visible
                 : Visibility.Collapsed;
-                
+
             List<ComboBoxItem> items = new List<ComboBoxItem>()
             {
                 new ComboBoxItem() {Content = "Google"},
@@ -51,7 +51,7 @@ namespace Wox.Plugin.WebSearch
 
         private void btnAddWebSearch_OnClick(object sender, RoutedEventArgs e)
         {
-            WebSearchSetting webSearch = new WebSearchSetting(this,context);
+            WebSearchSetting webSearch = new WebSearchSetting(this);
             webSearch.ShowDialog();
         }
 
@@ -60,9 +60,9 @@ namespace Wox.Plugin.WebSearch
             WebSearch selectedWebSearch = webSearchView.SelectedItem as WebSearch;
             if (selectedWebSearch != null)
             {
-                string msg = string.Format(context.API.GetTranslation("wox_plugin_websearch_delete_warning"),selectedWebSearch.Title);
+                string msg = string.Format(Context.API.GetTranslation("wox_plugin_websearch_delete_warning"), selectedWebSearch.Title);
-                    
+
-                if (MessageBox.Show(msg,string.Empty, MessageBoxButton.YesNo) == MessageBoxResult.Yes)
+                if (MessageBox.Show(msg, string.Empty, MessageBoxButton.YesNo) == MessageBoxResult.Yes)
                 {
                     WebSearchStorage.Instance.WebSearches.Remove(selectedWebSearch);
                     webSearchView.Items.Refresh();
@@ -70,7 +70,7 @@ namespace Wox.Plugin.WebSearch
             }
             else
             {
-                string warning =context.API.GetTranslation("wox_plugin_websearch_pls_select_web_search");
+                string warning = Context.API.GetTranslation("wox_plugin_websearch_pls_select_web_search");
                 MessageBox.Show(warning);
             }
         }
@@ -80,13 +80,13 @@ namespace Wox.Plugin.WebSearch
             WebSearch selectedWebSearch = webSearchView.SelectedItem as WebSearch;
             if (selectedWebSearch != null)
             {
-                WebSearchSetting webSearch = new WebSearchSetting(this,context);
+                WebSearchSetting webSearch = new WebSearchSetting(this);
                 webSearch.UpdateItem(selectedWebSearch);
                 webSearch.ShowDialog();
             }
             else
             {
-                string warning = context.API.GetTranslation("wox_plugin_websearch_pls_select_web_search");
+                string warning = Context.API.GetTranslation("wox_plugin_websearch_pls_select_web_search");
                 MessageBox.Show(warning);
             }
         }
@@ -109,7 +109,7 @@ namespace Wox.Plugin.WebSearch
         {
             if (e.AddedItems.Count > 0)
             {
-                WebSearchStorage.Instance.WebSearchSuggestionSource = ((ComboBoxItem) e.AddedItems[0]).Content.ToString();
+                WebSearchStorage.Instance.WebSearchSuggestionSource = ((ComboBoxItem)e.AddedItems[0]).Content.ToString();
                 WebSearchStorage.Instance.Save();
             }
         }

Plugins/Wox.Plugin.WebSearch/Wox.Plugin.WebSearch.csproj

@@ -49,6 +49,7 @@
     <Reference Include="WindowsBase" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Properties\Annotations.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="SuggestionSources\Baidu.cs" />
     <Compile Include="SuggestionSources\Google.cs" />

Wox.Core/Plugin/PluginManager.cs

@@ -7,10 +7,10 @@ using System.Threading;
 using Wox.Core.i18n;
 using Wox.Core.UI;
 using Wox.Core.UserSettings;
+using Wox.Infrastructure;
 using Wox.Infrastructure.Exception;
 using Wox.Infrastructure.Logger;
 using Wox.Plugin;
-using Stopwatch = Wox.Infrastructure.Stopwatch;
 
 namespace Wox.Core.Plugin
 {
@@ -56,7 +56,7 @@ namespace Wox.Core.Plugin
                     {
                         Directory.CreateDirectory(pluginDirectory);
                     }
-                    catch (System.Exception e)
+                    catch (Exception e)
                     {
                         Log.Error(e);
                     }
@@ -196,7 +196,7 @@ namespace Wox.Core.Plugin
                 pair.AvgQueryTime = pair.QueryCount == 1 ? milliseconds : (pair.AvgQueryTime + milliseconds) / 2;
                 API.PushResults(query, pair.Metadata, results);
             }
-            catch (System.Exception e)
+            catch (Exception e)
             {
                 throw new WoxPluginException(pair.Metadata.Name, $"QueryForPlugin failed", e);
             }
@@ -240,7 +240,7 @@ namespace Wox.Core.Plugin
                 {
                     return plugin.LoadContextMenus(result);
                 }
-                catch (System.Exception e)
+                catch (Exception e)
                 {
                     Log.Error(new WoxPluginException(pluginPair.Metadata.Name, $"Couldn't load plugin context menus", e));
                 }
@@ -248,5 +248,58 @@ namespace Wox.Core.Plugin
 
             return new List<Result>();
         }
+
+        public static void UpdateActionKeywordForPlugin(PluginPair plugin, string oldActionKeyword, string newActionKeyword)
+        {
+            var actionKeywords = plugin.Metadata.ActionKeywords;
+            if (string.IsNullOrEmpty(newActionKeyword))
+            {
+                string msg = InternationalizationManager.Instance.GetTranslation("newActionKeywordsCannotBeEmpty");
+                throw new WoxPluginException(plugin.Metadata.Name, msg);
+            }
+            if (NonGlobalPlugins.ContainsKey(newActionKeyword))
+            {
+                string msg = InternationalizationManager.Instance.GetTranslation("newActionKeywordsHasBeenAssigned");
+                throw new WoxPluginException(plugin.Metadata.Name, msg);
+            }
+
+            // add new action keyword
+            if (string.IsNullOrEmpty(oldActionKeyword))
+            {
+                actionKeywords.Add(newActionKeyword);
+                if (newActionKeyword == Query.GlobalPluginWildcardSign)
+                {
+                    GlobalPlugins.Add(plugin);
+                }
+                else
+                {
+                    NonGlobalPlugins[newActionKeyword] = plugin;
+                }
+            }
+            // update existing action keyword
+            else
+            {
+                int index = actionKeywords.IndexOf(oldActionKeyword);
+                actionKeywords[index] = newActionKeyword;
+                if (oldActionKeyword == Query.GlobalPluginWildcardSign)
+                {
+                    GlobalPlugins.Remove(plugin);
+                }
+                else
+                {
+                    NonGlobalPlugins.Remove(oldActionKeyword);
+                }
+                if (newActionKeyword == Query.GlobalPluginWildcardSign)
+                {
+                    GlobalPlugins.Add(plugin);
+                }
+                else
+                {
+                    NonGlobalPlugins[newActionKeyword] = plugin;
+                }
+            }
+
+        }
+
     }
 }

Wox.Core/UserSettings/UserSettingStorage.cs

@@ -2,9 +2,11 @@
 using System.Collections.Generic;
 using System.Drawing;
 using System.IO;
+using System.Linq;
 using System.Reflection;
 using Newtonsoft.Json;
 using Wox.Infrastructure.Storage;
+using Wox.Plugin;
 
 namespace Wox.Core.UserSettings
 {
@@ -118,7 +120,7 @@ namespace Wox.Core.UserSettings
         public void IncreaseActivateTimes()
         {
             ActivateTimes++;
-            if (ActivateTimes%15 == 0)
+            if (ActivateTimes % 15 == 0)
             {
                 Save();
             }
@@ -162,6 +164,26 @@ namespace Wox.Core.UserSettings
                 storage.Language = "en";
             }
         }
+
+        public void UpdateActionKeyword(PluginMetadata metadata)
+        {
+            var customizedPluginConfig = CustomizedPluginConfigs.FirstOrDefault(o => o.ID == metadata.ID);
+            if (customizedPluginConfig == null)
+            {
+                CustomizedPluginConfigs.Add(new CustomizedPluginConfig()
+                {
+                    Disabled = false,
+                    ID = metadata.ID,
+                    Name = metadata.Name,
+                    ActionKeywords = metadata.ActionKeywords
+                });
+            }
+            else
+            {
+                customizedPluginConfig.ActionKeywords = metadata.ActionKeywords;
+            }
+            Save();
+        }
     }
 
     public enum OpacityMode

Wox.Infrastructure/Exception/WoxPluginException.cs

@@ -1,11 +1,18 @@
-namespace Wox.Infrastructure.Exception
+using Wox.Plugin;
+
+namespace Wox.Infrastructure.Exception
 {
     public class WoxPluginException : WoxException
     {
         public string PluginName { get; set; }
 
         public WoxPluginException(string pluginName, string msg, System.Exception e)
-            : base($"{msg}: {pluginName}", e)
+            : base($"{pluginName} : {msg}", e)
+        {
+            PluginName = pluginName;
+        }
+
+        public WoxPluginException(string pluginName, string msg) : base(msg)
         {
             PluginName = pluginName;
         }

Wox.Plugin/Feature.cs

@@ -38,4 +38,17 @@ namespace Wox.Plugin
 
         string GetTranslatedPluginDescription();
     }
+
+    public interface IMultipleActionKeywords
+    {
+        event ActionKeywordsChangedEventHandler ActionKeywordsChanged;
+    }
+
+    public class ActionKeywordsChangedEventArgs : EventArgs
+    {
+        public string OldActionKeyword { get; set; }
+        public string NewActionKeyword { get; set; }
+    }
+
+    public delegate void ActionKeywordsChangedEventHandler(IMultipleActionKeywords sender, ActionKeywordsChangedEventArgs e);
 }

Wox.Plugin/PluginPair.cs

@@ -15,5 +15,24 @@
         {
             return Metadata.Name;
         }
+
+        public override bool Equals(object obj)
+        {
+            PluginPair r = obj as PluginPair;
+            if (r != null)
+            {
+                return string.Equals(r.Metadata.ID, Metadata.ID);
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        public override int GetHashCode()
+        {
+            var hashcode = Metadata.ID?.GetHashCode() ?? 0;
+            return hashcode;
+        }
     }
 }

Wox.Plugin/Result.cs

@@ -57,7 +57,8 @@ namespace Wox.Plugin
 
         public override int GetHashCode()
         {
-            return (Title?.GetHashCode() ?? 0) ^ (SubTitle?.GetHashCode() ?? 0);
+            var hashcode = (Title?.GetHashCode() ?? 0) ^ (SubTitle?.GetHashCode() ?? 0);
+            return hashcode;
         }
 
         public override string ToString()

Wox/ActionKeywords.xaml.cs

@@ -1,34 +1,34 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Windows;
 using Wox.Core.i18n;
 using Wox.Core.Plugin;
 using Wox.Core.UserSettings;
+using Wox.Infrastructure.Exception;
 using Wox.Plugin;
 
 namespace Wox
 {
     public partial class ActionKeywords : Window
     {
-        private PluginMetadata pluginMetadata;
+        private PluginPair _plugin;
 
         public ActionKeywords(string pluginId)
         {
             InitializeComponent();
-            PluginPair plugin = PluginManager.GetPluginForId(pluginId);
+            _plugin = PluginManager.GetPluginForId(pluginId);
-            if (plugin == null)
+            if (_plugin == null)
             {
                 MessageBox.Show(InternationalizationManager.Instance.GetTranslation("cannotFindSpecifiedPlugin"));
                 Close();
                 return;
             }
-
-            pluginMetadata = plugin.Metadata;
         }
 
         private void ActionKeyword_OnLoaded(object sender, RoutedEventArgs e)
         {
-            tbOldActionKeyword.Text = string.Join(Query.ActionKeywordSeperater, pluginMetadata.ActionKeywords.ToArray());
+            tbOldActionKeyword.Text = string.Join(Query.ActionKeywordSeperater, _plugin.Metadata.ActionKeywords.ToArray());
             tbAction.Focus();
         }
 
@@ -37,42 +37,23 @@ namespace Wox
             Close();
         }
 
-        private void btnDone_OnClick(object sender, RoutedEventArgs e)
+        private void btnDone_OnClick(object sender, RoutedEventArgs _)
         {
-            if (string.IsNullOrEmpty(tbAction.Text))
+            var oldActionKeyword = _plugin.Metadata.ActionKeywords[0];
+            var newActionKeyword = tbAction.Text.Trim();
+            try
             {
-                MessageBox.Show(InternationalizationManager.Instance.GetTranslation("newActionKeywordCannotBeEmpty"));
+                // update in-memory data
+                PluginManager.UpdateActionKeywordForPlugin(_plugin, oldActionKeyword, newActionKeyword);
+            }
+            catch (WoxPluginException e)
+            {
+                MessageBox.Show(e.Message);
                 return;
             }
+            // update persistant data
+            UserSettingStorage.Instance.UpdateActionKeyword(_plugin.Metadata);
 
-            var actionKeywords = tbAction.Text.Trim().Split(new[] { Query.ActionKeywordSeperater }, StringSplitOptions.RemoveEmptyEntries).ToList();
-            //check new action keyword didn't used by other plugin
-            if (actionKeywords[0] != Query.GlobalPluginWildcardSign && PluginManager.AllPlugins.
-                                        SelectMany(p => p.Metadata.ActionKeywords).
-                                        Any(k => actionKeywords.Contains(k)))
-            {
-                MessageBox.Show(InternationalizationManager.Instance.GetTranslation("newActionKeywordHasBeenAssigned"));
-                return;
-            }
-
-
-            pluginMetadata.ActionKeywords = actionKeywords;
-            var customizedPluginConfig = UserSettingStorage.Instance.CustomizedPluginConfigs.FirstOrDefault(o => o.ID == pluginMetadata.ID);
-            if (customizedPluginConfig == null)
-            {
-                UserSettingStorage.Instance.CustomizedPluginConfigs.Add(new CustomizedPluginConfig()
-                {
-                    Disabled = false,
-                    ID = pluginMetadata.ID,
-                    Name = pluginMetadata.Name,
-                    ActionKeywords = actionKeywords
-                });
-            }
-            else
-            {
-                customizedPluginConfig.ActionKeywords = actionKeywords;
-            }
-            UserSettingStorage.Instance.Save();
             MessageBox.Show(InternationalizationManager.Instance.GetTranslation("succeed"));
             Close();
         }

Wox/SettingWindow.xaml.cs

@@ -17,7 +17,7 @@ using Wox.Core.Theme;
 using Wox.Core.Updater;
 using Wox.Core.UserSettings;
 using Wox.Helper;
-using Wox.Infrastructure;
+using Wox.Infrastructure.Exception;
 using Wox.Plugin;
 using Application = System.Windows.Forms.Application;
 using Stopwatch = Wox.Infrastructure.Stopwatch;
@@ -188,23 +188,6 @@ namespace Wox
             {
                 OnHotkeyTabSelected();
             }
-
-            // save multiple action keywords settings, todo: this hack is ugly
-            var tab = e.RemovedItems.Count > 0 ? e.RemovedItems[0] : null;
-            if (ReferenceEquals(tab, tabPlugin))
-            {
-                var metadata = (lbPlugins.SelectedItem as PluginPair)?.Metadata;
-                if (metadata != null)
-                {
-                    var customizedPluginConfig = UserSettingStorage.Instance.CustomizedPluginConfigs.FirstOrDefault(o => o.ID == metadata.ID);
-                    if (customizedPluginConfig != null && !customizedPluginConfig.Disabled)
-                    {
-                        customizedPluginConfig.ActionKeywords = metadata.ActionKeywords;
-                        UserSettingStorage.Instance.Save();
-                    }
-
-                }
-            }
         }
 
         #region General
@@ -535,50 +518,64 @@ namespace Wox
 
         #region Plugin
 
-        private void lbPlugins_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
+        private void lbPlugins_OnSelectionChanged(object sender, SelectionChangedEventArgs _)
         {
-            ISettingProvider provider = null;
+
             var pair = lbPlugins.SelectedItem as PluginPair;
             string pluginId = string.Empty;
-
+            List<string> actionKeywords = null;
-            if (pair != null)
+            if (pair == null) return;
+            actionKeywords = pair.Metadata.ActionKeywords;
+            pluginAuthor.Visibility = Visibility.Visible;
+            pluginInitTime.Text =
+                string.Format(InternationalizationManager.Instance.GetTranslation("plugin_init_time"), pair.InitTime);
+            pluginQueryTime.Text =
+                string.Format(InternationalizationManager.Instance.GetTranslation("plugin_query_time"), pair.AvgQueryTime);
+            if (actionKeywords.Count > 1)
             {
-                provider = pair.Plugin as ISettingProvider;
+                pluginActionKeywordsTitle.Visibility = Visibility.Collapsed;
-                pluginAuthor.Visibility = Visibility.Visible;
+                pluginActionKeywords.Visibility = Visibility.Collapsed;
-                pluginInitTime.Text =
-                    string.Format(InternationalizationManager.Instance.GetTranslation("plugin_init_time"), pair.InitTime);
-                pluginQueryTime.Text =
-                    string.Format(InternationalizationManager.Instance.GetTranslation("plugin_query_time"), pair.AvgQueryTime);
-                if (pair.Metadata.ActionKeywords.Count > 1)
-                {
-                    pluginActionKeywordsTitle.Visibility = Visibility.Collapsed;
-                    pluginActionKeywords.Visibility = Visibility.Collapsed;
-                }
-                else
-                {
-                    pluginActionKeywordsTitle.Visibility = Visibility.Visible;
-                    pluginActionKeywords.Visibility = Visibility.Visible;
-                }
-                tbOpenPluginDirecoty.Visibility = Visibility.Visible;
-                pluginTitle.Text = pair.Metadata.Name;
-                pluginTitle.Cursor = Cursors.Hand;
-                pluginActionKeywords.Text = string.Join(Query.ActionKeywordSeperater, pair.Metadata.ActionKeywords.ToArray());
-                pluginAuthor.Text = InternationalizationManager.Instance.GetTranslation("author") + ": " + pair.Metadata.Author;
-                pluginSubTitle.Text = pair.Metadata.Description;
-                pluginId = pair.Metadata.ID;
-                pluginIcon.Source = ImageLoader.ImageLoader.Load(pair.Metadata.FullIcoPath);
             }
+            else
+            {
+                pluginActionKeywordsTitle.Visibility = Visibility.Visible;
+                pluginActionKeywords.Visibility = Visibility.Visible;
+            }
+            tbOpenPluginDirecoty.Visibility = Visibility.Visible;
+            pluginTitle.Text = pair.Metadata.Name;
+            pluginTitle.Cursor = Cursors.Hand;
+            pluginActionKeywords.Text = string.Join(Query.ActionKeywordSeperater, actionKeywords.ToArray());
+            pluginAuthor.Text = InternationalizationManager.Instance.GetTranslation("author") + ": " + pair.Metadata.Author;
+            pluginSubTitle.Text = pair.Metadata.Description;
+            pluginId = pair.Metadata.ID;
+            pluginIcon.Source = ImageLoader.ImageLoader.Load(pair.Metadata.FullIcoPath);
 
             var customizedPluginConfig = UserSettingStorage.Instance.CustomizedPluginConfigs.FirstOrDefault(o => o.ID == pluginId);
             cbDisablePlugin.IsChecked = customizedPluginConfig != null && customizedPluginConfig.Disabled;
 
             PluginContentPanel.Content = null;
-            if (provider != null)
+            var settingProvider = pair.Plugin as ISettingProvider;
+            if (settingProvider != null)
             {
-                Control control = null;
+                Control control;
-                if (!featureControls.TryGetValue(provider, out control))
+                if (!featureControls.TryGetValue(settingProvider, out control))
-                    featureControls.Add(provider, control = provider.CreateSettingPanel());
+                {
+                    var multipleActionKeywordsProvider = settingProvider as IMultipleActionKeywords;
+                    if (multipleActionKeywordsProvider != null)
+                    {
+                        multipleActionKeywordsProvider.ActionKeywordsChanged += (o, e) =>
+                        {
+                            // update in-memory data
+                            PluginManager.UpdateActionKeywordForPlugin(pair, e.OldActionKeyword, e.NewActionKeyword);
+                            // update persistant data
+                            UserSettingStorage.Instance.UpdateActionKeyword(pair.Metadata);
 
+                            MessageBox.Show(InternationalizationManager.Instance.GetTranslation("succeed"));
+                        };
+                    }
+
+                    featureControls.Add(settingProvider, control = settingProvider.CreateSettingPanel());
+                }
                 PluginContentPanel.Content = control;
                 control.HorizontalAlignment = HorizontalAlignment.Stretch;
                 control.VerticalAlignment = VerticalAlignment.Stretch;