void ParseNote(XmlReader reader, float parentWidthUnits, float parentHeightUnits)
{
DeviceHeight = parentHeightUnits;
// get the style first
Styles.Style.ParseStyleAttributesWithDefaults(reader, ref mStyle, ref ControlStyles.mMainNote);
// check for attributes we support
RectangleF bounds = new RectangleF( );
SizeF parentSize = new SizeF(parentWidthUnits, parentHeightUnits);
Parser.ParseBounds(reader, ref parentSize, ref bounds);
// Parent note doesn't support margins.
// PADDING
float leftPadding = Styles.Style.GetValueForNullable(mStyle.mPaddingLeft, parentWidthUnits, 0);
float rightPadding = Styles.Style.GetValueForNullable(mStyle.mPaddingRight, parentWidthUnits, 0);
float topPadding = Styles.Style.GetValueForNullable(mStyle.mPaddingTop, parentHeightUnits, 0);
float bottomPadding = Styles.Style.GetValueForNullable(mStyle.mPaddingBottom, parentHeightUnits, 0);
Padding = new RectangleF(leftPadding, rightPadding, topPadding, bottomPadding);
// now calculate the available width based on padding. (Don't actually change our width)
float availableWidth = parentWidthUnits - leftPadding - rightPadding;
// A "special" (we won't call this a hack) attribute that will enable the user
// to have a header container that spans the full width of the note, which allows
// it to be unaffected by the padding.
string result = reader.GetAttribute("FullWidthHeader");
if (string.IsNullOrEmpty(result) == false)
{
mStyle.mFullWidthHeader = bool.Parse(result);
}
// begin reading the xml stream
bool finishedReading = false;
while (finishedReading == false && reader.Read( ))
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
{
float workingWidth = availableWidth;
if (Header.ElementTagMatches(reader.Name) == true && mStyle.mFullWidthHeader == true)
{
workingWidth = parentWidthUnits;
}
IUIControl control = Parser.TryParseControl(new BaseControl.CreateParams(this, workingWidth, parentHeightUnits, ref mStyle), reader);
ChildControls.Add(control);
break;
}
case XmlNodeType.EndElement:
{
if (reader.Name == "Note")
{
finishedReading = true;
}
break;
}
}
}
// lay stuff out vertically. If the notes were built by hand, like a stackPanel.
// if not by hand, like a canvas.
float noteHeight = bounds.Y + topPadding;
foreach (IUIControl control in ChildControls)
{
RectangleF controlFrame = control.GetFrame( );
RectangleF controlMargin = control.GetMargin( );
// horizontally position the controls according to their
// requested alignment
Alignment controlAlignment = control.GetHorzAlignment( );
// adjust by our position
float xAdjust = 0;
switch (controlAlignment)
{
case Alignment.Center:
{
xAdjust = bounds.X + ((availableWidth / 2) - (controlFrame.Width / 2));
break;
}
case Alignment.Right:
{
xAdjust = bounds.X + (availableWidth - (controlFrame.Width + controlMargin.Width));
break;
}
case Alignment.Left:
{
xAdjust = bounds.X;
break;
}
}
// place this next control at yOffset. yOffset should be the current noteHeight, which makes each control relative to the one above it.
float yOffset = noteHeight;
// if it's the header and full width is specified, don't apply padding.
if (control as Header != null && mStyle.mFullWidthHeader == true)
{
control.AddOffset(xAdjust, yOffset);
}
else
{
control.AddOffset(xAdjust + leftPadding, yOffset);
}
// update the note height
noteHeight = control.GetFrame( ).Bottom + controlMargin.Height;
}
bounds.Width = parentWidthUnits;
bounds.Height = (noteHeight - bounds.Y) + bottomPadding;
Frame = bounds;
AddControlsToView( );
}
public Canvas(CreateParams parentParams, XmlReader reader)
{
Initialize( );
// Always get our style first
mStyle = parentParams.Style;
Styles.Style.ParseStyleAttributesWithDefaults(reader, ref mStyle, ref ControlStyles.mCanvas);
// check for attributes we support
RectangleF bounds = new RectangleF( );
SizeF parentSize = new SizeF(parentParams.Width, parentParams.Height);
ParseCommonAttribs(reader, ref parentSize, ref bounds);
// Get margins and padding
RectangleF padding;
RectangleF margin;
GetMarginsAndPadding(ref mStyle, ref parentSize, ref bounds, out margin, out padding);
// apply margins to as much of the bounds as we can (bottom must be done by our parent container)
ApplyImmediateMargins(ref bounds, ref margin, ref parentSize);
Margin = margin;
// check for border styling
int borderPaddingPx = 0;
if (mStyle.mBorderColor.HasValue)
{
BorderView.BorderColor = mStyle.mBorderColor.Value;
}
if (mStyle.mBorderRadius.HasValue)
{
BorderView.CornerRadius = mStyle.mBorderRadius.Value;
}
if (mStyle.mBorderWidth.HasValue)
{
BorderView.BorderWidth = mStyle.mBorderWidth.Value;
borderPaddingPx = (int)Rock.Mobile.Graphics.Util.UnitToPx(mStyle.mBorderWidth.Value + PrivateNoteConfig.BorderPadding);
}
if (mStyle.mBackgroundColor.HasValue)
{
BorderView.BackgroundColor = mStyle.mBackgroundColor.Value;
}
//
// now calculate the available width based on padding. (Don't actually change our width)
float availableWidth = bounds.Width - padding.Left - padding.Width - (borderPaddingPx * 2);
// now read what our children's alignment should be
// check for alignment
string result = reader.GetAttribute("ChildAlignment");
if (string.IsNullOrEmpty(result) == false)
{
switch (result)
{
case "Left":
ChildHorzAlignment = Alignment.Left;
break;
case "Right":
ChildHorzAlignment = Alignment.Right;
break;
case "Center":
ChildHorzAlignment = Alignment.Center;
break;
default:
ChildHorzAlignment = mStyle.mAlignment.Value;
break;
}
}
else
{
// if it wasn't specified, use OUR alignment.
ChildHorzAlignment = mStyle.mAlignment.Value;
}
// Parse Child Controls
bool finishedParsing = false;
while (finishedParsing == false && reader.Read( ))
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
{
// let each child have our available width.
Style style = new Style( );
style = mStyle;
style.mAlignment = ChildHorzAlignment;
IUIControl control = Parser.TryParseControl(new CreateParams(this, availableWidth, parentParams.Height, ref style), reader);
if (control != null)
{
ChildControls.Add(control);
}
break;
}
case XmlNodeType.EndElement:
{
// if we hit the end of our label, we're done.
//if( reader.Name == "Canvas" || reader.Name == "C" )
if (ElementTagMatches(reader.Name))
{
finishedParsing = true;
}
break;
}
}
}
// layout all controls
float yOffset = bounds.Y + padding.Top + borderPaddingPx; //vertically they should just stack
float height = 0;
// now we must center each control within the stack.
foreach (IUIControl control in ChildControls)
{
RectangleF controlFrame = control.GetFrame( );
RectangleF controlMargin = control.GetMargin( );
// horizontally position the controls according to their
// requested alignment
Alignment controlAlignment = control.GetHorzAlignment( );
// adjust by our position
float xAdjust = 0;
switch (controlAlignment)
{
case Alignment.Center:
xAdjust = bounds.X + ((availableWidth / 2) - (controlFrame.Width / 2));
break;
case Alignment.Right:
xAdjust = bounds.X + (availableWidth - (controlFrame.Width + controlMargin.Width));
break;
case Alignment.Left:
xAdjust = bounds.X;
break;
}
// adjust the next sibling by yOffset
control.AddOffset(xAdjust + padding.Left + borderPaddingPx, yOffset);
// track the height of the grid by the control lowest control
height = (control.GetFrame( ).Bottom + +controlMargin.Height) > height ? (control.GetFrame( ).Bottom + +controlMargin.Height) : height;
}
// we need to store our bounds. We cannot
// calculate them on the fly because we
// would lose any control defined offsets, which would throw everything off.
bounds.Height = height + padding.Height + borderPaddingPx;
// setup our bounding rect for the border
bounds = new RectangleF(bounds.X,
bounds.Y,
bounds.Width,
bounds.Height);
// and store that as our bounds
BorderView.Frame = bounds;
Frame = bounds;
// store our debug frame
SetDebugFrame(Frame);
// sort everything
ChildControls.Sort(BaseControl.Sort);
}
public List(CreateParams parentParams, XmlReader reader)
{
Initialize( );
// Always get our style first
mStyle = parentParams.Style;
Styles.Style.ParseStyleAttributesWithDefaults(reader, ref mStyle, ref ControlStyles.mList);
// check for attributes we support
RectangleF bounds = new RectangleF( );
SizeF parentSize = new SizeF(parentParams.Width, parentParams.Height);
ParseCommonAttribs(reader, ref parentSize, ref bounds);
// Get margins and padding
RectangleF padding;
RectangleF margin;
GetMarginsAndPadding(ref mStyle, ref parentSize, ref bounds, out margin, out padding);
// apply margins to as much of the bounds as we can (bottom must be done by our parent container)
ApplyImmediateMargins(ref bounds, ref margin, ref parentSize);
Margin = margin;
// check for border styling
int borderPaddingPx = 0;
if (mStyle.mBorderColor.HasValue)
{
BorderView.BorderColor = mStyle.mBorderColor.Value;
}
if (mStyle.mBorderRadius.HasValue)
{
BorderView.CornerRadius = mStyle.mBorderRadius.Value;
}
if (mStyle.mBorderWidth.HasValue)
{
BorderView.BorderWidth = mStyle.mBorderWidth.Value;
borderPaddingPx = (int)Rock.Mobile.Graphics.Util.UnitToPx(mStyle.mBorderWidth.Value + PrivateNoteConfig.BorderPadding);
}
if (mStyle.mBackgroundColor.HasValue)
{
BorderView.BackgroundColor = mStyle.mBackgroundColor.Value;
}
//
// convert indentation if it's a percentage
float listIndentation = mStyle.mListIndention.Value;
if (listIndentation < 1)
{
listIndentation = parentParams.Width * listIndentation;
}
// now calculate the available width based on padding. (Don't actually change our width)
// also consider the indention amount of the list.
float availableWidth = bounds.Width - padding.Left - padding.Width - listIndentation - (borderPaddingPx * 2);
// parse for the desired list style. Default to Bullet if they didn't put anything.
ListType = reader.GetAttribute("Type");
if (string.IsNullOrEmpty(ListType) == true)
{
ListType = ListTypeBullet;
}
// Parse Child Controls
int numberedCount = 1;
// don't force our alignment, borders, bullet style or indentation on children.
Style style = new Style( );
style = mStyle;
style.mAlignment = null;
style.mListIndention = null;
style.mListBullet = null;
style.mBorderColor = null;
style.mBorderRadius = null;
style.mBorderWidth = null;
bool finishedParsing = false;
while (finishedParsing == false && reader.Read( ))
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
{
// Create the prefix for this list item.
string listItemPrefixStr = mStyle.mListBullet + " ";
if (ListType == ListTypeNumbered)
{
listItemPrefixStr = numberedCount.ToString() + ". ";
}
NoteText textLabel = Parser.CreateNoteText(new CreateParams(this, availableWidth, parentParams.Height, ref style), listItemPrefixStr);
ChildControls.Add(textLabel);
// create our actual child, but throw an exception if it's anything but a ListItem.
IUIControl control = Parser.TryParseControl(new CreateParams(this, availableWidth - textLabel.GetFrame().Width, parentParams.Height, ref style), reader);
ListItem listItem = control as ListItem;
if (listItem == null)
{
throw new Exception(String.Format("Only a <ListItem> may be a child of a <List>. Found element <{0}>.", control.GetType( )));
}
// if it will actually use the bullet point, increment our count.
if (listItem.ShouldShowBulletPoint() == true)
{
numberedCount++;
}
else
{
// otherwise give it a blank space, and keep our count the same.
textLabel.SetText(" ");
}
// and finally add the actual list item.
ChildControls.Add(control);
break;
}
case XmlNodeType.EndElement:
{
// if we hit the end of our label, we're done.
//if( reader.Name == "List" || reader.Name == "L" )
if (ElementTagMatches(reader.Name))
{
finishedParsing = true;
}
break;
}
}
}
// layout all controls
float xAdjust = bounds.X + listIndentation;
float yOffset = bounds.Y + padding.Top + borderPaddingPx; //vertically they should just stack
// we know each child is a NoteText followed by ListItem. So, lay them out
// as: * - ListItem
// * - ListItem
foreach (IUIControl control in ChildControls)
{
// position the control
control.AddOffset(xAdjust + padding.Left + borderPaddingPx, yOffset);
RectangleF controlFrame = control.GetFrame( );
RectangleF controlMargin = control.GetMargin( );
// is this the item prefix?
if ((control as NoteText) != null)
{
// and update xAdjust so the actual item starts after.
xAdjust += controlFrame.Width;
}
else
{
// reset the values for the next line.
xAdjust = bounds.X + listIndentation;
yOffset = controlFrame.Bottom + controlMargin.Height;
}
}
// we need to store our bounds. We cannot
// calculate them on the fly because we
// would lose any control defined offsets, which would throw everything off.
bounds.Height = (yOffset - bounds.Y) + padding.Height + borderPaddingPx;
Frame = bounds;
BorderView.Frame = bounds;
// store our debug frame
SetDebugFrame(Frame);
// sort everything
ChildControls.Sort(BaseControl.Sort);
}
