/// <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); }