C# android.getMeasuredWidth方法代码示例

		/// <summary>
		/// Helper for makeAndAddView to set the position of a view
		/// and fill out its layout paramters.
		/// </summary>
		/// <remarks>
		/// Helper for makeAndAddView to set the position of a view
		/// and fill out its layout paramters.
		/// </remarks>
		/// <param name="child">The view to position</param>
		private void setUpChild(android.view.View child)
		{
			// Respect layout params that are already in the view. Otherwise
			// make some up...
			android.view.ViewGroup.LayoutParams lp = child.getLayoutParams();
			if (lp == null)
			{
				lp = generateDefaultLayoutParams();
			}
			addViewInLayout(child, 0, lp);
			child.setSelected(hasFocus());
			// Get measure specs
			int childHeightSpec = android.view.ViewGroup.getChildMeasureSpec(mHeightMeasureSpec
				, mSpinnerPadding.top + mSpinnerPadding.bottom, lp.height);
			int childWidthSpec = android.view.ViewGroup.getChildMeasureSpec(mWidthMeasureSpec
				, mSpinnerPadding.left + mSpinnerPadding.right, lp.width);
			// Measure child
			child.measure(childWidthSpec, childHeightSpec);
			int childLeft;
			int childRight;
			// Position vertically based on gravity setting
			int childTop = mSpinnerPadding.top + ((getMeasuredHeight() - mSpinnerPadding.bottom
				 - mSpinnerPadding.top - child.getMeasuredHeight()) / 2);
			int childBottom = childTop + child.getMeasuredHeight();
			int width = child.getMeasuredWidth();
			childLeft = 0;
			childRight = childLeft + width;
			child.layout(childLeft, childTop, childRight, childBottom);
		}

		internal override void measureChildBeforeLayout(android.view.View child, int childIndex
			, int widthMeasureSpec, int totalWidth, int heightMeasureSpec, int totalHeight)
		{
			if (mConstrainedColumnWidths != null)
			{
				android.widget.TableRow.LayoutParams lp = (android.widget.TableRow.LayoutParams)child
					.getLayoutParams();
				int measureMode = android.view.View.MeasureSpec.EXACTLY;
				int columnWidth = 0;
				int span = lp.span;
				int[] constrainedColumnWidths = mConstrainedColumnWidths;
				{
					for (int i = 0; i < span; i++)
					{
						columnWidth += constrainedColumnWidths[childIndex + i];
					}
				}
				int gravity = lp.gravity;
				bool isHorizontalGravity = android.view.Gravity.isHorizontal(gravity);
				if (isHorizontalGravity)
				{
					measureMode = android.view.View.MeasureSpec.AT_MOST;
				}
				// no need to care about padding here,
				// ViewGroup.getChildMeasureSpec() would get rid of it anyway
				// because of the EXACTLY measure spec we use
				int childWidthMeasureSpec = android.view.View.MeasureSpec.makeMeasureSpec(System.Math.Max
					(0, columnWidth - lp.leftMargin - lp.rightMargin), measureMode);
				int childHeightMeasureSpec = getChildMeasureSpec(heightMeasureSpec, mPaddingTop +
					 mPaddingBottom + lp.topMargin + lp.bottomMargin + totalHeight, lp.height);
				child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
				if (isHorizontalGravity)
				{
					int childWidth = child.getMeasuredWidth();
					lp.mOffset[android.widget.TableRow.LayoutParams.LOCATION_NEXT] = columnWidth - childWidth;
					int layoutDirection = getResolvedLayoutDirection();
					int absoluteGravity = android.view.Gravity.getAbsoluteGravity(gravity, layoutDirection
						);
					switch (absoluteGravity & android.view.Gravity.HORIZONTAL_GRAVITY_MASK)
					{
						case android.view.Gravity.LEFT:
						{
							// don't offset on X axis
							break;
						}

						case android.view.Gravity.RIGHT:
						{
							lp.mOffset[android.widget.TableRow.LayoutParams.LOCATION] = lp.mOffset[android.widget.TableRow
								.LayoutParams.LOCATION_NEXT];
							break;
						}

						case android.view.Gravity.CENTER_HORIZONTAL:
						{
							lp.mOffset[android.widget.TableRow.LayoutParams.LOCATION] = lp.mOffset[android.widget.TableRow
								.LayoutParams.LOCATION_NEXT] / 2;
							break;
						}
					}
				}
				else
				{
					lp.mOffset[android.widget.TableRow.LayoutParams.LOCATION] = lp.mOffset[android.widget.TableRow
						.LayoutParams.LOCATION_NEXT] = 0;
				}
			}
			else
			{
				// fail silently when column widths are not available
				base.measureChildBeforeLayout(child, childIndex, widthMeasureSpec, totalWidth, heightMeasureSpec
					, totalHeight);
			}
		}

		/// <summary>
		/// Helper for makeAndAddView to set the position of a view and fill out its
		/// layout parameters.
		/// </summary>
		/// <remarks>
		/// Helper for makeAndAddView to set the position of a view and fill out its
		/// layout parameters.
		/// </remarks>
		/// <param name="child">The view to position</param>
		/// <param name="offset">Offset from the selected position</param>
		/// <param name="x">
		/// X-coordinate indicating where this view should be placed. This
		/// will either be the left or right edge of the view, depending on
		/// the fromLeft parameter
		/// </param>
		/// <param name="fromLeft">
		/// Are we positioning views based on the left edge? (i.e.,
		/// building from left to right)?
		/// </param>
		private void setUpChild(android.view.View child, int offset, int x, bool fromLeft
			)
		{
			// Respect layout params that are already in the view. Otherwise
			// make some up...
			android.widget.Gallery.LayoutParams lp = (android.widget.Gallery.LayoutParams)child
				.getLayoutParams();
			if (lp == null)
			{
				lp = (android.widget.Gallery.LayoutParams)generateDefaultLayoutParams();
			}
			addViewInLayout(child, fromLeft != mIsRtl ? -1 : 0, lp);
			child.setSelected(offset == 0);
			// Get measure specs
			int childHeightSpec = android.view.ViewGroup.getChildMeasureSpec(mHeightMeasureSpec
				, mSpinnerPadding.top + mSpinnerPadding.bottom, lp.height);
			int childWidthSpec = android.view.ViewGroup.getChildMeasureSpec(mWidthMeasureSpec
				, mSpinnerPadding.left + mSpinnerPadding.right, lp.width);
			// Measure child
			child.measure(childWidthSpec, childHeightSpec);
			int childLeft;
			int childRight;
			// Position vertically based on gravity setting
			int childTop = calculateTop(child, true);
			int childBottom = childTop + child.getMeasuredHeight();
			int width = child.getMeasuredWidth();
			if (fromLeft)
			{
				childLeft = x;
				childRight = childLeft + width;
			}
			else
			{
				childLeft = x - width;
				childRight = x;
			}
			child.layout(childLeft, childTop, childRight, childBottom);
		}

			internal virtual android.graphics.Bitmap createOutline(android.view.View v, int type
				, int color)
			{
				mHolographicPaint.setColor(color);
				if (type == RES_OUT)
				{
					mBlurPaint.setMaskFilter(mSmallBlurMaskFilter);
				}
				else
				{
					if (type == CLICK_FEEDBACK)
					{
						mBlurPaint.setMaskFilter(mLargeBlurMaskFilter);
					}
				}
				if (v.getMeasuredWidth() == 0 || v.getMeasuredHeight() == 0)
				{
					return null;
				}
				android.graphics.Bitmap bitmap = android.graphics.Bitmap.createBitmap(v.getMeasuredWidth
					(), v.getMeasuredHeight(), android.graphics.Bitmap.Config.ARGB_8888);
				mCanvas.setBitmap(bitmap);
				float rotationX = v.getRotationX();
				float rotation = v.getRotation();
				float translationY = v.getTranslationY();
				float translationX = v.getTranslationX();
				v.setRotationX(0);
				v.setRotation(0);
				v.setTranslationY(0);
				v.setTranslationX(0);
				v.draw(mCanvas);
				v.setRotationX(rotationX);
				v.setRotation(rotation);
				v.setTranslationY(translationY);
				v.setTranslationX(translationX);
				drawOutline(mCanvas, bitmap);
				mCanvas.setBitmap(null);
				return bitmap;
			}

		/// <summary>Measure a child view to fit within cell-based formatting.</summary>
		/// <remarks>
		/// Measure a child view to fit within cell-based formatting. The child's width
		/// will be measured to a whole multiple of cellSize.
		/// <p>Sets the expandable and cellsUsed fields of LayoutParams.
		/// </remarks>
		/// <param name="child">Child to measure</param>
		/// <param name="cellSize">Size of one cell</param>
		/// <param name="cellsRemaining">Number of cells remaining that this view can expand to fill
		/// 	</param>
		/// <param name="parentHeightMeasureSpec">MeasureSpec used by the parent view</param>
		/// <param name="parentHeightPadding">Padding present in the parent view</param>
		/// <returns>Number of cells this child was measured to occupy</returns>
		internal static int measureChildForCells(android.view.View child, int cellSize, int
			 cellsRemaining, int parentHeightMeasureSpec, int parentHeightPadding)
		{
			[email protected] lp = ([email protected]
				.LayoutParams)child.getLayoutParams();
			int childHeightSize = android.view.View.MeasureSpec.getSize(parentHeightMeasureSpec
				) - parentHeightPadding;
			int childHeightMode = android.view.View.MeasureSpec.getMode(parentHeightMeasureSpec
				);
			int childHeightSpec = android.view.View.MeasureSpec.makeMeasureSpec(childHeightSize
				, childHeightMode);
			int cellsUsed = 0;
			if (cellsRemaining > 0)
			{
				int childWidthSpec = android.view.View.MeasureSpec.makeMeasureSpec(cellSize * cellsRemaining
					, android.view.View.MeasureSpec.AT_MOST);
				child.measure(childWidthSpec, childHeightSpec);
				int measuredWidth = child.getMeasuredWidth();
				cellsUsed = measuredWidth / cellSize;
				if (measuredWidth % cellSize != 0)
				{
					cellsUsed++;
				}
			}
			[email protected] itemView = child is [email protected]
				 ? ([email protected])child : null;
			bool expandable = !lp.isOverflowButton && itemView != null && itemView.hasText();
			lp.expandable = expandable;
			lp.cellsUsed = cellsUsed;
			int targetWidth = cellsUsed * cellSize;
			child.measure(android.view.View.MeasureSpec.makeMeasureSpec(targetWidth, android.view.View
				.MeasureSpec.EXACTLY), childHeightSpec);
			return cellsUsed;
		}

		/// <summary>
		/// Add a view as a child and make sure it is measured (if necessary) and
		/// positioned properly.
		/// </summary>
		/// <remarks>
		/// Add a view as a child and make sure it is measured (if necessary) and
		/// positioned properly.
		/// </remarks>
		/// <param name="child">The view to add</param>
		/// <param name="position">The position of the view</param>
		/// <param name="y">The y position relative to which this view will be positioned</param>
		/// <param name="flow">
		/// if true, align top edge to y. If false, align bottom edge
		/// to y.
		/// </param>
		/// <param name="childrenLeft">Left edge where children should be positioned</param>
		/// <param name="selected">Is this position selected?</param>
		/// <param name="recycled">
		/// Has this view been pulled from the recycle bin? If so it
		/// does not need to be remeasured.
		/// </param>
		/// <param name="where">Where to add the item in the list</param>
		private void setupChild(android.view.View child, int position, int y, bool flow, 
			int childrenLeft, bool selected, bool recycled, int where)
		{
			bool isSelected_1 = selected && shouldShowSelector();
			bool updateChildSelected = isSelected_1 != child.isSelected();
			int mode = mTouchMode;
			bool isPressed_1 = mode > TOUCH_MODE_DOWN && mode < TOUCH_MODE_SCROLL && mMotionPosition
				 == position;
			bool updateChildPressed = isPressed_1 != child.isPressed();
			bool needToMeasure = !recycled || updateChildSelected || child.isLayoutRequested(
				);
			// Respect layout params that are already in the view. Otherwise make
			// some up...
			android.widget.AbsListView.LayoutParams p = (android.widget.AbsListView.LayoutParams
				)child.getLayoutParams();
			if (p == null)
			{
				p = new android.widget.AbsListView.LayoutParams(android.view.ViewGroup.LayoutParams
					.MATCH_PARENT, android.view.ViewGroup.LayoutParams.WRAP_CONTENT, 0);
			}
			p.viewType = mAdapter.getItemViewType(position);
			if (recycled && !p.forceAdd)
			{
				attachViewToParent(child, where, p);
			}
			else
			{
				p.forceAdd = false;
				addViewInLayout(child, where, p, true);
			}
			if (updateChildSelected)
			{
				child.setSelected(isSelected_1);
				if (isSelected_1)
				{
					requestFocus();
				}
			}
			if (updateChildPressed)
			{
				child.setPressed(isPressed_1);
			}
			if (mChoiceMode != CHOICE_MODE_NONE && mCheckStates != null)
			{
				if (child is android.widget.Checkable)
				{
					((android.widget.Checkable)child).setChecked(mCheckStates.get(position));
				}
				else
				{
					if (getContext().getApplicationInfo().targetSdkVersion >= android.os.Build.VERSION_CODES
						.HONEYCOMB)
					{
						child.setActivated(mCheckStates.get(position));
					}
				}
			}
			if (needToMeasure)
			{
				int childHeightSpec = android.view.ViewGroup.getChildMeasureSpec(android.view.View
					.MeasureSpec.makeMeasureSpec(0, android.view.View.MeasureSpec.UNSPECIFIED), 0, p
					.height);
				int childWidthSpec = android.view.ViewGroup.getChildMeasureSpec(android.view.View
					.MeasureSpec.makeMeasureSpec(mColumnWidth, android.view.View.MeasureSpec.EXACTLY
					), 0, p.width);
				child.measure(childWidthSpec, childHeightSpec);
			}
			else
			{
				cleanupLayoutState(child);
			}
			int w = child.getMeasuredWidth();
			int h = child.getMeasuredHeight();
			int childLeft;
			int childTop = flow ? y : y - h;
			int layoutDirection = getResolvedLayoutDirection();
			int absoluteGravity = android.view.Gravity.getAbsoluteGravity(mGravity, layoutDirection
				);
//.........这里部分代码省略.........

		protected internal virtual int positionChildInverse(android.view.View child, int 
			x, int y, int contentHeight)
		{
			int childWidth = child.getMeasuredWidth();
			int childHeight = child.getMeasuredHeight();
			int childTop = y + (contentHeight - childHeight) / 2;
			child.layout(x - childWidth, childTop, x, childTop + childHeight);
			return childWidth;
		}

		protected internal virtual int measureChildView(android.view.View child, int availableWidth
			, int childSpecHeight, int spacing)
		{
			child.measure(android.view.View.MeasureSpec.makeMeasureSpec(availableWidth, android.view.View
				.MeasureSpec.AT_MOST), childSpecHeight);
			availableWidth -= child.getMeasuredWidth();
			availableWidth -= spacing;
			return System.Math.Max(0, availableWidth);
		}