eclipse - vanimir - Problemas de diseño en FieldEditorPreferencePage

guardian of elrianode title (4)

Tengo los siguientes problemas con la configuración de diseño en FieldEditorPreferencePage.
Mi código es algo como esto:

public void createFieldEditors () { Group pv = new group(getfieldEditorParent(), SWT.SHADOW_OUT); Group of = new group(getfieldEditorParent(), SWT.SHADOW_OUT); pv.setText(“pv”); of.setText(“of”); GridLayout layout = new GridLayout(2,false); pv.setLayout(layout); of.setLayout(layout); addField(new StringFieldEditor(“PreferenceStore name”,“Text:”, pv); addField(new StringFieldEditor(“PreferenceStore name”,“Text:”, pv); addField(new StringFieldEditor(“PreferenceStore name”,“Text:”, of); addField(new StringFieldEditor(“PreferenceStore name”,“Text:”, of); and so on. }

El problema es que no funciona con GridLayout.
Los StringFieldEditors no son paralelos. El número de columnas siempre es 1. Además, cuando trato de cambiar el tamaño de StringFieldEditors en los grupos, tampoco funciona.

¿Alguien tiene ideas?
Gracias.

Dos cosas para entender sobre FieldEditorPreferencePage (con estilo GRID ):

El diseño de los padres del editor de campo siempre se establece en GridLayout incluso para componentes "personalizados" como Groups ;
El número de columnas en el diseño se ajusta de acuerdo con la cantidad máxima de componentes en cualquiera de los editores de campo (que es 2 en el caso de StringFieldEditor) .

En el ejemplo anterior, los datos de diseño de los Groups deberían tener esto en cuenta:

GridDataFactory.defaultsFor(pv).grab(true, false).span(2, 1).applyTo(pv); GridDataFactory.defaultsFor(of).grab(true, false).span(2, 1).applyTo(of);

Implemento el Group-FieldEditor que puede contener otros FieldEditors y distribuirlos como un grupo.

import java.util.Collection; import org.eclipse.jface.preference.FieldEditor; import org.eclipse.jface.preference.FieldEditorPreferencePage; import org.eclipse.jface.preference.IPreferenceStore; import org.eclipse.swt.SWT; import org.eclipse.swt.layout.FillLayout; import org.eclipse.swt.layout.GridLayout; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Group; /** * Class is intended to create a Group Widgets, inside of the {@link FieldEditorPreferencePage} * objects. * This class should be used as following: *


 * use the {@link #getFieldEditorParent()} to as a parent, while creating new Field Editors.
 * 
use {@link #setFieldEditors(Collection)} to add the collection of FieldEditors to the
 * {@link GroupFieldEditor}.
 *


 *
 * @author alf
 *
 */
public class GroupFieldEditor extends FieldEditor {

    private String name;
    private Collection members;
    private int numcolumns;
    private Group group;
    private Composite parent;


    /**
     * The gap outside, between the group-frame and the widgets around the group
     */
    private static final int GROUP_PADDING = 5; // px

    /**
     * The gap inside, between the group-frame and the content
     */
    private static final int GROUP_VERTICAL_MARGIN = 5; // px



    /**
     * The inside-distance creates a new boolean field editor
     */
    protected GroupFieldEditor() {
    }

    /**
     * Creates a Group of {@link FieldEditor} objects
     *
     * @param name
     *            - name
     * @param fieldEditorParent
     *            - parent
     */
    public GroupFieldEditor(String name, Composite fieldEditorParent) {
        this.name = name;

        // the parent is a Composite, which is contained inside of the preference page. Initially it
        // does not have any layout.
        this.parent = fieldEditorParent;
        FillLayout fillLayout = new FillLayout();
        fillLayout.marginHeight = GROUP_VERTICAL_MARGIN;
        this.parent.setLayout(fillLayout);

        this.group = new Group(parent, SWT.DEFAULT);
        this.group.setText(this.name);
    }

    /**
     * The parent for all the FieldEditors inside of this Group.
     *
     * @return - the parent
     */
    public Composite getFieldEditorParent() {
        return group;
    }

    /**
     * Sets the FieldeditorChildren for this {@link GroupFieldEditor}
     * 
     * @param membersParam
     */
    public void setFieldEditors(Collection membersParam) {
        this.members = membersParam;
        doFillIntoGrid(getFieldEditorParent(), numcolumns);
    }

    /*
     * (non-Javadoc) Method declared on FieldEditor.
     */
    @Override
    protected void adjustForNumColumns(int numColumns) {
        this.numcolumns = numColumns;
    }

    /*
     * (non-Javadoc) Method declared on FieldEditor.
     */
    @Override
    protected void doFillIntoGrid(Composite parentParam, int numColumns) {

        GridLayout gridLayout = new GridLayout();
        gridLayout.marginLeft = GROUP_PADDING;
        gridLayout.marginRight = GROUP_PADDING;
        gridLayout.marginTop = GROUP_PADDING;
        gridLayout.marginBottom = GROUP_PADDING;
        this.group.setLayout(gridLayout);

        this.parent.layout();
        this.parent.redraw();

        if (members != null) {
            for (FieldEditor editor : members) {
                editor.fillIntoGrid(getFieldEditorParent(), 1);
            }
        }
    }


    /*
     * (non-Javadoc) Method declared on FieldEditor. Loads the value from the
     * preference store and sets it to the check box.
     */
    @Override
    protected void doLoad() {
        if (members != null) {
            for (FieldEditor editor : members) {
                editor.load();
            }
        }
    }

    /*
     * (non-Javadoc) Method declared on FieldEditor. Loads the default value
     * from the preference store and sets it to the check box.
     */
    @Override
    protected void doLoadDefault() {
        if (members != null) {
            for (FieldEditor editor : members) {
                editor.loadDefault();
            }
        }
    }


    /*
     * (non-Javadoc) Method declared on FieldEditor.
     */
    @Override
    protected void doStore() {
        if (members != null) {
            for (FieldEditor editor : members) {
                editor.store();
            }
        }
    }

    @Override
    public void store() {
        super.store();
        doStore();
    }



    /*
     * (non-Javadoc) Method declared on FieldEditor.
     */
    @Override
    public int getNumberOfControls() {
        return 1;
    }

    /*
     * (non-Javadoc) Method declared on FieldEditor.
     */
    @Override
    public void setFocus() {
        if (members != null && !members.isEmpty()) {
            members.iterator().next().setFocus();
        }
    }


    /*
     * @see FieldEditor.setEnabled
     */
    @Override
    public void setEnabled(boolean enabled, Composite parentParam) {
        if (members != null) {
            for (FieldEditor editor : members) {
                editor.setEnabled(enabled, parentParam);
            }
        }
    }

    @Override
    public void setPreferenceStore(IPreferenceStore store) {
        super.setPreferenceStore(store);
        if (members != null) {
            for (FieldEditor editor : members) {
                editor.setPreferenceStore(store);
            }
        }
    }


}

Otra solución (fácil): también puede crear nuevos Composites para crear más columnas. El problema es que estos FieldEditors se comunican con sus padres y estropean su diseño. Por lo tanto, al crear un compuesto "vacío", pueden comunicarse tanto como quieran :)

someGroup = new Group(..., SWT.NONE); someGroup .setLayout(new GridLayout(16, false)); Composite myC1= new Composite(someGroup,SWT.NONE); addField(new BooleanFieldEditor(...,C1); Composite myC2= new Composite(someGroup,SWT.NONE); addField(new BooleanFieldEditor(...,C2);

El problema es que cuando usa FieldEditorPreferencePage , puede usar solo FieldEditor subclases de FieldEditor como componentes. Aquí hay un fragmento de una documentación:

FieldEditorPreferencePage implementa una página que utiliza estos editores de campo para mostrar y almacenar los valores de preferencia en la página. En lugar de crear controles SWT para llenar sus contenidos, una subclase FieldEditorPreferencePage crea editores de campo para mostrar los contenidos. Todos los campos de la página deben implementarse como editores de campo .

Eso significa que tiene dos opciones para lograr lo que quiere:

Implemente su propia subclase de FieldEditor , que representaría el widget de Grupo.
No extienda FieldEditorPreferencePage , sino solo una página de PreferencePage lugar. Luego debe implementar el método createContents lugar de createFieldEditors . También deberá administrar la carga y el guardado de las propiedades.

Creo que la segunda forma podría ser más fácil si quieres proporcionar un diseño complejo. Puede encontrar más información aquí