使用scene2d在libgdx中居中SelectBox文本

Question

我有以下SelectBox：

//Select Box Style
SelectBox.SelectBoxStyle boxStyle = new SelectBox.SelectBoxStyle();
boxStyle.fontColor = settingsFontColor;
boxStyle.background = new SpriteDrawable(rectangle);
boxStyle.font = skin.getFont("default");
boxStyle.scrollStyle = sps;
boxStyle.scrollStyle.background = new SpriteDrawable(rectangle);
boxStyle.listStyle = new List.ListStyle();
boxStyle.listStyle.font = skin.getFont("default");
boxStyle.listStyle.fontColorSelected = selectBoxSelectedColor;
boxStyle.listStyle.fontColorUnselected = selectBoxUnselectedColor;
boxStyle.listStyle.selection = new SpriteDrawable(selectBoxOption);
boxStyle.listStyle.background = new SpriteDrawable(selectBoxOption);

//SelectBox
String[] ballSpeeds = new String[]{"Slow", "Medium", "Fast", "Fastest"};
final SelectBox<String> ballspeedbox = new SelectBox<String>(boxStyle);
ballspeedbox.setItems(ballSpeeds);

默认情况下，文本左对齐（慢，中，快，最快）。如何将文本居中？

Answer 1

我觉得这可能对你有所帮助，我测不了多少，因为我今天下午做了，你可以测试而不必编译库，你只需要小心导入一些类因为同名，改变呃事实是在simbol中：//=============================//或者是导入类要考虑的事情。

这是重复：

1类SelectBoxOverflow

import com.mygdx.game.testingClass.ListOverflow.ListStyle;
import com.mygdx.game.testingClass.ScrollPaneOverflow.ScrollPaneStyle;

public class SelectBoxOverflow<T> extends Widget implements Disableable{

    static final Vector2 temp = new Vector2();

    SelectBoxStyle style;
    final Array<T> items = new Array<T>();
    final ArraySelection<T> selection = new ArraySelection<T>(items);
    SelectBoxList<T> selectBoxList;
    private final TextBounds bounds = new TextBounds();
    private float prefWidth, prefHeight;
    private ClickListener clickListener;
    boolean disabled;

    public SelectBoxOverflow (Skin skin) {
        this(skin.get(SelectBoxStyle.class));
    }

    public SelectBoxOverflow (Skin skin, String styleName) {
        this(skin.get(styleName, SelectBoxStyle.class));
    }

    public SelectBoxOverflow (SelectBoxStyle style) {
        setStyle(style);
        setSize(getPrefWidth(), getPrefHeight());

        selection.setActor(this);
        selection.setRequired(true);

        selectBoxList = new SelectBoxList<T>(this);

        addListener(clickListener = new ClickListener() {
            public boolean touchDown (InputEvent event, float x, float y, int pointer, int button) {
                if (pointer == 0 && button != 0) return false;
                if (disabled) return false;
                if (selectBoxList.hasParent())
                    hideList();
                else
                    showList();
                return true;
            }
        });
    }

    /** Set the max number of items to display when the select box is opened. Set to 0 (the default) to display as many as fit in
     * the stage height. */
    public void setMaxListCount (int maxListCount) {
        selectBoxList.maxListCount = maxListCount;
    }

    /** @return Max number of items to display when the box is opened, or <= 0 to display them all. */
    public int getMaxListCount () {
        return selectBoxList.maxListCount;
    }

    protected void setStage (Stage stage) {
        if (stage == null) selectBoxList.hide();
        super.setStage(stage);
    }

    public void setStyle (SelectBoxStyle style) {
        if (style == null) throw new IllegalArgumentException("style cannot be null.");
        this.style = style;
        invalidateHierarchy();
    }

    /** Returns the select box's style. Modifying the returned style may not have an effect until {@link #setStyle(SelectBoxStyle)}
     * is called. */
    public SelectBoxStyle getStyle () {
        return style;
    }

    /** Set the backing Array that makes up the choices available in the SelectBox */
    public void setItems (T... newItems) {
        if (newItems == null) throw new IllegalArgumentException("newItems cannot be null.");
        float oldPrefWidth = getPrefWidth();

        items.clear();
        items.addAll(newItems);
        selection.validate();
        selectBoxList.list.setItems(items);

        invalidate();
        if (oldPrefWidth != getPrefWidth()) invalidateHierarchy();
    }

    /** Set the backing Array that makes up the choices available in the SelectBox */
    public void setItems (Array<T> newItems) {
        if (newItems == null) throw new IllegalArgumentException("newItems cannot be null.");
        float oldPrefWidth = getPrefWidth();

        items.clear();
        items.addAll(newItems);
        selection.validate();
        selectBoxList.list.setItems(items);

        invalidate();
        if (oldPrefWidth != getPrefWidth()) invalidateHierarchy();
    }

    //======================================//
    public void centerItems(boolean center){
        selectBoxList.list.centerItems(center);
    }
    //======================================//

    public void clearItems () {
        if (items.size == 0) return;
        items.clear();
        selection.clear();
        invalidateHierarchy();
    }

    /** Retrieve the backing Array that makes up the chocies available in the SelectBox
     * @see SelectBox#setItems(Array) */
    public Array<T> getItems () {
        return items;
    }

    @Override
    public void layout () {
        Drawable bg = style.background;
        BitmapFont font = style.font;

        if (bg != null) {
            prefHeight = Math.max(bg.getTopHeight() + bg.getBottomHeight() + font.getCapHeight() - font.getDescent() * 2,
                bg.getMinHeight());
        } else
            prefHeight = font.getCapHeight() - font.getDescent() * 2;

        float maxItemWidth = 0;
        for (int i = 0; i < items.size; i++)
            maxItemWidth = Math.max(font.getBounds(items.get(i).toString()).width, maxItemWidth);

        prefWidth = maxItemWidth;
        if (bg != null) prefWidth += bg.getLeftWidth() + bg.getRightWidth();

        //=========================================//
        ListStyle listStyle = style.listStyle;
        ScrollPaneStyle scrollStyle = style.scrollStyle;
        //=========================================//

        prefWidth = Math.max(
            prefWidth,
            maxItemWidth
                + (scrollStyle.background == null ? 0 : scrollStyle.background.getLeftWidth()
                    + scrollStyle.background.getRightWidth())
                + listStyle.selection.getLeftWidth()
                + listStyle.selection.getRightWidth()
                + Math.max(style.scrollStyle.vScroll != null ? style.scrollStyle.vScroll.getMinWidth() : 0,
                    style.scrollStyle.vScrollKnob != null ? style.scrollStyle.vScrollKnob.getMinWidth() : 0));
    }

    @Override
    public void draw (Batch batch, float parentAlpha) {
        validate();

        Drawable background;
        if (disabled && style.backgroundDisabled != null)
            background = style.backgroundDisabled;
        else if (selectBoxList.hasParent() && style.backgroundOpen != null)
            background = style.backgroundOpen;
        else if (clickListener.isOver() && style.backgroundOver != null)
            background = style.backgroundOver;
        else if (style.background != null)
            background = style.background;
        else
            background = null;
        final BitmapFont font = style.font;
        final Color fontColor = (disabled && style.disabledFontColor != null) ? style.disabledFontColor : style.fontColor;

        Color color = getColor();
        float x = getX();
        float y = getY();
        float width = getWidth();
        float height = getHeight();

        batch.setColor(color.r, color.g, color.b, color.a * parentAlpha);
        if (background != null) background.draw(batch, x, y, width, height);

        T selected = selection.first();
        if (selected != null) {
            String string = selected.toString();
            bounds.set(font.getBounds(string));
            if (background != null) {
                width -= background.getLeftWidth() + background.getRightWidth();
                height -= background.getBottomHeight() + background.getTopHeight();
                x += background.getLeftWidth();
                y += (int)(height / 2 + background.getBottomHeight() + bounds.height / 2);
            } else {
                y += (int)(height / 2 + bounds.height / 2);
            }
            int numGlyphs = font.computeVisibleGlyphs(string, 0, string.length(), width);
            font.setColor(fontColor.r, fontColor.g, fontColor.b, fontColor.a * parentAlpha);
            font.draw(batch, string, x, y, 0, numGlyphs);
        }
    }

    /** Get the set of selected items, useful when multiple items are selected
     * @return a Selection object containing the selected elements */
    public Selection<T> getSelection () {
        return selection;
    }

    /** Returns the first selected item, or null. For multiple selections use {@link SelectBox#getSelection()}. */
    public T getSelected () {
        return selection.first();
    }

    /** Sets the selection to only the passed item, if it is a possible choice, else selects the first item. */
    public void setSelected (T item) {
        if (items.contains(item, false))
            selection.set(item);
        else if (items.size > 0)
            selection.set(items.first());
        else
            selection.clear();
    }

    /** @return The index of the first selected item. The top item has an index of 0. Nothing selected has an index of -1. */
    public int getSelectedIndex () {
        ObjectSet<T> selected = selection.items();
        return selected.size == 0 ? -1 : items.indexOf(selected.first(), false);
    }

    /** Sets the selection to only the selected index. */
    public void setSelectedIndex (int index) {
        selection.set(items.get(index));
    }

    public void setDisabled (boolean disabled) {
        if (disabled && !this.disabled) hideList();
        this.disabled = disabled;
    }

    public float getPrefWidth () {
        validate();
        return prefWidth;
    }

    public float getPrefHeight () {
        validate();
        return prefHeight;
    }

    public void showList () {
        if (items.size == 0) return;
        selectBoxList.show(getStage());
    }

    public void hideList () {
        selectBoxList.hide();
    }

    /** Returns the list shown when the select box is open. */
    public ListOverflow<T> getList () {
        return selectBoxList.list;
    }

    /** Returns the scroll pane containing the list that is shown when the select box is open. */
    public ScrollPaneOverflow getScrollPane () {
        return selectBoxList;
    }

    protected void onShow (Actor selectBoxList, boolean below) {
        selectBoxList.getColor().a = 0;
        selectBoxList.addAction(fadeIn(0.3f, Interpolation.fade));
    }

    protected void onHide (Actor selectBoxList) {
        selectBoxList.getColor().a = 1;
        selectBoxList.addAction(sequence(fadeOut(0.15f, Interpolation.fade), removeActor()));
    }

    /** @author Nathan Sweet */
    static class SelectBoxList<T> extends ScrollPaneOverflow {
        private final SelectBoxOverflow<T> selectBox;
        int maxListCount;
        private final Vector2 screenPosition = new Vector2();

        //=========================//
        final ListOverflow<T> list;
        //=========================//

        private InputListener hideListener;
        private Actor previousScrollFocus;

        public SelectBoxList (final SelectBoxOverflow<T> selectBox) {
            super(null, selectBox.style.scrollStyle);
            this.selectBox = selectBox;

            setOverscroll(false, false);
            setFadeScrollBars(false);

            list = new ListOverflow<T>(selectBox.style.listStyle);
            list.setTouchable(Touchable.disabled);

            setWidget(list);

            list.addListener(new ClickListener() {
                public void clicked (InputEvent event, float x, float y) {
                    selectBox.selection.choose(list.getSelected());
                    hide();
                }

                public boolean mouseMoved (InputEvent event, float x, float y) {
                    list.setSelectedIndex(Math.min(selectBox.items.size - 1, (int)((list.getHeight() - y) / list.getItemHeight())));
                    return true;
                }
            });

            addListener(new InputListener() {
                public void exit (InputEvent event, float x, float y, int pointer, Actor toActor) {
                    if (toActor == null || !isAscendantOf(toActor)) list.getSelection().set(selectBox.getSelected());
                }
            });

            hideListener = new InputListener() {
                public boolean touchDown (InputEvent event, float x, float y, int pointer, int button) {
                    Actor target = event.getTarget();
                    if (isAscendantOf(target)) return false;
                    list.getSelection().set(selectBox.getSelected());
                    hide();
                    return false;
                }

                public boolean keyDown (InputEvent event, int keycode) {
                    if (keycode == Keys.ESCAPE) hide();
                    return false;
                }
            };
        }

        public void show (Stage stage) {
            if (list.isTouchable()) return;

            stage.removeCaptureListener(hideListener);
            stage.addCaptureListener(hideListener);
            stage.addActor(this);

            selectBox.localToStageCoordinates(screenPosition.set(0, 0));

            // Show the list above or below the select box, limited to a number of items and the available height in the stage.
            float itemHeight = list.getItemHeight();
            float height = itemHeight * (maxListCount <= 0 ? selectBox.items.size : Math.min(maxListCount, selectBox.items.size));
            Drawable scrollPaneBackground = getStyle().background;
            if (scrollPaneBackground != null)
                height += scrollPaneBackground.getTopHeight() + scrollPaneBackground.getBottomHeight();
            Drawable listBackground = list.getStyle().background;
            if (listBackground != null) height += listBackground.getTopHeight() + listBackground.getBottomHeight();

            float heightBelow = screenPosition.y;
            float heightAbove = stage.getCamera().viewportHeight - screenPosition.y - selectBox.getHeight();
            boolean below = true;
            if (height > heightBelow) {
                if (heightAbove > heightBelow) {
                    below = false;
                    height = Math.min(height, heightAbove);
                } else
                    height = heightBelow;
            }

            if (below)
                setY(screenPosition.y - height);
            else
                setY(screenPosition.y + selectBox.getHeight());
            setX(screenPosition.x);
            setSize(Math.max(getPrefWidth(), selectBox.getWidth()), height);

            //=====================================//
            list.widthForCenter(getWidth());
            //=====================================//

            validate();
            scrollToCenter(0, list.getHeight() - selectBox.getSelectedIndex() * itemHeight - itemHeight / 2, 0, 0);
            updateVisualScroll();

            previousScrollFocus = null;
            Actor actor = stage.getScrollFocus();
            if (actor != null && !actor.isDescendantOf(this)) previousScrollFocus = actor;
            stage.setScrollFocus(this);

            list.setTouchable(Touchable.enabled);
            clearActions();
            selectBox.onShow(this, below);
        }

        public void hide () {
            if (!list.isTouchable() || !hasParent()) return;
            list.setTouchable(Touchable.disabled);

            Stage stage = getStage();
            if (stage != null) {
                stage.removeCaptureListener(hideListener);
                if (previousScrollFocus != null && previousScrollFocus.getStage() == null) previousScrollFocus = null;
                Actor actor = stage.getScrollFocus();
                if (actor == null || isAscendantOf(actor)) stage.setScrollFocus(previousScrollFocus);
            }

            clearActions();
            selectBox.onHide(this);
        }

        public void draw (Batch batch, float parentAlpha) {
            selectBox.localToStageCoordinates(temp.set(0, 0));
            if (!temp.equals(screenPosition)) hide();
            super.draw(batch, parentAlpha);
        }

        public void act (float delta) {
            super.act(delta);
            toFront();
        }
    }

    /** The style for a select box, see {@link SelectBox}.
     * @author mzechner
     * @author Nathan Sweet */
    static public class SelectBoxStyle {
        public BitmapFont font;
        public Color fontColor = new Color(1, 1, 1, 1);
        /** Optional. */
        public Color disabledFontColor;
        /** Optional. */
        public Drawable background;

        //===============================//
        public ScrollPaneStyle scrollStyle;
        public ListStyle listStyle;
        //===============================//

        /** Optional. */
        public Drawable backgroundOver, backgroundOpen, backgroundDisabled;

        public SelectBoxStyle () {
        }

        public SelectBoxStyle (BitmapFont font, Color fontColor, Drawable background, ScrollPaneStyle scrollStyle,
                ListStyle listStyle) {
            this.font = font;
            this.fontColor.set(fontColor);
            this.background = background;
            this.scrollStyle = scrollStyle;
            this.listStyle = listStyle;
        }

        public SelectBoxStyle (SelectBoxStyle style) {
            this.font = style.font;
            this.fontColor.set(style.fontColor);
            if (style.disabledFontColor != null) this.disabledFontColor = new Color(style.disabledFontColor);
            this.background = style.background;
            this.backgroundOver = style.backgroundOver;
            this.backgroundOpen = style.backgroundOpen;
            this.backgroundDisabled = style.backgroundDisabled;
            this.scrollStyle = new ScrollPaneStyle(style.scrollStyle);
            this.listStyle = new ListStyle(style.listStyle);
        }
    }

}

2类SelectBoxOverflow

3类ListOverflow

编辑我无法发布其他课程，因为Exed最大甚至可以删除重要内容，如果有人知道该怎么做，我想如果你这样做了几天我就不会让这个回复＃39 ;有兴趣我发送课程