/// <summary>Returns a list of all monospace fonts installed in the system.</summary>
public static IEnumerable <string> GetMonospaceFonts()
{
if (_monospaceFontNames == null)
{
_monospaceFontNames = new HashSet <string>();
LOGFONT lf = createLogFont("");
IntPtr plogFont = Marshal.AllocHGlobal(Marshal.SizeOf(lf));
Marshal.StructureToPtr(lf, plogFont, true);
int ret = 0;
try
{
using (var bmp = new Bitmap(1024, 768, System.Drawing.Imaging.PixelFormat.Format32bppArgb))
using (var graphics = Graphics.FromImage(bmp))
{
IntPtr hdc = graphics.GetHdc();
ret = EnumFontFamiliesEx(hdc, plogFont, enumFontsCallback, IntPtr.Zero, 0);
graphics.ReleaseHdc(hdc);
}
}
finally
{
Marshal.DestroyStructure(plogFont, typeof(LOGFONT));
}
}
return(_monospaceFontNames);
}
IntPtr CreateFontIndirect_Hook(LOGFONT lplf)
{
#if DEBUG
try
{
lock (_messageQueue)
{
if (_messageQueue.Count < 1000)
{
_messageQueue.Enqueue(string.Format($"[{EasyHook.RemoteHooking.GetCurrentProcessId()}:{EasyHook.RemoteHooking.GetCurrentThreadId()}]: CreateFontIndirect_Hook {lplf}"));
}
}
}
catch
{
}
#endif
lplf.lfQuality = FontQuality.DEFAULT_QUALITY;
lplf.lfCharSet = FontCharSet.RUSSIAN_CHARSET;
if (!OkFonts.Contains(lplf.lfFaceName))
{
lplf.lfFaceName = "Arial";
}
// now call the original API...
return(CreateFontIndirectA(lplf));
}
public void ToLogFont_InvokeGraphics_ReturnsExpected(TextRenderingHint textRenderingHint, int expectedQuality)
{
using (FontFamily family = FontFamily.GenericMonospace)
using (var font = new Font(family, 10))
using (var image = new Bitmap(10, 10))
using (Graphics graphics = Graphics.FromImage(image))
{
graphics.TextRenderingHint = textRenderingHint;
var logFont = new LOGFONT();
font.ToLogFont(logFont, graphics);
Assert.Equal(-13, logFont.lfHeight);
Assert.Equal(0, logFont.lfWidth);
Assert.Equal(0, logFont.lfEscapement);
Assert.Equal(0, logFont.lfOrientation);
Assert.Equal(400, logFont.lfWeight);
Assert.Equal(0, logFont.lfItalic);
Assert.Equal(0, logFont.lfUnderline);
Assert.Equal(0, logFont.lfStrikeOut);
Assert.Equal(1, logFont.lfCharSet);
Assert.Equal(0, logFont.lfOutPrecision);
Assert.Equal(0, logFont.lfClipPrecision);
Assert.Equal(0, logFont.lfQuality);
Assert.Equal(0, logFont.lfPitchAndFamily);
Assert.Equal(family.Name, logFont.lfFaceName);
}
}
private void buildList()
{
// Need an HDC to pass to EnumFontFamilies
IntPtr hwnd = GetDesktopWindow();
IntPtr hdc = GetDC(hwnd);
LOGFONT logFont = new LOGFONT();
enumFontDelegate = new EnumFontDelegate(EnumFontFamiliesExProc);
fpEnumProc = Marshal.GetFunctionPointerForDelegate(enumFontDelegate);
EnumFontFamilies(hdc, null, fpEnumProc, IntPtr.Zero);
// We got a list of the major families. Copy the list,
// then clear it so we can go back and grab all the individual fonts.
List <string> fontFamilies = new List <string>();
fontFamilies.AddRange(fontNames);
fontNames.Clear();
foreach (string fontFamily in fontFamilies)
{
EnumFontFamilies(hdc, fontFamily, fpEnumProc, IntPtr.Zero);
}
ReleaseDC(hdc);
foreach (string s in fontNames)
{
//listBox1.Items.Add(s);
}
}
private static void AddCharSet(string fontName)
{
if (fontName != null)
{
lock (StyleProperties.m_charSetLookupLock)
{
if (!StyleProperties.m_charSetLookup.ContainsKey(fontName))
{
Font font = null;
try
{
bool flag = false;
bool flag2 = false;
font = FontCache.CreateGdiPlusFont(fontName, 400f, ref flag, ref flag2, false, false);
LOGFONT lOGFONT = new LOGFONT();
font.ToLogFont(lOGFONT);
StyleProperties.m_charSetLookup.Add(fontName, (CharSet)lOGFONT.lfCharSet);
}
finally
{
if (font != null)
{
font.Dispose();
font = null;
}
}
}
}
}
}
public static void Main()
{
LOGFONT lf = new LOGFONT();
lf.lfHeight = 9;
lf.lfFaceName = "Arial";
IntPtr handle = CreateFontIndirect(lf);
if (IntPtr.Zero == handle)
{
Console.WriteLine("Can't creates a logical font.");
}
else
{
if (IntPtr.Size == 4)
Console.WriteLine("{0:X}", handle.ToInt32());
else
Console.WriteLine("{0:X}", handle.ToInt64());
// delete the logical font created.
if (!DeleteObject(handle))
Console.WriteLine("Can't delete the logical font");
}
}
public static void Main()
{
LOGFONT lf = new LOGFONT();
lf.lfHeight = 9;
lf.lfFaceName = "Arial";
IntPtr handle = CreateFontIndirect(lf);
if (IntPtr.Zero == handle)
{
Console.WriteLine("Can't creates a logical font.");
}
else
{
if (IntPtr.Size == 4)
{
Console.WriteLine("{0:X}", handle.ToInt32());
}
else
{
Console.WriteLine("{0:X}", handle.ToInt64());
}
// delete the logical font created.
if (!DeleteObject(handle))
{
Console.WriteLine("Can't delete the logical font");
}
}
}
public LOGFONT GetThemeFont(int partId, int stateId, int propertyId)
{
var value = new LOGFONT();
HResult hr = StyleNativeMethods.GetThemeFont(theme, IntPtr.Zero, partId, stateId, propertyId, value);
return(Found(hr) ? value : null);
}
protected override void OnLoad(EventArgs e)
{
//build list of OpenType fonts
LOGFONT lf = new LOGFONT();
IntPtr plogFont = Marshal.AllocHGlobal(Marshal.SizeOf(lf));
Marshal.StructureToPtr(lf, plogFont, true);
try
{
fontList.Clear();
using (Graphics G = CreateGraphics())
{
IntPtr P = G.GetHdc();
EnumFontFamiliesEx(P, plogFont, Callback, IntPtr.Zero, 0);
G.ReleaseHdc(P);
}
}
finally
{
Marshal.DestroyStructure(plogFont, typeof(LOGFONT));
}
//sort fonts
fontList.Sort((f1, f2) => f1.elfFullName.CompareTo(f2.elfFullName));
//build combobox
cbFont.Items.Clear();
foreach (var item in fontList)
cbFont.Items.Add(item);
}
/// <summary>
/// Sets the font attributes to be used for text within the preview handler.
/// </summary>
/// <param name="plf">A pointer to a LOGFONTW Structure containing the necessary attributes for the font to use.</param>
/// <returns>
/// If this method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code.
/// </returns>
int IPreviewHandlerVisuals.SetFont(ref LOGFONT plf)
{
// Log key events.
Log("IPreviewHandlerVisuals.SetFont called.");
// Call the virtual function.
try
{
LOGFONT logfont = plf;
OnPreviewHostThread(
() =>
{
// Call the abstract function.
if (previewHandlerControl != null)
{
previewHandlerControl.SetVisualsFont(Font.FromLogFont(logfont));
}
});
}
catch (Exception exception)
{
// Log the error.
LogError("An exception occured when setting the font.", exception);
throw;
}
// Return success.
return(WinError.S_OK);
}
private static LOGFONT CreatePointFontStruct(string fontName, int pointSize, bool bold, bool italic)
{
const byte DEFAULT_CHARSET = 1;
const long FW_BOLD = 700;
const int LOGPIXELSY = 90;
LOGFONT font = new LOGFONT();
font.lfCharSet = DEFAULT_CHARSET;
font.lfFaceName = fontName;
if (bold)
{
font.lfWeight = FW_BOLD;
}
if (italic)
{
font.lfItalic = 1;
}
using (GraphicsContext context = GraphicsContext.CreateOffscreenContext())
{
font.lfHeight = -NativeMethods.MulDiv(pointSize, context.GetCapability(LOGPIXELSY), 72);
}
return(font);
}
private void cboFonts_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
try
{
if (!m_Loaded || cboFonts.SelectedIndex < 0)
{
return;
}
var lf = (LOGFONT)e.AddedItems[0];
var logF = new LOGFONT();
logF.Init();
logF.SetFontFace(lf.lfFaceName);
logF.SetFontSize((int)cboFontSize.SelectedItem);
m_Group.Font = logF;
PNStatic.DrawSkinlessPreview(m_Group, brdFrame, blkCaption, brdBody, blkBody);
if (lstSkins.SelectedIndex >= 0)
{
PNStatic.DrawSkinPreview(m_Group, m_Group.Skin, imgSkin);
}
}
catch (Exception ex)
{
PNStatic.LogException(ex);
}
}
public HCFont()
{
FFontStyles = new HCFontStyles();
FPixelsPerInch = HCCanvas.ScreenLogPixels;
FLogFont = new LOGFONT();
ReCreateHandle();
}
private static void AddCharSet(string fontName)
{
if (fontName == null)
{
return;
}
lock (m_charSetLookupLock)
{
if (m_charSetLookup.ContainsKey(fontName))
{
return;
}
Font font = null;
try
{
bool bold = false;
bool italic = false;
font = FontCache.CreateGdiPlusFont(fontName, 400f, ref bold, ref italic, lineThrough: false, underLine: false);
LOGFONT lOGFONT = new LOGFONT();
font.ToLogFont(lOGFONT);
m_charSetLookup.Add(fontName, (CharSet)lOGFONT.lfCharSet);
}
finally
{
if (font != null)
{
font.Dispose();
font = null;
}
}
}
}
public static List <FontData> Invoke(Func <FontData, bool> filter = null)
{
EnumFontFamiliesEx container = new EnumFontFamiliesEx
{
_filter = filter
};
Graphics graphics = Graphics.FromHwnd(IntPtr.Zero);
try
{
IntPtr hdc = graphics.GetHdc();
LOGFONT logfont = new LOGFONT
{
lfCharSet = (byte)FontLanguageCharSet.DEFAULT_CHARSET
};
EnumFontFamiliesEx(hdc, ref logfont, new FONTENUMPROC(container.EnumFontFamiliesExCallback), IntPtr.Zero, 0);
}
catch (Exception)
{
}
finally
{
graphics.ReleaseHdc();
}
return(container._fontDatas);
}
public LOGFONT GetThemeSysFont(int propertyId)
{
var value = new LOGFONT();
HResult hr = StyleNativeMethods.GetThemeSysFont(theme, propertyId, value);
return(Found(hr) ? value : null);
}
public static string GetFontFaceName(string fn)
{
Font ft = new Font(fn, 9F);
LOGFONT lt = new LOGFONT();
ft.ToLogFont(lt);
return lt.lfFaceName;
}
protected TCustomForm()
{
messageTable = new Dictionary <int, MessageProc>()
{
{ TApplication.CM_ACTIONEXECUTE, CMActionExecute },
{ TApplication.CM_ACTIONUPDATE, CMActionUpdate }
};
//http://stackoverflow.com/questions/4347873/changing-font-smoothing-for-my-application-alone-and-not-the-global-windows-font
LOGFONT lfont = new LOGFONT();
object boxedLFont = lfont;
this.Font.ToLogFont(boxedLFont);
lfont = (LOGFONT)boxedLFont;
lfont.lfCharSet = LOGFONT.DEFAULT_CHARSET;
lfont.lfQuality = LOGFONT.NONANTIALIASED_QUALITY;
this.Font = Font.FromLogFont(lfont);
if (TApplication.Instance.AppInitialized && TApplication.Instance.Icon != null)
{
Icon = TApplication.Instance.Icon;
}
//TODO: inject a call to AfterConstruction() in the calling frame!
// Use factory pattern Create<TForm>() as long as the injection is not implemented.
}
public void GetFonts()
{
LOGFONT lf = CreateLogFont("");
IntPtr plogFont = Marshal.AllocHGlobal(Marshal.SizeOf(lf));
Marshal.StructureToPtr(lf, plogFont, true);
int ret = 0;
try
{
//If anyone knows of a better way to get the pointer please let me know
var pictureBox = new PictureBox();
var graphic = pictureBox.CreateGraphics();
var ptr = graphic.GetHdc();
del1 = new EnumFontExDelegate(callback1);
ret = EnumFontFamiliesEx(ptr, plogFont, del1, IntPtr.Zero, 0);
graphic.ReleaseHdc(ptr);
}
catch
{
Console.WriteLine("Error!");
}
finally
{
Marshal.DestroyStructure(plogFont, typeof(LOGFONT));
}
}
private void SetIMEWindowFont(Font f)
{
if (disableIME || hIMEWnd == IntPtr.Zero)
{
return;
}
if (lf == null)
{
lf = new LOGFONT();
try
{
f.ToLogFont(lf);
}
catch (Exception ex)
{
//todo
}
lf.lfFaceName = f.Name; // This is very important! "Font.ToLogFont" Method sets invalid value to LOGFONT.lfFaceName
}
try
{
SendMessage(
hIMEWnd,
WM_IME_CONTROL,
new IntPtr(IMC_SETCOMPOSITIONFONT),
lf
);
}
catch (AccessViolationException ex)
{
Handle(ex);
}
}
public void ToLogFont_AssertUnmanagedCode()
{
Font f = new Font("Arial", 10);
LOGFONT lf = new LOGFONT();
f.ToLogFont(lf);
Assert.AreEqual(400, lf.lfWeight, "lfWeight");
Assert.AreEqual(1, lf.lfCharSet, "lfCharSet");
Assert.AreEqual(f.Name, lf.lfFaceName, "lfFaceName");
LOGFONT_STRUCT lfs = new LOGFONT_STRUCT();
f.ToLogFont(lfs);
Assert.AreEqual(0, lfs.lfWeight, "struct-lfWeight");
Assert.AreEqual(0, lfs.lfCharSet, "struct-lfCharSet");
Assert.AreEqual(0, lfs.lfHeight, "struct-lfHeight");
Assert.AreEqual(0, lfs.lfWidth, "struct-lfWidth");
Assert.AreEqual(0, lfs.lfEscapement, "struct-lfEscapement");
Assert.AreEqual(0, lfs.lfOrientation, "struct-lfOrientation");
Assert.AreEqual(0, lfs.lfWeight, "struct-lfWeight");
Assert.AreEqual(0, lfs.lfItalic, "struct-lfItalic");
Assert.AreEqual(0, lfs.lfUnderline, "struct-lfUnderline");
Assert.AreEqual(0, lfs.lfStrikeOut, "struct-lfStrikeOut");
Assert.AreEqual(0, lfs.lfCharSet, "struct-lfCharSet");
Assert.AreEqual(0, lfs.lfOutPrecision, "struct-lfOutPrecision");
Assert.AreEqual(0, lfs.lfClipPrecision, "struct-lfClipPrecision");
Assert.AreEqual(0, lfs.lfQuality, "struct-lfQuality");
Assert.AreEqual(0, lfs.lfPitchAndFamily, "struct-lfPitchAndFamily");
Assert.IsNull(lfs.lfFaceName, "struct-lfFaceName");
}
public void FromLogFont_ValidLogFont_ReturnsExpected(FontStyle fontStyle, int weight, byte charSet)
{
// The boundary values of the weight that is considered Bold are different between Windows 7 and Windows 8.
if (PlatformDetection.IsWindows7 || PlatformDetection.IsWindows8x)
{
return;
}
using (FontFamily family = FontFamily.GenericMonospace)
{
var logFont = new LOGFONT
{
lfFaceName = family.Name,
lfWeight = weight,
lfItalic = (fontStyle & FontStyle.Italic) != 0 ? (byte)1 : (byte)0,
lfStrikeOut = (fontStyle & FontStyle.Strikeout) != 0 ? (byte)1 : (byte)0,
lfUnderline = (fontStyle & FontStyle.Underline) != 0 ? (byte)1 : (byte)0,
lfCharSet = charSet
};
using (Font font = Font.FromLogFont(logFont))
{
VerifyFont(font, family.Name, font.Size, fontStyle, GraphicsUnit.World, charSet, expectedGdiVerticalFont: false);
}
}
}
public override IText AddText(string text, double fontSize, System.Windows.Media.SolidColorBrush brush)
{
if (cachedTypeface == null)
{
cachedTypeface = CreateTypeface();
}
LOGFONT logfont = new LOGFONT();
logfont.lfFaceName = cachedTypeface.FontFamily.Source;
logfont.lfHeight = -(int)fontSize;
//logfont.lfOutPrecision = 4;
//logfont.lfQuality = 5;
MyText myText = new MyText {
parent = this,
text = text,
color = brush.Color.R | (brush.Color.G << 8) | (brush.Color.B << 16),
font = CreateFontIndirect(ref logfont)
};
//myText.brush = new SolidBrush(myText.color);
texts.Add(myText);
return(myText);
}
private static bool CheckFamily(LOGFONT lf, FontFamilies families)
{
FontPitchAndFamily v = (FontPitchAndFamily)(lf.lfPitchAndFamily >> 2 << 2);
switch (v)
{
case FontPitchAndFamily.FF_DECORATIVE:
{
if ((families & FontFamilies.Decorative) == 0)
{
return(false);
}
break;
}
case FontPitchAndFamily.FF_DONTCARE:
{
return(families == FontFamilies.DontCare ? true : false);
}
case FontPitchAndFamily.FF_MODERN:
{
if ((families & FontFamilies.Modern) == 0)
{
return(false);
}
break;
}
case FontPitchAndFamily.FF_ROMAN:
{
if ((families & FontFamilies.Roman) == 0)
{
return(false);
}
break;
}
case FontPitchAndFamily.FF_SWISS:
{
if ((families & FontFamilies.Swiss) == 0)
{
return(false);
}
break;
}
case FontPitchAndFamily.FF_SCRIPT:
{
if ((families & FontFamilies.Script) == 0)
{
return(false);
}
break;
}
}
return(true);
}
/// <summary>
/// コンストラクタ。
/// </summary>
/// <param name="dummy">ダミーパラメータ。何を渡してもOK。</param>
public ICONMETRICS(int dummy)
{
this.cbSize = 0;
this.iHorzSpacing = 0;
this.iVertSpacing = 0;
this.iTitleWrap = 0;
this.lfFont = new LOGFONT();
}
public static int CalOffsetY(Font f)
{
LOGFONT lg = new LOGFONT();
f.ToLogFont(lg);
Log.Debug($"Name:{f.Name} Font.Height: {f.Height} lfHeight: {lg.lfHeight}");
return(f.Height - Math.Abs(lg.lfHeight));
}
public void Dispose_ToLogFont()
{
#if !TARGET_JVM
Font f = new Font(name, 12.5f);
f.Dispose();
LOGFONT lf = new LOGFONT();
f.ToLogFont(lf);
#endif
}
public static bool IsSymbolFont([NotNull] Font font)
{
const byte SYMBOL_FONT = 2;
LOGFONT logicalFont = new LOGFONT();
font.ToLogFont(logicalFont);
return(logicalFont.lfCharSet == SYMBOL_FONT);
}
public void Dispose_ToLogFont()
{
Font f = new Font(name, 12.5f);
f.Dispose();
LOGFONT lf = new LOGFONT();
Assert.Throws <ArgumentException> (() => f.ToLogFont(lf));
}
/// <summary>
///
/// </summary>
public SafeLogFont(string faceName)
{
var logfont = new LOGFONT()
{
lfFaceName = faceName,
};
_logFont = CreateFontIndirect(ref logfont);
}
/// <summary>
///
/// </summary>
/// <param name="typeface"></param>
/// <param name="size"></param>
public SafeLogFont(Typeface typeface, int size)
{
var logfont = new LOGFONT()
{
lfFaceName = typeface.FontFamily.Source,
lfHeight = -(int)(typeface.FontFamily.LineSpacing * 3 / 4 * size),
lfPitchAndFamily = FontPitchAndFamily.FIXED_PITCH,
lfCharSet = FontCharSet.ANSI_CHARSET,
};
if (typeface.Weight == FontWeights.Thin)
{
logfont.lfWeight = FontWeight.FW_THIN;
}
else if (typeface.Weight == FontWeights.ExtraLight || typeface.Weight == FontWeights.UltraLight)
{
logfont.lfWeight = FontWeight.FW_EXTRALIGHT;
}
else if (typeface.Weight == FontWeights.Light)
{
logfont.lfWeight = FontWeight.FW_LIGHT;
}
else if (typeface.Weight == FontWeights.Normal || typeface.Weight == FontWeights.Regular)
{
logfont.lfWeight = FontWeight.FW_NORMAL;
}
else if (typeface.Weight == FontWeights.Medium)
{
logfont.lfWeight = FontWeight.FW_MEDIUM;
}
else if (typeface.Weight == FontWeights.SemiBold || typeface.Weight == FontWeights.DemiBold)
{
logfont.lfWeight = FontWeight.FW_SEMIBOLD;
}
else if (typeface.Weight == FontWeights.Bold)
{
logfont.lfWeight = FontWeight.FW_BOLD;
}
else if (typeface.Weight == FontWeights.ExtraBold || typeface.Weight == FontWeights.UltraBold)
{
logfont.lfWeight = FontWeight.FW_EXTRABOLD;
}
else if (typeface.Weight == FontWeights.Black || typeface.Weight == FontWeights.ExtraBlack ||
typeface.Weight == FontWeights.UltraBlack || typeface.Weight == FontWeights.Heavy)
{
logfont.lfWeight = FontWeight.FW_HEAVY;
}
if (typeface.Style == FontStyles.Italic)
{
logfont.lfItalic = true;
}
//TODO: Реализовать подчеркивание и зачеркивание
_logFont = CreateFontIndirect(ref logfont);
}
public void Dispose_ToLogFont()
{
Font f = new Font(name, 12.5f);
f.Dispose();
LOGFONT lf = new LOGFONT();
f.ToLogFont(lf);
}
private void ComboBox_DrawItem(object sender, DrawItemEventArgs e)
{
if ((e.State & DrawItemState.Disabled) > 0)
{
return;
}
Graphics g = e.Graphics;
e.DrawBackground();
if ((e.State & DrawItemState.ComboBoxEdit) > 0)
{
e.DrawBackground();
TextRenderer.DrawText(g, FFontName, e.Font, new Point(e.Bounds.X, e.Bounds.Y), e.ForeColor);
}
else if (e.Index >= 0)
{
string name = (string)Items[e.Index];
if (!FExistingFonts.Contains(name))
{
return;
}
using (FontFamily family = new FontFamily(name))
using (Font font = new Font(name, 14, GetFirstAvailableFontStyle(family)))
{
g.DrawImage(Res.GetImage(59), e.Bounds.X + 2, e.Bounds.Y + 2);
LOGFONT lf = new LOGFONT();
font.ToLogFont(lf);
SizeF sz;
if (lf.lfCharSet == 2)
{
sz = g.MeasureString(name, e.Font);
int w = (int)sz.Width;
TextRenderer.DrawText(g, name, e.Font, new Point(e.Bounds.X + 20, e.Bounds.Y + (e.Bounds.Height - (int)sz.Height) / 2), e.ForeColor);
sz = g.MeasureString(name, font);
TextRenderer.DrawText(g, name, font, new Point(e.Bounds.X + w + 28, e.Bounds.Y + (e.Bounds.Height - (int)sz.Height) / 2), e.ForeColor);
}
else
{
sz = g.MeasureString(name, font);
TextRenderer.DrawText(g, name, font, new Point(e.Bounds.X + 20, e.Bounds.Y + (e.Bounds.Height - (int)sz.Height) / 2), e.ForeColor);
}
if (e.Index == FMruFonts.Count - 1)
{
g.DrawLine(Pens.Gray, e.Bounds.Left, e.Bounds.Bottom - 3, e.Bounds.Right, e.Bounds.Bottom - 3);
g.DrawLine(Pens.Gray, e.Bounds.Left, e.Bounds.Bottom - 1, e.Bounds.Right, e.Bounds.Bottom - 1);
}
}
}
}
public bool GdiMeasureString(
System.Drawing.Graphics pGraphics,
LOGFONT pLogFont,
string pszText,
System.Drawing.Point ptDraw,
ref float pfPixelsStartX,
ref float pfPixelsStartY,
ref float pfDestWidth,
ref float pfDestHeight)
{
using (GraphicsPath pPath = new GraphicsPath(System.Drawing.Drawing2D.FillMode.Winding))
{
bool b = GDIPath.GetStringPath(
pGraphics,
pPath,
pszText,
pLogFont,
ptDraw);
if (false == b)
{
return false;
}
pfDestWidth = ptDraw.X;
pfDestHeight = ptDraw.Y;
b = GDIPath.MeasureGraphicsPath(pGraphics, pPath, ref pfPixelsStartX, ref pfPixelsStartY, ref pfDestWidth, ref pfDestHeight);
if (false == b)
{
return false;
}
float pixelThick = 0.0f;
float fStartX = 0.0f;
float fStartY = 0.0f;
float fDestHeight = 0.0f;
b = GDIPath.ConvertToPixels(pGraphics, m_nThickness, 0.0f, ref fStartX, ref fStartY, ref pixelThick, ref fDestHeight);
if (false == b)
{
return false;
}
pfDestWidth += pixelThick;
pfDestHeight += pixelThick;
}
return true;
}
public static Font ToClearType(this Font font)
{
var lf = new LOGFONT();
var hFont = font.ToHfont();
if (NativeMethods.GetObject(hFont, Marshal.SizeOf(lf), ref lf) == 0)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
NativeMethods.DeleteObject(hFont);
lf.Quality = 6; // CLEARTYPE_COMPAT_QUALITY
hFont = NativeMethods.CreateFontIndirect(ref lf);
return Font.FromHfont(hFont);
}
public bool LoadSubtitles(IGraphBuilder graphBuilder, string filename)
{
FreeSubtitles();
LoadSettings();
{
//remove InternalScriptRenderer as it takes subtitle pin
IBaseFilter isr = null;
DirectShowUtil.FindFilterByClassID(graphBuilder, ClassId.InternalScriptRenderer, out isr);
if (isr != null)
{
graphBuilder.RemoveFilter(isr);
DirectShowUtil.ReleaseComObject(isr);
}
}
vobSub = (IDirectVobSub)DirectVobSubUtil.AddToGraph(graphBuilder);
if (vobSub == null)
return false;
{
//set style
Log.Debug("VideoPlayerVMR9: Setting DirectVobsub parameters");
LOGFONT logFont = new LOGFONT();
int txtcolor;
bool fShadow, fOutLine, fAdvancedRenderer = false;
int size = Marshal.SizeOf(typeof(LOGFONT));
vobSub.get_TextSettings(logFont, size, out txtcolor, out fShadow, out fOutLine, out fAdvancedRenderer);
FontStyle fontStyle = defStyle.fontIsBold ? FontStyle.Regular : FontStyle.Bold;
Font Subfont = new Font(defStyle.fontName, defStyle.fontSize, fontStyle, GraphicsUnit.Point,
(byte)defStyle.fontCharset);
Subfont.ToLogFont(logFont);
fShadow = defStyle.shadow > 0;
fOutLine = defStyle.isBorderOutline;
vobSub.put_TextSettings(logFont, size, defStyle.fontColor, fShadow, fOutLine, fAdvancedRenderer);
vobSub.put_FileName(filename);
bool fBuffer, fOnlyForced, fPolygonize;
vobSub.get_VobSubSettings(out fBuffer, out fOnlyForced, out fPolygonize);
vobSub.put_VobSubSettings(fBuffer, !this.autoShow, fPolygonize);
}
{
//load sub streams
IBaseFilter hms = null;
DirectShowUtil.FindFilterByClassID(graphBuilder, ClassId.HaaliGuid, out hms);
if (hms == null)
DirectShowUtil.FindFilterByClassID(graphBuilder, ClassId.LAVFilterSource, out hms);
if (hms == null)
DirectShowUtil.FindFilterByClassID(graphBuilder, ClassId.LAVFilter, out hms);
embeddedSelector = hms as IAMStreamSelect;
if (embeddedSelector != null)
{
AddStreams(embeddedSelector);
}
vobSub.get_LanguageCount(out extCount);
if (intSubs.Count > 0)
{
//if there are embedded subtitles,
//last stream of directvobsub is currently selected embedded subtitle
extCount--;
}
}
FFDShowEngine.DisableFFDShowSubtitles(graphBuilder);
Current = 0;
if (selectionOff)
{
Enable = false;
}
else
{
Enable = autoShow;
}
return true;
}
public static string GetFontFaceName(Font ft)
{
LOGFONT lt = new LOGFONT();
ft.ToLogFont(lt);
return lt.lfFaceName;
}
private void cboFontSize_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
try
{
if (!_Loaded || cboFontSize.SelectedIndex < 0) return;
var gr = selectedGroup();
if (gr == null) return;
var logF = new LOGFONT();
logF.Init();
logF.SetFontFace(gr.Font.lfFaceName);
logF.SetFontSize((int)cboFontSize.SelectedItem);
gr.Font = logF;
PNStatic.DrawSkinlessPreview(gr, brdFrame, blkCaption, brdBody, blkBody);
if (lstSkins.SelectedIndex >= 0)
{
PNStatic.DrawSkinPreview(gr, gr.Skin, imgSkin);
}
}
catch (Exception ex)
{
PNStatic.LogException(ex);
}
}
void IPreviewHandlerVisuals.SetFont(ref LOGFONT plf)
{
Font f = Font.FromLogFont(plf);
InvokeOnPreviewThread(delegate() { _previewControl.Font = f; });
}
public static extern int GetThemeSysFont(IntPtr hTheme, int iIntID, out LOGFONT pFont);
internal static extern int GetObject(IntPtr hObj, int cb, ref LOGFONT objdata);
public LOGFONT(LOGFONT lf) {}
public LOGFONT( LOGFONT lf )
{
Debug.Assert( lf != null, "lf is null" );
this.lfHeight = lf.lfHeight;
this.lfWidth = lf.lfWidth;
this.lfEscapement = lf.lfEscapement;
this.lfOrientation = lf.lfOrientation;
this.lfWeight = lf.lfWeight;
this.lfItalic = lf.lfItalic;
this.lfUnderline = lf.lfUnderline;
this.lfStrikeOut = lf.lfStrikeOut;
this.lfCharSet = lf.lfCharSet;
this.lfOutPrecision = lf.lfOutPrecision;
this.lfClipPrecision = lf.lfClipPrecision;
this.lfQuality = lf.lfQuality;
this.lfPitchAndFamily = lf.lfPitchAndFamily;
this.lfFaceName = lf.lfFaceName;
}
public override bool GdiDrawString(
System.Drawing.Graphics pGraphics,
LOGFONT pLogFont,
string pszText,
System.Drawing.Point ptDraw)
{
using (GraphicsPath pPath = new GraphicsPath(System.Drawing.Drawing2D.FillMode.Winding))
{
bool b = GDIPath.GetStringPath(
pGraphics,
pPath,
pszText,
pLogFont,
ptDraw);
if (false == b)
{
return false;
}
for (int i = 1; i <= m_nThickness; ++i)
{
using (Pen pen = new Pen(m_clrOutline, i))
{
pen.LineJoin = LineJoin.Round;
pGraphics.DrawPath(pen, pPath);
}
}
if (m_bClrText)
{
using (SolidBrush brush = new SolidBrush(m_clrText))
{
pGraphics.FillPath(brush, pPath);
}
}
else
{
pGraphics.FillPath(m_brushText, pPath);
}
}
return true;
}
public static extern IntPtr CreateFontIndirect(ref LOGFONT lplf);
public virtual void ReceiveData(BufferChunk aRecord)
{
// First read out the record type
int recordType = aRecord.NextInt32();
// Then deserialize the rest from there
switch (recordType)
{
case GDI32.EMR_HEADER:
break;
// Transform related
case GDI32.EMR_SCALEVIEWPORTEXTEX:
case GDI32.EMR_SCALEWINDOWEXTEX:
break;
case GDI32.EMR_SETWINDOWEXTEX:
{
int width = aRecord.NextInt32();
int height = aRecord.NextInt32();
SetWindowExtent(width, height);
}
break;
case GDI32.EMR_SETWINDOWORGEX:
{
int x = aRecord.NextInt32();
int y = aRecord.NextInt32();
SetWindowOrigin(x, y);
}
break;
case GDI32.EMR_SETVIEWPORTEXTEX:
{
int width = aRecord.NextInt32();
int height = aRecord.NextInt32();
SetViewportExtent(width, height);
}
break;
case GDI32.EMR_SETVIEWPORTORGEX:
{
int x = aRecord.NextInt32();
int y = aRecord.NextInt32();
SetViewportOrigin(x, y);
}
break;
case GDI32.EMR_SETWORLDTRANSFORM:
case GDI32.EMR_MODIFYWORLDTRANSFORM:
break;
case GDI32.EMR_SETBRUSHORGEX:
break;
case GDI32.EMR_EOF:
Flush();
break;
case GDI32.EMR_SETPIXELV:
{
int x = aRecord.NextInt32();
int y = aRecord.NextInt32();
UInt32 colorref = aRecord.NextUInt32();
SetPixel(x, y, colorref);
}
break;
case GDI32.EMR_SETMAPPERFLAGS:
break;
case GDI32.EMR_SETPOLYFILLMODE:
SetPolyFillMode(aRecord.NextInt32());
break;
case GDI32.EMR_SETSTRETCHBLTMODE:
break;
case GDI32.EMR_SETMAPMODE:
MappingModes aMode = (MappingModes)aRecord.NextInt32();
SetMappingMode(aMode);
break;
case GDI32.EMR_SETTEXTCOLOR:
SetTextColor(aRecord.NextUInt32());
break;
case GDI32.EMR_SETBKCOLOR:
SetBkColor(aRecord.NextUInt32());
break;
case GDI32.EMR_SETDCBRUSHCOLOR:
SetDefaultBrushColor(aRecord.NextUInt32());
break;
case GDI32.EMR_SETDCPENCOLOR:
SetDefaultPenColor(aRecord.NextUInt32());
break;
case GDI32.EMR_SETBKMODE:
SetBkMode(aRecord.NextInt32());
break;
case GDI32.EMR_SETROP2:
SetROP2((BinaryRasterOps)aRecord.NextInt32());
break;
case GDI32.EMR_SETTEXTALIGN:
case GDI32.EMR_SETCOLORADJUSTMENT:
break;
case GDI32.EMR_MOVETOEX:
MoveTo(aRecord.NextInt32(), aRecord.NextInt32());
break;
case GDI32.EMR_OFFSETCLIPRGN:
case GDI32.EMR_SETMETARGN:
case GDI32.EMR_EXCLUDECLIPRECT:
case GDI32.EMR_INTERSECTCLIPRECT:
break;
case GDI32.EMR_SAVEDC:
SaveState();
break;
case GDI32.EMR_RESTOREDC:
RestoreState(aRecord.NextInt32());
break;
// Creates a generic pen of any style
case GDI32.EMR_CREATEPEN:
{
int aStyle = aRecord.NextInt32();
int width = aRecord.NextInt32();
uint colorref = aRecord.NextUInt32();
Guid uniqueID = this.UnpackGuid(aRecord);
CreateCosmeticPen((PenStyle)aStyle, colorref, uniqueID);
}
break;
case GDI32.EMR_CREATECOSMETICPEN:
{
int aStyle = aRecord.NextInt32();
int width = aRecord.NextInt32();
uint colorref = aRecord.NextUInt32();
Guid uniqueID = this.UnpackGuid(aRecord);
CreateCosmeticPen((PenStyle)aStyle, colorref, uniqueID);
}
break;
case GDI32.EMR_CREATEBRUSHINDIRECT:
{
int aStyle = aRecord.NextInt32(); // chunk += aStyle;
int hatch = aRecord.NextInt32(); // chunk += hatch;
uint color = aRecord.NextUInt32(); // chunk += color;
Guid uniqueID = this.UnpackGuid(aRecord);
CreateBrush(aStyle, hatch, color, uniqueID);
}
break;
case GDI32.EMR_SELECTOBJECT:
break;
case GDI32.EMR_DELETEOBJECT:
break;
case GDI32.EMR_SELECTSTOCKOBJECT:
SelectStockObject(aRecord.NextInt32());
break;
case GDI32.EMR_SELECTUNIQUEOBJECT:
{
Guid uniqueID = this.UnpackGuid(aRecord);
SelectUniqueObject(uniqueID);
}
break;
case GDI32.EMR_ELLIPSE:
{
int left = aRecord.NextInt32();
int top = aRecord.NextInt32();
int right = aRecord.NextInt32();
int bottom = aRecord.NextInt32();
Ellipse(left, top, right, bottom);
}
break;
case GDI32.EMR_ROUNDRECT:
{
int left = aRecord.NextInt32();
int top = aRecord.NextInt32();
int right = aRecord.NextInt32();
int bottom = aRecord.NextInt32();
int width = aRecord.NextInt32();
int height = aRecord.NextInt32();
RoundRect(left, top, right, bottom, width, height);
}
break;
case GDI32.EMR_RECTANGLE:
{
int left = aRecord.NextInt32();
int top = aRecord.NextInt32();
int right = aRecord.NextInt32();
int bottom = aRecord.NextInt32();
Rectangle(left, top, right, bottom);
}
break;
case GDI32.EMR_GRADIENTFILL: // Only rectangles at the moment
{
// Unpack the vertices
TRIVERTEX[] pVertex = this.UnpackTRIVERTEX(aRecord);
// unpack the gradient mesh
GRADIENT_RECT[] pMesh = UnpackGRADIENT_RECT(aRecord);
// pack the mode
uint dwMode = aRecord.NextUInt32();
this.GradientRectangle(pVertex, pMesh, dwMode);
}
break;
case GDI32.EMR_ARC:
case GDI32.EMR_ARCTO:
case GDI32.EMR_ANGLEARC:
case GDI32.EMR_CHORD:
case GDI32.EMR_PIE:
break;
case GDI32.EMR_SELECTPALETTE:
case GDI32.EMR_CREATEPALETTE:
case GDI32.EMR_SETPALETTEENTRIES:
case GDI32.EMR_RESIZEPALETTE:
case GDI32.EMR_REALIZEPALETTE:
break;
case GDI32.EMR_LINETO:
LineTo(aRecord.NextInt32(), aRecord.NextInt32());
break;
case GDI32.EMR_EXTFLOODFILL:
break;
case GDI32.EMR_POLYDRAW:
//EMRPOLYDRAW polydraw = (EMRPOLYDRAW)aRecord;
//fRenderer.PolyDraw(polydraw.aptl, polydraw.abTypes);
break;
case GDI32.EMR_SETARCDIRECTION:
case GDI32.EMR_SETMITERLIMIT:
break;
case GDI32.EMR_BEGINPATH:
BeginPath();
break;
case GDI32.EMR_ENDPATH:
EndPath();
break;
case GDI32.EMR_FILLPATH:
FillPath();
break;
case GDI32.EMR_STROKEANDFILLPATH:
DrawPath();
break;
case GDI32.EMR_STROKEPATH:
FramePath();
break;
case GDI32.EMR_ABORTPATH:
case GDI32.EMR_FLATTENPATH:
case GDI32.EMR_WIDENPATH:
break;
case GDI32.EMR_CLOSEFIGURE:
case GDI32.EMR_SELECTCLIPPATH:
break;
case GDI32.EMR_BITBLT:
{
// Get the X, Y
int x = aRecord.NextInt32();
int y = aRecord.NextInt32();
int width = aRecord.NextInt32();
int height = aRecord.NextInt32();
// Now create a pixbuff on the specified size
PixelBuffer pixBuff = new PixelBuffer(width, height);
int dataSize = aRecord.NextInt32();
// Copy the received data into it right pixel data pointer
aRecord.CopyTo(pixBuff.Pixels.Data, dataSize);
// And finally, call the BitBlt function
BitBlt(x,y,pixBuff);
}
break;
case GDI32.EMR_POLYBEZIERTO:
break;
case GDI32.EMR_POLYBEZIER:
{
Point[] points = UnpackPoints(aRecord);
// Now we have everything, so call the call
PolyBezier(points);
}
break;
case GDI32.EMR_POLYGON:
{
Point[] points = UnpackPoints(aRecord);
// Now we have everything, so call the call
Polygon(points);
}
break;
case GDI32.EMR_POLYPOLYGON:
break;
case GDI32.EMR_POLYLINE:
{
Point[] points = UnpackPoints(aRecord);
// Now we have everything, so call the call
PolyLine(points);
}
break;
case GDI32.EMR_POLYLINETO:
{
Point[] points = UnpackPoints(aRecord);
//PolyLineTo(points);
}
break;
case GDI32.EMR_POLYPOLYLINE:
break;
case GDI32.EMR_POLYTEXTOUTA:
case GDI32.EMR_POLYTEXTOUTW:
break;
case GDI32.EMR_EXTTEXTOUTA:
case GDI32.EMR_EXTTEXTOUTW:
{
int x = aRecord.NextInt32();
int y = aRecord.NextInt32();
int strLength = aRecord.NextInt32();
string text = (string)aRecord;
DrawString(x, y, text);
}
break;
case GDI32.EMR_EXTCREATEFONTINDIRECTW:
{
LOGFONT newFont = new LOGFONT();
int faceNameLength = aRecord.NextInt32();
newFont.lfFaceName = aRecord.NextUtf8String(faceNameLength);
newFont.lfHeight = aRecord.NextInt32();
newFont.lfCharSet = aRecord.NextByte();
newFont.lfClipPrecision = aRecord.NextByte();
newFont.lfEscapement = aRecord.NextInt32();
newFont.lfItalic = aRecord.NextByte();
newFont.lfOrientation = aRecord.NextInt32();
newFont.lfOutPrecision = aRecord.NextByte();
newFont.lfPitchAndFamily = aRecord.NextByte();
newFont.lfQuality = aRecord.NextByte();
newFont.lfStrikeOut = aRecord.NextByte();
newFont.lfUnderline = aRecord.NextByte();
newFont.lfWeight = aRecord.NextInt32();
newFont.lfWidth = aRecord.NextInt32();
Guid uniqueID = this.UnpackGuid(aRecord);
CreateFont(newFont.lfFaceName, newFont.lfHeight, uniqueID);
}
break;
case GDI32.EMR_CREATEMONOBRUSH:
case GDI32.EMR_EXTCREATEPEN:
case GDI32.EMR_CREATEDIBPATTERNBRUSHPT:
break;
case GDI32.EMR_FILLRGN:
case GDI32.EMR_FRAMERGN:
case GDI32.EMR_INVERTRGN:
case GDI32.EMR_PAINTRGN:
case GDI32.EMR_EXTSELECTCLIPRGN:
break;
case GDI32.EMR_ALPHABLEND:
{
// Get the X, Y
int x = aRecord.NextInt32();
int y = aRecord.NextInt32();
int width = aRecord.NextInt32();
int height = aRecord.NextInt32();
int srcX = aRecord.NextInt32();
int srcY = aRecord.NextInt32();
int srcWidth = aRecord.NextInt32();
int srcHeight = aRecord.NextInt32();
byte alpha = aRecord.NextByte();
// Now create a pixbuff on the specified size
int buffWidth = aRecord.NextInt32();
int buffHeight = aRecord.NextInt32();
PixelBuffer pixBuff = new PixelBuffer(buffWidth, buffHeight);
int dataSize = aRecord.NextInt32();
// Copy the received data into it right pixel data pointer
aRecord.CopyTo(pixBuff.Pixels.Data, dataSize);
// And finally, call the BitBlt function
AlphaBlend(x,y,width,height, pixBuff,srcX,srcY, srcWidth,srcHeight,alpha);
}
break;
case GDI32.EMR_STRETCHBLT:
case GDI32.EMR_MASKBLT:
case GDI32.EMR_PLGBLT:
case GDI32.EMR_SETDIBITSTODEVICE:
case GDI32.EMR_STRETCHDIBITS:
case GDI32.EMR_TRANSPARENTBLT:
break;
case GDI32.EMR_GDICOMMENT:
case GDI32.EMR_GLSRECORD:
case GDI32.EMR_GLSBOUNDEDRECORD:
break;
case GDI32.EMR_SETLAYOUT:
break;
case GDI32.EMR_PIXELFORMAT:
break;
case GDI32.EMR_CREATECOLORSPACE:
case GDI32.EMR_SETCOLORSPACE:
case GDI32.EMR_DELETECOLORSPACE:
case GDI32.EMR_COLORCORRECTPALETTE:
case GDI32.EMR_SETICMMODE:
case GDI32.EMR_SETICMPROFILEA:
case GDI32.EMR_SETICMPROFILEW:
case GDI32.EMR_COLORMATCHTOTARGETW:
case GDI32.EMR_CREATECOLORSPACEW:
break;
case GDI32.EMR_RESERVED_105: // These will likely never show up
case GDI32.EMR_RESERVED_106:
case GDI32.EMR_RESERVED_107:
case GDI32.EMR_RESERVED_108:
case GDI32.EMR_RESERVED_109:
case GDI32.EMR_RESERVED_110:
case GDI32.EMR_RESERVED_117:
case GDI32.EMR_RESERVED_119:
case GDI32.EMR_RESERVED_120:
case GDI32.EMR_POLYBEZIER16: // Probably no real need to implement these
case GDI32.EMR_POLYBEZIERTO16:
case GDI32.EMR_POLYGON16:
case GDI32.EMR_POLYPOLYGON16:
case GDI32.EMR_POLYLINE16:
case GDI32.EMR_POLYLINETO16:
case GDI32.EMR_POLYPOLYLINE16:
case GDI32.EMR_POLYDRAW16:
default:
//if (CommandReceived != null)
// CommandReceived(aRecord);
break;
}
}
public override bool GdiDrawString(
System.Drawing.Graphics pGraphics,
LOGFONT pLogFont,
string pszText,
System.Drawing.Rectangle rtDraw)
{
using (GraphicsPath pPath = new GraphicsPath(System.Drawing.Drawing2D.FillMode.Winding))
{
bool b = GDIPath.GetStringPath(
pGraphics,
pPath,
pszText,
pLogFont,
rtDraw);
if (false == b)
{
return false;
}
using (Pen pen2 = new Pen(m_clrOutline2, m_nThickness1 + m_nThickness2))
{
pen2.LineJoin = LineJoin.Round;
pGraphics.DrawPath(pen2, pPath);
}
using (Pen pen1 = new Pen(m_clrOutline1, m_nThickness1))
{
pen1.LineJoin = LineJoin.Round;
pGraphics.DrawPath(pen1, pPath);
}
if (m_bClrText)
{
using (SolidBrush brush = new SolidBrush(m_clrText))
{
pGraphics.FillPath(brush, pPath);
}
}
else
{
pGraphics.FillPath(m_brushText, pPath);
}
}
return true;
}
private void cboFonts_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
try
{
if (!m_Loaded || cboFonts.SelectedIndex < 0) return;
var lf = (LOGFONT)e.AddedItems[0];
var logF = new LOGFONT();
logF.Init();
logF.SetFontFace(lf.lfFaceName);
logF.SetFontSize((int) cboFontSize.SelectedItem);
m_Group.Font = logF;
PNStatic.DrawSkinlessPreview(m_Group, brdFrame, blkCaption, brdBody, blkBody);
if (lstSkins.SelectedIndex >= 0)
{
PNStatic.DrawSkinPreview(m_Group, m_Group.Skin, imgSkin);
}
}
catch (Exception ex)
{
PNStatic.LogException(ex);
}
}
private void OnPaint(object sender, PaintEventArgs e)
{
e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
e.Graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
//Drawing the back ground color
Color m_clrBkgd = Color.FromArgb(255, 255, 255);
SolidBrush brushBkgnd = new SolidBrush(m_clrBkgd);
e.Graphics.FillRectangle(brushBkgnd, 0, 0, this.ClientSize.Width, this.ClientSize.Width);
PngOutlineText m_PngOutlineText = new PngOutlineText();
m_PngOutlineText.SetPngImage(new Bitmap(ClientSize.Width, ClientSize.Height));
m_PngOutlineText.TextGradOutline(
Color.FromArgb(255, 128, 64),
Color.FromArgb(255, 64, 0, 64),
Color.FromArgb(255, 255, 128, 255),
10);
m_PngOutlineText.EnableReflection(false);
m_PngOutlineText.EnableShadow(true);
//Rem to SetNullShadow() to release memory if a previous shadow has been set.
m_PngOutlineText.SetNullShadow();
m_PngOutlineText.Shadow(
Color.FromArgb(128, 0, 0, 0), 8,
new Point(4, 4));
LOGFONT m_LogFont = new LOGFONT();
m_LogFont.lfFaceName = "Arial Black";
m_LogFont.lfHeight = -48;
m_LogFont.lfOrientation = 0;
m_LogFont.lfEscapement = 0;
m_LogFont.lfItalic = false;
float fStartX = 0.0f;
float fStartY = 0.0f;
float fDestWidth = 0.0f;
float fDestHeight = 0.0f;
m_PngOutlineText.GdiMeasureString(
e.Graphics,
m_LogFont,
"TEXT DESIGNER",
new Point(10, 10),
ref fStartX,
ref fStartY,
ref fDestWidth,
ref fDestHeight);
m_PngOutlineText.SetShadowBkgd(m_clrBkgd, (int)fDestWidth+10, (int)fDestHeight+10);
LinearGradientBrush gradientBrush = new LinearGradientBrush(new RectangleF(fStartX, fStartY, fDestWidth - fStartX, fDestHeight - fStartY),
Color.FromArgb(255, 128, 64), Color.FromArgb(255, 0, 0), LinearGradientMode.Vertical);
m_PngOutlineText.TextGradOutline(
gradientBrush,
Color.FromArgb(255, 64, 0, 64),
Color.FromArgb(255, 255, 128, 255),
10);
m_PngOutlineText.GdiDrawString(
e.Graphics,
m_LogFont,
"TEXT DESIGNER",
new Point(10, 10));
e.Graphics.DrawImage(m_PngOutlineText.GetPngImage(), new Point(0, 0));
brushBkgnd.Dispose();
e.Graphics.Dispose();
}
public override bool GdiDrawString(
System.Drawing.Graphics pGraphics,
LOGFONT pLogFont,
string pszText,
System.Drawing.Rectangle rtDraw)
{
using (GraphicsPath pPath = new GraphicsPath(System.Drawing.Drawing2D.FillMode.Winding))
{
bool b = GDIPath.GetStringPath(
pGraphics,
pPath,
pszText,
pLogFont,
rtDraw);
if (false == b)
{
return false;
}
List<Color> list = new List<Color>();
CalculateGradient(
m_clrOutline1,
m_clrOutline2,
m_nThickness,
list);
for (int i = m_nThickness; i >= 1; --i)
{
System.Drawing.Color clr = list[i - 1];
using (Pen pen = new Pen(clr, i))
{
pen.LineJoin = LineJoin.Round;
pGraphics.DrawPath(pen, pPath);
}
}
if (m_bClrText)
{
using (SolidBrush brush = new SolidBrush(m_clrText))
{
pGraphics.FillPath(brush, pPath);
}
}
else
{
pGraphics.FillPath(m_brushText, pPath);
}
}
return true;
}
public override bool GdiDrawString(
System.Drawing.Graphics pGraphics,
LOGFONT pLogFont,
string pszText,
System.Drawing.Point ptDraw)
{
using (GraphicsPath pPath = new GraphicsPath(System.Drawing.Drawing2D.FillMode.Winding))
{
bool b = GDIPath.GetStringPath(
pGraphics,
pPath,
pszText,
pLogFont,
ptDraw);
if (false == b)
{
return false;
}
using (Pen pen = new Pen(m_clrOutline, m_nThickness))
{
if (m_bRoundedEdge)
pen.LineJoin = LineJoin.Round;
pGraphics.DrawPath(pen, pPath);
}
}
return true;
}
internal static extern IntPtr CreateFontIndirect(ref LOGFONT pLogFont);
public static bool GetStringPath(
System.Drawing.Graphics pGraphics,
System.Drawing.Drawing2D.GraphicsPath ppPath,
string pszText,
LOGFONT plf,
System.Drawing.Rectangle rtDraw)
{
IntPtr hDC = pGraphics.GetHdc();
int nPrevMode = SetBkMode(hDC, TRANSPARENT);
// create and select it
IntPtr hFont = CreateFontIndirect(plf);
if (null == hFont)
return false;
IntPtr hOldFont = (IntPtr)SelectObject(hDC, hFont);
RECT rect = new RECT(rtDraw);
// use a path to record how the text was drawn
const uint DT_CENTER = 0x00000001;
BeginPath(hDC);
DrawText(hDC, pszText, pszText.Length, ref rect, DT_CENTER);
EndPath(hDC);
// Find out how many points are in the path. Note that
// for long strings or complex fonts, this number might be
// gigantic!
int nNumPts = GetPath(hDC, null, null, 0);
if (nNumPts == 0)
return false;
// Allocate memory to hold points and stroke types from
// the path.
POINT[] lpPoints = new POINT[nNumPts];
byte[] lpTypes = new byte[nNumPts];
// Now that we have the memory, really get the path data.
nNumPts = GetPath(hDC, lpPoints, lpTypes, nNumPts);
// If it worked, draw the lines. Win95 and Win98 don't support
// the PolyDraw API, so we use our own member function to do
// similar work. If you're targeting only Windows NT, you can
// use the PolyDraw() API and avoid the COutlineView::PolyDraw()
// member function.
if (nNumPts != -1)
PolyDraw(ppPath, lpPoints, lpTypes, nNumPts);
// Put back the old font
SelectObject(hDC, hOldFont);
DeleteObject(hFont);
SetBkMode(hDC, nPrevMode);
pGraphics.ReleaseHdc(hDC);
return true;
}
public OpenTypeFontStyle(FastColoredTextBox fctb, LOGFONT font)
: base(null, null, FontStyle.Regular)
{
this.font = font;
//measure font
using (var gr = fctb.CreateGraphics())
{
var HDC = gr.GetHdc();
var fontHandle = CreateFontIndirect(font);
var f = SelectObject(HDC, fontHandle);
var measureSize = new Size(0, 0);
try
{
GetTextExtentPoint(HDC, "M", 1, ref measureSize);
}
finally
{
DeleteObject(SelectObject(HDC, f));
gr.ReleaseHdc(HDC);
}
fctb.CharWidth = measureSize.Width;
fctb.CharHeight = measureSize.Height + fctb.LineInterval;
fctb.NeedRecalc(true, true);
}
}
/// <summary>
/// Sets the font attributes to be used for text within the preview handler.
/// </summary>
/// <param name="plf">A pointer to a LOGFONTW Structure containing the necessary attributes for the font to use.</param>
/// <returns>
/// If this method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code.
/// </returns>
int IPreviewHandlerVisuals.SetFont(ref LOGFONT plf)
{
// DebugLog key events.
Log("IPreviewHandlerVisuals.SetFont called.");
// Call the virtual function.
try
{
LOGFONT logfont = plf;
OnPreviewHostThread(
() =>
{
// Call the abstract function.
if (previewHandlerControl != null)
previewHandlerControl.SetVisualsFont(Font.FromLogFont(logfont));
});
}
catch (Exception exception)
{
// DebugLog the error.
LogError("An exception occured when setting the font.", exception);
throw;
}
// Return success.
return WinError.S_OK;
}
public static extern IntPtr CreateFontIndirect(LOGFONT lpLogFont);
public override bool GdiDrawString(
System.Drawing.Graphics pGraphics,
LOGFONT pLogFont,
string pszText,
System.Drawing.Rectangle rtDraw)
{
using (GraphicsPath pPath = new GraphicsPath(System.Drawing.Drawing2D.FillMode.Winding))
{
bool b = GDIPath.GetStringPath(
pGraphics,
pPath,
pszText,
pLogFont,
rtDraw);
if (false == b)
{
return false;
}
if (m_bClrText)
{
using (SolidBrush brush = new SolidBrush(m_clrText))
{
pGraphics.FillPath(brush, pPath);
}
}
else
{
pGraphics.FillPath(m_brushText, pPath);
}
}
return true;
}
public static extern int GetObject( IntPtr hgdiobj, int cbBuffer, out LOGFONT lpvObject );
public LOGFONT( LOGFONT lf )
{
if (lf == null)
{
throw new ArgumentNullException("lf");
}
this.lfHeight = lf.lfHeight;
this.lfWidth = lf.lfWidth;
this.lfEscapement = lf.lfEscapement;
this.lfOrientation = lf.lfOrientation;
this.lfWeight = lf.lfWeight;
this.lfItalic = lf.lfItalic;
this.lfUnderline = lf.lfUnderline;
this.lfStrikeOut = lf.lfStrikeOut;
this.lfCharSet = lf.lfCharSet;
this.lfOutPrecision = lf.lfOutPrecision;
this.lfClipPrecision = lf.lfClipPrecision;
this.lfQuality = lf.lfQuality;
this.lfPitchAndFamily = lf.lfPitchAndFamily;
this.lfFaceName = lf.lfFaceName;
}
private void buildList(){
// Need an HDC to pass to EnumFontFamilies
IntPtr hwnd = GetDesktopWindow();
IntPtr hdc = GetDC(hwnd);
LOGFONT logFont = new LOGFONT();
enumFontDelegate = new EnumFontDelegate(EnumFontFamiliesExProc);
fpEnumProc = Marshal.GetFunctionPointerForDelegate(enumFontDelegate);
EnumFontFamilies(hdc, null, fpEnumProc, IntPtr.Zero);
// We got a list of the major families. Copy the list,
// then clear it so we can go back and grab all the individual fonts.
List<string> fontFamilies = new List<string>();
fontFamilies.AddRange(fontNames);
fontNames.Clear();
foreach(string fontFamily in fontFamilies)
{
EnumFontFamilies(hdc, fontFamily, fpEnumProc, IntPtr.Zero);
}
ReleaseDC(hdc);
foreach(string s in fontNames)
{
//listBox1.Items.Add(s);
}
}
