private static XmlElement toXmlElement(DeviceContextType deviceContext)
{
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add("samlp", Saml2Constants.SAML2_PROTOCOL_NAMESPACE);
ns.Add("saml", Saml2Constants.SAML2_ASSERTION_NAMESPACE);
ns.Add("xs", "http://www.w3.org/2001/XMLSchema");
XmlRootAttribute xRoot = new XmlRootAttribute();
xRoot.ElementName = "DeviceContext";
xRoot.Namespace = Saml2Constants.SAML2_ASSERTION_NAMESPACE;
XmlSerializer serializer = new XmlSerializer(typeof(DeviceContextType), xRoot);
MemoryStream memoryStream = new MemoryStream();
XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream, Encoding.UTF8);
serializer.Serialize(xmlTextWriter, deviceContext, ns);
XmlDocument document = new XmlDocument();
memoryStream.Seek(0, SeekOrigin.Begin);
document.Load(memoryStream);
foreach (XmlNode node in document.ChildNodes)
{
if (node is XmlElement)
{
return((XmlElement)node);
}
}
return(null);
}
/// <summary>
/// Constructor to construct a DeviceContext object from an existing Win32 device context handle.
/// </summary>
private DeviceContext(IntPtr hDC, DeviceContextType dcType)
{
_hDC = hDC;
_dcType = dcType;
CacheInitialState();
DeviceContexts.AddDeviceContext(this);
#if TRACK_HDC
Debug.WriteLine(DbgUtil.StackTraceToStr($"DeviceContext(hDC=0x{(int)hDC:X8}, Type={dcType})"));
#endif
}
//
// object construction API. Publicly constructable from static methods only.
//
/// <devdoc>
/// Constructor to contruct a DeviceContext object from an window handle.
/// </devdoc>
private DeviceContext(IntPtr hWnd)
{
this.hWnd = hWnd;
this.dcType = DeviceContextType.Display;
DeviceContexts.AddDeviceContext(this);
// the hDc will be created on demand.
#if TRACK_HDC
Debug.WriteLine(DbgUtil.StackTraceToStr(String.Format("DeviceContext( hWnd=0x{0:x8} )", unchecked ((int)hWnd))));
#endif
}
/// <summary>
/// Constructor to contruct a DeviceContext object from an existing Win32 device context handle.
/// </summary>
private DeviceContext(IntPtr hDC, DeviceContextType dcType)
{
_hDC = hDC;
DeviceContextType = dcType;
CacheInitialState();
DeviceContexts.AddDeviceContext(this);
if (dcType == DeviceContextType.Display)
{
_hWnd = User32.WindowFromDC(new HandleRef(this, this._hDC));
}
}
/// <summary>
/// Constructor to contruct a DeviceContext object from an existing Win32 device context handle.
/// </summary>
private DeviceContext(Gdi32.HDC hDC, DeviceContextType dcType)
{
_hDC = hDC;
DeviceContextType = dcType;
CacheInitialState();
DeviceContexts.AddDeviceContext(this);
if (dcType == DeviceContextType.Display)
{
_hWnd = User32.WindowFromDC(this);
}
}
/// <devdoc>
/// Constructor to contruct a DeviceContext object from an existing Win32 device context handle.
/// </devdoc>
private DeviceContext(IntPtr hDC, DeviceContextType dcType)
{
this.hDC = hDC;
this.dcType = dcType;
CacheInitialState();
DeviceContexts.AddDeviceContext(this);
if (dcType == DeviceContextType.Display)
{
this.hWnd = IntUnsafeNativeMethods.WindowFromDC(new HandleRef(this, this.hDC));
}
#if TRACK_HDC
Debug.WriteLine(DbgUtil.StackTraceToStr(String.Format("DeviceContext( hDC=0x{0:X8}, Type={1} )", unchecked ((int)hDC), dcType)));
#endif
}
/// <summary>
/// Constructor to construct a DeviceContext object from an existing Win32 device context handle.
/// </summary>
private DeviceContext(IntPtr hDC, DeviceContextType dcType)
{
_hDC = hDC;
_dcType = dcType;
CacheInitialState();
DeviceContexts.AddDeviceContext(this);
if (dcType == DeviceContextType.Display)
{
_hWnd = Interop.User32.WindowFromDC(new HandleRef(this, _hDC));
}
#if TRACK_HDC
Debug.WriteLine(DbgUtil.StackTraceToStr($"DeviceContext(hDC=0x{(int)hDC:X8}, Type={dcType})"));
#endif
}
void Paint (WidgetType widgetType, Rectangle bounds, IDeviceContext dc, TransparencyType transparencyType, Color background, DeviceContextType deviceContextType, Rectangle clippingArea, Painter painter, Rectangle excludedArea)
{
Rectangle painted_area = Rectangle.Intersect (bounds, clippingArea);
if (painted_area.Width == 0 || painted_area.Height == 0)
return;
painted_area.Offset (-bounds.X, -bounds.Y);
excludedArea.Offset (-bounds.X, -bounds.Y);
GdkDrawablePointer drawable = gdk_pixmap_new (IntPtr.Zero, bounds.Width, bounds.Height, 24);
painter.AttachStyle (widgetType, drawable, this);
GdkPixbufPointer pixbuf;
IntPtr pixel_data;
int rowstride;
GdkGCPointer gc = gdk_gc_new (drawable);
GdkColor color = new GdkColor (background);
gdk_gc_set_rgb_fg_color (gc, ref color);
Paint (drawable, gc, bounds, widgetType, out pixbuf, out pixel_data, out rowstride, painted_area, painter, excludedArea);
GdkPixbufPointer white_pixbuf = IntPtr.Zero;
IntPtr white_pixel_data = IntPtr.Zero;
int white_rowstride = 0;
GdkColor white_color = new GdkColor();
if (transparencyType == TransparencyType.Alpha) {
white_color.red = guint16.MaxValue;
white_color.green = guint16.MaxValue;
white_color.blue = guint16.MaxValue;
gdk_gc_set_rgb_fg_color (gc, ref white_color);
Paint (drawable, gc, bounds, widgetType, out white_pixbuf, out white_pixel_data, out white_rowstride, painted_area, painter, excludedArea);
}
g_object_unref (gc);
unsafe {
byte* row = (byte*)pixel_data;
byte* pixel;
byte* white_row = (byte*)white_pixel_data;
byte* white_pixel;
for (int row_index = 0; row_index < painted_area.Height; row_index++) {
pixel = row;
white_pixel = white_row;
for (int pixel_index = 0; pixel_index < painted_area.Width; pixel_index++) {
const int GdkRedOffset = 0;
const int GdkGreenOffset = 1;
const int GdkBlueOffset = 2;
const int BitmapAlphaOffset = 3;
const int BitmapRedOffset = 2;
const int BitmapBlueOffset = 0;
switch (transparencyType) {
case TransparencyType.Alpha:
pixel [BitmapAlphaOffset] = (byte)(pixel [GdkRedOffset] - white_pixel [GdkRedOffset] + byte.MaxValue);
break;
case TransparencyType.Color:
if (
pixel [GdkRedOffset] == background.R &&
pixel [GdkGreenOffset] == background.G &&
pixel [GdkBlueOffset] == background.B) {
const int AlphaFullyTransparent = 0;
pixel [BitmapAlphaOffset] = AlphaFullyTransparent;
}
break;
}
byte temporary = pixel [GdkRedOffset];
pixel [BitmapBlueOffset] = pixel [GdkBlueOffset];
pixel [BitmapRedOffset] = temporary;
const int PixelSize = 4;
pixel += PixelSize;
white_pixel += PixelSize;
}
row += rowstride;
white_row += white_rowstride;
}
}
if (transparencyType == TransparencyType.Alpha)
g_object_unref (white_pixbuf);
g_object_unref (drawable);
Bitmap bitmap = new Bitmap (painted_area.Width, painted_area.Height, rowstride, PixelFormat.Format32bppPArgb, pixel_data);
Graphics g;
bool graphics_is_from_hdc = false;
switch (deviceContextType) {
case DeviceContextType.Graphics:
g = (Graphics)dc;
break;
case DeviceContextType.Native:
g = Graphics.FromHdc (dc.GetHdc ());
break;
default:
g = dc as Graphics;
if (g == null) {
graphics_is_from_hdc = true;
g = Graphics.FromHdc (dc.GetHdc ());
} else
graphics_is_from_hdc = false;
break;
}
painted_area.Offset (bounds.X, bounds.Y);
g.DrawImage (bitmap, painted_area.Location);
switch (deviceContextType) {
case DeviceContextType.Graphics:
break;
case DeviceContextType.Native:
g.Dispose ();
dc.ReleaseHdc ();
break;
default:
if (graphics_is_from_hdc) {
g.Dispose ();
dc.ReleaseHdc ();
}
break;
}
bitmap.Dispose ();
g_object_unref (pixbuf);
}
/// <summary>
/// Generates a SAML v2.0 Authentication Request with HTTP Browser Post Binding.
/// The return string containing the request is NOT Base64 encoded.
/// </summary>
/// <param name="linkIDContext">the linkID authentication/payment configuration</param>
/// <returns>SAML request</returns>
public static AuthnRequestType generateAuthnRequest(LinkIDAuthenticationContext linkIDContext)
{
AuthnRequestType authnRequest = new AuthnRequestType();
authnRequest.ForceAuthn = true;
authnRequest.ID = Guid.NewGuid().ToString();
authnRequest.Version = "2.0";
authnRequest.IssueInstant = DateTime.UtcNow;
NameIDType issuer = new NameIDType();
issuer.Value = linkIDContext.applicationName;
authnRequest.Issuer = issuer;
NameIDPolicyType nameIdPolicy = new NameIDPolicyType();
nameIdPolicy.AllowCreate = true;
nameIdPolicy.AllowCreateSpecified = true;
authnRequest.NameIDPolicy = nameIdPolicy;
Dictionary <string, string> deviceContextMap = linkIDContext.getDeviceContextMap();
DeviceContextType deviceContext = null;
if (null != deviceContextMap && deviceContextMap.Count > 0)
{
deviceContext = new DeviceContextType();
List <AttributeType> attributes = new List <AttributeType>();
foreach (string deviceContextKey in deviceContextMap.Keys)
{
string deviceContextValue = deviceContextMap[deviceContextKey];
AttributeType attribute = new AttributeType();
attribute.Name = deviceContextKey;
attribute.AttributeValue = new object[] { deviceContextValue };
attributes.Add(attribute);
deviceContext.Items = attributes.ToArray();
}
}
SubjectAttributesType subjectAttributes = null;
if (null != linkIDContext.attributeSuggestions && linkIDContext.attributeSuggestions.Count > 0)
{
subjectAttributes = new SubjectAttributesType();
List <AttributeType> attributes = new List <AttributeType>();
foreach (string attributeName in linkIDContext.attributeSuggestions.Keys)
{
List <object> values = linkIDContext.attributeSuggestions[attributeName];
AttributeType attribute = new AttributeType();
attribute.Name = attributeName;
attribute.AttributeValue = values.ToArray();
attributes.Add(attribute);
subjectAttributes.Items = attributes.ToArray();
}
}
PaymentContextType paymentContextType = null;
if (null != linkIDContext.paymentContext)
{
Dictionary <String, String> paymentContextDict = linkIDContext.paymentContext.toDictionary();
paymentContextType = new PaymentContextType();
List <AttributeType> attributes = new List <AttributeType>();
foreach (string paymentContextKey in paymentContextDict.Keys)
{
string value = paymentContextDict[paymentContextKey];
AttributeType attribute = new AttributeType();
attribute.Name = paymentContextKey;
attribute.AttributeValue = new object[] { value };
attributes.Add(attribute);
paymentContextType.Items = attributes.ToArray();
}
}
CallbackType callbackType = null;
if (null != linkIDContext.callback)
{
Dictionary <String, String> callbackDict = linkIDContext.callback.toDictionary();
callbackType = new CallbackType();
List <AttributeType> attributes = new List <AttributeType>();
foreach (string callbackKey in callbackDict.Keys)
{
string value = callbackDict[callbackKey];
AttributeType attribute = new AttributeType();
attribute.Name = callbackKey;
attribute.AttributeValue = new object[] { value };
attributes.Add(attribute);
callbackType.Items = attributes.ToArray();
}
}
if (null != deviceContext || null != subjectAttributes || null != paymentContextType || null != callbackType)
{
ExtensionsType extensions = new ExtensionsType();
List <XmlElement> extensionsList = new List <XmlElement>();
if (null != subjectAttributes)
{
extensionsList.Add(toXmlElement(subjectAttributes));
}
if (null != deviceContext)
{
extensionsList.Add(toXmlElement(deviceContext));
}
if (null != paymentContextType)
{
extensionsList.Add(toXmlElement(paymentContextType));
}
if (null != callbackType)
{
extensionsList.Add(toXmlElement(callbackType));
}
extensions.Any = extensionsList.ToArray();
authnRequest.Extensions = extensions;
}
return(authnRequest);
}
public _DeviceContext(IntPtr compatibleDc, DeviceContextType type)
{
// System.Drawing.Internal.DeviceContext
hDC = compatibleDc;
}
private DeviceContext(IntPtr hDC, DeviceContextType dcType)
{
this.hDC = hDC;
this.dcType = dcType;
CacheInitialState();
DeviceContexts.AddDeviceContext(this);
if( dcType == DeviceContextType.Display )
{
this.hWnd = IntUnsafeNativeMethods.WindowFromDC( new HandleRef( this, this.hDC) );
}
#if TRACK_HDC
Debug.WriteLine( DbgUtil.StackTraceToStr( String.Format("DeviceContext( hDC=0x{0:X8}, Type={1} )", unchecked((int) hDC), dcType) ));
#endif
}
//
// object construction API. Publicly constructable from static methods only.
//
/// <devdoc>
/// Constructor to contruct a DeviceContext object from an window handle.
/// </devdoc>
private DeviceContext(IntPtr hWnd)
{
this.hWnd = hWnd;
this.dcType = DeviceContextType.Display;
DeviceContexts.AddDeviceContext(this);
// the hDc will be created on demand.
#if TRACK_HDC
Debug.WriteLine( DbgUtil.StackTraceToStr(String.Format( "DeviceContext( hWnd=0x{0:x8} )", unchecked((int) hWnd))));
#endif
}