Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Center SelectBox text in libgdx using scene2d

I have the following 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);

By default the text is left aligned (Slow, Medium, Fast, Fastest). How do I center the text?

like image 837
joshmmo Avatar asked Aug 02 '14 04:08

joshmmo


1 Answers

I think this may help you, I can not test much, because I did this afternoon, you can test without having to compile the library, you just have to be careful when you import some classes because the same name, changes eh fact are within simbol: //=============================// or are things to consider with import class.

this is resesult : enter image description here

1 class 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 class SelectBoxOverflow

3 class ListOverflow

Edit I can not post the other classes because Exed the maximum even erasing the impor, if anyone knows how to do, I think if I will not let this response a few days if you're interested I send Classes

like image 75
Angel Angel Avatar answered Oct 06 '22 02:10

Angel Angel