mirror/PowerToys
1
0
Fork 0
mirror of https://github.com/microsoft/PowerToys.git synced 2025-01-19 06:53:26 +08:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Merge pull request #377 from Wox-launcher/dev

Browse Source 
Fix UI flickering
This commit is contained in:
bao-qian 2015-11-09 16:21:55 +00:00
commit 34c516709b
54 changed files with 1792 additions and 634 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
Plugins/Wox.Plugin.CMD/CMD.cs
View File

@ -21,22 +21,17 @@ namespace Wox.Plugin.CMD
public List<Result> Query(Query query)
{
List<Result> results = new List<Result>();
List<Result> pushedResults = new List<Result>();
string cmd = query.Search;
if (string.IsNullOrEmpty(cmd))
{
return GetAllHistoryCmds();
return ResultsFromlHistory();
}
else
{
var queryCmd = GetCurrentCmd(cmd);
context.API.PushResults(query, context.CurrentPluginMetadata, new List<Result>() { queryCmd });
pushedResults.Add(queryCmd);
results.Add(queryCmd);
var history = GetHistoryCmds(cmd, queryCmd);
context.API.PushResults(query, context.CurrentPluginMetadata, history);
pushedResults.AddRange(history);
results.AddRange(history);
try
{
@ -57,7 +52,11 @@ namespace Wox.Plugin.CMD
if (basedir != null)
{
List<string> autocomplete = Directory.GetFileSystemEntries(basedir).Select(o => dir + Path.GetFileName(o)).Where(o => o.StartsWith(cmd, StringComparison.OrdinalIgnoreCase) && !results.Any(p => o.Equals(p.Title, StringComparison.OrdinalIgnoreCase)) && !pushedResults.Any(p => o.Equals(p.Title, StringComparison.OrdinalIgnoreCase))).ToList();
var autocomplete = Directory.GetFileSystemEntries(basedir).
Select(o => dir + Path.GetFileName(o)).
Where(o => o.StartsWith(cmd, StringComparison.OrdinalIgnoreCase) &&
!results.Any(p => o.Equals(p.Title, StringComparison.OrdinalIgnoreCase)) &&
!results.Any(p => o.Equals(p.Title, StringComparison.OrdinalIgnoreCase))).ToList();
autocomplete.Sort();
results.AddRange(autocomplete.ConvertAll(m => new Result()
{
@ -94,7 +93,7 @@ namespace Wox.Plugin.CMD
var ret = new Result
{
Title = m.Key,
SubTitle = string.Format(context.API.GetTranslation("wox_plugin_cmd_cmd_has_been_executed_times"), m.Value),
SubTitle = string.Format(context.API.GetTranslation("wox_plugin_cmd_cmd_has_been_executed_times"), m.Value),
IcoPath = "Images/cmd.png",
Action = (c) =>
{
@ -125,13 +124,13 @@ namespace Wox.Plugin.CMD
return result;
}
private List<Result> GetAllHistoryCmds()
private List<Result> ResultsFromlHistory()
{
IEnumerable<Result> history = CMDStorage.Instance.CMDHistory.OrderByDescending(o => o.Value)
.Select(m => new Result
{
Title = m.Key,
SubTitle = string.Format(context.API.GetTranslation("wox_plugin_cmd_cmd_has_been_executed_times"), m.Value),
SubTitle = string.Format(context.API.GetTranslation("wox_plugin_cmd_cmd_has_been_executed_times"), m.Value),
IcoPath = "Images/cmd.png",
Action = (c) =>
{

5
Plugins/Wox.Plugin.PluginIndicator/PluginIndicator.cs
View File

@ -13,10 +13,9 @@ namespace Wox.Plugin.PluginIndicator
public List<Result> Query(Query query)
{
var results = from plugin in PluginManager.NonGlobalPlugins
select plugin.Metadata into metadata
from keyword in metadata.ActionKeywords
var results = from keyword in PluginManager.NonGlobalPlugins.Keys
where keyword.StartsWith(query.Terms[0])
let metadata = PluginManager.NonGlobalPlugins[keyword].Metadata
let customizedPluginConfig =
UserSettingStorage.Instance.CustomizedPluginConfigs.FirstOrDefault(o => o.ID == metadata.ID)
where customizedPluginConfig == null || !customizedPluginConfig.Disabled

4
Plugins/Wox.Plugin.Program/FileChangeWatcher.cs
View File

@ -2,7 +2,7 @@
using System.Diagnostics;
using System.IO;
using System.Threading;
using Wox.Infrastructure.Logger;
namespace Wox.Plugin.Program
{
internal class FileChangeWatcher
@ -15,7 +15,7 @@ namespace Wox.Plugin.Program
if (watchedPath.Contains(path)) return;
if (!Directory.Exists(path))
{
Debug.WriteLine(string.Format("FileChangeWatcher: {0} doesn't exist", path));
Log.Warn($"FileChangeWatcher: {path} doesn't exist");
return;
}

4
Plugins/Wox.Plugin.Program/ProgramSources/AppPathsProgramSource.cs
View File

@ -38,7 +38,7 @@ namespace Wox.Plugin.Program.ProgramSources
using (var key = root.OpenSubKey(item))
{
string path = key.GetValue("") as string;
if (path == null) continue;
if (string.IsNullOrEmpty(path)) continue;
// fix path like this ""\"C:\\folder\\executable.exe\"""
const int begin = 0;
@ -57,7 +57,7 @@ namespace Wox.Plugin.Program.ProgramSources
}
catch (Exception e)
{
Log.Error(e.StackTrace);
Log.Error(e);
}
}
}

4
Plugins/Wox.Plugin.Program/ProgramSources/FileSystemProgramSource.cs
View File

@ -2,6 +2,7 @@
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Wox.Infrastructure.Exception;
using Wox.Infrastructure.Logger;
namespace Wox.Plugin.Program.ProgramSources
@ -70,7 +71,8 @@ namespace Wox.Plugin.Program.ProgramSources
}
catch (Exception e)
{
Log.Warn(string.Format("GetAppFromDirectory failed: {0} - {1}", path, e.Message));
var woxPluginException = new WoxPluginException("Program", $"GetAppFromDirectory failed: {path}", e);
Log.Error(woxPluginException);
}
}

9
Plugins/Wox.Plugin.Program/Programs.cs
View File

@ -8,6 +8,7 @@ using System.Windows;
using IWshRuntimeLibrary;
using Wox.Infrastructure;
using Wox.Plugin.Program.ProgramSources;
using Wox.Infrastructure.Logger;
using Stopwatch = Wox.Infrastructure.Stopwatch;
namespace Wox.Plugin.Program
@ -17,7 +18,7 @@ namespace Wox.Plugin.Program
private static object lockObject = new object();
private static List<Program> programs = new List<Program>();
private static List<IProgramSource> sources = new List<IProgramSource>();
private static Dictionary<string, Type> SourceTypes = new Dictionary<string, Type>() {
private static Dictionary<string, Type> SourceTypes = new Dictionary<string, Type>() {
{"FileSystemProgramSource", typeof(FileSystemProgramSource)},
{"CommonStartMenuProgramSource", typeof(CommonStartMenuProgramSource)},
{"UserStartMenuProgramSource", typeof(UserStartMenuProgramSource)},
@ -27,7 +28,7 @@ namespace Wox.Plugin.Program
public List<Result> Query(Query query)
{
var fuzzyMather = FuzzyMatcher.Create(query.Search);
List<Program> returnList = programs.Where(o => MatchProgram(o, fuzzyMather)).ToList();
returnList.ForEach(ScoreFilter);
@ -75,7 +76,7 @@ namespace Wox.Plugin.Program
{
programs = ProgramCacheStorage.Instance.Programs;
});
Debug.WriteLine($"Preload {programs.Count} programs from cache");
Log.Info($"Preload {programs.Count} programs from cache");
Stopwatch.Debug("Program Index", IndexPrograms);
}
@ -98,7 +99,7 @@ namespace Wox.Plugin.Program
}
sources.Clear();
foreach(var source in programSources.Where(o => o.Enabled))
foreach (var source in programSources.Where(o => o.Enabled))
{
Type sourceClass;
if (SourceTypes.TryGetValue(source.Type, out sourceClass))

144
Plugins/Wox.Plugin.Sys/Sys.cs
View File

@ -39,8 +39,11 @@ namespace Wox.Plugin.Sys
List<Result> results = new List<Result>();
foreach (Result availableResult in availableResults)
{
if (StringMatcher.IsMatch(availableResult.Title, query.Search) || StringMatcher.IsMatch(availableResult.SubTitle, query.Search))
int titleScore = StringMatcher.Match(availableResult.Title, query.Search);
int subTitleScore = StringMatcher.Match(availableResult.SubTitle, query.Search);
if (titleScore > 0 || subTitleScore > 0)
{
availableResult.Score = titleScore > 0 ? titleScore : subTitleScore;
results.Add(availableResult);
}
}
@ -55,92 +58,85 @@ namespace Wox.Plugin.Sys
private void LoadCommands()
{
availableResults.AddRange(new Result[] {
new Result
{
Title = "Shutdown",
SubTitle = context.API.GetTranslation("wox_plugin_sys_shutdown_computer"),
Score = 100,
IcoPath = "Images\\exit.png",
Action = (c) =>
{
if (MessageBox.Show("Are you sure you want to shut the computer down?","Shutdown Computer?",MessageBoxButtons.YesNo,MessageBoxIcon.Warning) == DialogResult.Yes) {
Process.Start("shutdown", "/s /t 0");
}
return true;
}
},
new Result
{
Title = "Log off",
availableResults.AddRange(new Result[] {
new Result
{
Title = "Shutdown",
SubTitle = context.API.GetTranslation("wox_plugin_sys_shutdown_computer"),
IcoPath = "Images\\exit.png",
Action = (c) =>
{
if (MessageBox.Show("Are you sure you want to shut the computer down?","Shutdown Computer?",MessageBoxButtons.YesNo,MessageBoxIcon.Warning) == DialogResult.Yes) {
Process.Start("shutdown", "/s /t 0");
}
return true;
}
},
new Result
{
Title = "Log off",
SubTitle = context.API.GetTranslation("wox_plugin_sys_log_off"),
Score = 100,
IcoPath = "Images\\logoff.png",
Action = (c) => ExitWindowsEx(EWX_LOGOFF, 0)
},
new Result
{
Title = "Lock",
IcoPath = "Images\\logoff.png",
Action = (c) => ExitWindowsEx(EWX_LOGOFF, 0)
},
new Result
{
Title = "Lock",
SubTitle = context.API.GetTranslation("wox_plugin_sys_lock"),
Score = 100,
IcoPath = "Images\\lock.png",
Action = (c) =>
{
LockWorkStation();
return true;
}
},
IcoPath = "Images\\lock.png",
Action = (c) =>
{
LockWorkStation();
return true;
}
},
new Result
{
Title = "Sleep",
SubTitle = context.API.GetTranslation("wox_plugin_sys_sleep"),
Score = 100,
IcoPath = "Images\\sleep.png",
Action = (c) => Application.SetSuspendState(PowerState.Suspend, false, false)
},
new Result
{
Title = "Exit",
{
Title = "Exit",
SubTitle = context.API.GetTranslation("wox_plugin_sys_exit"),
Score = 110,
IcoPath = "Images\\app.png",
Action = (c) =>
{
context.API.CloseApp();
return true;
}
},
new Result
{
Title = "Restart Wox",
IcoPath = "Images\\app.png",
Action = (c) =>
{
context.API.CloseApp();
return true;
}
},
new Result
{
Title = "Restart Wox",
SubTitle = context.API.GetTranslation("wox_plugin_sys_restart"),
Score = 110,
IcoPath = "Images\\restart.png",
Action = (c) =>
{
ProcessStartInfo Info = new ProcessStartInfo();
Info.Arguments = "/C ping 127.0.0.1 -n 1 && \"" + Application.ExecutablePath + "\"";
Info.WindowStyle = ProcessWindowStyle.Hidden;
Info.CreateNoWindow = true;
Info.FileName = "cmd.exe";
Process.Start(Info);
context.API.CloseApp();
return true;
}
},
new Result
{
Title = "Settings",
IcoPath = "Images\\restart.png",
Action = (c) =>
{
ProcessStartInfo Info = new ProcessStartInfo();
Info.Arguments = "/C ping 127.0.0.1 -n 1 && \"" + Application.ExecutablePath + "\"";
Info.WindowStyle = ProcessWindowStyle.Hidden;
Info.CreateNoWindow = true;
Info.FileName = "cmd.exe";
Process.Start(Info);
context.API.CloseApp();
return true;
}
},
new Result
{
Title = "Settings",
SubTitle = context.API.GetTranslation("wox_plugin_sys_setting"),
Score = 100,
IcoPath = "Images\\app.png",
Action = (c) =>
{
context.API.OpenSettingDialog();
return true;
}
}
});
IcoPath = "Images\\app.png",
Action = (c) =>
{
context.API.OpenSettingDialog();
return true;
}
}
});
}
public string GetLanguagesFolder()

40
Plugins/Wox.Plugin.WebSearch/EasyTimer.cs
View File

@ -1,40 +0,0 @@
using System;
namespace Wox.Plugin.WebSearch
{
public static class EasyTimer
{
public static IDisposable SetInterval(Action method, int delayInMilliseconds)
{
System.Timers.Timer timer = new System.Timers.Timer(delayInMilliseconds);
timer.Elapsed += (source, e) =>
{
method();
};
timer.Enabled = true;
timer.Start();
// Returns a stop handle which can be used for stopping
// the timer, if required
return timer as IDisposable;
}
public static IDisposable SetTimeout(Action method, int delayInMilliseconds)
{
System.Timers.Timer timer = new System.Timers.Timer(delayInMilliseconds);
timer.Elapsed += (source, e) =>
{
method();
};
timer.AutoReset = false;
timer.Enabled = true;
timer.Start();
// Returns a stop handle which can be used for stopping
// the timer, if required
return timer as IDisposable;
}
}
}

996
Plugins/Wox.Plugin.WebSearch/Properties/Annotations.cs Normal file
View File

@ -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 { }
}

110
Plugins/Wox.Plugin.WebSearch/WebSearchPlugin.cs
View File

@ -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;
private IDisposable suggestionTimer;
public PluginInitContext Context { get; private set; }
public List<Result> Query(Query query)
{
@ -21,71 +23,63 @@ namespace Wox.Plugin.WebSearch
if (webSearch != null)
{
string keyword = query.ActionKeyword;
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;
subtitle = null;
subtitle = string.Empty;
}
context.API.PushResults(query, context.CurrentPluginMetadata, new List<Result>()
var result = new Result
{
new Result()
Title = title,
SubTitle = subtitle,
Score = 6,
IcoPath = webSearch.IconPath,
Action = c =>
{
Title = title,
SubTitle = subtitle,
Score = 6,
IcoPath = webSearch.IconPath,
Action = (c) =>
{
Process.Start(webSearch.Url.Replace("{q}", Uri.EscapeDataString(keyword)));
return true;
}
Process.Start(webSearch.Url.Replace("{q}", Uri.EscapeDataString(keyword ?? string.Empty)));
return true;
}
});
};
results.Add(result);
if (WebSearchStorage.Instance.EnableWebSearchSuggestion && !string.IsNullOrEmpty(keyword))
{
if (suggestionTimer != null)
{
suggestionTimer.Dispose();
}
suggestionTimer = EasyTimer.SetTimeout(() => { QuerySuggestions(keyword, query, subtitle, webSearch); }, 350);
// todo use Task.Wait when .net upgraded
results.AddRange(ResultsFromSuggestions(keyword, subtitle, webSearch));
}
}
return results;
}
private void QuerySuggestions(string keyword, Query query, string subtitle, WebSearch webSearch)
private IEnumerable<Result> ResultsFromSuggestions(string keyword, string subtitle, WebSearch webSearch)
{
ISuggestionSource sugg = SuggestionSourceFactory.GetSuggestionSource(WebSearchStorage.Instance.WebSearchSuggestionSource, context);
if (sugg != null)
ISuggestionSource sugg = SuggestionSourceFactory.GetSuggestionSource(WebSearchStorage.Instance.WebSearchSuggestionSource, Context);
var suggestions = sugg?.GetSuggestions(keyword);
if (suggestions != null)
{
var result = sugg.GetSuggestions(keyword);
if (result != null)
var resultsFromSuggestion = suggestions.Select(o => new Result
{
context.API.PushResults(query, context.CurrentPluginMetadata,
result.Select(o => new Result()
{
Title = o,
SubTitle = subtitle,
Score = 5,
IcoPath = webSearch.IconPath,
Action = (c) =>
{
Process.Start(webSearch.Url.Replace("{q}", Uri.EscapeDataString(o)));
return true;
}
}).ToList());
}
Title = o,
SubTitle = subtitle,
Score = 5,
IcoPath = webSearch.IconPath,
Action = c =>
{
Process.Start(webSearch.Url.Replace("{q}", Uri.EscapeDataString(o)));
return true;
}
});
return resultsFromSuggestion;
}
return new List<Result>();
}
public void Init(PluginInitContext context)
{
this.context = context;
this.Context = context;
if (WebSearchStorage.Instance.WebSearches == null)
WebSearchStorage.Instance.WebSearches = WebSearchStorage.Instance.LoadDefaultWebSearches();
@ -93,9 +87,9 @@ namespace Wox.Plugin.WebSearch
#region ISettingProvider Members
public System.Windows.Controls.Control CreateSettingPanel()
public Control CreateSettingPanel()
{
return new WebSearchesSetting(context);
return new WebSearchesSetting(this);
}
#endregion
@ -107,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;
}
}

2
Plugins/Wox.Plugin.WebSearch/WebSearchSetting.xaml
View File

@ -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>

125
Plugins/Wox.Plugin.WebSearch/WebSearchSetting.xaml.cs
View File

@ -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 WebSearchesSetting settingWindow;
private bool update;
private WebSearch updateWebSearch;
private PluginInitContext context;
private string _defaultWebSearchImageDirectory = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Images\\websearch");
private readonly WebSearchesSetting _settingWindow;
private bool _isUpdate;
private WebSearch _updateWebSearch;
private readonly PluginInitContext _context;
private readonly WebSearchPlugin _plguin;
public WebSearchSetting(WebSearchesSetting settingWidow,PluginInitContext context)
public WebSearchSetting(WebSearchesSetting settingWidow)
{
this.context = context;
this.settingWindow = settingWidow;
_plguin = settingWidow.Plugin;
_context = settingWidow.Context;
_settingWindow = settingWidow;
InitializeComponent();
}
public void UpdateItem(WebSearch webSearch)
{
updateWebSearch = WebSearchStorage.Instance.WebSearches.FirstOrDefault(o => o == webSearch);
if (updateWebSearch == null || string.IsNullOrEmpty(updateWebSearch.Url))
_updateWebSearch = WebSearchStorage.Instance.WebSearches.FirstOrDefault(o => o == webSearch);
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);
@ -47,13 +50,7 @@ namespace Wox.Plugin.WebSearch
private void ShowIcon(string path)
{
try
{
imgIcon.Source = new BitmapImage(new Uri(path));
}
catch (Exception)
{
}
imgIcon.Source = new BitmapImage(new Uri($"{_defaultWebSearchImageDirectory}\\{path}", UriKind.Absolute));
}
private void BtnCancel_OnClick(object sender, RoutedEventArgs e)
@ -61,12 +58,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,89 +74,76 @@ 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;
if (string.IsNullOrEmpty(action))
string newActionKeyword = tbActionword.Text.Trim();
if (_isUpdate)
{
string warning = context.API.GetTranslation("wox_plugin_websearch_input_action_keyword");
MessageBox.Show(warning);
return;
}
if (!update)
{
if (WebSearchStorage.Instance.WebSearches.Exists(o => o.ActionKeyword == action))
try
{
string warning = context.API.GetTranslation("wox_plugin_websearch_action_keyword_exist");
MessageBox.Show(warning);
_plguin.NotifyActionKeywordsUpdated(_updateWebSearch.ActionKeyword, newActionKeyword);
}
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,
Filter ="Image files (*.jpg, *.jpeg, *.gif, *.png, *.bmp) |*.jpg; *.jpeg; *.gif; *.png; *.bmp"
InitialDirectory = _defaultWebSearchImageDirectory,
Filter = "Image files (*.jpg, *.jpeg, *.gif, *.png, *.bmp) |*.jpg; *.jpeg; *.gif; *.png; *.bmp"
};
bool? result = dlg.ShowDialog();
if (result == true)
{
string filename = dlg.FileName;
tbIconPath.Text = filename;
ShowIcon(filename);
tbIconPath.Text = Path.GetFileName(filename);
ShowIcon(tbIconPath.Text);
}
}
}

6
Plugins/Wox.Plugin.WebSearch/WebSearchStorage.cs
View File

@ -41,7 +41,7 @@ namespace Wox.Plugin.WebSearch
{
Title = "Google",
ActionKeyword = "g",
IconPath = @"Images\websearch\google.png",
IconPath = @"google.png",
Url = "https://www.google.com/search?q={q}",
Enabled = true
};
@ -52,7 +52,7 @@ namespace Wox.Plugin.WebSearch
{
Title = "Wikipedia",
ActionKeyword = "wiki",
IconPath = @"Images\websearch\wiki.png",
IconPath = @"wiki.png",
Url = "http://en.wikipedia.org/wiki/{q}",
Enabled = true
};
@ -62,7 +62,7 @@ namespace Wox.Plugin.WebSearch
{
Title = "FindIcon",
ActionKeyword = "findicon",
IconPath = @"Images\websearch\pictures.png",
IconPath = @"pictures.png",
Url = "http://findicons.com/search/{q}",
Enabled = true
};

28
Plugins/Wox.Plugin.WebSearch/WebSearchesSetting.xaml.cs
View File

@ -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);
if (MessageBox.Show(msg,string.Empty, MessageBoxButton.YesNo) == MessageBoxResult.Yes)
string msg = string.Format(Context.API.GetTranslation("wox_plugin_websearch_delete_warning"), selectedWebSearch.Title);
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();
}
}

5
Plugins/Wox.Plugin.WebSearch/Wox.Plugin.WebSearch.csproj
View File

@ -49,7 +49,7 @@
<Reference Include="WindowsBase" />
</ItemGroup>
<ItemGroup>
<Compile Include="EasyTimer.cs" />
<Compile Include="Properties\Annotations.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="SuggestionSources\Baidu.cs" />
<Compile Include="SuggestionSources\Google.cs" />
@ -93,9 +93,6 @@
<SubType>Designer</SubType>
</Page>
</ItemGroup>
<ItemGroup>
<WCFMetadata Include="Service References\" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\Wox.Infrastructure\Wox.Infrastructure.csproj">
<Project>{4fd29318-a8ab-4d8f-aa47-60bc241b8da3}</Project>

13
Wox.Core/Exception/WoxPluginException.cs
View File

@ -1,13 +0,0 @@
namespace Wox.Core.Exception
{
public class WoxPluginException : WoxException
{
public string PluginName { get; set; }
public WoxPluginException(string pluginName,System.Exception e)
: base(e.Message,e)
{
PluginName = pluginName;
}
}
}

12
Wox.Core/Plugin/CSharpPluginLoader.cs
View File

@ -2,6 +2,7 @@
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using Wox.Infrastructure.Exception;
using Wox.Infrastructure.Logger;
using Wox.Plugin;
@ -19,10 +20,10 @@ namespace Wox.Core.Plugin
try
{
Assembly asm = Assembly.Load(AssemblyName.GetAssemblyName(metadata.ExecuteFilePath));
List<Type> types = asm.GetTypes().Where(o => o.IsClass && !o.IsAbstract && o.GetInterfaces().Contains(typeof(IPlugin))).ToList();
List<Type> types = asm.GetTypes().Where(o => o.IsClass && !o.IsAbstract && o.GetInterfaces().Contains(typeof(IPlugin))).ToList();
if (types.Count == 0)
{
Log.Warn(string.Format("Couldn't load plugin {0}: didn't find the class that implement IPlugin", metadata.Name));
Log.Warn($"Couldn't load plugin {metadata.Name}: didn't find the class that implement IPlugin");
continue;
}
@ -39,12 +40,7 @@ namespace Wox.Core.Plugin
}
catch (System.Exception e)
{
Log.Error(string.Format("Couldn't load plugin {0}: {1}", metadata.Name, e.Message));
#if (DEBUG)
{
throw;
}
#endif
Log.Error(new WoxPluginException(metadata.Name, $"Couldn't load plugin", e));
}
}

4
Wox.Core/Plugin/JsonRPCPlugin.cs
View File

@ -5,7 +5,7 @@ using System.Reflection;
using System.Threading;
using System.Windows.Forms;
using Newtonsoft.Json;
using Wox.Core.Exception;
using Wox.Infrastructure.Exception;
using Wox.Infrastructure.Logger;
using Wox.Plugin;
@ -74,7 +74,7 @@ namespace Wox.Core.Plugin
}
catch (System.Exception e)
{
Log.Error(e.Message);
Log.Error(e);
}
}
return null;

35
Wox.Core/Plugin/PluginConfig.cs
View File

@ -2,8 +2,8 @@
using System.IO;
using System.Linq;
using Newtonsoft.Json;
using Wox.Core.Exception;
using Wox.Core.UserSettings;
using Wox.Infrastructure.Exception;
using Wox.Infrastructure.Logger;
using Wox.Plugin;
@ -47,7 +47,7 @@ namespace Wox.Core.Plugin
}
catch (System.Exception e)
{
Log.Error(ExceptionFormatter.FormatExcpetion(e));
Log.Fatal(e);
}
}
PluginMetadata metadata = GetPluginMetadata(directory);
@ -63,7 +63,7 @@ namespace Wox.Core.Plugin
string configPath = Path.Combine(pluginDirectory, pluginConfigName);
if (!File.Exists(configPath))
{
Log.Warn(string.Format("parse plugin {0} failed: didn't find config file.", configPath));
Log.Warn($"parse plugin {configPath} failed: didn't find config file.");
return null;
}
@ -77,40 +77,25 @@ namespace Wox.Core.Plugin
// for plugin still use old ActionKeyword
metadata.ActionKeyword = metadata.ActionKeywords?[0];
}
catch (System.Exception)
catch (System.Exception e)
{
string error = string.Format("Parse plugin config {0} failed: json format is not valid", configPath);
Log.Warn(error);
#if (DEBUG)
{
throw new WoxException(error);
}
#endif
string msg = $"Parse plugin config {configPath} failed: json format is not valid";
Log.Error(new WoxException(msg));
return null;
}
if (!AllowedLanguage.IsAllowed(metadata.Language))
{
string error = string.Format("Parse plugin config {0} failed: invalid language {1}", configPath, metadata.Language);
Log.Warn(error);
#if (DEBUG)
{
throw new WoxException(error);
}
#endif
string msg = $"Parse plugin config {configPath} failed: invalid language {metadata.Language}";
Log.Error(new WoxException(msg));
return null;
}
if (!File.Exists(metadata.ExecuteFilePath))
{
string error = string.Format("Parse plugin config {0} failed: ExecuteFile {1} didn't exist", configPath, metadata.ExecuteFilePath);
Log.Warn(error);
#if (DEBUG)
{
throw new WoxException(error);
}
#endif
string msg = $"Parse plugin config {configPath} failed: ExecuteFile {metadata.ExecuteFilePath} didn't exist";
Log.Error(new WoxException(msg));
return null;
}

133
Wox.Core/Plugin/PluginManager.cs
View File

@ -4,13 +4,13 @@ using System.IO;
using System.Linq;
using System.Reflection;
using System.Threading;
using Wox.Core.Exception;
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
{
@ -29,8 +29,8 @@ namespace Wox.Core.Plugin
public static IEnumerable<PluginPair> AllPlugins { get; private set; }
public static IEnumerable<PluginPair> GlobalPlugins { get; private set; }
public static IEnumerable<PluginPair> NonGlobalPlugins { get; private set; }
public static List<PluginPair> GlobalPlugins { get; } = new List<PluginPair>();
public static Dictionary<string, PluginPair> NonGlobalPlugins { get; set; } = new Dictionary<string, PluginPair>();
private static IEnumerable<PluginPair> InstantQueryPlugins { get; set; }
public static IPublicAPI API { private set; get; }
@ -56,9 +56,9 @@ namespace Wox.Core.Plugin
{
Directory.CreateDirectory(pluginDirectory);
}
catch (System.Exception e)
catch (Exception e)
{
Log.Error(e.Message);
Log.Error(e);
}
}
}
@ -69,7 +69,7 @@ namespace Wox.Core.Plugin
/// </summary>
public static void Init(IPublicAPI api)
{
if (api == null) throw new WoxCritialException("api is null");
if (api == null) throw new WoxFatalException("api is null");
SetupPluginDirectories();
API = api;
@ -104,8 +104,20 @@ namespace Wox.Core.Plugin
{
InstantQueryPlugins = GetPluginsForInterface<IInstantQuery>();
contextMenuPlugins = GetPluginsForInterface<IContextMenu>();
GlobalPlugins = AllPlugins.Where(p => IsGlobalPlugin(p.Metadata));
NonGlobalPlugins = AllPlugins.Where(p => !IsGlobalPlugin(p.Metadata));
foreach (var plugin in AllPlugins)
{
if (IsGlobalPlugin(plugin.Metadata))
{
GlobalPlugins.Add(plugin);
}
else
{
foreach (string actionKeyword in plugin.Metadata.ActionKeywords)
{
NonGlobalPlugins[actionKeyword] = plugin;
}
}
}
});
}
@ -123,7 +135,7 @@ namespace Wox.Core.Plugin
var search = rawQuery;
List<string> actionParameters = terms.ToList();
if (terms.Length == 0) return null;
if (IsVailldActionKeyword(terms[0]))
if (NonGlobalPlugins.ContainsKey(terms[0]))
{
actionKeyword = terms[0];
actionParameters = terms.Skip(1).ToList();
@ -143,8 +155,8 @@ namespace Wox.Core.Plugin
public static void QueryForAllPlugins(Query query)
{
var pluginPairs = GetPluginForActionKeyword(query.ActionKeyword) != null ?
new List<PluginPair> { GetPluginForActionKeyword(query.ActionKeyword) } : GlobalPlugins;
var pluginPairs = NonGlobalPlugins.ContainsKey(query.ActionKeyword) ?
new List<PluginPair> { NonGlobalPlugins[query.ActionKeyword] } : GlobalPlugins;
foreach (var plugin in pluginPairs)
{
var customizedPluginConfig = UserSettingStorage.Instance.
@ -152,7 +164,7 @@ namespace Wox.Core.Plugin
if (customizedPluginConfig != null && customizedPluginConfig.Disabled) continue;
if (IsInstantQueryPlugin(plugin))
{
Stopwatch.Debug($"Instant Query for {plugin.Metadata.Name}", () =>
Stopwatch.Normal($"Instant QueryForPlugin for {plugin.Metadata.Name}", () =>
{
QueryForPlugin(plugin, query);
});
@ -161,7 +173,10 @@ namespace Wox.Core.Plugin
{
ThreadPool.QueueUserWorkItem(state =>
{
QueryForPlugin(plugin, query);
Stopwatch.Normal($"Normal QueryForPlugin for {plugin.Metadata.Name}", () =>
{
QueryForPlugin(plugin, query);
});
});
}
}
@ -172,7 +187,7 @@ namespace Wox.Core.Plugin
try
{
List<Result> results = new List<Result>();
var milliseconds = Stopwatch.Normal($"Query for {pair.Metadata.Name}", () =>
var milliseconds = Stopwatch.Normal($"Plugin.Query cost for {pair.Metadata.Name}", () =>
{
results = pair.Plugin.Query(query) ?? results;
results.ForEach(o => { o.PluginID = pair.Metadata.ID; });
@ -181,27 +196,12 @@ 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, e);
throw new WoxPluginException(pair.Metadata.Name, $"QueryForPlugin failed", e);
}
}
/// <summary>
/// Check if a query contains valid action keyword
/// </summary>
/// <param name="actionKeyword"></param>
/// <returns></returns>
private static bool IsVailldActionKeyword(string actionKeyword)
{
if (string.IsNullOrEmpty(actionKeyword) || actionKeyword == Query.GlobalPluginWildcardSign) return false;
PluginPair pair = AllPlugins.FirstOrDefault(o => o.Metadata.ActionKeywords.Contains(actionKeyword));
if (pair == null) return false;
var customizedPluginConfig = UserSettingStorage.Instance.
CustomizedPluginConfigs.FirstOrDefault(o => o.ID == pair.Metadata.ID);
return customizedPluginConfig == null || !customizedPluginConfig.Disabled;
}
private static bool IsGlobalPlugin(PluginMetadata metadata)
{
return metadata.ActionKeywords.Contains(Query.GlobalPluginWildcardSign);
@ -225,13 +225,6 @@ namespace Wox.Core.Plugin
return AllPlugins.FirstOrDefault(o => o.Metadata.ID == id);
}
private static PluginPair GetPluginForActionKeyword(string actionKeyword)
{
//if a query doesn't contain a vaild action keyword, it should be a query for system plugin
if (string.IsNullOrEmpty(actionKeyword) || actionKeyword == Query.GlobalPluginWildcardSign) return null;
return NonGlobalPlugins.FirstOrDefault(o => o.Metadata.ActionKeywords.Contains(actionKeyword));
}
public static IEnumerable<PluginPair> GetPluginsForInterface<T>() where T : IFeatures
{
return AllPlugins.Where(p => p.Plugin is T);
@ -247,18 +240,66 @@ namespace Wox.Core.Plugin
{
return plugin.LoadContextMenus(result);
}
catch (System.Exception e)
catch (Exception e)
{
Log.Error($"Couldn't load plugin context menus {pluginPair.Metadata.Name}: {e.Message}");
#if (DEBUG)
{
throw;
}
#endif
Log.Error(new WoxPluginException(pluginPair.Metadata.Name, $"Couldn't load plugin context menus", e));
}
}
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;
}
}
}
}
}

2
Wox.Core/Theme/Theme.cs
View File

@ -35,7 +35,7 @@ namespace Wox.Core.Theme
}
catch (System.Exception e)
{
Log.Error(e.Message);
Log.Error(e);
}
}
}

2
Wox.Core/Updater/SemanticVersion.cs
View File

@ -1,5 +1,5 @@
using System;
using Wox.Core.Exception;
using Wox.Infrastructure.Exception;
namespace Wox.Core.Updater
{

24
Wox.Core/UserSettings/UserSettingStorage.cs
View File

@ -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

7
Wox.Core/Wox.Core.csproj
View File

@ -57,13 +57,6 @@
</ItemGroup>
<ItemGroup>
<Compile Include="APIServer.cs" />
<Compile Include="Exception\ExceptionFormatter.cs" />
<Compile Include="Exception\WoxCritialException.cs" />
<Compile Include="Exception\WoxException.cs" />
<Compile Include="Exception\WoxHttpException.cs" />
<Compile Include="Exception\WoxI18nException.cs" />
<Compile Include="Exception\WoxJsonRPCException.cs" />
<Compile Include="Exception\WoxPluginException.cs" />
<Compile Include="Updater\Release.cs" />
<Compile Include="Updater\UpdaterManager.cs" />
<Compile Include="Updater\WoxUpdateSource.cs" />

12
Wox.Core/i18n/Internationalization.cs
View File

@ -4,9 +4,9 @@ using System.IO;
using System.Linq;
using System.Reflection;
using System.Windows;
using Wox.Core.Exception;
using Wox.Core.UI;
using Wox.Core.UserSettings;
using Wox.Infrastructure.Exception;
using Wox.Infrastructure.Logger;
using Wox.Plugin;
@ -32,7 +32,7 @@ namespace Wox.Core.i18n
}
catch (System.Exception e)
{
Log.Error(e.Message);
Log.Error(e);
}
}
}
@ -122,12 +122,8 @@ namespace Wox.Core.i18n
}
catch (System.Exception e)
{
Log.Warn("Update Plugin metadata translation failed:" + e.Message);
#if (DEBUG)
{
throw;
}
#endif
var woxPluginException = new WoxPluginException(pluginPair.Metadata.Name, "Update Plugin metadata translation failed:", e);
Log.Error(woxPluginException);
}
}

2
Wox.Core/Exception/ExceptionFormatter.cs → Wox.Infrastructure/Exception/ExceptionFormatter.cs
View File

@ -5,7 +5,7 @@ using System.Text;
using System.Xml;
using Microsoft.Win32;
namespace Wox.Core.Exception
namespace Wox.Infrastructure.Exception
{
public class ExceptionFormatter
{

3
Wox.Core/Exception/WoxException.cs → Wox.Infrastructure/Exception/WoxException.cs
View File

@ -1,4 +1,4 @@
namespace Wox.Core.Exception
namespace Wox.Infrastructure.Exception
{
/// <summary>
/// Base Wox Exceptions
@ -14,7 +14,6 @@
public WoxException(string msg, System.Exception innerException)
: base(msg, innerException)
{
}
}
}

6
Wox.Core/Exception/WoxCritialException.cs → Wox.Infrastructure/Exception/WoxFatalException.cs
View File

@ -1,11 +1,11 @@
namespace Wox.Core.Exception
namespace Wox.Infrastructure.Exception
{
/// <summary>
/// Represent exceptions that wox can't handle and MUST close running Wox.
/// </summary>
public class WoxCritialException : WoxException
public class WoxFatalException : WoxException
{
public WoxCritialException(string msg) : base(msg)
public WoxFatalException(string msg) : base(msg)
{
}
}

2
Wox.Core/Exception/WoxHttpException.cs → Wox.Infrastructure/Exception/WoxHttpException.cs
View File

@ -1,4 +1,4 @@
namespace Wox.Core.Exception
namespace Wox.Infrastructure.Exception
{
public class WoxHttpException :WoxException
{

4
Wox.Core/Exception/WoxI18nException.cs → Wox.Infrastructure/Exception/WoxI18nException.cs
View File

@ -1,6 +1,6 @@
namespace Wox.Core.Exception
namespace Wox.Infrastructure.Exception
{
public class WoxI18nException:WoxException
public class WoxI18nException : WoxException
{
public WoxI18nException(string msg) : base(msg)
{

2
Wox.Core/Exception/WoxJsonRPCException.cs → Wox.Infrastructure/Exception/WoxJsonRPCException.cs
View File

@ -1,4 +1,4 @@
namespace Wox.Core.Exception
namespace Wox.Infrastructure.Exception
{
public class WoxJsonRPCException : WoxException
{

20
Wox.Infrastructure/Exception/WoxPluginException.cs Normal file
View File

@ -0,0 +1,20 @@
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($"{pluginName} : {msg}", e)
{
PluginName = pluginName;
}
public WoxPluginException(string pluginName, string msg) : base(msg)
{
PluginName = pluginName;
}
}
}

7
Wox.Infrastructure/Http/HttpRequest.cs
View File

@ -1,5 +1,4 @@
using System;
using System.IO;
using System.IO;
using System.Net;
using System.Text;
using Wox.Plugin;
@ -55,7 +54,7 @@ namespace Wox.Infrastructure.Http
}
}
}
catch (Exception e)
catch (System.Exception e)
{
Logger.Log.Error(e);
return string.Empty;
@ -108,7 +107,7 @@ namespace Wox.Infrastructure.Http
}
}
}
catch (Exception e)
catch (System.Exception e)
{
Logger.Log.Error(e);
return string.Empty;

26
Wox.Infrastructure/Logger/Log.cs
View File

@ -1,5 +1,5 @@
using System;
using NLog;
using NLog;
using Wox.Infrastructure.Exception;
namespace Wox.Infrastructure.Logger
{
@ -7,34 +7,40 @@ namespace Wox.Infrastructure.Logger
{
private static NLog.Logger logger = LogManager.GetCurrentClassLogger();
public static void Error(string msg)
{
logger.Error(msg);
}
public static void Error(Exception e)
public static void Error(System.Exception e)
{
#if DEBUG
throw e;
#else
logger.Error(e.Message + "\r\n" + e.StackTrace);
#endif
}
public static void Debug(string msg)
{
System.Diagnostics.Debug.WriteLine($"DEBUG: {msg}");
logger.Debug(msg);
}
public static void Info(string msg)
{
System.Diagnostics.Debug.WriteLine($"INFO: {msg}");
logger.Info(msg);
}
public static void Warn(string msg)
{
System.Diagnostics.Debug.WriteLine($"WARN: {msg}");
logger.Warn(msg);
}
public static void Fatal(string msg)
public static void Fatal(System.Exception e)
{
logger.Fatal(msg);
#if DEBUG
throw e;
#else
logger.Fatal(ExceptionFormatter.FormatExcpetion(e));
#endif
}
}
}

11
Wox.Infrastructure/Stopwatch.cs
View File

@ -18,14 +18,6 @@ namespace Wox.Infrastructure
#endif
}
[Conditional("DEBUG")]
private static void WriteTimeInfo(string name, long milliseconds)
{
string info = $"{name} : {milliseconds}ms";
System.Diagnostics.Debug.WriteLine(info);
Log.Info(info);
}
/// <summary>
/// This stopwatch will also appear only in Debug mode
/// </summary>
@ -36,7 +28,8 @@ namespace Wox.Infrastructure
action();
stopWatch.Stop();
var milliseconds = stopWatch.ElapsedMilliseconds;
WriteTimeInfo(name, milliseconds);
string info = $"{name} : {milliseconds}ms";
Log.Debug(info);
return milliseconds;
}

6
Wox.Infrastructure/Storage/BinaryStorage.cs
View File

@ -42,7 +42,7 @@ namespace Wox.Infrastructure.Storage
serializedObject = LoadDefault();
#if (DEBUG)
{
throw new Exception("deserialize failed");
throw new System.Exception("deserialize failed");
}
#endif
}
@ -53,7 +53,7 @@ namespace Wox.Infrastructure.Storage
}
}
}
catch (Exception e)
catch (System.Exception e)
{
Log.Error(e);
serializedObject = LoadDefault();
@ -101,7 +101,7 @@ namespace Wox.Infrastructure.Storage
binaryFormatter.Serialize(fileStream, serializedObject);
fileStream.Close();
}
catch (Exception e)
catch (System.Exception e)
{
Log.Error(e);
#if (DEBUG)

2
Wox.Infrastructure/Storage/JsonStorage.cs
View File

@ -25,7 +25,7 @@ namespace Wox.Infrastructure.Storage
{
serializedObject = JsonConvert.DeserializeObject<T>(json);
}
catch (Exception)
catch (System.Exception)
{
serializedObject = LoadDefault();
}

4
Wox.Infrastructure/WindowsShellRun.cs
View File

@ -115,7 +115,7 @@ namespace Wox.Infrastructure
needsCommandLine = peHeaderReader.OptionalHeader64.Subsystem == 3;
}
catch (Exception)
catch (System.Exception)
{
// Error reading the headers. We will try to run the command the standard way.
needsCommandLine = false;
@ -149,7 +149,7 @@ namespace Wox.Infrastructure
{
global::System.Diagnostics.Process.Start(startInfo);
}
catch (Exception e)
catch (System.Exception e)
{
if (!startInfo.ErrorDialog)
throw e;

8
Wox.Infrastructure/Wox.Infrastructure.csproj
View File

@ -46,9 +46,17 @@
</Reference>
<Reference Include="System" />
<Reference Include="System.Core" />
<Reference Include="System.Xml" />
<Reference Include="WindowsBase" />
</ItemGroup>
<ItemGroup>
<Compile Include="Exception\ExceptionFormatter.cs" />
<Compile Include="Exception\WoxException.cs" />
<Compile Include="Exception\WoxFatalException.cs" />
<Compile Include="Exception\WoxHttpException.cs" />
<Compile Include="Exception\WoxI18nException.cs" />
<Compile Include="Exception\WoxJsonRPCException.cs" />
<Compile Include="Exception\WoxPluginException.cs" />
<Compile Include="Hotkey\InterceptKeys.cs" />
<Compile Include="Hotkey\KeyEvent.cs" />
<Compile Include="Logger\Log.cs" />

13
Wox.Plugin/Feature.cs
View File

@ -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);
}

19
Wox.Plugin/PluginPair.cs
View File

@ -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;
}
}
}

19
Wox.Plugin/Result.cs
View File

@ -42,12 +42,23 @@ namespace Wox.Plugin
/// </summary>
public string PluginDirectory { get; internal set; }
public new bool Equals(object obj)
public override bool Equals(object obj)
{
if (obj == null || !(obj is Result)) return false;
Result r = obj as Result;
if (r != null)
{
return string.Equals(r.Title, Title) && string.Equals(r.SubTitle, SubTitle);
}
else
{
return false;
}
}
Result r = (Result)obj;
return r.Title == Title && r.SubTitle == SubTitle;
public override int GetHashCode()
{
var hashcode = (Title?.GetHashCode() ?? 0) ^ (SubTitle?.GetHashCode() ?? 0);
return hashcode;
}
public override string ToString()

4
Wox.Test/Plugins/PluginInitTest.cs
View File

@ -1,6 +1,6 @@
using NUnit.Framework;
using Wox.Core.Exception;
using Wox.Core.Plugin;
using Wox.Infrastructure.Exception;
namespace Wox.Test.Plugins
{
@ -11,7 +11,7 @@ namespace Wox.Test.Plugins
[Test]
public void PublicAPIIsNullTest()
{
Assert.Throws(typeof(WoxCritialException), () => PluginManager.Init(null));
Assert.Throws(typeof(WoxFatalException), () => PluginManager.Init(null));
}
}
}

55
Wox/ActionKeywords.xaml.cs
View File

@ -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);
if (plugin == null)
_plugin = PluginManager.GetPluginForId(pluginId);
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();
}

13
Wox/App.xaml.cs
View File

@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Windows;
@ -32,9 +33,7 @@ namespace Wox
Stopwatch.Debug("Startup Time", () =>
{
base.OnStartup(e);
DispatcherUnhandledException += ErrorReporting.DispatcherUnhandledException;
AppDomain.CurrentDomain.UnhandledException += ErrorReporting.UnhandledExceptionHandle;
RegisterUnhandledException();
ThreadPool.QueueUserWorkItem(o => { ImageLoader.ImageLoader.PreloadImages(); });
Window = new MainWindow();
PluginManager.Init(Window);
@ -43,6 +42,14 @@ namespace Wox
}
[Conditional("DEBUG")]
private void RegisterUnhandledException()
{
// let exception throw as normal is better for Debug
DispatcherUnhandledException += ErrorReporting.DispatcherUnhandledException;
AppDomain.CurrentDomain.UnhandledException += ErrorReporting.UnhandledExceptionHandle;
}
public bool OnActivate(IList<string> args)
{
CommandArgsFactory.Execute(args);

4
Wox/Helper/ErrorReporting.cs
View File

@ -1,6 +1,6 @@
using System;
using System.Windows.Threading;
using Wox.Core.Exception;
using Wox.Infrastructure.Exception;
using Wox.Infrastructure.Logger;
namespace Wox.Helper
@ -9,7 +9,7 @@ namespace Wox.Helper
{
public static void Report(Exception e)
{
Log.Error(ExceptionFormatter.FormatExcpetion(e));
Log.Fatal(e);
new CrashReporter.CrashReporter(e).Show();
}

67
Wox/Helper/ListBoxItems.cs Normal file
View File

@ -0,0 +1,67 @@
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Linq;
using Wox.Plugin;
namespace Wox.Helper
{
class ListBoxItems : ObservableCollection<Result>
// todo implement custom moveItem,removeItem,insertItem for better performance
{
public void RemoveAll(Predicate<Result> predicate)
{
CheckReentrancy();
List<Result> itemsToRemove = Items.Where(x => predicate(x)).ToList();
if (itemsToRemove.Count > 0)
{
itemsToRemove.ForEach(item => Items.Remove(item));
OnPropertyChanged(new PropertyChangedEventArgs("Count"));
OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));
// fuck ms
// http://blogs.msdn.com/b/nathannesbit/archive/2009/04/20/addrange-and-observablecollection.aspx
// http://geekswithblogs.net/NewThingsILearned/archive/2008/01/16/listcollectionviewcollectionview-doesnt-support-notifycollectionchanged-with-multiple-items.aspx
// PS: don't use Reset for other data updates, it will cause UI flickering
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
}
}
public void Update(List<Result> newItems)
{
int newCount = newItems.Count;
int oldCount = Items.Count;
int location = newCount > oldCount ? oldCount : newCount;
for (int i = 0; i < location; i++)
{
Result oldItem = Items[i];
Result newItem = newItems[i];
if (!Equals(oldItem, newItem))
{
this[i] = newItem;
}
}
if (newCount > oldCount)
{
for (int i = oldCount; i < newCount; i++)
{
Add(newItems[i]);
}
}
else
{
int removeIndex = newCount;
for (int i = newCount; i < oldCount; i++)
{
RemoveAt(removeIndex);
}
}
}
}
}

110
Wox/MainWindow.xaml.cs
View File

@ -32,6 +32,7 @@ using IDataObject = System.Windows.IDataObject;
using KeyEventArgs = System.Windows.Input.KeyEventArgs;
using MenuItem = System.Windows.Forms.MenuItem;
using MessageBox = System.Windows.MessageBox;
using Stopwatch = Wox.Infrastructure.Stopwatch;
using ToolTip = System.Windows.Controls.ToolTip;
namespace Wox
@ -43,11 +44,11 @@ namespace Wox
private readonly Storyboard progressBarStoryboard = new Storyboard();
private NotifyIcon notifyIcon;
private bool queryHasReturn;
private string lastQuery;
private bool _queryHasReturn;
private Query _lastQuery = new Query();
private ToolTip toolTip = new ToolTip();
private bool ignoreTextChange = false;
private bool _ignoreTextChange = false;
private List<Result> CurrentContextMenus = new List<Result>();
private string textBeforeEnterContextMenuMode;
@ -72,7 +73,7 @@ namespace Wox
{
Dispatcher.Invoke(new Action(() =>
{
ignoreTextChange = true;
_ignoreTextChange = true;
tbQuery.Text = query;
tbQuery.CaretIndex = tbQuery.Text.Length;
if (selectAll)
@ -162,7 +163,7 @@ namespace Wox
o.PluginID = plugin.ID;
o.OriginQuery = query;
});
UpdateResultView(results);
UpdateResultView(results, plugin, query);
}
public void ShowContextMenu(PluginMetadata plugin, List<Result> results)
@ -176,7 +177,7 @@ namespace Wox
o.ContextMenu = null;
});
pnlContextMenu.Clear();
pnlContextMenu.AddResults(results);
pnlContextMenu.AddResults(results, plugin.ID);
pnlContextMenu.Visibility = Visibility.Visible;
pnlResult.Visibility = Visibility.Collapsed;
}
@ -418,11 +419,12 @@ namespace Wox
private void QueryContextMenu()
{
var contextMenuId = "Context Menu Id";
pnlContextMenu.Clear();
var query = tbQuery.Text.ToLower();
if (string.IsNullOrEmpty(query))
{
pnlContextMenu.AddResults(CurrentContextMenus);
pnlContextMenu.AddResults(CurrentContextMenus, contextMenuId);
}
else
{
@ -435,54 +437,74 @@ namespace Wox
filterResults.Add(contextMenu);
}
}
pnlContextMenu.AddResults(filterResults);
pnlContextMenu.AddResults(filterResults, contextMenuId);
}
}
private void TbQuery_OnTextChanged(object sender, TextChangedEventArgs e)
{
if (ignoreTextChange) { ignoreTextChange = false; return; }
if (_ignoreTextChange) { _ignoreTextChange = false; return; }
toolTip.IsOpen = false;
pnlResult.Dirty = true;
if (IsInContextMenuMode)
{
QueryContextMenu();
return;
}
queryHasReturn = false;
Dispatcher.DelayInvoke("ClearResults", () =>
string query = tbQuery.Text.Trim();
if (!string.IsNullOrEmpty(query))
{
// Delay the invocation of clear method of pnlResult, minimize the time-span between clear results and add new results.
// So this will reduce splash issues. After waiting 100ms, if there still no results added, we
// must clear the result. otherwise, it will be confused why the query changed, but the results
// didn't.
if (pnlResult.Dirty) pnlResult.Clear();
}, TimeSpan.FromMilliseconds(100));
Query(tbQuery.Text);
Dispatcher.DelayInvoke("ShowProgressbar", () =>
Query(query);
//reset query history index after user start new query
ResetQueryHistoryIndex();
}
else
{
if (!string.IsNullOrEmpty(tbQuery.Text.Trim()) && tbQuery.Text != lastQuery && !queryHasReturn)
{
StartProgress();
}
}, TimeSpan.FromMilliseconds(150));
//reset query history index after user start new query
ResetQueryHistoryIndex();
pnlResult.Clear();
}
}
private void ResetQueryHistoryIndex()
{
pnlResult.RemoveResultsFor(QueryHistoryStorage.MetaData);
QueryHistoryStorage.Instance.Reset();
}
private void Query(string text)
{
_queryHasReturn = false;
var query = PluginManager.QueryInit(text);
if (query != null)
{
lastQuery = query.RawQuery;
// handle the exclusiveness of plugin using action keyword
string lastKeyword = _lastQuery.ActionKeyword;
string keyword = query.ActionKeyword;
if (string.IsNullOrEmpty(lastKeyword))
{
if (!string.IsNullOrEmpty(keyword))
{
pnlResult.RemoveResultsExcept(PluginManager.NonGlobalPlugins[keyword].Metadata);
}
}
else
{
if (string.IsNullOrEmpty(keyword))
{
pnlResult.RemoveResultsFor(PluginManager.NonGlobalPlugins[lastKeyword].Metadata);
}
else if (lastKeyword != keyword)
{
pnlResult.RemoveResultsExcept(PluginManager.NonGlobalPlugins[keyword].Metadata);
}
}
_lastQuery = query;
Dispatcher.DelayInvoke("ShowProgressbar", () =>
{
if (!string.IsNullOrEmpty(query.RawQuery) && query.RawQuery == _lastQuery.RawQuery && !_queryHasReturn)
{
StartProgress();
}
}, TimeSpan.FromMilliseconds(150));
PluginManager.QueryForAllPlugins(query);
}
StopProgress();
@ -719,10 +741,11 @@ namespace Wox
{
if (history != null)
{
var historyMetadata = QueryHistoryStorage.MetaData;
ChangeQueryText(history.Query, true);
pnlResult.Dirty = true;
var executeQueryHistoryTitle = GetTranslation("executeQuery");
var lastExecuteTime = GetTranslation("lastExecuteTime");
pnlResult.RemoveResultsExcept(historyMetadata);
UpdateResultViewInternal(new List<Result>()
{
new Result(){
@ -735,7 +758,7 @@ namespace Wox
return false;
}
}
});
}, historyMetadata);
}
}
@ -816,28 +839,27 @@ namespace Wox
}
}
private void UpdateResultView(List<Result> list)
private void UpdateResultView(List<Result> list, PluginMetadata metadata, Query originQuery)
{
queryHasReturn = true;
_queryHasReturn = true;
progressBar.Dispatcher.Invoke(new Action(StopProgress));
if (list == null || list.Count == 0) return;
if (list.Count > 0)
list.ForEach(o =>
{
list.ForEach(o =>
{
o.Score += UserSelectedRecordStorage.Instance.GetSelectedCount(o) * 5;
});
List<Result> l = list.Where(o => o.OriginQuery != null && o.OriginQuery.RawQuery == lastQuery).ToList();
UpdateResultViewInternal(l);
o.Score += UserSelectedRecordStorage.Instance.GetSelectedCount(o) * 5;
});
if (originQuery.RawQuery == _lastQuery.RawQuery)
{
UpdateResultViewInternal(list, metadata);
}
}
private void UpdateResultViewInternal(List<Result> list)
private void UpdateResultViewInternal(List<Result> list, PluginMetadata metadata)
{
Dispatcher.Invoke(new Action(() =>
{
pnlResult.AddResults(list);
Stopwatch.Normal($"UI update cost for {metadata.Name}",
() => { pnlResult.AddResults(list, metadata.ID); });
}));
}
@ -886,7 +908,7 @@ namespace Wox
textBeforeEnterContextMenuMode = tbQuery.Text;
ChangeQueryText("");
pnlContextMenu.Clear();
pnlContextMenu.AddResults(results);
pnlContextMenu.AddResults(results, result.PluginID);
CurrentContextMenus = results;
pnlContextMenu.Visibility = Visibility.Visible;
pnlResult.Visibility = Visibility.Collapsed;

26
Wox/Properties/Resources.Designer.cs generated
View File

@ -1,10 +1,10 @@
//------------------------------------------------------------------------------
// <auto-generated>
// 此代码由工具生成。
// 运行时版本:4.0.30319.0
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
//
// 对此文件的更改可能会导致不正确的行为，并且如果
// 重新生成代码，这些更改将会丢失。
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
@ -13,12 +13,12 @@ namespace Wox.Properties {
/// <summary>
/// 一个强类型的资源类，用于查找本地化的字符串等。
/// A strongly-typed resource class, for looking up localized strings, etc.
/// </summary>
// 此类是由 StronglyTypedResourceBuilder
// 类通过类似于 ResGen 或 Visual Studio 的工具自动生成的。
// 若要添加或移除成员，请编辑 .ResX 文件，然后重新运行 ResGen
// (以 /str 作为命令选项)，或重新生成 VS 项目。
// This class was auto-generated by the StronglyTypedResourceBuilder
// class via a tool like ResGen or Visual Studio.
// To add or remove a member, edit your .ResX file then rerun ResGen
// with the /str option, or rebuild your VS project.
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
@ -33,7 +33,7 @@ namespace Wox.Properties {
}
/// <summary>
/// 返回此类使用的缓存的 ResourceManager 实例。
/// Returns the cached ResourceManager instance used by this class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Resources.ResourceManager ResourceManager {
@ -47,8 +47,8 @@ namespace Wox.Properties {
}
/// <summary>
/// 使用此强类型资源类，为所有资源查找
/// 重写当前线程的 CurrentUICulture 属性。
/// Overrides the current thread's CurrentUICulture property for all
/// resource lookups using this strongly typed resource class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Globalization.CultureInfo Culture {
@ -61,7 +61,7 @@ namespace Wox.Properties {
}
/// <summary>
/// 查找类似于 (Icon) 的 System.Drawing.Icon 类型的本地化资源。
/// Looks up a localized resource of type System.Drawing.Icon similar to (Icon).
/// </summary>
internal static System.Drawing.Icon app {
get {

10
Wox/Properties/Settings.Designer.cs generated
View File

@ -1,10 +1,10 @@
//------------------------------------------------------------------------------
// <auto-generated>
// 此代码由工具生成。
// 运行时版本:4.0.30319.0
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
//
// 对此文件的更改可能会导致不正确的行为，并且如果
// 重新生成代码，这些更改将会丢失。
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
@ -12,7 +12,7 @@ namespace Wox.Properties {
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "12.0.0.0")]
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "14.0.0.0")]
internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));

121
Wox/ResultPanel.xaml.cs
View File

@ -1,20 +1,29 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using System.Linq;
using System.Runtime.Remoting.Contexts;
using Wox.Core.UserSettings;
using Wox.Helper;
using Wox.Plugin;
using Wox.Storage;
namespace Wox
{
[Synchronization]
public partial class ResultPanel : UserControl
{
public event Action<Result> LeftMouseClickEvent;
public event Action<Result> RightMouseClickEvent;
public event Action<Result, IDataObject, DragEventArgs> ItemDropEvent;
private readonly ListBoxItems _results;
private readonly object _resultsUpdateLock = new object();
protected virtual void OnRightMouseClick(Result result)
{
@ -28,36 +37,78 @@ namespace Wox
if (handler != null) handler(result);
}
public bool Dirty { get; set; }
public int MaxResultsToShow { get { return UserSettingStorage.Instance.MaxResultsToShow * 50; } }
public void AddResults(List<Result> results)
internal void RemoveResultsFor(PluginMetadata metadata)
{
if (Dirty)
lock (_resultsUpdateLock)
{
Dirty = false;
lbResults.Items.Clear();
_results.RemoveAll(r => r.PluginID == metadata.ID);
}
foreach (var result in results)
}
internal void RemoveResultsExcept(PluginMetadata metadata)
{
lock (_resultsUpdateLock)
{
int position = 0;
if (IsTopMostResult(result))
_results.RemoveAll(r => r.PluginID != metadata.ID);
}
}
public void AddResults(List<Result> newResults, string resultId)
{
lock (_resultsUpdateLock)
{
var resultCopy = _results.ToList();
var oldResults = resultCopy.Where(r => r.PluginID == resultId).ToList();
// intersection of A (old results) and B (new newResults)
var intersection = oldResults.Intersect(newResults).ToList();
// remove result of relative complement of B in A
foreach (var result in oldResults.Except(intersection))
{
result.Score = int.MaxValue;
resultCopy.Remove(result);
}
else
// update scores
foreach (var result in newResults)
{
if (result.Score >= int.MaxValue)
if (IsTopMostResult(result))
{
result.Score = int.MaxValue - 1;
result.Score = int.MaxValue;
}
position = GetInsertLocation(result.Score);
}
lbResults.Items.Insert(position, result);
// update index for result in intersection of A and B
foreach (var result in intersection)
{
int oldIndex = resultCopy.IndexOf(result);
int oldScore = resultCopy[oldIndex].Score;
if (result.Score != oldScore)
{
int newIndex = InsertIndexOf(result.Score, resultCopy);
if (newIndex != oldIndex)
{
var item = resultCopy[oldIndex];
resultCopy.RemoveAt(oldIndex);
resultCopy.Insert(newIndex, item);
}
}
}
// insert result in relative complement of A in B
foreach (var result in newResults.Except(intersection))
{
int newIndex = InsertIndexOf(result.Score, resultCopy);
resultCopy.Insert(newIndex, result);
}
// update UI in one run, so it can avoid UI flickering
_results.Update(resultCopy);
lbResults.Margin = lbResults.Items.Count > 0 ? new Thickness { Top = 8 } : new Thickness { Top = 0 };
SelectFirst();
}
lbResults.Margin = lbResults.Items.Count > 0 ? new Thickness { Top = 8 } : new Thickness { Top = 0 };
SelectFirst();
}
private bool IsTopMostResult(Result result)
@ -65,33 +116,18 @@ namespace Wox
return TopMostRecordStorage.Instance.IsTopMost(result);
}
private int GetInsertLocation(int currentScore)
private int InsertIndexOf(int newScore, IList<Result> list)
{
int location = lbResults.Items.Count;
if (lbResults.Items.Count == 0) return 0;
if (currentScore > ((Result)lbResults.Items[0]).Score) return 0;
for (int index = 1; index < lbResults.Items.Count; index++)
int index = 0;
for (; index < list.Count; index++)
{
Result next = lbResults.Items[index] as Result;
Result prev = lbResults.Items[index - 1] as Result;
if (next != null && prev != null)
var result = list[index];
if (newScore > result.Score)
{
if ((currentScore >= next.Score && currentScore <= prev.Score))
{
if (currentScore == next.Score)
{
location = index + 1;
}
else
{
location = index;
}
}
break;
}
}
return location;
return index;
}
public void SelectNext()
@ -211,12 +247,17 @@ namespace Wox
public ResultPanel()
{
InitializeComponent();
_results = new ListBoxItems();
lbResults.ItemsSource = _results;
}
public void Clear()
{
lbResults.Items.Clear();
lbResults.Margin = new Thickness { Top = 0 };
lock (_resultsUpdateLock)
{
_results.Clear();
lbResults.Margin = new Thickness { Top = 0 };
}
}
private void lbResults_SelectionChanged(object sender, SelectionChangedEventArgs e)

99
Wox/SettingWindow.xaml.cs
View File

@ -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
@ -429,7 +412,7 @@ namespace Wox
IcoPath = "Images/app.png",
PluginDirectory = Path.GetDirectoryName(Application.ExecutablePath)
}
});
}, "test id");
foreach (string theme in ThemeManager.Theme.LoadAvailableThemes())
{
@ -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;
if (pair != null)
List<string> actionKeywords = 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;
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 (pair.Metadata.ActionKeywords.Count > 0)
{
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);
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, 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;
if (!featureControls.TryGetValue(provider, out control))
featureControls.Add(provider, control = provider.CreateSettingPanel());
Control control;
if (!featureControls.TryGetValue(settingProvider, out control))
{
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;

6
Wox/Storage/QueryHistoryStorage.cs
View File

@ -5,6 +5,7 @@ using System.Linq;
using System.Reflection;
using Newtonsoft.Json;
using Wox.Infrastructure.Storage;
using Wox.Plugin;
namespace Wox.Storage
{
@ -16,6 +17,9 @@ namespace Wox.Storage
private int MaxHistory = 300;
private int cursor = 0;
public static PluginMetadata MetaData { get; } = new PluginMetadata
{ ID = "Query history", Name = "Query history" };
protected override string ConfigFolder
{
get { return Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Config"); }
@ -77,7 +81,7 @@ namespace Wox.Storage
return History.OrderByDescending(o => o.ExecutedDateTime).ToList();
}
}
public class HistoryItem
{
public string Query { get; set; }

8
Wox/Wox.csproj
View File

@ -106,6 +106,7 @@
<Compile Include="Converters\OpacityModeConverter.cs" />
<Compile Include="Converters\StringEmptyConverter.cs" />
<Compile Include="Converters\StringNullOrEmptyToVisibilityConverter.cs" />
<Compile Include="Helper\ListBoxItems.cs" />
<Compile Include="Helper\SingletonWindowOpener.cs" />
<Compile Include="ImageLoader\ImageCacheStroage.cs" />
<Compile Include="ShellContext\ShellContextMenuManager.cs" />
@ -280,7 +281,9 @@
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>Resources.Designer.cs</LastGenOutput>
</EmbeddedResource>
<None Include="App.config" />
<None Include="App.config">
<SubType>Designer</SubType>
</None>
<None Include="Properties\Settings.settings">
<Generator>SettingsSingleFileGenerator</Generator>
<LastGenOutput>Settings.Designer.cs</LastGenOutput>
@ -305,9 +308,6 @@
<Name>Wox.Plugin</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<WCFMetadata Include="Service References\" />
</ItemGroup>
<ItemGroup>
<Service Include="{508349B6-6B84-4DF5-91F0-309BEEBAD82D}" />
</ItemGroup>