/// <summary>
/// Measure children sizes
/// </summary>
private SizeRequest MeasureChildren(double width, double height)
{
SizeRequest size = new SizeRequest();
foreach (View child in Children)
{
if (child.IsVisible == false)
{
continue;
}
SizeRequest childSize = new SizeRequest();
SizeCache sizeCache = null;
if (m_childrenSizes.TryGetValue(child, out sizeCache) == false)
{
sizeCache = new SizeCache(child);
m_childrenSizes.Add(child, sizeCache);
}
if (Orientation == StackOrientations.Depth)
{
if (double.IsNaN(width) == false && double.IsNaN(height) == false && double.IsInfinity(width) == false && double.IsInfinity(height) == false)
{
Size s = new Size(width - Spacing * 2, height - Spacing * 2);
childSize = new SizeRequest(s, s);
}
else
{
childSize = sizeCache.GetSize(new Size(width, double.PositiveInfinity));
if (size.Request.Width < childSize.Request.Width)
{
size.Request = new Size(childSize.Request.Width, size.Request.Height);
}
if (size.Request.Height < childSize.Request.Height)
{
size.Request = new Size(size.Request.Width, childSize.Request.Height);
}
if (size.Minimum.Width < childSize.Minimum.Width)
{
size.Minimum = new Size(childSize.Minimum.Width, size.Minimum.Height);
}
if (size.Minimum.Height < childSize.Minimum.Height)
{
size.Minimum = new Size(size.Minimum.Width, childSize.Minimum.Height);
}
}
}
else if (Orientation == StackOrientations.Horizontal)
{
childSize = sizeCache.GetSize(new Size(double.PositiveInfinity, height));
// Update total size width
size.Request = new Size(size.Request.Width + childSize.Request.Width + Spacing, size.Request.Height);
size.Minimum = new Size(size.Minimum.Width + childSize.Minimum.Width + Spacing, size.Minimum.Height);
// Update total size height
double childReqHeight = childSize.Request.Height;
double childMinHeight = childSize.Minimum.Height;
if (size.Request.Height < childReqHeight)
{
size.Request = new Size(size.Request.Width, childReqHeight);
}
if (size.Minimum.Height < childMinHeight)
{
size.Minimum = new Size(size.Minimum.Width, childReqHeight);
}
}
else
{
childSize = sizeCache.GetSize(new Size(width, double.PositiveInfinity));
// Update total size height
size.Request = new Size(size.Request.Width, size.Request.Height + childSize.Request.Height + Spacing);
size.Minimum = new Size(size.Minimum.Width, size.Minimum.Height + childSize.Minimum.Height + Spacing);
// Update total size width
double childReqWidth = childSize.Request.Width;
double childMinWidth = childSize.Minimum.Width;
if (size.Request.Width < childReqWidth)
{
size.Request = new Size(childReqWidth, size.Request.Height);
}
if (size.Minimum.Width < childMinWidth)
{
size.Minimum = new Size(childMinWidth, size.Minimum.Height);
}
}
}
return(size);
}
private T InternalRead <T>(IntPtr address)
{
try
{
if (address == IntPtr.Zero)
{
throw new InvalidOperationException("Cannot retrieve a value at address 0");
}
object ret;
switch (SizeCache <T> .TypeCode)
{
case TypeCode.Object:
if (SizeCache <T> .IsIntPtr)
{
return((T)(object)*(IntPtr *)address);
}
// If the type doesn't require an explicit Marshal call, then ignore it and memcpy the f****n thing.
if (!SizeCache <T> .TypeRequiresMarshal)
{
T o = default(T);
void *ptr = SizeCache <T> .GetUnsafePtr(ref o);
NativeMethods.MoveMemory(ptr, (void *)address, SizeCache <T> .Size);
return(o);
}
// All System.Object's require marshaling!
ret = Marshal.PtrToStructure(address, typeof(T));
break;
case TypeCode.Boolean:
ret = *(byte *)address != 0;
break;
case TypeCode.Char:
ret = *(char *)address;
break;
case TypeCode.SByte:
ret = *(sbyte *)address;
break;
case TypeCode.Byte:
ret = *(byte *)address;
break;
case TypeCode.Int16:
ret = *(short *)address;
break;
case TypeCode.UInt16:
ret = *(ushort *)address;
break;
case TypeCode.Int32:
ret = *(int *)address;
break;
case TypeCode.UInt32:
ret = *(uint *)address;
break;
case TypeCode.Int64:
ret = *(long *)address;
break;
case TypeCode.UInt64:
ret = *(ulong *)address;
break;
case TypeCode.Single:
ret = *(float *)address;
break;
case TypeCode.Double:
ret = *(double *)address;
break;
case TypeCode.Decimal:
// Probably safe to remove this. I'm unaware of anything that actually uses "decimal" that would require memory reading...
ret = *(decimal *)address;
break;
default:
throw new ArgumentOutOfRangeException();
}
return((T)ret);
}
catch (AccessViolationException ex)
{
Trace.WriteLine("Access Violation on " + address + " with type " + typeof(T).Name);
return(default(T));
}
}
/// <summary>
/// Copies the specified number of bytes from value to buffer, starting at index.
/// </summary>
/// <param name="value">The value to copy</param>
/// <param name="bytes">The number of bytes to copy</param>
/// <param name="buffer">The buffer to copy the bytes into</param>
/// <param name="index">The index to start at</param>
protected override unsafe void CopyBytesImpl(long value, int bytes, byte[] buffer, int index)
{
fixed(byte *buf = buffer)
UnsafeNativeMethods.CopyMemory((byte *)SizeCache <long> .GetUnsafePtr(ref value), buf + index, bytes);
}
