| /* |
| * Copyright (C) 2008 The Android Open Source Project |
| * |
| * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/org/documents/epl-v10.php |
| * |
| * 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 com.android.ide.eclipse.adt.internal.ui; |
| |
| import com.android.SdkConstants; |
| import com.android.ide.common.resources.LocaleManager; |
| import com.android.ide.common.resources.configuration.CountryCodeQualifier; |
| import com.android.ide.common.resources.configuration.DensityQualifier; |
| import com.android.ide.common.resources.configuration.FolderConfiguration; |
| import com.android.ide.common.resources.configuration.KeyboardStateQualifier; |
| import com.android.ide.common.resources.configuration.LayoutDirectionQualifier; |
| import com.android.ide.common.resources.configuration.LocaleQualifier; |
| import com.android.ide.common.resources.configuration.NavigationMethodQualifier; |
| import com.android.ide.common.resources.configuration.NavigationStateQualifier; |
| import com.android.ide.common.resources.configuration.NetworkCodeQualifier; |
| import com.android.ide.common.resources.configuration.NightModeQualifier; |
| import com.android.ide.common.resources.configuration.ResourceQualifier; |
| import com.android.ide.common.resources.configuration.ScreenDimensionQualifier; |
| import com.android.ide.common.resources.configuration.ScreenHeightQualifier; |
| import com.android.ide.common.resources.configuration.ScreenOrientationQualifier; |
| import com.android.ide.common.resources.configuration.ScreenRatioQualifier; |
| import com.android.ide.common.resources.configuration.ScreenSizeQualifier; |
| import com.android.ide.common.resources.configuration.ScreenWidthQualifier; |
| import com.android.ide.common.resources.configuration.SmallestScreenWidthQualifier; |
| import com.android.ide.common.resources.configuration.TextInputMethodQualifier; |
| import com.android.ide.common.resources.configuration.TouchScreenQualifier; |
| import com.android.ide.common.resources.configuration.UiModeQualifier; |
| import com.android.ide.common.resources.configuration.VersionQualifier; |
| import com.android.ide.eclipse.adt.internal.resources.ResourceHelper; |
| import com.android.resources.Density; |
| import com.android.resources.Keyboard; |
| import com.android.resources.KeyboardState; |
| import com.android.resources.LayoutDirection; |
| import com.android.resources.Navigation; |
| import com.android.resources.NavigationState; |
| import com.android.resources.NightMode; |
| import com.android.resources.ResourceEnum; |
| import com.android.resources.ScreenOrientation; |
| import com.android.resources.ScreenRatio; |
| import com.android.resources.ScreenSize; |
| import com.android.resources.TouchScreen; |
| import com.android.resources.UiMode; |
| |
| import org.eclipse.jface.viewers.ILabelProviderListener; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.ISelectionChangedListener; |
| import org.eclipse.jface.viewers.IStructuredContentProvider; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.ITableLabelProvider; |
| import org.eclipse.jface.viewers.SelectionChangedEvent; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.jface.viewers.TableViewer; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.custom.StackLayout; |
| import org.eclipse.swt.events.ControlAdapter; |
| import org.eclipse.swt.events.ControlEvent; |
| import org.eclipse.swt.events.FocusAdapter; |
| import org.eclipse.swt.events.FocusEvent; |
| 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.events.SelectionListener; |
| import org.eclipse.swt.events.VerifyEvent; |
| import org.eclipse.swt.events.VerifyListener; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.graphics.Rectangle; |
| 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.Label; |
| import org.eclipse.swt.widgets.Table; |
| import org.eclipse.swt.widgets.TableColumn; |
| import org.eclipse.swt.widgets.Text; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Locale; |
| |
| /** |
| * Custom UI widget to let user build a Folder configuration. |
| * <p/> |
| * To use this, instantiate somewhere in the UI and then: |
| * <ul> |
| * <li>Use {@link #setConfiguration(String)} or {@link #setConfiguration(FolderConfiguration)}. |
| * <li>Retrieve the configuration using {@link #getConfiguration(FolderConfiguration)}. |
| * </ul> |
| */ |
| public class ConfigurationSelector extends Composite { |
| |
| public static final int WIDTH_HINT = 600; |
| public static final int HEIGHT_HINT = 250; |
| |
| private Runnable mOnChangeListener; |
| |
| private TableViewer mFullTableViewer; |
| private TableViewer mSelectionTableViewer; |
| private Button mAddButton; |
| private Button mRemoveButton; |
| private StackLayout mStackLayout; |
| |
| private boolean mOnRefresh = false; |
| |
| private final FolderConfiguration mBaseConfiguration = new FolderConfiguration(); |
| private final FolderConfiguration mSelectedConfiguration = new FolderConfiguration(); |
| |
| private final HashMap<Class<? extends ResourceQualifier>, QualifierEditBase> mUiMap = |
| new HashMap<Class<? extends ResourceQualifier>, QualifierEditBase>(); |
| private final SelectorMode mMode; |
| private Composite mQualifierEditParent; |
| private IQualifierFilter mQualifierFilter; |
| |
| /** |
| * Basic of {@link VerifyListener} to only accept digits. |
| */ |
| private static class DigitVerifier implements VerifyListener { |
| @Override |
| public void verifyText(VerifyEvent e) { |
| // check for digit only. |
| for (int i = 0 ; i < e.text.length(); i++) { |
| char letter = e.text.charAt(i); |
| if (letter < '0' || letter > '9') { |
| e.doit = false; |
| return; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Implementation of {@link VerifyListener} for Country Code qualifiers. |
| */ |
| public static class MobileCodeVerifier extends DigitVerifier { |
| @Override |
| public void verifyText(VerifyEvent e) { |
| super.verifyText(e); |
| |
| // basic tests passed? |
| if (e.doit) { |
| // check the max 3 digits. |
| if (e.text.length() - e.end + e.start + |
| ((Text)e.getSource()).getText().length() > 3) { |
| e.doit = false; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Implementation of {@link VerifyListener} for the Language and Region qualifiers. |
| */ |
| public static class LanguageRegionVerifier implements VerifyListener { |
| @Override |
| public void verifyText(VerifyEvent e) { |
| // check for length |
| if (e.text.length() - e.end + e.start + ((Combo)e.getSource()).getText().length() > 6) { |
| e.doit = false; |
| return; |
| } |
| |
| // check for lower case only. |
| for (int i = 0 ; i < e.text.length(); i++) { |
| char letter = e.text.charAt(i); |
| if (letter == '-') { |
| if (i+e.start != 2) { |
| e.doit = false; |
| return; |
| } else { |
| continue; |
| } |
| } |
| if (i+e.start == 3 && letter != 'r') { |
| e.doit = false; |
| return; |
| } |
| if ((letter < 'a' || letter > 'z') && (letter < 'A' || letter > 'Z')) { |
| e.doit = false; |
| return; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Implementation of {@link VerifyListener} for the Density qualifier. |
| */ |
| public static class DensityVerifier extends DigitVerifier { } |
| |
| /** |
| * Implementation of {@link VerifyListener} for the Screen Dimension qualifier. |
| */ |
| public static class DimensionVerifier extends DigitVerifier { } |
| |
| /** |
| * Enum for the state of the configuration being created. |
| */ |
| public enum ConfigurationState { |
| OK, INVALID_CONFIG, REGION_WITHOUT_LANGUAGE; |
| } |
| |
| /** |
| * Behavior mode for the Selector. |
| * |
| * @see #DEFAULT |
| * @see #DEVICE_ONLY |
| * @see #CONFIG_ONLY |
| */ |
| public enum SelectorMode { |
| /** the default mode */ |
| DEFAULT, |
| /** mode forcing the qualifier values to be valid on a device. |
| * For instance {@link Density#NODPI} is a valid qualifier for a resource configuration but |
| * this is not valid on a device */ |
| DEVICE_ONLY, |
| /** mode where only the specific config can be edited. The user can only select |
| * which non-empty qualifier to select. */ |
| CONFIG_ONLY; |
| } |
| |
| /** |
| * A filter for {@link ResourceQualifier}. |
| * @see ConfigurationSelector#setQualifierFilter(IQualifierFilter) |
| */ |
| public interface IQualifierFilter { |
| /** |
| * Returns true of the qualifier is accepted. |
| */ |
| boolean accept(ResourceQualifier qualifier); |
| } |
| |
| /** |
| * Creates the selector. |
| * <p/> |
| * The {@link SelectorMode} changes the behavior of the selector depending on what is being |
| * edited (a device config, a resource config, a given configuration). |
| * |
| * @param parent the composite parent. |
| * @param mode the mode for the selector. |
| */ |
| public ConfigurationSelector(Composite parent, SelectorMode mode) { |
| super(parent, SWT.NONE); |
| |
| mMode = mode; |
| mBaseConfiguration.createDefault(); |
| |
| GridLayout gl = new GridLayout(4, false); |
| gl.marginWidth = gl.marginHeight = 0; |
| setLayout(gl); |
| |
| // first column is the first table |
| final Table fullTable = new Table(this, SWT.SINGLE | SWT.FULL_SELECTION | SWT.BORDER); |
| fullTable.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| fullTable.setHeaderVisible(true); |
| fullTable.setLinesVisible(true); |
| |
| // create the column |
| final TableColumn fullTableColumn = new TableColumn(fullTable, SWT.LEFT); |
| // set the header |
| fullTableColumn.setText("Available Qualifiers"); |
| |
| fullTable.addControlListener(new ControlAdapter() { |
| @Override |
| public void controlResized(ControlEvent e) { |
| Rectangle r = fullTable.getClientArea(); |
| fullTableColumn.setWidth(r.width); |
| } |
| }); |
| |
| mFullTableViewer = new TableViewer(fullTable); |
| mFullTableViewer.setContentProvider(new QualifierContentProvider()); |
| // the label provider must return the value of the label only if the mode is |
| // CONFIG_ONLY |
| mFullTableViewer.setLabelProvider(new QualifierLabelProvider( |
| mMode == SelectorMode.CONFIG_ONLY)); |
| mFullTableViewer.setInput(mBaseConfiguration); |
| mFullTableViewer.addSelectionChangedListener(new ISelectionChangedListener() { |
| @Override |
| public void selectionChanged(SelectionChangedEvent event) { |
| ISelection selection = event.getSelection(); |
| if (selection instanceof IStructuredSelection) { |
| IStructuredSelection structSelection = (IStructuredSelection)selection; |
| Object first = structSelection.getFirstElement(); |
| |
| if (first instanceof ResourceQualifier) { |
| mAddButton.setEnabled(true); |
| return; |
| } |
| } |
| |
| mAddButton.setEnabled(false); |
| } |
| }); |
| |
| // 2nd column is the left/right arrow button |
| Composite buttonComposite = new Composite(this, SWT.NONE); |
| gl = new GridLayout(1, false); |
| gl.marginWidth = gl.marginHeight = 0; |
| buttonComposite.setLayout(gl); |
| buttonComposite.setLayoutData(new GridData(GridData.FILL_VERTICAL)); |
| |
| new Composite(buttonComposite, SWT.NONE); |
| mAddButton = new Button(buttonComposite, SWT.BORDER | SWT.PUSH); |
| mAddButton.setText("->"); |
| mAddButton.setEnabled(false); |
| mAddButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| IStructuredSelection selection = |
| (IStructuredSelection)mFullTableViewer.getSelection(); |
| |
| Object first = selection.getFirstElement(); |
| if (first instanceof ResourceQualifier) { |
| ResourceQualifier qualifier = (ResourceQualifier)first; |
| |
| mBaseConfiguration.removeQualifier(qualifier); |
| mSelectedConfiguration.addQualifier(qualifier); |
| |
| mFullTableViewer.refresh(); |
| mSelectionTableViewer.refresh(); |
| mSelectionTableViewer.setSelection(new StructuredSelection(qualifier), true); |
| |
| onChange(false /* keepSelection */); |
| } |
| } |
| }); |
| |
| mRemoveButton = new Button(buttonComposite, SWT.BORDER | SWT.PUSH); |
| mRemoveButton.setText("<-"); |
| mRemoveButton.setEnabled(false); |
| mRemoveButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| IStructuredSelection selection = |
| (IStructuredSelection)mSelectionTableViewer.getSelection(); |
| |
| Object first = selection.getFirstElement(); |
| if (first instanceof ResourceQualifier) { |
| ResourceQualifier qualifier = (ResourceQualifier)first; |
| |
| mSelectedConfiguration.removeQualifier(qualifier); |
| mBaseConfiguration.addQualifier(qualifier); |
| |
| mFullTableViewer.refresh(); |
| mSelectionTableViewer.refresh(); |
| |
| onChange(false /* keepSelection */); |
| } |
| } |
| }); |
| |
| // 3rd column is the selected config table |
| final Table selectionTable = new Table(this, SWT.SINGLE | SWT.FULL_SELECTION | SWT.BORDER); |
| selectionTable.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| selectionTable.setHeaderVisible(true); |
| selectionTable.setLinesVisible(true); |
| |
| // create the column |
| final TableColumn selectionTableColumn = new TableColumn(selectionTable, SWT.LEFT); |
| // set the header |
| selectionTableColumn.setText("Chosen Qualifiers"); |
| |
| selectionTable.addControlListener(new ControlAdapter() { |
| @Override |
| public void controlResized(ControlEvent e) { |
| Rectangle r = selectionTable.getClientArea(); |
| selectionTableColumn.setWidth(r.width); |
| } |
| }); |
| mSelectionTableViewer = new TableViewer(selectionTable); |
| mSelectionTableViewer.setContentProvider(new QualifierContentProvider()); |
| // always show the qualifier value in this case. |
| mSelectionTableViewer.setLabelProvider(new QualifierLabelProvider( |
| true /* showQualifierValue */)); |
| mSelectionTableViewer.setInput(mSelectedConfiguration); |
| mSelectionTableViewer.addSelectionChangedListener(new ISelectionChangedListener() { |
| @Override |
| public void selectionChanged(SelectionChangedEvent event) { |
| // ignore selection changes during resfreshes in some cases. |
| if (mOnRefresh) { |
| return; |
| } |
| |
| ISelection selection = event.getSelection(); |
| if (selection instanceof IStructuredSelection) { |
| IStructuredSelection structSelection = (IStructuredSelection)selection; |
| |
| if (structSelection.isEmpty() == false) { |
| Object first = structSelection.getFirstElement(); |
| |
| if (first instanceof ResourceQualifier) { |
| mRemoveButton.setEnabled(true); |
| |
| if (mMode != SelectorMode.CONFIG_ONLY) { |
| QualifierEditBase composite = mUiMap.get(first.getClass()); |
| |
| if (composite != null) { |
| composite.setQualifier((ResourceQualifier)first); |
| } |
| |
| mStackLayout.topControl = composite; |
| mQualifierEditParent.layout(); |
| } |
| |
| return; |
| } |
| } else { |
| if (mMode != SelectorMode.CONFIG_ONLY) { |
| mStackLayout.topControl = null; |
| mQualifierEditParent.layout(); |
| } |
| } |
| } |
| |
| mRemoveButton.setEnabled(false); |
| } |
| }); |
| |
| if (mMode != SelectorMode.CONFIG_ONLY) { |
| // 4th column is the detail of the selected qualifier |
| mQualifierEditParent = new Composite(this, SWT.NONE); |
| mQualifierEditParent.setLayout(mStackLayout = new StackLayout()); |
| mQualifierEditParent.setLayoutData(new GridData(GridData.FILL_VERTICAL)); |
| |
| // create the UI for all the qualifiers, and associate them to the |
| // ResourceQualifer class. |
| mUiMap.put(CountryCodeQualifier.class, new MCCEdit(mQualifierEditParent)); |
| mUiMap.put(NetworkCodeQualifier.class, new MNCEdit(mQualifierEditParent)); |
| mUiMap.put(LocaleQualifier.class, new LocaleEdit(mQualifierEditParent)); |
| mUiMap.put(LayoutDirectionQualifier.class, |
| new LayoutDirectionEdit(mQualifierEditParent)); |
| mUiMap.put(SmallestScreenWidthQualifier.class, |
| new SmallestScreenWidthEdit(mQualifierEditParent)); |
| mUiMap.put(ScreenWidthQualifier.class, new ScreenWidthEdit(mQualifierEditParent)); |
| mUiMap.put(ScreenHeightQualifier.class, new ScreenHeightEdit(mQualifierEditParent)); |
| mUiMap.put(ScreenSizeQualifier.class, new ScreenSizeEdit(mQualifierEditParent)); |
| mUiMap.put(ScreenRatioQualifier.class, new ScreenRatioEdit(mQualifierEditParent)); |
| mUiMap.put(ScreenOrientationQualifier.class, new OrientationEdit(mQualifierEditParent)); |
| mUiMap.put(UiModeQualifier.class, new UiModeEdit(mQualifierEditParent)); |
| mUiMap.put(NightModeQualifier.class, new NightModeEdit(mQualifierEditParent)); |
| mUiMap.put(DensityQualifier.class, new DensityEdit(mQualifierEditParent)); |
| mUiMap.put(TouchScreenQualifier.class, new TouchEdit(mQualifierEditParent)); |
| mUiMap.put(KeyboardStateQualifier.class, new KeyboardEdit(mQualifierEditParent)); |
| mUiMap.put(TextInputMethodQualifier.class, new TextInputEdit(mQualifierEditParent)); |
| mUiMap.put(NavigationStateQualifier.class, |
| new NavigationStateEdit(mQualifierEditParent)); |
| mUiMap.put(NavigationMethodQualifier.class, new NavigationEdit(mQualifierEditParent)); |
| mUiMap.put(ScreenDimensionQualifier.class, |
| new ScreenDimensionEdit(mQualifierEditParent)); |
| mUiMap.put(VersionQualifier.class, new VersionEdit(mQualifierEditParent)); |
| } |
| } |
| |
| /** |
| * Sets a {@link IQualifierFilter}. If non null, this will restrict the qualifiers that |
| * can be chosen. |
| * @param filter the filter to set. |
| */ |
| public void setQualifierFilter(IQualifierFilter filter) { |
| mQualifierFilter = filter; |
| } |
| |
| /** |
| * Sets a listener to be notified when the configuration changes. |
| * @param listener A {@link Runnable} whose <code>run()</code> method is called when the |
| * configuration is changed. The method is called from the UI thread. |
| */ |
| public void setOnChangeListener(Runnable listener) { |
| mOnChangeListener = listener; |
| } |
| |
| /** |
| * Initialize the UI with a given {@link FolderConfiguration}. This must |
| * be called from the UI thread. |
| * @param config The configuration. |
| */ |
| public void setConfiguration(FolderConfiguration config) { |
| |
| if (mMode != SelectorMode.CONFIG_ONLY) { |
| mSelectedConfiguration.set(config, true /*nonFakeValuesOnly*/); |
| |
| // create the base config, which is the default config minus the qualifiers |
| // in SelectedConfiguration |
| mBaseConfiguration.substract(mSelectedConfiguration); |
| } else { |
| // set the base config to the edited config. |
| // reset the config to be empty |
| mBaseConfiguration.reset(); |
| mBaseConfiguration.set(config, true /*nonFakeValuesOnly*/); |
| } |
| |
| mSelectionTableViewer.refresh(); |
| mFullTableViewer.refresh(); |
| } |
| |
| /** |
| * Initialize the UI with the configuration represented by a resource folder name. |
| * This must be called from the UI thread. |
| * |
| * @param folderSegments the segments of the folder name, |
| * split using {@link FolderConfiguration#QUALIFIER_SEP}. |
| * @return true if success, or false if the folder name is not a valid name. |
| */ |
| public boolean setConfiguration(String[] folderSegments) { |
| FolderConfiguration config = FolderConfiguration.getConfig(folderSegments); |
| |
| if (config == null) { |
| return false; |
| } |
| |
| setConfiguration(config); |
| |
| return true; |
| } |
| |
| /** |
| * Initialize the UI with the configuration represented by a resource folder name. |
| * This must be called from the UI thread. |
| * @param folderName the name of the folder. |
| * @return true if success, or false if the folder name is not a valid name. |
| */ |
| public boolean setConfiguration(String folderName) { |
| // split the name of the folder in segments. |
| String[] folderSegments = folderName.split(SdkConstants.RES_QUALIFIER_SEP); |
| |
| return setConfiguration(folderSegments); |
| } |
| |
| /** |
| * Gets the configuration as setup by the widget. |
| * @param config the {@link FolderConfiguration} object to be filled with the information |
| * from the UI. |
| */ |
| public void getConfiguration(FolderConfiguration config) { |
| config.set(mSelectedConfiguration); |
| } |
| |
| /** |
| * Returns the state of the configuration being edited/created. |
| */ |
| public ConfigurationState getState() { |
| if (mSelectedConfiguration.getInvalidQualifier() != null) { |
| return ConfigurationState.INVALID_CONFIG; |
| } |
| |
| return ConfigurationState.OK; |
| } |
| |
| /** |
| * Returns the first invalid qualifier of the configuration being edited/created, |
| * or <code>null<code> if they are all valid (or if none exists). |
| * <p/>If {@link #getState()} return {@link ConfigurationState#INVALID_CONFIG} then this will |
| * not return <code>null</code>. |
| */ |
| public ResourceQualifier getInvalidQualifier() { |
| return mSelectedConfiguration.getInvalidQualifier(); |
| } |
| |
| /** |
| * Handle changes in the configuration. |
| * @param keepSelection if <code>true</code> attemps to avoid triggering selection change in |
| * {@link #mSelectedConfiguration}. |
| */ |
| private void onChange(boolean keepSelection) { |
| ISelection selection = null; |
| if (keepSelection) { |
| mOnRefresh = true; |
| selection = mSelectionTableViewer.getSelection(); |
| } |
| |
| mSelectionTableViewer.refresh(true); |
| |
| if (keepSelection) { |
| mSelectionTableViewer.setSelection(selection); |
| mOnRefresh = false; |
| } |
| |
| if (mOnChangeListener != null) { |
| mOnChangeListener.run(); |
| } |
| } |
| |
| private void fillCombo(Combo combo, ResourceEnum[] resEnums) { |
| for (ResourceEnum resEnum : resEnums) { |
| // only add the enum if: |
| // not in device mode OR (device mode is true and) it's a valid device value. |
| // Also, always ignore fake values. |
| if ((mMode == SelectorMode.DEFAULT || resEnum.isValidValueForDevice()) && |
| resEnum.isFakeValue() == false) { |
| combo.add(resEnum.getShortDisplayValue()); |
| } |
| } |
| } |
| |
| /** |
| * Content provider around a {@link FolderConfiguration}. |
| */ |
| private class QualifierContentProvider implements IStructuredContentProvider { |
| |
| private FolderConfiguration mInput; |
| |
| public QualifierContentProvider() { |
| } |
| |
| @Override |
| public void dispose() { |
| // pass |
| } |
| |
| @Override |
| public Object[] getElements(Object inputElement) { |
| // default easy case |
| if (mQualifierFilter == null) { |
| return mInput.getQualifiers(); |
| } |
| |
| // in this case we have to compute the list |
| ArrayList<ResourceQualifier> list = new ArrayList<ResourceQualifier>(); |
| for (ResourceQualifier qual : mInput.getQualifiers()) { |
| if (mQualifierFilter.accept(qual)) { |
| list.add(qual); |
| } |
| } |
| |
| return list.toArray(); |
| } |
| |
| @Override |
| public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { |
| mInput = null; |
| if (newInput instanceof FolderConfiguration) { |
| mInput = (FolderConfiguration)newInput; |
| } |
| } |
| } |
| |
| /** |
| * Label provider for {@link ResourceQualifier} objects. |
| */ |
| private static class QualifierLabelProvider implements ITableLabelProvider { |
| |
| private final boolean mShowQualifierValue; |
| |
| public QualifierLabelProvider(boolean showQualifierValue) { |
| mShowQualifierValue = showQualifierValue; |
| } |
| |
| @Override |
| public String getColumnText(Object element, int columnIndex) { |
| // only one column, so we can ignore columnIndex |
| if (element instanceof ResourceQualifier) { |
| if (mShowQualifierValue) { |
| String value = ((ResourceQualifier)element).getShortDisplayValue(); |
| if (value == null || value.length() == 0) { |
| return String.format("%1$s (?)", |
| ((ResourceQualifier)element).getShortName()); |
| } else { |
| return value; |
| } |
| |
| } else { |
| return ((ResourceQualifier)element).getShortName(); |
| } |
| } |
| |
| return null; |
| } |
| |
| @Override |
| public Image getColumnImage(Object element, int columnIndex) { |
| // only one column, so we can ignore columnIndex |
| if (element instanceof ResourceQualifier) { |
| return ResourceHelper.getIcon(((ResourceQualifier)element).getClass()); |
| } |
| |
| return null; |
| } |
| |
| @Override |
| public void addListener(ILabelProviderListener listener) { |
| // pass |
| } |
| |
| @Override |
| public void dispose() { |
| // pass |
| } |
| |
| @Override |
| public boolean isLabelProperty(Object element, String property) { |
| // pass |
| return false; |
| } |
| |
| @Override |
| public void removeListener(ILabelProviderListener listener) { |
| // pass |
| } |
| } |
| |
| /** |
| * Base class for Edit widget for {@link ResourceQualifier}. |
| */ |
| private abstract static class QualifierEditBase extends Composite { |
| |
| public QualifierEditBase(Composite parent, String title) { |
| super(parent, SWT.NONE); |
| setLayout(new GridLayout(1, false)); |
| |
| new Label(this, SWT.NONE).setText(title); |
| } |
| |
| public abstract void setQualifier(ResourceQualifier qualifier); |
| } |
| |
| /** |
| * Edit widget for {@link CountryCodeQualifier}. |
| */ |
| private class MCCEdit extends QualifierEditBase { |
| |
| private final Text mText; |
| |
| public MCCEdit(Composite parent) { |
| super(parent, CountryCodeQualifier.NAME); |
| |
| mText = new Text(this, SWT.BORDER); |
| mText.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mText.addVerifyListener(new MobileCodeVerifier()); |
| mText.addModifyListener(new ModifyListener() { |
| @Override |
| public void modifyText(ModifyEvent e) { |
| onTextChange(); |
| } |
| }); |
| |
| mText.addFocusListener(new FocusAdapter() { |
| @Override |
| public void focusLost(FocusEvent e) { |
| onTextChange(); |
| } |
| }); |
| |
| new Label(this, SWT.NONE).setText("(3 digit code)"); |
| } |
| |
| private void onTextChange() { |
| String value = mText.getText(); |
| |
| if (value.length() == 0) { |
| // empty string, means a qualifier with no value. |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setCountryCodeQualifier(new CountryCodeQualifier()); |
| } else { |
| try { |
| CountryCodeQualifier qualifier = CountryCodeQualifier.getQualifier( |
| CountryCodeQualifier.getFolderSegment(Integer.parseInt(value))); |
| if (qualifier != null) { |
| mSelectedConfiguration.setCountryCodeQualifier(qualifier); |
| } else { |
| // Failure! Looks like the value is wrong |
| // (for instance not exactly 3 digits). |
| mSelectedConfiguration.setCountryCodeQualifier(new CountryCodeQualifier()); |
| } |
| } catch (NumberFormatException nfe) { |
| // Looks like the code is not a number. This should not happen since the text |
| // field has a VerifyListener that prevents it. |
| mSelectedConfiguration.setCountryCodeQualifier(new CountryCodeQualifier()); |
| } |
| } |
| |
| // notify of change |
| onChange(true /* keepSelection */); |
| } |
| |
| @Override |
| public void setQualifier(ResourceQualifier qualifier) { |
| CountryCodeQualifier q = (CountryCodeQualifier)qualifier; |
| |
| mText.setText(Integer.toString(q.getCode())); |
| } |
| } |
| |
| /** |
| * Edit widget for {@link NetworkCodeQualifier}. |
| */ |
| private class MNCEdit extends QualifierEditBase { |
| private final Text mText; |
| |
| public MNCEdit(Composite parent) { |
| super(parent, NetworkCodeQualifier.NAME); |
| |
| mText = new Text(this, SWT.BORDER); |
| mText.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mText.addVerifyListener(new MobileCodeVerifier()); |
| mText.addModifyListener(new ModifyListener() { |
| @Override |
| public void modifyText(ModifyEvent e) { |
| onTextChange(); |
| } |
| }); |
| mText.addFocusListener(new FocusAdapter() { |
| @Override |
| public void focusLost(FocusEvent e) { |
| onTextChange(); |
| } |
| }); |
| |
| new Label(this, SWT.NONE).setText("(1-3 digit code)"); |
| } |
| |
| private void onTextChange() { |
| String value = mText.getText(); |
| |
| if (value.length() == 0) { |
| // empty string, means a qualifier with no value. |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setNetworkCodeQualifier(new NetworkCodeQualifier()); |
| } else { |
| try { |
| NetworkCodeQualifier qualifier = NetworkCodeQualifier.getQualifier( |
| NetworkCodeQualifier.getFolderSegment(Integer.parseInt(value))); |
| if (qualifier != null) { |
| mSelectedConfiguration.setNetworkCodeQualifier(qualifier); |
| } else { |
| // Failure! Looks like the value is wrong |
| // (for instance not exactly 3 digits). |
| mSelectedConfiguration.setNetworkCodeQualifier(new NetworkCodeQualifier()); |
| } |
| } catch (NumberFormatException nfe) { |
| // Looks like the code is not a number. This should not happen since the text |
| // field has a VerifyListener that prevents it. |
| mSelectedConfiguration.setNetworkCodeQualifier(new NetworkCodeQualifier()); |
| } |
| } |
| |
| // notify of change |
| onChange(true /* keepSelection */); |
| } |
| |
| @Override |
| public void setQualifier(ResourceQualifier qualifier) { |
| NetworkCodeQualifier q = (NetworkCodeQualifier)qualifier; |
| |
| mText.setText(Integer.toString(q.getCode())); |
| } |
| } |
| |
| /** |
| * Edit widget for {@link LanguageQualifier}. |
| */ |
| private class LocaleEdit extends QualifierEditBase { |
| private final Combo mLanguage; |
| private final Label mName; |
| |
| public LocaleEdit(Composite parent) { |
| super(parent, LocaleQualifier.NAME); |
| |
| mLanguage = new Combo(this, SWT.DROP_DOWN); |
| List<String> codes = LocaleManager.getLanguageCodes(); |
| String[] items = codes.toArray(new String[codes.size()]); |
| Arrays.sort(items); |
| mLanguage.setItems(items); |
| |
| mLanguage.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mLanguage.addVerifyListener(new LanguageRegionVerifier()); |
| mLanguage.addSelectionListener(new SelectionListener() { |
| @Override |
| public void widgetDefaultSelected(SelectionEvent e) { |
| onLanguageChange(); |
| } |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| onLanguageChange(); |
| } |
| }); |
| mLanguage.addModifyListener(new ModifyListener() { |
| @Override |
| public void modifyText(ModifyEvent e) { |
| onLanguageChange(); |
| } |
| }); |
| |
| new Label(this, SWT.NONE).setText("(2 letter code or language-rRegion)"); |
| |
| mName = new Label(this, SWT.NONE); |
| mName.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| |
| } |
| |
| private void onLanguageChange() { |
| // update the current config |
| String value = mLanguage.getText(); |
| |
| String newName = ""; |
| if (value.length() == 2) { |
| String name = LocaleManager.getLanguageName(value.toLowerCase(Locale.US)); |
| if (name != null) { |
| newName = name; |
| } |
| } |
| mName.setText(newName); |
| |
| if (value.length() == 0) { |
| // empty string, means no qualifier. |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setLocaleQualifier(new LocaleQualifier()); |
| } else { |
| LocaleQualifier qualifier = LocaleQualifier.getQualifier(value); |
| if (qualifier != null) { |
| mSelectedConfiguration.setLocaleQualifier(qualifier); |
| } else { |
| // Failure! Looks like the value is wrong (for instance a one letter string). |
| mSelectedConfiguration.setLocaleQualifier(new LocaleQualifier()); |
| } |
| } |
| |
| // notify of change |
| onChange(true /* keepSelection */); |
| } |
| |
| @Override |
| public void setQualifier(ResourceQualifier qualifier) { |
| LocaleQualifier q = (LocaleQualifier)qualifier; |
| |
| String value = q.getValue(); |
| if (value != null) { |
| mLanguage.setText(value); |
| } |
| } |
| } |
| |
| /** |
| * Edit widget for {@link LayoutDirectionQualifier}. |
| */ |
| private class LayoutDirectionEdit extends QualifierEditBase { |
| |
| private final Combo mDirection; |
| |
| public LayoutDirectionEdit(Composite parent) { |
| super(parent, LayoutDirectionQualifier.NAME); |
| |
| mDirection = new Combo(this, SWT.DROP_DOWN | SWT.READ_ONLY); |
| fillCombo(mDirection, LayoutDirection.values()); |
| |
| mDirection.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mDirection.addSelectionListener(new SelectionListener() { |
| @Override |
| public void widgetDefaultSelected(SelectionEvent e) { |
| onDirectionChange(); |
| } |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| onDirectionChange(); |
| } |
| }); |
| } |
| |
| protected void onDirectionChange() { |
| // update the current config |
| int index = mDirection.getSelectionIndex(); |
| |
| if (index != -1) { |
| mSelectedConfiguration.setLayoutDirectionQualifier(new LayoutDirectionQualifier( |
| LayoutDirection.getByIndex(index))); |
| } else { |
| // empty selection, means no qualifier. |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setLayoutDirectionQualifier( |
| new LayoutDirectionQualifier()); |
| } |
| |
| // notify of change |
| onChange(true /* keepSelection */); |
| } |
| |
| @Override |
| public void setQualifier(ResourceQualifier qualifier) { |
| LayoutDirectionQualifier q = (LayoutDirectionQualifier)qualifier; |
| |
| LayoutDirection value = q.getValue(); |
| if (value == null) { |
| mDirection.clearSelection(); |
| } else { |
| mDirection.select(LayoutDirection.getIndex(value)); |
| } |
| } |
| } |
| |
| |
| /** |
| * Edit widget for {@link SmallestScreenWidthQualifier}. |
| */ |
| private class SmallestScreenWidthEdit extends QualifierEditBase { |
| |
| private final Text mSize; |
| |
| public SmallestScreenWidthEdit(Composite parent) { |
| super(parent, SmallestScreenWidthQualifier.NAME); |
| |
| ModifyListener modifyListener = new ModifyListener() { |
| @Override |
| public void modifyText(ModifyEvent e) { |
| onSizeChange(); |
| } |
| }; |
| |
| FocusAdapter focusListener = new FocusAdapter() { |
| @Override |
| public void focusLost(FocusEvent e) { |
| onSizeChange(); |
| } |
| }; |
| |
| mSize = new Text(this, SWT.BORDER); |
| mSize.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mSize.addVerifyListener(new DimensionVerifier()); |
| mSize.addModifyListener(modifyListener); |
| mSize.addFocusListener(focusListener); |
| } |
| |
| private void onSizeChange() { |
| // update the current config |
| String size = mSize.getText(); |
| |
| if (size.length() == 0) { |
| // if one of the strings is empty, reset to no qualifier. |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setSmallestScreenWidthQualifier( |
| new SmallestScreenWidthQualifier()); |
| } else { |
| SmallestScreenWidthQualifier qualifier = SmallestScreenWidthQualifier.getQualifier( |
| size); |
| |
| if (qualifier != null) { |
| mSelectedConfiguration.setSmallestScreenWidthQualifier(qualifier); |
| } else { |
| // Failure! Looks like the value is wrong, reset the qualifier |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setSmallestScreenWidthQualifier( |
| new SmallestScreenWidthQualifier()); |
| } |
| } |
| |
| // notify of change |
| onChange(true /* keepSelection */); |
| } |
| |
| @Override |
| public void setQualifier(ResourceQualifier qualifier) { |
| SmallestScreenWidthQualifier q = (SmallestScreenWidthQualifier)qualifier; |
| |
| mSize.setText(Integer.toString(q.getValue())); |
| } |
| } |
| |
| /** |
| * Edit widget for {@link ScreenWidthQualifier}. |
| */ |
| private class ScreenWidthEdit extends QualifierEditBase { |
| |
| private final Text mSize; |
| |
| public ScreenWidthEdit(Composite parent) { |
| super(parent, ScreenWidthQualifier.NAME); |
| |
| ModifyListener modifyListener = new ModifyListener() { |
| @Override |
| public void modifyText(ModifyEvent e) { |
| onSizeChange(); |
| } |
| }; |
| |
| FocusAdapter focusListener = new FocusAdapter() { |
| @Override |
| public void focusLost(FocusEvent e) { |
| onSizeChange(); |
| } |
| }; |
| |
| mSize = new Text(this, SWT.BORDER); |
| mSize.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mSize.addVerifyListener(new DimensionVerifier()); |
| mSize.addModifyListener(modifyListener); |
| mSize.addFocusListener(focusListener); |
| } |
| |
| private void onSizeChange() { |
| // update the current config |
| String size = mSize.getText(); |
| |
| if (size.length() == 0) { |
| // if one of the strings is empty, reset to no qualifier. |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setScreenWidthQualifier(new ScreenWidthQualifier()); |
| } else { |
| ScreenWidthQualifier qualifier = ScreenWidthQualifier.getQualifier(size); |
| |
| if (qualifier != null) { |
| mSelectedConfiguration.setScreenWidthQualifier(qualifier); |
| } else { |
| // Failure! Looks like the value is wrong, reset the qualifier |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setScreenWidthQualifier( |
| new ScreenWidthQualifier()); |
| } |
| } |
| |
| // notify of change |
| onChange(true /* keepSelection */); |
| } |
| |
| @Override |
| public void setQualifier(ResourceQualifier qualifier) { |
| ScreenWidthQualifier q = (ScreenWidthQualifier)qualifier; |
| |
| mSize.setText(Integer.toString(q.getValue())); |
| } |
| } |
| |
| /** |
| * Edit widget for {@link ScreenHeightQualifier}. |
| */ |
| private class ScreenHeightEdit extends QualifierEditBase { |
| |
| private final Text mSize; |
| |
| public ScreenHeightEdit(Composite parent) { |
| super(parent, ScreenHeightQualifier.NAME); |
| |
| ModifyListener modifyListener = new ModifyListener() { |
| @Override |
| public void modifyText(ModifyEvent e) { |
| onSizeChange(); |
| } |
| }; |
| |
| FocusAdapter focusListener = new FocusAdapter() { |
| @Override |
| public void focusLost(FocusEvent e) { |
| onSizeChange(); |
| } |
| }; |
| |
| mSize = new Text(this, SWT.BORDER); |
| mSize.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mSize.addVerifyListener(new DimensionVerifier()); |
| mSize.addModifyListener(modifyListener); |
| mSize.addFocusListener(focusListener); |
| } |
| |
| private void onSizeChange() { |
| // update the current config |
| String size = mSize.getText(); |
| |
| if (size.length() == 0) { |
| // if one of the strings is empty, reset to no qualifier. |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setScreenHeightQualifier(new ScreenHeightQualifier()); |
| } else { |
| ScreenHeightQualifier qualifier = ScreenHeightQualifier.getQualifier(size); |
| |
| if (qualifier != null) { |
| mSelectedConfiguration.setScreenHeightQualifier(qualifier); |
| } else { |
| // Failure! Looks like the value is wrong, reset the qualifier |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setScreenHeightQualifier( |
| new ScreenHeightQualifier()); |
| } |
| } |
| |
| // notify of change |
| onChange(true /* keepSelection */); |
| } |
| |
| @Override |
| public void setQualifier(ResourceQualifier qualifier) { |
| ScreenHeightQualifier q = (ScreenHeightQualifier)qualifier; |
| |
| mSize.setText(Integer.toString(q.getValue())); |
| } |
| } |
| |
| |
| /** |
| * Edit widget for {@link ScreenSizeQualifier}. |
| */ |
| private class ScreenSizeEdit extends QualifierEditBase { |
| |
| private final Combo mSize; |
| |
| public ScreenSizeEdit(Composite parent) { |
| super(parent, ScreenSizeQualifier.NAME); |
| |
| mSize = new Combo(this, SWT.DROP_DOWN | SWT.READ_ONLY); |
| fillCombo(mSize, ScreenSize.values()); |
| |
| mSize.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mSize.addSelectionListener(new SelectionListener() { |
| @Override |
| public void widgetDefaultSelected(SelectionEvent e) { |
| onScreenSizeChange(); |
| } |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| onScreenSizeChange(); |
| } |
| }); |
| } |
| |
| protected void onScreenSizeChange() { |
| // update the current config |
| int index = mSize.getSelectionIndex(); |
| |
| if (index != -1) { |
| mSelectedConfiguration.setScreenSizeQualifier(new ScreenSizeQualifier( |
| ScreenSize.getByIndex(index))); |
| } else { |
| // empty selection, means no qualifier. |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setScreenSizeQualifier( |
| new ScreenSizeQualifier()); |
| } |
| |
| // notify of change |
| onChange(true /* keepSelection */); |
| } |
| |
| @Override |
| public void setQualifier(ResourceQualifier qualifier) { |
| ScreenSizeQualifier q = (ScreenSizeQualifier)qualifier; |
| |
| ScreenSize value = q.getValue(); |
| if (value == null) { |
| mSize.clearSelection(); |
| } else { |
| mSize.select(ScreenSize.getIndex(value)); |
| } |
| } |
| } |
| |
| /** |
| * Edit widget for {@link ScreenRatioQualifier}. |
| */ |
| private class ScreenRatioEdit extends QualifierEditBase { |
| |
| private final Combo mRatio; |
| |
| public ScreenRatioEdit(Composite parent) { |
| super(parent, ScreenRatioQualifier.NAME); |
| |
| mRatio = new Combo(this, SWT.DROP_DOWN | SWT.READ_ONLY); |
| fillCombo(mRatio, ScreenRatio.values()); |
| |
| mRatio.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mRatio.addSelectionListener(new SelectionListener() { |
| @Override |
| public void widgetDefaultSelected(SelectionEvent e) { |
| onScreenRatioChange(); |
| } |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| onScreenRatioChange(); |
| } |
| }); |
| } |
| |
| protected void onScreenRatioChange() { |
| // update the current config |
| int index = mRatio.getSelectionIndex(); |
| |
| if (index != -1) { |
| mSelectedConfiguration.setScreenRatioQualifier(new ScreenRatioQualifier( |
| ScreenRatio.getByIndex(index))); |
| } else { |
| // empty selection, means no qualifier. |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setScreenRatioQualifier( |
| new ScreenRatioQualifier()); |
| } |
| |
| // notify of change |
| onChange(true /* keepSelection */); |
| } |
| |
| @Override |
| public void setQualifier(ResourceQualifier qualifier) { |
| ScreenRatioQualifier q = (ScreenRatioQualifier)qualifier; |
| |
| ScreenRatio value = q.getValue(); |
| if (value == null) { |
| mRatio.clearSelection(); |
| } else { |
| mRatio.select(ScreenRatio.getIndex(value)); |
| } |
| } |
| } |
| |
| /** |
| * Edit widget for {@link ScreenOrientationQualifier}. |
| */ |
| private class OrientationEdit extends QualifierEditBase { |
| |
| private final Combo mOrientation; |
| |
| public OrientationEdit(Composite parent) { |
| super(parent, ScreenOrientationQualifier.NAME); |
| |
| mOrientation = new Combo(this, SWT.DROP_DOWN | SWT.READ_ONLY); |
| fillCombo(mOrientation, ScreenOrientation.values()); |
| |
| mOrientation.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mOrientation.addSelectionListener(new SelectionListener() { |
| @Override |
| public void widgetDefaultSelected(SelectionEvent e) { |
| onOrientationChange(); |
| } |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| onOrientationChange(); |
| } |
| }); |
| } |
| |
| protected void onOrientationChange() { |
| // update the current config |
| int index = mOrientation.getSelectionIndex(); |
| |
| if (index != -1) { |
| mSelectedConfiguration.setScreenOrientationQualifier(new ScreenOrientationQualifier( |
| ScreenOrientation.getByIndex(index))); |
| } else { |
| // empty selection, means no qualifier. |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setScreenOrientationQualifier( |
| new ScreenOrientationQualifier()); |
| } |
| |
| // notify of change |
| onChange(true /* keepSelection */); |
| } |
| |
| @Override |
| public void setQualifier(ResourceQualifier qualifier) { |
| ScreenOrientationQualifier q = (ScreenOrientationQualifier)qualifier; |
| |
| ScreenOrientation value = q.getValue(); |
| if (value == null) { |
| mOrientation.clearSelection(); |
| } else { |
| mOrientation.select(ScreenOrientation.getIndex(value)); |
| } |
| } |
| } |
| |
| /** |
| * Edit widget for {@link DockModeQualifier}. |
| */ |
| private class UiModeEdit extends QualifierEditBase { |
| |
| private final Combo mUiMode; |
| |
| public UiModeEdit(Composite parent) { |
| super(parent, UiModeQualifier.NAME); |
| |
| mUiMode = new Combo(this, SWT.DROP_DOWN | SWT.READ_ONLY); |
| fillCombo(mUiMode, UiMode.values()); |
| |
| mUiMode.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mUiMode.addSelectionListener(new SelectionListener() { |
| @Override |
| public void widgetDefaultSelected(SelectionEvent e) { |
| onDockModeChange(); |
| } |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| onDockModeChange(); |
| } |
| }); |
| } |
| |
| protected void onDockModeChange() { |
| // update the current config |
| int index = mUiMode.getSelectionIndex(); |
| |
| if (index != -1) { |
| mSelectedConfiguration.setUiModeQualifier( |
| new UiModeQualifier(UiMode.getByIndex(index))); |
| } else { |
| // empty selection, means no qualifier. |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setUiModeQualifier(new UiModeQualifier()); |
| } |
| |
| // notify of change |
| onChange(true /* keepSelection */); |
| } |
| |
| @Override |
| public void setQualifier(ResourceQualifier qualifier) { |
| UiModeQualifier q = (UiModeQualifier)qualifier; |
| |
| UiMode value = q.getValue(); |
| if (value == null) { |
| mUiMode.clearSelection(); |
| } else { |
| mUiMode.select(UiMode.getIndex(value)); |
| } |
| } |
| } |
| |
| /** |
| * Edit widget for {@link NightModeQualifier}. |
| */ |
| private class NightModeEdit extends QualifierEditBase { |
| |
| private final Combo mNightMode; |
| |
| public NightModeEdit(Composite parent) { |
| super(parent, NightModeQualifier.NAME); |
| |
| mNightMode = new Combo(this, SWT.DROP_DOWN | SWT.READ_ONLY); |
| fillCombo(mNightMode, NightMode.values()); |
| |
| mNightMode.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mNightMode.addSelectionListener(new SelectionListener() { |
| @Override |
| public void widgetDefaultSelected(SelectionEvent e) { |
| onNightModeChange(); |
| } |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| onNightModeChange(); |
| } |
| }); |
| } |
| |
| protected void onNightModeChange() { |
| // update the current config |
| int index = mNightMode.getSelectionIndex(); |
| |
| if (index != -1) { |
| mSelectedConfiguration.setNightModeQualifier( |
| new NightModeQualifier(NightMode.getByIndex(index))); |
| } else { |
| // empty selection, means no qualifier. |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setNightModeQualifier(new NightModeQualifier()); |
| } |
| |
| // notify of change |
| onChange(true /* keepSelection */); |
| } |
| |
| @Override |
| public void setQualifier(ResourceQualifier qualifier) { |
| NightModeQualifier q = (NightModeQualifier)qualifier; |
| |
| NightMode value = q.getValue(); |
| if (value == null) { |
| mNightMode.clearSelection(); |
| } else { |
| mNightMode.select(NightMode.getIndex(value)); |
| } |
| } |
| } |
| |
| |
| /** |
| * Edit widget for {@link DensityQualifier}. |
| */ |
| private class DensityEdit extends QualifierEditBase { |
| private final Combo mDensity; |
| |
| public DensityEdit(Composite parent) { |
| super(parent, DensityQualifier.NAME); |
| |
| mDensity = new Combo(this, SWT.DROP_DOWN | SWT.READ_ONLY); |
| fillCombo(mDensity, Density.values()); |
| |
| mDensity.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mDensity.addSelectionListener(new SelectionListener() { |
| @Override |
| public void widgetDefaultSelected(SelectionEvent e) { |
| onDensityChange(); |
| } |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| onDensityChange(); |
| } |
| }); |
| } |
| |
| private void onDensityChange() { |
| // update the current config |
| int index = mDensity.getSelectionIndex(); |
| |
| if (index != -1) { |
| mSelectedConfiguration.setDensityQualifier(new DensityQualifier( |
| Density.getByIndex(index))); |
| } else { |
| // empty selection, means no qualifier. |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setDensityQualifier( |
| new DensityQualifier()); |
| } |
| |
| // notify of change |
| onChange(true /* keepSelection */); |
| } |
| |
| @Override |
| public void setQualifier(ResourceQualifier qualifier) { |
| DensityQualifier q = (DensityQualifier)qualifier; |
| |
| Density value = q.getValue(); |
| if (value == null) { |
| mDensity.clearSelection(); |
| } else { |
| mDensity.select(Density.getIndex(value)); |
| } |
| } |
| } |
| |
| /** |
| * Edit widget for {@link TouchScreenQualifier}. |
| */ |
| private class TouchEdit extends QualifierEditBase { |
| |
| private final Combo mTouchScreen; |
| |
| public TouchEdit(Composite parent) { |
| super(parent, TouchScreenQualifier.NAME); |
| |
| mTouchScreen = new Combo(this, SWT.DROP_DOWN | SWT.READ_ONLY); |
| fillCombo(mTouchScreen, TouchScreen.values()); |
| |
| mTouchScreen.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mTouchScreen.addSelectionListener(new SelectionListener() { |
| @Override |
| public void widgetDefaultSelected(SelectionEvent e) { |
| onTouchChange(); |
| } |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| onTouchChange(); |
| } |
| }); |
| } |
| |
| protected void onTouchChange() { |
| // update the current config |
| int index = mTouchScreen.getSelectionIndex(); |
| |
| if (index != -1) { |
| mSelectedConfiguration.setTouchTypeQualifier(new TouchScreenQualifier( |
| TouchScreen.getByIndex(index))); |
| } else { |
| // empty selection, means no qualifier. |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setTouchTypeQualifier(new TouchScreenQualifier()); |
| } |
| |
| // notify of change |
| onChange(true /* keepSelection */); |
| } |
| |
| @Override |
| public void setQualifier(ResourceQualifier qualifier) { |
| TouchScreenQualifier q = (TouchScreenQualifier)qualifier; |
| |
| TouchScreen value = q.getValue(); |
| if (value == null) { |
| mTouchScreen.clearSelection(); |
| } else { |
| mTouchScreen.select(TouchScreen.getIndex(value)); |
| } |
| } |
| } |
| |
| /** |
| * Edit widget for {@link KeyboardStateQualifier}. |
| */ |
| private class KeyboardEdit extends QualifierEditBase { |
| |
| private final Combo mKeyboardState; |
| |
| public KeyboardEdit(Composite parent) { |
| super(parent, KeyboardStateQualifier.NAME); |
| |
| mKeyboardState = new Combo(this, SWT.DROP_DOWN | SWT.READ_ONLY); |
| fillCombo(mKeyboardState, KeyboardState.values()); |
| |
| mKeyboardState.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mKeyboardState.addSelectionListener(new SelectionListener() { |
| @Override |
| public void widgetDefaultSelected(SelectionEvent e) { |
| onKeyboardChange(); |
| } |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| onKeyboardChange(); |
| } |
| }); |
| } |
| |
| protected void onKeyboardChange() { |
| // update the current config |
| int index = mKeyboardState.getSelectionIndex(); |
| |
| if (index != -1) { |
| mSelectedConfiguration.setKeyboardStateQualifier(new KeyboardStateQualifier( |
| KeyboardState.getByIndex(index))); |
| } else { |
| // empty selection, means no qualifier. |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setKeyboardStateQualifier( |
| new KeyboardStateQualifier()); |
| } |
| |
| // notify of change |
| onChange(true /* keepSelection */); |
| } |
| |
| @Override |
| public void setQualifier(ResourceQualifier qualifier) { |
| KeyboardStateQualifier q = (KeyboardStateQualifier)qualifier; |
| |
| KeyboardState value = q.getValue(); |
| if (value == null) { |
| mKeyboardState.clearSelection(); |
| } else { |
| mKeyboardState.select(KeyboardState.getIndex(value)); |
| } |
| } |
| } |
| |
| /** |
| * Edit widget for {@link TextInputMethodQualifier}. |
| */ |
| private class TextInputEdit extends QualifierEditBase { |
| |
| private final Combo mTextInput; |
| |
| public TextInputEdit(Composite parent) { |
| super(parent, TextInputMethodQualifier.NAME); |
| |
| mTextInput = new Combo(this, SWT.DROP_DOWN | SWT.READ_ONLY); |
| fillCombo(mTextInput, Keyboard.values()); |
| |
| mTextInput.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mTextInput.addSelectionListener(new SelectionListener() { |
| @Override |
| public void widgetDefaultSelected(SelectionEvent e) { |
| onTextInputChange(); |
| } |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| onTextInputChange(); |
| } |
| }); |
| } |
| |
| protected void onTextInputChange() { |
| // update the current config |
| int index = mTextInput.getSelectionIndex(); |
| |
| if (index != -1) { |
| mSelectedConfiguration.setTextInputMethodQualifier(new TextInputMethodQualifier( |
| Keyboard.getByIndex(index))); |
| } else { |
| // empty selection, means no qualifier. |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setTextInputMethodQualifier( |
| new TextInputMethodQualifier()); |
| } |
| |
| // notify of change |
| onChange(true /* keepSelection */); |
| } |
| |
| @Override |
| public void setQualifier(ResourceQualifier qualifier) { |
| TextInputMethodQualifier q = (TextInputMethodQualifier)qualifier; |
| |
| Keyboard value = q.getValue(); |
| if (value == null) { |
| mTextInput.clearSelection(); |
| } else { |
| mTextInput.select(Keyboard.getIndex(value)); |
| } |
| } |
| } |
| |
| /** |
| * Edit widget for {@link NavigationStateQualifier}. |
| */ |
| private class NavigationStateEdit extends QualifierEditBase { |
| |
| private final Combo mNavigationState; |
| |
| public NavigationStateEdit(Composite parent) { |
| super(parent, NavigationStateQualifier.NAME); |
| |
| mNavigationState = new Combo(this, SWT.DROP_DOWN | SWT.READ_ONLY); |
| fillCombo(mNavigationState, NavigationState.values()); |
| |
| mNavigationState.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mNavigationState.addSelectionListener(new SelectionListener() { |
| @Override |
| public void widgetDefaultSelected(SelectionEvent e) { |
| onNavigationChange(); |
| } |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| onNavigationChange(); |
| } |
| }); |
| } |
| |
| protected void onNavigationChange() { |
| // update the current config |
| int index = mNavigationState.getSelectionIndex(); |
| |
| if (index != -1) { |
| mSelectedConfiguration.setNavigationStateQualifier( |
| new NavigationStateQualifier(NavigationState.getByIndex(index))); |
| } else { |
| // empty selection, means no qualifier. |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setNavigationStateQualifier(new NavigationStateQualifier()); |
| } |
| |
| // notify of change |
| onChange(true /* keepSelection */); |
| } |
| |
| @Override |
| public void setQualifier(ResourceQualifier qualifier) { |
| NavigationStateQualifier q = (NavigationStateQualifier)qualifier; |
| |
| NavigationState value = q.getValue(); |
| if (value == null) { |
| mNavigationState.clearSelection(); |
| } else { |
| mNavigationState.select(NavigationState.getIndex(value)); |
| } |
| } |
| } |
| |
| |
| /** |
| * Edit widget for {@link NavigationMethodQualifier}. |
| */ |
| private class NavigationEdit extends QualifierEditBase { |
| |
| private final Combo mNavigation; |
| |
| public NavigationEdit(Composite parent) { |
| super(parent, NavigationMethodQualifier.NAME); |
| |
| mNavigation = new Combo(this, SWT.DROP_DOWN | SWT.READ_ONLY); |
| fillCombo(mNavigation, Navigation.values()); |
| |
| mNavigation.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mNavigation.addSelectionListener(new SelectionListener() { |
| @Override |
| public void widgetDefaultSelected(SelectionEvent e) { |
| onNavigationChange(); |
| } |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| onNavigationChange(); |
| } |
| }); |
| } |
| |
| protected void onNavigationChange() { |
| // update the current config |
| int index = mNavigation.getSelectionIndex(); |
| |
| if (index != -1) { |
| mSelectedConfiguration.setNavigationMethodQualifier(new NavigationMethodQualifier( |
| Navigation.getByIndex(index))); |
| } else { |
| // empty selection, means no qualifier. |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setNavigationMethodQualifier( |
| new NavigationMethodQualifier()); |
| } |
| |
| // notify of change |
| onChange(true /* keepSelection */); |
| } |
| |
| @Override |
| public void setQualifier(ResourceQualifier qualifier) { |
| NavigationMethodQualifier q = (NavigationMethodQualifier)qualifier; |
| |
| Navigation value = q.getValue(); |
| if (value == null) { |
| mNavigation.clearSelection(); |
| } else { |
| mNavigation.select(Navigation.getIndex(value)); |
| } |
| } |
| } |
| |
| /** |
| * Edit widget for {@link ScreenDimensionQualifier}. |
| */ |
| private class ScreenDimensionEdit extends QualifierEditBase { |
| |
| private final Text mSize1; |
| private final Text mSize2; |
| |
| public ScreenDimensionEdit(Composite parent) { |
| super(parent, ScreenDimensionQualifier.NAME); |
| |
| ModifyListener modifyListener = new ModifyListener() { |
| @Override |
| public void modifyText(ModifyEvent e) { |
| onSizeChange(); |
| } |
| }; |
| |
| FocusAdapter focusListener = new FocusAdapter() { |
| @Override |
| public void focusLost(FocusEvent e) { |
| onSizeChange(); |
| } |
| }; |
| |
| mSize1 = new Text(this, SWT.BORDER); |
| mSize1.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mSize1.addVerifyListener(new DimensionVerifier()); |
| mSize1.addModifyListener(modifyListener); |
| mSize1.addFocusListener(focusListener); |
| |
| mSize2 = new Text(this, SWT.BORDER); |
| mSize2.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mSize2.addVerifyListener(new DimensionVerifier()); |
| mSize2.addModifyListener(modifyListener); |
| mSize2.addFocusListener(focusListener); |
| } |
| |
| private void onSizeChange() { |
| // update the current config |
| String size1 = mSize1.getText(); |
| String size2 = mSize2.getText(); |
| |
| if (size1.length() == 0 || size2.length() == 0) { |
| // if one of the strings is empty, reset to no qualifier. |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setScreenDimensionQualifier(new ScreenDimensionQualifier()); |
| } else { |
| ScreenDimensionQualifier qualifier = ScreenDimensionQualifier.getQualifier(size1, |
| size2); |
| |
| if (qualifier != null) { |
| mSelectedConfiguration.setScreenDimensionQualifier(qualifier); |
| } else { |
| // Failure! Looks like the value is wrong, reset the qualifier |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setScreenDimensionQualifier( |
| new ScreenDimensionQualifier()); |
| } |
| } |
| |
| // notify of change |
| onChange(true /* keepSelection */); |
| } |
| |
| @Override |
| public void setQualifier(ResourceQualifier qualifier) { |
| ScreenDimensionQualifier q = (ScreenDimensionQualifier)qualifier; |
| |
| mSize1.setText(Integer.toString(q.getValue1())); |
| mSize2.setText(Integer.toString(q.getValue2())); |
| } |
| } |
| |
| /** |
| * Edit widget for {@link VersionQualifier}. |
| */ |
| private class VersionEdit extends QualifierEditBase { |
| private final Text mText; |
| |
| public VersionEdit(Composite parent) { |
| super(parent, VersionQualifier.NAME); |
| |
| mText = new Text(this, SWT.BORDER); |
| mText.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mText.addVerifyListener(new MobileCodeVerifier()); |
| mText.addModifyListener(new ModifyListener() { |
| @Override |
| public void modifyText(ModifyEvent e) { |
| onVersionChange(); |
| } |
| }); |
| mText.addFocusListener(new FocusAdapter() { |
| @Override |
| public void focusLost(FocusEvent e) { |
| onVersionChange(); |
| } |
| }); |
| |
| new Label(this, SWT.NONE).setText("(Platform API level)"); |
| } |
| |
| private void onVersionChange() { |
| String value = mText.getText(); |
| |
| if (value.length() == 0) { |
| // empty string, means a qualifier with no value. |
| // Since the qualifier classes are immutable, and we don't want to |
| // remove the qualifier from the configuration, we create a new default one. |
| mSelectedConfiguration.setVersionQualifier(new VersionQualifier()); |
| } else { |
| try { |
| VersionQualifier qualifier = VersionQualifier.getQualifier( |
| VersionQualifier.getFolderSegment(Integer.parseInt(value))); |
| if (qualifier != null) { |
| mSelectedConfiguration.setVersionQualifier(qualifier); |
| } else { |
| // Failure! Looks like the value is wrong |
| mSelectedConfiguration.setVersionQualifier(new VersionQualifier()); |
| } |
| } catch (NumberFormatException nfe) { |
| // Looks like the code is not a number. This should not happen since the text |
| // field has a VerifyListener that prevents it. |
| mSelectedConfiguration.setVersionQualifier(new VersionQualifier()); |
| } |
| } |
| |
| // notify of change |
| onChange(true /* keepSelection */); |
| } |
| |
| @Override |
| public void setQualifier(ResourceQualifier qualifier) { |
| VersionQualifier q = (VersionQualifier)qualifier; |
| |
| mText.setText(Integer.toString(q.getVersion())); |
| } |
| } |
| |
| } |
