| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| */ |
| |
| package org.apache.directory.studio.ldapbrowser.common.wizards; |
| |
| |
| import java.util.ArrayList; |
| import java.util.Comparator; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Map; |
| import java.util.SortedSet; |
| import java.util.TreeSet; |
| |
| import org.apache.directory.studio.common.ui.widgets.BaseWidgetUtils; |
| import org.eclipse.jface.wizard.WizardPage; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.ModifyEvent; |
| import org.eclipse.swt.events.ModifyListener; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.Combo; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Group; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.swt.widgets.Text; |
| |
| |
| /** |
| * The AttributeOptionsWizardPageprovides input elements for various options |
| * and a preview field. |
| * |
| * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a> |
| */ |
| public class AttributeOptionsWizardPage extends WizardPage |
| { |
| |
| /** The wizard. */ |
| private AttributeWizard wizard; |
| |
| /** The shell */ |
| private Shell shell; |
| |
| /** The possible languages. */ |
| private String[] possibleLanguages; |
| |
| /** The possible language to countries map. */ |
| private Map<String, String[]> possibleLangToCountriesMap; |
| |
| /** The parsed lang list. */ |
| private List<String> parsedLangList; |
| |
| /** The parsed option list. */ |
| private List<String> parsedOptionList; |
| |
| /** The parsed binary option. */ |
| private boolean parsedBinary; |
| |
| /** The language group. */ |
| private Group langGroup; |
| |
| /** The lang line list. */ |
| private ArrayList<LangLine> langLineList; |
| |
| /** The options group. */ |
| private Group optionsGroup; |
| |
| /** The option line list. */ |
| private ArrayList<OptionLine> optionLineList; |
| |
| /** The binary option button. */ |
| private Button binaryOptionButton; |
| |
| /** The preview text. */ |
| private Text previewText; |
| |
| |
| /** |
| * Creates a new instance of AttributeOptionsWizardPage. |
| * |
| * @param pageName the page name |
| * @param initialAttributeDescription the initial attribute description |
| * @param wizard the wizard |
| */ |
| public AttributeOptionsWizardPage( String pageName, String initialAttributeDescription, AttributeWizard wizard ) |
| { |
| super( pageName ); |
| super.setTitle( Messages.getString( "AttributeOptionsWizardPage.Options" ) ); //$NON-NLS-1$ |
| super.setDescription( Messages.getString( "AttributeOptionsWizardPage.OptionsDescription" ) ); //$NON-NLS-1$ |
| // super.setImageDescriptor(BrowserUIPlugin.getDefault().getImageDescriptor(BrowserUIConstants.IMG_ATTRIBUTE_WIZARD)); |
| super.setPageComplete( false ); |
| |
| this.wizard = wizard; |
| |
| // init possible languages and countries |
| SortedSet<String> languageSet = new TreeSet<String>(); |
| Map<String, SortedSet<String>> languageToCountrySetMap = new HashMap<String, SortedSet<String>>(); |
| Locale[] locales = Locale.getAvailableLocales(); |
| for ( int i = 0; i < locales.length; i++ ) |
| { |
| Locale locale = locales[i]; |
| languageSet.add( locale.getLanguage() ); |
| if ( !languageToCountrySetMap.containsKey( locale.getLanguage() ) ) |
| { |
| languageToCountrySetMap.put( locale.getLanguage(), new TreeSet<String>() ); |
| } |
| SortedSet<String> countrySet = languageToCountrySetMap.get( locale.getLanguage() ); |
| countrySet.add( locale.getCountry() ); |
| } |
| possibleLanguages = languageSet.toArray( new String[languageSet.size()] ); |
| possibleLangToCountriesMap = new HashMap<String, String[]>(); |
| for ( Iterator<String> it = languageToCountrySetMap.keySet().iterator(); it.hasNext(); ) |
| { |
| String language = it.next(); |
| SortedSet<String> countrySet = languageToCountrySetMap.get( language ); |
| String[] countries = countrySet.toArray( new String[countrySet.size()] ); |
| possibleLangToCountriesMap.put( language, countries ); |
| } |
| |
| // parse options |
| if ( initialAttributeDescription == null ) |
| { |
| initialAttributeDescription = ""; //$NON-NLS-1$ |
| } |
| String[] attributeDescriptionComponents = initialAttributeDescription.split( ";" ); //$NON-NLS-1$ |
| parsedLangList = new ArrayList<String>(); |
| parsedOptionList = new ArrayList<String>(); |
| parsedBinary = false; |
| for ( int i = 1; i < attributeDescriptionComponents.length; i++ ) |
| { |
| if ( attributeDescriptionComponents[i].startsWith( "lang-" ) ) //$NON-NLS-1$ |
| { |
| parsedLangList.add( attributeDescriptionComponents[i] ); |
| } |
| else if ( attributeDescriptionComponents[i].equals( "binary" ) ) //$NON-NLS-1$ |
| { |
| parsedBinary = true; |
| } |
| else |
| { |
| parsedOptionList.add( attributeDescriptionComponents[i] ); |
| } |
| } |
| } |
| |
| |
| /** |
| * Validates the options. |
| */ |
| private void validate() |
| { |
| previewText.setText( wizard.getAttributeDescription() ); |
| setPageComplete( true ); |
| } |
| |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public void setVisible( boolean visible ) |
| { |
| super.setVisible( visible ); |
| if ( visible ) |
| { |
| validate(); |
| } |
| } |
| |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public void createControl( Composite parent ) |
| { |
| shell = parent.getShell(); |
| |
| Composite composite = new Composite( parent, SWT.NONE ); |
| GridLayout gl = new GridLayout( 2, false ); |
| composite.setLayout( gl ); |
| composite.setLayoutData( new GridData( GridData.FILL_BOTH ) ); |
| |
| // Lang group |
| langGroup = BaseWidgetUtils.createGroup( composite, Messages |
| .getString( "AttributeOptionsWizardPage.LanguageTags" ), 2 ); //$NON-NLS-1$ |
| GridData gd = new GridData( GridData.FILL_HORIZONTAL ); |
| gd.horizontalSpan = 2; |
| langGroup.setLayoutData( gd ); |
| Composite langComposite = BaseWidgetUtils.createColumnContainer( langGroup, 6, 1 ); |
| langLineList = new ArrayList<LangLine>(); |
| |
| BaseWidgetUtils.createSpacer( composite, 2 ); |
| |
| // Options group with binary option |
| optionsGroup = BaseWidgetUtils.createGroup( composite, Messages |
| .getString( "AttributeOptionsWizardPage.OtherOptions" ), 2 ); //$NON-NLS-1$ |
| gd = new GridData( GridData.FILL_HORIZONTAL ); |
| gd.horizontalSpan = 2; |
| optionsGroup.setLayoutData( gd ); |
| Composite optionsComposite = BaseWidgetUtils.createColumnContainer( optionsGroup, 3, 1 ); |
| optionLineList = new ArrayList<OptionLine>(); |
| Composite binaryComposite = BaseWidgetUtils.createColumnContainer( optionsGroup, 1, 1 ); |
| binaryOptionButton = BaseWidgetUtils.createCheckbox( binaryComposite, Messages |
| .getString( "AttributeOptionsWizardPage.BinaryOption" ), 1 ); //$NON-NLS-1$ |
| binaryOptionButton.setSelection( parsedBinary ); |
| |
| Label la = new Label( composite, SWT.NONE ); |
| gd = new GridData( GridData.GRAB_VERTICAL ); |
| gd.horizontalSpan = 2; |
| la.setLayoutData( gd ); |
| |
| // Preview text |
| BaseWidgetUtils.createLabel( composite, Messages.getString( "AttributeOptionsWizardPage.Preview" ), 1 ); //$NON-NLS-1$ |
| previewText = BaseWidgetUtils.createReadonlyText( composite, "", 1 ); //$NON-NLS-1$ |
| |
| // fill lang |
| if ( parsedLangList.isEmpty() ) |
| { |
| addLangLine( langComposite, 0 ); |
| } |
| else |
| { |
| for ( int i = 0; i < parsedLangList.size(); i++ ) |
| { |
| addLangLine( langComposite, i ); |
| String l = parsedLangList.get( i ); |
| String[] ls = l.split( "-", 3 ); //$NON-NLS-1$ |
| if ( ls.length > 1 ) |
| { |
| langLineList.get( i ).languageCombo.setText( ls[1] ); |
| } |
| if ( ls.length > 2 ) |
| { |
| langLineList.get( i ).countryCombo.setText( ls[2] ); |
| } |
| } |
| } |
| |
| // fill options |
| if ( parsedOptionList.isEmpty() ) |
| { |
| addOptionLine( optionsComposite, 0 ); |
| } |
| else |
| { |
| for ( int i = 0; i < parsedOptionList.size(); i++ ) |
| { |
| addOptionLine( optionsComposite, i ); |
| optionLineList.get( i ).optionText.setText( parsedOptionList.get( i ) ); |
| } |
| } |
| |
| // binary listener |
| binaryOptionButton.addSelectionListener( new SelectionAdapter() |
| { |
| public void widgetSelected( SelectionEvent e ) |
| { |
| validate(); |
| } |
| } ); |
| |
| validate(); |
| |
| setControl( composite ); |
| } |
| |
| |
| /** |
| * Gets the attribute options. |
| * |
| * @return the attribute options |
| */ |
| String getAttributeOptions() |
| { |
| |
| if ( binaryOptionButton == null || binaryOptionButton.isDisposed() ) |
| { |
| return ""; //$NON-NLS-1$ |
| } |
| |
| // attribute type |
| StringBuffer sb = new StringBuffer(); |
| |
| // options |
| // sort and unique options |
| Comparator<String> comparator = new Comparator<String>() |
| { |
| public int compare( String s1, String s2 ) |
| { |
| if ( s1 == null || s2 == null ) |
| { |
| throw new ClassCastException( Messages.getString( "AttributeOptionsWizardPage.MustNotBeNull" ) ); //$NON-NLS-1$ |
| } |
| return s1.compareToIgnoreCase( s2 ); |
| } |
| }; |
| SortedSet<String> options = new TreeSet<String>( comparator ); |
| if ( binaryOptionButton.getSelection() ) |
| { |
| options.add( "binary" ); //$NON-NLS-1$ |
| } |
| for ( int i = 0; i < optionLineList.size(); i++ ) |
| { |
| OptionLine optionLine = optionLineList.get( i ); |
| if ( !"".equals( optionLine.optionText.getText() ) ) //$NON-NLS-1$ |
| { |
| options.add( optionLine.optionText.getText() ); |
| } |
| |
| if ( optionLineList.size() > 1 ) |
| { |
| optionLine.optionDeleteButton.setEnabled( true ); |
| } |
| else |
| { |
| optionLine.optionDeleteButton.setEnabled( false ); |
| } |
| } |
| for ( int i = 0; i < langLineList.size(); i++ ) |
| { |
| LangLine langLine = langLineList.get( i ); |
| String l = langLine.languageCombo.getText(); |
| String c = langLine.countryCombo.getText(); |
| |
| if ( !"".equals( l ) ) //$NON-NLS-1$ |
| { |
| String s = "lang-" + l; //$NON-NLS-1$ |
| if ( !"".equals( c ) ) //$NON-NLS-1$ |
| { |
| s += "-" + c; //$NON-NLS-1$ |
| } |
| options.add( s ); |
| } |
| |
| if ( langLineList.size() > 1 ) |
| { |
| langLine.deleteButton.setEnabled( true ); |
| } |
| else |
| { |
| langLine.deleteButton.setEnabled( false ); |
| } |
| } |
| |
| // append options |
| for ( Iterator<String> it = options.iterator(); it.hasNext(); ) |
| { |
| String option = it.next(); |
| sb.append( ';' ); |
| sb.append( option ); |
| } |
| |
| return sb.toString(); |
| } |
| |
| |
| /** |
| * Adds an option line at the given index. |
| * |
| * @param optionComposite the option composite |
| * @param index the index |
| */ |
| private void addOptionLine( Composite optionComposite, int index ) |
| { |
| OptionLine[] optionLines = optionLineList.toArray( new OptionLine[optionLineList.size()] ); |
| |
| if ( optionLines.length > 0 ) |
| { |
| for ( int i = 0; i < optionLines.length; i++ ) |
| { |
| OptionLine oldOptionLine = optionLines[i]; |
| |
| // remember values |
| String oldValue = oldOptionLine.optionText.getText(); |
| |
| // delete old |
| oldOptionLine.optionText.dispose(); |
| oldOptionLine.optionAddButton.dispose(); |
| oldOptionLine.optionDeleteButton.dispose(); |
| optionLineList.remove( oldOptionLine ); |
| |
| // add new |
| OptionLine newOptionLine = createOptionLine( optionComposite ); |
| optionLineList.add( newOptionLine ); |
| |
| // restore value |
| newOptionLine.optionText.setText( oldValue ); |
| |
| // check |
| if ( index == i + 1 ) |
| { |
| OptionLine optionLine = createOptionLine( optionComposite ); |
| optionLineList.add( optionLine ); |
| } |
| } |
| } |
| else |
| { |
| OptionLine optionLine = createOptionLine( optionComposite ); |
| optionLineList.add( optionLine ); |
| } |
| |
| shell.layout( true, true ); |
| } |
| |
| |
| /** |
| * Creates the option line. |
| * |
| * @param optionComposite the option composite |
| * |
| * @return the option line |
| */ |
| private OptionLine createOptionLine( final Composite optionComposite ) |
| { |
| OptionLine optionLine = new OptionLine(); |
| |
| optionLine.optionText = new Text( optionComposite, SWT.BORDER ); |
| GridData gd = new GridData( GridData.FILL_HORIZONTAL | GridData.GRAB_HORIZONTAL ); |
| optionLine.optionText.setLayoutData( gd ); |
| |
| optionLine.optionAddButton = new Button( optionComposite, SWT.PUSH ); |
| optionLine.optionAddButton.setText( " + " ); //$NON-NLS-1$ |
| optionLine.optionAddButton.addSelectionListener( new SelectionAdapter() |
| { |
| public void widgetSelected( SelectionEvent e ) |
| { |
| int index = optionLineList.size(); |
| for ( int i = 0; i < optionLineList.size(); i++ ) |
| { |
| OptionLine optionLine = optionLineList.get( i ); |
| if ( optionLine.optionAddButton == e.widget ) |
| { |
| index = i + 1; |
| } |
| } |
| |
| addOptionLine( optionComposite, index ); |
| |
| validate(); |
| } |
| } ); |
| |
| optionLine.optionDeleteButton = new Button( optionComposite, SWT.PUSH ); |
| optionLine.optionDeleteButton.setText( " \u2212 " ); //$NON-NLS-1$ |
| optionLine.optionDeleteButton.addSelectionListener( new SelectionAdapter() |
| { |
| public void widgetSelected( SelectionEvent e ) |
| { |
| int index = 0; |
| for ( int i = 0; i < optionLineList.size(); i++ ) |
| { |
| OptionLine optionLine = optionLineList.get( i ); |
| if ( optionLine.optionDeleteButton == e.widget ) |
| { |
| index = i; |
| } |
| } |
| |
| deleteOptionLine( optionComposite, index ); |
| |
| validate(); |
| } |
| } ); |
| |
| optionLine.optionText.addModifyListener( new ModifyListener() |
| { |
| public void modifyText( ModifyEvent e ) |
| { |
| validate(); |
| } |
| } ); |
| |
| return optionLine; |
| } |
| |
| |
| /** |
| * Deletes the option line at the given index. |
| * |
| * @param optionComposite the option composite |
| * @param index the index |
| */ |
| private void deleteOptionLine( Composite optionComposite, int index ) |
| { |
| OptionLine optionLine = optionLineList.remove( index ); |
| if ( optionLine != null ) |
| { |
| optionLine.optionText.dispose(); |
| optionLine.optionAddButton.dispose(); |
| optionLine.optionDeleteButton.dispose(); |
| |
| if ( !optionComposite.isDisposed() ) |
| { |
| shell.layout( true, true ); |
| } |
| } |
| } |
| |
| /** |
| * The class OptionLine is a wrapper for all input elements of an option. |
| * |
| * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a> |
| */ |
| public class OptionLine |
| { |
| /** The option text. */ |
| public Text optionText; |
| |
| /** The option add button. */ |
| public Button optionAddButton; |
| |
| /** The option delete button. */ |
| public Button optionDeleteButton; |
| } |
| |
| |
| /** |
| * Adds a language line at the given index. |
| * |
| * @param langComposite the language composite |
| * @param index the index |
| */ |
| private void addLangLine( Composite langComposite, int index ) |
| { |
| LangLine[] langLines = langLineList.toArray( new LangLine[langLineList.size()] ); |
| |
| if ( langLines.length > 0 ) |
| { |
| for ( int i = 0; i < langLines.length; i++ ) |
| { |
| LangLine oldLangLine = langLines[i]; |
| |
| // remember values |
| String oldLanguage = oldLangLine.languageCombo.getText(); |
| String oldCountry = oldLangLine.countryCombo.getText(); |
| |
| // delete old |
| oldLangLine.langLabel.dispose(); |
| oldLangLine.languageCombo.dispose(); |
| oldLangLine.minusLabel.dispose(); |
| oldLangLine.countryCombo.dispose(); |
| oldLangLine.addButton.dispose(); |
| oldLangLine.deleteButton.dispose(); |
| langLineList.remove( oldLangLine ); |
| |
| // add new |
| LangLine newLangLine = createLangLine( langComposite ); |
| langLineList.add( newLangLine ); |
| |
| // restore value |
| newLangLine.languageCombo.setText( oldLanguage ); |
| newLangLine.countryCombo.setText( oldCountry ); |
| |
| // check |
| if ( index == i + 1 ) |
| { |
| LangLine langLine = createLangLine( langComposite ); |
| langLineList.add( langLine ); |
| } |
| } |
| } |
| else |
| { |
| LangLine langLine = createLangLine( langComposite ); |
| langLineList.add( langLine ); |
| } |
| |
| shell.layout( true, true ); |
| } |
| |
| |
| /** |
| * Creates a language line. |
| * |
| * @param langComposite the language composite |
| * |
| * @return the language line |
| */ |
| private LangLine createLangLine( final Composite langComposite ) |
| { |
| final LangLine langLine = new LangLine(); |
| |
| langLine.langLabel = BaseWidgetUtils.createLabel( langComposite, "lang-", 1 ); //$NON-NLS-1$ |
| |
| langLine.languageCombo = BaseWidgetUtils.createCombo( langComposite, possibleLanguages, -1, 1 ); |
| |
| langLine.minusLabel = BaseWidgetUtils.createLabel( langComposite, "-", 1 ); //$NON-NLS-1$ |
| |
| langLine.countryCombo = BaseWidgetUtils.createCombo( langComposite, new String[0], -1, 1 ); |
| langLine.countryCombo.setEnabled( false ); |
| |
| langLine.addButton = new Button( langComposite, SWT.PUSH ); |
| langLine.addButton.setText( " + " ); //$NON-NLS-1$ |
| langLine.addButton.addSelectionListener( new SelectionAdapter() |
| { |
| public void widgetSelected( SelectionEvent e ) |
| { |
| int index = langLineList.size(); |
| for ( int i = 0; i < langLineList.size(); i++ ) |
| { |
| LangLine langLine = langLineList.get( i ); |
| if ( langLine.addButton == e.widget ) |
| { |
| index = i + 1; |
| } |
| } |
| |
| addLangLine( langComposite, index ); |
| |
| validate(); |
| } |
| } ); |
| |
| langLine.deleteButton = new Button( langComposite, SWT.PUSH ); |
| langLine.deleteButton.setText( " \u2212 " ); //$NON-NLS-1$ |
| langLine.deleteButton.addSelectionListener( new SelectionAdapter() |
| { |
| public void widgetSelected( SelectionEvent e ) |
| { |
| int index = 0; |
| for ( int i = 0; i < langLineList.size(); i++ ) |
| { |
| LangLine langLine = langLineList.get( i ); |
| if ( langLine.deleteButton == e.widget ) |
| { |
| index = i; |
| } |
| } |
| |
| deleteLangLine( langComposite, index ); |
| |
| validate(); |
| } |
| } ); |
| |
| langLine.languageCombo.addModifyListener( new ModifyListener() |
| { |
| public void modifyText( ModifyEvent e ) |
| { |
| if ( "".equals( langLine.languageCombo.getText() ) ) //$NON-NLS-1$ |
| { |
| langLine.countryCombo.setEnabled( false ); |
| } |
| else |
| { |
| langLine.countryCombo.setEnabled( true ); |
| String oldValue = langLine.countryCombo.getText(); |
| if ( possibleLangToCountriesMap.containsKey( langLine.languageCombo.getText() ) ) |
| { |
| langLine.countryCombo.setItems( possibleLangToCountriesMap.get( langLine.languageCombo |
| .getText() ) ); |
| } |
| else |
| { |
| langLine.countryCombo.setItems( new String[0] ); |
| } |
| langLine.countryCombo.setText( oldValue ); |
| } |
| validate(); |
| } |
| } ); |
| langLine.countryCombo.addModifyListener( new ModifyListener() |
| { |
| public void modifyText( ModifyEvent e ) |
| { |
| validate(); |
| } |
| } ); |
| |
| return langLine; |
| } |
| |
| |
| /** |
| * Deletes the language line at the given index. |
| * |
| * @param langComposite the language composite |
| * @param index the index |
| */ |
| private void deleteLangLine( Composite langComposite, int index ) |
| { |
| LangLine langLine = langLineList.remove( index ); |
| if ( langLine != null ) |
| { |
| langLine.langLabel.dispose(); |
| langLine.languageCombo.dispose(); |
| langLine.minusLabel.dispose(); |
| langLine.countryCombo.dispose(); |
| langLine.addButton.dispose(); |
| langLine.deleteButton.dispose(); |
| |
| if ( !langComposite.isDisposed() ) |
| { |
| shell.layout( true, true ); |
| } |
| } |
| } |
| |
| /** |
| * The class LangLine is a wrapper for all input elements of a language tag. |
| * |
| * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a> |
| */ |
| public class LangLine |
| { |
| |
| /** The lang label. */ |
| public Label langLabel; |
| |
| /** The language combo. */ |
| public Combo languageCombo; |
| |
| /** The minus label. */ |
| public Label minusLabel; |
| |
| /** The country combo. */ |
| public Combo countryCombo; |
| |
| /** The add button. */ |
| public Button addButton; |
| |
| /** The delete button. */ |
| public Button deleteButton; |
| } |
| |
| } |