public void SetLayout(LayoutAlignment vertical, LayoutAlignment horizontal, int offset = 0)
{
VerticalLayoutAlignment = vertical;
HorizontalLayoutAlignment = horizontal;
OffsetX = offset;
OffsetY = offset;
}
public static VerticalAlignment ToXamlVerticalAlignment(
this LayoutAlignment layoutAlignment)
{
VerticalAlignment alignment;
if (layoutAlignment == LayoutAlignment.Start)
{
alignment = VerticalAlignment.Top;
}
else if (layoutAlignment == LayoutAlignment.End)
{
alignment = VerticalAlignment.Bottom;
}
else if (layoutAlignment == LayoutAlignment.Center)
{
alignment = VerticalAlignment.Center;
}
else if (layoutAlignment == LayoutAlignment.Fill)
{
alignment = VerticalAlignment.Stretch;
}
else
{
throw new ArgumentOutOfRangeException(nameof(layoutAlignment), layoutAlignment, "Unsupported alignment.");
}
return(alignment);
}
public static CanvasHorizontalAlignment ToCanvasHorizontalAlignment(
this LayoutAlignment layoutAlignment)
{
CanvasHorizontalAlignment alignment;
if (layoutAlignment == LayoutAlignment.Start)
{
alignment = CanvasHorizontalAlignment.Left;
}
else if (layoutAlignment == LayoutAlignment.End)
{
alignment = CanvasHorizontalAlignment.Right;
}
else if (layoutAlignment == LayoutAlignment.Center)
{
alignment = CanvasHorizontalAlignment.Center;
}
else if (layoutAlignment == LayoutAlignment.Fill)
{
alignment = CanvasHorizontalAlignment.Justified;
}
else
{
throw new ArgumentOutOfRangeException(nameof(layoutAlignment), layoutAlignment, "Unsupported alignment.");
}
return(alignment);
}
static double AlignHorizontal(double startX, double startMargin, double endMargin, double boundsWidth,
double desiredWidth, LayoutAlignment horizontalLayoutAlignment)
{
double frameX = 0;
switch (horizontalLayoutAlignment)
{
case LayoutAlignment.Fill:
case LayoutAlignment.Start:
frameX = startX + startMargin;
break;
case LayoutAlignment.Center:
frameX = (boundsWidth - desiredWidth) / 2;
var marginOffset = (startMargin - endMargin) / 2;
frameX += marginOffset;
break;
case LayoutAlignment.End:
frameX = boundsWidth - endMargin - desiredWidth;
break;
}
return(frameX);
}
public LayoutOptions(LayoutAlignment alignment, bool expands)
{
var a = (int)alignment;
if (a < 0 || a > 3)
throw new ArgumentOutOfRangeException();
_flags = (int)alignment | (expands ? (int)LayoutExpandFlag.Expand : 0);
}
public static global::Android.Views.GravityFlags ToAndroidHorizontalLayoutGravityFlags(
this LayoutAlignment layoutAlignment)
{
global::Android.Views.GravityFlags gravityFlags;
if (layoutAlignment == LayoutAlignment.Start)
{
gravityFlags = global::Android.Views.GravityFlags.Left;
}
else if (layoutAlignment == LayoutAlignment.End)
{
gravityFlags = global::Android.Views.GravityFlags.Right;
}
else if (layoutAlignment == LayoutAlignment.Center)
{
gravityFlags = global::Android.Views.GravityFlags.CenterHorizontal;
}
else if (layoutAlignment == LayoutAlignment.Fill)
{
gravityFlags = global::Android.Views.GravityFlags.FillHorizontal;
}
else
{
throw new ArgumentOutOfRangeException(nameof(layoutAlignment), layoutAlignment, "Unsupported alignment.");
}
return(gravityFlags);
}
public HeaderView(UIEdgeInsets padding, LayoutAlignment align)
{
Label = new UILabel();
Label.Lines = 1;
Label.LineBreakMode = UILineBreakMode.TailTruncation;
Label.TranslatesAutoresizingMaskIntoConstraints = false;
this.AddSubview(Label);
Label.LeftAnchor.ConstraintEqualTo(this.LeftAnchor, padding.Left).Active = true;
Label.RightAnchor.ConstraintEqualTo(this.RightAnchor, -padding.Right).Active = true;
if (align == LayoutAlignment.Start)
{
Label.TopAnchor.ConstraintEqualTo(this.TopAnchor, padding.Top).Active = true;
}
else if (align == LayoutAlignment.End)
{
Label.BottomAnchor.ConstraintEqualTo(this.BottomAnchor, -padding.Bottom).Active = true;
}
else
{
Label.CenterYAnchor.ConstraintEqualTo(this.CenterYAnchor, 0).Active = true;
}
}
public static GravityFlags ToNativeVertical(this LayoutAlignment forms)
{
return(forms switch
{
LayoutAlignment.Start => GravityFlags.Top,
LayoutAlignment.Center => GravityFlags.CenterVertical,
LayoutAlignment.End => GravityFlags.Bottom,
_ => GravityFlags.FillHorizontal
});
public static UIStackViewAlignment ToNativeVertical(this LayoutAlignment forms)
{
return(forms switch
{
LayoutAlignment.Start => UIStackViewAlignment.Leading,
LayoutAlignment.Center => UIStackViewAlignment.Center,
LayoutAlignment.End => UIStackViewAlignment.Trailing,
_ => UIStackViewAlignment.Fill
});
public LayoutOptions(LayoutAlignment alignment, bool expands)
{
var a = (int)alignment;
if (a < 0 || a > 3)
{
throw new ArgumentOutOfRangeException();
}
_flags = (int)alignment | (expands ? (int)LayoutExpandFlag.Expand : 0);
}
public LayoutParams(
float width,
float height,
LayoutAlignment horizontalAlignment,
LayoutAlignment verticalAlignment)
{
this.Width = width;
this.Height = height;
this.HorizontalAlignment = horizontalAlignment;
this.VerticalAlignment = verticalAlignment;
}
public static double ToDouble(this LayoutAlignment align)
{
switch (align)
{
case LayoutAlignment.Start:
return(0);
case LayoutAlignment.Center:
return(0.5);
case LayoutAlignment.End:
return(1);
}
throw new ArgumentOutOfRangeException("align");
}
public static double LayoutAlignmentToDouble(this LayoutAlignment alignment)
{
double alignValue = 0.5;
switch (alignment)
{
case LayoutAlignment.Start:
alignValue = 0.0;
break;
case LayoutAlignment.End:
alignValue = 1.0;
break;
}
return(alignValue);
}
public static GravityFlags ToGravityFlags(this LayoutAlignment forms, bool expand)
{
GravityFlags result = forms switch
{
LayoutAlignment.Start => GravityFlags.Start | GravityFlags.CenterVertical,
LayoutAlignment.Center => GravityFlags.CenterHorizontal | GravityFlags.CenterVertical,
LayoutAlignment.End => GravityFlags.End | GravityFlags.CenterVertical,
_ => GravityFlags.Fill
};
if (expand)
{
result |= GravityFlags.Fill;
}
return(result);
}
/// <summary>
/// Tos the native horizontal.
/// </summary>
/// <returns>The native horizontal.</returns>
/// <param name="forms">Forms.</param>
public static UIStackViewAlignment ToNativeHorizontal(this LayoutAlignment forms)
{
switch (forms)
{
case LayoutAlignment.Start:
return(UIStackViewAlignment.Top);
case LayoutAlignment.Center:
return(UIStackViewAlignment.Center);
case LayoutAlignment.End:
return(UIStackViewAlignment.Bottom);
default:
return(UIStackViewAlignment.Fill);
}
}
/// <summary>
/// Tos the native vertical.
/// </summary>
/// <returns>The native vertical.</returns>
/// <param name="forms">Forms.</param>
public static UIStackViewAlignment ToNativeVertical(this LayoutAlignment forms)
{
switch (forms)
{
case LayoutAlignment.Start:
return(UIStackViewAlignment.Leading);
case LayoutAlignment.Center:
return(UIStackViewAlignment.Center);
case LayoutAlignment.End:
return(UIStackViewAlignment.Trailing);
default:
return(UIStackViewAlignment.Fill);
}
}
public static GravityFlags ToAndroidVertical(this LayoutAlignment formsAlignment)
{
switch (formsAlignment)
{
case LayoutAlignment.Start:
return(GravityFlags.Top);
case LayoutAlignment.Center:
return(GravityFlags.CenterVertical);
case LayoutAlignment.End:
return(GravityFlags.Bottom);
default:
return(GravityFlags.FillHorizontal);
}
}
/// <summary>
/// Tos the native horizontal.
/// </summary>
/// <returns>The native horizontal.</returns>
/// <param name="forms">Forms.</param>
public static GravityFlags ToNativeHorizontal(this LayoutAlignment forms)
{
switch (forms)
{
case LayoutAlignment.Start:
return(GravityFlags.Start);
case LayoutAlignment.Center:
return(GravityFlags.CenterHorizontal);
case LayoutAlignment.End:
return(GravityFlags.End);
default:
return(GravityFlags.FillVertical);
}
}
public void FrameSizeGoesToZeroWhenMarginsExceedBounds(LayoutAlignment layoutAlignment)
{
var element = Substitute.For <IView>();
var margin = new Thickness(200);
element.Margin.Returns(margin);
element.HorizontalLayoutAlignment.Returns(layoutAlignment);
element.VerticalLayoutAlignment.Returns(layoutAlignment);
var bounds = new Rectangle(0, 0, 100, 100);
var frame = element.ComputeFrame(bounds);
// The margin is simply too large for the bounds; since negative widths/heights on a frame don't make sense,
// we expect them to collapse to zero
Assert.Equal(0, frame.Height);
Assert.Equal(0, frame.Width);
}
public static void Show(String popupAutomationId, Rect rect, LayoutAlignment horizontalLayoutAlignment = LayoutAlignment.Start, Boolean outsideRectHorizontally = false, LayoutAlignment verticalLayoutAlignment = LayoutAlignment.End, Boolean outsideRectVertically = true, Point translation = default, int delay = -1)
{
// NOT NECESSARY TO BE ON MAIN THREAD
PopupAction popupAction = new PopupAction
{
PopupAutomationId = popupAutomationId,
LinkedToAutomationId = null,
Rect = rect,
OutsideRectHorizontally = outsideRectHorizontally,
OutsideRectVertically = outsideRectVertically,
HorizontalLayoutAlignment = horizontalLayoutAlignment,
VerticalLayoutAlignment = verticalLayoutAlignment,
Translation = translation,
Delay = delay
};
PrepareToShow(popupAction);
}
static double AlignHorizontal(double startX, double startMargin, double endMargin, double boundsWidth,
double desiredWidth, LayoutAlignment horizontalLayoutAlignment)
{
double frameX = startX + startMargin;
switch (horizontalLayoutAlignment)
{
case LayoutAlignment.Center:
frameX += (boundsWidth - desiredWidth) / 2;
break;
case LayoutAlignment.End:
frameX += boundsWidth - desiredWidth;
break;
}
return(frameX);
}
private int DimensionToAndroidDimension(
LayoutAlignment alignment,
Dimension dimension)
{
if (dimension == Dimension.Auto)
{
if (alignment == LayoutAlignment.Fill)
{
return(global::Android.Views.ViewGroup.LayoutParams.MatchParent);
}
else
{
return(global::Android.Views.ViewGroup.LayoutParams.WrapContent);
}
}
return((int)DevicePixelsToPixels(dimension));
}
public void FrameAccountsForVerticalLayoutAlignment(LayoutAlignment layoutAlignment, Thickness margin,
double expectedY, double expectedHeight)
{
var widthConstraint = 50;
var heightConstraint = 300;
var viewSize = new Size(50, 100);
var element = Substitute.For <IView>();
element.Margin.Returns(margin);
element.DesiredSize.Returns(viewSize);
element.VerticalLayoutAlignment.Returns(layoutAlignment);
var frame = element.ComputeFrame(new Rectangle(0, 0, widthConstraint, heightConstraint));
Assert.Equal(expectedY, frame.Top);
Assert.Equal(expectedHeight, frame.Height);
}
public void FrameAccountsForHorizontalLayoutAlignment(LayoutAlignment layoutAlignment, Thickness margin,
double expectedX, double expectedWidth)
{
var widthConstraint = 300;
var heightConstraint = 50;
var viewSize = new Size(100, 50);
var element = Substitute.For <IView>();
element.Margin.Returns(margin);
element.DesiredSize.Returns(viewSize);
element.HorizontalLayoutAlignment.Returns(layoutAlignment);
var frame = element.ComputeFrame(new Rectangle(0, 0, widthConstraint, heightConstraint));
Assert.Equal(expectedX, frame.Left);
Assert.Equal(expectedWidth, frame.Width);
}
public CustomPage(bool showTopMargin = false, LayoutAlignment footerLogoHorizontalOptions = LayoutAlignment.Start, bool showMinimumContents = false, double topMargin = -1, int cornersRadius = 0)
{
Animation = new CustomPageAnimation();
if (!showTopMargin)
{
BackgroundColor = Color.Transparent;
}
ShowTopMargin = showTopMargin;
FooterLogoHorizontalOptions = footerLogoHorizontalOptions;
ShowMinimumContents = showMinimumContents;
CornersRadius = cornersRadius;
if (topMargin > 0)
{
TopMargin = topMargin;
}
if (Device.RuntimePlatform == Device.iOS)
{
HasSystemPadding = false;
}
}
public void SetVerticalAlignment(LayoutAlignment align)
{
if (_isInitialized && align == _curAlignment)
{
return;
}
foreach (NSLayoutConstraint c in _constraints)
{
c.Active = false;
c.Dispose();
}
_constraints.Clear();
_constraints.Add(Label.LeftAnchor.ConstraintEqualTo(ContentView.LeftAnchor, 0));
_constraints.Add(Label.RightAnchor.ConstraintEqualTo(ContentView.RightAnchor, 0));
if (align == LayoutAlignment.Start)
{
_constraints.Add(Label.TopAnchor.ConstraintEqualTo(ContentView.TopAnchor, 0));
}
else if (align == LayoutAlignment.End)
{
_constraints.Add(Label.BottomAnchor.ConstraintEqualTo(ContentView.BottomAnchor, 0));
}
else
{
_constraints.Add(Label.CenterYAnchor.ConstraintEqualTo(ContentView.CenterYAnchor, 0));
}
_constraints.ForEach(c =>
{
c.Priority = 999f; // fix warning-log:Unable to simultaneously satisfy constraints.
c.Active = true;
}
);
_curAlignment = align;
_isInitialized = true;
}
public void FrameAccountsForHorizontalLayoutAlignmentRtl(LayoutAlignment layoutAlignment, Point offset, Thickness margin,
double expectedX, double expectedWidth)
{
var widthConstraint = 300;
var heightConstraint = 50;
var viewSizeIncludingMargins = new Size(100, 50);
var element = Substitute.For <IView>();
element.Margin.Returns(margin);
element.DesiredSize.Returns(viewSizeIncludingMargins);
element.FlowDirection.Returns(FlowDirection.RightToLeft);
element.HorizontalLayoutAlignment.Returns(layoutAlignment);
element.Width.Returns(Dimension.Unset);
element.Height.Returns(Dimension.Unset);
var frame = element.ComputeFrame(new Rectangle(offset.X, offset.Y, widthConstraint, heightConstraint));
Assert.Equal(expectedX, frame.Left);
Assert.Equal(expectedWidth, frame.Width);
}
public void LayoutExpansion(StackOrientation orientation, LayoutAlignment align, bool expand, double x1, double y1, double w1, double h1, double x2, double y2, double w2, double h2)
{
var options = new LayoutOptions(align, expand);
var stack = new StackLayout
{
IsPlatformEnabled = true,
Spacing = 0,
Orientation = orientation
};
View child1, child2;
stack.Children.Add(child1 = new View
{
IsPlatformEnabled = true,
WidthRequest = 100,
HeightRequest = 100
});
if (orientation == StackOrientation.Vertical)
{
child1.VerticalOptions = options;
}
else
{
child1.HorizontalOptions = options;
}
stack.Children.Add(child2 = new View
{
IsPlatformEnabled = true,
WidthRequest = 10,
HeightRequest = 10
});
stack.Layout(new Rectangle(0, 0, 200, 200));
Assert.AreEqual(new Rectangle(x1, y1, w1, h1), child1.Bounds);
Assert.AreEqual(new Rectangle(x2, y2, w2, h2), child2.Bounds);
}
public void FrameAccountsForVerticalLayoutAlignment(LayoutAlignment layoutAlignment, Point offset, Thickness margin,
double expectedY, double expectedHeight)
{
var widthConstraint = 50;
var heightConstraint = 300;
var viewSize = new Size(50, 100);
var viewSizeIncludingMargins = new Size(viewSize.Width + margin.HorizontalThickness, viewSize.Height + margin.VerticalThickness);
var element = Substitute.For <IView>();
element.Margin.Returns(margin);
element.DesiredSize.Returns(viewSizeIncludingMargins);
element.VerticalLayoutAlignment.Returns(layoutAlignment);
element.Width.Returns(Dimension.Unset);
element.Height.Returns(Dimension.Unset);
element.FlowDirection.Returns(FlowDirection.LeftToRight);
var frame = element.ComputeFrame(new Rect(offset.X, offset.Y, widthConstraint, heightConstraint));
Assert.Equal(expectedY, frame.Top);
Assert.Equal(expectedHeight, frame.Height);
}
private static float DimensionToSize(
LayoutAlignment alignment,
Dimension dimension)
{
float value;
if (dimension == Dimension.Auto)
{
if (alignment == LayoutAlignment.Fill)
{
value = NativeLayout.LayoutParams.MatchParent;
}
else
{
value = NativeLayout.LayoutParams.WrapContent;
}
}
else
{
value = dimension;
}
return(value);
}
private static double GetYPosition(ContentPage contentPage, View view, LayoutAlignment layoutAlignment, Rect rect, bool outsideRect, double translateY)
{
double Y = 0;
double viewHeight = view.HeightRequest;
if (viewHeight == -1)
{
viewHeight = view.Height;
}
// Do we want the popup outside or inside
if (outsideRect)
{
switch (layoutAlignment)
{
case LayoutAlignment.Start:
case LayoutAlignment.Fill:
Y = rect.Y - viewHeight;
break;
case LayoutAlignment.End:
Y = rect.Y + rect.Height;
break;
case LayoutAlignment.Center:
Y = rect.Y + (rect.Height - viewHeight) / 2;
break;
}
Y += translateY;
// Sanity check
if (Y + viewHeight + MINIMAL_MARGIN > contentPage.Height)
{
if (layoutAlignment == LayoutAlignment.End)
{
Y = GetYPosition(contentPage, view, LayoutAlignment.Start, rect, outsideRect, translateY);
}
}
}
else // We want the popup inside
{
switch (layoutAlignment)
{
case LayoutAlignment.Start:
case LayoutAlignment.Fill:
Y = rect.Y;
break;
case LayoutAlignment.End:
Y = rect.Y + rect.Height - viewHeight;
break;
case LayoutAlignment.Center:
Y = rect.Y + (rect.Height - viewHeight) / 2;
break;
}
}
// Fianl Sanity check on Y
if (Y + viewHeight + MINIMAL_MARGIN > contentPage.Height)
{
Y = contentPage.Height - viewHeight - MINIMAL_MARGIN;
}
if (Y < MINIMAL_MARGIN)
{
Y = MINIMAL_MARGIN;
}
return(Y);
}
public static Button CreateButton(
string text,
ButtonStyle style,
LayoutAlignment alignment,
bool stretch,
string img = "blank.png")
{
bool isBlank = img.Equals ("blank.jpg");
var imageSource = ImageSource.FromResource ("BeatFitApp.Icons." + img);
Button button = null;
Device.OnPlatform (
// iOS -- plain button
() => {
button = new Button()
{
Text = text,
FontSize = Device.GetNamedSize (NamedSize.Micro, typeof(Button)),
HorizontalOptions = new LayoutOptions () {
Alignment = alignment,
Expands = stretch
}
};
},
// Android -- image button
() => {
button = new ImageButton () {
Text = text,
FontSize = Device.GetNamedSize (NamedSize.Micro, typeof(Button)),
Orientation = (isBlank ? ImageOrientation.ImageToRight : ImageOrientation.ImageToLeft),
Source = imageSource,
DisabledSource = imageSource,
ImageHeightRequest = 16,
ImageWidthRequest = isBlank ? 1 : 16,
HorizontalOptions = new LayoutOptions () {
Alignment = alignment,
Expands = stretch
},
HeightRequest = 32
};
});
switch (style) {
case ButtonStyle.Positive:
button.BackgroundColor = PoliceBlue;
button.TextColor = Color.White;
break;
case ButtonStyle.Negative:
button.BackgroundColor = DarkPoliceBlue;
button.TextColor = Color.White;
break;
case ButtonStyle.Neutral:
button.BackgroundColor = Color.FromRgb (220, 220, 220);
button.BorderColor = Color.FromRgb (175, 175, 175);
button.TextColor = Color.Black;
break;
case ButtonStyle.Warning:
button.BackgroundColor = WarningRed;
button.TextColor = LightWarningRed;
break;
}
return button;
}
/// <summary>
/// 指定した矩形のレイアウト
/// </summary>
/// <param s="region">配置する矩形</param>
/// <param s="horizontalMargin">垂直方向のマージン</param>
/// <param s="verticalMargine">水平方向のマージン</param>
/// <param s="alignment">アライメント</param>
/// <returns>配置された矩形</returns>
public Rectangle Place(Rectangle region, float horizontalMargin, float verticalMargine, LayoutAlignment alignment)
{
// horizontal
if ((alignment & LayoutAlignment.Left) != 0)
{
region.X = ClientArea.X + (int) (ClientArea.Width * horizontalMargin);
}
else if ((alignment & LayoutAlignment.Right) != 0)
{
region.X = ClientArea.X +
(int) (ClientArea.Width * (1.0f - horizontalMargin)) - region.Width;
}
else if ((alignment & LayoutAlignment.HorizontalCenter) != 0)
{
region.X = ClientArea.X + (ClientArea.Width - region.Width) / 2 +
(int) (horizontalMargin * ClientArea.Width);
}
else
{
// no layout
}
// vertical
if ((alignment & LayoutAlignment.Top) != 0)
{
region.Y = ClientArea.Y + (int) (ClientArea.Height * verticalMargine);
}
else if ((alignment & LayoutAlignment.Bottom) != 0)
{
region.Y = ClientArea.Y +
(int) (ClientArea.Height * (1.0f - verticalMargine)) - region.Height;
}
else if ((alignment & LayoutAlignment.VerticalCenter) != 0)
{
region.Y = ClientArea.Y + (ClientArea.Height - region.Height) / 2 +
(int) (verticalMargine * ClientArea.Height);
}
else
{
// no layout
}
// check if the layout region is in the title safe area
if (region.Left < TitleSafeArea.Left)
{
region.X = TitleSafeArea.Left;
}
if (region.Right > TitleSafeArea.Right)
{
region.X = TitleSafeArea.Right - region.Width;
}
if (region.Top < TitleSafeArea.Top)
{
region.Y = TitleSafeArea.Top;
}
if (region.Bottom > TitleSafeArea.Bottom)
{
region.Y = TitleSafeArea.Bottom - region.Height;
}
return region;
}
/// <summary>
/// 指定したサイズ矩形のレイアウト
/// </summary>
/// <param s="region">配置する矩形</param>
/// <param s="horizontalMargin">垂直方向のマージン</param>
/// <param s="verticalMargine">水平方向のマージン</param>
/// <param s="alignment">アライメント</param>
/// <returns>配置された矩形</returns>
public Vector2 Place(Vector2 size, float horizontalMargin, float verticalMargine, LayoutAlignment alignment)
{
Rectangle rc = new Rectangle(0, 0, (int) size.X, (int) size.Y);
rc = Place(rc, horizontalMargin, verticalMargine, alignment);
return new Vector2(rc.X, rc.Y);
}
