/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.support.v7.widget;
import android.content.Context;
import android.content.res.ColorStateList;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.database.DataSetObserver;
import android.graphics.PorterDuff;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.support.annotation.DrawableRes;
import android.support.annotation.Nullable;
import android.support.v4.view.TintableBackgroundView;
import android.support.v4.view.ViewCompat;
import android.support.v7.appcompat.R;
import android.support.v7.internal.view.ContextThemeWrapper;
import android.support.v7.internal.widget.TintManager;
import android.support.v7.internal.widget.TintTypedArray;
import android.support.v7.internal.widget.ViewUtils;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewTreeObserver;
import android.widget.AdapterView;
import android.widget.ListAdapter;
import android.widget.ListView;
import android.widget.PopupWindow;
import android.widget.Spinner;
import android.widget.SpinnerAdapter;
/**
* A {@link Spinner} which supports compatible features on older version of the platform,
* including:
* <ul>
* <li>Allows dynamic tint of it background via the background tint methods in
* {@link android.support.v4.view.ViewCompat}.</li>
* <li>Allows setting of the background tint using {@link R.attr#backgroundTint} and
* {@link R.attr#backgroundTintMode}.</li>
* <li>Allows setting of the popups theme using {@link R.attr#popupTheme}.</li>
* </ul>
*
* <p>This will automatically be used when you use {@link Spinner} in your layouts.
* You should only need to manually use this class when writing custom views.</p>
*/
public class AppCompatSpinner extends Spinner implements TintableBackgroundView {
private static final boolean IS_AT_LEAST_M = Build.VERSION.SDK_INT >= 23;
private static final boolean IS_AT_LEAST_JB = Build.VERSION.SDK_INT >= 16;
private static final int[] ATTRS_ANDROID_SPINNERMODE = {android.R.attr.spinnerMode};
private static final int MAX_ITEMS_MEASURED = 15;
private static final String TAG = "AppCompatSpinner";
private static final int MODE_DIALOG = 0;
private static final int MODE_DROPDOWN = 1;
private static final int MODE_THEME = -1;
private TintManager mTintManager;
private AppCompatBackgroundHelper mBackgroundTintHelper;
/** Context used to inflate the popup window or dialog. */
private Context mPopupContext;
/** Forwarding listener used to implement drag-to-open. */
private ListPopupWindow.ForwardingListener mForwardingListener;
/** Temporary holder for setAdapter() calls from the super constructor. */
private SpinnerAdapter mTempAdapter;
private boolean mPopupSet;
private DropdownPopup mPopup;
private int mDropDownWidth;
private final Rect mTempRect = new Rect();
/**
* Construct a new spinner with the given context's theme.
*
* @param context The Context the view is running in, through which it can
* access the current theme, resources, etc.
*/
public AppCompatSpinner(Context context) {
this(context, null);
}
/**
* Construct a new spinner with the given context's theme and the supplied
* mode of displaying choices. <code>mode</code> may be one of
* {@link #MODE_DIALOG} or {@link #MODE_DROPDOWN}.
*
* @param context The Context the view is running in, through which it can
* access the current theme, resources, etc.
* @param mode Constant describing how the user will select choices from the spinner.
* @see #MODE_DIALOG
* @see #MODE_DROPDOWN
*/
public AppCompatSpinner(Context context, int mode) {
this(context, null, R.attr.spinnerStyle, mode);
}
/**
* Construct a new spinner with the given context's theme and the supplied attribute set.
*
* @param context The Context the view is running in, through which it can
* access the current theme, resources, etc.
* @param attrs The attributes of the XML tag that is inflating the view.
*/
public AppCompatSpinner(Context context, AttributeSet attrs) {
this(context, attrs, R.attr.spinnerStyle);
}
/**
* Construct a new spinner with the given context's theme, the supplied attribute set,
* and default style attribute.
*
* @param context The Context the view is running in, through which it can
* access the current theme, resources, etc.
* @param attrs The attributes of the XML tag that is inflating the view.
* @param defStyleAttr An attribute in the current theme that contains a
* reference to a style resource that supplies default values for
* the view. Can be 0 to not look for defaults.
*/
public AppCompatSpinner(Context context, AttributeSet attrs, int defStyleAttr) {
this(context, attrs, defStyleAttr, MODE_THEME);
}
/**
* Construct a new spinner with the given context's theme, the supplied attribute set,
* and default style. <code>mode</code> may be one of {@link #MODE_DIALOG} or
* {@link #MODE_DROPDOWN} and determines how the user will select choices from the spinner.
*
* @param context The Context the view is running in, through which it can
* access the current theme, resources, etc.
* @param attrs The attributes of the XML tag that is inflating the view.
* @param defStyleAttr An attribute in the current theme that contains a
* reference to a style resource that supplies default values for
* the view. Can be 0 to not look for defaults.
* @param mode Constant describing how the user will select choices from the spinner.
* @see #MODE_DIALOG
* @see #MODE_DROPDOWN
*/
public AppCompatSpinner(Context context, AttributeSet attrs, int defStyleAttr, int mode) {
this(context, attrs, defStyleAttr, mode, null);
}
/**
* Constructs a new spinner with the given context's theme, the supplied
* attribute set, default styles, popup mode (one of {@link #MODE_DIALOG}
* or {@link #MODE_DROPDOWN}), and the context against which the popup
* should be inflated.
*
* @param context The context against which the view is inflated, which
* provides access to the current theme, resources, etc.
* @param attrs The attributes of the XML tag that is inflating the view.
* @param defStyleAttr An attribute in the current theme that contains a
* reference to a style resource that supplies default
* values for the view. Can be 0 to not look for
* defaults.
* @param mode Constant describing how the user will select choices from
* the spinner.
* @param popupTheme The theme against which the dialog or dropdown popup
* should be inflated. May be {@code null} to use the
* view theme. If set, this will override any value
* specified by
* {@link R.styleable#Spinner_popupTheme}.
* @see #MODE_DIALOG
* @see #MODE_DROPDOWN
*/
public AppCompatSpinner(Context context, AttributeSet attrs, int defStyleAttr, int mode,
Resources.Theme popupTheme) {
super(context, attrs, defStyleAttr);
TintTypedArray a = TintTypedArray.obtainStyledAttributes(context, attrs,
R.styleable.Spinner, defStyleAttr, 0);
mTintManager = a.getTintManager();
mBackgroundTintHelper = new AppCompatBackgroundHelper(this, mTintManager);
if (popupTheme != null) {
mPopupContext = new ContextThemeWrapper(context, popupTheme);
} else {
final int popupThemeResId = a.getResourceId(R.styleable.Spinner_popupTheme, 0);
if (popupThemeResId != 0) {
mPopupContext = new ContextThemeWrapper(context, popupThemeResId);
} else {
// If we're running on a < M device, we'll use the current context and still handle
// any dropdown popup
mPopupContext = !IS_AT_LEAST_M ? context : null;
}
}
if (mPopupContext != null) {
if (mode == MODE_THEME) {
if (Build.VERSION.SDK_INT >= 11) {
// If we're running on API v11+ we will try and read android:spinnerMode
TypedArray aa = null;
try {
aa = context.obtainStyledAttributes(attrs, ATTRS_ANDROID_SPINNERMODE,
defStyleAttr, 0);
if (aa.hasValue(0)) {
mode = aa.getInt(0, MODE_DIALOG);
}
} catch (Exception e) {
Log.i(TAG, "Could not read android:spinnerMode", e);
} finally {
if (aa != null) {
aa.recycle();
}
}
} else {
// Else, we use a default mode of dropdown
mode = MODE_DROPDOWN;
}
}
if (mode == MODE_DROPDOWN) {
final DropdownPopup popup = new DropdownPopup(mPopupContext, attrs, defStyleAttr);
final TintTypedArray pa = TintTypedArray.obtainStyledAttributes(
mPopupContext, attrs, R.styleable.Spinner, defStyleAttr, 0);
mDropDownWidth = pa.getLayoutDimension(R.styleable.Spinner_android_dropDownWidth,
LayoutParams.WRAP_CONTENT);
popup.setBackgroundDrawable(
pa.getDrawable(R.styleable.Spinner_android_popupBackground));
popup.setPromptText(a.getString(R.styleable.Spinner_android_prompt));
pa.recycle();
mPopup = popup;
mForwardingListener = new ListPopupWindow.ForwardingListener(this) {
@Override
public ListPopupWindow getPopup() {
return popup;
}
@Override
public boolean onForwardingStarted() {
if (!mPopup.isShowing()) {
mPopup.show();
}
return true;
}
};
}
}
a.recycle();
mPopupSet = true;
// Base constructors can call setAdapter before we initialize mPopup.
// Finish setting things up if this happened.
if (mTempAdapter != null) {
setAdapter(mTempAdapter);
mTempAdapter = null;
}
mBackgroundTintHelper.loadFromAttributes(attrs, defStyleAttr);
}
/**
* @return the context used to inflate the Spinner's popup or dialog window
*/
public Context getPopupContext() {
if (mPopup != null) {
return mPopupContext;
} else if (IS_AT_LEAST_M) {
return super.getPopupContext();
}
return null;
}
public void setPopupBackgroundDrawable(Drawable background) {
if (mPopup != null) {
mPopup.setBackgroundDrawable(background);
} else if (IS_AT_LEAST_JB) {
super.setPopupBackgroundDrawable(background);
}
}
public void setPopupBackgroundResource(@DrawableRes int resId) {
setPopupBackgroundDrawable(getPopupContext().getDrawable(resId));
}
public Drawable getPopupBackground() {
if (mPopup != null) {
return mPopup.getBackground();
} else if (IS_AT_LEAST_JB) {
return super.getPopupBackground();
}
return null;
}
public void setDropDownVerticalOffset(int pixels) {
if (mPopup != null) {
mPopup.setVerticalOffset(pixels);
} else if (IS_AT_LEAST_JB) {
super.setDropDownVerticalOffset(pixels);
}
}
public int getDropDownVerticalOffset() {
if (mPopup != null) {
return mPopup.getVerticalOffset();
} else if (IS_AT_LEAST_JB) {
return super.getDropDownVerticalOffset();
}
return 0;
}
public void setDropDownHorizontalOffset(int pixels) {
if (mPopup != null) {
mPopup.setHorizontalOffset(pixels);
} else if (IS_AT_LEAST_JB) {
super.setDropDownHorizontalOffset(pixels);
}
}
/**
* Get the configured horizontal offset in pixels for the spinner's popup window of choices.
* Only valid in {@link #MODE_DROPDOWN}; other modes will return 0.
*
* @return Horizontal offset in pixels
*/
public int getDropDownHorizontalOffset() {
if (mPopup != null) {
return mPopup.getHorizontalOffset();
} else if (IS_AT_LEAST_JB) {
return super.getDropDownHorizontalOffset();
}
return 0;
}
public void setDropDownWidth(int pixels) {
if (mPopup != null) {
mDropDownWidth = pixels;
} else if (IS_AT_LEAST_JB) {
super.setDropDownWidth(pixels);
}
}
public int getDropDownWidth() {
if (mPopup != null) {
return mDropDownWidth;
} else if (IS_AT_LEAST_JB) {
return super.getDropDownWidth();
}
return 0;
}
@Override
public void setAdapter(SpinnerAdapter adapter) {
// The super constructor may call setAdapter before we're prepared.
// Postpone doing anything until we've finished construction.
if (!mPopupSet) {
mTempAdapter = adapter;
return;
}
super.setAdapter(adapter);
if (mPopup != null) {
final Context popupContext = mPopupContext == null ? getContext() : mPopupContext;
mPopup.setAdapter(new DropDownAdapter(adapter, popupContext.getTheme()));
}
}
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
if (mPopup != null && mPopup.isShowing()) {
mPopup.dismiss();
}
}
@Override
public boolean onTouchEvent(MotionEvent event) {
if (mForwardingListener != null && mForwardingListener.onTouch(this, event)) {
return true;
}
return super.onTouchEvent(event);
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
if (mPopup != null && MeasureSpec.getMode(widthMeasureSpec) == MeasureSpec.AT_MOST) {
final int measuredWidth = getMeasuredWidth();
setMeasuredDimension(Math.min(Math.max(measuredWidth,
compatMeasureContentWidth(getAdapter(), getBackground())),
MeasureSpec.getSize(widthMeasureSpec)),
getMeasuredHeight());
}
}
@Override
public boolean performClick() {
if (mPopup != null && !mPopup.isShowing()) {
mPopup.show();
return true;
}
return super.performClick();
}
@Override
public void setPrompt(CharSequence prompt) {
if (mPopup != null) {
mPopup.setPromptText(prompt);
} else {
super.setPrompt(prompt);
}
}
@Override
public CharSequence getPrompt() {
return mPopup != null ? mPopup.getHintText() : super.getPrompt();
}
@Override
public void setBackgroundResource(@DrawableRes int resId) {
super.setBackgroundResource(resId);
if (mBackgroundTintHelper != null) {
mBackgroundTintHelper.onSetBackgroundResource(resId);
}
}
@Override
public void setBackgroundDrawable(Drawable background) {
super.setBackgroundDrawable(background);
if (mBackgroundTintHelper != null) {
mBackgroundTintHelper.onSetBackgroundDrawable(background);
}
}
/**
* This should be accessed via
* {@link android.support.v4.view.ViewCompat#setBackgroundTintList(android.view.View,
* ColorStateList)}
*
* @hide
*/
@Override
public void setSupportBackgroundTintList(@Nullable ColorStateList tint) {
if (mBackgroundTintHelper != null) {
mBackgroundTintHelper.setSupportBackgroundTintList(tint);
}
}
/**
* This should be accessed via
* {@link android.support.v4.view.ViewCompat#getBackgroundTintList(android.view.View)}
*
* @hide
*/
@Override
@Nullable
public ColorStateList getSupportBackgroundTintList() {
return mBackgroundTintHelper != null
? mBackgroundTintHelper.getSupportBackgroundTintList() : null;
}
/**
* This should be accessed via
* {@link android.support.v4.view.ViewCompat#setBackgroundTintMode(android.view.View,
* PorterDuff.Mode)}
*
* @hide
*/
@Override
public void setSupportBackgroundTintMode(@Nullable PorterDuff.Mode tintMode) {
if (mBackgroundTintHelper != null) {
mBackgroundTintHelper.setSupportBackgroundTintMode(tintMode);
}
}
/**
* This should be accessed via
* {@link android.support.v4.view.ViewCompat#getBackgroundTintMode(android.view.View)}
*
* @hide
*/
@Override
@Nullable
public PorterDuff.Mode getSupportBackgroundTintMode() {
return mBackgroundTintHelper != null
? mBackgroundTintHelper.getSupportBackgroundTintMode() : null;
}
@Override
protected void drawableStateChanged() {
super.drawableStateChanged();
if (mBackgroundTintHelper != null) {
mBackgroundTintHelper.applySupportBackgroundTint();
}
}
private int compatMeasureContentWidth(SpinnerAdapter adapter, Drawable background) {
if (adapter == null) {
return 0;
}
int width = 0;
View itemView = null;
int itemType = 0;
final int widthMeasureSpec =
MeasureSpec.makeMeasureSpec(getMeasuredWidth(), MeasureSpec.UNSPECIFIED);
final int heightMeasureSpec =
MeasureSpec.makeMeasureSpec(getMeasuredHeight(), MeasureSpec.UNSPECIFIED);
// Make sure the number of items we'll measure is capped. If it's a huge data set
// with wildly varying sizes, oh well.
int start = Math.max(0, getSelectedItemPosition());
final int end = Math.min(adapter.getCount(), start + MAX_ITEMS_MEASURED);
final int count = end - start;
start = Math.max(0, start - (MAX_ITEMS_MEASURED - count));
for (int i = start; i < end; i++) {
final int positionType = adapter.getItemViewType(i);
if (positionType != itemType) {
itemType = positionType;
itemView = null;
}
itemView = adapter.getView(i, itemView, this);
if (itemView.getLayoutParams() == null) {
itemView.setLayoutParams(new LayoutParams(
LayoutParams.WRAP_CONTENT,
LayoutParams.WRAP_CONTENT));
}
itemView.measure(widthMeasureSpec, heightMeasureSpec);
width = Math.max(width, itemView.getMeasuredWidth());
}
// Add background padding to measured width
if (background != null) {
background.getPadding(mTempRect);
width += mTempRect.left + mTempRect.right;
}
return width;
}
/**
* <p>Wrapper class for an Adapter. Transforms the embedded Adapter instance
* into a ListAdapter.</p>
*/
private static class DropDownAdapter implements ListAdapter, SpinnerAdapter {
private SpinnerAdapter mAdapter;
private ListAdapter mListAdapter;
/**
* Creates a new ListAdapter wrapper for the specified adapter.
*
* @param adapter the SpinnerAdapter to transform into a ListAdapter
* @param dropDownTheme the theme against which to inflate drop-down
* views, may be {@null} to use default theme
*/
public DropDownAdapter(@Nullable SpinnerAdapter adapter,
@Nullable Resources.Theme dropDownTheme) {
mAdapter = adapter;
if (adapter instanceof ListAdapter) {
mListAdapter = (ListAdapter) adapter;
}
if (dropDownTheme != null) {
if (IS_AT_LEAST_M && adapter instanceof android.widget.ThemedSpinnerAdapter) {
final android.widget.ThemedSpinnerAdapter themedAdapter =
(android.widget.ThemedSpinnerAdapter) adapter;
if (themedAdapter.getDropDownViewTheme() != dropDownTheme) {
themedAdapter.setDropDownViewTheme(dropDownTheme);
}
} else if (adapter instanceof ThemedSpinnerAdapter) {
final ThemedSpinnerAdapter themedAdapter = (ThemedSpinnerAdapter) adapter;
if (themedAdapter.getDropDownViewTheme() == null) {
themedAdapter.setDropDownViewTheme(dropDownTheme);
}
}
}
}
public int getCount() {
return mAdapter == null ? 0 : mAdapter.getCount();
}
public Object getItem(int position) {
return mAdapter == null ? null : mAdapter.getItem(position);
}
public long getItemId(int position) {
return mAdapter == null ? -1 : mAdapter.getItemId(position);
}
public View getView(int position, View convertView, ViewGroup parent) {
return getDropDownView(position, convertView, parent);
}
public View getDropDownView(int position, View convertView, ViewGroup parent) {
return (mAdapter == null) ? null
: mAdapter.getDropDownView(position, convertView, parent);
}
public boolean hasStableIds() {
return mAdapter != null && mAdapter.hasStableIds();
}
public void registerDataSetObserver(DataSetObserver observer) {
if (mAdapter != null) {
mAdapter.registerDataSetObserver(observer);
}
}
public void unregisterDataSetObserver(DataSetObserver observer) {
if (mAdapter != null) {
mAdapter.unregisterDataSetObserver(observer);
}
}
/**
* If the wrapped SpinnerAdapter is also a ListAdapter, delegate this call.
* Otherwise, return true.
*/
public boolean areAllItemsEnabled() {
final ListAdapter adapter = mListAdapter;
if (adapter != null) {
return adapter.areAllItemsEnabled();
} else {
return true;
}
}
/**
* If the wrapped SpinnerAdapter is also a ListAdapter, delegate this call.
* Otherwise, return true.
*/
public boolean isEnabled(int position) {
final ListAdapter adapter = mListAdapter;
if (adapter != null) {
return adapter.isEnabled(position);
} else {
return true;
}
}
public int getItemViewType(int position) {
return 0;
}
public int getViewTypeCount() {
return 1;
}
public boolean isEmpty() {
return getCount() == 0;
}
}
private class DropdownPopup extends ListPopupWindow {
private CharSequence mHintText;
private ListAdapter mAdapter;
private final Rect mVisibleRect = new Rect();
public DropdownPopup(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
setAnchorView(AppCompatSpinner.this);
setModal(true);
setPromptPosition(POSITION_PROMPT_ABOVE);
setOnItemClickListener(new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View v, int position, long id) {
AppCompatSpinner.this.setSelection(position);
if (getOnItemClickListener() != null) {
AppCompatSpinner.this
.performItemClick(v, position, mAdapter.getItemId(position));
}
dismiss();
}
});
}
@Override
public void setAdapter(ListAdapter adapter) {
super.setAdapter(adapter);
mAdapter = adapter;
}
public CharSequence getHintText() {
return mHintText;
}
public void setPromptText(CharSequence hintText) {
// Hint text is ignored for dropdowns, but maintain it here.
mHintText = hintText;
}
void computeContentWidth() {
final Drawable background = getBackground();
int hOffset = 0;
if (background != null) {
background.getPadding(mTempRect);
hOffset = ViewUtils.isLayoutRtl(AppCompatSpinner.this) ? mTempRect.right
: -mTempRect.left;
} else {
mTempRect.left = mTempRect.right = 0;
}
final int spinnerPaddingLeft = AppCompatSpinner.this.getPaddingLeft();
final int spinnerPaddingRight = AppCompatSpinner.this.getPaddingRight();
final int spinnerWidth = AppCompatSpinner.this.getWidth();
if (mDropDownWidth == WRAP_CONTENT) {
int contentWidth = compatMeasureContentWidth(
(SpinnerAdapter) mAdapter, getBackground());
final int contentWidthLimit = getContext().getResources()
.getDisplayMetrics().widthPixels - mTempRect.left - mTempRect.right;
if (contentWidth > contentWidthLimit) {
contentWidth = contentWidthLimit;
}
setContentWidth(Math.max(
contentWidth, spinnerWidth - spinnerPaddingLeft - spinnerPaddingRight));
} else if (mDropDownWidth == MATCH_PARENT) {
setContentWidth(spinnerWidth - spinnerPaddingLeft - spinnerPaddingRight);
} else {
setContentWidth(mDropDownWidth);
}
if (ViewUtils.isLayoutRtl(AppCompatSpinner.this)) {
hOffset += spinnerWidth - spinnerPaddingRight - getWidth();
} else {
hOffset += spinnerPaddingLeft;
}
setHorizontalOffset(hOffset);
}
public void show() {
final boolean wasShowing = isShowing();
computeContentWidth();
setInputMethodMode(ListPopupWindow.INPUT_METHOD_NOT_NEEDED);
super.show();
final ListView listView = getListView();
listView.setChoiceMode(ListView.CHOICE_MODE_SINGLE);
setSelection(AppCompatSpinner.this.getSelectedItemPosition());
if (wasShowing) {
// Skip setting up the layout/dismiss listener below. If we were previously
// showing it will still stick around.
return;
}
// Make sure we hide if our anchor goes away.
// TODO: This might be appropriate to push all the way down to PopupWindow,
// but it may have other side effects to investigate first. (Text editing handles, etc.)
final ViewTreeObserver vto = getViewTreeObserver();
if (vto != null) {
final ViewTreeObserver.OnGlobalLayoutListener layoutListener
= new ViewTreeObserver.OnGlobalLayoutListener() {
@Override
public void onGlobalLayout() {
if (!isVisibleToUser(AppCompatSpinner.this)) {
dismiss();
} else {
computeContentWidth();
// Use super.show here to update; we don't want to move the selected
// position or adjust other things that would be reset otherwise.
DropdownPopup.super.show();
}
}
};
vto.addOnGlobalLayoutListener(layoutListener);
setOnDismissListener(new PopupWindow.OnDismissListener() {
@Override
public void onDismiss() {
final ViewTreeObserver vto = getViewTreeObserver();
if (vto != null) {
vto.removeGlobalOnLayoutListener(layoutListener);
}
}
});
}
}
/**
* Simplified version of the the hidden View.isVisibleToUser()
*/
private boolean isVisibleToUser(View view) {
return ViewCompat.isAttachedToWindow(view) && view.getGlobalVisibleRect(mVisibleRect);
}
}
}