Blackberry - Taille personnalisée EditField

voix
1

Je suis en train de mettre en place un dialogue qui devrait ressembler à ceci:

Remplissez les champs ci - dessous
_______________ likes ____________________

où les lignes « _ » sont les EditFields.

Je tous les champs en tiens dans un HorizontalFieldManager, que j'ajouter à la boîte de dialogue. Malheureusement, le premier EditField consomme tout l'espace sur la première ligne. J'ai essayé de remplacer la méthode getPreferredWidth () du EditField en créant ma propre classe étendant BasicEditField, mais ai pas eu de succès.

Certes, il doit y avoir un moyen simple de forcer une certaine taille pour un champ d'édition. Qu'est-ce que je rate?

Créé 27/08/2009 à 04:13
source utilisateur
Dans d'autres langues...                            


3 réponses

voix
5

Tout comme DaveJohnston dit:

class LikesHFManager extends HorizontalFieldManager {
    EditField mEditFieldLeft;
    LabelField mLabelField;
    EditField mEditFieldRight;
    String STR_LIKES = "likes";
    int mLabelWidth = 0;
    int mEditWidth = 0;
    int mOffset = 4;

    public LikesHFManager() {
        mEditFieldLeft = new EditField();
        mLabelField = new LabelField(STR_LIKES);
        mEditFieldRight = new EditField();

        mLabelWidth = mLabelField.getFont().getAdvance(STR_LIKES);
        int screenWidth = Display.getWidth();
        mEditWidth = (screenWidth - mLabelWidth) >> 1;
        mEditWidth -= 2 * mOffset;

        // calculate max with of one character
        int chMaxWith = mEditFieldLeft.getFont().getAdvance("W");
        // calculate max count of characters in edit field
        int chMaxCnt = mEditWidth / chMaxWith;

        mEditFieldLeft.setMaxSize(chMaxCnt);
        mEditFieldRight.setMaxSize(chMaxCnt);

        add(mEditFieldLeft);
        add(mLabelField);
        add(mEditFieldRight);
    }

    protected void sublayout(int maxWidth, int maxHeight) {

        int x = 0;
        int y = 0;

        int editHeight = mEditFieldLeft.getPreferredHeight();
        int labelHeight = mLabelField.getPreferredHeight();

        setPositionChild(mEditFieldLeft, x, y);
        layoutChild(mEditFieldLeft, mEditWidth, editHeight);
        x += mEditWidth;
        x += mOffset;

        setPositionChild(mLabelField, x, y);
        layoutChild(mLabelField, mLabelWidth, labelHeight);
        x += mLabelWidth;
        x += mOffset;

        setPositionChild(mEditFieldRight, x, y);
        layoutChild(mEditFieldRight, mEditWidth, editHeight);
        x += mEditWidth;

        setExtent(x, Math.max(labelHeight, editHeight));
    }
}
Créé 30/08/2009 à 07:38
source utilisateur

voix
4

Essayez HorizontalFieldManager sous-classement et remplacer la méthode sublayout:

protected void sublayout(int maxWidth, int maxHeight) { }

Dans cette méthode, vous devez appeler setPositionChild () et layoutChild () pour chaque composant que vous ajoutez afin que vous puissiez contrôler le positionnement et la taille de chacun.

Vous devez également remplacer la méthode de mise en page de chaque composant et appel

setExtent(getPreferredWidth(), getPreferredHeight()); 

cela fera usage de votre mise en œuvre des méthodes getPreferred ... vous avez déjà écrit.

J'espère que cela t'aides.

Créé 27/08/2009 à 16:11
source utilisateur

voix
0

S'appuyant sur la solution de Max Gontar, ce qui devrait résoudre le problème général d'attribuer une largeur aux sous champs de HorizontalFieldManagers:

import net.rim.device.api.ui.container.*;
import net.rim.device.api.ui.*;

public class FieldRowManager extends HorizontalFieldManager {
    public FieldRowManager(final long style)
    {
        super(style);
    }
    public FieldRowManager()
    {
        this(0);
    }

    private SubField FirstSubField = null;
    private SubField LastSubField = null;
    private static class SubField
    {
        public final Field Field;
        public final int Width;
        public final int Offset;
        private SubField Next;
        public SubField(final FieldRowManager container, final Field field, final int width, final int offset)
        {
            Field = field;
            Width = width;
            Offset = offset;

            if (container.LastSubField == null)
            {
                container.FirstSubField = this;
            }
            else
            {
                container.LastSubField.Next = this;
            }
            container.LastSubField = this;
        }
        public SubField getNext()
        {
            return Next;
        }
    }

    public void add(final Field field)
    {
        add(field, field.getPreferredWidth());
    }
    public void add(final Field field, final int width)
    {
        add(field, width, 0);
    }
    public void add(final Field field, final int width, final int offset)
    {
        new SubField(this, field, width, offset);
        super.add(field);
    }

    protected void sublayout(final int maxWidth, final int maxHeight)
    {
        int x = 0;
        int height = 0;
        SubField subField = FirstSubField;
        while (subField != null)
        {
            final Field field = subField.Field;
            final int fieldHeight = field.getPreferredHeight();
            this.setPositionChild(field, x, 0);
            this.layoutChild(field, subField.Width, fieldHeight);
            x += subField.Width+subField.Offset;
            if (fieldHeight > height)
            {
                height = fieldHeight;
            }

            subField = subField.getNext();
        }
        this.setExtent(x, height);
    }
}

Il suffit d'appeler les surcharges de la méthode d'ajout pour préciser la largeur et l'espace de décalage avant le prochain champ. Bien que cela ne permet pas de supprimer / remplacer les champs.

Il est que RIM ne gênant fournit pas cette fonctionnalité dans la bibliothèque standard. HorizontalFieldManager doit simplement fonctionner de cette façon.

Créé 19/03/2010 à 20:27
source utilisateur

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more