protected override void CreateEventHandlerInternal(Type eventHandlerType, string handlerName)
{
IClass c = GetDesignedClass();
if (c != null)
{
foreach (IMethod m in c.Methods)
{
if (m.Name == handlerName)
{
FileService.JumpToFilePosition(m.DeclaringType.CompilationUnit.FileName,
m.Region.BeginLine, m.Region.BeginColumn);
return;
}
}
}
c = GetDesignedClassCodeBehindPart(c);
if (c != null)
{
ITextEditorProvider tecp = FileService.OpenFile(c.CompilationUnit.FileName) as ITextEditorProvider;
if (tecp != null)
{
int lineNumber;
FormsDesigner.CSharpDesignerGenerator.CreateComponentEvent(
c, tecp.TextEditor, eventHandlerType, handlerName, null,
out lineNumber);
tecp.TextEditor.JumpTo(lineNumber, 0);
}
}
}
public override void Run()
{
SortOptionsDialog dlg = new SortOptionsDialog();
dlg.Owner = WorkbenchSingleton.MainWindow;
if (dlg.ShowDialog() == true)
{
StringComparer comparer = SortOptions.CaseSensitive ? StringComparer.CurrentCulture : StringComparer.CurrentCultureIgnoreCase;
if (SortOptions.IgnoreTrailingWhitespaces)
{
comparer = new IgnoreTrailingWhitespaceComparer(comparer);
}
if (SortOptions.SortDirection == SortDirection.Descending)
{
comparer = new DescendingStringComparer(comparer);
}
ITextEditorProvider provider = WorkbenchSingleton.Workbench.ActiveViewContent as ITextEditorProvider;
if (provider != null)
{
ITextEditor editor = provider.TextEditor;
if (editor.SelectionLength > 0)
{
int start = editor.Document.GetLineForOffset(editor.SelectionStart).LineNumber;
int end = editor.Document.GetLineForOffset(editor.SelectionStart + editor.SelectionLength).LineNumber;
SortLines(editor.Document, start, end, comparer, SortOptions.RemoveDuplicates);
}
else
{
SortLines(editor.Document, 1, editor.Document.TotalNumberOfLines, comparer, SortOptions.RemoveDuplicates);
}
}
}
}
public override void Run()
{
ITextEditorProvider provider = WorkbenchSingleton.Workbench.ActiveViewContent as ITextEditorProvider;
WindowsDebugger winDebugger = DebuggerService.CurrentDebugger as WindowsDebugger;
if (provider == null || winDebugger == null)
{
return;
}
ITextEditor textEditor = provider.TextEditor;
Breakpoint breakpoint = winDebugger.DebuggerCore.Breakpoints.Add(textEditor.FileName, null, textEditor.Caret.Line, textEditor.Caret.Column, true);
// Be careful to remove the breakpoint just once
breakpoint.Hit += delegate {
if (breakpoint != null)
{
breakpoint.Remove();
}
breakpoint = null;
};
winDebugger.DebuggedProcess.Paused += delegate {
if (breakpoint != null)
{
breakpoint.Remove();
}
breakpoint = null;
};
if (!winDebugger.IsProcessRunning)
{
winDebugger.Continue();
}
}
public bool CanAttachTo(IViewContent content)
{
ITextEditorProvider p = content as ITextEditorProvider;
if (p != null)
{
try {
using (XmlTextReader r = new XmlTextReader(p.TextEditor.Document.CreateReader())) {
r.XmlResolver = null;
// find the opening of the root element:
while (r.Read() && r.NodeType != XmlNodeType.Element)
{
;
}
// attach if this is a workflow node
return(r.NamespaceURI == "http://schemas.microsoft.com/netfx/2009/xaml/activities");
}
} catch (XmlException e) {
LoggingService.Debug("WorkflowDisplayBinding got exception: " + e.Message);
return(false);
}
}
else
{
return(false);
}
}
void WorkbenchActiveContentChanged(object sender, EventArgs e)
{
IViewContent view = WorkbenchSingleton.Workbench.ActiveViewContent;
if (view != null)
{
IOutlineContentHost content = view.GetService(typeof(IOutlineContentHost)) as IOutlineContentHost;
if (content != null)
{
contentControl.SetContent(content.OutlineContent, content);
return;
}
}
ITextEditorProvider provider = WorkbenchSingleton.Workbench.ActiveViewContent as ITextEditorProvider;
if (provider != null)
{
IOutlineContentHost content = provider.TextEditor.GetService(typeof(IOutlineContentHost)) as IOutlineContentHost;
if (content != null)
{
contentControl.SetContent(content.OutlineContent, content);
return;
}
}
contentControl.SetContent(StringParser.Parse("${res:MainWindow.Windows.OutlinePad.NoContentAvailable}"));
}
public ToolStripItem[] BuildSubmenu(Codon codon, object owner)
{
List <ToolStripItem> items = new List <ToolStripItem>();
ITextEditorProvider provider = WorkbenchSingleton.Workbench.ActiveWorkbenchWindow.ActiveViewContent as ITextEditorProvider;
BreakpointBookmark point = null;
foreach (BreakpointBookmark breakpoint in DebuggerService.Breakpoints)
{
if ((breakpoint.FileName == provider.TextEditor.FileName) &&
(breakpoint.LineNumber == provider.TextEditor.Caret.Line))
{
point = breakpoint;
break;
}
}
if (point != null)
{
foreach (string item in BreakpointAction.GetNames(typeof(BreakpointAction)))
{
items.Add(MakeItem("${res:MainWindow.Windows.Debug.Conditional.Breakpoints." + item + "}", item, point, point.Action.ToString(), delegate(object sender, EventArgs e) { HandleItem(sender); }));
}
}
return(items.ToArray());
}
public static bool ReplaceNextInSelection(IProgressMonitor monitor)
{
if (lastResult != null)
{
ITextEditorProvider provider = WorkbenchSingleton.Workbench.ActiveViewContent as ITextEditorProvider;
if (provider != null)
{
ITextEditor textarea = provider.TextEditor;
if (textarea.SelectionStart == lastResult.Offset &&
textarea.SelectionLength == lastResult.Length &&
lastResult.FileName == textarea.FileName)
{
string replacePattern = lastResult.TransformReplacePattern(SearchOptions.ReplacePattern);
using (textarea.Document.OpenUndoGroup()) {
textarea.Document.Replace(lastResult.Offset, lastResult.Length, replacePattern);
textarea.Select(lastResult.Offset + replacePattern.Length, 0); // clear selection and set caret position
}
textSelection.Length -= lastResult.Length - replacePattern.Length;
}
}
}
return(FindNextInSelection(monitor));
}
public bool IsValid(object caller, Condition condition)
{
if (WorkbenchSingleton.Workbench == null || WorkbenchSingleton.Workbench.ActiveWorkbenchWindow == null)
{
return(false);
}
ITextEditorProvider provider = WorkbenchSingleton.Workbench.ActiveWorkbenchWindow.ActiveViewContent as ITextEditorProvider;
if (provider == null)
{
return(false);
}
if (string.IsNullOrEmpty(provider.TextEditor.FileName))
{
return(false);
}
foreach (BreakpointBookmark mark in DebuggerService.Breakpoints)
{
if ((mark.FileName == provider.TextEditor.FileName) &&
(mark.LineNumber == provider.TextEditor.Caret.Line))
{
return(true);
}
}
return(false);
}
public override void Run()
{
PadDescriptor pad = WorkbenchSingleton.Workbench.GetPad(typeof(FSharpInteractive));
pad.BringPadToFront();
FSharpInteractive fsharpInteractive = (FSharpInteractive)pad.PadContent;
if (fsharpInteractive.foundCompiler)
{
ITextEditorProvider editorProvider = WorkbenchSingleton.Workbench.ActiveViewContent as ITextEditorProvider;
if (editorProvider != null)
{
var textEditor = editorProvider.TextEditor;
if (textEditor.SelectionLength > 0)
{
fsharpInteractive.fsiProcess.StandardInput.WriteLine(textEditor.SelectedText);
}
else
{
var line = textEditor.Document.GetLine(textEditor.Caret.Line);
fsharpInteractive.fsiProcess.StandardInput.WriteLine(line.Text);
}
fsharpInteractive.fsiProcess.StandardInput.WriteLine(";;");
}
}
}
public override void Run()
{
if (ParserService.LoadSolutionProjectsThreadRunning)
{
return;
}
if (WorkbenchSingleton.Workbench == null)
{
return;
}
ITextEditorProvider provider = WorkbenchSingleton.Workbench.ActiveViewContent as ITextEditorProvider;
if (provider == null)
{
return;
}
LanguageProperties language = ParserService.CurrentProjectContent.Language;
if (language == null)
{
return;
}
RefactoringProvider rp = language.RefactoringProvider;
Run(provider.TextEditor, rp);
}
public override void Run()
{
var viewContent = WorkbenchSingleton.Workbench.ActiveContent;
ITextEditorProvider provider = viewContent as ITextEditorProvider;
ITextEditor editor = null;
if (provider != null)
{
editor = provider.TextEditor;
if (!string.IsNullOrEmpty(editor.FileName))
{
DebuggerService.ToggleBreakpointAt(editor, editor.Caret.Line, typeof(BreakpointBookmark));
}
}
else
{
var view = viewContent as AbstractViewContentWithoutFile;
if (view != null)
{
editor = view.GetService(typeof(ITextEditor)) as ITextEditor;
if (editor != null)
{
DebuggerService.ToggleBreakpointAt(editor, editor.Caret.Line, typeof(DecompiledBreakpointBookmark));
}
}
}
}
void PinButton_Unchecked(object sender, RoutedEventArgs e)
{
ITextEditorProvider provider = WorkbenchSingleton.Workbench.ActiveViewContent as ITextEditorProvider;
var editor = provider.TextEditor;
if (editor == null)
{
return;
}
if (!string.IsNullOrEmpty(editor.FileName))
{
// remove from pinned DebuggerPopup
var pin = BookmarkManager.Bookmarks.Find(
b => b is PinBookmark &&
b.LineNumber == logicalPosition.Line &&
b.FileName == editor.FileName) as PinBookmark;
if (pin == null)
{
return;
}
ToggleButton button = (ToggleButton)e.OriginalSource;
pin.RemoveNode((ITreeNode)button.DataContext);
pin.Popup.ItemsSource = pin.Nodes;
// remove if no more data pins are available
if (pin.Nodes.Count == 0)
{
pin.Popup.Close();
BookmarkManager.RemoveMark(pin);
}
}
}
public override void Run()
{
if (WorkbenchSingleton.Workbench.ActiveViewContent == null)
{
return;
}
ITextEditorProvider provider = WorkbenchSingleton.Workbench.ActiveViewContent.GetService(typeof(ITextEditorProvider)) as ITextEditorProvider;
if (provider == null)
{
return;
}
OpenFileDialog dlg = new OpenFileDialog();
dlg.Filter = "Image files|*.png;*.jpg;*.gif;*.bmp;*.jpeg|All files|*.*";
dlg.CheckFileExists = true;
dlg.DereferenceLinks = true;
string baseDirectory = Path.GetDirectoryName(provider.TextEditor.FileName);
dlg.InitialDirectory = baseDirectory;
if (dlg.ShowDialog() == true)
{
string relativePath = FileUtility.GetRelativePath(baseDirectory, dlg.FileName);
if (!Path.IsPathRooted(relativePath))
{
relativePath = relativePath.Replace('\\', '/');
}
provider.TextEditor.Document.Insert(provider.TextEditor.Caret.Offset, "<<IMAGE:" + relativePath + ">>");
}
}
public bool CanAttachTo(IViewContent viewContent)
{
if (viewContent is ITextEditorProvider)
{
ITextEditorProvider textEditorProvider = (ITextEditorProvider)viewContent;
string fileExtension = String.Empty;
string fileName = viewContent.PrimaryFileName;
if (fileName == null)
{
return(false);
}
fileExtension = Path.GetExtension(fileName).ToLowerInvariant();
switch (fileExtension)
{
case ".cs":
case ".vb":
ParseInformation info = ParserService.ParseFile(fileName, textEditorProvider.TextEditor.Document);
if (IsDesignable(info))
{
return(true);
}
break;
}
}
return(false);
}
public static void Init()
{
if (init)
{
return;
}
init = true;
worker = new WorkerThread();
thread = new Thread(
delegate() {
LoggingService.Info("start background compiler");
worker.RunLoop();
}
);
thread.IsBackground = true;
thread.Name = "CSBackgroundCompiler";
ParserService.ParserUpdateStepFinished += delegate {
if (WorkbenchSingleton.Workbench.ActiveViewContent == null)
{
return;
}
if (ParserService.LoadSolutionProjectsThreadRunning)
{
return;
}
ITextEditorProvider provider = WorkbenchSingleton.Workbench.ActiveViewContent as ITextEditorProvider;
if (provider == null)
{
return;
}
ParseInformation parseInfo = ParserService.GetExistingParseInformation(provider.TextEditor.FileName);
if (parseInfo == null)
{
return;
}
string fileName = provider.TextEditor.FileName;
string fileContent = provider.TextEditor.Document.Text;
IProjectContent pc = parseInfo.CompilationUnit.ProjectContent;
if (currentWork == null)
{
thread.Start();
}
if (currentWork == null || currentWork.IsCompleted)
{
currentWork = worker.Enqueue(() => RunCompile(fileName, fileContent, pc));
}
};
}
System.Collections.ICollection IMenuItemBuilder.BuildItems(Codon codon, object owner)
{
ITextEditor editor = owner as ITextEditor;
if (editor == null)
{
ITextEditorProvider provider = owner as ITextEditorProvider;
if (provider == null)
{
return(EmptyControlArray);
}
editor = provider.TextEditor;
}
ResourceResolveResult result = ResourceResolverService.Resolve(editor, null);
if (result != null && result.ResourceFileContent != null && result.Key != null)
{
List <MenuItem> items = new List <MenuItem>();
MenuItem item = new MenuItem();
// add resource (if key does not exist) / edit resource (if key exists)
if (result.ResourceFileContent.ContainsKey(result.Key))
{
item.Header = MenuService.ConvertLabel(StringParser.Parse("${res:Hornung.ResourceToolkit.TextEditorContextMenu.EditResource}"));
}
else
{
item.Header = MenuService.ConvertLabel(StringParser.Parse("${res:Hornung.ResourceToolkit.TextEditorContextMenu.AddResource}"));
}
item.Click += this.EditResource;
item.Tag = result;
items.Add(item);
// find references
item = new MenuItem();
item.Header = MenuService.ConvertLabel(StringParser.Parse("${res:SharpDevelop.Refactoring.FindReferencesCommand}"));
item.Click += this.FindReferences;
item.Tag = result;
items.Add(item);
// rename
item = new MenuItem();
item.Header = MenuService.ConvertLabel(StringParser.Parse("${res:SharpDevelop.Refactoring.RenameCommand}"));
item.Click += this.Rename;
item.Tag = result;
items.Add(item);
// put the resource menu items into a submenu
// with the resource key as title
item = new MenuItem();
item.Header = result.Key;
item.ItemsSource = items;
return(new System.Windows.Controls.Control[] { item, new Separator() });
}
return(EmptyControlArray);
}
void Init(IViewContent view)
{
this.view = view;
editable = view as IEditable;
textEditorProvider = view as ITextEditorProvider;
textEditor = textEditorProvider.TextEditor;
textEditorOptions = textEditor.Options;
}
void Init(IViewContent view)
{
this.view = view;
editable = view as IEditable;
textEditorProvider = view as ITextEditorProvider;
textEditor = textEditorProvider.TextEditor;
textEditorOptions = textEditor.Options;
}
static void ShowCodeCoverage(IViewContent view)
{
ITextEditorProvider editorProvider = view as ITextEditorProvider;
if (editorProvider != null && view.PrimaryFileName != null)
{
ShowCodeCoverage(editorProvider.TextEditor, view.PrimaryFileName);
}
}
public static void SetPosition(IViewContent viewContent, int markerStartLine, int markerStartColumn, int markerEndLine, int markerEndColumn)
{
ITextEditorProvider tecp = viewContent as ITextEditorProvider;
if (tecp != null)
{
SetPosition(tecp.TextEditor.FileName, tecp.TextEditor.Document, markerStartLine, markerStartColumn, markerEndLine, markerEndColumn);
}
}
public override void Run()
{
ITextEditorProvider editorProvider = WorkbenchSingleton.Workbench.ActiveViewContent as ITextEditorProvider;
if (editorProvider != null)
{
Run(editorProvider.TextEditor, editorProvider.TextEditor.Caret.Offset);
}
}
public override void Run()
{
ITextEditorProvider provider = WorkbenchSingleton.Workbench.ActiveViewContent as ITextEditorProvider;
if (provider != null)
{
XmlView.FormatXml(provider.TextEditor);
}
}
ResolveResult ResolveAtCaret(ParserUpdateStepEventArgs e)
{
if (disableDefinitionView)
{
return(null);
}
IWorkbenchWindow window = WorkbenchSingleton.Workbench.ActiveWorkbenchWindow;
if (window == null)
{
return(null);
}
ITextEditorProvider provider = window.ActiveViewContent as ITextEditorProvider;
if (provider == null)
{
return(null);
}
ITextEditor editor = provider.TextEditor;
// e might be null when this is a manually triggered update
// don't resolve when an unrelated file was changed
if (e != null && editor.FileName != e.FileName)
{
return(null);
}
IExpressionFinder expressionFinder = ParserService.GetExpressionFinder(editor.FileName);
if (expressionFinder == null)
{
return(null);
}
ITextEditorCaret caret = editor.Caret;
string content = (e == null) ? editor.Document.Text : e.Content.Text;
if (caret.Offset > content.Length)
{
LoggingService.Debug("caret.Offset = " + caret.Offset + ", content.Length=" + content.Length);
return(null);
}
try {
ExpressionResult expr = expressionFinder.FindFullExpression(content, caret.Offset);
if (expr.Expression == null)
{
return(null);
}
return(ParserService.Resolve(expr, caret.Line, caret.Column, editor.FileName, content));
} catch (Exception ex) {
disableDefinitionView = true;
ctl.Visibility = Visibility.Collapsed;
MessageService.ShowException(ex, "Error resolving at " + caret.Line + "/" + caret.Column
+ ". DefinitionViewPad is disabled until you restart SharpDevelop.");
return(null);
}
}
public void ShowSourceCode(int lineNumber)
{
ShowSourceCode();
ITextEditorProvider tecp = this.primaryViewContent as ITextEditorProvider;
if (tecp != null)
{
tecp.TextEditor.JumpTo(lineNumber, 1);
}
}
public void SetItemsSource(IEnumerable <ITreeNode> value)
{
this.itemsSource = value;
this.lazyGrid = new LazyItemsControl <ITreeNode>(this.dataGrid, InitialItemsCount);
// HACK for updating the pins in tooltip
var observable = new List <ITreeNode>();
this.itemsSource.ForEach(item => observable.Add(item));
// verify if at the line of the root there's a pin bookmark
ITextEditor editor;
var viewContent = WorkbenchSingleton.Workbench.ActiveViewContent;
ITextEditorProvider provider = viewContent as ITextEditorProvider;
if (provider != null)
{
editor = provider.TextEditor;
}
else
{
editor = viewContent.GetService(typeof(ITextEditor)) as ITextEditor;
}
if (editor != null)
{
var pin = BookmarkManager.Bookmarks.Find(
b => b is PinBookmark &&
b.Location.Line == logicalPosition.Line &&
b.FileName == editor.FileName) as PinBookmark;
if (pin != null)
{
observable.ForEach(item => { // TODO: find a way not to use "observable"
if (pin.ContainsNode(item))
{
item.IsPinned = true;
}
});
}
}
var source = new VirtualizingIEnumerable <ITreeNode>(observable);
lazyGrid.ItemsSource = source;
this.dataGrid.AddHandler(ScrollViewer.ScrollChangedEvent, new ScrollChangedEventHandler(handleScroll));
if (this.lazyGrid.ItemsSourceTotalCount != null)
{
// hide up/down buttons if too few items
btnUp.Visibility = btnDown.Visibility =
this.lazyGrid.ItemsSourceTotalCount.Value <= VisibleItemsCount ? Visibility.Collapsed : Visibility.Visible;
}
}
/// <summary>
/// Registers event for changing documents texts after change of actual document.
/// </summary>
private void activeViewContentChanged(object src, EventArgs args)
{
ITextEditorProvider provider = WorkbenchSingleton.Workbench.ActiveViewContent as ITextEditorProvider;
if (provider != null)
{
changingFilename = provider.TextEditor.FileName;
provider.TextEditor.Document.Changing -= this.changingEvent;
provider.TextEditor.Document.Changing += this.changingEvent;
}
}
/// <summary>
/// Starts the command
/// </summary>
public override void Run()
{
ITextEditorProvider provider = WorkbenchSingleton.Workbench.ActiveViewContent as ITextEditorProvider;
if (provider == null)
{
return;
}
provider.TextEditor.Language.FormattingStrategy.SurroundSelectionWithComment(provider.TextEditor);
}
public bool IsValid(object owner, Condition condition)
{
ITextEditorProvider textEditorProvider = WorkbenchSingleton.Workbench.ActiveViewContent as ITextEditorProvider;
if (textEditorProvider != null)
{
ITextEditor textEditor = textEditorProvider.TextEditor;
return(textEditor.SelectionLength > 0);
}
return(false);
}
static void HideCodeCoverage()
{
foreach (IViewContent view in WorkbenchSingleton.Workbench.ViewContentCollection)
{
ITextEditorProvider editorProvider = view as ITextEditorProvider;
if (editorProvider != null)
{
codeCoverageHighlighter.RemoveMarkers(editorProvider.TextEditor.Document);
}
}
}
public void RemoveXPathNodeTextMarkers()
{
foreach (IViewContent view in workbench.ViewContentCollection)
{
ITextEditorProvider textEditorProvider = view as ITextEditorProvider;
if (textEditorProvider != null)
{
XPathNodeTextMarker marker = new XPathNodeTextMarker(textEditorProvider.TextEditor.Document);
marker.RemoveMarkers();
}
}
}
public static ITextEditor GetActiveTextEditor()
{
ITextEditorProvider provider = WorkbenchSingleton.Workbench.ActiveViewContent as ITextEditorProvider;
if (provider != null)
{
return(provider.TextEditor);
}
else
{
return(null);
}
}
