public Solution PreviewChanges(
string title,
string helpString,
string description,
string topLevelName,
Glyph topLevelGlyph,
Solution newSolution,
Solution oldSolution,
bool showCheckBoxes = true)
{
var engine = new PreviewEngine(
title,
helpString,
description,
topLevelName,
topLevelGlyph,
newSolution,
oldSolution,
_componentModel,
_imageService,
showCheckBoxes);
_previewChanges.PreviewChanges(engine);
engine.CloseWorkspace();
return engine.FinalSolution;
}
public FileSystemCompletionHelper(
CompletionListProvider completionProvider,
TextSpan textChangeSpan,
ICurrentWorkingDirectoryDiscoveryService fileSystemDiscoveryService,
Glyph folderGlyph,
Glyph fileGlyph,
ImmutableArray<string> searchPaths,
IEnumerable<string> allowableExtensions,
Func<string, bool> exclude = null,
CompletionItemRules itemRules = null)
{
Debug.Assert(searchPaths.All(path => PathUtilities.IsAbsolute(path)));
_completionProvider = completionProvider;
_textChangeSpan = textChangeSpan;
_searchPaths = searchPaths;
_allowableExtensions = allowableExtensions.Select(e => e.ToLowerInvariant()).ToSet();
_fileSystemDiscoveryService = fileSystemDiscoveryService;
_folderGlyph = folderGlyph;
_fileGlyph = fileGlyph;
_exclude = exclude;
_itemRules = itemRules;
_lazyGetDrives = new Lazy<string[]>(() =>
IOUtilities.PerformIO(Directory.GetLogicalDrives, SpecializedCollections.EmptyArray<string>()));
}
public SymbolCompletionItem(
CompletionListProvider completionProvider,
string displayText,
string insertionText,
string filterText,
TextSpan filterSpan,
int position,
List<ISymbol> symbols,
string sortText,
AbstractSyntaxContext context,
Glyph glyph,
bool preselect = false,
SupportedPlatformData supportedPlatforms = null,
CompletionItemRules rules = null)
: base(completionProvider, displayText, filterSpan,
descriptionFactory: null, glyph: glyph,
sortText: sortText, filterText: filterText, preselect: preselect, showsWarningIcon: supportedPlatforms != null, rules: rules,
filters: GetFilters(symbols))
{
this.InsertionText = insertionText;
this.Position = position;
this.Symbols = symbols;
this.Context = context;
_supportedPlatforms = supportedPlatforms;
}
public static CompletionItem Create(
string displayText,
TextSpan span,
ISymbol symbol,
int contextPosition = -1,
int descriptionPosition = -1,
string sortText = null,
string insertionText = null,
Glyph? glyph = null,
string filterText = null,
bool preselect = false,
SupportedPlatformData supportedPlatforms = null,
bool isArgumentName = false,
ImmutableDictionary<string, string> properties = null,
CompletionItemRules rules = null)
{
return Create(
displayText: displayText,
span: span,
symbols: ImmutableArray.Create(symbol),
contextPosition: contextPosition,
descriptionPosition: descriptionPosition,
sortText: sortText,
insertionText: insertionText,
glyph: glyph,
filterText: filterText,
preselect: preselect,
supportedPlatforms: supportedPlatforms,
isArgumentName: isArgumentName,
properties: properties,
rules: rules);
}
/// <summary>
/// Reads a glyph description from the specified offset.
/// </summary>
public Glyph ReadGlyph(int glyphIndex) {
FontFileStream stream = reader.Stream;
// Offset from beginning of font file
uint fileOffset = glyfEntry.Offset + loca[glyphIndex];
long length = GetGlyphLength(glyphIndex);
Glyph glyph = new Glyph(reader.IndexMappings.Map(glyphIndex));
if (length != 0) {
byte[] glyphData = new byte[length];
// Read glyph description into byte array
stream.Position = fileOffset;
stream.Read(glyphData, 0, glyphData.Length);
glyph.SetGlyphData(glyphData);
FontFileStream glyphStream = new FontFileStream(glyphData);
// This fields dictates whether the glyph is a simple or composite glyph
bool compositeGlyph = (glyphStream.ReadShort() < 0);
// Skip font bounding box
glyphStream.Skip(PrimitiveSizes.Short*4);
if (compositeGlyph) {
ReadCompositeGlyph(glyphStream, glyph);
}
}
return glyph;
}
public static CompletionItem Create(
string displayText,
ISymbol symbol,
int contextPosition = -1,
string sortText = null,
string insertionText = null,
Glyph? glyph = null,
string filterText = null,
int? matchPriority = null,
SupportedPlatformData supportedPlatforms = null,
ImmutableDictionary<string, string> properties = null,
CompletionItemRules rules = null)
{
return Create(
displayText: displayText,
symbols: ImmutableArray.Create(symbol),
contextPosition: contextPosition,
sortText: sortText,
insertionText: insertionText,
glyph: glyph,
filterText: filterText,
matchPriority: matchPriority.GetValueOrDefault(),
supportedPlatforms: supportedPlatforms,
properties: properties,
rules: rules);
}
public static Surface RenderGlyph (Fnt font, Glyph g, byte[] palette, int offset)
{
byte[] buf = new byte[g.Width * g.Height * 4];
int i = 0;
for (int y = g.Height - 1; y >= 0; y--) {
for (int x = g.Width - 1; x >= 0; x--) {
if (g.Bitmap[y,x] == 0)
buf [i + 0] = 0;
else if (g.Bitmap[y,x] == 1)
buf [i + 0] = 255;
else
buf [i + 0] = 128;
buf[i + 1] = palette[ (g.Bitmap[y,x] + offset) * 3 + 2];
buf[i + 2] = palette[ (g.Bitmap[y,x] + offset) * 3 + 1];
buf[i + 3] = palette[ (g.Bitmap[y,x] + offset) * 3 ];
if (buf[i+1] == 252 && buf[i+2] == 0 && buf[i+3] == 252)
buf[i + 0] = 0;
i += 4;
}
}
return CreateSurfaceFromRGBAData (buf, (ushort)g.Width, (ushort)g.Height, 32, g.Width * 4);
}
public PreviewEngine(
string title,
string helpString,
string description,
string topLevelItemName,
Glyph topLevelGlyph,
Solution newSolution,
Solution oldSolution,
IComponentModel componentModel,
IVsImageService2 imageService,
bool showCheckBoxes = true)
{
_topLevelName = topLevelItemName;
_topLevelGlyph = topLevelGlyph;
_title = title;
_helpString = helpString;
_description = description;
_newSolution = newSolution.WithMergedLinkedFileChangesAsync(oldSolution, cancellationToken: CancellationToken.None).Result;
_oldSolution = oldSolution;
_diffSelector = componentModel.GetService<ITextDifferencingSelectorService>();
_editorFactory = componentModel.GetService<IVsEditorAdaptersFactoryService>();
_componentModel = componentModel;
this.ShowCheckBoxes = showCheckBoxes;
_imageService = imageService;
}
public static void Crop(Glyph glyph)
{
// Crop the top.
while ((glyph.Subrect.Height > 1) && BitmapUtils.IsAlphaEntirely(0, glyph.Bitmap, new Rectangle(glyph.Subrect.X, glyph.Subrect.Y, glyph.Subrect.Width, 1)))
{
glyph.Subrect.Y++;
glyph.Subrect.Height--;
glyph.YOffset++;
}
// Crop the bottom.
while ((glyph.Subrect.Height > 1) && BitmapUtils.IsAlphaEntirely(0, glyph.Bitmap, new Rectangle(glyph.Subrect.X, glyph.Subrect.Bottom - 1, glyph.Subrect.Width, 1)))
{
glyph.Subrect.Height--;
}
// Crop the left.
while ((glyph.Subrect.Width > 1) && BitmapUtils.IsAlphaEntirely(0, glyph.Bitmap, new Rectangle(glyph.Subrect.X, glyph.Subrect.Y, 1, glyph.Subrect.Height)))
{
glyph.Subrect.X++;
glyph.Subrect.Width--;
glyph.XOffset++;
}
// Crop the right.
while ((glyph.Subrect.Width > 1) && BitmapUtils.IsAlphaEntirely(0, glyph.Bitmap, new Rectangle(glyph.Subrect.Right - 1, glyph.Subrect.Y, 1, glyph.Subrect.Height)))
{
glyph.Subrect.Width--;
}
}
public Bitmap Rasterize(Glyph glyph, TextQuality quality)
{
EnsureSurfaceSize(ref glyph_surface, ref glyph_renderer, glyph.Font);
SetTextRenderingOptions(glyph_renderer, glyph.Font, quality);
RectangleF r2 = new RectangleF();
glyph_renderer.Clear(Color.Transparent);
glyph_renderer.DrawString(glyph.Character.ToString(), glyph.Font, Brushes.White, Point.Empty, //new Point(glyph_surface.Width, 0),
glyph.Font.Style == FontStyle.Italic ? load_glyph_string_format : load_glyph_string_format_tight);
r2 = FindEdges(glyph_surface, true);
//if ((default_string_format.FormatFlags & StringFormatFlags.DirectionRightToLeft) != 0)
//{
// glyph_renderer.DrawString(glyph.Character.ToString(), glyph.Font, Brushes.White, Point.Empty, //new Point(glyph_surface.Width, 0),
// load_glyph_string_format);//glyph.Font.Style == FontStyle.Italic ? load_glyph_string_format : default_string_format);
// r2 = FindEdges(glyph_surface, true);
//}
//else
//{
// glyph_renderer.DrawString(glyph.Character.ToString(), glyph.Font, Brushes.White, Point.Empty,
// load_glyph_string_format_tight); //glyph.Font.Style == FontStyle.Italic ? load_glyph_string_format : default_string_format);
// r2 = FindEdges(glyph_surface, false);
//}
return glyph_surface.Clone(r2, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
}
public SymbolGlyphDeferredContent(Glyph glyph, IGlyphService glyphService)
{
Contract.ThrowIfNull(glyphService);
_glyph = glyph;
_glyphService = glyphService;
}
public CSharpCompletionItem(
Workspace workspace,
CompletionListProvider completionProvider,
string displayText,
TextSpan filterSpan,
Func<CancellationToken, Task<ImmutableArray<SymbolDisplayPart>>> descriptionFactory,
Glyph? glyph,
string sortText = null,
string filterText = null,
bool preselect = false,
bool isBuilder = false,
bool showsWarningIcon = false,
bool shouldFormatOnCommit = false)
: base(completionProvider,
displayText,
filterSpan,
descriptionFactory,
glyph,
sortText,
filterText,
preselect,
isBuilder,
showsWarningIcon,
shouldFormatOnCommit)
{
Contract.ThrowIfNull(workspace);
this.Workspace = workspace;
}
public static CompletionItem Create(
string displayText,
TextSpan span,
Glyph? glyph,
DeclarationModifiers modifiers,
int line,
ISymbol symbol,
SyntaxToken token,
int descriptionPosition,
CompletionItemRules rules)
{
var props = ImmutableDictionary<string, string>.Empty
.Add("Line", line.ToString())
.Add("Modifiers", modifiers.ToString())
.Add("TokenSpanEnd", token.Span.End.ToString());
return SymbolCompletionItem.Create(
displayText: displayText,
span: span,
symbol: symbol,
glyph: glyph,
descriptionPosition: descriptionPosition,
properties: props,
rules: rules);
}
private QuickInfoModel(SemanticModel semanticModel, TextSpan span, Glyph glyph, SymbolMarkup markup, string documentation)
{
SemanticModel = semanticModel;
Span = span;
Glyph = glyph;
Markup = markup;
Documentation = documentation;
}
public ChangeSignatureResult(bool succeeded, Solution updatedSolution = null, string name = null, Glyph? glyph = null, bool previewChanges = false)
{
this.Succeeded = succeeded;
this.UpdatedSolution = updatedSolution;
this.Name = name;
this.Glyph = glyph;
this.PreviewChanges = previewChanges;
}
public EditorNavigationTarget(string name, SnapshotSpan span, SnapshotSpan seek, Glyph icon, ImageSource glyph)
{
Name = name;
Span = span;
Seek = seek;
Icon = icon;
Glyph = glyph;
}
private void Convert()
{
DefineShape shape;
glyph = new Glyph(GlyphType.Symbol); ;
Segment seg;
PointF point0;
PointF basePoint = new PointF(0, 0);
PointF curvePoint1, curvePoint2;
foreach (BaseTag tag in swf.Tags)
{
if (tag is DefineShape)
{
shape = (DefineShape)tag;
glyph.Rect = shape.Rect.RectangleF;
foreach (ShapeRecord record in shape.ShapeWithStyle.Shapes)
{
if (record is StyleChangeRecord)
{
basePoint = ((StyleChangeRecord)record).Point0;
seg = new Segment(SegmentType.StartPoint, new PointF[] { basePoint });
glyph.Segments.Add(seg);
}
else if (record is StraightEdgeRecord)
{
point0 = ((StraightEdgeRecord)record).Point0;
basePoint.X += point0.X;
basePoint.Y += point0.Y;
seg = new Segment(SegmentType.Line, new PointF[] { basePoint });
glyph.Segments.Add(seg);
}
else if (record is CurvedEdgeRecord)
{
point0 = ((CurvedEdgeRecord)record).Point0;
curvePoint1 = basePoint;
curvePoint1.X += point0.X;
curvePoint1.Y += point0.Y;
point0 = ((CurvedEdgeRecord)record).Point1;
curvePoint2 = curvePoint1;
curvePoint2.X += point0.X;
curvePoint2.Y += point0.Y;
basePoint = curvePoint2;
seg = new Segment(SegmentType.QuadraticBezier, new PointF[] { curvePoint1, curvePoint2 });
glyph.Segments.Add(seg);
}
}
}
if (tag is ShowFrameTag)
{
break;
}
}
}
protected CompletionItem CreateItem(
Workspace workspace,
string displayText,
TextSpan textSpan,
Func<CancellationToken, Task<ImmutableArray<SymbolDisplayPart>>> descriptionFactory,
Glyph? glyph)
{
return new CompletionItem(this, displayText, textSpan, descriptionFactory, glyph, rules: ObjectInitializerCompletionItemRules.Instance);
}
public CompletionItem(string displayText, string insertionText, string description, Glyph? glyph, Symbol symbol, bool isBuilder)
{
DisplayText = displayText;
InsertionText = insertionText;
Description = description;
Glyph = glyph;
Symbol = symbol;
IsBuilder = isBuilder;
}
public InformationQuickInfoContent(Glyph? symbolGlyph, Glyph? warningGlyph, ImmutableArray<TaggedText> mainDescription, ImmutableArray<TaggedText> documentation, ImmutableArray<TaggedText> typeParameterMap, ImmutableArray<TaggedText> anonymousTypes, ImmutableArray<TaggedText> usageText, ImmutableArray<TaggedText> exceptionText) {
SymbolGlyph = symbolGlyph;
WarningGlyph = warningGlyph;
MainDescription = mainDescription.IsDefault ? ImmutableArray<TaggedText>.Empty : mainDescription;
Documentation = documentation.IsDefault ? ImmutableArray<TaggedText>.Empty : documentation;
TypeParameterMap = typeParameterMap.IsDefault ? ImmutableArray<TaggedText>.Empty : typeParameterMap;
AnonymousTypes = anonymousTypes.IsDefault ? ImmutableArray<TaggedText>.Empty : anonymousTypes;
UsageText = usageText.IsDefault ? ImmutableArray<TaggedText>.Empty : usageText;
ExceptionText = exceptionText.IsDefault ? ImmutableArray<TaggedText>.Empty : exceptionText;
}
public Solution PreviewChanges(string title, string helpString, string description, string topLevelName, Glyph topLevelGlyph, Solution newSolution, Solution oldSolution, bool showCheckBoxes = true)
{
Called = true;
Title = title;
HelpString = helpString;
Description = description;
TopLevelName = topLevelName;
TopLevelGlyph = topLevelGlyph;
ShowCheckBoxes = showCheckBoxes;
return ReturnsNull ? null : newSolution;
}
public NavigableItem(
Glyph glyph, ImmutableArray<TaggedText> displayTaggedParts,
bool displayFileLocation, bool isImplicitlyDeclared, Document document, TextSpan sourceSpan, ImmutableArray<INavigableItem> childItems)
{
Glyph = glyph;
DisplayTaggedParts = displayTaggedParts;
DisplayFileLocation = displayFileLocation;
IsImplicitlyDeclared = isImplicitlyDeclared;
Document = document;
SourceSpan = sourceSpan;
ChildItems = childItems;
}
public static CompletionItem Create(
string displayText,
TextSpan span,
Glyph? glyph = null,
ImmutableArray<SymbolDisplayPart> description = default(ImmutableArray<SymbolDisplayPart>),
string sortText = null,
string filterText = null,
bool preselect = false,
bool showsWarningIcon = false,
bool shouldFormatOnCommit = false,
bool isArgumentName = false,
ImmutableDictionary<string, string> properties = null,
ImmutableArray<string> tags = default(ImmutableArray<string>),
CompletionItemRules rules = null)
{
tags = tags.IsDefault ? ImmutableArray<string>.Empty : tags;
if (glyph != null)
{
// put glyph tags first
tags = GlyphTags.GetTags(glyph.Value).AddRange(tags);
}
if (showsWarningIcon)
{
tags = tags.Add(CompletionTags.Warning);
}
if (isArgumentName)
{
tags = tags.Add(CompletionTags.ArgumentName);
}
properties = properties ?? ImmutableDictionary<string, string>.Empty;
if (!description.IsDefault && description.Length > 0)
{
properties = properties.Add("Description", EncodeDescription(description));
}
rules = rules ?? CompletionItemRules.Default;
rules = rules.WithPreselect(preselect)
.WithFormatOnCommit(shouldFormatOnCommit);
return CompletionItem.Create(
displayText: displayText,
filterText: filterText,
sortText: sortText,
span: span,
properties: properties,
tags: tags,
rules: rules);
}
public ImageMoniker GetImageMoniker(Glyph glyph)
{
// We can't do the compositing of these glyphs at the editor layer. So just map them
// to the non-add versions.
switch (glyph)
{
case Glyph.AddReference:
glyph = Glyph.Reference;
break;
}
return glyph.GetImageMoniker();
}
public RecommendedKeyword(
string keyword,
Glyph glyph,
Func<CancellationToken, ImmutableArray<SymbolDisplayPart>> descriptionFactory,
bool isIntrinsic = false,
bool shouldFormatOnCommit = false)
{
this.Keyword = keyword;
this.Glyph = glyph;
this.DescriptionFactory = descriptionFactory;
this.IsIntrinsic = isIntrinsic;
this.ShouldFormatOnCommit = shouldFormatOnCommit;
}
public Item(
CompletionListProvider completionProvider,
string displayText,
string insertionText,
TextSpan textSpan,
Func<CancellationToken,
Task<ImmutableArray<SymbolDisplayPart>>> descriptionFactory,
Glyph? glyph,
string sortText)
: base(completionProvider, displayText, textSpan, descriptionFactory, glyph, sortText, rules: ItemRules.Instance)
{
this.InsertionText = insertionText;
}
public static CompletionItem Create(
string displayText,
TextSpan span,
IReadOnlyList<ISymbol> symbols,
int contextPosition = -1,
int descriptionPosition = -1,
string sortText = null,
string insertionText = null,
Glyph? glyph = null,
string filterText = null,
bool preselect = false,
SupportedPlatformData supportedPlatforms = null,
bool isArgumentName = false,
ImmutableDictionary<string, string> properties = null,
ImmutableArray<string> tags = default(ImmutableArray<string>),
CompletionItemRules rules = null)
{
var props = properties ?? ImmutableDictionary<string, string>.Empty;
props = props.Add("Symbols", EncodeSymbols(symbols));
if (insertionText != null)
{
props = props.Add("InsertionText", insertionText);
}
if (contextPosition >= 0)
{
props = props.Add("ContextPosition", contextPosition.ToString());
}
if (descriptionPosition >= 0)
{
props = props.Add("DescriptionPosition", descriptionPosition.ToString());
}
var item = CommonCompletionItem.Create(
displayText: displayText,
span: span,
filterText: filterText ?? (displayText.Length > 0 && displayText[0] == '@' ? displayText : symbols[0].Name),
sortText: sortText ?? symbols[0].Name,
glyph: glyph ?? symbols[0].GetGlyph(),
preselect: preselect,
isArgumentName: isArgumentName,
showsWarningIcon: supportedPlatforms != null,
properties: props,
tags: tags,
rules: rules);
return WithSupportedPlatforms(item, supportedPlatforms);
}
/// <summary>
/// Populate the <i>composites</i>IList containing all child glyphs
/// that this glyph uses.
/// </summary>
/// <remarks>
/// The <i>stream</i> parameter must be positioned 10 bytes from
/// the beginning of the glyph description, i.e. the flags field.
/// </remarks>
/// <param name="stream"></param>
private void ReadCompositeGlyph(FontFileStream stream, Glyph glyph) {
bool moreComposites = true;
while (moreComposites) {
short flags = stream.ReadShort();
long offset = stream.Position;
int subsetIndex = reader.IndexMappings.Map(stream.ReadShort());
glyph.AddChild(subsetIndex);
// While we're here, remap the child glyph index
stream.Position = stream.Position - PrimitiveSizes.Short;
stream.WriteShort(subsetIndex);
// The following code is based on the C pseudo code supplied
// in the glyf table specification.
int skipBytes = 0;
if ((flags & BitMasks.Arg1And2AreWords) > 0) {
skipBytes = PrimitiveSizes.Short*2;
}
else {
skipBytes = PrimitiveSizes.UShort;
}
if ((flags & BitMasks.WeHaveAScale) > 0) {
// Skip scale
skipBytes = PrimitiveSizes.F2DOT14;
}
else if ((flags & BitMasks.WeHaveAnXAndYScale) > 0) {
// Skip xscale and yscale
skipBytes = PrimitiveSizes.F2DOT14*2;
}
else if ((flags & BitMasks.WeHaveATwoByTwo) > 0) {
// Skip xscale, scale01, scale10 and yscale
skipBytes = PrimitiveSizes.F2DOT14*4;
}
// Glyph instructions
if ((flags & BitMasks.WeHaveInstructions) > 0) {
skipBytes = PrimitiveSizes.Byte*stream.ReadUShort();
}
if ((flags & BitMasks.MoreComponents) > 0) {
moreComposites = true;
}
else {
moreComposites = false;
}
stream.Skip(skipBytes);
}
}
public CrefCompletionItem(
Workspace workspace,
CompletionListProvider completionProvider,
string displayText,
string insertionText,
TextSpan textSpan,
Func<CancellationToken,
Task<ImmutableArray<SymbolDisplayPart>>> descriptionFactory,
Glyph? glyph,
string sortText)
: base(workspace, completionProvider, displayText, textSpan, descriptionFactory, glyph, sortText)
{
this.InsertionText = insertionText;
}
public ImageMoniker GetImageMoniker(Glyph glyph)
{
this.AssertIsForeground();
switch (glyph)
{
case Glyph.AddReference:
return GetCompositedImageMoniker(
CreateLayer(Glyph.Reference.GetImageMoniker(), virtualXOffset: 1, virtualYOffset: 2),
CreateLayer(KnownMonikers.PendingAddNode, virtualWidth: 7, virtualXOffset: -1, virtualYOffset: -2));
}
return glyph.GetImageMoniker();
}
public override bool OnMouseHover(Glyph g, System.Drawing.Point mouseLoc)
{
return(base.OnMouseHover(g, mouseLoc));
}
public override bool OnMouseDoubleClick(Glyph g, System.Windows.Forms.MouseButtons button, System.Drawing.Point mouseLoc)
{
return(base.OnMouseDoubleClick(g, button, mouseLoc));
}
public static ImageReference?GetImageReference(this Glyph glyph)
{
switch (glyph)
{
case Glyph.Assembly: return(DsImages.Assembly);
case Glyph.BasicFile: return(DsImages.VBFileNode);
case Glyph.BasicProject: return(DsImages.VBProjectNode);
case Glyph.ClassPublic: return(DsImages.ClassPublic);
case Glyph.ClassProtected: return(DsImages.ClassProtected);
case Glyph.ClassPrivate: return(DsImages.ClassPrivate);
case Glyph.ClassInternal: return(DsImages.ClassInternal);
case Glyph.CSharpFile: return(DsImages.CSFileNode);
case Glyph.CSharpProject: return(DsImages.CSProjectNode);
case Glyph.ConstantPublic: return(DsImages.ConstantPublic);
case Glyph.ConstantProtected: return(DsImages.ConstantProtected);
case Glyph.ConstantPrivate: return(DsImages.ConstantPrivate);
case Glyph.ConstantInternal: return(DsImages.ConstantInternal);
case Glyph.DelegatePublic: return(DsImages.DelegatePublic);
case Glyph.DelegateProtected: return(DsImages.DelegateProtected);
case Glyph.DelegatePrivate: return(DsImages.DelegatePrivate);
case Glyph.DelegateInternal: return(DsImages.DelegateInternal);
case Glyph.EnumPublic: return(DsImages.EnumerationPublic);
case Glyph.EnumProtected: return(DsImages.EnumerationProtected);
case Glyph.EnumPrivate: return(DsImages.EnumerationPrivate);
case Glyph.EnumInternal: return(DsImages.EnumerationInternal);
case Glyph.EnumMember: return(DsImages.EnumerationItemPublic);
case Glyph.Error: return(DsImages.StatusError);
case Glyph.EventPublic: return(DsImages.EventPublic);
case Glyph.EventProtected: return(DsImages.EventProtected);
case Glyph.EventPrivate: return(DsImages.EventPrivate);
case Glyph.EventInternal: return(DsImages.EventInternal);
case Glyph.ExtensionMethodPublic: return(DsImages.ExtensionMethod);
case Glyph.ExtensionMethodProtected: return(DsImages.ExtensionMethod);
case Glyph.ExtensionMethodPrivate: return(DsImages.ExtensionMethod);
case Glyph.ExtensionMethodInternal: return(DsImages.ExtensionMethod);
case Glyph.FieldPublic: return(DsImages.FieldPublic);
case Glyph.FieldProtected: return(DsImages.FieldProtected);
case Glyph.FieldPrivate: return(DsImages.FieldPrivate);
case Glyph.FieldInternal: return(DsImages.FieldInternal);
case Glyph.InterfacePublic: return(DsImages.InterfacePublic);
case Glyph.InterfaceProtected: return(DsImages.InterfaceProtected);
case Glyph.InterfacePrivate: return(DsImages.InterfacePrivate);
case Glyph.InterfaceInternal: return(DsImages.InterfaceInternal);
case Glyph.Intrinsic: return(DsImages.Type);
case Glyph.Keyword: return(DsImages.IntellisenseKeyword);
case Glyph.Label: return(DsImages.Label);
case Glyph.Local: return(DsImages.LocalVariable);
case Glyph.Namespace: return(DsImages.Namespace);
case Glyph.MethodPublic: return(DsImages.MethodPublic);
case Glyph.MethodProtected: return(DsImages.MethodProtected);
case Glyph.MethodPrivate: return(DsImages.MethodPrivate);
case Glyph.MethodInternal: return(DsImages.MethodInternal);
case Glyph.ModulePublic: return(DsImages.ModulePublic);
case Glyph.ModuleProtected: return(DsImages.ModuleProtected);
case Glyph.ModulePrivate: return(DsImages.ModulePrivate);
case Glyph.ModuleInternal: return(DsImages.ModuleInternal);
case Glyph.OpenFolder: return(DsImages.FolderOpened);
case Glyph.Operator: return(DsImages.OperatorPublic);
case Glyph.Parameter: return(DsImages.LocalVariable); // Same image as Local, just like what VS does
case Glyph.PropertyPublic: return(DsImages.Property);
case Glyph.PropertyProtected: return(DsImages.PropertyProtected);
case Glyph.PropertyPrivate: return(DsImages.PropertyPrivate);
case Glyph.PropertyInternal: return(DsImages.PropertyInternal);
case Glyph.RangeVariable: return(DsImages.LocalVariable);
case Glyph.Reference: return(DsImages.Reference);
case Glyph.StructurePublic: return(DsImages.StructurePublic);
case Glyph.StructureProtected: return(DsImages.StructureProtected);
case Glyph.StructurePrivate: return(DsImages.StructurePrivate);
case Glyph.StructureInternal: return(DsImages.StructureInternal);
case Glyph.TypeParameter: return(DsImages.Type);
case Glyph.Snippet: return(DsImages.Snippet);
case Glyph.CompletionWarning: return(DsImages.StatusWarning);
case Glyph.AddReference: return(DsImages.AddReference);
case Glyph.NuGet: return(DsImages.NuGet);
default:
Debug.Fail($"Unknown {nameof(Glyph)}: {glyph}");
return(null);
}
}
public static StandardGlyphGroup GetStandardGlyphGroup(this Glyph glyph)
{
switch (glyph)
{
case Glyph.Assembly:
return(StandardGlyphGroup.GlyphAssembly);
case Glyph.BasicFile:
case Glyph.BasicProject:
return(StandardGlyphGroup.GlyphVBProject);
case Glyph.ClassPublic:
case Glyph.ClassProtected:
case Glyph.ClassPrivate:
case Glyph.ClassInternal:
return(StandardGlyphGroup.GlyphGroupClass);
case Glyph.ConstantPublic:
case Glyph.ConstantProtected:
case Glyph.ConstantPrivate:
case Glyph.ConstantInternal:
return(StandardGlyphGroup.GlyphGroupConstant);
case Glyph.CSharpFile:
return(StandardGlyphGroup.GlyphCSharpFile);
case Glyph.CSharpProject:
return(StandardGlyphGroup.GlyphCoolProject);
case Glyph.DelegatePublic:
case Glyph.DelegateProtected:
case Glyph.DelegatePrivate:
case Glyph.DelegateInternal:
return(StandardGlyphGroup.GlyphGroupDelegate);
case Glyph.EnumPublic:
case Glyph.EnumProtected:
case Glyph.EnumPrivate:
case Glyph.EnumInternal:
return(StandardGlyphGroup.GlyphGroupEnum);
case Glyph.EnumMember:
return(StandardGlyphGroup.GlyphGroupEnumMember);
case Glyph.Error:
return(StandardGlyphGroup.GlyphGroupError);
case Glyph.ExtensionMethodPublic:
return(StandardGlyphGroup.GlyphExtensionMethod);
case Glyph.ExtensionMethodProtected:
return(StandardGlyphGroup.GlyphExtensionMethodProtected);
case Glyph.ExtensionMethodPrivate:
return(StandardGlyphGroup.GlyphExtensionMethodPrivate);
case Glyph.ExtensionMethodInternal:
return(StandardGlyphGroup.GlyphExtensionMethodInternal);
case Glyph.EventPublic:
case Glyph.EventProtected:
case Glyph.EventPrivate:
case Glyph.EventInternal:
return(StandardGlyphGroup.GlyphGroupEvent);
case Glyph.FieldPublic:
case Glyph.FieldProtected:
case Glyph.FieldPrivate:
case Glyph.FieldInternal:
return(StandardGlyphGroup.GlyphGroupField);
case Glyph.InterfacePublic:
case Glyph.InterfaceProtected:
case Glyph.InterfacePrivate:
case Glyph.InterfaceInternal:
return(StandardGlyphGroup.GlyphGroupInterface);
case Glyph.Intrinsic:
return(StandardGlyphGroup.GlyphGroupIntrinsic);
case Glyph.Keyword:
return(StandardGlyphGroup.GlyphKeyword);
case Glyph.Label:
return(StandardGlyphGroup.GlyphGroupIntrinsic);
case Glyph.Local:
return(StandardGlyphGroup.GlyphGroupVariable);
case Glyph.Namespace:
return(StandardGlyphGroup.GlyphGroupNamespace);
case Glyph.MethodPublic:
case Glyph.MethodProtected:
case Glyph.MethodPrivate:
case Glyph.MethodInternal:
return(StandardGlyphGroup.GlyphGroupMethod);
case Glyph.ModulePublic:
case Glyph.ModuleProtected:
case Glyph.ModulePrivate:
case Glyph.ModuleInternal:
return(StandardGlyphGroup.GlyphGroupModule);
case Glyph.OpenFolder:
return(StandardGlyphGroup.GlyphOpenFolder);
case Glyph.Operator:
return(StandardGlyphGroup.GlyphGroupOperator);
case Glyph.Parameter:
return(StandardGlyphGroup.GlyphGroupVariable);
case Glyph.PropertyPublic:
case Glyph.PropertyProtected:
case Glyph.PropertyPrivate:
case Glyph.PropertyInternal:
return(StandardGlyphGroup.GlyphGroupProperty);
case Glyph.RangeVariable:
return(StandardGlyphGroup.GlyphGroupVariable);
case Glyph.Reference:
return(StandardGlyphGroup.GlyphReference);
case Glyph.StructurePublic:
case Glyph.StructureProtected:
case Glyph.StructurePrivate:
case Glyph.StructureInternal:
return(StandardGlyphGroup.GlyphGroupStruct);
case Glyph.TypeParameter:
return(StandardGlyphGroup.GlyphGroupType);
case Glyph.Snippet:
return(StandardGlyphGroup.GlyphCSharpExpansion);
case Glyph.CompletionWarning:
return(StandardGlyphGroup.GlyphCompletionWarning);
default:
throw new ArgumentException("glyph");
}
}
public static ImageMoniker GetImageMoniker(this Glyph glyph)
{
switch (glyph)
{
case Glyph.Assembly:
return(KnownMonikers.Assembly);
case Glyph.BasicFile:
return(KnownMonikers.VBFileNode);
case Glyph.BasicProject:
return(KnownMonikers.VBProjectNode);
case Glyph.ClassPublic:
return(KnownMonikers.ClassPublic);
case Glyph.ClassProtected:
return(KnownMonikers.ClassProtected);
case Glyph.ClassPrivate:
return(KnownMonikers.ClassPrivate);
case Glyph.ClassInternal:
return(KnownMonikers.ClassInternal);
case Glyph.CSharpFile:
return(KnownMonikers.CSFileNode);
case Glyph.CSharpProject:
return(KnownMonikers.CSProjectNode);
case Glyph.ConstantPublic:
return(KnownMonikers.ConstantPublic);
case Glyph.ConstantProtected:
return(KnownMonikers.ConstantProtected);
case Glyph.ConstantPrivate:
return(KnownMonikers.ConstantPrivate);
case Glyph.ConstantInternal:
return(KnownMonikers.ConstantInternal);
case Glyph.DelegatePublic:
return(KnownMonikers.DelegatePublic);
case Glyph.DelegateProtected:
return(KnownMonikers.DelegateProtected);
case Glyph.DelegatePrivate:
return(KnownMonikers.DelegatePrivate);
case Glyph.DelegateInternal:
return(KnownMonikers.DelegateInternal);
case Glyph.EnumPublic:
return(KnownMonikers.EnumerationPublic);
case Glyph.EnumProtected:
return(KnownMonikers.EnumerationProtected);
case Glyph.EnumPrivate:
return(KnownMonikers.EnumerationPrivate);
case Glyph.EnumInternal:
return(KnownMonikers.EnumerationInternal);
case Glyph.EnumMember:
return(KnownMonikers.EnumerationItemPublic);
case Glyph.Error:
return(KnownMonikers.StatusError);
case Glyph.EventPublic:
return(KnownMonikers.EventPublic);
case Glyph.EventProtected:
return(KnownMonikers.EventProtected);
case Glyph.EventPrivate:
return(KnownMonikers.EventPrivate);
case Glyph.EventInternal:
return(KnownMonikers.EventInternal);
// Extension methods have the same glyph regardless of accessibility.
case Glyph.ExtensionMethodPublic:
case Glyph.ExtensionMethodProtected:
case Glyph.ExtensionMethodPrivate:
case Glyph.ExtensionMethodInternal:
return(KnownMonikers.ExtensionMethod);
case Glyph.FieldPublic:
return(KnownMonikers.FieldPublic);
case Glyph.FieldProtected:
return(KnownMonikers.FieldProtected);
case Glyph.FieldPrivate:
return(KnownMonikers.FieldPrivate);
case Glyph.FieldInternal:
return(KnownMonikers.FieldInternal);
case Glyph.InterfacePublic:
return(KnownMonikers.InterfacePublic);
case Glyph.InterfaceProtected:
return(KnownMonikers.InterfaceProtected);
case Glyph.InterfacePrivate:
return(KnownMonikers.InterfacePrivate);
case Glyph.InterfaceInternal:
return(KnownMonikers.InterfaceInternal);
// TODO: Figure out the right thing to return here.
case Glyph.Intrinsic:
return(KnownMonikers.Type);
case Glyph.Keyword:
return(KnownMonikers.IntellisenseKeyword);
case Glyph.Label:
return(KnownMonikers.Label);
case Glyph.Parameter:
case Glyph.Local:
return(KnownMonikers.LocalVariable);
case Glyph.Namespace:
return(KnownMonikers.Namespace);
case Glyph.MethodPublic:
return(KnownMonikers.MethodPublic);
case Glyph.MethodProtected:
return(KnownMonikers.MethodProtected);
case Glyph.MethodPrivate:
return(KnownMonikers.MethodPrivate);
case Glyph.MethodInternal:
return(KnownMonikers.MethodInternal);
case Glyph.ModulePublic:
return(KnownMonikers.ModulePublic);
case Glyph.ModuleProtected:
return(KnownMonikers.ModuleProtected);
case Glyph.ModulePrivate:
return(KnownMonikers.ModulePrivate);
case Glyph.ModuleInternal:
return(KnownMonikers.ModuleInternal);
case Glyph.OpenFolder:
return(KnownMonikers.OpenFolder);
case Glyph.Operator:
return(KnownMonikers.Operator);
case Glyph.PropertyPublic:
return(KnownMonikers.PropertyPublic);
case Glyph.PropertyProtected:
return(KnownMonikers.PropertyProtected);
case Glyph.PropertyPrivate:
return(KnownMonikers.PropertyPrivate);
case Glyph.PropertyInternal:
return(KnownMonikers.PropertyInternal);
case Glyph.RangeVariable:
return(KnownMonikers.FieldPublic);
case Glyph.Reference:
return(KnownMonikers.Reference);
case Glyph.StructurePublic:
return(KnownMonikers.ValueTypePublic);
case Glyph.StructureProtected:
return(KnownMonikers.ValueTypeProtected);
case Glyph.StructurePrivate:
return(KnownMonikers.ValueTypePrivate);
case Glyph.StructureInternal:
return(KnownMonikers.ValueTypeInternal);
case Glyph.TypeParameter:
return(KnownMonikers.Type);
case Glyph.Snippet:
return(KnownMonikers.Snippet);
case Glyph.CompletionWarning:
return(KnownMonikers.IntellisenseWarning);
case Glyph.StatusInformation:
return(KnownMonikers.StatusInformation);
case Glyph.NuGet:
return(KnownMonikers.NuGet);
default:
throw new ArgumentException("glyph");
}
}
public static string GetEssence(Glyph g)
{
return(GetGlyphEssence(g.Number));
}
public static string GetAction(Glyph g)
{
return(GetGlyphAction(g.Number));
}
/// <summary>Gets the kerning between two glyphs.</summary> /// <param name="first">the first glyph</param> /// <param name="second">the second glyph</param> /// <returns>the kerning to be applied</returns> public abstract int GetKerning(Glyph first, Glyph second);
/// <summary>Get glyph's bbox.</summary>
/// <param name="unicode">a unicode symbol or FontSpecif code.</param>
/// <returns>Gets bbox in normalized 1000 units.</returns>
public virtual int[] GetCharBBox(int unicode)
{
Glyph glyph = GetGlyph(unicode);
return(glyph != null?glyph.GetBbox() : null);
}
/// <summary>Get glyph's width.</summary>
/// <param name="unicode">a unicode symbol or FontSpecif code.</param>
/// <returns>Gets width in normalized 1000 units.</returns>
public virtual int GetWidth(int unicode)
{
Glyph glyph = GetGlyph(unicode);
return(glyph != null?glyph.GetWidth() : 0);
}
public override void OnDragLeave(Glyph g, EventArgs e)
{
base.OnDragLeave(g, e);
}
private static void AssertValidDefinitionProperties(LSP.VSInternalReferenceItem[] referenceItems, int definitionIndex, Glyph definitionGlyph)
{
var definition = referenceItems[definitionIndex];
var definitionId = definition.DefinitionId;
Assert.NotNull(definition.DefinitionText);
Assert.Equal(definitionGlyph.GetImageId(), definition.DefinitionIcon.ImageId);
for (var i = 0; i < referenceItems.Length; i++)
{
if (i == definitionIndex)
{
continue;
}
Assert.Null(referenceItems[i].DefinitionText);
Assert.Equal(0, referenceItems[i].DefinitionIcon.ImageId.Id);
Assert.Equal(definitionId, referenceItems[i].DefinitionId);
Assert.NotEqual(definitionId, referenceItems[i].Id);
}
}
public override void OnDragOver(Glyph g, System.Windows.Forms.DragEventArgs e)
{
base.OnDragOver(g, e);
}
void LoadGlyph()
{
glyphList = new List <Glyph>();
// load font config file
using (Stream stream = new MemoryStream(xmlFile.bytes))
{
XmlReaderSettings settings = new XmlReaderSettings();
settings.IgnoreComments = true;
settings.IgnoreWhitespace = true;
using (XmlReader reader = XmlReader.Create(stream, settings))
{
reader.MoveToContent();
reader.ReadStartElement("fontconfig");
{
// typeface
if (reader.Name == "font")
{
lineHeight = int.Parse(reader.GetAttribute("height"));
// move to next
reader.Read();
}
// texture info
if (reader.Name == "texture")
{
textureWidth = int.Parse(reader.GetAttribute("width"));
textureHeight = int.Parse(reader.GetAttribute("height"));
// move to next
reader.Read();
}
// texture info
reader.ReadToFollowing("size");
if (reader.Name == "size")
{
//glyphWidth = int.Parse(reader.GetAttribute("width"));
//glyphHeight = int.Parse(reader.GetAttribute("height"));
// move to next
reader.Read();
}
// images
reader.ReadToFollowing("images");
if (!reader.IsEmptyElement)
{
List <string> images = new List <string>();
reader.ReadStartElement("images");
if (reader.Name == "image")
{
do
{
string imagePath = reader.GetAttribute("path");
images.Add(imagePath);
}while (reader.ReadToNextSibling("image"));
}
reader.ReadEndElement();
if (images.Count > 0)
{
// only handle one texture
texturePath = images[0];
}
else
{
Debug.LogError("image path missing");
return;
}
}
else
{
reader.Read();
}
// glyph
if (!reader.IsEmptyElement)
{
reader.ReadStartElement("glyphs");
if (reader.Name == "glyph")
{
do
{
char character = char.Parse(reader.GetAttribute("char"));
int.Parse(reader.GetAttribute("page"));
int x = int.Parse(reader.GetAttribute("x"));
int y = int.Parse(reader.GetAttribute("y"));
int w = int.Parse(reader.GetAttribute("w"));
int h = int.Parse(reader.GetAttribute("h"));
int ix = int.Parse(reader.GetAttribute("ix"));
int iy = int.Parse(reader.GetAttribute("iy"));
int iw = int.Parse(reader.GetAttribute("iw"));
int ih = int.Parse(reader.GetAttribute("ih"));
Glyph glyph = new Glyph();
glyph.code = character;
glyph.bound = new Rect(x, y, w, h);
glyph.interiorBound = new Rect(ix, iy, iw, ih);
glyph.baseline = int.Parse(reader.GetAttribute("baseline"));
glyph.spacingA = int.Parse(reader.GetAttribute("spacingA"));
glyph.spacingB = int.Parse(reader.GetAttribute("spacingB"));
glyph.spacingC = int.Parse(reader.GetAttribute("spacingC"));
baseline = glyph.baseline;
glyphList.Add(glyph);
}while (reader.ReadToNextSibling("glyph"));
}
reader.ReadEndElement();
}
else
{
reader.Read();
}
}
reader.ReadEndElement();
}
}
}
public PreviewEngine(IThreadingContext threadingContext, string title, string helpString, string description, string topLevelItemName, Glyph topLevelGlyph, Solution newSolution, Solution oldSolution, IComponentModel componentModel, bool showCheckBoxes = true)
: this(threadingContext, title, helpString, description, topLevelItemName, topLevelGlyph, newSolution, oldSolution, componentModel, null, showCheckBoxes)
{
}
internal void InternalDrawGlyph(ref InternalDrawCommand parameters, ref Vector2 fontSize, ref Glyph glyph, float x, float y, float nextx, ref Vector2 auxiliaryScaling)
{
if (char.IsWhiteSpace((char)glyph.Character) || glyph.Subrect.Width == 0 || glyph.Subrect.Height == 0)
{
return;
}
var spriteEffects = parameters.SpriteEffects;
var offset = new Vector2(x, y + GetBaseOffsetY(fontSize.Y) + glyph.Offset.Y);
Vector2.Modulate(ref offset, ref AxisDirectionTable[(int)spriteEffects & 3], out offset);
Vector2.Add(ref offset, ref parameters.Origin, out offset);
offset.X = (float)Math.Round(offset.X);
offset.Y = (float)Math.Round(offset.Y);
if (spriteEffects != SpriteEffects.None)
{
// For mirrored characters, specify bottom and/or right instead of top left.
var glyphRect = new Vector2(glyph.Subrect.Right - glyph.Subrect.Left, glyph.Subrect.Top - glyph.Subrect.Bottom);
Vector2.Modulate(ref glyphRect, ref AxisIsMirroredTable[(int)spriteEffects & 3], out offset);
}
var destination = new RectangleF(parameters.Position.X, parameters.Position.Y, parameters.Scale.X, parameters.Scale.Y);
RectangleF?sourceRectangle = glyph.Subrect;
parameters.SpriteBatch.DrawSprite(Textures[glyph.BitmapIndex], ref destination, true, ref sourceRectangle, parameters.Color, parameters.Rotation, ref offset, spriteEffects, ImageOrientation.AsIs, parameters.Depth, Swizzle, true);
}
public static string GetPower(Glyph g)
{
return(GetGlyphPower(g.Number));
}
internal void InternalUIDrawGlyph(ref InternalUIDrawCommand parameters, ref Vector2 requestedFontSize, ref Glyph glyph, float x, float y, float nextx, ref Vector2 auxiliaryScaling)
{
if (char.IsWhiteSpace((char)glyph.Character))
{
return;
}
// Skip items with null size
var elementSize = new Vector2(auxiliaryScaling.X * glyph.Subrect.Width / parameters.RealVirtualResolutionRatio.X,
auxiliaryScaling.Y * glyph.Subrect.Height / parameters.RealVirtualResolutionRatio.Y);
if (elementSize.Length() < MathUtil.ZeroTolerance)
{
return;
}
var xShift = x;
var yShift = y + (GetBaseOffsetY(requestedFontSize.Y) + glyph.Offset.Y * auxiliaryScaling.Y);
if (parameters.SnapText)
{
xShift = (float)Math.Round(xShift);
yShift = (float)Math.Round(yShift);
}
var xScaledShift = xShift / parameters.RealVirtualResolutionRatio.X;
var yScaledShift = yShift / parameters.RealVirtualResolutionRatio.Y;
var worldMatrix = parameters.Matrix;
worldMatrix.M41 += worldMatrix.M11 * xScaledShift + worldMatrix.M21 * yScaledShift;
worldMatrix.M42 += worldMatrix.M12 * xScaledShift + worldMatrix.M22 * yScaledShift;
worldMatrix.M43 += worldMatrix.M13 * xScaledShift + worldMatrix.M23 * yScaledShift;
worldMatrix.M11 *= elementSize.X;
worldMatrix.M12 *= elementSize.X;
worldMatrix.M13 *= elementSize.X;
worldMatrix.M21 *= elementSize.Y;
worldMatrix.M22 *= elementSize.Y;
worldMatrix.M23 *= elementSize.Y;
RectangleF sourceRectangle = glyph.Subrect;
parameters.Batch.DrawCharacter(Textures[glyph.BitmapIndex], ref worldMatrix, ref sourceRectangle, ref parameters.Color, parameters.DepthBias, Swizzle);
}
private void InitializeFontProperties()
{
// initialize sfnt tables
OpenTypeParser.HeaderTable head = fontParser.GetHeadTable();
OpenTypeParser.HorizontalHeader hhea = fontParser.GetHheaTable();
OpenTypeParser.WindowsMetrics os_2 = fontParser.GetOs_2Table();
OpenTypeParser.PostTable post = fontParser.GetPostTable();
isFontSpecific = fontParser.GetCmapTable().fontSpecific;
kerning = fontParser.ReadKerning(head.unitsPerEm);
bBoxes = fontParser.ReadBbox(head.unitsPerEm);
// font names group
fontNames = fontParser.GetFontNames();
// font metrics group
fontMetrics.SetUnitsPerEm(head.unitsPerEm);
fontMetrics.UpdateBbox(head.xMin, head.yMin, head.xMax, head.yMax);
fontMetrics.SetNumberOfGlyphs(fontParser.ReadNumGlyphs());
fontMetrics.SetGlyphWidths(fontParser.GetGlyphWidthsByIndex());
fontMetrics.SetTypoAscender(os_2.sTypoAscender);
fontMetrics.SetTypoDescender(os_2.sTypoDescender);
fontMetrics.SetCapHeight(os_2.sCapHeight);
fontMetrics.SetXHeight(os_2.sxHeight);
fontMetrics.SetItalicAngle(post.italicAngle);
fontMetrics.SetAscender(hhea.Ascender);
fontMetrics.SetDescender(hhea.Descender);
fontMetrics.SetLineGap(hhea.LineGap);
fontMetrics.SetWinAscender(os_2.usWinAscent);
fontMetrics.SetWinDescender(os_2.usWinDescent);
fontMetrics.SetAdvanceWidthMax(hhea.advanceWidthMax);
fontMetrics.SetUnderlinePosition((post.underlinePosition - post.underlineThickness) / 2);
fontMetrics.SetUnderlineThickness(post.underlineThickness);
fontMetrics.SetStrikeoutPosition(os_2.yStrikeoutPosition);
fontMetrics.SetStrikeoutSize(os_2.yStrikeoutSize);
fontMetrics.SetSubscriptOffset(-os_2.ySubscriptYOffset);
fontMetrics.SetSubscriptSize(os_2.ySubscriptYSize);
fontMetrics.SetSuperscriptOffset(os_2.ySuperscriptYOffset);
fontMetrics.SetSuperscriptSize(os_2.ySuperscriptYSize);
fontMetrics.SetIsFixedPitch(post.isFixedPitch);
// font identification group
String[][] ttfVersion = fontNames.GetNames(5);
if (ttfVersion != null)
{
fontIdentification.SetTtfVersion(ttfVersion[0][3]);
}
String[][] ttfUniqueId = fontNames.GetNames(3);
if (ttfUniqueId != null)
{
fontIdentification.SetTtfVersion(ttfUniqueId[0][3]);
}
byte[] pdfPanose = new byte[12];
pdfPanose[1] = (byte)(os_2.sFamilyClass);
pdfPanose[0] = (byte)(os_2.sFamilyClass >> 8);
Array.Copy(os_2.panose, 0, pdfPanose, 2, 10);
fontIdentification.SetPanose(pdfPanose);
IDictionary <int, int[]> cmap = GetActiveCmap();
int[] glyphWidths = fontParser.GetGlyphWidthsByIndex();
int numOfGlyphs = fontMetrics.GetNumberOfGlyphs();
unicodeToGlyph = new LinkedDictionary <int, Glyph>(cmap.Count);
codeToGlyph = new LinkedDictionary <int, Glyph>(numOfGlyphs);
avgWidth = 0;
foreach (int charCode in cmap.Keys)
{
int index = cmap.Get(charCode)[0];
if (index >= numOfGlyphs)
{
ILog LOGGER = LogManager.GetLogger(typeof(iText.IO.Font.TrueTypeFont));
LOGGER.Warn(MessageFormatUtil.Format(iText.IO.LogMessageConstant.FONT_HAS_INVALID_GLYPH, GetFontNames().GetFontName
(), index));
continue;
}
Glyph glyph = new Glyph(index, glyphWidths[index], charCode, bBoxes != null ? bBoxes[index] : null);
unicodeToGlyph.Put(charCode, glyph);
// This is done on purpose to keep the mapping to glyphs with smaller unicode values, in contrast with
// larger values which often represent different forms of other characters.
if (!codeToGlyph.ContainsKey(index))
{
codeToGlyph.Put(index, glyph);
}
avgWidth += glyph.GetWidth();
}
FixSpaceIssue();
for (int index = 0; index < glyphWidths.Length; index++)
{
if (codeToGlyph.ContainsKey(index))
{
continue;
}
Glyph glyph = new Glyph(index, glyphWidths[index], -1);
codeToGlyph.Put(index, glyph);
avgWidth += glyph.GetWidth();
}
if (codeToGlyph.Count != 0)
{
avgWidth /= codeToGlyph.Count;
}
ReadGdefTable();
ReadGsubTable();
ReadGposTable();
isVertical = false;
}
public override int GetKerning(Glyph glyph1, Glyph glyph2)
{
return(0);
}
public static ImageSource GetImageSource(this Glyph glyph, IGlyphService glyphService)
{
return(glyphService.GetGlyph(glyph.GetStandardGlyphGroup(), glyph.GetStandardGlyphItem()));
}
public override void OnLoseCapture(Glyph g, EventArgs e)
{
base.OnLoseCapture(g, e);
}
/// <summary>
/// draw specfic glyph with current settings, at specific position
/// </summary>
/// <param name="glyph"></param>
/// <param name="x"></param>
/// <param name="y"></param>
public void DrawGlyph(Glyph glyph, double x, double y)
{
//TODO...
}
public virtual void IsDigitPositiveTest()
{
Glyph glyph = new Glyph(0, 0, '8');
NUnit.Framework.Assert.IsTrue(iText.IO.Util.TextUtil.IsLetterOrDigit(glyph));
}
public override bool OnMouseEnter(Glyph g)
{
return(base.OnMouseEnter(g));
}
public override void OnQueryContinueDrag(Glyph g, System.Windows.Forms.QueryContinueDragEventArgs e)
{
base.OnQueryContinueDrag(g, e);
}
public override void OnGiveFeedback(Glyph g, System.Windows.Forms.GiveFeedbackEventArgs e)
{
base.OnGiveFeedback(g, e);
}
public Result(Solution solutionWithProperty, string name, Glyph glyph)
{
this.Solution = solutionWithProperty;
this.Name = name;
this.Glyph = glyph;
}
public Result(Solution solutionWithProperty, string name, Glyph glyph, List <IFieldSymbol> failedFieldSymbols) :
this(solutionWithProperty, name, glyph)
{
this.FailedFields = failedFieldSymbols.ToImmutableArrayOrEmpty();
}
public override bool OnMouseUp(Glyph g, MouseButtons button)
{
_designer.AddPanel(this, EventArgs.Empty);
return(base.OnMouseUp(g, button));
}
