private void DrawStringGDI(Color color, FontConfig font, int x, int y, string text)
{
if (color.IsFullyOpaque())
{
DrawOpaqueStringGDI(color, font, x, y, text);
return;
}
SelectGDIFont(font);
Gdi32API.GetTextExtentPoint32W(hdc, text, text.Length, out var size);
int leftPadding, rightPadding;
if (font.IsItalic)
{
int infFontSize = Convert.ToInt32(font.Size);
leftPadding = 1 + (4 * infFontSize + 199) / 200;
rightPadding = 1 + (11 * infFontSize + 199) / 200;
}
else
{
leftPadding = 0;
rightPadding = 0;
}
WithTransparentCanvas(
new Rectangle(x - leftPadding, y, size.cx + leftPadding + rightPadding, size.cy),
color.A, true,
canvas => canvas.DrawOpaqueStringGDI(color, font, leftPadding, 0, text)
);
}
public static FontStyle GetFontStyle(FontConfig font)
{
FontStyle style = FontStyle.FontStyleRegular;
if (font.IsBold)
{
style |= FontStyle.FontStyleBold;
}
if (font.IsItalic)
{
style |= FontStyle.FontStyleItalic;
}
if (font.IsUnderline)
{
style |= FontStyle.FontStyleUnderline;
}
if (font.IsStrikeout)
{
style |= FontStyle.FontStyleStrikeout;
}
return(style);
}
public static TMP_FontAsset LoadFontAsset(FontConfig config)
{
TMP_FontAsset font = null;
try
{
if (config.Local)
{
var path = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Assets", config.Filename);
font = AssetBundle.LoadFromFile(path).LoadAllAssets <TMP_FontAsset>()[0];
}
else
{
var path = Path.Combine(Application.streamingAssetsPath, "fonts", config.Filename);
font = AssetBundle.LoadFromFile(path).LoadAllAssets <TMP_FontAsset>()[0];
}
AssetBundle.UnloadAllAssetBundles(false);
font.fontInfo.Scale = config.Scale;
}
catch (Exception e)
{
Debug.Log($"Load font failure...Exception: {e.Message}");
}
return(font);
}
protected override void OnPaint(ICanvas canvas, Rectangle area)
{
FontConfig arial = new FontConfig("Arial", 16);
canvas.FillRectangle(Color.LightBlue, 0, 0, 200, 25);
canvas.DrawString(Color.Black, arial, 1, 1, $"Mouse: {MousePosition}");
}
private void DrawOpaqueStringGDI(Color color, FontConfig font, int x, int y, string text)
{
SelectGDIFont(font);
Gdi32API.SetBkModeChecked(hdc, Gdi32BackgroundMode.TRANSPARENT);
Gdi32API.SetTextColorChecked(hdc, Gdi32API.ToCOLORREF(color));
Gdi32API.TextOutW(hdc, x, y, text, text.Length);
}
private void DrawStringGDIPlus(Color color, FontConfig font, int x, int y, string text)
{
PrepareGraphics();
PrepareDefaultStringFormat();
GdiPlusAPI.CheckStatus(GdiPlusAPI.GdipCreateFontFamilyFromName(font.FontFamily, IntPtr.Zero, out var fontFamilyPtr));
try
{
FontStyle fontStyle = GdiPlusAPI.GetFontStyle(font);
GdiPlusAPI.CheckStatus(GdiPlusAPI.GdipCreateFont(fontFamilyPtr, font.Size, fontStyle, Unit.UnitPixel, out var fontPtr));
try
{
GdiPlusAPI.CheckStatus(GdiPlusAPI.GdipCreateSolidFill(color.ToArgb(), out var brush));
try
{
RectF rect = new RectF(x, y, 0, 0);
GdiPlusAPI.GdipDrawString(graphics, text, text.Length, fontPtr, ref rect, defaultStringFormat, brush);
}
finally
{
GdiPlusAPI.CheckStatus(GdiPlusAPI.GdipDeleteBrush(brush));
}
}
finally
{
GdiPlusAPI.CheckStatus(GdiPlusAPI.GdipDeleteFont(fontPtr));
}
}
finally
{
GdiPlusAPI.CheckStatus(GdiPlusAPI.GdipDeleteFontFamily(fontFamilyPtr));
}
}
public Size MeasureString(FontConfig font, string text)
{
XftFontExt fontExt = objectCache.GetXftFont(font);
byte[] utf32Text = Encoding.UTF32.GetBytes(text);
int width = 0;
GCHandle utf32TextHandle = GCHandle.Alloc(utf32Text, GCHandleType.Pinned);
try
{
IntPtr utf32TextPtr = utf32TextHandle.AddrOfPinnedObject();
foreach (var range in fontExt.GetRanges(utf32Text))
{
LibXft.XftTextExtents32(
display,
range.Font,
utf32TextPtr + range.Start,
(range.End - range.Start) / 4,
out var extents
);
width += extents.xOff;
}
}
finally
{
utf32TextHandle.Free();
}
var fontInfo = Marshal.PtrToStructure <XftFont>(fontExt.MainFont);
return(new Size(width, fontInfo.height));
}
public void DrawString(Color color, FontConfig font, int x, int y, string text)
{
x -= origin.X;
y -= origin.Y;
var xftColorPtr = Marshal.AllocHGlobal(Marshal.SizeOf <XftColor>());
try
{
XRenderColor xColor = new XRenderColor(color);
LibXft.XftColorAllocValue(
display,
visual,
colormap,
ref xColor,
xftColorPtr
);
try
{
XftFontExt fontExt = objectCache.GetXftFont(font);
var fontInfo = Marshal.PtrToStructure <XftFont>(fontExt.MainFont);
int xOffset = DrawString(xftDraw, xftColorPtr, fontExt, x, y + fontInfo.ascent, text);
if (font.IsUnderline)
{
int lineHeight = Convert.ToInt32(Math.Max(font.Size / 10, 1));
LibXRender.XRenderFillRectangle(
display, PictOp.PictOpOver, pictureId, ref xColor,
x,
y + fontInfo.ascent + (fontInfo.descent - lineHeight) / 2,
(uint)xOffset,
(uint)lineHeight
);
}
if (font.IsStrikeout)
{
int lineHeight = Convert.ToInt32(Math.Max(font.Size / 20, 1));
LibXRender.XRenderFillRectangle
(
display, PictOp.PictOpOver, pictureId, ref xColor,
x,
y + fontInfo.ascent - (2 * fontInfo.ascent + 3 * lineHeight) / 6,
(uint)xOffset,
(uint)lineHeight
);
}
}
finally
{
LibXft.XftColorFree(display, visual, colormap, xftColorPtr);
}
}
finally
{
Marshal.FreeHGlobal(xftColorPtr);
}
}
public Size MeasureString(FontConfig font, string text)
{
IntPtr hdc = Win32API.GetDCChecked(IntPtr.Zero);
try
{
IntPtr fontPtr = objectCache.GetFont(font);
IntPtr oldFont = Gdi32API.SelectObjectChecked(hdc, fontPtr);
try
{
Gdi32API.GetTextExtentPoint32W(hdc, text, text.Length, out var size);
return(new Size(size.cx, size.cy));
}
finally
{
if (oldFont != IntPtr.Zero)
{
Gdi32API.SelectObjectChecked(hdc, fontPtr);
}
}
}
finally
{
Win32API.ReleaseDCChecked(IntPtr.Zero, hdc);
}
}
private static byte[] GetXftFontConfig(FontConfig font, int codePoint)
{
StringBuilder sb = new StringBuilder();
sb.Append(font.FontFamily);
if (font.IsBold)
{
sb.Append(":bold");
}
if (font.IsItalic)
{
sb.Append(":italic");
}
sb.Append(":pixelsize=");
sb.Append(font.Size.ToString("0.0", NumberFormatInfo.InvariantInfo));
if (codePoint >= 0)
{
sb.Append(":charset=");
sb.Append(codePoint.ToString("X", NumberFormatInfo.InvariantInfo));
}
sb.Append('\0');
return(Encoding.UTF8.GetBytes(sb.ToString()));
}
private XftFontExt(FontConfig fontConfig, IntPtr display, int screen, IntPtr mainFont)
{
this.fontConfig = fontConfig;
this.display = display;
this.screen = screen;
MainFont = mainFont;
fonts.Add(mainFont);
}
public void DrawString(Color color, FontConfig font, int x, int y, string text)
{
x += offset.X;
y += offset.Y;
// todo: pick
DrawStringGDI(color, font, x, y, text);
// DrawStringGDIPlus(color, font, x, y, text);
}
private void SelectGDIFont(FontConfig fontConfig)
{
IntPtr font = objectCache.GetFont(fontConfig);
IntPtr oldFont = Gdi32API.SelectObjectChecked(hdc, font);
if (originalFont == IntPtr.Zero)
{
originalFont = oldFont;
}
}
public Textbox(string fontName)
{
CursorAdvance = 0;
_fontmap = new Texture($"{fontName}/font.png", "Fonts");
_fontConfig = new FontConfig(fontName);
_shader = new Shader("vs.vert", "font.frag");
_shader.SetUniformValue("tex", new IntUniform
{
Value = 0
});
_shader.Use();
Hue = 1;
Saturation = 0;
Value = 1;
}
protected override void OnPaint(ICanvas canvas, Rectangle area)
{
const string sampleText = "Sample Text [x-\u263A\u03BE\u2690\xD83C\xDFC1][\u96EA]";
FontConfig arial = new FontConfig("Arial", 14);
canvas.SetClipRectangle(0, 0, Area.Width - 10, Area.Height);
canvas.FillRectangle(Color.FromArgb(0xFF, 0xFF, 0x98), 10, 10, Area.Width - 20, 16);
canvas.DrawString(Color.Blue, arial, 11, 11, sampleText);
canvas.FillRectangle(Color.FromArgb(0xFF, 0xFF, 0x98), 10, 30, Area.Width - 20, 16);
canvas.DrawString(Color.FromArgb(0x80, Color.Blue), arial, 11, 31, sampleText);
FontConfig times = new FontConfig("Times New Roman", 36).Bold().Italic().Underline().Strikeout();
canvas.FillRectangle(Color.FromArgb(0xFF, 0xFF, 0x98), 10, 50, Area.Width - 20, 45);
canvas.DrawString(Color.DarkBlue, times, 11, 51, sampleText);
}
protected override void OnEnable()
{
base.OnEnable();
_i18NText = (I18NText)target;
GameC.app.initConfigForEditor();
FontConfig[] configs = FontConfig.getDic();
if (_fontConfigList.length() == 0)
{
foreach (var fontConfig in FontConfig.getDic())
{
if (fontConfig != null)
{
_fontConfigList.add(fontConfig);
}
}
options = new string[_fontConfigList.length()];
for (int i = 0; i < _fontConfigList.length(); ++i)
{
options[i] = _fontConfigList[i].name;
}
}
fontId = serializedObject.FindProperty("_fontId");
m_Text = serializedObject.FindProperty("m_Text");
m_FontData = serializedObject.FindProperty("m_FontData");
//看看默认选第几个
for (int i = 0; i < _fontConfigList.length(); ++i)
{
if (_fontConfigList[i].id == fontId.intValue)
{
_lastIndex = i;
break;
}
}
}
private FontConfig CreateFontConfig()
{
byte[] ReadAllBytes(Stream s)
{
using (var ms = new MemoryStream()) {
s.CopyTo(ms);
return(ms.ToArray());
}
}
var assembly = typeof(TextTest).Assembly;
var fontData = ReadAllBytes(assembly.GetManifestResourceStream("Fonts.DDin"));
var font = new Font(fontData);
var config = new FontConfig();
config.AddFontFace(font.FontFaces[0], "D-DIN", FontStyle.Normal, 300);
return(config);
}
protected override void OnLoad(EventArgs e)
{
CursorVisible = true;
GL.ClearColor(0.2f, 0.2f, 0.2f, 1);
Logger.Log()(LogLevel.INFO, "Initialized JsonAnything");
IO io = ImGui.GetIO();
ImGui.GetIO().FontAtlas.AddDefaultFont();
FontConfig cfg = new FontConfig
{
MergeMode = 1,
PixelSnapH = 1
};
ImGuiRenderer.AddFontFromFileTTF("fonts/fa-solid-900.ttf", 16, cfg,
new[] { (char)FontAwesome5.IconMin, (char)FontAwesome5.IconMax, (char)0 });
}
public static void AddFontFromFileTTF(string filename, float sizePixels, FontConfig config, char[] glyphRanges)
{
IO io = ImGui.GetIO();
config.OversampleH = 1;
config.OversampleV = 1;
config.RasterizerMultiply = 1;
IntPtr cnfPtr = Marshal.AllocHGlobal(Marshal.SizeOf <FontConfig>());
Marshal.StructureToPtr(config, cnfPtr, false);
unsafe
{
NativeFontAtlas *atlas = io.GetNativePointer()->FontAtlas;
fixed(char *glyphs = &glyphRanges[0])
{
ImGuiNative.ImFontAtlas_AddFontFromFileTTF(atlas, filename, sizePixels, cnfPtr,
glyphs);
}
}
}
/************************************************Unity方法与事件***********************************************/
protected override void Start()
{
base.Start();
videoPlayer.loopPointReached += (VideoPlayer source) =>
{
bMovieEnd = true;
};
BuglyUtil.Init();
videoPlayer.Prepare();
MissionConifg.LoadMissionConfig();
propertyConfig.LoadPropertyConfig();
TaskConifg.LoadTaskData();
ItemConifg.LoadItemsConfig();
TreasureBoxConfig.LoadTreasureBoxConfig();
iconManager.OnlyLoadSelf();
RoleConifg.LoadRoleConfig();
LanConfig.LoadLanConfig();
FontConfig.LoadFontConfig();
I18NConfig.LoadResConfig();
AccessoryConfig.LoadAccessoryConfig();
AwardConfig.LoadAwardConfig();
ActionConifg.LoadActionConfig();
LevelConifg.LoadLevelConfig();
SoundConfig.LoadSoundConfig();
imageProgress.fillAmount = 0;
GuLog.Debug("<><Preload>Load Begin!");
StartCoroutine(StartLoading());
#if CLEAR_DATA
LocalDataManager.getInstance().deleteAll();
#endif
mHeartbearActionManager.addEventListener(mUploadFreindHeatbeatAction);
mHeartbearActionManager.addEventListener(mUploadintakeHeatbeatAction);
mHeartbeatManager.setHeartbeatListener(() =>
{
GuLog.Debug("Preload start do heart beat");
mHeartbearActionManager.startHeartbeat();
});
}
// https://stackoverflow.com/questions/544972/load-fonts-from-file-on-a-c-sharp-application
// System.Drawing.Text.PrivateFontCollection
// https://web.archive.org/web/20170313145219/https://blog.andreloker.de/post/2008/07/03/Load-a-font-from-disk-stream-or-byte-array.aspx
// https://stackoverflow.com/questions/7742148/how-to-convert-text-to-svg-paths
public static void Test(string[] args)
{
if (args.Length < 1)
{
return;
}
string fontFamily = args[0];
System.IntPtr config = FontConfig.FcInitLoadConfigAndFonts();
System.IntPtr pattern = FontConfig.FcPatternCreate();
FontConfig.FcPatternAddString(pattern, FontConfig.FC_FAMILY, fontFamily);
FontConfig.FcConfigSubstitute(config, pattern, FontConfig.FcMatchKind.FcMatchPattern);
FontConfig.FcDefaultSubstitute(pattern);
System.IntPtr font = FontConfig.FcFontMatch(config, pattern, out FontConfig.FcResult result);
if (font != System.IntPtr.Zero)
{
if (FontConfig.FcPatternGetString(font, FontConfig.FC_FILE, 0, out string file) == FontConfig.FcResult.FcResultMatch)
{
System.Console.Write($"{file} ");
}
if (FontConfig.FcPatternGetString(font, FontConfig.FC_FAMILY, 0, out string family) == FontConfig.FcResult.FcResultMatch)
{
System.Console.Write($"[{family}] ");
}
if (FontConfig.FcPatternGetString(font, FontConfig.FC_POSTSCRIPT_NAME, 0, out string postscriptname) == FontConfig.FcResult.FcResultMatch)
{
System.Console.Write($"[{postscriptname}] ");
}
System.Console.WriteLine();
}
FontConfig.FcPatternDestroy(pattern);
}
public static unsafe Font AddFontFromFileTTF(this FontAtlas atlas, string fileName, float pixelSize, FontConfig config, char[] glyphRanges)
{
NativeFontAtlas *atlasPtr = ImGui.GetIO().GetNativePointer()->FontAtlas;
IntPtr cfgPtr = Marshal.AllocHGlobal(Marshal.SizeOf(config));
Marshal.StructureToPtr(config, cfgPtr, false);
fixed(char *glyphPtr = &glyphRanges[0])
{
NativeFont *fontPtr =
ImGuiNative.ImFontAtlas_AddFontFromFileTTF(atlasPtr, fileName, pixelSize, cfgPtr, glyphPtr);
return(new Font(fontPtr));
}
}
void parseXML(string filePath)
{
XDocument xDoc = XDocument.Load(filePath);
List <XElement> element = xDoc.Elements("locale").ToList();
if (element != null)
{
lManager.Enter(Sender.MANAGER, Level.DEBUG, "<locale/> found for locale:{0}", key);
Locale locale = new Locale();
if (!element[0].HasAttributes)
{
lManager.Enter(Sender.MANAGER, Level.ERROR, "<locale/> element does not have expected attributes!");
return;
}
locale.Name = element[0].FirstAttribute.Value;
List <XElement> childNodes = element[0].Elements().ToList();
locale.DisplayName = childNodes[0].Value;
locale.Encoding = Convert.ToInt32(childNodes[1].Value);
FontConfig globalFont = new FontConfig();
System.Windows.Forms.RightToLeft rightToLeft = System.Windows.Forms.RightToLeft.No;
if (childNodes.Count == 4) // Global font is likely defined
{
if (childNodes[2].Name == "font")
{
List <XElement> fontElements = childNodes[2].Elements().ToList();
globalFont.Style = (System.Drawing.FontStyle)Enum.Parse(typeof(System.Drawing.FontStyle), fontElements[0].Value);
globalFont.Size = Convert.ToDouble(fontElements[1].Value, CultureInfo.InvariantCulture);
lManager.Enter(Sender.MANAGER, Level.DEBUG, "Global <font/> is defined.\nFamily:{0}\nStyle:{1}\nSize:{2}", globalFont.Name,
globalFont.Style.ToString(),
globalFont.Size);
}
}
else if (childNodes.Count == 5) // Global right to left is likely defined
{
if (childNodes[3].Name == "rightToLeft")
{
rightToLeft = (System.Windows.Forms.RightToLeft)Enum.Parse(typeof(System.Windows.Forms.RightToLeft), childNodes[3].Value);
lManager.Enter(Sender.MANAGER, Level.DEBUG, "Global <rightToLeft/> defined.");
}
}
// Get the <control/> nodes in the <controls/> elemenent
childNodes = childNodes[childNodes.Count - 1].Elements().ToList();
lManager.Enter(Sender.MANAGER, Level.DEBUG, "{0} <control/> nodes found.", childNodes.Count);
List <ControlConfig> controls = new List <ControlConfig>();
for (int c = 0; c < childNodes.Count; c++)
{
ControlConfig control = new ControlConfig();
if (childNodes[c].HasAttributes)
{
List <XAttribute> attributes = childNodes[c].Attributes().ToList();
if (attributes.Count >= 1)
{
control.Name = attributes[0].Value;
}
if (attributes.Count >= 2)
{
control.Comment = attributes[1].Value;
}
lManager.Enter(Sender.MANAGER, Level.DEBUG, "<control/> {0} has expected attributes.", control.Name);
}
else
{
string msg = string.Format("<control/> at index: {0} does not have attributes! Ignoring!", c);
lManager.Enter(Sender.MANAGER, Level.WARNING, msg);
System.Windows.Forms.MessageBox.Show(msg, "XML Exception", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Warning);
}
FontConfig controlFont = null;
List <XElement> fontElements = childNodes[c].Elements("font").ToList();
if (fontElements.Count > 0)
{
controlFont = new FontConfig();
controlFont.Name = fontElements[0].FirstAttribute.Value;
fontElements = fontElements[0].Elements().ToList();
controlFont.Style = (System.Drawing.FontStyle)Enum.Parse(typeof(System.Drawing.FontStyle), fontElements[0].Value);
controlFont.Size = Convert.ToDouble(fontElements[1].Value, CultureInfo.InvariantCulture);
lManager.Enter(Sender.MANAGER, Level.DEBUG, "<font/> detected.\nFamily:{0}\nStyle:{2}\nSize:{1}", controlFont.Name,
controlFont.Style.ToString(),
controlFont.Size);
}
else
{
lManager.Enter(Sender.MANAGER, Level.DEBUG, "No <font/> detected for control: {0}", control.Name);
}
control.Font = (controlFont != null) ? controlFont : globalFont;
List <XElement> locationElements = childNodes[c].Elements("location").ToList();
if (locationElements.Count == 1)
{
string[] location = childNodes[c].Elements("location").ToList()[0].Value.Split(',');
control.Location = new System.Drawing.Point(int.Parse(location[0]), int.Parse(location[1]));
lManager.Enter(Sender.MANAGER, Level.DEBUG, "<location/> detected.\nx:{0}\ny:{1}", control.Location.X,
control.Location.Y);
}
else
{
control.Location = new System.Drawing.Point(0, 0);
}
List <XElement> sizeElements = childNodes[c].Elements("size").ToList();
if (sizeElements.Count == 1)
{
string[] size = childNodes[c].Elements("size").ToList()[0].Value.Split(',');
control.Size = new System.Drawing.Size(int.Parse(size[0]), int.Parse(size[1]));
lManager.Enter(Sender.MANAGER, Level.DEBUG, "<size/> detected. \nheight:{0}\nwidth:{1}", control.Size.Height,
control.Size.Width);
}
else
{
control.Size = new System.Drawing.Size(0, 0);
}
TextConfig text = new TextConfig();
text.Alignment = System.Drawing.ContentAlignment.MiddleLeft;
List <XElement> textElements = childNodes[c].Elements("text").ToList();
if (textElements.Count > 0)
{
lManager.Enter(Sender.MANAGER, Level.DEBUG, "<text/> element detected!");
if (textElements[0].HasAttributes)
{
List <XAttribute> attributes = textElements[0].Attributes().ToList();
XAttribute attribute = attributes.Find(a => a.Name == "align");
if (attribute != null)
{
text.Alignment = (System.Drawing.ContentAlignment)Enum.Parse(typeof(System.Drawing.ContentAlignment), attribute.Value);
}
attribute = attributes.Find(a => a.Name == "rightToLeft");
if (attribute != null)
{
text.RightToLeft = (System.Windows.Forms.RightToLeft)Enum.Parse(typeof(System.Windows.Forms.RightToLeft), attribute.Value);
}
}
text.Text = textElements[0].Value;
}
else
{
text.Text = string.Empty;
}
control.Text = text;
if (control.Populated)
{
controls.Add(control);
}
}
locale.Controls = controls;
if (locale.Populated)
{
locales.Add(locale);
}
lManager.Enter(Sender.MANAGER, Level.DEBUG, string.Format("{0} controls configurations loaded from locale: {1} from\n\t- {2}", locale.Controls.Count, locale.Name, filePath));
}
}
/// <summary>
/// 刷新语言
/// </summary>
public void refreshLanguage()
{
#if UNITY_EDITOR
GameC.app.initConfigForEditor();
#endif
//补丁，以后想办法
if (FontConfig.getDic() == null)
{
Ctrl.print("**********************出现异常情况***************");
return;
}
//暂时加个补丁
if (_fontId == -1)
{
_fontId = 1;
}
//获取字体
string fontSource = FontConfig.getFontSource(_fontId);
if (String.IsNullOrEmpty(fontSource))
{
return;
}
if (font != null)
{
if (fontSource.Contains(this.font.name))
{
return;
}
}
Font loadFont = null;
if (ShineSetting.isEditor)
{
#if UNITY_EDITOR
if (fontSource.Contains("Arial"))
{
this.font = Resources.GetBuiltinResource(typeof(Font), "Arial.ttf") as Font;
}
else
{
this.font = AssetDatabase.LoadAssetAtPath <Font>("Assets/source/" + fontSource);
}
#endif
}
else
{
if (fontSource.Contains("Arial"))
{
loadFont = Resources.GetBuiltinResource(typeof(Font), "Arial.ttf") as Font;
if (loadFont != null)
{
this.font = loadFont;
}
}
else
{
LoadControl.loadOne(fontSource, () =>
{
if (this != null)
{
loadFont = LoadControl.getResource(fontSource) as Font;
if (loadFont != null)
{
this.font = loadFont;
}
}
});
}
}
}
private XftFontExt CreateXftFont(FontConfig fontConfig)
{
return(XftFontExt.Create(fontConfig, display, screen));
}
public DANFeNFeConfig(ACBrNFe acbrlib) : base(acbrlib, ACBrSessao.DANFENFe)
{
Fonte = new FontConfig <ACBrNFe>(acbrlib, ACBrSessao.DANFENFe);
}
public FontConfig()
{
_instance = this;
}
public static XftFontExt Create(FontConfig fontConfig, IntPtr display, int screen)
{
IntPtr fontPtr = LibXft.XftFontOpenName(display, screen, GetXftFontConfig(fontConfig, -1));
return(new XftFontExt(fontConfig, display, screen, fontPtr));
}
public XftFontExt GetXftFont(FontConfig fontConfig)
{
return(fonts.Get(fontConfig));
}
protected override void OnPaint(ICanvas canvas, Rectangle area)
{
Stopwatch sw = Stopwatch.StartNew();
canvas.FillRectangle(Color.Blue, 0, 0, 200, 200);
canvas.FillRectangle(Color.Lime, 1, 1, 198, 99);
canvas.FillRectangle(Color.FromArgb(0x80, Color.Red), 20, 20, 160, 200);
canvas.DrawImage(arrow, 68, 60);
canvas.DrawPath(Color.FromArgb(0xFF, Color.Green), 5, new Point[] { new Point(10, 20), new Point(25, 40), new Point(40, 30) });
canvas.DrawPath(Color.FromArgb(0x80, Color.Green), 5, new Point[] { new Point(10, 70), new Point(25, 90), new Point(40, 80) });
canvas.DrawPath(Color.FromArgb(0xC0, Color.Green), 5, new Point[] { new Point(10, 50), new Point(25, 70), new Point(40, 60) });
canvas.DrawPath(Color.FromArgb(0xFF, Color.Green), 4, new Point[] { new Point(10, 50), new Point(25, 70), new Point(40, 60) });
canvas.FillRectangle(Color.DarkBlue, 10, 110, 31, 51);
canvas.DrawPath(Color.FromArgb(0x80, Color.White), 0, new Point[] { new Point(10, 110), new Point(25, 130), new Point(40, 120) });
canvas.DrawPath(Color.FromArgb(0xFF, Color.White), 0, new Point[] { new Point(10, 140), new Point(25, 160), new Point(40, 150) });
canvas.FillRectangle(Color.DarkBlue, 60, 110, 31, 51);
canvas.DrawPath(Color.FromArgb(0x80, Color.White), 1, new Point[] { new Point(60, 110), new Point(75, 130), new Point(90, 120) });
canvas.DrawPath(Color.FromArgb(0xFF, Color.White), 1, new Point[] { new Point(60, 140), new Point(75, 160), new Point(90, 150) });
canvas.FillRectangle(Color.DarkBlue, 110, 110, 31, 51);
canvas.DrawPath(Color.FromArgb(0x80, Color.White), 2, new Point[] { new Point(110, 110), new Point(125, 130), new Point(140, 120) });
canvas.DrawPath(Color.FromArgb(0xFF, Color.White), 2, new Point[] { new Point(110, 140), new Point(125, 160), new Point(140, 150) });
canvas.FillRectangle(Color.Pink, 130, 70, 60, 40);
canvas.FillEllipse(Color.FromArgb(0xFF, Color.Green), 130, 70, 60, 40);
canvas.FillEllipse(Color.FromArgb(0x80, Color.Green), 130, 120, 60, 40);
canvas.FillEllipse(Color.FromArgb(0x20, Color.Green), 129, 169, 62, 42);
canvas.FillEllipse(Color.FromArgb(0xE0, Color.Green), 130, 170, 60, 40);
canvas.FillEllipse(Color.FromArgb(0xFF, Color.Green), 131, 171, 58, 38);
FontConfig arial = new FontConfig("Arial", 14);
const string sampleText = "Sample Text [x-\u263A\u03BE\u2690\xD83C\xDFC1][\u96EA]";
canvas.FillRectangle(Color.FromArgb(0xFF, 0xFF, 0x98), 250, 10, 450, 16);
canvas.DrawString(Color.FromArgb(0xFF, Color.DarkBlue), arial, 251, 11, sampleText);
canvas.FillRectangle(Color.FromArgb(0xFF, 0xFF, 0x98), 250, 30, 450, 16);
canvas.DrawString(Color.FromArgb(0x80, Color.DarkBlue), arial, 251, 31, sampleText);
FontConfig times = new FontConfig("Times New Roman", 36).Bold().Italic().Underline().Strikeout();
canvas.FillRectangle(Color.FromArgb(0xFF, 0xFF, 0x98), 250, 50, 450, 45);
canvas.DrawString(Color.FromArgb(0xFF, Color.DarkBlue), times, 251, 51, sampleText);
canvas.FillRectangle(Color.FromArgb(0xFF, 0xFF, 0x98), 250, 100, 450, 45);
canvas.DrawString(Color.FromArgb(0x80, Color.DarkBlue), times, 251, 101, sampleText);
sw.Stop();
double overallTimeSeconds = overallTime.Elapsed.TotalSeconds;
frameCount++;
const int labelAreaHeight = 40;
canvas.FillRectangle(Color.Black, 0, Area.Height - labelAreaHeight, Area.Width, labelAreaHeight);
if (overallTime.IsRunning)
{
int barOffset = (int)((overallTime.ElapsedMilliseconds / 10) % Area.Width);
int barWidth1 = Area.Width / 4;
int barWidth2 = barOffset + barWidth1 - Area.Width;
canvas.FillRectangle(Color.MidnightBlue, barOffset, Area.Height - labelAreaHeight, barWidth1, labelAreaHeight);
if (barWidth2 > 0)
{
canvas.FillRectangle(Color.MidnightBlue, 0, Area.Height - labelAreaHeight, barWidth2, labelAreaHeight);
}
}
canvas.DrawString(Color.White, new FontConfig("Arial", 16), 2, Area.Height - labelAreaHeight + 2, $"Paint: {area}, {sw.ElapsedMilliseconds} ms.");
canvas.DrawString(Color.White, new FontConfig("Arial", 16), 2, Area.Height - labelAreaHeight + 22, $"FPS: {frameCount / overallTimeSeconds:#.0}");
if (overallTime.IsRunning)
{
// todo: use series of messages instead?
InvalidatePainting();
}
}
