Editfield Tamanho personalizado - Blackberry

votos
1

Eu estou tentando montar um diálogo que deve ser semelhante a este:

Preencha os campos abaixo
_______________ gosta ____________________

onde os _ linhas são a EditFields.

Eu estou furando todos os campos em um HorizontalFieldManager, que eu adicionar ao diálogo. Infelizmente, o primeiro editfield consome todo o espaço na primeira linha. Eu tentei substituir o método getPreferredWidth () do editfield criando minha própria classe estendendo BasicEditField, mas não tiveram sucesso.

Certamente deve haver uma maneira simples para forçar um determinado tamanho de um campo de edição. o que estou perdendo?

Publicado 27/08/2009 em 04:13
fonte usuário
Em outras línguas...                            


3 respostas

votos
5

Assim como DaveJohnston disse:

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));
    }
}
Respondeu 30/08/2009 em 07:38
fonte usuário

votos
4

Tente subclasse HorizontalFieldManager e substituir o método sublayout:

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

Neste método, você deve chamar setPositionChild () e layoutChild () para cada componente que você está adicionando assim você pode controlar o posicionamento e tamanho de cada um.

Você também deve substituir o método de layout de cada componente e chamada

setExtent(getPreferredWidth(), getPreferredHeight()); 

isso vai fazer uso de sua implementação das getPreferred ... métodos que você já tenha escrito.

Espero que isto ajude.

Respondeu 27/08/2009 em 16:11
fonte usuário

votos
0

Com base na solução de Max Gontar, isso deve resolver o problema geral de atribuição de largura de sub Fields of 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);
    }
}

Basta ligar as sobrecargas do método add para especificar a largura, eo espaço compensado antes do próximo campo. Embora este não permite apagar / substituir Fields.

É irritante que a RIM não fornece essa funcionalidade na biblioteca padrão. HorizontalFieldManager deve apenas trabalhar desta forma.

Respondeu 19/03/2010 em 20:27
fonte usuário

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