org.eclipse.jface.preference.FieldEditor Java Examples

/**
 * @return a new field editor for the user name
 */
private FieldEditor createUserFieldEditor() {
	return new CheckedStringFieldEditor(USER_ID, //
			Messages.WorkbenchPreferencePage_UserId, //
			getFieldEditorParent(), //
			Messages.WorkbenchPreferencePage_Validate_InvalidUserId) {

		/**
		 * {@inheritDoc}
		 */
		@Override
		protected boolean check() {
			return StringUtils.isNotEmpty(getTextControl().getText());
		}

	};
}
 

/**  
 * The field editor preference page implementation of a <code>PreferencePage</code>
 * method loads all the field editors with their default values.
 */
protected void performDefaults()
{
    if (fields != null)
    {
        Iterator e = fields.iterator();
        while (e.hasNext())
        {
            FieldEditor pe = (FieldEditor) e.next();
            pe.loadDefault();
        }
    }
    // Force a recalculation of my error state.
    checkState();
    super.performDefaults();
}
 

/**
 * The field editor preference page implementation of this <code>IPreferencePage</code>
 * (and <code>IPropertyChangeListener</code>) method intercepts <code>IS_VALID</code> 
 * events but passes other events on to its superclass.
 */
public void propertyChange(PropertyChangeEvent event)
{

    if (event.getProperty().equals(FieldEditor.IS_VALID))
    {
        boolean newValue = ((Boolean) event.getNewValue()).booleanValue();
        // If the new value is true then we must check all field editors.
        // If it is false, then the page is invalid in any case.
        if (newValue)
        {
            checkState();
        } else
        {
            setInvalidFieldEditor((FieldEditor) event.getSource());
            setValid(newValue);
        }
    }
}
 

protected void addField(final FieldEditor editor, Composite parent, IPreferenceStore preferenceStore) {
    fields.add(editor);

    editor.setPreferenceStore(preferenceStore);
    editor.load();
    editor.setPropertyChangeListener(new IPropertyChangeListener() {

        @Override
        public void propertyChange(PropertyChangeEvent event) {
            // Apply on any change!
            editor.store();
        }
    });
    if (editor instanceof BooleanFieldEditorCustom) {
        editor.fillIntoGrid(parent, 2);
    } else {
        editor.fillIntoGrid(parent, 1);
    }
}
 

/**
 * Recomputes the page's error state by calling <code>isValid</code> for
 * every field editor.
 */
protected void checkState()
{
    boolean valid = true;
    setInvalidFieldEditor(null);
    // The state can only be set to true if all
    // field editors contain a valid value. So we must check them all
    if (fields != null)
    {
        int size = fields.size();
        for (int i = 0; i < size; i++)
        {
            FieldEditor editor = (FieldEditor) fields.get(i);
            valid = valid && editor.isValid();
            if (!valid)
            {
                setInvalidFieldEditor(editor);
                break;
            }
        }
    }
    setValid(valid);
}
 

/**
 * Saves the 'use project settings' as a preference in the store using the
 * {@link #useProjectSettingsPreferenceName()} as the key. If not project specific, all affected keys are removed
 * from the project preferences.
 */
private void saveUseProjectSettings(boolean isProjectSpecific) throws IOException {
	final FixedScopedPreferenceStore store = (FixedScopedPreferenceStore) getPreferenceStore();
	if (!isProjectSpecific) {
		// remove all the keys (written by various field editors)
		IEclipsePreferences storePreferences = store.getStorePreferences();
		for (FieldEditor field : editors) {
			storePreferences.remove(field.getPreferenceName());
		}
		// Also remove the master key (i.e. use default/default == false when later reading).
		storePreferences.remove(useProjectSettingsPreferenceName());
	} else {
		store.setValue(useProjectSettingsPreferenceName(), Boolean.toString(isProjectSpecific));
	}
	store.save();
}
 

/**
 * Recomputes the page's error state by calling <code>isValid</code> for every field editor.
 */
protected void checkState() {
    boolean valid = true;
    m_invalidFieldEditor = null;
    // The state can only be set to true if all
    // field editors contain a valid value. So we must check them all
    if (m_fields != null) {
        int size = m_fields.size();
        for (int i = 0; i < size; i++) {
            FieldEditor editor = m_fields.get(i);
            valid = valid && editor.isValid();
            if (!valid) {
                m_invalidFieldEditor = editor;
                break;
            }
        }
    }
    setValid(true);
}
 

@Override
public void propertyChange(PropertyChangeEvent event) {
    super.propertyChange(event);

    if (event.getProperty().equals(FieldEditor.VALUE)) {

        if (event.getSource() == getCacheHashCodeField()) {
            getHashCodeCachingField().setEnabled(getCacheHashCodeField().getBooleanValue(), getFieldEditorParent());

        } else if (event.getSource() == getCacheToStringField()) {
            getToStringCachingField().setEnabled(getCacheToStringField().getBooleanValue(), getFieldEditorParent());

        } else
            if (event.getSource() == getHashCodeCachingField() || event.getSource() == getToStringCachingField()) {
            checkState();
        }
    }
}
 

@Override
protected void createFieldEditors ()
{
    final List<String> tzs = Arrays.asList ( TimeZone.getAvailableIDs () );
    Collections.sort ( tzs );
    final String[][] entries = new String[tzs.size ()][2];
    int i = 0;
    for ( final String id : tzs )
    {
        entries[i][0] = id;
        entries[i][1] = id;
        i += 1;
    }
    final FieldEditor field = new ComboFieldEditor ( "timeZone", Messages.TimeZonePreferencePage_TimeZone_Label, entries, getFieldEditorParent () ); //$NON-NLS-1$
    addField ( field );
}
 

/**
 * @return a new field editor for the window size
 */
private FieldEditor createWindowSizeFieldEditor() {
	return new CheckedStringFieldEditor(WINDOW_SIZE, //
			Messages.WorkbenchPreferencePage_WindowSize, //
			getFieldEditorParent(), //
			Messages.WorkbenchPreferencePage_Validate_WindowLocationSizeWrongFormat) {

		/**
		 * Checks the format defines coordinates, e.g. 120,160 or 200,350.
		 * 
		 * {@inheritDoc}
		 */
		@Override
		protected boolean check() {
			return getTextControl().getText().matches("^-?\\d+,-?\\d+$"); //$NON-NLS-1$
		}

	};
}
 

/**
 * @return a new field editor for the window location
 */
private FieldEditor createWindowLocationFieldEditor() {
	return new CheckedStringFieldEditor(WINDOW_LOCATION, //
			Messages.WorkbenchPreferencePage_WindowLocation, //
			getFieldEditorParent(), //
			Messages.WorkbenchPreferencePage_Validate_WindowLocationSizeWrongFormat) {

		/**
		 * Checks the format defines coordinates, e.g. 120,160 or 200,350.
		 * 
		 * {@inheritDoc}
		 */
		@Override
		protected boolean check() {
			return getTextControl().getText().matches("^-?\\d+,-?\\d+$"); //$NON-NLS-1$
		}

	};
}
 

@Override
public Control createContents(Composite parent) {
  Composite container = new Composite(parent, SWT.NONE);
  parent.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
  fieldEditor = createFieldEditor(container);
  fieldEditor.setPage(messages);
  fieldEditor.setPropertyChangeListener(new IPropertyChangeListener() {
    @Override
    public void propertyChange(PropertyChangeEvent event) {
      if (FieldEditor.IS_VALID.equals(event.getProperty())) {
        fireValueChanged(IS_VALID, event.getOldValue(), event.getNewValue());
      } else if (FieldEditor.VALUE.equals(event.getProperty())) {
        fireValueChanged(VALUE, event.getOldValue(), event.getNewValue());
      }
    }
  });
  fieldEditor.setPreferenceStore(getPreferenceStore());
  fieldEditor.load();
  fieldEditor.fillIntoGrid(container, fieldEditor.getNumberOfControls());
  return container;
}
 

/**
 * The field editor preference page implementation of this <code>PreferencePage</code> method saves all field
 * editors by calling <code>FieldEditor.store</code>. Note that this method does not save the preference store
 * itself; it just stores the values back into the preference store.
 *
 * @see FieldEditor#store()
 */
@Override
public boolean performOk() {
    if (m_fields != null) {
        Iterator<FieldEditor> I = m_fields.iterator();
        while (I.hasNext()) {
            FieldEditor editor = I.next();
            editor.store();
        }
    }
    return true;
}
 

public boolean hasLocaleProperties( )
{
	if ( !firstCheck )
	{
		firstCheck = true;
		String[] fields = getPreferenceNames( );
		if ( fields != null )
		{
			for ( int i = 0; i < fields.length; i++ )
			{
				if ( getPreferenceStore( ) instanceof StylePreferenceStore )
				{
					StylePreferenceStore store = (StylePreferenceStore) getPreferenceStore( );
					if ( store.hasLocalValue( fields[i] ) )
					{
						hasLocaleProperty = true;
						return true;
					}
				}
			}
		}
	}
	else
	{
		if ( fields != null )
		{
			for ( int i = 0; i < fields.size( ); i++ )
			{
				FieldEditor editor = (FieldEditor) fields.get( i );
				if ( editor instanceof AbstractFieldEditor )
				{
					if ( ( (AbstractFieldEditor) editor ).hasLocaleValue( ) )
						return true;
				}
			}
			return false;
		}
	}
	return hasLocaleProperty;
}
 

protected void createPreferenceEditorContributions(final String contributorId) {
    final List<IPreferenceFieldEditorContribution> prefEditorContributions = getFieldEditorContibutions();
    for (final IPreferenceFieldEditorContribution prefEditorContrib : prefEditorContributions) {
        if (prefEditorContrib.appliesTo(contributorId)) {
            addContribution(prefEditorContrib);
            for (final FieldEditor fe : prefEditorContrib.createFieldEditors(getFieldEditorParent())) {
                addField(fe);
                contributedEditors.put(fe, fe.getPreferenceStore());
            }
        }
    }
}
 

@Override
protected void initialize() {
    super.initialize();
    for (final Entry<FieldEditor, IPreferenceStore> pe : getContributedEditors().entrySet()) {
        if (pe.getValue() != null) {
            pe.getKey().setPreferenceStore(pe.getValue());
            pe.getKey().load();
        }
    }
}
 

@Test
public void should_initialize_load_editor_preference_store() throws Exception {
    final Map<FieldEditor, IPreferenceStore> contributedEditor = mapOfContributedEditors(aFieldEditor);
    when(preferencePage.getContributedEditors()).thenReturn(contributedEditor);
    doCallRealMethod().when(preferencePage).initialize();
    preferencePage.initialize();

    verify(contributedEditor.keySet().iterator().next()).setPreferenceStore(contributedEditor.values().iterator().next());
    verify(contributedEditor.keySet().iterator().next()).load();
}
 

private Map<FieldEditor, IPreferenceStore> mapOfContributedEditors(final FieldEditor... editors) {
    final Map<FieldEditor, IPreferenceStore> contribuedEditors = new HashMap<FieldEditor, IPreferenceStore>();
    for (final FieldEditor editor : editors) {
        contribuedEditors.put(editor, mock(IPreferenceStore.class));
    }
    return contribuedEditors;
}
 

public List<FieldEditor> createFieldEditors(Composite parent) {
	editors = new ArrayList<FieldEditor>();
	
	//addRulerFields( parent );
	addGridFields( parent );

	return editors;
}
 

/**
 * {@inheritDoc}
 */
@Override
protected void createFieldEditors() {
	/*
	 * The following field may be required if GIT repositories should not be created
	 * automatically, as they are provided by a central shared directory, where many
	 * developers use these repositories for GIT merge.
	 */
	final Path gitRepositories = Paths
			.get(Activator.getDefault().getPreferenceStore().getString(GIT_REPOSITORIES_FOLDER));
	if (!gitRepositories.toFile().exists()) {
		try {
			Files.createDirectories(gitRepositories);
		} catch (IOException e) {
			Logger.getLogger(GitRepositoriesPreferencePage.class.getName()).log(Level.SEVERE, e.getMessage(), e);
		}
	}
	final DirectoryFieldEditor repositoryFolderEditor = new DirectoryFieldEditor(GIT_REPOSITORIES_FOLDER,
			Messages.GitRepositoriesPreferencePage_title, getFieldEditorParent()) {

		/**
		 * {@inheritDoc}
		 */
		@Override
		protected void fireValueChanged(String property, Object oldValue, Object newValue) {
			super.fireValueChanged(property, oldValue, newValue);
			if (FieldEditor.VALUE.equals(property) && !Objects.equals(oldValue, newValue)) {
				tableViewer.setInput(getGitRepositoryPaths(newValue.toString()));
			}
		}

	};
	addField(repositoryFolderEditor);
}
 

@Override
public List<FieldEditor> createFieldEditors(final Composite parent) {
    final List<FieldEditor> editors = new ArrayList<FieldEditor>();

    final BooleanFieldEditor dropOnExitFieldEditor = new BooleanFieldEditor(EnginePreferenceConstants.DROP_BUSINESS_DATA_DB_ON_EXIT_PREF,
            Messages.dropBusinessDataDBOnExit,
            BooleanFieldEditor.DEFAULT, parent);
    dropOnExitFieldEditor.setPreferenceStore(EnginePlugin.getDefault().getPreferenceStore());
    editors.add(dropOnExitFieldEditor);

    return editors;
}
 

@Override
public void propertyChange(PropertyChangeEvent event) {
	FieldEditor fe = (FieldEditor) event.getSource();
	if (PreferenceConstants.ENABLE_AUTOMATIC_UPDATES.equals(fe.getPreferenceName())) {
		boolean isAutomaticUpdateEnabled = (boolean) event.getNewValue();
		updateSiteURL.setEnabled(isAutomaticUpdateEnabled, enableDisableSet);
		releaseSiteURL.setEnabled(isAutomaticUpdateEnabled, enableDisableSet);
		updateInstallationRadioBttn.setEnabled(isAutomaticUpdateEnabled, enableDisableSet);
		updateSchedulingRadioBttn.setEnabled(isAutomaticUpdateEnabled, enableDisableSet);
		if (preferenceStore.getString(PreferenceConstants.UPDATE_RUNNING_CONFIGURATION)
				.equals(PreferenceConstants.SCHEDULE)) {
			intervalDayEditor.setEnabled(true, enableDisableSet);
			intervalTimeEditor.setEnabled(true, enableDisableSet);
		}

	} else if (PreferenceConstants.UPDATE_RUNNING_CONFIGURATION.equals(fe.getPreferenceName())) {
		String newPref = null;
		boolean isScheduler = false;
		if (event.getNewValue() != null && !((String) event.getNewValue()).isEmpty()) {
			newPref = (String) event.getNewValue();
		}
		if (PreferenceConstants.SCHEDULE.equals(newPref)) {
			isScheduler = true;
		}
		intervalDayEditor.setEnabled(isScheduler, enableDisableSet);
		intervalTimeEditor.setEnabled(isScheduler, enableDisableSet);
	} 
	super.propertyChange(event);
}
 

/**
 * The field editor preference page implementation of this <code>IPreferencePage</code> (and
 * <code>IPropertyChangeListener</code>) method intercepts <code>IS_VALID</code> events but passes other events on
 * to its superclass.
 */
@Override
public void propertyChange(PropertyChangeEvent event) {
    if (event.getProperty().equals(FieldEditor.IS_VALID)) {
        boolean newValue = ((Boolean) event.getNewValue()).booleanValue();
        // If the new value is true then we must check all field editors.
        // If it is false, then the page is invalid in any case.
        if (newValue) {
            checkState();
        } else {
            m_invalidFieldEditor = (FieldEditor) event.getSource();
            setValid(newValue);
        }
    }
}
 

@Override
protected void createFieldEditors() {
    Composite composite = new Composite(getFieldEditorParent(), SWT.NONE);

    GridLayoutFactory.fillDefaults() //
            .numColumns(2) //
            .margins(5, 8) //
            .spacing(5, 20) //
            .applyTo(composite);

    Group group = new Group(composite, SWT.SHADOW_ETCHED_IN);
    GridDataFactory.fillDefaults().span(2, 1).applyTo(group);

    group.setText("Allow JSON references in additional contexts");

    addField(new BooleanFieldEditor(VALIDATION_REF_SECURITY_DEFINITIONS_OBJECT, "Security Definitions Object",
            group));
    addField(new BooleanFieldEditor(VALIDATION_REF_SECURITY_SCHEME_OBJECT, "Security Scheme Object", group));
    addField(new BooleanFieldEditor(VALIDATION_REF_SECURITY_REQUIREMENTS_ARRAY, "Security Requirements Array",
            group));
    addField(new BooleanFieldEditor(VALIDATION_REF_SECURITY_REQUIREMENT_OBJECT, "Security Requirement Object",
            group));

    // FieldEditor set parent layout to GridLayout with margin = 0
    ((GridLayout) group.getLayout()).marginTop = 8;
    ((GridLayout) group.getLayout()).marginBottom = 8;
    ((GridLayout) group.getLayout()).marginLeft = 8;
    ((GridLayout) group.getLayout()).marginRight = 8;

    // Validation

    Set<PreferenceProvider> providers = ExtensionUtils.getPreferenceProviders(VALIDATION_PREFERENCE_PAGE);
    providers.forEach(provider -> {
        for (FieldEditor field : provider.createFields(Version.SWAGGER, composite)) {
            addField(field);
        }
    });
}
 

/**
 * The field editor preference page implementation of a <code>PreferencePage</code> method loads all the field
 * editors with their default values.
 */
@Override
protected void performDefaults() {
    if (m_fields != null) {
        Iterator<FieldEditor> I = m_fields.iterator();
        while (I.hasNext()) {
            FieldEditor editor = I.next();
            editor.loadDefault();
        }
    }
    // Force a recalculation of my error state.
    checkState();
    super.performDefaults();
}
 

@Override
public void propertyChange(PropertyChangeEvent event){
	super.propertyChange(event);
	if (event.getSource() instanceof FieldEditor) {
		FieldEditor fe = ((FieldEditor) event.getSource());
		if (Preferences.LABSETTINGS_CFG_LOCAL_REFVALUES.equals(fe.getPreferenceName())) {
			if (event.getNewValue().equals(Boolean.TRUE)) {
				MessageDialog.openInformation(UiDesk.getTopShell(),
					Messages.LabSettings_enableUseLocalLabRefValues_title,
					Messages.LabSettings_enableUseLocalLabRefValues_text);
			}
		}
	}
}
 

/**
 * Initializes all field editors.
 */
protected void initialize() {
    if (m_fields != null) {
        Iterator<FieldEditor> I = m_fields.iterator();
        while (I.hasNext()) {
            FieldEditor editor = I.next();
            editor.setPage(null);
            editor.setPropertyChangeListener(this);
            editor.setPreferenceStore(getPreferenceStore());
            editor.load();
        }
    }
}
 

/**
 * The field editor preference page implementation of an <code>IDialogPage</code> method disposes of this page's
 * controls and images. Subclasses may override to release their own allocated SWT resources, but must call
 * <code>super.dispose</code>.
 */
@Override
public void dispose() {
    super.dispose();
    if (m_fields != null) {
        Iterator<FieldEditor> I = m_fields.iterator();
        while (I.hasNext()) {
            FieldEditor editor = I.next();
            editor.setPage(null);
            editor.setPropertyChangeListener(null);
            editor.setPreferenceStore(null);
        }
    }
}
 

@Override
protected void createFieldEditors() {
    for (PluginPreference<?> pluginPreference : JeneratePreferences.getAllPreferences()) {
        FieldEditor fieldEditor = pluginPreference.createFieldEditor(getFieldEditorParent());
        fieldEditors.put(pluginPreference, fieldEditor);
        addField(fieldEditor);
    }
}
 

@Override
public FieldEditor createFieldEditor(Composite parent) {
    MethodContentStrategyIdentifier[] values = MethodContentStrategyIdentifier.values();
    String[][] comboValues = new String[values.length][2];
    for (int i = 0; i < values.length; i++) {
        comboValues[i] = new String[] { values[i].name(), values[i].name() };
    }
    return new ComboFieldEditor(this.getKey(), this.getDescription(), comboValues, parent);
}