Question

Do you know any examples, screencasts that document how to develop with ToolBar on “mono for android” ?

I would like to develop a tiny toolbar and I’m searching for the proper way to code it?

Answer 1

Here is Dashboard, and if you or somebody else will need ActionBar here is a link!

public class DashboardLayout : ViewGroup
{
    private const int UNEVEN_GRID_PENALTY_MULTIPLIER = 10;
    private int _mMaxChildWidth;
    private int _mMaxChildHeight;

    public DashboardLayout(IntPtr doNotUse, JniHandleOwnership transfer) : base(doNotUse, transfer)
    {
    }

    public DashboardLayout(Context context)
        : base(context)
    {
    }

    public DashboardLayout(Context context, IAttributeSet attrs)
        : base(context, attrs)
    {
    }

    public DashboardLayout(Context context, IAttributeSet attrs, int defStyle)
        : base(context, attrs, defStyle)
    {
    }

    protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
    {
        _mMaxChildWidth = 0;
        _mMaxChildHeight = 0;

        // Measure once to find the maximum child size.

        var childWidthMeasureSpec = MeasureSpec.MakeMeasureSpec(
                MeasureSpec.GetSize(widthMeasureSpec), MeasureSpecMode.AtMost);
        var childHeightMeasureSpec = MeasureSpec.MakeMeasureSpec(
                MeasureSpec.GetSize(widthMeasureSpec), MeasureSpecMode.AtMost);

        var count = ChildCount;
        for (var i = 0; i < count; i++)
        {
            var child = GetChildAt(i);
            if (child.Visibility == ViewStates.Gone)
            {
                continue;
            }

            child.Measure(childWidthMeasureSpec, childHeightMeasureSpec);

            _mMaxChildWidth = Math.Max(_mMaxChildWidth, child.MeasuredWidth);
            _mMaxChildHeight = Math.Max(_mMaxChildHeight, child.MeasuredHeight);
        }

        // Measure again for each child to be exactly the same size.

        childWidthMeasureSpec = MeasureSpec.MakeMeasureSpec(
                _mMaxChildWidth, MeasureSpecMode.Exactly);
        childHeightMeasureSpec = MeasureSpec.MakeMeasureSpec(
                _mMaxChildHeight, MeasureSpecMode.Exactly);

        for (int i = 0; i < count; i++)
        {
            var child = GetChildAt(i);
            if (child.Visibility == ViewStates.Gone)
            {
                continue;
            }

            child.Measure(childWidthMeasureSpec, childHeightMeasureSpec);
        }

        SetMeasuredDimension(
                ResolveSize(_mMaxChildWidth, widthMeasureSpec),
                ResolveSize(_mMaxChildHeight, heightMeasureSpec));
    }

    protected override void OnLayout(bool changed, int l, int t, int r, int b)
    {
        var width = r - l;
        var height = b - t;

        var count = ChildCount;

        // Calculate the number of visible children.
        var visibleCount = 0;
        for (var i = 0; i < count; i++)
        {
            var child = GetChildAt(i);
            if (child.Visibility == ViewStates.Gone)
            {
                continue;
            }
            ++visibleCount;
        }

        if (visibleCount == 0)
        {
            return;
        }

        // Calculate what number of rows and columns will optimize for even horizontal and
        // vertical whitespace between items. Start with a 1 x N grid, then try 2 x N, and so on.
        var bestSpaceDifference = int.MaxValue;

        // Horizontal and vertical space between items
        int hSpace;
        int vSpace;

        var cols = 1;
        int rows;

        while (true)
        {
            rows = (visibleCount - 1) / cols + 1;

            hSpace = ((width - _mMaxChildWidth * cols) / (cols + 1));
            vSpace = ((height - _mMaxChildHeight * rows) / (rows + 1));

            var spaceDifference = Math.Abs(vSpace - hSpace);
            if (rows * cols != visibleCount)
            {
                spaceDifference *= UNEVEN_GRID_PENALTY_MULTIPLIER;
            }

            if (spaceDifference < bestSpaceDifference)
            {
                // Found a better whitespace squareness/ratio
                bestSpaceDifference = spaceDifference;

                // If we found a better whitespace squareness and there's only 1 row, this is
                // the best we can do.
                if (rows == 1)
                {
                    break;
                }
            }
            else
            {
                // This is a worse whitespace ratio, use the previous value of cols and exit.
                --cols;
                rows = (visibleCount - 1) / cols + 1;
                hSpace = ((width - _mMaxChildWidth * cols) / (cols + 1));
                vSpace = ((height - _mMaxChildHeight * rows) / (rows + 1));
                break;
            }

            ++cols;
        }

        // Lay out children based on calculated best-fit number of rows and cols.

        // If we chose a layout that has negative horizontal or vertical space, force it to zero.
        hSpace = Math.Max(0, hSpace);
        vSpace = Math.Max(0, vSpace);

        // Re-use width/height variables to be child width/height.
        width = (width - hSpace * (cols + 1)) / cols;
        height = (height - vSpace * (rows + 1)) / rows;

        var visibleIndex = 0;
        for (var i = 0; i < count; i++)
        {
            var child = GetChildAt(i);
            if (child.Visibility == ViewStates.Gone)
            {
                continue;
            }

            var row = visibleIndex / cols;
            var col = visibleIndex % cols;

            var left = hSpace * (col + 1) + width * col;
            var top = vSpace * (row + 1) + height * row;

            child.Layout(left, top,
                    (hSpace == 0 && col == cols - 1) ? r : (left + width),
                    (vSpace == 0 && row == rows - 1) ? b : (top + height));
            ++visibleIndex;
        }
    }
}