protected override int measureRawSize(LayoutingType lt)
{
if (Children.Count > 0)
{
if (lt == LayoutingType.Width)
{
if (largestChild == null)
{
searchLargestChild();
}
if (largestChild == null)
{
//if still null, not possible to determine a width
//because all children are stretched, force first one to fit
Children [0].Width = Measure.Fit;
return(-1); //cancel actual sizing to let child computation take place
}
}
else
{
if (tallestChild == null)
{
searchTallestChild();
}
if (tallestChild == null)
{
Children [0].Height = Measure.Fit;
return(-1);
}
}
}
return(base.measureRawSize(lt));
}
public override void OnLayoutChanges(LayoutingType layoutType)
{
base.OnLayoutChanges(layoutType);
if (layoutType == LayoutingType.Height)
{
using (ImageSurface img = new ImageSurface(Format.Argb32, 10, 10)) {
using (Context gr = new Context(img)) {
//Cairo.FontFace cf = gr.GetContextFontFace ();
gr.SelectFontFace(Font.Name, Font.Slant, Font.Wheight);
gr.SetFontSize(Font.Size);
fe = gr.FontExtents;
}
}
lineHeight = fe.Height;
visibleLines = (int)Math.Floor((double)ClientRectangle.Height / fe.Height);
System.Diagnostics.Debug.WriteLine("Visible lines: {0})", visibleLines);
if (Scroll + visibleLines > Datas?.Count)
{
Scroll = Datas.Count - visibleLines;
}
}
}
void updateMaxScroll(LayoutingType lt)
{
if (Child == null)
{
MaxScrollX = 0;
MaxScrollY = 0;
return;
}
Rectangle cb = ClientRectangle;
if (lt == LayoutingType.Height)
{
MaxScrollY = child.Slot.Height - cb.Height;
if (child.Slot.Height > 0)
{
NotifyValueChanged("ChildHeightRatio", Slot.Height * Slot.Height / child.Slot.Height);
}
}
else if (lt == LayoutingType.Width)
{
MaxScrollX = child.Slot.Width - cb.Width;
if (child.Slot.Width > 0)
{
NotifyValueChanged("ChildWidthRatio", Slot.Width * Slot.Width / child.Slot.Width);
}
}
}
public override void OnLayoutChanges(LayoutingType layoutType)
{
base.OnLayoutChanges (layoutType);
if (layoutType == LayoutingType.Width)
MinimumPopupSize = new Size (this.Slot.Width, minimumPopupSize.Height);
}
protected override int measureRawSize(LayoutingType lt)
{
int totSpace = 0;
for (int i = 0; i < Children.Count; i++)
{
if (Children [i].Visible)
{
totSpace += Spacing;
}
}
if (totSpace > 0)
{
totSpace -= Spacing;
}
if (lt == LayoutingType.Width)
{
if (Orientation == Orientation.Horizontal)
{
return(contentSize.Width + totSpace + 2 * Margin);
}
}
else if (Orientation == Orientation.Vertical)
{
return(contentSize.Height + totSpace + 2 * Margin);
}
return(base.measureRawSize(lt));
}
public override bool UpdateLayout(LayoutingType layoutType)
{
GenericStack gs = Parent as GenericStack;
if (layoutType == LayoutingType.Width)
{
if (gs.Orientation == Orientation.Horizontal)
{
Width = thickness;
}
else
{
Width = Measure.Stretched;
}
}
else if (layoutType == LayoutingType.Height)
{
if (gs.Orientation == Orientation.Vertical)
{
Height = thickness;
}
else
{
Height = Measure.Stretched;
}
}
return(base.UpdateLayout(layoutType));
}
public void EnqueueAfterThisAndParentSizing(LayoutingType _lt, ILayoutable _object)
{
LayoutingQueueItem lqi = new LayoutingQueueItem(_lt, _object);
LayoutingType sizing = LayoutingType.Width;
if (_lt == LayoutingType.Y)
{
sizing = LayoutingType.Height;
}
LinkedListNode <LayoutingQueueItem> parentLqi = searchLqi(_object.Parent, sizing);
LinkedListNode <LayoutingQueueItem> thisLqi = searchLqi(_object, sizing);
if (parentLqi == null)
{
if (thisLqi != null)
{
_object.RegisteredLQINodes.Add(this.AddAfter(thisLqi, lqi));
}
else
{
_object.RegisteredLQINodes.Add(this.AddLast(lqi));
}
}
else
{
if (thisLqi == null)
{
_object.RegisteredLQINodes.Add(this.AddAfter(parentLqi, lqi));
}
else
{
switch (sizing)
{
case LayoutingType.Width:
if (_object.Parent.getBounds().Width < 0)
{
_object.RegisteredLQINodes.Add(this.AddAfter(parentLqi, lqi));
}
else
{
_object.RegisteredLQINodes.Add(this.AddAfter(thisLqi, lqi));
}
break;
case LayoutingType.Height:
if (_object.Parent.getBounds().Height < 0)
{
_object.RegisteredLQINodes.Add(this.AddAfter(parentLqi, lqi));
}
else
{
_object.RegisteredLQINodes.Add(this.AddAfter(thisLqi, lqi));
}
break;
}
}
}
}
public override void ChildrenLayoutingConstraints(ref LayoutingType layoutType)
{
//Prevent child repositionning in the direction of stacking
if (Orientation == Orientation.Horizontal)
layoutType &= (~LayoutingType.X);
else
layoutType &= (~LayoutingType.Y);
}
public override void OnLayoutChanges(LayoutingType layoutType)
{
base.OnLayoutChanges(layoutType);
if ((layoutType | LayoutingType.Sizing) > 0)
{
updateMaxScrolls();
}
}
public override int measureRawSize(LayoutingType lt)
{
if (lt == LayoutingType.Height)
{
return((int)Math.Ceiling((fe.Ascent + fe.Descent) * buffer.LineCount) + Margin * 2);
}
return(0); // (int)(fe.MaxXAdvance * buffer.GetLineLength(buffer.longestLineIdx)) + Margin * 2;
}
public override void OnLayoutChanges(LayoutingType layoutType)
{
base.OnLayoutChanges(layoutType);
if (layoutType == LayoutingType.Width)
{
MinimumPopupSize = new Size(this.Slot.Width, minimumPopupSize.Height);
}
}
protected override int measureRawSize(LayoutingType lt)
{
if (lt == LayoutingType.Height)
{
return((int)Math.Ceiling(fe.Height * buffer.LineCount) + Margin * 2);
}
return((int)(fe.MaxXAdvance * buffer.longestLineCharCount) + Margin * 2 + leftMargin);
}
public override void OnLayoutChanges(LayoutingType layoutType)
{
base.OnLayoutChanges (layoutType);
if (Orientation == Orientation.Horizontal) {
if (layoutType == LayoutingType.Width)
updateMousePosFromHue ();
} else if (layoutType == LayoutingType.Height)
updateMousePosFromHue ();
}
LinkedListNode <LayoutingQueueItem> searchLqi(ILayoutable go, LayoutingType lt)
{
for (int i = 0; i < go.RegisteredLQINodes.Count; i++)
{
if (go.RegisteredLQINodes [i].Value.LayoutType == lt)
{
return(go.RegisteredLQINodes [i]);
}
}
return(null);
}
public override void OnLayoutChanges(LayoutingType layoutType)
{
base.OnLayoutChanges(layoutType);
switch (layoutType)
{
case LayoutingType.Width:
case LayoutingType.Height:
imlVE.ProcessResize(this.ClientRectangle.Size);
break;
}
}
public override void OnLayoutChanges(LayoutingType layoutType)
{
base.OnLayoutChanges(layoutType);
switch (layoutType)
{
case LayoutingType.Width:
case LayoutingType.Height:
imlVE.ProcessResize(new Size(designWidth, designHeight));
break;
}
}
public override void OnLayoutChanges(LayoutingType layoutType)
{
base.OnLayoutChanges (layoutType);
switch (layoutType) {
case LayoutingType.Width:
mousePos.X = (int)Math.Floor(s * (double)ClientRectangle.Width);
break;
case LayoutingType.Height:
mousePos.Y = (int)Math.Floor((1.0-v) * (double)ClientRectangle.Height);
break;
}
}
public override void ChildrenLayoutingConstraints(ref LayoutingType layoutType)
{
//Prevent child repositionning in the direction of stacking
if (Orientation == Orientation.Horizontal)
{
layoutType &= (~LayoutingType.X);
}
else
{
layoutType &= (~LayoutingType.Y);
}
}
public override void OnLayoutChanges(LayoutingType layoutType)
{
base.OnLayoutChanges(layoutType);
if (layoutType == LayoutingType.Height)
{
updateVisibleLines();
}
else if (layoutType == LayoutingType.Width)
{
updateVisibleColumns();
}
}
void adjustStretchedGo(LayoutingType lt)
{
if (stretchedGO == null)
{
return;
}
if (lt == LayoutingType.Width)
{
int newW = Math.Max(
this.ClientRectangle.Width - contentSize.Width - Spacing * (Children.Count - 1),
stretchedGO.MinimumSize.Width);
if (stretchedGO.MaximumSize.Width > 0)
{
newW = Math.Min(newW, stretchedGO.MaximumSize.Width);
}
if (newW != stretchedGO.Slot.Width)
{
stretchedGO.Slot.Width = newW;
stretchedGO.IsDirty = true;
#if DEBUG_LAYOUTING
Debug.WriteLine("\tAdjusting Width of " + stretchedGO.ToString());
#endif
stretchedGO.LayoutChanged -= OnChildLayoutChanges;
stretchedGO.OnLayoutChanges(LayoutingType.Width);
stretchedGO.LayoutChanged += OnChildLayoutChanges;
stretchedGO.LastSlots.Width = stretchedGO.Slot.Width;
}
}
else
{
int newH = Math.Max(
this.ClientRectangle.Height - contentSize.Height - Spacing * (Children.Count - 1),
stretchedGO.MinimumSize.Height);
if (stretchedGO.MaximumSize.Height > 0)
{
newH = Math.Min(newH, stretchedGO.MaximumSize.Height);
}
if (newH != stretchedGO.Slot.Height)
{
stretchedGO.Slot.Height = newH;
stretchedGO.IsDirty = true;
#if DEBUG_LAYOUTING
Debug.WriteLine("\tAdjusting Height of " + stretchedGO.ToString());
#endif
stretchedGO.LayoutChanged -= OnChildLayoutChanges;
stretchedGO.OnLayoutChanges(LayoutingType.Height);
stretchedGO.LayoutChanged += OnChildLayoutChanges;
stretchedGO.LastSlots.Height = stretchedGO.Slot.Height;
}
}
}
public override void OnLayoutChanges(LayoutingType layoutType)
{
base.OnLayoutChanges(layoutType);
if (_content == null)
{
return;
}
if (layoutType == LayoutingType.Width)
{
_content.MinimumSize = new Size(this.Slot.Width, _content.MinimumSize.Height);
}
}
public LayoutingQueueItem(LayoutingType _layoutType, ILayoutable _graphicObject)
{
LayoutType = _layoutType;
Layoutable = _graphicObject;
Layoutable.RegisteredLayoutings |= LayoutType;
LayoutingTries = 0;
DiscardCount = 0;
#if DEBUG_LAYOUTING
LQITime = new Stopwatch();
Slot = Rectangle.Empty;
NewSlot = Rectangle.Empty;
Debug.WriteLine("\tRegister => " + this.ToString());
#endif
}
public void EnqueueBeforeParentSizing(LayoutingType _lt, ILayoutable _object)
{
LayoutingQueueItem lqi = new LayoutingQueueItem(_lt, _object);
LinkedListNode <LayoutingQueueItem> parentLqi = searchLqi(_object.Parent, _lt);
if (parentLqi == null)
{
_object.RegisteredLQINodes.Add(this.AddLast(lqi));
}
else
{
_object.RegisteredLQINodes.Add(this.AddBefore(parentLqi, lqi));
}
}
public override void OnLayoutChanges(LayoutingType layoutType)
{
base.OnLayoutChanges(layoutType);
switch (layoutType)
{
case LayoutingType.Width:
mousePos.X = (int)Math.Floor(s * (double)ClientRectangle.Width);
break;
case LayoutingType.Height:
mousePos.Y = (int)Math.Floor((1.0 - v) * (double)ClientRectangle.Height);
break;
}
}
protected override int measureRawSize(LayoutingType lt)
{
if ((lt == LayoutingType.Width && contentSize.Width == 0) || (lt == LayoutingType.Height && contentSize.Height == 0))
{
using (Surface drawing = new ImageSurface(Format.A1, 1, 1)) {
using (Context ctx = new Context(drawing)) {
executePath(ctx);
Rectangle r = ctx.StrokeExtents();
contentSize = new Size(r.Right, r.Bottom);
}
}
}
return(lt == LayoutingType.Width ?
contentSize.Width + 2 * Margin: contentSize.Height + 2 * Margin);
}
protected override int measureRawSize(LayoutingType lt)
{
if (lines == null)
{
lines = getLines;
}
using (ImageSurface img = new ImageSurface(Format.Argb32, 10, 10)) {
using (Context gr = new Context(img)) {
//Cairo.FontFace cf = gr.GetContextFontFace ();
gr.SelectFontFace(Font.Name, Font.Slant, Font.Wheight);
gr.SetFontSize(Font.Size);
fe = gr.FontExtents;
te = new TextExtents();
if (lt == LayoutingType.Height)
{
int lc = lines.Count;
//ensure minimal height = text line height
if (lc == 0)
{
lc = 1;
}
return((int)Math.Ceiling(fe.Height * lc) + Margin * 2);
}
try {
foreach (string s in lines)
{
string l = s.Replace("\t", new String(' ', Interface.TabSize));
TextExtents tmp = gr.TextExtents(l);
if (tmp.XAdvance > te.XAdvance)
{
te = tmp;
}
}
} catch (Exception ex) {
return(-1);
}
return((int)Math.Ceiling(te.XAdvance) + Margin * 2);
}
}
}
public override void OnLayoutChanges(LayoutingType layoutType)
{
base.OnLayoutChanges(layoutType);
switch (layoutType)
{
case LayoutingType.Width:
DesignWidth = Slot.Width * 100 / zoom;
imlVE.ProcessResize(new Size(designWidth, designHeight));
break;
case LayoutingType.Height:
DesignHeight = Slot.Height * 100 / zoom;
imlVE.ProcessResize(new Size(designWidth, designHeight));
break;
}
}
public override void OnLayoutChanges(LayoutingType layoutType)
{
if (_orientation == Orientation.Horizontal)
{
if (layoutType == LayoutingType.Width)
{
RegisterForLayouting(LayoutingType.ArrangeChildren);
}
}
else if (layoutType == LayoutingType.Height)
{
RegisterForLayouting(LayoutingType.ArrangeChildren);
}
base.OnLayoutChanges(layoutType);
}
public override void OnLayoutChanges(LayoutingType layoutType)
{
base.OnLayoutChanges(layoutType);
if (Orientation == Orientation.Horizontal)
{
if (layoutType == LayoutingType.Width)
{
updateMousePosFromHue();
}
}
else if (layoutType == LayoutingType.Height)
{
updateMousePosFromHue();
}
}
protected override int measureRawSize(LayoutingType lt)
{
if (_pic == null)
{
_pic = "#Crow.Images.Icons.IconAlerte.svg";
}
//TODO:take scalling in account
if (lt == LayoutingType.Width)
{
return(_pic.Dimensions.Width + 2 * Margin);
}
else
{
return(_pic.Dimensions.Height + 2 * Margin);
}
}
public override void OnLayoutChanges(LayoutingType layoutType)
{
base.OnLayoutChanges(layoutType);
if (child == null)
{
return;
}
LayoutingType ltChild = LayoutingType.None;
if (layoutType == LayoutingType.Width)
{
if (child.Width.Units == Unit.Percent)
{
ltChild |= LayoutingType.Width;
if (child.Width.Value < 100 && child.Left == 0)
{
ltChild |= LayoutingType.X;
}
}
else if (child.Left == 0)
{
ltChild |= LayoutingType.X;
}
}
else if (layoutType == LayoutingType.Height)
{
if (child.Height.Units == Unit.Percent)
{
ltChild |= LayoutingType.Height;
if (child.Height.Value < 100 && child.Top == 0)
{
ltChild |= LayoutingType.Y;
}
}
else if (child.Top == 0)
{
ltChild |= LayoutingType.Y;
}
}
if (ltChild == LayoutingType.None)
{
return;
}
child.RegisterForLayouting(ltChild);
}
public override void OnLayoutChanges(LayoutingType layoutType)
{
#if DEBUG_LAYOUTING
LayoutingQueueItem.currentLQI.Slot = LastSlots;
LayoutingQueueItem.currentLQI.Slot = Slot;
#endif
switch (layoutType)
{
case LayoutingType.Width:
foreach (GraphicObject c in Children)
{
if (c.Width.Units == Unit.Percent)
{
c.RegisterForLayouting(LayoutingType.Width);
}
}
if (Height == Measure.Fit)
{
RegisterForLayouting(LayoutingType.Height);
}
RegisterForLayouting(LayoutingType.X);
break;
case LayoutingType.Height:
foreach (GraphicObject c in Children)
{
if (c.Height.Units == Unit.Percent)
{
c.RegisterForLayouting(LayoutingType.Height);
}
}
if (Width == Measure.Fit)
{
RegisterForLayouting(LayoutingType.Width);
}
RegisterForLayouting(LayoutingType.Y);
break;
default:
return;
}
RegisterForLayouting(LayoutingType.ArrangeChildren);
//LayoutChanged.Raise (this, new LayoutingEventArgs (layoutType));
}
public override void OnLayoutChanges(LayoutingType layoutType)
{
base.OnLayoutChanges(layoutType);
if (layoutType == LayoutingType.Height)
{
NotifyValueChanged("PageHeight", Slot.Height);
}
else if (layoutType == LayoutingType.Width)
{
NotifyValueChanged("PageWidth", Slot.Width);
}
else
{
return;
}
updateMaxScroll(layoutType);
}
public LayoutingQueueItem(LayoutingType _layoutType, ILayoutable _graphicObject)
{
LayoutType = _layoutType;
Layoutable = _graphicObject;
Layoutable.RegisteredLayoutings |= LayoutType;
#if DEBUG_LAYOUTING
if (graphicObject.CurrentDrawLQIs == null)
{
graphicObject.CurrentDrawLQIs = new List <LayoutingQueueItem>();
}
graphicObject.CurrentDrawLQIs.Add(this);
if (currentLQI != null)
{
wasTriggeredBy = currentLQI;
currentLQI.triggeredLQIs.Add(this);
}
#endif
}
/// <summary> return size of content + margins </summary>
protected virtual int measureRawSize(LayoutingType lt)
{
return lt == LayoutingType.Width ?
contentSize.Width + 2 * Margin: contentSize.Height + 2 * Margin;
}
/// <summary> Update layout component only one at a time, this is where the computation of alignement
/// and size take place.
/// The redrawing will only be triggered if final slot size has changed </summary>
/// <returns><c>true</c>, if layouting was possible, <c>false</c> if conditions were not
/// met and LQI has to be re-queued</returns>
public virtual bool UpdateLayout(LayoutingType layoutType)
{
//unset bit, it would be reset if LQI is re-queued
registeredLayoutings &= (~layoutType);
switch (layoutType) {
case LayoutingType.X:
if (Left == 0) {
if (Parent.RegisteredLayoutings.HasFlag (LayoutingType.Width) ||
RegisteredLayoutings.HasFlag (LayoutingType.Width))
return false;
switch (HorizontalAlignment) {
case HorizontalAlignment.Left:
Slot.X = 0;
break;
case HorizontalAlignment.Right:
Slot.X = Parent.ClientRectangle.Width - Slot.Width;
break;
case HorizontalAlignment.Center:
Slot.X = Parent.ClientRectangle.Width / 2 - Slot.Width / 2;
break;
}
} else
Slot.X = Left;
if (LastSlots.X == Slot.X)
break;
IsDirty = true;
OnLayoutChanges (layoutType);
LastSlots.X = Slot.X;
break;
case LayoutingType.Y:
if (Top == 0) {
if (Parent.RegisteredLayoutings.HasFlag (LayoutingType.Height) ||
RegisteredLayoutings.HasFlag (LayoutingType.Height))
return false;
switch (VerticalAlignment) {
case VerticalAlignment.Top://this could be processed even if parent Height is not known
Slot.Y = 0;
break;
case VerticalAlignment.Bottom:
Slot.Y = Parent.ClientRectangle.Height - Slot.Height;
break;
case VerticalAlignment.Center:
Slot.Y = Parent.ClientRectangle.Height / 2 - Slot.Height / 2;
break;
}
} else
Slot.Y = Top;
if (LastSlots.Y == Slot.Y)
break;
IsDirty = true;
OnLayoutChanges (layoutType);
LastSlots.Y = Slot.Y;
break;
case LayoutingType.Width:
if (Visible) {
if (Width.IsFixed)
Slot.Width = Width;
else if (Width == Measure.Fit) {
Slot.Width = measureRawSize (LayoutingType.Width);
} else if (Parent.RegisteredLayoutings.HasFlag (LayoutingType.Width))
return false;
else if (Width == Measure.Stretched)
Slot.Width = Parent.ClientRectangle.Width;
else
Slot.Width = (int)Math.Round ((double)(Parent.ClientRectangle.Width * Width) / 100.0);
if (Slot.Width < 0)
return false;
//size constrain
if (Slot.Width < MinimumSize.Width) {
Slot.Width = MinimumSize.Width;
//NotifyValueChanged ("WidthPolicy", Measure.Stretched);
} else if (Slot.Width > MaximumSize.Width && MaximumSize.Width > 0) {
Slot.Width = MaximumSize.Width;
//NotifyValueChanged ("WidthPolicy", Measure.Stretched);
}
} else
Slot.Width = 0;
if (LastSlots.Width == Slot.Width)
break;
IsDirty = true;
OnLayoutChanges (layoutType);
LastSlots.Width = Slot.Width;
break;
case LayoutingType.Height:
if (Visible) {
if (Height.IsFixed)
Slot.Height = Height;
else if (Height == Measure.Fit) {
Slot.Height = measureRawSize (LayoutingType.Height);
} else if (Parent.RegisteredLayoutings.HasFlag (LayoutingType.Height))
return false;
else if (Height == Measure.Stretched)
Slot.Height = Parent.ClientRectangle.Height;
else
Slot.Height = (int)Math.Round ((double)(Parent.ClientRectangle.Height * Height) / 100.0);
if (Slot.Height < 0)
return false;
//size constrain
if (Slot.Height < MinimumSize.Height) {
Slot.Height = MinimumSize.Height;
//NotifyValueChanged ("HeightPolicy", Measure.Stretched);
} else if (Slot.Height > MaximumSize.Height && MaximumSize.Height > 0) {
Slot.Height = MaximumSize.Height;
//NotifyValueChanged ("HeightPolicy", Measure.Stretched);
}
} else
Slot.Height = 0;
if (LastSlots.Height == Slot.Height)
break;
IsDirty = true;
OnLayoutChanges (layoutType);
LastSlots.Height = Slot.Height;
break;
}
//if no layouting remains in queue for item, registre for redraw
if (this.registeredLayoutings == LayoutingType.None && IsDirty)
CurrentInterface.EnqueueForRepaint (this);
return true;
}
public virtual void RegisterForLayouting(LayoutingType layoutType)
{
if (Parent == null)
return;
lock (CurrentInterface.LayoutMutex) {
//prevent queueing same LayoutingType for this
layoutType &= (~RegisteredLayoutings);
if (layoutType == LayoutingType.None)
return;
//dont set position for stretched item
if (Width == Measure.Stretched)
layoutType &= (~LayoutingType.X);
if (Height == Measure.Stretched)
layoutType &= (~LayoutingType.Y);
if (!ArrangeChildren)
layoutType &= (~LayoutingType.ArrangeChildren);
//apply constraints depending on parent type
if (Parent is GraphicObject)
(Parent as GraphicObject).ChildrenLayoutingConstraints (ref layoutType);
// //prevent queueing same LayoutingType for this
// layoutType &= (~RegisteredLayoutings);
if (layoutType == LayoutingType.None)
return;
//enqueue LQI LayoutingTypes separately
if (layoutType.HasFlag (LayoutingType.Width))
CurrentInterface.LayoutingQueue.Enqueue (new LayoutingQueueItem (LayoutingType.Width, this));
if (layoutType.HasFlag (LayoutingType.Height))
CurrentInterface.LayoutingQueue.Enqueue (new LayoutingQueueItem (LayoutingType.Height, this));
if (layoutType.HasFlag (LayoutingType.X))
CurrentInterface.LayoutingQueue.Enqueue (new LayoutingQueueItem (LayoutingType.X, this));
if (layoutType.HasFlag (LayoutingType.Y))
CurrentInterface.LayoutingQueue.Enqueue (new LayoutingQueueItem (LayoutingType.Y, this));
if (layoutType.HasFlag (LayoutingType.ArrangeChildren))
CurrentInterface.LayoutingQueue.Enqueue (new LayoutingQueueItem (LayoutingType.ArrangeChildren, this));
}
}
protected override int measureRawSize(LayoutingType lt)
{
if (lines == null)
lines = getLines;
using (ImageSurface img = new ImageSurface (Format.Argb32, 10, 10)) {
using (Context gr = new Context (img)) {
//Cairo.FontFace cf = gr.GetContextFontFace ();
gr.SelectFontFace (Font.Name, Font.Slant, Font.Wheight);
gr.SetFontSize (Font.Size);
fe = gr.FontExtents;
te = new TextExtents();
if (lt == LayoutingType.Height){
int lc = lines.Count;
//ensure minimal height = text line height
if (lc == 0)
lc = 1;
return (int)Math.Ceiling(fe.Height * lc) + Margin * 2;
}
foreach (string s in lines) {
string l = s.Replace("\t", new String (' ', Interface.TabSize));
TextExtents tmp = gr.TextExtents (l);
if (tmp.XAdvance > te.XAdvance)
te = tmp;
}
return (int)Math.Ceiling (te.XAdvance) + Margin * 2;
}
}
}
protected override int measureRawSize(LayoutingType lt)
{
if (Children.Count > 0) {
if (lt == LayoutingType.Width) {
if (largestChild == null)
searchLargestChild ();
if (largestChild == null) {
//if still null, not possible to determine a width
//because all children are stretched, force first one to fit
Children [0].Width = Measure.Fit;
return -1;//cancel actual sizing to let child computation take place
}
} else {
if (tallestChild == null)
searchTallestChild ();
if (tallestChild == null) {
Children [0].Height = Measure.Fit;
return -1;
}
}
}
return base.measureRawSize (lt);
}
protected override int measureRawSize(LayoutingType lt)
{
if (_pic == null)
_pic = "#Crow.Images.Icons.IconAlerte.svg";
//TODO:take scalling in account
if (lt == LayoutingType.Width)
return _pic.Dimensions.Width + 2 * Margin;
else
return _pic.Dimensions.Height + 2 * Margin;
}
public override bool UpdateLayout(LayoutingType layoutType)
{
RegisteredLayoutings &= (~layoutType);
if (layoutType == LayoutingType.ArrangeChildren) {
//allow 1 child to have size to 0 if stack has fixed or streched size policy,
//this child will occupy remaining space
//if stack size policy is Fit, no child may have stretch enabled
//in the direction of stacking.
ComputeChildrenPositions ();
//if no layouting remains in queue for item, registre for redraw
if (RegisteredLayoutings == LayoutingType.None && IsDirty)
CurrentInterface.EnqueueForRepaint (this);
return true;
}
return base.UpdateLayout(layoutType);
}
protected override int measureRawSize(LayoutingType lt)
{
int tmp = 0;
//Wrapper can't fit in the direction of the wrapper
if (lt == LayoutingType.Width) {
if (Orientation == Orientation.Vertical) {
Width = Measure.Stretched;
return -1;
} else if (RegisteredLayoutings.HasFlag (LayoutingType.Height))
return -1;
else {
int dy = 0;
int largestChild = 0;
lock (Children) {
foreach (GraphicObject c in Children) {
if (!c.Visible)
continue;
if (c.Height.Units == Unit.Percent &&
c.RegisteredLayoutings.HasFlag (LayoutingType.Height))
return -1;
if (dy + c.Slot.Height > ClientRectangle.Height) {
dy = 0;
tmp += largestChild + Spacing;
largestChild = c.Slot.Width;
} else if (largestChild < c.Slot.Width)
largestChild = c.Slot.Width;
dy += c.Slot.Height + Spacing;
}
if (dy == 0)
tmp -= Spacing;
return tmp + largestChild + 2 * Margin;
}
}
} else if (Orientation == Orientation.Horizontal) {
Height = Measure.Stretched;
return -1;
} else if (RegisteredLayoutings.HasFlag (LayoutingType.Width))
return -1;
else {
int dx = 0;
int tallestChild = 0;
lock (Children) {
foreach (GraphicObject c in Children) {
if (!c.Visible)
continue;
if (c.Width.Units == Unit.Percent &&
c.RegisteredLayoutings.HasFlag (LayoutingType.Width))
return -1;
if (dx + c.Slot.Width > ClientRectangle.Width) {
dx = 0;
tmp += tallestChild + Spacing;
tallestChild = c.Slot.Height;
} else if (tallestChild < c.Slot.Height)
tallestChild = c.Slot.Height;
dx += c.Slot.Width + Spacing;
}
if (dx == 0)
tmp -= Spacing;
return tmp + tallestChild + 2 * Margin;
}
}
}
public override bool UpdateLayout(LayoutingType layoutType)
{
RegisteredLayoutings &= (~layoutType);
if (layoutType == LayoutingType.ArrangeChildren) {
if ((RegisteredLayoutings & LayoutingType.Sizing) != 0)
return false;
ComputeChildrenPositions ();
//if no layouting remains in queue for item, registre for redraw
if (RegisteredLayoutings == LayoutingType.None && IsDirty)
CurrentInterface.EnqueueForRepaint (this);
return true;
}
return base.UpdateLayout(layoutType);
}
public override void OnLayoutChanges(LayoutingType layoutType)
{
#if DEBUG_LAYOUTING
CurrentInterface.currentLQI.Slot = LastSlots;
CurrentInterface.currentLQI.Slot = Slot;
#endif
switch (layoutType) {
case LayoutingType.Width:
foreach (GraphicObject c in Children) {
if (c.Width.Units == Unit.Percent)
c.RegisterForLayouting (LayoutingType.Width);
}
if (Height == Measure.Fit)
RegisterForLayouting (LayoutingType.Height);
RegisterForLayouting (LayoutingType.X);
break;
case LayoutingType.Height:
foreach (GraphicObject c in Children) {
if (c.Height.Units == Unit.Percent)
c.RegisterForLayouting (LayoutingType.Height);
}
if (Width == Measure.Fit)
RegisterForLayouting (LayoutingType.Width);
RegisterForLayouting (LayoutingType.Y);
break;
default:
return;
}
RegisterForLayouting (LayoutingType.ArrangeChildren);
//LayoutChanged.Raise (this, new LayoutingEventArgs (layoutType));
}
public bool UpdateLayout (LayoutingType layoutType) { throw new NotImplementedException (); }
protected override int measureRawSize(LayoutingType lt)
{
int tmp = base.measureRawSize (lt);
return tmp < 0 ? tmp : tmp + 2 * BorderWidth;
}
public override void OnLayoutChanges(LayoutingType layoutType)
{
base.OnLayoutChanges (layoutType);
if (child == null)
return;
LayoutingType ltChild = LayoutingType.None;
if (layoutType == LayoutingType.Width) {
if (child.Width.Units == Unit.Percent) {
ltChild |= LayoutingType.Width;
if (child.Width.Value < 100 && child.Left == 0)
ltChild |= LayoutingType.X;
} else if (child.Left == 0)
ltChild |= LayoutingType.X;
} else if (layoutType == LayoutingType.Height) {
if (child.Height.Units == Unit.Percent) {
ltChild |= LayoutingType.Height;
if (child.Height.Value < 100 && child.Top == 0)
ltChild |= LayoutingType.Y;
} else if (child.Top == 0)
ltChild |= LayoutingType.Y;
}
if (ltChild == LayoutingType.None)
return;
child.RegisterForLayouting (ltChild);
}
/// <summary> By default in groups, LayoutingType.ArrangeChildren is reset </summary>
public virtual void ChildrenLayoutingConstraints(ref LayoutingType layoutType)
{
}
/// <summary> trigger dependant sizing component update </summary>
public virtual void OnLayoutChanges(LayoutingType layoutType)
{
#if DEBUG_LAYOUTING
CurrentInterface.currentLQI.Slot = LastSlots;
CurrentInterface.currentLQI.NewSlot = Slot;
#endif
switch (layoutType) {
case LayoutingType.Width:
RegisterForLayouting (LayoutingType.X);
break;
case LayoutingType.Height:
RegisterForLayouting (LayoutingType.Y);
break;
}
LayoutChanged.Raise (this, new LayoutingEventArgs (layoutType));
}
public override void ChildrenLayoutingConstraints(ref LayoutingType layoutType)
{
layoutType &= (~LayoutingType.Positioning);
}
public override void OnLayoutChanges(LayoutingType layoutType)
{
base.OnLayoutChanges (layoutType);
if (_content == null)
return;
if (layoutType == LayoutingType.Width)
_content.MinimumSize = new Size (this.Slot.Width, _content.MinimumSize.Height);
}
public override void OnLayoutChanges(LayoutingType layoutType)
{
base.OnLayoutChanges (layoutType);
//position smaller objects in group when group size is fit
switch (layoutType) {
case LayoutingType.Width:
foreach (GraphicObject c in Children){
if (c.Width.Units == Unit.Percent)
c.RegisterForLayouting (LayoutingType.Width);
else
c.RegisterForLayouting (LayoutingType.X);
}
break;
case LayoutingType.Height:
foreach (GraphicObject c in Children) {
if (c.Height.Units == Unit.Percent)
c.RegisterForLayouting (LayoutingType.Height);
else
c.RegisterForLayouting (LayoutingType.Y);
}
break;
}
}
public LayoutingEventArgs(LayoutingType _layoutType)
: base()
{
LayoutType = _layoutType;
}
protected override int measureRawSize(LayoutingType lt)
{
int totSpace = 0;
for (int i = 0; i < Children.Count; i++) {
if (Children [i].Visible)
totSpace += Spacing;
}
if (totSpace > 0)
totSpace -= Spacing;
if (lt == LayoutingType.Width) {
if (Orientation == Orientation.Horizontal)
return contentSize.Width + totSpace + 2 * Margin;
}else if (Orientation == Orientation.Vertical)
return contentSize.Height + totSpace + 2 * Margin;
return base.measureRawSize (lt);
}
public void EnqueueForLayouting (LayoutingType layoutType)
{
throw new NotImplementedException ();
}
public override bool UpdateLayout(LayoutingType layoutType)
{
if (child != null) {
//force sizing to fit if sizing on children and child has stretched size
switch (layoutType) {
case LayoutingType.Width:
if (Width == Measure.Fit && child.Width.Units == Unit.Percent)
child.Width = Measure.Fit;
break;
case LayoutingType.Height:
if (Height == Measure.Fit && child.Height.Units == Unit.Percent)
child.Height = Measure.Fit;
break;
}
}
return base.UpdateLayout (layoutType);
}
public override bool UpdateLayout(LayoutingType layoutType)
{
RegisteredLayoutings &= (~layoutType);
if (layoutType == LayoutingType.ArrangeChildren) {
int curOffset = Spacing;
for (int i = 0; i < Children.Count; i++) {
if (!Children [i].Visible)
continue;
TabItem ti = Children [i] as TabItem;
ti.TabOffset = curOffset;
if (Orientation == Orientation.Horizontal) {
if (ti.TabTitle.RegisteredLayoutings.HasFlag (LayoutingType.Width))
return false;
curOffset += ti.TabTitle.Slot.Width + Spacing;
} else {
if (ti.TabTitle.RegisteredLayoutings.HasFlag (LayoutingType.Height))
return false;
curOffset += ti.TabTitle.Slot.Height + Spacing;
}
}
//if no layouting remains in queue for item, registre for redraw
if (RegisteredLayoutings == LayoutingType.None && IsDirty)
CurrentInterface.EnqueueForRepaint (this);
return true;
}
return base.UpdateLayout(layoutType);
}
public override bool UpdateLayout(LayoutingType layoutType)
{
GenericStack gs = Parent as GenericStack;
if (layoutType == LayoutingType.Width){
if (gs.Orientation == Orientation.Horizontal)
Width = thickness;
else
Width = Measure.Stretched;
} else if (layoutType == LayoutingType.Height){
if (gs.Orientation == Orientation.Vertical)
Height = thickness;
else
Height = Measure.Stretched;
}
return base.UpdateLayout (layoutType);
}
