Пример #1
0
		/// <summary>
		/// Ask one of the children of this view to measure itself, taking into
		/// account both the MeasureSpec requirements for this view and its padding
		/// and margins.
		/// </summary>
		/// <remarks>
		/// Ask one of the children of this view to measure itself, taking into
		/// account both the MeasureSpec requirements for this view and its padding
		/// and margins. The child must have MarginLayoutParams The heavy lifting is
		/// done in getChildMeasureSpec.
		/// </remarks>
		/// <param name="child">The child to measure</param>
		/// <param name="parentWidthMeasureSpec">The width requirements for this view</param>
		/// <param name="widthUsed">
		/// Extra space that has been used up by the parent
		/// horizontally (possibly by other children of the parent)
		/// </param>
		/// <param name="parentHeightMeasureSpec">The height requirements for this view</param>
		/// <param name="heightUsed">
		/// Extra space that has been used up by the parent
		/// vertically (possibly by other children of the parent)
		/// </param>
		protected internal virtual void measureChildWithMargins(android.view.View child, 
			int parentWidthMeasureSpec, int widthUsed, int parentHeightMeasureSpec, int heightUsed
			)
		{
			android.view.ViewGroup.MarginLayoutParams lp = (android.view.ViewGroup.MarginLayoutParams
				)child.getLayoutParams();
			int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec, mPaddingLeft
				 + mPaddingRight + lp.leftMargin + lp.rightMargin + widthUsed, lp.width);
			int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec, mPaddingTop
				 + mPaddingBottom + lp.topMargin + lp.bottomMargin + heightUsed, lp.height);
			child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
		}
Пример #2
0
		/// <summary>Adds a child view.</summary>
		/// <remarks>
		/// Adds a child view. If no layout parameters are already set on the child, the
		/// default parameters for this ViewGroup are set on the child.
		/// </remarks>
		/// <param name="child">the child view to add</param>
		/// <param name="index">the position at which to add the child</param>
		/// <seealso cref="generateDefaultLayoutParams()">generateDefaultLayoutParams()</seealso>
		public virtual void addView(android.view.View child, int index)
		{
			android.view.ViewGroup.LayoutParams @params = child.getLayoutParams();
			if (@params == null)
			{
				@params = generateDefaultLayoutParams();
				if (@params == null)
				{
					throw new System.ArgumentException("generateDefaultLayoutParams() cannot return null"
						);
				}
			}
			addView(child, index, @params);
		}
Пример #3
0
		/// <summary>
		/// Ask one of the children of this view to measure itself, taking into
		/// account both the MeasureSpec requirements for this view and its padding.
		/// </summary>
		/// <remarks>
		/// Ask one of the children of this view to measure itself, taking into
		/// account both the MeasureSpec requirements for this view and its padding.
		/// The heavy lifting is done in getChildMeasureSpec.
		/// </remarks>
		/// <param name="child">The child to measure</param>
		/// <param name="parentWidthMeasureSpec">The width requirements for this view</param>
		/// <param name="parentHeightMeasureSpec">The height requirements for this view</param>
		protected internal virtual void measureChild(android.view.View child, int parentWidthMeasureSpec
			, int parentHeightMeasureSpec)
		{
			android.view.ViewGroup.LayoutParams lp = child.getLayoutParams();
			int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec, mPaddingLeft
				 + mPaddingRight, lp.width);
			int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec, mPaddingTop
				 + mPaddingBottom, lp.height);
			child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
		}
Пример #4
0
		/// <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);
		}
Пример #5
0
		public override void addView(android.view.View child)
		{
			if (child.getLayoutParams() == null)
			{
				android.widget.LinearLayout.LayoutParams lp = new android.widget.LinearLayout.LayoutParams
					(0, android.view.ViewGroup.LayoutParams.MATCH_PARENT, 1.0f);
				lp.setMargins(0, 0, 0, 0);
				child.setLayoutParams(lp);
			}
			// Ensure you can navigate to the tab with the keyboard, and you can touch it
			child.setFocusable(true);
			child.setClickable(true);
			base.addView(child);
			// TODO: detect this via geometry with a tabwidget listener rather
			// than potentially interfere with the view's listener
			child.setOnClickListener(new android.widget.TabWidget.TabClickListener(this, getTabCount
				() - 1));
			child.setOnFocusChangeListener(this);
		}
Пример #6
0
		/// <summary>
		/// Returns the amount of milliseconds by which the specified view's
		/// animation must be delayed or offset.
		/// </summary>
		/// <remarks>
		/// Returns the amount of milliseconds by which the specified view's
		/// animation must be delayed or offset. Subclasses should override this
		/// method to return a suitable value.
		/// This implementation returns <code>child animation delay</code>
		/// milliseconds where:
		/// <pre>
		/// child animation delay = child index * delay
		/// </pre>
		/// The index is retrieved from the
		/// <see cref="AnimationParameters">AnimationParameters</see>
		/// found in the view's
		/// <see cref="android.view.ViewGroup.LayoutParams">android.view.ViewGroup.LayoutParams
		/// 	</see>
		/// .
		/// </remarks>
		/// <param name="view">the view for which to obtain the animation's delay</param>
		/// <returns>a delay in milliseconds</returns>
		/// <seealso cref="getAnimationForView(android.view.View)">getAnimationForView(android.view.View)
		/// 	</seealso>
		/// <seealso cref="getDelay()">getDelay()</seealso>
		/// <seealso cref="getTransformedIndex(AnimationParameters)">getTransformedIndex(AnimationParameters)
		/// 	</seealso>
		/// <seealso cref="android.view.ViewGroup.LayoutParams">android.view.ViewGroup.LayoutParams
		/// 	</seealso>
		protected internal virtual long getDelayForView(android.view.View view)
		{
			android.view.ViewGroup.LayoutParams lp = view.getLayoutParams();
			android.view.animation.LayoutAnimationController.AnimationParameters @params = lp
				.layoutAnimationParameters;
			if (@params == null)
			{
				return 0;
			}
			float delay = mDelay * mAnimation.getDuration();
			long viewDelay = (long)(getTransformedIndex(@params) * delay);
			float totalDelay = delay * @params.count;
			if (mInterpolator == null)
			{
				mInterpolator = new android.view.animation.LinearInterpolator();
			}
			float normalizedDelay = viewDelay / totalDelay;
			normalizedDelay = mInterpolator.getInterpolation(normalizedDelay);
			return (long)(normalizedDelay * totalDelay);
		}
Пример #7
0
		/// <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);
		}
Пример #8
0
		internal override int getNextLocationOffset(android.view.View child)
		{
			return ((android.widget.TableRow.LayoutParams)child.getLayoutParams()).mOffset[android.widget.TableRow
				.LayoutParams.LOCATION_NEXT];
		}
Пример #9
0
		protected internal override void measureChild(android.view.View child, int parentWidthMeasureSpec
			, int parentHeightMeasureSpec)
		{
			android.view.ViewGroup.LayoutParams lp = child.getLayoutParams();
			int childWidthMeasureSpec;
			int childHeightMeasureSpec;
			childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec, mPaddingTop
				 + mPaddingBottom, lp.height);
			childWidthMeasureSpec = android.view.View.MeasureSpec.makeMeasureSpec(0, android.view.View
				.MeasureSpec.UNSPECIFIED);
			child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
		}
Пример #10
0
		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);
			}
		}
Пример #11
0
		internal override int getChildrenSkipCount(android.view.View child, int index)
		{
			android.widget.TableRow.LayoutParams layoutParams = (android.widget.TableRow.LayoutParams
				)child.getLayoutParams();
			// when the span is 1 (default), we need to skip 0 child
			return layoutParams.span - 1;
		}
Пример #12
0
		internal override void transformViewForTransition(int fromIndex, int toIndex, android.view.View
			 view, bool animate_1)
		{
			if (!animate_1)
			{
				((android.widget.StackView.StackFrame)view).cancelSliderAnimator();
				view.setRotationX(0f);
				android.widget.StackView.LayoutParams lp = (android.widget.StackView.LayoutParams
					)view.getLayoutParams();
				lp.setVerticalOffset(0);
				lp.setHorizontalOffset(0);
			}
			if (fromIndex == -1 && toIndex == getNumActiveViews() - 1)
			{
				transformViewAtIndex(toIndex, view, false);
				view.setVisibility(VISIBLE);
				view.setAlpha(1.0f);
			}
			else
			{
				if (fromIndex == 0 && toIndex == 1)
				{
					((android.widget.StackView.StackFrame)view).cancelSliderAnimator();
					view.setVisibility(VISIBLE);
					int duration = Sharpen.Util.Round(mStackSlider.getDurationForNeutralPosition(mYVelocity
						));
					android.widget.StackView.StackSlider animationSlider = new android.widget.StackView
						.StackSlider(this, mStackSlider);
					animationSlider.setView(view);
					if (animate_1)
					{
						android.animation.PropertyValuesHolder slideInY = android.animation.PropertyValuesHolder
							.ofFloat("YProgress", 0.0f);
						android.animation.PropertyValuesHolder slideInX = android.animation.PropertyValuesHolder
							.ofFloat("XProgress", 0.0f);
						android.animation.ObjectAnimator slideIn = android.animation.ObjectAnimator.ofPropertyValuesHolder
							(animationSlider, slideInX, slideInY);
						slideIn.setDuration(duration);
						slideIn.setInterpolator(new android.view.animation.LinearInterpolator());
						((android.widget.StackView.StackFrame)view).setSliderAnimator(slideIn);
						slideIn.start();
					}
					else
					{
						animationSlider.setYProgress(0f);
						animationSlider.setXProgress(0f);
					}
				}
				else
				{
					if (fromIndex == 1 && toIndex == 0)
					{
						((android.widget.StackView.StackFrame)view).cancelSliderAnimator();
						int duration = Sharpen.Util.Round(mStackSlider.getDurationForOffscreenPosition(mYVelocity
							));
						android.widget.StackView.StackSlider animationSlider = new android.widget.StackView
							.StackSlider(this, mStackSlider);
						animationSlider.setView(view);
						if (animate_1)
						{
							android.animation.PropertyValuesHolder slideOutY = android.animation.PropertyValuesHolder
								.ofFloat("YProgress", 1.0f);
							android.animation.PropertyValuesHolder slideOutX = android.animation.PropertyValuesHolder
								.ofFloat("XProgress", 0.0f);
							android.animation.ObjectAnimator slideOut = android.animation.ObjectAnimator.ofPropertyValuesHolder
								(animationSlider, slideOutX, slideOutY);
							slideOut.setDuration(duration);
							slideOut.setInterpolator(new android.view.animation.LinearInterpolator());
							((android.widget.StackView.StackFrame)view).setSliderAnimator(slideOut);
							slideOut.start();
						}
						else
						{
							animationSlider.setYProgress(1.0f);
							animationSlider.setXProgress(0f);
						}
					}
					else
					{
						if (toIndex == 0)
						{
							view.setAlpha(0.0f);
							view.setVisibility(INVISIBLE);
						}
						else
						{
							if ((fromIndex == 0 || fromIndex == 1) && toIndex > 1)
							{
								view.setVisibility(VISIBLE);
								view.setAlpha(1.0f);
								view.setRotationX(0f);
								android.widget.StackView.LayoutParams lp = (android.widget.StackView.LayoutParams
									)view.getLayoutParams();
								lp.setVerticalOffset(0);
								lp.setHorizontalOffset(0);
							}
							else
							{
								if (fromIndex == -1)
								{
									view.setAlpha(1.0f);
									view.setVisibility(VISIBLE);
								}
								else
								{
									if (toIndex == -1)
									{
										if (animate_1)
										{
											postDelayed(new _Runnable_294(view), STACK_RELAYOUT_DURATION);
										}
										else
										{
											view.setAlpha(0f);
										}
									}
								}
							}
						}
					}
				}
			}
			// Implement the faked perspective
			if (toIndex != -1)
			{
				transformViewAtIndex(toIndex, view, animate_1);
			}
		}
Пример #13
0
		internal override android.view.ViewGroup.LayoutParams createOrReuseLayoutParams(android.view.View
			 v)
		{
			android.view.ViewGroup.LayoutParams currentLp = v.getLayoutParams();
			if (currentLp is android.widget.StackView.LayoutParams)
			{
				android.widget.StackView.LayoutParams lp = (android.widget.StackView.LayoutParams
					)currentLp;
				lp.setHorizontalOffset(0);
				lp.setVerticalOffset(0);
				lp.width = 0;
				lp.width = 0;
				return lp;
			}
			return new android.widget.StackView.LayoutParams(this, v);
		}
Пример #14
0
		/// <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;
		}
		protected internal override long getDelayForView(android.view.View view)
		{
			android.view.ViewGroup.LayoutParams lp = view.getLayoutParams();
			android.view.animation.GridLayoutAnimationController.AnimationParameters @params = 
				(android.view.animation.GridLayoutAnimationController.AnimationParameters)lp.layoutAnimationParameters;
			if (@params == null)
			{
				return 0;
			}
			int column = getTransformedColumnIndex(@params);
			int row = getTransformedRowIndex(@params);
			int rowsCount = @params.rowsCount;
			int columnsCount = @params.columnsCount;
			long duration = mAnimation.getDuration();
			float columnDelay = mColumnDelay * duration;
			float rowDelay = mRowDelay * duration;
			float totalDelay;
			long viewDelay;
			if (mInterpolator == null)
			{
				mInterpolator = new android.view.animation.LinearInterpolator();
			}
			switch (mDirectionPriority)
			{
				case PRIORITY_COLUMN:
				{
					viewDelay = (long)(row * rowDelay + column * rowsCount * rowDelay);
					totalDelay = rowsCount * rowDelay + columnsCount * rowsCount * rowDelay;
					break;
				}

				case PRIORITY_ROW:
				{
					viewDelay = (long)(column * columnDelay + row * columnsCount * columnDelay);
					totalDelay = columnsCount * columnDelay + rowsCount * columnsCount * columnDelay;
					break;
				}

				case PRIORITY_NONE:
				default:
				{
					viewDelay = (long)(column * columnDelay + row * rowDelay);
					totalDelay = columnsCount * columnDelay + rowsCount * rowDelay;
					break;
				}
			}
			float normalizedDelay = viewDelay / totalDelay;
			normalizedDelay = mInterpolator.getInterpolation(normalizedDelay);
			return (long)(normalizedDelay * totalDelay);
		}
Пример #16
0
		protected internal override void measureChildWithMargins(android.view.View child, 
			int parentWidthMeasureSpec, int widthUsed, int parentHeightMeasureSpec, int heightUsed
			)
		{
			android.view.ViewGroup.MarginLayoutParams lp = (android.view.ViewGroup.MarginLayoutParams
				)child.getLayoutParams();
			int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec, mPaddingTop
				 + mPaddingBottom + lp.topMargin + lp.bottomMargin + heightUsed, lp.height);
			int childWidthMeasureSpec = android.view.View.MeasureSpec.makeMeasureSpec(lp.leftMargin
				 + lp.rightMargin, android.view.View.MeasureSpec.UNSPECIFIED);
			child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
		}
Пример #17
0
		public virtual void setTabContainer([email protected]
			 tabView)
		{
			if (mTabContainer != null)
			{
				removeView(mTabContainer);
			}
			mTabContainer = tabView;
			if (tabView != null)
			{
				addView(tabView);
				android.view.ViewGroup.LayoutParams lp = tabView.getLayoutParams();
				lp.width = android.view.ViewGroup.LayoutParams.MATCH_PARENT;
				lp.height = android.view.ViewGroup.LayoutParams.WRAP_CONTENT;
				tabView.setAllowCollapse(false);
			}
		}
Пример #18
0
		/// <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
				);
			switch (absoluteGravity & android.view.Gravity.HORIZONTAL_GRAVITY_MASK)
			{
				case android.view.Gravity.LEFT:
				{
					childLeft = childrenLeft;
					break;
				}

				case android.view.Gravity.CENTER_HORIZONTAL:
				{
					childLeft = childrenLeft + ((mColumnWidth - w) / 2);
					break;
				}

				case android.view.Gravity.RIGHT:
				{
					childLeft = childrenLeft + mColumnWidth - w;
					break;
				}

				default:
				{
					childLeft = childrenLeft;
					break;
				}
			}
			if (needToMeasure)
			{
				int childRight = childLeft + w;
				int childBottom = childTop + h;
				child.layout(childLeft, childTop, childRight, childBottom);
			}
			else
			{
				child.offsetLeftAndRight(childLeft - child.getLeft());
				child.offsetTopAndBottom(childTop - child.getTop());
			}
			if (mCachingStarted)
			{
				child.setDrawingCacheEnabled(true);
			}
			if (recycled && (((android.widget.AbsListView.LayoutParams)child.getLayoutParams(
				)).scrappedFromPosition) != position)
			{
				child.jumpDrawablesToCurrentState();
			}
		}