示例#1
0
 public string ChildText(int row, int child)
 {
     RowIndex   = row.ToString();
     ChildIndex = child.ToString();
     GridChild.WaitTilIsVisible();
     return(GridChild.Text());
 }
示例#2
0
 public static void DeregisterChild(GridChild child)
 {
     if (allChilds.TryGetValue(child.Order, out var grids))
     {
         grids.Remove(child);
         if (allChilds[child.Order].Count == 0)
         {
             allChilds.Remove(child.Order);
         }
     }
     RefreshChildDictionary();
 }
示例#3
0
 public static void RegisterChild(GridChild child)
 {
     if (allChilds.TryGetValue(child.Order, out var grids))
     {
         grids.Add(child);
     }
     else
     {
         allChilds[child.Order] = new List <GridChild>()
         {
             child
         };
     }
     RefreshChildDictionary();
 }
示例#4
0
        private void InitChildrenData(MeasureSpecification widthMeasureSpec, MeasureSpecification heightMeasureSpec)
        {
            int  childCount = LayoutChildren.Count;
            bool isHorizontal = (GridOrientation == Orientation.Horizontal);
            int  mainPivot = 0, subPivot = 0;

            int[] pivotStack = new int[isHorizontal ? Columns : Rows];

            vLocations     = hLocations = null;
            vEdgeList      = hEdgeList = null;
            gridChildren   = new GridChild[childCount];
            maxColumnConut = Columns;
            maxRowCount    = Rows;

            totalVerticalExpand   = 0;
            totalHorizontalExpand = 0;

            for (int i = 0; i < childCount; i++)
            {
                LayoutItem item = LayoutChildren[i];
                View       view = item?.Owner;
                if (view == null)
                {
                    continue;
                }

                int          column, columnSpan, row, rowSpan;
                StretchFlags verticalStretch, horizontalStretch;

                column            = GetColumn(view);
                columnSpan        = GetColumnSpan(view);
                row               = GetRow(view);
                rowSpan           = GetRowSpan(view);
                verticalStretch   = GetVerticalStretch(view);
                horizontalStretch = GetHorizontalStretch(view);

                if (column + columnSpan > maxColumnConut || row + rowSpan > maxRowCount)
                {
                    if (column + columnSpan > maxColumnConut)
                    {
                        Tizen.Log.Error("NUI", "Column + ColumnSapn exceeds Grid Columns. Column + ColumnSpan (" + column + " + " + columnSpan + ") > Grid Columns(" + maxColumnConut + ")");
                    }
                    else
                    {
                        Tizen.Log.Error("NUI", "Row + RowSapn exceeds Grid Rows. Row + RowSapn (" + row + " + " + rowSpan + ") > Grid Rows(" + maxRowCount + ")");
                    }

                    gridChildren[i] = new GridChild(null, new Node(0, 1, 0, 0), new Node(0, 1, 0, 0));

                    continue;
                }

                if (horizontalStretch.HasFlag(StretchFlags.Expand))
                {
                    totalHorizontalExpand++;
                }

                if (verticalStretch.HasFlag(StretchFlags.Expand))
                {
                    totalVerticalExpand++;
                }

                // assign column/row depending on GridOrientation. The main axis count(Columns on Horizontal, Rows otherwise) won't be exceeded
                // explicit column(row) count which is assigned by Columns(Rows). but, cross axis count(Rows(Columns)) can be increased by sub axis count.
                if (column == CellUndefined || row == CellUndefined)
                {
                    (int point, int span)mainAxis = isHorizontal ? (column, columnSpan) : (row, rowSpan);
                    (int point, int span)subAxis  = isHorizontal ? (row, rowSpan) : (column, columnSpan);

                    if (subAxis.point != CellUndefined)
                    {
                        subPivot = subAxis.point;
                    }
                    if (mainAxis.point != CellUndefined)
                    {
                        mainPivot = mainAxis.point;
                    }

                    if (mainPivot + mainAxis.span > pivotStack.Length)
                    {
                        mainPivot = 0;
                        subPivot++;
                    }

                    for (int n = mainPivot + mainAxis.span - 1; n >= mainPivot; n--)
                    {
                        if (pivotStack[n] > subPivot)
                        {
                            mainPivot = n + 1;
                            n         = mainPivot + mainAxis.span;

                            if (n > pivotStack.Length)
                            {
                                if (mainAxis.point != CellUndefined)
                                {
                                    mainPivot = mainAxis.point;
                                }
                                else
                                {
                                    mainPivot = 0;
                                }

                                n = mainPivot + mainAxis.span;
                                subPivot++;
                            }
                        }
                    }

                    if (isHorizontal)
                    {
                        column = mainPivot;
                        row    = subPivot;
                    }
                    else
                    {
                        column = subPivot;
                        row    = mainPivot;
                    }

                    for (int start = mainPivot, end = mainPivot + mainAxis.span; start < end; start++)
                    {
                        pivotStack[start] = subPivot + subAxis.span;
                    }

                    mainPivot += mainAxis.span;
                }

                if (maxColumnConut < column + columnSpan)
                {
                    maxColumnConut = column + columnSpan;
                }
                if (maxRowCount < row + rowSpan)
                {
                    maxRowCount = row + rowSpan;
                }

                MeasureChildWithMargins(item, widthMeasureSpec, new LayoutLength(0), heightMeasureSpec, new LayoutLength(0));
                gridChildren[i] = new GridChild(item,
                                                new Node(column, columnSpan, item.MeasuredWidth.Size.AsDecimal() + item.Owner.Margin.Start + item.Owner.Margin.End, horizontalStretch),
                                                new Node(row, rowSpan, item.MeasuredHeight.Size.AsDecimal() + item.Owner.Margin.Top + item.Owner.Margin.Bottom, verticalStretch));
            }
        }