| /* |
| * Copyright (C) 2012 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.wizards.newxmlfile; |
| |
| import static com.android.SdkConstants.FD_RES; |
| import static com.android.SdkConstants.FD_RES_VALUES; |
| import static com.android.SdkConstants.RES_QUALIFIER_SEP; |
| |
| import com.android.ide.common.rendering.api.ResourceValue; |
| import com.android.ide.common.res2.ValueXmlHelper; |
| import com.android.ide.common.resources.LocaleManager; |
| import com.android.ide.common.resources.ResourceItem; |
| import com.android.ide.common.resources.configuration.FolderConfiguration; |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| import com.android.ide.eclipse.adt.AdtUtils; |
| import com.android.ide.eclipse.adt.internal.editors.layout.configuration.FlagManager; |
| import com.android.ide.eclipse.adt.internal.editors.layout.gle2.ImageControl; |
| import com.android.ide.eclipse.adt.internal.editors.layout.gle2.RenderPreviewManager; |
| import com.android.ide.eclipse.adt.internal.resources.manager.ProjectResources; |
| import com.android.ide.eclipse.adt.internal.resources.manager.ResourceManager; |
| import com.android.resources.ResourceType; |
| import com.google.common.base.Charsets; |
| import com.google.common.collect.Maps; |
| |
| import org.eclipse.core.resources.IContainer; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IFolder; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IWorkspaceRoot; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.jface.dialogs.Dialog; |
| import org.eclipse.jface.dialogs.IDialogConstants; |
| import org.eclipse.jface.viewers.ArrayContentProvider; |
| import org.eclipse.jface.viewers.CellEditor; |
| import org.eclipse.jface.viewers.CellLabelProvider; |
| import org.eclipse.jface.viewers.ColumnViewer; |
| import org.eclipse.jface.viewers.EditingSupport; |
| import org.eclipse.jface.viewers.IBaseLabelProvider; |
| import org.eclipse.jface.viewers.TableViewer; |
| import org.eclipse.jface.viewers.TableViewerColumn; |
| import org.eclipse.jface.viewers.TextCellEditor; |
| import org.eclipse.jface.viewers.ViewerCell; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.ControlEvent; |
| import org.eclipse.swt.events.ControlListener; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.events.SelectionListener; |
| import org.eclipse.swt.events.TraverseEvent; |
| import org.eclipse.swt.events.TraverseListener; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.graphics.Point; |
| 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.Control; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.swt.widgets.Table; |
| import org.eclipse.swt.widgets.TableColumn; |
| import org.eclipse.ui.ISharedImages; |
| import org.eclipse.ui.IWorkbench; |
| import org.eclipse.ui.PlatformUI; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.InputStream; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.SortedSet; |
| |
| /** |
| * Dialog which adds a new translation to the project |
| */ |
| public class AddTranslationDialog extends Dialog implements ControlListener, SelectionListener, |
| TraverseListener { |
| private static final int KEY_COLUMN = 0; |
| private static final int DEFAULT_TRANSLATION_COLUMN = 1; |
| private static final int NEW_TRANSLATION_COLUMN = 2; |
| private final FolderConfiguration mConfiguration = new FolderConfiguration(); |
| private final IProject mProject; |
| private String mTarget; |
| private boolean mIgnore; |
| private Map<String, String> mTranslations; |
| private Set<String> mExistingLanguages; |
| private String mSelectedLanguage; |
| private String mSelectedRegion; |
| |
| private Table mTable; |
| private Combo mLanguageCombo; |
| private Combo mRegionCombo; |
| private ImageControl mFlag; |
| private Label mFile; |
| private Button mOkButton; |
| private Composite mErrorPanel; |
| private Label mErrorLabel; |
| private MyTableViewer mTableViewer; |
| |
| /** |
| * Creates the dialog. |
| * @param parentShell the parent shell |
| * @param project the project to add translations into |
| */ |
| public AddTranslationDialog(Shell parentShell, IProject project) { |
| super(parentShell); |
| setShellStyle(SWT.CLOSE | SWT.RESIZE | SWT.TITLE); |
| mProject = project; |
| } |
| |
| @Override |
| protected Control createDialogArea(Composite parent) { |
| Composite container = (Composite) super.createDialogArea(parent); |
| GridLayout gl_container = new GridLayout(6, false); |
| gl_container.horizontalSpacing = 0; |
| container.setLayout(gl_container); |
| |
| Label languageLabel = new Label(container, SWT.NONE); |
| languageLabel.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1)); |
| languageLabel.setText("Language:"); |
| mLanguageCombo = new Combo(container, SWT.READ_ONLY); |
| GridData gd_mLanguageCombo = new GridData(SWT.FILL, SWT.CENTER, false, false, 1, 1); |
| gd_mLanguageCombo.widthHint = 150; |
| mLanguageCombo.setLayoutData(gd_mLanguageCombo); |
| |
| Label regionLabel = new Label(container, SWT.NONE); |
| GridData gd_regionLabel = new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1); |
| gd_regionLabel.horizontalIndent = 10; |
| regionLabel.setLayoutData(gd_regionLabel); |
| regionLabel.setText("Region:"); |
| mRegionCombo = new Combo(container, SWT.READ_ONLY); |
| GridData gd_mRegionCombo = new GridData(SWT.LEFT, SWT.CENTER, false, false, 1, 1); |
| gd_mRegionCombo.widthHint = 150; |
| mRegionCombo.setLayoutData(gd_mRegionCombo); |
| mRegionCombo.setEnabled(false); |
| |
| mFlag = new ImageControl(container, SWT.NONE, null); |
| mFlag.setDisposeImage(false); |
| GridData gd_mFlag = new GridData(SWT.LEFT, SWT.CENTER, false, false, 1, 1); |
| gd_mFlag.exclude = true; |
| gd_mFlag.widthHint = 32; |
| gd_mFlag.horizontalIndent = 3; |
| mFlag.setLayoutData(gd_mFlag); |
| |
| mFile = new Label(container, SWT.NONE); |
| mFile.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1)); |
| |
| mTableViewer = new MyTableViewer(container, SWT.BORDER | SWT.FULL_SELECTION); |
| mTable = mTableViewer.getTable(); |
| mTable.setEnabled(false); |
| mTable.setLinesVisible(true); |
| mTable.setHeaderVisible(true); |
| mTable.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 6, 2)); |
| mTable.addControlListener(this); |
| mTable.addTraverseListener(this); |
| // If you have difficulty opening up this form in WindowBuilder and it complains about |
| // the next line, change the type of the mTableViewer field and the above |
| // constructor call from MyTableViewer to TableViewer |
| TableViewerColumn keyViewerColumn = new TableViewerColumn(mTableViewer, SWT.NONE); |
| TableColumn keyColumn = keyViewerColumn.getColumn(); |
| keyColumn.setWidth(100); |
| keyColumn.setText("Key"); |
| TableViewerColumn defaultViewerColumn = new TableViewerColumn(mTableViewer, SWT.NONE); |
| TableColumn defaultColumn = defaultViewerColumn.getColumn(); |
| defaultColumn.setWidth(200); |
| defaultColumn.setText("Default"); |
| TableViewerColumn translationViewerColumn = new TableViewerColumn(mTableViewer, SWT.NONE); |
| TableColumn translationColumn = translationViewerColumn.getColumn(); |
| translationColumn.setWidth(200); |
| translationColumn.setText("New Translation"); |
| |
| mErrorPanel = new Composite(container, SWT.NONE); |
| GridData gd_mErrorLabel = new GridData(SWT.FILL, SWT.CENTER, false, false, 6, 1); |
| gd_mErrorLabel.exclude = true; |
| mErrorPanel.setLayoutData(gd_mErrorLabel); |
| |
| translationViewerColumn.setEditingSupport(new TranslationEditingSupport(mTableViewer)); |
| |
| fillLanguages(); |
| fillRegions(); |
| fillStrings(); |
| updateColumnWidths(); |
| validatePage(); |
| |
| mLanguageCombo.addSelectionListener(this); |
| mRegionCombo.addSelectionListener(this); |
| |
| return container; |
| } |
| |
| /** Populates the table with keys and default strings */ |
| private void fillStrings() { |
| ResourceManager manager = ResourceManager.getInstance(); |
| ProjectResources resources = manager.getProjectResources(mProject); |
| mExistingLanguages = resources.getLanguages(); |
| |
| Collection<ResourceItem> items = resources.getResourceItemsOfType(ResourceType.STRING); |
| |
| ResourceItem[] array = items.toArray(new ResourceItem[items.size()]); |
| Arrays.sort(array); |
| |
| // TODO: Read in the actual XML files providing the default keys here |
| // (they can be obtained via ResourceItem.getSourceFileList()) |
| // such that we can read all the attributes associated with each |
| // item, and if it defines translatable=false, or the filename is |
| // donottranslate.xml, we can ignore it, and in other cases just |
| // duplicate all the attributes (such as "formatted=true", or other |
| // local conventions such as "product=tablet", or "msgid="123123123", |
| // etc.) |
| |
| mTranslations = Maps.newHashMapWithExpectedSize(items.size()); |
| IBaseLabelProvider labelProvider = new CellLabelProvider() { |
| @Override |
| public void update(ViewerCell cell) { |
| Object element = cell.getElement(); |
| int index = cell.getColumnIndex(); |
| ResourceItem item = (ResourceItem) element; |
| switch (index) { |
| case KEY_COLUMN: { |
| // Key |
| cell.setText(item.getName()); |
| return; |
| } |
| case DEFAULT_TRANSLATION_COLUMN: { |
| // Default translation |
| ResourceValue value = item.getResourceValue(ResourceType.STRING, |
| mConfiguration, false); |
| |
| if (value != null) { |
| cell.setText(value.getValue()); |
| return; |
| } |
| break; |
| } |
| case NEW_TRANSLATION_COLUMN: { |
| // New translation |
| String translation = mTranslations.get(item.getName()); |
| if (translation != null) { |
| cell.setText(translation); |
| return; |
| } |
| break; |
| } |
| default: |
| assert false : index; |
| } |
| cell.setText(""); |
| } |
| }; |
| |
| mTableViewer.setLabelProvider(labelProvider); |
| mTableViewer.setContentProvider(new ArrayContentProvider()); |
| mTableViewer.setInput(array); |
| } |
| |
| /** Populate the languages dropdown */ |
| private void fillLanguages() { |
| List<String> languageCodes = LocaleManager.getLanguageCodes(); |
| List<String> labels = new ArrayList<String>(); |
| for (String code : languageCodes) { |
| labels.add(code + ": " + LocaleManager.getLanguageName(code)); //$NON-NLS-1$ |
| } |
| Collections.sort(labels); |
| labels.add(0, "(Select)"); |
| mLanguageCombo.setItems(labels.toArray(new String[labels.size()])); |
| mLanguageCombo.select(0); |
| } |
| |
| /** Populate the regions dropdown */ |
| private void fillRegions() { |
| // TODO: When you switch languages, offer some "default" usable options. For example, |
| // when you choose English, offer the countries that use English, and so on. Unfortunately |
| // we don't have good data about this, we'd just need to hardcode a few common cases. |
| List<String> regionCodes = LocaleManager.getRegionCodes(); |
| List<String> labels = new ArrayList<String>(); |
| for (String code : regionCodes) { |
| labels.add(code + ": " + LocaleManager.getRegionName(code)); //$NON-NLS-1$ |
| } |
| Collections.sort(labels); |
| labels.add(0, "Any"); |
| mRegionCombo.setItems(labels.toArray(new String[labels.size()])); |
| mRegionCombo.select(0); |
| } |
| |
| /** React to resizing by distributing the space evenly between the last two columns */ |
| private void updateColumnWidths() { |
| Rectangle r = mTable.getClientArea(); |
| int availableWidth = r.width; |
| // Distribute all available space to the last two columns |
| int columnCount = mTable.getColumnCount(); |
| for (int i = 0; i < columnCount; i++) { |
| TableColumn column = mTable.getColumn(i); |
| availableWidth -= column.getWidth(); |
| } |
| if (availableWidth != 0) { |
| TableColumn column = mTable.getColumn(DEFAULT_TRANSLATION_COLUMN); |
| column.setWidth(column.getWidth() + availableWidth / 2); |
| column = mTable.getColumn(NEW_TRANSLATION_COLUMN); |
| column.setWidth(column.getWidth() + availableWidth / 2 + availableWidth % 2); |
| } |
| } |
| |
| @Override |
| protected void createButtonsForButtonBar(Composite parent) { |
| mOkButton = createButton(parent, IDialogConstants.OK_ID, IDialogConstants.OK_LABEL, |
| // Don't make the OK button default as in most dialogs, since when you press |
| // Return thinking you might edit a value it dismisses the dialog instead |
| false); |
| createButton(parent, IDialogConstants.CANCEL_ID, IDialogConstants.CANCEL_LABEL, false); |
| mOkButton.setEnabled(false); |
| |
| validatePage(); |
| } |
| |
| /** |
| * Return the initial size of the dialog. |
| */ |
| @Override |
| protected Point getInitialSize() { |
| return new Point(800, 600); |
| } |
| |
| private void updateTarget() { |
| if (mSelectedLanguage == null) { |
| mTarget = null; |
| mFile.setText(""); |
| } else { |
| String folder = FD_RES + '/' + FD_RES_VALUES + RES_QUALIFIER_SEP + mSelectedLanguage; |
| if (mSelectedRegion != null) { |
| folder = folder + RES_QUALIFIER_SEP + 'r' + mSelectedRegion; |
| } |
| mTarget = folder + "/strings.xml"; //$NON-NLS-1$ |
| mFile.setText(String.format("Creating %1$s", mTarget)); |
| } |
| } |
| |
| private void updateFlag() { |
| if (mSelectedLanguage == null) { |
| // Nothing selected |
| ((GridData) mFlag.getLayoutData()).exclude = true; |
| } else { |
| FlagManager manager = FlagManager.get(); |
| Image flag = manager.getFlag(mSelectedLanguage, mSelectedRegion); |
| if (flag != null) { |
| ((GridData) mFlag.getLayoutData()).exclude = false; |
| mFlag.setImage(flag); |
| } |
| } |
| |
| mFlag.getParent().layout(true); |
| mFlag.getParent().redraw(); |
| } |
| |
| /** Actually create the new translation file and write it to disk */ |
| private void createTranslation() { |
| List<String> keys = new ArrayList<String>(mTranslations.keySet()); |
| Collections.sort(keys); |
| |
| StringBuilder sb = new StringBuilder(keys.size() * 120); |
| sb.append("<resources>\n\n"); //$NON-NLS-1$ |
| for (String key : keys) { |
| String value = mTranslations.get(key); |
| if (value == null || value.trim().isEmpty()) { |
| continue; |
| } |
| sb.append(" <string name=\""); //$NON-NLS-1$ |
| sb.append(key); |
| sb.append("\">"); //$NON-NLS-1$ |
| sb.append(ValueXmlHelper.escapeResourceString(value)); |
| sb.append("</string>\n"); //$NON-NLS-1$ |
| } |
| sb.append("\n</resources>"); //$NON-NLS-1$ |
| |
| IFile file = mProject.getFile(mTarget); |
| |
| try { |
| IContainer parent = file.getParent(); |
| AdtUtils.ensureExists(parent); |
| InputStream source = new ByteArrayInputStream(sb.toString().getBytes(Charsets.UTF_8)); |
| file.create(source, true, new NullProgressMonitor()); |
| AdtPlugin.openFile(file, null, true /*showEditorTab*/); |
| |
| // Ensure that the project resources updates itself to notice the new language. |
| // In theory, this shouldn't be necessary. |
| ResourceManager manager = ResourceManager.getInstance(); |
| IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot(); |
| IFolder folder = root.getFolder(parent.getFullPath()); |
| manager.getResourceFolder(folder); |
| RenderPreviewManager.bumpRevision(); |
| } catch (CoreException e) { |
| AdtPlugin.log(e, null); |
| } |
| } |
| |
| private void validatePage() { |
| if (mOkButton == null) { // Early initialization |
| return; |
| } |
| |
| String message = null; |
| |
| if (mSelectedLanguage == null) { |
| message = "Select a language"; |
| } else if (mExistingLanguages.contains(mSelectedLanguage)) { |
| if (mSelectedRegion == null) { |
| message = String.format("%1$s is already translated in this project", |
| LocaleManager.getLanguageName(mSelectedLanguage)); |
| } else { |
| ResourceManager manager = ResourceManager.getInstance(); |
| ProjectResources resources = manager.getProjectResources(mProject); |
| SortedSet<String> regions = resources.getRegions(mSelectedLanguage); |
| if (regions.contains(mSelectedRegion)) { |
| message = String.format("%1$s (%2$s) is already translated in this project", |
| LocaleManager.getLanguageName(mSelectedLanguage), |
| LocaleManager.getRegionName(mSelectedRegion)); |
| } |
| } |
| } else { |
| // Require all strings to be translated? No, some of these may not |
| // be translatable (e.g. translatable=false, defined in donottranslate.xml, etc.) |
| //int missing = mTable.getItemCount() - mTranslations.values().size(); |
| //if (missing > 0) { |
| // message = String.format("Missing %1$d translations", missing); |
| //} |
| } |
| |
| boolean valid = message == null; |
| mTable.setEnabled(message == null); |
| mOkButton.setEnabled(valid); |
| showError(message); |
| } |
| |
| private void showError(String error) { |
| GridData data = (GridData) mErrorPanel.getLayoutData(); |
| |
| boolean show = error != null; |
| if (show == data.exclude) { |
| if (show) { |
| if (mErrorLabel == null) { |
| mErrorPanel.setLayout(new GridLayout(2, false)); |
| IWorkbench workbench = PlatformUI.getWorkbench(); |
| ISharedImages sharedImages = workbench.getSharedImages(); |
| String iconName = ISharedImages.IMG_OBJS_ERROR_TSK; |
| Image image = sharedImages.getImage(iconName); |
| @SuppressWarnings("unused") |
| ImageControl icon = new ImageControl(mErrorPanel, SWT.NONE, image); |
| |
| mErrorLabel = new Label(mErrorPanel, SWT.NONE); |
| mErrorLabel.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, |
| 1, 1)); |
| } |
| mErrorLabel.setText(error); |
| } |
| data.exclude = !show; |
| mErrorPanel.getParent().layout(true); |
| } |
| } |
| |
| @Override |
| protected void okPressed() { |
| mTableViewer.applyEditorValue(); |
| |
| super.okPressed(); |
| createTranslation(); |
| } |
| |
| // ---- Implements ControlListener ---- |
| |
| @Override |
| public void controlMoved(ControlEvent e) { |
| } |
| |
| @Override |
| public void controlResized(ControlEvent e) { |
| if (mIgnore) { |
| return; |
| } |
| |
| updateColumnWidths(); |
| } |
| |
| // ---- Implements SelectionListener ---- |
| |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| if (mIgnore) { |
| return; |
| } |
| |
| Object source = e.getSource(); |
| if (source == mLanguageCombo) { |
| try { |
| mIgnore = true; |
| mRegionCombo.select(0); |
| mSelectedRegion = null; |
| } finally { |
| mIgnore = false; |
| } |
| |
| int languageIndex = mLanguageCombo.getSelectionIndex(); |
| if (languageIndex == 0) { |
| mSelectedLanguage = null; |
| mRegionCombo.setEnabled(false); |
| } else { |
| // This depends on the label format |
| mSelectedLanguage = mLanguageCombo.getItem(languageIndex).substring(0, 2); |
| mRegionCombo.setEnabled(true); |
| } |
| |
| updateTarget(); |
| updateFlag(); |
| } else if (source == mRegionCombo) { |
| int regionIndex = mRegionCombo.getSelectionIndex(); |
| if (regionIndex == 0) { |
| mSelectedRegion = null; |
| } else { |
| mSelectedRegion = mRegionCombo.getItem(regionIndex).substring(0, 2); |
| } |
| |
| updateTarget(); |
| updateFlag(); |
| } |
| |
| try { |
| mIgnore = true; |
| validatePage(); |
| } finally { |
| mIgnore = false; |
| } |
| } |
| |
| @Override |
| public void widgetDefaultSelected(SelectionEvent e) { |
| } |
| |
| // ---- TraverseListener ---- |
| |
| @Override |
| public void keyTraversed(TraverseEvent e) { |
| // If you press Return and we're not cell editing, start editing the current row |
| if (e.detail == SWT.TRAVERSE_RETURN && !mTableViewer.isCellEditorActive()) { |
| int index = mTable.getSelectionIndex(); |
| if (index != -1) { |
| Object next = mTable.getItem(index).getData(); |
| mTableViewer.editElement(next, NEW_TRANSLATION_COLUMN); |
| } |
| } |
| } |
| |
| /** Editing support for the translation column */ |
| private class TranslationEditingSupport extends EditingSupport { |
| /** |
| * When true, setValue is being called as part of a default action |
| * (e.g. Return), not due to focus loss |
| */ |
| private boolean mDefaultAction; |
| |
| private TranslationEditingSupport(ColumnViewer viewer) { |
| super(viewer); |
| } |
| |
| @Override |
| protected void setValue(Object element, Object value) { |
| ResourceItem item = (ResourceItem) element; |
| mTranslations.put(item.getName(), value.toString()); |
| mTableViewer.update(element, null); |
| validatePage(); |
| |
| // If the user is pressing Return to finish editing a value (which is |
| // not the only way this method can get called - for example, if you click |
| // outside the cell while editing, the focus loss will also result in |
| // this method getting called), then mDefaultAction is true, and we automatically |
| // start editing the next row. |
| if (mDefaultAction) { |
| mTable.getDisplay().asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| if (!mTable.isDisposed() && !mTableViewer.isCellEditorActive()) { |
| int index = mTable.getSelectionIndex(); |
| if (index != -1 && index < mTable.getItemCount() - 1) { |
| Object next = mTable.getItem(index + 1).getData(); |
| mTableViewer.editElement(next, NEW_TRANSLATION_COLUMN); |
| } |
| } |
| } |
| }); |
| } |
| } |
| |
| @Override |
| protected Object getValue(Object element) { |
| ResourceItem item = (ResourceItem) element; |
| String value = mTranslations.get(item.getName()); |
| if (value == null) { |
| return ""; |
| } |
| return value; |
| } |
| |
| @Override |
| protected CellEditor getCellEditor(Object element) { |
| return new TextCellEditor(mTable) { |
| @Override |
| protected void handleDefaultSelection(SelectionEvent event) { |
| try { |
| mDefaultAction = true; |
| super.handleDefaultSelection(event); |
| } finally { |
| mDefaultAction = false; |
| } |
| } |
| }; |
| } |
| |
| @Override |
| protected boolean canEdit(Object element) { |
| return true; |
| } |
| } |
| |
| private class MyTableViewer extends TableViewer { |
| public MyTableViewer(Composite parent, int style) { |
| super(parent, style); |
| } |
| |
| // Make this public so we can call it to ensure values are applied before the dialog |
| // is dismissed in {@link #okPressed} |
| @Override |
| public void applyEditorValue() { |
| super.applyEditorValue(); |
| } |
| } |
| } |
