public static FlowDocument CreateTooltip(IEntity entity, bool useFullyQualifiedMemberNames = true)
{
var ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.ShowDeclaringType;
if (useFullyQualifiedMemberNames)
{
ambience.ConversionFlags |= ConversionFlags.UseFullyQualifiedEntityNames;
}
string header = ambience.ConvertSymbol(entity);
var documentation = XmlDocumentationElement.Get(entity);
ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList;
DocumentationUIBuilder b = new DocumentationUIBuilder(ambience);
b.AddCodeBlock(header, keepLargeMargin: true);
if (documentation != null)
{
foreach (var child in documentation.Children)
{
b.AddDocumentationElement(child);
}
}
return(b.CreateFlowDocument());
}
protected virtual IAmbience GetAmbience()
{
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList;
return(ambience);
}
public override string ToString()
{
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.ShowReturnType | ConversionFlags.ShowModifiers;
return(ambience.Convert(field));
}
public override string ToString()
{
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList;
return(ambience.Convert(c));
}
void FindOverrides(object sender, EventArgs e)
{
MenuCommand item = (MenuCommand)sender;
IMember member = (IMember)item.Tag;
IEnumerable <IClass> derivedClasses = RefactoringService.FindDerivedClasses(member.DeclaringType, ParserService.AllProjectContents, false);
List <SearchResultMatch> results = new List <SearchResultMatch>();
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedMemberNames | ConversionFlags.ShowTypeParameterList;
foreach (IClass derivedClass in derivedClasses)
{
if (derivedClass.CompilationUnit == null)
{
continue;
}
if (derivedClass.CompilationUnit.FileName == null)
{
continue;
}
IMember m = MemberLookupHelper.FindSimilarMember(derivedClass, member);
if (m != null && !m.Region.IsEmpty)
{
string matchText = ambience.Convert(m);
SearchResultMatch res = new SimpleSearchResultMatch(matchText, new TextLocation(m.Region.BeginColumn - 1, m.Region.BeginLine - 1));
res.ProvidedDocumentInformation = FindReferencesAndRenameHelper.GetDocumentInformation(m.DeclaringType.CompilationUnit.FileName);
results.Add(res);
}
}
SearchResultPanel.Instance.ShowSearchResults(new SearchResult(
StringParser.Parse("${res:SharpDevelop.Refactoring.OverridesOf}", new string[, ] {
{ "Name", member.Name }
}),
results
));
}
public override string ToString()
{
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.ShowParameterNames;
return(ambience.Convert(property));
}
public override string ToString()
{
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.None;
return(ambience.Convert(evt));
}
public CodeCompletionItem(IEntity entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
this.entity = entity;
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = entity is IClass ? ConversionFlags.ShowTypeParameterList : ConversionFlags.None;
this.Text = ambience.Convert(entity);
ambience.ConversionFlags = ConversionFlags.StandardConversionFlags;
if (entity is IClass)
{
// Show fully qualified Type name (called UseFullyQualifiedMemberNames though)
ambience.ConversionFlags |= ConversionFlags.UseFullyQualifiedMemberNames;
}
description = ambience.Convert(entity);
this.Image = ClassBrowserIconService.GetIcon(entity);
this.Overloads = 1;
this.InsertGenericArguments = false;
this.Priority = CodeCompletionDataUsageCache.GetPriority(entity.DotNetName, true);
}
protected IAmbience GetAmbience()
{
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.None;
return(ambience);
}
static string GetName(IMember member, ConversionFlags flags)
{
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = flags | ConversionFlags.ShowParameterNames | ConversionFlags.ShowTypeParameterList;
return(ambience.Convert(member));
}
void AddClasses(ArrayList items, ICollection <IClass> classes)
{
foreach (IClass c in classes)
{
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedMemberNames | ConversionFlags.ShowTypeParameterList;
items.Add(new ComboBoxItem(c, ambience.Convert(c), ClassBrowserIconService.GetIcon(c), true));
AddClasses(items, c.InnerClasses);
}
}
public override string ToString()
{
if (cachedStringRepresentation == null)
{
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.ShowParameterNames;
cachedStringRepresentation = ambience.Convert(method);
}
return(cachedStringRepresentation);
}
public string GetInsightData(int number)
{
IMember method = methods[number];
IAmbience conv = AmbienceService.GetCurrentAmbience();
conv.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.UseFullyQualifiedMemberNames;
string documentation = method.Documentation;
string text = conv.Convert(method);
return(text + "\n" + CodeCompletionData.ConvertDocumentation(documentation));
}
ContextActionViewModel MakeViewModel(IUnresolvedTypeDefinition entity)
{
var ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.ShowDeclaringType | ConversionFlags.ShowTypeParameterList;
return(new ContextActionViewModel {
Action = new GoToDomRegionAction(entity.Region),
Image = IconService.GetImageSource(IconService.GetImageForFile(entity.Region.FileName)),
Comment = string.Format("(in {0})", Path.GetDirectoryName(entity.Region.FileName)),
ChildActions = null
});
}
public CodeCompletionData(IMember member)
{
this.entity = member;
imageIndex = ClassBrowserIconService.GetIcon(member);
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.None;
text = ambience.Convert(member);
ambience.ConversionFlags = ConversionFlags.StandardConversionFlags;
description = ambience.Convert(member);
InitializePriority(member.DotNetName);
}
public static ContextActionViewModel MakeViewModel(IEntity entity, ObservableCollection <ContextActionViewModel> childActions)
{
var ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.ShowDeclaringType | ConversionFlags.ShowTypeParameterList;
return(new ContextActionViewModel {
Action = new GoToEntityAction(entity, ambience.ConvertSymbol(entity)),
Image = CompletionImage.GetImage(entity),
Comment = string.Format("(in {0})", entity.Namespace),
ChildActions = childActions
});
}
static IEnumerable <ImplementInterfaceAction> MakeImplementActions(IClass c, IEnumerable <IReturnType> interfaces, bool isExplicit, string format)
{
var ambience = AmbienceService.GetCurrentAmbience();
foreach (var iface in interfaces)
{
yield return(new ImplementInterfaceAction(iface, c, isExplicit)
{
Title = string.Format(format, ambience.Convert(iface))
});
}
}
object GetText()
{
var member = model.Resolve();
if (member == null)
{
return(model.Name);
}
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList | ConversionFlags.ShowParameterList | ConversionFlags.ShowParameterNames;
return(ambience.ConvertSymbol(member));
}
public CodeCompletionData(IClass c)
{
IAmbience ambience = AmbienceService.GetCurrentAmbience();
// save class (for the delegate description shortcut)
this.entity = c;
imageIndex = ClassBrowserIconService.GetIcon(c);
ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList;
text = ambience.Convert(c);
ambience.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.UseFullyQualifiedMemberNames;
description = ambience.Convert(c);
InitializePriority(c.DotNetName);
}
object GenerateHeader()
{
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.StandardConversionFlags;
if (headerText == null)
{
headerText = ambience.Convert(entity);
}
if (highlightParameter < 0)
{
return(headerText);
}
if (entity is IMethod)
{
var method = entity as IMethod;
string param = "";
if (method.Parameters.Count > highlightParameter)
{
param = ambience.Convert(method.Parameters[highlightParameter]);
}
if (!string.IsNullOrEmpty(param))
{
// append ',' or ')' to avoid missing highlighting if there are multiple parameter names starting with the same substring.
string[] parts = headerText.Split(new[] { param + (method.Parameters.Count - 1 == highlightParameter ? ')' : ',') }, StringSplitOptions.None);
if (parts.Length != 2)
{
return(headerText);
}
return(new TextBlock
{ // add text wrapping
TextWrapping = TextWrapping.Wrap,
Inlines =
{
parts[0],
new Bold()
{
Inlines = { param }
},
(method.Parameters.Count - 1 == highlightParameter ? ')' : ',') + parts[1]
}
});
}
}
return(headerText);
}
object GenerateHeader()
{
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.StandardConversionFlags;
if (headerText == null)
{
headerText = ambience.Convert(entity);
}
if (highlightParameter < 0)
{
return(headerText);
}
if (entity is IMethod)
{
var method = entity as IMethod;
string param = "";
if (method.Parameters.Count > highlightParameter)
{
param = ambience.Convert(method.Parameters[highlightParameter]);
}
if (!string.IsNullOrEmpty(param))
{
string[] parts = headerText.Split(new[] { param }, StringSplitOptions.None);
if (parts.Length != 2)
{
return(headerText);
}
return(new Span()
{
Inlines =
{
parts[0],
new Bold()
{
Inlines = { param }
},
parts[1]
}
});
}
}
return(headerText);
}
public FieldWrapper(IField member)
{
if (member == null)
{
throw new ArgumentNullException("member");
}
this.field = member;
addSetter = true;
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags |=
ConversionFlags.ShowReturnType
| ConversionFlags.ShowModifiers
| ConversionFlags.ShowAccessibility;
this.text = ambience.ConvertSymbol(member);
}
public SettingsView()
{
InitializeComponent();
ambience = AmbienceService.GetCurrentAmbience();
compilation = MinimalCorlib.Instance.CreateCompilation();
foreach (Type type in defaultAvailableTypes)
{
types.Add(type);
typeNames.Add(ambience.ConvertType(type.ToTypeReference().Resolve(compilation)));
}
foreach (SpecialTypeDescriptor d in SpecialTypeDescriptor.Descriptors)
{
types.Add(d.type);
typeNames.Add(d.name);
}
Entries = new ObservableCollection <SettingsVM>();
}
public SettingsView()
{
InitializeComponent();
ambience = AmbienceService.GetCurrentAmbience();
foreach (Type type in defaultAvailableTypes)
{
types.Add(type);
typeNames.Add(ambience.GetIntrinsicTypeName(type.FullName));
}
foreach (SpecialTypeDescriptor d in SpecialTypeDescriptor.Descriptors)
{
types.Add(d.type);
typeNames.Add(d.name);
}
ScopeColumn.DataSource = Enum.GetValues(typeof(SettingScope));
TypeColumn.DataSource = typeNames;
}
public CodeCompletionItem(IEntity entity, IProjectContent projectContent)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
_entity = entity;
_projectContent = projectContent;
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = entity is IClass ? ConversionFlags.ShowTypeParameterList : ConversionFlags.None;
Text = entity.Name;
Content = ambience.Convert(entity);
Overloads = 1;
Priority = CodeCompletionDataUsageCache.GetPriority(entity.DotNetName, true);
}
protected override void Run(TextEditorControl editor, string clipboardText)
{
TextArea textArea = editor.ActiveTextAreaControl.TextArea;
string indentation = GetIndentation(editor.Document, textArea.Caret.Line);
IAmbience ambience = AmbienceService.GetCurrentAmbience();
int maxLineLength = textArea.TextEditorProperties.VerticalRulerRow - VisualIndentationLength(textArea, indentation);
StringBuilder insertedText = new StringBuilder();
using (StringReader reader = new StringReader(clipboardText)) {
string line;
while ((line = reader.ReadLine()) != null)
{
AppendTextLine(indentation, ambience, maxLineLength, insertedText, line);
}
}
var document = textArea.Document;
int insertionPos = document.GetLineSegment(textArea.Caret.Line).Offset + indentation.Length;
document.Insert(insertionPos, insertedText.ToString());
}
protected override void Run(ITextEditor editor, string clipboardText)
{
string indentation = GetIndentation(editor.Document, editor.Caret.Line);
IAmbience ambience = AmbienceService.GetCurrentAmbience();
int maxLineLength = editor.Options.VerticalRulerColumn - VisualIndentationLength(editor, indentation);
StringWriter insertedText = new StringWriter();
insertedText.NewLine = DocumentUtilitites.GetLineTerminator(editor.Document, editor.Caret.Line);
using (StringReader reader = new StringReader(clipboardText)) {
string line;
while ((line = reader.ReadLine()) != null)
{
AppendTextLine(indentation, ambience, maxLineLength, insertedText, line);
}
}
IDocument document = editor.Document;
int insertionPos = document.GetLine(editor.Caret.Line).Offset + indentation.Length;
document.Insert(insertionPos, insertedText.ToString());
}
public DocumentationUIBuilder(IAmbience ambience = null)
{
this.ambience = ambience ?? AmbienceService.GetCurrentAmbience();
this.flowDocument = new FlowDocument();
this.blockCollection = flowDocument.Blocks;
this.ShowSummary = true;
this.ShowAllParameters = true;
this.ShowReturns = true;
this.ShowThreadSafety = true;
this.ShowExceptions = true;
this.ShowTypeParameters = true;
this.ShowExample = true;
this.ShowPreliminary = true;
this.ShowSeeAlso = true;
this.ShowValue = true;
this.ShowPermissions = true;
this.ShowRemarks = true;
}
public PropertyOrFieldWrapper(IMember member)
{
isIncluded = false;
if (member == null)
{
throw new ArgumentNullException("member");
}
if (!(member is IField || member is IProperty))
{
throw new ArgumentException("member must be IField or IProperty");
}
this.Member = member;
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags |=
ConversionFlags.ShowReturnType
| ConversionFlags.ShowModifiers
| ConversionFlags.ShowAccessibility;
this.text = ambience.ConvertSymbol(member);
}
public static FlowDocument CreateTooltip(ISymbol symbol)
{
var ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.ShowDeclaringType;
string header = ambience.ConvertSymbol(symbol);
if (symbol is IParameter)
{
header = "parameter " + header;
}
else if (symbol is IVariable)
{
header = "local variable " + header;
}
ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList;
DocumentationUIBuilder b = new DocumentationUIBuilder(ambience);
b.AddCodeBlock(header, keepLargeMargin: true);
return(b.CreateFlowDocument());
}
