public void OnCommand(EnsoCommand command, String postfix)
{
Match m = boundsParser.Match(postfix);
int from = 0;
String s_from = m.Groups[1].Value;
try
{
if (!"".Equals(s_from.Trim()))
from = Convert.ToInt32(s_from);
}
catch (Exception)
{
service.DisplayMessage(new EnsoMessage(INVALID_BOUNDS_ERROR));
}
int to = int.MaxValue;
String s_to = m.Groups[2].Value;
try
{
if (!"".Equals(s_to.Trim()))
to = Convert.ToInt32(s_to);
}
catch (Exception)
{
service.DisplayMessage(new EnsoMessage(INVALID_BOUNDS_ERROR));
}
int result = random.Next(from, to);
service.InsertUnicodeAtCursor(result.ToString(), command);
}
public LingvoExtension()
{
translateCommand = new EnsoCommand(COMMAND_NAME, COMMAND_POSTFIX,
COMMAND_DESC, COMMAND_HELP, EnsoPostfixType.Arbitrary);
quitCommand = new EnsoCommand(QUIT_NAME, null, QUIT_DESC,
QUIT_DESC, EnsoPostfixType.None);
}
private static void PrepareHelp(EnsoCommand command)
{
if (string.IsNullOrEmpty(command.Help))
{
command.Help = command.Description.Replace("&", "_").Replace(@"/", "_").Replace(@"\", "_").Replace(@"#", "_").Replace(@"<", "_").Replace(@">", "_");
}
if (string.IsNullOrEmpty(command.Help))
{
command.Help = "No help specified.";
}
}
public void OnCommand(EnsoCommand command, string postfix)
{
Guid guid = Guid.NewGuid();
String result;
if (POSTFIX_NUMERIC.Equals(postfix))
result = guid.ToString("N").ToUpper();
else
result = POSTFIX_LOWER.Equals(postfix)
? guid.ToString()
: guid.ToString().ToUpper();
service.InsertUnicodeAtCursor(result, command);
}
private static void OnClose(EnsoCommand c, string postfix, IntPtr fw)
{
Program.extensionPlus.OnCommand(c, postfix, fw);
}
public RandomExtension()
{
command = new EnsoCommand(COMMAND_NAME, COMMAND_POSTFIX,
COMMAND_DESC, COMMAND_DESC, EnsoPostfixType.Arbitrary);
}
public void OnCommand(EnsoCommand ensoCommand, string postfix, IntPtr foregroundWindowForGrab)
{
Logging.AddDebugLog("OnCommand:" + ensoCommand.Name + " postfix:" + postfix + "------------------------------------------------------------------------------------------------");
try
{
//SelectionListener.Listener.Current.IfOpenedPause();
MergedCommand mergedCommand = this.mergedCommands[ensoCommand.Name];
//if none of potentially chosen commands use selection skip expensive operations:
// this.service.GetFileSelection() and/or this.service.GetUnicodeSelection();
bool skipGetUnicodeSelection = true;
bool skipGetFileSelection = true;
foreach (var sourceCommand in mergedCommand.sourceCommands)
{
if (sourceCommand.canUseTextSelectionForParameter)
{
skipGetUnicodeSelection = false;
}
if (sourceCommand.canUseFileSelectionForParameter)
{
skipGetFileSelection = false;
}
if (!skipGetUnicodeSelection && !skipGetFileSelection)
{
break;
}
}
Logging.AddDebugLog("OnCommand: skipGetUnicodeSelection=" + skipGetUnicodeSelection + " skipGetFilesSelection=" + skipGetFileSelection);
//do we need file selection?
if ((ensoCommand.Name == "topen" || ensoCommand.Name == "rtopen" || ensoCommand.Name == "empty"))
{
try
{
if (CraftSynth.BuildingBlocks.WindowsNT.Misc.GetForegroundWindowCaption().Contains("Total Commander"))
{
skipGetFileSelection = true;
}
}
catch
{
}
}
//read selection
ClipboardData selectedData = null;
if (!skipGetUnicodeSelection || !skipGetFileSelection)
{
selectedData = HandlerForSelection.Get(foregroundWindowForGrab);
}
Logging.AddDebugLog("OnCommand: first 100 chars of HandlerForSelection.Get=" + (selectedData == null?"null":selectedData.AsUnicodeText).FirstXChars(100, "..."));
//Get text selection if needed
string selectedText = null;
if (!skipGetUnicodeSelection && selectedData != null)
{
selectedText = selectedData.AsUnicodeText;
}
Logging.AddDebugLog("OnCommand: first 100 chars of selectedText=" + (selectedText ?? "null").FirstXChars(100, "..."));
//Get file selection if needed
string[] fileSelectionArray = null;
if (!skipGetFileSelection &&
!skipGetUnicodeSelection && string.IsNullOrEmpty(selectedText) && selectedData != null)
{
var ffl = selectedData.AsFileFolderList;
if (ffl == null)
{
fileSelectionArray = null;
}
else
{
fileSelectionArray = ffl.ToArray();
}
; //ex: this.service.GetFileSelection();
}
else
{
fileSelectionArray = new string[] { };
}
Logging.AddDebugLog("OnCommand: first 100 chars of fileSelectionArray=" + (fileSelectionArray == null? "null": Syntax.FileSelectionArrayToString(fileSelectionArray)).FirstXChars(100, "..."));
if (fileSelectionArray != null && fileSelectionArray.Length > 0 && string.IsNullOrEmpty(selectedText))
{
selectedText = Syntax.FileSelectionArrayToString(fileSelectionArray);
}
Command bestCandidateForUsedCommand = null;
bool bestCandidateForUsedCommandRequiresParameterInput = false;
foreach (Command sourceCommand in mergedCommand.sourceCommands)
{
Logging.AddDebugLog("OnCommand: Syntax.ExtractParameterValues...");
int parameterCountInSyntax = 0;
List <string> parametersFromInlineCommand = Syntax.ExtractParameterValues(sourceCommand.Postfix, postfix, (GetSelectionForCommand(selectedText, sourceCommand)), mergedCommand.sourceCommands.Count == 1, out parameterCountInSyntax);
Logging.AddDebugLog("OnCommand: parametersFromInlineCommand=" + (parametersFromInlineCommand == null?"null":parametersFromInlineCommand.ToCSV()));
if (parametersFromInlineCommand == null)
{
continue;
}
//replace jockers - should be refactored
Logging.AddDebugLog("OnCommand: replace jockers...");
int i = parametersFromInlineCommand.Count - 1;
while (i >= 0)
{
if (parametersFromInlineCommand[i] == Syntax.lastMessageInPostfix)
{
parametersFromInlineCommand[i] = MessagesHandler.GetLastFromHistory().Text;
}
else if (parametersFromInlineCommand[i] == Syntax.selectionInPostfix1 || parametersFromInlineCommand[i] == Syntax.selectionInPostfix2)
{
parametersFromInlineCommand.RemoveAt(i);
}
i--;
}
Logging.AddDebugLog("OnCommand: Determine best candidate...");
if ((GetSelectionForCommand(selectedText, sourceCommand) == string.Empty && parametersFromInlineCommand.Count == parameterCountInSyntax) ||
(parameterCountInSyntax == 0 && sourceCommand.Postfix == " ") ||
(GetSelectionForCommand(selectedText, sourceCommand) != string.Empty && parametersFromInlineCommand.Count == parameterCountInSyntax && GetSelectionForCommand(selectedText, sourceCommand).CompareTo(parametersFromInlineCommand[parametersFromInlineCommand.Count - 1]) == 0))
{
bestCandidateForUsedCommand = sourceCommand.GetClone();
bestCandidateForUsedCommand.parametersOnExecute = StringWorkItem.CreateInstances(parametersFromInlineCommand);
bestCandidateForUsedCommandRequiresParameterInput = false;
Logging.AddDebugLog("OnCommand: bc=a");
break;
}
else if (GetSelectionForCommand(selectedText, sourceCommand) != string.Empty && parametersFromInlineCommand.Count == parameterCountInSyntax && GetSelectionForCommand(selectedText, sourceCommand).CompareTo(parametersFromInlineCommand[parametersFromInlineCommand.Count - 1]) != 0)
{
bestCandidateForUsedCommand = sourceCommand.GetClone();
bestCandidateForUsedCommand.parametersOnExecute = StringWorkItem.CreateInstances(parametersFromInlineCommand);
bestCandidateForUsedCommandRequiresParameterInput = false;
Logging.AddDebugLog("OnCommand: bc=b");
}
else if (parametersFromInlineCommand.Count == (parameterCountInSyntax - 1))
{
bestCandidateForUsedCommand = sourceCommand.GetClone();
bestCandidateForUsedCommand.parametersOnExecute = StringWorkItem.CreateInstances(parametersFromInlineCommand);
bestCandidateForUsedCommandRequiresParameterInput = true;
Logging.AddDebugLog("OnCommand: bc=c");
}
}
if (bestCandidateForUsedCommand == null)
{
Logging.AddDebugLog("OnCommand: postfix Invalid!");
MessagesHandler.Display("Postfix invalid!", ensoCommand.Name + " " + ensoCommand.Postfix);
}
else
{
Logging.AddDebugLog("OnCommand: bestCandidateForUsedCommand=" + bestCandidateForUsedCommand.Name);
Logging.AddDebugLog("OnCommand: replace 'last' parameter with last used parameter/WorkItem");
//replace 'last' parameter with last used parameter/WorkItem
int j = 0;
while (j < bestCandidateForUsedCommand.parametersOnExecute.Count)
{
Logging.AddDebugLog("OnCommand: first 100 chars of paramsOnExecute[" + j + "]=" + (bestCandidateForUsedCommand.parametersOnExecute[j].GetValueAsText().FirstXChars(100, "...")));
if (bestCandidateForUsedCommand.parametersOnExecute[j].GetValueAsText() == Syntax.lastParameterInPostfix)
{
bestCandidateForUsedCommand.parametersOnExecute[j] = WorkItemsProviders.CommandsHistory.CommandsHistory.GetLastWorkItem();
Logging.AddDebugLog("OnCommand: first 100 chars of paramsOnExecute[" + j + "]=" + bestCandidateForUsedCommand.parametersOnExecute[j].GetValueAsText().FirstXChars(100, "..."));
}
j++;
}
if (bestCandidateForUsedCommand.parameterInputArguments.acceptOnlySuggested && !bestCandidateForUsedCommandRequiresParameterInput && bestCandidateForUsedCommand.parametersOnExecute.Count > 0)
{//user entered all parameters and command uses cloased parameter group
Logging.AddDebugLog("OnCommand: user entered all parameters and command uses cloased parameter group");
Dictionary <string, IWorkItem> suggestions = GetAvailableSuggestions(bestCandidateForUsedCommand);
IWorkItem selectedSuggestion = null;
if (suggestions.TryGetValue(bestCandidateForUsedCommand.parametersOnExecute[bestCandidateForUsedCommand.parametersOnExecute.Count - 1].GetCaption(), out selectedSuggestion))
{//user-entered parameter does not exist in group - add it to list
Logging.AddDebugLog("OnCommand: user-entered parameter does not exist in group - add it to list");
IWorkItem postProcessedSuggestion = PostProcessSelectedSuggestion(selectedSuggestion);
if (postProcessedSuggestion == null)
{//user probably canceled command - abort command
Logging.AddDebugLog("OnCommand: user probably canceled command - abort command");
return;
}
bestCandidateForUsedCommand.parametersOnExecute[bestCandidateForUsedCommand.parametersOnExecute.Count - 1] = postProcessedSuggestion;
}
else
{//user-entered parameter does not exist in group - plan input parameter box
Logging.AddDebugLog("OnCommand: user-entered parameter does not exist in group - plan input parameter box");
if (bestCandidateForUsedCommand.parameterInputArguments.acceptOnlySuggested)
{
bestCandidateForUsedCommand.parameterInputArguments.predefinedValue = string.Empty;
}
else
{
bestCandidateForUsedCommand.parameterInputArguments.predefinedValue = bestCandidateForUsedCommand.parametersOnExecute[bestCandidateForUsedCommand.parametersOnExecute.Count - 1].GetCaption();
}
bestCandidateForUsedCommand.parametersOnExecute.RemoveAt(bestCandidateForUsedCommand.parametersOnExecute.Count - 1);
bestCandidateForUsedCommandRequiresParameterInput = true;
}
}
if (!bestCandidateForUsedCommandRequiresParameterInput)
{
Logging.AddDebugLog("OnCommand: bestCandidateForUsedCommandRequiresParameterInput==false");
Logging.AddDebugLog("OnCommand: ExecuteCommandCandidate...");
ExecuteCommandCandidate(bestCandidateForUsedCommand);
}
else
{
Logging.AddDebugLog("OnCommand: ProcessingBeforeParameterInput...");
bool cancel = false;
bestCandidateForUsedCommand.provider.ProcessingBeforeParameterInput(bestCandidateForUsedCommand, ref cancel);
Logging.AddDebugLog("OnCommand: ProcessingBeforeParameterInput done. cancel=" + cancel);
if (cancel)
{
return;
}
Logging.AddDebugLog("OnCommand: GetAvailableSuggestions...");
Dictionary <string, IWorkItem> suggestions = GetAvailableSuggestions(bestCandidateForUsedCommand);
//prepare parameters to suggestions
bestCandidateForUsedCommand.parameterInputArguments.suggestions = new List <string>();
foreach (var suggestion in suggestions)
{
bestCandidateForUsedCommand.parameterInputArguments.suggestions.Add(suggestion.Key);
}
//execute dropbox
Logging.AddDebugLog("OnCommand: execute dropbox...");
try
{
PostParameterInputArguments contextData = new PostParameterInputArguments();
contextData.suggestions = suggestions;
contextData.bestCandidateForUsedCommand = bestCandidateForUsedCommand;
contextData.bestCandidateForUsedCommandRequiresParameterInput = bestCandidateForUsedCommandRequiresParameterInput;
ParameterInput.Display(bestCandidateForUsedCommand.parameterInputArguments, ParameterInput_OnClose, contextData, Screen.FromPoint(Cursor.Position));
}
catch (Exception exception)
{
MessagesHandler.Display("Error", exception.Message);
Logging.AddErrorLog("Parameter input failed: " + exception.Message + ((exception.InnerException != null) ? ":" + exception.InnerException.Message : ""));
Common.Logging.AddExceptionLog(exception);
}
}
}
}
catch (Exception exception)
{
Logging.AddErrorLog("Command execution failed: " + exception.Message + ((exception.InnerException != null) ? ":" + exception.InnerException.Message : ""));
Logging.AddExceptionLog(exception);
throw exception;
}
//SelectionListener.Listener.Current.IfOpenedContinue();
}
public void OnCommand(EnsoCommand command, string postfix)
{
Action action = commandActions[command.Name];
if (action != null)
new Thread(new ThreadStart(action)).Start();
}
public void OnCommand(EnsoCommand command, string postfix)
{
CommandDesc desc = commandActions[command.Name];
new Thread(() => desc.action(postfix, service)).Start();
}
public void OnCommand(EnsoCommand command, String postfix)
{
Action<String, IEnsoService> action = commandActions[command.Name];
if (action != null)
new Thread(() => action(postfix, service)).Start();
}
public GUIDExtension()
{
command = new EnsoCommand(COMMAND_NAME, COMMAND_POSTFIX,
COMMAND_DESC, COMMAND_DESC, EnsoPostfixType.Bounded);
}
void IEnsoService.UnregisterCommand(EnsoCommand command)
{
if (disposed)
throw new ObjectDisposedException(GetType().Name);
if (command == null)
throw new ArgumentNullException("command");
IDictionary<EnsoCommand, EnsoExtensionProxy> commands = this.commands;
if (commands == null)
throw new ObjectDisposedException(GetType().Name);
lock (this)
{
EnsoExtensionProxy extensionProxy;
if (!commands.TryGetValue(command, out extensionProxy))
throw new EnsoException("Command not registered.");
try
{
ensoProxy.UnregisterCommand(GetUrlForUri(extensionProxy.Uri), command.ToString());
}
catch (Exception e)
{
throw new EnsoException("UnregisterCommand failed", e);
}
commands.Remove(command);
extensionProxy.Commands.Remove(command.ToString());
if (extensionProxy.Commands.Count == 0)
extensions.Remove(extensionProxy.Uri);
}
}
void IEnsoService.SetUnicodeSelection(string text, EnsoCommand fromCommand)
{
if (disposed)
throw new ObjectDisposedException(GetType().Name);
if (text == null)
throw new ArgumentNullException("text");
if (fromCommand == null)
throw new ArgumentNullException("fromCommand");
try
{
ensoProxy.SetUnicodeSelection(text, fromCommand.ToString());
}
catch (Exception e)
{
throw new EnsoException("SetUnicodeSelection failed", e);
}
}
void IEnsoService.SetCommandValidPostfixes(EnsoCommand command, string[] postfixes)
{
if (disposed)
throw new ObjectDisposedException(GetType().Name);
if (command == null)
throw new ArgumentNullException("command");
if (postfixes == null)
throw new ArgumentNullException("postfixes");
IDictionary<EnsoCommand, EnsoExtensionProxy> commands = this.commands;
if (commands == null)
throw new ObjectDisposedException(GetType().Name);
EnsoExtensionProxy extensionProxy;
if (!commands.TryGetValue(command, out extensionProxy))
throw new EnsoException("Command not registered.");
try
{
ensoProxy.SetCommandValidPostfixes(GetUrlForUri(extensionProxy.Uri), command.ToString(), postfixes);
}
catch (Exception e)
{
throw new EnsoException("SetCommandValidPostfixes failed", e);
}
}
void IEnsoService.RegisterCommand(IEnsoExtension extension, string uri, EnsoCommand command)
{
if (disposed)
throw new ObjectDisposedException(GetType().Name);
if (extension == null)
throw new ArgumentNullException("extension");
if (command == null)
throw new ArgumentNullException("command");
IDictionary<string, EnsoExtensionProxy> extensions = this.extensions;
IDictionary<EnsoCommand, EnsoExtensionProxy> commands = this.commands;
if (extensions == null || commands == null)
throw new ObjectDisposedException(GetType().Name);
lock (this)
{
EnsoExtensionProxy extensionProxy;
if (!extensions.TryGetValue(uri, out extensionProxy))
{
extensionProxy = new EnsoExtensionProxy(extension, uri);
RemotingServices.Marshal(extensionProxy, uri, typeof(EnsoExtensionProxy));
extensions.Add(uri, extensionProxy);
}
else if (extensionProxy.Extension != extension)
throw new EnsoException("Invalid uri.");
try
{
ensoProxy.RegisterCommand(GetUrlForUri(uri), command.ToString(),
command.Description, command.Help, postfixTypes[(int)command.PostfixType]);
}
catch (Exception e)
{
throw new EnsoException("RegisterCommand failed", e);
}
commands.Add(command, extensionProxy);
extensionProxy.Commands.Add(command.ToString(), command);
}
}
