public int GetNativeDataSize() => - 1; // not a value type, so use -1
public IntPtr MarshalManagedToNative(object obj)
{
Font font = (Font)obj;
User32.LOGFONTW logFont = User32.LOGFONTW.FromFont(font);
var fontDesc = new Oleaut32.FONTDESC
{
cbSizeOfStruct = (uint)Marshal.SizeOf <Oleaut32.FONTDESC>(),
lpstrName = font.Name,
cySize = (long)(font.SizeInPoints * 10000),
sWeight = (short)logFont.lfWeight,
sCharset = logFont.lfCharSet,
fItalic = font.Italic.ToBOOL(),
fUnderline = font.Underline.ToBOOL(),
fStrikethrough = font.Strikeout.ToBOOL(),
};
Guid iid = typeof(Ole32.IFont).GUID;
Ole32.IFont oleFont = Oleaut32.OleCreateFontIndirect(ref fontDesc, ref iid);
IntPtr pFont = Marshal.GetIUnknownForObject(oleFont);
int hr = Marshal.QueryInterface(pFont, ref iid, out IntPtr pIFont);
Marshal.Release(pFont);
if (NativeMethods.Failed(hr))
{
Marshal.ThrowExceptionForHR(hr);
}
return(pIFont);
}
=> - 1; // not a value type, so use -1
public IntPtr MarshalManagedToNative(object obj)
{
Font font = (Font)obj;
NativeMethods.tagFONTDESC fontDesc = new NativeMethods.tagFONTDESC();
NativeMethods.LOGFONTW logFont = NativeMethods.LOGFONTW.FromFont(font);
fontDesc.lpstrName = font.Name;
fontDesc.cySize = (long)(font.SizeInPoints * 10000);
fontDesc.sWeight = (short)logFont.lfWeight;
fontDesc.sCharset = logFont.lfCharSet;
fontDesc.fItalic = font.Italic;
fontDesc.fUnderline = font.Underline;
fontDesc.fStrikethrough = font.Strikeout;
Guid iid = typeof(UnsafeNativeMethods.IFont).GUID;
UnsafeNativeMethods.IFont oleFont = UnsafeNativeMethods.OleCreateFontIndirect(fontDesc, ref iid);
IntPtr pFont = Marshal.GetIUnknownForObject(oleFont);
int hr = Marshal.QueryInterface(pFont, ref iid, out IntPtr pIFont);
Marshal.Release(pFont);
if (NativeMethods.Failed(hr))
{
Marshal.ThrowExceptionForHR(hr);
}
return(pIFont);
}
/// <devdoc>
/// This method locates our per-process app domain and connects to a running
/// instance of ComponentManagerBroker. That instance then demand-
/// creates an instance of ComponentManagerProxy for the calling thread
/// and returns it.
/// </devdoc>
internal static UnsafeNativeMethods.IMsoComponentManager GetComponentManager(IntPtr pOriginal)
{
lock (_syncObject) {
if (_broker == null)
{
// We need the default domain for the process. That's the domain we will use
// for all component managers. There is no managed way to get this domain, however,
// so we use ICorRuntimeHost.
UnsafeNativeMethods.ICorRuntimeHost host = (UnsafeNativeMethods.ICorRuntimeHost)RuntimeEnvironment.GetRuntimeInterfaceAsObject(typeof(UnsafeNativeMethods.CorRuntimeHost).GUID, typeof(UnsafeNativeMethods.ICorRuntimeHost).GUID);
object domainObj;
int hr = host.GetDefaultDomain(out domainObj);
Debug.Assert(NativeMethods.Succeeded(hr), "ICorRuntimeHost failed to return the default domain. The only way that should happen is if it hasn't been started yet, but if it hasn't been started how are we running managed code?");
AppDomain domain = domainObj as AppDomain;
if (domain == null)
{
Debug.Assert(NativeMethods.Failed(hr) || domain != null, "ICorRuntimeHost::GetDefaultDomain succeeded but didn't retrn us an app domain.");
domain = AppDomain.CurrentDomain;
}
// Ok, we have a domain. Next, check to see if it is our current domain.
// If it is, we bypass the CreateInstanceAndUnwrap logic because we
// can directly go with the broker. In this case we will create a broker
// and NOT remote it. We will defer the remoting until we have a different
// domain. To detect this, the _broker static variable will be assigned
// a broker in the primary app domain. The CreateInstance code looks at this
// and if it is aready set, simply remotes that broker. That is why there
// is a "Singleton" property on the broker -- just in case we had to create
// a temporary broker during CreateInstanceAndUnwrap.
if (domain == AppDomain.CurrentDomain)
{
_broker = new ComponentManagerBroker();
}
else
{
_broker = GetRemotedComponentManagerBroker(domain);
}
}
}
// However we got here, we got here. What's important is that we have a proxied instance to the broker object
// and we can now call on it.
//
return(_broker.GetProxy((long)pOriginal));
}
// Due to the nature of PRINTDLGEX vs PRINTDLG, separate but similar methods
// are required for showing the print dialog on Win2k and newer OS'.
private bool ShowPrintDialog(IntPtr hwndOwner, NativeMethods.PRINTDLGEX data)
{
data.Flags = GetFlags();
data.nCopies = PrinterSettings.Copies;
data.hwndOwner = hwndOwner;
try
{
if (PageSettings == null)
{
data.hDevMode = PrinterSettings.GetHdevmode();
}
else
{
data.hDevMode = PrinterSettings.GetHdevmode(PageSettings);
}
data.hDevNames = PrinterSettings.GetHdevnames();
}
catch (InvalidPrinterException)
{
data.hDevMode = IntPtr.Zero;
data.hDevNames = IntPtr.Zero;
// Leave those fields null; Windows will fill them in
}
try
{
// Windows doesn't like it if page numbers are invalid
if (AllowSomePages)
{
if (PrinterSettings.FromPage < PrinterSettings.MinimumPage ||
PrinterSettings.FromPage > PrinterSettings.MaximumPage)
{
throw new ArgumentException(string.Format(SR.PDpageOutOfRange, "FromPage"));
}
if (PrinterSettings.ToPage < PrinterSettings.MinimumPage ||
PrinterSettings.ToPage > PrinterSettings.MaximumPage)
{
throw new ArgumentException(string.Format(SR.PDpageOutOfRange, "ToPage"));
}
if (PrinterSettings.ToPage < PrinterSettings.FromPage)
{
throw new ArgumentException(string.Format(SR.PDpageOutOfRange, "FromPage"));
}
unsafe
{
int *pageRangeField = (int *)data.pageRanges;
* pageRangeField = PrinterSettings.FromPage;
pageRangeField += 1;
*pageRangeField = PrinterSettings.ToPage;
}
data.nPageRanges = 1;
data.nMinPage = PrinterSettings.MinimumPage;
data.nMaxPage = PrinterSettings.MaximumPage;
}
//
// The flags NativeMethods.PD_SHOWHELP and NativeMethods.PD_NONETWORKBUTTON don't work with
// PrintDlgEx. So we have to strip them out.
data.Flags &= ~(NativeMethods.PD_SHOWHELP | NativeMethods.PD_NONETWORKBUTTON);
int hr = UnsafeNativeMethods.PrintDlgEx(data);
if (NativeMethods.Failed(hr) || data.dwResultAction == NativeMethods.PD_RESULT_CANCEL)
{
return(false);
}
UpdatePrinterSettings(data.hDevMode, data.hDevNames, (short)data.nCopies, data.Flags, PrinterSettings, PageSettings);
PrintToFile = ((data.Flags & NativeMethods.PD_PRINTTOFILE) != 0);
PrinterSettings.PrintToFile = PrintToFile;
if (AllowSomePages)
{
unsafe
{
int *pageRangeField = (int *)data.pageRanges;
PrinterSettings.FromPage = *pageRangeField;
pageRangeField += 1;
PrinterSettings.ToPage = *pageRangeField;
}
}
// When the flag PD_USEDEVMODECOPIESANDCOLLATE is not set,
// PRINTDLG.nCopies or PRINTDLG.nCopies indicates the number of copies the user wants
// to print, and the PD_COLLATE flag in the Flags member indicates
// whether the user wants to print them collated.
if ((data.Flags & NativeMethods.PD_USEDEVMODECOPIESANDCOLLATE) == 0)
{
PrinterSettings.Copies = (short)(data.nCopies);
PrinterSettings.Collate = ((data.Flags & NativeMethods.PD_COLLATE) == NativeMethods.PD_COLLATE);
}
// We should return true only if the user pressed the "Print" button while dismissing the dialog.
return(data.dwResultAction == NativeMethods.PD_RESULT_PRINT);
}
finally
{
if (data.hDevMode != IntPtr.Zero)
{
UnsafeNativeMethods.GlobalFree(new HandleRef(data, data.hDevMode));
}
if (data.hDevNames != IntPtr.Zero)
{
UnsafeNativeMethods.GlobalFree(new HandleRef(data, data.hDevNames));
}
if (data.pageRanges != IntPtr.Zero)
{
UnsafeNativeMethods.GlobalFree(new HandleRef(data, data.pageRanges));
}
}
}
