android设置视图大小的文本中心

这就是问题所在：

正如您所注意到的，我正在使用，但我想将其定制为：

    int offset : view_width/2;
    text_view.setPadding(offset,0,0,0,);// just left padding matters

我知道我可以使用Gravity.CENTER，它将文本置于其视图的中心（其父视图或其自己的视图，在这里并不重要）

但这并不能解决我的问题，因为这个文本视图并没有填充父视图，所以即使我将它设置为居中，仍然有另一个文本在它附近占据了部分视图

我想要这个：

     int view_width = getViewWidth();// width of the android screen device
     textview.set_it_to_center_of(view_width);

这可能吗？ 顺便问一下，有没有好的图书馆可以这样做

最终我要实现这一目标：

无论有多少个选项卡，即使有两个选项卡，选定的选项卡始终位于视图的中心

编辑：

我甚至试着这样做：

    int offset : view_width/2;
    text_view.setPadding(offset,0,0,0,);// just left padding matters

---

但这并不完美，因为文本大小并不总是相同的，其他一些文本可能会有更大的大小，比如：重要的，比特殊的大，所以左填充不起作用。

我用过这个类，这是官方幻灯片的一个分支，可以做你想做的事情：

 import android.animation.LayoutTransition;
 import android.content.Context;
 import android.graphics.Rect;
 import android.graphics.Typeface;
 import android.os.Build;
 import android.support.v4.view.PagerAdapter;
 import android.support.v4.view.ViewPager;
 import android.util.AttributeSet;
 import android.util.Log;
 import android.util.SparseArray;
 import android.util.TypedValue;
 import android.view.Gravity;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.ViewTreeObserver;
 import android.widget.HorizontalScrollView;
 import android.widget.LinearLayout;
 import android.widget.TextView;

 /**
  * To be used with ViewPager to provide a tab indicator component which give constant feedback as to
  * the user's scroll progress.
  * <p/>
  * To use the component, simply add it to your view hierarchy. Then in your
  * {@link android.app.Activity} or {@link android.support.v4.app.Fragment} call
  * {@link #setViewPager(ViewPager)} providing it the ViewPager this layout is being used for.
  * <p/>
  * The colors can be customized in two ways. The first and simplest is to provide an array of colors
  * via {@link #setSelectedIndicatorColors(int...)}. The
  * alternative is via the {@link TabColorizer} interface which provides you complete control over
  * which color is used for any individual position.
  * <p/>
  * The views used as tabs can be customized by calling {@link      #setCustomTabView(int, int)},
  * providing the layout ID of your custom layout.
  */
 public class SlidingTabLayout extends HorizontalScrollView {
/**
 * Allows complete control over the colors drawn in the tab layout. Set with
 * {@link #setCustomTabColorizer(TabColorizer)}.
 */
public interface TabColorizer {

    /**
     * @return return the color of the indicator used when {@code position} is selected.
     */
    int getIndicatorColor(int position);

}

private static final int TAB_VIEW_PADDING_DIPS = 16;
private static final int TAB_VIEW_TEXT_SIZE_SP = 12;

private int mTabViewLayoutId;
private int mTabViewTextViewId;
private boolean mDistributeEvenly;

private ViewPager mViewPager;
private SparseArray<String> mContentDescriptions = new SparseArray<String>();
private ViewPager.OnPageChangeListener mViewPagerPageChangeListener;

private final SlidingTabStrip mTabStrip;

public SlidingTabLayout(Context context) {
    this(context, null);
}

public SlidingTabLayout(Context context, AttributeSet attrs) {
    this(context, attrs, 0);
}

public SlidingTabLayout(Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);

    // Disable the Scroll Bar
    setHorizontalScrollBarEnabled(false);
    // Make sure that the Tab Strips fills this View
    setFillViewport(true);

    mTabStrip = new SlidingTabStrip(context);
    //mTabStrip.setVisibility(View.INVISIBLE);
    addView(mTabStrip, LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);

    getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
        @Override
        public void onGlobalLayout() {
            // Set spacer tab widths
            View firstTab = mTabStrip.getChildAt(0);
            int firstTabPadding = (getWidth() - mTabStrip.getChildAt(1).getMeasuredWidth()) / 2;
            firstTab.setPadding(firstTabPadding, firstTab.getPaddingTop(), firstTab.getPaddingRight(), firstTab.getPaddingBottom());

            View lastTab = mTabStrip.getChildAt(mTabStrip.getChildCount() - 1);
            int lastTabPadding = (getWidth() - mTabStrip.getChildAt(mTabStrip.getChildCount() - 2).getMeasuredWidth()) / 4;
            lastTab.setPadding(lastTabPadding, 0, lastTabPadding, 0);


            if (Build.VERSION.SDK_INT > Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1)
                getViewTreeObserver().removeOnGlobalLayoutListener(this);
            else
                getViewTreeObserver().removeGlobalOnLayoutListener(this);
        }
    });
}

/**
 * Set the custom {@link TabColorizer} to be used.
 * <p/>
 * If you only require simple customisation then you can use
 * {@link #setSelectedIndicatorColors(int...)} to achieve
 * similar effects.
 */
public void setCustomTabColorizer(TabColorizer tabColorizer) {
    mTabStrip.setCustomTabColorizer(tabColorizer);
}

public void setDistributeEvenly(boolean distributeEvenly) {
    mDistributeEvenly = distributeEvenly;
}

/**
 * Sets the colors to be used for indicating the selected tab. These colors are treated as a
 * circular array. Providing one color will mean that all tabs are indicated with the same color.
 */
public void setSelectedIndicatorColors(int... colors) {
    mTabStrip.setSelectedIndicatorColors(colors);
}

/**
 * Set the {@link ViewPager.OnPageChangeListener}. When using {@link SlidingTabLayout} you are
 * required to set any {@link ViewPager.OnPageChangeListener} through this method. This is so
 * that the layout can update it's scroll position correctly.
 *
 * @see ViewPager#setOnPageChangeListener(ViewPager.OnPageChangeListener)
 */
public void setOnPageChangeListener(ViewPager.OnPageChangeListener listener) {
    mViewPagerPageChangeListener = listener;
}

/**
 * Set the custom layout to be inflated for the tab views.
 *
 * @param layoutResId Layout id to be inflated
 * @param textViewId  id of the {@link TextView} in the inflated view
 */
public void setCustomTabView(int layoutResId, int textViewId) {
    mTabViewLayoutId = layoutResId;
    mTabViewTextViewId = textViewId;
}

/**
 * Sets the associated view pager. Note that the assumption here is that the pager content
 * (number of tabs and tab titles) does not change after this call has been made.
 */
public void setViewPager(ViewPager viewPager) {
    mTabStrip.removeAllViews();

    mViewPager = viewPager;
    if (viewPager != null) {
        viewPager.setOnPageChangeListener(new InternalViewPagerListener());
        populateTabStrip();
    }
}

/**
 * Create a default view to be used for tabs. This is called if a custom tab view is not set via
 * {@link #setCustomTabView(int, int)}.
 */
protected TextView createDefaultTabView(Context context) {
    TextView textView = new TextView(context);
    textView.setGravity(Gravity.CENTER);
    textView.setTextSize(TypedValue.COMPLEX_UNIT_SP, TAB_VIEW_TEXT_SIZE_SP);
    textView.setTypeface(Typeface.DEFAULT_BOLD);
    textView.setLayoutParams(new LinearLayout.LayoutParams(
            ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT));

    TypedValue outValue = new TypedValue();
    getContext().getTheme().resolveAttribute(android.R.attr.selectableItemBackground,
            outValue, true);
    textView.setBackgroundResource(outValue.resourceId);
    textView.setAllCaps(true);

    int padding = (int) (TAB_VIEW_PADDING_DIPS * getResources().getDisplayMetrics().density);
    textView.setPadding(padding, padding, padding, padding);

    return textView;
}

private void populateTabStrip() {
    final PagerAdapter adapter = mViewPager.getAdapter();
    final View.OnClickListener tabClickListener = new TabClickListener();

    for (int i = 0; i < adapter.getCount(); i++) {
        View tabView = null;
        TextView tabTitleView = null;

        if (mTabViewLayoutId != 0) {
            // If there is a custom tab view layout id set, try and inflate it
            tabView = LayoutInflater.from(getContext()).inflate(mTabViewLayoutId, mTabStrip,
                    false);
            tabTitleView = (TextView) tabView.findViewById(mTabViewTextViewId);
        }

        if (tabView == null) {
            tabView = createDefaultTabView(getContext());
        }

        if (tabTitleView == null && TextView.class.isInstance(tabView)) {
            tabTitleView = (TextView) tabView;
        }

        if (mDistributeEvenly) {
            LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) tabView.getLayoutParams();
            lp.width = 0;
            lp.weight = 1;
        }

        tabTitleView.setText(adapter.getPageTitle(i));
        tabView.setOnClickListener(tabClickListener);
        String desc = mContentDescriptions.get(i, null);
        if (desc != null) {
            tabView.setContentDescription(desc);
        }

        mTabStrip.addView(tabView);
        if (i == mViewPager.getCurrentItem()) {
            tabView.setSelected(true);
        }
    }

    // First spacer tab
    TextView firstTab = new TextView(getContext());
    mTabStrip.addView(firstTab, 0);

    // Last spacer tab
    TextView lastTab = new TextView(getContext());
    mTabStrip.addView(lastTab);
}

public void setContentDescription(int i, String desc) {
    mContentDescriptions.put(i, desc);
}

private void scrollToTab(int tabIndex, int positionOffset) {
    final int tabStripChildCount = mTabStrip.getChildCount();
    if (tabStripChildCount == 0 || tabIndex < 0 || tabIndex >= tabStripChildCount) {
        return;
    }

    if (positionOffset == -1) {// Not manual scroll. Do not animate. Just cut to tab and center.
        if (tabIndex == 1)
            positionOffset = 0;
        else
            positionOffset = mTabStrip.getChildAt(tabIndex).getWidth() / 2 + mTabStrip.getChildAt(tabIndex + 1).getWidth() / 2;
    }

    if (tabIndex == 1) // if tab number one, no need to calculate previously scrolled X
        scrollTo(positionOffset, 0);
    else { // If tab number is greater than 1, we need to calculate previously scrolled X
        int previouslyScrolledX = 0;

        // Simulate previously scrolled X by summing half of each of the previous tabs' width.
        // Use 2 tabs per loop for correct simulation.
        for (int i = 1; i < tabIndex; i++) {
            previouslyScrolledX += mTabStrip.getChildAt(i).getWidth() / 2;
            previouslyScrolledX += mTabStrip.getChildAt(i + 1).getWidth() / 2;
        }

        scrollTo(previouslyScrolledX + positionOffset, 0);
    }
}

private class InternalViewPagerListener implements ViewPager.OnPageChangeListener {
    private int mScrollState;

    @Override
    public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
        int tabStripChildCount = mTabStrip.getChildCount();
        if ((tabStripChildCount == 0) || (position < 0) || (position >= tabStripChildCount)) {
            return;
        }

        position++; // Offset position by 1 to make up for left blank tab

        mTabStrip.onViewPagerPageChanged(position, positionOffset);

        // Adding half of current tab's width & half of next tab's width and scrolling by that width will center next tab
        int offsetToCenterNextTab = (mTabStrip.getChildAt(position).getWidth() / 2) + (mTabStrip.getChildAt(position + 1).getWidth() / 2);

        scrollToTab(position, Math.round(offsetToCenterNextTab * positionOffset));

        if (mViewPagerPageChangeListener != null) {
            mViewPagerPageChangeListener.onPageScrolled(position, positionOffset,
                    positionOffsetPixels);
        }
    }

    @Override
    public void onPageScrollStateChanged(int state) {
        mScrollState = state;

        if (mViewPagerPageChangeListener != null) {
            mViewPagerPageChangeListener.onPageScrollStateChanged(state);
        }
    }

    @Override
    public void onPageSelected(int position) {
        if (mScrollState == ViewPager.SCROLL_STATE_IDLE) {
            mTabStrip.onViewPagerPageChanged(position, 0f);
            scrollToTab(position, -1);
        }
        for (int i = 0; i < mTabStrip.getChildCount(); i++) {
            mTabStrip.getChildAt(i).setSelected(position + 1 == i);
        }
        if (mViewPagerPageChangeListener != null) {
            mViewPagerPageChangeListener.onPageSelected(position);
        }
    }

}

private class TabClickListener implements View.OnClickListener {
    @Override
    public void onClick(View selectedView) {
        View lastSelectedView = null;
        int selectedViewIndex = 0;

        for (int i = 1; i < mTabStrip.getChildCount() - 1; i++) {
            View currentViewInLoop = mTabStrip.getChildAt(i);
            if (currentViewInLoop.isSelected()) {
                lastSelectedView = currentViewInLoop;
            }

            if (selectedView == currentViewInLoop) {
                selectedViewIndex = i - 1;
            }

            if (lastSelectedView != null && selectedViewIndex != 0)
                break;
        }

        Rect tabContainerRect = new Rect();
        Rect lastSelectedTabRect = new Rect();

        getDrawingRect(tabContainerRect);
        lastSelectedView.getHitRect(lastSelectedTabRect);

        if (Rect.intersects(tabContainerRect, lastSelectedTabRect))
            mViewPager.setCurrentItem(selectedViewIndex);
        else
            mViewPager.setCurrentItem(selectedViewIndex, false);
    }
}

导入android.animation.LayoutTransition；
导入android.content.Context；
导入android.graphics.Rect；
导入android.graphics.Typeface；
导入android.os.Build；
导入android.support.v4.view.PagerAdapter；
导入android.support.v4.view.ViewPager；
导入android.util.AttributeSet；
导入android.util.Log；
导入android.util.SparseArray；
导入android.util.TypedValue；
导入android.view.Gravity；
导入android.view.LayoutInflater；
导入android.view.view；
导入android.view.ViewGroup；
导入android.view.ViewTreeObserver；
导入android.widget.HorizontalScrollView；
导入android.widget.LinearLayout；
导入android.widget.TextView；
/**
*与ViewPager一起使用，以提供一个选项卡指示器组件，该组件提供有关
*用户的滚动进度。
*

*要使用该组件，只需将其添加到视图层次结构中即可。然后在你的
*{@link android.app.Activity}或{@link android.support.v4.app.Fragment}调用
*{@link#setViewPager（ViewPager）}提供此布局正用于的ViewPager。
*

*颜色可以通过两种方式进行定制。第一个也是最简单的是提供一组颜色
*通过{@link#setSelectedIndicatorColors（int…）}。这个
*另一种方法是通过{@link-TabColorizer}接口，它为您提供对
*哪种颜色用于任何单个位置。
*

*用作选项卡的视图可以通过调用{@link#setCustomTabView（int，int）}进行自定义，
*提供自定义布局的布局ID。
*/
公共类SlidingTableOut扩展了水平滚动视图{
/**
*允许完全控制选项卡布局中绘制的颜色。设置为
*{@link#setCustomTabColorizer（TabColorizer）}。
*/
公共接口选项卡着色程序{
/**
*@return选择{@code position}时使用的指示器的颜色。
*/
int getIndicatorColor（int位置）；
}
私有静态最终整数选项卡\视图\填充\倾角=16；
私有静态最终整数选项卡\视图\文本\大小\ SP=12；
私有内部mTabViewLayoutId；
私有int mTabViewTextViewId；
私有布尔值不一致；
私有视图寻呼机mViewPager；
private SparseArray mContentDescriptions=新SparseArray（）；
私有ViewPager.OnPageChangeListener mViewPagerPageChangeListener；
私人最终幻灯片Abstrip mTabStrip；
公共幻灯片布局（上下文）{
这个（上下文，空）；
}
公共幻灯片布局（上下文、属性集属性）{
这（上下文，属性，0）；
}
公共幻灯片布局（上下文、属性集属性、int-defStyle）{
超级（上下文、属性、定义样式）；
//禁用滚动条
setHorizontalScrollBarEnabled（假）；
//确保选项卡条填充此视图
setFillViewport（true）；
mTabStrip=新的SlidengAbstrip（上下文）；
//mTabStrip.setVisibility（View.INVISIBLE）；
addView（mTabStrip、LayoutParams.MATCH\u父级、LayoutParams.WRAP\u内容）；
getViewTreeObserver（）.addOnGlobalLayoutListener（新ViewTreeObserver.OnGlobalLayoutListener（））{
@凌驾
公共图书馆{
//设置间隔片的宽度
View firstTab=mTabStrip.getChildAt（0）；
int firstTabPadding=（getWidth（）-mTabStrip.getChildAt（1.getMeasuredWidth（））/2；
setPadding（firstTabPadding，firstTab.getPaddingTop（），firstTab.getPaddingRight（），firstTab.getPaddingBottom（））；
查看lastTab=mTabStrip.getChildAt（mTabStrip.getChildCount（）-1）；
int lastTabPadding=（getWidth（）-mTabStrip.getChildAt（mTabStrip.getChildCount（）-2.getMeasuredWidth（））/4；
setPadding（lastabpadding，0，lastabpadding，0）；
if（Build.VERSION.SDK\u INT>Build.VERSION\u代码.冰淇淋\u三明治\u MR1）
getViewTreeObserver（）；
其他的
getViewTreeObserver（）；
}
});
}
/**
*设置要使用的自定义{@link TabColorizer}。
*

*如果您只需要简单的定制，那么您可以使用
*{@link#设置所选的指示颜色（int..）}以实现
*类似的效果。
*/
公共无效设置CustomTabColorizer（TabColorizer TabColorizer）{
mTabStrip.setCustomTabColorizer（tabColorizer）；
}
public void setDistributeEvenly（布尔值distributeEvenly）{
mDistributeEvenly=distributeEvenly；
}
/**
*设置用于指示所选选项卡的颜色。这些颜色被视为
*圆形数组。提供一种颜色意味着所有选项卡都用相同的颜色表示。
*/
公共无效设置选定的指示颜色（整数…颜色）{
mTabStrip.SetSelectedIndicator颜色（颜色）；
}
/**
*使用时设置{@link ViewPager.OnPageChangeListener}{@