//初始化布局参数(lua用)
public void InitLayoutParam(LayoutDirection dir_,
int divNum_,
float itemSizeX_, float itemSizeY_,
float itemGapX_, float itemGapY_,
float originX_, float originY_,
float pivotX_, float pivotY_,
float paddingL_, float paddingT_, float paddingR_, float paddingB_)
{
if (itemSizeX_ <= 0 || itemSizeY_ <= 0)
{
itemSizeX_ = m_layoutParam.itemSize.x;
itemSizeY_ = m_layoutParam.itemSize.y;
}
if (pivotX_ < 0 || pivotY_ < 0)
{
pivotX_ = m_layoutParam.pivot.x;
pivotY_ = m_layoutParam.pivot.y;
}
m_layoutParam.Init(
dir_,
divNum_,
itemSizeX_, itemSizeY_,
itemGapX_, itemGapY_,
originX_, originY_,
pivotX_, pivotY_,
paddingL_, paddingT_, paddingR_, paddingB_);
}
private static IHtmlContent RenderBootstrapFormCheckGroup <TModel, TResult>(this IHtmlHelper <TModel> helper,
Expression <Func <TModel, TResult> > expression,
FormCheckType formCheckType,
IEnumerable <SelectListItem> selectListItems,
LayoutDirection layoutDirection = LayoutDirection.Horizontal,
object?htmlAttributes = null)
{
var result = new HtmlContentBuilder();
foreach (var item in selectListItems)
{
var inputTag = new TagBuilder("input")
{
TagRenderMode = TagRenderMode.SelfClosing
};
inputTag.Attributes.Add("id", "_" + Crypto.RandomString());
inputTag.Attributes.Add("name", helper.NameFor(expression));
inputTag.Attributes.Add("value", item.Value);
inputTag.Attributes.Add("type", formCheckType == FormCheckType.Switch ? "checkbox" : formCheckType.ToLower());
if (item.Selected)
{
inputTag.Attributes.Add("checked", "checked");
}
inputTag.MergeAttributes(htmlAttributes);
var additionalCssClass = (layoutDirection == LayoutDirection.Horizontal ? "form-check-inline custom-control-inline" : "");
var formCheck = BootstrapFormCheck(inputTag, formCheckType, item.Text, additionalCssClass);
result.AppendHtml(formCheck);
}
return(result);
}
public LayoutBox(LayoutDirection direction, float spacing, float padding)
{
PadLeft = PadRight = PadTop = PadBottom = padding;
this.Direction = direction;
this.Spacing = spacing;
this.Align = LayoutAlign.Center;
}
static RectTransform PopulateLayout(RectTransform container, LayoutDirection dir, int count)
{
bool vertical = dir == LayoutDirection.Vertical;
if (vertical)
{
container.gameObject.AddComponent <VerticalLayoutGroup>().SetChildControl();
}
else
{
container.gameObject.AddComponent <HorizontalLayoutGroup>().SetChildControl();
}
List <GameObject> cretedObjects = new List <GameObject>();
for (int i = 0; i < count; i++)
{
RectTransform child = container.AddChild();
Undo.RegisterCreatedObjectUndo(child, "layoutt");
cretedObjects.Add(child.gameObject);
child.anchorMin = new Vector2(0, 0);
child.anchorMax = new Vector2(1, 1);
child.offsetMin = new Vector2(0, 0);
child.offsetMax = new Vector2(0, 0);
Image im = child.gameObject.AddComponent <Image>();
im.color = im.color.Random();
child.name = "Item " + (i + 1);
LayoutElement le = child.gameObject.AddComponent <LayoutElement>();
le.flexibleHeight = (vertical ? 1f / count : 1);
le.flexibleWidth = (vertical ? 1 : 1f / count);
child.localScale = Vector3.one; //why do we need this
}
container.name = (vertical ? "VerticalLayout" : "HorizontalLayout");
return(container);
}
private static double GetSide(Drawing.Rectangle r, LayoutDirection direction)
{
switch (direction)
{
case (LayoutDirection.Up):
{
return(r.Top);
}
case (LayoutDirection.Down):
{
return(r.Bottom);
}
case (LayoutDirection.Left):
{
return(r.Left);
}
case (LayoutDirection.Right):
{
return(r.Right);
}
default:
{
throw new System.ArgumentOutOfRangeException();
}
}
}
protected override void OnLayout(bool changed, int left, int top, int right, int bottom)
{
base.OnLayout(changed, left, top, right, bottom);
if (Element is Xamarin.Forms.ScrollView scrollView && (scrollView.Orientation == ScrollOrientation.Horizontal || scrollView.Orientation == ScrollOrientation.Both))
{
var horizontal = (HorizontalScrollView)GetChildAt(0);
var container = (ViewGroup)horizontal.GetChildAt(0);
if (LayoutDirection == LayoutDirection.Rtl)
{
if (container.ChildCount == 1)
{
var content = (ViewGroup)container.GetChildAt(0);
var desiredWidth = content.Width;
container.Layout(0, 0, content.Width, content.Height);
content.Layout(0, 0, desiredWidth, content.Height);
}
}
if (LayoutDirection != currentDirection)
{
currentDirection = LayoutDirection;
horizontal.ScrollX = LayoutDirection == LayoutDirection.Ltr
? 0
: container.Right;
}
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="element">The element that caused the layout operation.</param>
/// <param name="other">The list of other elements that were affected by the operation.</param>
/// <param name="direction">The direction that the layout should be performed in.</param>
/// <param name="value">The value that the elements will be affected by in the layout direction.</param>
internal LayoutOperation(VisualElement element, IEnumerable<VisualElement> other, LayoutDirection direction, double value)
{
RootElement = element;
Elements = new [] { element }.Union(other).ToList();
Direction = direction;
Value = value;
}
public static LayoutDirection GetOpposite(LayoutDirection direction)
{
switch (direction)
{
case (LayoutDirection.Up):
{
return(LayoutDirection.Down);
}
case (LayoutDirection.Down):
{
return(LayoutDirection.Up);
}
case (LayoutDirection.Left):
{
return(LayoutDirection.Right);
}
case (LayoutDirection.Right):
{
return(LayoutDirection.Left);
}
default:
{
throw new System.ArgumentOutOfRangeException();
}
}
}
private InternalTree.LayoutDirection map_direction2(LayoutDirection input_dir)
{
InternalTree.LayoutDirection dir;
if (input_dir == LayoutDirection.Down)
{
dir = InternalTree.LayoutDirection.Down;
}
else if (input_dir == LayoutDirection.Up)
{
dir = InternalTree.LayoutDirection.Up;
}
else if (input_dir == LayoutDirection.Left)
{
dir = InternalTree.LayoutDirection.Left;
}
else if (input_dir == LayoutDirection.Right)
{
dir = InternalTree.LayoutDirection.Right;
}
else
{
dir = InternalTree.LayoutDirection.Down;
}
return(dir);
}
protected void Page_Load(object sender, EventArgs e)
{
if (this.Layout == LayoutDirection.Unknown)
{
this.Layout = LayoutDirection.Vertical;
}
}
private static double _get_side(VisioAutomation.Geometry.Rectangle r, LayoutDirection direction)
{
switch (direction)
{
case (LayoutDirection.Up):
{
return(r.Top);
}
case (LayoutDirection.Down):
{
return(r.Bottom);
}
case (LayoutDirection.Left):
{
return(r.Left);
}
case (LayoutDirection.Right):
{
return(r.Right);
}
default:
{
throw new System.ArgumentOutOfRangeException();
}
}
}
public AGSStackLayoutComponent()
{
_isPaused = true;
OnLayoutChanged = new AGSEvent();
EntitiesToIgnore = new AGSConcurrentHashSet <string>();
_direction = LayoutDirection.Vertical;
_relativeSpacing = -1f; //a simple vertical layout top to bottom by default.
}
public static TreeGraphNode Create(LayoutDirection direction, ObjectGraphNode objectNode)
{
switch (direction) {
case LayoutDirection.TopBottom: return new TreeNodeTB(objectNode);
case LayoutDirection.LeftRight: return new TreeNodeLR(objectNode);
default: throw new DebuggerVisualizerException("Unsupported layout direction: " + direction.ToString());
}
}
void OnActionSheetRequested(Page sender, ActionSheetArguments arguments)
{
// Verify that the page making the request is part of this activity
if (!PageIsInThisContext(sender))
{
return;
}
var builder = new DialogBuilder(Activity);
builder.SetTitle(arguments.Title);
string[] items = arguments.Buttons.ToArray();
builder.SetItems(items, (o, args) => arguments.Result.TrySetResult(items[args.Which]));
if (arguments.Cancel != null)
{
builder.SetPositiveButton(arguments.Cancel, (o, args) => arguments.Result.TrySetResult(arguments.Cancel));
}
if (arguments.Destruction != null)
{
builder.SetNegativeButton(arguments.Destruction, (o, args) => arguments.Result.TrySetResult(arguments.Destruction));
}
var dialog = builder.Create();
builder.Dispose();
//to match current functionality of renderer we set cancelable on outside
//and return null
if (arguments.FlowDirection == FlowDirection.MatchParent && sender is IVisualElementController ve)
{
dialog.Window.DecorView.UpdateFlowDirection(ve);
}
else if (arguments.FlowDirection == FlowDirection.LeftToRight)
{
dialog.Window.DecorView.LayoutDirection = LayoutDirection.Ltr;
}
else if (arguments.FlowDirection == FlowDirection.RightToLeft)
{
dialog.Window.DecorView.LayoutDirection = LayoutDirection.Rtl;
}
dialog.SetCanceledOnTouchOutside(true);
dialog.SetCancelEvent((o, e) => arguments.SetResult(null));
dialog.Show();
dialog.GetListView().TextDirection = GetTextDirection(sender, arguments.FlowDirection);
LayoutDirection layoutDirection = GetLayoutDirection(sender, arguments.FlowDirection);
if (arguments.Cancel != null)
{
((dialog.GetButton((int)DialogButtonType.Positive).Parent) as global::Android.Views.View).LayoutDirection = layoutDirection;
}
if (arguments.Destruction != null)
{
((dialog.GetButton((int)DialogButtonType.Negative).Parent) as global::Android.Views.View).LayoutDirection = layoutDirection;
}
}
public Layout(Vector2 size, bool autoLayout, LayoutDirection autoLayoutDirection, LayoutStart autoLayoutStart, int spacing, string backgroundSprite = "")
{
Size = size;
AutoLayout = autoLayout;
AutoLayoutDirection = autoLayoutDirection;
AutoLayoutStart = autoLayoutStart;
Spacing = spacing;
BackgroundSprite = backgroundSprite;
}
IndexRange m_curContentRange = IndexRange.NullRange; //现有缓存条目的显示范围
//methods
/// <summary>
/// 设置布局，缓冲数量等
/// 注意：在ResetScroll前调用
/// </summary>
/// <param name="dir"></param>
/// <param name="cachenum"></param>
/// <param name="layout"></param>
public void SetConfig(LayoutDirection dir = LayoutDirection.Vertical, int cachenum = 0, Layout layout = new Layout())
{
if (m_isValid)
{
return;
}
m_layoutDirection = dir;
m_layout = layout;
m_cacheNum = cachenum;
}
public void StartLayout(RectangleF bounds, LayoutDirection layoutDirection, LayoutDirection flowDirection)
{
_maxSize = 0;
_views = new List <IViewLayoutBox>();
_viewBounds = bounds;
_layoutToView = LayoutTransform(_viewBounds, layoutDirection, flowDirection);
_viewToLayout = _layoutToView.Inverted();
_layoutBounds = _viewToLayout.Transform(bounds);
_layoutOrigin = _layoutBounds.Location;
}
public SimpleBuilder Group(int margin = 0, Vector2?minSize = null, Alignment align = Alignment.None)
{
AssertState();
LayoutDirection dir = Layout.Direction == LayoutDirection.Vertical ? LayoutDirection.Horizontal : LayoutDirection.Vertical;
LayoutNode child = new(dir, null, margin, minSize, alignment : align);
Nodes.Add(child);
return(new SimpleBuilder(this, child));
}
public void AddLogEntry(LayoutDirection direction, int frameId, LayoutReason reason, string description = null)
{
log.Add(new LayoutHistoryEntry()
{
direction = direction,
frameId = frameId,
reason = reason,
description = description
});
}
public LayoutHelper(LayoutDirection direction)
{
_direction = direction;
if (_direction == LayoutDirection.Vertical)
GUILayout.BeginVertical();
else
{
GUILayout.BeginHorizontal();
}
}
private int _inUpdate; //For preventing re-entrancy
public AGSStackLayoutComponent(IGameEvents gameEvents)
{
_gameEvents = gameEvents;
_isPaused = true;
_isDirty = true;
OnLayoutChanged = new AGSEvent();
EntitiesToIgnore = new AGSConcurrentHashSet <string>();
_direction = LayoutDirection.Vertical;
_relativeSpacing = -1f; //a simple vertical layout top to bottom by default.
gameEvents.OnRepeatedlyExecute.Subscribe(onRepeatedlyExecute);
}
public static TreeGraphNode Create(LayoutDirection direction, ObjectGraphNode objectNode)
{
switch (direction)
{
case LayoutDirection.TopBottom: return(new TreeNodeTB(objectNode));
case LayoutDirection.LeftRight: return(new TreeNodeLR(objectNode));
default: throw new DebuggerVisualizerException("Unsupported layout direction: " + direction.ToString());
}
}
/// <summary>
/// Determine if the size of the command is fixed in provided direction.
/// </summary>
/// <param name="dir">Direction to be tested.</param>
/// <returns>true if fixed in requested direction; otherwise false</returns>
public bool FixedByDirection(LayoutDirection dir)
{
if (dir == LayoutDirection.Vertical)
{
return(_fixedVert);
}
else
{
return(_fixedHorz);
}
}
/// <summary>
/// Gets a value indicating if command is visible in given direction.
/// </summary>
/// <param name="direction"></param>
/// <returns></returns>
public bool IsDirectionVisible(LayoutDirection direction)
{
// Must be visible and allowed to show in given direction
if (direction == LayoutDirection.Horizontal)
{
return(Visible && ShowHorz);
}
else
{
return(Visible && ShowVert);
}
}
public bool RanLayoutInFrame(LayoutDirection direction, int frameId)
{
for (int i = 0; i < log.size; i++)
{
if (log.array[i].frameId == frameId && log.array[i].direction == direction)
{
return(true);
}
}
return(false);
}
public static void SetAutoLayout(
this UIPanel c,
LayoutDirection direction,
RectOffset padding = null,
LayoutStart start = LayoutStart.TopLeft
)
{
c.autoLayout = true;
c.autoLayoutDirection = direction;
c.autoLayoutStart = start;
c.autoLayoutPadding = padding ?? Helper.ZeroOffset;
}
/*
* Calculates transform matrix from layout coordinate system to view coordinate system.
*/
private static Matrix2d LayoutTransform(RectangleF bounds, LayoutDirection layoutDirection, LayoutDirection flowDirection)
{
switch (layoutDirection)
{
case LayoutDirection.LeftRight:
switch (flowDirection)
{
case LayoutDirection.TopBottom:
return(new Matrix2d());
case LayoutDirection.BottomTop:
return(Matrix2d.Translation(0, bounds.Height) * Matrix2d.Stretch(1, -1));
}
break;
case LayoutDirection.RightLeft:
switch (flowDirection)
{
case LayoutDirection.TopBottom:
return(Matrix2d.Translation(bounds.Width, 0) * Matrix2d.Stretch(-1, 1));
case LayoutDirection.BottomTop:
return(Matrix2d.Translation(bounds.Width, bounds.Height) * Matrix2d.Stretch(-1, -1));
}
break;
case LayoutDirection.TopBottom:
switch (flowDirection)
{
case LayoutDirection.LeftRight:
return(Matrix2d.Rotation(90) * Matrix2d.Stretch(1, -1));
case LayoutDirection.RightLeft:
return(Matrix2d.Translation(bounds.Width, 0) * Matrix2d.Rotation(90));
}
break;
case LayoutDirection.BottomTop:
switch (flowDirection)
{
case LayoutDirection.LeftRight:
return(Matrix2d.Translation(0, bounds.Height) * Matrix2d.Rotation(-90));
case LayoutDirection.RightLeft:
return(Matrix2d.Translation(bounds.Width, bounds.Height) * Matrix2d.Stretch(-1, 1) * Matrix2d.Rotation(-90));
}
break;
}
var message = $"Layout direction {layoutDirection} is not compatible with flow direction {flowDirection}";
throw new ArgumentException(message);
}
internal ChartViewManager(StripChartX parentChart, Chart plotChart, PlotManager plotManager)
{
this._parentChart = parentChart;
this._plotChart = plotChart;
this._plotManager = plotManager;
this.MainPlotArea = new StripChartXPlotArea(parentChart, plotChart.ChartAreas[0]);
this.MainPlotArea.ChartArea.Position.Auto = true;
this._layoutDirection = LayoutDirection.LeftToRight;
this._oneWayChartNum = 3;
this.UseMainAreaConfig = true;
this.SplitPlotAreas = new StripChartXPlotAreaCollection(parentChart, plotChart.ChartAreas);
AdaptView();
}
public LayoutGroupSpec(
LayoutDirection layoutDirection,
Padding padding = new Padding(),
float spacing = 0f,
TextAnchor childAlignment = TextAnchor.UpperLeft,
ChildBehavior childBehavior = new ChildBehavior())
{
LayoutDirection = layoutDirection;
Padding = padding;
Spacing = spacing;
ChildAlignment = childAlignment;
ChildBehavior = childBehavior;
}
static RectTransform CreateHoritontalOrVertical(LayoutDirection dir, int count)
{
RectTransform target = null;
if (Selection.activeGameObject != null && Selection.activeGameObject.GetComponent <RectTransform>() != null)
{
target = Selection.activeGameObject.GetComponent <RectTransform>();
Undo.RecordObject(target, "adding layout 1");
Undo.RecordObject(Selection.activeGameObject, "Adding layout");
return(PopulateLayout(target.AddImageChild().GetComponent <RectTransform>(), dir, count));
}
else
{
Debug.LogError("Works on selected rect, please create or select a Panel ");
return(null);
}
var canvas = CreateCanvasIfNotPresent();
RectTransform container = canvas.GetComponent <RectTransform>();
{
Debug.Log("rect selection");
container = Selection.activeGameObject.GetComponent <RectTransform>();
var newObj = new GameObject("Layout", typeof(RectTransform), typeof(Image));
Undo.RegisterCreatedObjectUndo(newObj, "Layout");
newObj.transform.SetParent(container);
container = newObj.GetComponent <RectTransform>();
Selection.activeObject = container;
// container=container.gameObject.AddChildRectTransform();
}
if (container == null)
{
Debug.Log("no container");
var newCont = new GameObject("RectContainer", typeof(RectTransform), typeof(Image));
Undo.RegisterCreatedObjectUndo(newCont, "Layout");
container = newCont.GetComponent <RectTransform>();
}
Image a = container.GetComponent <Image>();
if (a != null)
{
a.enabled = false;
}
}
public static IScrollViewLayout GridLayout(int gridSize = 0, LayoutDirection direction = LayoutDirection.Vertical,
float margin = 5, float subMargin = 5, float topShift = 0, float bottomShift = 0, Vector2 forceSize = default)
{
return(new GridLayout(new GridLayoutSettings
{
direction = direction,
forceSize = forceSize,
marginVec = new Vector2(direction == LayoutDirection.Horizontal ? margin : subMargin, direction == LayoutDirection.Horizontal ? subMargin : margin),
subMargin = subMargin,
gridSize = gridSize,
topShift = topShift,
bottomShift = bottomShift,
}));
}
public static IHtmlContent RadioButtonListFor <TModel, TResult>(this IHtmlHelper <TModel> helper,
Expression <Func <TModel, TResult> > expression,
Type enumType,
LayoutDirection layoutDirection = LayoutDirection.Horizontal,
object?htmlAttributes = null)
{
if (enumType == null)
{
throw new ArgumentNullException(nameof(enumType));
}
var selectListItems = EnumHelper.ToSelectListItems(enumType);
return(helper.RadioButtonListFor(expression, selectListItems, layoutDirection, htmlAttributes));
}
/// <summary>
/// Calculates layout for given <see cref="ObjectGraph" />.
/// </summary>
/// <param name="objectGraph"></param>
/// <returns></returns>
public PositionedGraph CalculateLayout(ObjectGraph objectGraph, LayoutDirection direction, Expanded expanded)
{
layoutDirection = direction;
treeNodeFor = new Dictionary<ObjectGraphNode, PositionedGraphNode>();
seenNodes = new HashSet<PositionedGraphNode>();
//TreeGraphNode tree = buildTreeRecursive(objectGraph.Root, expandedNodes);
// convert ObjectGraph to PositionedGraph with TreeEdges
var resultGraph = buildTreeGraph(objectGraph, expanded);
// first layout pass
calculateSubtreeSizes((TreeGraphNode)resultGraph.Root);
// second layout pass
calculateNodePosRecursive((TreeGraphNode)resultGraph.Root, 0, 0);
//var neatoRouter = new NeatoEdgeRouter();
//resultGraph = neatoRouter.CalculateEdges(resultGraph);
resultGraph = new GraphEdgeRouter().RouteEdges(resultGraph);
return resultGraph;
}
/// <summary>
/// Initializes a new instance of a class
/// </summary>
public SliderControl()
{
Direction = LayoutDirection.Horizontal;
}
public TreeLayout(LayoutDirection layoutDirection)
{
this.LayoutDirection = layoutDirection;
}
/// <summary>
/// Initializes a new instance of a class
/// </summary>
public LayoutControl()
{
Direction = LayoutDirection.Vertical;
}
/// <summary>
/// Apply the layout operation to the given element.
/// </summary>
/// <param name="element">The element to apply the translation to.</param>
/// <param name="length">The speed of the animation.</param>
/// <param name="direction">The direction in which to perform the operation.</param>
/// <param name="value">The amount to which to apply the translation.</param>
/// <returns>A task which asynchronously performs the operation.</returns>
static Task TranslateAsync(VisualElement element, uint length, LayoutDirection direction, double value)
{
if (Math.Abs(value) < Double.Epsilon)
{
return Task.FromResult(0);
}
var operation = LayoutOperation.Push(new LayoutOperation(element, CalculateAffectedElements(element), direction, value));
return LayoutOperation.TranslateAsync(operation.Elements, length);
}
public LayoutOptions()
{
this.ResizeBorderWidth = new VA.Drawing.Size(0.5, 0.5);
this.DefaultShapeSize = new VA.Drawing.Size(1.0, 0.75);
this.LayoutDirection = LayoutDirection.TopToBottom;
}
public MDBox (LayoutDirection direction, float spacing, float padding) : this (null, direction, spacing, padding)
{
}
public MDBox (NSView unownedView, LayoutDirection direction, float spacing, float padding) : base (direction, spacing, padding)
{
View = unownedView ?? new NSView ();
ownsView = unownedView == null;
}
// /////////////////////////////////////////////////////////////////////////////////
// /////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Layout helper - Aligns this control to the specified direction of the spcecified
/// control template. This provides a means to specify control positions relative to
/// previously created templates.
/// </summary>
/// <param name="toDirection"></param>
/// <param name="ofControl"></param>
/// <param name="padding"></param>
public void AlignTo(LayoutDirection toDirection, ControlTemplate ofControl,int padding = 0)
{
switch (toDirection)
{
case LayoutDirection.North:
AlignNorth(ofControl.CalculateRect(), padding);
break;
case LayoutDirection.NorthEast:
AlignNorthEast(ofControl.CalculateRect(), padding);
break;
case LayoutDirection.East:
AlignEast(ofControl.CalculateRect(), padding);
break;
case LayoutDirection.SouthEast:
AlignSouthEast(ofControl.CalculateRect(), padding);
break;
case LayoutDirection.South:
AlignSouth(ofControl.CalculateRect(), padding);
break;
case LayoutDirection.SouthWest:
AlignSouthWest(ofControl.CalculateRect(), padding);
break;
case LayoutDirection.West:
AlignWest(ofControl.CalculateRect(), padding);
break;
case LayoutDirection.NorthWest:
AlignNorthWest(ofControl.CalculateRect(), padding);
break;
}
}
private InternalTree.LayoutDirection map_direction2(LayoutDirection input_dir)
{
InternalTree.LayoutDirection dir;
if (input_dir == LayoutDirection.Down)
{
dir = InternalTree.LayoutDirection.Down;
}
else if (input_dir == LayoutDirection.Up)
{
dir = InternalTree.LayoutDirection.Up;
}
else if (input_dir == LayoutDirection.Left)
{
dir = InternalTree.LayoutDirection.Left;
}
else if (input_dir == LayoutDirection.Right)
{
dir = InternalTree.LayoutDirection.Right;
}
else
{
dir = InternalTree.LayoutDirection.Down;
}
return dir;
}
