ToolBar on MonoDroid

Question

"mono for android"でToolBarを使って開発する方法を示すスクリーンキャストは何ですか？

私は小さなツールバーを開発したいと思いますし、それをコード化する適切な方法を探していますか？

Answer 1

ここにDashboardがあり、あなたや他の誰かがActionBarを必要とする場合は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; 
     } 
    } 
}